zod-to-x 1.4.2 → 1.4.4

package/README.md

@@ -27,8 +27,8 @@
 - [Intersections and Unions](#intersections-and-unions)
 - [Layered modeling](#layered-modeling) <sup>*(new)*</sup>
 - [Supported output languages](#supported-output-languages)
-- [Mapping of supported Zod Types](#mapping-of-supported-zod-types)
 - [Additional utils](#additional-utils)
+- [Mapping of supported Zod Types by Language](#mapping-of-supported-zod-types-by-langauge)
 
 
 
@@ -126,13 +126,6 @@ console.log(tsVisitorAsClass)
 ```
 
 
-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++ outputs](test/test_zod2cpp/)
-
-
 
 ## Intersections and Unions
 Starting from `v1.3.0`, a best practices helper is enabled by default when handling data intersections and unions:
@@ -281,7 +274,7 @@ class UserModels extends Zod2XModel {
 }
 
 const userModels = new UserModels();
-console.log(userModels.transpile(Transpilers.Zod2Ts));
+console.log(userModels.transpile(Zod2XTranspilers.Zod2Ts));
 // Output:
 // export enum UserRole {
 //     Admin = "Admin",
@@ -353,6 +346,8 @@ console.log(userDtos.transpile(Zod2XTranspilers.Zod2Ts))
 3 - Are your models too large? Simplify them!  
 If you are dealing with complex models whose definitions are too extensive, split them into multiple classes and then combine them using `Zod2XMixin` as shown below:
 ```ts
+import { Zod2XMixin } from "zod-to-x";
+
 // Sub-models do not require a layer decorator; it is applied automatically when inherited by the main model.
 
 // Sub-model 1
@@ -480,190 +475,81 @@ Common options:
 ### 1) Typescript  
 - Options:
   - **outType**: Output transpilation using Typescript interfaces or Classes. Defaults to `interface`.
+  - **keepKeys**: Specifies whether property names should follow the TypeScript naming convention (false) or remain as originally defined (true). The default is `false`.
+- [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2ts)
 
-### 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:
-  - `ZodTuple` is supported only for items of the same type.
-
-
-### 3) C++
+### 2) 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`.
+  - **keepKeys**: Specifies whether property names should follow the C++ naming convention (false) or remain as originally defined (true). The default is `false`.
+- [Examples](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2cpp)
 
 
 
-## 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                              | `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()` <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> 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`  
-In case of use of libraries like [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema), the provided zod extension can also be used
-as a JSON Schema definitions mapper:
+Additional useful tools to convert Zod Schemas into different formats.
+
+### 1) `zod2JsonSchemaDefinitions`  
+In case of use of libraries like [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema), the provided zod extension can also be used as a JSON Schema definitions mapper. Check out this [input example](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2jschema_def/user_schema.ts) and its [output](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2jschema_def/user_schema.json) (\*).
+
+<sup>*(\*) Output is generated using definitions from `zod2JsonSchemaDefinitions` and [`@zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema) to create the schema with them.*</sup>
+
 ```ts
 import { z } from 'zod';
-import { extendZod, zod2JsonSchemaDefinitions } from 'zod-to-x';
+import { extendZod, Zod2XConverters } from 'zod-to-x';
 import { zodToJsonSchema } from 'zod-to-json-schema';
+extendZod(z);
+
+// Example using model from `Quick-start` section
+const visitorDefinitions = Zod2XConverters.zod2JsonSchemaDefinitions(VisitorSchema);
+const visitorJsonSchema = zodToJsonSchema(
+  VisitorSchema,
+  {definitions: visitorDefinitions}
+);
+console.log(visitorJsonSchema); // JSON Schema with definitions
+
+// Example using model from `Layer modeling` section
+const createUserDtoDefinitions = Zod2XConverters.zod2JsonSchemaDefinitions(userDtos.createUserUseCaseDto);
+const createUserDtoJsonSchema = zodToJsonSchema(
+  userDtos.createUserUseCaseDto,
+  {definitions: createUserDtoDefinitions}
+);
+console.log(createUserDtoJsonSchema); // JSON Schema with definitions
+```
+
+### 2) `zod2ProtoV3`
+In case of use of Google protobuf to improve communication performance, you can automatically generate `proto` files directly from your models. Check out this [input example](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2proto3/proto3_supported_schemas.ts) and its [output](https://github.com/rroumenov/zod-to-x/blob/main/test/test_zod2proto3/proto3_supported_schemas.expect.proto)
 
+- Options:
+  - **packageName**: Name of the protobuf file package.
+  - **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.
+  - **keepKeys**: Specifies whether property names should follow the Google Protobuf naming convention (false) or remain as originally defined (true). The default is `false`.
+
+- Limitations:
+  - ZodTuple is supported only for items of the same type.
+
+```ts
+import { z } from 'zod';
+import { extendZod, Zod2XConverters } from 'zod-to-x';
+import { zodToJsonSchema } from 'zod-to-json-schema';
 extendZod(z);
 
-const Address = z.object({
-    street: z.string(),
-    city: z.string(),
-    zipCode: z.string().nullable(),
-}).zod2x("UserAddress");
-
-const UserRole = z.union([
-    z.literal('admin'),
-    z.literal('editor'),
-    z.literal('viewer')
-]).zod2x("UserRole");
-
-const StatusEnum = z.enum([
-    'active',
-    'inactive',
-    'pending']
-)
-.describe("This is a UserStatus enumerate description.")
-.zod2x("UserStatus");
-
-export const UserModel = z.object({
-    address: Address,
-    roles: z.array(UserRole),
-    status: StatusEnum,
-    friends: z.lazy((): ZodType => UserModel.array().optional().nullable()),
-  // [... more attributes]
-})
-.describe("This is a UserModel interface description.")
-.zod2x("UserModel");
-
-const userDefinitions = zod2JsonSchemaDefinitions(UserModel);
-const userJsonSchema = zodToJsonSchema(UserModel, {definitions: userDefinitions});
-console.log(userJsonSchema);
-// output:
-// {
-//   "$ref": "#/definitions/UserModel",
-//   "definitions": {
-//     "UserAddress": {
-//       "type": "object",
-//       "properties": {
-//         "street": {
-//           "type": "string"
-//         },
-//         "city": {
-//           "type": "string"
-//         },
-//         "zipCode": {
-//           "type": [
-//             "string",
-//             "null"
-//           ]
-//         }
-//       },
-//       "required": [
-//         "street",
-//         "city",
-//         "zipCode"
-//       ],
-//       "additionalProperties": false
-//     },
-//     "UserRole": {
-//       "type": "string",
-//       "enum": [
-//         "admin",
-//         "editor",
-//         "viewer"
-//       ]
-//     },
-//     "UserStatus": {
-//       "type": "string",
-//       "enum": [
-//         "active",
-//         "inactive",
-//         "pending"
-//       ],
-//       "description": "This is a UserStatus enumerate description."
-//     },
-//     "UserModel": {
-//       "type": "object",
-//       "properties": {
-//         "address": {
-//           "$ref": "#/definitions/UserAddress"
-//         },
-//         "roles": {
-//           "type": "array",
-//           "items": {
-//             "$ref": "#/definitions/UserRole"
-//           }
-//         },
-//         "status": {
-//           "$ref": "#/definitions/UserStatus"
-//         },
-//         "friends": {
-//           "anyOf": [
-//             {
-//               "anyOf": [
-//                 {
-//                   "not": {}
-//                 },
-//                 {
-//                   "type": "array",
-//                   "items": {
-//                     "$ref": "#/definitions/UserModel"
-//                   },
-//                   "description": "This is a UserModel interface description."
-//                 }
-//               ],
-//               "description": "This is a UserModel interface description."
-//             },
-//             {
-//               "type": "null"
-//             }
-//           ],
-//           "description": "This is a UserModel interface description."
-//         },
-//       },
-//       "required": [
-//         "address",
-//         "roles",
-//         "status",
-//       ],
-//       "additionalProperties": false,
-//       "description": "This is a UserModel interface description."
-//     }
-//   },
-//   "$schema": "http://json-schema.org/draft-07/schema#"
-// }
-```
+// Example using model from `Quick-start` section
+const visitorProtobuf = Zod2XConverters.zod2ProtoV3(VisitorSchema);
+console.log(visitorProtobuf); // Proto file of Visitor's model
+
+// Example using model from `Layer modeling` section
+const createUserDtoProtobuf = Zod2XConverters.zod2ProtoV3(userDtos.createUserUseCaseDto);
+console.log(createUserDtoProtobuf); // Proto file of CreateUserUseCaseDto's model
+```
+
+
+
+## Mapping of supported Zod Types by Langauge
+For a detailed mapping of supported Zod types across supported targets, please refer to the [SUPPORTED_ZOD_TYPES.md](https://github.com/rroumenov/zod-to-x/blob/main/SUPPORTED_ZOD_TYPES.md) file.

package/dist/converters/index.d.ts

@@ -0,0 +1,2 @@
+export { zod2ProtoV3 } from "./protobuf_v3/runner";
+export { zod2JsonSchemaDefinitions } from "./json_schema_definitions";

package/dist/converters/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zod2JsonSchemaDefinitions = exports.zod2ProtoV3 = void 0;
+var runner_1 = require("./protobuf_v3/runner");
+Object.defineProperty(exports, "zod2ProtoV3", { enumerable: true, get: function () { return runner_1.zod2ProtoV3; } });
+var json_schema_definitions_1 = require("./json_schema_definitions");
+Object.defineProperty(exports, "zod2JsonSchemaDefinitions", { enumerable: true, get: function () { return json_schema_definitions_1.zod2JsonSchemaDefinitions; } });

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

@@ -0,0 +1,13 @@
+import { IZodToXOpt } from "../../core";
+export interface IZod2ProtoV3Opt extends IZodToXOpt {
+    /**
+     * Name of the protobuf file package.
+     */
+    packageName?: string;
+    /**
+     * By default (false), structure/class property names are converted according to the target
+     * language's naming conventions. If set to true, the original property names are preserved.
+     */
+    keepKeys?: boolean;
+}
+export declare const defaultOpts: IZod2ProtoV3Opt;

package/dist/{transpilers → converters}/protobuf_v3/options.js

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

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

@@ -0,0 +1,20 @@
+import { ZodObject, ZodRawShape } from "zod";
+import { IZod2AstOpt } from "../../core";
+import { IZod2ProtoV3Opt } from "./options";
+/**
+ * Converts a Zod schema into a Protocol Buffers v3 definition.
+ *
+ * @template T - The shape of the Zod schema.
+ * @param schema - The Zod object schema to be converted.
+ * @param opt - Optional configuration for the conversion process.
+ * @param opt.strict - Whether to enforce strict mode during AST generation.
+ * @param opt.packageName - The package name to use in the generated Protocol Buffers definition.
+ * @param opt.keepKeys - Whether to keep the original property names in the generated file instead
+ *                       of converting them to snake_case as per Protobuf conventions.
+ * @param opt.header - Custom header text to include in the generated file.
+ * @param opt.indent - The indentation style to use in the generated file.
+ * @param opt.includeComments - Whether to include comments in the generated Protocol Buffers
+ *                              definition.
+ * @returns The Protocol Buffers v3 definition as a string.
+ */
+export declare function zod2ProtoV3<T extends ZodRawShape>(schema: ZodObject<T>, opt?: Pick<IZod2AstOpt, "strict"> & Pick<IZod2ProtoV3Opt, "packageName" | "keepKeys" | "header" | "indent" | "includeComments">): string;

package/dist/{transpilers → converters}/protobuf_v3/runner.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Zod2ProtoV3 = void 0;
+exports.zod2ProtoV3 = zod2ProtoV3;
 const case_1 = __importDefault(require("case"));
 const core_1 = require("../../core");
 const number_limits_1 = require("../../utils/number_limits");
+const string_utils_1 = __importDefault(require("../../utils/string_utils"));
 const options_1 = require("./options");
 const allowedKeyTypes = [
     "int32",
@@ -22,10 +23,6 @@ const allowedKeyTypes = [
     "bool",
     "string",
 ];
-/**
- * @deprecated Zod2ProtoV3 will not be considered as a transpilerable programming language, but as
- *             another utility such as `zod2JsonSchemaDefinitions`.
- */
 class Zod2ProtoV3 extends core_1.Zod2X {
     constructor(opt = {}) {
         super(Object.assign(Object.assign({}, options_1.defaultOpts), opt));
@@ -198,9 +195,9 @@ class Zod2ProtoV3 extends core_1.Zod2X {
             throw new core_1.NotTranspilerableTypeError("Map and Repeated fields are not suported by Protobuf oneOf");
         }
         this.push0(`message ${data.name} {`);
-        this.push1(`oneof ${this._adaptField(data.name + "Oneof")} {`);
+        this.push1(`oneof ${string_utils_1.default.lowerFirstChar(this._adaptField(data.name + "Oneof"))} {`);
         attributesTypes.forEach((item, index) => {
-            this.push2(`${item} ${this._adaptField(item)} = ${index + 1};`);
+            this.push2(`${item} ${string_utils_1.default.lowerFirstChar(this._adaptField(item))} = ${index + 1};`);
         });
         this.push1(`}`);
         this.push0("}\n");
@@ -219,12 +216,31 @@ class Zod2ProtoV3 extends core_1.Zod2X {
      * @returns
      */
     _adaptField(fieldName) {
-        if (this.opt.useCamelCase) {
-            return case_1.default.camel(fieldName);
+        if (this.opt.keepKeys === true) {
+            return fieldName;
         }
         else {
             return case_1.default.snake(fieldName);
         }
     }
 }
-exports.Zod2ProtoV3 = Zod2ProtoV3;
+/**
+ * Converts a Zod schema into a Protocol Buffers v3 definition.
+ *
+ * @template T - The shape of the Zod schema.
+ * @param schema - The Zod object schema to be converted.
+ * @param opt - Optional configuration for the conversion process.
+ * @param opt.strict - Whether to enforce strict mode during AST generation.
+ * @param opt.packageName - The package name to use in the generated Protocol Buffers definition.
+ * @param opt.keepKeys - Whether to keep the original property names in the generated file instead
+ *                       of converting them to snake_case as per Protobuf conventions.
+ * @param opt.header - Custom header text to include in the generated file.
+ * @param opt.indent - The indentation style to use in the generated file.
+ * @param opt.includeComments - Whether to include comments in the generated Protocol Buffers
+ *                              definition.
+ * @returns The Protocol Buffers v3 definition as a string.
+ */
+function zod2ProtoV3(schema, opt = {}) {
+    const astNode = new core_1.Zod2Ast({ strict: opt.strict }).build(schema);
+    return new Zod2ProtoV3(opt).transpile(astNode);
+}

package/dist/core/ast_node.d.ts

@@ -44,9 +44,13 @@ export declare class Zod2Ast {
     private _getTranspilerableFile;
     /**
      * Transpilerable items are treated as references in the AST
-     * @param ref
-     * @param refType
-     * @param discriminantValue
+     * @param ref - Output type name
+     * @param refType - Type of the output type
+     * @param discriminantValue - Discriminant value (for ZodDiscriminatedUnion)
+     * @param parentNamespace - For Layered modeling, the namespace of the parent type if does not
+     *                          belong to the same file.
+     * @param parentFile - For Layered modeling, the file of the parent type if does not belong to
+     *                      the same file.
      * @returns
      */
     private _createDefinition;

package/dist/core/ast_node.js

@@ -27,17 +27,38 @@ class Zod2Ast {
      */
     _getTranspilerableFile(itemName, metadata) {
         var _a;
-        const layer = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.parentLayer) !== null && _a !== void 0 ? _a : metadata === null || metadata === void 0 ? void 0 : metadata.layer;
-        if (this.opt.layer && layer) {
-            if (this.opt.layer.index < layer.index) {
-                throw new errors_1.BadLayerDefinitionError(`${itemName}: Layer with number ${this.opt.layer.index} can only use models` +
-                    `from the same or lower layer. Found layer with number ${layer.index}`);
+        let layer;
+        if (this.opt.layer !== undefined && (metadata === null || metadata === void 0 ? void 0 : metadata.layer) !== undefined) {
+            if (metadata.layer.file === this.opt.layer.file) {
+                // Case 1: Only layer exists and belongs to the same file
+                // Case 2: Layer (belongs to same file) and parentLayer exist
+                // Behaviour: New type is created extending the parent layer (if any)
+                layer = (_a = metadata.parentLayer) !== null && _a !== void 0 ? _a : metadata.layer;
+                if (this.opt.layer.index < layer.index) {
+                    throw new errors_1.BadLayerDefinitionError(`${itemName}: Layer with number ${this.opt.layer.index} can only use models` +
+                        `from the same or lower layer. Found layer with number ${layer.index}`);
+                }
+                if (this.opt.layer.file !== layer.file) {
+                    return {
+                        parentFile: layer.file,
+                        parentNamespace: layer.namespace,
+                        parentTypeName: metadata === null || metadata === void 0 ? void 0 : metadata.parentTypeName,
+                    };
+                }
             }
-            if (this.opt.layer.file !== layer.file) {
+            else {
+                // Case 3: Only layer exists and belongs to a different file
+                // Case 4: Layer (belongs to different file) and parentLayer exist
+                // Behaviour: Type is imported from Layer file
+                layer = metadata.layer;
+                if (this.opt.layer.index < layer.index) {
+                    throw new errors_1.BadLayerDefinitionError(`${itemName}: Layer with number ${this.opt.layer.index} can only use models` +
+                        `from the same or lower layer. Found layer with number ${layer.index}`);
+                }
                 return {
                     parentFile: layer.file,
                     parentNamespace: layer.namespace,
-                    parentTypeName: metadata === null || metadata === void 0 ? void 0 : metadata.parentTypeName,
+                    parentTypeName: undefined,
                 };
             }
         }
@@ -45,18 +66,23 @@ class Zod2Ast {
     }
     /**
      * Transpilerable items are treated as references in the AST
-     * @param ref
-     * @param refType
-     * @param discriminantValue
+     * @param ref - Output type name
+     * @param refType - Type of the output type
+     * @param discriminantValue - Discriminant value (for ZodDiscriminatedUnion)
+     * @param parentNamespace - For Layered modeling, the namespace of the parent type if does not
+     *                          belong to the same file.
+     * @param parentFile - For Layered modeling, the file of the parent type if does not belong to
+     *                      the same file.
      * @returns
      */
-    _createDefinition(ref, refType, discriminantValue, parentNamespace) {
+    _createDefinition(ref, refType, discriminantValue, parentNamespace, parentFile) {
         return {
             type: "definition",
             reference: ref,
             referenceType: refType,
             discriminantValue,
             parentNamespace,
+            parentFile,
         };
     }
     /**
@@ -170,7 +196,7 @@ class Zod2Ast {
         if (!this.nodes.has(name)) {
             this.nodes.set(name, item);
         }
-        return this._createDefinition(name, zodTypeName, undefined, parentNamespace);
+        return this._createDefinition(name, zodTypeName, undefined, parentNamespace, parentFile);
     }
     _getObjectAst(schema, opt) {
         const { name, zodTypeName, parentFile, parentNamespace, parentTypeName } = this._getNames(schema, "ZodObject type must have a typeName. Use zod2x method to provide one.");
@@ -205,7 +231,7 @@ class Zod2Ast {
                 }
             }
         }
-        return this._createDefinition(name, zodTypeName, discriminantValue, parentTypeName ? undefined : parentNamespace);
+        return this._createDefinition(name, zodTypeName, discriminantValue, parentTypeName ? undefined : parentNamespace, parentTypeName ? undefined : parentFile);
     }
     _getUnionAst(schema) {
         const def = schema._def;
@@ -241,7 +267,7 @@ class Zod2Ast {
         if (name && !this.nodes.has(name)) {
             this.nodes.set(name, item);
         }
-        return this._createDefinition(name, zodTypeName, undefined, parentTypeName ? undefined : parentNamespace);
+        return this._createDefinition(name, zodTypeName, undefined, parentTypeName ? undefined : parentNamespace, parentTypeName ? undefined : parentFile);
     }
     _getIntersectionAst(schema) {
         const def = schema._def;
@@ -274,7 +300,7 @@ class Zod2Ast {
         if (name && !this.nodes.has(name)) {
             this.nodes.set(name, item);
         }
-        return this._createDefinition(name, zodTypeName, undefined, parentTypeName ? undefined : parentNamespace);
+        return this._createDefinition(name, zodTypeName, undefined, parentTypeName ? undefined : parentNamespace, parentTypeName ? undefined : parentFile);
     }
     /**
      * Build the AST node of provided Zod Schema

package/dist/core/ast_types.d.ts

@@ -116,12 +116,7 @@ export type ASTDefintion = ASTCommon & {
     reference: string;
     referenceType: ZodFirstPartyTypeKind;
     discriminantValue?: string;
-    /**
-     * Namespace where the transpilerable model is defined. Used to use import statements in the
-     * transpiled code.
-     */
-    parentNamespace?: string;
-};
+} & Omit<ASTLayerMetadata, "parentTypeName">;
 /**
  * Represents a general AST node, encompassing various Zod schema types.
  */

package/dist/core/transpiler.d.ts

@@ -187,6 +187,14 @@ export declare abstract class Zod2X<T extends IZodToXOpt> {
      * @returns A string representing the type in the target language.
      */
     protected getAttributeType(token: ASTNode | TranspilerableTypes): string;
+    /**
+     * Determines whether a given type is an external type import.
+     *
+     * @param item - An object containing the `parentFile` and `parentNamespace`
+     *               properties of the type to evaluate.
+     * @returns `true` if the type is an external type import; otherwise, `false`.
+     */
+    protected isExternalTypeImport(item: Pick<TranspilerableTypes, "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.
@@ -195,7 +203,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: TranspilerableTypes): boolean;
+    protected addExternalTypeImport(item: Pick<TranspilerableTypes, "parentFile" | "parentNamespace">): boolean;
     /**
      * Transpiles a single item from the transpiler queue.
      * @param item - The transpilerable type to transpile.

package/dist/core/transpiler.js

@@ -55,10 +55,16 @@ class Zod2X {
             varType = token.name;
         }
         else if (token.type === "definition") {
-            varType =
-                this.opt.useImports === true && token.parentNamespace
-                    ? this.getTypeFromExternalNamespace(token.parentNamespace, token.reference)
-                    : token.reference;
+            if (this.opt.useImports === true && token.parentNamespace) {
+                varType = this.getTypeFromExternalNamespace(token.parentNamespace, token.reference);
+                this.addExternalTypeImport({
+                    parentNamespace: token.parentNamespace,
+                    parentFile: token.parentFile,
+                });
+            }
+            else {
+                varType = token.reference;
+            }
         }
         else if (token.type === zod_1.ZodFirstPartyTypeKind.ZodString) {
             varType = this.getStringType();
@@ -106,6 +112,18 @@ class Zod2X {
         }
         return token.arrayDimension ? this.getArrayType(varType, token.arrayDimension) : varType;
     }
+    /**
+     * Determines whether a given type is an external type import.
+     *
+     * @param item - An object containing the `parentFile` and `parentNamespace`
+     *               properties of the type to evaluate.
+     * @returns `true` if the type is an external type import; otherwise, `false`.
+     */
+    isExternalTypeImport(item) {
+        return (item.parentFile !== undefined &&
+            item.parentNamespace !== undefined &&
+            this.opt.useImports !== false);
+    }
     /**
      * 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.
@@ -115,7 +133,7 @@ class Zod2X {
      * @returns `true` if the import was successfully added, otherwise `false`.
      */
     addExternalTypeImport(item) {
-        if (item.parentFile && item.parentNamespace && this.opt.useImports !== false) {
+        if (this.isExternalTypeImport(item)) {
             this.imports.add(this.addImportFromFile(item.parentFile, item.parentNamespace));
             return true;
         }

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export { Zod2Ast } from "./core/ast_node";
 export { Zod2X } from "./core/transpiler";
 export * from "./layered-modeling";
 export * as Zod2XTranspilers from "./transpilers";
-export { zod2JsonSchemaDefinitions } from "./utils/json_schema_definitions";
+export * as Zod2XConverters from "./converters";

package/dist/index.js

@@ -15,18 +15,28 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zod2JsonSchemaDefinitions = exports.Zod2XTranspilers = exports.Zod2X = exports.Zod2Ast = exports.Zod2XTypes = exports.extendZod = void 0;
+exports.Zod2XConverters = exports.Zod2XTranspilers = exports.Zod2X = exports.Zod2Ast = exports.Zod2XTypes = exports.extendZod = void 0;
 // Core
 var zod_ext_1 = require("./lib/zod_ext");
 Object.defineProperty(exports, "extendZod", { enumerable: true, get: function () { return zod_ext_1.extendZod; } });
@@ -38,6 +48,5 @@ Object.defineProperty(exports, "Zod2X", { enumerable: true, get: function () { r
 __exportStar(require("./layered-modeling"), exports);
 // Transpilers
 exports.Zod2XTranspilers = __importStar(require("./transpilers"));
-// Utilities
-var json_schema_definitions_1 = require("./utils/json_schema_definitions");
-Object.defineProperty(exports, "zod2JsonSchemaDefinitions", { enumerable: true, get: function () { return json_schema_definitions_1.zod2JsonSchemaDefinitions; } });
+// Converters
+exports.Zod2XConverters = __importStar(require("./converters"));

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

@@ -42,7 +42,6 @@ export declare class Zod2XModel {
      */
     transpile(target: Target<"Zod2Cpp">, opt?: TargetOpt<"Zod2Cpp">, astOpt?: AstOpt): string;
     transpile(target: Target<"Zod2Cpp17">, opt?: TargetOpt<"Zod2Cpp17">, astOpt?: AstOpt): string;
-    transpile(target: Target<"Zod2ProtoV3">, opt?: TargetOpt<"Zod2ProtoV3">, astOpt?: AstOpt): string;
     transpile(target: Target<"Zod2Ts">, opt?: TargetOpt<"Zod2Ts">, astOpt?: AstOpt): string;
 }
 export {};

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

@@ -20,5 +20,10 @@ export interface IZod2CppOpt extends IZodToXOpt {
      * Remove Nlohmann JSON serialization/deserialization. Default is false.
      */
     skipSerialize?: boolean;
+    /**
+     * By default (false), structure/class property names are converted according to the target
+     * language's naming conventions. If set to true, the original property names are preserved.
+     */
+    keepKeys?: boolean;
 }
 export declare const defaultOpts: IZod2CppOpt;

package/dist/transpilers/cpp/options.js

@@ -8,4 +8,5 @@ exports.defaultOpts = {
     namespace: "zodtocpp",
     outType: "struct",
     includeNulls: false,
+    keepKeys: false,
 };

package/dist/transpilers/cpp/runner.js

@@ -166,7 +166,7 @@ class Zod2Cpp extends core_1.Zod2X {
      *  }
      */
     transpileEnum(data) {
-        if (this.addExternalTypeImport(data)) {
+        if (this.isExternalTypeImport(data)) {
             return;
         }
         this.addComment(data.description);
@@ -196,7 +196,7 @@ class Zod2Cpp extends core_1.Zod2X {
      *  }
      */
     transpileIntersection(data) {
-        if (this.addExternalTypeImport(data)) {
+        if (this.isExternalTypeImport(data)) {
             if (data.parentTypeName) {
                 this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName);
             }
@@ -232,7 +232,7 @@ class Zod2Cpp extends core_1.Zod2X {
     }
     /** Ex: using TypeC = boost::variant<TypeA, TypeB> */
     transpileUnion(data) {
-        if (this.addExternalTypeImport(data)) {
+        if (this.isExternalTypeImport(data)) {
             if (data.parentTypeName) {
                 this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName, true);
             }
@@ -251,7 +251,7 @@ class Zod2Cpp extends core_1.Zod2X {
         this._createUnionDeserializer(data.name, attributesData, data.discriminantKey);
     }
     transpileStruct(data) {
-        if (this.addExternalTypeImport(data)) {
+        if (this.isExternalTypeImport(data)) {
             if (data.parentTypeName) {
                 this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName);
             }
@@ -275,7 +275,7 @@ class Zod2Cpp extends core_1.Zod2X {
         this.push0(`struct ${data.name} {`);
         const serializeData = [];
         Object.entries(data.properties).forEach(([key, value]) => {
-            const snakeName = case_1.default.snake(key);
+            const snakeName = this.opt.keepKeys === true ? key : case_1.default.snake(key);
             const origType = this._transpileMember(snakeName, value);
             serializeData.push({
                 origName: key,
@@ -310,7 +310,7 @@ class Zod2Cpp extends core_1.Zod2X {
         const setterGetter = [];
         const serializeData = [];
         Object.entries(data.properties).forEach(([key, value]) => {
-            const snakeName = case_1.default.snake(key);
+            const snakeName = this.opt.keepKeys === true ? key : case_1.default.snake(key);
             const origType = this._transpileMember(snakeName, value);
             setterGetter.push(...this._createSetterGetter(snakeName, origType, !(value.isNullable || value.isOptional)));
             serializeData.push({
@@ -351,7 +351,7 @@ class Zod2Cpp extends core_1.Zod2X {
         if (memberNode.isOptional || memberNode.isNullable) {
             keyType = this._getOptional(keyType);
         }
-        this.push1(`${keyType} ${case_1.default.snake(memberName)};`);
+        this.push1(`${keyType} ${memberName};`);
         return origType;
     }
     /**

package/dist/transpilers/index.d.ts

@@ -1,3 +1,2 @@
 export { Zod2Ts } from "./typescript/runner";
-export { Zod2ProtoV3 } from "./protobuf_v3/runner";
 export { Zod2Cpp, Zod2Cpp17 } from "./cpp/runner";

package/dist/transpilers/index.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Zod2Cpp17 = exports.Zod2Cpp = exports.Zod2ProtoV3 = exports.Zod2Ts = void 0;
+exports.Zod2Cpp17 = exports.Zod2Cpp = exports.Zod2Ts = void 0;
 var runner_1 = require("./typescript/runner");
 Object.defineProperty(exports, "Zod2Ts", { enumerable: true, get: function () { return runner_1.Zod2Ts; } });
-var runner_2 = require("./protobuf_v3/runner");
-Object.defineProperty(exports, "Zod2ProtoV3", { enumerable: true, get: function () { return runner_2.Zod2ProtoV3; } });
-var runner_3 = require("./cpp/runner");
-Object.defineProperty(exports, "Zod2Cpp", { enumerable: true, get: function () { return runner_3.Zod2Cpp; } });
-Object.defineProperty(exports, "Zod2Cpp17", { enumerable: true, get: function () { return runner_3.Zod2Cpp17; } });
+var runner_2 = require("./cpp/runner");
+Object.defineProperty(exports, "Zod2Cpp", { enumerable: true, get: function () { return runner_2.Zod2Cpp; } });
+Object.defineProperty(exports, "Zod2Cpp17", { enumerable: true, get: function () { return runner_2.Zod2Cpp17; } });

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

@@ -4,5 +4,10 @@ export interface IZod2TsOpt extends IZodToXOpt {
      * Output transpilation using Typescript interfaces or Classes.
      */
     outType?: "interface" | "class";
+    /**
+     * By default (false), structure/class property names are converted according to the target
+     * language's naming conventions. If set to true, the original property names are preserved.
+     */
+    keepKeys?: boolean;
 }
 export declare const defaultOpts: IZod2TsOpt;

package/dist/transpilers/typescript/options.js

@@ -6,4 +6,5 @@ exports.defaultOpts = {
     indent: 4,
     useImports: true,
     outType: "interface",
+    keepKeys: false,
 };

package/dist/transpilers/typescript/runner.js

@@ -91,7 +91,7 @@ class Zod2Ts extends core_1.Zod2X {
      *  }
      */
     transpileEnum(data) {
-        if (this.addExternalTypeImport(data)) {
+        if (this.isExternalTypeImport(data)) {
             return;
         }
         this.addComment(data.description);
@@ -123,7 +123,7 @@ class Zod2Ts extends core_1.Zod2X {
      * */
     transpileIntersection(data) {
         var _a;
-        if (this.addExternalTypeImport(data)) {
+        if (this.isExternalTypeImport(data)) {
             if (data.parentTypeName) {
                 this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName);
             }
@@ -140,7 +140,7 @@ class Zod2Ts extends core_1.Zod2X {
         }
     }
     transpileStruct(data) {
-        if (this.addExternalTypeImport(data)) {
+        if (this.isExternalTypeImport(data)) {
             if (data.parentTypeName) {
                 this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName);
             }
@@ -171,7 +171,7 @@ class Zod2Ts extends core_1.Zod2X {
      * */
     transpileUnion(data) {
         var _a;
-        if (this.addExternalTypeImport(data)) {
+        if (this.isExternalTypeImport(data)) {
             if (data.parentTypeName) {
                 this.addExtendedType(data.name, data.parentNamespace, data.parentTypeName, {
                     isUnion: data.type === zod_1.ZodFirstPartyTypeKind.ZodUnion,
@@ -199,7 +199,7 @@ class Zod2Ts extends core_1.Zod2X {
     _transpileStructuAsInterface(data) {
         this.push0(`export interface ${data.name} {`);
         for (const [key, value] of Object.entries(data.properties)) {
-            this._transpileMember(case_1.default.camel(key), value);
+            this._transpileMember(this.opt.keepKeys === true ? key : case_1.default.camel(key), value);
         }
         this.push0("}\n");
     }
@@ -218,8 +218,9 @@ class Zod2Ts extends core_1.Zod2X {
         this.push0(`export class ${data.name} {`);
         const constructorBody = [];
         for (const [key, value] of Object.entries(data.properties)) {
-            this._transpileMember(key, value);
-            constructorBody.push(`this.${key} = data.${key};`);
+            const keyName = this.opt.keepKeys === true ? key : case_1.default.camel(key);
+            this._transpileMember(keyName, value);
+            constructorBody.push(`this.${keyName} = data.${keyName};`);
         }
         this.push0("");
         this.push1(`constructor(data: ${data.name}) {`);

package/dist/utils/string_utils.d.ts

@@ -10,4 +10,12 @@ export default class StringUtils {
      *          size.
      */
     static getIndentationLevels(indentSize: number): [string, string, string, string, string];
+    /**
+     * Converts the first character of a string to lowercase while leaving the rest of the string
+     * unchanged.
+     *
+     * @param str - The input string to process.
+     * @returns A new string with the first character converted to lowercase.
+     */
+    static lowerFirstChar(str: string): string;
 }

package/dist/utils/string_utils.js

@@ -18,5 +18,17 @@ class StringUtils {
             " ".repeat(indentSize * 4),
         ];
     }
+    /**
+     * Converts the first character of a string to lowercase while leaving the rest of the string
+     * unchanged.
+     *
+     * @param str - The input string to process.
+     * @returns A new string with the first character converted to lowercase.
+     */
+    static lowerFirstChar(str) {
+        if (str.length === 0)
+            return str;
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
 }
 exports.default = StringUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [
@@ -61,6 +61,7 @@
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.10",
     "tsconfig-paths": "4.2.0",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "zod-to-json-schema": "^3.21.4"
   }
 }

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

@@ -1,12 +0,0 @@
-import { IZodToXOpt } from "../../core";
-export interface IZod2ProtoV3Opt extends Omit<IZodToXOpt, "skipDiscriminatorNodes"> {
-    /**
-     * Name of the protobuf file package.
-     */
-    packageName?: string;
-    /**
-     * Protobuf follows the snake_case convention for field names, but camelCase can also be used.
-     */
-    useCamelCase?: boolean;
-}
-export declare const defaultOpts: IZod2ProtoV3Opt;

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

@@ -1,80 +0,0 @@
-import { ASTCommon, ASTDiscriminatedUnion, ASTEnum, ASTIntersection, ASTNativeEnum, ASTObject, ASTUnion, Zod2X } from "../../core";
-import { IZod2ProtoV3Opt } from "./options";
-/**
- * @deprecated Zod2ProtoV3 will not be considered as a transpilerable programming language, but as
- *             another utility such as `zod2JsonSchemaDefinitions`.
- */
-export declare class Zod2ProtoV3 extends Zod2X<IZod2ProtoV3Opt> {
-    constructor(opt?: IZod2ProtoV3Opt);
-    protected getUnionType: () => string;
-    protected addImportFromFile(filename: string, namespace: string): string;
-    protected getTypeFromExternalNamespace(namespace: string, typeName: string): string;
-    protected addExtendedType(name: string, parentNamespace: string, parentTypeName: string): void;
-    protected getComment: (data: string, indent?: string) => string;
-    protected getBooleanType: () => string;
-    protected getStringType: () => string;
-    protected getNumberType: (isInt: boolean, range: {
-        min?: number;
-        max?: number;
-    }) => string;
-    protected getAnyType: () => string;
-    protected getDateType: () => string;
-    protected getSetType: (itemType: string) => string;
-    /**
-     * @description Determines the equivalent Protobuf type for a tuple based on its item types.
-     *
-     * Protobuf v3 does not directly support tuples. However, if all the types
-     * in the tuple are identical, it can be represented as a `repeated` field
-     * of that type. If the tuple contains mixed types, Protobuf cannot represent
-     * it directly, and an alternative approach (e.g., defining a Protobuf message)
-     * should be considered.
-     *
-     * @param itemsType - An array of strings representing the types of the tuple elements.
-     * @returns A string representing the Protobuf type for the tuple.
-     *          If all tuple elements are of the same type, it returns a `repeated` field of that
-     *          type.
-     * @throws NotTranspilerableTypeError if the tuple contains mixed types.
-     */
-    protected getTupleType: (itemsType: string[]) => string;
-    protected getIntersectionType: (itemsType: string[]) => string;
-    protected getArrayType(arrayType: string, arrayDeep: number): string;
-    protected getLiteralStringType(value: string | number): string | number;
-    protected getMapType(keyType: string, valueType: string): string;
-    protected getRecordType(keyType: string, valueType: string): string;
-    protected transpileEnum(data: (ASTEnum | ASTNativeEnum) & ASTCommon): void;
-    protected transpileIntersection(data: ASTIntersection & ASTCommon): void;
-    protected transpileStruct(data: ASTObject & ASTCommon): void;
-    /**
-     * Transpiles a Zod union or discriminated union into a Protobuf-compatible `oneof` message.
-     *
-     * @limitations Currently supports `oneOf` for options that can be represented as a
-     *              Protobuf message or enum. Other types are not yet supported.
-     * @param data  The AST representation of a union or discriminated union, including its
-     *              common metadata.
-     * @example
-     * Input:
-     * {
-     *   name: "UserContact",
-     *   options: ["EmailContact", "PhoneContact", "SocialContact"],
-     *   description: "Represents different ways to contact a user."
-     * }
-     *
-     * Generated Output:
-     * message UserContact {
-     *   oneof user_contact_oneof {
-     *     EmailContact email_contact = 1;
-     *     PhoneContact phone_contact = 2;
-     *     SocialContact social_contact = 3;
-     *   }
-     * }
-     */
-    protected transpileUnion(data: (ASTUnion | ASTDiscriminatedUnion) & ASTCommon): void;
-    protected runBefore(): void;
-    protected runAfter(): void;
-    /**
-     * Adapt field name according to user input.
-     * @param fieldName
-     * @returns
-     */
-    private _adaptField;
-}