zodselect 1.0.8 → 1.0.10

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()
@@ -91,13 +113,13 @@ describe('.buildSelectSchema()', () => {
         assert.strictEqual(getInnerType(select.shape.optionalField).def.type, 'boolean');
     });
     it('should handle direct recursion', () => {
-        const RoleSchema = z.lazy(() => {
+        const roleSchema = z.lazy(() => {
             return (z.object({
                 name: z.string(),
-                roles: z.array(RoleSchema)
+                roles: z.array(roleSchema)
             }));
         });
-        const select = buildSelectSchema(RoleSchema);
+        const select = buildSelectSchema(roleSchema);
         assert.deepStrictEqual(Object.keys(select.shape), ['name', 'roles']);
         const nameSelect = select.shape.name;
         assert.strictEqual(nameSelect.def.type, 'optional');
@@ -112,13 +134,13 @@ describe('.buildSelectSchema()', () => {
         assert.strictEqual(roleItem.def.type, 'object');
     });
     it('should support mutual recursion (cross-recursive)', () => {
-        const A = z.lazy(() => z.object({
-            b: B
+        const schemaA = z.lazy(() => z.object({
+            b: schemaB
         }));
-        const B = z.lazy(() => z.object({
-            a: A
+        const schemaB = z.lazy(() => z.object({
+            a: schemaA
         }));
-        const select = buildSelectSchema(A);
+        const select = buildSelectSchema(schemaA);
         assert.strictEqual(select.shape.b.def.type, 'lazy');
         const bUnion = select.shape.b.def.getter();
         assert.strictEqual(bUnion.def.innerType.def.type, 'union');
@@ -126,11 +148,11 @@ describe('.buildSelectSchema()', () => {
         assert.strictEqual(bObj.shape.a.def.type, 'lazy');
     });
     it('should share the same instance in recursion (no infinite loop)', () => {
-        const Role = z.lazy(() => z.object({
+        const role = z.lazy(() => z.object({
             name: z.string(),
-            roles: z.array(Role)
+            roles: z.array(role)
         }));
-        const select = buildSelectSchema(Role);
+        const select = buildSelectSchema(role);
         const rolesSelect = select.shape.roles;
         const unionSelect = rolesSelect.def.getter().def.innerType;
         const nestedRoleSelect = unionSelect.def.options[1].shape.roles;
@@ -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

@@ -4,16 +4,16 @@ import { z, ZodError } from 'zod';
 import { refineSchema } from './refine-schema.js';
 describe('.refineSchema()', () => {
     it('should retain required fields', () => {
-        const UserSchema = z.object({
+        const userSchema = z.object({
             age: z.number().optional(),
             firstName: z.string(),
             lastName: z.string()
         });
-        const RefinedSchema = refineSchema(UserSchema, {
+        const refinedSchema = refineSchema(userSchema, {
             firstName: true,
             lastName: true
         });
-        const parsedData = RefinedSchema.parse({
+        const parsedData = refinedSchema.parse({
             firstName: 'John',
             lastName: 'Doe'
         });
@@ -21,74 +21,74 @@ describe('.refineSchema()', () => {
         assert.equal(parsedData.lastName, 'Doe');
     });
     it('should handle optional fields', () => {
-        const UserSchema = z.object({
+        const userSchema = z.object({
             age: z.number().optional(),
             firstName: z.string(),
             lastName: z.string()
         });
-        const RefinedSchema = refineSchema(UserSchema, {
+        const refinedSchema = refineSchema(userSchema, {
             age: true
         });
-        const parsedData = RefinedSchema.parse({ age: 25 });
+        const parsedData = refinedSchema.parse({ age: 25 });
         assert.equal(parsedData.age, 25);
-        const parsedWithoutAge = RefinedSchema.parse({});
+        const parsedWithoutAge = refinedSchema.parse({});
         assert.equal(parsedWithoutAge.age, undefined);
     });
     it('should handle nullable fields', () => {
-        const RoleSchema = z.object({
+        const roleSchema = z.object({
             name: z.string()
         });
-        const UserSchema = z.object({
+        const userSchema = z.object({
             firstName: z.string(),
-            role: RoleSchema.nullable()
+            role: roleSchema.nullable()
         });
-        const RefinedSchema = refineSchema(UserSchema, {
+        const refinedSchema = refineSchema(userSchema, {
             role: true
         });
-        const parsedWithNullRole = RefinedSchema.parse({
+        const parsedWithNullRole = refinedSchema.parse({
             firstName: 'Alice',
             role: null
         });
         assert.equal(parsedWithNullRole.role, null);
     });
     it('should handle both optional and nullable fields', () => {
-        const RoleSchema = z.object({
+        const roleSchema = z.object({
             name: z.string()
         });
-        const UserSchema = z.object({
+        const userSchema = z.object({
             firstName: z.string(),
-            role: RoleSchema.nullable().optional()
+            role: roleSchema.nullable().optional()
         });
-        const RefinedSchema = refineSchema(UserSchema, {
+        const refinedSchema = refineSchema(userSchema, {
             role: {
                 name: true
             }
         });
-        const parsedWithRole = RefinedSchema.parse({
+        const parsedWithRole = refinedSchema.parse({
             firstName: 'Alice',
             role: { name: 'Admin' }
         });
         assert.deepStrictEqual(parsedWithRole.role, { name: 'Admin' });
-        const parsedWithNullRole = RefinedSchema.parse({
+        const parsedWithNullRole = refinedSchema.parse({
             firstName: 'Alice',
             role: null
         });
         assert.strictEqual(parsedWithNullRole.role, null);
-        const parsedWithoutRole = RefinedSchema.parse({ firstName: 'Alice' });
+        const parsedWithoutRole = refinedSchema.parse({ firstName: 'Alice' });
         assert.strictEqual(parsedWithoutRole.role, undefined);
     });
     it('should apply custom schema transformations', () => {
-        const RoleSchema = z.object({
+        const roleSchema = z.object({
             name: z.string()
         });
-        const UserSchema = z.object({
+        const userSchema = z.object({
             firstName: z.string(),
-            role: RoleSchema
+            role: roleSchema
         });
-        const RefinedSchema = refineSchema(UserSchema, {
-            role: (schema) => schema.extend({ permissions: z.array(z.string()) })
+        const refinedSchema = refineSchema(userSchema, {
+            role: schema => schema.extend({ permissions: z.array(z.string()) })
         });
-        const parsedData = RefinedSchema.parse({
+        const parsedData = refinedSchema.parse({
             firstName: 'Bob',
             role: { name: 'User', permissions: ['read', 'write'] }
         });
@@ -98,46 +98,46 @@ describe('.refineSchema()', () => {
         });
     });
     it('should handle nested arrays', () => {
-        const RoleSchema = z.object({
+        const roleSchema = z.object({
             level: z.number(),
             title: z.string()
         });
-        const UserSchema = z.object({
+        const userSchema = z.object({
             age: z.number().optional(),
             firstName: z.string(),
             lastName: z.string(),
             nestedArray: z.array(z.object({ name: z.string(), value: z.number() })).optional().nullable(),
-            role: RoleSchema.nullable().optional(),
+            role: roleSchema.nullable().optional(),
             tags: z.array(z.string()).optional()
         });
-        const RefinedSchema = refineSchema(UserSchema, {
+        const refinedSchema = refineSchema(userSchema, {
             nestedArray: {
                 name: true
             }
         });
-        const parsedData = RefinedSchema.parse({
+        const parsedData = refinedSchema.parse({
             firstName: 'Alice',
             lastName: 'Smith',
             nestedArray: [{ name: 'Feature1', value: 10 }, { name: 'Feature2', value: 20 }]
         });
         assert.deepStrictEqual(parsedData.nestedArray, [{ name: 'Feature1' }, { name: 'Feature2' }]);
         // Test optional array
-        const parsedWithoutNestedArray = RefinedSchema.parse({
+        const parsedWithoutNestedArray = refinedSchema.parse({
             firstName: 'Alice',
             lastName: 'Smith'
         });
         assert.equal(parsedWithoutNestedArray.nestedArray, undefined);
     });
     it('should handle custom fields', () => {
-        const UserSchema = z.object({
+        const userSchema = z.object({
             address: z.custom().optional(),
             firstName: z.string(),
             lastName: z.string()
         });
-        const RefinedSchema = refineSchema(UserSchema, {
+        const refinedSchema = refineSchema(userSchema, {
             address: true
         });
-        const parsedData = RefinedSchema.parse({
+        const parsedData = refinedSchema.parse({
             address: {
                 city: 'Austin',
                 state: 'TX',
@@ -155,45 +155,45 @@ describe('.refineSchema()', () => {
         });
     });
     it('should support unions of objects', () => {
-        const Person = z.object({
+        const person = z.object({
             firstName: z.string(),
             lastName: z.string()
         });
-        const Address = z.object({
+        const address = z.object({
             address: z.string(),
             city: z.string()
         });
-        const Schema = refineSchema(z.union([Person, Address]), {
+        const schema = refineSchema(z.union([person, address]), {
             address: true,
             firstName: true
         });
-        let parseResult = Schema.parse({
+        let parseResult = schema.parse({
             address: '123 Main Street',
             firstName: 'Jerry',
             lastName: 'Springer'
         });
         deepStrictEqual(parseResult, { firstName: 'Jerry' });
-        parseResult = Schema.parse({
+        parseResult = schema.parse({
             address: '123 Main Street',
             city: 'Austin'
         });
         deepStrictEqual(parseResult, { address: '123 Main Street' });
     });
     it('should error if none of the types are matched', () => {
-        const Person = z.object({
+        const person = z.object({
             firstName: z.string(),
             lastName: z.string()
         });
-        const Address = z.object({
+        const address = z.object({
             address: z.string(),
             city: z.string()
         });
-        const Schema = refineSchema(z.union([Person, Address]), {
+        const schema = refineSchema(z.union([person, address]), {
             address: true,
             firstName: true
         });
         throws(() => {
-            Schema.parse({
+            schema.parse({
                 lastName: 'Springer'
             });
         }, (err) => {
@@ -203,21 +203,34 @@ 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({
+        const person = z.object({
             firstName: z.string(),
             lastName: z.string()
         });
-        const Schema = refineSchema(z.union([Person, z.string()]), {
+        const schema = refineSchema(z.union([person, z.string()]), {
             address: true,
             firstName: true
         });
-        let parseResult = Schema.parse({
+        let parseResult = schema.parse({
             firstName: 'Jerry',
             lastName: 'Springer'
         });
         deepStrictEqual(parseResult, { firstName: 'Jerry' });
-        parseResult = Schema.parse('123 Main Street');
+        parseResult = schema.parse('123 Main Street');
         deepStrictEqual(parseResult, '123 Main Street');
     });
 });

package/dist/select.d.ts

@@ -7,6 +7,9 @@ type InferTuple<T extends ZodType<object> | ZodUnion, U extends readonly ZodSele
 };
 export type InferType<T extends ZodType<object> | ZodUnion, U extends ZodSelect<T>> = U extends ZodType<object> ? z.infer<U> : U extends ZodUnion ? z.infer<U> : T extends ZodUnion ? (U extends RefineZodUnion<T> ? z.infer<RefinedUnionSchema<T, U>> : z.infer<T>) : T extends ZodType<object> ? (U extends RefineObject<z.infer<T>, false> ? z.infer<RefinedTypeSchema<z.infer<T>, U>> : z.infer<T>) : z.infer<T>;
 export type MergeSelect<T extends ZodType<object> | ZodUnion, TSelect1 extends ZodSelect<T>, TSelect2 extends MultiSelect<T>> = TSelect2 extends undefined ? [TSelect1, T] : IsEqual<TSelect2, T, TSelect1, TSelect2 extends [ZodSelect<T>, ...ZodSelect<T>[]] ? [TSelect1, ...TSelect2] : [TSelect1, TSelect2]>;
-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 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> | (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/dist/utilities.spec.js

@@ -30,8 +30,8 @@ describe('.utilities()', () => {
             assert.strictEqual(inner.def.type, 'string');
         });
         it('should unwrap lazy inside nested wrappers', () => {
-            const LazySchema = z.lazy(() => z.string());
-            const wrapped = LazySchema.optional().nullable().default('abc');
+            const lazySchema = z.lazy(() => z.string());
+            const wrapped = lazySchema.optional().nullable().default('abc');
             const inner = getInnerType(wrapped);
             assert.strictEqual(inner.def.type, 'string');
         });
@@ -56,20 +56,20 @@ describe('.utilities()', () => {
     });
     it('isZodRecord detects complex record schemas with optional fields', () => {
         // Create a sample RecordAttachmentSchema
-        const RecordAttachmentSchema = z.object({
+        const recordAttachmentSchema = z.object({
             name: z.string(),
             size: z.number(),
             type: z.string()
         });
         // Create a record schema with optional field
-        const attachmentsSchema = z.record(z.string(), RecordAttachmentSchema).optional();
+        const attachmentsSchema = z.record(z.string(), recordAttachmentSchema).optional();
         const nonRecordSchema = z.object({ field: z.string() });
         // Test record detection
-        assert.ok(isZodRecord(z.record(z.string(), RecordAttachmentSchema)), 'Should detect record schema');
+        assert.ok(isZodRecord(z.record(z.string(), recordAttachmentSchema)), 'Should detect record schema');
         assert.ok(isZodRecord(attachmentsSchema.unwrap()), 'Should detect optional record schema when unwrapped');
         assert.ok(!isZodRecord(nonRecordSchema), 'Should not detect object schema as record');
         // Test with actual record data
-        const validRecord = z.record(z.string(), RecordAttachmentSchema).parse({
+        const validRecord = z.record(z.string(), recordAttachmentSchema).parse({
             'file1': { name: 'test.pdf', size: 1024, type: 'application/pdf' },
             'file2': { name: 'image.jpg', size: 2048, type: 'image/jpeg' }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "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,21 +25,22 @@
     }
   },
   "devDependencies": {
-    "@secure-data-systems/eslint-config": "^1.0.26",
-    "@secure-data-systems/tsconfig": "^1.0.2",
-    "@types/node": "^24.10.1",
-    "glob": "^11.0.3",
-    "tsx": "^4.20.6",
+    "@secure-data-systems/eslint-config": "^1.0.33",
+    "@secure-data-systems/tsconfig": "^1.0.3",
+    "@types/node": "^25.3.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "zod": "^4.1.12"
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "node scripts/build.mjs && tsc --project tsconfig.build.json",
+    "clean": "node scripts/clean.mjs",
     "deploy": "npm run build && node ./scripts/publish.mjs",
     "lint": "eslint . --c eslint.config.mjs",
     "lint:fix": "eslint . --c eslint.config.mjs --fix",
-    "test": "glob -c \"tsx --tsconfig ./tsconfig.build.json --test\" \"./src/**/*.{spec,test}.ts\""
+    "prune": "node scripts/prune.mjs",
+    "test": "tsx --tsconfig ./tsconfig.build.json --test ./src/**/*.{spec,test}.ts ./test/**/*.{spec,test}.ts"
   }
 }