Storing all unknown keys under an "additionalProperties" key

[disintegrator]

Hey there, I'm posting a problem which I've attempted to solve and now I'm looking for ideas or someone to nerd snipe. It's also possible that I'm describing a feature request. Regardless, if you have a better approach then what I've come up with then I'd love to hear about it!

Problem

I have a Zod object schema like this:

export const blogSchema = z
  .object({
    id: z.string(),
    slug: z.string(),
    title: z.string(),
    content: z.string(),
    readTime: z.number().int().positive(),
  })
  .catchall(z.unknown());

The output type for this will be:

type ActualBlogSchema = {
  id: string;
  slug: string;
  title: string;
  content: string;
  readTime: number;
} & {
  [k: string]: unknown;
};

What I would like instead is to have this result:

type ExpectedBlogSchema = {
  id: string;
  slug: string;
  title: string;
  content: string;
  readTime: number;
} & {
  additionalProperties: { [k: string]: unknown };
};

One approach is to use a transform:

blogSchema.transform((v) => {
  const { id, slug, title, content, readTime, ...additionalProperties } = v;
  return { id, slug, title, content, readTime, additionalProperties };
});

Caution

The problem with this approach is that it does not minify well especially if you have many Zod schemas that need this treatment. Those destructured keys have to stay as-is in the minified source. With esbuild, it can even be slightly larger (example).

My solution

So, I resorted to doing some meta-programming and created a helper function that can take a ZodObject and amend it with a .transform to do the work above.

export function collectExtraKeys<
  Shape extends z.ZodRawShape,
  Catchall extends z.ZodTypeAny,
  const K extends string
>(
  obj: z.ZodObject<Shape, "strip", Catchall>,
  extrasKey: K
): z.ZodEffects<
  typeof obj,
  z.output<z.ZodObject<Shape, "strict">> & {
    [k in K]: Record<string, z.output<Catchall>>;
  }
> {
  return obj.transform((val) => {
    const extras: Record<string, z.output<Catchall>> = {};
    const { shape } = obj;
    for (const [key] of Object.entries(val)) {
      if (key in shape) {
        continue;
      }

      const v = val[key];
      if (typeof v === "undefined") {
        continue;
      }

      extras[key] = v;
      delete val[key];
    }

    return { ...val, [extrasKey]: extras };
  });
}

And it's applied like this:

export const blogSchema = collectExtraKeys(
  z
    .object({
      id: z.string(),
      slug: z.string(),
      title: z.string(),
      content: z.string(),
      readTime: z.number().int().positive(),
    })
    .catchall(z.unknown()),
  "additionalProperties",
);

The modified schema now results in the desired type but I have a feeling there's a simpler approach to this problem. If not, then I propose a new feature to Zod's .catchall that allows specifying a key to group unrecognized fields under e.g. z.object(...).catchall(z.unknown(), "extraKeys").

Here's a playground link to tinker with.