@triophore/falcon-cli 1.0.0

package/README.md

@@ -0,0 +1,62 @@
+# Falcon CLI
+
+Command-line interface for creating and managing Falcon.js applications.
+
+## Installation
+
+```bash
+npm install -g falcon-cli
+```
+
+## Usage
+
+### Create a new project
+```bash
+falcon-cli create my-app
+falcon-cli create my-app --template api
+falcon-cli create my-app --skip-install
+```
+
+### Generate components
+```bash
+# Generate a model
+falcon-cli generate model User
+falcon-cli g model Product --crud
+
+# Generate a route
+falcon-cli generate route users
+
+# Generate a service
+falcon-cli generate service email
+
+# Generate a worker
+falcon-cli generate worker image-processor
+```
+
+## Commands
+
+- `create [name]` - Create a new Falcon.js project
+- `generate <type> [name]` - Generate project components
+  - Types: `model`, `route`, `service`, `worker`, `validator`
+
+## Options
+
+- `--verbose, -V` - Run with verbose logging
+- `--help, -h` - Show help
+- `--version, -v` - Show version
+
+## Project Structure
+
+```
+my-falcon-app/
+├── index.js              # Application entry point
+├── settings.js           # Falcon configuration
+├── .env                  # Environment variables
+├── models/mongo/         # Mongoose models
+├── routes/               # API routes
+├── services/             # Background services
+├── workers/              # Job processors
+├── validators/           # Joi validation schemas
+├── init/                 # Initialization scripts
+└── logs/                 # Application logs
+```

package/auth/basic.js

@@ -0,0 +1,8 @@
+module.exports.validate = async function (request, username, password, CONTXET) {
+    // TODO: Implement your own logic here
+    // Example: Check against database or environment variables
+    if (username === process.env.ADMIN_USER && password === process.env.ADMIN_PASSWORD) {
+        return { isValid: true, credentials: { id: 1, name: 'Admin', roles: ['admin'], permissions: { admin: ['*'] } } };
+    }
+    return { isValid: false };
+}

package/auth/cookie.js

@@ -0,0 +1,10 @@
+module.exports.validate = async function (request, session, CONTXET) {
+    // TODO: Implement your own logic here
+    // Example: Validate session against database or Redis
+    /*
+    if (session.valid) {
+        return { isValid: true, credentials: { id: session.userId, ... } };
+    }
+    */
+    return { isValid: false };
+}

package/auth/jwks.js

@@ -0,0 +1,6 @@
+module.exports.validate = async function (decoded, CONTXET) {
+    if (username === 'admin' && password === 'secret') {
+        return { isValid: true, credentials: { id: 1, name: 'Admin', roles: ['admin'], permissions: { admin: ['*'] } } };
+    }
+    return { isValid: false };
+}

package/auth/jwt.js

@@ -0,0 +1,9 @@
+module.exports.validate = async function (decoded, CONTXET) {
+    // TODO: Implement your own logic here
+    // Example: Check against database or environment variables
+    // For example, check if a specific environment variable matches a decoded value
+    if (decoded.role === process.env.EXPECTED_ADMIN_ROLE && decoded.secret === process.env.EXPECTED_ADMIN_SECRET) {
+        return { isValid: true, credentials: { id: decoded.sub, name: 'Admin', roles: ['admin'] } };
+    }
+    return { isValid: false };
+}

package/auth/openid.js

@@ -0,0 +1,5 @@
+module.exports.validate = async function (decoded, CONTXET) {
+    // TODO: Implement your own logic here
+    // Example: Validate OpenID token claims
+    return { isValid: false };
+}

package/auth/webscoket.js

@@ -0,0 +1,6 @@
+module.exports.validate = async function (decoded, CONTXET) {
+    if (username === 'admin' && password === 'secret') {
+        return { isValid: true, credentials: { id: 1, name: 'Admin', roles: ['admin'], permissions: { admin: ['*'] } } };
+    }
+    return { isValid: false };
+}

package/builder/createCjsModule.js

@@ -0,0 +1,95 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Create a CJS module from data that may include raw JS expressions
+ * @param {string} filePath
+ * @param {Object} data - Can include strings starting with 'JS:' for raw code
+ * @param {Object} options
+ */
+async function createCjsModule(filePath, data, options = {}) {
+  const {
+    exportStyle = 'default',
+    functionName = 'getValue',
+    pretty = true,
+    async = false,
+    imports = false
+  } = options;
+
+  const dir = path.dirname(filePath);
+  await fs.promises.mkdir(dir, { recursive: true });
+
+  let content = '';
+
+  // Helper: convert value to JS source string
+  function toSource(value, indent = '  ') {
+    // Special case: raw JS code via prefix
+    if (typeof value === 'string' && value.startsWith('JS:')) {
+      const rawCode = value.slice(3).trim();
+      return rawCode;
+    }
+
+    // Functions: preserve source if possible
+    if (typeof value === 'function') {
+      const funcStr = value.toString();
+      return pretty ? funcStr.split('\n').map(line => indent + line).join('\n') : funcStr;
+    }
+
+    // Objects/Arrays: recursive
+    if (value && typeof value === 'object') {
+      if (Array.isArray(value)) {
+        const items = value.map(v => toSource(v, indent + '  '));
+        return `[\n${indent}  ${items.join(`,\n${indent}  `)}\n${indent}]`;
+      } else {
+        const entries = Object.entries(value)
+          .map(([k, v]) => `${indent}  ${JSON.stringify(k)}: ${toSource(v, indent + '  ')}`);
+        return `{\n${entries.join(`,\n`)}\n${indent}}`;
+      }
+    }
+
+    // Primitives
+    return JSON.stringify(value);
+  }
+
+  const dataSource = toSource(data, '');
+
+  switch (exportStyle) {
+    case 'default':
+      content = `module.exports.${functionName} = ${dataSource};\n`;
+      break;
+
+    case 'named':
+      if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        throw new Error('Named exports require a plain object');
+      }
+      const namedLines = Object.entries(data)
+        .filter(([_, v]) => !v?.toString().startsWith?.('function')) // skip functions for now
+        .map(([key, value]) => {
+          const src = toSource(value, '');
+          return `exports.${key} = ${src};`;
+        });
+      content = namedLines.join('\n') + '\n';
+      break;
+
+    case 'function':
+      const asyncKw = async ? 'async ' : '';
+      const returnVal = async ? `Promise.resolve(${dataSource})` : dataSource;
+      content = `module.exports.${functionName} = ${asyncKw}() => ${returnVal};\n`;
+      break;
+
+    default:
+      throw new Error(`Invalid exportStyle: ${exportStyle}`);
+  }
+
+  if (imports) {
+    await fs.promises.appendFile(filePath, imports, 'utf8');
+    await fs.promises.appendFile(filePath, content, 'utf8');
+  } else {
+    await fs.promises.writeFile(filePath, content, 'utf8');
+    return path.resolve(filePath);
+  }
+
+
+}
+
+module.exports = { createCjsModule };

package/builder/editModelInteractive.js

@@ -0,0 +1,159 @@
+// editModelInteractive.js
+const {
+  input,
+  confirm,
+  select,
+} = require('@inquirer/prompts');
+const fs = require('fs');
+const path = require('path');
+const { interactiveUnifiedBuilder } = require('./interactiveUnifiedBuilder');
+
+async function editModelInteractive(baseDir, modelName) {
+  const mongoDir = path.join(baseDir, 'mongo');
+  const sequelizeDir = path.join(baseDir, 'sequelize');
+
+  // Find model
+  let filePath = path.join(mongoDir, `${modelName}.json`);
+  let isMongo = fs.existsSync(filePath);
+  if (!isMongo) {
+    filePath = path.join(sequelizeDir, `${modelName}.json`);
+    isMongo = false;
+  }
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Model "${modelName}" not found in ${mongoDir} or ${sequelizeDir}`);
+  }
+
+  const existingConfig = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  const dbType = existingConfig.type || (isMongo ? 'mongodb' : 'sequelize');
+
+  if (dbType === 'mongodb') {
+    throw new Error('Edit with alter migration is only supported for Sequelize (SQL). Use Mongoose schema evolution.');
+  }
+
+  console.log(`\nEditing SEQUELIZE model: ${modelName}\n`);
+
+  // Reuse interactive builder to get new config
+  const { config: newConfig } = await interactiveUnifiedBuilder(baseDir);
+
+  // Merge: keep only name, type, tableName, options
+  const updatedConfig = {
+    name: modelName,
+    type: 'sequelize',
+    tableName: newConfig.tableName || existingConfig.tableName,
+    schema: newConfig.schema,
+    associations: newConfig.associations.length > 0 ? newConfig.associations : (existingConfig.associations || []),
+    options: { ...existingConfig.options, ...newConfig.options },
+  };
+
+  // Generate alter migration
+  const migration = generateAlterMigration(existingConfig, updatedConfig);
+
+  // Save updated JSON
+  const savePath = path.join(sequelizeDir, `${modelName}.json`);
+  fs.writeFileSync(savePath, JSON.stringify(updatedConfig, null, 2), 'utf8');
+  console.log(`Updated model saved: ${savePath}`);
+
+  return { config: updatedConfig, migration };
+}
+
+// ── Generate Real Alter Migration
+function generateAlterMigration(oldConfig, newConfig) {
+  const timestamp = new Date().toISOString().replace(/[-:T.]/g, '').slice(0, 14);
+  const table = newConfig.tableName || `${newConfig.name.toLowerCase()}s`;
+  const fileName = `${timestamp}-alter-${table}.js`;
+
+  const oldFields = oldConfig.schema || {};
+  const newFields = newConfig.schema || {};
+
+  const added = Object.keys(newFields).filter(f => !oldFields[f]);
+  const removed = Object.keys(oldFields).filter(f => !newFields[f]);
+  const changed = Object.keys(newFields).filter(f => oldFields[f] && !deepEqual(oldFields[f], newFields[f]));
+
+  if (added.length === 0 && removed.length === 0 && changed.length === 0 && oldConfig.tableName === newConfig.tableName) {
+    return null; // No changes
+  }
+
+  let upCode = [];
+  let downCode = [];
+
+  // Add columns
+  added.forEach(field => {
+    const def = newFields[field];
+    upCode.push(`    await queryInterface.addColumn('${table}', '${field}', ${formatField(def)});`);
+    downCode.push(`    await queryInterface.removeColumn('${table}', '${field}');`);
+  });
+
+  // Remove columns
+  removed.forEach(field => {
+    upCode.push(`    await queryInterface.removeColumn('${table}', '${field}');`);
+    downCode.push(`    await queryInterface.addColumn('${table}', '${field}', ${formatField(oldFields[field])});`);
+  });
+
+  // Change columns
+  changed.forEach(field => {
+    const def = newFields[field];
+    upCode.push(`    await queryInterface.changeColumn('${table}', '${field}', ${formatField(def)});`);
+    downCode.push(`    await queryInterface.changeColumn('${table}', '${field}', ${formatField(oldFields[field])});`);
+  });
+
+  // Rename table
+  if (oldConfig.tableName && newConfig.tableName && oldConfig.tableName !== newConfig.tableName) {
+    upCode.unshift(`    await queryInterface.renameTable('${oldConfig.tableName}', '${newConfig.tableName}');`);
+    downCode.unshift(`    await queryInterface.renameTable('${newConfig.tableName}', '${oldConfig.tableName}');`);
+  }
+
+  let code = `'use strict';\n\nmodule.exports = {\n`;
+  code += `  up: async (queryInterface, Sequelize) => {\n`;
+  code += upCode.join('\n') || `    // No schema changes detected\n`;
+  code += `\n  },\n\n`;
+  code += `  down: async (queryInterface, Sequelize) => {\n`;
+  code += downCode.join('\n') || `    // No rollback needed\n`;
+  code += `\n  }\n};\n`;
+
+  return { fileName, code };
+}
+
+// Format field for migration
+function formatField(field) {
+  const parts = [];
+  parts.push(`type: ${formatType(field.type, field.values)}`);
+  if (field.allowNull === false) parts.push(`allowNull: false`);
+  if (field.unique) parts.push(`unique: true`);
+  if (field.default !== undefined) parts.push(`defaultValue: ${formatDefault(field.default)}`);
+
+  return `{ ${parts.join(', ')} }`;
+}
+
+function formatType(type, values) {
+  if (type.includes('[]')) return `Sequelize.ARRAY(Sequelize.${type.replace('[]', '')})`;
+  if (type.includes('(')) return `Sequelize.${type}`;
+  if (type === 'ENUM') return `Sequelize.ENUM(${values.map(v => `'${v}'`).join(', ')})`;
+  return `Sequelize.${type}`;
+}
+
+function formatDefault(val) {
+  if (val === 'now') return `Sequelize.fn('NOW')`;
+  if (val === true) return 'true';
+  if (val === false) return 'false';
+  if (!isNaN(val)) return val;
+  return `'${val}'`;
+}
+
+// Deep compare (for changed detection)
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== 'object' || typeof b !== 'object' || a == null || b == null) return false;
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    if (!deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+
+module.exports = { editModelInteractive };

package/builder/interactiveModelBuilder.js

@@ -0,0 +1,215 @@
+// interactiveModelBuilder.js
+const {
+  input,
+  confirm,
+  select,
+  checkbox,
+} = require('@inquirer/prompts');
+const fs = require('fs');
+const path = require('path');
+
+async function interactiveModelBuilder() {
+  console.log('\nUnified Model Builder (Mongoose / Sequelize / Joi)\n');
+
+  // ── 1. Database Type
+  const dbType = await select({
+    message: 'Choose database:',
+    choices: [
+      { name: 'MongoDB (Mongoose)', value: 'mongodb' },
+      { name: 'SQL (Sequelize)', value: 'sequelize' },
+    ],
+  });
+
+  // ── 2. Model Name
+  const modelName = await input({
+    message: 'Model name (e.g., User):',
+    validate: v => v.trim() ? true : 'Required',
+  });
+
+  const tableName = dbType === 'sequelize' ? await input({
+    message: 'Table name (or Enter for default):',
+    default: modelName.toLowerCase() + 's',
+  }) : undefined;
+
+  const schema = {};
+  const joiRules = {};
+  const associations = [];
+  const options = { timestamps: true };
+
+  if (dbType === 'sequelize') {
+    options.paranoid = await confirm({ message: 'Enable soft deletes (deletedAt)?', default: false });
+  }
+
+  console.log('\nAdd fields:\n');
+
+  // ── 3. Fields
+  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 && !schema[v] ? true : 'Invalid/duplicate',
+    });
+
+    // Type selection
+    const typeChoices = dbType === 'mongodb'
+      ? ['string', 'number', 'boolean', 'date', 'objectid', 'array', 'object', 'mixed']
+      : ['STRING', 'TEXT', 'INTEGER', 'FLOAT', 'BOOLEAN', 'DATE', 'JSON', 'ARRAY', 'ENUM'];
+
+    const fieldType = await select({
+      message: `Type for "${fieldName}":`,
+      choices: typeChoices.map(t => ({ name: t, value: t })),
+    });
+
+    const field = { type: fieldType };
+    const joiField = {};
+
+    // ── Common Options
+    const required = await confirm({ message: 'Required?', default: false });
+    if (required) {
+      field[dbType === 'mongodb' ? 'required' : 'allowNull'] = dbType === 'mongodb' ? true : false;
+      joiField.required = true;
+    }
+
+    const unique = await confirm({ message: 'Unique?', default: false });
+    if (unique) {
+      field.unique = true;
+      joiField.unique = true;
+    }
+
+    // ── Default Value
+    const hasDefault = await confirm({ message: 'Set default?', default: false });
+    if (hasDefault) {
+      if (fieldType.toLowerCase() === 'boolean') {
+        const val = await confirm({ message: 'Default TRUE?', default: true });
+        field.default = val;
+        joiField.default = val;
+      } else if (fieldType.toLowerCase().includes('date')) {
+        const now = await confirm({ message: 'Default to NOW?', default: true });
+        field.default = now ? 'now' : await input({ message: 'Default value:' });
+        joiField.default = now ? 'now' : field.default;
+      } else {
+        const def = await input({ message: 'Default value:' });
+        field.default = def;
+        joiField.default = def;
+      }
+    }
+
+    // ── String Options (Mongoose & Sequelize)
+    if (fieldType.toLowerCase() === 'string') {
+      const stringOpts = await checkbox({
+        message: 'String options:',
+        choices: ['trim', 'lowercase', 'uppercase', 'email'],
+      });
+      stringOpts.forEach(opt => {
+        if (opt !== 'email') field[opt] = true;
+        if (opt === 'email') joiField.email = true;
+        if (opt === 'trim') joiField.trim = true;
+        if (opt === 'lowercase') joiField.lowercase = true;
+      });
+
+      if (dbType === 'sequelize') {
+        const len = await input({ message: 'Length (default 255):', default: '255' });
+        if (len !== '255') field.type = `STRING(${len})`;
+      }
+    }
+
+    // ── Number/Date Min/Max
+    if (['number', 'integer', 'float', 'date'].includes(fieldType.toLowerCase())) {
+      const min = await input({ message: 'Min value (or leave empty):' });
+      const max = await input({ message: 'Max value (or leave empty):' });
+      if (min) { field.min = +min; joiField.min = +min; }
+      if (max) { field.max = +max; joiField.max = +max; }
+    }
+
+    // ── Enum
+    if (fieldType.toUpperCase() === 'ENUM') {
+      const values = await input({ message: 'Comma-separated values:' });
+      const vals = values.split(',').map(v => v.trim()).filter(Boolean);
+      field.values = vals;
+      joiField.enum = vals;
+    }
+
+    // ── Array
+    if (fieldType.toLowerCase() === 'array') {
+      const itemType = await select({
+        message: 'Array item type:',
+        choices: dbType === 'mongodb'
+          ? ['string', 'number', 'object', 'objectid']
+          : ['STRING', 'INTEGER', 'FLOAT'],
+      });
+      field.items = { type: itemType };
+      joiField.items = { type: itemType.toLowerCase() };
+    }
+
+    // ── Nested Object
+    if (fieldType.toLowerCase() === 'object') {
+      field.properties = await buildNestedObject(dbType);
+      joiField.properties = await buildNestedJoi();
+    }
+
+    schema[fieldName] = field;
+    joiRules[fieldName] = joiField;
+  }
+
+  // ── 4. Associations
+  while (true) {
+    const addAssoc = await confirm({ message: 'Add association?', default: false });
+    if (!addAssoc) break;
+
+    const assocType = await select({
+      message: 'Type:',
+      choices: dbType === 'mongodb'
+        ? ['hasMany', 'belongsTo']
+        : ['hasMany', 'belongsTo', 'hasOne'],
+    });
+
+    const target = await input({ message: 'Target model:' });
+    const fk = await input({ message: 'Foreign key:', default: `${modelName.toLowerCase()}Id` });
+    const as = await input({ message: 'Alias (as):', default: target.toLowerCase() });
+
+    associations.push({ type: assocType, targetModel: target, foreignKey: fk, as });
+  }
+
+  return {
+    name: modelName,
+    type: dbType,
+    tableName: tableName?.trim(),
+    schema,
+    joi: joiRules,
+    associations,
+    options,
+  };
+}
+
+// Helper: nested object
+async function buildNestedObject(dbType) {
+  const props = {};
+  while (true) {
+    const add = await confirm({ message: 'Add property?', default: true });
+    if (!add) break;
+    const name = await input({ message: 'Name:' });
+    const type = await select({
+      message: 'Type:',
+      choices: dbType === 'mongodb'
+        ? ['string', 'number', 'boolean', 'date', 'objectid']
+        : ['STRING', 'INTEGER', 'BOOLEAN', 'DATE'],
+    });
+    props[name] = { type };
+  }
+  return props;
+}
+
+async function buildNestedJoi() {
+  const props = {};
+  while (true) {
+    const add = await confirm({ message: 'Add Joi rule?', default: true });
+    if (!add) break;
+    const name = await input({ message: 'Field name:' });
+    props[name] = { type: 'string' }; // simplified
+  }
+  return props;
+}
+
+module.exports = { interactiveModelBuilder };