arkos 2.0.0-next.2 → 2.0.0-next.21

package/dist/esm/utils/cli/utils/template-generator/templates/class-validator-dto-generator.js

@@ -1,5 +1,6 @@
 import prismaSchemaParser from "../../../../prisma/prisma-schema-parser.js";
 import { getUserFileExtension } from "../../../../helpers/fs.helpers.js";
+import { getArkosConfig } from "../../../../helpers/arkos-config.helpers.js";
 export class ClassValidatorDtoGenerator {
     ensureCorrectOptions(options) {
         const { modelName } = options;
@@ -38,6 +39,33 @@ export class ClassValidatorDtoGenerator {
             if (isForeignKey) {
                 continue;
             }
+            if (field.isCompositeType) {
+                const compositeType = prismaSchemaParser.compositeTypes.find((t) => t.name === field.type);
+                const compositeDtoName = `${field.type}ForCreate${modelName.pascal}Dto`;
+                validatorsUsed.add("ValidateNested");
+                transformersUsed.add("Type");
+                if (!nestedDtoClasses.find((c) => c.includes(`class ${compositeDtoName}`))) {
+                    const nestedFields = compositeType.fields.map((f) => {
+                        const { decorators, type } = this.generateClassValidatorField(f, false, validatorsUsed, transformersUsed);
+                        const mod = isTypeScript ? (f.isOptional ? "?" : "!") : "";
+                        return `${decorators}  ${f.name}${mod}: ${type};`;
+                    });
+                    nestedDtoClasses.push(`class ${compositeDtoName} {\n${nestedFields.join("\n\n")}\n}`);
+                }
+                const isOptional = field.isOptional || field.defaultValue !== undefined;
+                if (isOptional)
+                    validatorsUsed.add("IsOptional");
+                const optDecorator = isOptional ? "  @IsOptional()\n" : "";
+                const mod = isTypeScript ? (isOptional ? "?" : "!") : "";
+                const eachOpt = field.isArray ? "{ each: true }" : "";
+                const typeStr = field.isArray
+                    ? `${compositeDtoName}[]`
+                    : compositeDtoName;
+                if (field.isArray)
+                    validatorsUsed.add("IsArray");
+                dtoFields.push(`${optDecorator}${field.isArray ? "  @IsArray()\n" : ""}  @ValidateNested(${eachOpt})\n  @Type(() => ${compositeDtoName})\n  ${field.name}${mod}: ${typeStr};`);
+                continue;
+            }
             if (field.isRelation) {
                 if (field.isArray)
                     continue;
@@ -53,7 +81,7 @@ export class ClassValidatorDtoGenerator {
                     validatorsUsed.add("ValidateNested");
                     transformersUsed.add("Type");
                     const relationDtoName = `${referencedModel.name}ForCreate${modelName.pascal}Dto`;
-                    const nestedDtoClass = this.generateNestedDtoClass(field, referencedModel, relationDtoName, validatorsUsed, enumsUsed, isTypeScript);
+                    const nestedDtoClass = this.generateNestedDtoClass(field, referencedModel, relationDtoName, validatorsUsed, enumsUsed, isTypeScript, transformersUsed);
                     if (!dtoFields.find((dtoField) => dtoField.includes(relationDtoName)))
                         nestedDtoClasses.push(nestedDtoClass);
                     dtoFields.push(`${optionalDecorator}  @ValidateNested()\n  @Type(() => ${relationDtoName})\n  ${field.name}${typeModifier}: ${relationDtoName};`);
@@ -63,7 +91,7 @@ export class ClassValidatorDtoGenerator {
             if (prismaSchemaParser.isEnum(field.type)) {
                 enumsUsed.add(field.type);
             }
-            const { decorators, type } = this.generateClassValidatorField(field, isUserModule, validatorsUsed);
+            const { decorators, type } = this.generateClassValidatorField(field, isUserModule, validatorsUsed, transformersUsed);
             const isOptional = field.isOptional || field.defaultValue !== undefined;
             const typeModifier = isTypeScript ? (isOptional ? "?" : "!") : "";
             dtoFields.push(`${decorators}  ${field.name}${typeModifier}: ${type};`);
@@ -103,6 +131,29 @@ ${dtoFields.join("\n\n")}
             if (isForeignKey) {
                 continue;
             }
+            if (field.isCompositeType) {
+                const compositeType = prismaSchemaParser.compositeTypes.find((t) => t.name === field.type);
+                const compositeDtoName = `${field.type}ForUpdate${modelName.pascal}Dto`;
+                validatorsUsed.add("ValidateNested");
+                validatorsUsed.add("IsOptional");
+                transformersUsed.add("Type");
+                if (!nestedDtoClasses.find((c) => c.includes(`class ${compositeDtoName}`))) {
+                    const nestedFields = compositeType.fields.map((f) => {
+                        const { decorators, type } = this.generateClassValidatorFieldForUpdate(f, false, validatorsUsed, transformersUsed);
+                        const mod = isTypeScript ? "?" : "";
+                        return `${decorators}  ${f.name}${mod}: ${type};`;
+                    });
+                    nestedDtoClasses.push(`class ${compositeDtoName} {\n${nestedFields.join("\n\n")}\n}`);
+                }
+                if (field.isArray)
+                    validatorsUsed.add("IsArray");
+                const eachOpt = field.isArray ? "{ each: true }" : "";
+                const typeStr = field.isArray
+                    ? `${compositeDtoName}[]`
+                    : compositeDtoName;
+                dtoFields.push(`  @IsOptional()\n${field.isArray ? "  @IsArray()\n" : ""}  @ValidateNested(${eachOpt})\n  @Type(() => ${compositeDtoName})\n  ${field.name}?: ${typeStr};`);
+                continue;
+            }
             if (field.isRelation) {
                 if (field.isArray)
                     continue;
@@ -114,7 +165,7 @@ ${dtoFields.join("\n\n")}
                         validatorsUsed.add("IsNotEmpty");
                     transformersUsed.add("Type");
                     const relationDtoName = `${referencedModel.name}ForUpdate${modelName.pascal}Dto`;
-                    const nestedDtoClass = this.generateNestedDtoClass(field, referencedModel, relationDtoName, validatorsUsed, enumsUsed, isTypeScript);
+                    const nestedDtoClass = this.generateNestedDtoClass(field, referencedModel, relationDtoName, validatorsUsed, enumsUsed, isTypeScript, transformersUsed);
                     if (!dtoFields.find((dtoField) => dtoField.includes(relationDtoName)))
                         nestedDtoClasses.push(nestedDtoClass);
                     const typeModifier = isTypeScript ? "?" : "";
@@ -125,7 +176,7 @@ ${dtoFields.join("\n\n")}
             if (prismaSchemaParser.isEnum(field.type)) {
                 enumsUsed.add(field.type);
             }
-            const { decorators, type } = this.generateClassValidatorFieldForUpdate(field, isUserModule, validatorsUsed);
+            const { decorators, type } = this.generateClassValidatorFieldForUpdate(field, isUserModule, validatorsUsed, transformersUsed);
             const typeModifier = isTypeScript ? "?" : "";
             dtoFields.push(`${decorators}  ${field.name}${typeModifier}: ${type};`);
         }
@@ -164,7 +215,7 @@ ${dtoFields.join("\n\n")}
             if (prismaSchemaParser.isEnum(field.type)) {
                 enumsUsed.add(field.type);
             }
-            const { decorators, type } = this.generateClassValidatorField(field, isUserModule, validatorsUsed);
+            const { decorators, type } = this.generateClassValidatorField(field, isUserModule, validatorsUsed, transformersUsed);
             const isOptional = field.isOptional;
             const typeModifier = isTypeScript ? (isOptional ? "?" : "!") : "";
             dtoFields.push(`${decorators}  ${field.name}${typeModifier}: ${type};`);
@@ -234,7 +285,7 @@ ${dtoFields.join("\n\n")}
                     validatorsUsed.add("ValidateNested");
                     transformersUsed.add("Type");
                     const relationDtoName = `${referencedModel.name}ForQuery${modelName.pascal}Dto`;
-                    const nestedDtoClass = this.generateNestedDtoClass(field, referencedModel, relationDtoName, validatorsUsed, enumsUsed, isTypeScript);
+                    const nestedDtoClass = this.generateNestedDtoClass(field, referencedModel, relationDtoName, validatorsUsed, enumsUsed, isTypeScript, transformersUsed);
                     if (!dtoFields.find((dtoField) => dtoField.includes(relationDtoName)) &&
                         !timestampDtoFields.find((dtoField) => dtoField.includes(relationDtoName))) {
                         nestedDtoClasses.push(nestedDtoClass);
@@ -264,7 +315,8 @@ ${dtoFields.join("\n\n")}
             }
             if (field.type === "Boolean") {
                 validatorsUsed.add("IsBoolean");
-                const fieldDef = `  @IsOptional()\n  @IsBoolean()\n  ${field.name}${typeModifier}: boolean;`;
+                transformersUsed.add("Transform");
+                const fieldDef = `  @IsOptional()\n  @Transform(({ value }) => value === true || value === "true" || value === 1 || value === "1")\n  @IsBoolean()\n  ${field.name}${typeModifier}: boolean;`;
                 if (timestampFields.includes(field.name)) {
                     timestampDtoFields.push(fieldDef);
                 }
@@ -380,14 +432,14 @@ ${allFields.join("\n\n")}
         }
         return classes.join("\n\n");
     }
-    generateNestedDtoClass(field, referencedModel, dtoName, validatorsUsed, enumsUsed, isTypeScript) {
+    generateNestedDtoClass(field, referencedModel, dtoName, validatorsUsed, enumsUsed, isTypeScript, transformersUsed) {
         const fields = [];
         const refFieldName = field.foreignReferenceField || "id";
         const refFieldAsPrismaField = referencedModel.fields.find((f) => f.name === refFieldName);
         if (refFieldAsPrismaField) {
             if (prismaSchemaParser.isEnum(refFieldAsPrismaField.type))
                 enumsUsed.add(refFieldAsPrismaField.type);
-            const { decorators, type } = this.generateClassValidatorField(refFieldAsPrismaField, false, validatorsUsed);
+            const { decorators, type } = this.generateClassValidatorField(refFieldAsPrismaField, false, validatorsUsed, transformersUsed);
             const typeModifier = isTypeScript ? "!" : "";
             fields.push(`${decorators}  ${refFieldAsPrismaField.name}${typeModifier}: ${type};`);
         }
@@ -395,7 +447,32 @@ ${allFields.join("\n\n")}
 ${fields.join("\n\n")}
 }`;
     }
-    generateClassValidatorField(field, isUserModule, validatorsUsed) {
+    generateTransformDecorator(field) {
+        const isArray = field.isArray;
+        switch (field.type) {
+            case "Int":
+            case "Float":
+            case "Decimal":
+                return isArray
+                    ? `@Transform(({ value }) => (Array.isArray(value) ? value.map((v: any) => (v !== undefined && v !== null && v !== "" ? Number(v) : v)) : value))`
+                    : `@Transform(({ value }) => (value !== undefined && value !== null && value !== "" ? Number(value) : value))`;
+            case "BigInt":
+                return isArray
+                    ? `@Transform(({ value }) => (Array.isArray(value) ? value.map((v: any) => (v !== undefined && v !== null && v !== "" ? BigInt(v) : v)) : value))`
+                    : `@Transform(({ value }) => (value !== undefined && value !== null && value !== "" ? BigInt(value) : value))`;
+            case "Boolean":
+                return isArray
+                    ? `@Transform(({ value }) => (Array.isArray(value) ? value.map((v: any) => v === true || v === "true" || v === 1 || v === "1") : value))`
+                    : `@Transform(({ value }) => value === true || value === "true" || value === 1 || value === "1")`;
+            case "DateTime":
+                return isArray
+                    ? `@Transform(({ value }) => (Array.isArray(value) ? value.map((v: any) => (v ? new Date(v) : v)) : value))`
+                    : `@Transform(({ value }) => (value ? new Date(value) : value))`;
+            default:
+                return null;
+        }
+    }
+    generateClassValidatorField(field, isUserModule, validatorsUsed, transformersUsed) {
         let decorators = [];
         let type = this.mapPrismaTypeToTS(field.type);
         const isOptional = field.isOptional || field.defaultValue !== undefined;
@@ -421,6 +498,11 @@ ${fields.join("\n\n")}
             type = field.isArray ? `${field.type}[]` : field.type;
         }
         else {
+            const transformDecorator = this.generateTransformDecorator(field);
+            if (transformDecorator) {
+                decorators.push(transformDecorator);
+                transformersUsed.add("Transform");
+            }
             const fieldValidators = this.getValidatorsForType(field, isUserModule);
             decorators.push(...fieldValidators);
             fieldValidators.forEach((decorator) => {
@@ -435,7 +517,7 @@ ${fields.join("\n\n")}
             type,
         };
     }
-    generateClassValidatorFieldForUpdate(field, isUserModule, validatorsUsed) {
+    generateClassValidatorFieldForUpdate(field, isUserModule, validatorsUsed, transformersUsed) {
         let decorators = [];
         let type = this.mapPrismaTypeToTS(field.type);
         decorators.push("@IsOptional()");
@@ -458,6 +540,11 @@ ${fields.join("\n\n")}
             type = field.isArray ? `${field.type}[]` : field.type;
         }
         else {
+            const transformDecorator = this.generateTransformDecorator(field);
+            if (transformDecorator) {
+                decorators.push(transformDecorator);
+                transformersUsed.add("Transform");
+            }
             const fieldValidators = this.getValidatorsForType(field, isUserModule);
             decorators.push(...fieldValidators);
             fieldValidators.forEach((decorator) => {
@@ -534,9 +621,218 @@ ${fields.join("\n\n")}
             case "BigInt":
                 return "bigint";
             default:
+                if (prismaSchemaParser.compositeTypes.some((t) => t.name === prismaType))
+                    return prismaType;
                 return prismaSchemaParser.isEnum(prismaType) ? prismaType : "any";
         }
     }
+    generateLoginDto(_) {
+        const ext = getUserFileExtension();
+        const isTypeScript = ext === "ts";
+        const allowedUsernames = getArkosConfig()?.authentication?.login
+            ?.allowedUsernames || ["username"];
+        const usernameFields = allowedUsernames.map((field) => {
+            const displayName = field.includes(".") ? field.split(".").pop() : field;
+            const typeModifier = isTypeScript ? "?" : "";
+            const emailDecorator = displayName === "email" ? "\n  @IsEmail()" : "\n  @IsString()";
+            return `  @IsOptional()${emailDecorator}\n  ${displayName}${typeModifier}: string;`;
+        });
+        const validatorsUsed = new Set([
+            "IsOptional",
+            "IsNotEmpty",
+            "IsString",
+            "MinLength",
+            "Matches",
+        ]);
+        const hasEmail = allowedUsernames.some((f) => (f.includes(".") ? f.split(".").pop() : f) === "email");
+        if (hasEmail)
+            validatorsUsed.add("IsEmail");
+        const typeModifier = isTypeScript ? "!" : "";
+        return `import { ${Array.from(validatorsUsed).join(", ")} } from "class-validator";
+
+export default class LoginDto {
+${usernameFields.join("\n\n")}
+
+  @IsNotEmpty()
+  @IsString()
+  @MinLength(8)
+  @Matches(/[a-z]/, { message: "Must contain lowercase" })
+  @Matches(/[A-Z]/, { message: "Must contain uppercase" })
+  @Matches(/[0-9]/, { message: "Must contain number" })
+  password${typeModifier}: string;
+}
+`;
+    }
+    generateSignupDto(_) {
+        const ext = getUserFileExtension();
+        const isTypeScript = ext === "ts";
+        const userModel = prismaSchemaParser.models.find((m) => m.name.toLowerCase() === "user");
+        if (!userModel)
+            throw new Error("User model not found in Prisma schema");
+        const restrictedFields = [
+            "id",
+            "createdAt",
+            "updatedAt",
+            "deletedAt",
+            "roles",
+            "role",
+            "isActive",
+            "isStaff",
+            "isSuperUser",
+            "passwordChangedAt",
+            "deletedSelfAccountAt",
+            "lastLoginAt",
+        ];
+        const enumsUsed = new Set();
+        const validatorsUsed = new Set();
+        const transformersUsed = new Set();
+        const nestedDtoClasses = [];
+        const dtoFields = [];
+        for (const field of userModel.fields) {
+            const isForeignKey = userModel.fields.some((f) => f.foreignKeyField === field.name);
+            if (field.isId || restrictedFields.includes(field.name) || isForeignKey)
+                continue;
+            if (field.isRelation) {
+                if (field.isArray)
+                    continue;
+                const referencedModel = prismaSchemaParser.models.find((m) => m.name === field.type);
+                if (referencedModel) {
+                    const isOptional = field.isOptional || field.defaultValue !== undefined;
+                    if (isOptional)
+                        validatorsUsed.add("IsOptional");
+                    validatorsUsed.add("ValidateNested");
+                    transformersUsed.add("Type");
+                    const relationDtoName = `${referencedModel.name}ForSignupDto`;
+                    const nestedDtoClass = this.generateNestedDtoClass(field, referencedModel, relationDtoName, validatorsUsed, enumsUsed, isTypeScript, transformersUsed);
+                    if (!dtoFields.find((d) => d.includes(relationDtoName)))
+                        nestedDtoClasses.push(nestedDtoClass);
+                    const typeModifier = isTypeScript ? (isOptional ? "?" : "!") : "";
+                    dtoFields.push(`  ${isOptional ? "@IsOptional()\n  " : ""}@ValidateNested()\n  @Type(() => ${relationDtoName})\n  ${field.name}${typeModifier}: ${relationDtoName};`);
+                }
+                continue;
+            }
+            if (prismaSchemaParser.isEnum(field.type))
+                enumsUsed.add(field.type);
+            if (field.name === "password") {
+                validatorsUsed.add("IsNotEmpty");
+                validatorsUsed.add("IsString");
+                validatorsUsed.add("MinLength");
+                validatorsUsed.add("Matches");
+                const typeModifier = isTypeScript ? "!" : "";
+                dtoFields.push(`  @IsNotEmpty()\n  @IsString()\n  @MinLength(8)\n  @Matches(/[a-z]/, { message: "Must contain lowercase" })\n  @Matches(/[A-Z]/, { message: "Must contain uppercase" })\n  @Matches(/[0-9]/, { message: "Must contain number" })\n  ${field.name}${typeModifier}: string;`);
+                continue;
+            }
+            const { decorators, type } = this.generateClassValidatorField(field, true, validatorsUsed, transformersUsed);
+            const isOptional = field.isOptional || field.defaultValue !== undefined;
+            const typeModifier = isTypeScript ? (isOptional ? "?" : "!") : "";
+            dtoFields.push(`${decorators}  ${field.name}${typeModifier}: ${type};`);
+        }
+        const enumImports = enumsUsed.size > 0
+            ? `import { ${Array.from(enumsUsed).join(", ")} } from "@prisma/client";\n`
+            : "";
+        const validatorImports = validatorsUsed.size > 0
+            ? `import { ${Array.from(validatorsUsed).join(", ")} } from "class-validator";\n`
+            : "";
+        const transformerImports = transformersUsed.size > 0
+            ? `import { ${Array.from(transformersUsed).join(", ")} } from "class-transformer";\n`
+            : "";
+        const nestedDtoSection = nestedDtoClasses.length > 0 ? `\n${nestedDtoClasses.join("\n\n")}\n` : "";
+        return `${validatorImports}${transformerImports}${enumImports}${nestedDtoSection}
+export default class SignupDto {
+${dtoFields.join("\n\n")}
+}
+`;
+    }
+    generateUpdateMeDto(_) {
+        const ext = getUserFileExtension();
+        const isTypeScript = ext === "ts";
+        const userModel = prismaSchemaParser.models.find((m) => m.name.toLowerCase() === "user");
+        if (!userModel)
+            throw new Error("User model not found in Prisma schema");
+        const restrictedFields = [
+            "id",
+            "createdAt",
+            "updatedAt",
+            "deletedAt",
+            "roles",
+            "role",
+            "isActive",
+            "isStaff",
+            "isSuperUser",
+            "passwordChangedAt",
+            "deletedSelfAccountAt",
+            "lastLoginAt",
+            "password",
+        ];
+        const enumsUsed = new Set();
+        const validatorsUsed = new Set();
+        const transformersUsed = new Set();
+        const nestedDtoClasses = [];
+        const dtoFields = [];
+        for (const field of userModel.fields) {
+            const isForeignKey = userModel.fields.some((f) => f.foreignKeyField === field.name);
+            if (field.isId || restrictedFields.includes(field.name) || isForeignKey)
+                continue;
+            if (field.isRelation) {
+                if (field.isArray)
+                    continue;
+                const referencedModel = prismaSchemaParser.models.find((m) => m.name === field.type);
+                if (referencedModel) {
+                    validatorsUsed.add("IsOptional");
+                    validatorsUsed.add("ValidateNested");
+                    transformersUsed.add("Type");
+                    const relationDtoName = `${referencedModel.name}ForUpdateMeDto`;
+                    const nestedDtoClass = this.generateNestedDtoClass(field, referencedModel, relationDtoName, validatorsUsed, enumsUsed, isTypeScript, transformersUsed);
+                    if (!dtoFields.find((d) => d.includes(relationDtoName)))
+                        nestedDtoClasses.push(nestedDtoClass);
+                    const typeModifier = isTypeScript ? "?" : "";
+                    dtoFields.push(`  @IsOptional()\n  @ValidateNested()\n  @Type(() => ${relationDtoName})\n  ${field.name}${typeModifier}: ${relationDtoName};`);
+                }
+                continue;
+            }
+            if (prismaSchemaParser.isEnum(field.type))
+                enumsUsed.add(field.type);
+            const { decorators, type } = this.generateClassValidatorFieldForUpdate(field, true, validatorsUsed, transformersUsed);
+            const typeModifier = isTypeScript ? "?" : "";
+            dtoFields.push(`${decorators}  ${field.name}${typeModifier}: ${type};`);
+        }
+        const enumImports = enumsUsed.size > 0
+            ? `import { ${Array.from(enumsUsed).join(", ")} } from "@prisma/client";\n`
+            : "";
+        const validatorImports = validatorsUsed.size > 0
+            ? `import { ${Array.from(validatorsUsed).join(", ")} } from "class-validator";\n`
+            : "";
+        const transformerImports = transformersUsed.size > 0
+            ? `import { ${Array.from(transformersUsed).join(", ")} } from "class-transformer";\n`
+            : "";
+        const nestedDtoSection = nestedDtoClasses.length > 0 ? `\n${nestedDtoClasses.join("\n\n")}\n` : "";
+        return `${validatorImports}${transformerImports}${enumImports}${nestedDtoSection}
+export default class UpdateMeDto {
+${dtoFields.join("\n\n")}
+}
+`;
+    }
+    generateUpdatePasswordDto(_) {
+        const ext = getUserFileExtension();
+        const isTypeScript = ext === "ts";
+        const typeModifier = isTypeScript ? "!" : "";
+        return `import { IsNotEmpty, IsString, MinLength, Matches } from "class-validator";
+
+export default class UpdatePasswordDto {
+  @IsNotEmpty()
+  @IsString()
+  currentPassword${typeModifier}: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MinLength(8)
+  @Matches(/[a-z]/, { message: "Must contain lowercase" })
+  @Matches(/[A-Z]/, { message: "Must contain uppercase" })
+  @Matches(/[0-9]/, { message: "Must contain number" })
+  newPassword${typeModifier}: string;
+}
+`;
+    }
 }
 const classValidatorDtoGenerator = new ClassValidatorDtoGenerator();
 export default classValidatorDtoGenerator;