3 replies

Type safety for nested objects on patch

Is there any way to get type safety on patch operations in convex?

schema:

import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";

const reactiveText = v.object({
  stateId: v.string(),
  text: v.string(),
});

export default defineSchema({
  myData: defineTable({
    text1: reactiveText,
    text2: reactiveText,
  }),
});

import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";

const reactiveText = v.object({
  stateId: v.string(),
  text: v.string(),
});

export default defineSchema({
  myData: defineTable({
    text1: reactiveText,
    text2: reactiveText,
  }),
});

myfunction

import { v } from "convex/values";
import { query, mutation, action } from "./_generated/server";
import { api } from "./_generated/api";

export const update = mutation({
  args: {
    text: v.string(),
    id: v.id("myData"),
    stateId: v.string(),
    field: v.union(v.literal("text1"), v.literal("text2")),
  },
  handler: async (ctx, args) => {
    await ctx.db.patch(args.id, {
      [args.field]: { text: args.text },
      // should have been
      [args.field]: { text: args.text, stateId: args.stateId },
    });
  },
});

import { v } from "convex/values";
import { query, mutation, action } from "./_generated/server";
import { api } from "./_generated/api";

export const update = mutation({
  args: {
    text: v.string(),
    id: v.id("myData"),
    stateId: v.string(),
    field: v.union(v.literal("text1"), v.literal("text2")),
  },
  handler: async (ctx, args) => {
    await ctx.db.patch(args.id, {
      [args.field]: { text: args.text },
      // should have been
      [args.field]: { text: args.text, stateId: args.stateId },
    });
  },
});

This does not show any type errors

Convex Community•2y ago•

3 replies

loliklr:)

Type safety for nested objects on patch

Is there any way to get type safety on patch operations in convex?

schema:

import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";

const reactiveText = v.object({
  stateId: v.string(),
  text: v.string(),
});

export default defineSchema({
  myData: defineTable({
    text1: reactiveText,
    text2: reactiveText,
  }),
});

import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";

const reactiveText = v.object({
  stateId: v.string(),
  text: v.string(),
});

export default defineSchema({
  myData: defineTable({
    text1: reactiveText,
    text2: reactiveText,
  }),
});

myfunction

import { v } from "convex/values";
import { query, mutation, action } from "./_generated/server";
import { api } from "./_generated/api";

export const update = mutation({
  args: {
    text: v.string(),
    id: v.id("myData"),
    stateId: v.string(),
    field: v.union(v.literal("text1"), v.literal("text2")),
  },
  handler: async (ctx, args) => {
    await ctx.db.patch(args.id, {
      [args.field]: { text: args.text },
      // should have been
      [args.field]: { text: args.text, stateId: args.stateId },
    });
  },
});

import { v } from "convex/values";
import { query, mutation, action } from "./_generated/server";
import { api } from "./_generated/api";

export const update = mutation({
  args: {
    text: v.string(),
    id: v.id("myData"),
    stateId: v.string(),
    field: v.union(v.literal("text1"), v.literal("text2")),
  },
  handler: async (ctx, args) => {
    await ctx.db.patch(args.id, {
      [args.field]: { text: args.text },
      // should have been
      [args.field]: { text: args.text, stateId: args.stateId },
    });
  },
});

This does not show any type errors

Continue the conversation

Join the Discord to ask follow-up questions and connect with the community

Convex Community

Where Convex builders ask questions, share what they're building.

16,722 Members

Join

Type safety for nested objects on patch

Type safety for nested objects on patch

Continue the conversation

Convex Community

Continue the conversation

Convex Community

Similar Threads