Explicitly set additionalProperties for .passthrough() (#405)

src/create/schema/parsers/object.test.ts

@@ -52,6 +52,35 @@ describe('createObjectSchema', () => {
     expect(result).toEqual(expected);
   });
 
+  it('supports passthrough', () => {
+    const expected: Schema = {
+      type: 'schema',
+      schema: {
+        type: 'object',
+        properties: {
+          a: {
+            type: 'string',
+          },
+        },
+        required: ['a'],
+        additionalProperties: true,
+      },
+    };
+    const schema = z
+      .object({
+        a: z.string(),
+      })
+      .passthrough();
+
+    const result = createObjectSchema(
+      schema,
+      undefined,
+      createOutputState(undefined),
+    );
+
+    expect(result).toEqual(expected);
+  });
+
   it('supports catchall', () => {
     const expected: Schema = {
       type: 'schema',

src/create/schema/parsers/object.ts

@@ -237,6 +237,25 @@ interface AdditionalPropertyOptions {
   catchAll: ZodType;
 }
 
+const mapAdditionalProperties = (
+  { unknownKeys, catchAll }: AdditionalPropertyOptions,
+  state: SchemaState,
+) => {
+  if (!isZodType(catchAll, 'ZodNever')) {
+    return createSchemaObject(catchAll, state, ['additional properties']);
+  }
+
+  if (unknownKeys === 'strict') {
+    return false;
+  }
+
+  if (unknownKeys === 'passthrough') {
+    return true;
+  }
+
+  return undefined;
+};
+
 export const createObjectSchemaFromShape = (
   shape: ZodRawShape,
   { unknownKeys, catchAll }: AdditionalPropertyOptions,
@@ -245,24 +264,27 @@ export const createObjectSchemaFromShape = (
 ): Schema => {
   const properties = mapProperties(shape, state);
   const required = mapRequired(properties, shape, state);
-  const additionalProperties = !isZodType(catchAll, 'ZodNever')
-    ? createSchemaObject(catchAll, state, ['additional properties'])
-    : undefined;
+  const additionalProperties = mapAdditionalProperties(
+    { catchAll, unknownKeys },
+    state,
+  );
 
   return {
     type: 'schema',
     schema: {
       ...(!omitType && { type: 'object' }),
       ...(properties && { properties: properties.properties }),
       ...(required?.required.length && { required: required.required }),
-      ...(unknownKeys === 'strict' && { additionalProperties: false }),
-      ...(additionalProperties && {
-        additionalProperties: additionalProperties.schema,
+      ...(additionalProperties !== undefined && {
+        additionalProperties:
+          typeof additionalProperties === 'object'
+            ? additionalProperties.schema
+            : additionalProperties,
       }),
     },
     effects: flattenEffects([
       ...(properties?.effects ?? []),
-      additionalProperties?.effects,
+      typeof additionalProperties === 'object' && additionalProperties?.effects,
       required?.effects,
     ]),
   };

src/create/schema/parsers/transform.ts

@@ -225,7 +225,9 @@ export const verifyEffects = (effects: Effect[], state: SchemaState) => {
   }
 };
 
-export const flattenEffects = (effects: Array<Effect[] | undefined>) => {
+export const flattenEffects = (
+  effects: Array<Effect[] | undefined | false>,
+) => {
   const allEffects = effects.reduce<Effect[]>((acc, effect) => {
     if (effect) {
       return acc.concat(effect);