@decaf-ts/as-zod 0.0.3

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tiago Venceslau 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+[![Banner](./workdocs/assets/Banner.png)](https://decaf-ts.github.io/ts-workspace/)
+
+## Decaf-ts as Zod module
+
+Small addon to enable two-way convertion between Models and Zod
+
+
+![Licence](https://img.shields.io/github/license/decaf-ts/ts-workspace.svg?style=plastic)
+![GitHub language count](https://img.shields.io/github/languages/count/decaf-ts/as-zod?style=plastic)
+![GitHub top language](https://img.shields.io/github/languages/top/decaf-ts/ts-workspace?style=plastic)
+
+[![Build & Test](https://github.com/decaf-ts/ts-workspace/actions/workflows/nodejs-build-prod.yaml/badge.svg)](https://github.com/decaf-ts/ts-workspace/actions/workflows/nodejs-build-prod.yaml)
+[![CodeQL](https://github.com/decaf-ts/ts-workspace/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/decaf-ts/ts-workspace/actions/workflows/codeql-analysis.yml)[![Snyk Analysis](https://github.com/decaf-ts/ts-workspace/actions/workflows/snyk-analysis.yaml/badge.svg)](https://github.com/decaf-ts/ts-workspace/actions/workflows/snyk-analysis.yaml)
+[![Pages builder](https://github.com/decaf-ts/ts-workspace/actions/workflows/pages.yaml/badge.svg)](https://github.com/decaf-ts/ts-workspace/actions/workflows/pages.yaml)
+[![.github/workflows/release-on-tag.yaml](https://github.com/decaf-ts/ts-workspace/actions/workflows/release-on-tag.yaml/badge.svg?event=release)](https://github.com/decaf-ts/ts-workspace/actions/workflows/release-on-tag.yaml)
+
+![Open Issues](https://img.shields.io/github/issues/decaf-ts/ts-workspace.svg)
+![Closed Issues](https://img.shields.io/github/issues-closed/decaf-ts/ts-workspace.svg)
+![Pull Requests](https://img.shields.io/github/issues-pr-closed/decaf-ts/ts-workspace.svg)
+![Maintained](https://img.shields.io/badge/Maintained%3F-yes-green.svg)
+
+![Forks](https://img.shields.io/github/forks/decaf-ts/ts-workspace.svg)
+![Stars](https://img.shields.io/github/stars/decaf-ts/ts-workspace.svg)
+![Watchers](https://img.shields.io/github/watchers/decaf-ts/ts-workspace.svg)
+
+![Node Version](https://img.shields.io/badge/dynamic/json.svg?url=https%3A%2F%2Fraw.githubusercontent.com%2Fbadges%2Fshields%2Fmaster%2Fpackage.json&label=Node&query=$.engines.node&colorB=blue)
+![NPM Version](https://img.shields.io/badge/dynamic/json.svg?url=https%3A%2F%2Fraw.githubusercontent.com%2Fbadges%2Fshields%2Fmaster%2Fpackage.json&label=NPM&query=$.engines.npm&colorB=purple)
+
+Documentation available [here](https://decaf-ts.github.io/as-zod/)
+
+### Description
+
+Easy two-way conversion from Models to Zod
+
+### How to Use
+
+- [Initial Setup](./tutorials/For%20Developers.md#_initial-setup_)
+- [Installation](./tutorials/For%20Developers.md#installation)
+
+
+
+
+### Related
+
+[![Decorator Validation Readme Card](https://github-readme-stats.vercel.app/api/pin/?username=decaf-ts&repo=decorator-validation)](https://github.com/decaf-ts/decorator-validation)
+
+[![Decaf Readme Card](https://github-readme-stats.vercel.app/api/pin/?username=decaf-ts&repo=decaf-ts)](https://github.com/decaf-ts/decaf-ts)
+
+
+### Social
+
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/decaf-ts/)
+
+
+
+
+#### Languages
+
+![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)
+![JavaScript](https://img.shields.io/badge/JavaScript-F7DF1E?style=for-the-badge&logo=javascript&logoColor=black)
+![NodeJS](https://img.shields.io/badge/Node.js-43853D?style=for-the-badge&logo=node.js&logoColor=white)
+![ShellScript](https://img.shields.io/badge/Shell_Script-121011?style=for-the-badge&logo=gnu-bash&logoColor=white)
+
+## Getting help
+
+If you have bug reports, questions or suggestions please [create a new issue](https://github.com/decaf-ts/ts-workspace/issues/new/choose).
+
+## Contributing
+
+I am grateful for any contributions made to this project. Please read [this](./workdocs/98-Contributing.md) to get started.
+
+## Supporting
+
+The first and easiest way you can support it is by [Contributing](./workdocs/98-Contributing.md). Even just finding a typo in the documentation is important.
+
+Financial support is always welcome and helps keep both me and the project alive and healthy.
+
+So if you can, if this project in any way. either by learning something or simply by helping you save precious time, please consider donating.
+
+## License
+
+This project is released under the [MIT License](./LICENSE.md).
+
+By developers, for developers...

package/dist/as-zod.cjs

@@ -0,0 +1,141 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/decorator-validation'), require('zod'), require('@decaf-ts/reflection')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/decorator-validation', 'zod', '@decaf-ts/reflection'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["as-zod"] = {}, global.decoratorValidation, global.zod, global.reflection));
+})(this, (function (exports, decoratorValidation, zod, reflection) { 'use strict';
+
+    const ReservedKeys = [
+        decoratorValidation.ValidationKeys.REQUIRED,
+        decoratorValidation.ValidationKeys.TYPE,
+        decoratorValidation.ModelKeys.TYPE,
+    ];
+    function isReservedKey(el) {
+        return ReservedKeys.includes(el);
+    }
+    function zodify(type, zz = zod.ZodAny) {
+        type = typeof type === "string" ? [type] : type;
+        function innerZodify(type) {
+            switch (type.toLowerCase()) {
+                case decoratorValidation.Primitives.STRING:
+                    return zod.z.string();
+                case decoratorValidation.Primitives.NUMBER:
+                    return zod.z.number();
+                case decoratorValidation.Primitives.BIGINT:
+                    return zod.z.bigint();
+                case decoratorValidation.Primitives.BOOLEAN:
+                    return zod.z.boolean();
+                case decoratorValidation.ValidationKeys.DATE:
+                    return zod.z.date();
+                case Array.name.toLowerCase():
+                    return zod.z.array(zz);
+                case Set.name.toLowerCase():
+                    return zod.z.set(zz);
+                default: {
+                    const m = decoratorValidation.Model.get(type);
+                    if (!m) {
+                        throw new Error(`Unzodifiable type: ${type}`);
+                    }
+                    try {
+                        const zz = new m().toZod();
+                        return zz;
+                    }
+                    catch (e) {
+                        throw new Error(`Failed to zodify model ${type}: ${e}`);
+                    }
+                }
+            }
+        }
+        let zod$1;
+        for (const t of type) {
+            zod$1 = zod$1 ? zod$1.or(innerZodify(t)) : innerZodify(t);
+        }
+        return zod$1;
+    }
+    function zodifyValidation(zod, type, values) {
+        switch (type) {
+            case decoratorValidation.ValidationKeys.MIN:
+                return zod.min(values[decoratorValidation.ValidationKeys.MIN]);
+            case decoratorValidation.ValidationKeys.MIN_LENGTH:
+                return zod.min(values[decoratorValidation.ValidationKeys.MIN_LENGTH]);
+            case decoratorValidation.ValidationKeys.MAX:
+                return zod.max(values[decoratorValidation.ValidationKeys.MAX]);
+            case decoratorValidation.ValidationKeys.MAX_LENGTH:
+                return zod.max(values[decoratorValidation.ValidationKeys.MAX_LENGTH]);
+            case decoratorValidation.ValidationKeys.STEP:
+                return zod.multipleOf(values[decoratorValidation.ValidationKeys.STEP]);
+            case decoratorValidation.ValidationKeys.PATTERN:
+                return zod.regex(values[decoratorValidation.ValidationKeys.PATTERN]);
+            case decoratorValidation.ValidationKeys.URL:
+                return zod.regex(values[decoratorValidation.ValidationKeys.PATTERN]);
+            case decoratorValidation.ValidationKeys.EMAIL:
+                return zod.regex(values[decoratorValidation.ValidationKeys.PATTERN]);
+            case decoratorValidation.ValidationKeys.PASSWORD:
+                return zod.regex(values[decoratorValidation.ValidationKeys.PATTERN]);
+            case decoratorValidation.ValidationKeys.DATE:
+                return zod.date();
+            default:
+                return zod;
+        }
+    }
+    decoratorValidation.Model.prototype.toZod = function () {
+        const result = {};
+        const properties = Object.getOwnPropertyNames(this);
+        if (Array.isArray(properties) && !properties.length)
+            return zod.z.object({});
+        for (const prop of Object.getOwnPropertyNames(this)) {
+            if (typeof this[prop] === "function" ||
+                prop.startsWith("_") ||
+                prop === "constructor") {
+                continue;
+            }
+            const allDecs = reflection.Reflection.getPropertyDecorators(decoratorValidation.ValidationKeys.REFLECT, this, prop, false, true);
+            const decoratorData = allDecs.decorators.reduce((accum, el) => {
+                const { key, props } = el;
+                if (key === decoratorValidation.ModelKeys.TYPE && !accum[decoratorValidation.ValidationKeys.TYPE]) {
+                    accum[decoratorValidation.ValidationKeys.TYPE] = {
+                        customTypes: [props.name],
+                        message: decoratorValidation.DEFAULT_ERROR_MESSAGES.TYPE,
+                        description: "defines the accepted types for the attribute",
+                    };
+                }
+                else {
+                    accum[key] = props;
+                }
+                return accum;
+            }, {});
+            if (!Object.keys(decoratorData).length) {
+                continue;
+            }
+            let zod$1 = zod.ZodAny;
+            const typeData = decoratorData[decoratorValidation.ValidationKeys.TYPE];
+            if (!typeData) {
+                throw new Error(`Missing type information`);
+            }
+            zod$1 = zodify(typeData.customTypes, decoratorData[decoratorValidation.ValidationKeys.LIST]
+                ? zodify(decoratorData[decoratorValidation.ValidationKeys.LIST].clazz)
+                : zod.ZodAny);
+            for (const [key, props] of Object.entries(decoratorData).filter(([k]) => !isReservedKey(k))) {
+                zod$1 = zodifyValidation(zod$1, key, props);
+            }
+            if (!decoratorData[decoratorValidation.ValidationKeys.REQUIRED]) {
+                zod$1 = zod$1.optional();
+            }
+            result[prop] = zod$1;
+        }
+        return zod.z.object(result);
+    };
+
+    /**
+     * @description Current version of the reflection package
+     * @summary Stores the semantic version number of the package
+     * @const VERSION
+     * @memberOf module:as-zod
+     */
+    const VERSION = "0.0.2";
+
+    exports.VERSION = VERSION;
+    exports.zodify = zodify;
+    exports.zodifyValidation = zodifyValidation;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"as-zod.cjs","sources":["../src/overrides.ts","../src/index.ts"],"sourcesContent":["import {\n  Model,\n  ModelKeys,\n  TypeMetadata,\n  Primitives,\n  DEFAULT_ERROR_MESSAGES,\n  ValidatorOptions,\n  MinLengthValidatorOptions,\n  MinValidatorOptions,\n  MaxValidatorOptions,\n  MaxLengthValidatorOptions,\n  StepValidatorOptions,\n  PatternValidatorOptions,\n  ListMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport { z, ZodAny, ZodObject, ZodRawShape } from \"zod\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidationKeys } from \"@decaf-ts/decorator-validation\";\n\nconst ReservedKeys = [\n  ValidationKeys.REQUIRED,\n  ValidationKeys.TYPE,\n  ModelKeys.TYPE,\n] as const;\n\nfunction isReservedKey(el: string) {\n  return ReservedKeys.includes(el as any);\n}\n\nexport function zodify(type: string | string[], zz: any = ZodAny) {\n  type = typeof type === \"string\" ? [type] : type;\n\n  function innerZodify(type: string) {\n    switch (type.toLowerCase()) {\n      case Primitives.STRING:\n        return z.string();\n      case Primitives.NUMBER:\n        return z.number();\n      case Primitives.BIGINT:\n        return z.bigint();\n      case Primitives.BOOLEAN:\n        return z.boolean();\n      case ValidationKeys.DATE:\n        return z.date();\n      case Array.name.toLowerCase():\n        return z.array(zz);\n      case Set.name.toLowerCase():\n        return z.set(zz);\n      default: {\n        const m = Model.get(type);\n        if (!m) {\n          throw new Error(`Unzodifiable type: ${type}`);\n        }\n        try {\n          const zz = new m().toZod();\n          return zz;\n        } catch (e: unknown) {\n          throw new Error(`Failed to zodify model ${type}: ${e}`);\n        }\n      }\n    }\n  }\n\n  let zod: any;\n  for (const t of type) {\n    zod = zod ? zod.or(innerZodify(t)) : innerZodify(t);\n  }\n\n  return zod;\n}\n\nexport function zodifyValidation(\n  zod: any,\n  type: string,\n  values: ValidatorOptions\n) {\n  switch (type) {\n    case ValidationKeys.MIN:\n      return zod.min((values as MinValidatorOptions)[ValidationKeys.MIN]);\n    case ValidationKeys.MIN_LENGTH:\n      return zod.min(\n        (values as MinLengthValidatorOptions)[ValidationKeys.MIN_LENGTH]\n      );\n    case ValidationKeys.MAX:\n      return zod.max((values as MaxValidatorOptions)[ValidationKeys.MAX]);\n    case ValidationKeys.MAX_LENGTH:\n      return zod.max(\n        (values as MaxLengthValidatorOptions)[ValidationKeys.MAX_LENGTH]\n      );\n    case ValidationKeys.STEP:\n      return zod.multipleOf(\n        (values as StepValidatorOptions)[ValidationKeys.STEP]\n      );\n    case ValidationKeys.PATTERN:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.URL:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.EMAIL:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.PASSWORD:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.DATE:\n      return zod.date();\n    default:\n      return zod;\n  }\n}\n\nModel.prototype.toZod = function <M extends Model>(this: M): ZodObject<any> {\n  const result: { [key: string]: ZodRawShape } = {};\n\n  const properties = Object.getOwnPropertyNames(this);\n  if (Array.isArray(properties) && !properties.length) return z.object({});\n  for (const prop of Object.getOwnPropertyNames(this)) {\n    if (\n      typeof (this as any)[prop] === \"function\" ||\n      prop.startsWith(\"_\") ||\n      prop === \"constructor\"\n    ) {\n      continue;\n    }\n\n    const allDecs = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      this,\n      prop,\n      false,\n      true\n    );\n\n    const decoratorData = allDecs.decorators.reduce(\n      (accum: Record<string, any>, el) => {\n        const { key, props } = el;\n        if (key === ModelKeys.TYPE && !accum[ValidationKeys.TYPE]) {\n          accum[ValidationKeys.TYPE] = {\n            customTypes: [props.name as string],\n            message: DEFAULT_ERROR_MESSAGES.TYPE,\n            description: \"defines the accepted types for the attribute\",\n          };\n        } else {\n          accum[key] = props;\n        }\n        return accum;\n      },\n      {}\n    );\n\n    if (!Object.keys(decoratorData).length) {\n      continue;\n    }\n\n    let zod: any = ZodAny;\n\n    const typeData: TypeMetadata = decoratorData[\n      ValidationKeys.TYPE\n    ] as TypeMetadata;\n\n    if (!typeData) {\n      throw new Error(`Missing type information`);\n    }\n\n    zod = zodify(\n      typeData.customTypes,\n      decoratorData[ValidationKeys.LIST]\n        ? zodify((decoratorData[ValidationKeys.LIST] as ListMetadata).clazz)\n        : ZodAny\n    );\n\n    for (const [key, props] of Object.entries(decoratorData).filter(\n      ([k]) => !isReservedKey(k)\n    )) {\n      zod = zodifyValidation(zod, key, props);\n    }\n\n    if (!decoratorData[ValidationKeys.REQUIRED]) {\n      zod = zod.optional();\n    }\n\n    result[prop] = zod;\n  }\n\n  return z.object(result);\n};\n","export * from \"./model\";\nexport * from \"./overrides\";\n\n/**\n * @description Current version of the reflection package\n * @summary Stores the semantic version number of the package\n * @const VERSION\n * @memberOf module:as-zod\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["ValidationKeys","ModelKeys","ZodAny","Primitives","z","Model","zod","Reflection","DEFAULT_ERROR_MESSAGES"],"mappings":"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"}

package/dist/as-zod.esm.cjs

@@ -0,0 +1,135 @@
+import { ValidationKeys, ModelKeys, Model, DEFAULT_ERROR_MESSAGES, Primitives } from '@decaf-ts/decorator-validation';
+import { z, ZodAny } from 'zod';
+import { Reflection } from '@decaf-ts/reflection';
+
+const ReservedKeys = [
+    ValidationKeys.REQUIRED,
+    ValidationKeys.TYPE,
+    ModelKeys.TYPE,
+];
+function isReservedKey(el) {
+    return ReservedKeys.includes(el);
+}
+function zodify(type, zz = ZodAny) {
+    type = typeof type === "string" ? [type] : type;
+    function innerZodify(type) {
+        switch (type.toLowerCase()) {
+            case Primitives.STRING:
+                return z.string();
+            case Primitives.NUMBER:
+                return z.number();
+            case Primitives.BIGINT:
+                return z.bigint();
+            case Primitives.BOOLEAN:
+                return z.boolean();
+            case ValidationKeys.DATE:
+                return z.date();
+            case Array.name.toLowerCase():
+                return z.array(zz);
+            case Set.name.toLowerCase():
+                return z.set(zz);
+            default: {
+                const m = Model.get(type);
+                if (!m) {
+                    throw new Error(`Unzodifiable type: ${type}`);
+                }
+                try {
+                    const zz = new m().toZod();
+                    return zz;
+                }
+                catch (e) {
+                    throw new Error(`Failed to zodify model ${type}: ${e}`);
+                }
+            }
+        }
+    }
+    let zod;
+    for (const t of type) {
+        zod = zod ? zod.or(innerZodify(t)) : innerZodify(t);
+    }
+    return zod;
+}
+function zodifyValidation(zod, type, values) {
+    switch (type) {
+        case ValidationKeys.MIN:
+            return zod.min(values[ValidationKeys.MIN]);
+        case ValidationKeys.MIN_LENGTH:
+            return zod.min(values[ValidationKeys.MIN_LENGTH]);
+        case ValidationKeys.MAX:
+            return zod.max(values[ValidationKeys.MAX]);
+        case ValidationKeys.MAX_LENGTH:
+            return zod.max(values[ValidationKeys.MAX_LENGTH]);
+        case ValidationKeys.STEP:
+            return zod.multipleOf(values[ValidationKeys.STEP]);
+        case ValidationKeys.PATTERN:
+            return zod.regex(values[ValidationKeys.PATTERN]);
+        case ValidationKeys.URL:
+            return zod.regex(values[ValidationKeys.PATTERN]);
+        case ValidationKeys.EMAIL:
+            return zod.regex(values[ValidationKeys.PATTERN]);
+        case ValidationKeys.PASSWORD:
+            return zod.regex(values[ValidationKeys.PATTERN]);
+        case ValidationKeys.DATE:
+            return zod.date();
+        default:
+            return zod;
+    }
+}
+Model.prototype.toZod = function () {
+    const result = {};
+    const properties = Object.getOwnPropertyNames(this);
+    if (Array.isArray(properties) && !properties.length)
+        return z.object({});
+    for (const prop of Object.getOwnPropertyNames(this)) {
+        if (typeof this[prop] === "function" ||
+            prop.startsWith("_") ||
+            prop === "constructor") {
+            continue;
+        }
+        const allDecs = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, this, prop, false, true);
+        const decoratorData = allDecs.decorators.reduce((accum, el) => {
+            const { key, props } = el;
+            if (key === ModelKeys.TYPE && !accum[ValidationKeys.TYPE]) {
+                accum[ValidationKeys.TYPE] = {
+                    customTypes: [props.name],
+                    message: DEFAULT_ERROR_MESSAGES.TYPE,
+                    description: "defines the accepted types for the attribute",
+                };
+            }
+            else {
+                accum[key] = props;
+            }
+            return accum;
+        }, {});
+        if (!Object.keys(decoratorData).length) {
+            continue;
+        }
+        let zod = ZodAny;
+        const typeData = decoratorData[ValidationKeys.TYPE];
+        if (!typeData) {
+            throw new Error(`Missing type information`);
+        }
+        zod = zodify(typeData.customTypes, decoratorData[ValidationKeys.LIST]
+            ? zodify(decoratorData[ValidationKeys.LIST].clazz)
+            : ZodAny);
+        for (const [key, props] of Object.entries(decoratorData).filter(([k]) => !isReservedKey(k))) {
+            zod = zodifyValidation(zod, key, props);
+        }
+        if (!decoratorData[ValidationKeys.REQUIRED]) {
+            zod = zod.optional();
+        }
+        result[prop] = zod;
+    }
+    return z.object(result);
+};
+
+/**
+ * @description Current version of the reflection package
+ * @summary Stores the semantic version number of the package
+ * @const VERSION
+ * @memberOf module:as-zod
+ */
+const VERSION = "0.0.2";
+
+export { VERSION, zodify, zodifyValidation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"as-zod.esm.cjs","sources":["../src/overrides.ts","../src/index.ts"],"sourcesContent":["import {\n  Model,\n  ModelKeys,\n  TypeMetadata,\n  Primitives,\n  DEFAULT_ERROR_MESSAGES,\n  ValidatorOptions,\n  MinLengthValidatorOptions,\n  MinValidatorOptions,\n  MaxValidatorOptions,\n  MaxLengthValidatorOptions,\n  StepValidatorOptions,\n  PatternValidatorOptions,\n  ListMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport { z, ZodAny, ZodObject, ZodRawShape } from \"zod\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidationKeys } from \"@decaf-ts/decorator-validation\";\n\nconst ReservedKeys = [\n  ValidationKeys.REQUIRED,\n  ValidationKeys.TYPE,\n  ModelKeys.TYPE,\n] as const;\n\nfunction isReservedKey(el: string) {\n  return ReservedKeys.includes(el as any);\n}\n\nexport function zodify(type: string | string[], zz: any = ZodAny) {\n  type = typeof type === \"string\" ? [type] : type;\n\n  function innerZodify(type: string) {\n    switch (type.toLowerCase()) {\n      case Primitives.STRING:\n        return z.string();\n      case Primitives.NUMBER:\n        return z.number();\n      case Primitives.BIGINT:\n        return z.bigint();\n      case Primitives.BOOLEAN:\n        return z.boolean();\n      case ValidationKeys.DATE:\n        return z.date();\n      case Array.name.toLowerCase():\n        return z.array(zz);\n      case Set.name.toLowerCase():\n        return z.set(zz);\n      default: {\n        const m = Model.get(type);\n        if (!m) {\n          throw new Error(`Unzodifiable type: ${type}`);\n        }\n        try {\n          const zz = new m().toZod();\n          return zz;\n        } catch (e: unknown) {\n          throw new Error(`Failed to zodify model ${type}: ${e}`);\n        }\n      }\n    }\n  }\n\n  let zod: any;\n  for (const t of type) {\n    zod = zod ? zod.or(innerZodify(t)) : innerZodify(t);\n  }\n\n  return zod;\n}\n\nexport function zodifyValidation(\n  zod: any,\n  type: string,\n  values: ValidatorOptions\n) {\n  switch (type) {\n    case ValidationKeys.MIN:\n      return zod.min((values as MinValidatorOptions)[ValidationKeys.MIN]);\n    case ValidationKeys.MIN_LENGTH:\n      return zod.min(\n        (values as MinLengthValidatorOptions)[ValidationKeys.MIN_LENGTH]\n      );\n    case ValidationKeys.MAX:\n      return zod.max((values as MaxValidatorOptions)[ValidationKeys.MAX]);\n    case ValidationKeys.MAX_LENGTH:\n      return zod.max(\n        (values as MaxLengthValidatorOptions)[ValidationKeys.MAX_LENGTH]\n      );\n    case ValidationKeys.STEP:\n      return zod.multipleOf(\n        (values as StepValidatorOptions)[ValidationKeys.STEP]\n      );\n    case ValidationKeys.PATTERN:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.URL:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.EMAIL:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.PASSWORD:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.DATE:\n      return zod.date();\n    default:\n      return zod;\n  }\n}\n\nModel.prototype.toZod = function <M extends Model>(this: M): ZodObject<any> {\n  const result: { [key: string]: ZodRawShape } = {};\n\n  const properties = Object.getOwnPropertyNames(this);\n  if (Array.isArray(properties) && !properties.length) return z.object({});\n  for (const prop of Object.getOwnPropertyNames(this)) {\n    if (\n      typeof (this as any)[prop] === \"function\" ||\n      prop.startsWith(\"_\") ||\n      prop === \"constructor\"\n    ) {\n      continue;\n    }\n\n    const allDecs = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      this,\n      prop,\n      false,\n      true\n    );\n\n    const decoratorData = allDecs.decorators.reduce(\n      (accum: Record<string, any>, el) => {\n        const { key, props } = el;\n        if (key === ModelKeys.TYPE && !accum[ValidationKeys.TYPE]) {\n          accum[ValidationKeys.TYPE] = {\n            customTypes: [props.name as string],\n            message: DEFAULT_ERROR_MESSAGES.TYPE,\n            description: \"defines the accepted types for the attribute\",\n          };\n        } else {\n          accum[key] = props;\n        }\n        return accum;\n      },\n      {}\n    );\n\n    if (!Object.keys(decoratorData).length) {\n      continue;\n    }\n\n    let zod: any = ZodAny;\n\n    const typeData: TypeMetadata = decoratorData[\n      ValidationKeys.TYPE\n    ] as TypeMetadata;\n\n    if (!typeData) {\n      throw new Error(`Missing type information`);\n    }\n\n    zod = zodify(\n      typeData.customTypes,\n      decoratorData[ValidationKeys.LIST]\n        ? zodify((decoratorData[ValidationKeys.LIST] as ListMetadata).clazz)\n        : ZodAny\n    );\n\n    for (const [key, props] of Object.entries(decoratorData).filter(\n      ([k]) => !isReservedKey(k)\n    )) {\n      zod = zodifyValidation(zod, key, props);\n    }\n\n    if (!decoratorData[ValidationKeys.REQUIRED]) {\n      zod = zod.optional();\n    }\n\n    result[prop] = zod;\n  }\n\n  return z.object(result);\n};\n","export * from \"./model\";\nexport * from \"./overrides\";\n\n/**\n * @description Current version of the reflection package\n * @summary Stores the semantic version number of the package\n * @const VERSION\n * @memberOf module:as-zod\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}

package/lib/esm/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./model";
+export * from "./overrides";
+/**
+ * @description Current version of the reflection package
+ * @summary Stores the semantic version number of the package
+ * @const VERSION
+ * @memberOf module:as-zod
+ */
+export declare const VERSION = "0.0.2";

package/lib/esm/index.js

@@ -0,0 +1,10 @@
+export * from "./model";
+export * from "./overrides";
+/**
+ * @description Current version of the reflection package
+ * @summary Stores the semantic version number of the package
+ * @const VERSION
+ * @memberOf module:as-zod
+ */
+export const VERSION = "0.0.2";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxhQUFhLENBQUM7QUFFNUI7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL292ZXJyaWRlc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHZlcnNpb24gb2YgdGhlIHJlZmxlY3Rpb24gcGFja2FnZVxuICogQHN1bW1hcnkgU3RvcmVzIHRoZSBzZW1hbnRpYyB2ZXJzaW9uIG51bWJlciBvZiB0aGUgcGFja2FnZVxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6YXMtem9kXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19

package/lib/esm/model.d.ts

@@ -0,0 +1,6 @@
+import { ZodObject } from "zod";
+declare module "@decaf-ts/decorator-validation" {
+    interface Model {
+        toZod(): ZodObject;
+    }
+}

package/lib/esm/model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFpvZE9iamVjdCB9IGZyb20gXCJ6b2RcIjtcblxuZGVjbGFyZSBtb2R1bGUgXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIiB7XG4gIGludGVyZmFjZSBNb2RlbCB7XG4gICAgdG9ab2QoKTogWm9kT2JqZWN0O1xuICB9XG59XG4iXX0=

package/lib/esm/overrides.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorOptions } from "@decaf-ts/decorator-validation";
+export declare function zodify(type: string | string[], zz?: any): any;
+export declare function zodifyValidation(zod: any, type: string, values: ValidatorOptions): any;

package/lib/esm/overrides.js

@@ -0,0 +1,125 @@
+import { Model, ModelKeys, Primitives, DEFAULT_ERROR_MESSAGES, } from "@decaf-ts/decorator-validation";
+import { z, ZodAny } from "zod";
+import { Reflection } from "@decaf-ts/reflection";
+import { ValidationKeys } from "@decaf-ts/decorator-validation";
+const ReservedKeys = [
+    ValidationKeys.REQUIRED,
+    ValidationKeys.TYPE,
+    ModelKeys.TYPE,
+];
+function isReservedKey(el) {
+    return ReservedKeys.includes(el);
+}
+export function zodify(type, zz = ZodAny) {
+    type = typeof type === "string" ? [type] : type;
+    function innerZodify(type) {
+        switch (type.toLowerCase()) {
+            case Primitives.STRING:
+                return z.string();
+            case Primitives.NUMBER:
+                return z.number();
+            case Primitives.BIGINT:
+                return z.bigint();
+            case Primitives.BOOLEAN:
+                return z.boolean();
+            case ValidationKeys.DATE:
+                return z.date();
+            case Array.name.toLowerCase():
+                return z.array(zz);
+            case Set.name.toLowerCase():
+                return z.set(zz);
+            default: {
+                const m = Model.get(type);
+                if (!m) {
+                    throw new Error(`Unzodifiable type: ${type}`);
+                }
+                try {
+                    const zz = new m().toZod();
+                    return zz;
+                }
+                catch (e) {
+                    throw new Error(`Failed to zodify model ${type}: ${e}`);
+                }
+            }
+        }
+    }
+    let zod;
+    for (const t of type) {
+        zod = zod ? zod.or(innerZodify(t)) : innerZodify(t);
+    }
+    return zod;
+}
+export function zodifyValidation(zod, type, values) {
+    switch (type) {
+        case ValidationKeys.MIN:
+            return zod.min(values[ValidationKeys.MIN]);
+        case ValidationKeys.MIN_LENGTH:
+            return zod.min(values[ValidationKeys.MIN_LENGTH]);
+        case ValidationKeys.MAX:
+            return zod.max(values[ValidationKeys.MAX]);
+        case ValidationKeys.MAX_LENGTH:
+            return zod.max(values[ValidationKeys.MAX_LENGTH]);
+        case ValidationKeys.STEP:
+            return zod.multipleOf(values[ValidationKeys.STEP]);
+        case ValidationKeys.PATTERN:
+            return zod.regex(values[ValidationKeys.PATTERN]);
+        case ValidationKeys.URL:
+            return zod.regex(values[ValidationKeys.PATTERN]);
+        case ValidationKeys.EMAIL:
+            return zod.regex(values[ValidationKeys.PATTERN]);
+        case ValidationKeys.PASSWORD:
+            return zod.regex(values[ValidationKeys.PATTERN]);
+        case ValidationKeys.DATE:
+            return zod.date();
+        default:
+            return zod;
+    }
+}
+Model.prototype.toZod = function () {
+    const result = {};
+    const properties = Object.getOwnPropertyNames(this);
+    if (Array.isArray(properties) && !properties.length)
+        return z.object({});
+    for (const prop of Object.getOwnPropertyNames(this)) {
+        if (typeof this[prop] === "function" ||
+            prop.startsWith("_") ||
+            prop === "constructor") {
+            continue;
+        }
+        const allDecs = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, this, prop, false, true);
+        const decoratorData = allDecs.decorators.reduce((accum, el) => {
+            const { key, props } = el;
+            if (key === ModelKeys.TYPE && !accum[ValidationKeys.TYPE]) {
+                accum[ValidationKeys.TYPE] = {
+                    customTypes: [props.name],
+                    message: DEFAULT_ERROR_MESSAGES.TYPE,
+                    description: "defines the accepted types for the attribute",
+                };
+            }
+            else {
+                accum[key] = props;
+            }
+            return accum;
+        }, {});
+        if (!Object.keys(decoratorData).length) {
+            continue;
+        }
+        let zod = ZodAny;
+        const typeData = decoratorData[ValidationKeys.TYPE];
+        if (!typeData) {
+            throw new Error(`Missing type information`);
+        }
+        zod = zodify(typeData.customTypes, decoratorData[ValidationKeys.LIST]
+            ? zodify(decoratorData[ValidationKeys.LIST].clazz)
+            : ZodAny);
+        for (const [key, props] of Object.entries(decoratorData).filter(([k]) => !isReservedKey(k))) {
+            zod = zodifyValidation(zod, key, props);
+        }
+        if (!decoratorData[ValidationKeys.REQUIRED]) {
+            zod = zod.optional();
+        }
+        result[prop] = zod;
+    }
+    return z.object(result);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overrides.js","sourceRoot":"","sources":["../../src/overrides.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Model,\n  ModelKeys,\n  TypeMetadata,\n  Primitives,\n  DEFAULT_ERROR_MESSAGES,\n  ValidatorOptions,\n  MinLengthValidatorOptions,\n  MinValidatorOptions,\n  MaxValidatorOptions,\n  MaxLengthValidatorOptions,\n  StepValidatorOptions,\n  PatternValidatorOptions,\n  ListMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport { z, ZodAny, ZodObject, ZodRawShape } from \"zod\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidationKeys } from \"@decaf-ts/decorator-validation\";\n\nconst ReservedKeys = [\n  ValidationKeys.REQUIRED,\n  ValidationKeys.TYPE,\n  ModelKeys.TYPE,\n] as const;\n\nfunction isReservedKey(el: string) {\n  return ReservedKeys.includes(el as any);\n}\n\nexport function zodify(type: string | string[], zz: any = ZodAny) {\n  type = typeof type === \"string\" ? [type] : type;\n\n  function innerZodify(type: string) {\n    switch (type.toLowerCase()) {\n      case Primitives.STRING:\n        return z.string();\n      case Primitives.NUMBER:\n        return z.number();\n      case Primitives.BIGINT:\n        return z.bigint();\n      case Primitives.BOOLEAN:\n        return z.boolean();\n      case ValidationKeys.DATE:\n        return z.date();\n      case Array.name.toLowerCase():\n        return z.array(zz);\n      case Set.name.toLowerCase():\n        return z.set(zz);\n      default: {\n        const m = Model.get(type);\n        if (!m) {\n          throw new Error(`Unzodifiable type: ${type}`);\n        }\n        try {\n          const zz = new m().toZod();\n          return zz;\n        } catch (e: unknown) {\n          throw new Error(`Failed to zodify model ${type}: ${e}`);\n        }\n      }\n    }\n  }\n\n  let zod: any;\n  for (const t of type) {\n    zod = zod ? zod.or(innerZodify(t)) : innerZodify(t);\n  }\n\n  return zod;\n}\n\nexport function zodifyValidation(\n  zod: any,\n  type: string,\n  values: ValidatorOptions\n) {\n  switch (type) {\n    case ValidationKeys.MIN:\n      return zod.min((values as MinValidatorOptions)[ValidationKeys.MIN]);\n    case ValidationKeys.MIN_LENGTH:\n      return zod.min(\n        (values as MinLengthValidatorOptions)[ValidationKeys.MIN_LENGTH]\n      );\n    case ValidationKeys.MAX:\n      return zod.max((values as MaxValidatorOptions)[ValidationKeys.MAX]);\n    case ValidationKeys.MAX_LENGTH:\n      return zod.max(\n        (values as MaxLengthValidatorOptions)[ValidationKeys.MAX_LENGTH]\n      );\n    case ValidationKeys.STEP:\n      return zod.multipleOf(\n        (values as StepValidatorOptions)[ValidationKeys.STEP]\n      );\n    case ValidationKeys.PATTERN:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.URL:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.EMAIL:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.PASSWORD:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.DATE:\n      return zod.date();\n    default:\n      return zod;\n  }\n}\n\nModel.prototype.toZod = function <M extends Model>(this: M): ZodObject<any> {\n  const result: { [key: string]: ZodRawShape } = {};\n\n  const properties = Object.getOwnPropertyNames(this);\n  if (Array.isArray(properties) && !properties.length) return z.object({});\n  for (const prop of Object.getOwnPropertyNames(this)) {\n    if (\n      typeof (this as any)[prop] === \"function\" ||\n      prop.startsWith(\"_\") ||\n      prop === \"constructor\"\n    ) {\n      continue;\n    }\n\n    const allDecs = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      this,\n      prop,\n      false,\n      true\n    );\n\n    const decoratorData = allDecs.decorators.reduce(\n      (accum: Record<string, any>, el) => {\n        const { key, props } = el;\n        if (key === ModelKeys.TYPE && !accum[ValidationKeys.TYPE]) {\n          accum[ValidationKeys.TYPE] = {\n            customTypes: [props.name as string],\n            message: DEFAULT_ERROR_MESSAGES.TYPE,\n            description: \"defines the accepted types for the attribute\",\n          };\n        } else {\n          accum[key] = props;\n        }\n        return accum;\n      },\n      {}\n    );\n\n    if (!Object.keys(decoratorData).length) {\n      continue;\n    }\n\n    let zod: any = ZodAny;\n\n    const typeData: TypeMetadata = decoratorData[\n      ValidationKeys.TYPE\n    ] as TypeMetadata;\n\n    if (!typeData) {\n      throw new Error(`Missing type information`);\n    }\n\n    zod = zodify(\n      typeData.customTypes,\n      decoratorData[ValidationKeys.LIST]\n        ? zodify((decoratorData[ValidationKeys.LIST] as ListMetadata).clazz)\n        : ZodAny\n    );\n\n    for (const [key, props] of Object.entries(decoratorData).filter(\n      ([k]) => !isReservedKey(k)\n    )) {\n      zod = zodifyValidation(zod, key, props);\n    }\n\n    if (!decoratorData[ValidationKeys.REQUIRED]) {\n      zod = zod.optional();\n    }\n\n    result[prop] = zod;\n  }\n\n  return z.object(result);\n};\n"]}

package/lib/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+__exportStar(require("./model.cjs"), exports);
+__exportStar(require("./overrides.cjs"), exports);
+/**
+ * @description Current version of the reflection package
+ * @summary Stores the semantic version number of the package
+ * @const VERSION
+ * @memberOf module:as-zod
+ */
+exports.VERSION = "0.0.2";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSw4Q0FBd0I7QUFDeEIsa0RBQTRCO0FBRTVCOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL292ZXJyaWRlc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHZlcnNpb24gb2YgdGhlIHJlZmxlY3Rpb24gcGFja2FnZVxuICogQHN1bW1hcnkgU3RvcmVzIHRoZSBzZW1hbnRpYyB2ZXJzaW9uIG51bWJlciBvZiB0aGUgcGFja2FnZVxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6YXMtem9kXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./model";
+export * from "./overrides";
+/**
+ * @description Current version of the reflection package
+ * @summary Stores the semantic version number of the package
+ * @const VERSION
+ * @memberOf module:as-zod
+ */
+export declare const VERSION = "0.0.2";

package/lib/model.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFpvZE9iamVjdCB9IGZyb20gXCJ6b2RcIjtcblxuZGVjbGFyZSBtb2R1bGUgXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIiB7XG4gIGludGVyZmFjZSBNb2RlbCB7XG4gICAgdG9ab2QoKTogWm9kT2JqZWN0O1xuICB9XG59XG4iXX0=

package/lib/model.d.ts

@@ -0,0 +1,6 @@
+import { ZodObject } from "zod";
+declare module "@decaf-ts/decorator-validation" {
+    interface Model {
+        toZod(): ZodObject;
+    }
+}

package/lib/overrides.cjs

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodify = zodify;
+exports.zodifyValidation = zodifyValidation;
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const zod_1 = require("zod");
+const reflection_1 = require("@decaf-ts/reflection");
+const decorator_validation_2 = require("@decaf-ts/decorator-validation");
+const ReservedKeys = [
+    decorator_validation_2.ValidationKeys.REQUIRED,
+    decorator_validation_2.ValidationKeys.TYPE,
+    decorator_validation_1.ModelKeys.TYPE,
+];
+function isReservedKey(el) {
+    return ReservedKeys.includes(el);
+}
+function zodify(type, zz = zod_1.ZodAny) {
+    type = typeof type === "string" ? [type] : type;
+    function innerZodify(type) {
+        switch (type.toLowerCase()) {
+            case decorator_validation_1.Primitives.STRING:
+                return zod_1.z.string();
+            case decorator_validation_1.Primitives.NUMBER:
+                return zod_1.z.number();
+            case decorator_validation_1.Primitives.BIGINT:
+                return zod_1.z.bigint();
+            case decorator_validation_1.Primitives.BOOLEAN:
+                return zod_1.z.boolean();
+            case decorator_validation_2.ValidationKeys.DATE:
+                return zod_1.z.date();
+            case Array.name.toLowerCase():
+                return zod_1.z.array(zz);
+            case Set.name.toLowerCase():
+                return zod_1.z.set(zz);
+            default: {
+                const m = decorator_validation_1.Model.get(type);
+                if (!m) {
+                    throw new Error(`Unzodifiable type: ${type}`);
+                }
+                try {
+                    const zz = new m().toZod();
+                    return zz;
+                }
+                catch (e) {
+                    throw new Error(`Failed to zodify model ${type}: ${e}`);
+                }
+            }
+        }
+    }
+    let zod;
+    for (const t of type) {
+        zod = zod ? zod.or(innerZodify(t)) : innerZodify(t);
+    }
+    return zod;
+}
+function zodifyValidation(zod, type, values) {
+    switch (type) {
+        case decorator_validation_2.ValidationKeys.MIN:
+            return zod.min(values[decorator_validation_2.ValidationKeys.MIN]);
+        case decorator_validation_2.ValidationKeys.MIN_LENGTH:
+            return zod.min(values[decorator_validation_2.ValidationKeys.MIN_LENGTH]);
+        case decorator_validation_2.ValidationKeys.MAX:
+            return zod.max(values[decorator_validation_2.ValidationKeys.MAX]);
+        case decorator_validation_2.ValidationKeys.MAX_LENGTH:
+            return zod.max(values[decorator_validation_2.ValidationKeys.MAX_LENGTH]);
+        case decorator_validation_2.ValidationKeys.STEP:
+            return zod.multipleOf(values[decorator_validation_2.ValidationKeys.STEP]);
+        case decorator_validation_2.ValidationKeys.PATTERN:
+            return zod.regex(values[decorator_validation_2.ValidationKeys.PATTERN]);
+        case decorator_validation_2.ValidationKeys.URL:
+            return zod.regex(values[decorator_validation_2.ValidationKeys.PATTERN]);
+        case decorator_validation_2.ValidationKeys.EMAIL:
+            return zod.regex(values[decorator_validation_2.ValidationKeys.PATTERN]);
+        case decorator_validation_2.ValidationKeys.PASSWORD:
+            return zod.regex(values[decorator_validation_2.ValidationKeys.PATTERN]);
+        case decorator_validation_2.ValidationKeys.DATE:
+            return zod.date();
+        default:
+            return zod;
+    }
+}
+decorator_validation_1.Model.prototype.toZod = function () {
+    const result = {};
+    const properties = Object.getOwnPropertyNames(this);
+    if (Array.isArray(properties) && !properties.length)
+        return zod_1.z.object({});
+    for (const prop of Object.getOwnPropertyNames(this)) {
+        if (typeof this[prop] === "function" ||
+            prop.startsWith("_") ||
+            prop === "constructor") {
+            continue;
+        }
+        const allDecs = reflection_1.Reflection.getPropertyDecorators(decorator_validation_2.ValidationKeys.REFLECT, this, prop, false, true);
+        const decoratorData = allDecs.decorators.reduce((accum, el) => {
+            const { key, props } = el;
+            if (key === decorator_validation_1.ModelKeys.TYPE && !accum[decorator_validation_2.ValidationKeys.TYPE]) {
+                accum[decorator_validation_2.ValidationKeys.TYPE] = {
+                    customTypes: [props.name],
+                    message: decorator_validation_1.DEFAULT_ERROR_MESSAGES.TYPE,
+                    description: "defines the accepted types for the attribute",
+                };
+            }
+            else {
+                accum[key] = props;
+            }
+            return accum;
+        }, {});
+        if (!Object.keys(decoratorData).length) {
+            continue;
+        }
+        let zod = zod_1.ZodAny;
+        const typeData = decoratorData[decorator_validation_2.ValidationKeys.TYPE];
+        if (!typeData) {
+            throw new Error(`Missing type information`);
+        }
+        zod = zodify(typeData.customTypes, decoratorData[decorator_validation_2.ValidationKeys.LIST]
+            ? zodify(decoratorData[decorator_validation_2.ValidationKeys.LIST].clazz)
+            : zod_1.ZodAny);
+        for (const [key, props] of Object.entries(decoratorData).filter(([k]) => !isReservedKey(k))) {
+            zod = zodifyValidation(zod, key, props);
+        }
+        if (!decoratorData[decorator_validation_2.ValidationKeys.REQUIRED]) {
+            zod = zod.optional();
+        }
+        result[prop] = zod;
+    }
+    return zod_1.z.object(result);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overrides.js","sourceRoot":"","sources":["../src/overrides.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Model,\n  ModelKeys,\n  TypeMetadata,\n  Primitives,\n  DEFAULT_ERROR_MESSAGES,\n  ValidatorOptions,\n  MinLengthValidatorOptions,\n  MinValidatorOptions,\n  MaxValidatorOptions,\n  MaxLengthValidatorOptions,\n  StepValidatorOptions,\n  PatternValidatorOptions,\n  ListMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport { z, ZodAny, ZodObject, ZodRawShape } from \"zod\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidationKeys } from \"@decaf-ts/decorator-validation\";\n\nconst ReservedKeys = [\n  ValidationKeys.REQUIRED,\n  ValidationKeys.TYPE,\n  ModelKeys.TYPE,\n] as const;\n\nfunction isReservedKey(el: string) {\n  return ReservedKeys.includes(el as any);\n}\n\nexport function zodify(type: string | string[], zz: any = ZodAny) {\n  type = typeof type === \"string\" ? [type] : type;\n\n  function innerZodify(type: string) {\n    switch (type.toLowerCase()) {\n      case Primitives.STRING:\n        return z.string();\n      case Primitives.NUMBER:\n        return z.number();\n      case Primitives.BIGINT:\n        return z.bigint();\n      case Primitives.BOOLEAN:\n        return z.boolean();\n      case ValidationKeys.DATE:\n        return z.date();\n      case Array.name.toLowerCase():\n        return z.array(zz);\n      case Set.name.toLowerCase():\n        return z.set(zz);\n      default: {\n        const m = Model.get(type);\n        if (!m) {\n          throw new Error(`Unzodifiable type: ${type}`);\n        }\n        try {\n          const zz = new m().toZod();\n          return zz;\n        } catch (e: unknown) {\n          throw new Error(`Failed to zodify model ${type}: ${e}`);\n        }\n      }\n    }\n  }\n\n  let zod: any;\n  for (const t of type) {\n    zod = zod ? zod.or(innerZodify(t)) : innerZodify(t);\n  }\n\n  return zod;\n}\n\nexport function zodifyValidation(\n  zod: any,\n  type: string,\n  values: ValidatorOptions\n) {\n  switch (type) {\n    case ValidationKeys.MIN:\n      return zod.min((values as MinValidatorOptions)[ValidationKeys.MIN]);\n    case ValidationKeys.MIN_LENGTH:\n      return zod.min(\n        (values as MinLengthValidatorOptions)[ValidationKeys.MIN_LENGTH]\n      );\n    case ValidationKeys.MAX:\n      return zod.max((values as MaxValidatorOptions)[ValidationKeys.MAX]);\n    case ValidationKeys.MAX_LENGTH:\n      return zod.max(\n        (values as MaxLengthValidatorOptions)[ValidationKeys.MAX_LENGTH]\n      );\n    case ValidationKeys.STEP:\n      return zod.multipleOf(\n        (values as StepValidatorOptions)[ValidationKeys.STEP]\n      );\n    case ValidationKeys.PATTERN:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.URL:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.EMAIL:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.PASSWORD:\n      return zod.regex(\n        (values as PatternValidatorOptions)[ValidationKeys.PATTERN]\n      );\n    case ValidationKeys.DATE:\n      return zod.date();\n    default:\n      return zod;\n  }\n}\n\nModel.prototype.toZod = function <M extends Model>(this: M): ZodObject<any> {\n  const result: { [key: string]: ZodRawShape } = {};\n\n  const properties = Object.getOwnPropertyNames(this);\n  if (Array.isArray(properties) && !properties.length) return z.object({});\n  for (const prop of Object.getOwnPropertyNames(this)) {\n    if (\n      typeof (this as any)[prop] === \"function\" ||\n      prop.startsWith(\"_\") ||\n      prop === \"constructor\"\n    ) {\n      continue;\n    }\n\n    const allDecs = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      this,\n      prop,\n      false,\n      true\n    );\n\n    const decoratorData = allDecs.decorators.reduce(\n      (accum: Record<string, any>, el) => {\n        const { key, props } = el;\n        if (key === ModelKeys.TYPE && !accum[ValidationKeys.TYPE]) {\n          accum[ValidationKeys.TYPE] = {\n            customTypes: [props.name as string],\n            message: DEFAULT_ERROR_MESSAGES.TYPE,\n            description: \"defines the accepted types for the attribute\",\n          };\n        } else {\n          accum[key] = props;\n        }\n        return accum;\n      },\n      {}\n    );\n\n    if (!Object.keys(decoratorData).length) {\n      continue;\n    }\n\n    let zod: any = ZodAny;\n\n    const typeData: TypeMetadata = decoratorData[\n      ValidationKeys.TYPE\n    ] as TypeMetadata;\n\n    if (!typeData) {\n      throw new Error(`Missing type information`);\n    }\n\n    zod = zodify(\n      typeData.customTypes,\n      decoratorData[ValidationKeys.LIST]\n        ? zodify((decoratorData[ValidationKeys.LIST] as ListMetadata).clazz)\n        : ZodAny\n    );\n\n    for (const [key, props] of Object.entries(decoratorData).filter(\n      ([k]) => !isReservedKey(k)\n    )) {\n      zod = zodifyValidation(zod, key, props);\n    }\n\n    if (!decoratorData[ValidationKeys.REQUIRED]) {\n      zod = zod.optional();\n    }\n\n    result[prop] = zod;\n  }\n\n  return z.object(result);\n};\n"]}

package/lib/overrides.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorOptions } from "@decaf-ts/decorator-validation";
+export declare function zodify(type: string | string[], zz?: any): any;
+export declare function zodifyValidation(zod: any, type: string, values: ValidatorOptions): any;

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@decaf-ts/as-zod",
+  "version": "0.0.3",
+  "description": "Zod compatibility library",
+  "type": "module",
+  "exports": {
+    "require": "./lib/index.cjs",
+    "import": "./lib/esm/index.js"
+  },
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "do-install": "TOKEN=$(cat .token) npm install",
+    "update-scripts": "node ./bin/update-scripts.cjs",
+    "on-first-run": "node ./bin/update-scripts.cjs --boot",
+    "set-git-auth": "git config url.\"https://api:$(cat .token)@github.com/\".insteadOf \"https://github.com/\" && git config url.\"https://ssh:$(cat .token)@github.com/\".insteadOf \"ssh://git@github.com/\" && git config url.\"https://git:$(cat .token)@github.com/\".insteadOf \"git@github.com:\"",
+    "flash-forward": "npx npm-check-updates -u && npm run do-install",
+    "reset": "rm -rf * && git checkout . && git pull && npm run do-install",
+    "build": "node ./bin/build-scripts.cjs --dev",
+    "build:prod": "node ./bin/build-scripts.cjs --prod",
+    "test": "jest --runInBand --detectOpenHandles",
+    "test:unit": "jest --testPathPattern=\"/tests/unit\" --passWithNoTests --detectOpenHandles",
+    "test:integration": "jest --testPathPattern=\"/tests/(integration)\" --passWithNoTests --detectOpenHandles",
+    "test:all": "jest --testPathPattern=\"/tests\" --passWithNoTests --detectOpenHandles",
+    "test:circular": "dpdm -T --no-warning --no-tree ./src/index.ts",
+    "coverage": "rimraf ./workdocs/reports/data/*.json && npm run test:all -- --coverage --config=./workdocs/reports/jest.coverage.config.ts",
+    "lint": "eslint .",
+    "lint-fix": "eslint --fix .",
+    "prepare-release": "npm run lint-fix && npm run build:prod && npm run coverage && npm run docs",
+    "release": "./bin/tag-release.sh",
+    "clean-publish": "npx clean-publish",
+    "drawings": "for FILE in workdocs/drawings/*.drawio; do echo \"converting $FILE to image...\" && docker run --rm -v $(pwd):/data rlespinasse/drawio-export --format png $FILE; done && cp -rf workdocs/drawings/export/* workdocs/resources/",
+    "uml": "cd workdocs/uml && for FILE in ./*.puml; do docker run --rm -v $(pwd):/work -w /work miy4/plantuml -DPLANTUML_LIMIT_SIZE=8192 -tpng $FILE; done && cd ../.. && cp -fr workdocs/uml/*.png workdocs/resources/",
+    "docs": "npx rimraf ./docs && mkdir docs && node ./bin/build-scripts.cjs --docs",
+    "publish-docs": "docker run -it --rm --user $(id -u):$(id -g) -v \"$(pwd)/workdocs/confluence:/content\" -e ATLASSIAN_API_TOKEN=$(cat .confluence-token) ghcr.io/markdown-confluence/publish:latest",
+    "docker:login": "docker login ghcr.io -u $(cat .dockeruser) -p $(cat .dockertoken)",
+    "docker:build": "npm run docker:build-base",
+    "docker:build-base": "DOCKER_BUILDKIT=1 docker build --secret id=TOKEN,src=$PWD/.npmtoken -t ghcr.io/decaf-ts/as-zod:base-$(cat package.json | jq -r '.version') -t ghcr.io/decaf-ts/as-zod:base-${VERSION:-latest} -f ./Dockerfile .",
+    "docker:publish": "npm run docker:publish-base",
+    "docker:publish-base": "docker push ghcr.io/decaf-ts/as-zod:base-$(cat package.json | jq -r '.version') && docker push ghcr.io/decaf-ts/as-zod:base-${VERSION:-latest}"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/decaf-ts/ts-workspace.git"
+  },
+  "engines": {
+    "node": ">=20.0.0",
+    "npm": ">=10.0.0"
+  },
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "keywords": [
+    "plantuml",
+    "mermaid",
+    "uml",
+    "drawio",
+    "mddocs",
+    "md",
+    "jsdoc",
+    "doc",
+    "docs",
+    "documentation",
+    "test",
+    "reports",
+    "confluence",
+    "ci/cd",
+    "ci",
+    "cd",
+    "template",
+    "typescript",
+    "ts"
+  ],
+  "author": "Tiago Venceslau",
+  "bugs": {
+    "url": "https://github.com/decaf-ts/ts-workspace/issues"
+  },
+  "homepage": "https://github.com/decaf-ts/ts-workspace#readme",
+  "devDependencies": {
+    "@decaf-ts/logging": "latest",
+    "@decaf-ts/utils": "latest",
+    "@eslint/js": "^9.25.1",
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@stylistic/eslint-plugin": "^4.2.0",
+    "@types/jest": "^29.5.14",
+    "clean-publish": "^5.1.0",
+    "dpdm": "^3.14.0",
+    "eslint": "^9.25.1",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-prettier": "^5.2.6",
+    "globals": "^16.0.0",
+    "jest": "^29.7.0",
+    "jest-html-reporters": "^3.1.7",
+    "jest-junit": "^16.0.0",
+    "jsdoc": "^4.0.4",
+    "jsdoc-mermaid": "^1.0.0",
+    "markdown-include": "^0.4.3",
+    "minimist": "^1.2.8",
+    "nodemon": "^3.1.9",
+    "npm-check-updates": "^18.0.0",
+    "prettier": "3.5.3",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.40.0",
+    "ts-jest": "^29.3.2",
+    "ts-loader": "^9.5.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.31.0"
+  },
+  "peerDependencies": {
+    "@decaf-ts/decorator-validation": "^1.7.4",
+    "@decaf-ts/reflection": "^0.4.5",
+    "zod": "^4.0.4"
+  }
+}