fastnode-cli 0.6.1 → 0.6.2

package/dist/index.js

@@ -14,6 +14,9 @@ if (command === "create" && resource) {
 else if (command === "serve" && resource) {
     serveProject(resource);
 }
+else if (command === "build") {
+    buildProject();
+}
 else if (command === "generate" && resource === "controller" && name) {
     generateController(name, moduleName);
 }
@@ -79,11 +82,36 @@ function createProject(projectName) {
 function serveProject(projectName) {
     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 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`;
@@ -92,14 +120,112 @@ function generateController(controllerName, moduleName) {
     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));
     updateModuleControllers(moduleFile, className, normalizedName);
     console.log(`Controller '${normalizedName}' created at ${controllerFile}`);
     console.log(`Added ${className} to ${path_1.default.basename(moduleFile)}.`);
 }
+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 { createApp } from "fastnode-core";
@@ -194,22 +320,19 @@ 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);
+        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)) {
-            console.error(`Cannot find default module at ${defaultModuleFile}`);
-            process.exit(1);
+            fail(`Cannot find default module at ${defaultModuleFile}`);
         }
         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);
+        fail(`Cannot find module '${moduleName}'. Expected ${expectedFileName} under ${srcDir}`);
     }
     return moduleFile;
 }
@@ -238,8 +361,7 @@ function updateModuleControllers(moduleFile, controllerClassName, controllerName
     }
     const controllersMatch = moduleSource.match(/controllers\s*:\s*\[([\s\S]*?)\]/);
     if (!controllersMatch) {
-        console.error(`Could not find a controllers array inside ${moduleFile}`);
-        process.exit(1);
+        fail(`Could not find a controllers array inside ${moduleFile}`);
     }
     const existingControllers = controllersMatch[1]
         .split(",")
@@ -261,6 +383,19 @@ function buildRelativeImportPath(fromFile, toFile) {
     }
     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);
 }
@@ -283,6 +418,7 @@ function printUsage() {
 Usage:
   fastnode create <project-name>
   fastnode serve <project-name>
+  fastnode build
   fastnode generate controller <controller-name> [module-name]
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastnode-cli",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "The official CLI for scaffolding and serving FastNode applications.",
   "bin": {
     "fastnode": "dist/index.js"