zodselect 1.0.8 → 1.0.9

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

@@ -91,13 +91,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 +112,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 +126,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;

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) => {
@@ -204,20 +204,20 @@ describe('.refineSchema()', () => {
         });
     });
     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 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 {};

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.9",
   "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,21 @@
     }
   },
   "devDependencies": {
-    "@secure-data-systems/eslint-config": "^1.0.26",
-    "@secure-data-systems/tsconfig": "^1.0.2",
+    "@secure-data-systems/eslint-config": "^1.0.33",
+    "@secure-data-systems/tsconfig": "^1.0.3",
     "@types/node": "^24.10.1",
-    "glob": "^11.0.3",
-    "tsx": "^4.20.6",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "zod": "^4.1.12"
+    "zod": "^4.1.13"
   },
   "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\""
+    "test": "tsx --tsconfig ./tsconfig.build.json --test ./src/**/*.{spec,test}.ts ./test/**/*.{spec,test}.ts"
   }
 }