zodselect 1.2.2 → 1.2.4

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

@@ -3,7 +3,8 @@ import { UnionToIntersection } from './refine-schema.js';
 import { ZodSelect } from './select.js';
 type Depth = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type FieldSelectAll<T, TDepth extends number> = TDepth extends 0 ? true : Unwrap<T> extends ZodArray<infer TItem> ? ItemSelectAll<TItem, Depth[TDepth]> : ItemSelectAll<T, Depth[TDepth]>;
-type ItemSelectAll<T, TDepth extends number> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, TDepth> : Unwrap<T> extends ZodUnion<infer TOptions> ? UnionShape<TOptions> extends infer TShape extends ZodRawShape ? ObjectSelectAll<TShape, TDepth> : true : true;
+type ItemSelectAll<T, TDepth extends number> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, TDepth> : Unwrap<T> extends ZodUnion<infer TOptions> ? [NotObject<TOptions[number]>] extends [never] ? UnionShape<TOptions> extends infer TShape extends ZodRawShape ? ObjectSelectAll<TShape, TDepth> : true : true : true;
+type NotObject<T> = T extends unknown ? Unwrap<T> extends ZodObject<any, any> ? never : T : never;
 type ObjectSelectAll<TShape extends ZodRawShape, TDepth extends number> = {
     [K in keyof TShape]-?: FieldSelectAll<TShape[K], TDepth>;
 };
@@ -11,7 +12,7 @@ type ShapeOf<T> = T extends unknown ? Unwrap<T> extends ZodObject<infer TShape,
 /** The shapes of a union's object variants, merged; `unknown` when it has none. */
 type UnionShape<TOptions> = UnionToIntersection<TOptions extends readonly (infer TOption)[] ? ShapeOf<TOption> : never>;
 type Unwrap<T> = T extends ZodCatch<infer I> | ZodDefault<infer I> | ZodNullable<infer I> | ZodOptional<infer I> ? Unwrap<I> : T extends ZodLazy<infer I> ? Unwrap<I> : T;
-/** What {@link buildSelectObject} answers: nested for objects, unions with an object variant, and arrays of either; `true` for anything else. */
+/** What {@link buildSelectObject} answers: nested for objects, unions of objects, and arrays of either; `true` for anything else. */
 export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, 10> : {
     [K in keyof ZodSelect<T, true>]-?: true;
 };
@@ -20,9 +21,10 @@ export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = Unwrap<T> exten
  *
  * Every scalar key is set to `true`. Nested object fields, and arrays of
  * objects, are recursively expanded into nested select objects. A union field
- * with an object variant, such as a file stored as an id and read as the file,
- * expands into the merged keys of its object variants. Other arrays and
- * records remain `true`.
+ * whose every variant is an object expands into their merged keys. A union
+ * with any other variant, such as a name that is a string or a structured
+ * name, remains `true`: its sub-fields would miss the plain value. Other arrays
+ * and records remain `true`.
  * For union schemas the result is the merged set of keys across all variants.
  *
  * @example

package/dist/build-select-object.js

@@ -5,9 +5,10 @@ import { getInnerType, isZodArray, isZodObject, isZodUnion } from './utilities.j
  *
  * Every scalar key is set to `true`. Nested object fields, and arrays of
  * objects, are recursively expanded into nested select objects. A union field
- * with an object variant, such as a file stored as an id and read as the file,
- * expands into the merged keys of its object variants. Other arrays and
- * records remain `true`.
+ * whose every variant is an object expands into their merged keys. A union
+ * with any other variant, such as a name that is a string or a structured
+ * name, remains `true`: its sub-fields would miss the plain value. Other arrays
+ * and records remain `true`.
  * For union schemas the result is the merged set of keys across all variants.
  *
  * @example
@@ -46,7 +47,7 @@ function collectKeys(schema, result, depth = 0) {
         for (const key in schema.shape) {
             const field = unwrapField(schema.shape[key]);
             const fieldInner = isZodArray(field) ? unwrapField(field.def.element) : field;
-            if (isZodObject(fieldInner) || hasObjectVariant(fieldInner)) {
+            if (isZodObject(fieldInner) || isUnionOfObjects(fieldInner)) {
                 const nested = {};
                 collectKeys(fieldInner, nested, depth + 1);
                 result[key] = nested;
@@ -66,6 +67,6 @@ function collectKeys(schema, result, depth = 0) {
         collectKeys(schema.def.right, result, depth);
     }
 }
-function hasObjectVariant(schema) {
-    return isZodUnion(schema) && schema.options.some(option => isZodObject(unwrapField(option)));
+function isUnionOfObjects(schema) {
+    return isZodUnion(schema) && schema.options.every(option => isZodObject(unwrapField(option)));
 }

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

@@ -148,15 +148,15 @@ describe('.buildSelectObject()', () => {
         assert.ok(isTyped);
         assert.deepStrictEqual(select, { byKey: true, matrix: true, tags: true });
     });
-    it('should expand a union field into the keys of its object variants', () => {
+    it('should select a union field whole when a variant is not an object', () => {
         const schema = z.object({
             file: z.union([z.object({ _id: z.string(), filename: z.string() }), z.string()]),
-            name: z.string()
+            name: z.union([z.string(), z.object({ first: z.string(), last: z.string() })])
         });
         const select = buildSelectObject(schema);
         const isTyped = true;
         assert.ok(isTyped);
-        assert.deepStrictEqual(select, { file: { _id: true, filename: true }, name: true });
+        assert.deepStrictEqual(select, { file: true, name: true });
     });
     it('should merge the keys of every object variant of a union field', () => {
         const schema = z.object({
@@ -183,16 +183,6 @@ describe('.buildSelectObject()', () => {
         assert.ok(isTyped);
         assert.deepStrictEqual(select, { options: { a: true, b: true } });
     });
-    it('should expand an attachment whose file is stored as an id and read as the file', () => {
-        const file = z.object({ _id: z.string(), contentType: z.string().optional(), filename: z.string() });
-        const revision = z.object({ file: z.union([file, z.string()]), uploadedBy: z.object({ _id: z.string(), username: z.string() }) });
-        const schema = z.object({ attachments: z.array(revision.extend({ history: z.array(revision).optional(), title: z.string().optional() })).optional() });
-        const select = buildSelectObject(schema);
-        const revisionSelect = { file: { _id: true, contentType: true, filename: true }, uploadedBy: { _id: true, username: true } };
-        const isTyped = true;
-        assert.ok(isTyped);
-        assert.deepStrictEqual(select, { attachments: { ...revisionSelect, history: revisionSelect, title: true } });
-    });
     it('should be a select the schema accepts', () => {
         const schema = z.object({
             client: z.object({ _id: z.string(), name: z.string() }),

package/dist/refine-schema.d.ts

@@ -1,8 +1,8 @@
 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';
-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 ApplyOptionalNullable<T, U extends ZodType> = IsAny<T, U, unknown extends 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<{
+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 ? number extends T ? ZodNumber : ZodLiteral<T> : T extends boolean ? boolean extends T ? ZodBoolean : ZodLiteral<T> : 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;
@@ -12,7 +12,7 @@ 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;
+    [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 ? ZodifyField<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>>,
@@ -36,8 +36,10 @@ export type TuplifyUnion<T, TDepth extends number = 0, L = LastOf<T>, N = [T] ex
 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, IsAny<T, ZodAny, [
-    Exclude<T, null | undefined>
-] extends [string] ? string extends Exclude<T, null | undefined> ? ZodString : ZodLiteral<Exclude<T, null | undefined>> : IsTuple<TuplifyUnion<Exclude<T, null | undefined>, TDepth>, ZodUnion<TuplifyUnion<Exclude<T, null | undefined>, TDepth>>, InternalZodify<Exclude<T, null | undefined>, TDepth>>>>;
+export type Zodify<T, TDepth extends number = 0> = ApplyOptionalNullable<T, IsAny<T, ZodAny, ZodifyLiteral<Exclude<T, null | undefined>, IsTuple<TuplifyUnion<Exclude<T, null | undefined>, TDepth>, ZodUnion<TuplifyUnion<Exclude<T, null | undefined>, TDepth>>, InternalZodify<Exclude<T, null | undefined>, TDepth>>>>>;
+type ZodifyField<T, TKey extends keyof T> = unknown extends T[TKey] ? Partial<Pick<T, TKey>> extends Pick<T, TKey> ? ZodOptional<Zodify<T[TKey]>> : Zodify<T[TKey]> : Zodify<T[TKey]>;
+type ZodifyLiteral<T, TElse> = [
+    T
+] extends [boolean | number | string] ? [T] extends [boolean] ? boolean extends T ? ZodBoolean : ZodLiteral<T> : string extends T ? [T] extends [string] ? ZodString : TElse : number extends T ? [T] extends [number] ? ZodNumber : TElse : ZodLiteral<T> : TElse;
 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.spec.js

@@ -356,3 +356,46 @@ describe('.refineSchema()', () => {
         deepStrictEqual(selected.map(s => refined.parse(s).stage), stage.options);
     });
 });
+describe('.refineSchema() literal and unknown field types', () => {
+    // Regression tests for `Zodify` (refine-schema.ts) when a schema's fields are listed
+    // (e.g. via `buildSelectObject`) instead of selected whole. Before the fix a numeric
+    // literal union widened to `number` and a required `z.unknown()` field became
+    // optional, so the selected type no longer fit the source type. Runtime was
+    // unaffected; these assignments fail the type-check (`tsc`).
+    const question = z.object({
+        answer: z.object({ value: z.unknown() }),
+        flag: z.literal(true),
+        note: z.unknown().optional(),
+        scale: z.union([z.literal(5), z.literal(10)]),
+        steps: z.literal([3, 7]),
+        value: z.unknown()
+    });
+    const survey = z.object({
+        name: z.string(),
+        pages: z.array(z.object({ questions: z.array(question) }))
+    });
+    it('keeps a numeric literal union instead of widening it to number', () => {
+        const refined = refineSchema(survey, { pages: { questions: { scale: true, steps: true } } });
+        // With the bug these resolve to `number`, so the source type can't take them.
+        const scale = {}.scale;
+        const steps = {}.steps;
+        void scale;
+        void steps;
+        const parsed = refined.parse({ pages: [{ questions: [{ scale: 10, steps: 3 }] }] });
+        assert.equal(parsed.pages[0]?.questions[0]?.scale, 10);
+        throws(() => refined.parse({ pages: [{ questions: [{ scale: 7, steps: 3 }] }] }), ZodError);
+    });
+    it('keeps a boolean literal instead of widening it to boolean', () => {
+        const refined = refineSchema(survey, { pages: { questions: { flag: true } } });
+        const isFlag = {}.flag;
+        void isFlag;
+        throws(() => refined.parse({ pages: [{ questions: [{ flag: false }] }] }), ZodError);
+    });
+    it('keeps a required unknown field required', () => {
+        const refined = refineSchema(survey, { pages: { questions: { answer: true, note: true, value: true } } });
+        // With the bug `value` became an optional key; `note` must stay optional.
+        const selected = { answer: { value: 1 }, value: 'x' };
+        const questions = [selected];
+        deepStrictEqual(refined.parse({ pages: [{ questions }] }).pages[0]?.questions, questions);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.2.2",
+  "version": "1.2.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",