zodselect 1.0.9 → 1.0.11

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

@@ -5,5 +5,5 @@ export type BasicSelect = ZodObject<Readonly<{
     [k: string]: Clause | ZodLazy<Clause>;
 }>> | ZodRecord<$ZodRecordKey, Clause | ZodLazy<Clause>>;
 type Clause = ZodOptional<ZodBoolean> | ZodOptional<ZodUnion<readonly [ZodBoolean, BasicSelect]>>;
-export declare function buildSelectSchema<T extends ZodType<object> | ZodUnion>(schema: T): ZodType<ZodSelect<T, true>>;
+export declare function buildSelectSchema<T extends ZodType<object> | ZodUnion>(schema: T): ZodType<ZodSelect<T, true>, ZodSelect<T, true>>;
 export {};

package/dist/build-select-schema.js

@@ -61,18 +61,18 @@ function buildSelect(schema, cache = new Map()) {
         const hasLazy = types.some(item => isZodLazy(item));
         if (hasLazy) {
             return z.lazy(() => {
-                return buildSelectMerge(types);
+                return buildSelectMerge(types, cache);
             });
         }
-        return buildSelectMerge(types);
+        return buildSelectMerge(types, cache);
     }
     return z.boolean().optional();
 }
-function buildSelectMerge(types) {
+function buildSelectMerge(types, cache) {
     const shape = {};
     let isStrict = false;
     for (const cur of types) {
-        const select = buildSelect(cur);
+        const select = buildSelect(cur, cache);
         let clause;
         if (isZodLazy(select)) {
             clause = select.def.getter();

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

@@ -60,6 +60,18 @@ describe('.buildSelectSchema()', () => {
         });
         assert.throws(() => selectSchema.parse({ valueC: true }), /Unrecognized key/);
     });
+    it('z.infer of a union select schema should be a plain select type', () => {
+        const schema = z.union([
+            z.object({ shared: z.string(), type: z.literal('a'), valueA: z.string() }).strict(),
+            z.object({ shared: z.string(), type: z.literal('b'), valueB: z.number() }).strict()
+        ]);
+        const selectSchema = buildSelectSchema(schema);
+        // Runtime: the schema correctly parses a plain select object
+        assert.deepEqual(selectSchema.parse({ shared: true, type: true, valueA: true }), { shared: true, type: true, valueA: true });
+        const plain = {};
+        void plain;
+        assert.ok(true);
+    });
     it('should support intersections of objects', () => {
         const schema = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
         const select = buildSelectSchema(schema);
@@ -75,7 +87,7 @@ describe('.buildSelectSchema()', () => {
         assert.strictEqual(getInnerType(select.shape.foo).def.type, 'boolean');
         assert.strictEqual(getInnerType(select.shape.bar).def.type, 'boolean');
     });
-    it('should return a strict schema if all members are strict', () => {
+    it('should return a strict schema if any member is strict', () => {
         const schema = z.union([
             z.object({ strictA: z.string() }).strict(),
             z.object({ strictB: z.number() }).strict()
@@ -83,6 +95,16 @@ describe('.buildSelectSchema()', () => {
         const select = buildSelectSchema(schema);
         assert.strictEqual(isZodObjectLoose(select), false);
     });
+    it('should return a strict schema when only one union member is strict', () => {
+        const schema = z.union([
+            z.object({ strictA: z.string() }).strict(),
+            z.looseObject({ looseB: z.number() })
+        ]);
+        const select = buildSelectSchema(schema);
+        // Any strict member makes the merged select strict so callers cannot
+        // accidentally reference fields outside any member's defined shape.
+        assert.strictEqual(isZodObjectLoose(select), false);
+    });
     it('should allow optional keys in the select schema', () => {
         const schema = z.object({
             optionalField: z.string().optional()
@@ -152,6 +174,19 @@ describe('.buildSelectSchema()', () => {
         assert.strictEqual(union.def.options[1].def.valueType.type, 'optional');
         assert.strictEqual(union.def.options[1].def.valueType.def.innerType.type, 'boolean');
     });
+    it('should share the same lazy instance for a recursive schema referenced by multiple union members', () => {
+        const nested = z.lazy(() => z.object({ children: z.array(nested) }));
+        const schema = z.union([
+            z.object({ a: nested }),
+            z.object({ b: nested })
+        ]);
+        const select = buildSelectSchema(schema);
+        // Both 'a' and 'b' reference the same `nested` schema.
+        // Their select schemas must be the same lazy instance (shared cache).
+        const aSelect = select.shape.a;
+        const bSelect = select.shape.b;
+        assert.strictEqual(aSelect, bSelect);
+    });
     it('should support unknown types', () => {
         const schema = z.object({
             tags: z.unknown()

package/dist/refine-schema.js

@@ -6,7 +6,7 @@ export function refineSchema(schema, shape) {
         const refinedShape = {};
         const schemaShape = schema.shape;
         for (const key in shape) {
-            if (key in schemaShape) {
+            if (key in schemaShape && shape[key] !== false) {
                 refinedShape[key] = refineSchemaField(schemaShape[key], shape[key]);
             }
         }

package/dist/refine-schema.spec.js

@@ -203,6 +203,19 @@ describe('.refineSchema()', () => {
             return true;
         });
     });
+    it('should exclude fields specified as false in the shape', () => {
+        const schema = z.object({
+            firstName: z.string(),
+            lastName: z.string()
+        });
+        const refined = refineSchema(schema, {
+            firstName: true,
+            lastName: false
+        });
+        // lastName was specified as false — it should be excluded from the refined schema
+        const result = refined.parse({ firstName: 'Alice', lastName: 'Smith' });
+        assert.deepStrictEqual(result, { firstName: 'Alice' });
+    });
     it('should support unions of objects and simple types', () => {
         const person = z.object({
             firstName: z.string(),

package/dist/select.d.ts

@@ -11,5 +11,5 @@ export type MultiSelect<T extends ZodType<object> | ZodUnion> = [
     ZodSelect<T>,
     ...ZodSelect<T>[]
 ] | undefined | ZodSelect<T>;
-export type ZodSelect<T extends ZodTuple | ZodType<object> | ZodUnion, TIsSimple extends boolean = false> = (T extends ZodUnion ? (RefineZodUnion<T> | ZodUnion) : T extends ZodTuple ? (RefineZodTuple<T> | ZodTuple) : T extends ZodType<object> ? (RefineObject<z.infer<T>, TIsSimple> | ZodType<object>) : never);
+export type ZodSelect<T extends ZodTuple | ZodType<object> | ZodUnion, TIsSimple extends boolean = false> = (T extends ZodUnion ? (RefineZodUnion<T> | (TIsSimple extends true ? never : ZodUnion)) : T extends ZodTuple ? (RefineZodTuple<T> | (TIsSimple extends true ? never : ZodTuple)) : T extends ZodType<object> ? (RefineObject<z.infer<T>, TIsSimple> | (TIsSimple extends true ? never : ZodType<object>)) : never);
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "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",
@@ -25,14 +25,14 @@
     }
   },
   "devDependencies": {
-    "@secure-data-systems/eslint-config": "^1.0.33",
-    "@secure-data-systems/tsconfig": "^1.0.3",
-    "@types/node": "^24.10.1",
+    "@secure-data-systems/eslint-config": "^1.0.36",
+    "@secure-data-systems/tsconfig": "^1.0.5",
+    "@types/node": "^25.6.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "dependencies": {
-    "zod": "^4.1.13"
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "node scripts/build.mjs && tsc --project tsconfig.build.json",
@@ -40,6 +40,7 @@
     "deploy": "npm run build && node ./scripts/publish.mjs",
     "lint": "eslint . --c eslint.config.mjs",
     "lint:fix": "eslint . --c eslint.config.mjs --fix",
+    "prune": "node scripts/prune.mjs",
     "test": "tsx --tsconfig ./tsconfig.build.json --test ./src/**/*.{spec,test}.ts ./test/**/*.{spec,test}.ts"
   }
 }