zodselect 1.0.13 → 1.0.15

package/dist/build-select-object.d.ts

@@ -6,9 +6,9 @@ export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = {
 /**
  * Produces a runtime select-all object for the given Zod schema.
  *
- * Every top-level key is set to `true`, which tells the server to include
- * that field in the response.  For union schemas the result is the merged
- * set of keys across all variants.
+ * Every scalar key is set to `true`. Nested object fields are recursively
+ * expanded into nested select objects. Array fields remain `true`.
+ * For union schemas the result is the merged set of keys across all variants.
  *
  * @example
  * ```ts

package/dist/build-select-object.js

@@ -1,10 +1,11 @@
+import { ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodOptional } from 'zod';
 import { getInnerType, isZodObject, isZodUnion } from './utilities.js';
 /**
  * Produces a runtime select-all object for the given Zod schema.
  *
- * Every top-level key is set to `true`, which tells the server to include
- * that field in the response.  For union schemas the result is the merged
- * set of keys across all variants.
+ * Every scalar key is set to `true`. Nested object fields are recursively
+ * expanded into nested select objects. Array fields remain `true`.
+ * For union schemas the result is the merged set of keys across all variants.
  *
  * @example
  * ```ts
@@ -17,20 +18,47 @@ export function buildSelectObject(schema) {
     collectKeys(schema, result);
     return result;
 }
-function collectKeys(schema, result) {
+/**
+ * Unwraps optional/nullable/default/catch/lazy wrappers but NOT arrays.
+ */
+function unwrapField(schema) {
+    if (schema instanceof ZodOptional
+        || schema instanceof ZodNullable
+        || schema instanceof ZodDefault
+        || schema instanceof ZodCatch) {
+        return unwrapField(schema.def.innerType);
+    }
+    if (schema instanceof ZodLazy) {
+        return unwrapField(schema.def.getter());
+    }
+    return schema;
+}
+const MAX_DEPTH = 10;
+function collectKeys(schema, result, depth = 0) {
+    if (depth >= MAX_DEPTH) {
+        return;
+    }
     schema = getInnerType(schema);
     if (isZodObject(schema)) {
         for (const key in schema.shape) {
-            result[key] = true;
+            const fieldInner = unwrapField(schema.shape[key]);
+            if (isZodObject(fieldInner)) {
+                const nested = {};
+                collectKeys(fieldInner, nested, depth + 1);
+                result[key] = nested;
+            }
+            else {
+                result[key] = true;
+            }
         }
     }
     else if (isZodUnion(schema)) {
         for (const option of schema.options) {
-            collectKeys(option, result);
+            collectKeys(option, result, depth);
         }
     }
     else if (schema.def.type === 'intersection') {
-        collectKeys(schema.def.left, result);
-        collectKeys(schema.def.right, result);
+        collectKeys(schema.def.left, result, depth);
+        collectKeys(schema.def.right, result, depth);
     }
 }

package/dist/build-select-object.spec.js

@@ -45,7 +45,7 @@ describe('.buildSelectObject()', () => {
             c: true
         });
     });
-    it('should only collect top-level keys (not nested)', () => {
+    it('should recursively expand nested objects', () => {
         const schema = z.object({
             active: z.boolean(),
             user: z.object({
@@ -53,6 +53,69 @@ describe('.buildSelectObject()', () => {
                 name: z.string()
             })
         });
-        assert.deepStrictEqual(buildSelectObject(schema), { active: true, user: true });
+        assert.deepStrictEqual(buildSelectObject(schema), {
+            active: true,
+            user: { age: true, name: true }
+        });
+    });
+    it('should recursively expand deeply nested objects', () => {
+        const schema = z.object({
+            name: z.string(),
+            organization: z.object({
+                _id: z.string(),
+                address: z.object({
+                    city: z.string(),
+                    country: z.string()
+                })
+            })
+        });
+        assert.deepStrictEqual(buildSelectObject(schema), {
+            name: true,
+            organization: { _id: true, address: { city: true, country: true } }
+        });
+    });
+    it('should expand optional nested objects', () => {
+        const schema = z.object({
+            name: z.string(),
+            organization: z.object({
+                _id: z.string(),
+                name: z.string()
+            }).optional()
+        });
+        assert.deepStrictEqual(buildSelectObject(schema), {
+            name: true,
+            organization: { _id: true, name: true }
+        });
+    });
+    it('should not expand arrays', () => {
+        const schema = z.object({
+            name: z.string(),
+            tags: z.array(z.string())
+        });
+        assert.deepStrictEqual(buildSelectObject(schema), { name: true, tags: true });
+    });
+    it('should not expand arrays of objects', () => {
+        const schema = z.object({
+            items: z.array(z.object({ id: z.string(), value: z.number() })),
+            name: z.string()
+        });
+        assert.deepStrictEqual(buildSelectObject(schema), { items: true, name: true });
+    });
+    it('should handle recursive schemas without infinite loop', () => {
+        ;
+        const node = z.lazy(() => z.object({
+            children: z.array(node).optional(),
+            name: z.string(),
+            parent: node.optional()
+        }));
+        const schema = z.object({
+            name: z.string(),
+            root: node
+        });
+        // Should not throw or hang — recursive objects hit depth limit
+        const result = buildSelectObject(schema);
+        assert.strictEqual(result.name, true);
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        assert.ok(typeof result.root === 'object' && result.root !== null);
     });
 });

package/dist/build-select-schema.spec.js

@@ -210,4 +210,33 @@ describe('.buildSelectSchema()', () => {
             }
         });
     });
+    it('should allow nested object sub-selection in union members', () => {
+        const account = z.object({
+            _id: z.string(),
+            name: z.string()
+        });
+        const individual = z.object({
+            account: account.optional(),
+            name: z.object({ first: z.string(), last: z.string() }),
+            type: z.literal('individual')
+        });
+        const organization = z.object({
+            account: account.optional(),
+            name: z.string(),
+            type: z.literal('organization')
+        });
+        const contact = z.union([individual, organization]);
+        const selectSchema = buildSelectSchema(contact);
+        // Runtime: nested sub-selection on a shared nested object field should parse
+        const result = selectSchema.parse({
+            account: { _id: true, name: true },
+            type: true
+        });
+        assert.deepStrictEqual(result, {
+            account: { _id: true, name: true },
+            type: true
+        });
+        const nested = { account: { _id: true, name: true }, type: true };
+        void nested;
+    });
 });

package/dist/refine-schema.d.ts

@@ -30,9 +30,11 @@ export type RefineZodTuple<T extends ZodTuple> = {
     [K in keyof UnionToIntersection<T['def']['items'][number] extends ZodObject<infer Shape extends ZodRawShape> ? Shape : object>]?: boolean;
 };
 export type RefineZodUnion<T extends ZodUnion> = {
-    [K in keyof UnionToIntersection<T['options'][number] extends ZodObject<infer Shape extends ZodRawShape> ? Shape : object>]?: boolean;
+    [K in keyof UnionMergedShape<T>]?: UnionMergedShape<T>[K] extends ZodType ? UnionFieldType<UnionMergedShape<T>[K]> : boolean;
 };
 export type TuplifyUnion<T, TDepth extends number = 0, L = LastOf<T>, N = [T] extends [never] ? true : false> = TDepth extends 9 ? [] : true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>, NextDepth<TDepth>>, InternalZodify<L>>;
+type UnionFieldType<T extends ZodType> = z.infer<T> extends Array<infer U> ? Exclude<U, null | undefined> extends object ? boolean | RefineObject<Extract<U, object>, true> : boolean : Exclude<z.infer<T>, null | undefined> extends object ? boolean | RefineObject<Exclude<z.infer<T>, null | undefined>, true> : boolean;
+type UnionMergedShape<T extends ZodUnion> = UnionToIntersection<T['options'][number] extends ZodObject<infer Shape extends ZodRawShape> ? Shape : object>;
 export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
 export type Zodify<T, TDepth extends number = 0> = ApplyOptionalNullable<T, IsTuple<TuplifyUnion<Exclude<T, null | undefined>, TDepth>, ZodUnion<TuplifyUnion<Exclude<T, null | undefined>, TDepth>>, InternalZodify<Exclude<T, null | undefined>, TDepth>>>;
 export declare function refineSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, false>>(schema: T, shape: TShape): RefinedSchema<T, TShape, false>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "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",
@@ -29,7 +29,7 @@
     "@secure-data-systems/tsconfig": "^1.0.5",
     "@types/node": "^25.6.0",
     "tsx": "^4.21.0",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.3"
   },
   "dependencies": {
     "zod": "^4.3.6"