zodselect 1.2.6 → 1.2.8

package/dist/refine-schema.d.ts

@@ -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 ? ZodifyField<T, K> : TShape[K] extends object ? Exclude<T[K], null | undefined> extends Array<infer U> ? [U] extends [object] ? ApplyOptionalNullable<T[K], z.ZodArray<RefinedVariants<U, TShape[K], NextDepth<TDepth>>>> : Zodify<T[K]> : Exclude<T[K], null | undefined> extends object ? ApplyOptionalNullable<T[K], RefinedVariants<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> ? [Extract<U, object>] extends [never] ? Zodify<T[K]> : ApplyOptionalNullable<T[K], z.ZodArray<RefinedVariants<Extract<U, object>, TShape[K], NextDepth<TDepth>>>> : [Extract<Exclude<T[K], null | undefined>, object>] extends [never] ? ZodNever : ApplyOptionalNullable<T[K], RefinedVariants<Extract<Exclude<T[K], null | undefined>, object>, TShape[K], NextDepth<TDepth>>> : 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>>,
@@ -27,7 +27,7 @@ export type RefineObject<T extends object, TIsSimple extends boolean> = {
     [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>>, ([Exclude<Exclude<T, null | undefined>, object>] extends [never] ? RefineObject<Extract<Exclude<T, null | undefined>, object>, TIsSimple> : never) | 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>;
+type RefineType<T, TIsSimple extends boolean> = IsTuple<TuplifyUnion<Exclude<T, null | undefined>>, ([Extract<Exclude<T, null | undefined>, object>] extends [never] ? never : RefineObject<Extract<Exclude<T, null | undefined>, object>, TIsSimple>) | 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> ? [Extract<U, object>] extends [never] ? Refinement<Zodify<T>, TIsSimple> : Refinement<Zodify<T>, TIsSimple> | RefineObject<Extract<U, object>, 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;
 };

package/dist/refine-schema.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { getInnerType, isZodArray, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
+import { isZodArray, isZodCatch, isZodDefault, isZodLazy, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
 // Main function to refine the schema
 export function refineSchema(schema, shape) {
     if (isZodObject(schema)) {
@@ -45,12 +45,12 @@ function refineSchemaField(fieldSchema, fieldShape) {
     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 !== fieldSchema) {
-            return refineSchemaField(innerType, fieldShape);
-        }
+    else if (isZodDefault(fieldSchema) || isZodCatch(fieldSchema)) {
+        // A default or catch is a whole value, which a picked part no longer fits, so it gives way to what it wraps.
+        return refineSchemaField(fieldSchema.def.innerType, fieldShape);
+    }
+    else if (isZodLazy(fieldSchema)) {
+        return refineSchemaField(fieldSchema.def.getter(), fieldShape);
     }
     return fieldSchema;
 }

package/dist/refine-schema.spec.js

@@ -128,6 +128,19 @@ describe('.refineSchema()', () => {
         });
         assert.equal(parsedWithoutNestedArray.nestedArray, undefined);
     });
+    it('keeps an array under a default, a catch or a lazy an array of the picked fields', () => {
+        const line = z.object({ id: z.string(), secret: z.string() });
+        const order = z.object({
+            caught: z.array(line).catch([]),
+            defaulted: z.array(line).default([]),
+            lazy: z.lazy(() => z.array(line))
+        });
+        const refined = refineSchema(order, { caught: { id: true }, defaulted: { id: true }, lazy: { id: true } });
+        const lines = [{ id: 'a', secret: 's' }];
+        deepStrictEqual(refined.parse({ caught: lines, defaulted: lines, lazy: lines }), { caught: [{ id: 'a' }], defaulted: [{ id: 'a' }], lazy: [{ id: 'a' }] });
+        assert.ok(refined.shape.defaulted instanceof z.ZodArray);
+        assert.ok(refined.shape.caught instanceof z.ZodArray);
+    });
     it('should handle custom fields', () => {
         const userSchema = z.object({
             address: z.custom().optional(),

package/dist/select.spec.js

@@ -88,9 +88,21 @@ describe('a field whose value is a union of objects', () => {
             name: true
         });
     });
-    it('still refuses a nested select into a union with a plain variant, which would miss the plain value', () => {
-        // @ts-expect-error `name` may be a string, so only the whole value can be selected.
+    it('accepts a nested select into the object variants of a union with a plain one, as a join read as its record is', () => {
         const select = { name: { en: true } };
-        assert.ok(select);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepEqual(refineSchema(policy, select).parse({ name: { en: 'Software' } }), { name: { en: 'Software' } });
+    });
+    it('accepts the select a screen builds by declaring a joined id as its record', () => {
+        const file = z.object({ _id: z.string(), filename: z.string() });
+        const attachment = z.object({ file: z.union([file, z.string()]), title: z.string().optional() });
+        const stored = z.object({ attachments: z.array(attachment).optional() });
+        const read = z.object({ attachments: z.array(attachment.extend({ file })).optional() });
+        const select = buildSelectObject(read);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepEqual(select, { attachments: { file: { _id: true, filename: true }, title: true } });
+        assert.deepEqual(refineSchema(stored, select).parse({ attachments: [{ file: { _id: 'f1', filename: 'a.pdf' } }] }), { attachments: [{ file: { _id: 'f1', filename: 'a.pdf' } }] });
     });
 });

package/dist/utilities.d.ts

@@ -1,6 +1,8 @@
-import { ZodArray, ZodLazy, ZodNullable, ZodObject, ZodOptional, ZodRecord, ZodType, ZodUnion, ZodUnknown } from 'zod';
+import { ZodArray, ZodCatch, ZodDefault, 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 isZodCatch(obj: unknown): obj is ZodCatch<ZodType>;
+export declare function isZodDefault(obj: unknown): obj is ZodDefault<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;

package/dist/utilities.js

@@ -17,6 +17,12 @@ export function getInnerType(schema, unwrapLazy = true) {
 export function isZodArray(obj) {
     return isZodType(obj) && (obj.def.type === 'array');
 }
+export function isZodCatch(obj) {
+    return isZodType(obj) && (obj.def.type === 'catch');
+}
+export function isZodDefault(obj) {
+    return isZodType(obj) && (obj.def.type === 'default');
+}
 export function isZodLazy(obj) {
     return isZodType(obj) && (obj.def.type === 'lazy');
 }

package/package.json

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