fastnode-cli 0.6.0 → 0.6.2

package/dist/index.js

@@ -7,160 +7,265 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const [, , command, resource, name] = process.argv;
+const [, , command, resource, name, moduleName] = process.argv;
 if (command === "create" && resource) {
     createProject(resource);
 }
 else if (command === "serve" && resource) {
     serveProject(resource);
 }
+else if (command === "build") {
+    buildProject();
+}
 else if (command === "generate" && resource === "controller" && name) {
-    generateController(name);
+    generateController(name, moduleName);
 }
 else {
     printUsage();
 }
 function createProject(projectName) {
     const projectDir = path_1.default.resolve(projectName);
-    const moduleDir = path_1.default.join(projectDir, "src", projectName);
-    fs_1.default.mkdirSync(moduleDir, { recursive: true });
-    fs_1.default.writeFileSync(path_1.default.join(moduleDir, "main.ts"), buildMainTemplate(projectName));
+    const srcDir = path_1.default.join(projectDir, "src");
+    const constantsDir = path_1.default.join(srcDir, "constants");
+    const controllersDir = path_1.default.join(srcDir, "controllers");
+    const servicesDir = path_1.default.join(srcDir, "services");
+    const helpersDir = path_1.default.join(srcDir, "helpers");
+    fs_1.default.mkdirSync(constantsDir, { recursive: true });
+    fs_1.default.mkdirSync(controllersDir, { recursive: true });
+    fs_1.default.mkdirSync(servicesDir, { recursive: true });
+    fs_1.default.mkdirSync(helpersDir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(srcDir, "main.ts"), buildMainTemplate());
+    fs_1.default.writeFileSync(path_1.default.join(srcDir, "app.module.ts"), buildAppModuleTemplate(projectName));
+    fs_1.default.writeFileSync(path_1.default.join(controllersDir, "app.controller.ts"), buildAppControllerTemplate(projectName));
+    fs_1.default.writeFileSync(path_1.default.join(constantsDir, "config.ts"), buildConfigTemplate());
     fs_1.default.writeFileSync(path_1.default.join(projectDir, "tsconfig.json"), `{
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "CommonJS",
-    "rootDir": "./src",
-    "outDir": "./dist",
+    "target": "ES2022",
+    "module": "es2022",
+    "moduleResolution": "bundler",
+    "rootDir": "src",
+    "outDir": "dist",
     "strict": true,
     "esModuleInterop": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
-    "useDefineForClassFields": false
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "types": ["node"]
   },
-  "include": ["src"]
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
 }
 `);
     fs_1.default.writeFileSync(path_1.default.join(projectDir, "package.json"), `{
   "name": "${projectName}",
   "version": "1.0.0",
-  "type": "commonjs",
-  "main": "dist/index.js",
+  "type": "module",
   "scripts": {
-    "dev": "tsx src/${projectName}/main.ts",
-    "build": "tsc",
-    "start": "node dist/${projectName}/main.js"
+    "dev": "tsx watch src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/main.js"
   },
   "dependencies": {
-    "fastnode-core": "latest",
-    "reflect-metadata": "^0.1.13"
+    "fastnode-core": "^0.6.1",
+    "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "tsx": "^4.7.0",
-    "typescript": "^5.0.0"
+    "@types/node": "^24.12.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
   }
 }
 `);
-    console.log(`✔ Project '${projectName}' created at ${projectDir}`);
+    console.log(`Project '${projectName}' created at ${projectDir}`);
 }
 function serveProject(projectName) {
-    const entry = path_1.default.resolve(process.cwd(), `src/${projectName}/main.ts`);
+    const entry = path_1.default.resolve(process.cwd(), "src", "main.ts");
     if (!fs_1.default.existsSync(entry)) {
-        console.error(`❌ Cannot find module at ${entry}`);
-        process.exit(1);
+        fail(`Cannot find module at ${entry}`);
     }
     (0, child_process_1.execSync)(`npx tsx ${entry}`, { stdio: "inherit" });
 }
-function generateController(controllerName) {
+function buildProject() {
+    const errors = validateProjectConfiguration();
+    if (errors.length > 0) {
+        printValidationErrors(errors);
+        process.exit(1);
+    }
+    try {
+        clearBuildOutput();
+        (0, child_process_1.execSync)("npx tsc -p tsconfig.json", { stdio: "inherit" });
+        console.log("Build completed successfully.");
+    }
+    catch (error) {
+        console.error("Build failed.");
+        if (error instanceof Error && error.message) {
+            console.error(error.message);
+        }
+        process.exit(1);
+    }
+}
+function clearBuildOutput() {
+    const distDir = path_1.default.resolve(process.cwd(), "dist");
+    if (!fs_1.default.existsSync(distDir)) {
+        return;
+    }
+    fs_1.default.rmSync(distDir, { recursive: true, force: true });
+}
+function generateController(controllerName, moduleName) {
     const normalizedName = toKebabCase(controllerName);
     const className = `${toPascalCase(controllerName)}Controller`;
-    const controllerDir = path_1.default.resolve(process.cwd(), "src", normalizedName);
+    const moduleFile = resolveModuleFile(moduleName);
+    const controllerDir = path_1.default.resolve(process.cwd(), "src", "controllers");
     const controllerFile = path_1.default.join(controllerDir, `${normalizedName}.controller.ts`);
     fs_1.default.mkdirSync(controllerDir, { recursive: true });
     if (fs_1.default.existsSync(controllerFile)) {
-        console.error(`❌ Controller already exists at ${controllerFile}`);
-        process.exit(1);
+        fail(`Controller already exists at ${controllerFile}`);
     }
     fs_1.default.writeFileSync(controllerFile, buildControllerTemplate(normalizedName));
-    console.log(`✔ Controller '${normalizedName}' created at ${controllerFile}`);
-    console.log(`ℹ Add ${className} to a module so FastNode can register it.`);
+    updateModuleControllers(moduleFile, className, normalizedName);
+    console.log(`Controller '${normalizedName}' created at ${controllerFile}`);
+    console.log(`Added ${className} to ${path_1.default.basename(moduleFile)}.`);
 }
-function buildMainTemplate(projectName) {
-    const className = `${toPascalCase(projectName)}Controller`;
-    const moduleName = `${toPascalCase(projectName)}Module`;
+function validateProjectConfiguration() {
+    const errors = [];
+    const packageJsonPath = path_1.default.resolve(process.cwd(), "package.json");
+    const tsconfigPath = path_1.default.resolve(process.cwd(), "tsconfig.json");
+    const mainFilePath = path_1.default.resolve(process.cwd(), "src", "main.ts");
+    const packageJson = readJsonFile(packageJsonPath, "package.json", errors);
+    const tsconfig = readJsonFile(tsconfigPath, "tsconfig.json", errors);
+    if (!fs_1.default.existsSync(mainFilePath)) {
+        errors.push(`Missing entry file: ${mainFilePath}`);
+    }
+    validatePackageJson(packageJson, errors);
+    validateTsconfig(tsconfig, errors);
+    return errors;
+}
+function validatePackageJson(packageJson, errors) {
+    if (!packageJson) {
+        return;
+    }
+    const scripts = asRecord(packageJson.scripts);
+    const dependencies = asRecord(packageJson.dependencies);
+    const devDependencies = asRecord(packageJson.devDependencies);
+    if (packageJson.type !== "module") {
+        errors.push(`package.json: expected "type" to be "module".`);
+    }
+    if (typeof scripts?.build !== "string" || !scripts.build.includes("tsc")) {
+        errors.push(`package.json: expected scripts.build to run TypeScript, for example "tsc -p tsconfig.json".`);
+    }
+    if (typeof dependencies?.["fastnode-core"] !== "string") {
+        errors.push(`package.json: missing dependency "fastnode-core".`);
+    }
+    else if (!hasLocalInstalledPackage("fastnode-core")) {
+        errors.push(`package.json: dependency "fastnode-core" is not installed. Run npm install.`);
+    }
+    if (typeof dependencies?.["reflect-metadata"] !== "string") {
+        errors.push(`package.json: missing dependency "reflect-metadata".`);
+    }
+    else if (!hasLocalInstalledPackage("reflect-metadata")) {
+        errors.push(`package.json: dependency "reflect-metadata" is not installed. Run npm install.`);
+    }
+    if (typeof devDependencies?.typescript !== "string") {
+        errors.push(`package.json: missing devDependency "typescript".`);
+    }
+    else if (!hasLocalInstalledPackage("typescript")) {
+        errors.push(`package.json: devDependency "typescript" is not installed. Run npm install.`);
+    }
+}
+function validateTsconfig(tsconfig, errors) {
+    if (!tsconfig) {
+        return;
+    }
+    const compilerOptions = asRecord(tsconfig.compilerOptions);
+    if (!compilerOptions) {
+        errors.push(`tsconfig.json: missing compilerOptions.`);
+        return;
+    }
+    if (compilerOptions.rootDir !== "src") {
+        errors.push(`tsconfig.json: expected compilerOptions.rootDir to be "src".`);
+    }
+    if (compilerOptions.outDir !== "dist") {
+        errors.push(`tsconfig.json: expected compilerOptions.outDir to be "dist".`);
+    }
+    if (compilerOptions.moduleResolution !== "bundler") {
+        errors.push(`tsconfig.json: expected compilerOptions.moduleResolution to be "bundler".`);
+    }
+    if (compilerOptions.experimentalDecorators !== true) {
+        errors.push(`tsconfig.json: expected compilerOptions.experimentalDecorators to be true.`);
+    }
+    if (compilerOptions.emitDecoratorMetadata !== true) {
+        errors.push(`tsconfig.json: expected compilerOptions.emitDecoratorMetadata to be true.`);
+    }
+    if (compilerOptions.module !== "es2022" &&
+        compilerOptions.module !== "ES2022") {
+        errors.push(`tsconfig.json: expected compilerOptions.module to be "es2022".`);
+    }
+}
+function readJsonFile(filePath, label, errors) {
+    if (!fs_1.default.existsSync(filePath)) {
+        errors.push(`Missing ${label} at ${filePath}`);
+        return undefined;
+    }
+    try {
+        const content = fs_1.default.readFileSync(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown JSON parsing error.";
+        errors.push(`Invalid ${label}: ${message}`);
+        return undefined;
+    }
+}
+function printValidationErrors(errors) {
+    console.error("FastNode build validation failed.");
+    console.error("");
+    for (const error of errors) {
+        console.error(`- ${error}`);
+    }
+    console.error("");
+    console.error("Update your package.json and tsconfig.json, then run `fastnode build` again.");
+}
+function buildMainTemplate() {
     return `import "reflect-metadata";
-import {
-  Body,
-  Context,
-  Controller,
-  EmitToClient,
-  ExecutionPolicy,
-  Get,
-  Module,
-  Param,
-  Post,
-  Query,
-  SocketController,
-  Subscribe,
-  createApp,
-} from "fastnode-core";
-
-@Controller("/${projectName}")
-@ExecutionPolicy({ timeout: 5000 })
-class ${className} {
-  @Get("/")
-  async hello(
-    @Query("name") name?: string,
-    @Context() ctx?: any
-  ) {
-    await ctx?.sleep(25);
+import { createApp } from "fastnode-core";
+import { AppModule } from "./app.module.js";
+import { API_CONFIG } from "./constants/config.js";
 
-    return {
-      message: \`Hello from ${projectName}\${name ? \`, \${name}\` : ""}\`,
-      deadline: ctx?.snapshot?.().deadline,
-    };
-  }
+export const app = createApp([AppModule], {
 
-  @Get("/{item_id}")
-  getOne(
-    @Param("item_id") itemId: number,
-    @Query("include") include?: string
-  ) {
-    return {
-      item_id: itemId,
-      include,
-    };
-  }
+}).listen({ port: API_CONFIG.port, host: API_CONFIG.host });
+`;
+}
+function buildAppModuleTemplate(projectName) {
+    const controllerName = `${toPascalCase(projectName)}Controller`;
+    return `import { Module } from "fastnode-core";
+import { ${controllerName} } from "./controllers/app.controller.js";
 
-  @Post("/")
-  create() {
-    return {
-      created: true,
-    };
-  }
+@Module({ controllers: [${controllerName}] })
+export class AppModule {}
+`;
 }
+function buildAppControllerTemplate(projectName) {
+    const className = `${toPascalCase(projectName)}Controller`;
+    return `import { Controller, Get } from "fastnode-core";
 
-@SocketController("/chat")
-class ${toPascalCase(projectName)}SocketController {
-  @Subscribe("ping")
-  @EmitToClient()
-  ping(@Body("message") message?: string) {
+@Controller("/")
+export class ${className} {
+  @Get("/")
+  getHello() {
     return {
-      message: message ?? "pong",
+      message: "Hello from ${projectName}",
     };
   }
 }
-
-@Module({ controllers: [${className}, ${toPascalCase(projectName)}SocketController] })
-class ${moduleName} {}
-
-// Drop files into ./static to serve them automatically, for example static/logo.png -> /logo.png.
-// Upload routes can use @Upload() and @File() to save files under ./static/uploads by default.
-createApp([${moduleName}], {
-  executionPolicy: {
-    timeout: 30000,
-    mode: "inline",
-  },
-}).listen(3000);
+`;
+}
+function buildConfigTemplate() {
+    return `export const API_CONFIG = {
+  host: "0.0.0.0",
+  port: 3000,
+};
 `;
 }
 function buildControllerTemplate(controllerName) {
@@ -169,8 +274,8 @@ function buildControllerTemplate(controllerName) {
   Body,
   Controller,
   Get,
-  Post,
   Param,
+  Post,
   Query,
 } from "fastnode-core";
 
@@ -212,6 +317,85 @@ export class ${className} {
 }
 `;
 }
+function resolveModuleFile(moduleName) {
+    const srcDir = path_1.default.resolve(process.cwd(), "src");
+    if (!fs_1.default.existsSync(srcDir)) {
+        fail(`Cannot find src directory at ${srcDir}`);
+    }
+    if (!moduleName) {
+        const defaultModuleFile = path_1.default.join(srcDir, "app.module.ts");
+        if (!fs_1.default.existsSync(defaultModuleFile)) {
+            fail(`Cannot find default module at ${defaultModuleFile}`);
+        }
+        return defaultModuleFile;
+    }
+    const expectedFileName = `${toKebabCase(moduleName)}.module.ts`;
+    const moduleFile = findFileRecursive(srcDir, expectedFileName);
+    if (!moduleFile) {
+        fail(`Cannot find module '${moduleName}'. Expected ${expectedFileName} under ${srcDir}`);
+    }
+    return moduleFile;
+}
+function findFileRecursive(dir, fileName) {
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const match = findFileRecursive(fullPath, fileName);
+            if (match) {
+                return match;
+            }
+        }
+        else if (entry.isFile() && entry.name === fileName) {
+            return fullPath;
+        }
+    }
+    return undefined;
+}
+function updateModuleControllers(moduleFile, controllerClassName, controllerName) {
+    const controllerFile = path_1.default.resolve(process.cwd(), "src", "controllers", `${controllerName}.controller.ts`);
+    const importStatement = `import { ${controllerClassName} } from "${buildRelativeImportPath(moduleFile, controllerFile)}";`;
+    let moduleSource = fs_1.default.readFileSync(moduleFile, "utf8");
+    if (!moduleSource.includes(importStatement)) {
+        moduleSource = `${importStatement}\n${moduleSource}`;
+    }
+    const controllersMatch = moduleSource.match(/controllers\s*:\s*\[([\s\S]*?)\]/);
+    if (!controllersMatch) {
+        fail(`Could not find a controllers array inside ${moduleFile}`);
+    }
+    const existingControllers = controllersMatch[1]
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (!existingControllers.includes(controllerClassName)) {
+        existingControllers.push(controllerClassName);
+    }
+    moduleSource = moduleSource.replace(/controllers\s*:\s*\[[\s\S]*?\]/, `controllers: [${existingControllers.join(", ")}]`);
+    fs_1.default.writeFileSync(moduleFile, moduleSource);
+}
+function buildRelativeImportPath(fromFile, toFile) {
+    const relativePath = path_1.default
+        .relative(path_1.default.dirname(fromFile), toFile)
+        .replace(/\\/g, "/")
+        .replace(/\.ts$/, ".js");
+    if (relativePath.startsWith(".")) {
+        return relativePath;
+    }
+    return `./${relativePath}`;
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function hasLocalInstalledPackage(packageName) {
+    return fs_1.default.existsSync(path_1.default.resolve(process.cwd(), "node_modules", packageName));
+}
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
 function capitalize(value) {
     return value.charAt(0).toUpperCase() + value.slice(1);
 }
@@ -234,6 +418,7 @@ function printUsage() {
 Usage:
   fastnode create <project-name>
   fastnode serve <project-name>
-  fastnode generate controller <controller-name>
+  fastnode build
+  fastnode generate controller <controller-name> [module-name]
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastnode-cli",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "The official CLI for scaffolding and serving FastNode applications.",
   "bin": {
     "fastnode": "dist/index.js"
@@ -25,7 +25,7 @@
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^11.0.0",
-    "fastnode-core": "^0.6.0",
+    "fastnode-core": "^0.6.1",
     "reflect-metadata": "^0.1.13"
   },
   "devDependencies": {