zodselect 1.0.15 → 1.0.17

package/dist/refine-schema.d.ts

@@ -22,7 +22,7 @@ export type RefinedUnionSchema<T extends ZodUnion, TShape> = ZodUnion<T['options
 ] : never : never>;
 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>;
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]?: 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> | RefineZodUnion<Extract<T, ZodUnion>>, 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>;
@@ -33,7 +33,7 @@ export type RefineZodUnion<T extends ZodUnion> = {
     [K in keyof UnionMergedShape<T>]?: UnionMergedShape<T>[K] extends ZodType ? UnionFieldType<UnionMergedShape<T>[K]> : 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>>;
-type UnionFieldType<T extends ZodType> = z.infer<T> extends Array<infer U> ? Exclude<U, null | undefined> extends object ? boolean | RefineObject<Extract<U, object>, true> : boolean : Exclude<z.infer<T>, null | undefined> extends object ? boolean | RefineObject<Exclude<z.infer<T>, null | undefined>, true> : boolean;
+type UnionFieldType<T extends ZodType> = Exclude<z.infer<T>, null | undefined> extends Array<infer U> ? Exclude<U, null | undefined> extends object ? boolean | RefineObject<Extract<U, object>, true> : boolean : Exclude<z.infer<T>, null | undefined> extends object ? boolean | RefineObject<Exclude<z.infer<T>, null | undefined>, true> : boolean;
 type UnionMergedShape<T extends ZodUnion> = UnionToIntersection<T['options'][number] extends ZodObject<infer Shape extends ZodRawShape> ? Shape : object>;
 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>>>;

package/dist/refine-schema.spec.js

@@ -233,4 +233,78 @@ describe('.refineSchema()', () => {
         parseResult = schema.parse('123 Main Street');
         deepStrictEqual(parseResult, '123 Main Street');
     });
+    it('should accept selecting a subfield of a union member with an optional array-of-objects field', () => {
+        // Regression test for a bug in `UnionFieldType` (refine-schema.ts).
+        //
+        // `UnionFieldType` chose a union member field's refine shape with
+        // `z.infer<T> extends Array<infer U>` but, unlike `RefineType`, it did not
+        // strip `| undefined` first. For an OPTIONAL array-of-objects member
+        // (`field: Obj.array().optional()`), `z.infer<T>` is `Obj[] | undefined`,
+        // which is NOT assignable to `Array<infer U>`, so the field's refine shape
+        // collapsed to `RefineObject<Obj[]>` (the array's own keys) instead of
+        // `RefineObject<Obj>`. The runtime was unaffected, so this only broke the
+        // type-check (`tsc`), not `tsx --test`.
+        const accessLevel = z.object({
+            _id: z.string(),
+            name: z.string()
+        });
+        const organizationInvitation = z.object({
+            accessLevels: accessLevel.array().optional(),
+            organizationId: z.string(),
+            type: z.literal('organization')
+        });
+        const platformInvitation = z.object({
+            accessLevels: accessLevel.array().optional(),
+            type: z.literal('platform')
+        });
+        const invitation = z.discriminatedUnion('type', [organizationInvitation, platformInvitation]);
+        // Type-level assertion: drilling into a subfield of the optional array
+        // member is a valid select and MUST be assignable to the refine shape.
+        // With the bug present, this `satisfies` fails to compile.
+        const select = {
+            accessLevels: { name: true },
+            type: true
+        };
+        const refined = refineSchema(invitation, select);
+        const parsed = refined.parse({
+            accessLevels: [{ name: 'Admin' }],
+            type: 'organization'
+        });
+        assert.equal(parsed.type, 'organization');
+        assert.deepEqual(parsed.accessLevels, [{ name: 'Admin' }]);
+    });
+    it('allows selecting a nested subfield of a declared looseObject field', () => {
+        // Regression test for `RefineObject` collapsing a `z.looseObject`'s declared fields.
+        //
+        // A `z.looseObject` carries a catchall index signature (`[k: string]: unknown`).
+        // `RefineObject` maps over `keyof T`, and when `T` has an index signature `keyof T`
+        // collapses to `string | number`, so every declared field's value type came from the
+        // catchall (`unknown` -> scalar `boolean`). Declared fields could be marked `true` but
+        // could NOT be drilled into. The runtime was unaffected, so this only broke the
+        // type-check (`tsc`), not `tsx --test`.
+        const personName = z.object({
+            first: z.string().optional(),
+            last: z.string().optional()
+        });
+        const user = z.looseObject({
+            _id: z.string(),
+            name: personName.optional(),
+            username: z.string()
+        });
+        const root = z.object({
+            invitedBy: user
+        });
+        // Type-level assertion: drilling into `invitedBy.name.first` is valid and MUST be
+        // assignable to the refine shape. With the bug present this `satisfies` fails to
+        // compile because `invitedBy`'s declared fields collapse to an index signature with
+        // `boolean` values.
+        const select = {
+            invitedBy: { name: { first: true } }
+        };
+        const refined = refineSchema(root, select);
+        const parsed = refined.parse({
+            invitedBy: { name: { first: 'Alice' } }
+        });
+        assert.equal(parsed.invitedBy.name?.first, 'Alice');
+    });
 });

package/dist/select.spec.d.ts

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

package/dist/select.spec.js

@@ -0,0 +1,48 @@
+import { describe, it } from 'node:test';
+import { z } from 'zod';
+const internalService = z.object({
+    name: z.string(),
+    type: z.literal('internal')
+}).strict();
+const externalService = z.object({
+    iconUrl: z.string().optional(),
+    name: z.string(),
+    type: z.literal('external')
+}).strict();
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const serviceType = z.union([internalService, externalService]);
+describe('InferMergedType', () => {
+    it('should resolve to z.infer<T> when used in a generic function with TSelect = undefined', () => {
+        function getServices(options) {
+            void options;
+            return {};
+        }
+        // When called without select, TSelect defaults to undefined
+        // InferMergedType<typeof Service, undefined> should resolve to z.infer<typeof Service>
+        const services = getServices({});
+        const service = Object.values(services)[0];
+        // This is a compile-time test: the assertion below must type-check (all
+        // union members have `name: string`). The impl returns `{}`, so guard the
+        // dereference — the block never runs but TS still checks it.
+        if (service) {
+            const name = service.name;
+            void name;
+        }
+    });
+    it('should resolve to projected type when used in a generic function with a select', () => {
+        function getServices(options) {
+            void options;
+            return {};
+        }
+        // When called with a select, the return type should be the projected type
+        const services = getServices({ select: { name: true } });
+        const service = Object.values(services)[0];
+        // This is a compile-time test: the assertion below must type-check (name
+        // was selected). The impl returns `{}`, so guard the dereference — the
+        // block never runs but TS still checks it.
+        if (service) {
+            const name = service.name;
+            void name;
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "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",