fastnode-cli 0.6.0 → 0.6.1

package/dist/index.js

@@ -7,7 +7,7 @@ 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);
 }
@@ -15,152 +15,131 @@ else if (command === "serve" && resource) {
     serveProject(resource);
 }
 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}`);
+        console.error(`Cannot find module at ${entry}`);
         process.exit(1);
     }
     (0, child_process_1.execSync)(`npx tsx ${entry}`, { stdio: "inherit" });
 }
-function generateController(controllerName) {
+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}`);
+        console.error(`Controller already exists at ${controllerFile}`);
         process.exit(1);
     }
     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 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 +148,8 @@ function buildControllerTemplate(controllerName) {
   Body,
   Controller,
   Get,
-  Post,
   Param,
+  Post,
   Query,
 } from "fastnode-core";
 
@@ -212,6 +191,76 @@ export class ${className} {
 }
 `;
 }
+function resolveModuleFile(moduleName) {
+    const srcDir = path_1.default.resolve(process.cwd(), "src");
+    if (!fs_1.default.existsSync(srcDir)) {
+        console.error(`Cannot find src directory at ${srcDir}`);
+        process.exit(1);
+    }
+    if (!moduleName) {
+        const defaultModuleFile = path_1.default.join(srcDir, "app.module.ts");
+        if (!fs_1.default.existsSync(defaultModuleFile)) {
+            console.error(`Cannot find default module at ${defaultModuleFile}`);
+            process.exit(1);
+        }
+        return defaultModuleFile;
+    }
+    const expectedFileName = `${toKebabCase(moduleName)}.module.ts`;
+    const moduleFile = findFileRecursive(srcDir, expectedFileName);
+    if (!moduleFile) {
+        console.error(`Cannot find module '${moduleName}'. Expected ${expectedFileName} under ${srcDir}`);
+        process.exit(1);
+    }
+    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) {
+        console.error(`Could not find a controllers array inside ${moduleFile}`);
+        process.exit(1);
+    }
+    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 capitalize(value) {
     return value.charAt(0).toUpperCase() + value.slice(1);
 }
@@ -234,6 +283,6 @@ function printUsage() {
 Usage:
   fastnode create <project-name>
   fastnode serve <project-name>
-  fastnode generate controller <controller-name>
+  fastnode generate controller <controller-name> [module-name]
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastnode-cli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "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": {