simpledi-app-generator 0.0.7 → 0.0.9

package/dist/generate_crud_use_cases.js

@@ -24,14 +24,19 @@ export async function generateCrudUseCases(EntityName, entityName, kebabName, sr
     await generateDeleteUseCase(useCaseBaseDir, config);
     // Generate aggregator module
     await generateUseCaseAggregatorModule(useCaseBaseDir, config);
-    // Auto-register in UseCaseModule.ts and main.routes.ts
+    // Auto-register in UseCaseModule.ts
     await registerInUseCaseModule(srcDir, config);
-    await registerRoutes(srcDir, config);
+    // Phase 3: Generate Scaffolded E2E Tests
+    await generateCreateE2ETest(useCaseBaseDir, config);
+    await generateUpdateE2ETest(useCaseBaseDir, config);
+    await generateGetE2ETest(useCaseBaseDir, config);
+    await generateListE2ETest(useCaseBaseDir, config);
+    await generateDeleteE2ETest(useCaseBaseDir, config);
     console.log(`\n✅ CRUD use cases generated for ${EntityName}!`);
 }
 // ============ CREATE USE CASE ============
 async function generateCreateUseCase(baseDir, config) {
-    const { EntityName, entityName, kebabName, TOKEN_BASE } = config;
+    const { EntityName, entityName, kebabName, TOKEN_BASE, pluralKebab } = config;
     const useCaseName = `Create${EntityName}`;
     const useCaseDir = join(baseDir, `create-${kebabName}`);
     const inputsDir = join(useCaseDir, 'inputs');
@@ -111,28 +116,42 @@ import { StatusCodes } from 'http-status-codes';
 import { inject } from '@kanian77/simple-di';
 import { ${useCaseName}, ${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN } from './${useCaseName}';
 import { ${useCaseName}Failure } from './outputs/${useCaseName}Failure';
-import type { ${useCaseName}Input } from './inputs/${useCaseName}Input';
+import { ${EntityName}InsertSchema } from '@root/core/${kebabName}/${EntityName}';
+import { getContextUser } from '@root/lib/functions/getContextUser';
+import { authGuard } from '@root/middlewares/authGuard';
+import { roleGuard } from '@root/middlewares/roleGuard';
+import { AdminRoleEnum } from '@root/lib';
 
 const ${toCamelCase(useCaseName)}Routes = new Hono();
+const ${toCamelCase(useCaseName)}RoutesPath = '/${pluralKebab}';
 
-${toCamelCase(useCaseName)}Routes.post('/', async (c) => {
-  try {
-    const input = await c.req.json<${useCaseName}Input>();
-    const useCase = inject<${useCaseName}>(${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN);
-    const result = await useCase.execute(input);
-    return c.json(result, StatusCodes.CREATED);
-  } catch (e) {
-    console.error('Error in ${toCamelCase(useCaseName)}Routes:', e);
-    return c.json(
-      new ${useCaseName}Failure('Internal Server Error'),
-      StatusCodes.INTERNAL_SERVER_ERROR,
-    );
-  }
-});
+${toCamelCase(useCaseName)}Routes.post(
+  ${toCamelCase(useCaseName)}RoutesPath,
+  authGuard(),
+  roleGuard([AdminRoleEnum.ADMIN]),
+  async (c) => {
+    try {
+      const rawInput = await c.req.json();
+      const user = getContextUser(c);
+      if (user) {
+        rawInput.createdBy = user.id;
+      }
 
-const ${toCamelCase(useCaseName)}RoutesPath = '/';
+      const input = ${EntityName}InsertSchema.parse(rawInput);
+      const useCase = inject<${useCaseName}>(${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN);
+      const result = await useCase.execute(input);
+      return c.json(result, StatusCodes.CREATED);
+    } catch (e) {
+      console.error('Error in ${toCamelCase(useCaseName)}Routes:', e);
+      return c.json(
+        new ${useCaseName}Failure('Internal Server Error'),
+        StatusCodes.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+);
 
-export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPath };
+export { ${toCamelCase(useCaseName)}Routes as Route, ${toCamelCase(useCaseName)}RoutesPath as Path };
 `;
     await writeFile(join(inputsDir, `${useCaseName}Input.ts`), inputContent);
     await writeFile(join(outputsDir, `${useCaseName}Success.ts`), successContent);
@@ -143,7 +162,7 @@ export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPat
 }
 // ============ UPDATE USE CASE ============
 async function generateUpdateUseCase(baseDir, config) {
-    const { EntityName, entityName, kebabName, TOKEN_BASE } = config;
+    const { EntityName, entityName, kebabName, TOKEN_BASE, pluralKebab } = config;
     const useCaseName = `Update${EntityName}`;
     const useCaseDir = join(baseDir, `update-${kebabName}`);
     const inputsDir = join(useCaseDir, 'inputs');
@@ -227,29 +246,45 @@ import { inject } from '@kanian77/simple-di';
 import { ${useCaseName}, ${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN } from './${useCaseName}';
 import { ${useCaseName}Failure } from './outputs/${useCaseName}Failure';
 import type { ${useCaseName}Input } from './inputs/${useCaseName}Input';
+import { ${EntityName}UpdateSchema } from '@root/core/${kebabName}/${EntityName}';
+import { getContextUser } from '@root/lib/functions/getContextUser';
+import { authGuard } from '@root/middlewares/authGuard';
+import { roleGuard } from '@root/middlewares/roleGuard';
+import { AdminRoleEnum } from '@root/lib';
 
 const ${toCamelCase(useCaseName)}Routes = new Hono();
+const ${toCamelCase(useCaseName)}RoutesPath = '/${pluralKebab}/:id';
 
-${toCamelCase(useCaseName)}Routes.put('/:id', async (c) => {
-  try {
-    const id = c.req.param('id');
-    const data = await c.req.json();
-    const input: ${useCaseName}Input = { id, data };
-    const useCase = inject<${useCaseName}>(${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN);
-    const result = await useCase.execute(input);
-    return c.json(result, StatusCodes.OK);
-  } catch (e) {
-    console.error('Error in ${toCamelCase(useCaseName)}Routes:', e);
-    return c.json(
-      new ${useCaseName}Failure('Internal Server Error'),
-      StatusCodes.INTERNAL_SERVER_ERROR,
-    );
-  }
-});
+${toCamelCase(useCaseName)}Routes.put(
+  ${toCamelCase(useCaseName)}RoutesPath,
+  authGuard(),
+  roleGuard([AdminRoleEnum.ADMIN]),
+  async (c) => {
+    try {
+      const id = c.req.param('id');
+      const rawBody = await c.req.json();
 
-const ${toCamelCase(useCaseName)}RoutesPath = '/';
+      const user = getContextUser(c);
+      if (user) {
+        rawBody.updatedBy = user.id;
+      }
 
-export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPath };
+      const data = ${EntityName}UpdateSchema.parse(rawBody);
+      const input: ${useCaseName}Input = { id, data };
+      const useCase = inject<${useCaseName}>(${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN);
+      const result = await useCase.execute(input);
+      return c.json(result, StatusCodes.OK);
+    } catch (e) {
+      console.error('Error in ${toCamelCase(useCaseName)}Routes:', e);
+      return c.json(
+        new ${useCaseName}Failure('Internal Server Error'),
+        StatusCodes.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+);
+
+export { ${toCamelCase(useCaseName)}Routes as Route, ${toCamelCase(useCaseName)}RoutesPath as Path };
 `;
     await writeFile(join(inputsDir, `${useCaseName}Input.ts`), inputContent);
     await writeFile(join(outputsDir, `${useCaseName}Success.ts`), successContent);
@@ -260,7 +295,7 @@ export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPat
 }
 // ============ GET USE CASE ============
 async function generateGetUseCase(baseDir, config) {
-    const { EntityName, entityName, kebabName, TOKEN_BASE } = config;
+    const { EntityName, entityName, kebabName, TOKEN_BASE, pluralKebab } = config;
     const useCaseName = `Get${EntityName}`;
     const useCaseDir = join(baseDir, `get-${kebabName}`);
     const outputsDir = join(useCaseDir, 'outputs');
@@ -334,8 +369,9 @@ import { ${useCaseName}, ${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN } from
 import { ${useCaseName}Failure } from './outputs/${useCaseName}Failure';
 
 const ${toCamelCase(useCaseName)}Routes = new Hono();
+const ${toCamelCase(useCaseName)}RoutesPath = '/${pluralKebab}/:id';
 
-${toCamelCase(useCaseName)}Routes.get('/:id', async (c) => {
+${toCamelCase(useCaseName)}Routes.get(${toCamelCase(useCaseName)}RoutesPath, async (c) => {
   try {
     const id = c.req.param('id');
     const useCase = inject<${useCaseName}>(${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN);
@@ -350,9 +386,7 @@ ${toCamelCase(useCaseName)}Routes.get('/:id', async (c) => {
   }
 });
 
-const ${toCamelCase(useCaseName)}RoutesPath = '/';
-
-export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPath };
+export { ${toCamelCase(useCaseName)}Routes as Route, ${toCamelCase(useCaseName)}RoutesPath as Path };
 `;
     await writeFile(join(outputsDir, `${useCaseName}Success.ts`), successContent);
     await writeFile(join(outputsDir, `${useCaseName}Failure.ts`), failureContent);
@@ -362,7 +396,7 @@ export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPat
 }
 // ============ LIST USE CASE ============
 async function generateListUseCase(baseDir, config) {
-    const { EntityName, entityName, kebabName, TOKEN_BASE, pluralPascal } = config;
+    const { EntityName, entityName, kebabName, TOKEN_BASE, pluralPascal, pluralKebab, } = config;
     const useCaseName = `List${pluralPascal}`;
     const useCaseDir = join(baseDir, `list-${config.pluralKebab}`);
     const outputsDir = join(useCaseDir, 'outputs');
@@ -436,8 +470,9 @@ import { ${useCaseName}, ${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN } from
 import { ${useCaseName}Failure } from './outputs/${useCaseName}Failure';
 
 const ${toCamelCase(useCaseName)}Routes = new Hono();
+const ${toCamelCase(useCaseName)}RoutesPath = '/${pluralKebab}';
 
-${toCamelCase(useCaseName)}Routes.get('/', async (c) => {
+${toCamelCase(useCaseName)}Routes.get(${toCamelCase(useCaseName)}RoutesPath, async (c) => {
   try {
     const useCase = inject<${useCaseName}>(${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN);
     const result = await useCase.execute();
@@ -451,9 +486,7 @@ ${toCamelCase(useCaseName)}Routes.get('/', async (c) => {
   }
 });
 
-const ${toCamelCase(useCaseName)}RoutesPath = '/';
-
-export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPath };
+export { ${toCamelCase(useCaseName)}Routes as Route, ${toCamelCase(useCaseName)}RoutesPath as Path };
 `;
     await writeFile(join(outputsDir, `${useCaseName}Success.ts`), successContent);
     await writeFile(join(outputsDir, `${useCaseName}Failure.ts`), failureContent);
@@ -463,7 +496,7 @@ export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPat
 }
 // ============ DELETE USE CASE ============
 async function generateDeleteUseCase(baseDir, config) {
-    const { EntityName, entityName, kebabName, TOKEN_BASE } = config;
+    const { EntityName, entityName, kebabName, TOKEN_BASE, pluralKebab } = config;
     const useCaseName = `Delete${EntityName}`;
     const useCaseDir = join(baseDir, `delete-${kebabName}`);
     const outputsDir = join(useCaseDir, 'outputs');
@@ -472,7 +505,7 @@ async function generateDeleteUseCase(baseDir, config) {
     // Success Output
     const successContent = `import { SuccessfullOperation } from '@root/lib';
 
-export type ${useCaseName}Payload = { id: string; deleted: boolean };
+export type ${useCaseName}Payload = { id: string; deleted: boolean; softDelete: boolean };
 
 export class ${useCaseName}Success extends SuccessfullOperation {
   constructor(
@@ -512,9 +545,9 @@ export class ${useCaseName} implements IUseCase {
     private readonly ${entityName}Service: I${EntityName}Service,
   ) {}
 
-  async execute(id: string): Promise<${useCaseName}Success> {
-    await this.${entityName}Service.delete(id);
-    const result: ${useCaseName}Payload = { id, deleted: true };
+  async execute(id: string, softDelete: boolean = true): Promise<${useCaseName}Success> {
+    await this.${entityName}Service.delete(id, softDelete);
+    const result: ${useCaseName}Payload = { id, deleted: true, softDelete };
     return new ${useCaseName}Success(result);
   }
 }
@@ -535,27 +568,45 @@ import { StatusCodes } from 'http-status-codes';
 import { inject } from '@kanian77/simple-di';
 import { ${useCaseName}, ${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN } from './${useCaseName}';
 import { ${useCaseName}Failure } from './outputs/${useCaseName}Failure';
+import { authGuard } from '@root/middlewares/authGuard';
+import { roleGuard } from '@root/middlewares/roleGuard';
+import { AdminRoleEnum } from '@root/lib';
 
 const ${toCamelCase(useCaseName)}Routes = new Hono();
+const ${toCamelCase(useCaseName)}RoutesPath = '/${pluralKebab}/:id';
 
-${toCamelCase(useCaseName)}Routes.delete('/:id', async (c) => {
-  try {
-    const id = c.req.param('id');
-    const useCase = inject<${useCaseName}>(${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN);
-    const result = await useCase.execute(id);
-    return c.json(result, StatusCodes.OK);
-  } catch (e) {
-    console.error('Error in ${toCamelCase(useCaseName)}Routes:', e);
-    return c.json(
-      new ${useCaseName}Failure('Internal Server Error'),
-      StatusCodes.INTERNAL_SERVER_ERROR,
-    );
-  }
-});
+${toCamelCase(useCaseName)}Routes.delete(
+  ${toCamelCase(useCaseName)}RoutesPath,
+  authGuard(),
+  roleGuard([AdminRoleEnum.ADMIN]),
+  async (c) => {
+    try {
+      const id = c.req.param('id');
+
+      let softDelete = true;
+      try {
+        const body = await c.req.json();
+        if (typeof body.softDelete === 'boolean') {
+          softDelete = body.softDelete;
+        }
+      } catch (e) {
+        // Body is likely empty, default to softDelete = true
+      }
 
-const ${toCamelCase(useCaseName)}RoutesPath = '/';
+      const useCase = inject<${useCaseName}>(${toUpperSnakeCase(useCaseName)}_USE_CASE_TOKEN);
+      const result = await useCase.execute(id, softDelete);
+      return c.json(result, StatusCodes.OK);
+    } catch (e) {
+      console.error('Error in ${toCamelCase(useCaseName)}Routes:', e);
+      return c.json(
+        new ${useCaseName}Failure('Internal Server Error'),
+        StatusCodes.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
+);
 
-export { ${toCamelCase(useCaseName)}Routes, ${toCamelCase(useCaseName)}RoutesPath };
+export { ${toCamelCase(useCaseName)}Routes as Route, ${toCamelCase(useCaseName)}RoutesPath as Path };
 `;
     await writeFile(join(outputsDir, `${useCaseName}Success.ts`), successContent);
     await writeFile(join(outputsDir, `${useCaseName}Failure.ts`), failureContent);
@@ -644,66 +695,456 @@ async function registerInUseCaseModule(srcDir, config) {
     await writeFile(useCaseModulePath, content);
     console.log(`Updated: src/use-case/UseCaseModule.ts`);
 }
-// ============ REGISTER ROUTES ============
-async function registerRoutes(srcDir, config) {
-    const { EntityName, entityName, kebabName, pluralPascal, pluralKebab } = config;
-    const mainRoutesPath = join(srcDir, 'main.routes.ts');
-    if (!existsSync(mainRoutesPath)) {
-        console.warn('Warning: src/main.routes.ts not found');
-        return;
-    }
-    let content = await readFile(mainRoutesPath, 'utf8');
-    // Import all route handlers
-    const routeImports = `import { create${EntityName}Routes } from './use-case/${kebabName}/create-${kebabName}/create${EntityName}Routes';
-import { update${EntityName}Routes } from './use-case/${kebabName}/update-${kebabName}/update${EntityName}Routes';
-import { get${EntityName}Routes } from './use-case/${kebabName}/get-${kebabName}/get${EntityName}Routes';
-import { list${pluralPascal}Routes } from './use-case/${kebabName}/list-${pluralKebab}/list${pluralPascal}Routes';
-import { delete${EntityName}Routes } from './use-case/${kebabName}/delete-${kebabName}/delete${EntityName}Routes';`;
-    if (content.includes(`create${EntityName}Routes`)) {
-        return; // Already registered
-    }
-    // Add imports after last import
-    const lastImportIndex = content.lastIndexOf('import ');
-    if (lastImportIndex !== -1) {
-        let searchPos = lastImportIndex;
-        while (searchPos < content.length) {
-            if (content[searchPos] === ';') {
-                content =
-                    content.slice(0, searchPos + 1) +
-                        '\n' +
-                        routeImports +
-                        content.slice(searchPos + 1);
-                break;
-            }
-            searchPos++;
-        }
-    }
-    // Add route registrations before export
-    const routeRegistrations = `
-// ${EntityName} CRUD routes
-const ${entityName}Routes = new Hono();
-${entityName}Routes.route('/', create${EntityName}Routes);
-${entityName}Routes.route('/', update${EntityName}Routes);
-${entityName}Routes.route('/', get${EntityName}Routes);
-${entityName}Routes.route('/', list${pluralPascal}Routes);
-${entityName}Routes.route('/', delete${EntityName}Routes);
-mainRoutes.route('/${pluralKebab}', ${entityName}Routes);
+// ============ E2E TESTS GENERATION ============
+async function generateCreateE2ETest(baseDir, config) {
+    const { EntityName, entityName, kebabName, pluralKebab } = config;
+    const useCaseDir = join(baseDir, `create-${kebabName}`);
+    const testContent = `import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { EnvFileNames, UserRoleEnum, UserTypeEnum } from '@root/lib';
+import { bootstrap, inject, Module } from '@kanian77/simple-di';
+import { UseCaseModule } from '@root/use-case/UseCaseModule';
+import { getConfigModule } from 'config/getConfigModule';
+import { getDbModule } from 'db/getDbModule';
+import { CoreModule } from '@root/core/CoreModule';
+import { DB_SERVICE, type DbService } from 'db/DbService';
+import { APP, AppModule } from '@root/AppModule';
+import type { Hono } from 'hono';
+import * as schema from '@root/schema';
+import { eq } from 'drizzle-orm';
+import { getTestServer, type TestServer } from '@root/lib/functions/test-related/getTestServer';
+import { createOneSignedUpUser, deleteCreatedSignedUsers } from '@root/lib/functions/test-related/createSignedUpUser';
+import { USER_REPOSITORY_INTERFACE, type UserRepository } from '@root/core/user/IUserRepository';
+import { UserModule } from '@root/core/user/UserModule';
+
+describe('Create${EntityName} e2e', () => {
+  let dbService: DbService;
+  let server: TestServer;
+  let app: Hono;
+  let userRepository: UserRepository;
+
+  beforeAll(async () => {
+    const TestModule = new Module({
+      imports: [
+        AppModule,
+        getConfigModule(EnvFileNames.TESTING),
+        getDbModule(),
+        CoreModule,
+        UserModule,
+        UseCaseModule,
+      ],
+    });
+    bootstrap(TestModule);
+    dbService = inject<DbService>(DB_SERVICE);
+    app = inject<Hono>(APP);
+    userRepository = inject(USER_REPOSITORY_INTERFACE);
+    server = await getTestServer(app);
+  });
+
+  afterAll(async () => {
+    await dbService.getDb().delete(schema.${entityName}Schema).execute();
+    await deleteCreatedSignedUsers(userRepository);
+  });
+
+  it('fails if unauthenticated', async () => {
+    const req = await server.client.request('/${pluralKebab}', {
+      method: 'POST',
+      body: JSON.stringify({ /* TODO: Add valid payload */ }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+    expect(req.status).toBe(401);
+  });
+
+  it('fails with fake generated ID for createdBy', async () => {
+    const { token } = await createOneSignedUpUser(userRepository, {
+      userType: UserTypeEnum.ADMIN,
+      role: UserRoleEnum.AUTHENTICATED,
+    });
+
+    // Attempting to forge createdBy should be overwritten by the backend Context Injection
+    const maliciousPayload = {
+      // TODO: Add required payload properties
+      createdBy: 'fake-malicious-id'
+    };
+
+    const req = await server.client.request('/${pluralKebab}', {
+      method: 'POST',
+      body: JSON.stringify(maliciousPayload),
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: \`Bearer \${token}\`,
+      },
+    });
+
+    expect(req.status).toBe(201);
+    const body: any = await req.json();
+
+    // Verify creation succeeded but createdBy was securely overwritten
+    expect(body.result.createdBy).not.toBe('fake-malicious-id');
+
+    // Direct DB check
+    const row = await dbService.getDb().query.${entityName}Schema.findFirst({
+      where: eq(schema.${entityName}Schema.id, body.result.id)
+    });
+    expect(row).toBeDefined();
+    expect(row!.createdBy).not.toBe('fake-malicious-id');
+  });
+});
 `;
-    const exportIndex = content.indexOf('export { mainRoutes }');
-    if (exportIndex !== -1) {
-        content =
-            content.slice(0, exportIndex) +
-                routeRegistrations +
-                '\n' +
-                content.slice(exportIndex);
-    }
-    // Check if Hono is imported
-    if (!content.includes('import { Hono }') &&
-        !content.includes('import {Hono}')) {
-        // Add Hono import at top if not present
-        content = "import { Hono } from 'hono';\n" + content;
-    }
-    await writeFile(mainRoutesPath, content);
-    console.log(`Updated: src/main.routes.ts with ${EntityName} CRUD routes`);
+    await writeFile(join(useCaseDir, `Create${EntityName}.e2e.spec.ts`), testContent);
+}
+async function generateUpdateE2ETest(baseDir, config) {
+    const { EntityName, entityName, kebabName, pluralKebab } = config;
+    const useCaseDir = join(baseDir, `update-${kebabName}`);
+    const testContent = `import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { EnvFileNames, UserRoleEnum, UserTypeEnum } from '@root/lib';
+import { bootstrap, inject, Module } from '@kanian77/simple-di';
+import { UseCaseModule } from '@root/use-case/UseCaseModule';
+import { getConfigModule } from 'config/getConfigModule';
+import { getDbModule } from 'db/getDbModule';
+import { CoreModule } from '@root/core/CoreModule';
+import { DB_SERVICE, type DbService } from 'db/DbService';
+import { APP, AppModule } from '@root/AppModule';
+import type { Hono } from 'hono';
+import * as schema from '@root/schema';
+import { eq } from 'drizzle-orm';
+import { getTestServer, type TestServer } from '@root/lib/functions/test-related/getTestServer';
+import { createOneSignedUpUser, deleteCreatedSignedUsers } from '@root/lib/functions/test-related/createSignedUpUser';
+import { USER_REPOSITORY_INTERFACE, type UserRepository } from '@root/core/user/IUserRepository';
+import { UserModule } from '@root/core/user/UserModule';
+
+describe('Update${EntityName} e2e', () => {
+  let dbService: DbService;
+  let server: TestServer;
+  let app: Hono;
+  let targetId: string;
+  let userRepository: UserRepository;
+
+  beforeAll(async () => {
+    const TestModule = new Module({
+      imports: [
+        AppModule,
+        getConfigModule(EnvFileNames.TESTING),
+        getDbModule(),
+        CoreModule,
+        UserModule,
+        UseCaseModule,
+      ],
+    });
+    bootstrap(TestModule);
+    dbService = inject<DbService>(DB_SERVICE);
+    app = inject<Hono>(APP);
+    userRepository = inject(USER_REPOSITORY_INTERFACE);
+    server = await getTestServer(app);
+
+    // TODO: Seed a target entity here and save targetId
+  });
+
+  afterAll(async () => {
+    await dbService.getDb().delete(schema.${entityName}Schema).execute();
+    await deleteCreatedSignedUsers(userRepository);
+  });
+
+  it('fails if unauthenticated', async () => {
+    const req = await server.client.request(\`/\${pluralKebab}/\${targetId}\`, {
+      method: 'PUT',
+      body: JSON.stringify({ /* TODO: valid update payload */ }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+    expect(req.status).toBe(401);
+  });
+
+  it('successfully updates and overrides updatedBy context', async () => {
+    const { token } = await createOneSignedUpUser(userRepository, {
+      userType: UserTypeEnum.ADMIN,
+      role: UserRoleEnum.AUTHENTICATED,
+    });
+
+    const payload = {
+      // TODO: Add properties to update
+      updatedBy: 'hacker-id' // Should be discarded
+    };
+
+    const req = await server.client.request(\`/\${pluralKebab}/\${targetId}\`, {
+      method: 'PUT',
+      body: JSON.stringify(payload),
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: \`Bearer \${token}\`,
+      },
+    });
+
+    expect(req.status).toBe(200);
+    const body: any = await req.json();
+
+    expect(body.result.updatedBy).not.toBe('hacker-id');
+
+    const row = await dbService.getDb().query.${entityName}Schema.findFirst({
+      where: eq(schema.${entityName}Schema.id, targetId)
+    });
+    expect(row!.updatedBy).not.toBe('hacker-id');
+  });
+});
+`;
+    await writeFile(join(useCaseDir, `Update${EntityName}.e2e.spec.ts`), testContent);
+}
+async function generateGetE2ETest(baseDir, config) {
+    const { EntityName, entityName, kebabName, pluralKebab } = config;
+    const useCaseDir = join(baseDir, `get-${kebabName}`);
+    const testContent = `import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { EnvFileNames, UserRoleEnum, UserTypeEnum } from '@root/lib';
+import { bootstrap, inject, Module } from '@kanian77/simple-di';
+import { UseCaseModule } from '@root/use-case/UseCaseModule';
+import { getConfigModule } from 'config/getConfigModule';
+import { getDbModule } from 'db/getDbModule';
+import { CoreModule } from '@root/core/CoreModule';
+import { DB_SERVICE, type DbService } from 'db/DbService';
+import { APP, AppModule } from '@root/AppModule';
+import type { Hono } from 'hono';
+import * as schema from '@root/schema';
+import { getTestServer, type TestServer } from '@root/lib/functions/test-related/getTestServer';
+import { createOneSignedUpUser, deleteCreatedSignedUsers } from '@root/lib/functions/test-related/createSignedUpUser';
+import { USER_REPOSITORY_INTERFACE, type UserRepository } from '@root/core/user/IUserRepository';
+import { UserModule } from '@root/core/user/UserModule';
+
+describe('Get${EntityName} e2e', () => {
+  let dbService: DbService;
+  let server: TestServer;
+  let app: Hono;
+  let targetId: string;
+  let userRepository: UserRepository;
+
+  beforeAll(async () => {
+    const TestModule = new Module({
+      imports: [
+        AppModule,
+        getConfigModule(EnvFileNames.TESTING),
+        getDbModule(),
+        CoreModule,
+        UserModule,
+        UseCaseModule,
+      ],
+    });
+    bootstrap(TestModule);
+    dbService = inject<DbService>(DB_SERVICE);
+    app = inject<Hono>(APP);
+    userRepository = inject(USER_REPOSITORY_INTERFACE);
+    server = await getTestServer(app);
+
+    // TODO: Seed an entity here and assign targetId
+  });
+
+  afterAll(async () => {
+    await dbService.getDb().delete(schema.${entityName}Schema).execute();
+    await deleteCreatedSignedUsers(userRepository);
+  });
+
+  it('fails if unauthenticated (assuming route requires auth)', async () => {
+    // Note: Adjust depending on whether the GET route should be public or private
+    // const req = await server.client.request(\`/\${pluralKebab}/\${targetId}\`);
+    // expect(req.status).toBe(401);
+  });
+
+  it('retrieves the entity', async () => {
+    const { token } = await createOneSignedUpUser(userRepository, {
+      userType: UserTypeEnum.ADMIN,
+      role: UserRoleEnum.AUTHENTICATED,
+    });
+
+    const req = await server.client.request(\`/\${pluralKebab}/\${targetId}\`, {
+      method: 'GET',
+      headers: {
+        Authorization: \`Bearer \${token}\`,
+      },
+    });
+
+    expect(req.status).toBe(200);
+    const body: any = await req.json();
+    expect(body.result.id).toBe(targetId);
+  });
+});
+`;
+    await writeFile(join(useCaseDir, `Get${EntityName}.e2e.spec.ts`), testContent);
+}
+async function generateListE2ETest(baseDir, config) {
+    const { EntityName, entityName, kebabName, pluralKebab, pluralPascal } = config;
+    const useCaseDir = join(baseDir, `list-${pluralKebab}`);
+    const testContent = `import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { EnvFileNames, UserRoleEnum, UserTypeEnum } from '@root/lib';
+import { bootstrap, inject, Module } from '@kanian77/simple-di';
+import { UseCaseModule } from '@root/use-case/UseCaseModule';
+import { getConfigModule } from 'config/getConfigModule';
+import { getDbModule } from 'db/getDbModule';
+import { CoreModule } from '@root/core/CoreModule';
+import { DB_SERVICE, type DbService } from 'db/DbService';
+import { APP, AppModule } from '@root/AppModule';
+import type { Hono } from 'hono';
+import * as schema from '@root/schema';
+import { getTestServer, type TestServer } from '@root/lib/functions/test-related/getTestServer';
+import { createOneSignedUpUser, deleteCreatedSignedUsers } from '@root/lib/functions/test-related/createSignedUpUser';
+import { USER_REPOSITORY_INTERFACE, type UserRepository } from '@root/core/user/IUserRepository';
+import { UserModule } from '@root/core/user/UserModule';
+
+describe('List${pluralPascal} e2e', () => {
+  let dbService: DbService;
+  let server: TestServer;
+  let app: Hono;
+  let userRepository: UserRepository;
+
+  beforeAll(async () => {
+    const TestModule = new Module({
+      imports: [
+        AppModule,
+        getConfigModule(EnvFileNames.TESTING),
+        getDbModule(),
+        CoreModule,
+        UserModule,
+        UseCaseModule,
+      ],
+    });
+    bootstrap(TestModule);
+    dbService = inject<DbService>(DB_SERVICE);
+    app = inject<Hono>(APP);
+    userRepository = inject(USER_REPOSITORY_INTERFACE);
+    server = await getTestServer(app);
+
+    // TODO: Seed multiple entities here
+  });
+
+  afterAll(async () => {
+    await dbService.getDb().delete(schema.${entityName}Schema).execute();
+    await deleteCreatedSignedUsers(userRepository);
+  });
+
+  it('lists entities successfully', async () => {
+    const { token } = await createOneSignedUpUser(userRepository, {
+      userType: UserTypeEnum.ADMIN,
+      role: UserRoleEnum.AUTHENTICATED,
+    });
+
+    const req = await server.client.request('/${pluralKebab}', {
+      method: 'GET',
+      headers: {
+        Authorization: \`Bearer \${token}\`,
+      },
+    });
+
+    expect(req.status).toBe(200);
+    const body: any = await req.json();
+    expect(Array.isArray(body.result)).toBe(true);
+  });
+});
+`;
+    await writeFile(join(useCaseDir, `List${pluralPascal}.e2e.spec.ts`), testContent);
+}
+async function generateDeleteE2ETest(baseDir, config) {
+    const { EntityName, entityName, kebabName, pluralKebab } = config;
+    const useCaseDir = join(baseDir, `delete-${kebabName}`);
+    const testContent = `import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { EnvFileNames, UserRoleEnum, UserTypeEnum } from '@root/lib';
+import { bootstrap, inject, Module } from '@kanian77/simple-di';
+import { UseCaseModule } from '@root/use-case/UseCaseModule';
+import { getConfigModule } from 'config/getConfigModule';
+import { getDbModule } from 'db/getDbModule';
+import { CoreModule } from '@root/core/CoreModule';
+import { DB_SERVICE, type DbService } from 'db/DbService';
+import { APP, AppModule } from '@root/AppModule';
+import type { Hono } from 'hono';
+import * as schema from '@root/schema';
+import { eq } from 'drizzle-orm';
+import { getTestServer, type TestServer } from '@root/lib/functions/test-related/getTestServer';
+import { createOneSignedUpUser, deleteCreatedSignedUsers } from '@root/lib/functions/test-related/createSignedUpUser';
+import { USER_REPOSITORY_INTERFACE, type UserRepository } from '@root/core/user/IUserRepository';
+import { UserModule } from '@root/core/user/UserModule';
+
+describe('Delete${EntityName} e2e', () => {
+  let dbService: DbService;
+  let server: TestServer;
+  let app: Hono;
+  let targetIdSoft: string;
+  let targetIdHard: string;
+  let userRepository: UserRepository;
+
+  beforeAll(async () => {
+    const TestModule = new Module({
+      imports: [
+        AppModule,
+        getConfigModule(EnvFileNames.TESTING),
+        getDbModule(),
+        CoreModule,
+        UserModule,
+        UseCaseModule,
+      ],
+    });
+    bootstrap(TestModule);
+    dbService = inject<DbService>(DB_SERVICE);
+    app = inject<Hono>(APP);
+    userRepository = inject(USER_REPOSITORY_INTERFACE);
+    server = await getTestServer(app);
+
+    // TODO: Seed two entities, assign to targetIdSoft and targetIdHard
+  });
+
+  afterAll(async () => {
+    await dbService.getDb().delete(schema.${entityName}Schema).execute();
+  });
+
+  it('fails if unauthenticated', async () => {
+    const req = await server.client.request(\`/\${pluralKebab}/\${targetIdSoft}\`, {
+      method: 'DELETE',
+    });
+    expect(req.status).toBe(401);
+  });
+
+  it('soft deletes by default', async () => {
+    const { token } = await createOneSignedUpUser(userRepository, {
+      userType: UserTypeEnum.ADMIN,
+      role: UserRoleEnum.AUTHENTICATED,
+    });
+
+    const req = await server.client.request(\`/\${pluralKebab}/\${targetIdSoft}\`, {
+      method: 'DELETE',
+      headers: {
+        Authorization: \`Bearer \${token}\`,
+      },
+    });
+
+    expect(req.status).toBe(200);
+
+    // Direct DB check for soft delete
+    const row = await dbService.getDb().query.${entityName}Schema.findFirst({
+      where: eq(schema.${entityName}Schema.id, targetIdSoft)
+    });
+    expect(row).toBeDefined();
+    expect(row!.deleted).toBe(true);
+    expect(row!.deletedAt).not.toBeNull();
+  });
+
+  it('hard deletes when flag is false', async () => {
+    const { token } = await createOneSignedUpUser(userRepository, {
+      userType: UserTypeEnum.ADMIN,
+      role: UserRoleEnum.AUTHENTICATED,
+    });
+
+    const req = await server.client.request(\`/\${pluralKebab}/\${targetIdHard}\`, {
+      method: 'DELETE',
+      body: JSON.stringify({ softDelete: false }),
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: \`Bearer \${token}\`,
+      },
+    });
+
+    expect(req.status).toBe(200);
+
+    // Direct DB check for physical row missing
+    const row = await dbService.getDb().query.${entityName}Schema.findFirst({
+      where: eq(schema.${entityName}Schema.id, targetIdHard)
+    });
+    expect(row).toBeUndefined();
+  });
+});
+`;
+    await writeFile(join(useCaseDir, `Delete${EntityName}.e2e.spec.ts`), testContent);
 }
+// END ROUTES
 //# sourceMappingURL=generate_crud_use_cases.js.map