zod-to-x 1.0.3 → 1.2.0

package/README.md

@@ -10,7 +10,6 @@
 - [Supported output languages](#supported-output-languages)
 - [Mapping of supported Zod Types](#mapping-of-supported-zod-types)
 - [Additional utils](#additional-utils)
-- [Known limitations](#known-limitations)
 
 
 
@@ -140,6 +139,7 @@ A complete and more complex schema definition with its outputs can be found in t
 - [Zod Schemas](test/data)
 - [Typescript outputs](test/test_zod2ts)
 - [Protobuf V3 outputs](test/test_zod2proto3/)
+- [C++ 11 outputs](test/test_zod2cpp/)
 
 
 
@@ -148,44 +148,61 @@ 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`.
 
-### · **Typescript**  
-Options:
-  - **outType**: Output transpilation using Typescript interfaces or Classes.
+### Typescript  
+#### Options:
+  - **outType**: Output transpilation using Typescript interfaces or Classes. Defaults to `interface`.
 
-### · Protobuf V3
-Options:
+### Protobuf V3
+#### Options:
   - **packageName**: Name of the protobuf file package.
   - **useCamelCase**: Protobuf follows the snake_case convention for field names, but camelCase can also be used. Defaults to `false`.
 
-### · C++ (upcoming)
+#### Limitations:
+  - `oneof` fields support only unions of `ZodObject` schemas.
 
 
+### C++
+  - `Nlohmann` dependency is used for data serialization/deserialization.
+  - For *C++11*, `Boost` dependency is used. For *C++17* or newer, standard libraries are used.
+#### Options:
+  - **includeNulls**: When serializing, include all values even if `null`. Defaults to `false`.
+  - **namespace**: Name of the namespace containing the output code.
+  - **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
 
-| Zod Type          | TypeScript                  | Protobuf                                      |
-|-------------------|-----------------------------|-----------------------------------------------|
-| `z.string()`      | `string`                    | `string`                                      |
-| `z.number()`      | `number`                    | `double`, `uint32`, `uint64`, `ìnt32`, `int64`|
-| `z.bigint()`      | `number`                    | `int64`, `uint64`                             |
-| `z.boolean()`     | `boolean`                   | `bool`                                        |
-| `z.date()`        | `Date`                      | `google.protobuf.Timestamp`                   |
-| `z.literal()`     | Literal value (`'value'`)   | `number` or `string`                          |
-| `z.enum()`        | `enum`                      | `enum`                                        |
-| `z.nativeEnum()`  | Native `enum`               | `enum`                                        |
-| `z.array()`       | `T[]`                       | `repeated` field                              |
-| `z.set()`         | `Set<T>`                    | `repeated` field                              |
-| `z.tuple()`       | `[T1, T2, T3]`              | Not supported                                 |
-| `z.object()`      | `interface` or `class`      | `message`                                     |
-| `z.record()`      | `Record<string, T>`         | `map<string, K>`                              |
-| `z.union()`       | `T1 \| T2` or `type`        | `oneof`                                       |
-| `z.intersection()`| `T1 & T2` or `type`         | Not supported                                 |
-| `z.any()`         | `any`                       | `google.protobuf.Any`                         |
-| `z.optional()`    | `T \| undefined`            | Not supported                                 |
-| `z.nullable()`    | `T \| null`                 | Not supported                                 |
 
+## Mapping of supported Zod Types
 
+| Zod Type              | TypeScript                  | Protobuf                                      | C++                                           |
+|-----------------------|-----------------------------|-----------------------------------------------|-----------------------------------------------|
+| `z.string()`          | `string`                    | `string`                                      | `std::string`
+| `z.number()`          | `number`                    | `double`, `uint32`, `uint64`, `ìnt32`, `int64`| `double`, `uint32_t`, `uint64_t`, `ìnt32_t`, `int64_t`
+| `z.bigint()`          | `number`                    | `int64`, `uint64`                             | `int64_t`, `uint64_t`
+| `z.boolean()`         | `boolean`                   | `bool`                                        | `bool`
+| `z.date()`            | `Date`                      | `google.protobuf.Timestamp`                   | Not supported
+| `z.literal()`         | Literal value (`'value'`)   | As number or string                           | As string
+| `z.enum()`            | `enum`                      | `enum`                                        | `enum class T: int`
+| `z.nativeEnum()`      | Native `enum`               | `enum`                                        | `enum class T: int`
+| `z.array()`           | `T[]`                       | `repeated` field                              | `std::vector<T>`
+| `z.set()`             | `Set<T>`                    | `repeated` field                              | `std::set<T>`
+| `z.tuple()`           | `[T1, T2, T3]`              | `repeated` field <sup>(1)</sup>               | `std::tuple<T1, T2, T3>`
+| `z.object()`          | `interface` or `class`      | `message`                                     | `struct` or `class`
+| `z.record()`          | `Record<string, T>`         | `map<string, K>`                              | `std::unordered_map<T>`
+| `z.map()`             | `Map<string, T>`            | `map<string, K>`                              | `std::unordered_map<T>`
+| `z.union()`           | `T1 \| T2` or `type`        | `oneof`                                       | `std::variant<T, K>` (`boost::variant<T, K>` for C++11)
+| `z.intersection()` <sup>(2)</sup>| `T1 & T2` or `type`         | Not supported                      | `struct` or `class` with `inheritance`
+| `z.any()`             | `any`                       | `google.protobuf.Any`                         | `nlohmann::json`
+| `z.optional()`        | `T \| undefined`            | Not supported                                 | `std::optional<T>` (`boost::optional<T>` for C++11)
+| `z.nullable()`        | `T \| null`                 | Not supported                                 | `std::optional<T>` (`boost::optional<T>` for C++11)
+
+<sup>(1)</sup> Only for tuple with items of the same type.  
+<sup>(2)</sup> Consider to use Zod's merge instead of ZodIntersection when possible.
 
 ## Additional utils
 - `zod2JsonSchemaDefinitions`  
@@ -325,10 +342,4 @@ console.log(userJsonSchema);
 //   },
 //   "$schema": "http://json-schema.org/draft-07/schema#"
 // }
-```
-
-
-
-## Known limitations
-- Protobuf V3:  
-  - `oneof` fields support only unions of `ZodObject` schemas.
+```

package/dist/core/ast_node.d.ts

@@ -1,5 +1,5 @@
-import { ZodObject, ZodRawShape, ZodTypeAny } from 'zod';
-import { ASTNode, ASTNodes } from './ast_types';
+import { ZodObject, ZodRawShape } from "zod";
+import { ASTNodes } from "./ast_types";
 export declare class Zod2Ast {
     private nodes;
     private discriminatorNodes;
@@ -7,8 +7,6 @@ export declare class Zod2Ast {
     constructor();
     private _createDefinition;
     private _getEnumValues;
-    zodToAST(schema: ZodTypeAny, state?: {
-        isUnionDiscriminator?: boolean;
-    }): ASTNode;
+    private zodToAST;
     build<T extends ZodRawShape>(schema: ZodObject<T>): ASTNodes;
 }

package/dist/core/ast_node.js

@@ -8,13 +8,12 @@ class Zod2Ast {
         this.discriminatorNodes = new Map();
         this.lazyPointers = [];
     }
-    _createDefinition(ref) {
-        return { type: "definition", reference: ref };
+    _createDefinition(ref, refType, discriminantValue) {
+        return { type: "definition", reference: ref, referenceType: refType, discriminantValue };
     }
     _getEnumValues(schema) {
         if (schema instanceof zod_1.ZodEnum) {
-            return Object.entries(schema.Enum)
-                .map(([key, value]) => {
+            return Object.entries(schema.Enum).map(([key, value]) => {
                 key = isNaN(Number(key.at(0))) ? key : `"${key}"`;
                 return [key, value];
             });
@@ -28,44 +27,43 @@ class Zod2Ast {
             });
         }
     }
-    zodToAST(schema, state) {
+    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 {
                 type: zod_1.ZodFirstPartyTypeKind.ZodString,
-                description: schema.description
+                description: schema.description,
             };
         }
-        else if (schema instanceof zod_1.ZodNumber ||
-            schema instanceof zod_1.ZodBigInt) {
+        else if (schema instanceof zod_1.ZodNumber || schema instanceof zod_1.ZodBigInt) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodNumber,
                 constraints: {
-                    min: (_a = def.checks.find((i) => i.kind === 'min')) === null || _a === void 0 ? void 0 : _a.value,
-                    max: (_b = def.checks.find((i) => i.kind === 'max')) === null || _b === void 0 ? void 0 : _b.value,
-                    isInt: (schema instanceof zod_1.ZodBigInt ||
-                        def.checks.find((i) => i.kind === 'int') != undefined)
+                    min: (_a = def.checks.find((i) => i.kind === "min")) === null || _a === void 0 ? void 0 : _a.value,
+                    max: (_b = def.checks.find((i) => i.kind === "max")) === null || _b === void 0 ? void 0 : _b.value,
+                    isInt: schema instanceof zod_1.ZodBigInt ||
+                        def.checks.find((i) => i.kind === "int") != undefined,
                 },
-                description: schema.description
+                description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodBoolean) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodBoolean,
-                description: schema.description
+                description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodDate) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodDate,
-                description: schema.description
+                description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodAny) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodAny,
-                description: schema.description
+                description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodNullable) {
@@ -86,14 +84,14 @@ class Zod2Ast {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodSet,
                 value: this.zodToAST(def.valueType),
-                description: schema.description
+                description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodLiteral) {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodLiteral,
                 value: def.value,
-                description: schema.description
+                description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodRecord) {
@@ -101,12 +99,12 @@ class Zod2Ast {
                 type: zod_1.ZodFirstPartyTypeKind.ZodRecord,
                 key: this.zodToAST(def.keyType),
                 value: this.zodToAST(def.valueType),
-                description: schema.description
+                description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodLazy) {
             const lazySchema = def.getter();
-            const lazyPointer = this._createDefinition("pending");
+            const lazyPointer = this._createDefinition("pending", zod_1.ZodFirstPartyTypeKind.ZodAny);
             this.lazyPointers.push([lazyPointer, lazySchema]);
             return lazyPointer;
         }
@@ -114,7 +112,7 @@ class Zod2Ast {
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodTuple,
                 items: def.items.map(this.zodToAST.bind(this)),
-                description: schema.description
+                description: schema.description,
             };
         }
         else if (schema instanceof zod_1.ZodMap) {
@@ -122,11 +120,10 @@ class Zod2Ast {
                 type: zod_1.ZodFirstPartyTypeKind.ZodMap,
                 key: this.zodToAST(def.keyType),
                 value: this.zodToAST(def.valueType),
-                description: schema.description
+                description: schema.description,
             };
         }
-        else if (schema instanceof zod_1.ZodNativeEnum ||
-            schema instanceof zod_1.ZodEnum) {
+        else if (schema instanceof zod_1.ZodNativeEnum || schema instanceof zod_1.ZodEnum) {
             let name = (_c = def.zod2x) === null || _c === void 0 ? void 0 : _c.typeName;
             const item = {
                 type: def.typeName,
@@ -134,9 +131,8 @@ class Zod2Ast {
                 values: this._getEnumValues(schema),
                 description: def.description,
             };
-            if (state === null || state === void 0 ? void 0 : state.isUnionDiscriminator) {
-                if (!this.nodes.has(name) &&
-                    !this.discriminatorNodes.has(name)) {
+            if (opt === null || opt === void 0 ? void 0 : opt.isUnionDiscriminator) {
+                if (!this.nodes.has(name) && !this.discriminatorNodes.has(name)) {
                     this.discriminatorNodes.set(name, item);
                 }
             }
@@ -148,41 +144,48 @@ class Zod2Ast {
                     this.discriminatorNodes.delete(name);
                 }
             }
-            return this._createDefinition(name);
+            return this._createDefinition(name, def.typeName);
         }
         else if (schema instanceof zod_1.ZodObject) {
             let name = (_e = def.zod2x) === null || _e === void 0 ? void 0 : _e.typeName;
+            let discriminantValue = undefined;
             if (!this.nodes.has(name)) {
                 const properties = {};
                 for (const key in def.shape()) {
                     properties[key] = this.zodToAST(def.shape()[key]);
+                    if ((opt === null || opt === void 0 ? void 0 : opt.discriminantKey) && key === (opt === null || opt === void 0 ? void 0 : opt.discriminantKey)) {
+                        if (properties[key].type === zod_1.ZodFirstPartyTypeKind.ZodLiteral) {
+                            discriminantValue = String(properties[key].value);
+                        }
+                        else {
+                            console.warn(`Consider to set '${key}' key of '${name}' as ZodLiteral`);
+                        }
+                    }
                 }
                 this.nodes.set(name, {
                     type: zod_1.ZodFirstPartyTypeKind.ZodObject,
                     name: (_f = def.zod2x) === null || _f === void 0 ? void 0 : _f.typeName,
                     properties,
-                    description: schema.description
+                    description: schema.description,
                 });
             }
-            ;
-            return this._createDefinition(name);
+            return this._createDefinition(name, def.typeName, discriminantValue);
         }
-        else if (schema instanceof zod_1.ZodUnion ||
-            schema instanceof zod_1.ZodDiscriminatedUnion) {
+        else if (schema instanceof zod_1.ZodUnion || schema instanceof zod_1.ZodDiscriminatedUnion) {
             let name = (_g = def.zod2x) === null || _g === void 0 ? void 0 : _g.typeName;
             const item = {
                 type: def.typeName,
                 name: (_h = def.zod2x) === null || _h === void 0 ? void 0 : _h.typeName,
-                options: def.options.map(this.zodToAST.bind(this)),
-                description: schema.description
+                options: def.options.map((i) => this.zodToAST(i, { discriminantKey: def.discriminator })),
+                description: schema.description,
+                discriminantKey: def.discriminator,
             };
             if ((_j = def.zod2x) === null || _j === void 0 ? void 0 : _j.discriminatorEnum) {
                 this.zodToAST((_k = def.zod2x) === null || _k === void 0 ? void 0 : _k.discriminatorEnum, { isUnionDiscriminator: true });
             }
-            if (name &&
-                !this.nodes.has(name)) {
+            if (name && !this.nodes.has(name)) {
                 this.nodes.set(name, item);
-                return this._createDefinition(name);
+                return this._createDefinition(name, def.typeName);
             }
             return item;
         }
@@ -193,12 +196,11 @@ class Zod2Ast {
                 name: (_m = def.zod2x) === null || _m === void 0 ? void 0 : _m.typeName,
                 left: this.zodToAST(def.left),
                 right: this.zodToAST(def.right),
-                description: schema.description
+                description: schema.description,
             };
-            if (name &&
-                !this.nodes.has(name)) {
+            if (name && !this.nodes.has(name)) {
                 this.nodes.set(name, item);
-                return this._createDefinition(name);
+                return this._createDefinition(name, def.typeName);
             }
             return item;
         }
@@ -210,7 +212,7 @@ class Zod2Ast {
         while (this.lazyPointers.length > 0) {
             const [pointer, schema] = this.lazyPointers.shift();
             const lazyResolve = this.zodToAST(schema);
-            Object.keys(pointer).forEach(key => {
+            Object.keys(pointer).forEach((key) => {
                 delete pointer[key];
             });
             Object.entries(lazyResolve).forEach(([key, value]) => {
@@ -219,7 +221,7 @@ class Zod2Ast {
         }
         return {
             nodes: [...this.nodes.values()],
-            discriminatorNodes: [...this.discriminatorNodes.values()]
+            discriminatorNodes: [...this.discriminatorNodes.values()],
         };
     }
 }

package/dist/core/ast_types.d.ts

@@ -53,6 +53,7 @@ export type ASTDiscriminatedUnion = {
     type: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
     name: string;
     options: ASTNode[];
+    discriminantKey?: string;
 };
 export type ASTIntersection = {
     type: ZodFirstPartyTypeKind.ZodIntersection;
@@ -66,10 +67,12 @@ export type ASTCommon = {
     isNullable?: boolean;
     isOptional?: boolean;
 };
-export type ASTDefintion = ASTCommon & ({
+export type ASTDefintion = ASTCommon & {
     type: "definition";
     reference: string;
-});
+    referenceType: ZodFirstPartyTypeKind;
+    discriminantValue?: string;
+};
 export type ASTNode = ASTCommon & ({
     type: ZodFirstPartyTypeKind.ZodString;
 } | {

package/dist/core/transpiler.d.ts

@@ -1,4 +1,5 @@
-import { ASTCommon, ASTDiscriminatedUnion, ASTEnum, ASTIntersection, ASTNativeEnum, ASTNode, ASTNodes, ASTObject, ASTUnion, TranspilerableTypes } from './ast_types';
+import { TIndentationLevels } from "../utils/string_utils";
+import { ASTCommon, ASTDiscriminatedUnion, ASTEnum, ASTIntersection, ASTNativeEnum, ASTNode, ASTNodes, ASTObject, ASTUnion, TranspilerableTypes } from "./ast_types";
 export interface IZodToXOpt extends Record<string, any> {
     header?: string;
     indent?: number;
@@ -8,16 +9,16 @@ export interface IZodToXOpt extends Record<string, any> {
 interface IInternalOpts {
     enableCompositeTypes: boolean;
 }
-export declare abstract class Zod2X {
-    protected output: string;
-    protected indent: string;
+export declare abstract class Zod2X<T extends IZodToXOpt> {
+    protected output: string[];
+    protected indent: TIndentationLevels;
     protected imports: Set<string>;
-    protected opt: Partial<IZodToXOpt>;
+    protected opt: Partial<T>;
     private inOpt;
-    protected constructor(inOpt: IInternalOpts, opt: Partial<IZodToXOpt>);
+    protected constructor(inOpt: IInternalOpts, opt: Partial<T>);
     protected abstract runBefore(): void;
     protected abstract runAfter(): void;
-    protected abstract addComment(data?: string, indent?: string): void;
+    protected abstract getComment(data: string, indent?: string): string;
     protected abstract getStringType(): string;
     protected abstract getBooleanType(): string;
     protected abstract getNumberType(isInt: boolean, range: {
@@ -39,6 +40,11 @@ export declare abstract class Zod2X {
     protected abstract transpileUnion(data: (ASTUnion | ASTDiscriminatedUnion) & ASTCommon): void;
     protected abstract transpileIntersection(data: ASTIntersection & ASTCommon): void;
     protected isTranspilerable(token: TranspilerableTypes): boolean | "";
+    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;

package/dist/core/transpiler.js

@@ -1,26 +1,36 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Zod2X = void 0;
 const zod_1 = require("zod");
+const string_utils_1 = __importDefault(require("../utils/string_utils"));
 class Zod2X {
     constructor(inOpt, opt) {
-        var _a;
-        this.output = "";
+        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}`);
+        this.push3 = (data) => this.output.push(`${this.indent[3]}${data}`);
+        this.output = [];
         this.imports = new Set();
-        this.indent = " ".repeat((_a = opt === null || opt === void 0 ? void 0 : opt.indent) !== null && _a !== void 0 ? _a : 4);
+        this.indent = string_utils_1.default.getIndentationLevels(opt.indent || 4);
         this.opt = opt;
         this.inOpt = inOpt;
-        if (opt === null || opt === void 0 ? void 0 : opt.header) {
-            this.addComment(opt.header);
-        }
     }
     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.name &&
+                (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) {
@@ -55,7 +65,10 @@ class Zod2X {
             varType = this.getSetType(this.getAttributeType(token.value));
         }
         else if (token.type === zod_1.ZodFirstPartyTypeKind.ZodNumber) {
-            varType = this.getNumberType(token.constraints.isInt, { min: token.constraints.min, max: token.constraints.max });
+            varType = this.getNumberType(token.constraints.isInt, {
+                min: token.constraints.min,
+                max: token.constraints.max,
+            });
         }
         else if (token.type === zod_1.ZodFirstPartyTypeKind.ZodTuple) {
             const tupleAttributeTypes = token.items.map(this.getAttributeType.bind(this));
@@ -77,8 +90,9 @@ class Zod2X {
             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)) {
+        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);
@@ -108,16 +122,25 @@ class Zod2X {
         }
     }
     transpile(transpilerQueue) {
+        var _a;
         this.runBefore();
         if (this.opt.skipDiscriminatorNodes !== true) {
             transpilerQueue.discriminatorNodes.forEach(this._transpileItem.bind(this));
         }
         transpilerQueue.nodes.forEach(this._transpileItem.bind(this));
+        this.runAfter();
+        let header = [];
+        if (this.opt.header) {
+            header.push(...this.opt.header.split("\n").map((i) => this.getComment(i)));
+        }
         if (this.imports.size > 0) {
-            this.output = [...this.imports.keys()].join('\n') + `\n\n${this.output}`;
+            header.push(...this.imports);
+            if (!((_a = header.at(-1)) === null || _a === void 0 ? void 0 : _a.endsWith("\n"))) {
+                header.push("");
+            }
         }
-        this.runAfter();
-        return this.output;
+        this.output = [...header, ...this.output];
+        return this.output.join("\n");
     }
 }
 exports.Zod2X = Zod2X;

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export * from "./core/ast_types";
 export { Zod2Ast } from "./core/ast_node";
 export { Zod2X } from "./core/transpiler";
 export * from "./transpilers";
-export { zod2JsonSchemaDefinitions } from './utils/json_schema_definitions';
+export { zod2JsonSchemaDefinitions } from "./utils/json_schema_definitions";

package/dist/lib/zod_ext.d.ts

@@ -1,9 +1,9 @@
-import { EnumLike, UnknownKeysParam, z, ZodEnum, ZodNativeEnum, ZodRawShape, ZodTypeAny, ZodUnionOptions } from 'zod';
+import { EnumLike, UnknownKeysParam, z, ZodEnum, ZodNativeEnum, ZodRawShape, ZodTypeAny, ZodUnionOptions } from "zod";
 export interface Zod2xMetadata {
     typeName: string;
     discriminatorEnum?: ZodEnum<any> | ZodNativeEnum<any>;
 }
-declare module 'zod' {
+declare module "zod" {
     interface ZodTypeDef {
         zod2x?: Zod2xMetadata;
     }

package/dist/lib/zod_ext.js

@@ -3,26 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendZod = extendZod;
 function getZod2XConstructor() {
     return function (opt) {
-        return new this.constructor(Object.assign(Object.assign({}, this._def), { zod2x: typeof opt === 'string' ? { typeName: opt } : opt }));
+        return new this.constructor(Object.assign(Object.assign({}, this._def), { zod2x: typeof opt === "string" ? { typeName: opt } : opt }));
     };
 }
 function extendZod(zod) {
-    if (typeof zod.ZodObject.prototype.zod2x === 'undefined') {
+    if (typeof zod.ZodObject.prototype.zod2x === "undefined") {
         zod.ZodObject.prototype.zod2x = getZod2XConstructor();
     }
-    if (typeof zod.ZodEnum.prototype.zod2x === 'undefined') {
+    if (typeof zod.ZodEnum.prototype.zod2x === "undefined") {
         zod.ZodEnum.prototype.zod2x = getZod2XConstructor();
     }
-    if (typeof zod.ZodNativeEnum.prototype.zod2x === 'undefined') {
+    if (typeof zod.ZodNativeEnum.prototype.zod2x === "undefined") {
         zod.ZodNativeEnum.prototype.zod2x = getZod2XConstructor();
     }
-    if (typeof zod.ZodDiscriminatedUnion.prototype.zod2x === 'undefined') {
+    if (typeof zod.ZodDiscriminatedUnion.prototype.zod2x === "undefined") {
         zod.ZodDiscriminatedUnion.prototype.zod2x = getZod2XConstructor();
     }
-    if (typeof zod.ZodUnion.prototype.zod2x === 'undefined') {
+    if (typeof zod.ZodUnion.prototype.zod2x === "undefined") {
         zod.ZodUnion.prototype.zod2x = getZod2XConstructor();
     }
-    if (typeof zod.ZodIntersection.prototype.zod2x === 'undefined') {
+    if (typeof zod.ZodIntersection.prototype.zod2x === "undefined") {
         zod.ZodIntersection.prototype.zod2x = getZod2XConstructor();
     }
 }

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

@@ -0,0 +1,15 @@
+export declare function getLibs(useBoost: boolean): {
+    exceptions: string;
+    integers: string;
+    map: string;
+    nlohmann: string;
+    set: string;
+    string: string;
+    tuple: string;
+    vector: string;
+    optional: string;
+    variant: string;
+};
+export declare const USING: {
+    nlohmann: string;
+};

package/dist/transpilers/cpp/libs.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USING = void 0;
+exports.getLibs = getLibs;
+function getLibs(useBoost) {
+    return {
+        exceptions: "#include <stdexcept>",
+        integers: "#include <cstdint>",
+        map: "#include <unordered_map>",
+        nlohmann: "#include <nlohmann/json.hpp>",
+        set: "#include <set>",
+        string: "#include <string>",
+        tuple: "#include <tuple>",
+        vector: "#include <vector>",
+        optional: useBoost ? "#include <boost/optional.hpp>" : "#include <optional>",
+        variant: useBoost ? "#include <boost/variant.hpp>" : "#include <variant>",
+    };
+}
+exports.USING = {
+    nlohmann: "using nlohmann::json;",
+};

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

@@ -0,0 +1 @@
+export declare function getNlohmannOptionalHelper(indent: number, useBoost?: boolean): string[];

package/dist/transpilers/cpp/nlohmann.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNlohmannOptionalHelper = getNlohmannOptionalHelper;
+function getNlohmannOptionalHelper(indent, useBoost) {
+    const optType = useBoost ? "boost::optional" : "std::optional";
+    return [
+        "#ifndef NLOHMANN_OPTIONAL_HELPER_zodtocpp",
+        "#define NLOHMANN_OPTIONAL_HELPER_zodtocpp",
+        "template <typename T>",
+        `${optType}<T> get_opt(const json& j, const std::string& key) {`,
+        `${" ".repeat(indent)}auto it = j.find(key);`,
+        `${" ".repeat(indent)}if (it != j.end() && !it->is_null()) {`,
+        `${" ".repeat(indent * 2)}return it->get<T>();`,
+        `${" ".repeat(indent)}}`,
+        `${" ".repeat(indent)}return ${optType}<T>();`,
+        `}\n`,
+        `template <typename T>`,
+        `void set_opt(json& j, const std::string& key, const ${optType}<T>& opt) {`,
+        `${" ".repeat(indent)}if (opt) {`,
+        `${" ".repeat(indent * 2)}j[key] = *opt;`,
+        `${" ".repeat(indent)}}`,
+        `}`,
+        `#endif\n`,
+    ];
+}