@miroir-framework/jzod-ts 0.5.0

package/dist/bundle.js

@@ -0,0 +1,303 @@
+import { printNode, withGetType, zodToTs, createTypeAlias } from 'zod-to-ts';
+import { jzodElementSchemaToZodSchemaAndDescription } from '@miroir-framework/jzod';
+import { z } from 'zod';
+
+function printTsTypeAlias(typeAlias, exportPrefix = true) {
+    return (exportPrefix ? "export " : "") + printNode(typeAlias);
+}
+function printTsTypeAliases(typeAliases, exportPrefix = true) {
+    const result = Object.entries(typeAliases).reduce((acc, curr) => {
+        return `${acc}
+${printTsTypeAlias(curr[1], exportPrefix)}`;
+    }, "");
+    return result;
+}
+
+function jzodToTsTypeAliasesAndZodText(element, typeName) {
+    var _a, _b;
+    const elementZodSchemaAndDescription = jzodElementSchemaToZodSchemaAndDescription(element, () => ({}), () => ({}), (innerReference, relativeReference) => withGetType(innerReference, (ts) => {
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(relativeReference ? relativeReference : "RELATIVEPATH_NOT_DEFINED"));
+    }));
+    const contextTsTypesString = Object.fromEntries(Object.entries((_a = elementZodSchemaAndDescription.contextZodSchema) !== null && _a !== void 0 ? _a : {}).map((curr) => {
+        const tsNode = zodToTs(curr[1], typeName).node;
+        const typeAlias = createTypeAlias(tsNode, curr[0]);
+        return [curr[0], typeAlias];
+    }));
+    const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
+    const tsTypeStringTypeAlias = createTypeAlias(tsTypeStringNode, typeName !== null && typeName !== void 0 ? typeName : "");
+    return {
+        contextTsTypeAliases: contextTsTypesString,
+        contextZodText: (_b = elementZodSchemaAndDescription.contextZodText) !== null && _b !== void 0 ? _b : {},
+        mainZodText: elementZodSchemaAndDescription.zodText,
+        mainTsTypeAlias: tsTypeStringTypeAlias,
+    };
+}
+function jzodToTsCode(jzodElement, exportPrefix = true, typeName) {
+    const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
+    const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
+    const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, typeName);
+    const bodyJsCode = `export const ${schemaName} = ${typeAliasesAndZodText.mainZodText};`;
+    const contextTsTypesString = printTsTypeAliases(typeAliasesAndZodText.contextTsTypeAliases, exportPrefix);
+    const contextJsCode = typeAliasesAndZodText.contextZodText
+        ? Object.entries(typeAliasesAndZodText.contextZodText).reduce((acc, curr) => {
+            return `${acc}
+export const ${curr[0]}=${curr[1]};`;
+        }, "")
+        : "";
+    const tsTypesString = (exportPrefix ? "export " : "") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
+    return `${header}
+${contextTsTypesString}
+${tsTypesString}
+${contextJsCode}
+${bodyJsCode}
+`;
+}
+
+z.object({
+    optional: z.boolean().optional(),
+}).strict();
+const jzodEnumAttributeTypesSchema = z.enum([
+    "any",
+    "bigint",
+    "boolean",
+    "date",
+    "never",
+    "null",
+    "number",
+    "string",
+    "uuid",
+    "undefined",
+    "unknown",
+    "void",
+]);
+const jzodEnumElementTypesSchema = z.enum([
+    "array",
+    "enum",
+    "function",
+    "lazy",
+    "literal",
+    "intersection",
+    "map",
+    "object",
+    "promise",
+    "record",
+    "schemaReference",
+    "set",
+    "simpleType",
+    "tuple",
+    "union",
+]);
+const jzodArraySchema = z.object({
+    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();
+const jzodAttributeDateValidationsSchema = z
+    .object({
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.enum([
+        "min",
+        "max",
+    ]),
+    parameter: z.any(),
+})
+    .strict();
+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();
+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();
+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();
+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();
+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();
+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();
+const jzodElementSchema = 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),
+]);
+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();
+const jzodFunctionSchema = z.object({
+    type: z.literal(jzodEnumElementTypesSchema.enum.function),
+    extra: z.record(z.string(), z.any()).optional(),
+    definition: z.object({
+        args: z.array(jzodElementSchema),
+        returns: jzodElementSchema.optional(),
+    })
+}).strict();
+const jzodLazySchema = z.object({
+    type: z.literal(jzodEnumElementTypesSchema.enum.lazy),
+    extra: z.record(z.string(), z.any()).optional(),
+    definition: jzodFunctionSchema,
+}).strict();
+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();
+const jzodIntersectionSchema = 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();
+const jzodMapSchema = z.object({
+    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();
+const jzodObjectSchema = 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();
+const jzodPromiseSchema = z.object({
+    extra: z.record(z.string(), z.any()).optional(),
+    type: z.literal('promise'),
+    definition: z.lazy(() => jzodElementSchema)
+}).strict();
+const jzodRecordSchema = 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();
+const jzodReferenceSchema = z.object({
+    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();
+const jzodSetSchema = z.object({
+    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();
+const jzodTupleSchema = 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();
+const jzodUnionSchema = 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();
+
+export { jzodArraySchema, jzodAttributeDateValidationsSchema, jzodAttributeDateWithValidationsSchema, jzodAttributeNumberValidationsSchema, jzodAttributeNumberWithValidationsSchema, jzodAttributeSchema, jzodAttributeStringValidationsSchema, jzodAttributeStringWithValidationsSchema, jzodElementSchema, jzodEnumAttributeTypesSchema, jzodEnumElementTypesSchema, jzodEnumSchema, jzodFunctionSchema, jzodIntersectionSchema, jzodLazySchema, jzodLiteralSchema, jzodMapSchema, jzodObjectSchema, jzodPromiseSchema, jzodRecordSchema, jzodReferenceSchema, jzodSetSchema, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTupleSchema, jzodUnionSchema, printTsTypeAlias, printTsTypeAliases };

package/dist/src/JzodToTs.d.ts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+import { JzodElement } from "./JzodTsInterface";
+export type TsTypeAliases = {
+    [k: string]: ts.TypeAliasDeclaration;
+};
+export interface TsTypeAliasesAndZodText {
+    contextTsTypeAliases: {
+        [k: string]: ts.TypeAliasDeclaration;
+    };
+    contextZodText: {
+        [k: string]: string;
+    };
+    mainTsTypeAlias: ts.TypeAliasDeclaration;
+    mainZodText: string;
+}
+export declare function jzodToTsTypeAliasesAndZodText(element: JzodElement, typeName?: string): TsTypeAliasesAndZodText;
+export declare function jzodToTsCode(jzodElement: JzodElement, exportPrefix?: boolean, typeName?: string): string;