@miroir-framework/jzod-ts 0.5.2 → 0.6.0

package/dist/bundle.js

@@ -16,11 +16,13 @@ ${printTsTypeAlias(curr[1], exportPrefix)}`;
 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 actualTypeName = relativeReference ? relativeReference.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(actualTypeName ? actualTypeName : "RELATIVEPATH_NOT_DEFINED"), undefined);
     }));
     const contextTsTypesString = Object.fromEntries(Object.entries((_a = elementZodSchemaAndDescription.contextZodSchema) !== null && _a !== void 0 ? _a : {}).map((curr) => {
+        const actualTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
         const tsNode = zodToTs(curr[1], typeName).node;
-        const typeAlias = createTypeAlias(tsNode, curr[0]);
+        const typeAlias = createTypeAlias(tsNode, actualTypeName);
         return [curr[0], typeAlias];
     }));
     const tsTypeStringNode = zodToTs(elementZodSchemaAndDescription.zodSchema, typeName).node;
@@ -32,272 +34,59 @@ function jzodToTsTypeAliasesAndZodText(element, typeName) {
         mainTsTypeAlias: tsTypeStringTypeAlias,
     };
 }
-function jzodToTsCode(jzodElement, exportPrefix = true, typeName) {
+function jzodToTsCode(jzodElement, exportPrefix = true, typeName, typeSchema = false) {
     const schemaName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toLowerCase() + c) : "";
+    const actualTypeName = typeName ? typeName.replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
     const header = `import { ZodType, ZodTypeAny, z } from "zod";`;
-    const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, typeName);
-    const bodyJsCode = `export const ${schemaName}: z.ZodType<${schemaName}> = ${typeAliasesAndZodText.mainZodText};`;
+    const typeAliasesAndZodText = jzodToTsTypeAliasesAndZodText(jzodElement, actualTypeName);
+    const bodyJsCode = typeSchema
+        ? `export const ${schemaName}: z.ZodType<${actualTypeName}> = ${typeAliasesAndZodText.mainZodText};`
+        : `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]}:z.ZodType<${curr[0]}> = ${curr[1]};`;
+            const contextTypeName = curr[0] ? curr[0].replace(/^(.)(.*)$/, (a, b, c) => b.toUpperCase() + c) : "";
+            return typeSchema ?
+                `${acc}
+export const ${curr[0]}: z.ZodType<${contextTypeName}> = ${curr[1]};` :
+                `${acc}
+export const ${curr[0]} = ${curr[1]};`;
         }, "")
         : "";
     const tsTypesString = (exportPrefix ? "export " : "") + printNode(typeAliasesAndZodText.mainTsTypeAlias);
-    return `${header}
-${contextTsTypesString}
-${tsTypesString}
-${contextJsCode}
-${bodyJsCode}
+    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();
+z.object({ optional: z.boolean().optional(), nullable: z.boolean().optional(), extra: z.record(z.string(), z.any()).optional() }).strict();
+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();
+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();
+const jzodAttributeDateValidations = z.object({ extra: z.record(z.string(), z.any()).optional(), type: z.enum(["min", "max"]), parameter: z.any() }).strict();
+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"), validations: z.array(z.lazy(() => jzodAttributeDateValidations)) }).strict();
+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();
+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"), validations: z.array(z.lazy(() => jzodAttributeNumberValidations)) }).strict();
+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();
+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"), validations: z.array(z.lazy(() => jzodAttributeStringValidations)) }).strict();
+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)]);
+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();
+const jzodEnumAttributeTypes = z.enum(["any", "bigint", "boolean", "date", "never", "null", "number", "string", "uuid", "undefined", "unknown", "void"]);
+const jzodEnumElementTypes = z.enum(["array", "enum", "function", "lazy", "literal", "intersection", "map", "object", "promise", "record", "schemaReference", "set", "simpleType", "tuple", "union"]);
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+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();
+z.lazy(() => jzodElement);
 
-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 };
+export { jzodArray, jzodAttribute, jzodAttributeDateValidations, jzodAttributeDateWithValidations, jzodAttributeNumberValidations, jzodAttributeNumberWithValidations, jzodAttributeStringValidations, jzodAttributeStringWithValidations, jzodElement, jzodEnum, jzodEnumAttributeTypes, jzodEnumElementTypes, jzodFunction, jzodIntersection, jzodLazy, jzodLiteral, jzodMap, jzodObject, jzodPromise, jzodRecord, jzodReference, jzodSet, jzodToTsCode, jzodToTsTypeAliasesAndZodText, jzodTuple, jzodUnion, printTsTypeAlias, printTsTypeAliases };

package/dist/out-tsc/dts/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;