@cabloy/zod-query 1.0.15 → 1.0.17

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/lib/query.js

@@ -106,7 +106,7 @@ const _parseArray = z.ZodArray.prototype._parse;
 z.ZodArray.prototype._parse = function (input) {
     _coerceWithNil(input, () => {
         if (typeof input.data === 'string') {
-            if (input.data[0] === '[') {
+            if (input.data.startsWith('[') && input.data.endsWith(']')) {
                 input.data = JSON.parse(input.data);
             }
             else {

package/dist/lib/zodMetadata.d.ts

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,56 @@
+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;
+}

package/package.json

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