@miroir-framework/jzod-ts 0.5.0

package/src/JzodTsInterface.ts

@@ -0,0 +1,450 @@
+import { ZodType, z } from "zod";
+
+const jzodRootSchema = z.object({
+  optional: z.boolean().optional(),
+}).strict();
+type JzodRoot = z.infer<typeof jzodRootSchema>;
+
+// ##############################################################################################################
+export const jzodEnumAttributeTypesSchema = z.enum([
+  "any",
+  "bigint",
+  "boolean",
+  "date",
+  "never",
+  "null",
+  "number",
+  "string",
+  "uuid",
+  "undefined",
+  "unknown",
+  "void",
+])
+
+export type JzodEnumTypes = z.infer<typeof jzodEnumAttributeTypesSchema>;
+
+// ##############################################################################################################
+export const jzodEnumElementTypesSchema = z.enum([
+  "array",
+  "enum",
+  "function",
+  "lazy",
+  "literal",
+  "intersection",
+  "map",
+  "object",
+  "promise",
+  "record",
+  "schemaReference",
+  "set",
+  "simpleType",
+  "tuple",
+  "union",
+])
+
+export type JzodEnumElementTypes = z.infer<typeof jzodEnumElementTypesSchema>;
+
+
+// ##############################################################################################################
+export interface JzodArray extends JzodRoot {
+  optional?: boolean,
+  nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: 'array',
+  definition: JzodElement
+}
+
+export const jzodArraySchema: z.ZodType<JzodArray> = z.object({ // issue with JsonSchema conversion when using extend from ZodRootSchema, although the 2 are functionnaly equivalent
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal('array'),
+  definition: z.lazy(()=>jzodElementSchema)
+}).strict();
+
+// ##############################################################################################################
+export const jzodAttributeDateValidationsSchema = z
+  .object({
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.enum([
+      "min",
+      "max",
+    ]),
+    parameter: z.any(),
+  })
+  .strict();
+
+export type JzodAttributeDateValidations = z.infer<typeof jzodAttributeDateValidationsSchema>;
+
+// ##############################################################################################################
+export const jzodAttributeNumberValidationsSchema = 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 type JzodAttributeNumberValidations = z.infer<typeof jzodAttributeNumberValidationsSchema>;
+
+// ##############################################################################################################
+export const jzodAttributeStringValidationsSchema = 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 type JzodAttributeStringValidations = z.infer<typeof jzodAttributeStringValidationsSchema>;
+
+// ##############################################################################################################
+export const jzodAttributeDateWithValidationsSchema = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  coerce: z.boolean().optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.simpleType),
+  definition: z.literal(jzodEnumAttributeTypesSchema.enum.date),
+  validations: z.array(jzodAttributeDateValidationsSchema),
+}).strict();
+
+export type JzodAttributeDateWithValidations = z.infer<typeof jzodAttributeDateWithValidationsSchema>;
+
+// ##############################################################################################################
+export const jzodAttributeNumberWithValidationsSchema = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  coerce: z.boolean().optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.simpleType),
+  definition: z.literal(jzodEnumAttributeTypesSchema.enum.number),
+  validations: z.array(jzodAttributeNumberValidationsSchema),
+}).strict();
+
+export type JzodAttributeNumberWithValidations = z.infer<typeof jzodAttributeNumberWithValidationsSchema>;
+
+// ##############################################################################################################
+export const jzodAttributeStringWithValidationsSchema = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  coerce: z.boolean().optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.simpleType),
+  definition: z.literal(jzodEnumAttributeTypesSchema.enum.string),
+  validations: z.array(jzodAttributeStringValidationsSchema),
+}).strict();
+
+export type JzodAttributeStringWithValidations = z.infer<typeof jzodAttributeStringWithValidationsSchema>;
+
+// ##############################################################################################################
+export const jzodAttributeSchema = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  coerce: z.boolean().optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.simpleType),
+  definition: z.lazy(()=>jzodEnumAttributeTypesSchema),
+}).strict();
+
+export type JzodAttribute = z.infer<typeof jzodAttributeSchema>;
+
+
+// ##############################################################################################################
+export type JzodElement =
+| JzodArray
+| JzodAttribute
+| JzodAttributeDateWithValidations
+| JzodAttributeNumberWithValidations
+| JzodAttributeStringWithValidations
+| JzodEnum
+| JzodFunction
+| JzodLazy
+| JzodLiteral
+| JzodIntersection
+| JzodMap
+| JzodRecord
+| JzodObject
+| JzodPromise
+| JzodReference
+| JzodSet
+| JzodTuple
+| JzodUnion
+;
+
+export const jzodElementSchema: z.ZodType<JzodElement> = z.union([
+  z.lazy(()=>jzodArraySchema),
+  z.lazy(()=>jzodAttributeSchema),
+  z.lazy(()=>jzodAttributeDateWithValidationsSchema),
+  z.lazy(()=>jzodAttributeNumberWithValidationsSchema),
+  z.lazy(()=>jzodAttributeStringWithValidationsSchema),
+  z.lazy(()=>jzodEnumSchema),
+  z.lazy(()=>jzodFunctionSchema),
+  z.lazy(()=>jzodLazySchema),
+  z.lazy(()=>jzodLiteralSchema),
+  z.lazy(()=>jzodIntersectionSchema),
+  z.lazy(()=>jzodMapSchema),
+  z.lazy(()=>jzodObjectSchema),
+  z.lazy(()=>jzodPromiseSchema),
+  z.lazy(()=>jzodRecordSchema),
+  z.lazy(()=>jzodReferenceSchema),
+  z.lazy(()=>jzodSetSchema),
+  z.lazy(()=>jzodTupleSchema),
+  z.lazy(()=>jzodUnionSchema),
+])
+
+// // ##############################################################################################################
+// export const jzodElementSetSchema = z.record(z.string(),jzodElementSchema);
+// export type JzodElementSet = z.infer<typeof jzodElementSetSchema>;
+
+// ##############################################################################################################
+export const jzodEnumSchema = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.enum),
+  definition: z.array(z.string()),
+}).strict();
+
+export type JzodEnum = z.infer<typeof jzodEnumSchema>;
+
+// ##############################################################################################################
+export interface JzodFunction {
+  // optional?: boolean,
+  // nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: 'function',
+  definition: {args: JzodElement[], returns?: JzodElement},
+}
+export const jzodFunctionSchema: ZodType<JzodFunction> = z.object({
+  type: z.literal(jzodEnumElementTypesSchema.enum.function),
+  extra: z.record(z.string(),z.any()).optional(),
+  // anyway, arg and returns types are not use upon validation to check the function's interface. Suffices for it to be a function, it is then valid.
+  definition: z.object({
+    args:z.array(jzodElementSchema),
+    returns: jzodElementSchema.optional(),
+  })
+}).strict();
+
+// ##############################################################################################################
+export const jzodLazySchema = z.object({
+  type: z.literal(jzodEnumElementTypesSchema.enum.lazy),
+  extra: z.record(z.string(),z.any()).optional(),
+  definition: jzodFunctionSchema,
+}).strict();
+
+export type JzodLazy = z.infer<typeof jzodLazySchema>;
+
+// ##############################################################################################################
+export const jzodLiteralSchema = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.literal),
+  definition: z.string(),
+}).strict();
+
+export type JzodLiteral = z.infer<typeof jzodLiteralSchema>;
+
+// ##############################################################################################################
+export interface JzodIntersection {
+  optional?: boolean,
+  nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: 'intersection',
+  definition: {left: JzodElement, right: JzodElement},
+}
+
+export const jzodIntersectionSchema: z.ZodType<JzodIntersection> = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.intersection),
+  definition: z.lazy(()=>z.object({left: jzodElementSchema, right: jzodElementSchema}))
+}).strict();
+
+// ##############################################################################################################
+export interface JzodMap extends JzodRoot {
+  optional?: boolean,
+  nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: 'map',
+  definition: [JzodElement,JzodElement]
+}
+
+export const jzodMapSchema: z.ZodType<JzodMap> = z.object({ // issue with JsonSchema conversion when using extend from ZodRootSchema, although the 2 are functionnaly equivalent
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal('map'),
+  definition: z.lazy(()=>z.tuple([jzodElementSchema, jzodElementSchema]))
+}).strict();
+
+// ##############################################################################################################
+export interface JzodObject extends JzodRoot {
+  optional?: boolean,
+  nullable?: boolean,
+  extend?: JzodReference | JzodObject,
+  extra?: {[k:string]:any},
+  type: "object",
+  nonStrict?: boolean,
+  // context?: {[attributeName:string]: JzodElement},
+  definition: {[attributeName:string]: JzodElement}
+}
+
+export const jzodObjectSchema: z.ZodType<JzodObject> = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extend: z.lazy(()=>z.union([jzodReferenceSchema,jzodObjectSchema])).optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.object),
+  nonStrict: z.boolean().optional(),
+  definition: z.lazy(()=>z.record(z.string(),jzodElementSchema)),
+}).strict();
+
+// ##############################################################################################################
+export interface JzodPromise extends JzodRoot {
+  // optional?: boolean,
+  // nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: 'promise',
+  definition: JzodElement
+}
+
+export const jzodPromiseSchema: z.ZodType<JzodPromise> = z.object({ // issue with JsonSchema conversion when using extend from ZodRootSchema, although the 2 are functionnaly equivalent
+  // optional: z.boolean().optional(),
+  // nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal('promise'),
+  definition: z.lazy(()=>jzodElementSchema)
+}).strict();
+
+
+// ##############################################################################################################
+export interface JzodRecord {
+  optional?: boolean,
+  nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: 'record',
+  definition: JzodElement,
+}
+
+export const jzodRecordSchema: z.ZodType<JzodRecord> = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.record),
+  definition: z.lazy(()=>jzodElementSchema)
+}).strict();
+
+// ##############################################################################################################
+export interface JzodReference {
+  optional?: boolean,
+  nullable?: boolean,
+  extra?: {[k:string]:any},
+  context?: {[attributeName:string]: JzodElement},
+  type: 'schemaReference',
+  definition: {
+    eager?: boolean,
+    relativePath?: string,
+    absolutePath?: string,
+  },
+}
+
+export const jzodReferenceSchema: ZodType<JzodReference> = z.object({ // inheritance from ZodRootSchema leads to a different JsonSchema thus invalidates tests, although it is semantically equivalent
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.schemaReference),
+  context: z.lazy(()=>z.record(z.string(),jzodElementSchema)).optional(),
+  definition: z.object({
+    eager: z.boolean().optional(),
+    relativePath: z.string().optional(),
+    absolutePath: z.string().optional(),
+  })
+}).strict()
+
+// export type JzodReference = z.infer<typeof jzodReferenceSchema>;
+
+// ##############################################################################################################
+export interface JzodSet extends JzodRoot {
+  optional?: boolean,
+  nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: 'set',
+  definition: JzodElement
+}
+
+export const jzodSetSchema: z.ZodType<JzodSet> = z.object({ // issue with JsonSchema conversion when using extend from ZodRootSchema, although the 2 are functionnaly equivalent
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal('set'),
+  definition: z.lazy(()=>jzodElementSchema)
+}).strict();
+
+// ##############################################################################################################
+export interface JzodTuple {
+  optional?: boolean,
+  nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: 'tuple',
+  definition: JzodElement[],
+}
+
+export const jzodTupleSchema: z.ZodType<JzodTuple> = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.tuple),
+  definition: z.array(jzodElementSchema),
+}).strict();
+
+// ##############################################################################################################
+export interface JzodUnion {
+  optional?: boolean,
+  nullable?: boolean,
+  extra?: {[k:string]:any},
+  type: "union",
+  discriminator?: string,
+  definition: JzodElement[],
+}
+export const jzodUnionSchema: z.ZodType<JzodUnion> = z.object({
+  optional: z.boolean().optional(),
+  nullable: z.boolean().optional(),
+  extra: z.record(z.string(),z.any()).optional(),
+  type: z.literal(jzodEnumElementTypesSchema.enum.union),
+  discriminator: z.string().optional(),
+  definition: z.lazy(()=>z.array(jzodElementSchema))
+}).strict();
+

package/src/index.ts

@@ -0,0 +1,60 @@
+export {
+  jzodToTsCode,
+  jzodToTsTypeAliasesAndZodText,
+  TsTypeAliasesAndZodText as JzodTypeAliasesAndZodText,
+  TsTypeAliases,
+} from "./JzodToTs";
+export { printTsTypeAlias, printTsTypeAliases } from "./tools";
+
+export {
+  // SCHEMAS (const)
+  jzodArraySchema,
+  jzodAttributeSchema,
+  jzodAttributeDateValidationsSchema,
+  jzodAttributeDateWithValidationsSchema,
+  jzodAttributeNumberValidationsSchema,
+  jzodAttributeNumberWithValidationsSchema,
+  jzodAttributeStringValidationsSchema,
+  jzodAttributeStringWithValidationsSchema,
+  jzodElementSchema,
+  jzodEnumAttributeTypesSchema,
+  jzodEnumElementTypesSchema,
+  jzodEnumSchema,
+  jzodFunctionSchema,
+  jzodIntersectionSchema,
+  jzodLazySchema,
+  jzodLiteralSchema,
+  jzodMapSchema,
+  jzodObjectSchema,
+  jzodPromiseSchema,
+  jzodRecordSchema,
+  jzodReferenceSchema,
+  jzodSetSchema,
+  jzodTupleSchema,
+  jzodUnionSchema,
+  // 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";

package/src/tools.ts

@@ -0,0 +1,25 @@
+import { printNode } from "zod-to-ts";
+import ts from "typescript";
+
+import { TsTypeAliases } from "./JzodToTs";
+
+// ################################################################################################
+export function printTsTypeAlias(
+  typeAlias: ts.TypeAliasDeclaration,
+  exportPrefix: boolean = true,
+): string {
+  return (exportPrefix?"export ":"")+printNode(typeAlias)
+}
+
+// ################################################################################################
+export function printTsTypeAliases(
+  typeAliases: TsTypeAliases,
+  exportPrefix: boolean = true,
+): string {
+  const result = Object.entries(typeAliases).reduce((acc, curr) => {
+    // console.log("printTypeAliases ", JSON.stringify(curr));
+    return `${acc}
+${printTsTypeAlias(curr[1],exportPrefix)}`;
+  }, "");
+  return result;
+}

package/tests/jzod-ts.test.ts

@@ -0,0 +1,108 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import { jzodBootstrapElementSchema } from "@miroir-framework/jzod";
+import { jzodToTsCode } from "../src/JzodToTs";
+import { JzodElement, jzodElementSchema } 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: "jzodArraySchema"} }
+            }
+          },
+          definition: {
+            relativePath: "a"
+          },
+        }
+
+        testJzodToTs(
+          "tsTypeGeneration-testJzodSchema4 - reference.ts",
+          "tsTypeGeneration-testJzodSchema4.ts",
+          testJzodSchema4,
+          true,
+          "testJzodSchema4"
+        );
+      }
+    )
+  }
+)
+
+
+

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

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

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

@@ -0,0 +1,11 @@
+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

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