create-forgeon 0.1.2 → 0.1.6

package/src/core/validate.test.mjs

@@ -1,73 +1,73 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { validatePresetSupport } from './validate.mjs';
-
-describe('validatePresetSupport', () => {
-  it('accepts current supported presets', () => {
-    assert.doesNotThrow(() =>
-      validatePresetSupport({
-        frontend: 'react',
-        db: 'prisma',
-        dockerEnabled: true,
-        proxy: 'caddy',
-      }),
-    );
-
-    assert.doesNotThrow(() =>
-      validatePresetSupport({
-        frontend: 'react',
-        db: 'prisma',
-        dockerEnabled: true,
-        proxy: 'none',
-      }),
-    );
-  });
-
-  it('throws for angular not-yet-implemented preset', () => {
-    assert.throws(
-      () =>
-        validatePresetSupport({
-          frontend: 'angular',
-          db: 'prisma',
-          dockerEnabled: false,
-          proxy: 'none',
-        }),
-      /Frontend preset "angular" is not implemented yet/,
-    );
-  });
-
-  it('throws for unsupported db preset', () => {
-    assert.throws(
-      () =>
-        validatePresetSupport({
-          frontend: 'react',
-          db: 'mongo',
-          dockerEnabled: false,
-          proxy: 'none',
-        }),
-      /Unsupported db preset: mongo/,
-    );
-  });
-
-  it('throws for unsupported proxy only when docker is enabled', () => {
-    assert.throws(
-      () =>
-        validatePresetSupport({
-          frontend: 'react',
-          db: 'prisma',
-          dockerEnabled: true,
-          proxy: 'traefik',
-        }),
-      /Unsupported proxy preset: traefik/,
-    );
-
-    assert.doesNotThrow(() =>
-      validatePresetSupport({
-        frontend: 'react',
-        db: 'prisma',
-        dockerEnabled: false,
-        proxy: 'traefik',
-      }),
-    );
-  });
-});
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { validatePresetSupport } from './validate.mjs';
+
+describe('validatePresetSupport', () => {
+  it('accepts current supported presets', () => {
+    assert.doesNotThrow(() =>
+      validatePresetSupport({
+        frontend: 'react',
+        db: 'prisma',
+        dockerEnabled: true,
+        proxy: 'caddy',
+      }),
+    );
+
+    assert.doesNotThrow(() =>
+      validatePresetSupport({
+        frontend: 'react',
+        db: 'prisma',
+        dockerEnabled: true,
+        proxy: 'none',
+      }),
+    );
+  });
+
+  it('throws for angular not-yet-implemented preset', () => {
+    assert.throws(
+      () =>
+        validatePresetSupport({
+          frontend: 'angular',
+          db: 'prisma',
+          dockerEnabled: false,
+          proxy: 'none',
+        }),
+      /Frontend preset "angular" is not implemented yet/,
+    );
+  });
+
+  it('throws for unsupported db preset', () => {
+    assert.throws(
+      () =>
+        validatePresetSupport({
+          frontend: 'react',
+          db: 'mongo',
+          dockerEnabled: false,
+          proxy: 'none',
+        }),
+      /Unsupported db preset: mongo/,
+    );
+  });
+
+  it('throws for unsupported proxy only when docker is enabled', () => {
+    assert.throws(
+      () =>
+        validatePresetSupport({
+          frontend: 'react',
+          db: 'prisma',
+          dockerEnabled: true,
+          proxy: 'traefik',
+        }),
+      /Unsupported proxy preset: traefik/,
+    );
+
+    assert.doesNotThrow(() =>
+      validatePresetSupport({
+        frontend: 'react',
+        db: 'prisma',
+        dockerEnabled: false,
+        proxy: 'traefik',
+      }),
+    );
+  });
+});

package/src/databases/index.mjs

@@ -1,26 +1,26 @@
-const DATABASE_PRESETS = {
-  prisma: {
-    id: 'prisma',
-    label: 'Prisma + PostgreSQL',
-    implemented: true,
-  },
-};
-
-export function getDatabasePreset(db) {
-  return DATABASE_PRESETS[db] ?? null;
-}
-
-export function getDatabaseLabel(db) {
-  return getDatabasePreset(db)?.label ?? db;
-}
-
-export function ensureDatabaseSupported(db) {
-  const preset = getDatabasePreset(db);
-  if (!preset) {
-    throw new Error(`Unsupported db preset: ${db}. Currently implemented: prisma.`);
-  }
-
-  if (!preset.implemented) {
-    throw new Error(`DB preset "${db}" is not implemented yet.`);
-  }
-}
+const DATABASE_PRESETS = {
+  prisma: {
+    id: 'prisma',
+    label: 'Prisma + PostgreSQL',
+    implemented: true,
+  },
+};
+
+export function getDatabasePreset(db) {
+  return DATABASE_PRESETS[db] ?? null;
+}
+
+export function getDatabaseLabel(db) {
+  return getDatabasePreset(db)?.label ?? db;
+}
+
+export function ensureDatabaseSupported(db) {
+  const preset = getDatabasePreset(db);
+  if (!preset) {
+    throw new Error(`Unsupported db preset: ${db}. Currently implemented: prisma.`);
+  }
+
+  if (!preset.implemented) {
+    throw new Error(`DB preset "${db}" is not implemented yet.`);
+  }
+}

package/src/frameworks/index.mjs

@@ -1,32 +1,32 @@
-const FRONTEND_PRESETS = {
-  react: {
-    id: 'react',
-    label: 'React + Vite + TypeScript',
-    implemented: true,
-  },
-  angular: {
-    id: 'angular',
-    label: 'Angular',
-    implemented: false,
-    message: 'Frontend preset "angular" is not implemented yet. Use --frontend react.',
-  },
-};
-
-export function getFrontendPreset(frontend) {
-  return FRONTEND_PRESETS[frontend] ?? null;
-}
-
-export function getFrontendLabel(frontend) {
-  return getFrontendPreset(frontend)?.label ?? frontend;
-}
-
-export function ensureFrontendSupported(frontend) {
-  const preset = getFrontendPreset(frontend);
-  if (!preset) {
-    throw new Error(`Unsupported frontend preset: ${frontend}`);
-  }
-
-  if (!preset.implemented) {
-    throw new Error(preset.message ?? `Frontend preset "${frontend}" is not implemented yet.`);
-  }
-}
+const FRONTEND_PRESETS = {
+  react: {
+    id: 'react',
+    label: 'React + Vite + TypeScript',
+    implemented: true,
+  },
+  angular: {
+    id: 'angular',
+    label: 'Angular',
+    implemented: false,
+    message: 'Frontend preset "angular" is not implemented yet. Use --frontend react.',
+  },
+};
+
+export function getFrontendPreset(frontend) {
+  return FRONTEND_PRESETS[frontend] ?? null;
+}
+
+export function getFrontendLabel(frontend) {
+  return getFrontendPreset(frontend)?.label ?? frontend;
+}
+
+export function ensureFrontendSupported(frontend) {
+  const preset = getFrontendPreset(frontend);
+  if (!preset) {
+    throw new Error(`Unsupported frontend preset: ${frontend}`);
+  }
+
+  if (!preset.implemented) {
+    throw new Error(preset.message ?? `Frontend preset "${frontend}" is not implemented yet.`);
+  }
+}

package/src/infrastructure/proxy.mjs

@@ -1,12 +1,12 @@
-const SUPPORTED_PROXIES = ['caddy', 'nginx', 'none'];
-
-export function ensureProxySupported(proxy) {
-  if (!SUPPORTED_PROXIES.includes(proxy)) {
-    throw new Error(`Unsupported proxy preset: ${proxy}. Use caddy, nginx, or none.`);
-  }
-}
-
-export function getProxyConfigPath(proxy) {
-  if (proxy === 'none') return 'n/a';
-  return proxy === 'caddy' ? 'infra/caddy/Caddyfile' : 'infra/nginx/nginx.conf';
-}
+const SUPPORTED_PROXIES = ['caddy', 'nginx', 'none'];
+
+export function ensureProxySupported(proxy) {
+  if (!SUPPORTED_PROXIES.includes(proxy)) {
+    throw new Error(`Unsupported proxy preset: ${proxy}. Use caddy, nginx, or none.`);
+  }
+}
+
+export function getProxyConfigPath(proxy) {
+  if (proxy === 'none') return 'n/a';
+  return proxy === 'caddy' ? 'infra/caddy/Caddyfile' : 'infra/nginx/nginx.conf';
+}

package/src/modules/docs.mjs

@@ -1,70 +1,70 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-function renderTemplate(content, variables) {
-  return content.replace(/\{\{([A-Z0-9_]+)\}\}/g, (_, key) => String(variables[key] ?? ''));
-}
-
-function readModuleFragment(packageRoot, moduleId, fragmentName, variables) {
-  const fragmentPath = path.join(
-    packageRoot,
-    'templates',
-    'module-fragments',
-    moduleId,
-    `${fragmentName}.md`,
-  );
-  if (!fs.existsSync(fragmentPath)) {
-    throw new Error(`Missing module docs fragment: ${fragmentPath}`);
-  }
-  const raw = fs.readFileSync(fragmentPath, 'utf8').replace(/\r\n/g, '\n').trim();
-  return renderTemplate(raw, variables).trim();
-}
-
-function ensureModuleIndex(targetRoot) {
-  const indexPath = path.join(targetRoot, 'docs', 'AI', 'MODULES', 'README.md');
-  if (!fs.existsSync(indexPath)) {
-    fs.mkdirSync(path.dirname(indexPath), { recursive: true });
-    fs.writeFileSync(
-      indexPath,
-      '# MODULES\n\nGenerated notes for module presets added via `create-forgeon add`.\n',
-      'utf8',
-    );
-  }
-  return indexPath;
-}
-
-function updateModuleIndex(indexPath, preset) {
-  const relativePath = `${preset.id}.md`;
-  const nextLine = `- \`${preset.id}\` - ${preset.label} (${preset.implemented ? 'implemented' : 'planned'})`;
-  const current = fs.readFileSync(indexPath, 'utf8').replace(/\r\n/g, '\n');
-
-  if (current.includes(`\`${preset.id}\``)) {
-    return;
-  }
-
-  const content = `${current.trimEnd()}\n${nextLine}\n`;
-  fs.writeFileSync(indexPath, content, 'utf8');
-}
-
-export function writeModuleDocs({ packageRoot, targetRoot, preset }) {
-  const variables = {
-    MODULE_ID: preset.id,
-    MODULE_LABEL: preset.label,
-    MODULE_CATEGORY: preset.category,
-    MODULE_STATUS: preset.implemented ? 'implemented' : 'planned',
-    MODULE_DESCRIPTION: preset.description,
-  };
-
-  const sections = preset.docFragments
-    .map((fragmentName) => readModuleFragment(packageRoot, preset.id, fragmentName, variables))
-    .filter(Boolean);
-
-  const outputPath = path.join(targetRoot, 'docs', 'AI', 'MODULES', `${preset.id}.md`);
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-  fs.writeFileSync(outputPath, `${sections.join('\n\n').trimEnd()}\n`, 'utf8');
-
-  const indexPath = ensureModuleIndex(targetRoot);
-  updateModuleIndex(indexPath, preset);
-
-  return outputPath;
-}
+import fs from 'node:fs';
+import path from 'node:path';
+
+function renderTemplate(content, variables) {
+  return content.replace(/\{\{([A-Z0-9_]+)\}\}/g, (_, key) => String(variables[key] ?? ''));
+}
+
+function readModuleFragment(packageRoot, moduleId, fragmentName, variables) {
+  const fragmentPath = path.join(
+    packageRoot,
+    'templates',
+    'module-fragments',
+    moduleId,
+    `${fragmentName}.md`,
+  );
+  if (!fs.existsSync(fragmentPath)) {
+    throw new Error(`Missing module docs fragment: ${fragmentPath}`);
+  }
+  const raw = fs.readFileSync(fragmentPath, 'utf8').replace(/\r\n/g, '\n').trim();
+  return renderTemplate(raw, variables).trim();
+}
+
+function ensureModuleIndex(targetRoot) {
+  const indexPath = path.join(targetRoot, 'docs', 'AI', 'MODULES', 'README.md');
+  if (!fs.existsSync(indexPath)) {
+    fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+    fs.writeFileSync(
+      indexPath,
+      '# MODULES\n\nGenerated notes for module presets added via `create-forgeon add`.\n',
+      'utf8',
+    );
+  }
+  return indexPath;
+}
+
+function updateModuleIndex(indexPath, preset) {
+  const relativePath = `${preset.id}.md`;
+  const nextLine = `- \`${preset.id}\` - ${preset.label} (${preset.implemented ? 'implemented' : 'planned'})`;
+  const current = fs.readFileSync(indexPath, 'utf8').replace(/\r\n/g, '\n');
+
+  if (current.includes(`\`${preset.id}\``)) {
+    return;
+  }
+
+  const content = `${current.trimEnd()}\n${nextLine}\n`;
+  fs.writeFileSync(indexPath, content, 'utf8');
+}
+
+export function writeModuleDocs({ packageRoot, targetRoot, preset }) {
+  const variables = {
+    MODULE_ID: preset.id,
+    MODULE_LABEL: preset.label,
+    MODULE_CATEGORY: preset.category,
+    MODULE_STATUS: preset.implemented ? 'implemented' : 'planned',
+    MODULE_DESCRIPTION: preset.description,
+  };
+
+  const sections = preset.docFragments
+    .map((fragmentName) => readModuleFragment(packageRoot, preset.id, fragmentName, variables))
+    .filter(Boolean);
+
+  const outputPath = path.join(targetRoot, 'docs', 'AI', 'MODULES', `${preset.id}.md`);
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.writeFileSync(outputPath, `${sections.join('\n\n').trimEnd()}\n`, 'utf8');
+
+  const indexPath = ensureModuleIndex(targetRoot);
+  updateModuleIndex(indexPath, preset);
+
+  return outputPath;
+}

package/src/modules/executor.mjs

@@ -2,38 +2,56 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { ensureModuleExists } from './registry.mjs';
 import { writeModuleDocs } from './docs.mjs';
+import { applyI18nModule } from './i18n.mjs';
+
+function ensureForgeonLikeProject(targetRoot) {
+  const requiredPaths = [
+    path.join(targetRoot, 'package.json'),
+    path.join(targetRoot, 'pnpm-workspace.yaml'),
+    path.join(targetRoot, 'apps', 'api'),
+  ];
+
+  for (const requiredPath of requiredPaths) {
+    if (!fs.existsSync(requiredPath)) {
+      throw new Error(
+        `Target path does not look like a Forgeon project: missing ${path.relative(targetRoot, requiredPath)}`,
+      );
+    }
+  }
+}
+
+const MODULE_APPLIERS = {
+  i18n: applyI18nModule,
+};
 
-function ensureForgeonLikeProject(targetRoot) {
-  const requiredPaths = [
-    path.join(targetRoot, 'package.json'),
-    path.join(targetRoot, 'pnpm-workspace.yaml'),
-    path.join(targetRoot, 'apps', 'api'),
-  ];
-
-  for (const requiredPath of requiredPaths) {
-    if (!fs.existsSync(requiredPath)) {
-      throw new Error(
-        `Target path does not look like a Forgeon project: missing ${path.relative(targetRoot, requiredPath)}`,
-      );
-    }
+export function applyModulePreset({ moduleId, targetRoot, packageRoot }) {
+  const applier = MODULE_APPLIERS[moduleId];
+  if (!applier) {
+    return false;
   }
+
+  applier({ targetRoot, packageRoot });
+  return true;
 }
 
-export function addModule({ moduleId, targetRoot, packageRoot }) {
+export function addModule({ moduleId, targetRoot, packageRoot, writeDocs = true }) {
   ensureForgeonLikeProject(targetRoot);
 
   const preset = ensureModuleExists(moduleId);
-  const docsPath = writeModuleDocs({
-    packageRoot,
-    targetRoot,
-    preset,
-  });
+  const applied = applyModulePreset({ moduleId, targetRoot, packageRoot });
+  const docsPath = writeDocs
+    ? writeModuleDocs({
+        packageRoot,
+        targetRoot,
+        preset,
+      })
+    : path.join(targetRoot, 'docs', 'AI', 'MODULES', `${preset.id}.md`);
 
   return {
     preset,
     docsPath,
-    applied: preset.implemented,
-    message: preset.implemented
+    applied: applied || preset.implemented,
+    message: applied
       ? `Module "${preset.id}" applied.`
       : `Module "${preset.id}" is planned; docs note created only.`,
   };

package/src/modules/executor.test.mjs

@@ -1,60 +1,110 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { addModule } from './executor.mjs';
+import { scaffoldProject } from '../core/scaffold.mjs';
+
+function mkTmp(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function createMinimalForgeonProject(targetRoot) {
+  fs.mkdirSync(path.join(targetRoot, 'apps', 'api'), { recursive: true });
+  fs.writeFileSync(path.join(targetRoot, 'package.json'), '{"name":"demo"}\n', 'utf8');
+  fs.writeFileSync(path.join(targetRoot, 'pnpm-workspace.yaml'), 'packages:\n  - apps/*\n', 'utf8');
+}
+
+describe('addModule', () => {
+  const modulesDir = path.dirname(fileURLToPath(import.meta.url));
+  const packageRoot = path.resolve(modulesDir, '..', '..');
+
+  it('creates module docs note for planned module', () => {
+    const targetRoot = mkTmp('forgeon-module-');
+    try {
+      createMinimalForgeonProject(targetRoot);
+      const result = addModule({
+        moduleId: 'jwt-auth',
+        targetRoot,
+        packageRoot,
+      });
+
+      assert.equal(result.applied, false);
+      assert.match(result.message, /planned/);
+      assert.equal(fs.existsSync(result.docsPath), true);
+
+      const note = fs.readFileSync(result.docsPath, 'utf8');
+      assert.match(note, /JWT Auth/);
+      assert.match(note, /Status: planned/);
+    } finally {
+      fs.rmSync(targetRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('throws for unknown module id', () => {
+    const targetRoot = mkTmp('forgeon-module-unknown-');
+    try {
+      createMinimalForgeonProject(targetRoot);
+      assert.throws(
+        () =>
+          addModule({
+            moduleId: 'unknown-module',
+            targetRoot,
+            packageRoot,
+          }),
+        /Unknown module/,
+      );
+    } finally {
+      fs.rmSync(targetRoot, { recursive: true, force: true });
+    }
+  });
 
-function mkTmp(prefix) {
-  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-}
-
-function createMinimalForgeonProject(targetRoot) {
-  fs.mkdirSync(path.join(targetRoot, 'apps', 'api'), { recursive: true });
-  fs.writeFileSync(path.join(targetRoot, 'package.json'), '{"name":"demo"}\n', 'utf8');
-  fs.writeFileSync(path.join(targetRoot, 'pnpm-workspace.yaml'), 'packages:\n  - apps/*\n', 'utf8');
-}
-
-describe('addModule', () => {
-  const modulesDir = path.dirname(fileURLToPath(import.meta.url));
-  const packageRoot = path.resolve(modulesDir, '..', '..');
+  it('applies i18n module on top of scaffold without i18n', () => {
+    const targetRoot = mkTmp('forgeon-module-i18n-');
+    const projectRoot = path.join(targetRoot, 'demo-i18n');
+    const templateRoot = path.join(packageRoot, 'templates', 'base');
 
-  it('creates module docs note for planned module', () => {
-    const targetRoot = mkTmp('forgeon-module-');
     try {
-      createMinimalForgeonProject(targetRoot);
+      scaffoldProject({
+        templateRoot,
+        packageRoot,
+        targetRoot: projectRoot,
+        projectName: 'demo-i18n',
+        frontend: 'react',
+        db: 'prisma',
+        i18nEnabled: false,
+        proxy: 'caddy',
+      });
+
       const result = addModule({
-        moduleId: 'jwt-auth',
-        targetRoot,
+        moduleId: 'i18n',
+        targetRoot: projectRoot,
         packageRoot,
       });
 
-      assert.equal(result.applied, false);
-      assert.match(result.message, /planned/);
-      assert.equal(fs.existsSync(result.docsPath), true);
+      assert.equal(result.applied, true);
+      assert.match(result.message, /applied/);
+      assert.equal(
+        fs.existsSync(path.join(projectRoot, 'packages', 'i18n-contracts', 'package.json')),
+        true,
+      );
+      assert.equal(
+        fs.existsSync(path.join(projectRoot, 'packages', 'i18n-web', 'package.json')),
+        true,
+      );
 
-      const note = fs.readFileSync(result.docsPath, 'utf8');
-      assert.match(note, /JWT Auth/);
-      assert.match(note, /Status: planned/);
-    } finally {
-      fs.rmSync(targetRoot, { recursive: true, force: true });
-    }
-  });
+      const apiPackage = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'package.json'), 'utf8');
+      assert.match(apiPackage, /@forgeon\/i18n/);
+      assert.match(apiPackage, /@forgeon\/i18n-contracts/);
 
-  it('throws for unknown module id', () => {
-    const targetRoot = mkTmp('forgeon-module-unknown-');
-    try {
-      createMinimalForgeonProject(targetRoot);
-      assert.throws(
-        () =>
-          addModule({
-            moduleId: 'unknown-module',
-            targetRoot,
-            packageRoot,
-          }),
-        /Unknown module/,
-      );
+      const compose = fs.readFileSync(path.join(projectRoot, 'infra', 'docker', 'compose.yml'), 'utf8');
+      assert.match(compose, /I18N_ENABLED/);
+
+      const appTsx = fs.readFileSync(path.join(projectRoot, 'apps', 'web', 'src', 'App.tsx'), 'utf8');
+      assert.match(appTsx, /@forgeon\/i18n-web/);
+      assert.match(appTsx, /Language:/);
     } finally {
       fs.rmSync(targetRoot, { recursive: true, force: true });
     }