API Generator: Add support for soft delete by setting deletedAt in delete mutation

.changeset/silly-masks-tickle.md

@@ -0,0 +1,7 @@
+---
+"@comet/api-generator": minor
+---
+
+Add support for soft delete by setting deletedAt in delete mutation
+
+Note: The filter to exclude deleted entries by default has to be added manually to the entity, api-generator can't do that.

packages/api/api-generator/src/commands/generate/generateCrud/__tests__/deleted-at.spec.ts

@@ -0,0 +1,52 @@
+import { BaseEntity, defineConfig, Entity, Filter, MikroORM, PrimaryKey, Property } from "@mikro-orm/postgresql";
+import { LazyMetadataStorage } from "@nestjs/graphql/dist/schema-builder/storages/lazy-metadata.storage";
+import { v4 as uuid } from "uuid";
+
+import { formatGeneratedFiles, testPermission } from "../../utils/test-helper";
+import { type GeneratedFile } from "../../utils/write-generated-files";
+import { buildOptions } from "../build-options";
+import { generateCrud } from "../generate-crud";
+
+@Entity()
+@Filter({ name: "deletedAt", cond: { deletedAt: { $ne: null } }, default: true })
+export class TestEntity extends BaseEntity {
+    @PrimaryKey({ type: "uuid" })
+    id: string = uuid();
+
+    @Property({ nullable: true, columnType: "timestamp with time zone", onUpdate: () => new Date() })
+    deletedAt?: Date;
+}
+
+describe("deletedAt soft delete", () => {
+    let formattedOut: GeneratedFile[];
+    let orm: MikroORM;
+    beforeEach(async () => {
+        LazyMetadataStorage.load();
+        orm = await MikroORM.init(
+            defineConfig({
+                dbName: "test-db",
+                connect: false,
+                entities: [TestEntity],
+            }),
+        );
+
+        const out = await generateCrud({ targetDirectory: __dirname, requiredPermission: testPermission }, orm.em.getMetadata().get("TestEntity"));
+        formattedOut = await formatGeneratedFiles(out);
+    });
+    afterEach(async () => {
+        await orm.close();
+    });
+
+    it("should detect deletedAt property", () => {
+        const options = buildOptions(orm.em.getMetadata().get("TestEntity"), { targetDirectory: __dirname, requiredPermission: testPermission });
+        expect(options.hasDeletedAtProp).toBe(true);
+    });
+
+    it("resolver should contain soft delete logic and not remove logic", async () => {
+        const file = formattedOut.find((file) => file.name === "test-entity.resolver.ts");
+        if (!file) throw new Error("File not found");
+
+        expect(file.content).toContain("testEntity.assign({ deletedAt: new Date() })");
+        expect(file.content).not.toContain("entityManager.remove(testEntity)");
+    });
+});

packages/api/api-generator/src/commands/generate/generateCrud/build-options.ts

@@ -115,6 +115,8 @@ export function buildOptions(metadata: EntityMetadata<any>, generatorOptions: Cr
     const scopeProp = metadata.props.find((prop) => prop.name == "scope");
     if (scopeProp && !scopeProp.targetMeta) throw new Error("Scope prop has no targetMeta");
 
+    const hasDeletedAtProp = metadata.props.some((prop) => prop.name == "deletedAt");
+
     const hasPositionProp = metadata.props.some((prop) => prop.name == "position");
 
     const positionGroupPropNames: string[] = hasPositionProp
@@ -144,6 +146,7 @@ export function buildOptions(metadata: EntityMetadata<any>, generatorOptions: Cr
         hasSlugProp,
         hasPositionProp,
         positionGroupProps,
+        hasDeletedAtProp,
         scopeProp,
         skipScopeCheck,
         argsClassName,

packages/api/api-generator/src/commands/generate/generateCrud/generate-crud.ts

@@ -790,6 +790,7 @@ function generateResolver({ generatorOptions, metadata }: { generatorOptions: Cr
         hasFilterArg,
         hasPositionProp,
         positionGroupProps,
+        hasDeletedAtProp,
         dedicatedResolverArgProps,
     } = buildOptions(metadata, generatorOptions);
 
@@ -1131,7 +1132,8 @@ function generateResolver({ generatorOptions, metadata }: { generatorOptions: Cr
         @AffectedEntity(${metadata.className})
         async delete${metadata.className}(${generateIdArg("id", metadata)}): Promise<boolean> {
             const ${instanceNameSingular} = await this.entityManager.findOneOrFail(${metadata.className}, id);
-            this.entityManager.remove(${instanceNameSingular});${
+            ${hasDeletedAtProp ? `${instanceNameSingular}.assign({ deletedAt: new Date() });` : `this.entityManager.remove(${instanceNameSingular});`}
+            ${
                 hasPositionProp
                     ? `await this.${instanceNamePlural}Service.decrementPositions(${
                           positionGroupProps.length