zodselect 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SecureDataSystems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,241 @@
+# ZodSelect
+
+**ZodSelect** is a strongly typed selection utility library built on top of [Zod](https://github.com/colinhacks/zod) (v4). It allows developers to create dynamic select statements with precise TypeScript inference — perfect for shaping responses in database queries, or APIs. `ZodSelect` ensures that both your types and runtime logic stay in sync — with no external dependencies.
+
+- ✅ Built on Zod v4
+- ✅ No external dependencies (except `zod`)
+- ✅ Fully type-safe field selections
+- ✅ Supports merging multiple Zod Selects
+- ✅ Generate Zod schemas from Zod Selects
+- ✅ Allows schema refinement and overrides
+
+---
+
+## Install
+
+```bash
+pnpm add zod @securedatasystems/zod-select
+# or
+npm install zod @securedatasystems/zod-select
+```
+
+---
+
+## Example Schema
+
+All examples use the following Zod schema:
+
+```ts
+const UserSchema = z.object({
+	email: z.string(),
+	firstName: z.string(),
+	lastName: z.string(),
+	address: z.object({
+		street: z.string(),
+		city: z.string(),
+		state: z.string(),
+		zip: z.string()
+	})
+});
+```
+
+---
+
+## 🧠 Zod Select with Inferred Type
+
+A single selection object returns a strongly typed result:
+
+```ts
+function find<T extends ZodSelect<typeof UserSchema>>(select: T): InferType<typeof UserSchema, T> {
+	// ...Find Logic
+}
+
+const user = find({
+	firstName: true,
+	lastName: true,
+	address: { street: true }
+});
+```
+
+```ts
+// user inferred as:
+{
+	firstName: string;
+	lastName: string;
+	address: { street: string };
+}
+```
+
+---
+
+## 🔀 Merging Multiple Zod Selects
+
+You can combine multiple select statements and still get precise inference:
+
+```ts
+function find<T extends MultiSelect<typeof UserSchema>>(select: T): InferMergedType<typeof UserSchema, T> {
+	// ...Find Logic
+}
+
+const user = find([
+	{ lastName: true },
+	{ firstName: true }
+]);
+```
+
+```ts
+// user inferred as:
+{
+	firstName: string;
+	lastName: string;
+}
+```
+
+---
+
+## 🧹 Mix Zod Schemas with Zod Selects
+
+You can mix plain field selections with Zod object schemas for flexible results:
+
+```ts
+function find<T extends MultiSelect<typeof UserSchema>>(select: T): InferMergedType<typeof UserSchema, T> {
+	// ...Find Logic
+}
+
+const user = find([
+	{ lastName: true },
+	z.object({
+		address: z.object({ state: z.string() })
+	})
+]);
+```
+
+```ts
+// user inferred as:
+{
+	lastName: string;
+	address: { state: string };
+}
+```
+
+---
+
+## 🛠️ Generate Zod Schemas from Zod Selects
+
+Use `refineSchema` to turn a selection into a Zod schema:
+
+```ts
+const schema = refineSchema(UserSchema, {
+	firstName: true,
+	address: true
+});
+```
+
+```ts
+// schema.shape:
+{
+	firstName: z.ZodString;
+	address: z.ZodObject<...>;
+}
+```
+
+---
+
+## 🧪 Refine Field Types Inline
+
+Selections can refine field types inline using Zod methods:
+
+```ts
+const schema = refineSchema(UserSchema, {
+	firstName: s => s.optional()
+});
+```
+
+```ts
+// schema.shape:
+{
+	firstName: z.ZodOptional<z.ZodString>;
+}
+```
+
+---
+
+## 🧬 Redefine Field Types
+
+Selections can also redefine types entirely:
+
+```ts
+const schema = refineSchema(UserSchema, {
+	firstName: z.number()
+});
+```
+
+```ts
+// schema.shape:
+{
+	firstName: z.ZodNumber;
+}
+```
+
+---
+
+## 🧵 Putting it all together
+
+Combining all methods and types together you can build powerful, type-safe selection and inference using the zod schemas you already have.
+
+```ts
+function find<T extends MultiSelect<typeof UserSchema>>(select: T): InferMergedType<typeof UserSchema, T>[] {
+	const selectArr = Array.isArray(select) ? select : [select];
+	const sel: Record<string, 1> = {};
+
+	for (let schema of selectArr) {
+		if (!(schema instanceof ZodType)) {
+			schema = refineSchema(UserSchema, schema);
+			continue;
+		}
+
+		// Crawl each zod schema building the select statement
+	}
+
+	// Find Logic
+}
+
+function getUsersFromTexas<T extends MultiSelect<typeof UserSchema>>(
+	sel: T
+): InferMergedType<typeof UserSchema, MergeSelect<typeof UserSchema, { address: boolean }, T>>[] {
+	const users = find(
+		// Use the merge select function to combined a ZodSelect with a MultiSelect
+		mergeSelect(UserSchema, { address: true }, sel)
+	);
+
+	return users.filter((user) =>
+		// At this point the user object has address and whatever fields are specified in the
+		// passed in select but VS code doesn't know what fields are going to be passed in at
+		// runtime. It does know that address was selected inside this function so it is
+		// strongly typed with a fully selected address object
+		user.address.state === 'TX'
+	);
+}
+
+const users = getUsersFromTexas({
+	firstName: true,
+	lastName: true
+});
+
+// At this point we know what fields we selected and the extra fields added by the
+// getUsersFromTexas function
+```
+
+```ts
+// user inferred as:
+{
+	firstName: string;
+	lastName: string;
+	address: {
+		street: string;
+		city: string;
+		state: string;
+		zip: string;
+	};
+}[]
+```

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/merge-select.d.ts

@@ -0,0 +1,3 @@
+import { ZodType, ZodUnion } from 'zod/v4';
+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/merge-select.js

@@ -0,0 +1,9 @@
+export function mergeSelect(schema, select1, select2) {
+    if (select2 === undefined) {
+        return [select1, schema];
+    }
+    if (Array.isArray(select2)) {
+        return [select1, ...select2];
+    }
+    return [select1, select2];
+}

package/dist/refine-schema.d.ts

@@ -0,0 +1,36 @@
+import { core, z, ZodAny, ZodArray, ZodBoolean, ZodDate, ZodLiteral, ZodNever, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodRawShape, ZodString, ZodType, ZodUnion, ZodUnknown } from 'zod/v4';
+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;
+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;
+export type RefinedUnionSchema<T extends ZodUnion, TShape> = ZodUnion<T['options'] extends Readonly<[infer A, ...infer Rest]> ? Rest extends ZodType[] ? [
+    ReapplyOptionalNullable<A, A extends ZodType<object> ? RefinedTypeSchema<z.infer<A>, TShape> : Extract<A, ZodType>>,
+    ...{
+        [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]>;
+};
+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 {};

package/dist/refine-schema.js

@@ -0,0 +1,56 @@
+import { z } from 'zod/v4';
+import { getInnerType, isZodArray, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
+// Main function to refine the schema
+export function refineSchema(schema, shape) {
+    if (isZodObject(schema)) {
+        const refinedShape = {};
+        const schemaShape = schema.shape;
+        for (const key in shape) {
+            if (key in schemaShape) {
+                refinedShape[key] = refineSchemaField(schemaShape[key], shape[key]);
+            }
+        }
+        return z.object(refinedShape);
+    }
+    else if (isZodUnion(schema)) {
+        const refinedOptions = schema.options.map(option => refineSchemaField(option, shape));
+        return z.union(refinedOptions);
+    }
+    throw new Error('Unsupported schema type for refinement');
+}
+// Helper function to refine a single schema field
+function refineSchemaField(fieldSchema, fieldShape) {
+    if (fieldShape === true) {
+        return fieldSchema; // Keep original type
+    }
+    else if (typeof fieldShape === 'function') {
+        return fieldShape(fieldSchema); // Apply refinement function
+    }
+    else if (isZodType(fieldShape)) {
+        return fieldShape; // Use redefined type
+    }
+    else if (isZodObject(fieldSchema)) {
+        return refineSchema(fieldSchema, fieldShape); // Recursively refine nested objects
+    }
+    else if (isZodUnion(fieldSchema)) {
+        return refineSchema(fieldSchema, fieldShape);
+    }
+    else if (isZodArray(fieldSchema)) {
+        // Recursively refine array items
+        return z.array(refineSchemaField(fieldSchema.element, fieldShape));
+    }
+    else if (isZodOptional(fieldSchema)) {
+        return refineSchemaField(fieldSchema._def.innerType, fieldShape).optional();
+    }
+    else if (isZodNullable(fieldSchema)) {
+        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) {
+            return refineSchemaField(innerType, fieldShape);
+        }
+    }
+    return fieldSchema;
+}

package/dist/refine-schema.spec.d.ts

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

package/dist/refine-schema.spec.js

@@ -0,0 +1,223 @@
+import { strict as assert, deepStrictEqual, throws } from 'assert';
+import { describe, it } from 'node:test';
+import { z, ZodError } from 'zod/v4';
+import { refineSchema } from './refine-schema.js';
+describe('.refineSchema()', () => {
+    it('should retain required fields', () => {
+        const UserSchema = z.object({
+            age: z.number().optional(),
+            firstName: z.string(),
+            lastName: z.string()
+        });
+        const RefinedSchema = refineSchema(UserSchema, {
+            firstName: true,
+            lastName: true
+        });
+        const parsedData = RefinedSchema.parse({
+            firstName: 'John',
+            lastName: 'Doe'
+        });
+        assert.equal(parsedData.firstName, 'John');
+        assert.equal(parsedData.lastName, 'Doe');
+    });
+    it('should handle optional fields', () => {
+        const UserSchema = z.object({
+            age: z.number().optional(),
+            firstName: z.string(),
+            lastName: z.string()
+        });
+        const RefinedSchema = refineSchema(UserSchema, {
+            age: true
+        });
+        const parsedData = RefinedSchema.parse({ age: 25 });
+        assert.equal(parsedData.age, 25);
+        const parsedWithoutAge = RefinedSchema.parse({});
+        assert.equal(parsedWithoutAge.age, undefined);
+    });
+    it('should handle nullable fields', () => {
+        const RoleSchema = z.object({
+            name: z.string()
+        });
+        const UserSchema = z.object({
+            firstName: z.string(),
+            role: RoleSchema.nullable()
+        });
+        const RefinedSchema = refineSchema(UserSchema, {
+            role: true
+        });
+        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({
+            name: z.string()
+        });
+        const UserSchema = z.object({
+            firstName: z.string(),
+            role: RoleSchema.nullable().optional()
+        });
+        const RefinedSchema = refineSchema(UserSchema, {
+            role: {
+                name: true
+            }
+        });
+        const parsedWithRole = RefinedSchema.parse({
+            firstName: 'Alice',
+            role: { name: 'Admin' }
+        });
+        assert.deepStrictEqual(parsedWithRole.role, { name: 'Admin' });
+        const parsedWithNullRole = RefinedSchema.parse({
+            firstName: 'Alice',
+            role: null
+        });
+        assert.strictEqual(parsedWithNullRole.role, null);
+        const parsedWithoutRole = RefinedSchema.parse({ firstName: 'Alice' });
+        assert.strictEqual(parsedWithoutRole.role, undefined);
+    });
+    it('should apply custom schema transformations', () => {
+        const RoleSchema = z.object({
+            name: z.string()
+        });
+        const UserSchema = z.object({
+            firstName: z.string(),
+            role: RoleSchema
+        });
+        const RefinedSchema = refineSchema(UserSchema, {
+            role: (schema) => schema.extend({ permissions: z.array(z.string()) })
+        });
+        const parsedData = RefinedSchema.parse({
+            firstName: 'Bob',
+            role: { name: 'User', permissions: ['read', 'write'] }
+        });
+        assert.deepEqual(parsedData.role, {
+            name: 'User',
+            permissions: ['read', 'write']
+        });
+    });
+    it('should handle nested arrays', () => {
+        const RoleSchema = z.object({
+            level: z.number(),
+            title: z.string()
+        });
+        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(),
+            tags: z.array(z.string()).optional()
+        });
+        const RefinedSchema = refineSchema(UserSchema, {
+            nestedArray: {
+                name: true
+            }
+        });
+        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({
+            firstName: 'Alice',
+            lastName: 'Smith'
+        });
+        assert.equal(parsedWithoutNestedArray.nestedArray, undefined);
+    });
+    it('should handle custom fields', () => {
+        const UserSchema = z.object({
+            address: z.custom().optional(),
+            firstName: z.string(),
+            lastName: z.string()
+        });
+        const RefinedSchema = refineSchema(UserSchema, {
+            address: true
+        });
+        const parsedData = RefinedSchema.parse({
+            address: {
+                city: 'Austin',
+                state: 'TX',
+                street: '123 Main Street'
+            },
+            firstName: 'Alice',
+            lastName: 'Smith'
+        });
+        assert.deepStrictEqual(parsedData, {
+            address: {
+                city: 'Austin',
+                state: 'TX',
+                street: '123 Main Street'
+            }
+        });
+    });
+    it('should support unions of objects', () => {
+        const Person = z.object({
+            firstName: z.string(),
+            lastName: z.string()
+        });
+        const Address = z.object({
+            address: z.string(),
+            city: z.string()
+        });
+        const Schema = refineSchema(z.union([Person, Address]), {
+            address: true,
+            firstName: true
+        });
+        let parseResult = Schema.parse({
+            address: '123 Main Street',
+            firstName: 'Jerry',
+            lastName: 'Springer'
+        });
+        deepStrictEqual(parseResult, { firstName: 'Jerry' });
+        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({
+            firstName: z.string(),
+            lastName: z.string()
+        });
+        const Address = z.object({
+            address: z.string(),
+            city: z.string()
+        });
+        const Schema = refineSchema(z.union([Person, Address]), {
+            address: true,
+            firstName: true
+        });
+        throws(() => {
+            Schema.parse({
+                lastName: 'Springer'
+            });
+        }, (err) => {
+            if (!(err instanceof ZodError) || err.issues[0].code !== 'invalid_union') {
+                return false;
+            }
+            return true;
+        });
+    });
+    it('should support unions of objects and simple types', () => {
+        const Person = z.object({
+            firstName: z.string(),
+            lastName: z.string()
+        });
+        const Schema = refineSchema(z.union([Person, z.string()]), {
+            address: true,
+            firstName: true
+        });
+        let parseResult = Schema.parse({
+            firstName: 'Jerry',
+            lastName: 'Springer'
+        });
+        deepStrictEqual(parseResult, { firstName: 'Jerry' });
+        parseResult = Schema.parse('123 Main Street');
+        deepStrictEqual(parseResult, '123 Main Street');
+    });
+});

package/dist/select.d.ts

@@ -0,0 +1,12 @@
+import { z, ZodType, ZodUnion } from 'zod/v4';
+import { RefinedTypeSchema, RefinedUnionSchema, RefineObject, 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 {};

package/dist/select.js

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

package/dist/types.d.ts

@@ -0,0 +1,16 @@
+export type DeepMerge<T, U> = {
+    [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] extends object ? U[K] extends object ? DeepMerge<T[K], U[K]> : T[K] | U[K] : T[K] | U[K] : T[K] : K extends keyof U ? U[K] : never;
+};
+export type DeepMergeAll<T> = T extends readonly any[] ? T extends [infer First, ...infer Rest] ? Rest extends [] ? First : DeepMerge<First, DeepMergeAll<Rest>> : unknown : T;
+export type IsAny<T, TTrue = true, TFalse = false> = 0 extends (1 & T) ? TTrue : TFalse;
+export type IsEqual<T, U, TTrue = true, TFalse = false> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? TTrue : TFalse;
+export type IsJsonType<T, TDeep extends boolean = true, TTrue = true, TFalse = false> = T extends JsonType ? TTrue : T extends Function ? TFalse : T extends Array<infer U> ? TDeep extends false ? TTrue : IsJsonType<U, TDeep, TTrue, TFalse> : T extends object ? TDeep extends false ? TTrue : {
+    [K in keyof T]: IsJsonType<T[K], true, false>;
+} extends {
+    [K in keyof T]: true;
+} ? TTrue : TFalse : TFalse;
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+type JsonType = boolean | null | number | string | undefined;
+export {};

package/dist/types.js

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

package/dist/utilities.d.ts

@@ -0,0 +1,9 @@
+import { ZodArray, ZodNullable, ZodObject, ZodOptional, ZodType, ZodUnion, ZodUnknown } from 'zod/v4';
+export declare function getInnerType(schema: ZodType): undefined | ZodType;
+export declare function isZodArray(obj: unknown): obj is ZodArray<ZodType>;
+export declare function isZodNullable(obj: unknown): obj is ZodNullable<ZodType>;
+export declare function isZodObject(obj: unknown, isLoose?: boolean): obj is ZodObject;
+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[]>;
+export declare function isZodUnknown(obj: unknown): obj is ZodUnknown;

package/dist/utilities.js

@@ -0,0 +1,41 @@
+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;
+    }
+    else if (schema instanceof ZodLazy) {
+        return schema.def.getter();
+    }
+    else if (schema instanceof ZodArray) {
+        return schema.element;
+    }
+    // Not a recognized wrapper type
+    return undefined;
+}
+export function isZodArray(obj) {
+    return isZodType(obj) && (obj.def.type === 'array');
+}
+export function isZodNullable(obj) {
+    return isZodType(obj) && (obj.def.type === 'nullable');
+}
+export function isZodObject(obj, isLoose) {
+    if (!isZodType(obj) || (obj.def.type !== 'object')) {
+        return false;
+    }
+    if (typeof isLoose === 'undefined') {
+        return true;
+    }
+    return isLoose === isZodUnknown(obj.def.catchall);
+}
+export function isZodOptional(obj) {
+    return isZodType(obj) && (obj.def.type === 'optional');
+}
+export function isZodType(obj) {
+    return typeof obj === 'object' && obj !== null && 'def' in obj && 'safeParse' in obj && typeof obj.safeParse === 'function';
+}
+export function isZodUnion(obj) {
+    return isZodType(obj) && (obj.def.type === 'union');
+}
+export function isZodUnknown(obj) {
+    return isZodType(obj) && (obj.def.type === 'unknown');
+}

package/dist/utilities.spec.d.ts

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

package/dist/utilities.spec.js

@@ -0,0 +1,49 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { z } from 'zod/v4';
+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
+    });
+    it('isZodObject detects ZodObject', () => {
+        const objectSchema = z.object({ name: z.string() });
+        const stringSchema = z.string();
+        assert.ok(isZodObject(objectSchema));
+        assert.ok(!isZodObject(stringSchema));
+    });
+    it('isZodObject should detect loose objects when isLoose is passed', () => {
+        assert.ok(isZodObject(z.looseObject({}), true));
+        assert.ok(!isZodObject(z.looseObject({}), false));
+        assert.ok(!isZodObject(z.strictObject({}), true));
+        assert.ok(isZodObject(z.strictObject({}), false));
+    });
+    it('isZodOptional detects ZodOptional', () => {
+        const optionalSchema = z.string().optional();
+        const stringSchema = z.string();
+        assert.ok(isZodOptional(optionalSchema));
+        assert.ok(!isZodOptional(stringSchema));
+    });
+    it('isZodUnion detects ZodUnion', () => {
+        const unionSchema = z.union([z.string(), z.number()]);
+        const stringSchema = z.string();
+        assert.ok(isZodUnion(unionSchema));
+        assert.ok(!isZodUnion(stringSchema));
+    });
+    it('isZodUnknown detects ZodUnknown', () => {
+        assert.ok(isZodUnknown(z.unknown()));
+        assert.ok(!isZodUnknown(z.string()));
+    });
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "zodselect",
+  "version": "1.0.0",
+  "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",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "./dist",
+    "package.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "@securedatasystems/eslint-config": "^1.0.2",
+    "@securedatasystems/tsconfig": "^1.0.0",
+    "@types/node": "^24.0.0",
+    "glob": "^11.0.2",
+    "tsx": "^4.20.0",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "zod": "^3.25.58"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs && tsc --project tsconfig.build.json",
+    "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\""
+  }
+}