zod-to-x 2.4.0 → 2.6.0

package/dist/core/ast_node.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Zod2Ast = void 0;
 const core_1 = require("../core");
+const zod2x_metadata_1 = require("../lib/zod2x_metadata");
 const zod_helpers_1 = require("../lib/zod_helpers");
 const logger_1 = require("../utils/logger");
 const errors_1 = require("./errors");
@@ -14,6 +15,7 @@ class Zod2Ast {
     constructor(opt = {}) {
         var _a;
         this.nodes = new Map();
+        this.nodeSchemas = new Map();
         this.lazyPointers = [];
         this.warnings = [];
         this.opt = Object.assign(Object.assign({}, opt), { strict: (_a = opt.strict) !== null && _a !== void 0 ? _a : true });
@@ -30,6 +32,77 @@ class Zod2Ast {
             parentFile === undefined ||
             ((_a = this.opt.layer) === null || _a === void 0 ? void 0 : _a.file) === parentFile);
     }
+    /**
+     * Returns the key used to store a transpilerable node. Types imported from other files are
+     * namespaced by their file, so they do not clash with local types that share the same name.
+     * Aliases of external types are local definitions.
+     */
+    _getNodeKey(item) {
+        return item.parentFile !== undefined && item.aliasOf === undefined
+            ? `${item.parentFile}::${item.name}`
+            : item.name;
+    }
+    /**
+     * Determines if two schemas that share the same type name represent the same definition.
+     * Schemas created from the same definition (`.zod2x()`, `.describe()`, `.meta()`, layer
+     * aliases) and instances of the same generic type are considered equal. Otherwise, a shallow
+     * structural comparison is performed.
+     */
+    _isSameDefinition(a, b) {
+        var _a, _b;
+        if (a === b || a.def === b.def) {
+            return true;
+        }
+        if (((_a = (0, zod2x_metadata_1.resolveZod2xMetadata)(a)) === null || _a === void 0 ? void 0 : _a.genericTypes) !== undefined ||
+            ((_b = (0, zod2x_metadata_1.resolveZod2xMetadata)(b)) === null || _b === void 0 ? void 0 : _b.genericTypes) !== undefined) {
+            return true;
+        }
+        if (a.def.type !== b.def.type) {
+            return false;
+        }
+        const sameSignatures = (x, y) => x.length === y.length &&
+            x.every((i, j) => zod_helpers_1.ZodHelpers.getShallowSignature(i) === zod_helpers_1.ZodHelpers.getShallowSignature(y[j]));
+        if (zod_helpers_1.ZodHelpers.isZodObject(a) && zod_helpers_1.ZodHelpers.isZodObject(b)) {
+            const keysA = Object.keys(a.def.shape);
+            const keysB = Object.keys(b.def.shape);
+            return (keysA.length === keysB.length &&
+                keysA.every((key) => key in b.def.shape) &&
+                sameSignatures(keysA.map((key) => a.def.shape[key]), keysA.map((key) => b.def.shape[key])));
+        }
+        else if (zod_helpers_1.ZodHelpers.isZodEnum(a) && zod_helpers_1.ZodHelpers.isZodEnum(b)) {
+            return JSON.stringify(a.enum) === JSON.stringify(b.enum);
+        }
+        else if (zod_helpers_1.ZodHelpers.isZodAnyUnionType(a) && zod_helpers_1.ZodHelpers.isZodAnyUnionType(b)) {
+            return sameSignatures(a.def.options, b.def.options);
+        }
+        else if (zod_helpers_1.ZodHelpers.isZodIntersection(a) && zod_helpers_1.ZodHelpers.isZodIntersection(b)) {
+            return sameSignatures([a.def.left, a.def.right], [b.def.left, b.def.right]);
+        }
+        else if (zod_helpers_1.ZodHelpers.isZodArray(a) && zod_helpers_1.ZodHelpers.isZodArray(b)) {
+            return sameSignatures([a.element], [b.element]);
+        }
+        return true;
+    }
+    /**
+     * Checks if a transpilerable node is already registered.
+     *
+     * @throws AstTypeNameDefinitionError - If the node key is used by a different schema.
+     */
+    _hasNode(key, schema) {
+        const registered = this.nodeSchemas.get(key);
+        if (registered === undefined) {
+            return false;
+        }
+        if (!this._isSameDefinition(registered, schema)) {
+            throw new errors_1.AstTypeNameDefinitionError(`Type name '${key}' is used by different schemas. Each transpilerable type ` +
+                `must have a unique name.`);
+        }
+        return true;
+    }
+    _setNode(key, schema, node) {
+        this.nodes.set(key, node);
+        this.nodeSchemas.set(key, schema);
+    }
     /**
      * Check if the layer of the item is compatible with the layer of the schema. If does and the
      * transpilerable item is in a different file, it returns the file name.
@@ -44,19 +117,24 @@ class Zod2Ast {
         if (this.opt.layer !== undefined && (metadata === null || metadata === void 0 ? void 0 : metadata.layer) !== undefined) {
             if (Array.isArray(metadata.genericTypes)) {
                 // Check that all templates used with a generic type follows the layering rules
-                if (metadata.genericTypes.some((i) => this.opt.layer.index < i.layer.index)) {
+                if (metadata.genericTypes.some((i) => i.layer !== undefined && this.opt.layer.index < i.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. Review templates used for generic ` +
                         `type ${metadata.typeName}.`);
                 }
             }
-            const templatesTranslation = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.genericTypes) === null || _a === void 0 ? void 0 : _a.map((i) => {
-                var _a, _b;
-                return ({
-                    parentFile: ((_a = this.opt.layer) === null || _a === void 0 ? void 0 : _a.file) !== i.layer.file ? i.layer.file : undefined,
-                    parentNamespace: ((_b = this.opt.layer) === null || _b === void 0 ? void 0 : _b.file) !== i.layer.file ? i.layer.namespace : undefined,
+            const templatesTranslation = (_a = metadata.genericTypes) === null || _a === void 0 ? void 0 : _a.map((i) => {
+                var _a;
+                if (i.typeName === undefined) {
+                    // Not named types (basic types, arrays, ...) are used directly.
+                    return { type: this._zodToAST(i.schema) };
+                }
+                const isExternal = i.layer !== undefined && ((_a = this.opt.layer) === null || _a === void 0 ? void 0 : _a.file) !== i.layer.file;
+                return {
+                    parentFile: isExternal ? i.layer.file : undefined,
+                    parentNamespace: isExternal ? i.layer.namespace : undefined,
                     aliasOf: i.typeName,
-                });
+                };
             });
             if (metadata.layer.file === this.opt.layer.file) {
                 // Case 1: Only layer exists and belongs to the same file
@@ -113,7 +191,7 @@ class Zod2Ast {
     _createDefinition(node, constraints = {}, templatesTranslation = []) {
         return new core_1.ASTDefinition({
             name: node.name,
-            instanceType: node.constructor.name,
+            instanceType: (0, core_1.getASTKind)(node),
             parentFile: node.parentFile,
             parentNamespace: node.parentNamespace,
             aliasOf: node.aliasOf,
@@ -183,13 +261,13 @@ class Zod2Ast {
      */
     _unionAstNodes(options) {
         let typeA, typeB;
-        const data = options.map((i) => this.nodes.get(i.name));
+        const data = options.map((i) => this.nodes.get(this._getNodeKey(i)));
         const properties = data.reduce((acc, i, j) => {
             for (const key in i.properties) {
                 if (acc[key]) {
                     acc[key] = Object.assign(Object.create(Object.getPrototypeOf(acc[key])), acc[key]);
-                    typeA = acc[key].constructor.name;
-                    typeB = i.properties[key].constructor.name;
+                    typeA = (0, core_1.getASTKind)(acc[key]);
+                    typeB = (0, core_1.getASTKind)(i.properties[key]);
                     if (typeA !== typeB) {
                         this.warnings.push(`Merging properties with different types: ${typeA} ` +
                             `(from a previous variant) and ${typeB} ` +
@@ -243,7 +321,7 @@ class Zod2Ast {
      */
     _getNames(schema) {
         var _a, _b, _c;
-        const name = (_a = schema._zod2x) === null || _a === void 0 ? void 0 : _a.typeName;
+        const name = (_a = (0, zod2x_metadata_1.resolveZod2xMetadata)(schema)) === null || _a === void 0 ? void 0 : _a.typeName;
         if (!name) {
             let itemProperties = ["Unknown type"];
             if (zod_helpers_1.ZodHelpers.isZodObject(schema)) {
@@ -252,15 +330,15 @@ class Zod2Ast {
             else if (zod_helpers_1.ZodHelpers.isZodAnyUnionType(schema)) {
                 itemProperties = schema.def.options.map((i) => {
                     var _a;
-                    return ((_a = i._zod2x) === null || _a === void 0 ? void 0 : _a.typeName) || i.def.type;
+                    return ((_a = (0, zod2x_metadata_1.resolveZod2xMetadata)(i)) === null || _a === void 0 ? void 0 : _a.typeName) || i.def.type;
                 });
             }
             else if (zod_helpers_1.ZodHelpers.isZodIntersection(schema)) {
                 const left = schema.def.left;
                 const right = schema.def.right;
                 itemProperties = [
-                    ((_b = left._zod2x) === null || _b === void 0 ? void 0 : _b.typeName) || left.def.type,
-                    ((_c = right._zod2x) === null || _c === void 0 ? void 0 : _c.typeName) || right.def.type,
+                    ((_b = (0, zod2x_metadata_1.resolveZod2xMetadata)(left)) === null || _b === void 0 ? void 0 : _b.typeName) || left.def.type,
+                    ((_c = (0, zod2x_metadata_1.resolveZod2xMetadata)(right)) === null || _c === void 0 ? void 0 : _c.typeName) || right.def.type,
                 ];
             }
             else if (zod_helpers_1.ZodHelpers.isZodEnum(schema)) {
@@ -270,7 +348,8 @@ class Zod2Ast {
                 `avoid nesting schemas definitions. Otherwise, use zod2x method to provide one. ` +
                 `Affected type properties: ${itemProperties.join(", ")}`);
         }
-        return Object.assign({ name }, this._getTranspilerableFile(name, schema._zod2x));
+        const metadata = (0, zod2x_metadata_1.resolveZod2xMetadata)(schema);
+        return Object.assign({ name, genericOf: metadata === null || metadata === void 0 ? void 0 : metadata.genericOf }, this._getTranspilerableFile(name, metadata));
     }
     /**
      * Generates an Abstract Syntax Tree (AST) definition for a Zod enum schema.
@@ -293,8 +372,9 @@ class Zod2Ast {
             aliasOf,
             isFromDiscriminatedUnion: opt === null || opt === void 0 ? void 0 : opt.isInjectedEnum,
         });
-        if (!this.nodes.has(name)) {
-            this.nodes.set(name, item);
+        const key = this._getNodeKey(item);
+        if (!this._hasNode(key, schema)) {
+            this._setNode(key, schema, item);
         }
         return this._createDefinition(item);
     }
@@ -309,10 +389,11 @@ class Zod2Ast {
      */
     _getObjectAst(schema, opt) {
         var _a;
-        const { name, parentFile, parentNamespace, aliasOf, templatesTranslation, isGenericChild } = this._getNames(schema);
+        const { name, parentFile, parentNamespace, aliasOf, templatesTranslation, isGenericChild, genericOf, } = this._getNames(schema);
         let discriminantValue = undefined;
         const shape = schema.def.shape;
-        if (!this.nodes.has(name)) {
+        const key = this._getNodeKey({ name, parentFile, aliasOf });
+        if (!this._hasNode(key, schema)) {
             const properties = {};
             const templates = new Set();
             for (const key in shape) {
@@ -332,7 +413,7 @@ class Zod2Ast {
             if (opt === null || opt === void 0 ? void 0 : opt.skipLayerClass) {
                 return {}; // Layer classes are not transpilerable
             }
-            this.nodes.set(name, new core_1.ASTObject({
+            this._setNode(key, schema, new core_1.ASTObject({
                 name,
                 properties,
                 description: (_a = schema.meta()) === null || _a === void 0 ? void 0 : _a.description,
@@ -341,9 +422,10 @@ class Zod2Ast {
                 aliasOf,
                 templates,
                 templatesTranslation: templatesTranslation || [],
+                genericOf,
             }));
         }
-        const item = this.nodes.get(name);
+        const item = this.nodes.get(key);
         if (opt === null || opt === void 0 ? void 0 : opt.discriminantKey) {
             if (Object.keys(item.properties).includes(opt.discriminantKey)) {
                 const key = opt.discriminantKey;
@@ -357,7 +439,7 @@ class Zod2Ast {
                 }
             }
         }
-        return this._createDefinition(this.nodes.get(name), { discriminantValue }, isGenericChild ? undefined : templatesTranslation);
+        return this._createDefinition(item, { discriminantValue }, isGenericChild ? undefined : templatesTranslation);
     }
     /**
      * Generates an Abstract Syntax Tree (AST) definition for a Zod union schema.
@@ -415,8 +497,9 @@ class Zod2Ast {
                 templatesTranslation: [],
             });
         }
-        if (name && !this.nodes.has(name)) {
-            this.nodes.set(name, item);
+        const key = this._getNodeKey(item);
+        if (!this._hasNode(key, schema)) {
+            this._setNode(key, schema, item);
         }
         return this._createDefinition(item);
     }
@@ -464,8 +547,9 @@ class Zod2Ast {
                 templatesTranslation: [],
             });
         }
-        if (name && !this.nodes.has(name)) {
-            this.nodes.set(name, item);
+        const key = this._getNodeKey(item);
+        if (!this._hasNode(key, schema)) {
+            this._setNode(key, schema, item);
         }
         return this._createDefinition(item);
     }
@@ -487,14 +571,16 @@ class Zod2Ast {
             parentNamespace,
             aliasOf,
         });
-        if (!this.nodes.has(name)) {
-            this.nodes.set(name, item);
+        const key = this._getNodeKey(item);
+        if (!this._hasNode(key, schema)) {
+            this._setNode(key, schema, item);
         }
         return this._createDefinition(item);
     }
     _getAliasAst(schema, item) {
         var _a;
-        if (((_a = schema._zod2x) === null || _a === void 0 ? void 0 : _a.typeName) === undefined || this.opt.skipBasicTypes === true) {
+        if (((_a = (0, zod2x_metadata_1.resolveZod2xMetadata)(schema)) === null || _a === void 0 ? void 0 : _a.typeName) === undefined ||
+            this.opt.skipBasicTypes === true) {
             return item;
         }
         const { name, parentFile, parentNamespace, aliasOf } = this._getNames(schema);
@@ -502,8 +588,9 @@ class Zod2Ast {
         item.parentFile = parentFile;
         item.parentNamespace = parentNamespace;
         item.aliasOf = aliasOf;
-        if (!this.nodes.has(name)) {
-            this.nodes.set(name, item);
+        const key = this._getNodeKey(item);
+        if (!this._hasNode(key, schema)) {
+            this._setNode(key, schema, item);
         }
         return this._createDefinition(item);
     }
@@ -513,7 +600,7 @@ class Zod2Ast {
      * @returns
      */
     _zodToAST(schema, opt) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
         if (zod_helpers_1.ZodHelpers.isZodString(schema)) {
             return this._getAliasAst(schema, new core_1.ASTString({ description: (_a = schema.meta()) === null || _a === void 0 ? void 0 : _a.description }));
         }
@@ -544,19 +631,33 @@ class Zod2Ast {
             subSchema.description = ((_g = schema.meta()) === null || _g === void 0 ? void 0 : _g.description) || subSchema.description;
             return subSchema;
         }
-        else if (zod_helpers_1.ZodHelpers.isZodDefault(schema)) {
-            const subSchema = this._zodToAST(schema.def.defaultValue());
+        else if (zod_helpers_1.ZodHelpers.isZodNonOptional(schema)) {
+            const subSchema = this._zodToAST(schema.def.innerType, opt);
+            subSchema.isOptional = false;
             subSchema.description = ((_h = schema.meta()) === null || _h === void 0 ? void 0 : _h.description) || subSchema.description;
             return subSchema;
         }
+        else if (zod_helpers_1.ZodHelpers.isZodTransparentWrapper(schema)) {
+            const subSchema = this._zodToAST(schema.def.innerType, opt);
+            subSchema.description = ((_j = schema.meta()) === null || _j === void 0 ? void 0 : _j.description) || subSchema.description;
+            return subSchema;
+        }
+        else if (zod_helpers_1.ZodHelpers.isZodPipe(schema)) {
+            const subSchema = this._zodToAST(zod_helpers_1.ZodHelpers.getPipeModelSchema(schema), opt);
+            subSchema.description = ((_k = schema.meta()) === null || _k === void 0 ? void 0 : _k.description) || subSchema.description;
+            return subSchema;
+        }
+        else if (zod_helpers_1.ZodHelpers.isZodUnknown(schema)) {
+            return new core_1.ASTAny({ description: (_l = schema.meta()) === null || _l === void 0 ? void 0 : _l.description });
+        }
         else if (zod_helpers_1.ZodHelpers.isZodArray(schema)) {
             const isParentArray = (opt === null || opt === void 0 ? void 0 : opt.calledFromArray) !== true;
             const subSchema = this._zodToAST(schema.element, { calledFromArray: true });
-            subSchema.description = ((_j = schema.meta()) === null || _j === void 0 ? void 0 : _j.description) || subSchema.description;
+            subSchema.description = ((_m = schema.meta()) === null || _m === void 0 ? void 0 : _m.description) || subSchema.description;
             subSchema.arrayDimension = Number.isInteger(subSchema.arrayDimension)
                 ? ++subSchema.arrayDimension
                 : 1;
-            if (isParentArray && ((_k = schema._zod2x) === null || _k === void 0 ? void 0 : _k.typeName)) {
+            if (isParentArray && ((_o = (0, zod2x_metadata_1.resolveZod2xMetadata)(schema)) === null || _o === void 0 ? void 0 : _o.typeName)) {
                 return this._getArrayAst(schema, subSchema);
             }
             else {
@@ -566,22 +667,22 @@ class Zod2Ast {
         else if (zod_helpers_1.ZodHelpers.isZodSet(schema)) {
             return this._getAliasAst(schema, new core_1.ASTSet({
                 value: this._zodToAST(schema.def.valueType),
-                description: (_l = schema.meta()) === null || _l === void 0 ? void 0 : _l.description,
+                description: (_p = schema.meta()) === null || _p === void 0 ? void 0 : _p.description,
             }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodLiteral(schema)) {
             let parentEnum = undefined;
             let parentEnumKey = undefined;
             // TODO: Support multiple values
-            if ((_m = schema._zod2x) === null || _m === void 0 ? void 0 : _m.parentEnum) {
-                parentEnumKey = (_p = this._getEnumValues((_o = schema._zod2x) === null || _o === void 0 ? void 0 : _o.parentEnum).find((i) => i[1] === schema.def.values.at(0))) === null || _p === void 0 ? void 0 : _p[0];
-                parentEnum = this._zodToAST((_q = schema._zod2x) === null || _q === void 0 ? void 0 : _q.parentEnum, {
+            if ((_q = (0, zod2x_metadata_1.resolveZod2xMetadata)(schema)) === null || _q === void 0 ? void 0 : _q.parentEnum) {
+                parentEnumKey = (_s = this._getEnumValues((_r = (0, zod2x_metadata_1.resolveZod2xMetadata)(schema)) === null || _r === void 0 ? void 0 : _r.parentEnum).find((i) => i[1] === schema.def.values.at(0))) === null || _s === void 0 ? void 0 : _s[0];
+                parentEnum = this._zodToAST((_t = (0, zod2x_metadata_1.resolveZod2xMetadata)(schema)) === null || _t === void 0 ? void 0 : _t.parentEnum, {
                     isInjectedEnum: true,
                 });
             }
             return new core_1.ASTLiteral({
                 value: schema.def.values.at(0), // TODO: Support multiple values
-                description: (_r = schema.meta()) === null || _r === void 0 ? void 0 : _r.description,
+                description: (_u = schema.meta()) === null || _u === void 0 ? void 0 : _u.description,
                 parentEnum: parentEnum,
                 parentEnumKey,
             });
@@ -591,21 +692,29 @@ class Zod2Ast {
                 type: zod_helpers_1.ZodHelpers.isZodRecord(schema) ? "record" : "map",
                 key: this._zodToAST(schema.keyType),
                 value: this._zodToAST(schema.valueType),
-                description: (_s = schema.meta()) === null || _s === void 0 ? void 0 : _s.description,
+                description: (_v = schema.meta()) === null || _v === void 0 ? void 0 : _v.description,
             }));
         }
         else if (zod_helpers_1.ZodHelpers.isZodLazy(schema)) {
             /** Lazy items use to be recursive schemas of its own, so the are trated as another
              *  definition */
-            const lazySchema = schema.def.getter();
+            let lazySchema = schema;
+            while (zod_helpers_1.ZodHelpers.isZodLazy(lazySchema)) {
+                // innerType is cached by Zod, so the getter is evaluated only once per instance.
+                lazySchema = lazySchema._zod.innerType;
+            }
             const lazyPointer = this._createDefinition({ name: "pending" });
-            this.lazyPointers.push([lazyPointer, lazySchema]);
+            this.lazyPointers.push([
+                lazyPointer,
+                lazySchema,
+                (opt === null || opt === void 0 ? void 0 : opt.discriminantKey) ? { discriminantKey: opt.discriminantKey } : undefined,
+            ]);
             return lazyPointer;
         }
         else if (zod_helpers_1.ZodHelpers.isZodTuple(schema)) {
             return this._getAliasAst(schema, new core_1.ASTTuple({
                 items: schema.def.items.map(this._zodToAST.bind(this)),
-                description: (_t = schema.meta()) === null || _t === void 0 ? void 0 : _t.description,
+                description: (_w = schema.meta()) === null || _w === void 0 ? void 0 : _w.description,
             }));
             /**
              *
@@ -628,7 +737,9 @@ class Zod2Ast {
             return this._getIntersectionAst(schema);
         }
         else {
-            logger_1.log.warn(`Unsupported Zod type: ${JSON.stringify(schema)}`);
+            logger_1.log.warn(`Unsupported Zod type: ${schema.def.type}`);
+            this.warnings.push(`Unsupported Zod type '${schema.def.type}' is transpiled as an any type. Avoid ` +
+                "it, or disable strict mode if not possible.");
             return new core_1.ASTAny({
                 description: `Unsupported Zod type: ${schema.def.type}`,
             });
@@ -640,20 +751,29 @@ class Zod2Ast {
      * @returns Transpilerable nodes.
      */
     build(schema) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this._zodToAST(schema, {
             skipLayerClass: ((_a = this.opt) === null || _a === void 0 ? void 0 : _a.layer) !== undefined && ((_c = (_b = this.opt) === null || _b === void 0 ? void 0 : _b.layer) === null || _c === void 0 ? void 0 : _c.skipLayerInterface) !== false,
         });
         while (this.lazyPointers.length > 0) {
-            const [pointer, schema] = this.lazyPointers.shift();
-            const lazyResolve = this._zodToAST(schema);
+            const [pointer, schema, opt] = this.lazyPointers.shift();
+            const lazyResolve = this._zodToAST(schema, opt);
+            // Modifiers applied by wrappers of the lazy schema (optional, nullable, array, ...)
+            // were set on the pointer and shall be kept.
+            const { arrayDimension, isOptional, isNullable, description } = pointer;
             /** Pointer to the pending AST node is updated with the lazy resolve */
             Object.keys(pointer).forEach((key) => {
                 delete pointer[key];
             });
-            Object.entries(lazyResolve).forEach(([key, value]) => {
-                pointer[key] = value;
-            });
+            Object.setPrototypeOf(pointer, Object.getPrototypeOf(lazyResolve));
+            Object.assign(pointer, lazyResolve);
+            const resolved = pointer;
+            if (arrayDimension) {
+                resolved.arrayDimension = ((_d = resolved.arrayDimension) !== null && _d !== void 0 ? _d : 0) + arrayDimension;
+            }
+            resolved.isOptional = isOptional !== null && isOptional !== void 0 ? isOptional : resolved.isOptional;
+            resolved.isNullable = isNullable !== null && isNullable !== void 0 ? isNullable : resolved.isNullable;
+            resolved.description = description || resolved.description;
         }
         if (this.opt.strict !== false && this.warnings.length > 0) {
             throw new errors_1.AstNodeError(this.warnings.join("\n"));

package/dist/core/transpiler.d.ts

@@ -1,4 +1,4 @@
-import { ASTAliasedTypes, ASTEnum, ASTIntersection, ASTNode, ASTNodes, ASTObject, ASTType, ASTUnion } from "../core";
+import { ASTAliasedTypes, ASTDefinition, ASTEnum, ASTIntersection, ASTNode, ASTNodes, ASTObject, ASTType, ASTUnion } from "../core";
 import { TIndentationLevels } from "../utils/string_utils";
 /**
  * Optional user settings
@@ -24,6 +24,10 @@ export interface IZodToXOpt extends Record<string, any> {
      */
     useImports?: boolean;
 }
+/**
+ * For Layered Modeling. Kind of type that extends another one.
+ */
+export type TExtendedTypeKind = "alias" | "union" | "d-union";
 /**
  * Abstract base class for transpiling Zod schemas into other programming languages.
  * Extend this class and implement the abstract methods to define how each Zod type
@@ -56,10 +60,14 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @param typeName
      */
     protected abstract getTypeFromExternalNamespace(namespace: string, typeName: string): string;
+    /**
+     * Opening and closing brackets of generic templates in the target language.
+     */
+    protected readonly genericTemplatesBrackets: [string, string];
     /**
      * Returns the translation of generic templates for a given AST node.
      */
-    protected abstract getGenericTemplatesTranslation(data: ASTNode): string | undefined;
+    protected getGenericTemplatesTranslation(data: ASTNode | ASTDefinition): string | undefined;
     /**
      * For Layered Modeling.
      * If a property type is an imported type, without any modification, the transpiled type will be
@@ -68,7 +76,26 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @param parentNamespace
      * @param aliasOf
      */
-    protected abstract addExtendedType(name: string, parentNamespace: string, aliasOf: string): void;
+    protected abstract addExtendedType(name: string, parentNamespace: string, aliasOf: string, opt?: {
+        isInternal?: boolean;
+    }): void;
+    /**
+     * For Layered Modeling.
+     * Returns the language specific options used by `addExtendedType` to declare a type that
+     * extends another one.
+     * @param data - The AST node of the type.
+     * @param type - Kind of the type.
+     */
+    protected getExtendedTypeOptions(data: ASTNode, type?: TExtendedTypeKind): object;
+    /**
+     * For Layered Modeling.
+     * Emits the declaration of a type that extends another layered type, if the node is an alias.
+     * @param data - The AST node to transpile.
+     * @param type - Kind of the type.
+     * @returns `true` if the node shall not be transpiled as a new type: it is an alias, or a
+     *          type imported from another file.
+     */
+    protected checkExtendedTypeInclusion(data: ASTNode, type?: TExtendedTypeKind): boolean;
     /**
      * Returns the keyword representing a string type in the target language.
      */
@@ -210,7 +237,7 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      *               properties of the type to evaluate.
      * @returns `true` if the type is an external type import; otherwise, `false`.
      */
-    protected isExternalTypeImport(item: ASTNode): boolean;
+    protected isExternalTypeImport(item: Pick<ASTNode, "parentFile" | "parentNamespace">): boolean;
     /**
      * 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.
@@ -219,7 +246,7 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      *                  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: ASTNode): boolean;
+    protected addExternalTypeImport(item: Pick<ASTNode, "parentFile" | "parentNamespace">): boolean;
     /**
      * Transpiles a single item from the transpiler queue.
      * @param item - The transpilerable type to transpile.

package/dist/core/transpiler.js

@@ -13,6 +13,10 @@ const string_utils_1 = __importDefault(require("../utils/string_utils"));
  */
 class Zod2X {
     constructor(opt) {
+        /**
+         * Opening and closing brackets of generic templates in the target language.
+         */
+        this.genericTemplatesBrackets = ["<", ">"];
         /**
          * Returns a comment.
          */
@@ -34,6 +38,62 @@ class Zod2X {
         this.indent = string_utils_1.default.getIndentationLevels(opt.indent || 4);
         this.opt = opt;
     }
+    /**
+     * Returns the translation of generic templates for a given AST node.
+     */
+    getGenericTemplatesTranslation(data) {
+        if ((data instanceof core_1.ASTObject || data instanceof core_1.ASTDefinition) &&
+            data.templatesTranslation.length > 0) {
+            const [open, close] = this.genericTemplatesBrackets;
+            const templates = data.templatesTranslation.map((t) => {
+                if (t.type !== undefined) {
+                    return this.getAttributeType(t.type);
+                }
+                else if (this.isExternalTypeImport(t)) {
+                    this.addExternalTypeImport(t);
+                    return this.getTypeFromExternalNamespace(t.parentNamespace, t.aliasOf);
+                }
+                else {
+                    return t.aliasOf;
+                }
+            });
+            return `${open}${templates.join(", ")}${close}`;
+        }
+    }
+    /**
+     * For Layered Modeling.
+     * Returns the language specific options used by `addExtendedType` to declare a type that
+     * extends another one.
+     * @param data - The AST node of the type.
+     * @param type - Kind of the type.
+     */
+    getExtendedTypeOptions(data, type) {
+        return { type };
+    }
+    /**
+     * For Layered Modeling.
+     * Emits the declaration of a type that extends another layered type, if the node is an alias.
+     * @param data - The AST node to transpile.
+     * @param type - Kind of the type.
+     * @returns `true` if the node shall not be transpiled as a new type: it is an alias, or a
+     *          type imported from another file.
+     */
+    checkExtendedTypeInclusion(data, type) {
+        // Options are computed in advance because they can have side effects (imports, ...).
+        const options = this.getExtendedTypeOptions(data, type);
+        if (this.isExternalTypeImport(data)) {
+            if (data.aliasOf) {
+                this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, options);
+                this.addExternalTypeImport(data);
+            }
+            return true;
+        }
+        else if (data.aliasOf) {
+            this.addExtendedType(data.name, data.parentNamespace, data.aliasOf, Object.assign(Object.assign({}, options), { isInternal: true }));
+            return true;
+        }
+        return false;
+    }
     /**
      * Determines if the given type token can be transpiled into the target language.
      * @param token - The type token to check.
@@ -146,7 +206,7 @@ class Zod2X {
             varType = token.name;
         }
         else {
-            console.log("  # Unknown attribute equivalent for ---> ", token.constructor.name);
+            console.log("  # Unknown attribute equivalent for ---> ", (0, core_1.getASTKind)(token));
         }
         return token.arrayDimension ? this.getArrayType(varType, token.arrayDimension) : varType;
     }
@@ -198,7 +258,7 @@ class Zod2X {
             this.transpileAliasedType(item);
         }
         else if (item instanceof core_1.ASTCommon) {
-            console.log(`Under construction: ${item.constructor.name}`);
+            console.log(`Under construction: ${(0, core_1.getASTKind)(item)}`);
         }
         else {
             throw new Error(`Unexpected item for transpilation: ${JSON.stringify(item)}`);