create-forgeon 0.3.19 → 0.3.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-forgeon",
-  "version": "0.3.19",
+  "version": "0.3.21",
   "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 {