zodselect 1.2.7 → 1.2.8

package/dist/refine-schema.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { getInnerType, isZodArray, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
+import { isZodArray, isZodCatch, isZodDefault, isZodLazy, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
 // Main function to refine the schema
 export function refineSchema(schema, shape) {
     if (isZodObject(schema)) {
@@ -45,12 +45,12 @@ function refineSchemaField(fieldSchema, fieldShape) {
     else if (isZodNullable(fieldSchema)) {
         return refineSchemaField(fieldSchema.def.innerType, fieldShape).nullable();
     }
-    else {
-        const innerType = getInnerType(fieldSchema);
-        // There are wrapper types we can't forward because the underlying object structures are changing.
-        if (innerType !== fieldSchema) {
-            return refineSchemaField(innerType, fieldShape);
-        }
+    else if (isZodDefault(fieldSchema) || isZodCatch(fieldSchema)) {
+        // A default or catch is a whole value, which a picked part no longer fits, so it gives way to what it wraps.
+        return refineSchemaField(fieldSchema.def.innerType, fieldShape);
+    }
+    else if (isZodLazy(fieldSchema)) {
+        return refineSchemaField(fieldSchema.def.getter(), fieldShape);
     }
     return fieldSchema;
 }

package/dist/refine-schema.spec.js

@@ -128,6 +128,19 @@ describe('.refineSchema()', () => {
         });
         assert.equal(parsedWithoutNestedArray.nestedArray, undefined);
     });
+    it('keeps an array under a default, a catch or a lazy an array of the picked fields', () => {
+        const line = z.object({ id: z.string(), secret: z.string() });
+        const order = z.object({
+            caught: z.array(line).catch([]),
+            defaulted: z.array(line).default([]),
+            lazy: z.lazy(() => z.array(line))
+        });
+        const refined = refineSchema(order, { caught: { id: true }, defaulted: { id: true }, lazy: { id: true } });
+        const lines = [{ id: 'a', secret: 's' }];
+        deepStrictEqual(refined.parse({ caught: lines, defaulted: lines, lazy: lines }), { caught: [{ id: 'a' }], defaulted: [{ id: 'a' }], lazy: [{ id: 'a' }] });
+        assert.ok(refined.shape.defaulted instanceof z.ZodArray);
+        assert.ok(refined.shape.caught instanceof z.ZodArray);
+    });
     it('should handle custom fields', () => {
         const userSchema = z.object({
             address: z.custom().optional(),

package/dist/utilities.d.ts

@@ -1,6 +1,8 @@
-import { ZodArray, ZodLazy, ZodNullable, ZodObject, ZodOptional, ZodRecord, ZodType, ZodUnion, ZodUnknown } from 'zod';
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodObject, ZodOptional, ZodRecord, ZodType, ZodUnion, ZodUnknown } from 'zod';
 export declare function getInnerType(schema: ZodType, unwrapLazy?: boolean): ZodType;
 export declare function isZodArray(obj: unknown): obj is ZodArray<ZodType>;
+export declare function isZodCatch(obj: unknown): obj is ZodCatch<ZodType>;
+export declare function isZodDefault(obj: unknown): obj is ZodDefault<ZodType>;
 export declare function isZodLazy(obj: unknown): obj is ZodLazy;
 export declare function isZodNullable(obj: unknown): obj is ZodNullable<ZodType>;
 export declare function isZodObject(obj: unknown, isLoose?: boolean): obj is ZodObject;

package/dist/utilities.js

@@ -17,6 +17,12 @@ export function getInnerType(schema, unwrapLazy = true) {
 export function isZodArray(obj) {
     return isZodType(obj) && (obj.def.type === 'array');
 }
+export function isZodCatch(obj) {
+    return isZodType(obj) && (obj.def.type === 'catch');
+}
+export function isZodDefault(obj) {
+    return isZodType(obj) && (obj.def.type === 'default');
+}
 export function isZodLazy(obj) {
     return isZodType(obj) && (obj.def.type === 'lazy');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "Type-safe selection utility built on top of Zod. Allows for strongly typed field selection, schema merging, and runtime refinement for frontend or backend use.",
   "author": "SecureDataSystems",
   "license": "MIT",