@cabloy/zod-query 1.0.17 → 2.0.3

package/dist/index.d.ts

@@ -1,2 +1 @@
 export * from './lib/query.ts';
-export * from './lib/zodMetadata.ts';

package/dist/index.js

@@ -1,2 +1 @@
 export * from "./lib/query.js";
-export * from "./lib/zodMetadata.js";

package/dist/lib/metadata.d.ts

@@ -0,0 +1,6 @@
+import type z from 'zod';
+import type { ZodTypes } from './zod-is-type.ts';
+export declare class Metadata {
+    static unwrapUntil(schema: z.ZodType): z.ZodType;
+    static unwrapUntil<TypeName extends keyof ZodTypes>(schema: z.ZodType, typeName: TypeName | undefined): ZodTypes[TypeName] | undefined;
+}

package/dist/lib/metadata.js

@@ -0,0 +1,31 @@
+import { isAnyZodType, isZodType } from "./zod-is-type.js";
+export class Metadata {
+    static unwrapUntil(schema, typeName) {
+        if (typeName && isZodType(schema, typeName)) {
+            return schema;
+        }
+        if (isZodType(schema, [
+            'ZodOptional',
+            'ZodNullable',
+            'ZodDefault',
+            'ZodReadonly',
+            'ZodNonOptional',
+        ]) &&
+            isAnyZodType(schema._zod.def.innerType)) {
+            return this.unwrapUntil(schema._zod.def.innerType, typeName);
+        }
+        if (isZodType(schema, 'ZodPipe')) {
+            const inSchema = schema._zod.def.in;
+            const outSchema = schema._zod.def.out;
+            // meaning preprocess
+            if (isZodType(inSchema, 'ZodTransform') && isAnyZodType(outSchema)) {
+                return this.unwrapUntil(outSchema, typeName);
+            }
+            // meaning transform
+            if (isAnyZodType(inSchema)) {
+                return this.unwrapUntil(inSchema, typeName);
+            }
+        }
+        return typeName ? undefined : schema;
+    }
+}

package/dist/lib/query.d.ts

@@ -1,2 +1,4 @@
-export declare function coerceWithNil(data: any, fn?: Function): any;
-export declare function getTypeName(schema: any): any;
+import { z } from 'zod';
+export declare function setParseAdapter(zodMetadata: any): void;
+export declare function coerceWithNil(value: any, fn?: Function): any;
+export declare function getInnerTypeName(schema: z.ZodType): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "any" | "array" | "default" | "transform" | "enum" | "intersection" | "literal" | "never" | "null" | "nullable" | "nonoptional" | "optional" | "pipe" | "readonly" | "record" | "tuple" | "union" | "unknown" | "void" | "date" | "map" | "int" | "file" | "set" | "success" | "prefault" | "catch" | "nan" | "template_literal" | "promise" | "lazy" | "custom";

package/dist/lib/query.js

@@ -1,5 +1,29 @@
 import { z } from 'zod';
+import { Metadata } from "./metadata.js";
 import { isNil } from "./utils.js";
+import { isZodType } from "./zod-is-type.js";
+let ZodMetadata;
+export function setParseAdapter(zodMetadata) {
+    ZodMetadata = zodMetadata;
+    (z.core).setParseAdapter(__parseAdapter);
+}
+function __parseAdapter(inst, parse) {
+    return (payload, _) => {
+        const type = inst.type;
+        switch (type) {
+            case 'string': return __parseString(inst, parse, payload, _);
+            case 'number': return __parseNumber(inst, parse, payload, _);
+            case 'bigint': return __parseBigInt(inst, parse, payload, _);
+            case 'boolean': return __parseBoolean(inst, parse, payload, _);
+            case 'date': return __parseDate(inst, parse, payload, _);
+            case 'object': return __parseObject(inst, parse, payload, _);
+            case 'array': return __parseArray(inst, parse, payload, _);
+            case 'optional': return __parseOptional(inst, parse, payload, _);
+            case 'default': return __parseDefault(inst, parse, payload, _);
+        }
+        return parse(payload, _);
+    };
+}
 /////////////////////////////////////////
 /////////////////////////////////////////
 /// ///////                     /////////
@@ -7,17 +31,15 @@ import { isNil } from "./utils.js";
 /// ///////                     /////////
 /////////////////////////////////////////
 /////////////////////////////////////////
-const _parseString = z.ZodString.prototype._parse;
-z.ZodString.prototype._parse = function (input) {
-    if (this._def?.openapi?.metadata?.format === 'binary' && !isNil(input.data)) {
+function __parseString(inst, parse, payload, _) {
+    const metadata = ZodMetadata?.getOpenapiMetadata(inst);
+    if (metadata?.format === 'binary' && !isNil(payload.value)) {
         // ignore upload file
-        return { status: 'valid', value: input.data };
+        return payload;
     }
-    _coerce(input, () => {
-        input.data = String(input.data);
-    });
-    return _parseString.call(this, input);
-};
+    _coerceString(payload);
+    return parse(payload, _);
+}
 /////////////////////////////////////////
 /////////////////////////////////////////
 /// ///////                     /////////
@@ -25,13 +47,12 @@ z.ZodString.prototype._parse = function (input) {
 /// ///////                     /////////
 /////////////////////////////////////////
 /////////////////////////////////////////
-const _parseNumber = z.ZodNumber.prototype._parse;
-z.ZodNumber.prototype._parse = function (input) {
-    _coerceWithNil(input, () => {
-        input.data = Number(input.data);
+function __parseNumber(_inst, parse, payload, _) {
+    _coerceWithNil(payload, () => {
+        payload.value = Number(payload.value);
     });
-    return _parseNumber.call(this, input);
-};
+    return parse(payload, _);
+}
 /////////////////////////////////////////
 /////////////////////////////////////////
 /// ///////                     /////////
@@ -39,13 +60,12 @@ z.ZodNumber.prototype._parse = function (input) {
 /// ///////                     /////////
 /////////////////////////////////////////
 /////////////////////////////////////////
-const _parseBigInt = z.ZodBigInt.prototype._parse;
-z.ZodBigInt.prototype._parse = function (input) {
-    _coerceWithNil(input, () => {
-        input.data = BigInt(input.data);
+function __parseBigInt(_inst, parse, payload, _) {
+    _coerceWithNil(payload, () => {
+        payload.value = BigInt(payload.value);
     });
-    return _parseBigInt.call(this, input);
-};
+    return parse(payload, _);
+}
 //////////////////////////////////////////
 //////////////////////////////////////////
 /// ///////                     //////////
@@ -53,18 +73,17 @@ z.ZodBigInt.prototype._parse = function (input) {
 /// ///////                     //////////
 //////////////////////////////////////////
 //////////////////////////////////////////
-const _parseBoolean = z.ZodBoolean.prototype._parse;
-z.ZodBoolean.prototype._parse = function (input) {
-    _coerceWithNil(input, () => {
-        if (input.data === 'false' || input.data === '0') {
-            input.data = false;
+function __parseBoolean(_inst, parse, payload, _) {
+    _coerceWithNil(payload, () => {
+        if (payload.value === 'false' || payload.value === '0') {
+            payload.value = false;
         }
         else {
-            input.data = Boolean(input.data);
+            payload.value = Boolean(payload.value);
         }
     });
-    return _parseBoolean.call(this, input);
-};
+    return parse(payload, _);
+}
 ///////////////////////////////////////
 ///////////////////////////////////////
 /// ///////                     ///////
@@ -72,13 +91,12 @@ z.ZodBoolean.prototype._parse = function (input) {
 /// ///////                     ///////
 ///////////////////////////////////////
 ///////////////////////////////////////
-const _parseDate = z.ZodDate.prototype._parse;
-z.ZodDate.prototype._parse = function (input) {
-    _coerceWithNil(input, () => {
-        input.data = new Date(input.data);
+function __parseDate(_inst, parse, payload, _) {
+    _coerceWithNil(payload, () => {
+        payload.value = new Date(payload.value);
     });
-    return _parseDate.call(this, input);
-};
+    return parse(payload, _);
+}
 /////////////////////////////////////////
 /////////////////////////////////////////
 /// ///////                     /////////
@@ -86,15 +104,14 @@ z.ZodDate.prototype._parse = function (input) {
 /// ///////                     /////////
 /////////////////////////////////////////
 /////////////////////////////////////////
-const _parseObject = z.ZodObject.prototype._parse;
-z.ZodObject.prototype._parse = function (input) {
-    _coerceWithNil(input, () => {
-        if (typeof input.data === 'string') {
-            input.data = JSON.parse(input.data);
+function __parseObject(_inst, parse, payload, _) {
+    _coerceWithNil(payload, () => {
+        if (typeof payload.value === 'string') {
+            payload.value = JSON.parse(payload.value);
         }
     });
-    return _parseObject.call(this, input);
-};
+    return parse(payload, _);
+}
 ////////////////////////////////////////
 ////////////////////////////////////////
 /// ///////                    /////////
@@ -102,20 +119,19 @@ z.ZodObject.prototype._parse = function (input) {
 /// ///////                    /////////
 ////////////////////////////////////////
 ////////////////////////////////////////
-const _parseArray = z.ZodArray.prototype._parse;
-z.ZodArray.prototype._parse = function (input) {
-    _coerceWithNil(input, () => {
-        if (typeof input.data === 'string') {
-            if (input.data.startsWith('[') && input.data.endsWith(']')) {
-                input.data = JSON.parse(input.data);
+function __parseArray(_inst, parse, payload, _) {
+    _coerceWithNil(payload, () => {
+        if (typeof payload.value === 'string') {
+            if (payload.value.startsWith('[') && payload.value.endsWith(']')) {
+                payload.value = JSON.parse(payload.value);
             }
             else {
-                input.data = input.data.split(',');
+                payload.value = payload.value.split(',');
             }
         }
     });
-    return _parseArray.call(this, input);
-};
+    return parse(payload, _);
+}
 ///////////////////////////////////////////
 ///////////////////////////////////////////
 /// ///////                       /////////
@@ -123,19 +139,18 @@ z.ZodArray.prototype._parse = function (input) {
 /// ///////                       /////////
 ///////////////////////////////////////////
 ///////////////////////////////////////////
-const _parseOptional = z.ZodOptional.prototype._parse;
-z.ZodOptional.prototype._parse = function (input) {
-    if (_getTypeName(_getInnerType(this)) === 'ZodString') {
-        _coerce(input);
+function __parseOptional(_inst, parse, payload, _) {
+    if (isZodType(Metadata.unwrapUntil(_inst), 'ZodString')) {
+        _coerceString(payload);
     }
     else {
-        _coerceWithNil(input);
+        _coerceWithNil(payload);
     }
-    if (input.data === null) {
-        input.data = undefined;
+    if (payload.value === null) {
+        payload.value = undefined;
     }
-    return _parseOptional.call(this, input);
-};
+    return parse(payload, _);
+}
 ////////////////////////////////////////////
 ////////////////////////////////////////////
 /// ///////                        /////////
@@ -143,16 +158,15 @@ z.ZodOptional.prototype._parse = function (input) {
 /// ///////                        /////////
 ////////////////////////////////////////////
 ////////////////////////////////////////////
-const _parseDefault = z.ZodDefault.prototype._parse;
-z.ZodDefault.prototype._parse = function (input) {
-    if (_getTypeName(_getInnerType(this)) === 'ZodString') {
-        _coerce(input);
+function __parseDefault(_inst, parse, payload, _) {
+    if (isZodType(Metadata.unwrapUntil(_inst), 'ZodString')) {
+        _coerceString(payload);
     }
     else {
-        _coerceWithNil(input);
+        _coerceWithNil(payload);
     }
-    return _parseDefault.call(this, input);
-};
+    return parse(payload, _);
+}
 ///////////////////////////////////////
 ///////////////////////////////////////
 /// ///////                     ///////
@@ -160,53 +174,49 @@ z.ZodDefault.prototype._parse = function (input) {
 /// ///////                     ///////
 ///////////////////////////////////////
 ///////////////////////////////////////
-function _coerce(input, fn) {
-    if (!isNil(input.data)) {
-        fn?.();
-    }
-}
-function _coerceWithNil(input, fn) {
-    if (!isNil(input.data)) {
-        if (input.data === 'undefined' || input.data === '') {
-            input.data = undefined;
+// function _coerce(payload: IParsePayload, fn?: Function) {
+//   if (!isNil(payload.value)) {
+//     fn?.(payload);
+//   }
+// }
+function _coerceString(payload, fn) {
+    if (!isNil(payload.value)) {
+        if (payload.value === '') {
+            payload.value = undefined;
         }
-        else if (input.data === 'null') {
-            input.data = null;
+        else if (typeof payload.value !== 'string') {
+            payload.value = String(payload.value);
         }
         else {
-            fn?.();
+            fn?.(payload);
         }
     }
 }
-export function coerceWithNil(data, fn) {
-    const input = { data };
-    _coerceWithNil(input, fn);
-    return data;
-}
-function _getInnerType(schema) {
-    let innerType = schema._def.innerType;
-    if (!innerType)
-        return schema;
-    while (innerType._def.innerType) {
-        innerType = innerType._def.innerType;
+function _coerceWithNil(payload, fn) {
+    if (!isNil(payload.value)) {
+        if (payload.value === 'undefined' || payload.value === '') {
+            payload.value = undefined;
+        }
+        else if (payload.value === 'null') {
+            payload.value = null;
+        }
+        else {
+            fn?.(payload);
+        }
     }
-    return innerType;
 }
-function _getTypeName(schema) {
-    let typeName = schema.typeName;
-    while (!typeName) {
-        schema = schema._def;
-        typeName = schema.typeName;
-    }
-    return typeName;
+export function coerceWithNil(value, fn) {
+    const payload = { value, issues: [] };
+    _coerceWithNil(payload, fn);
+    return payload.value;
 }
-export function getTypeName(schema) {
-    return _getTypeName(_getInnerType(schema));
+export function getInnerTypeName(schema) {
+    return Metadata.unwrapUntil(schema).type;
 }
 // function _coerce(instance, input, fn) {
 //   if (instance._def.coerce !== false) {
 //     if (instance._def.coerce === true) instance._def.coerce = undefined as any;
-//     if (!isNil(input.data)) {
+//     if (!isNil(payload.value)) {
 //       fn();
 //     }
 //   }

package/dist/lib/zod-is-type.d.ts

@@ -0,0 +1,43 @@
+import type { z } from 'zod';
+export interface ZodTypes {
+    ZodAny: z.ZodAny;
+    ZodArray: z.ZodArray;
+    ZodBigInt: z.ZodBigInt;
+    ZodBoolean: z.ZodBoolean;
+    ZodDefault: z.ZodDefault;
+    ZodTransform: z.ZodTransform;
+    ZodEnum: z.ZodEnum;
+    ZodIntersection: z.ZodIntersection;
+    ZodLiteral: z.ZodLiteral;
+    ZodNever: z.ZodNever;
+    ZodNull: z.ZodNull;
+    ZodNullable: z.ZodNullable;
+    ZodNumber: z.ZodNumber;
+    ZodNonOptional: z.ZodNonOptional;
+    ZodObject: z.ZodObject;
+    ZodOptional: z.ZodOptional;
+    ZodPipe: z.ZodPipe;
+    ZodReadonly: z.ZodReadonly;
+    ZodRecord: z.ZodRecord;
+    ZodString: z.ZodString;
+    ZodTuple: z.ZodTuple;
+    ZodType: z.ZodType;
+    ZodUnion: z.ZodUnion;
+    ZodDiscriminatedUnion: z.ZodDiscriminatedUnion;
+    ZodUnknown: z.ZodUnknown;
+    ZodVoid: z.ZodVoid;
+    ZodDate: z.ZodDate;
+}
+export declare function isZodType<TypeName extends keyof ZodTypes>(schema: object, typeNames: TypeName[]): schema is ZodTypes[TypeName];
+export declare function isZodType<TypeName extends keyof ZodTypes>(schema: object, typeName: TypeName): schema is ZodTypes[TypeName];
+export declare function isAnyZodType(schema: object): schema is z.ZodType;
+/**
+ * The schema.isNullable() is deprecated. This is the suggested replacement
+ * as this was how isNullable operated beforehand.
+ */
+export declare function isNullableSchema(schema: z.ZodType): boolean;
+/**
+ * The schema.isOptional() is deprecated. This is the suggested replacement
+ * as this was how isOptional operated beforehand.
+ */
+export declare function isOptionalSchema(schema: z.ZodType): boolean;

package/dist/lib/zod-is-type.js

@@ -0,0 +1,58 @@
+;
+const ZodTypeKeys = {
+    ZodAny: 'any',
+    ZodArray: 'array',
+    ZodBigInt: 'bigint',
+    ZodBoolean: 'boolean',
+    ZodDefault: 'default',
+    ZodTransform: 'transform',
+    ZodEnum: 'enum',
+    ZodIntersection: 'intersection',
+    ZodLiteral: 'literal',
+    ZodNever: 'never',
+    ZodNull: 'null',
+    ZodNullable: 'nullable',
+    ZodNumber: 'number',
+    ZodNonOptional: 'nonoptional',
+    ZodObject: 'object',
+    ZodOptional: 'optional',
+    ZodPipe: 'pipe',
+    ZodReadonly: 'readonly',
+    ZodRecord: 'record',
+    ZodString: 'string',
+    ZodTuple: 'tuple',
+    ZodType: 'type',
+    ZodUnion: 'union',
+    ZodDiscriminatedUnion: 'union',
+    ZodUnknown: 'unknown',
+    ZodVoid: 'void',
+    ZodDate: 'date',
+};
+export function isZodType(schema, typeNames) {
+    const typeNamesArray = Array.isArray(typeNames) ? typeNames : [typeNames];
+    return typeNamesArray.some(typeName => {
+        const typeNameMatch = schema?.def?.type === ZodTypeKeys[typeName];
+        if (typeName === 'ZodDiscriminatedUnion') {
+            return (typeNameMatch &&
+                'discriminator' in schema.def);
+        }
+        return typeNameMatch;
+    });
+}
+export function isAnyZodType(schema) {
+    return 'def' in schema;
+}
+/**
+ * The schema.isNullable() is deprecated. This is the suggested replacement
+ * as this was how isNullable operated beforehand.
+ */
+export function isNullableSchema(schema) {
+    return schema.safeParse(null).success;
+}
+/**
+ * The schema.isOptional() is deprecated. This is the suggested replacement
+ * as this was how isOptional operated beforehand.
+ */
+export function isOptionalSchema(schema) {
+    return schema.safeParse(undefined).success;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cabloy/zod-query",
   "type": "module",
-  "version": "1.0.17",
+  "version": "2.0.3",
   "description": "zod-query",
   "publishConfig": {
     "access": "public"

package/dist/lib/zodMetadata.d.ts

@@ -1,12 +0,0 @@
-import type z from 'zod';
-export declare class ZodMetadata {
-    static unwrapUntil(schema: any, typeName?: any): any;
-    static unwrapChained(schema: any): any;
-    static getDefaultValue(zodSchema: any): any;
-    static getInternalMetadata(zodSchema: any): any;
-    static getLazySchema(zodSchema: any): any;
-    static getRefId(zodSchema: any): any;
-    static getFieldSchema(schema: any, key: string): z.ZodSchema;
-    static getOpenapiMetadata(schema: any): any;
-}
-export declare function isZodType(schema: any, typeName: any): boolean;

package/dist/lib/zodMetadata.js

@@ -1,56 +0,0 @@
-export class ZodMetadata {
-    static unwrapUntil(schema, typeName) {
-        if (typeName && isZodType(schema, typeName)) {
-            return schema;
-        }
-        if (isZodType(schema, 'ZodOptional') ||
-            isZodType(schema, 'ZodNullable') ||
-            isZodType(schema, 'ZodBranded')) {
-            return this.unwrapUntil(schema.unwrap(), typeName);
-        }
-        if (isZodType(schema, 'ZodDefault') || isZodType(schema, 'ZodReadonly')) {
-            return this.unwrapUntil(schema._def.innerType, typeName);
-        }
-        if (isZodType(schema, 'ZodEffects')) {
-            return this.unwrapUntil(schema._def.schema, typeName);
-        }
-        if (isZodType(schema, 'ZodPipeline')) {
-            return this.unwrapUntil(schema._def.in, typeName);
-        }
-        return typeName ? undefined : schema;
-    }
-    static unwrapChained(schema) {
-        return this.unwrapUntil(schema);
-    }
-    static getDefaultValue(zodSchema) {
-        const unwrapped = this.unwrapUntil(zodSchema, 'ZodDefault');
-        return unwrapped === null || unwrapped === void 0 ? void 0 : unwrapped._def.defaultValue();
-    }
-    static getInternalMetadata(zodSchema) {
-        const innerSchema = this.unwrapChained(zodSchema);
-        const openapi = zodSchema._def.openapi
-            ? zodSchema._def.openapi
-            : innerSchema._def.openapi;
-        return openapi === null || openapi === void 0 ? void 0 : openapi._internal;
-    }
-    static getLazySchema(zodSchema) {
-        const innerSchema = this.unwrapChained(zodSchema);
-        return zodSchema._def?.getter ?? innerSchema._def?.getter;
-    }
-    static getRefId(zodSchema) {
-        let _a;
-        // eslint-disable-next-line
-        return (_a = this.getInternalMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a.refId;
-    }
-    static getFieldSchema(schema, key) {
-        return schema.shape[key];
-    }
-    static getOpenapiMetadata(schema) {
-        return schema._def.openapi?.metadata;
-    }
-}
-export function isZodType(schema, typeName) {
-    let _a;
-    // eslint-disable-next-line
-    return ((_a = schema === null || schema === void 0 ? void 0 : schema._def) === null || _a === void 0 ? void 0 : _a.typeName) === typeName;
-}