Type safety for nested objects on patch

[honest cloak]

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,
  }),
});

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 },
    });
  },
});

This does not show any type errors

[coarse glacier]

Thanks for posting in #1088161997662724167.
Reminder: If you have a Convex Pro account, use the Convex Dashboard to file support tickets.

    - Provide context: What are you trying to achieve, what is the end-user interaction, what are you seeing? (full error message, command output, etc.)
    - Use [search.convex.dev](https://search.convex.dev) to search Docs, Stack, and Discord all at once.
    - Additionally, you can post your questions in the Convex Community's #1228095053885476985 channel to receive a response from AI.
    - Avoid tagging staff unless specifically instructed.

    Thank you!

[patent wraith]

That's not a Convex specific thing, TypeScript handles dynamic keys differently than static, unless the dynamic key type is a single literal (not union). I'd rework for clearer types.