aegisnode 0.0.1

package/src/cli/commands/createapp.js

@@ -0,0 +1,191 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { ensureDir, ensureValidName, exists, normalizeMountPath, writeFile } from '../utils/fs.js';
+import { resolveProjectRoot } from '../utils/project.js';
+import {
+  renderAppRoutes,
+  renderAppViewsFile,
+  renderAppModelsFile,
+  renderAppValidatorsFile,
+  renderAppServicesFile,
+  renderAppSubscribersFile,
+  renderAppModelTest,
+  renderAppValidatorTest,
+  renderAppServiceTest,
+  renderAppRoutesTest,
+  renderSettingsApps,
+} from '../utils/scaffolds.js';
+
+const APPS_START = '// AEGIS_APPS_START';
+const APPS_END = '// AEGIS_APPS_END';
+
+function renderAppEntries(apps) {
+  return apps
+    .map((app) => `    { name: ${JSON.stringify(app.name)}, mount: ${JSON.stringify(app.mount)} },`)
+    .join('\n');
+}
+
+function toImportName(appName) {
+  const safe = appName
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+
+  if (!safe) {
+    return 'appRoutes';
+  }
+
+  return `${safe.charAt(0).toLowerCase()}${safe.slice(1)}`;
+}
+
+async function readDefaultExport(filePath) {
+  const moduleUrl = `${pathToFileURL(filePath).href}?t=${Date.now()}`;
+  const loaded = await import(moduleUrl);
+  return loaded?.default;
+}
+
+async function detectSettingsMode(projectRoot) {
+  const single = path.join(projectRoot, 'settings.js');
+  const split = path.join(projectRoot, 'settings', 'apps.js');
+
+  if (await exists(single)) {
+    return { mode: 'single', file: single };
+  }
+
+  if (await exists(split)) {
+    return { mode: 'split', file: split };
+  }
+
+  throw new Error(`Not an AegisNode project root: missing ${single} (or legacy ${split})`);
+}
+
+async function readAppsConfig(settingsMode) {
+  const normalizeApp = (entry) => {
+    if (!entry || typeof entry !== 'object' || typeof entry.name !== 'string') {
+      return null;
+    }
+
+    ensureValidName(entry.name, 'app');
+    return {
+      name: entry.name,
+      mount: normalizeMountPath(entry.mount || `/${entry.name}`),
+    };
+  };
+
+  if (settingsMode.mode === 'single') {
+    const settings = await readDefaultExport(settingsMode.file);
+    const apps = settings?.apps;
+
+    if (!Array.isArray(apps)) {
+      throw new Error(`settings.js must export { apps: [] }. File: ${settingsMode.file}`);
+    }
+
+    return apps.map(normalizeApp).filter(Boolean);
+  }
+
+  const apps = await readDefaultExport(settingsMode.file);
+  if (!Array.isArray(apps)) {
+    throw new Error(`settings/apps.js must export an array. File: ${settingsMode.file}`);
+  }
+
+  return apps.map(normalizeApp).filter(Boolean);
+}
+
+async function updateSingleSettingsApps(settingsFile, apps) {
+  const current = await fs.readFile(settingsFile, 'utf8');
+
+  if (!current.includes(APPS_START) || !current.includes(APPS_END)) {
+    throw new Error(`settings.js is missing ${APPS_START}/${APPS_END} markers: ${settingsFile}`);
+  }
+
+  const replacement = `${APPS_START}\n${renderAppEntries(apps)}\n    ${APPS_END}`;
+  const updated = current.replace(/\/\/ AEGIS_APPS_START[\s\S]*?\/\/ AEGIS_APPS_END/m, replacement);
+
+  await writeFile(settingsFile, updated);
+}
+
+async function updateAppRegistry(projectRoot, apps, settingsMode) {
+  if (settingsMode.mode === 'single') {
+    await updateSingleSettingsApps(settingsMode.file, apps);
+    return;
+  }
+
+  await writeFile(path.join(projectRoot, 'settings', 'apps.js'), renderSettingsApps(apps));
+}
+
+async function updateProjectRoutesFile(projectRoot, appName, mountPath) {
+  const routesFile = path.join(projectRoot, 'routes.js');
+  if (!(await exists(routesFile))) {
+    // Keep backward compatibility for legacy projects that still use routes/index.js.
+    return;
+  }
+
+  const importName = toImportName(appName);
+  const importLine = `import ${importName} from './apps/${appName}/routes.js';`;
+  const routeLine = `    route.use(${JSON.stringify(mountPath)}, ${importName});`;
+
+  let content = await fs.readFile(routesFile, 'utf8');
+
+  if (!content.includes(importLine)) {
+    if (content.includes('// AEGIS_APP_IMPORTS_START') && content.includes('// AEGIS_APP_IMPORTS_END')) {
+      content = content.replace('// AEGIS_APP_IMPORTS_END', `${importLine}\n// AEGIS_APP_IMPORTS_END`);
+    } else {
+      content = `${importLine}\n${content}`;
+    }
+  }
+
+  if (!content.includes(routeLine)) {
+    if (content.includes('// AEGIS_PROJECT_APP_ROUTES_START') && content.includes('// AEGIS_PROJECT_APP_ROUTES_END')) {
+      content = content.replace('    // AEGIS_PROJECT_APP_ROUTES_END', `${routeLine}\n    // AEGIS_PROJECT_APP_ROUTES_END`);
+    } else {
+      const match = content.match(/register\s*\([^)]*\)\s*{[\s\S]*?\n\s*}/m);
+      if (match) {
+        content = content.replace(match[0], `${match[0]}\n${routeLine}`);
+      }
+    }
+  }
+
+  await writeFile(routesFile, content);
+}
+
+async function createScaffold(projectRoot, appName) {
+  const appRoot = path.join(projectRoot, 'apps', appName);
+
+  await ensureDir(appRoot);
+  await ensureDir(path.join(appRoot, 'tests'));
+
+  await writeFile(path.join(appRoot, 'views.js'), renderAppViewsFile(appName));
+  await writeFile(path.join(appRoot, 'models.js'), renderAppModelsFile(appName));
+  await writeFile(path.join(appRoot, 'validators.js'), renderAppValidatorsFile(appName));
+  await writeFile(path.join(appRoot, 'services.js'), renderAppServicesFile(appName));
+  await writeFile(path.join(appRoot, 'subscribers.js'), renderAppSubscribersFile(appName));
+  await writeFile(path.join(appRoot, 'routes.js'), renderAppRoutes(appName));
+  await writeFile(path.join(appRoot, 'tests', 'models.test.js'), renderAppModelTest(appName));
+  await writeFile(path.join(appRoot, 'tests', 'validators.test.js'), renderAppValidatorTest(appName));
+  await writeFile(path.join(appRoot, 'tests', 'services.test.js'), renderAppServiceTest(appName));
+  await writeFile(path.join(appRoot, 'tests', 'routes.test.js'), renderAppRoutesTest(appName));
+}
+
+export async function createApp({ appName, projectRoot, mount }) {
+  ensureValidName(appName, 'app');
+
+  const resolvedRoot = await resolveProjectRoot(projectRoot);
+
+  const settingsMode = await detectSettingsMode(resolvedRoot);
+  const normalizedMount = normalizeMountPath(mount || `/${appName}`);
+  const existingApps = await readAppsConfig(settingsMode);
+
+  if (existingApps.some((entry) => entry.name === appName)) {
+    throw new Error(`App \"${appName}\" already exists in project settings`);
+  }
+
+  const updatedApps = [...existingApps, { name: appName, mount: normalizedMount }];
+
+  await createScaffold(resolvedRoot, appName);
+  await updateAppRegistry(resolvedRoot, updatedApps, settingsMode);
+  await updateProjectRoutesFile(resolvedRoot, appName, normalizedMount);
+
+  console.log(`App \"${appName}\" created at ${path.join(resolvedRoot, 'apps', appName)}`);
+}

package/src/cli/commands/doctor.js

@@ -0,0 +1,199 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadProjectConfig } from '../../runtime/config.js';
+import { resolveProjectRoot } from '../utils/project.js';
+
+function createCollector() {
+  const entries = [];
+  return {
+    entries,
+    ok: (message) => entries.push({ level: 'OK', message }),
+    warn: (message) => entries.push({ level: 'WARN', message }),
+    error: (message) => entries.push({ level: 'ERROR', message }),
+  };
+}
+
+function hasStrongSecret(value) {
+  return typeof value === 'string' && value.trim().length >= 16;
+}
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function runAppChecks(rootDir, config, collector) {
+  const apps = Array.isArray(config.apps) ? config.apps : [];
+
+  if (apps.length === 0) {
+    collector.warn('No apps declared in settings.apps.');
+    return;
+  }
+
+  collector.ok(`Declared apps: ${apps.map((app) => app.name).join(', ')}`);
+
+  for (const app of apps) {
+    const appName = app?.name;
+    const mount = app?.mount;
+    if (typeof appName !== 'string' || appName.trim().length === 0) {
+      collector.error(`Invalid app entry: ${JSON.stringify(app)}`);
+      continue;
+    }
+
+    if (typeof mount !== 'string' || !mount.startsWith('/')) {
+      collector.error(`App "${appName}" has invalid mount "${String(mount)}" (must start with /).`);
+    }
+
+    const appRoot = path.join(rootDir, 'apps', appName);
+    const appRootExists = await fileExists(appRoot);
+    if (!appRootExists) {
+      collector.error(`App directory missing: apps/${appName}`);
+      continue;
+    }
+
+    const requiredFiles = ['routes.js', 'views.js', 'services.js', 'models.js', 'validators.js'];
+    for (const fileName of requiredFiles) {
+      const target = path.join(appRoot, fileName);
+      if (!(await fileExists(target))) {
+        collector.warn(`App "${appName}" missing ${fileName}.`);
+      }
+    }
+
+    const subscribersFile = path.join(appRoot, 'subscribers.js');
+    if (!(await fileExists(subscribersFile))) {
+      collector.warn(`App "${appName}" missing subscribers.js.`);
+    }
+  }
+}
+
+function runSecurityChecks(config, collector) {
+  const env = String(config.env || process.env.NODE_ENV || 'development');
+  const security = config.security || {};
+
+  if (!hasStrongSecret(security.appSecret)) {
+    if (env === 'production') {
+      collector.error('security.appSecret is missing/weak for production (min length: 16).');
+    } else {
+      collector.warn('security.appSecret is missing/weak (recommended min length: 16).');
+    }
+  } else {
+    collector.ok('security.appSecret is set.');
+  }
+
+  if (security?.headers?.enabled === false) {
+    collector.warn('security.headers.enabled is false.');
+  }
+  if (security?.csrf?.enabled === false) {
+    collector.warn('security.csrf.enabled is false.');
+  }
+  if (security?.ddos?.enabled === false) {
+    collector.warn('security.ddos.enabled is false.');
+  }
+}
+
+function runAuthChecks(config, collector) {
+  const auth = config.auth || {};
+  if (auth.enabled !== true) {
+    collector.ok('Auth subsystem disabled.');
+    return;
+  }
+
+  collector.ok(`Auth subsystem enabled (${auth.provider || 'jwt'}).`);
+
+  if (auth.provider === 'jwt') {
+    const jwtSecret = auth?.jwt?.secret;
+    const appSecret = config?.security?.appSecret;
+    if (!hasStrongSecret(jwtSecret) && !hasStrongSecret(appSecret)) {
+      collector.error('JWT enabled but neither auth.jwt.secret nor security.appSecret is strong.');
+    }
+  }
+
+  if (auth.provider === 'oauth2' && config.env === 'production') {
+    if (auth?.oauth2?.server?.allowHttp === true) {
+      collector.error('OAuth2 server allowHttp=true in production.');
+    }
+  }
+}
+
+function runApiChecks(config, collector) {
+  const apiApps = Array.isArray(config?.api?.apps) ? config.api.apps : [];
+  const appNames = new Set((Array.isArray(config.apps) ? config.apps : []).map((app) => app.name));
+
+  for (const apiAppName of apiApps) {
+    if (!appNames.has(apiAppName)) {
+      collector.warn(`api.apps references unknown app "${apiAppName}".`);
+    }
+  }
+}
+
+async function runTemplateChecks(rootDir, config, collector) {
+  const templates = config.templates || {};
+  if (templates.enabled === false) {
+    collector.ok('Templates disabled.');
+    return;
+  }
+
+  const templatesDir = typeof templates.dir === 'string' && templates.dir.trim().length > 0
+    ? templates.dir.trim()
+    : 'templates';
+  const templatesRoot = path.isAbsolute(templatesDir)
+    ? templatesDir
+    : path.join(rootDir, templatesDir);
+
+  if (!(await fileExists(templatesRoot))) {
+    collector.warn(`Template directory does not exist: ${templatesRoot}`);
+  } else {
+    collector.ok(`Template directory exists: ${templatesRoot}`);
+  }
+}
+
+function printSummary(entries, output = console) {
+  for (const entry of entries) {
+    output.log(`[${entry.level}] ${entry.message}`);
+  }
+
+  const errors = entries.filter((item) => item.level === 'ERROR').length;
+  const warnings = entries.filter((item) => item.level === 'WARN').length;
+  const oks = entries.filter((item) => item.level === 'OK').length;
+
+  output.log('');
+  output.log(`Doctor summary: ${errors} error(s), ${warnings} warning(s), ${oks} ok.`);
+  return { errors, warnings, oks };
+}
+
+export async function runDoctor({
+  projectRoot,
+  failOnError = true,
+  output = console,
+} = {}) {
+  const resolvedRoot = await resolveProjectRoot(projectRoot || process.cwd());
+  const collector = createCollector();
+
+  collector.ok(`Project root: ${resolvedRoot}`);
+
+  const config = await loadProjectConfig(resolvedRoot);
+  collector.ok(`Environment: ${config.env || 'development'}`);
+
+  await runAppChecks(resolvedRoot, config, collector);
+  runSecurityChecks(config, collector);
+  runAuthChecks(config, collector);
+  runApiChecks(config, collector);
+  await runTemplateChecks(resolvedRoot, config, collector);
+
+  const summary = printSummary(collector.entries, output);
+
+  if (failOnError && summary.errors > 0) {
+    throw new Error('Doctor failed with configuration errors.');
+  }
+
+  return {
+    rootDir: resolvedRoot,
+    config,
+    entries: collector.entries,
+    summary,
+  };
+}

package/src/cli/commands/generate.js

@@ -0,0 +1,266 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { ensureValidName, exists, writeFile } from '../utils/fs.js';
+import { toPascalCase } from '../utils/scaffolds.js';
+
+const SUPPORTED_TYPES = new Set(['view', 'controller', 'model', 'validator', 'dto', 'service', 'subscriber', 'route']);
+
+function normalizeType(type) {
+  if (type === 'controller') {
+    return 'view';
+  }
+  if (type === 'dto') {
+    return 'validator';
+  }
+  return type;
+}
+
+function assertType(type) {
+  if (!SUPPORTED_TYPES.has(type)) {
+    throw new Error(`Unsupported generate type \"${type}\". Supported: ${Array.from(SUPPORTED_TYPES).join(', ')}`);
+  }
+}
+
+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')));
+
+  if (!hasSingleSettings && !hasLegacySettings) {
+    throw new Error('Not an AegisNode project root: missing settings.js');
+  }
+}
+
+async function assertAppRoot(projectRoot, appName) {
+  const appRoot = path.join(projectRoot, 'apps', appName);
+  if (!(await exists(appRoot))) {
+    throw new Error(`App \"${appName}\" does not exist. Create it first with: aegisnode createapp ${appName}`);
+  }
+  return appRoot;
+}
+
+function renderView(name, appName) {
+  const className = `${toPascalCase(name)}View`;
+  return `class ${className} {
+  static index(req, res) {
+    res.json({
+      app: '${appName}',
+      view: '${name}',
+      message: 'Generated by AegisNode',
+    });
+  }
+}
+
+export default ${className};
+`;
+}
+
+function renderModel(name) {
+  const className = `${toPascalCase(name)}Model`;
+  return `class ${className} {
+  constructor({ dbClient }) {
+    this.dbClient = dbClient;
+  }
+}
+
+export default ${className};
+`;
+}
+
+function renderService(name) {
+  const className = `${toPascalCase(name)}Service`;
+  return `class ${className} {
+  constructor({ models }) {
+    this.models = models;
+  }
+}
+
+export default ${className};
+`;
+}
+
+function renderValidator(name) {
+  const className = `${toPascalCase(name)}Validator`;
+  return `class ${className} {
+  normalize(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+      const error = new Error('Payload must be an object.');
+      error.statusCode = 400;
+      throw error;
+    }
+    return payload;
+  }
+}
+
+export default ${className};
+`;
+}
+
+function renderSubscriber(name, appName) {
+  const fnName = `register${toPascalCase(name)}Subscriber`;
+  return `export default function ${fnName}({ events, logger }) {
+  events.subscribe('app.booted', ({ appName: mountedApp }) => {
+    if (mountedApp !== '${appName}') {
+      return;
+    }
+
+    logger.debug('[subscriber:${name}] ${appName} booted');
+  });
+}
+`;
+}
+
+async function getAppRoutesFile(appRoot) {
+  const primary = path.join(appRoot, 'routes.js');
+  if (await exists(primary)) {
+    return primary;
+  }
+
+  const legacy = path.join(appRoot, 'routes', 'index.js');
+  if (await exists(legacy)) {
+    return legacy;
+  }
+
+  throw new Error(`Missing app routes file in ${appRoot}. Expected routes.js or routes/index.js`);
+}
+
+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`);
+
+  let importPath = null;
+  if (await exists(flatViewPath)) {
+    importPath = usesFlatRoutesFile
+      ? `./${routeName}.view.js`
+      : `../${routeName}.view.js`;
+  } else if (await exists(nestedViewPath)) {
+    importPath = usesFlatRoutesFile
+      ? `./views/${routeName}.view.js`
+      : `../views/${routeName}.view.js`;
+  } else {
+    throw new Error(`Missing view for route generation: ${flatViewPath} (or ${nestedViewPath}). Create it first with generate view ${routeName}.`);
+  }
+
+  const viewClass = `${toPascalCase(routeName)}View`;
+  const importLine = `import ${viewClass} from '${importPath}';`;
+  const routeLine = `    route.get('/${routeName}', ${viewClass}.index);`;
+
+  let content = await fs.readFile(routesFile, 'utf8');
+
+  if (!content.includes(importLine)) {
+    const lines = content.split('\n');
+    let lastImportIndex = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+      if (lines[i].startsWith('import ')) {
+        lastImportIndex = i;
+      }
+    }
+
+    if (lastImportIndex >= 0) {
+      lines.splice(lastImportIndex + 1, 0, importLine);
+    } else {
+      lines.unshift(importLine);
+    }
+    content = lines.join('\n');
+  }
+
+  if (!content.includes(routeLine)) {
+    const markerEnd = '    // AEGIS_APP_EXTRA_ROUTES_END';
+    if (content.includes(markerEnd)) {
+      content = content.replace(markerEnd, `${routeLine}\n${markerEnd}`);
+    } else {
+      const lines = content.split('\n');
+      let closeIndex = -1;
+      for (let i = lines.length - 1; i >= 0; i -= 1) {
+        if (lines[i].trim() === '},' || lines[i].trim() === '})' || lines[i].trim() === '};') {
+          closeIndex = i;
+          break;
+        }
+      }
+
+      if (closeIndex < 0) {
+        throw new Error(`Cannot auto-wire route in ${routesFile}. Could not find object block end.`);
+      }
+
+      lines.splice(closeIndex, 0, routeLine);
+      content = lines.join('\n');
+    }
+  }
+
+  await writeFile(routesFile, content);
+  return routesFile;
+}
+
+function resolveTarget(appRoot, type, name) {
+  switch (type) {
+    case 'view':
+      return path.join(appRoot, `${name}.view.js`);
+    case 'model':
+      return path.join(appRoot, `${name}.model.js`);
+    case 'service':
+      return path.join(appRoot, `${name}.service.js`);
+    case 'validator':
+      return path.join(appRoot, `${name}.validator.js`);
+    case 'subscriber':
+      return path.join(appRoot, `${name}.subscriber.js`);
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+}
+
+function renderContent(type, name, appName) {
+  switch (type) {
+    case 'view':
+      return renderView(name, appName);
+    case 'model':
+      return renderModel(name);
+    case 'service':
+      return renderService(name);
+    case 'validator':
+      return renderValidator(name);
+    case 'subscriber':
+      return renderSubscriber(name, appName);
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+}
+
+export async function generateArtifact({ type, name, appName, projectRoot }) {
+  if (!type) {
+    throw new Error('Missing generate type. Usage: aegisnode generate <type> <name> --app <app-name>');
+  }
+
+  if (!name) {
+    throw new Error('Missing artifact name. Usage: aegisnode generate <type> <name> --app <app-name>');
+  }
+
+  if (!appName) {
+    throw new Error('Missing app name. Use --app <app-name>');
+  }
+
+  assertType(type);
+  const normalizedType = normalizeType(type);
+  ensureValidName(name, normalizedType);
+  ensureValidName(appName, 'app');
+
+  const resolvedRoot = path.resolve(projectRoot);
+  await assertProjectRoot(resolvedRoot);
+  const appRoot = await assertAppRoot(resolvedRoot, appName);
+
+  if (normalizedType === 'route') {
+    const routesFile = await appendRouteToApp({ appRoot, routeName: name });
+    console.log(`Generated route /${name} in ${routesFile}`);
+    return;
+  }
+
+  const targetFile = resolveTarget(appRoot, normalizedType, name);
+  if (await exists(targetFile)) {
+    throw new Error(`File already exists: ${targetFile}`);
+  }
+
+  await writeFile(targetFile, renderContent(normalizedType, name, appName));
+
+  console.log(`Generated ${normalizedType}: ${targetFile}`);
+}

package/src/cli/commands/runserver.js

@@ -0,0 +1,17 @@
+import { runProject } from '../../index.js';
+import { resolveProjectRoot } from '../utils/project.js';
+
+export async function runServer({ projectRoot, port }) {
+  const resolvedRoot = await resolveProjectRoot(projectRoot);
+  const overrides = {};
+
+  if (Number.isFinite(port) && port >= 0) {
+    overrides.port = Number(port);
+  }
+
+  return runProject({
+    rootDir: resolvedRoot,
+    overrides,
+    startupSource: 'runserver',
+  });
+}