zodselect 1.0.2 → 1.0.4

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

@@ -0,0 +1,8 @@
+import { ZodBoolean, ZodLazy, ZodObject, ZodOptional, ZodType, ZodUnion } from 'zod';
+import { ZodSelect } from './select.js';
+export type BasicSelect = ZodObject<Readonly<{
+    [k: string]: 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

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { getInnerType, isZodLazy, isZodObject, isZodObjectLoose } from './utilities.js';
+function buildSelect(schema, cache = new Map()) {
+    schema = getInnerType(schema, false);
+    if (cache.has(schema)) {
+        return cache.get(schema);
+    }
+    if (isZodLazy(schema)) {
+        const select = z.lazy(() => {
+            return buildSelect(schema.def.getter(), cache);
+        });
+        cache.set(schema, select);
+        return select;
+    }
+    if (isZodObject(schema)) {
+        const shape = {};
+        let select;
+        for (const key in schema.shape) {
+            shape[key] = buildSelect(schema.shape[key], cache);
+        }
+        select = z.object(shape);
+        if (!isZodObjectLoose(schema)) {
+            select = select.strict();
+        }
+        const result = z.union([z.boolean(), select]).optional();
+        cache.set(schema, result);
+        return result;
+    }
+    let types;
+    if (schema.def.type === 'intersection') {
+        types = [schema.def.left, schema.def.right];
+    }
+    if (schema.def.type === 'tuple') {
+        types = schema.def.items;
+    }
+    if (schema.def.type === 'union') {
+        types = schema.def.options;
+    }
+    if (types) {
+        const hasLazy = types.some(item => isZodLazy(item));
+        if (hasLazy) {
+            return z.lazy(() => {
+                return buildSelectMerge(types);
+            });
+        }
+        return buildSelectMerge(types);
+    }
+    return z.boolean().optional();
+}
+function buildSelectMerge(types) {
+    const shape = {};
+    let isStrict = false;
+    for (const cur of types) {
+        const select = buildSelect(cur);
+        let clause;
+        if (isZodLazy(select)) {
+            clause = select.def.getter();
+        }
+        else {
+            clause = select;
+        }
+        if (clause.def.innerType.def.type === 'union') {
+            const obj = getInnerType(clause.def.innerType.def.options[1]);
+            for (const key in obj.shape) {
+                shape[key] = obj.shape[key];
+            }
+            if (!isZodObjectLoose(obj)) {
+                isStrict = true;
+            }
+        }
+    }
+    let result = z.object(shape);
+    if (isStrict) {
+        result = result.strict();
+    }
+    return z.union([z.boolean(), result]).optional();
+}
+export function buildSelectSchema(schema) {
+    const result = buildSelect(schema);
+    if (isZodLazy(result)) {
+        return result.def.getter().def.innerType.def.options[1];
+    }
+    return result.def.innerType.def.options[1];
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,140 @@
+import { strict as assert } from 'assert';
+import { describe, it } from 'node:test';
+import { z, ZodObject } from 'zod';
+import { buildSelectSchema } from './build-select-schema.js';
+import { getInnerType, isZodObjectLoose } from './utilities.js';
+describe('.buildSelectSchema()', () => {
+    it('should build select schema for a flat object', () => {
+        const schema = z.object({
+            age: z.number(),
+            name: z.string()
+        });
+        const selectSchema = buildSelectSchema(schema);
+        assert(selectSchema instanceof ZodObject);
+        assert.deepEqual(selectSchema.parse({ name: true }), { name: true });
+        assert.deepEqual(selectSchema.parse({}), {});
+        assert.throws(() => selectSchema.parse({ name: 'yes' }), /expected boolean/);
+        assert.throws(() => selectSchema.parse({ unknown: true }), /Unrecognized key/);
+    });
+    it('should handle nested objects', () => {
+        const schema = z.object({
+            user: z.object({
+                id: z.string(),
+                profile: z.object({
+                    displayName: z.string()
+                })
+            })
+        });
+        const selectSchema = buildSelectSchema(schema);
+        const result = selectSchema.parse({
+            user: {
+                id: true,
+                profile: {
+                    displayName: true
+                }
+            }
+        });
+        assert.deepEqual(result, {
+            user: {
+                id: true,
+                profile: {
+                    displayName: true
+                }
+            }
+        });
+    });
+    it('should build select schema for a union of objects', () => {
+        const schema = z.union([
+            z.object({ type: z.literal('a'), valueA: z.string() }).strict(),
+            z.object({ type: z.literal('b'), valueB: z.number() }).strict()
+        ]);
+        const selectSchema = buildSelectSchema(schema);
+        assert(selectSchema instanceof ZodObject);
+        const result = selectSchema.parse({
+            type: true,
+            valueA: true
+        });
+        assert.deepEqual(result, {
+            type: true,
+            valueA: true
+        });
+        assert.throws(() => selectSchema.parse({ valueC: true }), /Unrecognized key/);
+    });
+    it('should support intersections of objects', () => {
+        const schema = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
+        const select = buildSelectSchema(schema);
+        assert.strictEqual(getInnerType(select.shape.a).def.type, 'boolean');
+        assert.strictEqual(getInnerType(select.shape.b).def.type, 'boolean');
+    });
+    it('should support tuples of objects', () => {
+        const schema = z.tuple([
+            z.object({ foo: z.string() }),
+            z.object({ bar: z.number() })
+        ]);
+        const select = buildSelectSchema(schema);
+        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', () => {
+        const schema = z.union([
+            z.object({ strictA: z.string() }).strict(),
+            z.object({ strictB: z.number() }).strict()
+        ]);
+        const select = buildSelectSchema(schema);
+        assert.strictEqual(isZodObjectLoose(select), false);
+    });
+    it('should allow optional keys in the select schema', () => {
+        const schema = z.object({
+            optionalField: z.string().optional()
+        });
+        const select = buildSelectSchema(schema);
+        assert.strictEqual(getInnerType(select.shape.optionalField).def.type, 'boolean');
+    });
+    it('should handle direct recursion', () => {
+        const RoleSchema = z.lazy(() => {
+            return (z.object({
+                name: z.string(),
+                roles: z.array(RoleSchema)
+            }));
+        });
+        const select = buildSelectSchema(RoleSchema);
+        assert.deepStrictEqual(Object.keys(select.shape), ['name', 'roles']);
+        const nameSelect = select.shape.name;
+        assert.strictEqual(nameSelect.def.type, 'optional');
+        assert.strictEqual(nameSelect.def.innerType.def.type, 'boolean');
+        const rolesSelect = select.shape.roles;
+        assert.strictEqual(rolesSelect.def.type, 'lazy');
+        const innerUnion = rolesSelect.def.getter().def.innerType;
+        assert.strictEqual(innerUnion.def.type, 'union');
+        const booleanItem = innerUnion.def.options[0];
+        assert.strictEqual(booleanItem.def.type, 'boolean');
+        const roleItem = innerUnion.def.options[1];
+        assert.strictEqual(roleItem.def.type, 'object');
+    });
+    it('should support mutual recursion (cross-recursive)', () => {
+        const A = z.lazy(() => z.object({
+            b: B
+        }));
+        const B = z.lazy(() => z.object({
+            a: A
+        }));
+        const select = buildSelectSchema(A);
+        assert.strictEqual(select.shape.b.def.type, 'lazy');
+        const bUnion = select.shape.b.def.getter();
+        assert.strictEqual(bUnion.def.innerType.def.type, 'union');
+        const bObj = bUnion.def.innerType.def.options[1];
+        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({
+            name: z.string(),
+            roles: z.array(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;
+        // Should be the same object (by reference)
+        assert.strictEqual(rolesSelect, nestedRoleSelect);
+    });
+});

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './build-select-schema.js';
 export * from './merge-select.js';
 export * from './refine-schema.js';
 export * from './select.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from './build-select-schema.js';
 export * from './merge-select.js';
 export * from './refine-schema.js';
 export * from './select.js';

package/dist/merge-select.d.ts

@@ -1,3 +1,3 @@
-import { ZodType, ZodUnion } from 'zod/v4';
+import { ZodType, ZodUnion } from 'zod';
 import { MergeSelect, MultiSelect, ZodSelect } from './select.js';
 export declare function mergeSelect<T extends ZodType<object> | ZodUnion, TSelect1 extends ZodSelect<T>, TSelect2 extends MultiSelect<T>>(schema: T, select1: TSelect1, select2?: TSelect2): MergeSelect<T, TSelect1, TSelect2>;

package/dist/refine-schema.d.ts

@@ -1,6 +1,16 @@
-import { core, z, ZodAny, ZodArray, ZodBoolean, ZodDate, ZodLiteral, ZodNever, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodRawShape, ZodString, ZodType, ZodUnion, ZodUnknown } from 'zod/v4';
+import { core, z, ZodAny, ZodArray, ZodBoolean, ZodDate, ZodLiteral, ZodNever, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodRawShape, ZodString, ZodTuple, ZodType, ZodUnion, ZodUnknown } from 'zod';
 import { IsAny, IsJsonType } from './types.js';
-export type RefinedSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T>> = T extends ZodUnion ? RefinedUnionSchema<T, TShape> : T extends ZodType<object> ? RefinedTypeSchema<z.infer<T>, TShape> : never;
+type ApplyOptionalNullable<T, U extends ZodType> = IsAny<T, U, undefined extends T ? null extends T ? ZodOptional<ZodNullable<U>> : ZodOptional<U> : null extends T ? ZodNullable<U> : U>;
+type DepthLimit = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+type InternalZodify<T, TDepth extends number = 0> = TDepth extends 9 ? ZodType : IsAny<T, ZodAny, T extends string ? string extends T ? ZodString : ZodLiteral<T> : T extends number ? ZodNumber : T extends boolean ? ZodBoolean : T extends Date ? ZodDate : unknown extends T ? ZodUnknown : T extends Array<infer U> ? ZodArray<Zodify<U, NextDepth<TDepth>>> : T extends object ? IsJsonType<T, true, ZodObject<{
+    [K in keyof T]-?: Zodify<T[K], NextDepth<TDepth>>;
+}, core.$strict>, ZodType<T>> : never>;
+type IsTuple<T, TTrue = true, TFalse = false> = T extends [infer TFirst, infer TSecond, ...infer TRest] ? TTrue : TFalse;
+type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => (infer R) ? R : never;
+type NextDepth<T extends number> = T extends 0 ? 1 : T extends 1 ? 2 : T extends 2 ? 3 : T extends 3 ? 4 : T extends 4 ? 5 : T extends 5 ? 6 : T extends 6 ? 7 : T extends 7 ? 8 : T extends 8 ? 9 : 9;
+type Push<T extends any[], V> = [...T, V];
+type ReapplyOptionalNullable<T, U extends z.ZodType> = T extends ZodOptional<ZodNullable<ZodType>> ? ZodOptional<ZodNullable<U>> : T extends ZodNullable<ZodOptional<ZodType>> ? ZodNullable<ZodOptional<U>> : T extends ZodOptional<ZodType> ? ZodOptional<U> : T extends ZodNullable<ZodType> ? ZodNullable<U> : U;
+export type RefinedSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, TIsSimple>, TIsSimple extends boolean> = T extends ZodUnion ? RefinedUnionSchema<T, TShape> : T extends ZodType<object> ? RefinedTypeSchema<z.infer<T>, TShape> : never;
 export type RefinedTypeSchema<T extends object, TShape, TDepth extends number = 0> = TDepth extends keyof DepthLimit ? ZodObject<{
     [K in keyof T & keyof TShape]: TShape[K] extends (schema: infer S) => ZodType ? ReturnType<TShape[K]> : TShape[K] extends ZodType ? TShape[K] : TShape[K] extends boolean ? Zodify<T[K]> : TShape[K] extends object ? Exclude<T[K], null | undefined> extends Array<infer U> ? U extends object ? ApplyOptionalNullable<T[K], z.ZodArray<RefinedTypeSchema<U, TShape[K], NextDepth<TDepth>>>> : Zodify<T[K]> : Exclude<T[K], null | undefined> extends object ? ApplyOptionalNullable<T[K], RefinedTypeSchema<Exclude<T[K], null | undefined>, TShape[K], NextDepth<TDepth>>> : ZodNever : ZodNever;
 }, core.$strict> : any;
@@ -10,27 +20,20 @@ export type RefinedUnionSchema<T extends ZodUnion, TShape> = ZodUnion<T['options
         [K in keyof Rest]: Rest[K] extends ZodType ? z.infer<Rest[K]> extends object ? RefinedTypeSchema<z.infer<Rest[K]>, TShape> : Extract<Rest[K], ZodType> : Extract<Rest[K], ZodType>;
     }
 ] : never : never>;
-export type RefineObject<T extends object> = {
-    [K in keyof T]?: RefineType<T[K]>;
+type Refinement<T extends ZodType, TIsSimple extends boolean> = TIsSimple extends true ? boolean : ((schema: T) => ZodType) | boolean | ZodType;
+export type RefineObject<T extends object, TIsSimple extends boolean> = {
+    [K in keyof T]?: RefineType<T[K], TIsSimple>;
+};
+export type RefineSchema<T extends ZodType<object> | ZodUnion, TIsSimple extends boolean> = T extends ZodUnion ? RefineZodUnion<T> : T extends ZodType<object> ? RefineObject<z.infer<T>, TIsSimple> : never;
+type RefineType<T, TIsSimple extends boolean> = IsTuple<TuplifyUnion<Exclude<T, null | undefined>>, Refinement<Zodify<T>, TIsSimple>, Exclude<T, null | undefined> extends string ? Refinement<ApplyOptionalNullable<T, ZodString>, TIsSimple> : Exclude<T, null | undefined> extends number ? Refinement<ApplyOptionalNullable<T, ZodNumber>, TIsSimple> : Exclude<T, null | undefined> extends boolean ? Refinement<ApplyOptionalNullable<T, ZodBoolean>, TIsSimple> : Exclude<T, null | undefined> extends Date ? Refinement<ApplyOptionalNullable<T, ZodDate>, TIsSimple> : Exclude<T, null | undefined> extends Array<infer U> ? Exclude<U, null | undefined> extends object ? Refinement<Zodify<T>, TIsSimple> | RefineObject<Extract<U, object>, TIsSimple> : Refinement<Zodify<T>, TIsSimple> : Exclude<T, null | undefined> extends object ? IsJsonType<Exclude<T, null | undefined>, false, Refinement<Zodify<T>, TIsSimple> | RefineObject<Extract<T, object>, TIsSimple>, Refinement<Zodify<T>, TIsSimple>> : unknown extends Exclude<T, null | undefined> ? Refinement<Zodify<T>, TIsSimple> : never>;
+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 RefineSchema<T extends ZodType<object> | ZodUnion> = T extends ZodUnion ? RefineZodUnion<T> : T extends ZodType<object> ? RefineObject<z.infer<T>> : never;
 export type RefineZodUnion<T extends ZodUnion> = {
     [K in keyof UnionToIntersection<T['options'][number] extends ZodObject<infer Shape extends ZodRawShape> ? Shape : object>]?: 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>>;
 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>>>;
-type ApplyOptionalNullable<T, U extends ZodType> = IsAny<T, U, undefined extends T ? null extends T ? ZodOptional<ZodNullable<U>> : ZodOptional<U> : null extends T ? ZodNullable<U> : U>;
-type DepthLimit = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-type InternalZodify<T, TDepth extends number = 0> = TDepth extends 9 ? ZodType : IsAny<T, ZodAny, T extends string ? string extends T ? ZodString : ZodLiteral<T> : T extends number ? ZodNumber : T extends boolean ? ZodBoolean : T extends Date ? ZodDate : unknown extends T ? ZodUnknown : T extends Array<infer U> ? ZodArray<Zodify<U, NextDepth<TDepth>>> : T extends object ? IsJsonType<T, true, ZodObject<{
-    [K in keyof T]-?: Zodify<T[K], NextDepth<TDepth>>;
-}, core.$strict>, ZodType<T>> : never>;
-type IsTuple<T, TTrue = true, TFalse = false> = T extends [infer TFirst, infer TSecond, ...infer TRest] ? TTrue : TFalse;
-type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => (infer R) ? R : never;
-type NextDepth<T extends number> = T extends 0 ? 1 : T extends 1 ? 2 : T extends 2 ? 3 : T extends 3 ? 4 : T extends 4 ? 5 : T extends 5 ? 6 : T extends 6 ? 7 : T extends 7 ? 8 : T extends 8 ? 9 : 9;
-type Push<T extends any[], V> = [...T, V];
-type ReapplyOptionalNullable<T, U extends z.ZodType> = T extends ZodOptional<ZodNullable<ZodType>> ? ZodOptional<ZodNullable<U>> : T extends ZodNullable<ZodOptional<ZodType>> ? ZodNullable<ZodOptional<U>> : T extends ZodOptional<ZodType> ? ZodOptional<U> : T extends ZodNullable<ZodType> ? ZodNullable<U> : U;
-type Refinement<T extends ZodType> = ((schema: T) => ZodType) | boolean | ZodType;
-type RefineType<T> = IsTuple<TuplifyUnion<Exclude<T, null | undefined>>, Refinement<Zodify<T>>, Exclude<T, null | undefined> extends string ? Refinement<ApplyOptionalNullable<T, ZodString>> : Exclude<T, null | undefined> extends number ? Refinement<ApplyOptionalNullable<T, ZodNumber>> : Exclude<T, null | undefined> extends boolean ? Refinement<ApplyOptionalNullable<T, ZodBoolean>> : Exclude<T, null | undefined> extends Date ? Refinement<ApplyOptionalNullable<T, ZodDate>> : Exclude<T, null | undefined> extends Array<infer U> ? Exclude<U, null | undefined> extends object ? Refinement<Zodify<T>> | RefineObject<Extract<U, object>> : Refinement<Zodify<T>> : Exclude<T, null | undefined> extends object ? IsJsonType<Exclude<T, null | undefined>, false, Refinement<Zodify<T>> | RefineObject<Extract<T, object>>, Refinement<Zodify<T>>> : unknown extends Exclude<T, null | undefined> ? Refinement<Zodify<T>> : never>;
-export declare function refineSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T>>(schema: T, shape: TShape): RefinedSchema<T, TShape>;
+export declare function refineSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, false>>(schema: T, shape: TShape): RefinedSchema<T, TShape, false>;
 export {};

package/dist/refine-schema.js

@@ -1,4 +1,4 @@
-import { z } from 'zod/v4';
+import { z } from 'zod';
 import { getInnerType, isZodArray, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
 // Main function to refine the schema
 export function refineSchema(schema, shape) {
@@ -40,15 +40,15 @@ function refineSchemaField(fieldSchema, fieldShape) {
         return z.array(refineSchemaField(fieldSchema.element, fieldShape));
     }
     else if (isZodOptional(fieldSchema)) {
-        return refineSchemaField(fieldSchema._def.innerType, fieldShape).optional();
+        return refineSchemaField(fieldSchema.def.innerType, fieldShape).optional();
     }
     else if (isZodNullable(fieldSchema)) {
-        return refineSchemaField(fieldSchema._def.innerType, fieldShape).nullable();
+        return refineSchemaField(fieldSchema.def.innerType, fieldShape).nullable();
     }
     else {
         const innerType = getInnerType(fieldSchema);
         // There are wrapper types we can't forward because the underlying object structures are changing.
-        if (innerType) {
+        if (innerType !== fieldSchema) {
             return refineSchemaField(innerType, fieldShape);
         }
     }

package/dist/refine-schema.spec.js

@@ -1,6 +1,6 @@
 import { strict as assert, deepStrictEqual, throws } from 'assert';
 import { describe, it } from 'node:test';
-import { z, ZodError } from 'zod/v4';
+import { z, ZodError } from 'zod';
 import { refineSchema } from './refine-schema.js';
 describe('.refineSchema()', () => {
     it('should retain required fields', () => {

package/dist/select.d.ts

@@ -1,12 +1,12 @@
-import { z, ZodType, ZodUnion } from 'zod/v4';
-import { RefinedTypeSchema, RefinedUnionSchema, RefineObject, RefineZodUnion } from './refine-schema.js';
+import { z, ZodTuple, ZodType, ZodUnion } from 'zod';
+import { RefinedTypeSchema, RefinedUnionSchema, RefineObject, RefineZodTuple, RefineZodUnion } from './refine-schema.js';
 import { DeepMergeAll, IsEqual } from './types.js';
 export type InferMergedType<T extends ZodType<object> | ZodUnion, U extends readonly ZodSelect<T>[] | undefined | ZodSelect<T>> = U extends undefined ? z.infer<T> : U extends readonly ZodSelect<T>[] ? DeepMergeAll<InferTuple<T, U>> : U extends ZodSelect<T> ? InferType<T, U> : never;
-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>> ? 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 ZodType<object> | ZodUnion> = (T extends ZodUnion ? (RefineZodUnion<T> | ZodUnion) : T extends ZodType<object> ? (RefineObject<z.infer<T>> | ZodType<object>) : never);
 type InferTuple<T extends ZodType<object> | ZodUnion, U extends readonly ZodSelect<T>[]> = {
     [K in keyof U]: InferType<T, U[K]>;
 };
+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 {};

package/dist/types.d.ts

@@ -9,8 +9,8 @@ export type IsJsonType<T, TDeep extends boolean = true, TTrue = true, TFalse = f
 } extends {
     [K in keyof T]: true;
 } ? TTrue : TFalse : TFalse;
+type JsonType = boolean | null | number | string | undefined;
 export type Mutable<T> = {
     -readonly [P in keyof T]: T[P];
 };
-type JsonType = boolean | null | number | string | undefined;
 export {};

package/dist/utilities.d.ts

@@ -1,8 +1,10 @@
-import { ZodArray, ZodNullable, ZodObject, ZodOptional, ZodType, ZodUnion, ZodUnknown } from 'zod/v4';
-export declare function getInnerType(schema: ZodType): undefined | ZodType;
+import { ZodArray, ZodLazy, ZodNullable, ZodObject, ZodOptional, 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;
 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 isZodType(obj: unknown): obj is ZodType;
 export declare function isZodUnion(obj: unknown): obj is ZodUnion<ZodType[]>;

package/dist/utilities.js

@@ -1,20 +1,25 @@
-import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodOptional } from 'zod/v4';
-export function getInnerType(schema) {
-    if (schema instanceof ZodOptional || schema instanceof ZodNullable || schema instanceof ZodDefault || schema instanceof ZodCatch) {
-        return schema.def.innerType;
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodOptional } from 'zod';
+export function getInnerType(schema, unwrapLazy = true) {
+    if (schema instanceof ZodOptional
+        || schema instanceof ZodNullable
+        || schema instanceof ZodDefault
+        || schema instanceof ZodCatch) {
+        return getInnerType(schema.def.innerType, unwrapLazy);
     }
-    else if (schema instanceof ZodLazy) {
-        return schema.def.getter();
+    if (schema instanceof ZodArray) {
+        return getInnerType(schema.def.element, unwrapLazy);
     }
-    else if (schema instanceof ZodArray) {
-        return schema.element;
+    if (unwrapLazy && schema instanceof ZodLazy) {
+        return getInnerType(schema.def.getter());
     }
-    // Not a recognized wrapper type
-    return undefined;
+    return schema;
 }
 export function isZodArray(obj) {
     return isZodType(obj) && (obj.def.type === 'array');
 }
+export function isZodLazy(obj) {
+    return isZodType(obj) && (obj.def.type === 'lazy');
+}
 export function isZodNullable(obj) {
     return isZodType(obj) && (obj.def.type === 'nullable');
 }
@@ -27,6 +32,9 @@ export function isZodObject(obj, isLoose) {
     }
     return isLoose === isZodUnknown(obj.def.catchall);
 }
+export function isZodObjectLoose(obj) {
+    return !!isZodUnknown(obj.def.catchall);
+}
 export function isZodOptional(obj) {
     return isZodType(obj) && (obj.def.type === 'optional');
 }

package/dist/utilities.spec.js

@@ -1,22 +1,40 @@
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
-import { z } from 'zod/v4';
+import { z } from 'zod';
 import { getInnerType, isZodObject, isZodOptional, isZodUnion, isZodUnknown } from './utilities.js';
 describe('.utilities()', () => {
-    it('getInnerType identifies inner types', () => {
-        const optionalString = z.string().optional();
-        const nullableString = z.string().nullable();
-        const defaultString = z.string().default('default');
-        const catchString = z.string().catch('fallback');
-        const lazyString = z.lazy(() => z.string());
-        const arrayString = z.array(z.string());
-        assert.strictEqual(getInnerType(optionalString).def.type, optionalString.def.innerType.def.type);
-        assert.strictEqual(getInnerType(nullableString).def.type, nullableString.def.innerType.def.type);
-        assert.strictEqual(getInnerType(defaultString).def.type, defaultString.def.innerType.def.type);
-        assert.strictEqual(getInnerType(catchString).def.type, catchString.def.innerType.def.type);
-        assert.strictEqual(getInnerType(lazyString).def.type, lazyString.def.getter().def.type);
-        assert.strictEqual(getInnerType(arrayString).def.type, arrayString.element.def.type);
-        assert.strictEqual(getInnerType(z.string()), undefined); // Not a wrapper type
+    describe('.getInnerType()', () => {
+        it('getInnerType identifies inner types', () => {
+            const optionalString = z.string().optional();
+            const nullableString = z.string().nullable();
+            const defaultString = z.string().default('default');
+            const catchString = z.string().catch('fallback');
+            const lazyString = z.lazy(() => z.string());
+            const arrayString = z.array(z.string());
+            assert.strictEqual(getInnerType(optionalString).def.type, optionalString.def.innerType.def.type);
+            assert.strictEqual(getInnerType(nullableString).def.type, nullableString.def.innerType.def.type);
+            assert.strictEqual(getInnerType(defaultString).def.type, defaultString.def.innerType.def.type);
+            assert.strictEqual(getInnerType(catchString).def.type, catchString.def.innerType.def.type);
+            assert.strictEqual(getInnerType(lazyString).def.type, lazyString.def.getter().def.type);
+            assert.strictEqual(getInnerType(arrayString).def.type, arrayString.element.def.type);
+            assert.strictEqual(getInnerType(z.string()).def.type, 'string'); // Not a wrapper type
+        });
+        it('should return base type from array', () => {
+            const schema = z.array(z.number());
+            const inner = getInnerType(schema);
+            assert.strictEqual(inner.def.type, 'number');
+        });
+        it('should unwrap nested optional -> nullable -> default -> string', () => {
+            const schema = z.string().default('x').nullable().optional();
+            const inner = getInnerType(schema);
+            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 inner = getInnerType(wrapped);
+            assert.strictEqual(inner.def.type, 'string');
+        });
     });
     it('isZodObject detects ZodObject', () => {
         const objectSchema = z.object({ name: z.string() });

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "zodselect",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/secure-data-systems/zod-select.git"
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,15 +25,15 @@
     }
   },
   "devDependencies": {
-    "@secure-data-systems/eslint-config": "^1.0.2",
-    "@secure-data-systems/tsconfig": "^1.0.0",
-    "@types/node": "^24.0.0",
+    "@secure-data-systems/eslint-config": "^1.0.7",
+    "@secure-data-systems/tsconfig": "^1.0.1",
+    "@types/node": "^24.0.13",
     "glob": "^11.0.3",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "zod": "^3.25.58"
+    "zod": "^4.0.5"
   },
   "scripts": {
     "build": "node scripts/build.mjs && tsc --project tsconfig.build.json",