create-forgeon 0.3.19 → 0.3.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-forgeon",
-  "version": "0.3.19",
+  "version": "0.3.20",
   "description": "Forgeon project generator CLI",
   "license": "MIT",
   "author": "Forgeon",

package/src/cli/add-help.mjs

@@ -1,8 +1,8 @@
 export function printAddHelp() {
   console.log(`create-forgeon add
 
-Usage:
-  npx create-forgeon@latest add <module-id> [options]
+Usage:
+  npx create-forgeon@latest add <module-id|all> [options]
 
 Options:
   --project <path>   Target project path (default: current directory)
@@ -14,6 +14,7 @@ Options:
   -h, --help         Show this help
 
 Note:
+  Use "add all" to install every implemented module and choose one provider per provider-choice capability.
   Hard prerequisites are resolved explicitly.
   Pair integrations remain explicit follow-up actions.
   Run "pnpm forgeon:sync-integrations" in the target project after add-module steps.

package/src/core/docs.test.mjs

@@ -117,6 +117,7 @@ describe('generateDocs', () => {
       assert.doesNotMatch(readme, /docs\/Agents\.md/);
       assert.doesNotMatch(packageJson, /"create:forgeon"/);
       assert.match(packageJson, /"forgeon:sync-integrations"/);
+      assert.match(packageJson, /"add-all": "npx create-forgeon@latest add all --project \."?/);
     } finally {
       fs.rmSync(tempRoot, { recursive: true, force: true });
     }

package/src/core/scaffold.test.mjs

@@ -26,6 +26,7 @@ function assertProxyPreset(targetRoot, proxy) {
   assert.equal(fs.existsSync(path.join(dockerDir, 'compose.nginx.yml')), false);
   assert.equal(fs.existsSync(path.join(dockerDir, 'compose.none.yml')), false);
   assert.match(packageJson, /"forgeon:sync-integrations"/);
+  assert.match(packageJson, /"add-all": "npx create-forgeon@latest add all --project \."?/);
   assert.doesNotMatch(packageJson, /"create:forgeon"/);
   assert.match(compose, /^services:\s*$/m);
   assert.match(compose, /^\s{2}api:\s*$/m);

package/src/modules/accounts.mjs

@@ -1,4 +1,4 @@
-import fs from 'node:fs';
+import fs from 'node:fs';
 import path from 'node:path';
 import { copyRecursive, writeJson } from '../utils/fs.mjs';
 import {
@@ -171,20 +171,20 @@ function patchAppModule(targetRoot) {
 
   let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
   content = content.replace(
-    "import { authConfig, authEnvSchema, ForgeonAccountsModule } from '@forgeon/accounts-api';",
     "import { ACCOUNTS_PERSISTENCE_PORT, authConfig, authEnvSchema, ForgeonAccountsModule, UsersModule } from '@forgeon/accounts-api';",
+    "import { authConfig, authEnvSchema, ForgeonAccountsModule, UsersModule } from '@forgeon/accounts-api';",
   );
   content = content.replace(
+    "import { authConfig, authEnvSchema, ForgeonAccountsModule } from '@forgeon/accounts-api';",
     "import { authConfig, authEnvSchema, ForgeonAccountsModule, UsersModule } from '@forgeon/accounts-api';",
-    "import { ACCOUNTS_PERSISTENCE_PORT, authConfig, authEnvSchema, ForgeonAccountsModule, UsersModule } from '@forgeon/accounts-api';",
   );
   content = ensureImportLine(
     content,
-    "import { ACCOUNTS_PERSISTENCE_PORT, authConfig, authEnvSchema, ForgeonAccountsModule, UsersModule } from '@forgeon/accounts-api';",
+    "import { authConfig, authEnvSchema, ForgeonAccountsModule, UsersModule } from '@forgeon/accounts-api';",
   );
-  content = ensureImportLine(
-    content,
-    "import { PrismaAccountsPersistenceStore } from './accounts/prisma-accounts-persistence.store';",
+  content = content.replace(
+    /^import \{ PrismaAccountsPersistenceStore \} from '\.\/accounts\/prisma-accounts-persistence\.store';\r?\n/m,
+    '',
   );
   content = content.replace(
     /^import \{ ForgeonAccountsDbPrismaModule \} from '\.\/accounts\/forgeon-accounts-db-prisma\.module';\r?\n/m,
@@ -195,20 +195,12 @@ function patchAppModule(targetRoot) {
   content = content.replace(/^\s*ForgeonAccountsDbPrismaModule,\r?\n/gm, '');
 
   const accountsModuleLine = `    ForgeonAccountsModule.register({
-      imports: [DbPrismaModule],
-      providers: [
-        PrismaAccountsPersistenceStore,
-        {
-          provide: ACCOUNTS_PERSISTENCE_PORT,
-          useExisting: PrismaAccountsPersistenceStore,
-        },
-      ],
       users: UsersModule.register({}),
     }),`;
 
   if (content.includes('    ForgeonAccountsModule.register({')) {
     content = content.replace(
-      / {4}ForgeonAccountsModule\.register\(\{[\s\S]*? {4}\}\),/m,
+      / {4}ForgeonAccountsModule\.register\([\s\S]*? {4}\}\),/m,
       accountsModuleLine,
     );
   } else if (content.includes('    ForgeonI18nModule.register({')) {
@@ -221,7 +213,6 @@ function patchAppModule(targetRoot) {
 
   fs.writeFileSync(filePath, `${content.trimEnd()}\n`, 'utf8');
 }
-
 function patchHealthController(targetRoot, probeTargets) {
   patchHealthControllerServiceProbe(targetRoot, probeTargets, {
     importLine: "import { AuthService } from '@forgeon/accounts-api';",
@@ -386,7 +377,6 @@ function patchReadme(targetRoot) {
 export function applyAccountsModule({ packageRoot, targetRoot }) {
   copyFromPreset(packageRoot, targetRoot, path.join('packages', 'accounts-contracts'));
   copyFromPreset(packageRoot, targetRoot, path.join('packages', 'accounts-api'));
-  copyFromPreset(packageRoot, targetRoot, path.join('apps', 'api', 'src', 'accounts'));
   copyFromPreset(
     packageRoot,
     targetRoot,
@@ -429,3 +419,4 @@ export function applyAccountsModule({ packageRoot, targetRoot }) {
 
 
 
+

package/src/modules/dependencies.mjs

@@ -1,7 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { promptSelect } from '../cli/prompt-select.mjs';
-import { getCapabilityProviders, listModulePresets } from './registry.mjs';
+import {
+  getCapabilityProviders,
+  getRecommendedCapabilityProvider,
+  listModulePresets,
+} from './registry.mjs';
 
 function getPresetMap(presets) {
   return new Map(presets.map((preset) => [preset.id, preset]));
@@ -94,15 +98,16 @@ async function selectProviderForCapability({
     );
   }
 
-  const choices = providers.map((provider, index) => ({
-    label: index === 0 ? `${provider.id} (Recommended)` : provider.id,
+  const recommendedProvider = getRecommendedCapabilityProvider(capabilityId, providers) ?? providers[0];
+  const choices = providers.map((provider) => ({
+    label: provider.id === recommendedProvider.id ? `${provider.id} (Recommended)` : provider.id,
     value: provider.id,
   }));
   choices.push({ label: 'Cancel', value: '__cancel' });
 
   const picked = await promptSelectImpl({
     message: `Module "${moduleId}" requires capability: ${capabilityId}`,
-    defaultValue: providers[0].id,
+    defaultValue: recommendedProvider.id,
     choices,
   });
 
@@ -113,6 +118,53 @@ async function selectProviderForCapability({
   return picked;
 }
 
+function getAmbiguousCapabilityProviders(presets = listModulePresets()) {
+  const providersByCapability = new Map();
+
+  for (const preset of presets) {
+    if (preset.implemented === false || !Array.isArray(preset.provides)) {
+      continue;
+    }
+
+    for (const capabilityId of preset.provides) {
+      const providers = providersByCapability.get(capabilityId) ?? [];
+      providers.push(preset);
+      providersByCapability.set(capabilityId, providers);
+    }
+  }
+
+  return new Map(
+    [...providersByCapability.entries()].filter(([, providers]) => providers.length > 1),
+  );
+}
+
+function getAllModulesInstallTargets({ presets = listModulePresets(), selectedProviders = {} }) {
+  const ambiguousCapabilityProviders = getAmbiguousCapabilityProviders(presets);
+
+  return presets
+    .filter((preset) => preset.implemented !== false)
+    .filter((preset) => {
+      const providedCapabilities = Array.isArray(preset.provides) ? preset.provides : [];
+      const ambiguousCapabilities = providedCapabilities.filter((capabilityId) =>
+        ambiguousCapabilityProviders.has(capabilityId),
+      );
+
+      if (ambiguousCapabilities.length === 0) {
+        return true;
+      }
+
+      const hasNonAmbiguousCapability = providedCapabilities.some(
+        (capabilityId) => !ambiguousCapabilityProviders.has(capabilityId),
+      );
+      if (hasNonAmbiguousCapability) {
+        return true;
+      }
+
+      return ambiguousCapabilities.some((capabilityId) => selectedProviders[capabilityId] === preset.id);
+    })
+    .map((preset) => preset.id);
+}
+
 export async function resolveModuleInstallPlan({
   moduleId,
   targetRoot,
@@ -229,6 +281,103 @@ export async function resolveModuleInstallPlan({
   };
 }
 
+export async function resolveAllModulesInstallPlan({
+  targetRoot,
+  presets = listModulePresets(),
+  providerSelections = {},
+  promptSelectImpl = promptSelect,
+  isInteractive = process.stdin.isTTY && process.stdout.isTTY,
+}) {
+  const ambiguousCapabilityProviders = getAmbiguousCapabilityProviders(presets);
+  const selectedProviders = { ...providerSelections };
+
+  for (const [capabilityId, providers] of ambiguousCapabilityProviders.entries()) {
+    const explicitProvider = selectedProviders[capabilityId];
+    if (explicitProvider) {
+      const matchedProvider = providers.find((provider) => provider.id === explicitProvider);
+      if (!matchedProvider) {
+        throw createResolutionError('all', { type: 'capability', id: capabilityId }, providers, explicitProvider);
+      }
+      continue;
+    }
+
+    if (isInteractive) {
+      const pickedProvider = await selectProviderForCapability({
+        moduleId: 'all',
+        capabilityId,
+        providers,
+        promptSelectImpl,
+      });
+      if (!pickedProvider) {
+        return {
+          cancelled: true,
+          moduleSequence: [],
+          selectedProviders: {},
+          rootModuleIds: [],
+        };
+      }
+      selectedProviders[capabilityId] = pickedProvider;
+      continue;
+    }
+
+    const recommendedProvider = getRecommendedCapabilityProvider(capabilityId, providers);
+    if (!recommendedProvider) {
+      throw createResolutionError('all', { type: 'capability', id: capabilityId }, providers);
+    }
+    selectedProviders[capabilityId] = recommendedProvider.id;
+  }
+
+  const rootModuleIds = getAllModulesInstallTargets({
+    presets,
+    selectedProviders,
+  });
+
+  const moduleSequence = [];
+  const plannedSet = new Set();
+  let accumulatedProviderSelections = { ...selectedProviders };
+
+  for (const moduleId of rootModuleIds) {
+    const plan = await resolveModuleInstallPlan({
+      moduleId,
+      targetRoot,
+      presets,
+      withRequired: true,
+      providerSelections: accumulatedProviderSelections,
+      promptSelectImpl,
+      isInteractive: false,
+    });
+
+    if (plan.cancelled) {
+      return {
+        cancelled: true,
+        moduleSequence,
+        selectedProviders: accumulatedProviderSelections,
+        rootModuleIds,
+      };
+    }
+
+    accumulatedProviderSelections = {
+      ...accumulatedProviderSelections,
+      ...plan.selectedProviders,
+    };
+
+    for (const plannedModuleId of plan.moduleSequence) {
+      if (plannedSet.has(plannedModuleId)) {
+        continue;
+      }
+      plannedSet.add(plannedModuleId);
+      moduleSequence.push(plannedModuleId);
+    }
+  }
+
+  return {
+    cancelled: false,
+    moduleSequence,
+    selectedProviders: accumulatedProviderSelections,
+    rootModuleIds,
+  };
+}
+
 function requirementIsMissing(requirement, installedModules, providedCapabilities) {
   if (requirement.type === 'capability') {
     return !providedCapabilities.has(requirement.id);

package/src/modules/dependencies.test.mjs

@@ -8,6 +8,7 @@ import {
   detectInstalledModules,
   getPendingOptionalIntegrations,
   getPendingRecommendedCompanions,
+  resolveAllModulesInstallPlan,
   resolveModuleInstallPlan,
 } from './dependencies.mjs';
 
@@ -361,6 +362,63 @@ describe('module dependency helpers', () => {
     }
   });
 
+  it('builds a full install plan with the recommended provider for ambiguous capabilities', async () => {
+    const targetRoot = mkTmp('forgeon-deps-all-plan-');
+
+    try {
+      const result = await resolveAllModulesInstallPlan({
+        targetRoot,
+        presets: TEST_PRESETS,
+        isInteractive: false,
+      });
+
+      assert.equal(result.cancelled, false);
+      assert.deepEqual(result.moduleSequence, [
+        'db-prisma',
+        'accounts',
+        'rbac',
+        'files-local',
+        'files',
+        'files-access',
+        'files-quotas',
+        'files-image',
+        'queue',
+        'scheduler',
+      ]);
+      assert.deepEqual(result.selectedProviders, {
+        'files-storage-adapter': 'files-local',
+        'db-adapter': 'db-prisma',
+        'files-runtime': 'files',
+        'queue-runtime': 'queue',
+      });
+      assert.equal(result.rootModuleIds.includes('files-s3'), false);
+    } finally {
+      fs.rmSync(targetRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('builds a full install plan with an explicit provider override', async () => {
+    const targetRoot = mkTmp('forgeon-deps-all-provider-');
+
+    try {
+      const result = await resolveAllModulesInstallPlan({
+        targetRoot,
+        presets: TEST_PRESETS,
+        isInteractive: false,
+        providerSelections: {
+          'files-storage-adapter': 'files-s3',
+        },
+      });
+
+      assert.equal(result.cancelled, false);
+      assert.equal(result.moduleSequence.includes('files-s3'), true);
+      assert.equal(result.moduleSequence.includes('files-local'), false);
+      assert.equal(result.selectedProviders['files-storage-adapter'], 'files-s3');
+    } finally {
+      fs.rmSync(targetRoot, { recursive: true, force: true });
+    }
+  });
+
   it('reports pending optional integrations for accounts when rbac is missing', () => {
     const targetRoot = mkTmp('forgeon-deps-optional-');
     try {

package/src/modules/executor.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it } from 'node:test';
+import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -239,10 +239,10 @@ function assertFilesWiring(projectRoot, expectedStorageDriver = 'local') {
   assert.match(appModule, /filesConfig/);
   assert.match(appModule, /filesEnvSchema/);
   assert.match(appModule, /ForgeonFilesModule\.register\(\{/);
-  assert.match(appModule, /ForgeonFilesDbPrismaModule/);
+  assert.doesNotMatch(appModule, /ForgeonFilesDbPrismaModule/);
   if (expectedStorageDriver === 's3') {
     assert.match(appModule, /ForgeonFilesS3StorageModule/);
-    assert.doesNotMatch(appModule, /imports: \[ForgeonFilesDbPrismaModule, ForgeonFilesLocalStorageModule\]/);
+    assert.doesNotMatch(appModule, /ForgeonFilesLocalStorageModule/);
   } else {
     assert.match(appModule, /ForgeonFilesLocalStorageModule/);
   }
@@ -285,14 +285,16 @@ function assertFilesWiring(projectRoot, expectedStorageDriver = 'local') {
     path.join(projectRoot, 'packages', 'files', 'src', 'files.service.ts'),
     'utf8',
   );
-  assert.match(filesService, /FILES_PERSISTENCE_PORT/);
+  assert.match(filesService, /FilesStore/);
   assert.match(filesService, /FILES_STORAGE_ADAPTER/);
+  assert.match(filesService, /requireStorageAdapter/);
   assert.match(filesService, /getOrCreateBlob/);
   assert.match(filesService, /cleanupReferencedBlobs/);
   assert.match(filesService, /isUniqueConstraintError/);
   assert.match(filesService, /storageAdapter\.put/);
-  assert.match(filesService, /persistence\.createBlob/);
-  assert.match(filesService, /persistence\.deleteBlobIfUnreferenced/);
+  assert.match(filesService, /filesStore\.createBlob/);
+  assert.match(filesService, /filesStore\.deleteBlobIfUnreferenced/);
+  assert.doesNotMatch(filesService, /FILES_PERSISTENCE_PORT/);
   assert.doesNotMatch(filesService, /PrismaService/);
   assert.doesNotMatch(filesService, /@aws-sdk\/client-s3/);
 
@@ -300,38 +302,34 @@ function assertFilesWiring(projectRoot, expectedStorageDriver = 'local') {
     path.join(projectRoot, 'packages', 'files', 'src', 'files.ports.ts'),
     'utf8',
   );
-  assert.match(filesPorts, /FILES_PERSISTENCE_PORT/);
+  assert.doesNotMatch(filesPorts, /FILES_PERSISTENCE_PORT/);
+  assert.doesNotMatch(filesPorts, /interface FilesPersistencePort/);
   assert.match(filesPorts, /FILES_STORAGE_ADAPTER/);
-  assert.match(filesPorts, /interface FilesPersistencePort/);
   assert.match(filesPorts, /interface FilesStorageAdapter/);
 
+  const filesStore = fs.readFileSync(
+    path.join(projectRoot, 'packages', 'files', 'src', 'files.store.ts'),
+    'utf8',
+  );
+  assert.match(filesStore, /PrismaService/);
+  assert.match(filesStore, /fileBlob\.deleteMany/);
+
   const filesModule = fs.readFileSync(
     path.join(projectRoot, 'packages', 'files', 'src', 'forgeon-files.module.ts'),
     'utf8',
   );
   assert.match(filesModule, /ForgeonFilesModuleOptions/);
   assert.match(filesModule, /static register\(options: ForgeonFilesModuleOptions = \{\}\)/);
-  assert.match(filesModule, /FILES_PERSISTENCE_PORT/);
-  assert.match(filesModule, /FILES_STORAGE_ADAPTER/);
+  assert.match(filesModule, /DbPrismaModule/);
+  assert.match(filesModule, /FilesStore/);
+  assert.doesNotMatch(filesModule, /FILES_PERSISTENCE_PORT/);
 
   const filesPackage = fs.readFileSync(path.join(projectRoot, 'packages', 'files', 'package.json'), 'utf8');
-  assert.doesNotMatch(filesPackage, /@forgeon\/db-prisma/);
+  assert.match(filesPackage, /@forgeon\/db-prisma/);
 
-  const prismaFilesStore = fs.readFileSync(
-    path.join(projectRoot, 'apps', 'api', 'src', 'files', 'prisma-files-persistence.store.ts'),
-    'utf8',
-  );
-  assert.match(prismaFilesStore, /PrismaService/);
-  assert.match(prismaFilesStore, /FILES_PERSISTENCE_PORT/);
-  assert.match(prismaFilesStore, /fileBlob\.deleteMany/);
-
-  const prismaFilesModule = fs.readFileSync(
-    path.join(projectRoot, 'apps', 'api', 'src', 'files', 'forgeon-files-db-prisma.module.ts'),
-    'utf8',
-  );
-  assert.match(prismaFilesModule, /ForgeonFilesDbPrismaModule/);
-  assert.match(prismaFilesModule, /DbPrismaModule/);
-  assert.match(prismaFilesModule, /FILES_PERSISTENCE_PORT/);
+  const prismaFilesDir = path.join(projectRoot, 'apps', 'api', 'src', 'files');
+  assert.equal(fs.existsSync(path.join(prismaFilesDir, 'prisma-files-persistence.store.ts')), false);
+  assert.equal(fs.existsSync(path.join(prismaFilesDir, 'forgeon-files-db-prisma.module.ts')), false);
 
   assertWebProbeShell(projectRoot);
   const probesTs = readWebProbes(projectRoot);
@@ -619,14 +617,19 @@ function assertFilesImageWiring(projectRoot) {
   );
   assert.match(filesModule, /ForgeonFilesImageModule/);
 
-  const filesService = fs.readFileSync(
-    path.join(projectRoot, 'packages', 'files', 'src', 'files.service.ts'),
-    'utf8',
-  );
-  assert.match(filesService, /FilesImageService/);
-  assert.match(filesService, /filesImageService\.sanitizeForStorage/);
-  assert.match(filesService, /sanitizeForStorage\({/);
-  assert.match(filesService, /auditContext: input\.auditContext/);
+  const filesService = fs.readFileSync(
+    path.join(projectRoot, 'packages', 'files', 'src', 'files.service.ts'),
+    'utf8',
+  );
+  assert.match(filesService, /FilesImageService/);
+  assert.match(filesService, /filesImageService\.sanitizeForStorage/);
+  assert.match(filesService, /sanitizeForStorage\({/);
+  assert.match(filesService, /auditContext: input\.auditContext/);
+  assert.equal(
+    (filesService.match(/protected normalizeFileName\(originalName: string, extension: string, suffix\?: string\): string \{/g) ?? [])
+      .length,
+    1,
+  );
 
   const filesController = fs.readFileSync(
     path.join(projectRoot, 'packages', 'files', 'src', 'files.controller.ts'),
@@ -717,11 +720,9 @@ function assertAccountsWiring(projectRoot) {
   assert.match(appModule, /authConfig/);
   assert.match(appModule, /authEnvSchema/);
   assert.match(appModule, /ForgeonAccountsModule\.register\(\{/);
-  assert.match(appModule, /imports: \[DbPrismaModule\]/);
-  assert.match(appModule, /PrismaAccountsPersistenceStore/);
-  assert.match(appModule, /provide: ACCOUNTS_PERSISTENCE_PORT/);
-  assert.match(appModule, /useExisting: PrismaAccountsPersistenceStore/);
   assert.match(appModule, /UsersModule\.register\(\{\}\)/);
+  assert.doesNotMatch(appModule, /ACCOUNTS_PERSISTENCE_PORT/);
+  assert.doesNotMatch(appModule, /PrismaAccountsPersistenceStore/);
   assert.doesNotMatch(appModule, /AUTH_REFRESH_TOKEN_STORE/);
 
   const healthController = fs.readFileSync(
@@ -773,6 +774,33 @@ function assertAccountsWiring(projectRoot) {
   );
   assert.match(authServiceSource, /import type \{ RegisterRequest \} from '@forgeon\/accounts-contracts';/);
 
+  const authCoreSource = fs.readFileSync(
+    path.join(projectRoot, 'packages', 'accounts-api', 'src', 'auth-core.service.ts'),
+    'utf8',
+  );
+  assert.match(authCoreSource, /AuthStore/);
+  assert.doesNotMatch(authCoreSource, /ACCOUNTS_PERSISTENCE_PORT/);
+
+  const accountsApiPackage = fs.readFileSync(
+    path.join(projectRoot, 'packages', 'accounts-api', 'package.json'),
+    'utf8',
+  );
+  assert.match(accountsApiPackage, /@forgeon\/db-prisma/);
+
+  const authStoreSource = fs.readFileSync(
+    path.join(projectRoot, 'packages', 'accounts-api', 'src', 'auth.store.ts'),
+    'utf8',
+  );
+  assert.match(authStoreSource, /PrismaService/);
+  assert.match(authStoreSource, /authRefreshToken\.updateMany/);
+
+  const usersStoreSource = fs.readFileSync(
+    path.join(projectRoot, 'packages', 'accounts-api', 'src', 'users.store.ts'),
+    'utf8',
+  );
+  assert.match(usersStoreSource, /PrismaService/);
+  assert.match(usersStoreSource, /userProfile\.upsert/);
+
   const prismaStorePath = path.join(
     projectRoot,
     'apps',
@@ -781,7 +809,7 @@ function assertAccountsWiring(projectRoot) {
     'accounts',
     'prisma-accounts-persistence.store.ts',
   );
-  assert.equal(fs.existsSync(prismaStorePath), true);
+  assert.equal(fs.existsSync(prismaStorePath), false);
 }
 function stripDbPrismaArtifacts(projectRoot) {
   const dbPackageDir = path.join(projectRoot, 'packages', 'db-prisma');
@@ -1550,7 +1578,7 @@ describe('addModule', () => {
 
       const appModule = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'src', 'app.module.ts'), 'utf8');
       assert.match(appModule, /ForgeonFilesS3StorageModule/);
-      assert.doesNotMatch(appModule, /imports: \[ForgeonFilesDbPrismaModule, ForgeonFilesLocalStorageModule\]/);
+      assert.doesNotMatch(appModule, /ForgeonFilesLocalStorageModule/);
 
       const filesService = fs.readFileSync(
         path.join(projectRoot, 'packages', 'files', 'src', 'files.service.ts'),
@@ -2650,3 +2678,4 @@ describe('addModule', () => {
 
 
 
+

package/src/modules/files-image.mjs

@@ -258,9 +258,10 @@ function patchFilesService(targetRoot) {
   }`,
     );
 
-    content = content.replace(
-      `  private extensionFromMime(mimeType: string): string | null {`,
-      `  protected normalizeFileName(originalName: string, extension: string, suffix?: string): string {
+    if (!content.includes('protected normalizeFileName(originalName: string, extension: string, suffix?: string): string')) {
+      content = content.replace(
+        `  private extensionFromMime(mimeType: string): string | null {`,
+        `  protected normalizeFileName(originalName: string, extension: string, suffix?: string): string {
     const parsed = path.parse(originalName);
     const safeExtension = extension.startsWith('.') ? extension : \`.\${extension}\`;
     const base = suffix ? \`\${parsed.name}-\${suffix}\` : parsed.name;
@@ -268,7 +269,8 @@ function patchFilesService(targetRoot) {
   }
 
   private extensionFromMime(mimeType: string): string | null {`,
-    );
+      );
+    }
   }
 
   fs.writeFileSync(filePath, `${content.trimEnd()}\n`, 'utf8');

package/src/modules/files.mjs

@@ -170,9 +170,9 @@ function patchAppModule(targetRoot) {
     content,
     "import { filesConfig, filesEnvSchema, ForgeonFilesModule } from '@forgeon/files';",
   );
-  content = ensureImportLine(
-    content,
-    "import { ForgeonFilesDbPrismaModule } from './files/forgeon-files-db-prisma.module';",
+  content = content.replace(
+    /^import \{ ForgeonFilesDbPrismaModule \} from '\.\/files\/forgeon-files-db-prisma\.module';\r?\n/m,
+    '',
   );
 
   if (fs.existsSync(path.join(targetRoot, 'packages', 'files-local', 'package.json'))) {
@@ -188,7 +188,6 @@ function patchAppModule(targetRoot) {
 
   fs.writeFileSync(filePath, `${content.trimEnd()}\n`, 'utf8');
 }
-
 function patchApiDockerfile(targetRoot) {
   const dockerfilePath = path.join(targetRoot, 'apps', 'api', 'Dockerfile');
   if (!fs.existsSync(dockerfilePath)) {
@@ -378,7 +377,7 @@ function patchReadme(targetRoot) {
 
   const section = `## Files Module
 
-The files module adds runtime file endpoints with DB-backed metadata and storage-driver-aware behavior.
+The files module adds runtime file endpoints with Prisma-backed metadata and storage-driver-aware behavior.
 
 What it currently adds:
 - \`@forgeon/files\` package with:
@@ -425,7 +424,6 @@ Key env:
 
 export function applyFilesModule({ packageRoot, targetRoot }) {
   copyFromPreset(packageRoot, targetRoot, path.join('packages', 'files'));
-  copyFromPreset(packageRoot, targetRoot, path.join('apps', 'api', 'src', 'files'));
   const probeTargets = resolveProbeTargets({ targetRoot, moduleId: 'files' });
 
 
@@ -456,3 +454,4 @@ export function applyFilesModule({ packageRoot, targetRoot }) {
 }
 
 
+

package/src/modules/idempotency.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it } from 'node:test';
+import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -91,7 +91,7 @@ describe('addModule idempotency', () => {
           fs.existsSync(
             path.join(projectRoot, 'apps', 'api', 'src', 'accounts', 'prisma-accounts-persistence.store.ts'),
           ),
-          true,
+          false,
         );
         assert.match(
           readFile(path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts')),
@@ -178,3 +178,4 @@ describe('addModule idempotency', () => {
     }
   });
 });
+