zod-to-x 1.2.1 → 1.3.0

package/README.md

@@ -7,9 +7,11 @@
 - [Why use `@zod-to-x`](#why-use-zod-to-x)
 - [Installation](#installation)
 - [Quick start](#quick-start)
+- [Intersections and Unions](#intersections-and-unions)
 - [Supported output languages](#supported-output-languages)
 - [Mapping of supported Zod Types](#mapping-of-supported-zod-types)
 - [Additional utils](#additional-utils)
+- [Changelog](#changelog)
 
 
 
@@ -17,7 +19,7 @@
 Managing data consistency across multiple layers and languages is a common challenge in modern software development. [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) solves this by allowing you to define your data models once and effortlessly transpile them into multiple programming languages. Here’s why it stands out:
 
 1. **Centralized Data Definition**  
-Define your data structures in one place using the powerful [`@zod`]((https://github.com/colinhacks/zod)) library. This eliminates redundancy, reduces inconsistencies, and simplifies maintenance across your entire codebase, all while allowing you to continue leveraging any npm package in the [`@zod`]((https://github.com/colinhacks/zod)) ecosystem like [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema)
+Define your data structures in one place using the powerful [`@zod`](https://github.com/colinhacks/zod) library. This eliminates redundancy, reduces inconsistencies, and simplifies maintenance across your entire codebase, all while allowing you to continue leveraging any npm package in the [`@zod`](https://github.com/colinhacks/zod) ecosystem like [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema)
 
 2. **Multi-Language Compatibility**  
 Generate data models for TypeScript, Protobuf V3 and C++ (with languages like Golang on the roadmap). No more manually rewriting models for different platforms.
@@ -26,14 +28,14 @@ Generate data models for TypeScript, Protobuf V3 and C++ (with languages like Go
 Automate the transpilation of data models to save time, reduce errors, and let your team focus on business logic instead of boilerplate code.
 
 
-
 ## Installation
-### 1) Install [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) and [`@zod`]((https://github.com/colinhacks/zod)) dependency.
+### 1) Install [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) and [`@zod(*)`](https://github.com/colinhacks/zod) dependency.
 ```bash
-npm install zod-to-x
+npm install zod-to-x zod
 ```
+(*) [`zod@3.22.0`](https://www.npmjs.com/package/zod/v/3.22.0) version or greather is required.
 
-### 2) Extend Zod using the `extendZod` method after the first [`@zod`]((https://github.com/colinhacks/zod)) import:
+### 2) Extend Zod using the `extendZod` method after the first [`@zod`](https://github.com/colinhacks/zod) import:
 ```ts
 import { z } from "zod";
 import { extendZod } from "zod-to-x";
@@ -115,6 +117,124 @@ Example of supported schemas with its outputs can be found in the `test` folder:
 
 
 
+## Intersections and Unions
+Starting from `v1.3.0`, a best practices helper is enabled by default when handling data intersections and unions:
+- Intersections and Unions can only be performed between ZodObject schemas.
+- Discriminant unions shall be used instead of Unions.
+
+These rules help ensure that each data model follows the single responsibility principle. Otherwise, an error will be thrown when building an `ASTNode`.
+
+**NOTE**: You can disable these rules at your own risk by setting the `strict` flag to `false` when building the `ASTNode` data model. However, any unexpected behavior or issues resulting from this will not be supported.
+
+### Expected outputs
+- **For Intersections**: whenever possible, an intersection is transpiled into a struct/class that inherits from the intersected data models. Otherwise, a new struct/class is created, where attributes are the result of merging the intersected data models. Any shared key is overridden by the last matching type.
+```ts
+const DataA = z.object({ keyA: z.string(), keyC: z.string() }).zod2x("DataA");
+const DataB = z.object({ keyB: z.string(), keyC: z.number() }).zod2x("DataB");
+const Intersection = z.intersection(DataA, DataB).zod2x("Intersection");
+
+// C++ case (with inheritance)
+// struct Intersection : public DataA, public DataB {
+//   // Intersection fields are inherited from base structs.
+// };
+
+// Typescript case (with attribute merging)
+// class Intersection {
+//   keyA: string;
+//   keyB: string;
+//   keyC: number; // Shared key overriden using the last type.
+// };
+```
+- **For Unions**: whenever possible, a union is transpiled into a variant type composed of the united data models. Otherwise, a new struct/class is created, where attributes are the result of merging the intersected data models. Any common key is preserved as is (if only its requirement differs, it is changed to optional). Other keys are also set as optional.
+```ts
+const DataA = z.object({ keyA: z.string(), keyD: z.string() }).zod2x("DataA");
+const DataB = z.object({ keyB: z.string(), keyD: z.string() }).zod2x("DataB");
+const Intersection = z.intersection(DataA, DataB).zod2x("Intersection");
+
+// C++ case (with variant type)
+// using Intersection = std::variant<DataA, DataB>;
+
+// Typescript case (with attributes merge)
+// class Intersection {
+//   keyA?: string; // Different keys are set as optional
+//   keyB?: string;
+//   keyD: number; // Shared key preserved as is.
+// };
+```
+
+
+
+### Tips for discriminated unions
+To enhance data modeling and the serialization/deserialization of a discriminated union type, two key steps should be considered:
+- Using `ZodEnum` or `ZodNativeEnum` the define the discriminator key options.
+- Using `ZodLiteral` to define the specific value of the discriminator key.
+
+Example of discriminant definition:
+```ts
+// Define message types
+export const MsgType = z.enum(["TypeA", "TypeB"]).zod2x("MsgType");
+
+// Define different message structures based on the 'msgType' value.
+const MessageA = z
+    .object({
+        key: z.string(),
+
+        // Assign the type using the corresponding MsgType value and link it with 'zod2x'.
+        msgType: z.literal(MsgType.Values.TypeA).zod2x(MsgType),  
+    })
+    .zod2x("MessageA");
+
+const MessageB = z
+    .object({
+        otherKey: z.string(),
+
+        // Same process as MessageA.
+        msgType: z.literal(MsgType.Values.TypeB).zod2x(MsgType),
+    })
+    .zod2x("MessageB");
+
+// Define the main Message type using ZodDiscriminatedUnion.
+export const Message = z
+    .discriminatedUnion("msgType", [MessageA, MessageB])
+    .zod2x("Message");
+```
+
+Example of C++ output:
+```cpp
+// Discriminated union with direct serialization/deserialization
+inline void from_json(const json& j, Message& x) {
+    const auto& k = j.at("msgType").get<std::string>();
+    if (k == "TypeA") {
+        x = j.get<MessageA>();
+    }
+    else if (k == "TypeB") {
+        x = j.get<MessageB>();
+    }
+    else {
+        throw std::runtime_error("Failed to deserialize Message: unknown format");
+    }
+}
+
+
+
+// Using a regular union or a discriminated union without the above approach:
+// Fallback to try-catch for serialization/deserialization
+inline void from_json(const json& j, Message& x) {
+  try {
+      x = j.get<MessageA>();
+      return;
+  } catch (const std::exception&) {
+  }
+  try {
+      x = j.get<MessageB>();
+      return;
+  } catch (const std::exception&) {
+      throw std::runtime_error("Failed to deserialize Message: unknown format");
+  }
+}
+```
+
+
 ## Supported output languages
 Common options:
 - **header**: Text to add as a comment at the beginning of the output.
@@ -122,6 +242,10 @@ Common options:
 - **includeComments**: Determines whether to include comments in the transpiled code. Defaults to `true`.
 - **skipDiscriminatorNodes**: prevents the inclusion of `ZodEnum` or `ZodNativeEnum` schemas that are used solely as discriminator keys in a `ZodDiscriminatedUnion`. Defaults to `false`.
 
+### 0) ASTNode
+- Options:
+  - **strict**: When true, it will throw an error if a bad data modeling practice is detected. Default is `true`.
+
 ### 1) Typescript  
 - Options:
   - **outType**: Output transpilation using Typescript interfaces or Classes. Defaults to `interface`.
@@ -132,7 +256,6 @@ Common options:
   - **useCamelCase**: Protobuf follows the snake_case convention for field names, but camelCase can also be used. Defaults to `false`.
 
 - Limitations:
-  - `oneof` fields support only unions of `ZodObject` schemas.
   - `ZodTuple` is supported only for items of the same type.
 
 
@@ -144,9 +267,6 @@ Common options:
   - **outType**: Output transpilation using C++ Structs or Classes. Defaults to `struct`.
   - **skipSerialize**: Remove Nlohmann JSON serialization/deserialization. Defaults to `false`.
 
-- Limitations:
-  - `ZodIntersection` is supported only for intersection of `ZodObject` schemas.
-
 
 
 ## Mapping of supported Zod Types
@@ -315,4 +435,7 @@ console.log(userJsonSchema);
 //   },
 //   "$schema": "http://json-schema.org/draft-07/schema#"
 // }
-```
+```
+
+## Changelog
+View the changelog at [Releases](https://github.com/rroumenov/zod-to-x/releases).

package/dist/core/ast_node.d.ts

@@ -1,12 +1,20 @@
 import { ZodObject, ZodRawShape } from "zod";
 import { ASTNodes } from "./ast_types";
+interface IZod2AstOpt {
+    strict?: boolean;
+}
 export declare class Zod2Ast {
     private nodes;
     private discriminatorNodes;
     private lazyPointers;
-    constructor();
+    private warnings;
+    private opt;
+    constructor(opt?: IZod2AstOpt);
     private _createDefinition;
     private _getEnumValues;
-    private zodToAST;
+    private _intersectAstNodes;
+    private _unionAstNodes;
+    private _zodToAST;
     build<T extends ZodRawShape>(schema: ZodObject<T>): ASTNodes;
 }
+export {};

package/dist/core/ast_node.js

@@ -2,11 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Zod2Ast = void 0;
 const zod_1 = require("zod");
+const logger_1 = require("../utils/logger");
+const errors_1 = require("./errors");
 class Zod2Ast {
-    constructor() {
+    constructor(opt = {}) {
+        var _a;
         this.nodes = new Map();
         this.discriminatorNodes = new Map();
         this.lazyPointers = [];
+        this.warnings = [];
+        this.opt = {
+            strict: (_a = opt.strict) !== null && _a !== void 0 ? _a : true,
+        };
     }
     _createDefinition(ref, refType, discriminantValue) {
         return { type: "definition", reference: ref, referenceType: refType, discriminantValue };
@@ -27,8 +34,53 @@ class Zod2Ast {
             });
         }
     }
-    zodToAST(schema, opt) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    _intersectAstNodes(left, right) {
+        const leftData = this.nodes.get(left.reference);
+        const rightData = this.nodes.get(right.reference);
+        return {
+            properties: Object.assign(Object.assign({}, leftData.properties), rightData.properties),
+        };
+    }
+    _unionAstNodes(options) {
+        const data = options.map((i) => this.nodes.get(i.reference));
+        return {
+            properties: data.reduce((acc, i, j) => {
+                var _a, _b;
+                for (const key in i.properties) {
+                    if (acc[key]) {
+                        acc[key] = structuredClone(acc[key]);
+                        if (acc[key].type !== i.properties[key].type) {
+                            this.warnings.push(`Merging properties with different types: ${acc[key].type} ` +
+                                `(from ${(_a = data[j - 1]) === null || _a === void 0 ? void 0 : _a.name}) and ${i.properties[key].type} ` +
+                                `(from ${i.name})`);
+                            acc[key].type = i.properties[key].type;
+                        }
+                        if (acc[key].arrayDimension !== i.properties[key].arrayDimension) {
+                            this.warnings.push(`Merging properties with different array dimensions: ` +
+                                `${acc[key].arrayDimension} (from ${(_b = data[j - 1]) === null || _b === void 0 ? void 0 : _b.name}) and ` +
+                                `${i.properties[key].arrayDimension} (from ${i.name})`);
+                            acc[key].arrayDimension = Math.max(acc[key].arrayDimension || 0, i.properties[key].arrayDimension || 0);
+                        }
+                        if (acc[key].isNullable !== i.properties[key].isNullable) {
+                            acc[key].isNullable = true;
+                        }
+                        if (acc[key].isOptional !== i.properties[key].isOptional) {
+                            acc[key].isOptional = true;
+                        }
+                        if (i.properties[key].description) {
+                            acc[key].description = i.properties[key].description;
+                        }
+                    }
+                    else {
+                        acc[key] = i.properties[key];
+                    }
+                }
+                return acc;
+            }, {}),
+        };
+    }
+    _zodToAST(schema, opt) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         const def = schema._def;
         if (schema instanceof zod_1.ZodString) {
             return {
@@ -67,15 +119,19 @@ class Zod2Ast {
             };
         }
         else if (schema instanceof zod_1.ZodNullable) {
-            const subSchema = this.zodToAST(def.innerType);
+            const subSchema = this._zodToAST(def.innerType);
             return Object.assign(Object.assign({ isNullable: true }, subSchema), { description: schema.description || subSchema.description });
         }
         else if (schema instanceof zod_1.ZodOptional) {
-            const subSchema = this.zodToAST(def.innerType);
+            const subSchema = this._zodToAST(def.innerType);
             return Object.assign(Object.assign({ isOptional: true }, subSchema), { description: schema.description || subSchema.description });
         }
+        else if (schema instanceof zod_1.ZodDefault) {
+            const subSchema = this._zodToAST(def.innerType);
+            return Object.assign(Object.assign({}, subSchema), { description: schema.description || subSchema.description });
+        }
         else if (schema instanceof zod_1.ZodArray) {
-            const subSchema = this.zodToAST(def.type);
+            const subSchema = this._zodToAST(def.type);
             return Object.assign(Object.assign({}, subSchema), { description: schema.description || subSchema.description, arrayDimension: Number.isInteger(subSchema.arrayDimension)
                     ? ++subSchema.arrayDimension
                     : 1 });
@@ -83,7 +139,7 @@ class Zod2Ast {
         else if (schema instanceof zod_1.ZodSet) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodSet,
-                value: this.zodToAST(def.valueType),
+                value: this._zodToAST(def.valueType),
                 description: schema.description,
             };
         }
@@ -93,7 +149,7 @@ class Zod2Ast {
             if ((_c = def.zod2x) === null || _c === void 0 ? void 0 : _c.parentEnum) {
                 parentEnumName = (_e = (_d = def.zod2x) === null || _d === void 0 ? void 0 : _d.parentEnum._def.zod2x) === null || _e === void 0 ? void 0 : _e.typeName;
                 parentEnumKey = (_g = this._getEnumValues((_f = def.zod2x) === null || _f === void 0 ? void 0 : _f.parentEnum).find((i) => i[1] === def.value)) === null || _g === void 0 ? void 0 : _g[0];
-                this.zodToAST((_h = def.zod2x) === null || _h === void 0 ? void 0 : _h.parentEnum, { isInjectedEnum: true });
+                this._zodToAST((_h = def.zod2x) === null || _h === void 0 ? void 0 : _h.parentEnum, { isInjectedEnum: true });
             }
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodLiteral,
@@ -106,8 +162,8 @@ class Zod2Ast {
         else if (schema instanceof zod_1.ZodRecord) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodRecord,
-                key: this.zodToAST(def.keyType),
-                value: this.zodToAST(def.valueType),
+                key: this._zodToAST(def.keyType),
+                value: this._zodToAST(def.valueType),
                 description: schema.description,
             };
         }
@@ -120,23 +176,27 @@ class Zod2Ast {
         else if (schema instanceof zod_1.ZodTuple) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodTuple,
-                items: def.items.map(this.zodToAST.bind(this)),
+                items: def.items.map(this._zodToAST.bind(this)),
                 description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodMap) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodMap,
-                key: this.zodToAST(def.keyType),
-                value: this.zodToAST(def.valueType),
+                key: this._zodToAST(def.keyType),
+                value: this._zodToAST(def.valueType),
                 description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodNativeEnum || schema instanceof zod_1.ZodEnum) {
-            let name = (_j = def.zod2x) === null || _j === void 0 ? void 0 : _j.typeName;
+            const name = (_j = def.zod2x) === null || _j === void 0 ? void 0 : _j.typeName;
+            if (!name) {
+                throw new errors_1.AstTypeNameDefinitionError("ZodEnum/ZodNativeEnum type must have a typeName. " +
+                    "Use zod2x method to provide one.");
+            }
             const item = {
                 type: def.typeName,
-                name: (_k = def.zod2x) === null || _k === void 0 ? void 0 : _k.typeName,
+                name,
                 values: this._getEnumValues(schema),
                 description: def.description,
             };
@@ -156,16 +216,19 @@ class Zod2Ast {
             return this._createDefinition(name, def.typeName);
         }
         else if (schema instanceof zod_1.ZodObject) {
-            let name = (_l = def.zod2x) === null || _l === void 0 ? void 0 : _l.typeName;
+            const name = (_k = def.zod2x) === null || _k === void 0 ? void 0 : _k.typeName;
             let discriminantValue = undefined;
+            if (!name) {
+                throw new errors_1.AstTypeNameDefinitionError("ZodObject type must have a typeName. Use zod2x method to provide one.");
+            }
             if (!this.nodes.has(name)) {
                 const properties = {};
                 for (const key in def.shape()) {
-                    properties[key] = this.zodToAST(def.shape()[key]);
+                    properties[key] = this._zodToAST(def.shape()[key]);
                 }
                 this.nodes.set(name, {
                     type: zod_1.ZodFirstPartyTypeKind.ZodObject,
-                    name: (_m = def.zod2x) === null || _m === void 0 ? void 0 : _m.typeName,
+                    name,
                     properties,
                     description: schema.description,
                 });
@@ -185,14 +248,34 @@ class Zod2Ast {
             return this._createDefinition(name, def.typeName, discriminantValue);
         }
         else if (schema instanceof zod_1.ZodUnion || schema instanceof zod_1.ZodDiscriminatedUnion) {
-            let name = (_o = def.zod2x) === null || _o === void 0 ? void 0 : _o.typeName;
+            const name = (_l = def.zod2x) === null || _l === void 0 ? void 0 : _l.typeName;
+            if (!name) {
+                throw new errors_1.AstTypeNameDefinitionError("ZodUnion/ZodDiscriminatedUnion type must have a typeName. " +
+                    "Use zod2x method to provide one.");
+            }
             const item = {
                 type: def.typeName,
-                name: (_p = def.zod2x) === null || _p === void 0 ? void 0 : _p.typeName,
-                options: def.options.map((i) => this.zodToAST(i, { discriminantKey: def.discriminator })),
+                name,
+                options: def.options.map((i) => this._zodToAST(i, { discriminantKey: def.discriminator })),
                 description: schema.description,
                 discriminantKey: def.discriminator,
             };
+            if (!def.options.every((i) => i instanceof zod_1.ZodObject)) {
+                this.warnings.push("Union of non-object types is a bad data modeling practice, " +
+                    "and could lead to unexpected results.");
+            }
+            else if (schema instanceof zod_1.ZodUnion) {
+                this.warnings.push("Using ZodUnion is a bad data modeling practice. " +
+                    "Use ZodDiscriminatedUnion instead.");
+                item.newObject = {
+                    name,
+                    type: zod_1.ZodFirstPartyTypeKind.ZodObject,
+                    properties: this._unionAstNodes(item.options).properties,
+                    description: (schema.description ? `${schema.description} - ` : "") +
+                        `Built from union of ` +
+                        `${item.options.map((i) => i.reference).join(", ")}`,
+                };
+            }
             if (name && !this.nodes.has(name)) {
                 this.nodes.set(name, item);
                 return this._createDefinition(name, def.typeName);
@@ -200,28 +283,51 @@ class Zod2Ast {
             return item;
         }
         else if (schema instanceof zod_1.ZodIntersection) {
-            let name = (_q = def.zod2x) === null || _q === void 0 ? void 0 : _q.typeName;
+            const name = (_m = def.zod2x) === null || _m === void 0 ? void 0 : _m.typeName;
+            if (!name) {
+                throw new errors_1.AstTypeNameDefinitionError("ZodIntersection type must have a typeName. Use zod2x method to provide one.");
+            }
             const item = {
                 type: zod_1.ZodFirstPartyTypeKind.ZodIntersection,
-                name: (_r = def.zod2x) === null || _r === void 0 ? void 0 : _r.typeName,
-                left: this.zodToAST(def.left),
-                right: this.zodToAST(def.right),
+                name,
+                left: this._zodToAST(def.left),
+                right: this._zodToAST(def.right),
                 description: schema.description,
             };
+            if (def.left._def.typeName !== "ZodObject" || def.right._def.typeName !== "ZodObject") {
+                this.warnings.push("Intersection of non-object is a bad data modeling practice, " +
+                    "and could lead to unexpected results.");
+            }
+            else {
+                item.newObject = {
+                    type: zod_1.ZodFirstPartyTypeKind.ZodObject,
+                    name,
+                    properties: this._intersectAstNodes(item.left, item.right).properties,
+                    description: (schema.description ? `${schema.description} - ` : "") +
+                        `Built from intersection of ` +
+                        `${item.left.reference} and ` +
+                        `${item.right.reference}`,
+                };
+            }
             if (name && !this.nodes.has(name)) {
                 this.nodes.set(name, item);
                 return this._createDefinition(name, def.typeName);
             }
             return item;
         }
-        else
-            throw new Error(`Unsupported Zod type: ${schema}`);
+        else {
+            logger_1.log.warn(`Unsupported Zod type: ${JSON.stringify(schema)}`);
+            return {
+                type: zod_1.ZodFirstPartyTypeKind.ZodAny,
+                description: `Unsupported Zod type: ${schema._def.typeName}`,
+            };
+        }
     }
     build(schema) {
-        this.zodToAST(schema);
+        this._zodToAST(schema);
         while (this.lazyPointers.length > 0) {
             const [pointer, schema] = this.lazyPointers.shift();
-            const lazyResolve = this.zodToAST(schema);
+            const lazyResolve = this._zodToAST(schema);
             Object.keys(pointer).forEach((key) => {
                 delete pointer[key];
             });
@@ -229,9 +335,13 @@ class Zod2Ast {
                 pointer[key] = value;
             });
         }
+        if (this.opt.strict !== false && this.warnings.length > 0) {
+            throw new errors_1.AstNodeError(this.warnings.join("\n"));
+        }
         return {
             nodes: [...this.nodes.values()],
             discriminatorNodes: [...this.discriminatorNodes.values()],
+            warnings: this.warnings,
         };
     }
 }

package/dist/core/ast_types.d.ts

@@ -1,4 +1,10 @@
 import { ZodFirstPartyTypeKind } from "zod";
+export type ASTCommon = {
+    arrayDimension?: number;
+    description?: string;
+    isNullable?: boolean;
+    isOptional?: boolean;
+};
 export type ASTLiteral = {
     type: ZodFirstPartyTypeKind.ZodLiteral;
     value: any;
@@ -50,6 +56,7 @@ export type ASTUnion = {
     type: ZodFirstPartyTypeKind.ZodUnion;
     name: string;
     options: ASTNode[];
+    newObject?: ASTCommon & ASTObject;
 };
 export type ASTDiscriminatedUnion = {
     type: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
@@ -62,12 +69,7 @@ export type ASTIntersection = {
     name: string;
     left: ASTNode;
     right: ASTNode;
-};
-export type ASTCommon = {
-    arrayDimension?: number;
-    description?: string;
-    isNullable?: boolean;
-    isOptional?: boolean;
+    newObject?: ASTCommon & ASTObject;
 };
 export type ASTDefintion = ASTCommon & {
     type: "definition";
@@ -91,4 +93,5 @@ export type TranspilerableTypes = ASTCommon & (ASTEnum | ASTNativeEnum | ASTObje
 export type ASTNodes = {
     nodes: TranspilerableTypes[];
     discriminatorNodes: TranspilerableTypes[];
+    warnings: string[];
 };

package/dist/core/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class AstTypeNameDefinitionError extends Error {
+    constructor(message: string);
+}
+export declare class AstNodeError extends Error {
+    constructor(message: string);
+}
+export declare class NotTranspilerableTypeError extends Error {
+    constructor(message: string);
+}

package/dist/core/errors.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotTranspilerableTypeError = exports.AstNodeError = exports.AstTypeNameDefinitionError = void 0;
+class AstTypeNameDefinitionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TypeNameDefinitionError";
+    }
+}
+exports.AstTypeNameDefinitionError = AstTypeNameDefinitionError;
+class AstNodeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AstNodeError";
+    }
+}
+exports.AstNodeError = AstNodeError;
+class NotTranspilerableTypeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NotTranspilerableTypeError";
+    }
+}
+exports.NotTranspilerableTypeError = NotTranspilerableTypeError;

package/dist/core/index.d.ts

@@ -1,3 +1,4 @@
 export { Zod2Ast } from "./ast_node";
 export * from "./ast_types";
 export { Zod2X, IZodToXOpt } from "./transpiler";
+export * from "./errors";

package/dist/core/index.js

@@ -20,3 +20,4 @@ Object.defineProperty(exports, "Zod2Ast", { enumerable: true, get: function () {
 __exportStar(require("./ast_types"), exports);
 var transpiler_1 = require("./transpiler");
 Object.defineProperty(exports, "Zod2X", { enumerable: true, get: function () { return transpiler_1.Zod2X; } });
+__exportStar(require("./errors"), exports);

package/dist/core/transpiler.d.ts

@@ -6,16 +6,12 @@ export interface IZodToXOpt extends Record<string, any> {
     includeComments?: boolean;
     skipDiscriminatorNodes?: boolean;
 }
-interface IInternalOpts {
-    enableCompositeTypes: boolean;
-}
 export declare abstract class Zod2X<T extends IZodToXOpt> {
     protected output: string[];
     protected indent: TIndentationLevels;
     protected imports: Set<string>;
     protected opt: Partial<T>;
-    private inOpt;
-    protected constructor(inOpt: IInternalOpts, opt: Partial<T>);
+    protected constructor(opt: Partial<T>);
     protected abstract runBefore(): void;
     protected abstract runAfter(): void;
     protected abstract getComment(data: string, indent?: string): string;
@@ -39,15 +35,13 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
     protected abstract transpileStruct(data: ASTObject & ASTCommon): void;
     protected abstract transpileUnion(data: (ASTUnion | ASTDiscriminatedUnion) & ASTCommon): void;
     protected abstract transpileIntersection(data: ASTIntersection & ASTCommon): void;
-    protected isTranspilerable(token: TranspilerableTypes): boolean | "";
+    protected isTranspilerable(token: TranspilerableTypes): token is (ASTCommon & ASTUnion) | (ASTCommon & ASTDiscriminatedUnion) | (ASTCommon & ASTIntersection) | (ASTCommon & ASTObject) | (ASTCommon & ASTEnum) | (ASTCommon & ASTNativeEnum);
     protected push0: (data: string) => number;
     protected push1: (data: string) => number;
     protected push2: (data: string) => number;
     protected push3: (data: string) => number;
     protected addComment(data?: string, indent?: string): void;
-    private _checkCompositeFlag;
     protected getAttributeType(token: ASTNode | TranspilerableTypes): string;
     private _transpileItem;
     transpile(transpilerQueue: ASTNodes): string;
 }
-export {};

package/dist/core/transpiler.js

@@ -7,7 +7,7 @@ exports.Zod2X = void 0;
 const zod_1 = require("zod");
 const string_utils_1 = __importDefault(require("../utils/string_utils"));
 class Zod2X {
-    constructor(inOpt, opt) {
+    constructor(opt) {
         this.push0 = (data) => this.output.push(`${this.indent[0]}${data}`);
         this.push1 = (data) => this.output.push(`${this.indent[1]}${data}`);
         this.push2 = (data) => this.output.push(`${this.indent[2]}${data}`);
@@ -16,28 +16,20 @@ class Zod2X {
         this.imports = new Set();
         this.indent = string_utils_1.default.getIndentationLevels(opt.indent || 4);
         this.opt = opt;
-        this.inOpt = inOpt;
     }
     isTranspilerable(token) {
         return (token.type === zod_1.ZodFirstPartyTypeKind.ZodEnum ||
             token.type === zod_1.ZodFirstPartyTypeKind.ZodNativeEnum ||
             token.type === zod_1.ZodFirstPartyTypeKind.ZodObject ||
-            (token.name &&
-                (token.type === zod_1.ZodFirstPartyTypeKind.ZodUnion ||
-                    token.type === zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion ||
-                    token.type === zod_1.ZodFirstPartyTypeKind.ZodIntersection)));
+            token.type === zod_1.ZodFirstPartyTypeKind.ZodUnion ||
+            token.type === zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion ||
+            token.type === zod_1.ZodFirstPartyTypeKind.ZodIntersection);
     }
     addComment(data = "", indent = "") {
         if (data && this.opt.includeComments) {
             this.output.push(this.getComment(data, indent));
         }
     }
-    _checkCompositeFlag() {
-        if (!this.inOpt.enableCompositeTypes) {
-            throw new Error(`Composite Types cannot be performed for this output Language. ` +
-                `Add the missing 'typeName' to transpilerable schemas`);
-        }
-    }
     getAttributeType(token) {
         let varType = "";
         if (this.isTranspilerable(token)) {
@@ -87,19 +79,6 @@ class Zod2X {
                 varType = this.getRecordType(key, value);
             }
         }
-        else if (!token.name &&
-            token.type === zod_1.ZodFirstPartyTypeKind.ZodIntersection) {
-            this._checkCompositeFlag();
-            const items = [token.left, token.right].map(this.getAttributeType.bind(this));
-            varType = this.getIntersectionType(items);
-        }
-        else if (!token.name &&
-            (token.type === zod_1.ZodFirstPartyTypeKind.ZodUnion ||
-                token.type === zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion)) {
-            this._checkCompositeFlag();
-            const items = token.options.map(this.getAttributeType.bind(this));
-            varType = this.getUnionType(items);
-        }
         else {
             console.log("  # Unknown attribute equivalent for ---> ", token.type);
         }

package/dist/lib/zod_ext.d.ts

@@ -19,7 +19,7 @@ declare module "zod" {
         zod2x(this: ZodNativeEnum<T>, typeName: string): this;
         zod2x(this: ZodNativeEnum<T>, opt: Pick<Zod2xMetadata, "typeName">): this;
     }
-    interface ZodDiscriminatedUnion<Discriminator extends string, Options extends z.ZodDiscriminatedUnionOption<Discriminator>[]> {
+    interface ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly z.ZodDiscriminatedUnionOption<Discriminator>[]> {
         zod2x(this: ZodDiscriminatedUnion<Discriminator, Options>, typeName: string): this;
         zod2x(this: ZodDiscriminatedUnion<Discriminator, Options>, opt: Pick<Zod2xMetadata, "typeName">): this;
     }
@@ -36,4 +36,4 @@ declare module "zod" {
         zod2x(this: ZodLiteral<T>, opt: Pick<Zod2xMetadata, "parentEnum">): this;
     }
 }
-export declare function extendZod(zod: typeof z): void;
+export declare function extendZod(zod: any): void;

package/dist/transpilers/cpp/runner.js

@@ -13,9 +13,7 @@ const nlohmann_1 = require("./nlohmann");
 const options_1 = require("./options");
 class Zod2Cpp extends core_1.Zod2X {
     constructor(opt = {}) {
-        super({
-            enableCompositeTypes: false,
-        }, Object.assign(Object.assign({}, options_1.defaultOpts), opt));
+        super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
         this.getIntersectionType = () => {
             return "";
         };
@@ -144,7 +142,7 @@ class Zod2Cpp extends core_1.Zod2X {
             data.left.referenceType === zod_1.ZodFirstPartyTypeKind.ZodObject &&
             data.right.type === "definition" &&
             data.right.referenceType === zod_1.ZodFirstPartyTypeKind.ZodObject)) {
-            throw new Error(`${data.name}: only intersection of ZodObjects is supported.`);
+            throw new core_1.NotTranspilerableTypeError(`${data.name}: only intersection of ZodObjects is supported.`);
         }
         const leftType = this.getAttributeType(data.left);
         const rightType = this.getAttributeType(data.right);

package/dist/transpilers/protobuf_v3/options.d.ts

@@ -0,0 +1,6 @@
+import { IZodToXOpt } from "../../core";
+export interface IZod2ProtoV3Opt extends Omit<IZodToXOpt, "skipDiscriminatorNodes"> {
+    packageName?: string;
+    useCamelCase?: boolean;
+}
+export declare const defaultOpts: IZod2ProtoV3Opt;

package/dist/transpilers/protobuf_v3/options.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOpts = void 0;
+exports.defaultOpts = {
+    includeComments: true,
+    indent: 4,
+    useCamelCase: false,
+    skipDiscriminatorNodes: true,
+};

package/dist/transpilers/protobuf_v3/runner.d.ts

@@ -1,8 +1,5 @@
-import { ASTCommon, ASTDiscriminatedUnion, ASTEnum, ASTIntersection, ASTNativeEnum, ASTObject, ASTUnion, IZodToXOpt, Zod2X } from "../../core";
-interface IZod2ProtoV3Opt extends Omit<IZodToXOpt, "skipDiscriminatorNodes"> {
-    packageName?: string;
-    useCamelCase?: boolean;
-}
+import { ASTCommon, ASTDiscriminatedUnion, ASTEnum, ASTIntersection, ASTNativeEnum, ASTObject, ASTUnion, Zod2X } from "../../core";
+import { IZod2ProtoV3Opt } from "./options";
 export declare class Zod2ProtoV3 extends Zod2X<IZod2ProtoV3Opt> {
     constructor(opt?: IZod2ProtoV3Opt);
     protected getUnionType: () => string;
@@ -30,4 +27,3 @@ export declare class Zod2ProtoV3 extends Zod2X<IZod2ProtoV3Opt> {
     protected runAfter(): void;
     private _adaptField;
 }
-export {};

package/dist/transpilers/protobuf_v3/runner.js

@@ -7,6 +7,7 @@ exports.Zod2ProtoV3 = void 0;
 const case_1 = __importDefault(require("case"));
 const core_1 = require("../../core");
 const number_limits_1 = require("../../utils/number_limits");
+const options_1 = require("./options");
 const allowedKeyTypes = [
     "int32",
     "int64",
@@ -21,17 +22,9 @@ const allowedKeyTypes = [
     "bool",
     "string",
 ];
-const defaultOpts = {
-    includeComments: true,
-    indent: 4,
-    useCamelCase: false,
-    skipDiscriminatorNodes: true,
-};
 class Zod2ProtoV3 extends core_1.Zod2X {
     constructor(opt = {}) {
-        super({
-            enableCompositeTypes: true,
-        }, Object.assign(Object.assign({}, defaultOpts), opt));
+        super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
         this.getUnionType = () => {
             return "";
         };
@@ -76,11 +69,11 @@ class Zod2ProtoV3 extends core_1.Zod2X {
                 return this.getArrayType(itemsType[0], 1);
             }
             else {
-                throw new Error("Protobuf v3 does not support mixed-type tuples. Consider defining a message type.");
+                throw new core_1.NotTranspilerableTypeError("Protobuf v3 does not support mixed-type tuples. Consider defining a message type.");
             }
         };
         this.getIntersectionType = (itemsType) => {
-            throw new Error("Protobuf v3 does not support intersection types directly.");
+            throw new core_1.NotTranspilerableTypeError("Protobuf v3 does not support intersection types directly.");
         };
     }
     getArrayType(arrayType, arrayDeep) {
@@ -88,7 +81,7 @@ class Zod2ProtoV3 extends core_1.Zod2X {
             return `repeated ${arrayType}`;
         }
         else {
-            throw new Error("Protobuf v3 does not support multidimensional arrays directly. " +
+            throw new core_1.NotTranspilerableTypeError("Protobuf v3 does not support multidimensional arrays directly. " +
                 "You need to define nested message types for deeper arrays");
         }
     }
@@ -100,12 +93,12 @@ class Zod2ProtoV3 extends core_1.Zod2X {
             return this.getNumberType(Number.isInteger(value), { min: value, max: value });
         }
         else {
-            throw new Error(`Protobuf v3 does not support Literals for this value type: ${value}`);
+            throw new core_1.NotTranspilerableTypeError(`Protobuf v3 does not support Literals for this value type: ${value}`);
         }
     }
     getMapType(keyType, valueType) {
         if (!allowedKeyTypes.includes(keyType)) {
-            throw new Error(`Protobuf map keys must be an integral or string type, got '${keyType}'.`);
+            throw new core_1.NotTranspilerableTypeError(`Protobuf map keys must be an integral or string type, got '${keyType}'.`);
         }
         return `map<${keyType}, ${valueType}>`;
     }
@@ -117,14 +110,14 @@ class Zod2ProtoV3 extends core_1.Zod2X {
         this.push0(`enum ${data.name} {`);
         data.values.forEach(([key, value], index) => {
             if (Number.isInteger(key.at(0))) {
-                throw new Error(`Enumerate item name cannot start with number: ${key}`);
+                throw new core_1.NotTranspilerableTypeError(`Enumerate item name cannot start with number: ${key}`);
             }
             this.push1(`${key} = ${index};`);
         });
         this.push0("}\n");
     }
     transpileIntersection(data) {
-        throw new Error(`Protobuf does not support message intersections.`);
+        throw new core_1.NotTranspilerableTypeError(`Protobuf does not support message intersections.`);
     }
     transpileStruct(data) {
         this.addComment(data.description);
@@ -141,7 +134,7 @@ class Zod2ProtoV3 extends core_1.Zod2X {
         this.addComment(data.description);
         const attributesTypes = data.options.map(this.getAttributeType.bind(this));
         if (attributesTypes.find((i) => i.startsWith("map<") || i.startsWith("repeated "))) {
-            throw new Error("Map and Repeated fields are not suported by Protobuf oneOf");
+            throw new core_1.NotTranspilerableTypeError("Map and Repeated fields are not suported by Protobuf oneOf");
         }
         this.push0(`message ${data.name} {`);
         this.push1(`oneof ${this._adaptField(data.name + "Oneof")} {`);

package/dist/transpilers/typescript/options.d.ts

@@ -0,0 +1,5 @@
+import { IZodToXOpt } from "../../core";
+export interface IZod2TsOpt extends IZodToXOpt {
+    outType?: "interface" | "class";
+}
+export declare const defaultOpts: IZod2TsOpt;

package/dist/transpilers/typescript/options.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOpts = void 0;
+exports.defaultOpts = {
+    includeComments: true,
+    indent: 4,
+    skipDiscriminatorNodes: false,
+    outType: "interface",
+};

package/dist/transpilers/typescript/runner.d.ts

@@ -1,7 +1,5 @@
-import { ASTCommon, ASTDiscriminatedUnion, ASTEnum, ASTIntersection, ASTNativeEnum, ASTObject, ASTUnion, IZodToXOpt, Zod2X } from "../../core";
-interface IZod2TsOpt extends IZodToXOpt {
-    outType?: "interface" | "class";
-}
+import { ASTCommon, ASTDiscriminatedUnion, ASTEnum, ASTIntersection, ASTNativeEnum, ASTObject, ASTUnion, Zod2X } from "../../core";
+import { IZod2TsOpt } from "./options";
 export declare class Zod2Ts extends Zod2X<IZod2TsOpt> {
     constructor(opt?: IZod2TsOpt);
     protected runAfter(): void;
@@ -28,4 +26,3 @@ export declare class Zod2Ts extends Zod2X<IZod2TsOpt> {
     private _transpileStructAsClass;
     private _transpileMember;
 }
-export {};

package/dist/transpilers/typescript/runner.js

@@ -6,17 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Zod2Ts = void 0;
 const case_1 = __importDefault(require("case"));
 const core_1 = require("../../core");
-const defaultOpts = {
-    includeComments: true,
-    indent: 4,
-    skipDiscriminatorNodes: false,
-    outType: "interface",
-};
+const options_1 = require("./options");
 class Zod2Ts extends core_1.Zod2X {
     constructor(opt = {}) {
-        super({
-            enableCompositeTypes: true,
-        }, Object.assign(Object.assign({}, defaultOpts), opt));
+        super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
         this.getComment = (data, indent = "") => `${indent}// ${data}`;
         this.getAnyType = () => "any";
         this.getBooleanType = () => "boolean";
@@ -41,7 +34,7 @@ class Zod2Ts extends core_1.Zod2X {
     }
     getLiteralStringType(value, parentEnumNameKey) {
         return parentEnumNameKey
-            ? `${parentEnumNameKey[0]}.${parentEnumNameKey[1]}`
+            ? `${parentEnumNameKey[0]}.${case_1.default.pascal(parentEnumNameKey[1])}`
             : isNaN(Number(value))
                 ? `"${value}"`
                 : value;
@@ -56,16 +49,24 @@ class Zod2Ts extends core_1.Zod2X {
         this.addComment(data.description);
         this.push0(`export enum ${data.name} {`);
         data.values.forEach((i) => {
-            const keyValue = isNaN(Number(i[0].at(0))) ? i[0] : `"${i[0]}"`;
+            const key = case_1.default.pascal(i[0]);
+            const keyValue = isNaN(Number(key.at(0))) ? key : `"${key}"`;
             const enumValue = typeof i[1] === "string" ? `"${i[1]}"` : `${i[1]}`;
             this.push1(`${keyValue} = ${enumValue},`);
         });
         this.push0("}\n");
     }
     transpileIntersection(data) {
-        this.addComment(data.description);
-        const attributesTypes = [data.left, data.right].map(this.getAttributeType.bind(this));
-        this.push0(`export type ${data.name} = ${this.getIntersectionType(attributesTypes)};\n`);
+        var _a;
+        if (this.opt.outType === "class" && data.newObject) {
+            this.addComment((_a = data.newObject) === null || _a === void 0 ? void 0 : _a.description);
+            this._transpileStructAsClass(data.newObject);
+        }
+        else {
+            this.addComment(data.description);
+            const attributesTypes = [data.left, data.right].map(this.getAttributeType.bind(this));
+            this.push0(`export type ${data.name} = ${this.getIntersectionType(attributesTypes)};\n`);
+        }
     }
     transpileStruct(data) {
         this.addComment(data.description);
@@ -77,9 +78,16 @@ class Zod2Ts extends core_1.Zod2X {
         }
     }
     transpileUnion(data) {
-        this.addComment(data.description);
-        const attributesTypes = data.options.map(this.getAttributeType.bind(this));
-        this.push0(`export type ${data.name} = ${this.getUnionType(attributesTypes)};\n`);
+        var _a;
+        if (this.opt.outType === "class" && data.newObject) {
+            this.addComment((_a = data.newObject) === null || _a === void 0 ? void 0 : _a.description);
+            this._transpileStructAsClass(data.newObject);
+        }
+        else {
+            this.addComment(data.description);
+            const attributesTypes = data.options.map(this.getAttributeType.bind(this));
+            this.push0(`export type ${data.name} = ${this.getUnionType(attributesTypes)};\n`);
+        }
     }
     _transpileStructuAsInterface(data) {
         this.push0(`export interface ${data.name} {`);

package/dist/utils/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const log: {
+    info: (...args: any) => void;
+    error: (...args: any) => void;
+    warn: (...args: any) => void;
+    debug: (...args: any) => void;
+    trace: (...args: any) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+const DEBUG = false;
+function execute(fn) {
+    if (DEBUG) {
+        fn();
+    }
+}
+exports.log = {
+    info: (...args) => execute(() => console.log(args)),
+    error: (...args) => execute(() => console.error(args)),
+    warn: (...args) => execute(() => console.warn(args)),
+    debug: (...args) => execute(() => console.debug(args)),
+    trace: (...args) => execute(() => console.trace(args)),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [
@@ -40,9 +40,11 @@
   "lint-staged": {
     "*.ts": "prettier --write"
   },
+  "peerDependencies": {
+    "zod": ">=3.22.3"
+  },
   "dependencies": {
-    "case": "1.6.3",
-    "zod": "^3.23.8"
+    "case": "1.6.3"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",