@triophore/falcon-cli 1.0.0

package/lib/ModelGenerator.js

@@ -0,0 +1,203 @@
+const { input, select, confirm, checkbox } = require("@inquirer/prompts");
+const fs = require("fs").promises;
+const path = require("path");
+
+class ModelGenerator {
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+    }
+
+    async generate(modelName, options = {}) {
+        const currentDir = process.cwd();
+        const modelsDir = path.join(currentDir, 'models', 'mongo');
+
+        // 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.');
+        }
+
+        // Get model name if not provided
+        if (!modelName) {
+            modelName = await input({
+                message: 'Model name (e.g., User):',
+                validate: v => v.trim() ? true : 'Model name is required',
+            });
+        }
+
+        console.log(`\n🔧 Generating model: ${modelName}\n`);
+
+        // Create models directory if it doesn't exist
+        try {
+            await fs.mkdir(modelsDir, { recursive: true });
+        } catch (error) {
+            // Directory already exists
+        }
+
+        // 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);
+
+        console.log(`✅ Model created: ${modelPath}`);
+
+        // Update settings.js to include the model
+        await this.updateSettings(currentDir, modelName.toLowerCase());
+
+        // Generate CRUD routes if requested
+        if (options.crud) {
+            await this.generateCrudRoutes(currentDir, modelName);
+        }
+    }
+
+    async buildModelInteractively(modelName) {
+        const fields = {};
+        const indexes = [];
+        
+        // Add timestamps option
+        const useTimestamps = await confirm({
+            message: 'Enable timestamps (createdAt, updatedAt)?',
+            default: true
+        });
+
+        console.log('\n📝 Add fields to your model:\n');
+
+        // Add fields interactively
+        while (true) {
+            const addField = await confirm({
+                message: 'Add a field?',
+                default: true
+            });
+
+            if (!addField) break;
+
+            const fieldName = await input({
+                message: 'Field name:',
+                validate: v => v && !fields[v] ? true : 'Invalid or duplicate field name',
+            });
+
+            const fieldType = await select({
+                message: 'Field type:',
+                choices: [
+                    { name: 'String', value: 'String' },
+                    { name: 'Number', value: 'Number' },
+                    { name: 'Boolean', value: 'Boolean' },
+                    { name: 'Date', value: 'Date' },
+                    { name: 'ObjectId (Reference)', value: 'ObjectId' },
+                    { name: 'Array', value: 'Array' },
+                    { name: 'Mixed (Object)', value: 'Mixed' }
+                ]
+            });
+
+            const fieldOptions = {};
+
+            // Common options
+            const isRequired = await confirm({
+                message: 'Is this field required?',
+                default: false
+            });
+            if (isRequired) fieldOptions.required = true;
+
+            const hasIndex = await confirm({
+                message: 'Add index to this field?',
+                default: false
+            });
+            if (hasIndex) fieldOptions.index = true;
+
+            // Type-specific options
+            if (fieldType === 'String') {
+                const isUnique = await confirm({
+                    message: 'Should this field be unique?',
+                    default: false
+                });
+                if (isUnique) fieldOptions.unique = true;
+
+                const maxLength = await input({
+                    message: 'Maximum length (optional):',
+                    validate: v => !v || !isNaN(v) ? true : 'Must be a number'
+                });
+                if (maxLength) fieldOptions.maxlength = parseInt(maxLength);
+            }
+
+            if (fieldType === 'ObjectId') {
+                const refModel = await input({
+                    message: 'Reference model name:',
+                    validate: v => v.trim() ? true : 'Reference model is required'
+                });
+                fieldOptions.ref = refModel;
+            }
+
+            fields[fieldName] = {
+                type: fieldType,
+                ...fieldOptions
+            };
+        }
+
+        return this.generateModelCode(modelName, fields, { timestamps: useTimestamps });
+    }
+
+    generateModelCode(modelName, fields, options = {}) {
+        const fieldsCode = Object.entries(fields)
+            .map(([name, config]) => {
+                const configStr = JSON.stringify(config, null, 4)
+                    .replace(/"([^"]+)":/g, '$1:')
+                    .replace(/"/g, "'");
+                return `    ${name}: ${configStr}`;
+            })
+            .join(',\n');
+
+        const optionsCode = options.timestamps ? '{ timestamps: true }' : '{}';
+
+        return `module.exports = async function (mongoose) {
+    const ${modelName}Schema = new mongoose.Schema({
+${fieldsCode}
+    }, ${optionsCode});
+
+    // Add any custom methods here
+    // ${modelName}Schema.methods.customMethod = function() {
+    //     // Custom instance method
+    // };
+
+    // ${modelName}Schema.statics.customStatic = function() {
+    //     // Custom static method
+    // };
+
+    return mongoose.model('${modelName}', ${modelName}Schema);
+};`;
+    }
+
+    async updateSettings(projectDir, modelName) {
+        const settingsPath = path.join(projectDir, 'settings.js');
+        let settingsContent = await fs.readFile(settingsPath, 'utf8');
+
+        // Add model to models array if not already present
+        const modelRegex = /models:\s*\[(.*?)\]/s;
+        const match = settingsContent.match(modelRegex);
+
+        if (match) {
+            const modelsArray = match[1];
+            if (!modelsArray.includes(`"${modelName}"`)) {
+                const newModelsArray = modelsArray.trim() 
+                    ? `${modelsArray.trim()}, "${modelName}"`
+                    : `"${modelName}"`;
+                settingsContent = settingsContent.replace(
+                    modelRegex,
+                    `models: [${newModelsArray}]`
+                );
+                await fs.writeFile(settingsPath, settingsContent);
+                console.log(`✅ Added "${modelName}" to settings.js models array`);
+            }
+        }
+    }
+
+    async generateCrudRoutes(projectDir, modelName) {
+        // This would generate basic CRUD routes
+        console.log(`🔧 Generating CRUD routes for ${modelName}...`);
+        // Implementation would go here
+    }
+}
+
+module.exports = ModelGenerator;

package/lib/ProjectGenerator.js

@@ -0,0 +1,246 @@
+const { input, select, confirm } = require("@inquirer/prompts");
+const fs = require("fs").promises;
+const path = require("path");
+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;
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+    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)
+        );
+    }
+
+    async createSettings(projectPath, projectName) {
+        const settings = `module.exports.settings = {
+  name: "${projectName}",
+  http: {
+    host: process.env.HTTP_HOST || "localhost",
+    port: process.env.HTTP_PORT || 3000
+  },
+  database: {
+    mongodb: {
+      database: process.env.MONGODB_URL || "mongodb://localhost:27017/${projectName}_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: {
+    jwt: {
+      key: process.env.JWT_SECRET || "your-secret-key-here",
+      validate: async (decoded, request) => {
+        // Your JWT validation logic
+        return { id: decoded.id, roles: decoded.roles };
+      }
+    },
+    default: "jwt"
+  },
+  services: [],
+  workers: [],
+  models: [],
+  routes: [],
+  crud: {
+    exclude: []
+  },
+  postInit: "post"
+};`;
+
+        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 createEnvFile(projectPath, projectName) {
+        const envContent = `# Falcon.js Environment Configuration
+# Generated by falcon-cli
+
+# Server Configuration
+HTTP_HOST=localhost
+HTTP_PORT=3000
+
+# Database Configuration  
+MONGODB_URL=mongodb://localhost:27017/${projectName}_db
+
+# MQTT Configuration
+MQTT_PORT=1883
+MQTT_URL=mqtt://localhost:1883
+
+# Redis Configuration (optional)
+REDIS_ENABLE=false
+REDIS_URL=redis://localhost:6379
+
+# Authentication
+JWT_SECRET=your-super-secret-jwt-key-change-this-in-production
+
+# Logging
+LOG_LEVEL=info
+LOG_FILE_NAME=logs/app.log
+LOG_MAX_SIZE=10M
+
+# Development Mode
+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);
+        }
+    }
+}
+
+module.exports = ProjectGenerator;

package/lib/utils.js

@@ -0,0 +1,100 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { spawn } = require('child_process');
+
+const logo = `
+███████╗ █████╗ ██╗      ██████╗ ██████╗ ███╗   ██╗
+██╔════╝██╔══██╗██║     ██╔════╝██╔═══██╗████╗  ██║
+█████╗  ███████║██║     ██║     ██║   ██║██╔██╗ ██║
+██╔══╝  ██╔══██║██║     ██║     ██║   ██║██║╚██╗██║
+██║     ██║  ██║███████╗╚██████╗╚██████╔╝██║ ╚████║
+╚═╝     ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝
+                                                    
+🚀 Falcon.js CLI - Build powerful Node.js APIs
+`;
+
+function showLogo() {
+    console.log(logo);
+}
+
+function showSuccess(projectName, skipInstall = false) {
+    console.log(`
+✅ Falcon.js project created successfully!
+
+📁 Project structure:
+   ├── index.js          # Main application entry point
+   ├── settings.js       # Falcon configuration
+   ├── .env             # Environment variables
+   ├── package.json     # Dependencies
+   ├── routes/          # API route handlers
+   ├── models/mongo/    # Database models
+   ├── services/        # Background services
+   ├── workers/         # Job processors
+   ├── validators/      # Joi validation schemas
+   ├── init/           # Initialization scripts
+   └── logs/           # Application logs
+
+🚀 Next steps:
+   1. cd ${projectName}${skipInstall ? '\n   2. npm install' : ''}
+   ${skipInstall ? '3' : '2'}. npm run dev
+
+📚 Documentation will be available at: http://localhost:3000/documentation
+❤️  Health check at: http://localhost:3000/health
+`);
+}
+
+async function createDirectory(dirPath) {
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+    } catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+}
+
+function runNpmInstall(projectPath, packageName = null) {
+    return new Promise((resolve, reject) => {
+        const args = packageName ? ['install', packageName] : ['install'];
+        const npm = spawn('npm', args, {
+            cwd: projectPath,
+            stdio: 'inherit'
+        });
+
+        npm.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            } else {
+                reject(new Error(`npm install failed with code ${code}`));
+            }
+        });
+
+        npm.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+
+function validateProjectName(name) {
+    if (!name || typeof name !== 'string') {
+        return 'Project name is required';
+    }
+    
+    if (!/^[a-z0-9-_]+$/i.test(name)) {
+        return 'Project name can only contain letters, numbers, hyphens, and underscores';
+    }
+    
+    if (name.length < 2) {
+        return 'Project name must be at least 2 characters long';
+    }
+    
+    return true;
+}
+
+module.exports = {
+    showLogo,
+    showSuccess,
+    createDirectory,
+    runNpmInstall,
+    validateProjectName
+};

package/logo.js

@@ -0,0 +1,3 @@
+module.exports.logo =`     ▄▖▄▖▄▖▄▖▄▖▖▖▄▖▄▖▄▖
+     ▐ ▙▘▐ ▌▌▙▌▙▌▌▌▙▘▙▖
+     ▐ ▌▌▟▖▙▌▌ ▌▌▙▌▌▌▙▖`

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@triophore/falcon-cli",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "bin": {
+    "falcon-cli": "./cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.9.0",
+    "acorn": "^8.15.0",
+    "ajv": "^8.17.1",
+    "escodegen": "^2.1.0",
+    "estraverse": "^5.3.0",
+    "joi": "^18.0.1",
+    "mongoose": "^8.19.3",
+    "prompt-sync": "^4.2.0",
+    "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"
+  }
+}

package/readme.md

@@ -0,0 +1,2 @@
+- create project
+- create models for both mongo and sequalize

package/schema.json

@@ -0,0 +1,42 @@
+{
+  "$id": "configSchema",
+  "type": "object",
+  "required": ["crud", "routes", "models"],
+  "properties": {
+    "crud": {
+      "type": "object",
+      "required": ["exclude"],
+      "properties": {
+        "exclude": {
+          "type": "array",
+          "items": { "type": "string" },
+          "minItems": 1
+        }
+      },
+      "additionalProperties": false
+    },
+    "auth": { "type": "object" },
+    "services": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "workers": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "preInit": { "type": "string" },
+    "postInit": { "type": "string" },
+    "routes": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "models": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1
+    }
+  },
+  "additionalProperties": false
+}

package/templates/auth_vals.json

@@ -0,0 +1,3 @@
+{
+    "basic":""
+}