@triophore/falcon-cli 1.0.0

package/builder/runMigrations.js

@@ -0,0 +1,106 @@
+// runMigrations.js
+const fs = require('fs');
+const path = require('path');
+const { Sequelize, QueryInterface } = require('sequelize');
+
+/**
+ * Run migrations from a folder
+ * @param {string} migrationsDir - Path to migrations folder
+ * @param {Sequelize} sequelize - Sequelize instance
+ * @param {('up'|'down')} direction - 'up' to apply, 'down' to rollback
+ * @param {string} [toMigration] - Run down to this migration name (optional)
+ */
+async function runMigrations(migrationsDir, sequelize, direction = 'up', toMigration = null) {
+  if (!fs.existsSync(migrationsDir)) {
+    throw new Error(`Migrations directory not found: ${migrationsDir}`);
+  }
+
+  const queryInterface = sequelize.getQueryInterface();
+
+  // Ensure SequelizeMeta table exists
+  await ensureMetaTable(queryInterface);
+
+  const executed = await getExecutedMigrations(queryInterface);
+  const allFiles = fs.readdirSync(migrationsDir)
+    .filter(f => f.endsWith('.js'))
+    .sort();
+
+  let migrationsToRun = [];
+
+  if (direction === 'up') {
+    migrationsToRun = allFiles.filter(f => !executed.includes(f));
+  } else if (direction === 'down') {
+    const targetIndex = toMigration ? allFiles.indexOf(toMigration) : allFiles.length - 1;
+    if (targetIndex === -1) throw new Error(`Migration not found: ${toMigration}`);
+    migrationsToRun = allFiles
+      .slice(0, targetIndex + 1)
+      .filter(f => executed.includes(f))
+      .reverse();
+  }
+
+  if (migrationsToRun.length === 0) {
+    console.log(`No migrations to run (${direction})`);
+    return;
+  }
+
+  console.log(`Running ${migrationsToRun.length} migration(s) ${direction}...`);
+
+  for (const file of migrationsToRun) {
+    const filePath = path.join(migrationsDir, file);
+    const migration = require(filePath);
+
+    console.log(`${direction === 'up' ? 'Applying' : 'Rolling back'}: ${file}`);
+
+    try {
+      if (direction === 'up') {
+        await migration.up(queryInterface, Sequelize);
+        await queryInterface.sequelize.query(
+          `INSERT INTO "SequelizeMeta" (name) VALUES (:name)`,
+          { replacements: { name: file } }
+        );
+      } else {
+        await migration.down(queryInterface, Sequelize);
+        await queryInterface.sequelize.query(
+          `DELETE FROM "SequelizeMeta" WHERE name = :name`,
+          { replacements: { name: file } }
+        );
+      }
+    } catch (err) {
+      console.error(`Failed on ${file}:`, err.message);
+      throw err;
+    }
+  }
+
+  console.log(`Completed ${direction} of ${migrationsToRun.length} migration(s)`);
+}
+
+// ── Ensure SequelizeMeta table exists
+async function ensureMetaTable(queryInterface) {
+  const tableExists = await queryInterface.showAllTables().then(tables => tables.includes('SequelizeMeta'));
+  if (!tableExists) {
+    await queryInterface.createTable('SequelizeMeta', {
+      name: {
+        type: Sequelize.STRING,
+        allowNull: false,
+        unique: true,
+        primaryKey: true,
+      },
+    });
+    console.log('Created SequelizeMeta table');
+  }
+}
+
+// ── Get list of executed migrations
+async function getExecutedMigrations(queryInterface) {
+  try {
+    const result = await queryInterface.sequelize.query(
+      `SELECT name FROM "SequelizeMeta" ORDER BY name`,
+      { type: queryInterface.sequelize.QueryTypes.SELECT }
+    );
+    return result.map(row => row.name);
+  } catch (err) {
+    return [];
+  }
+}
+
+module.exports = { runMigrations };

package/builder/sequelizeModelBuilder.js

@@ -0,0 +1,180 @@
+// builder/sequelizeModelBuilder.js
+const {
+  input,
+  confirm,
+  select,
+  checkbox,
+} = require('@inquirer/prompts');
+const fs = require('fs');
+const path = require('path');
+const { capitalize } = require('lodash');
+
+async function sequelizeModelBuilder(baseDir = process.cwd()) {
+  console.log('\nSequelize Model + Migration Builder\n');
+
+  const sequelizeDir = path.join(baseDir, 'models', 'sequelize');
+  const migrationsDir = path.join(baseDir, 'migrations');
+
+  // Auto-create folders
+  [sequelizeDir, migrationsDir].forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+      console.log(`Created: ${dir}`);
+    }
+  });
+
+  const modelName = await input({
+    message: 'Model name (singular, e.g., User):',
+    validate: v => v.trim() ? true : 'Required',
+  });
+
+  const tableName = await input({
+    message: 'Table name (optional, leave empty for pluralized):',
+    default: '',
+  }) || undefined;
+
+  const fields = {};
+  const indexes = [];
+  const associations = [];
+
+  // === Field Builder ===
+  while (await confirm({ message: 'Add field?', default: true })) {
+    const name = await input({ message: 'Field name:' });
+
+    const type = await select({
+      message: 'Data type:',
+      choices: [
+        'STRING', 'TEXT', 'INTEGER', 'BIGINT', 'FLOAT', 'DOUBLE', 'DECIMAL',
+        'BOOLEAN', 'DATE', 'DATEONLY', 'JSON', 'UUID', 'ENUM'
+      ],
+    });
+
+    const field = { type: `DataTypes.${type}` };
+
+    // Common options
+    if (await confirm({ message: 'Allow null?', default: true })) field.allowNull = true;
+    if (await confirm({ message: 'Unique?', default: false })) field.unique = true;
+    if (await confirm({ message: 'Primary key?', default: false })) field.primaryKey = true;
+
+    const hasDefault = await confirm({ message: 'Default value?', default: false });
+    if (hasDefault) {
+      if (type === 'BOOLEAN') field.defaultValue = await confirm({ message: 'true?', default: true });
+      else if (type === 'DATE') field.defaultValue = "DataTypes.NOW";
+      else if (type === 'UUID') field.defaultValue = "DataTypes.UUIDV4";
+      else field.defaultValue = await input({ message: 'Default (JS):' });
+    }
+
+    if (type === 'ENUM') {
+      const values = await input({ message: 'Enum values (comma-separated):' });
+      field.type = `DataTypes.ENUM(${values.split(',').map(v => `'${v.trim()}'`).join(', ')})`;
+    }
+
+    if (type === 'DECIMAL') {
+      const precision = await input({ message: 'Precision (e.g. 10):', default: '10' });
+      const scale = await input({ message: 'Scale (e.g. 2):', default: '2' });
+      field.type = `DataTypes.DECIMAL(${precision}, ${scale})`;
+    }
+
+    fields[name] = field;
+  }
+
+  // === Indexes ===
+  while (await confirm({ message: 'Add index?', default: false })) {
+    const fieldsList = await input({ message: 'Fields (comma-separated):' });
+    const opts = await checkbox({
+      message: 'Index options:',
+      choices: ['unique', 'fulltext', 'spatial'],
+    });
+    indexes.push({
+      fields: fieldsList.split(',').map(f => f.trim()),
+      unique: opts.includes('unique'),
+      type: opts.includes('fulltext') ? 'FULLTEXT' : opts.includes('spatial') ? 'SPATIAL' : undefined,
+    });
+  }
+
+  // === Associations (for future reference in code) ===
+  while (await confirm({ message: 'Add association?', default: false })) {
+    const type = await select({ message: 'Type:', choices: ['belongsTo', 'hasOne', 'hasMany', 'belongsToMany'] });
+    const target = await input({ message: 'Target model:' });
+    const options = {};
+    if (type !== 'hasMany') options.foreignKey = await input({ message: 'Foreign key:', default: `${modelName.toLowerCase()}Id` });
+    if (type === 'belongsToMany') options.through = await input({ message: 'Through table:' });
+    associations.push({ type, target, options });
+  }
+
+  // === Generate Files ===
+  const timestamp = new Date().toISOString().replace(/[-:]/g, '').split('.')[0];
+  const migrationName = `${timestamp}-create-${modelName.toLowerCase()}-table`;
+
+  const modelCode = generateSequelizeModel(modelName, fields, tableName, indexes, associations);
+  const migrationCode = generateSequelizeMigration(migrationName, modelName, fields, tableName, indexes);
+
+  const modelPath = path.join(sequelizeDir, `${capitalize(modelName)}.js`);
+  const migrationPath = path.join(migrationsDir, `${migrationName}.js`);
+
+  fs.writeFileSync(modelPath, modelCode, 'utf8');
+  fs.writeFileSync(migrationPath, migrationCode, 'utf8');
+
+  console.log(`\nModel: ${modelPath}`);
+  console.log(`Migration: ${migrationPath}\n`);
+  console.log(`Run: npx sequelize-cli db:migrate   (or let Falcon run it automatically)\n`);
+}
+
+// === Code Generators ===
+function generateSequelizeModel(name, fields, tableName, indexes, associations) {
+  const modelName = capitalize(name);
+  return `'use strict';
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('${tableName || name.toLowerCase() + 's'}', {
+      id: {
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+        type: Sequelize.INTEGER
+      },
+${Object.entries(fields)
+  .map(([k, v]) => `      ${k}: {\n        type: ${v.type},\n        allowNull: ${v.allowNull !== false},\n        ${v.unique ? 'unique: true,' : ''}\n        ${v.defaultValue ? `defaultValue: ${v.defaultValue},` : ''}\n      },`)
+  .join('\n')}
+      createdAt: { allowNull: false, type: Sequelize.DATE },
+      updatedAt: { allowNull: false, type: Sequelize.DATE },
+    });
+
+${indexes.map(idx => `    await queryInterface.addIndex('${tableName || name.toLowerCase() + 's'}', [${idx.fields.map(f => `'${f}'`).join(', ')}], { ${idx.unique ? 'unique: true,' : ''} ${idx.type ? `type: '${idx.type}',` : ''} });`).join('\n')}
+  },
+
+  down: async (queryInterface) => {
+    await queryInterface.dropTable('${tableName || name.toLowerCase() + 's'}');
+  }
+};
+`;
+}
+
+function generateSequelizeMigration(migrationName, modelName, fields, tableName, indexes) {
+  const capitalized = capitalize(modelName);
+  return `'use strict';
+const { DataTypes } = require('sequelize');
+
+module.exports = (sequelize) => {
+  const ${capitalized} = sequelize.define('${capitalized}', {
+${Object.entries(fields)
+  .map(([name, def]) => `    ${name}: {\n      type: ${def.type},\n      allowNull: ${def.allowNull !== false},\n      ${def.primaryKey ? 'primaryKey: true,' : ''}\n      ${def.unique ? 'unique: true,' : ''}\n      ${def.defaultValue ? `defaultValue: ${def.defaultValue},` : ''}\n    },`)
+  .join('\n')}
+  }, {
+    tableName: '${tableName || modelName.toLowerCase() + 's'}',
+    timestamps: true,
+    indexes: [
+${indexes.map(idx => `      { fields: [${idx.fields.map(f => `'${f}'`).join(', ')}], ${idx.unique ? 'unique: true,' : ''} ${idx.type ? `type: '${idx.type}',` : ''} },`).join('\n')}
+    ]
+  });
+
+  ${capitalized}.associate = (models) => {
+    // Add associations here later
+  };
+
+  return ${capitalized};
+};
+`;
+}
+
+module.exports = { sequelizeModelBuilder };

package/cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * Falcon CLI - Command Line Interface for Falcon.js Framework
+ * 
+ * Standard CLI structure with proper command handling
+ */
+
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+const path = require('path');
+
+// Import command modules
+const createCommand = require('./commands/create');
+const generateCommand = require('./commands/generate');
+const { version } = require('./package.json');
+
+// Setup graceful shutdown
+process.on('SIGINT', () => {
+    console.log('\n👋 Goodbye!');
+    process.exit(0);
+});
+
+process.on('uncaughtException', (error) => {
+    if (error.name === 'ExitPromptError') {
+        console.log('\n👋 Operation cancelled');
+        process.exit(0);
+    } else {
+        console.error('❌ Unexpected error:', error.message);
+        process.exit(1);
+    }
+});
+
+// CLI Configuration
+const cli = yargs(hideBin(process.argv))
+    .scriptName('falcon-cli')
+    .version(version)
+    .usage('Usage: $0 <command> [options]')
+    .help('h')
+    .alias('h', 'help')
+    .alias('v', 'version')
+    .demandCommand(1, 'You need at least one command before moving on')
+    .strict()
+    .recommendCommands()
+    .wrap(Math.min(120, process.stdout.columns || 80));
+
+// Register commands
+cli.command(createCommand);
+cli.command(generateCommand);
+
+// Global options
+cli.option('verbose', {
+    alias: 'V',
+    type: 'boolean',
+    description: 'Run with verbose logging',
+    global: true
+});
+
+// Parse and execute
+cli.parse();

package/commands/create.js

@@ -0,0 +1,57 @@
+const { input, select, confirm } = require("@inquirer/prompts");
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require('child_process');
+
+const ProjectGenerator = require('../lib/ProjectGenerator');
+const { showLogo, showSuccess } = require('../lib/utils');
+
+module.exports = {
+    command: 'create [name]',
+    describe: 'Create a new Falcon.js project',
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Project name',
+                type: 'string'
+            })
+            .option('template', {
+                alias: 't',
+                describe: 'Project template',
+                type: 'string',
+                choices: ['basic', 'api', 'microservice'],
+                default: 'basic'
+            })
+            .option('skip-install', {
+                describe: 'Skip npm install',
+                type: 'boolean',
+                default: false
+            })
+            .option('yes', {
+                alias: 'y',
+                describe: 'Use default options',
+                type: 'boolean',
+                default: false
+            });
+    },
+    handler: async (argv) => {
+        try {
+            showLogo();
+            
+            const generator = new ProjectGenerator({
+                verbose: argv.verbose,
+                skipInstall: argv.skipInstall,
+                useDefaults: argv.yes
+            });
+            
+            await generator.create(argv.name, argv.template);
+            
+        } catch (error) {
+            console.error('❌ Failed to create project:', error.message);
+            if (argv.verbose) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    }
+};

package/commands/generate.js

@@ -0,0 +1,74 @@
+const ModelGenerator = require('../lib/ModelGenerator');
+const RouteGenerator = require('../lib/RouteGenerator');
+const ServiceGenerator = require('../lib/ServiceGenerator');
+
+module.exports = {
+    command: 'generate <type> [name]',
+    aliases: ['g'],
+    describe: 'Generate project components',
+    builder: (yargs) => {
+        return yargs
+            .positional('type', {
+                describe: 'Type of component to generate',
+                type: 'string',
+                choices: ['model', 'route', 'service', 'worker', 'validator']
+            })
+            .positional('name', {
+                describe: 'Component name',
+                type: 'string'
+            })
+            .option('fields', {
+                alias: 'f',
+                describe: 'Model fields (for model generation)',
+                type: 'array'
+            })
+            .option('crud', {
+                describe: 'Generate CRUD routes (for model generation)',
+                type: 'boolean',
+                default: false
+            });
+    },
+    handler: async (argv) => {
+        try {
+            const { type, name } = argv;
+            
+            switch (type) {
+                case 'model':
+                    const modelGen = new ModelGenerator({ verbose: argv.verbose });
+                    await modelGen.generate(name, { fields: argv.fields, crud: argv.crud });
+                    break;
+                    
+                case 'route':
+                    const routeGen = new RouteGenerator({ verbose: argv.verbose });
+                    await routeGen.generate(name);
+                    break;
+                    
+                case 'service':
+                    const serviceGen = new ServiceGenerator({ verbose: argv.verbose });
+                    await serviceGen.generate(name);
+                    break;
+                    
+                case 'worker':
+                    const workerGen = new ServiceGenerator({ verbose: argv.verbose, type: 'worker' });
+                    await workerGen.generate(name);
+                    break;
+                    
+                case 'validator':
+                    const validatorGen = new RouteGenerator({ verbose: argv.verbose, type: 'validator' });
+                    await validatorGen.generate(name);
+                    break;
+                    
+                default:
+                    console.error(`❌ Unknown generator type: ${type}`);
+                    process.exit(1);
+            }
+            
+        } catch (error) {
+            console.error(`❌ Failed to generate ${argv.type}:`, error.message);
+            if (argv.verbose) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    }
+};

package/dev/Uset.schema.json

@@ -0,0 +1,18 @@
+{
+  "name": "Uset",
+  "type": "mongodb",
+  "schema": {
+    "username": {
+      "type": "string",
+      "required": true,
+      "unique": true,
+      "index": true,
+      "enum": [
+        "test"
+      ]
+    }
+  },
+  "options": {
+    "timestamps": true
+  }
+}

package/dev/buildSchemaInteractive.js

@@ -0,0 +1,189 @@
+// buildSchemaInteractive.js
+const {
+  input,
+  confirm,
+  select,
+  checkbox,
+  rawlist,
+} = require('@inquirer/prompts');
+
+/**
+ * Interactive function to build Mongoose JSON schema
+ * @returns {Promise<Object>} Final schema JSON
+ */
+async function buildMongooseSchemaInteractive() {
+  console.log('\nMongoose Schema Builder\n'.bold);
+
+  // 1. Model Name
+  const modelName = await input({
+    message: 'Model name (e.g., User, Product):',
+    validate: (v) => v.trim() ? true : 'Model name is required',
+  });
+
+  // 2. Options
+  const useTimestamps = await confirm({
+    message: 'Add timestamps (createdAt, updatedAt)?',
+    default: true,
+  });
+
+  const schema = {};
+  const options = { timestamps: useTimestamps };
+
+  console.log('\nAdd fields (one at a time):\n');
+
+  while (true) {
+    const addMore = await confirm({
+      message: 'Add a new field?',
+      default: true,
+    });
+
+    if (!addMore) break;
+
+    const fieldName = await input({
+      message: 'Field name:',
+      validate: (v) => v.trim() && !schema[v] ? true : 'Invalid or duplicate field name',
+    });
+
+    const fieldType = await select({
+      message: `Type for "${fieldName}":`,
+      choices: [
+        { name: 'string', value: 'string' },
+        { name: 'number', value: 'number' },
+        { name: 'boolean', value: 'boolean' },
+        { name: 'date', value: 'date' },
+        { name: 'objectid', value: 'objectid' },
+        { name: 'array', value: 'array' },
+        { name: 'object', value: 'object' },
+        { name: 'mixed', value: 'mixed' },
+      ],
+    });
+
+    const field = { type: fieldType };
+
+    // Common options
+    const required = await confirm({ message: 'Required?', default: false });
+    if (required) field.required = true;
+
+    const unique = await confirm({ message: 'Unique?', default: false });
+    if (unique) field.unique = true;
+
+    const index = await confirm({ message: 'Indexed?', default: false });
+    if (index) field.index = true;
+
+    // Type-specific
+    if (fieldType === 'string') {
+      const extras = await checkbox({
+        message: 'String options:',
+        choices: [
+          { name: 'trim', value: 'trim' },
+          { name: 'lowercase', value: 'lowercase' },
+          { name: 'uppercase', value: 'uppercase' },
+        ],
+      });
+      extras.forEach(opt => field[opt] = true);
+
+      const hasEnum = await confirm({ message: 'Use enum values?', default: false });
+      if (hasEnum) {
+        const enumStr = await input({ message: 'Comma-separated values (e.g., admin,user,guest):' });
+        field.enum = enumStr.split(',').map(v => v.trim()).filter(v => v);
+      }
+    }
+
+    if (fieldType === 'date' || fieldType === 'number') {
+      const hasDefaultNow = await confirm({ message: 'Default to now/current?', default: fieldType === 'date' });
+      if (hasDefaultNow) {
+        field.default = 'now';
+      }
+    }
+
+    if (fieldType === 'array') {
+      const itemType = await select({
+        message: 'Array item type:',
+        choices: [
+          { name: 'string', value: 'string' },
+          { name: 'number', value: 'number' },
+          { name: 'boolean', value: 'boolean' },
+          { name: 'date', value: 'date' },
+          { name: 'objectid', value: 'objectid' },
+          { name: 'object', value: 'object' },
+        ],
+      });
+
+      if (itemType === 'object') {
+        console.log(`\nDefine nested object for "${fieldName}[]":\n`);
+        const nested = await buildNestedObject();
+        field.items = nested;
+      } else {
+        field.items = { type: itemType };
+      }
+    }
+
+    if (fieldType === 'object') {
+      console.log(`\nDefine nested object for "${fieldName}":\n`);
+      field.properties = await buildNestedObject();
+    }
+
+    if (fieldType === 'objectid') {
+      const ref = await input({ message: 'Reference model (e.g., User):', default: modelName });
+      field.ref = ref.trim();
+    }
+
+    schema[fieldName] = field;
+  }
+
+  return {
+    name: modelName,
+    type: 'mongodb',
+    schema,
+    options,
+  };
+}
+
+// Helper: recursively build nested object
+async function buildNestedObject() {
+  const props = {};
+
+  while (true) {
+    const add = await confirm({ message: 'Add property to this object?', default: true });
+    if (!add) break;
+
+    const name = await input({ message: 'Property name:' });
+    const type = await select({
+      message: 'Type:',
+      choices: [
+        'string', 'number', 'boolean', 'date', 'objectid', 'array', 'object', 'mixed'
+      ].map(t => ({ name: t, value: t })),
+    });
+
+    const prop = { type };
+
+    if (type === 'string') {
+      const opts = await checkbox({
+        message: 'Options:',
+        choices: ['required', 'trim', 'lowercase', 'uppercase'],
+      });
+      opts.forEach(o => prop[o] = true);
+    }
+
+    if (['string', 'number', 'date'].includes(type)) {
+      const req = await confirm({ message: 'Required?', default: false });
+      if (req) prop.required = true;
+    }
+
+    if (type === 'array') {
+      const itemType = await select({ message: 'Item type:', choices: ['string', 'number', 'object'].map(t => ({ name: t, value: t })) });
+      prop.items = itemType === 'object' ? await buildNestedObject() : { type: itemType };
+    }
+
+    if (type === 'object') {
+      console.log(`\nNested object for "${name}":\n`);
+      prop.properties = await buildNestedObject();
+    }
+
+    props[name] = prop;
+  }
+
+  return props;
+}
+
+module.exports = { buildMongooseSchemaInteractive };