zodselect 1.2.9 → 1.3.1

package/README.md

@@ -139,6 +139,14 @@ const schema = refineSchema(UserSchema, {
 }
 ```
 
+A field the schema doesn't have is a type error, at any depth and even beside valid fields:
+
+```ts
+refineSchema(UserSchema, { firstName: true, lastNmae: true }); // ✖ 'lastNmae' is not a field of UserSchema
+```
+
+Code that builds a selection generically, whose type the check can't evaluate, calls `refineSchemaUnchecked` instead: the same refinement, with a field the schema doesn't have skipped.
+
 ---
 
 ## 🧪 Refine Field Types Inline

package/dist/refine-schema.d.ts

@@ -2,6 +2,20 @@ import { core, z, ZodAny, ZodArray, ZodBoolean, ZodDate, ZodLiteral, ZodNever, Z
 import { IsAny, IsJsonType } from './types.js';
 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];
+/** `TShape` with every key `T` doesn't have, at any depth, as `never`, so a misspelt select is a type error even beside valid keys. */
+type Exact<TShape, T> = {
+    [K in keyof TShape]: K extends FieldKeys<T> ? TShape[K] extends ((schema: never) => unknown) | boolean | ZodType ? TShape[K] : TShape[K] extends object ? Exact<TShape[K], FieldObjects<FieldAt<T, K>>> : TShape[K] : never;
+};
+/** What {@link refineSchema} takes for `T`: `TShape`, with a key `T` doesn't have, at any depth, a type error even beside valid keys. */
+export type ExactRefineSchema<T extends ZodType<object> | ZodUnion, TShape> = TShape & Exact<TShape, z.infer<T>>;
+/** What the field `TKey` holds in any object of `T`. */
+type FieldAt<T, TKey> = T extends unknown ? TKey extends keyof T ? T[TKey] : never : never;
+/** The declared keys of every object in `T`, each of a union's own. */
+type FieldKeys<T> = T extends unknown ? Extract<keyof {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: unknown;
+}, string> : never;
+/** The objects a field of type `T` holds, through arrays: what a nested select picks within. */
+type FieldObjects<T> = T extends readonly (infer E)[] ? FieldObjects<E> : T extends Date ? never : T extends object ? T : never;
 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>;
@@ -13,13 +27,15 @@ type ReapplyOptionalNullable<T, U extends z.ZodType> = T extends ZodOptional<Zod
 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> ? [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;
+}, core.$strip> : 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>;
+/** The value of the fields of `T` that `TShape` picks: the output of {@link RefinedTypeSchema}. */
+export type RefinedValue<T extends object, TShape> = z.output<RefinedTypeSchema<T, TShape>>;
 /** One refined schema per variant of a union of objects (a plain object is its own one variant), so the result narrows by variant. */
 type RefinedVariants<T, TShape, TDepth extends number> = T extends object ? RefinedTypeSchema<T, TShape, TDepth> : never;
 type Refinement<T extends ZodType, TIsSimple extends boolean> = TIsSimple extends true ? boolean : ((schema: T) => ZodType) | boolean | ZodType;
@@ -43,5 +59,11 @@ type ZodifyField<T, TKey extends keyof T> = unknown extends T[TKey] ? Partial<Pi
 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>;
+/** `shape`'s fields of `schema`. A key the schema doesn't have, at any depth, is a type error. */
+export declare function refineSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, false>>(schema: T, shape: ExactRefineSchema<T, TShape>): RefinedSchema<T, TShape, false>;
+/**
+ * {@link refineSchema} for a shape whose type is still generic, which the exact key check can't evaluate.
+ * Prefer {@link refineSchema}: a key the schema doesn't have is skipped here, not refused.
+ */
+export declare function refineSchemaUnchecked<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,22 +1,8 @@
 import { z } from 'zod';
 import { isZodArray, isZodCatch, isZodDefault, isZodLazy, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
-// Main function to refine the schema
+/** `shape`'s fields of `schema`. A key the schema doesn't have, at any depth, is a type error. */
 export function refineSchema(schema, shape) {
-    if (isZodObject(schema)) {
-        const refinedShape = {};
-        const schemaShape = schema.shape;
-        for (const key in shape) {
-            if (key in schemaShape && shape[key] !== false) {
-                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');
+    return refineSchemaUnchecked(schema, shape);
 }
 // Helper function to refine a single schema field
 function refineSchemaField(fieldSchema, fieldShape) {
@@ -30,10 +16,10 @@ function refineSchemaField(fieldSchema, fieldShape) {
         return fieldShape; // Use redefined type
     }
     else if (isZodObject(fieldSchema)) {
-        return refineSchema(fieldSchema, fieldShape); // Recursively refine nested objects
+        return refineSchemaUnchecked(fieldSchema, fieldShape); // Recursively refine nested objects
     }
     else if (isZodUnion(fieldSchema)) {
-        return refineSchema(fieldSchema, fieldShape);
+        return refineSchemaUnchecked(fieldSchema, fieldShape);
     }
     else if (isZodArray(fieldSchema)) {
         // Recursively refine array items
@@ -54,3 +40,24 @@ function refineSchemaField(fieldSchema, fieldShape) {
     }
     return fieldSchema;
 }
+/**
+ * {@link refineSchema} for a shape whose type is still generic, which the exact key check can't evaluate.
+ * Prefer {@link refineSchema}: a key the schema doesn't have is skipped here, not refused.
+ */
+export function refineSchemaUnchecked(schema, shape) {
+    if (isZodObject(schema)) {
+        const refinedShape = {};
+        const schemaShape = schema.shape;
+        for (const key in shape) {
+            if (key in schemaShape && shape[key] !== false) {
+                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');
+}

package/package.json

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