aegisnode 0.0.5 → 0.1.1

package/scripts/smoke-test.js

@@ -136,14 +136,29 @@ async function main() {
   const dotenvSandboxRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aegisnode-dotenv-'));
   const httpsSandboxRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aegisnode-https-'));
   const proxySandboxRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aegisnode-proxy-'));
+  const typescriptSandboxRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aegisnode-ts-'));
 
-  await startProject({ projectName, cwd: sandboxRoot });
+  await fs.mkdir(projectRoot, { recursive: true });
+  await startProject({ projectName, cwd: projectRoot });
   const generatedProjectEnv = await fs.readFile(path.join(projectRoot, '.env'), 'utf8');
   assert.match(generatedProjectEnv, /^APP_SECRET=.{16,}$/m);
   const generatedAppSecret = generatedProjectEnv.match(/^APP_SECRET=(.+)$/m)?.[1]?.trim();
   assert.ok(generatedAppSecret);
   const generatedSettings = await fs.readFile(path.join(projectRoot, 'settings.js'), 'utf8');
+  assert.ok(generatedSettings.includes("staticDir: 'public'"));
+  assert.ok(generatedSettings.includes("templates: {\n    enabled: true,\n    engine: 'ejs',\n    dir: 'templates',\n    base: 'base',\n  }"));
   assert.ok(generatedSettings.includes(`appSecret: process.env.APP_SECRET || ${JSON.stringify(generatedAppSecret)}`));
+  const generatedConfig = await loadProjectConfig(projectRoot);
+  assert.equal(generatedConfig.security.ddos.maxRequests, 300);
+  await fs.access(path.join(projectRoot, 'public'));
+  await fs.access(path.join(projectRoot, 'templates'));
+  const nonEmptyProjectRoot = path.join(sandboxRoot, 'non-empty-project');
+  await fs.mkdir(nonEmptyProjectRoot, { recursive: true });
+  await fs.writeFile(path.join(nonEmptyProjectRoot, 'keep.txt'), 'occupied', 'utf8');
+  await assert.rejects(
+    () => startProject({ projectName: 'busy', cwd: nonEmptyProjectRoot }),
+    /Current directory is not empty/,
+  );
   await assert.rejects(
     () => runProject({
       rootDir: projectRoot,
@@ -155,9 +170,73 @@ async function main() {
     /started with "aegisnode runserver"/,
   );
 
+  const tsProjectName = 'forumts';
+  const tsProjectRoot = path.join(typescriptSandboxRoot, tsProjectName);
+  await fs.mkdir(tsProjectRoot, { recursive: true });
+  await startProject({ projectName: tsProjectName, cwd: tsProjectRoot, typescript: true });
+  await fs.access(path.join(tsProjectRoot, 'app.ts'));
+  await fs.access(path.join(tsProjectRoot, 'settings.ts'));
+  await fs.access(path.join(tsProjectRoot, 'routes.ts'));
+  await fs.access(path.join(tsProjectRoot, 'tsconfig.json'));
+  await fs.access(path.join(tsProjectRoot, 'public'));
+  await fs.access(path.join(tsProjectRoot, 'templates'));
+  const tsPackageJson = JSON.parse(await fs.readFile(path.join(tsProjectRoot, 'package.json'), 'utf8'));
+  assert.equal(tsPackageJson.scripts.test, 'node --import tsx/esm --test');
+  assert.equal(tsPackageJson.scripts.typecheck, 'tsc --noEmit');
+  assert.equal(tsPackageJson.devDependencies.tsx, '^4.21.0');
+  assert.equal(tsPackageJson.devDependencies.typescript, '^5.9.3');
+  const tsConfig = await loadProjectConfig(tsProjectRoot);
+  assert.equal(tsConfig.appName, 'forumts');
+  await createApp({
+    appName: 'users',
+    projectRoot: tsProjectRoot,
+    mount: '/users',
+  });
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'routes.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'views.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'models.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'validators.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'services.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'utils.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'subscribers.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'tests', 'models.test.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'tests', 'validators.test.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'tests', 'services.test.ts'));
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'tests', 'routes.test.ts'));
+  await generateArtifact({
+    type: 'view',
+    name: 'profile',
+    appName: 'users',
+    projectRoot: tsProjectRoot,
+  });
+  await fs.access(path.join(tsProjectRoot, 'apps', 'users', 'profile.view.ts'));
+  await generateArtifact({
+    type: 'route',
+    name: 'profile',
+    appName: 'users',
+    projectRoot: tsProjectRoot,
+  });
+  const tsUsersRoutesFile = await fs.readFile(path.join(tsProjectRoot, 'apps', 'users', 'routes.ts'), 'utf8');
+  assert.match(tsUsersRoutesFile, /import ProfileView from '\.\/profile\.view\.ts';/);
+  assert.match(tsUsersRoutesFile, /route\.get\('\/profile', ProfileView\.index\);/);
+  const tsDoctorReport = await runDoctor({
+    projectRoot: tsProjectRoot,
+    failOnError: true,
+    output: {
+      log() {},
+    },
+  });
+  assert.equal(tsDoctorReport.summary.errors, 0);
+  const tsServer = await runServer({
+    projectRoot: tsProjectRoot,
+    port: 0,
+  });
+  await tsServer.stop();
+
   const envProjectName = 'envdemo';
   const envProjectRoot = path.join(envSandboxRoot, envProjectName);
-  await startProject({ projectName: envProjectName, cwd: envSandboxRoot });
+  await fs.mkdir(envProjectRoot, { recursive: true });
+  await startProject({ projectName: envProjectName, cwd: envProjectRoot });
   await fs.writeFile(
     path.join(envProjectRoot, 'settings.js'),
     `export default {
@@ -210,7 +289,8 @@ async function main() {
 
   const dotenvProjectName = 'dotenvdemo';
   const dotenvProjectRoot = path.join(dotenvSandboxRoot, dotenvProjectName);
-  await startProject({ projectName: dotenvProjectName, cwd: dotenvSandboxRoot });
+  await fs.mkdir(dotenvProjectRoot, { recursive: true });
+  await startProject({ projectName: dotenvProjectName, cwd: dotenvProjectRoot });
   await fs.writeFile(
     path.join(dotenvProjectRoot, '.env'),
     `AEGIS_TEST_HOST=127.0.0.1
@@ -245,7 +325,8 @@ AEGIS_TEST_APP_SECRET=test-dotenv-secret
 
   const httpsProjectName = 'httpsdemo';
   const httpsProjectRoot = path.join(httpsSandboxRoot, httpsProjectName);
-  await startProject({ projectName: httpsProjectName, cwd: httpsSandboxRoot });
+  await fs.mkdir(httpsProjectRoot, { recursive: true });
+  await startProject({ projectName: httpsProjectName, cwd: httpsProjectRoot });
   await fs.mkdir(path.join(httpsProjectRoot, 'certs'), { recursive: true });
   await fs.writeFile(
     path.join(httpsProjectRoot, 'certs', 'localhost-key.pem'),
@@ -328,7 +409,8 @@ dkcqnJD4SGWVeG+KhA==
 
   const proxyProjectName = 'proxydemo';
   const proxyProjectRoot = path.join(proxySandboxRoot, proxyProjectName);
-  await startProject({ projectName: proxyProjectName, cwd: proxySandboxRoot });
+  await fs.mkdir(proxyProjectRoot, { recursive: true });
+  await startProject({ projectName: proxyProjectName, cwd: proxyProjectRoot });
   await fs.writeFile(
     path.join(proxyProjectRoot, 'routes.js'),
     `export default {\n  register(route) {\n    route.get('/secure-check', (req, res) => {\n      res.json({ secure: req.secure, protocol: req.protocol });\n    });\n  },\n};\n`,

package/src/cli/commands/createapp.js

@@ -1,5 +1,5 @@
 import { ensureValidName, normalizeMountPath } from '../utils/fs.js';
-import { resolveProjectRoot } from '../utils/project.js';
+import { getProjectSourceExtension, resolveProjectRoot } from '../utils/project.js';
 import {
   detectSettingsMode,
   ensureAppScaffold,
@@ -12,6 +12,7 @@ export async function createApp({ appName, projectRoot, mount }) {
   ensureValidName(appName, 'app');
 
   const resolvedRoot = await resolveProjectRoot(projectRoot);
+  const sourceExtension = getProjectSourceExtension(resolvedRoot);
   const settingsMode = await detectSettingsMode(resolvedRoot);
   const normalizedMount = normalizeMountPath(mount || `/${appName}`);
   const existingApps = await readAppsConfig(settingsMode);
@@ -20,9 +21,9 @@ export async function createApp({ appName, projectRoot, mount }) {
     throw new Error(`App "${appName}" already exists in project settings`);
   }
 
-  await ensureAppScaffold(resolvedRoot, appName);
+  await ensureAppScaffold(resolvedRoot, appName, { sourceExtension });
   await updateAppRegistry(resolvedRoot, [...existingApps, { name: appName, mount: normalizedMount }], settingsMode);
-  await updateProjectRoutesFile(resolvedRoot, appName, normalizedMount);
+  await updateProjectRoutesFile(resolvedRoot, appName, normalizedMount, sourceExtension);
 
   console.log(`App "${appName}" created at ${resolvedRoot}/apps/${appName}`);
 }

package/src/cli/commands/doctor.js

@@ -2,8 +2,10 @@ import fs from 'fs/promises';
 import path from 'path';
 import { loadProjectConfig } from '../../runtime/config.js';
 import { ensureValidName } from '../utils/fs.js';
-import { resolveProjectRoot } from '../utils/project.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 = [];
@@ -34,6 +36,9 @@ function escapeRegExp(value) {
 
 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) {
@@ -52,7 +57,6 @@ async function runAppChecks(rootDir, config, collector, targetAppName = null) {
     collector.ok(`Declared apps: ${apps.map((app) => app.name).join(', ')}`);
   }
 
-  const routesFile = path.join(rootDir, 'routes.js');
   const routesFileExists = await fileExists(routesFile);
   const routesContent = routesFileExists ? await fs.readFile(routesFile, 'utf8') : '';
   const targetApps = targetAppName ? [targetAppName] : apps;
@@ -79,7 +83,7 @@ async function runAppChecks(rootDir, config, collector, targetAppName = null) {
       continue;
     }
 
-    for (const entry of getAppScaffoldEntries(appName)) {
+    for (const entry of getAppScaffoldEntries(appName, sourceExtension)) {
       const target = path.join(rootDir, entry.target);
       if (!(await fileExists(target))) {
         collector.warn(`App "${appName}" missing ${path.relative(appRoot, target)}.`);
@@ -96,37 +100,39 @@ async function runAppChecks(rootDir, config, collector, targetAppName = null) {
     }
 
     if (!routesFileExists) {
-      collector.warn(`Project routes.js is missing; app "${appName}" cannot be mounted centrally.`);
+      collector.warn(`Project ${routesLabel} is missing; app "${appName}" cannot be mounted centrally.`);
       continue;
     }
 
-    const importPath = `./apps/${appName}/routes.js`;
+    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 routes.js is missing import for app "${appName}".`);
+      collector.warn(`Project ${routesLabel} is missing import for app "${appName}".`);
     }
 
     if (!routePattern.test(routesContent)) {
-      collector.warn(`Project routes.js is missing route.use(...) mount for app "${appName}".`);
+      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) {

package/src/cli/commands/fixapp.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import { ensureValidName, normalizeMountPath } from '../utils/fs.js';
-import { resolveProjectRoot } from '../utils/project.js';
+import { getProjectSourceExtension, resolveProjectRoot } from '../utils/project.js';
+import { withSourceExtension } from '../utils/scaffolds.js';
 import {
   detectSettingsMode,
   ensureAppScaffold,
@@ -17,12 +18,16 @@ export async function runFixApp({ appName, projectRoot, mount } = {}) {
   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 });
+  const scaffoldResult = await ensureAppScaffold(resolvedRoot, appName, {
+    overwrite: false,
+    sourceExtension,
+  });
 
   let registryUpdated = false;
   if (!existingApp) {
@@ -34,7 +39,7 @@ export async function runFixApp({ appName, projectRoot, mount } = {}) {
     registryUpdated = true;
   }
 
-  const routesResult = await updateProjectRoutesFile(resolvedRoot, appName, appMount);
+  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) {
@@ -48,7 +53,7 @@ export async function runFixApp({ appName, projectRoot, mount } = {}) {
       console.log(`Added app "${appName}" to settings.apps with mount ${appMount}`);
     }
     if (routesResult.updatedImport || routesResult.updatedRoute) {
-      console.log(`Updated routes.js registration for app "${appName}"`);
+      console.log(`Updated ${path.basename(routesResult.routesFile || withSourceExtension('routes', sourceExtension))} registration for app "${appName}"`);
     }
   }
 

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() {
@@ -33,40 +35,45 @@ async function assertCanCreateProject(projectDir) {
 
   const empty = await isDirectoryEmpty(projectDir);
   if (!empty) {
-    throw new Error(`Directory already exists and is not empty: ${projectDir}`);
+    throw new Error(`Current directory is not empty: ${projectDir}. Create and enter an empty project directory before running "aegisnode startproject".`);
   }
 }
 
-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')),
+    ensureDir(path.join(projectRoot, 'public')),
+    ensureDir(path.join(projectRoot, 'templates')),
   ]);
 
-  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);
+  const projectRoot = path.resolve(cwd);
   await assertCanCreateProject(projectRoot);
-  await createBaseProjectFiles(projectRoot, projectName);
+  await createBaseProjectFiles(projectRoot, projectName, { typescript });
 
-  console.log(`AegisNode project created at ${projectRoot}`);
+  console.log(`AegisNode project created in ${projectRoot}`);
   console.log('Next steps:');
-  console.log(`  cd ${projectName}`);
   console.log('  npm install');
   console.log('  aegisnode runserver');
 }

package/src/cli/index.js

@@ -11,7 +11,7 @@ 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>]
@@ -21,17 +21,18 @@ Usage:
   aegisnode updatedeps [--project <path>]
 
 Examples:
+  mkdir blog && cd blog
   aegisnode startproject blog
-  cd blog
+  aegisnode startproject blog --typescript
   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
+  aegisnode generateloader
+  aegisnode doctor --app users
+  aegisnode updatedeps
 `);
 }
 
@@ -70,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;
@@ -101,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;
     }