@triophore/falcon-cli 1.0.0

package/templates/example-route.js

@@ -0,0 +1,94 @@
+/**
+ * Example route handler
+ * This file demonstrates the route structure expected by Falcon.js
+ */
+
+module.exports.route = async function (server, context) {
+    
+    // Example GET route
+    server.route({
+        method: 'GET',
+        path: '/api/example',
+        options: {
+            tags: ['api', 'example'],
+            description: 'Example GET endpoint',
+            notes: 'Returns example data'
+        },
+        handler: async (request, h) => {
+            return {
+                success: true,
+                message: 'Hello from Falcon.js!',
+                timestamp: new Date().toISOString()
+            };
+        }
+    });
+
+    // Example POST route with validation
+    server.route({
+        method: 'POST',
+        path: '/api/example',
+        options: {
+            tags: ['api', 'example'],
+            description: 'Example POST endpoint',
+            validate: {
+                payload: context.validators?.ExamplePayload || undefined
+            }
+        },
+        handler: async (request, h) => {
+            const { name, email } = request.payload;
+            
+            // Example: Save to database if models are available
+            if (context.models.example) {
+                const result = await context.models.example.create({
+                    name,
+                    email,
+                    createdAt: new Date()
+                });
+                
+                return {
+                    success: true,
+                    data: result,
+                    message: 'Data saved successfully'
+                };
+            }
+            
+            return {
+                success: true,
+                message: 'Data received',
+                data: { name, email }
+            };
+        }
+    });
+
+    // Example route that sends job to worker
+    server.route({
+        method: 'POST',
+        path: '/api/example/job',
+        options: {
+            tags: ['api', 'jobs'],
+            description: 'Queue a job for processing'
+        },
+        handler: async (request, h) => {
+            const jobData = request.payload;
+            
+            // Send job to worker via MQTT (if available)
+            if (context.mqtt_client) {
+                context.mqtt_client.publish('worker_example_job', JSON.stringify({
+                    jobId: Date.now().toString(),
+                    data: jobData,
+                    timestamp: new Date().toISOString()
+                }));
+                
+                return {
+                    success: true,
+                    message: 'Job queued for processing'
+                };
+            }
+            
+            return {
+                success: false,
+                message: 'Job queue not available'
+            };
+        }
+    });
+};

package/templates/example-service.js

@@ -0,0 +1,63 @@
+const { FalconBaseService } = require('falconjs');
+
+/**
+ * Example service - rename and customize as needed
+ */
+class ExampleService extends FalconBaseService {
+    
+    constructor() {
+        super('example'); // Service ID for MQTT topics
+    }
+
+    /**
+     * Handle incoming MQTT messages
+     */
+    async onMessage(topic, msg) {
+        try {
+            const message = JSON.parse(msg.toString());
+            
+            switch (topic) {
+                case 'service_example':
+                    await this.handleRequest(message);
+                    break;
+                default:
+                    console.log(`Unhandled topic: ${topic}`);
+            }
+        } catch (error) {
+            console.error('Error processing message:', error);
+        }
+    }
+
+    /**
+     * Handle service requests
+     */
+    async handleRequest(request) {
+        console.log('Processing request:', request);
+        
+        // Your service logic here
+        
+        // Send response back via MQTT
+        this.publish({
+            status: 'completed',
+            result: 'success',
+            timestamp: new Date().toISOString()
+        }, 'service_example_response');
+    }
+
+    /**
+     * Service main logic
+     */
+    async run() {
+        console.log('Example service is running...');
+        
+        // Your initialization logic here
+    }
+}
+
+// Start the service if this file is run directly
+if (require.main === module) {
+    const service = new ExampleService();
+    service.init().catch(console.error);
+}
+
+module.exports = ExampleService;

package/templates/example-validator.js

@@ -0,0 +1,15 @@
+const Joi = require('joi');
+
+/**
+ * Example Joi validator for API endpoints
+ * This validator can be automatically matched with routes by name
+ */
+module.exports = Joi.object({
+    name: Joi.string().min(2).max(50).required().description('User name'),
+    email: Joi.string().email().required().description('User email address'),
+    age: Joi.number().integer().min(18).max(120).optional().description('User age'),
+    preferences: Joi.object({
+        newsletter: Joi.boolean().default(false),
+        notifications: Joi.boolean().default(true)
+    }).optional().description('User preferences')
+}).description('Example payload validation schema');

package/templates/example-worker.js

@@ -0,0 +1,83 @@
+const { FalconBaseWorker } = require('falconjs');
+
+/**
+ * Example worker - rename and customize as needed
+ */
+class ExampleWorker extends FalconBaseWorker {
+    
+    constructor() {
+        super('example'); // Worker ID for MQTT topics
+    }
+
+    /**
+     * Handle incoming MQTT messages
+     */
+    async onMessage(topic, msg) {
+        try {
+            const message = JSON.parse(msg.toString());
+            
+            switch (topic) {
+                case 'worker_example_job':
+                    await this.processJob(message);
+                    break;
+                default:
+                    console.log(`Unhandled topic: ${topic}`);
+            }
+        } catch (error) {
+            console.error('Error processing message:', error);
+        }
+    }
+
+    /**
+     * Process a job
+     */
+    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, {
+                status: 'completed',
+                completedAt: new Date(),
+                result: { processed: true }
+            });
+        }
+        
+        // Send completion notification
+        await this.publish('worker_example_complete', {
+            jobId: jobId,
+            status: 'completed',
+            timestamp: new Date().toISOString()
+        });
+    }
+
+    /**
+     * Worker main logic
+     */
+    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...');
+    }
+}
+
+// Start the worker if this file is run directly
+if (require.main === module) {
+    const worker = new ExampleWorker();
+    worker.init().catch(console.error);
+}
+
+module.exports = ExampleWorker;

package/templates/index.txt

@@ -0,0 +1,41 @@
+/**
+ * Falcon.js Application Entry Point
+ */
+require('dotenv').config();
+const { FalconServer } = require("falconjs");
+
+async function main() {
+    try {
+        /**
+         * Create the server instance with path to settings
+         */
+        const server = new FalconServer(__dirname);
+        
+        /**
+         * Optional: Set custom authentication strategy
+         */
+        // server.setAuthStrategy(async (context) => {
+        //     // Custom auth setup here
+        // });
+        
+        /**
+         * Initialize the server and related modules
+         */
+        await server.init();
+        
+        /**
+         * Start the HTTP server
+         */
+        await server.runServer();
+        
+        console.log(`🚀 Falcon server running on http://${server.SETTINGS.http.host}:${server.SETTINGS.http.port}`);
+        console.log(`📚 API Documentation: http://${server.SETTINGS.http.host}:${server.SETTINGS.http.port}/documentation`);
+        console.log(`❤️  Health Check: http://${server.SETTINGS.http.host}:${server.SETTINGS.http.port}/health`);
+        
+    } catch (error) {
+        console.error('❌ Failed to start server:', error);
+        process.exit(1);
+    }
+}
+
+main();

package/templates/post-init.js

@@ -0,0 +1,78 @@
+/**
+ * Post-initialization script
+ * This runs after all Falcon components are initialized
+ */
+
+module.exports.run = async function(context) {
+    const { logger, mqtt_client, models, server } = context;
+    
+    logger.info("Running post-initialization script...");
+    
+    // Example: Set up MQTT subscriptions for the main server
+    if (mqtt_client) {
+        // Subscribe to service responses
+        mqtt_client.subscribe("service_*_response", (err) => {
+            if (err) {
+                logger.error("Failed to subscribe to service responses:", err);
+            } else {
+                logger.info("Subscribed to service response topics");
+            }
+        });
+        
+        // Subscribe to worker completions
+        mqtt_client.subscribe("worker_*_complete", (err) => {
+            if (err) {
+                logger.error("Failed to subscribe to worker completions:", err);
+            } else {
+                logger.info("Subscribed to worker completion topics");
+            }
+        });
+        
+        // Handle incoming messages
+        mqtt_client.on("message", async function (topic, msg) {
+            try {
+                const message = JSON.parse(msg.toString());
+                logger.info(`Received message on ${topic}:`, message);
+                
+                // Handle different message types
+                if (topic.includes('_response')) {
+                    // Handle service responses
+                    logger.info("Service response received:", message);
+                } else if (topic.includes('_complete')) {
+                    // Handle worker completions
+                    logger.info("Worker job completed:", message);
+                }
+            } catch (error) {
+                logger.error("Error processing MQTT message:", error);
+            }
+        });
+    }
+    
+    // Example: Add custom routes dynamically
+    if (server) {
+        server.route({
+            method: 'GET',
+            path: '/api/status',
+            options: {
+                tags: ['system'],
+                description: 'System status endpoint'
+            },
+            handler: async (request, h) => {
+                return {
+                    status: 'running',
+                    timestamp: new Date().toISOString(),
+                    uptime: process.uptime(),
+                    memory: process.memoryUsage(),
+                    version: require('../package.json').version
+                };
+            }
+        });
+    }
+    
+    // Example: Initialize background tasks
+    setInterval(() => {
+        logger.debug("Heartbeat - System is running");
+    }, 60000); // Every minute
+    
+    logger.info("Post-initialization completed successfully");
+};

package/templates/settings.js

@@ -0,0 +1,192 @@
+module.exports.settings = {
+  name: "falcon-app",
+  http: {
+    host: process.env.HTTP_HOST || "localhost",
+    port: process.env.HTTP_PORT || 3000
+  },
+  database: {
+    mongodb: {
+      database: process.env.MONGODB_URL || "mongodb://localhost:27017/falcon_db"
+    }
+  },
+  mqtt: {
+    internal: true,
+    external: false
+  },
+  log: {
+    appenders: {
+      file: {
+        type: "file",
+        filename: process.env.LOG_FILE_NAME || "logs/app.log",
+        maxLogSize: process.env.LOG_MAX_SIZE || "10M",
+        backups: 3
+      },
+      console: {
+        type: "console"
+      }
+    },
+    categories: {
+      default: {
+        appenders: ["file", "console"],
+        level: process.env.LOG_LEVEL || "info"
+      }
+    }
+  },
+  swagger: {
+    enabled: true,
+    path: "/documentation"
+  },
+  auth: {
+    // Custom Authentication (API Keys, etc.)
+    custom: {
+      name: 'api-key',
+      validate: async (token, request, context) => {
+        // Custom validation logic with access to context (logger, redis, models)
+        context.logger.info('Validating API key');
+        
+        // Check cache first
+        const cacheKey = `api-key:${token}`;
+        if (context.redis) {
+          const cached = await context.redis.get(cacheKey);
+          if (cached) return JSON.parse(cached);
+        }
+        
+        // Validate against database or external service
+        if (context.models.apiKey) {
+          const apiKey = await context.models.apiKey.findOne({ key: token, active: true });
+          if (apiKey) {
+            const user = { id: apiKey.userId, roles: apiKey.roles };
+            // Cache for 5 minutes
+            if (context.redis) {
+              await context.redis.setEx(cacheKey, 300, JSON.stringify(user));
+            }
+            return user;
+          }
+        }
+        
+        return null;
+      },
+      extractToken: (request) => {
+        // Custom token extraction
+        return request.headers['x-api-key'] || request.query.apiKey;
+      }
+    },
+    
+    // JWT Authentication
+    jwt: {
+      secret: process.env.JWT_SECRET || "your-secret-key-here",
+      algorithms: ['HS256'],
+      cache: {
+        enabled: true,
+        ttl: 300 // 5 minutes
+      },
+      validate: async (decoded, request, context) => {
+        context.logger.info(`JWT validation for user: ${decoded.sub}`);
+        
+        // Check if user exists and is active
+        if (context.models.user) {
+          const user = await context.models.user.findById(decoded.sub).select('-password');
+          if (user && user.active) {
+            return {
+              id: user._id,
+              email: user.email,
+              roles: user.roles || ['user']
+            };
+          }
+        }
+        
+        // Fallback for development
+        return {
+          id: decoded.sub,
+          email: decoded.email,
+          roles: decoded.roles || ['user']
+        };
+      }
+    },
+    
+    // Cookie Authentication
+    cookie: {
+      password: process.env.COOKIE_SECRET || "your-32-char-cookie-password-here",
+      name: "falcon-session",
+      ttl: 24 * 60 * 60 * 1000, // 24 hours
+      isSecure: process.env.NODE_ENV === "production",
+      isHttpOnly: true,
+      validate: async (request, session, context) => {
+        context.logger.info(`Session validation for user: ${session.userId}`);
+        
+        if (context.models.user) {
+          const user = await context.models.user.findById(session.userId).select('-password');
+          if (user && user.active) {
+            return {
+              id: user._id,
+              email: user.email,
+              roles: user.roles || ['user']
+            };
+          }
+        }
+        
+        return session.user;
+      }
+    },
+    
+    // JWKS Authentication (External Identity Providers)
+    jwks: {
+      jwksUri: process.env.JWKS_URI || "https://your-auth0-domain/.well-known/jwks.json",
+      issuer: process.env.JWT_ISSUER || "https://your-auth0-domain/",
+      audience: process.env.JWT_AUDIENCE || "your-api-identifier",
+      algorithms: ['RS256'],
+      cache: {
+        enabled: true,
+        ttl: 3600 // 1 hour
+      },
+      validate: async (decoded, request, context) => {
+        context.logger.info(`JWKS validation for user: ${decoded.sub}`);
+        
+        // Map external identity to internal user
+        if (context.models.user) {
+          let user = await context.models.user.findOne({ externalId: decoded.sub });
+          
+          if (!user && decoded.email) {
+            // Create user if doesn't exist
+            user = await context.models.user.create({
+              externalId: decoded.sub,
+              email: decoded.email,
+              name: decoded.name,
+              roles: ['user'],
+              active: true
+            });
+          }
+          
+          if (user) {
+            return {
+              id: user._id,
+              email: user.email,
+              roles: user.roles || ['user']
+            };
+          }
+        }
+        
+        // Fallback
+        return {
+          id: decoded.sub,
+          email: decoded.email,
+          roles: decoded['https://yourapp.com/roles'] || ['user']
+        };
+      }
+    },
+    
+    // Socket.IO Configuration
+    socketio: {
+      enabled: true,
+      timeout: 5000
+    }
+  },
+  services: [],
+  workers: [],
+  models: [],
+  routes: [],
+  crud: {
+    exclude: []
+  },
+  postInit: "post"
+};

package/templates/template1.settings.txt

@@ -0,0 +1,15 @@
+module.exports.settings = {
+    crud: {
+        exclude: [
+        ]
+    },
+    auth:{},
+    services:[],
+    workers:[],
+    preInit:"",
+    postInit:"",
+    routes: [
+    ],
+    models: [
+    ]
+}

package/templates/templatev1.json

@@ -0,0 +1,38 @@
+{
+  "name": "falcon-app",
+  "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": "@triophore/falconjs",
+    "@hapi/boom": "^10.0.1",
+    "@hapi/inert": "^7.1.0",
+    "@hapi/vision": "^7.0.3",
+    "joi": "^17.13.3",
+    "jose": "^5.2.0",
+    "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"
+  }
+}