zod-to-x 2.5.0 → 2.6.0

package/README.md

@@ -601,6 +601,21 @@ readonly DiscriminantDataRetrieve = z.lazy(() =>  // Lazy the zod type itself
 //   | HttpSuccessfulResponse<SomeDtoResult>
 //   | HttpUnsuccessfulResponse;
 ```
+4) A default type can be provided as the second argument of `createGenericType`. It can be any supported type: a basic type, an array, a named type, ... Templates with a default type can be omitted in `useGenericType`, and the default type is used instead. The default is applied when the generic type is instantiated, so the output is valid for all supported languages, including the ones without default type parameters (Go, Dart):
+```ts
+// inside GenericsInfrastructure class
+readonly Page = z.object({
+  cursor: createGenericType("TCursor", z.string()),
+  content: createGenericType("TContent", this.SomeDtoResult),
+});
+
+readonly DefaultPage = useGenericType(this.Page, {});
+readonly PageOfIds = useGenericType(this.Page, { content: z.array(z.string()) });
+
+// Output
+// export interface DefaultPage extends Page<string, SomeDtoResult> {}
+// export interface PageOfIds extends Page<string, string[]> {}
+```
 
 Complete definition examples can be found [here](https://github.com/rroumenov/zod-to-x/blob/main/test/common/layered_generics.ts).
 

package/dist/lib/zod_ext.d.ts

@@ -112,6 +112,12 @@ export interface IZod2xMetadata {
         generic: ZodObject<any>;
         templates: [string, ZodType][];
     };
+    /**
+     * For Layered Modeling defining generics.
+     * For generic templates created with `createGenericType`, the type used by `useGenericType`
+     * when no type is provided for the template.
+     */
+    genericDefault?: ZodType;
 }
 declare module "zod/v4" {
     interface ZodObject<in Shape, Config> {

package/dist/lib/zod_helpers.d.ts

@@ -125,13 +125,21 @@ export declare class ZodHelpers {
     static createZodObject(properties: Map<string, ZodType>): ZodObject<any>;
     static getZodNumberConstraints(i: ZodNumber | z.ZodBigInt): ZodNumberConstraints;
 }
-export declare function createGenericType(name: string): any;
+/**
+ * Creates a generic template to be used as a property of a generic ZodObject.
+ * @param name Template name. Ex: "T", "K", "TData", ...
+ * @param defaultType Optional type used by `useGenericType` when no type is provided for the
+ * template. It can be any supported type: basic types, arrays, named types, ...
+ * @returns The generic template.
+ */
+export declare function createGenericType(name: string, defaultType?: ZodType): any;
 /**
  * Use generic types defined in a generic ZodObject by replacing them with the actual child types.
  * The new type references the generic type and the child types used for each template, so its
  * type name, layer and templates translation are resolved from them when transpiled.
  * @param genObj ZodObject with generic types.
- * @param childrens Record of child types to replace generics.
+ * @param childrens Record of child types to replace generics. Templates created with a default
+ * type can be omitted.
  * @returns The extended ZodObject with replaced generic types.
  */
 export declare function useGenericType(genObj: ZodObject<any>, childrens: Record<string, ZodType>, skipLazy: true): ZodObject<any>;

package/dist/lib/zod_helpers.js

@@ -294,25 +294,33 @@ class ZodHelpers {
     }
 }
 exports.ZodHelpers = ZodHelpers;
-function createGenericType(name) {
-    return zod_ext_1.Extended.getZ().promise(zod_ext_1.Extended.getZ().literal(name));
+/**
+ * Creates a generic template to be used as a property of a generic ZodObject.
+ * @param name Template name. Ex: "T", "K", "TData", ...
+ * @param defaultType Optional type used by `useGenericType` when no type is provided for the
+ * template. It can be any supported type: basic types, arrays, named types, ...
+ * @returns The generic template.
+ */
+function createGenericType(name, defaultType) {
+    const template = zod_ext_1.Extended.getZ().promise(zod_ext_1.Extended.getZ().literal(name));
+    return defaultType ? (0, zod2x_metadata_1.setZod2xMetadata)(template, { genericDefault: defaultType }) : template;
 }
 function useGenericType(genObj, childrens, skipLazy) {
     const builder = () => {
-        var _a, _b;
+        var _a, _b, _c, _d;
         let extended = genObj;
         const templates = [];
         // Zod 4's extend() doesn't copy meta() (unlike Zod 3 which spread _def).
         // Capture it once so it can be restored after each extend call, keeping the
         // description of the generic type.
         // The id is not restored because it must be unique in Zod's global registry.
-        const _c = (_a = genObj.meta()) !== null && _a !== void 0 ? _a : {}, { id: _id } = _c, genObjMeta = __rest(_c, ["id"]);
+        const _e = (_a = genObj.meta()) !== null && _a !== void 0 ? _a : {}, { id: _id } = _e, genObjMeta = __rest(_e, ["id"]);
         for (const [key, property] of Object.entries(genObj.shape)) {
             if (ZodHelpers.isZod2XGeneric(property)) {
-                const childType = childrens[key];
+                const childType = (_b = childrens[key]) !== null && _b !== void 0 ? _b : (_c = (0, zod2x_metadata_1.getZod2xMetadata)(property)) === null || _c === void 0 ? void 0 : _c.genericDefault;
                 if (!childType) {
                     throw new Error(`Missing child type for generic property ${key} in ` +
-                        `${(_b = (0, zod2x_metadata_1.resolveZod2xMetadata)(genObj)) === null || _b === void 0 ? void 0 : _b.typeName}.`);
+                        `${(_d = (0, zod2x_metadata_1.resolveZod2xMetadata)(genObj)) === null || _d === void 0 ? void 0 : _d.typeName}.`);
                 }
                 extended = extended.extend({ [key]: childType });
                 if (Object.keys(genObjMeta).length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-x",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Multi language types generation from Zod schemas.",
   "main": "dist/index.js",
   "files": [