zod-to-x 1.4.1 → 1.4.2

package/README.md

@@ -71,7 +71,7 @@ This extension appends a `zod2x` method to:
 ## Quick start
 ```ts
 import { z } from "zod";
-import { extendZod, Zod2Ast, Zod2Ts } from "zod-to-x";
+import { extendZod, Zod2Ast, Zod2XTranspilers } from "zod-to-x";
 extendZod(z); // The extend step can be skipped if it has already been done.
 
 /**
@@ -94,7 +94,7 @@ const visitorNodes = new Zod2Ast().build(VisitorSchema);
  * 3) Generate types in the desired language.
  *    Depending on the transpiled language, data models can be generated using classes.
  */
-const tsVisitorAsInterface: string = new Zod2Ts().transpile(visitorNodes);
+const tsVisitorAsInterface: string = new Zod2XTranspilers.Zod2Ts().transpile(visitorNodes);
 console.log(tsVisitorAsInterface)
 // output:
 // export interface Visitor {
@@ -105,7 +105,7 @@ console.log(tsVisitorAsInterface)
 //     comments?: string;
 // }
 
-const tsVisitorAsClass: string = new Zod2Ts({outType: "class"}).transpile(visitorNodes);
+const tsVisitorAsClass: string = new Zod2XTranspilers.Zod2Ts({outType: "class"}).transpile(visitorNodes);
 console.log(tsVisitorAsClass)
 // output:
 // export class Visitor {
@@ -255,9 +255,12 @@ inline void from_json(const json& j, Message& x) {
 ## Layered modeling
 To improve Separation of Concerns (SoC), the Dependency Rule, and Maintainability, a new layer-based modeling approach was introduced in `v1.4.0`. This approach establishes relationships between models in separate files, which are transpiled into file imports. This feature provides a powerful tool not only for type systems with robust architectures, such as Clean, Hexagonal, or Layered, but also enforces their usage.
 
-To achieve this, two new components are included:
+To achieve this, new components are included:
 - **Zod2XModel**: With layered modeling, data is defined using classes. Inheriting this abstract class provides metadata management to handle relationships and also simplifies transpilation by including a `transpile()` method that receives the target language class.
-- **Layer**: A class decorator that defines class metadata, including a reference to the output file of the modeled data, a namespace under which its types are grouped, and an integer index representing the layer number. It can also be used as a decorator factory to define custom layers. Out of the box, four layers are provided: *Domain*, *Application*, *Infrastructure*, and *Presentation*.
+- **Layer**: A class decorator that defines class metadata, including a reference to the output file of the modeled data, a namespace under which its types are grouped, and an integer index representing the layer number. It can also be used as a decorator factory to define custom layers. Out of the box, four layers are provided: *Domain*, *Application*, *Infrastructure*, and *Presentation*. Parameters:  
+  - **namespace**: Defines the namespace under which the types are grouped.
+  - **file**: Specifies the expected output file where the transpiled types will be saved.
+  - **externalInheritance**: When a type from one layer is imported into another layer without modifications, it is transpiled as a new type inheriting from the imported type. This ensures type consistency across layers while maintaining reusability. See example (4) below. The default value is `true`.
 - **Zod2XMixin**: A function that enables the creation of layers by extending multiple data models, thereby simplifying their definition and organization.
 
 ### Usage example
@@ -319,7 +322,7 @@ class UserDtos extends Zod2XModel {
 }
 
 const userDtos = new UserDtos();
-console.log(userDtos.transpile(Transpilers.Zod2Ts))
+console.log(userDtos.transpile(Zod2XTranspilers.Zod2Ts))
 // Output:
 // import * as USER from "./user.entity";    <--- Reusing models from other layers.
 
@@ -375,7 +378,7 @@ class UserDtos extends Zod2XMixin(
 ) {}
 
 export const userDtos = new UserDtos();
-console.log(userDtos.transpile(Transpilers.Zod2Ts))
+console.log(userDtos.transpile(Zod2XTranspilers.Zod2Ts))
 // Output (same as above):
 // import * as USER from "./user.entity";    <--- Reusing models from other layers.
 
@@ -401,6 +404,67 @@ console.log(userDtos.transpile(Transpilers.Zod2Ts))
 // }
 ```
 
+4 - Difference of using **externalInheritance** (defaults) or not.  
+```ts
+// Default output (externalInheritance = true)
+@Application({ namespace: "USER_DTOS", file: "user.dtos" })
+class UserDtos extends Zod2XModel {
+
+    createUserUseCaseDto = userModels.userEntity.omit({ id: true });
+
+    createUserUseCaseResultDto = userModels.userEntity;
+}
+
+// Output:
+// import * as USER from "./user.entity";
+
+// export interface CreateUserUseCaseDto {
+//     name: string;
+//     email: string;
+//     age?: number;
+//     role: USER.UserRole;
+// }
+
+// export interface CreateUserUseCaseResultDto extends USER.UserEntity {}
+
+// export interface UserDtos {
+//     createUserUseCaseDto: CreateUserUseCaseDto;
+//     createUserUseCaseResultDto: CreateUserUseCaseResultDto;
+// }
+
+// ---------------
+// If `USER.UserEntity` were a Union or a Discriminated Union, the output would be a Type equivalent to `USER.UserEntity` rather than an Interface that extends it.  
+
+```
+
+```ts
+// Output without externalInheritance
+@Application({ namespace: "USER_DTOS", file: "user.dtos",  externalInheritance: false})
+class UserDtos extends Zod2XModel {
+
+    createUserUseCaseDto = userModels.userEntity.omit({ id: true });
+
+    createUserUseCaseResultDto = userModels.userEntity;
+}
+
+// Output:
+// import * as USER from "./user.entity";
+
+// export interface CreateUserUseCaseDto {
+//     name: string;
+//     email: string;
+//     age?: number;
+//     role: USER.UserRole;
+// }
+
+// export interface UserDtos {
+//     createUserUseCaseDto: CreateUserUseCaseDto;
+//     createUserUseCaseResultDto: USER.UserEntity;
+// }
+
+// ---------------
+// In this case, the type of `createUserUseCaseResultDto` is inferred from the parent model (`UserDtos`), but there is no explicit definition of the type itself.
+```
 
 
 ## Supported output languages
@@ -408,7 +472,6 @@ Common options:
 - **header**: Text to add as a comment at the beginning of the output.
 - **indent**: Number of spaces to use for indentation in the generated code. Defaults to 4 if not specified.
 - **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:

package/dist/core/ast_node.d.ts

@@ -23,14 +23,6 @@ export declare class Zod2Ast {
      * Transpilerable nodes of current data model
      */
     private nodes;
-    /**
-     * Transpilerable nodes of external data models (used for layered modeling)
-     */
-    private externalNodes;
-    /**
-     * Additional transpilerable nodes supplied by ZodDiscriminatedUnion
-     */
-    private discriminatorNodes;
     /**
      * Lazy schemas for further analysis
      */
@@ -87,7 +79,6 @@ export declare class Zod2Ast {
      */
     private _unionAstNodes;
     private _getNames;
-    private _getNode;
     private _getEnumAst;
     private _getObjectAst;
     private _getUnionAst;

package/dist/core/ast_node.js

@@ -13,8 +13,6 @@ class Zod2Ast {
     constructor(opt = {}) {
         var _a;
         this.nodes = new Map();
-        this.externalNodes = new Map();
-        this.discriminatorNodes = new Map();
         this.lazyPointers = [];
         this.warnings = [];
         this.opt = Object.assign(Object.assign({}, opt), { strict: (_a = opt.strict) !== null && _a !== void 0 ? _a : true });
@@ -27,14 +25,20 @@ class Zod2Ast {
      * @param layerMetadata
      * @returns
      */
-    _getTranspilerableFile(itemName, layerMetadata) {
-        if (this.opt.layer && layerMetadata) {
-            if (this.opt.layer.index < layerMetadata.index) {
+    _getTranspilerableFile(itemName, metadata) {
+        var _a;
+        const layer = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.parentLayer) !== null && _a !== void 0 ? _a : metadata === null || metadata === void 0 ? void 0 : metadata.layer;
+        if (this.opt.layer && layer) {
+            if (this.opt.layer.index < layer.index) {
                 throw new errors_1.BadLayerDefinitionError(`${itemName}: Layer with number ${this.opt.layer.index} can only use models` +
-                    `from the same or lower layer. Found layer with number ${layerMetadata.index}`);
+                    `from the same or lower layer. Found layer with number ${layer.index}`);
             }
-            if (this.opt.layer.file !== layerMetadata.file) {
-                return { parentFile: layerMetadata.file, parentNamespace: layerMetadata.namespace };
+            if (this.opt.layer.file !== layer.file) {
+                return {
+                    parentFile: layer.file,
+                    parentNamespace: layer.namespace,
+                    parentTypeName: metadata === null || metadata === void 0 ? void 0 : metadata.parentTypeName,
+                };
             }
         }
         return {};
@@ -144,63 +148,51 @@ class Zod2Ast {
         };
     }
     _getNames(schema, errorString) {
-        var _a, _b;
+        var _a;
         const name = (_a = schema._zod2x) === null || _a === void 0 ? void 0 : _a.typeName;
         if (!name) {
             throw new errors_1.AstTypeNameDefinitionError(errorString);
         }
-        return Object.assign({ name, typeName: schema._def.typeName }, this._getTranspilerableFile(name, (_b = schema._zod2x) === null || _b === void 0 ? void 0 : _b.layer));
-    }
-    _getNode(fileName) {
-        return fileName ? this.externalNodes : this.nodes;
+        return Object.assign({ name, zodTypeName: schema._def.typeName }, this._getTranspilerableFile(name, schema._zod2x));
     }
     _getEnumAst(schema, opt) {
-        const { name, typeName, parentFile, parentNamespace } = this._getNames(schema, "ZodEnum/ZodNativeEnum type must have a typeName. Use zod2x method to provide one.");
+        const { name, zodTypeName, parentFile, parentNamespace, parentTypeName } = this._getNames(schema, "ZodEnum/ZodNativeEnum type must have a typeName. Use zod2x method to provide one.");
         const item = {
-            type: typeName,
+            type: zodTypeName,
             name,
             values: this._getEnumValues(schema),
             description: schema._def.description,
             parentFile,
             parentNamespace,
+            parentTypeName,
+            isFromDiscriminatedUnion: opt === null || opt === void 0 ? void 0 : opt.isInjectedEnum,
         };
-        const node = this._getNode(parentFile);
-        if (opt === null || opt === void 0 ? void 0 : opt.isInjectedEnum) {
-            if (!node.has(name) && !this.discriminatorNodes.has(name)) {
-                this.discriminatorNodes.set(name, item);
-            }
-        }
-        else {
-            if (!node.has(name)) {
-                node.set(name, item);
-            }
-            if (this.discriminatorNodes.has(name)) {
-                this.discriminatorNodes.delete(name);
-            }
+        if (!this.nodes.has(name)) {
+            this.nodes.set(name, item);
         }
-        return this._createDefinition(name, typeName, undefined, parentNamespace);
+        return this._createDefinition(name, zodTypeName, undefined, parentNamespace);
     }
     _getObjectAst(schema, opt) {
-        const { name, typeName, parentFile, parentNamespace } = this._getNames(schema, "ZodObject type must have a typeName. Use zod2x method to provide one.");
+        const { name, zodTypeName, parentFile, parentNamespace, parentTypeName } = this._getNames(schema, "ZodObject type must have a typeName. Use zod2x method to provide one.");
         let discriminantValue = undefined;
         const shape = schema._def.shape();
-        const node = this._getNode(parentFile);
-        if (!node.has(name)) {
+        if (!this.nodes.has(name)) {
             const properties = {};
             for (const key in shape) {
                 properties[key] = this._zodToAST(shape[key]);
             }
-            node.set(name, {
+            this.nodes.set(name, {
                 type: zod_1.ZodFirstPartyTypeKind.ZodObject,
                 name,
                 properties,
                 description: schema.description,
                 parentFile,
                 parentNamespace,
+                parentTypeName,
             });
         }
         if (opt === null || opt === void 0 ? void 0 : opt.discriminantKey) {
-            const item = node.get(name);
+            const item = this.nodes.get(name);
             if (Object.keys(item.properties).includes(opt.discriminantKey)) {
                 const key = opt.discriminantKey;
                 if (item.properties[key].type === zod_1.ZodFirstPartyTypeKind.ZodLiteral) {
@@ -213,22 +205,22 @@ class Zod2Ast {
                 }
             }
         }
-        return this._createDefinition(name, typeName, discriminantValue, parentNamespace);
+        return this._createDefinition(name, zodTypeName, discriminantValue, parentTypeName ? undefined : parentNamespace);
     }
     _getUnionAst(schema) {
         const def = schema._def;
         const discriminator = schema instanceof zod_1.ZodDiscriminatedUnion ? schema._def.discriminator : undefined;
-        const { name, typeName, parentFile, parentNamespace } = this._getNames(schema, "ZodUnion/ZodDiscriminatedUnion type must have a typeName. " +
+        const { name, zodTypeName, parentFile, parentNamespace, parentTypeName } = this._getNames(schema, "ZodUnion/ZodDiscriminatedUnion type must have a typeName. " +
             "Use zod2x method to provide one.");
-        const node = this._getNode(parentFile);
         const item = {
-            type: typeName,
+            type: zodTypeName,
             name,
             options: def.options.map((i) => this._zodToAST(i, { discriminantKey: discriminator })),
             description: schema.description,
             discriminantKey: discriminator,
             parentFile,
             parentNamespace,
+            parentTypeName,
         };
         if (!def.options.every((i) => i instanceof zod_1.ZodObject)) {
             this.warnings.push("Union of non-object types is a bad data modeling practice, " +
@@ -246,15 +238,14 @@ class Zod2Ast {
                     `${item.options.map((i) => i.reference).join(", ")}`,
             };
         }
-        if (name && !node.has(name)) {
-            node.set(name, item);
+        if (name && !this.nodes.has(name)) {
+            this.nodes.set(name, item);
         }
-        return this._createDefinition(name, typeName, undefined, parentNamespace);
+        return this._createDefinition(name, zodTypeName, undefined, parentTypeName ? undefined : parentNamespace);
     }
     _getIntersectionAst(schema) {
         const def = schema._def;
-        const { name, typeName, parentFile, parentNamespace } = this._getNames(schema, "ZodIntersection type must have a typeName. Use zod2x method to provide one.");
-        const node = this._getNode(parentFile);
+        const { name, zodTypeName, parentFile, parentNamespace, parentTypeName } = this._getNames(schema, "ZodIntersection type must have a typeName. Use zod2x method to provide one.");
         const item = {
             type: zod_1.ZodFirstPartyTypeKind.ZodIntersection,
             name,
@@ -263,6 +254,7 @@ class Zod2Ast {
             description: schema.description,
             parentFile,
             parentNamespace,
+            parentTypeName,
         };
         if (def.left._def.typeName !== "ZodObject" || def.right._def.typeName !== "ZodObject") {
             this.warnings.push("Intersection of non-object is a bad data modeling practice, " +
@@ -279,10 +271,10 @@ class Zod2Ast {
                     `${item.right.reference}`,
             };
         }
-        if (name && !node.has(name)) {
-            node.set(name, item);
+        if (name && !this.nodes.has(name)) {
+            this.nodes.set(name, item);
         }
-        return this._createDefinition(name, typeName, undefined, parentNamespace);
+        return this._createDefinition(name, zodTypeName, undefined, parentTypeName ? undefined : parentNamespace);
     }
     /**
      * Build the AST node of provided Zod Schema
@@ -450,8 +442,6 @@ class Zod2Ast {
         }
         return {
             nodes: this.nodes,
-            externalNodes: this.externalNodes,
-            discriminatorNodes: this.discriminatorNodes,
             warnings: this.warnings,
         };
     }

package/dist/core/ast_types.d.ts

@@ -8,6 +8,19 @@ export type ASTCommon = {
     isNullable?: boolean;
     isOptional?: boolean;
 };
+export type ASTLayerMetadata = {
+    /**
+     * File where the transpilerable model is defined and the reference used to group imports.
+     * Used to generate import statements in the transpiled code.
+     */
+    parentFile?: string;
+    parentNamespace?: string;
+    /**
+     * For Layered Modeling.
+     * Stores the used type from an external model. Used to create models inheritance.
+     */
+    parentTypeName?: string;
+};
 /**
  * AST (Abstract Syntax Tree) type for each Zod Schema that encapsulates
  * additional information beyond just the schema type.
@@ -48,17 +61,25 @@ export type ASTEnum = {
     type: ZodFirstPartyTypeKind.ZodEnum;
     name: string;
     values: [string, string | number][];
-};
+    /**
+     * The enum is injected using zod2x method during ZodDiscriminatedUnion creation.
+     */
+    isFromDiscriminatedUnion?: boolean;
+} & ASTLayerMetadata;
 export type ASTNativeEnum = {
     type: ZodFirstPartyTypeKind.ZodNativeEnum;
     name: string;
     values: [string, string | number][];
-};
+    /**
+     * The enum is injected using zod2x method during ZodDiscriminatedUnion creation.
+     */
+    isFromDiscriminatedUnion?: boolean;
+} & ASTLayerMetadata;
 export type ASTObject = {
     type: ZodFirstPartyTypeKind.ZodObject;
     name: string;
     properties: Record<string, ASTNode>;
-};
+} & ASTLayerMetadata;
 export type ASTUnion = {
     type: ZodFirstPartyTypeKind.ZodUnion;
     name: string;
@@ -68,13 +89,13 @@ export type ASTUnion = {
      * have a variant type or discriminated union cannot be used.
      */
     newObject?: ASTCommon & ASTObject;
-};
+} & ASTLayerMetadata;
 export type ASTDiscriminatedUnion = {
     type: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
     name: string;
     options: ASTNode[];
     discriminantKey?: string;
-};
+} & ASTLayerMetadata;
 export type ASTIntersection = {
     type: ZodFirstPartyTypeKind.ZodIntersection;
     name: string;
@@ -85,7 +106,7 @@ export type ASTIntersection = {
      * support multiple inheritance.
      */
     newObject?: ASTCommon & ASTObject;
-};
+} & ASTLayerMetadata;
 /**
  * Represents a type definition in the AST. Used to reduce node size and identify
  * schemas that can be referenced in a transpilation process.
@@ -119,17 +140,8 @@ export type ASTNode = ASTCommon & ({
 /**
  * Represents schemas that can be directly transpiled into types in other programming languages.
  */
-export type TranspilerableTypes = ASTCommon & (ASTEnum | ASTNativeEnum | ASTObject | ASTUnion | ASTDiscriminatedUnion | ASTIntersection) & {
-    /**
-     * File where the transpilerable model is defined and the reference used to group imports.
-     * Used to generate import statements in the transpiled code.
-     */
-    parentFile?: string;
-    parentNamespace?: string;
-};
+export type TranspilerableTypes = ASTCommon & (ASTEnum | ASTNativeEnum | ASTObject | ASTUnion | ASTDiscriminatedUnion | ASTIntersection);
 export type ASTNodes = {
     nodes: Map<string, TranspilerableTypes>;
-    externalNodes: Map<string, TranspilerableTypes>;
-    discriminatorNodes: Map<string, TranspilerableTypes>;
     warnings: string[];
 };

package/dist/core/transpiler.d.ts

@@ -19,13 +19,6 @@ export interface IZodToXOpt extends Record<string, any> {
      * Defaults to `true`.
      */
     includeComments?: boolean;
-    /**
-     * When set to `true`, this option excludes discriminator enums from the output types.
-     * Specifically, it prevents the inclusion of `ZodEnum` or `ZodNativeEnum` schemas that are used
-     * solely as discriminator keys in a `ZodDiscriminatedUnion`. This helps avoid adding
-     * enum types to the generated output when unnecessary.
-     */
-    skipDiscriminatorNodes?: boolean;
     /**
      * Every external type will be imported from the file where it is defined. Default: true
      */
@@ -39,7 +32,9 @@ export interface IZodToXOpt extends Record<string, any> {
 export declare abstract class Zod2X<T extends IZodToXOpt> {
     protected output: string[];
     protected indent: TIndentationLevels;
+    protected preImports: Set<string>;
     protected imports: Set<string>;
+    protected postImports: Set<string>;
     protected opt: Partial<T>;
     protected constructor(opt: Partial<T>);
     /**
@@ -60,6 +55,15 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @param typeName
      */
     protected abstract getTypeFromExternalNamespace(namespace: string, typeName: string): string;
+    /**
+     * For Layered Modeling.
+     * If a property type is an imported type, without any modification, the transpiled type will be
+     * an inherited type from the imported type.
+     * @param name
+     * @param parentNamespace
+     * @param parentTypeName
+     */
+    protected abstract addExtendedType(name: string, parentNamespace: string, parentTypeName: string): void;
     /**
      * Returns a comment.
      */
@@ -183,13 +187,30 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @returns A string representing the type in the target language.
      */
     protected getAttributeType(token: ASTNode | TranspilerableTypes): string;
+    /**
+     * Adds an external type import to the transpiler's imports if the provided transpiled item
+     * is located into another file and namespace, and if the `useImports` option is not disabled.
+     *
+     * @param item - An object of type `TranspilerableTypes` containing information
+     *                  about the type to be imported, including its parent file and namespace.
+     * @returns `true` if the import was successfully added, otherwise `false`.
+     */
+    protected addExternalTypeImport(item: TranspilerableTypes): boolean;
     /**
      * Transpiles a single item from the transpiler queue.
      * @param item - The transpilerable type to transpile.
      */
     private _transpileItem;
-    private _getTranspilerableNodes;
-    private _getImports;
+    /**
+     * Constructs and returns an array of strings representing the header section
+     * of the transpiled output. The header may include custom comments, pre-imports,
+     * imports, and post-imports, depending on the provided options and internal state.
+     *
+     * Each section is separated by an empty string for readability.
+     *
+     * @returns An array of strings representing the header section.
+     *
+     */
     private _getHeader;
     /**
      * Transpiles a queue of AST nodes into the target language.

package/dist/core/transpiler.js

@@ -20,7 +20,9 @@ class Zod2X {
         this.push2 = (data) => this.output.push(`${this.indent[2]}${data}`);
         this.push3 = (data) => this.output.push(`${this.indent[3]}${data}`);
         this.output = [];
+        this.preImports = new Set();
         this.imports = new Set();
+        this.postImports = new Set();
         this.indent = string_utils_1.default.getIndentationLevels(opt.indent || 4);
         this.opt = opt;
     }
@@ -104,6 +106,21 @@ class Zod2X {
         }
         return token.arrayDimension ? this.getArrayType(varType, token.arrayDimension) : varType;
     }
+    /**
+     * Adds an external type import to the transpiler's imports if the provided transpiled item
+     * is located into another file and namespace, and if the `useImports` option is not disabled.
+     *
+     * @param item - An object of type `TranspilerableTypes` containing information
+     *                  about the type to be imported, including its parent file and namespace.
+     * @returns `true` if the import was successfully added, otherwise `false`.
+     */
+    addExternalTypeImport(item) {
+        if (item.parentFile && item.parentNamespace && this.opt.useImports !== false) {
+            this.imports.add(this.addImportFromFile(item.parentFile, item.parentNamespace));
+            return true;
+        }
+        return false;
+    }
     /**
      * Transpiles a single item from the transpiler queue.
      * @param item - The transpilerable type to transpile.
@@ -127,35 +144,33 @@ class Zod2X {
             throw new Error(`Unexpected type for transpilation: ${item.type}`);
         }
     }
-    _getTranspilerableNodes(transpilerQueue) {
-        return new Map([
-            ...(this.opt.useImports === false ? transpilerQueue.externalNodes : []),
-            ...(this.opt.skipDiscriminatorNodes !== true ? transpilerQueue.discriminatorNodes : []),
-            ...transpilerQueue.nodes,
-        ]);
-    }
-    _getImports(externalNodes) {
-        const importData = new Map();
-        externalNodes.forEach((i) => {
-            if (i.parentFile && i.parentNamespace && !importData.has(i.parentFile)) {
-                importData.set(i.parentFile, i.parentNamespace);
-            }
-        });
-        importData.forEach((namespace, file) => {
-            this.imports.add(this.addImportFromFile(file, namespace));
-        });
-    }
+    /**
+     * Constructs and returns an array of strings representing the header section
+     * of the transpiled output. The header may include custom comments, pre-imports,
+     * imports, and post-imports, depending on the provided options and internal state.
+     *
+     * Each section is separated by an empty string for readability.
+     *
+     * @returns An array of strings representing the header section.
+     *
+     */
     _getHeader() {
-        var _a;
         const header = [];
         if (this.opt.header) {
             header.push(...this.opt.header.split("\n").map((i) => this.getComment(i)));
+            header.push("");
+        }
+        if (this.preImports.size > 0) {
+            header.push(...this.preImports);
+            header.push("");
         }
         if (this.imports.size > 0) {
-            header.push(...this.imports);
-            if (!((_a = header.at(-1)) === null || _a === void 0 ? void 0 : _a.endsWith("\n"))) {
-                header.push("");
-            }
+            header.push(...[...this.imports].sort());
+            header.push("");
+        }
+        if (this.postImports.size > 0) {
+            header.push(...this.postImports);
+            header.push("");
         }
         return header;
     }
@@ -166,11 +181,8 @@ class Zod2X {
      */
     transpile(transpilerQueue) {
         this.runBefore();
-        this._getTranspilerableNodes(transpilerQueue).forEach(this._transpileItem.bind(this));
+        transpilerQueue.nodes.forEach(this._transpileItem.bind(this));
         this.runAfter();
-        if (this.opt.useImports === true) {
-            this._getImports(transpilerQueue.externalNodes);
-        }
         this.output = [...this._getHeader(), ...this.output];
         return this.output.join("\n");
     }

package/dist/core/zod_helpers.d.ts

@@ -1 +1,8 @@
+import { ZodDiscriminatedUnion, ZodIntersection, ZodObject, ZodTypeAny, ZodUnion } from "zod";
 export declare function isTranspilerableZodType(zodType: string): boolean;
+export declare function isTranspiledExtendable(zodType: string): boolean;
+export declare function cloneTranspiledExtendable(zodItem: ZodTypeAny): ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodObject<any, any, any, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;

package/dist/core/zod_helpers.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTranspilerableZodType = isTranspilerableZodType;
+exports.isTranspiledExtendable = isTranspiledExtendable;
+exports.cloneTranspiledExtendable = cloneTranspiledExtendable;
 const zod_1 = require("zod");
 function isTranspilerableZodType(zodType) {
     return (zodType === zod_1.ZodFirstPartyTypeKind.ZodEnum ||
@@ -10,3 +12,26 @@ function isTranspilerableZodType(zodType) {
         zodType === zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion ||
         zodType === zod_1.ZodFirstPartyTypeKind.ZodIntersection);
 }
+function isTranspiledExtendable(zodType) {
+    return (zodType === zod_1.ZodFirstPartyTypeKind.ZodObject ||
+        zodType === zod_1.ZodFirstPartyTypeKind.ZodUnion ||
+        zodType === zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion ||
+        zodType === zod_1.ZodFirstPartyTypeKind.ZodIntersection);
+}
+function cloneTranspiledExtendable(zodItem) {
+    if (zodItem instanceof zod_1.ZodObject) {
+        return new zod_1.ZodObject(Object.assign({}, zodItem._def));
+    }
+    else if (zodItem instanceof zod_1.ZodUnion) {
+        return new zod_1.ZodUnion(Object.assign({}, zodItem._def));
+    }
+    else if (zodItem instanceof zod_1.ZodDiscriminatedUnion) {
+        return new zod_1.ZodDiscriminatedUnion(Object.assign({}, zodItem._def));
+    }
+    else if (zodItem instanceof zod_1.ZodIntersection) {
+        return new zod_1.ZodIntersection(Object.assign({}, zodItem._def));
+    }
+    else {
+        throw new Error(`This type cannot be extended when transpiled: ${zodItem}`);
+    }
+}

package/dist/layered-modeling/layer.d.ts

@@ -55,7 +55,7 @@ export declare function Layer(opt: IZod2xLayerMetadata): <T extends {
  *
  * @returns The configured Domain layer.
  */
-export declare function Domain(opt: Pick<IZod2xLayerMetadata, "file" | "namespace">): <T extends {
+export declare function Domain(opt: Omit<IZod2xLayerMetadata, "index">): <T extends {
     new (...args: any[]): {};
 }>(constructor: T) => {
     new (...args: any[]): {
@@ -76,7 +76,7 @@ export declare function Domain(opt: Pick<IZod2xLayerMetadata, "file" | "namespac
  * @returns The result of invoking the `Layer` function with the provided options and
  *          the `APPLICATION` layer index.
  */
-export declare function Application(opt: Pick<IZod2xLayerMetadata, "file" | "namespace">): <T extends {
+export declare function Application(opt: Omit<IZod2xLayerMetadata, "index">): <T extends {
     new (...args: any[]): {};
 }>(constructor: T) => {
     new (...args: any[]): {
@@ -97,7 +97,7 @@ export declare function Application(opt: Pick<IZod2xLayerMetadata, "file" | "nam
  *
  * @returns A configured Infrastructure layer.
  */
-export declare function Infrastructure(opt: Pick<IZod2xLayerMetadata, "file" | "namespace">): <T extends {
+export declare function Infrastructure(opt: Omit<IZod2xLayerMetadata, "index">): <T extends {
     new (...args: any[]): {};
 }>(constructor: T) => {
     new (...args: any[]): {
@@ -115,7 +115,7 @@ export declare function Infrastructure(opt: Pick<IZod2xLayerMetadata, "file" | "
  *   - `name`: The name of the layer.
  * @returns The configured Presentation layer.
  */
-export declare function Presentation(opt: Pick<IZod2xLayerMetadata, "file" | "namespace">): <T extends {
+export declare function Presentation(opt: Omit<IZod2xLayerMetadata, "index">): <T extends {
     new (...args: any[]): {};
 }>(constructor: T) => {
     new (...args: any[]): {

package/dist/layered-modeling/layer.js

@@ -81,17 +81,35 @@ function Layer(opt) {
                             zodItem["_zod2x"] = metadata;
                         }
                         else if (!metadata.typeName) {
+                            // Only possible if `zod2xExtendable` is used.
                             metadata.typeName = name;
                         }
                         if (metadata.layer === undefined) {
+                            // Metadata is set independently because typeName could already exist if
+                            // zod2x was used before.
                             metadata.layer = opt;
                         }
+                        if (opt.externalInheritance !== false &&
+                            (0, zod_helpers_1.isTranspiledExtendable)(zodItem._def.typeName)) {
+                            if (metadata.layer.file !== opt.file) {
+                                // Type used from another layer. A new type is created inheriting the
+                                // original type.
+                                zodItem = (0, zod_helpers_1.cloneTranspiledExtendable)(zodItem);
+                                zodItem._zod2x = {
+                                    parentLayer: metadata.layer,
+                                    parentTypeName: metadata.typeName,
+                                    layer: opt,
+                                    typeName: name,
+                                };
+                            }
+                        }
+                        return zodItem;
                     };
                     Object.getOwnPropertyNames(this).forEach((prop) => {
                         var _b, _c;
                         const zodType = (_c = (_b = this[prop]) === null || _b === void 0 ? void 0 : _b._def) === null || _c === void 0 ? void 0 : _c.typeName;
                         if ((0, zod_helpers_1.isTranspilerableZodType)(zodType)) {
-                            setMetadata(case_1.default.pascal(prop), this[prop], opt);
+                            this[prop] = setMetadata(case_1.default.pascal(prop), this[prop], opt);
                         }
                     });
                 }

package/dist/lib/zod_ext.d.ts

@@ -25,6 +25,35 @@ export interface IZod2xLayerMetadata {
      * from layer 3.
      */
     index: number;
+    /**
+     * Indicates if types inherited from other layers should be transpiled as extendable types and
+     * then used (true) or just used as imports (false).
+     *
+     * For example:
+     * // Definition
+     * class MyModels extends Zod2XModel {
+     *   myType: ExternalNamespace.OtherType
+     * }
+     *
+     * Case true:
+     *   // Output example for typescript:
+     *   import * as ExternalNamespace from "external_file";
+     *
+     *   interface MyType extends ExternalNamespace.OtherType {}
+     *
+     *   interface MyModels {
+     *     myType: MyType;
+     *   }
+     *
+     * Case false:
+     *   // Output example for typescript:
+     *   import * as ExternalNamespace from "external_file";
+     *
+     *   interface MyModels {
+     *     myType: ExternalNamespace.OtherType;
+     *   }
+     */
+    externalInheritance?: boolean;
 }
 export interface IZod2xMetadata {
     /**
@@ -36,7 +65,19 @@ export interface IZod2xMetadata {
      * ZodDiscriminatedUnion schemas.
      */
     parentEnum?: ZodEnum<any> | ZodNativeEnum<any>;
+    /**
+     * For Layered Modeling.
+     * The file where the schema is transpiled. Used to allow importing types from other files.
+     */
     layer?: IZod2xLayerMetadata;
+    /**
+     * For Layered Modeling.
+     * When a type of another file is used without modifying it, by default it is sustituted by
+     * the import without creating a new type. If wanted. it can be forced to create a new type
+     * which will be the extension of the original type if `zod2xExtendable` is used.
+     */
+    parentTypeName?: string;
+    parentLayer?: IZod2xLayerMetadata;
 }
 declare module "zod" {
     interface ZodType {

package/dist/transpilers/cpp/options.js

@@ -4,7 +4,6 @@ exports.defaultOpts = void 0;
 exports.defaultOpts = {
     includeComments: true,
     indent: 4,
-    skipDiscriminatorNodes: false,
     useImports: true,
     namespace: "zodtocpp",
     outType: "struct",

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

@@ -23,6 +23,7 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
     protected runBefore(): void;
     protected addImportFromFile(filename: string, _: string): string;
     protected getTypeFromExternalNamespace(namespace: string, typeName: string): string;
+    protected addExtendedType(name: string, parentNamespace: string, parentTypeName: string, isUnionOrDiscriminatedUnion?: boolean): void;
     protected runAfter(): void;
     protected getComment: (data: string, indent?: string) => string;
     protected getDateType: () => string;

package/dist/transpilers/cpp/runner.js

@@ -82,7 +82,6 @@ class Zod2Cpp extends core_1.Zod2X {
         this._push2 = (item, data) => item.push(`${this.indent[2]}${data}`);
         this._push3 = (item, data) => item.push(`${this.indent[3]}${data}`);
         this._push4 = (item, data) => item.push(`${this.indent[4]}${data}`);
-        this.imports.add("#pragma once\n");
         this.serializers = [];
         this.useBoost = true;
         this.lib = (0, libs_1.getLibs)(this.useBoost);
@@ -95,7 +94,23 @@ class Zod2Cpp extends core_1.Zod2X {
     getTypeFromExternalNamespace(namespace, typeName) {
         return `${namespace}::${typeName}`;
     }
+    addExtendedType(name, parentNamespace, parentTypeName, isUnionOrDiscriminatedUnion) {
+        const extendedType = this.getTypeFromExternalNamespace(parentNamespace, parentTypeName);
+        if (isUnionOrDiscriminatedUnion) {
+            this.push0(`using ${name} = ${extendedType};\n`);
+        }
+        else {
+            if (this.opt.outType === "class") {
+                this.push0(`class ${name} : public ${extendedType} {};\n`);
+            }
+            else {
+                this.push0(`struct ${name} : public ${extendedType} {};\n`);
+            }
+        }
+    }
     runAfter() {
+        this.preImports.add("#pragma once");
+        // Add the output inside the namespace
         this.output = this.output.map((i) => `${this.indent[1]}${i}`);
         this.output.unshift(`namespace ${this.opt.namespace} {`);
         this.output.push("}");
@@ -111,7 +126,7 @@ class Zod2Cpp extends core_1.Zod2X {
             this.output.push("}");
         }
         if (this.imports.has(this.lib.nlohmann)) {
-            this.imports.add(`\n${libs_1.USING.nlohmann}`);
+            this.postImports.add(`${libs_1.USING.nlohmann}`);
         }
     }
     /** Ex: std::vector<std::vector<TypeA>> */
@@ -151,6 +166,9 @@ class Zod2Cpp extends core_1.Zod2X {
      *  }
      */
     transpileEnum(data) {
+        if (this.addExternalTypeImport(data)) {
+            return;
+        }
         this.addComment(data.description);
         const serializeData = [];
         this.push0(`enum class ${data.name}: int {`);
@@ -178,6 +196,12 @@ class Zod2Cpp extends core_1.Zod2X {
      *  }
      */
     transpileIntersection(data) {
+        if (this.addExternalTypeImport(data)) {
+            if (data.parentTypeName) {
+                this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName);
+            }
+            return;
+        }
         console.warn(`${data.name}: use zod's merge instead of intersection whenever possible.`);
         console.warn(`${data.name}: no field name conflicts is assumed.`);
         this.addComment(data.description);
@@ -208,6 +232,12 @@ class Zod2Cpp extends core_1.Zod2X {
     }
     /** Ex: using TypeC = boost::variant<TypeA, TypeB> */
     transpileUnion(data) {
+        if (this.addExternalTypeImport(data)) {
+            if (data.parentTypeName) {
+                this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName, true);
+            }
+            return;
+        }
         this.addComment(data.description);
         const attributesData = data.options.map((i) => {
             return {
@@ -221,6 +251,12 @@ class Zod2Cpp extends core_1.Zod2X {
         this._createUnionDeserializer(data.name, attributesData, data.discriminantKey);
     }
     transpileStruct(data) {
+        if (this.addExternalTypeImport(data)) {
+            if (data.parentTypeName) {
+                this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName);
+            }
+            return;
+        }
         this.addComment(data.description);
         if (this.opt.outType === "class") {
             this._transpileStructAsClass(data);

package/dist/transpilers/protobuf_v3/options.js

@@ -5,6 +5,5 @@ exports.defaultOpts = {
     includeComments: true,
     indent: 4,
     useCamelCase: false,
-    skipDiscriminatorNodes: true, // Not required for protobuf files
     useImports: false, // Not required for protobuf files
 };

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

@@ -1,10 +1,15 @@
 import { ASTCommon, ASTDiscriminatedUnion, ASTEnum, ASTIntersection, ASTNativeEnum, ASTObject, ASTUnion, Zod2X } from "../../core";
 import { IZod2ProtoV3Opt } from "./options";
+/**
+ * @deprecated Zod2ProtoV3 will not be considered as a transpilerable programming language, but as
+ *             another utility such as `zod2JsonSchemaDefinitions`.
+ */
 export declare class Zod2ProtoV3 extends Zod2X<IZod2ProtoV3Opt> {
     constructor(opt?: IZod2ProtoV3Opt);
     protected getUnionType: () => string;
     protected addImportFromFile(filename: string, namespace: string): string;
     protected getTypeFromExternalNamespace(namespace: string, typeName: string): string;
+    protected addExtendedType(name: string, parentNamespace: string, parentTypeName: string): void;
     protected getComment: (data: string, indent?: string) => string;
     protected getBooleanType: () => string;
     protected getStringType: () => string;

package/dist/transpilers/protobuf_v3/runner.js

@@ -22,6 +22,10 @@ const allowedKeyTypes = [
     "bool",
     "string",
 ];
+/**
+ * @deprecated Zod2ProtoV3 will not be considered as a transpilerable programming language, but as
+ *             another utility such as `zod2JsonSchemaDefinitions`.
+ */
 class Zod2ProtoV3 extends core_1.Zod2X {
     constructor(opt = {}) {
         super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
@@ -100,6 +104,10 @@ class Zod2ProtoV3 extends core_1.Zod2X {
         // Zod2ProtoV3 does not support layered modeling.
         return "";
     }
+    addExtendedType(name, parentNamespace, parentTypeName) {
+        // Zod2ProtoV3 does not support layered modeling.
+        return;
+    }
     getArrayType(arrayType, arrayDeep) {
         if (arrayDeep === 1) {
             return `repeated ${arrayType}`;
@@ -130,6 +138,10 @@ class Zod2ProtoV3 extends core_1.Zod2X {
         return this.getMapType(keyType, valueType);
     }
     transpileEnum(data) {
+        if (data.isFromDiscriminatedUnion === true) {
+            // Injected enum from ZodDiscriminatedUnion are not transpiled.
+            return;
+        }
         this.addComment(data.description);
         this.push0(`enum ${data.name} {`);
         data.values.forEach(([key, value], index) => {
@@ -195,9 +207,9 @@ class Zod2ProtoV3 extends core_1.Zod2X {
     }
     runBefore() {
         var _a, _b;
-        this.imports.add(`syntax = "proto3";\n`);
+        this.preImports.add(`syntax = "proto3";`);
         if ((_a = this.opt) === null || _a === void 0 ? void 0 : _a.packageName) {
-            this.imports.add(`package ${(_b = this.opt) === null || _b === void 0 ? void 0 : _b.packageName};\n`);
+            this.preImports.add(`package ${(_b = this.opt) === null || _b === void 0 ? void 0 : _b.packageName};`);
         }
     }
     runAfter() { }

package/dist/transpilers/typescript/options.js

@@ -4,7 +4,6 @@ exports.defaultOpts = void 0;
 exports.defaultOpts = {
     includeComments: true,
     indent: 4,
-    skipDiscriminatorNodes: false,
     useImports: true,
     outType: "interface",
 };

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

@@ -6,6 +6,10 @@ export declare class Zod2Ts extends Zod2X<IZod2TsOpt> {
     protected runBefore(): void;
     protected addImportFromFile(filename: string, namespace: string): string;
     protected getTypeFromExternalNamespace(namespace: string, typeName: string): string;
+    protected addExtendedType(name: string, parentNamespace: string, parentTypeName: string, opt?: {
+        isUnion?: boolean;
+        isDiscriminatedUnion?: boolean;
+    }): void;
     protected getComment: (data: string, indent?: string) => string;
     protected getAnyType: () => string;
     protected getBooleanType: () => string;

package/dist/transpilers/typescript/runner.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Zod2Ts = void 0;
+const zod_1 = require("zod");
 const case_1 = __importDefault(require("case"));
 const core_1 = require("../../core");
 const options_1 = require("./options");
@@ -36,6 +37,28 @@ class Zod2Ts extends core_1.Zod2X {
     getTypeFromExternalNamespace(namespace, typeName) {
         return `${namespace}.${typeName}`;
     }
+    addExtendedType(name, parentNamespace, parentTypeName, opt) {
+        const extendedType = this.getTypeFromExternalNamespace(parentNamespace, parentTypeName);
+        if (this.opt.outType === "class") {
+            if (opt === null || opt === void 0 ? void 0 : opt.isDiscriminatedUnion) {
+                this.push0(`export type ${name} = ${extendedType};\n`);
+            }
+            else {
+                this.push0(`export class ${name} extends ${extendedType} {}\n`);
+            }
+        }
+        else {
+            if (opt === null || opt === void 0 ? void 0 : opt.isUnion) {
+                this.push0(`export type ${name} = ${extendedType};\n`);
+            }
+            else if (opt === null || opt === void 0 ? void 0 : opt.isDiscriminatedUnion) {
+                this.push0(`export type ${name} = ${extendedType};\n`);
+            }
+            else {
+                this.push0(`export interface ${name} extends ${extendedType} {}\n`);
+            }
+        }
+    }
     /** Ex: Array<Array<TypeA[]>> */
     getArrayType(arrayType, arrayDeep) {
         let output = arrayType.includes("|") || arrayType.includes("&")
@@ -68,6 +91,9 @@ class Zod2Ts extends core_1.Zod2X {
      *  }
      */
     transpileEnum(data) {
+        if (this.addExternalTypeImport(data)) {
+            return;
+        }
         this.addComment(data.description);
         this.push0(`export enum ${data.name} {`);
         data.values.forEach((i) => {
@@ -97,6 +123,12 @@ class Zod2Ts extends core_1.Zod2X {
      * */
     transpileIntersection(data) {
         var _a;
+        if (this.addExternalTypeImport(data)) {
+            if (data.parentTypeName) {
+                this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName);
+            }
+            return;
+        }
         if (this.opt.outType === "class" && data.newObject) {
             this.addComment((_a = data.newObject) === null || _a === void 0 ? void 0 : _a.description);
             this._transpileStructAsClass(data.newObject);
@@ -108,6 +140,12 @@ class Zod2Ts extends core_1.Zod2X {
         }
     }
     transpileStruct(data) {
+        if (this.addExternalTypeImport(data)) {
+            if (data.parentTypeName) {
+                this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName);
+            }
+            return;
+        }
         this.addComment(data.description);
         if (this.opt.outType === "class") {
             this._transpileStructAsClass(data);
@@ -133,6 +171,15 @@ class Zod2Ts extends core_1.Zod2X {
      * */
     transpileUnion(data) {
         var _a;
+        if (this.addExternalTypeImport(data)) {
+            if (data.parentTypeName) {
+                this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName, {
+                    isUnion: data.type === zod_1.ZodFirstPartyTypeKind.ZodUnion,
+                    isDiscriminatedUnion: data.type === zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
+                });
+            }
+            return;
+        }
         if (this.opt.outType === "class" && data.newObject) {
             this.addComment((_a = data.newObject) === null || _a === void 0 ? void 0 : _a.description);
             this._transpileStructAsClass(data.newObject);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [
@@ -8,6 +8,7 @@
   ],
   "scripts": {
     "build": "tsc && tsc-alias",
+    "build:debug": "tsc --project tsconfig.dev.json && tsc-alias",
     "format:check": "prettier --check .",
     "test": "jest",
     "test:cpp": "bash ./test/test_zod2cpp/test_cpp.sh",