@comet/api-generator 8.0.0-beta.4 → 8.0.0-beta.6

package/bin/api-generator.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 require("ts-node").register({
     require: ["tsconfig-paths/register"],
+    transpileOnly: true,
 });
 require("../lib/apiGenerator");

package/lib/commands/generate/generate-command.js

@@ -10,44 +10,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommand = void 0;
-const cli_1 = require("@mikro-orm/cli");
-const lazy_metadata_storage_1 = require("@nestjs/graphql/dist/schema-builder/storages/lazy-metadata.storage");
 const commander_1 = require("commander");
-const generate_crud_1 = require("./generateCrud/generate-crud");
-const generate_crud_single_1 = require("./generateCrudSingle/generate-crud-single");
-const write_generated_files_1 = require("./utils/write-generated-files");
-exports.generateCommand = new commander_1.Command("generate").action((options) => __awaiter(void 0, void 0, void 0, function* () {
-    let orm = null;
-    try {
-        orm = yield cli_1.CLIHelper.getORM(undefined, undefined, { dbName: "generator" });
+const generateFiles_1 = require("./generateFiles");
+const watchMode_1 = require("./watchMode/watchMode");
+exports.generateCommand = new commander_1.Command("generate")
+    .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (options.watch) {
+        yield (0, generateFiles_1.generateFiles)();
+        console.log("Watching for modified entities...");
+        yield (0, watchMode_1.watchMode)();
     }
-    catch (e) {
-        console.warn(e);
+    else {
+        (0, generateFiles_1.generateFiles)(options.file);
     }
-    if (orm != null) {
-        const entities = orm.em.getMetadata().getAll();
-        lazy_metadata_storage_1.LazyMetadataStorage.load();
-        for (const name in entities) {
-            const entity = entities[name];
-            if (!entity.class) {
-                // Ignore e.g. relation entities that don't have a class
-                continue;
-            }
-            {
-                const generatorOptions = Reflect.getMetadata(`data:crudGeneratorOptions`, entity.class);
-                if (generatorOptions) {
-                    const files = yield (0, generate_crud_1.generateCrud)(generatorOptions, entity);
-                    yield (0, write_generated_files_1.writeGeneratedFiles)(files, { targetDirectory: generatorOptions.targetDirectory });
-                }
-            }
-            {
-                const generatorOptions = Reflect.getMetadata(`data:crudSingleGeneratorOptions`, entity.class);
-                if (generatorOptions) {
-                    const files = yield (0, generate_crud_single_1.generateCrudSingle)(generatorOptions, entity);
-                    yield (0, write_generated_files_1.writeGeneratedFiles)(files, { targetDirectory: generatorOptions.targetDirectory });
-                }
-            }
-        }
-        yield orm.close(true);
-    }
-}));
+}))
+    .option("-f, --file <file>", "path to entity file")
+    .option("-w, --watch", "Watch for changes");

package/lib/commands/generate/generateCrud/generate-crud.js

@@ -106,7 +106,8 @@ function buildOptions(metadata, generatorOptions) {
             prop.type === "DateType" ||
             prop.type === "Date" ||
             prop.kind === "m:1" ||
-            prop.type === "EnumArrayType"));
+            prop.type === "EnumArrayType" ||
+            prop.enum));
     const hasSortArg = crudSortProps.length > 0;
     const hasSlugProp = metadata.props.some((prop) => prop.name == "slug");
     const scopeProp = metadata.props.find((prop) => prop.name == "scope");
@@ -147,7 +148,7 @@ function buildOptions(metadata, generatorOptions) {
 function generateFilterDto({ generatorOptions, metadata }) {
     const { classNameSingular } = (0, build_name_variants_1.buildNameVariants)(metadata);
     const { crudFilterProps } = buildOptions(metadata, generatorOptions);
-    let importsOut = "";
+    const imports = [];
     let enumFiltersOut = "";
     const generatedEnumNames = new Set();
     const generatedEnumsNames = new Set();
@@ -160,7 +161,7 @@ function generateFilterDto({ generatorOptions, metadata }) {
                 enumFiltersOut += `@InputType()
                     class ${enumName}EnumsFilter extends createEnumsFilter(${enumName}) {}
                 `;
-                importsOut += `import { ${enumName} } from "${importPath}";`;
+                imports.push({ name: enumName, importPath });
             }
         }
         else if (prop.enum) {
@@ -171,7 +172,7 @@ function generateFilterDto({ generatorOptions, metadata }) {
                 enumFiltersOut += `@InputType()
                     class ${enumName}EnumFilter extends createEnumFilter(${enumName}) {}
                 `;
-                importsOut += `import { ${enumName} } from "${importPath}";`;
+                imports.push({ name: enumName, importPath });
             }
         }
     });
@@ -179,7 +180,7 @@ function generateFilterDto({ generatorOptions, metadata }) {
     import { Field, InputType } from "@nestjs/graphql";
     import { Type } from "class-transformer";
     import { IsNumber, IsOptional, IsString, ValidateNested } from "class-validator";
-    ${importsOut}
+    ${(0, generate_imports_code_1.generateImportsCode)(imports)}
 
     ${enumFiltersOut}
 
@@ -434,9 +435,7 @@ function generateService({ generatorOptions, metadata }) {
         })
             .join(",")} }`
         : false;
-    const serviceOut = `import { FilterQuery } from "@mikro-orm/postgresql";
-    import { InjectRepository } from "@mikro-orm/nestjs";
-    import { EntityRepository, EntityManager, raw } from "@mikro-orm/postgresql";
+    const serviceOut = `import { EntityManager, FilterQuery, raw } from "@mikro-orm/postgresql";
     import { Injectable } from "@nestjs/common";
 
     ${(0, generate_imports_code_1.generateImportsCode)([generateEntityImport(metadata, generatorOptions.targetDirectory)])}
@@ -452,8 +451,7 @@ function generateService({ generatorOptions, metadata }) {
     export class ${classNamePlural}Service {    
         ${hasPositionProp
         ? `constructor(
-                    private readonly entityManager: EntityManager,
-                    @InjectRepository(${metadata.className}) private readonly repository: EntityRepository<${metadata.className}>,
+                    protected readonly entityManager: EntityManager,
                 ) {}`
         : ""}
 
@@ -461,7 +459,7 @@ function generateService({ generatorOptions, metadata }) {
         ? `
                 async incrementPositions(${positionGroupProps.length ? `group: ${positionGroupType},` : ``}lowestPosition: number, highestPosition?: number) {
                     // Increment positions between newPosition (inclusive) and oldPosition (exclusive)
-                    await this.repository.nativeUpdate(
+                    await this.entityManager.nativeUpdate(${metadata.className},
                     ${positionGroupProps.length
             ? `{
                             $and: [
@@ -476,7 +474,7 @@ function generateService({ generatorOptions, metadata }) {
 
                 async decrementPositions(${positionGroupProps.length ? `group: ${positionGroupType},` : ``}lowestPosition: number, highestPosition?: number) {
                     // Decrement positions between oldPosition (exclusive) and newPosition (inclusive)
-                    await this.repository.nativeUpdate(
+                    await this.entityManager.nativeUpdate(${metadata.className},
                     ${positionGroupProps.length
             ? `{
                             $and: [
@@ -490,7 +488,7 @@ function generateService({ generatorOptions, metadata }) {
                 }
 
                 async getLastPosition(${positionGroupProps.length ? `group: ${positionGroupType}` : ``}) {
-                    return this.repository.count(${positionGroupProps.length ? `this.getPositionGroupCondition(group)` : `{}`});
+                    return this.entityManager.count(${metadata.className}, ${positionGroupProps.length ? `this.getPositionGroupCondition(group)` : `{}`});
                 }
 
                 ${positionGroupProps.length
@@ -515,7 +513,6 @@ function generateEntityImport(targetMetadata, relativeTo) {
 function generateInputHandling(options, metadata, generatorOptions) {
     const { instanceNameSingular } = (0, build_name_variants_1.buildNameVariants)(metadata);
     const { blockProps, scopeProp, hasPositionProp, dedicatedResolverArgProps } = buildOptions(metadata, generatorOptions);
-    const injectRepositories = [];
     const props = metadata.props.filter((prop) => !options.excludeFields || !options.excludeFields.includes(prop.name));
     const relationManyToOneProps = props.filter((prop) => prop.kind === "m:1");
     const relationOneToManyProps = props.filter((prop) => prop.kind === "1:m");
@@ -531,13 +528,11 @@ function generateInputHandling(options, metadata, generatorOptions) {
         const targetMeta = prop.targetMeta;
         if (!targetMeta)
             throw new Error("targetMeta is not set for relation");
-        injectRepositories.push(targetMeta);
         return {
             name: prop.name,
             singularName: (0, pluralize_1.singular)(prop.name),
             nullable: prop.nullable,
             type: prop.type,
-            repositoryName: `${(0, build_name_variants_1.classNameToInstanceName)(prop.type)}Repository`,
         };
     });
     const inputRelationOneToOneProps = relationOneToOneProps
@@ -546,13 +541,11 @@ function generateInputHandling(options, metadata, generatorOptions) {
         const targetMeta = prop.targetMeta;
         if (!targetMeta)
             throw new Error("targetMeta is not set for relation");
-        injectRepositories.push(targetMeta);
         return {
             name: prop.name,
             singularName: (0, pluralize_1.singular)(prop.name),
             nullable: prop.nullable,
             type: prop.type,
-            repositoryName: `${(0, build_name_variants_1.classNameToInstanceName)(prop.type)}Repository`,
             targetMeta,
         };
     });
@@ -562,20 +555,17 @@ function generateInputHandling(options, metadata, generatorOptions) {
         const targetMeta = prop.targetMeta;
         if (!targetMeta)
             throw new Error("targetMeta is not set for relation");
-        injectRepositories.push(targetMeta);
         return {
             name: prop.name,
             singularName: (0, pluralize_1.singular)(prop.name),
             nullable: prop.nullable,
             type: prop.type,
-            repositoryName: `${(0, build_name_variants_1.classNameToInstanceName)(prop.type)}Repository`,
             orphanRemoval: prop.orphanRemoval,
             targetMeta,
         };
     });
     function innerGenerateInputHandling(...args) {
         const ret = generateInputHandling(...args);
-        injectRepositories.push(...ret.injectRepositories);
         return ret.code;
     }
     const noAssignProps = [...inputRelationToManyProps, ...inputRelationManyToOneProps, ...inputRelationOneToOneProps, ...blockProps];
@@ -589,13 +579,13 @@ function generateInputHandling(options, metadata, generatorOptions) {
         ${options.mode == "create"
         ? dedicatedResolverArgProps
             .map((dedicatedResolverArgProp) => {
-            return `${dedicatedResolverArgProp.name}: Reference.create(await this.${(0, build_name_variants_1.classNameToInstanceName)(dedicatedResolverArgProp.type)}Repository.findOneOrFail(${dedicatedResolverArgProp.name})), `;
+            return `${dedicatedResolverArgProp.name}: Reference.create(await this.entityManager.findOneOrFail(${dedicatedResolverArgProp.type}, ${dedicatedResolverArgProp.name})), `;
         })
             .join("")
         : ""}
         ${options.mode == "create" || options.mode == "updateNested"
         ? inputRelationManyToOneProps
-            .map((prop) => `${prop.name}: ${prop.nullable ? `${prop.name}Input ? ` : ""}Reference.create(await this.${prop.repositoryName}.findOneOrFail(${prop.name}Input))${prop.nullable ? ` : undefined` : ""}, `)
+            .map((prop) => `${prop.name}: ${prop.nullable ? `${prop.name}Input ? ` : ""}Reference.create(await this.entityManager.findOneOrFail(${prop.type}, ${prop.name}Input))${prop.nullable ? ` : undefined` : ""}, `)
             .join("")
         : ""}
         ${options.mode == "create" || options.mode == "updateNested"
@@ -608,8 +598,8 @@ ${inputRelationToManyProps
             const code = innerGenerateInputHandling({
                 mode: "updateNested",
                 inputName: `${prop.singularName}Input`,
-                // alternative `return this.${prop.repositoryName}.create({` requires back relation to be set
-                assignEntityCode: `return this.${prop.repositoryName}.assign(new ${prop.type}(), {`,
+                // alternative `return this.entityManager.create(${prop.type}, {` requires back relation to be set
+                assignEntityCode: `return this.entityManager.assign(new ${prop.type}(), {`,
                 excludeFields: prop.targetMeta.props
                     .filter((prop) => prop.kind == "m:1" && prop.targetMeta == metadata) //filter out referencing back to this entity
                     .map((prop) => prop.name),
@@ -629,7 +619,7 @@ ${inputRelationToManyProps
         else {
             return `
             if (${prop.name}Input) {
-                const ${prop.name} = await this.${prop.repositoryName}.find({ id: ${prop.name}Input });
+                const ${prop.name} = await this.entityManager.find(${prop.type}, { id: ${prop.name}Input });
                 if (${prop.name}.length != ${prop.name}Input.length) throw new Error("Couldn't find all ${prop.name} that were passed as input");
                 await ${instanceNameSingular}.${prop.name}.loadItems();
                 ${instanceNameSingular}.${prop.name}.set(${prop.name}.map((${prop.singularName}) => Reference.create(${prop.singularName})));
@@ -647,7 +637,7 @@ ${inputRelationOneToOneProps
                 ${innerGenerateInputHandling({
         mode: "updateNested",
         inputName: `${prop.name}Input`,
-        assignEntityCode: `this.${prop.repositoryName}.assign(${prop.singularName}, {`,
+        assignEntityCode: `this.entityManager.assign(${prop.singularName}, {`,
         excludeFields: prop.targetMeta.props
             .filter((prop) => prop.kind == "1:1" && prop.targetMeta == metadata) //filter out referencing back to this entity
             .map((prop) => prop.name),
@@ -659,7 +649,7 @@ ${options.mode == "update"
             .map((prop) => `if (${prop.name}Input !== undefined) {
                         ${instanceNameSingular}.${prop.name} =
                             ${prop.nullable ? `${prop.name}Input ? ` : ""}
-                            Reference.create(await this.${prop.repositoryName}.findOneOrFail(${prop.name}Input))
+                            Reference.create(await this.entityManager.findOneOrFail(${prop.type}, ${prop.name}Input))
                             ${prop.nullable ? ` : undefined` : ""};
                         }`)
             .join("")
@@ -673,7 +663,7 @@ ${options.mode == "update"
             .join("")
         : ""}
     `;
-    return { code, injectRepositories };
+    return { code };
 }
 function generateNestedEntityResolver({ generatorOptions, metadata }) {
     const { classNameSingular } = (0, build_name_variants_1.buildNameVariants)(metadata);
@@ -692,7 +682,7 @@ function generateNestedEntityResolver({ generatorOptions, metadata }) {
     @Resolver(() => ${metadata.className})
     @RequiredPermission(${JSON.stringify(generatorOptions.requiredPermission)}${skipScopeCheck ? `, { skipScopeCheck: true }` : ""})
     export class ${classNameSingular}Resolver {
-        ${needsBlocksTransformer ? `constructor(private readonly blocksTransformer: BlocksTransformerService) {}` : ""}
+        ${needsBlocksTransformer ? `constructor(protected readonly blocksTransformer: BlocksTransformerService) {}` : ""}
         ${code}
     }
     `;
@@ -800,16 +790,12 @@ function generateResolver({ generatorOptions, metadata }) {
     const outputRelationManyToManyProps = relationManyToManyProps.filter((prop) => (0, cms_api_1.hasCrudFieldFeature)(metadata.class, prop.name, "resolveField"));
     const outputRelationOneToOneProps = relationOneToOneProps.filter((prop) => (0, cms_api_1.hasCrudFieldFeature)(metadata.class, prop.name, "resolveField"));
     const imports = [];
-    const injectRepositories = new Array();
-    const { code: createInputHandlingCode, injectRepositories: createInputHandlingInjectRepositories } = generateInputHandling({ mode: "create", inputName: "input", assignEntityCode: `const ${instanceNameSingular} = this.repository.create({` }, metadata, generatorOptions);
-    injectRepositories.push(...createInputHandlingInjectRepositories);
-    const { code: updateInputHandlingCode, injectRepositories: updateInputHandlingInjectRepositories } = generateInputHandling({ mode: "update", inputName: "input", assignEntityCode: `${instanceNameSingular}.assign({` }, metadata, generatorOptions);
-    injectRepositories.push(...updateInputHandlingInjectRepositories);
-    injectRepositories.push(...dedicatedResolverArgProps.map((prop) => {
-        if (!prop.targetMeta)
-            throw new Error("targetMeta is not set for relation");
-        return prop.targetMeta;
-    }));
+    const { code: createInputHandlingCode } = generateInputHandling({
+        mode: "create",
+        inputName: "input",
+        assignEntityCode: `const ${instanceNameSingular} = this.entityManager.create(${metadata.className}, {`,
+    }, metadata, generatorOptions);
+    const { code: updateInputHandlingCode } = generateInputHandling({ mode: "update", inputName: "input", assignEntityCode: `${instanceNameSingular}.assign({` }, metadata, generatorOptions);
     const { imports: relationsFieldResolverImports, code: relationsFieldResolverCode, hasOutputRelations, needsBlocksTransformer, } = generateRelationsFieldResolver({
         generatorOptions,
         metadata,
@@ -819,7 +805,6 @@ function generateResolver({ generatorOptions, metadata }) {
     if (scopeProp && scopeProp.targetMeta) {
         imports.push(generateEntityImport(scopeProp.targetMeta, generatorOptions.targetDirectory));
     }
-    imports.push(...injectRepositories.map((meta) => generateEntityImport(meta, generatorOptions.targetDirectory)));
     function generateIdArg(name, metadata) {
         if (constants_1.integerTypes.includes(metadata.properties[name].type)) {
             return `@Args("${name}", { type: () => ID }, { transform: (value) => parseInt(value) }) ${name}: number`;
@@ -836,9 +821,7 @@ function generateResolver({ generatorOptions, metadata }) {
     imports.push({ name: "RootBlockDataScalar", importPath: "@comet/cms-api" });
     imports.push({ name: "BlocksTransformerService", importPath: "@comet/cms-api" });
     imports.push({ name: "gqlArgsToMikroOrmQuery", importPath: "@comet/cms-api" });
-    const resolverOut = `import { InjectRepository } from "@mikro-orm/nestjs";
-    import { EntityRepository, EntityManager } from "@mikro-orm/postgresql";
-    import { FindOptions, ObjectQuery, Reference } from "@mikro-orm/postgresql";
+    const resolverOut = `import { EntityManager, FindOptions, ObjectQuery, Reference } from "@mikro-orm/postgresql";
     import { Args, ID, Info, Mutation, Query, Resolver, ResolveField, Parent } from "@nestjs/graphql";
     import { GraphQLResolveInfo } from "graphql";
 
@@ -852,19 +835,20 @@ function generateResolver({ generatorOptions, metadata }) {
     @RequiredPermission(${JSON.stringify(generatorOptions.requiredPermission)}${skipScopeCheck ? `, { skipScopeCheck: true }` : ""})
     export class ${classNameSingular}Resolver {
         constructor(
-            private readonly entityManager: EntityManager,${hasPositionProp ? `private readonly ${instanceNamePlural}Service: ${classNamePlural}Service,` : ``}
-            @InjectRepository(${metadata.className}) private readonly repository: EntityRepository<${metadata.className}>,
-            ${[...new Set(injectRepositories.map((meta) => meta.className))]
-        .map((type) => `@InjectRepository(${type}) private readonly ${(0, build_name_variants_1.classNameToInstanceName)(type)}Repository: EntityRepository<${type}>,`)
-        .join("")}${needsBlocksTransformer ? `private readonly blocksTransformer: BlocksTransformerService,` : ""}
+            protected readonly entityManager: EntityManager,${hasPositionProp ? `protected readonly ${instanceNamePlural}Service: ${classNamePlural}Service,` : ``}
+            ${needsBlocksTransformer ? `private readonly blocksTransformer: BlocksTransformerService,` : ""}
         ) {}
 
+        ${generatorOptions.single
+        ? `
         @Query(() => ${metadata.className})
         @AffectedEntity(${metadata.className})
         async ${instanceNameSingular}(${generateIdArg("id", metadata)}): Promise<${metadata.className}> {
-            const ${instanceNameSingular} = await this.repository.findOneOrFail(id);
+            const ${instanceNameSingular} = await this.entityManager.findOneOrFail(${metadata.className}, id);
             return ${instanceNameSingular};
         }
+        `
+        : ""}
 
         ${hasSlugProp
         ? `
@@ -873,7 +857,7 @@ function generateResolver({ generatorOptions, metadata }) {
             @Args("slug") slug: string
             ${scopeProp ? `, @Args("scope", { type: () => ${scopeProp.type} }) scope: ${scopeProp.type}` : ""}
         ): Promise<${metadata.className} | null> {
-            const ${instanceNameSingular} = await this.repository.findOne({ slug${scopeProp ? `, scope` : ""}});
+            const ${instanceNameSingular} = await this.entityManager.findOne(${metadata.className}, { slug${scopeProp ? `, scope` : ""}});
 
             return ${instanceNameSingular} ?? null;
         }
@@ -900,7 +884,7 @@ function generateResolver({ generatorOptions, metadata }) {
             ${hasOutputRelations ? `, @Info() info: GraphQLResolveInfo` : ""}
         ): Promise<Paginated${classNamePlural}> {
             const where${hasSearchArg || hasFilterArg
-            ? ` = gqlArgsToMikroOrmQuery({ ${hasSearchArg ? `search, ` : ""}${hasFilterArg ? `filter, ` : ""} }, this.repository);`
+            ? ` = gqlArgsToMikroOrmQuery({ ${hasSearchArg ? `search, ` : ""}${hasFilterArg ? `filter, ` : ""} }, this.entityManager.getMetadata(${metadata.className}));`
             : `: ObjectQuery<${metadata.className}> = {}`}
             ${scopeProp ? `where.scope = scope;` : ""}
             ${dedicatedResolverArgProps
@@ -932,7 +916,7 @@ function generateResolver({ generatorOptions, metadata }) {
             }`
             : ""}
 
-            const [entities, totalCount] = await this.repository.findAndCount(where, options);
+            const [entities, totalCount] = await this.entityManager.findAndCount(${metadata.className}, where, options);
             return new Paginated${classNamePlural}(entities, totalCount);
         }
         `
@@ -1003,7 +987,7 @@ function generateResolver({ generatorOptions, metadata }) {
             ${generateIdArg("id", metadata)},
             @Args("input", { type: () => ${classNameSingular}UpdateInput }) input: ${classNameSingular}UpdateInput
         ): Promise<${metadata.className}> {
-            const ${instanceNameSingular} = await this.repository.findOneOrFail(id);
+            const ${instanceNameSingular} = await this.entityManager.findOneOrFail(${metadata.className}, id);
 
             ${hasPositionProp
             ? `
@@ -1052,7 +1036,7 @@ function generateResolver({ generatorOptions, metadata }) {
         @Mutation(() => Boolean)
         @AffectedEntity(${metadata.className})
         async delete${metadata.className}(${generateIdArg("id", metadata)}): Promise<boolean> {
-            const ${instanceNameSingular} = await this.repository.findOneOrFail(id);
+            const ${instanceNameSingular} = await this.entityManager.findOneOrFail(${metadata.className}, id);
             this.entityManager.remove(${instanceNameSingular});${hasPositionProp
             ? `await this.${instanceNamePlural}Service.decrementPositions(${positionGroupProps.length
                 ? `{ ${positionGroupProps
@@ -1075,8 +1059,11 @@ function generateResolver({ generatorOptions, metadata }) {
 }
 function generateCrud(generatorOptionsParam, metadata) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        const generatorOptions = Object.assign(Object.assign({}, generatorOptionsParam), { create: (_a = generatorOptionsParam.create) !== null && _a !== void 0 ? _a : true, update: (_b = generatorOptionsParam.update) !== null && _b !== void 0 ? _b : true, delete: (_c = generatorOptionsParam.delete) !== null && _c !== void 0 ? _c : true, list: (_d = generatorOptionsParam.list) !== null && _d !== void 0 ? _d : true });
+        var _a, _b, _c, _d, _e;
+        const generatorOptions = Object.assign(Object.assign({}, generatorOptionsParam), { create: (_a = generatorOptionsParam.create) !== null && _a !== void 0 ? _a : true, update: (_b = generatorOptionsParam.update) !== null && _b !== void 0 ? _b : true, delete: (_c = generatorOptionsParam.delete) !== null && _c !== void 0 ? _c : true, list: (_d = generatorOptionsParam.list) !== null && _d !== void 0 ? _d : true, single: (_e = generatorOptionsParam.single) !== null && _e !== void 0 ? _e : true });
+        if (!generatorOptions.create && !generatorOptions.update && !generatorOptions.delete && !generatorOptions.list && !generatorOptions.single) {
+            throw new Error("At least one of create, update, delete, list or single must be true");
+        }
         const generatedFiles = [];
         const { fileNameSingular, fileNamePlural, instanceNamePlural } = (0, build_name_variants_1.buildNameVariants)(metadata);
         const { hasFilterArg, hasSortArg, argsFileName, hasPositionProp } = buildOptions(metadata, generatorOptions);

package/lib/commands/generate/generateCrudInput/generate-crud-input.js

@@ -96,6 +96,7 @@ function generateCrudInput(generatorOptions_1, metadata_1) {
                 const fieldOptions = tsCodeRecordToString({ nullable: "true", defaultValue });
                 isOptional = true;
                 decorators.push(`@IsOptional()`);
+                imports.push({ name: "Min", importPath: "class-validator" });
                 decorators.push(`@Min(1)`);
                 decorators.push("@IsInt()");
                 decorators.push(`@Field(() => Int, ${fieldOptions})`);
@@ -395,6 +396,16 @@ function generateCrudInput(generatorOptions_1, metadata_1) {
                 decorators.push("@IsUUID()");
                 type = "string";
             }
+            else if ((0, ts_morph_helper_1.getFieldDecoratorClassName)(prop.name, metadata)) {
+                //for custom mikro-orm type
+                const className = (0, ts_morph_helper_1.getFieldDecoratorClassName)(prop.name, metadata);
+                const importPath = (0, ts_morph_helper_1.findInputClassImportPath)(className, `${generatorOptions.targetDirectory}/dto`, metadata);
+                imports.push({ name: className, importPath });
+                decorators.push(`@ValidateNested()`);
+                decorators.push(`@Type(() => ${className})`);
+                decorators.push(`@Field(() => ${className}${prop.nullable ? ", { nullable: true }" : ""})`);
+                type = className;
+            }
             else {
                 console.warn(`${prop.name}: unsupported type ${type}`);
                 continue;
@@ -434,7 +445,7 @@ function generateCrudInput(generatorOptions_1, metadata_1) {
         const className = (_m = options.className) !== null && _m !== void 0 ? _m : `${metadata.className}Input`;
         const inputOut = `import { Field, InputType, ID, Int } from "@nestjs/graphql";
 import { Transform, Type } from "class-transformer";
-import { IsString, IsNotEmpty, ValidateNested, IsNumber, IsBoolean, IsDate, IsOptional, IsEnum, IsUUID, IsArray, IsInt, Min } from "class-validator";
+import { IsString, IsNotEmpty, ValidateNested, IsNumber, IsBoolean, IsDate, IsOptional, IsEnum, IsUUID, IsArray, IsInt } from "class-validator";
 import { GraphQLJSONObject } from "graphql-scalars";
 import { GraphQLDate } from "graphql-scalars";
 ${(0, generate_imports_code_1.generateImportsCode)(imports)}

package/lib/commands/generate/generateCrudSingle/generate-crud-single.js

@@ -67,8 +67,6 @@ function generateCrudSingle(generatorOptions, metadata) {
                     return (0, cms_api_1.hasCrudFieldFeature)(metadata.class, prop.name, "input") && prop.type === "RootBlockType";
                 });
                 const serviceOut = `import { ObjectQuery } from "@mikro-orm/postgresql";
-    import { InjectRepository } from "@mikro-orm/nestjs";
-    import { EntityRepository } from "@mikro-orm/postgresql";
     import { Injectable } from "@nestjs/common";
     import { ${metadata.className} } from "${path.relative(generatorOptions.targetDirectory, metadata.path).replace(/\.ts$/, "")}";
     
@@ -78,9 +76,7 @@ function generateCrudSingle(generatorOptions, metadata) {
     }
     `;
                 generatedFiles.push({ name: `${fileNamePlural}.service.ts`, content: serviceOut, type: "service" });
-                const resolverOut = `import { InjectRepository } from "@mikro-orm/nestjs";
-    import { EntityRepository, EntityManager } from "@mikro-orm/postgresql";
-    import { FindOptions } from "@mikro-orm/postgresql";
+                const resolverOut = `import { FindOptions, EntityManager } from "@mikro-orm/postgresql";
     import { Args, ID, Mutation, Query, Resolver } from "@nestjs/graphql";
     import { RequiredPermission, SortDirection, validateNotModified } from "@comet/cms-api";
     
@@ -92,22 +88,20 @@ function generateCrudSingle(generatorOptions, metadata) {
                     : ""}
     import { ${classNamePlural}Service } from "./${fileNamePlural}.service";
     import { ${classNameSingular}Input } from "./dto/${fileNameSingular}.input";
-    import { Paginated${classNamePlural} } from "./dto/paginated-${fileNamePlural}";
 
     @Resolver(() => ${metadata.className})
     @RequiredPermission(${JSON.stringify(generatorOptions.requiredPermission)}${!scopeProp ? `, { skipScopeCheck: true }` : ""})
     export class ${classNameSingular}Resolver {
         constructor(
-            private readonly entityManager: EntityManager,
-            private readonly ${instanceNamePlural}Service: ${classNamePlural}Service,
-            @InjectRepository(${metadata.className}) private readonly repository: EntityRepository<${metadata.className}>
+            protected readonly entityManager: EntityManager,
+            protected readonly ${instanceNamePlural}Service: ${classNamePlural}Service,
         ) {}
     
         @Query(() => ${metadata.className}, { nullable: true })
         async ${instanceNameSingular}(
                 ${scopeProp ? `@Args("scope", { type: () => ${scopeProp.type} }) scope: ${scopeProp.type},` : ""}
             ): Promise<${metadata.className} | null> {
-            const ${instanceNamePlural} = await this.repository.find({${scopeProp ? `scope` : ""}});
+            const ${instanceNamePlural} = await this.entityManager.find(${metadata.className}, {${scopeProp ? `scope` : ""}});
             if (${instanceNamePlural}.length > 1) {
                 throw new Error("There must be only one ${instanceNameSingular}");
             }
@@ -120,10 +114,10 @@ function generateCrudSingle(generatorOptions, metadata) {
             ${scopeProp ? `@Args("scope", { type: () => ${scopeProp.type} }) scope: ${scopeProp.type},` : ""}
             @Args("input", { type: () => ${classNameSingular}Input }) input: ${classNameSingular}Input
         ): Promise<${metadata.className}> {
-            let ${instanceNameSingular} = await this.repository.findOne({${scopeProp ? `scope` : ""}});
+            let ${instanceNameSingular} = await this.entityManager.findOne(${metadata.className}, {${scopeProp ? `scope` : ""}});
 
             if (!${instanceNameSingular}) {
-                ${instanceNameSingular} = this.repository.create({ 
+                ${instanceNameSingular} = this.entityManager.create(${metadata.className}, {
                     ...input,
                     ${blockProps.length ? `${blockProps.map((prop) => `${prop.name}: input.${prop.name}.transformToBlockData()`).join(", ")}, ` : ""}
                     ${scopeProp ? `scope,` : ""} 

package/lib/commands/generate/generateFiles.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generate mode for the generator.
+ *
+ * Generates CRUD files for all entities or a specific entity available at file path.
+ * @param file
+ */
+export declare const generateFiles: (file?: string) => Promise<void>;

package/lib/commands/generate/generateFiles.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFiles = void 0;
+const node_console_1 = __importDefault(require("node:console"));
+const cli_1 = require("@mikro-orm/cli");
+const lazy_metadata_storage_1 = require("@nestjs/graphql/dist/schema-builder/storages/lazy-metadata.storage");
+const generate_crud_1 = require("./generateCrud/generate-crud");
+const generate_crud_single_1 = require("./generateCrudSingle/generate-crud-single");
+const write_generated_files_1 = require("./utils/write-generated-files");
+/**
+ * Generate mode for the generator.
+ *
+ * Generates CRUD files for all entities or a specific entity available at file path.
+ * @param file
+ */
+const generateFiles = (
+/**
+ * File path to the entity for which to generate CRUD files.
+ *
+ * @default undefined -> generate all entities
+ */
+file) => __awaiter(void 0, void 0, void 0, function* () {
+    let orm = null;
+    try {
+        orm = yield cli_1.CLIHelper.getORM(undefined, undefined, { dbName: "generator" });
+    }
+    catch (e) {
+        node_console_1.default.warn(e);
+    }
+    if (orm != null) {
+        const entities = orm.em.getMetadata().getAll();
+        lazy_metadata_storage_1.LazyMetadataStorage.load();
+        for (const name in entities) {
+            const entity = entities[name];
+            if (!entity.class) {
+                // Ignore e.g. relation entities that don't have a class
+                continue;
+            }
+            if (file == null || entity.path === `./${file}`) {
+                {
+                    const generatorOptions = Reflect.getMetadata(`data:crudGeneratorOptions`, entity.class);
+                    if (generatorOptions) {
+                        node_console_1.default.log(`🚀 start generateCrud for Entity ${entity.path}`);
+                        const files = yield (0, generate_crud_1.generateCrud)(generatorOptions, entity);
+                        yield (0, write_generated_files_1.writeGeneratedFiles)(files, { targetDirectory: generatorOptions.targetDirectory });
+                    }
+                }
+                {
+                    const generatorOptions = Reflect.getMetadata(`data:crudSingleGeneratorOptions`, entity.class);
+                    if (generatorOptions) {
+                        node_console_1.default.log(`🚀 start generateCrudSingle for Entity ${entity.path}`);
+                        const files = yield (0, generate_crud_single_1.generateCrudSingle)(generatorOptions, entity);
+                        yield (0, write_generated_files_1.writeGeneratedFiles)(files, { targetDirectory: generatorOptions.targetDirectory });
+                    }
+                }
+            }
+        }
+    }
+});
+exports.generateFiles = generateFiles;

package/lib/commands/generate/utils/build-name-variants.d.ts

@@ -1,5 +1,4 @@
 import { type EntityMetadata } from "@mikro-orm/postgresql";
-export declare function classNameToInstanceName(className: string): string;
 export declare function buildNameVariants(metadata: EntityMetadata<any>): {
     classNameSingular: string;
     classNamePlural: string;

package/lib/commands/generate/utils/build-name-variants.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.classNameToInstanceName = classNameToInstanceName;
 exports.buildNameVariants = buildNameVariants;
 const pluralize_1 = require("pluralize");
 function classNameToInstanceName(className) {

package/lib/commands/generate/utils/ts-morph-helper.d.ts

@@ -8,3 +8,4 @@ export declare function findValidatorImportPath(validatorName: string, generator
 export declare function findBlockName(propertyName: string, metadata: EntityMetadata<any>): string;
 export declare function findBlockImportPath(blockName: string, targetDirectory: string, metadata: EntityMetadata<any>): string;
 export declare function findInputClassImportPath(className: string, targetDirectory: string, metadata: EntityMetadata<any>): string;
+export declare function getFieldDecoratorClassName(propertyName: string, metadata: EntityMetadata<any>): string | false;

package/lib/commands/generate/utils/ts-morph-helper.js

@@ -40,6 +40,7 @@ exports.findValidatorImportPath = findValidatorImportPath;
 exports.findBlockName = findBlockName;
 exports.findBlockImportPath = findBlockImportPath;
 exports.findInputClassImportPath = findInputClassImportPath;
+exports.getFieldDecoratorClassName = getFieldDecoratorClassName;
 const path = __importStar(require("path"));
 const ts_morph_1 = require("ts-morph");
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -61,8 +62,14 @@ function morphTsClass(metadata) {
     return tsClass;
 }
 function morphTsProperty(name, metadata) {
-    const tsClass = morphTsClass(metadata);
-    return tsClass.getPropertyOrThrow(name);
+    let currentClass = morphTsClass(metadata);
+    while (currentClass) {
+        const prop = currentClass.getProperty(name);
+        if (prop)
+            return prop;
+        currentClass = currentClass.getBaseClass();
+    }
+    throw new Error(`Property ${name} not found in ${metadata.className}`);
 }
 function findImportPath(importName, targetDirectory, metadata) {
     var _a;
@@ -189,3 +196,22 @@ function findInputClassImportPath(className, targetDirectory, metadata) {
     }
     return returnImportPath;
 }
+function getFieldDecoratorClassName(propertyName, metadata) {
+    const definedDecorators = morphTsProperty(propertyName, metadata).getDecorators();
+    const fieldDecorator = definedDecorators.find((decorator) => decorator.getName() == "Field");
+    if (!fieldDecorator) {
+        return false;
+    }
+    const typeFnArg = fieldDecorator.getArguments()[0];
+    if (!typeFnArg)
+        throw new Error(`${propertyName}: @Field is missing argument`);
+    if (typeFnArg.getKind() != ts_morph_1.SyntaxKind.ArrowFunction)
+        throw new Error(`${propertyName}: @Field first argument must be an ArrowFunction`);
+    const typeReturningArrowFunction = typeFnArg;
+    const body = typeReturningArrowFunction.getBody();
+    if (body.getKind() != ts_morph_1.SyntaxKind.Identifier)
+        throw new Error(`${propertyName}: @Field first argument must be an ArrowFunction returning an Identifier`);
+    const identifier = body;
+    const className = identifier.getText();
+    return className;
+}

package/lib/commands/generate/utils/write-generated-file.d.ts

@@ -1 +1,3 @@
+import ts from "typescript";
 export declare function writeGeneratedFile(filePath: string, contents: string): Promise<void>;
+export declare function removeUnusedImports(): ts.TransformerFactory<ts.SourceFile>;

package/lib/commands/generate/utils/write-generated-file.js

@@ -41,29 +41,84 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeGeneratedFile = writeGeneratedFile;
-const eslint_1 = require("eslint");
+exports.removeUnusedImports = removeUnusedImports;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
 function writeGeneratedFile(filePath, contents) {
     return __awaiter(this, void 0, void 0, function* () {
         const header = `// This file has been generated by comet api-generator.
     // You may choose to use this file as scaffold by moving this file out of generated folder and removing this comment.
     `;
         yield fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
-        yield fs_1.promises.writeFile(filePath, contents);
-        const eslint = new eslint_1.ESLint({
-            cwd: process.cwd(),
-            fix: true,
-        });
-        const lintResult = yield eslint.lintText(header + contents, {
-            filePath,
+        const sourceFile = typescript_1.default.createSourceFile(filePath, header + contents, typescript_1.default.ScriptTarget.ES2024, true, typescript_1.default.ScriptKind.TS);
+        const result = typescript_1.default.transform(sourceFile, [removeUnusedImports()]);
+        const printer = typescript_1.default.createPrinter({
+            newLine: typescript_1.default.NewLineKind.LineFeed,
+            removeComments: false,
         });
-        const output = lintResult[0] && lintResult[0].output ? lintResult[0].output : lintResult[0].source;
-        if (output) {
-            yield fs_1.promises.writeFile(filePath, output);
-        }
+        const prettyCode = printer.printFile(result.transformed[0]);
+        result.dispose();
+        yield fs_1.promises.writeFile(filePath, prettyCode);
         console.log(`generated ${filePath}`);
     });
 }
+function removeUnusedImports() {
+    return (context) => {
+        function visit(sourceFile) {
+            const usedIdentifiers = new Set();
+            // Step 1: Collect all used identifiers
+            function collectUsage(node) {
+                if (typescript_1.default.isIdentifier(node)) {
+                    usedIdentifiers.add(node.text);
+                }
+                else if (typescript_1.default.isImportDeclaration(node)) {
+                    // Skip import declarations (those identifiers are not usages)
+                    return;
+                }
+                typescript_1.default.forEachChild(node, collectUsage);
+            }
+            typescript_1.default.forEachChild(sourceFile, collectUsage);
+            // Step 2: Visit and update the import declarations
+            function visitor(node) {
+                if (typescript_1.default.isImportDeclaration(node) && node.importClause) {
+                    const { name, namedBindings } = node.importClause;
+                    const updatedBindings = [];
+                    if (name && usedIdentifiers.has(name.text)) {
+                        // default import is used
+                    }
+                    else if (name) {
+                        // default import is unused
+                        return undefined;
+                    }
+                    if (namedBindings && typescript_1.default.isNamedImports(namedBindings)) {
+                        for (const specifier of namedBindings.elements) {
+                            const importName = specifier.name.text;
+                            if (usedIdentifiers.has(importName)) {
+                                updatedBindings.push(specifier);
+                            }
+                        }
+                        if (updatedBindings.length === 0 && !name) {
+                            // nothing left in this import
+                            return undefined;
+                        }
+                        return typescript_1.default.factory.updateImportDeclaration(node, node.modifiers, typescript_1.default.factory.updateImportClause(node.importClause, node.importClause.isTypeOnly, name, updatedBindings.length > 0 ? typescript_1.default.factory.updateNamedImports(namedBindings, updatedBindings) : undefined), node.moduleSpecifier, node.assertClause);
+                    }
+                    if (!namedBindings && !name) {
+                        // empty import, probably a side-effect import
+                        return node;
+                    }
+                    return node;
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            }
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        }
+        return (sourceFile) => visit(sourceFile);
+    };
+}

package/lib/commands/generate/watchMode/handleChildProcess.d.ts

@@ -0,0 +1,2 @@
+import { type ChildProcessWithoutNullStreams } from "child_process";
+export declare function handleChildProcess(child: ChildProcessWithoutNullStreams): Promise<string>;

package/lib/commands/generate/watchMode/handleChildProcess.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleChildProcess = handleChildProcess;
+function handleChildProcess(child) {
+    return new Promise((resolve, reject) => {
+        let scriptOutput = "";
+        let errorOutput = "";
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (data) => {
+            scriptOutput += data;
+            console.log(data);
+        });
+        child.stderr.on("data", (data) => {
+            errorOutput += data;
+            console.error(data);
+        });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(errorOutput);
+            }
+            else {
+                resolve(scriptOutput);
+            }
+        });
+    });
+}

package/lib/commands/generate/watchMode/watchMode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Watch mode for the generator.
+ *
+ * Watches the `src` directory for changes and triggers child processes of generator for the changed file, to process it.
+ */
+export declare const watchMode: () => Promise<void>;

package/lib/commands/generate/watchMode/watchMode.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchMode = void 0;
+const node_console_1 = __importDefault(require("node:console"));
+const child_process_1 = require("child_process");
+const chokidar_1 = require("chokidar");
+const handleChildProcess_1 = require("./handleChildProcess");
+const waitForExit = (proc) => {
+    return new Promise((resolve) => {
+        proc.on("exit", (code, signal) => {
+            resolve({ code, signal });
+        });
+    });
+};
+/**
+ * Watch mode for the generator.
+ *
+ * Watches the `src` directory for changes and triggers child processes of generator for the changed file, to process it.
+ */
+const watchMode = () => __awaiter(void 0, void 0, void 0, function* () {
+    /**
+     * Collection of last ChildProcesses for each file
+     */
+    const childProcesses = {};
+    (0, chokidar_1.watch)("./src", {
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 200,
+        },
+        ignored: (path, stats) => {
+            if (stats === null || stats === void 0 ? void 0 : stats.isFile()) {
+                return !path.endsWith(".entity.ts");
+            }
+            return false;
+        },
+    })
+        .on("change", (path) => __awaiter(void 0, void 0, void 0, function* () {
+        node_console_1.default.log(`🚀 File changed: ${path}`);
+        // Kill running processes for the changed file
+        if (childProcesses[path]) {
+            if (childProcesses[path].exitCode == null) {
+                childProcesses[path].kill();
+                yield waitForExit(childProcesses[path]);
+                node_console_1.default.log("💀 Killed running process for file: ", path);
+            }
+            delete childProcesses[path];
+        }
+        // Generate changed file with child process.
+        //
+        // Triggering the generator with changed files in the same process has problems with
+        // reflection and new Classes / Decorator are not recognised correctly.
+        const childProcess = (0, child_process_1.spawn)(`node ${__dirname}/../../../../bin/api-generator.js generate -f ${path}`, {
+            shell: true,
+        });
+        childProcesses[path] = childProcess;
+        try {
+            (0, handleChildProcess_1.handleChildProcess)(childProcess);
+        }
+        catch (e) {
+            node_console_1.default.error(`❌ Error processing ${path} with error: ${e}`);
+        }
+    }))
+        .on("error", (error) => {
+        node_console_1.default.error(`Watcher error: ${error}`);
+    });
+});
+exports.watchMode = watchMode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comet/api-generator",
-  "version": "8.0.0-beta.4",
+  "version": "8.0.0-beta.6",
   "repository": {
     "directory": "packages/api/api-generator",
     "type": "git",
@@ -17,11 +17,12 @@
     "lib/*"
   ],
   "dependencies": {
+    "chokidar": "^4.0.3",
     "commander": "^9.5.0",
     "pluralize": "^8.0.0",
     "ts-morph": "^25.0.1",
     "ts-node": "^10.9.2",
-    "@comet/cms-api": "8.0.0-beta.4"
+    "@comet/cms-api": "8.0.0-beta.6"
   },
   "devDependencies": {
     "@mikro-orm/cli": "^6.4.10",
@@ -29,9 +30,9 @@
     "@mikro-orm/postgresql": "^6.4.10",
     "@nestjs/graphql": "^13.1.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.14.0",
+    "@types/node": "^22.15.34",
     "@types/pluralize": "^0.0.33",
-    "class-validator": "^0.14.1",
+    "class-validator": "^0.14.2",
     "eslint": "^9.22.0",
     "jest": "^29.7.0",
     "npm-run-all2": "^5.0.2",
@@ -41,7 +42,7 @@
     "ts-jest": "^29.2.6",
     "typescript": "^5.7.3",
     "uuid": "^11.1.0",
-    "@comet/eslint-config": "8.0.0-beta.4"
+    "@comet/eslint-config": "8.0.0-beta.6"
   },
   "peerDependencies": {
     "@mikro-orm/cli": "^6.0.0",