@miroir-framework/jzod-ts 0.5.3 → 0.6.1

package/src/generated_jzodBootstrapElementSchema.ts

@@ -0,0 +1,252 @@
+import { ZodType, ZodTypeAny, z } from "zod";
+
+export type JzodBaseObject = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+};
+export type JzodArray = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "array";
+    definition: JzodElement;
+};
+export type JzodAttribute = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    coerce?: boolean | undefined;
+    definition: JzodEnumAttributeTypes;
+};
+export type JzodAttributeDateValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "min" | "max";
+    parameter?: any;
+};
+export type JzodAttributeDateWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "date";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeDateValidations[];
+};
+export type JzodAttributeNumberValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "gt" | "gte" | "lt" | "lte" | "int" | "positive" | "nonpositive" | "negative" | "nonnegative" | "multipleOf" | "finite" | "safe";
+    parameter?: any;
+};
+export type JzodAttributeNumberWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "number";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeNumberValidations[];
+};
+export type JzodAttributeStringValidations = {
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "max" | "min" | "length" | "email" | "url" | "emoji" | "uuid" | "cuid" | "cuid2" | "ulid" | "regex" | "includes" | "startsWith" | "endsWith" | "datetime" | "ip";
+    parameter?: any;
+};
+export type JzodAttributeStringWithValidations = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "simpleType";
+    definition: "string";
+    coerce?: boolean | undefined;
+    validations: JzodAttributeStringValidations[];
+};
+export type JzodElement = JzodArray | JzodAttribute | JzodAttributeDateWithValidations | JzodAttributeNumberWithValidations | JzodAttributeStringWithValidations | JzodEnum | JzodFunction | JzodLazy | JzodLiteral | JzodIntersection | JzodMap | JzodObject | JzodPromise | JzodRecord | JzodReference | JzodSet | JzodTuple | JzodUnion;
+export type JzodEnum = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "enum";
+    definition: string[];
+};
+export type JzodEnumAttributeTypes = "any" | "bigint" | "boolean" | "date" | "never" | "null" | "number" | "string" | "uuid" | "undefined" | "unknown" | "void";
+export type JzodEnumElementTypes = "array" | "enum" | "function" | "lazy" | "literal" | "intersection" | "map" | "object" | "promise" | "record" | "schemaReference" | "set" | "simpleType" | "tuple" | "union";
+export type JzodFunction = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "function";
+    definition: {
+        args: JzodElement[];
+        returns?: JzodElement | undefined;
+    };
+};
+export type JzodLazy = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "lazy";
+    definition: JzodFunction;
+};
+export type JzodLiteral = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "literal";
+    definition: string;
+};
+export type JzodIntersection = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "intersection";
+    definition: {
+        left: JzodElement;
+        right: JzodElement;
+    };
+};
+export type JzodMap = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "map";
+    definition: [
+        JzodElement,
+        JzodElement
+    ];
+};
+export type JzodObject = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    extend?: (JzodReference | JzodObject) | undefined;
+    type: "object";
+    nonStrict?: boolean | undefined;
+    definition: {
+        [x: string]: JzodElement;
+    };
+};
+export type JzodPromise = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "promise";
+    definition: JzodElement;
+};
+export type JzodRecord = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "record";
+    definition: JzodElement;
+};
+export type JzodReference = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "schemaReference";
+    context?: {
+        [x: string]: JzodElement;
+    } | undefined;
+    definition: {
+        eager?: boolean | undefined;
+        relativePath?: string | undefined;
+        absolutePath?: string | undefined;
+    };
+};
+export type JzodSet = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "set";
+    definition: JzodElement;
+};
+export type JzodTuple = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "tuple";
+    definition: JzodElement[];
+};
+export type JzodUnion = {
+    optional?: boolean | undefined;
+    nullable?: boolean | undefined;
+    extra?: {
+        [x: string]: any;
+    } | undefined;
+    type: "union";
+    discriminator?: string | undefined;
+    definition: JzodElement[];
+};
+export type JzodBootstrapElementSchema = JzodElement;
+
+export const jzodBaseObject: z.ZodType<JzodBaseObject> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict();
+export const jzodArray: z.ZodType<JzodArray> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("array"), definition:z.lazy(() =>jzodElement)}).strict();
+export const jzodAttribute: z.ZodType<JzodAttribute> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), coerce:z.boolean().optional(), definition:z.lazy(() =>jzodEnumAttributeTypes)}).strict();
+export const jzodAttributeDateValidations: z.ZodType<JzodAttributeDateValidations> = z.object({extra:z.record(z.string(),z.any()).optional(), type:z.enum(["min","max"]), parameter:z.any()}).strict();
+export const jzodAttributeDateWithValidations: z.ZodType<JzodAttributeDateWithValidations> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("date"), coerce:z.boolean().optional(), validations:z.array(z.lazy(() =>jzodAttributeDateValidations))}).strict();
+export const jzodAttributeNumberValidations: z.ZodType<JzodAttributeNumberValidations> = z.object({extra:z.record(z.string(),z.any()).optional(), type:z.enum(["gt","gte","lt","lte","int","positive","nonpositive","negative","nonnegative","multipleOf","finite","safe"]), parameter:z.any()}).strict();
+export const jzodAttributeNumberWithValidations: z.ZodType<JzodAttributeNumberWithValidations> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("number"), coerce:z.boolean().optional(), validations:z.array(z.lazy(() =>jzodAttributeNumberValidations))}).strict();
+export const jzodAttributeStringValidations: z.ZodType<JzodAttributeStringValidations> = z.object({extra:z.record(z.string(),z.any()).optional(), type:z.enum(["max","min","length","email","url","emoji","uuid","cuid","cuid2","ulid","regex","includes","startsWith","endsWith","datetime","ip"]), parameter:z.any()}).strict();
+export const jzodAttributeStringWithValidations: z.ZodType<JzodAttributeStringWithValidations> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("simpleType"), definition:z.literal("string"), coerce:z.boolean().optional(), validations:z.array(z.lazy(() =>jzodAttributeStringValidations))}).strict();
+export const jzodElement: z.ZodType<JzodElement> = z.union([z.lazy(() =>jzodArray), z.lazy(() =>jzodAttribute), z.lazy(() =>jzodAttributeDateWithValidations), z.lazy(() =>jzodAttributeNumberWithValidations), z.lazy(() =>jzodAttributeStringWithValidations), z.lazy(() =>jzodEnum), z.lazy(() =>jzodFunction), z.lazy(() =>jzodLazy), z.lazy(() =>jzodLiteral), z.lazy(() =>jzodIntersection), z.lazy(() =>jzodMap), z.lazy(() =>jzodObject), z.lazy(() =>jzodPromise), z.lazy(() =>jzodRecord), z.lazy(() =>jzodReference), z.lazy(() =>jzodSet), z.lazy(() =>jzodTuple), z.lazy(() =>jzodUnion)]);
+export const jzodEnum: z.ZodType<JzodEnum> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("enum"), definition:z.array(z.string())}).strict();
+export const jzodEnumAttributeTypes: z.ZodType<JzodEnumAttributeTypes> = z.enum(["any","bigint","boolean","date","never","null","number","string","uuid","undefined","unknown","void"]);
+export const jzodEnumElementTypes: z.ZodType<JzodEnumElementTypes> = z.enum(["array","enum","function","lazy","literal","intersection","map","object","promise","record","schemaReference","set","simpleType","tuple","union"]);
+export const jzodFunction: z.ZodType<JzodFunction> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("function"), definition:z.object({args:z.array(z.lazy(() =>jzodElement)), returns:z.lazy(() =>jzodElement).optional()}).strict()}).strict();
+export const jzodLazy: z.ZodType<JzodLazy> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("lazy"), definition:z.lazy(() =>jzodFunction)}).strict();
+export const jzodLiteral: z.ZodType<JzodLiteral> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("literal"), definition:z.string()}).strict();
+export const jzodIntersection: z.ZodType<JzodIntersection> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("intersection"), definition:z.object({left:z.lazy(() =>jzodElement), right:z.lazy(() =>jzodElement)}).strict()}).strict();
+export const jzodMap: z.ZodType<JzodMap> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("map"), definition:z.tuple([z.lazy(() =>jzodElement), z.lazy(() =>jzodElement)])}).strict();
+export const jzodObject: z.ZodType<JzodObject> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({extend:z.union([z.lazy(() =>jzodReference), z.lazy(() =>jzodObject)]).optional(), type:z.literal("object"), nonStrict:z.boolean().optional(), definition:z.record(z.string(),z.lazy(() =>jzodElement))}).strict();
+export const jzodPromise: z.ZodType<JzodPromise> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("promise"), definition:z.lazy(() =>jzodElement)}).strict();
+export const jzodRecord: z.ZodType<JzodRecord> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("record"), definition:z.lazy(() =>jzodElement)}).strict();
+export const jzodReference: z.ZodType<JzodReference> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("schemaReference"), context:z.record(z.string(),z.lazy(() =>jzodElement)).optional(), definition:z.object({eager:z.boolean().optional(), relativePath:z.string().optional(), absolutePath:z.string().optional()}).strict()}).strict();
+export const jzodSet: z.ZodType<JzodSet> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("set"), definition:z.lazy(() =>jzodElement)}).strict();
+export const jzodTuple: z.ZodType<JzodTuple> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("tuple"), definition:z.array(z.lazy(() =>jzodElement))}).strict();
+export const jzodUnion: z.ZodType<JzodUnion> = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict().extend({type:z.literal("union"), discriminator:z.string().optional(), definition:z.array(z.lazy(() =>jzodElement))}).strict();
+export const jzodBootstrapElementSchema = z.lazy(() =>jzodElement);
+

package/src/index.ts

@@ -1,60 +1,60 @@
-export {
-  jzodToTsCode,
-  jzodToTsTypeAliasesAndZodText,
-  TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText,
-  TsTypeAliases,
-} from "./JzodToTs";
-export { printTsTypeAlias, printTsTypeAliases } from "./tools";
-
-export {
-  // SCHEMAS (const)
-  jzodArray,
-  jzodAttribute,
-  jzodAttributeDateValidations,
-  jzodAttributeDateWithValidations,
-  jzodAttributeNumberValidations,
-  jzodAttributeNumberWithValidations,
-  jzodAttributeStringValidations,
-  jzodAttributeStringWithValidations,
-  jzodElement,
-  jzodEnumAttributeTypes,
-  jzodEnumElementTypes,
-  jzodEnum,
-  jzodFunction,
-  jzodIntersection,
-  jzodLazy,
-  jzodLiteral,
-  jzodMapSchema,
-  jzodObject,
-  jzodPromise,
-  jzodRecord,
-  jzodReference,
-  jzodSet,
-  jzodTuple,
-  jzodUnion,
-  // TYPES
-  JzodArray,
-  JzodAttribute,
-  JzodAttributeDateValidations,
-  JzodAttributeDateWithValidations,
-  JzodAttributeNumberValidations,
-  JzodAttributeNumberWithValidations,
-  JzodAttributeStringValidations,
-  JzodAttributeStringWithValidations,
-  JzodElement,
-  JzodEnum,
-  JzodEnumTypes,
-  JzodFunction,
-  JzodEnumElementTypes,
-  JzodIntersection,
-  JzodLazy,
-  JzodLiteral,
-  JzodMap,
-  JzodObject,
-  JzodPromise,
-  JzodRecord,
-  JzodReference,
-  JzodSet,
-  JzodUnion,
-  JzodTuple,
-} from "./JzodTsInterface";
+export {
+  jzodToTsCode,
+  jzodToTsTypeAliasesAndZodText,
+  TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText,
+  TsTypeAliases,
+} from "./JzodToTs";
+export { printTsTypeAlias, printTsTypeAliases } from "./tools";
+
+export {
+  // SCHEMAS (const)
+  jzodArray,
+  jzodAttribute,
+  jzodAttributeDateValidations,
+  jzodAttributeDateWithValidations,
+  jzodAttributeNumberValidations,
+  jzodAttributeNumberWithValidations,
+  jzodAttributeStringValidations,
+  jzodAttributeStringWithValidations,
+  jzodElement,
+  jzodEnumAttributeTypes,
+  jzodEnumElementTypes,
+  jzodEnum,
+  jzodFunction,
+  jzodIntersection,
+  jzodLazy,
+  jzodLiteral,
+  jzodMap,
+  jzodObject,
+  jzodPromise,
+  jzodRecord,
+  jzodReference,
+  jzodSet,
+  jzodTuple,
+  jzodUnion,
+  // TYPES
+  JzodArray,
+  JzodAttribute,
+  JzodAttributeDateValidations,
+  JzodAttributeDateWithValidations,
+  JzodAttributeNumberValidations,
+  JzodAttributeNumberWithValidations,
+  JzodAttributeStringValidations,
+  JzodAttributeStringWithValidations,
+  JzodElement,
+  JzodEnum,
+  JzodEnumAttributeTypes,
+  JzodFunction,
+  JzodEnumElementTypes,
+  JzodIntersection,
+  JzodLazy,
+  JzodLiteral,
+  JzodMap,
+  JzodObject,
+  JzodPromise,
+  JzodRecord,
+  JzodReference,
+  JzodSet,
+  JzodUnion,
+  JzodTuple,
+} from "./generated_jzodBootstrapElementSchema";

package/src/preBuild.ts

@@ -0,0 +1,54 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { jzodBootstrapElementSchema } from '@miroir-framework/jzod';
+
+import { jzodToTsCode } from './JzodToTs.js';
+
+export function generateZodSchemaFileFromJzodSchema(
+  jzodElement: any, //JzodElement,
+  targetFileName: string,
+  jzodSchemaVariableName:string,
+) {
+  // console.log("generateZodSchemaFileFromJzodSchema called!");
+ 
+  const newFileContentsNotFormated = jzodToTsCode(jzodElement, true, jzodSchemaVariableName,Object.keys(jzodElement.context))
+  // const newFileContents = `import { JzodObject, jzodObject } from "@miroir-framework/jzod-ts";
+  const newFileContents = `${newFileContentsNotFormated}
+`;
+
+  if (targetFileName && existsSync(targetFileName)) {
+    const oldFileContents = readFileSync(targetFileName).toString()
+    if (newFileContents != oldFileContents)  {
+      // console.log("generateZodSchemaFileFromJzodSchema newFileContents",newFileContents);
+      writeFileSync(targetFileName,newFileContents);
+    } else {
+      console.log("generateZodSchemaFileFromJzodSchema entityDefinitionReport old contents equal new contents, no file generation needed.");
+    }
+  } else {
+    writeFileSync(targetFileName,newFileContents);
+  }
+}
+
+// ################################################################################################
+const jzodSchemaConversion
+: {
+  jzodElement: any,
+  targetFileName: string,
+  jzodSchemaVariableName:string,
+}[]
+= [
+  {
+    jzodElement: jzodBootstrapElementSchema,
+    targetFileName: "./src/generated_jzodBootstrapElementSchema.ts",
+    jzodSchemaVariableName: "jzodBootstrapElementSchema",
+  },
+];
+
+try {
+  for (const schema of jzodSchemaConversion) {
+    generateZodSchemaFileFromJzodSchema(schema.jzodElement,schema.targetFileName,schema.jzodSchemaVariableName)
+    console.info("GENERATED",schema.targetFileName);
+  }
+  
+} catch (error) {
+  console.error("could not generate TS files from Jzod schemas", error);
+}

package/tests/jzod-ts.test.ts

@@ -1,108 +1,107 @@
-import * as fs from "fs";
-import * as path from "path";
-
-import { jzodBootstrapElementSchema } from "@miroir-framework/jzod";
-import { jzodToTsCode } from "../src/JzodToTs";
-import { JzodElement, jzodElement } from "../src/JzodTsInterface";
-
-const refsPath = "./tests/resources"
-const tmpPath = "./tests/tmp";
-
-
-const testJzodToTs = (
-  // testDirectory: string,
-  referenceFileName: string,
-  testFileName: string,
-  testJzodSchema:JzodElement,
-  exportPrefix: boolean,
-  typeName: string
-) => {
-  console.log("testJzodToTs:", typeName);
-  
-  const testResultSchemaFilePath = path.join(tmpPath,testFileName);
-  const expectedSchemaFilePath = path.join(refsPath,referenceFileName);
-
-  const result = jzodToTsCode(testJzodSchema,exportPrefix,typeName)
-  fs.writeFileSync(testResultSchemaFilePath,result);
-
-  const resultContents = result.replace(/(\r\n|\n|\r)/gm, "");
-  // console.log("ts Type generation resultContents", resultContents);
-
-  const expectedFileContents = fs.readFileSync(expectedSchemaFilePath).toString().replace(/(\r\n|\n|\r)/gm, "")
-  expect(resultContents).toEqual(expectedFileContents);
-}
-
-
-describe(
-  'Jzod-Ts',
-  () => {
-    // ############################################################################################
-    it(
-      "Jzod to TS Type",
-      async() => {
-
-
-        // ########################################################################################
-        const testJzodSchema1: JzodElement = { type: "simpleType", definition: "string" };
-
-        testJzodToTs(
-          "tsTypeGeneration-testJzodSchema1 - reference.ts",
-          "tsTypeGeneration-testJzodSchema1.ts",
-          testJzodSchema1,
-          true,
-          "testJzodSchema1"
-        );
-
-        // ########################################################################################
-        const testJzodSchema2: JzodElement = {
-          type: "schemaReference",
-          context: {
-            a: { type: "simpleType", definition: "string" },
-            b: {
-              type: "object",
-              definition: {
-                test: { type: "schemaReference", definition: { relativePath: "a" } }
-              },
-            },
-          },
-          definition: { relativePath: "b" },
-        };
-
-        testJzodToTs(
-          "tsTypeGeneration-testJzodSchema2 - reference.ts",
-          "tsTypeGeneration-testJzodSchema2.ts",
-          testJzodSchema2,
-          true,
-          "testJzodSchema2"
-        );
-
-        // ########################################################################################
-        const testJzodSchema4:JzodElement = 
-        {
-          type: "schemaReference", 
-          context: {
-            ...jzodBootstrapElementSchema.context,
-            a: {
-              type: "array",
-              definition: { type: "schemaReference", definition: {relativePath: "jzodArray"} }
-            }
-          },
-          definition: {
-            relativePath: "a"
-          },
-        }
-
-        testJzodToTs(
-          "tsTypeGeneration-testJzodSchema4 - reference.ts",
-          "tsTypeGeneration-testJzodSchema4.ts",
-          testJzodSchema4,
-          true,
-          "testJzodSchema4"
-        );
-      }
-    )
-  }
-)
-
-
-
+import * as fs from "fs";
+import * as path from "path";
+
+import { jzodBootstrapElementSchema } from "@miroir-framework/jzod";
+import { jzodToTsCode } from "../src/JzodToTs";
+
+const refsPath = "./tests/resources"
+const tmpPath = "./tests/tmp";
+
+
+const testJzodToTs = (
+  // testDirectory: string,
+  referenceFileName: string,
+  testFileName: string,
+  testJzodSchema: any, //JzodElement,
+  exportPrefix: boolean,
+  typeName: string
+) => {
+  console.log("testJzodToTs:", typeName);
+  
+  const testResultSchemaFilePath = path.join(tmpPath,testFileName);
+  const expectedSchemaFilePath = path.join(refsPath,referenceFileName);
+
+  const result = jzodToTsCode(testJzodSchema,exportPrefix,typeName)
+  fs.writeFileSync(testResultSchemaFilePath,result);
+
+  const resultContents = result.replace(/(\r\n|\n|\r)/gm, "");
+  // console.log("ts Type generation resultContents", resultContents);
+
+  const expectedFileContents = fs.readFileSync(expectedSchemaFilePath).toString().replace(/(\r\n|\n|\r)/gm, "")
+  expect(resultContents).toEqual(expectedFileContents);
+}
+
+
+describe(
+  'Jzod-Ts',
+  () => {
+    // ############################################################################################
+    it(
+      "Jzod to TS Type",
+      async() => {
+
+
+        // ########################################################################################
+        const testJzodSchema1: any /**JzodElement*/ = { type: "simpleType", definition: "string" };
+
+        testJzodToTs(
+          "tsTypeGeneration-testJzodSchema1 - reference.ts",
+          "tsTypeGeneration-testJzodSchema1.ts",
+          testJzodSchema1,
+          true,
+          "testJzodSchema1"
+        );
+
+        // ########################################################################################
+        const testJzodSchema2: any /**JzodElement*/ = {
+          type: "schemaReference",
+          context: {
+            a: { type: "simpleType", definition: "string" },
+            b: {
+              type: "object",
+              definition: {
+                test: { type: "schemaReference", definition: { relativePath: "a" } }
+              },
+            },
+          },
+          definition: { relativePath: "b" },
+        };
+
+        testJzodToTs(
+          "tsTypeGeneration-testJzodSchema2 - reference.ts",
+          "tsTypeGeneration-testJzodSchema2.ts",
+          testJzodSchema2,
+          true,
+          "testJzodSchema2"
+        );
+
+        // ########################################################################################
+        const testJzodSchema4: any /**JzodElement*/ = 
+        {
+          type: "schemaReference", 
+          context: {
+            ...jzodBootstrapElementSchema.context,
+            a: {
+              type: "array",
+              definition: { type: "schemaReference", definition: {relativePath: "jzodArray"} }
+            }
+          },
+          definition: {
+            relativePath: "a"
+          },
+        }
+
+        testJzodToTs(
+          "tsTypeGeneration-testJzodSchema4 - reference.ts",
+          "tsTypeGeneration-testJzodSchema4.ts",
+          testJzodSchema4,
+          true,
+          "testJzodSchema4"
+        );
+      }
+    )
+  }
+)
+
+
+

package/tests/resources/tsTypeGeneration-testJzodSchema1 - reference.ts

@@ -1,5 +1,5 @@
-import { ZodType, ZodTypeAny, z } from "zod";
-
-export type TestJzodSchema1 = string;
-
-export const testJzodSchema1: z.ZodType<TestJzodSchema1> = z.string();
+import { ZodType, ZodTypeAny, z } from "zod";
+
+export type TestJzodSchema1 = string;
+
+export const testJzodSchema1 = z.string();