@triophore/falcon-cli 1.0.4 → 1.0.8

package/lib/ModelGenerator.js

@@ -37,7 +37,7 @@ class ModelGenerator {
 
         // Generate model interactively
         const modelContent = await this.buildModelInteractively(modelName);
-        
+
         // Write model file
         const modelPath = path.join(modelsDir, `${modelName.toLowerCase()}.js`);
         await fs.writeFile(modelPath, modelContent);
@@ -56,7 +56,7 @@ class ModelGenerator {
     async buildModelInteractively(modelName) {
         const fields = {};
         const indexes = [];
-        
+
         // Add timestamps option
         const useTimestamps = await confirm({
             message: 'Enable timestamps (createdAt, updatedAt)?',
@@ -76,7 +76,7 @@ class ModelGenerator {
 
             const fieldName = await input({
                 message: 'Field name:',
-                validate: v => v && !fields[v] ? true : 'Invalid or duplicate field name',
+                validate: v => v.trim() && !fields[v.trim()] ? true : 'Invalid or duplicate field name',
             });
 
             const fieldType = await select({
@@ -120,6 +120,38 @@ class ModelGenerator {
                     validate: v => !v || !isNaN(v) ? true : 'Must be a number'
                 });
                 if (maxLength) fieldOptions.maxlength = parseInt(maxLength);
+
+                // Enum support for String
+                const hasEnum = await confirm({
+                    message: 'Should this field have enum values (restricted choices)?',
+                    default: false
+                });
+                if (hasEnum) {
+                    const enumValues = await input({
+                        message: 'Enter enum values (comma-separated):',
+                        validate: v => v.trim() ? true : 'At least one enum value is required'
+                    });
+                    fieldOptions.enum = enumValues.split(',').map(v => v.trim()).filter(v => v);
+                }
+            }
+
+            if (fieldType === 'Number') {
+                // Enum support for Number
+                const hasEnum = await confirm({
+                    message: 'Should this field have enum values (restricted choices)?',
+                    default: false
+                });
+                if (hasEnum) {
+                    const enumValues = await input({
+                        message: 'Enter enum values (comma-separated numbers):',
+                        validate: v => {
+                            if (!v.trim()) return 'At least one enum value is required';
+                            const values = v.split(',').map(n => n.trim());
+                            return values.every(n => !isNaN(n)) ? true : 'All values must be numbers';
+                        }
+                    });
+                    fieldOptions.enum = enumValues.split(',').map(v => parseFloat(v.trim()));
+                }
             }
 
             if (fieldType === 'ObjectId') {
@@ -130,7 +162,7 @@ class ModelGenerator {
                 fieldOptions.ref = refModel;
             }
 
-            fields[fieldName] = {
+            fields[fieldName.trim()] = {
                 type: fieldType,
                 ...fieldOptions
             };
@@ -180,7 +212,7 @@ ${fieldsCode}
         if (match) {
             const modelsArray = match[1];
             if (!modelsArray.includes(`"${modelName}"`)) {
-                const newModelsArray = modelsArray.trim() 
+                const newModelsArray = modelsArray.trim()
                     ? `${modelsArray.trim()}, "${modelName}"`
                     : `"${modelName}"`;
                 settingsContent = settingsContent.replace(

package/lib/RouteGenerator.js

@@ -1,6 +1,6 @@
 const path = require('path');
 const fs = require('fs').promises;
-const { input } = require('@inquirer/prompts');
+const { input, select } = require('@inquirer/prompts');
 
 class RouteGenerator {
     constructor(options = {}) {
@@ -25,43 +25,85 @@ class RouteGenerator {
             });
         }
 
-        console.log(`\n🔧 Generating route: ${name}\n`);
+        const method = await select({
+            message: 'HTTP Method:',
+            choices: [
+                { name: 'GET', value: 'GET' },
+                { name: 'POST', value: 'POST' },
+                { name: 'PUT', value: 'PUT' },
+                { name: 'DELETE', value: 'DELETE' },
+                { name: 'PATCH', value: 'PATCH' },
+                { name: 'ANY', value: '*' },
+            ]
+        });
 
-        // Create routes directory if it doesn't exist
-        try {
-            await fs.mkdir(routesDir, { recursive: true });
-        } catch (error) {
-            // Directory already exists
+        console.log(`\n🔧 Generating route: ${name} [${method}]\n`);
+
+        // Construct filename: [METHOD]#name.js
+        const filename = `[${method.toUpperCase()}]#${name.toLowerCase()}.js`;
+
+        // Handle nested paths
+        // If name contains slashes, we need to handle directory creation
+        // But wait, if name is "auth/login", filename becomes "[GET]#auth/login.js" which is wrong.
+        // We want "auth/[GET]#login.js".
+
+        let finalPath;
+        if (name.includes('/') || name.includes('\\')) {
+            const parts = name.split(/[/\\]/);
+            const baseName = parts.pop();
+            const dirPath = parts.join('/');
+
+            finalPath = path.join(routesDir, dirPath, `[${method.toUpperCase()}]#${baseName.toLowerCase()}.js`);
+
+            // Create subdirectories
+            try {
+                await fs.mkdir(path.dirname(finalPath), { recursive: true });
+            } catch (error) {
+                // Ignore
+            }
+        } else {
+            finalPath = path.join(routesDir, filename);
+            // Ensure routes dir exists
+            try {
+                await fs.mkdir(routesDir, { recursive: true });
+            } catch (err) { }
         }
 
-        const routeContent = this.getRouteTemplate(name);
-        const routePath = path.join(routesDir, `${name.toLowerCase()}.js`);
 
-        await fs.writeFile(routePath, routeContent);
+        const routeContent = this.getRouteTemplate(name, method);
+        await fs.writeFile(finalPath, routeContent);
 
-        console.log(`✅ Route created: ${routePath}`);
+        console.log(`✅ Route created: ${finalPath}`);
     }
 
-    getRouteTemplate(name) {
-        return `module.exports.route = async function (context) {
-            context.server.route({
-                method: 'GET',
-                path: '/${name.toLowerCase()}',
-                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()
-                    };
-                }
-            });
+    getRouteTemplate(name, method) {
+        method = method === '*' ? 'ANY' : method; //${method} 
+        return `/**
+ * ${method} Route for ${name}
+ */
+
+module.exports.route = async function (context) {
+    return {
+        options: {
+            tags: ['api'],
+            description: 'Auto-generated ${method} route',
+            notes: 'Returns example data',
+            validate: {} // Add payload/query/params validation here
+        },
+        handler: async (request, h) => {
+            return {
+                success: true,
+                message: 'Hello from Falcon.js!',
+                timestamp: new Date().toISOString(),
+                // data: request.payload // for POST/PUT
+            };
+        }
+    };
+};
+
+`
 
-        };`;
+            ;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triophore/falcon-cli",
-  "version": "1.0.4",
+  "version": "1.0.8",
   "description": "",
   "main": "index.js",
   "scripts": {

package/templates/example-route.js

@@ -4,91 +4,22 @@
  */
 
 module.exports.route = async function (context) {
-
-    // Example GET route
-    context.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
-    context.server.route({
+    return {
         method: 'POST',
         path: '/api/example',
         options: {
-            tags: ['api', 'example'],
-            description: 'Example POST endpoint',
-            validate: {
-                payload: context.validators?.ExamplePayload || undefined
-            }
+            tags: ['api'],
+            description: 'Auto-generated POST route',
+            notes: 'Returns example data',
+            validate: {} // Add payload/query/params validation here
         },
         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
-    context.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'
+                message: 'Hello from Falcon.js!',
+                timestamp: new Date().toISOString(),
+                // data: request.payload // for POST/PUT
             };
         }
-    });
-};
+    };
+};