feat(zui): handle object catchall in multiple transformers (#591)

Author: franklevasseur

zui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpinternal/zui",
-  "version": "0.20.2",
+  "version": "0.21.0",
   "description": "A fork of Zod with additional features",
   "type": "module",
   "source": "./src/index.ts",

zui/src/transforms/common/json-schema.ts

@@ -82,10 +82,11 @@ type _ObjectSchema = util.Satisfies<
   {
     type: 'object'
     properties: { [key: string]: ZuiJsonSchema }
+    additionalProperties?: ZuiJsonSchema
     required: string[]
   },
   JSONSchema7
-> // TODO: add support for unknownKeys ('passthrough' | 'strict' | 'strip')
+>
 type _TupleSchema = util.Satisfies<
   { type: 'array'; items: ZuiJsonSchema[]; additionalItems?: ZuiJsonSchema },
   JSONSchema7

zui/src/transforms/json-schema-to-zui-next/index.test.ts

@@ -139,6 +139,42 @@ describe.concurrent('zuifromJsonSchemaNext', () => {
     assert(zSchema).toEqual(expected)
   })
 
+  test('should map ObjectSchema with additional properties NumberSchema to ZodObject', () => {
+    const jSchema = buildSchema({
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      required: ['name'],
+      additionalProperties: { type: 'number' },
+    })
+    const zSchema = fromJsonSchema(jSchema)
+    const expected = z.object({ name: z.string() }).catchall(z.number())
+    assert(zSchema).toEqual(expected)
+  })
+
+  test('should map ObjectSchema with additional properties AnySchema to ZodObject', () => {
+    const jSchema = buildSchema({
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      required: ['name'],
+      additionalProperties: true,
+    })
+    const zSchema = fromJsonSchema(jSchema)
+    const expected = z.object({ name: z.string() }).passthrough()
+    assert(zSchema).toEqual(expected)
+  })
+
+  test('should map ObjectSchema with additional properties NeverSchema to ZodObject', () => {
+    const jSchema = buildSchema({
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      required: ['name'],
+      additionalProperties: false,
+    })
+    const zSchema = fromJsonSchema(jSchema)
+    const expected = z.object({ name: z.string() }).strict()
+    assert(zSchema).toEqual(expected)
+  })
+
   test('should map UnionSchema to ZodUnion', () => {
     const jSchema = buildSchema({ anyOf: [{ type: 'string' }, { type: 'number' }] })
     const zSchema = fromJsonSchema(jSchema)

zui/src/transforms/json-schema-to-zui-next/index.ts

@@ -126,11 +126,9 @@ function _fromJsonSchema(schema: JSONSchema7Definition | undefined): z.ZodType {
 
   if (schema.type === 'object') {
     if (schema.additionalProperties !== undefined && schema.properties !== undefined) {
-      // TODO: should be supported with the .catchall() method but the behavior of this method is inconsistent
-      throw new errors.UnsupportedJSONSchemaToZuiError({
-        additionalProperties: schema.additionalProperties,
-        properties: schema.properties,
-      })
+      const catchAll = _fromJsonSchema(schema.additionalProperties)
+      const inner = _fromJsonSchema({ ...schema, additionalProperties: undefined }) as z.ZodObject
+      return inner.catchall(catchAll)
     }
 
     if (schema.properties !== undefined) {

zui/src/transforms/zui-to-json-schema-next/index.test.ts

@@ -95,6 +95,36 @@ describe('zuiToJsonSchemaNext', () => {
     })
   })
 
+  test('should map strict ZodObject to ObjectSchema with addtionalProperties never', () => {
+    const schema = toJsonSchema(z.object({ name: z.string() }).strict())
+    expect(schema).toEqual({
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      required: ['name'],
+      additionalProperties: { not: true },
+    })
+  })
+
+  test('should map passthrough ZodObject to ObjectSchema with addtionalProperties any', () => {
+    const schema = toJsonSchema(z.object({ name: z.string() }).passthrough())
+    expect(schema).toEqual({
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      required: ['name'],
+      additionalProperties: {},
+    })
+  })
+
+  test('should map ZodObject with catchall ZodNumber to ObjectSchema with addtionalProperties number', () => {
+    const schema = toJsonSchema(z.object({ name: z.string() }).catchall(z.number()))
+    expect(schema).toEqual({
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      required: ['name'],
+      additionalProperties: { type: 'number' },
+    })
+  })
+
   test('should map ZodUnion to UnionSchema', () => {
     const schema = toJsonSchema(z.union([z.string(), z.number()]))
     expect(schema).toEqual({

zui/src/transforms/zui-to-json-schema-next/index.ts

@@ -75,13 +75,15 @@ export function toJsonSchema(schema: z.Schema): json.ZuiJsonSchema {
         .map(([key, value]) => [key, _toRequired(value)] satisfies [string, z.ZodType])
         .map(([key, value]) => [key, toJsonSchema(value)] satisfies [string, json.ZuiJsonSchema])
 
-      // TODO: ensure unknownKeys and catchall are not lost
+      const zAdditionalProperties = (schema as z.ZodObject).additionalProperties()
+      const additionalProperties = zAdditionalProperties ? toJsonSchema(zAdditionalProperties) : undefined
 
       return {
         type: 'object',
         properties: Object.fromEntries(properties),
         required,
         'x-zui': def['x-zui'],
+        additionalProperties,
       } satisfies json.ObjectSchema
 
     case z.ZodFirstPartyTypeKind.ZodUnion:

zui/src/transforms/zui-to-typescript-schema/index.test.ts

@@ -301,6 +301,37 @@ describe.concurrent('toTypescriptZuiString', () => {
     })
     assert(schema).toGenerateItself()
   })
+
+  test('strict object', () => {
+    const schema = z
+      .object({
+        a: z.string(),
+        b: z.number(),
+      })
+      .strict()
+    assert(schema).toGenerateItself()
+  })
+
+  test('passthrough object', () => {
+    const schema = z
+      .object({
+        a: z.string(),
+        b: z.number(),
+      })
+      .passthrough()
+    assert(schema).toGenerateItself()
+  })
+
+  test('catchall object', () => {
+    const schema = z
+      .object({
+        a: z.string(),
+        b: z.number(),
+      })
+      .catchall(z.boolean())
+    assert(schema).toGenerateItself()
+  })
+
   test('union', () => {
     const schema = z.union([z.string(), z.number(), z.boolean()])
     assert(schema).toGenerateItself()

zui/src/transforms/zui-to-typescript-schema/index.ts

@@ -72,17 +72,14 @@ function sUnwrapZod(schema: z.Schema): string {
       return `z.array(${sUnwrapZod(def.type)})${generateArrayChecks(def)}${_addZuiExtensions(def)}${_maybeDescribe(def)}`
 
     case z.ZodFirstPartyTypeKind.ZodObject:
-      const props = mapValues(def.shape(), (value) => {
-        if (value instanceof z.Schema) {
-          return sUnwrapZod(value)
-        }
-        return `z.any()`
-      })
+      const props = mapValues(def.shape(), sUnwrapZod)
+      const catchall = (schema as z.ZodObject).additionalProperties()
+      const catchallString = catchall ? `.catchall(${sUnwrapZod(catchall)})` : ''
       return [
         //
         `z.object({`,
         ...Object.entries(props).map(([key, value]) => `  ${key}: ${value},`),
-        `})${_addZuiExtensions(def)}${_maybeDescribe(def)}`,
+        `})${catchallString}${_addZuiExtensions(def)}${_maybeDescribe(def)}`,
       ]
         .join('\n')
         .trim()

zui/src/z/is-equal.test.ts

@@ -178,6 +178,40 @@ describe('isEqual', () => {
       }),
     )
   })
+  test('strict object', () => {
+    expectZui(
+      z
+        .object({
+          a: z.string(),
+          b: z.number(),
+        })
+        .strict(),
+    ).toEqual(
+      z
+        .object({
+          b: z.number(),
+          a: z.string(),
+        })
+        .catchall(z.never()),
+    )
+  })
+  test('passthrough object', () => {
+    expectZui(
+      z
+        .object({
+          a: z.string(),
+          b: z.number(),
+        })
+        .passthrough(),
+    ).toEqual(
+      z
+        .object({
+          b: z.number(),
+          a: z.string(),
+        })
+        .catchall(z.any()),
+    )
+  })
   test('optional', () => {
     expectZui(z.string().optional()).toEqual(z.optional(z.string()))
   })
@@ -280,5 +314,21 @@ describe('isNotEqual', () => {
     expectZui(z.bigint().min(min1)).not.toEqual(z.bigint().min(min2))
   })
 
-  // TODO: add more not equal tests
+  test('object with different catchall', () => {
+    expectZui(
+      z
+        .object({
+          a: z.string(),
+          b: z.number(),
+        })
+        .catchall(z.string()),
+    ).not.toEqual(
+      z
+        .object({
+          a: z.string(),
+          b: z.number(),
+        })
+        .catchall(z.number()),
+    )
+  })
 })

zui/src/z/types/object/index.ts

@@ -26,8 +26,8 @@ import {
   errorUtil,
   partialUtil,
   createZodEnum,
-  ZodUnknown,
   ZodNever,
+  ZodAny,
 } from '../index'
 import { CustomSet } from '../utils/custom-set'
 
@@ -75,6 +75,14 @@ export type UnknownKeysOutputType<T extends UnknownKeysParam> = T extends ZodTyp
     ? { [k: string]: unknown }
     : {}
 
+export type AdditionalProperties<T extends UnknownKeysParam> = T extends ZodTypeAny
+  ? T
+  : T extends 'passthrough'
+    ? ZodAny
+    : T extends 'strict'
+      ? ZodNever
+      : undefined
+
 export type deoptional<T extends ZodTypeAny> =
   T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T
 
@@ -280,6 +288,22 @@ export class ZodObject<
     })
   }
 
+  /**
+   * @returns The ZodType that is used to validate additional properties or undefined if extra keys are stripped.
+   */
+  additionalProperties(): AdditionalProperties<UnknownKeys> {
+    if (this._def.unknownKeys instanceof ZodType) {
+      return this._def.unknownKeys as AdditionalProperties<UnknownKeys>
+    }
+    if (this._def.unknownKeys === 'passthrough') {
+      return ZodAny.create() as AdditionalProperties<UnknownKeys>
+    }
+    if (this._def.unknownKeys === 'strict') {
+      return ZodNever.create() as AdditionalProperties<UnknownKeys>
+    }
+    return undefined as AdditionalProperties<UnknownKeys>
+  }
+
   /**
    * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
    * If you want to pass through unknown properties, use `.passthrough()` instead.
@@ -579,7 +603,7 @@ export class ZodObject<
 
   isEqual(schema: ZodType): boolean {
     if (!(schema instanceof ZodObject)) return false
-    if (!this._unknownKeysEqual(schema._def.unknownKeys)) return false
+    if (!this._unknownKeysEqual(schema)) return false
 
     const thisShape = this._def.shape()
     const thatShape = schema._def.shape()
@@ -592,11 +616,13 @@ export class ZodObject<
     return thisProps.isEqual(thatProps)
   }
 
-  private _unknownKeysEqual(that: UnknownKeysParam): boolean {
-    if (this._def.unknownKeys instanceof ZodType && that instanceof ZodType) {
-      return this._def.unknownKeys.isEqual(that)
+  private _unknownKeysEqual(that: ZodObject): boolean {
+    const thisAdditionalProperties = this.additionalProperties()
+    const thatAdditionalProperties = that.additionalProperties()
+    if (thisAdditionalProperties === undefined || thatAdditionalProperties === undefined) {
+      return thisAdditionalProperties === thatAdditionalProperties
     }
-    return this._def.unknownKeys === that
+    return thisAdditionalProperties.isEqual(thatAdditionalProperties)
   }
 
   static create = <T extends ZodRawShape>(shape: T, params?: RawCreateParams): ZodObject<T, 'strip'> => {