aegisnode 0.0.4 → 0.1.0

package/src/cli/commands/doctor.js

@@ -1,7 +1,11 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { loadProjectConfig } from '../../runtime/config.js';
-import { resolveProjectRoot } from '../utils/project.js';
+import { ensureValidName } from '../utils/fs.js';
+import { getProjectSourceExtension, resolveProjectRoot } from '../utils/project.js';
+import { getAppScaffoldEntries, toImportName } from '../utils/apps.js';
+import { withSourceExtension } from '../utils/scaffolds.js';
+import { resolveSourceFile } from '../../utils/source-files.js';
 
 function createCollector() {
   const entries = [];
@@ -26,25 +30,49 @@ async function fileExists(filePath) {
   }
 }
 
-async function runAppChecks(rootDir, config, collector) {
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+async function runAppChecks(rootDir, config, collector, targetAppName = null) {
   const apps = Array.isArray(config.apps) ? config.apps : [];
+  const sourceExtension = getProjectSourceExtension(rootDir);
+  const routesFile = resolveSourceFile(path.join(rootDir, 'routes'), [sourceExtension]) || resolveSourceFile(path.join(rootDir, 'routes'));
+  const routesLabel = routesFile ? path.basename(routesFile) : withSourceExtension('routes', sourceExtension);
+  const declaredApps = new Map();
+
+  for (const app of apps) {
+    const appName = app?.name;
+    if (typeof appName === 'string' && appName.trim().length > 0) {
+      declaredApps.set(appName, app);
+    }
+  }
 
-  if (apps.length === 0) {
+  if (!targetAppName && apps.length === 0) {
     collector.warn('No apps declared in settings.apps.');
     return;
   }
 
-  collector.ok(`Declared apps: ${apps.map((app) => app.name).join(', ')}`);
+  if (!targetAppName) {
+    collector.ok(`Declared apps: ${apps.map((app) => app.name).join(', ')}`);
+  }
 
-  for (const app of apps) {
-    const appName = app?.name;
+  const routesFileExists = await fileExists(routesFile);
+  const routesContent = routesFileExists ? await fs.readFile(routesFile, 'utf8') : '';
+  const targetApps = targetAppName ? [targetAppName] : apps;
+
+  for (const appEntry of targetApps) {
+    const appName = targetAppName || appEntry?.name;
+    const app = targetAppName ? declaredApps.get(appName) || null : appEntry;
     const mount = app?.mount;
     if (typeof appName !== 'string' || appName.trim().length === 0) {
-      collector.error(`Invalid app entry: ${JSON.stringify(app)}`);
+      collector.error(`Invalid app entry: ${JSON.stringify(appEntry)}`);
       continue;
     }
 
-    if (typeof mount !== 'string' || !mount.startsWith('/')) {
+    if (!app) {
+      collector.warn(`App "${appName}" is not declared in settings.apps.`);
+    } else if (typeof mount !== 'string' || !mount.startsWith('/')) {
       collector.error(`App "${appName}" has invalid mount "${String(mount)}" (must start with /).`);
     }
 
@@ -55,34 +83,56 @@ async function runAppChecks(rootDir, config, collector) {
       continue;
     }
 
-    const requiredFiles = ['routes.js', 'views.js', 'services.js', 'models.js', 'validators.js'];
-    for (const fileName of requiredFiles) {
-      const target = path.join(appRoot, fileName);
+    for (const entry of getAppScaffoldEntries(appName, sourceExtension)) {
+      const target = path.join(rootDir, entry.target);
       if (!(await fileExists(target))) {
-        collector.warn(`App "${appName}" missing ${fileName}.`);
+        collector.warn(`App "${appName}" missing ${path.relative(appRoot, target)}.`);
       }
     }
 
-    const subscribersFile = path.join(appRoot, 'subscribers.js');
-    if (!(await fileExists(subscribersFile))) {
-      collector.warn(`App "${appName}" missing subscribers.js.`);
+    if (!app) {
+      continue;
+    }
+
+    if (config.autoMountApps === true) {
+      collector.ok(`App "${appName}" will be mounted automatically from settings.apps.`);
+      continue;
+    }
+
+    if (!routesFileExists) {
+      collector.warn(`Project ${routesLabel} is missing; app "${appName}" cannot be mounted centrally.`);
+      continue;
+    }
+
+    const importPath = `./apps/${appName}/routes${sourceExtension}`;
+    const importName = toImportName(appName);
+    const routePattern = new RegExp(`route\\.use\\([^\\n]*,\\s*${escapeRegExp(importName)}\\s*\\);`);
+
+    if (!routesContent.includes(importPath)) {
+      collector.warn(`Project ${routesLabel} is missing import for app "${appName}".`);
+    }
+
+    if (!routePattern.test(routesContent)) {
+      collector.warn(`Project ${routesLabel} is missing route.use(...) mount for app "${appName}".`);
     }
   }
 }
 
 async function runStartupEntryChecks(rootDir, config, collector) {
   const env = String(config.env || process.env.NODE_ENV || 'development').trim().toLowerCase();
-  const appEntryPath = path.join(rootDir, 'app.js');
+  const sourceExtension = getProjectSourceExtension(rootDir);
+  const appEntryPath = resolveSourceFile(path.join(rootDir, 'app'), [sourceExtension])
+    || path.join(rootDir, withSourceExtension('app', sourceExtension));
   const loaderEntryPath = path.join(rootDir, 'loader.cjs');
   const appEntryExists = await fileExists(appEntryPath);
   const loaderEntryExists = await fileExists(loaderEntryPath);
 
   if (appEntryExists) {
-    collector.ok('app.js exists.');
+    collector.ok(`${path.basename(appEntryPath)} exists.`);
   } else if (env === 'production') {
-    collector.error('app.js is missing for production startup. Run "aegisnode generateloader" to restore startup entry files.');
+    collector.error(`${path.basename(appEntryPath)} is missing for production startup. Run "aegisnode generateloader" to restore startup entry files.`);
   } else {
-    collector.warn('app.js is missing. Run "aegisnode generateloader" to restore startup entry files.');
+    collector.warn(`${path.basename(appEntryPath)} is missing. Run "aegisnode generateloader" to restore startup entry files.`);
   }
 
   if (loaderEntryExists) {
@@ -193,7 +243,12 @@ export async function runDoctor({
   projectRoot,
   failOnError = true,
   output = console,
+  appName = null,
 } = {}) {
+  if (appName) {
+    ensureValidName(appName, 'app');
+  }
+
   const resolvedRoot = await resolveProjectRoot(projectRoot || process.cwd());
   const collector = createCollector();
 
@@ -202,12 +257,17 @@ export async function runDoctor({
   const config = await loadProjectConfig(resolvedRoot);
   collector.ok(`Environment: ${config.env || 'development'}`);
 
-  await runAppChecks(resolvedRoot, config, collector);
-  await runStartupEntryChecks(resolvedRoot, config, collector);
-  runSecurityChecks(config, collector);
-  runAuthChecks(config, collector);
-  runApiChecks(config, collector);
-  await runTemplateChecks(resolvedRoot, config, collector);
+  if (appName) {
+    collector.ok(`Doctor scope: app "${appName}"`);
+    await runAppChecks(resolvedRoot, config, collector, appName);
+  } else {
+    await runAppChecks(resolvedRoot, config, collector);
+    await runStartupEntryChecks(resolvedRoot, config, collector);
+    runSecurityChecks(config, collector);
+    runAuthChecks(config, collector);
+    runApiChecks(config, collector);
+    await runTemplateChecks(resolvedRoot, config, collector);
+  }
 
   const summary = printSummary(collector.entries, output);
 

package/src/cli/commands/fixapp.js

@@ -0,0 +1,70 @@
+import path from 'path';
+import { ensureValidName, normalizeMountPath } from '../utils/fs.js';
+import { getProjectSourceExtension, resolveProjectRoot } from '../utils/project.js';
+import { withSourceExtension } from '../utils/scaffolds.js';
+import {
+  detectSettingsMode,
+  ensureAppScaffold,
+  readAppsConfig,
+  updateAppRegistry,
+  updateProjectRoutesFile,
+} from '../utils/apps.js';
+
+export async function runFixApp({ appName, projectRoot, mount } = {}) {
+  if (!appName) {
+    throw new Error('Missing app name. Usage: aegisnode fix --app <app-name>');
+  }
+
+  ensureValidName(appName, 'app');
+
+  const resolvedRoot = await resolveProjectRoot(projectRoot || process.cwd());
+  const sourceExtension = getProjectSourceExtension(resolvedRoot);
+  const settingsMode = await detectSettingsMode(resolvedRoot);
+  const existingApps = await readAppsConfig(settingsMode);
+  const existingApp = existingApps.find((entry) => entry.name === appName) || null;
+  const appMount = existingApp?.mount || normalizeMountPath(mount || `/${appName}`);
+
+  const scaffoldResult = await ensureAppScaffold(resolvedRoot, appName, {
+    overwrite: false,
+    sourceExtension,
+  });
+
+  let registryUpdated = false;
+  if (!existingApp) {
+    await updateAppRegistry(
+      resolvedRoot,
+      [...existingApps, { name: appName, mount: appMount }],
+      settingsMode,
+    );
+    registryUpdated = true;
+  }
+
+  const routesResult = await updateProjectRoutesFile(resolvedRoot, appName, appMount, sourceExtension);
+  const relativeWritten = scaffoldResult.written.map((target) => path.relative(resolvedRoot, target));
+
+  if (relativeWritten.length === 0 && !registryUpdated && !routesResult.updatedImport && !routesResult.updatedRoute) {
+    console.log(`App "${appName}" is already complete.`);
+  } else {
+    console.log(`App "${appName}" repaired at ${resolvedRoot}/apps/${appName}`);
+    if (relativeWritten.length > 0) {
+      console.log(`Created missing files: ${relativeWritten.join(', ')}`);
+    }
+    if (registryUpdated) {
+      console.log(`Added app "${appName}" to settings.apps with mount ${appMount}`);
+    }
+    if (routesResult.updatedImport || routesResult.updatedRoute) {
+      console.log(`Updated ${path.basename(routesResult.routesFile || withSourceExtension('routes', sourceExtension))} registration for app "${appName}"`);
+    }
+  }
+
+  return {
+    rootDir: resolvedRoot,
+    appName,
+    mount: appMount,
+    createdFiles: scaffoldResult.written,
+    skippedFiles: scaffoldResult.skipped,
+    registryUpdated,
+    routesUpdated: routesResult.updatedImport || routesResult.updatedRoute,
+    routesFile: routesResult.routesFile,
+  };
+}

package/src/cli/commands/generate.js

@@ -1,7 +1,9 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { ensureValidName, exists, writeFile } from '../utils/fs.js';
-import { toPascalCase } from '../utils/scaffolds.js';
+import { toPascalCase, withSourceExtension } from '../utils/scaffolds.js';
+import { getProjectSourceExtension } from '../utils/project.js';
+import { resolveSourceFile, resolveSourceIndexFile } from '../../utils/source-files.js';
 
 const SUPPORTED_TYPES = new Set(['view', 'controller', 'model', 'validator', 'dto', 'service', 'subscriber', 'route']);
 
@@ -22,12 +24,14 @@ function assertType(type) {
 }
 
 async function assertProjectRoot(projectRoot) {
-  const hasSingleSettings = await exists(path.join(projectRoot, 'settings.js'));
-  const hasLegacySettings = (await exists(path.join(projectRoot, 'settings', 'index.js')))
-    || (await exists(path.join(projectRoot, 'settings', 'apps.js')));
+  const hasSingleSettings = Boolean(resolveSourceFile(path.join(projectRoot, 'settings')));
+  const hasLegacySettings = Boolean(
+    resolveSourceIndexFile(path.join(projectRoot, 'settings'))
+    || resolveSourceFile(path.join(projectRoot, 'settings', 'apps')),
+  );
 
   if (!hasSingleSettings && !hasLegacySettings) {
-    throw new Error('Not an AegisNode project root: missing settings.js');
+    throw new Error('Not an AegisNode project root: missing settings.js/settings.ts');
   }
 }
 
@@ -110,35 +114,35 @@ function renderSubscriber(name, appName) {
 `;
 }
 
-async function getAppRoutesFile(appRoot) {
-  const primary = path.join(appRoot, 'routes.js');
-  if (await exists(primary)) {
+async function getAppRoutesFile(appRoot, sourceExtension) {
+  const primary = resolveSourceFile(path.join(appRoot, 'routes'), [sourceExtension]) || resolveSourceFile(path.join(appRoot, 'routes'));
+  if (primary && await exists(primary)) {
     return primary;
   }
 
-  const legacy = path.join(appRoot, 'routes', 'index.js');
-  if (await exists(legacy)) {
+  const legacy = resolveSourceIndexFile(path.join(appRoot, 'routes'), [sourceExtension]) || resolveSourceIndexFile(path.join(appRoot, 'routes'));
+  if (legacy && await exists(legacy)) {
     return legacy;
   }
 
-  throw new Error(`Missing app routes file in ${appRoot}. Expected routes.js or routes/index.js`);
+  throw new Error(`Missing app routes file in ${appRoot}. Expected routes${sourceExtension} or routes/index${sourceExtension}`);
 }
 
-async function appendRouteToApp({ appRoot, routeName }) {
-  const routesFile = await getAppRoutesFile(appRoot);
-  const usesFlatRoutesFile = path.basename(routesFile) === 'routes.js';
-  const flatViewPath = path.join(appRoot, `${routeName}.view.js`);
-  const nestedViewPath = path.join(appRoot, 'views', `${routeName}.view.js`);
+async function appendRouteToApp({ appRoot, routeName, sourceExtension }) {
+  const routesFile = await getAppRoutesFile(appRoot, sourceExtension);
+  const usesFlatRoutesFile = path.basename(routesFile) === withSourceExtension('routes', sourceExtension);
+  const flatViewPath = path.join(appRoot, `${routeName}.view${sourceExtension}`);
+  const nestedViewPath = path.join(appRoot, 'views', `${routeName}.view${sourceExtension}`);
 
   let importPath = null;
   if (await exists(flatViewPath)) {
     importPath = usesFlatRoutesFile
-      ? `./${routeName}.view.js`
-      : `../${routeName}.view.js`;
+      ? `./${routeName}.view${sourceExtension}`
+      : `../${routeName}.view${sourceExtension}`;
   } else if (await exists(nestedViewPath)) {
     importPath = usesFlatRoutesFile
-      ? `./views/${routeName}.view.js`
-      : `../views/${routeName}.view.js`;
+      ? `./views/${routeName}.view${sourceExtension}`
+      : `../views/${routeName}.view${sourceExtension}`;
   } else {
     throw new Error(`Missing view for route generation: ${flatViewPath} (or ${nestedViewPath}). Create it first with generate view ${routeName}.`);
   }
@@ -193,18 +197,18 @@ async function appendRouteToApp({ appRoot, routeName }) {
   return routesFile;
 }
 
-function resolveTarget(appRoot, type, name) {
+function resolveTarget(appRoot, type, name, sourceExtension) {
   switch (type) {
     case 'view':
-      return path.join(appRoot, `${name}.view.js`);
+      return path.join(appRoot, `${name}.view${sourceExtension}`);
     case 'model':
-      return path.join(appRoot, `${name}.model.js`);
+      return path.join(appRoot, `${name}.model${sourceExtension}`);
     case 'service':
-      return path.join(appRoot, `${name}.service.js`);
+      return path.join(appRoot, `${name}.service${sourceExtension}`);
     case 'validator':
-      return path.join(appRoot, `${name}.validator.js`);
+      return path.join(appRoot, `${name}.validator${sourceExtension}`);
     case 'subscriber':
-      return path.join(appRoot, `${name}.subscriber.js`);
+      return path.join(appRoot, `${name}.subscriber${sourceExtension}`);
     default:
       throw new Error(`Unsupported type: ${type}`);
   }
@@ -248,14 +252,15 @@ export async function generateArtifact({ type, name, appName, projectRoot }) {
   const resolvedRoot = path.resolve(projectRoot);
   await assertProjectRoot(resolvedRoot);
   const appRoot = await assertAppRoot(resolvedRoot, appName);
+  const sourceExtension = getProjectSourceExtension(resolvedRoot);
 
   if (normalizedType === 'route') {
-    const routesFile = await appendRouteToApp({ appRoot, routeName: name });
+    const routesFile = await appendRouteToApp({ appRoot, routeName: name, sourceExtension });
     console.log(`Generated route /${name} in ${routesFile}`);
     return;
   }
 
-  const targetFile = resolveTarget(appRoot, normalizedType, name);
+  const targetFile = resolveTarget(appRoot, normalizedType, name, sourceExtension);
   if (await exists(targetFile)) {
     throw new Error(`File already exists: ${targetFile}`);
   }

package/src/cli/commands/generateloader.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import { exists, writeFile } from '../utils/fs.js';
-import { resolveProjectRoot } from '../utils/project.js';
-import { renderProjectAppJs, renderProjectLoaderCjs } from '../utils/scaffolds.js';
+import { getProjectSourceExtension, resolveProjectRoot } from '../utils/project.js';
+import { renderProjectAppJs, renderProjectLoaderCjs, withSourceExtension } from '../utils/scaffolds.js';
 
 async function ensureStartupFile(rootDir, fileName, content, output) {
   const target = path.join(rootDir, fileName);
@@ -20,8 +20,14 @@ export async function runGenerateLoader({
   output = console,
 } = {}) {
   const resolvedRoot = await resolveProjectRoot(projectRoot || process.cwd());
-  const createdApp = await ensureStartupFile(resolvedRoot, 'app.js', renderProjectAppJs(), output);
-  const createdLoader = await ensureStartupFile(resolvedRoot, 'loader.cjs', renderProjectLoaderCjs(), output);
+  const sourceExtension = getProjectSourceExtension(resolvedRoot);
+  const createdApp = await ensureStartupFile(
+    resolvedRoot,
+    withSourceExtension('app', sourceExtension),
+    renderProjectAppJs(),
+    output,
+  );
+  const createdLoader = await ensureStartupFile(resolvedRoot, 'loader.cjs', renderProjectLoaderCjs(sourceExtension), output);
 
   if (!createdApp && !createdLoader) {
     output.log(`Startup entry files already exist in ${resolvedRoot}`);

package/src/cli/commands/startproject.js

@@ -10,6 +10,8 @@ import {
   renderProjectPackageJson,
   renderProjectRoutes,
   renderProjectSettings,
+  renderTsConfig,
+  withSourceExtension,
 } from '../utils/scaffolds.js';
 
 async function createSecret() {
@@ -37,32 +39,36 @@ async function assertCanCreateProject(projectDir) {
   }
 }
 
-async function createBaseProjectFiles(projectRoot, projectName) {
+async function createBaseProjectFiles(projectRoot, projectName, { typescript = false } = {}) {
   const apps = [];
   const appSecret = await createSecret();
+  const sourceExtension = typescript ? '.ts' : '.js';
 
   await ensureDir(projectRoot);
   await Promise.all([
     ensureDir(path.join(projectRoot, 'apps')),
   ]);
 
-  await writeFile(path.join(projectRoot, 'app.js'), renderProjectAppJs());
-  await writeFile(path.join(projectRoot, 'loader.cjs'), renderProjectLoaderCjs());
-  await writeFile(path.join(projectRoot, 'package.json'), renderProjectPackageJson(projectName));
+  await writeFile(path.join(projectRoot, withSourceExtension('app', sourceExtension)), renderProjectAppJs());
+  await writeFile(path.join(projectRoot, 'loader.cjs'), renderProjectLoaderCjs(sourceExtension));
+  await writeFile(path.join(projectRoot, 'package.json'), renderProjectPackageJson(projectName, { typescript }));
   await writeFile(path.join(projectRoot, '.gitignore'), renderProjectGitIgnore());
   await writeFile(path.join(projectRoot, '.env'), renderProjectEnv(appSecret));
   await writeFile(path.join(projectRoot, '.env.example'), renderEnvExample());
 
-  await writeFile(path.join(projectRoot, 'settings.js'), renderProjectSettings(projectName, apps, appSecret));
-  await writeFile(path.join(projectRoot, 'routes.js'), renderProjectRoutes());
+  await writeFile(path.join(projectRoot, withSourceExtension('settings', sourceExtension)), renderProjectSettings(projectName, apps, appSecret));
+  await writeFile(path.join(projectRoot, withSourceExtension('routes', sourceExtension)), renderProjectRoutes());
+  if (typescript) {
+    await writeFile(path.join(projectRoot, 'tsconfig.json'), renderTsConfig());
+  }
 }
 
-export async function startProject({ projectName, cwd }) {
+export async function startProject({ projectName, cwd, typescript = false }) {
   ensureValidName(projectName, 'project');
 
   const projectRoot = path.resolve(cwd, projectName);
   await assertCanCreateProject(projectRoot);
-  await createBaseProjectFiles(projectRoot, projectName);
+  await createBaseProjectFiles(projectRoot, projectName, { typescript });
 
   console.log(`AegisNode project created at ${projectRoot}`);
   console.log('Next steps:');

package/src/cli/index.js

@@ -5,28 +5,33 @@ import { generateArtifact } from './commands/generate.js';
 import { runDoctor } from './commands/doctor.js';
 import { runUpdateDependencies } from './commands/updatedeps.js';
 import { runGenerateLoader } from './commands/generateloader.js';
+import { runFixApp } from './commands/fixapp.js';
 
 function printHelp() {
   console.log(`AegisNode CLI
 
 Usage:
-  aegisnode startproject <project-name>
+  aegisnode startproject <project-name> [--typescript]
   aegisnode createapp <app-name> [--project <path>] [--mount </path>]
+  aegisnode fix [--app <app-name>] [--project <path>]
   aegisnode generate <type> <name> --app <app-name> [--project <path>]
   aegisnode runserver [--project <path>] [--port <number>]
   aegisnode generateloader [--project <path>]
-  aegisnode doctor [--project <path>]
+  aegisnode doctor [--app <app-name>] [--project <path>]
   aegisnode updatedeps [--project <path>]
 
 Examples:
   aegisnode startproject blog
+  aegisnode startproject blog --typescript
   cd blog
   npm install
   aegisnode runserver
   aegisnode createapp users
+  aegisnode fix --app users
   aegisnode generate view user --app users
   aegisnode generate validator user --app users
   aegisnode generateloader --project blog
+  aegisnode doctor --app users --project blog
   aegisnode updatedeps --project blog
 `);
 }
@@ -66,6 +71,11 @@ function parseFlags(tokens) {
       continue;
     }
 
+    if (token === '--typescript' || token === '--ts') {
+      flags.typescript = true;
+      continue;
+    }
+
     if (token === '-h' || token === '--help') {
       flags.help = true;
       continue;
@@ -97,7 +107,11 @@ export async function runCli(argv) {
       if (!projectName) {
         throw new Error('Missing project name. Usage: aegisnode startproject <project-name>');
       }
-      await startProject({ projectName, cwd: process.cwd() });
+      await startProject({
+        projectName,
+        cwd: process.cwd(),
+        typescript: flags.typescript === true,
+      });
       return;
     }
 
@@ -123,8 +137,24 @@ export async function runCli(argv) {
     }
 
     case 'doctor': {
+      if (positional.length > 0) {
+        throw new Error('Doctor app target must use --app <app-name>. Usage: aegisnode doctor [--app <app-name>] [--project <path>]');
+      }
       await runDoctor({
         projectRoot: flags.project ? String(flags.project) : process.cwd(),
+        appName: flags.app ? String(flags.app) : null,
+      });
+      return;
+    }
+
+    case 'fix':
+    case 'fixapp': {
+      if (positional.length > 0) {
+        throw new Error('Fix app target must use --app <app-name>. Usage: aegisnode fix [--app <app-name>] [--project <path>]');
+      }
+      await runFixApp({
+        appName: flags.app ? String(flags.app) : undefined,
+        projectRoot: flags.project ? String(flags.project) : process.cwd(),
       });
       return;
     }