zod-to-x 1.2.0 → 1.2.1

package/README.md

@@ -14,36 +14,16 @@
 
 
 ## Why Use [`@zod-to-x`](https://github.com/rroumenov/zod-to-x)?
-In modern software development, managing data consistency across multiple layers and languages is a persistent challenge. [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) tackles this problem head-on by enabling you to define your data models once, in a centralized and expressive way, and then effortlessly transpile these models into multiple programming languages. Here's why [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) stands out:
+Managing data consistency across multiple layers and languages is a common challenge in modern software development. [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) solves this by allowing you to define your data models once and effortlessly transpile them into multiple programming languages. Here’s why it stands out:
 
-1. Centralized Data Definition  
-With [`@zod-to-x`](https://github.com/rroumenov/zod-to-x), you define your data structures in one place using the powerful Zod library. This eliminates redundancy, reduces the risk of inconsistencies, and simplifies maintenance across your codebase.
+1. **Centralized Data Definition**  
+Define your data structures in one place using the powerful [`@zod`]((https://github.com/colinhacks/zod)) library. This eliminates redundancy, reduces inconsistencies, and simplifies maintenance across your entire codebase, all while allowing you to continue leveraging any npm package in the [`@zod`]((https://github.com/colinhacks/zod)) ecosystem like [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema)
 
-2. Multi-Language Compatibility  
-Gone are the days of manually rewriting data models for different platforms. [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) lets you generate data types for:
+2. **Multi-Language Compatibility**  
+Generate data models for TypeScript, Protobuf V3 and C++ (with languages like Golang on the roadmap). No more manually rewriting models for different platforms.
 
-    - TypeScript: Build strong, type-safe interfaces or classes for front-end and back-end applications.
-    - Protobuf V3: Seamlessly integrate with gRPC and other Protobuf-based systems.
-    - More Languages: Support for additional languages like C++ is on the roadmap.
-
-3. Enhanced Productivity  
-By automating the transpilation of data models, [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) allows your team to focus on writing business logic instead of boilerplate code. Changes to schemas are propagated automatically, saving time and minimizing errors.
-
-4. Built on Zod's Robust Ecosystem  
-[`@zod-to-x`](https://github.com/rroumenov/zod-to-x) extends the capabilities of Zod, a popular and intuitive schema validation library. This means you can:
-
-    - Leverage Zod's wide array of schema types and validations.
-    - Maintain compatibility with existing Zod-based projects.
-    - Easily integrate with tools like [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema).
-
-5. Flexible Output Options  
-Whether you need plain interfaces, full-fledged classes with constructors, or Protobuf definitions, [`@zod-to-x`](https://github.com/rroumenov/zod-to-x) can adapt to your specific needs with customizable output formats.
-
-6. Transparent and Extendable  
-The library is designed to be lightweight, transparent, and easy to integrate into existing workflows. Its extendable architecture ensures it can evolve to meet your project’s growing demands.
-
-7. Ideal for Cross-Language Development  
-If your application spans multiple languages—like a front-end in TypeScript, a back-end in Python, and microservices in Protobuf—[`@zod-to-x`](https://github.com/rroumenov/zod-to-x) simplifies the process of keeping data structures consistent across the stack.
+3. **Enhanced Productivity**  
+Automate the transpilation of data models to save time, reduce errors, and let your team focus on business logic instead of boilerplate code.
 
 
 
@@ -67,39 +47,36 @@ This extension appends a `zod2x` method to:
 - ZodUnion
 - ZodDiscriminatedUnion
 - ZodIntersection
+- ZodLiteral
 
 ## Quick start
-### 1) Define a data model using Zod schemas
 ```ts
 import { z } from "zod";
+import { extendZod, Zod2Ast, Zod2Ts } from "zod-to-x";
+extendZod(z); // The extend step can be skipped if it has already been done.
 
-// Skip the extend step if it has already been done.
-import { extendZod } from "zod-to-x";
-extendZod(z);
-
+/**
+ * 1) Define a data model using Zod schemas
+ */
 const VisitorSchema = z.object({
   id: z.string().uuid(),
   name: z.string(),
   email: z.string().email(),
   visitDate: z.date(),
   comments: z.string().optional(),
-}).zod2x("Visitor");    // Add your expected output type name using the 'zod2x' method.
-
-```
-
-### 2) Build an AST node of the Zod schema
-```ts
-import { Zod2Ast } from "zod-to-x";
+}).zod2x("Visitor"); // Add your expected output type name using the 'zod2x' method.
 
+/**
+ * 2) Build an AST node of the Zod schema
+ */
 const visitorNodes = new Zod2Ast().build(VisitorSchema);
-```
 
-### 3) Generate types in the desired language
-```ts
-import { Zod2Ts } from "zod-to-x";
-
-const tsVisitor: string = new Zod2Ts().transpile(visitorNodes);
-console.log(tsVisitor)
+/**
+ * 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);
+console.log(tsVisitorAsInterface)
 // output:
 // export interface Visitor {
 //     id: string;
@@ -108,14 +85,9 @@ console.log(tsVisitor)
 //     visitDate: Date;
 //     comments?: string;
 // }
-```
-Depending on the transpiled language, data models can be generated using classes:
-
-```ts
-import { Zod2Ts } from "zod-to-x";
 
-const tsVisitor: string = new Zod2Ts({outType: "class"}).transpile(visitorNodes);
-console.log(tsVisitor)
+const tsVisitorAsClass: string = new Zod2Ts({outType: "class"}).transpile(visitorNodes);
+console.log(tsVisitorAsClass)
 // output:
 // export class Visitor {
 //     id: string;
@@ -135,11 +107,11 @@ console.log(tsVisitor)
 ```
 
 
-A complete and more complex schema definition with its outputs can be found in the `test` folder:
-- [Zod Schemas](test/data)
+Example of supported schemas with its outputs can be found in the `test` folder:
+- [Zod Schemas](test/common)
 - [Typescript outputs](test/test_zod2ts)
 - [Protobuf V3 outputs](test/test_zod2proto3/)
-- [C++ 11 outputs](test/test_zod2cpp/)
+- [C++ outputs](test/test_zod2cpp/)
 
 
 
@@ -150,29 +122,29 @@ Common options:
 - **includeComments**: Determines whether to include comments in the transpiled code. Defaults to `true`.
 - **skipDiscriminatorNodes**: prevents the inclusion of `ZodEnum` or `ZodNativeEnum` schemas that are used solely as discriminator keys in a `ZodDiscriminatedUnion`. Defaults to `false`.
 
-### Typescript  
-#### Options:
+### 1) Typescript  
+- Options:
   - **outType**: Output transpilation using Typescript interfaces or Classes. Defaults to `interface`.
 
-### Protobuf V3
-#### Options:
+### 2) 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`.
 
-#### Limitations:
+- Limitations:
   - `oneof` fields support only unions of `ZodObject` schemas.
+  - `ZodTuple` is supported only for items of the same type.
 
 
-### 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:
+### 3) 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:
+- Limitations:
   - `ZodIntersection` is supported only for intersection of `ZodObject` schemas.
 
 
@@ -191,18 +163,19 @@ Common options:
 | `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.tuple()`           | `[T1, T2, T3]`              | `repeated` field                              | `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.union()` <sup>(2)</sup> | `T1 \| T2` or `type`   | `oneof`                                       | `std::variant<T, K>` (`boost::variant<T, K>` for C++11)
+| `z.discriminatedUnion()`| `T1 \| T2` or `type`      | `oneof`                                       | `std::variant<T, K>` (`boost::variant<T, K>` for C++11)
+| `z.intersection()` <sup>(1)</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.
+<sup>(1)</sup> Consider to use Zod's merge instead of ZodIntersection when possible.  
+<sup>(2)</sup> Consider to use ZodDiscriminatedUnion when possible. In languages like C++, deserialization is O(1) against the O(n) of the ZodUnion.
 
 ## Additional utils
 - `zod2JsonSchemaDefinitions`  

package/dist/core/ast_node.js

@@ -28,7 +28,7 @@ class Zod2Ast {
         }
     }
     zodToAST(schema, opt) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
         const def = schema._def;
         if (schema instanceof zod_1.ZodString) {
             return {
@@ -88,10 +88,19 @@ class Zod2Ast {
             };
         }
         else if (schema instanceof zod_1.ZodLiteral) {
+            let parentEnumName = undefined;
+            let parentEnumKey = undefined;
+            if ((_c = def.zod2x) === null || _c === void 0 ? void 0 : _c.parentEnum) {
+                parentEnumName = (_e = (_d = def.zod2x) === null || _d === void 0 ? void 0 : _d.parentEnum._def.zod2x) === null || _e === void 0 ? void 0 : _e.typeName;
+                parentEnumKey = (_g = this._getEnumValues((_f = def.zod2x) === null || _f === void 0 ? void 0 : _f.parentEnum).find((i) => i[1] === def.value)) === null || _g === void 0 ? void 0 : _g[0];
+                this.zodToAST((_h = def.zod2x) === null || _h === void 0 ? void 0 : _h.parentEnum, { isInjectedEnum: true });
+            }
             return {
                 type: zod_1.ZodFirstPartyTypeKind.ZodLiteral,
                 value: def.value,
                 description: schema.description,
+                parentEnumName,
+                parentEnumKey,
             };
         }
         else if (schema instanceof zod_1.ZodRecord) {
@@ -124,14 +133,14 @@ class Zod2Ast {
             };
         }
         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;
+            let name = (_j = def.zod2x) === null || _j === void 0 ? void 0 : _j.typeName;
             const item = {
                 type: def.typeName,
-                name: (_d = def.zod2x) === null || _d === void 0 ? void 0 : _d.typeName,
+                name: (_k = def.zod2x) === null || _k === void 0 ? void 0 : _k.typeName,
                 values: this._getEnumValues(schema),
                 description: def.description,
             };
-            if (opt === null || opt === void 0 ? void 0 : opt.isUnionDiscriminator) {
+            if (opt === null || opt === void 0 ? void 0 : opt.isInjectedEnum) {
                 if (!this.nodes.has(name) && !this.discriminatorNodes.has(name)) {
                     this.discriminatorNodes.set(name, item);
                 }
@@ -147,42 +156,43 @@ class Zod2Ast {
             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 name = (_l = def.zod2x) === null || _l === void 0 ? void 0 : _l.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,
+                    name: (_m = def.zod2x) === null || _m === void 0 ? void 0 : _m.typeName,
                     properties,
                     description: schema.description,
                 });
             }
+            if (opt === null || opt === void 0 ? void 0 : opt.discriminantKey) {
+                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) {
+                        discriminantValue = String(item.properties[key].value);
+                    }
+                    else {
+                        console.warn(`Consider to set '${key}' key of '${name}' as ZodLiteral`);
+                    }
+                }
+            }
             return this._createDefinition(name, def.typeName, discriminantValue);
         }
         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;
+            let name = (_o = def.zod2x) === null || _o === void 0 ? void 0 : _o.typeName;
             const item = {
                 type: def.typeName,
-                name: (_h = def.zod2x) === null || _h === void 0 ? void 0 : _h.typeName,
+                name: (_p = def.zod2x) === null || _p === void 0 ? void 0 : _p.typeName,
                 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)) {
                 this.nodes.set(name, item);
                 return this._createDefinition(name, def.typeName);
@@ -190,10 +200,10 @@ class Zod2Ast {
             return item;
         }
         else if (schema instanceof zod_1.ZodIntersection) {
-            let name = (_l = def.zod2x) === null || _l === void 0 ? void 0 : _l.typeName;
+            let name = (_q = def.zod2x) === null || _q === void 0 ? void 0 : _q.typeName;
             const item = {
                 type: zod_1.ZodFirstPartyTypeKind.ZodIntersection,
-                name: (_m = def.zod2x) === null || _m === void 0 ? void 0 : _m.typeName,
+                name: (_r = def.zod2x) === null || _r === void 0 ? void 0 : _r.typeName,
                 left: this.zodToAST(def.left),
                 right: this.zodToAST(def.right),
                 description: schema.description,

package/dist/core/ast_types.d.ts

@@ -2,6 +2,8 @@ import { ZodFirstPartyTypeKind } from "zod";
 export type ASTLiteral = {
     type: ZodFirstPartyTypeKind.ZodLiteral;
     value: any;
+    parentEnumName?: string;
+    parentEnumKey?: string;
 };
 export type ASTNumber = {
     type: ZodFirstPartyTypeKind.ZodNumber;

package/dist/core/transpiler.d.ts

@@ -25,7 +25,7 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
         min?: number;
         max?: number;
     }): string;
-    protected abstract getLiteralStringType(value: string | number): string | number;
+    protected abstract getLiteralStringType(value: string | number, parentEnumNameKey?: [string, string]): string | number;
     protected abstract getAnyType(): string;
     protected abstract getDateType(): string;
     protected abstract getTupleType(itemsType: string[]): string;

package/dist/core/transpiler.js

@@ -59,7 +59,10 @@ class Zod2X {
             varType = this.getDateType();
         }
         else if (token.type === zod_1.ZodFirstPartyTypeKind.ZodLiteral) {
-            varType = this.getLiteralStringType(token.value);
+            const parentEnum = token.parentEnumName && token.parentEnumKey
+                ? [token.parentEnumName, token.parentEnumKey]
+                : undefined;
+            varType = this.getLiteralStringType(token.value, parentEnum);
         }
         else if (token.type === zod_1.ZodFirstPartyTypeKind.ZodSet) {
             varType = this.getSetType(this.getAttributeType(token.value));

package/dist/lib/zod_ext.d.ts

@@ -1,7 +1,7 @@
 import { EnumLike, UnknownKeysParam, z, ZodEnum, ZodNativeEnum, ZodRawShape, ZodTypeAny, ZodUnionOptions } from "zod";
 export interface Zod2xMetadata {
     typeName: string;
-    discriminatorEnum?: ZodEnum<any> | ZodNativeEnum<any>;
+    parentEnum?: ZodEnum<any> | ZodNativeEnum<any>;
 }
 declare module "zod" {
     interface ZodTypeDef {
@@ -9,27 +9,31 @@ declare module "zod" {
     }
     interface ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> {
         zod2x(this: ZodObject<T, UnknownKeys, Catchall>, typeName: string): this;
-        zod2x(this: ZodObject<T, UnknownKeys, Catchall>, opt: Zod2xMetadata): this;
+        zod2x(this: ZodObject<T, UnknownKeys, Catchall>, opt: Pick<Zod2xMetadata, "typeName">): this;
     }
     interface ZodEnum<T extends [string, ...string[]]> {
         zod2x(this: ZodEnum<T>, typeName: string): this;
-        zod2x(this: ZodEnum<T>, opt: Zod2xMetadata): this;
+        zod2x(this: ZodEnum<T>, opt: Pick<Zod2xMetadata, "typeName">): this;
     }
     interface ZodNativeEnum<T extends EnumLike = EnumLike> {
         zod2x(this: ZodNativeEnum<T>, typeName: string): this;
-        zod2x(this: ZodNativeEnum<T>, opt: Zod2xMetadata): this;
+        zod2x(this: ZodNativeEnum<T>, opt: Pick<Zod2xMetadata, "typeName">): this;
     }
     interface ZodDiscriminatedUnion<Discriminator extends string, Options extends z.ZodDiscriminatedUnionOption<Discriminator>[]> {
         zod2x(this: ZodDiscriminatedUnion<Discriminator, Options>, typeName: string): this;
-        zod2x(this: ZodDiscriminatedUnion<Discriminator, Options>, opt: Zod2xMetadata): this;
+        zod2x(this: ZodDiscriminatedUnion<Discriminator, Options>, opt: Pick<Zod2xMetadata, "typeName">): this;
     }
     interface ZodUnion<T extends ZodUnionOptions> {
         zod2x(this: ZodUnion<ZodUnionOptions>, typeName: string): this;
-        zod2x(this: ZodUnion<ZodUnionOptions>, opt: Zod2xMetadata): this;
+        zod2x(this: ZodUnion<ZodUnionOptions>, opt: Pick<Zod2xMetadata, "typeName">): this;
     }
     interface ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> {
         zod2x(this: ZodIntersection<T, U>, typeName: string): this;
-        zod2x(this: ZodIntersection<T, U>, opt: Zod2xMetadata): this;
+        zod2x(this: ZodIntersection<T, U>, opt: Pick<Zod2xMetadata, "typeName">): this;
+    }
+    interface ZodLiteral<T extends ZodTypeAny> {
+        zod2x(this: ZodLiteral<T>, parentEnum: ZodNativeEnum | ZodEnum<any>): this;
+        zod2x(this: ZodLiteral<T>, opt: Pick<Zod2xMetadata, "parentEnum">): this;
     }
 }
 export declare function extendZod(zod: typeof z): void;

package/dist/lib/zod_ext.js

@@ -25,4 +25,11 @@ function extendZod(zod) {
     if (typeof zod.ZodIntersection.prototype.zod2x === "undefined") {
         zod.ZodIntersection.prototype.zod2x = getZod2XConstructor();
     }
+    if (typeof zod.ZodLiteral.prototype.zod2x === "undefined") {
+        zod.ZodLiteral.prototype.zod2x = function (opt) {
+            return new this.constructor(Object.assign(Object.assign({}, this._def), { zod2x: opt instanceof zod.ZodEnum || opt instanceof zod.ZodNativeEnum
+                    ? { parentEnum: opt }
+                    : opt }));
+        };
+    }
 }

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

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

package/dist/transpilers/cpp/nlohmann.js

@@ -1,11 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNlohmannOptionalHelper = getNlohmannOptionalHelper;
-function getNlohmannOptionalHelper(indent, useBoost) {
+function getNlohmannOptionalHelper(indent, includeNulls, useBoost, namespace) {
     const optType = useBoost ? "boost::optional" : "std::optional";
+    const setOpt = includeNulls
+        ? [
+            `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)}}`,
+            `${" ".repeat(indent)}else {`,
+            `${" ".repeat(indent * 2)}j[key] = nullptr;`,
+            `${" ".repeat(indent)}}`,
+            `}`,
+            `#endif\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`,
+        ];
     return [
-        "#ifndef NLOHMANN_OPTIONAL_HELPER_zodtocpp",
-        "#define NLOHMANN_OPTIONAL_HELPER_zodtocpp",
+        `#ifndef NLOHMANN_OPTIONAL_HELPER_${namespace}`,
+        `#define NLOHMANN_OPTIONAL_HELPER_${namespace}`,
         "template <typename T>",
         `${optType}<T> get_opt(const json& j, const std::string& key) {`,
         `${" ".repeat(indent)}auto it = j.find(key);`,
@@ -14,12 +36,6 @@ function getNlohmannOptionalHelper(indent, useBoost) {
         `${" ".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`,
+        ...setOpt,
     ];
 }

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

@@ -32,7 +32,7 @@ export declare class Zod2Cpp extends Zod2X<IZod2CppOpt> {
         max?: number;
     }) => string;
     protected getArrayType(arrayType: string, arrayDeep: number): string;
-    protected getLiteralStringType(value: string | number): string;
+    protected getLiteralStringType(value: string | number, parentEnumNameKey?: [string, string]): string;
     protected getMapType(keyType: string, valueType: string): string;
     protected getRecordType(keyType: string, valueType: string): string;
     protected _getOptional(type: string): string;

package/dist/transpilers/cpp/runner.js

@@ -83,8 +83,8 @@ class Zod2Cpp extends core_1.Zod2X {
             this.imports.add(this.lib.nlohmann);
             this.output.push("");
             this.output.push(`namespace ${this.opt.namespace} {`);
-            if (this.imports.has(this.lib.optional) && !this.opt.includeNulls) {
-                this.serializers.unshift(...(0, nlohmann_1.getNlohmannOptionalHelper)(this.opt.indent, this.useBoost));
+            if (this.imports.has(this.lib.optional)) {
+                this.serializers.unshift(...(0, nlohmann_1.getNlohmannOptionalHelper)(this.opt.indent, this.opt.includeNulls === true, this.useBoost, this.opt.namespace));
             }
             this.serializers = this.serializers.map((i) => `${this.indent[1]}${i}`);
             this.output.push(...this.serializers);
@@ -102,13 +102,14 @@ class Zod2Cpp extends core_1.Zod2X {
         }
         return output;
     }
-    getLiteralStringType(value) {
-        return isNaN(Number(value))
+    getLiteralStringType(value, parentEnumNameKey) {
+        var _a;
+        return ((_a = parentEnumNameKey === null || parentEnumNameKey === void 0 ? void 0 : parentEnumNameKey[0]) !== null && _a !== void 0 ? _a : (isNaN(Number(value))
             ? this.getStringType()
             : this.getNumberType(Number.isInteger(value), {
                 min: value,
                 max: value,
-            });
+            })));
     }
     getMapType(keyType, valueType) {
         this.imports.add(this.lib.map);
@@ -261,7 +262,7 @@ class Zod2Cpp extends core_1.Zod2X {
     _createStructSerializer(parent, childs) {
         this._push0(this.serializers, `inline void to_json(json& j, const ${parent}& x) {`);
         childs.forEach((i) => {
-            if (i.required || this.opt.includeNulls === true) {
+            if (i.required) {
                 this._push1(this.serializers, `j["${i.origName}"] = x.${i.snakeName};`);
             }
             else {
@@ -285,7 +286,7 @@ class Zod2Cpp extends core_1.Zod2X {
     _createClassSerializer(parent, childs) {
         this._push0(this.serializers, `inline void to_json(json& j, const ${parent}& x) {`);
         childs.forEach((i) => {
-            if (i.required || this.opt.includeNulls === true) {
+            if (i.required) {
                 this._push1(this.serializers, `j["${i.origName}"] = x.get_${i.snakeName}();`);
             }
             else {

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

@@ -17,7 +17,7 @@ export declare class Zod2Ts extends Zod2X<IZod2TsOpt> {
     protected getIntersectionType: (itemsType: string[]) => string;
     protected getNumberType: () => string;
     protected getArrayType(arrayType: string, arrayDeep: number): string;
-    protected getLiteralStringType(value: string | number): string | number;
+    protected getLiteralStringType(value: string | number, parentEnumNameKey?: [string, string]): string | number;
     protected getMapType(keyType: string, valueType: string): string;
     protected getRecordType(keyType: string, valueType: string): string;
     protected transpileEnum(data: (ASTEnum | ASTNativeEnum) & ASTCommon): void;

package/dist/transpilers/typescript/runner.js

@@ -39,8 +39,12 @@ class Zod2Ts extends core_1.Zod2X {
         }
         return output;
     }
-    getLiteralStringType(value) {
-        return isNaN(Number(value)) ? `"${value}"` : value;
+    getLiteralStringType(value, parentEnumNameKey) {
+        return parentEnumNameKey
+            ? `${parentEnumNameKey[0]}.${parentEnumNameKey[1]}`
+            : isNaN(Number(value))
+                ? `"${value}"`
+                : value;
     }
     getMapType(keyType, valueType) {
         return `Map<${keyType}, ${valueType}>`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [
@@ -10,6 +10,7 @@
     "build": "tsc && tsc-alias",
     "format:check": "prettier --check .",
     "test": "jest",
+    "test:cpp": "bash ./test/test_zod2cpp/test_cpp.sh",
     "ts-run": "ts-node -r tsconfig-paths/register",
     "prepare": "husky"
   },