@miroir-framework/jzod-ts 0.6.1 → 0.6.3

package/tests/jzod-ts.test.ts

@@ -1,107 +0,0 @@
-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 +0,0 @@
-import { ZodType, ZodTypeAny, z } from "zod";
-
-export type TestJzodSchema1 = string;
-
-export const testJzodSchema1 = z.string();

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

@@ -1,11 +0,0 @@
-import { ZodType, ZodTypeAny, z } from "zod";
-
-export type A = string;
-export type B = {
-    test: A;
-};
-export type TestJzodSchema2 = B;
-
-export const a = z.string();
-export const b = z.object({test:z.lazy(() =>a)}).strict();
-export const testJzodSchema2 = z.lazy(() =>b);

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

@@ -1,19 +0,0 @@
-import { ZodType, ZodTypeAny, z } from "zod";
-
-
-type jzodLiteral = {
-    optional?: boolean | undefined;
-    extra?: {
-        [x: string]: any;
-    } | undefined;
-    type: "literal";
-    definition: string;
-};
-type jzodElement = jzodLiteral;
-type testJzodSchema3 = {
-    b: jzodElement[];
-};
-
-export const jzodLiteral=z.object({optional:z.boolean().optional(),extra:z.record(z.string(),z.any()).optional(),type:z.literal("literal"),definition:z.string(),}).strict();
-export const jzodElement=z.union([z.lazy(() =>jzodLiteral),]);
-export const testJzodSchema3 = z.object({b:z.array(z.lazy(() =>jzodElement)),}).strict();

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

@@ -1,253 +0,0 @@
-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 A = JzodArray[];
-export type TestJzodSchema4 = A;
-
-export const jzodBaseObject = z.object({optional:z.boolean().optional(), nullable:z.boolean().optional(), extra:z.record(z.string(),z.any()).optional()}).strict();
-export const 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.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.object({extra:z.record(z.string(),z.any()).optional(), type:z.enum(["min","max"]), parameter:z.any()}).strict();
-export const 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.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.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.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.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.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.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.enum(["any","bigint","boolean","date","never","null","number","string","uuid","undefined","unknown","void"]);
-export const jzodEnumElementTypes = z.enum(["array","enum","function","lazy","literal","intersection","map","object","promise","record","schemaReference","set","simpleType","tuple","union"]);
-export const 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.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.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.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.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.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.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.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.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.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.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.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 a = z.array(z.lazy(() =>jzodArray));
-export const testJzodSchema4 = z.lazy(() =>a);

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {  
-    "outDir": "dist/out-tsc",
-    "declaration": true,
-    "declarationDir": "dist/out-tsc/dts",
-    "rootDir": "./",
-    "baseUrl": "./",
-    "types": ["node", "jest"],
-    "removeComments": true,
-    "module": "ESNext",
-    "target": "ES2017",
-    "jsx": "react-jsx",
-    "moduleResolution": "Node",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports":true,
-    "resolveJsonModule": true,
-    "lib": ["es6", "dom"],
-    "noImplicitAny": true,
-    "noImplicitThis": true,
-    "strictNullChecks": true,
-    "plugins": [
-    ],
-  },
-  "exclude": ["./node_modules/**","./src/**/*.spec.js", "./src/**/*.spec.jsx", "./src/**/*.spec.ts", "./src/**/*.spec.tsx"],
-  "include": ["./src/**/*.json", "./src/**/*.js", "./src/**/*.jsx", "./src/**/*.ts", "./src/**/*.tsx", "src/preBuild.ts"]
-}