zodselect 1.0.5 → 1.0.6

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

@@ -1,8 +1,9 @@
-import { ZodBoolean, ZodLazy, ZodObject, ZodOptional, ZodType, ZodUnion } from 'zod';
+import { ZodBoolean, ZodLazy, ZodObject, ZodOptional, ZodRecord, ZodType, ZodUnion } from 'zod';
+import { $ZodRecordKey } from 'zod/v4/core';
 import { ZodSelect } from './select.js';
 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 {};

package/dist/build-select-schema.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { getInnerType, isZodLazy, isZodObject, isZodObjectLoose } from './utilities.js';
+import { getInnerType, isZodLazy, isZodObject, isZodObjectLoose, isZodRecord } from './utilities.js';
 function buildSelect(schema, cache = new Map()) {
     schema = getInnerType(schema, false);
     if (cache.has(schema)) {
@@ -26,6 +26,27 @@ function buildSelect(schema, cache = new Map()) {
         cache.set(schema, result);
         return result;
     }
+    if (isZodRecord(schema)) {
+        const valueType = schema.def.valueType;
+        const select = buildSelect(valueType, cache);
+        // A record select means: either a boolean, or a record of the same key type with select-values
+        const result = z.union([
+            z.boolean(),
+            z.record(schema.def.keyType, select)
+        ]).optional();
+        cache.set(schema, result);
+        return result;
+    }
+    if (schema.def.type === 'unknown') {
+        const result = z
+            .union([
+            z.boolean(),
+            z.record(z.string(), z.lazy(() => buildSelect(schema, cache)))
+        ])
+            .optional();
+        cache.set(schema, result);
+        return result;
+    }
     let types;
     if (schema.def.type === 'intersection') {
         types = [schema.def.left, schema.def.right];

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

@@ -137,4 +137,42 @@ describe('.buildSelectSchema()', () => {
         // Should be the same object (by reference)
         assert.strictEqual(rolesSelect, nestedRoleSelect);
     });
+    it('should support record types', () => {
+        const schema = z.object({
+            tags: z.record(z.string(), z.string())
+        });
+        const select = buildSelectSchema(schema);
+        const tagsSelect = select.shape.tags;
+        assert.strictEqual(tagsSelect.type, 'optional');
+        const union = tagsSelect.def.innerType;
+        assert.strictEqual(union.type, 'union');
+        assert.strictEqual(union.def.options[0].type, 'boolean');
+        assert.strictEqual(union.def.options[1].type, 'record');
+        assert.strictEqual(union.def.options[1].def.keyType.type, 'string');
+        assert.strictEqual(union.def.options[1].def.valueType.type, 'optional');
+        assert.strictEqual(union.def.options[1].def.valueType.def.innerType.type, 'boolean');
+    });
+    it('should support unknown types', () => {
+        const schema = z.object({
+            tags: z.unknown()
+        });
+        const select = buildSelectSchema(schema);
+        const result = select.safeParse({
+            tags: {
+                any: {
+                    damn: true
+                },
+                thing: true
+            }
+        });
+        assert.strictEqual(result.success, true);
+        assert.deepStrictEqual(result.data, {
+            tags: {
+                any: {
+                    damn: true
+                },
+                thing: true
+            }
+        });
+    });
 });

package/dist/utilities.d.ts

@@ -1,4 +1,4 @@
-import { ZodArray, ZodLazy, ZodNullable, ZodObject, ZodOptional, ZodType, ZodUnion, ZodUnknown } from 'zod';
+import { ZodArray, 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 isZodLazy(obj: unknown): obj is ZodLazy;
@@ -6,6 +6,7 @@ export declare function isZodNullable(obj: unknown): obj is ZodNullable<ZodType>
 export declare function isZodObject(obj: unknown, isLoose?: boolean): obj is ZodObject;
 export declare function isZodObjectLoose(obj: ZodObject): boolean;
 export declare function isZodOptional(obj: unknown): obj is ZodOptional<ZodType>;
+export declare function isZodRecord(obj: unknown): obj is ZodRecord;
 export declare function isZodType(obj: unknown): obj is ZodType;
 export declare function isZodUnion(obj: unknown): obj is ZodUnion<ZodType[]>;
 export declare function isZodUnknown(obj: unknown): obj is ZodUnknown;

package/dist/utilities.js

@@ -38,6 +38,9 @@ export function isZodObjectLoose(obj) {
 export function isZodOptional(obj) {
     return isZodType(obj) && (obj.def.type === 'optional');
 }
+export function isZodRecord(obj) {
+    return isZodType(obj) && (obj.def.type === 'record');
+}
 export function isZodType(obj) {
     return typeof obj === 'object' && obj !== null && 'def' in obj && 'safeParse' in obj && typeof obj.safeParse === 'function';
 }

package/dist/utilities.spec.js

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
 import { z } from 'zod';
-import { getInnerType, isZodObject, isZodOptional, isZodUnion, isZodUnknown } from './utilities.js';
+import { getInnerType, isZodObject, isZodOptional, isZodRecord, isZodUnion, isZodUnknown } from './utilities.js';
 describe('.utilities()', () => {
     describe('.getInnerType()', () => {
         it('getInnerType identifies inner types', () => {
@@ -54,6 +54,33 @@ describe('.utilities()', () => {
         assert.ok(isZodOptional(optionalSchema));
         assert.ok(!isZodOptional(stringSchema));
     });
+    it('isZodRecord detects complex record schemas with optional fields', () => {
+        // Create a sample RecordAttachmentSchema
+        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 nonRecordSchema = z.object({ field: z.string() });
+        // Test record detection
+        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({
+            'file1': { name: 'test.pdf', size: 1024, type: 'application/pdf' },
+            'file2': { name: 'image.jpg', size: 2048, type: 'image/jpeg' }
+        });
+        assert.ok(validRecord, 'Should successfully parse valid record data');
+    });
+    it('isZodRecord detects ZodRecord', () => {
+        const recordSchema = z.record(z.string(), z.string());
+        const stringSchema = z.string();
+        assert.ok(isZodRecord(recordSchema));
+        assert.ok(!isZodRecord(stringSchema));
+    });
     it('isZodUnion detects ZodUnion', () => {
         const unionSchema = z.union([z.string(), z.number()]);
         const stringSchema = z.string();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "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",
@@ -33,7 +33,7 @@
     "typescript": "^5.9.2"
   },
   "dependencies": {
-    "zod": "^4.0.17"
+    "zod": "^4.1.1"
   },
   "scripts": {
     "build": "node scripts/build.mjs && tsc --project tsconfig.build.json",