@triophore/falcon-cli 1.0.0 → 1.0.2

package/lib/ProjectGenerator.js

@@ -6,122 +6,120 @@ const { spawn } = require('child_process');
 const { showSuccess, runNpmInstall, createDirectory } = require('./utils');
 
 class ProjectGenerator {
-    constructor(options = {}) {
-        this.verbose = options.verbose || false;
-        this.skipInstall = options.skipInstall || false;
-        this.useDefaults = options.useDefaults || false;
+  constructor(options = {}) {
+    this.verbose = options.verbose || false;
+    this.skipInstall = options.skipInstall || false;
+    this.useDefaults = options.useDefaults || false;
+  }
+
+  async create(projectName, template = 'basic') {
+    const currentDir = process.cwd();
+
+    // Get project name if not provided
+    if (!projectName) {
+      projectName = await input({
+        message: 'Project name:',
+        validate: v => v.trim() ? true : 'Project name is required',
+      });
     }
 
-    async create(projectName, template = 'basic') {
-        const currentDir = process.cwd();
-        
-        // Get project name if not provided
-        if (!projectName) {
-            projectName = await input({
-                message: 'Project name:',
-                validate: v => v.trim() ? true : 'Project name is required',
-            });
-        }
-
-        const projectPath = path.join(currentDir, projectName);
-
-        // Check if directory exists
-        try {
-            await fs.access(projectPath);
-            const overwrite = await confirm({
-                message: `Directory "${projectName}" already exists. Overwrite?`,
-                default: false
-            });
-            if (!overwrite) {
-                console.log('❌ Project creation cancelled');
-                return;
-            }
-        } catch (error) {
-            // Directory doesn't exist, which is good
-        }
-
-        console.log(`\n🚀 Creating Falcon.js project: ${projectName}\n`);
-
-        // Create project structure
-        await this.createProjectStructure(projectPath, projectName, template);
-        
-        // Install dependencies
-        if (!this.skipInstall) {
-            console.log('📦 Installing dependencies...');
-            await runNpmInstall(projectPath);
-        }
-
-        showSuccess(projectName, this.skipInstall);
+    const projectPath = path.join(currentDir, projectName);
+
+    // Check if directory exists
+    try {
+      await fs.access(projectPath);
+      const overwrite = await confirm({
+        message: `Directory "${projectName}" already exists. Overwrite?`,
+        default: false
+      });
+      if (!overwrite) {
+        console.log('❌ Project creation cancelled');
+        return;
+      }
+    } catch (error) {
+      // Directory doesn't exist, which is good
     }
 
-    async createProjectStructure(projectPath, projectName, template) {
-        // Create directories
-        const directories = [
-            'models/mongo',
-            'routes',
-            'services', 
-            'workers',
-            'validators',
-            'init',
-            'logs',
-            'public'
-        ];
-
-        for (const dir of directories) {
-            await createDirectory(path.join(projectPath, dir));
-        }
-
-        // Create files
-        await this.createPackageJson(projectPath, projectName);
-        await this.createSettings(projectPath, projectName);
-        await this.createIndexJs(projectPath);
-        await this.createEnvFile(projectPath, projectName);
-        await this.createExampleFiles(projectPath);
+    console.log(`\n🚀 Creating Falcon.js project: ${projectName}\n`);
+
+    // Create project structure
+    await this.createProjectStructure(projectPath, projectName, template);
+
+    // Install dependencies
+    if (!this.skipInstall) {
+      console.log('📦 Installing dependencies...');
+      await runNpmInstall(projectPath);
     }
 
-    async createPackageJson(projectPath, projectName) {
-        const packageJson = {
-            name: projectName,
-            version: "1.0.0",
-            description: "Falcon.js application",
-            main: "index.js",
-            scripts: {
-                start: "node index.js",
-                dev: "nodemon index.js",
-                test: "echo \"Error: no test specified\" && exit 1"
-            },
-            keywords: ["falcon", "nodejs", "api"],
-            author: "",
-            license: "ISC",
-            type: "commonjs",
-            dependencies: {
-                "falconjs": "file:../falconjs",
-                "@hapi/boom": "^10.0.1",
-                "@hapi/inert": "^7.1.0", 
-                "@hapi/vision": "^7.0.3",
-                "joi": "^17.13.3",
-                "mongoose": "^8.3.1",
-                "redis": "^4.7.0",
-                "mqtt": "^5.13.3",
-                "log4js": "^6.9.1",
-                "rate-limiter-flexible": "^2.4.2",
-                "hapi-alive": "^2.0.4",
-                "hapi-swagger": "^17.2.1",
-                "dotenv": "^16.0.0"
-            },
-            devDependencies: {
-                "nodemon": "^3.1.10"
-            }
-        };
-
-        await fs.writeFile(
-            path.join(projectPath, 'package.json'),
-            JSON.stringify(packageJson, null, 2)
-        );
+    showSuccess(projectName, this.skipInstall);
+  }
+
+  async createProjectStructure(projectPath, projectName, template) {
+    // Create directories
+    const directories = [
+      'models/mongo',
+      'routes',
+      'services',
+      'workers',
+      'validators',
+      'init',
+      'logs',
+      'public'
+    ];
+
+    for (const dir of directories) {
+      await createDirectory(path.join(projectPath, dir));
     }
 
-    async createSettings(projectPath, projectName) {
-        const settings = `module.exports.settings = {
+    // Create files
+    await this.createPackageJson(projectPath, projectName);
+    await this.createSettings(projectPath, projectName);
+    await this.createIndexJs(projectPath);
+    await this.createEnvFile(projectPath, projectName);
+    await this.createExampleFiles(projectPath);
+  }
+
+  async createPackageJson(projectPath, projectName) {
+    const packageJson = {
+      name: projectName,
+      version: "1.0.0",
+      description: "Falcon.js application",
+      main: "index.js",
+      scripts: {
+        start: "node index.js",
+        dev: "nodemon index.js",
+        test: "echo \"Error: no test specified\" && exit 1"
+      },
+      keywords: ["falcon", "nodejs", "api"],
+      author: "",
+      license: "ISC",
+      type: "commonjs",
+      dependencies: {
+        "@triophore/falconjs": "^1.0.0",
+        "@hapi/boom": "^10.0.1",
+        "@hapi/inert": "^7.1.0",
+        "@hapi/vision": "^7.0.3",
+        "joi": "^17.13.3",
+        "mongoose": "^8.3.1",
+        "redis": "^4.7.0",
+        "rate-limiter-flexible": "^2.4.2",
+        "hapi-alive": "^2.0.4",
+        "hapi-swagger": "^17.2.1",
+        "dotenv": "^16.0.0"
+      },
+      devDependencies: {
+        "nodemon": "^3.1.10"
+      }
+    };
+
+    await fs.writeFile(
+      path.join(projectPath, 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+  }
+
+  async createSettings(projectPath, projectName) {
+    const settings = `module.exports.settings = {
   name: "${projectName}",
   http: {
     host: process.env.HTTP_HOST || "localhost",
@@ -179,19 +177,19 @@ class ProjectGenerator {
   postInit: "post"
 };`;
 
-        await fs.writeFile(path.join(projectPath, 'settings.js'), settings);
-    }
+    await fs.writeFile(path.join(projectPath, 'settings.js'), settings);
+  }
 
-    async createIndexJs(projectPath) {
-        const indexContent = await fs.readFile(
-            path.join(__dirname, '../templates/index.txt'),
-            'utf8'
-        );
-        await fs.writeFile(path.join(projectPath, 'index.js'), indexContent);
-    }
+  async createIndexJs(projectPath) {
+    const indexContent = await fs.readFile(
+      path.join(__dirname, '../templates/index.txt'),
+      'utf8'
+    );
+    await fs.writeFile(path.join(projectPath, 'index.js'), indexContent);
+  }
 
-    async createEnvFile(projectPath, projectName) {
-        const envContent = `# Falcon.js Environment Configuration
+  async createEnvFile(projectPath, projectName) {
+    const envContent = `# Falcon.js Environment Configuration
 # Generated by falcon-cli
 
 # Server Configuration
@@ -221,26 +219,26 @@ LOG_MAX_SIZE=10M
 MODE=DEV
 `;
 
-        await fs.writeFile(path.join(projectPath, '.env'), envContent);
-    }
-
-    async createExampleFiles(projectPath) {
-        const templates = [
-            { src: 'example-route.js', dest: 'routes/example.js' },
-            { src: 'example-validator.js', dest: 'validators/ExamplePayload.js' },
-            { src: 'example-service.js', dest: 'services/example.js' },
-            { src: 'example-worker.js', dest: 'workers/example.js' },
-            { src: 'post-init.js', dest: 'init/post.js' }
-        ];
-
-        for (const template of templates) {
-            const content = await fs.readFile(
-                path.join(__dirname, '../templates', template.src),
-                'utf8'
-            );
-            await fs.writeFile(path.join(projectPath, template.dest), content);
-        }
+    await fs.writeFile(path.join(projectPath, '.env'), envContent);
+  }
+
+  async createExampleFiles(projectPath) {
+    const templates = [
+      { src: 'example-route.js', dest: 'routes/example.js' },
+      { src: 'example-validator.js', dest: 'validators/ExamplePayload.js' },
+      { src: 'example-service.js', dest: 'services/example.js' },
+      { src: 'example-worker.js', dest: 'workers/example.js' },
+      { src: 'post-init.js', dest: 'init/post.js' }
+    ];
+
+    for (const template of templates) {
+      const content = await fs.readFile(
+        path.join(__dirname, '../templates', template.src),
+        'utf8'
+      );
+      await fs.writeFile(path.join(projectPath, template.dest), content);
     }
+  }
 }
 
 module.exports = ProjectGenerator;

package/lib/RouteGenerator.js

@@ -0,0 +1,101 @@
+const { input, select, confirm } = require("@inquirer/prompts");
+const fs = require("fs").promises;
+const path = require("path");
+
+class RouteGenerator {
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.type = options.type || 'route'; // 'route' or 'validator'
+    }
+
+    async generate(name) {
+        const currentDir = process.cwd();
+
+        // Check if we're in a Falcon project
+        try {
+            await fs.access(path.join(currentDir, 'settings.js'));
+        } catch (error) {
+            throw new Error('Not in a Falcon.js project directory. Run this command from your project root.');
+        }
+
+        if (!name) {
+            name = await input({
+                message: `${this.type === 'validator' ? 'Validator' : 'Route'} name (e.g., User):`,
+                validate: v => v.trim() ? true : 'Name is required',
+            });
+        }
+
+        if (this.type === 'validator') {
+            await this.generateValidator(currentDir, name);
+        } else {
+            await this.generateRoute(currentDir, name);
+        }
+    }
+
+    async generateRoute(projectDir, name) {
+        const routesDir = path.join(projectDir, 'routes');
+        await fs.mkdir(routesDir, { recursive: true });
+
+        // Determine path and filename
+        // If name contains /, treat as path
+        const parts = name.split('/');
+        const fileName = parts.pop();
+        const subDir = parts.join('/');
+
+        const targetDir = path.join(routesDir, subDir);
+        await fs.mkdir(targetDir, { recursive: true });
+
+        const filePath = path.join(targetDir, `${fileName}.js`);
+
+        // Check if file exists
+        try {
+            await fs.access(filePath);
+            const overwrite = await confirm({
+                message: `Route file ${filePath} already exists. Overwrite?`,
+                default: false
+            });
+            if (!overwrite) return;
+        } catch (e) {
+            // File doesn't exist, proceed
+        }
+
+        // Helper to get template content
+        const templatePath = path.join(__dirname, '..', 'templates', 'example-route.js');
+        let content = await fs.readFile(templatePath, 'utf8');
+
+        // Simple replacements if needed, or just use the example as a starter
+        // For now, we'll just write the template
+
+        await fs.writeFile(filePath, content);
+        console.log(`✅ Route created: ${filePath}`);
+    }
+
+    async generateValidator(projectDir, name) {
+        const validatorsDir = path.join(projectDir, 'validators');
+        await fs.mkdir(validatorsDir, { recursive: true });
+
+        const filePath = path.join(validatorsDir, `${name}.js`);
+
+        // Check if file exists
+        try {
+            await fs.access(filePath);
+            const overwrite = await confirm({
+                message: `Validator file ${filePath} already exists. Overwrite?`,
+                default: false
+            });
+            if (!overwrite) return;
+        } catch (e) {
+            // File doesn't exist, proceed
+        }
+
+        const templatePath = path.join(__dirname, '..', 'templates', 'example-validator.js');
+        let content = await fs.readFile(templatePath, 'utf8');
+
+        // Replace Joi with Joi (no change needed usually, but good for future)
+
+        await fs.writeFile(filePath, content);
+        console.log(`✅ Validator created: ${filePath}`);
+    }
+}
+
+module.exports = RouteGenerator;

package/lib/ServiceGenerator.js

@@ -0,0 +1,85 @@
+const { input, confirm } = require("@inquirer/prompts");
+const fs = require("fs").promises;
+const path = require("path");
+
+class ServiceGenerator {
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.type = options.type || 'service'; // 'service' or 'worker'
+    }
+
+    async generate(name) {
+        const currentDir = process.cwd();
+
+        // Check if we're in a Falcon project
+        try {
+            await fs.access(path.join(currentDir, 'settings.js'));
+        } catch (error) {
+            throw new Error('Not in a Falcon.js project directory. Run this command from your project root.');
+        }
+
+        if (!name) {
+            name = await input({
+                message: `${this.type === 'worker' ? 'Worker' : 'Service'} name (e.g., Email):`,
+                validate: v => v.trim() ? true : 'Name is required',
+            });
+        }
+
+        const dirName = this.type === 'worker' ? 'workers' : 'services';
+        const targetDir = path.join(currentDir, dirName);
+        await fs.mkdir(targetDir, { recursive: true });
+
+        const filePath = path.join(targetDir, `${name}.js`);
+
+        // Check if file exists
+        try {
+            await fs.access(filePath);
+            const overwrite = await confirm({
+                message: `${this.type === 'worker' ? 'Worker' : 'Service'} file ${filePath} already exists. Overwrite?`,
+                default: false
+            });
+            if (!overwrite) return;
+        } catch (e) {
+            // File doesn't exist, proceed
+        }
+
+        // Get template
+        const templateName = this.type === 'worker' ? 'example-worker.js' : 'example-service.js';
+        const templatePath = path.join(__dirname, '..', 'templates', templateName);
+        let content = await fs.readFile(templatePath, 'utf8');
+
+        await fs.writeFile(filePath, content);
+        console.log(`✅ ${this.type === 'worker' ? 'Worker' : 'Service'} created: ${filePath}`);
+
+        // Update settings.js to include the service/worker
+        await this.updateSettings(currentDir, name, dirName);
+    }
+
+    async updateSettings(projectDir, name, listName) {
+        const settingsPath = path.join(projectDir, 'settings.js');
+        let settingsContent = await fs.readFile(settingsPath, 'utf8');
+
+        // Regex to find the array:  services: [...] or workers: [...]
+        const regex = new RegExp(`${listName}:\\s*\\[(.*?)\\]`, 's');
+        const match = settingsContent.match(regex);
+
+        if (match) {
+            const listContent = match[1];
+            // Simple check if name is already there
+            if (!listContent.includes(`"${name}"`) && !listContent.includes(`'${name}'`)) {
+                const newListContent = listContent.trim()
+                    ? `${listContent.trim()}, "${name}"`
+                    : `"${name}"`;
+
+                settingsContent = settingsContent.replace(
+                    regex,
+                    `${listName}: [${newListContent}]`
+                );
+                await fs.writeFile(settingsPath, settingsContent);
+                console.log(`✅ Added "${name}" to settings.js ${listName} array`);
+            }
+        }
+    }
+}
+
+module.exports = ServiceGenerator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triophore/falcon-cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -17,6 +17,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^7.9.0",
     "acorn": "^8.15.0",
     "ajv": "^8.17.1",
@@ -25,11 +26,10 @@
     "joi": "^18.0.1",
     "mongoose": "^8.19.3",
     "prompt-sync": "^4.2.0",
+    "rate-limiter-flexible": "^2.4.2",
     "reflect-metadata": "^0.2.2",
     "sequelize": "^6.37.7",
     "unzipper": "^0.12.3",
-    "yargs": "^18.0.0",
-    "@hapi/boom": "^10.0.1",
-    "rate-limiter-flexible": "^2.4.2"
+    "yargs": "^18.0.0"
   }
 }

package/templates/example-service.js

@@ -1,10 +1,10 @@
-const { FalconBaseService } = require('falconjs');
+const { FalconBaseService } = require('@triophore/falconjs');
 
 /**
  * Example service - rename and customize as needed
  */
 class ExampleService extends FalconBaseService {
-    
+
     constructor() {
         super('example'); // Service ID for MQTT topics
     }
@@ -15,7 +15,7 @@ class ExampleService extends FalconBaseService {
     async onMessage(topic, msg) {
         try {
             const message = JSON.parse(msg.toString());
-            
+
             switch (topic) {
                 case 'service_example':
                     await this.handleRequest(message);
@@ -33,9 +33,9 @@ class ExampleService extends FalconBaseService {
      */
     async handleRequest(request) {
         console.log('Processing request:', request);
-        
+
         // Your service logic here
-        
+
         // Send response back via MQTT
         this.publish({
             status: 'completed',
@@ -49,7 +49,7 @@ class ExampleService extends FalconBaseService {
      */
     async run() {
         console.log('Example service is running...');
-        
+
         // Your initialization logic here
     }
 }

package/templates/example-worker.js

@@ -1,10 +1,10 @@
-const { FalconBaseWorker } = require('falconjs');
+const { FalconBaseWorker } = require('@triophore/falconjs');
 
 /**
  * Example worker - rename and customize as needed
  */
 class ExampleWorker extends FalconBaseWorker {
-    
+
     constructor() {
         super('example'); // Worker ID for MQTT topics
     }
@@ -15,7 +15,7 @@ class ExampleWorker extends FalconBaseWorker {
     async onMessage(topic, msg) {
         try {
             const message = JSON.parse(msg.toString());
-            
+
             switch (topic) {
                 case 'worker_example_job':
                     await this.processJob(message);
@@ -33,12 +33,12 @@ class ExampleWorker extends FalconBaseWorker {
      */
     async processJob(job) {
         const { jobId, data } = job;
-        
+
         console.log(`Processing job ${jobId}:`, data);
-        
+
         // Simulate work
         await new Promise(resolve => setTimeout(resolve, 2000));
-        
+
         // Update job status in database if available
         if (this.models.job) {
             await this.models.job.findByIdAndUpdate(jobId, {
@@ -47,7 +47,7 @@ class ExampleWorker extends FalconBaseWorker {
                 result: { processed: true }
             });
         }
-        
+
         // Send completion notification
         await this.publish('worker_example_complete', {
             jobId: jobId,
@@ -62,13 +62,13 @@ class ExampleWorker extends FalconBaseWorker {
     async run() {
         const args = this.parseArgs();
         console.log('Example worker started with args:', args);
-        
+
         // If specific job passed as argument, process it immediately
         if (args.jobId) {
             await this.processJob(args);
             process.exit(0); // Exit after processing single job
         }
-        
+
         // Otherwise, keep running and wait for MQTT jobs
         console.log('Waiting for jobs...');
     }

package/templates/index.txt

@@ -2,7 +2,7 @@
  * Falcon.js Application Entry Point
  */
 require('dotenv').config();
-const { FalconServer } = require("falconjs");
+const { FalconServer } = require("@triophore/falconjs");
 
 async function main() {
     try {