@triophore/falcon-cli 1.0.0

package/builder/interactiveMongobuilder.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 };

package/builder/interactiveUnifiedBuilder.js

@@ -0,0 +1,277 @@
+// interactiveUnifiedBuilder.js
+const {
+  input,
+  confirm,
+  select,
+} = require('@inquirer/prompts');
+const fs = require('fs');
+const path = require('path');
+
+async function interactiveUnifiedBuilder(baseDir, migrationsDir = './migrations') {
+  console.log('\nUnified Model Builder (Mongoose / Sequelize)\n');
+
+  // Ensure base directories exist
+  if (!fs.existsSync(baseDir)) {
+    console.log(`Creating base directory: ${baseDir}`);
+    fs.mkdirSync(baseDir, { recursive: true });
+  }
+
+  const mongoDir = path.join(baseDir, 'mongo');
+  const sequelizeDir = path.join(baseDir, 'sequelize');
+  [mongoDir, sequelizeDir].forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      console.log(`Creating directory: ${dir}`);
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  });
+
+  // Ensure migrations directory exists
+  if (!fs.existsSync(migrationsDir)) {
+    console.log(`Creating migrations directory: ${migrationsDir}`);
+    fs.mkdirSync(migrationsDir, { recursive: true });
+  }
+
+  // 1. Choose DB type
+  const dbType = await select({
+    message: 'Database type:',
+    choices: [
+      { name: 'MongoDB (Mongoose)', value: 'mongodb' },
+      { name: 'SQL (Sequelize)', value: 'sequelize' },
+    ],
+  });
+
+  const modelName = await input({
+    message: 'Model name:',
+    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 associations = [];
+  const options = { timestamps: true };
+
+  if (dbType === 'sequelize') {
+    options.paranoid = await confirm({ message: 'Enable soft deletes?', default: false });
+  }
+
+  // Load models from correct subdir
+  const modelsSubDir = dbType === 'mongodb' ? mongoDir : sequelizeDir;
+  const availableModels = loadModelsFromDir(modelsSubDir);
+
+  console.log('\nAdd fields:\n');
+
+  while (true) {
+    const add = await confirm({ message: 'Add field?', default: true });
+    if (!add) break;
+
+    const fieldName = await input({
+      message: 'Field name:',
+      validate: v => v && !schema[v] ? true : 'Invalid/duplicate',
+    });
+
+    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 required = await confirm({ message: 'Required?', default: false });
+    if (required) {
+      field[dbType === 'mongodb' ? 'required' : 'allowNull'] = dbType === 'mongodb' ? true : false;
+    }
+
+    const unique = await confirm({ message: 'Unique?', default: false });
+    if (unique) field.unique = true;
+
+    const hasDefault = await confirm({ message: 'Set default?', default: false });
+    if (hasDefault) {
+      if (fieldType.toLowerCase().includes('boolean')) {
+        field.default = await confirm({ message: 'Default TRUE?', default: true });
+      } else if (fieldType.toLowerCase().includes('date')) {
+        field.default = await confirm({ message: 'Default NOW?', default: true }) ? 'now' : await input({ message: 'Default:' });
+      } else {
+        field.default = await input({ message: 'Default value:' });
+      }
+    }
+
+    if (fieldType === 'STRING' && dbType === 'sequelize') {
+      const len = await input({ message: 'Length (default 255):', default: '255' });
+      if (len !== '255') field.type = `STRING(${len})`;
+    }
+
+    if (fieldType.toUpperCase() === 'ENUM') {
+      const vals = await input({ message: 'Comma-separated values:' });
+      field.values = vals.split(',').map(v => v.trim()).filter(Boolean);
+    }
+
+    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 };
+    }
+
+    if (fieldType.toLowerCase() === 'object') {
+      field.properties = await buildNestedObject(dbType);
+    }
+
+    schema[fieldName] = field;
+  }
+
+  // Associations
+  if (availableModels.length > 0) {
+    while (true) {
+      const addAssoc = await confirm({ message: 'Add association?', default: false });
+      if (!addAssoc) break;
+
+      const assocType = await select({
+        message: 'Association type:',
+        choices: dbType === 'mongodb'
+          ? ['hasMany', 'belongsTo']
+          : ['hasMany', 'belongsTo', 'hasOne'],
+      });
+
+      const targetModel = await select({
+        message: 'Target model:',
+        choices: availableModels.map(m => ({ name: m, value: m })),
+      });
+
+      const fk = await input({
+        message: 'Foreign key:',
+        default: `${targetModel.toLowerCase()}Id`,
+      });
+
+      const as = await input({ message: 'Alias (as):', default: targetModel.toLowerCase() });
+
+      associations.push({ type: assocType, targetModel, foreignKey: fk, as });
+    }
+  }
+
+  // Build final config
+  const config = {
+    name: modelName,
+    type: dbType,
+    tableName: tableName?.trim(),
+    schema,
+    associations,
+    options,
+  };
+
+  // Generate and SAVE migration for Sequelize
+  let migration = null;
+  if (dbType === 'sequelize') {
+    migration = generateMigration(config);
+    const migrationPath = path.join(migrationsDir, migration.fileName);
+    fs.writeFileSync(migrationPath, migration.code, 'utf8');
+    console.log(`Migration saved: ${migrationPath}`);
+  }
+
+  return {
+    config,
+    migration, // { fileName, code } or null
+  };
+}
+
+// Load model names
+function loadModelsFromDir(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter(file => file.endsWith('.json'))
+    .map(file => {
+      try {
+        const content = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+        return content.name || path.basename(file, '.json');
+      } catch (err) {
+        console.warn(`Failed to read ${file}:`, err.message);
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+// Nested object
+async function buildNestedObject(dbType) {
+  const props = {};
+  while (true) {
+    const add = await confirm({ message: 'Add nested field?', 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;
+}
+
+// ── Generate + Save Migration
+function generateMigration(config) {
+  const timestamp = new Date().toISOString().replace(/[-:T.]/g, '').slice(0, 14);
+  const table = config.tableName || `${config.name.toLowerCase()}s`;
+  const fileName = `${timestamp}-create-${table}.js`;
+
+  let code = `'use strict';\n\nmodule.exports = {\n`;
+  code += `  up: async (queryInterface, Sequelize) => {\n`;
+  code += `    await queryInterface.createTable('${table}', {\n`;
+  code += `      id: {\n`;
+  code += `        allowNull: false,\n`;
+  code += `        autoIncrement: true,\n`;
+  code += `        primaryKey: true,\n`;
+  code += `        type: Sequelize.INTEGER\n`;
+  code += `      },\n`;
+
+  for (const [field, def] of Object.entries(config.schema)) {
+    code += `      ${field}: {\n`;
+    code += `        type: ${formatType(def.type, def.values)},\n`;
+    if (def.allowNull === false) code += `        allowNull: false,\n`;
+    if (def.unique) code += `        unique: true,\n`;
+    if (def.default !== undefined) code += `        defaultValue: ${formatDefault(def.default)},\n`;
+    code = code.replace(/,\n$/, '\n') + `      },\n`;
+  }
+
+  if (config.options.timestamps) {
+    code += `      createdAt: { allowNull: false, type: Sequelize.DATE, defaultValue: Sequelize.fn('NOW') },\n`;
+    code += `      updatedAt: { allowNull: false, type: Sequelize.DATE, defaultValue: Sequelize.fn('NOW') },\n`;
+  }
+  if (config.options.paranoid) code += `      deletedAt: { type: Sequelize.DATE },\n`;
+
+  code += `    });\n`;
+  code += `  },\n\n`;
+  code += `  down: async (queryInterface) => {\n`;
+  code += `    await queryInterface.dropTable('${table}');\n`;
+  code += `  }\n};\n`;
+
+  return { fileName, code };
+}
+
+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}'`;
+}
+
+module.exports = { interactiveUnifiedBuilder };

package/builder/joiValidatorBuilder.js

@@ -0,0 +1,218 @@
+// builder/joiValidatorBuilder.js
+const {
+  input,
+  confirm,
+  select,
+  checkbox,
+} = require('@inquirer/prompts');
+const fs = require('fs');
+const path = require('path');
+
+async function joiValidatorBuilder(outputDir) {
+  console.log('\nJoi Validator Builder (Nested, Refs, Messages, Labels)\n');
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+    console.log(`Created directory: ${outputDir}`);
+  }
+
+  const validatorName = await input({
+    message: 'Validator name (e.g., CreateUser, UpdatePost):',
+    validate: v => v.trim() ? true : 'Required',
+  });
+
+  const schemaDef = {};
+  const refs = new Set();
+
+  console.log('\nAdd validation rules:\n');
+
+  while (true) {
+    const addMore = await confirm({ message: 'Add another field?', default: true });
+    if (!addMore) break;
+
+    const fieldName = await input({
+      message: 'Field name:',
+      validate: v => v && !schemaDef[v] ? true : 'Invalid or duplicate',
+    });
+
+    const type = await select({
+      message: `Joi type for "${fieldName}":`,
+      choices: [
+        'string', 'number', 'boolean', 'date',
+        'object', 'array', 'binary', 'any', 'ref'
+      ].map(t => ({ name: t, value: t })),
+    });
+
+    let rule = type === 'ref' ? null : `Joi.${type}()`;
+
+    // Required / Optional / Forbidden
+    const presence = await select({
+      message: 'Presence:',
+      choices: [
+        { name: 'Required', value: 'required' },
+        { name: 'Optional', value: 'optional' },
+        { name: 'Forbidden', value: 'forbidden' },
+        { name: 'Allow null/empty', value: 'allow_null' },
+      ],
+      default: 'optional',
+    });
+
+    if (presence === 'required') rule += `.required()`;
+    if (presence === 'forbidden') rule += `.forbidden()`;
+    if (presence === 'allow_null') rule += `.allow(null, '')`;
+
+    // Label & Description
+    const label = await input({ message: 'Label (for error messages):', default: fieldName });
+    if (label) rule += `.label('${label}')`;
+
+    const description = await input({ message: 'Description (optional):' });
+    if (description) rule += `.description('${description}')`;
+
+    // Type-specific rules
+    if (type === 'string') {
+      const opts = await checkbox({
+        message: 'String rules:',
+        choices: ['email', 'uri', 'uuid', 'lowercase', 'uppercase', 'trim', 'min', 'max', 'length', 'pattern', 'alphanum', 'token'],
+      });
+
+      if (opts.includes('email')) rule += `.email({ tlds: { allow: false } })`;
+      if (opts.includes('uri')) rule += `.uri()`;
+      if (opts.includes('uuid')) rule += `.uuid()`;
+      if (opts.includes('lowercase')) rule += `.lowercase()`;
+      if (opts.includes('uppercase')) rule += `.uppercase()`;
+      if (opts.includes('trim')) rule += `.trim()`;
+      if (opts.includes('alphanum')) rule += `.alphanum()`;
+      if (opts.includes('token')) rule += `.token()`;
+
+      if (opts.includes('min')) {
+        const min = await input({ message: 'Min length:' });
+        rule += `.min(${min})`;
+      }
+      if (opts.includes('max')) {
+        const max = await input({ message: 'Max length:' });
+        rule += `.max(${max})`;
+      }
+      if (opts.includes('length')) {
+        const len = await input({ message: 'Exact length:' });
+        rule += `.length(${len})`;
+      }
+      if (opts.includes('pattern')) {
+        const regex = await input({ message: 'Regex (without //):' });
+        rule += `.pattern(new RegExp('${regex}'))`;
+      }
+    }
+
+    if (type === 'number') {
+      const opts = await checkbox({
+        message: 'Number rules:',
+        choices: ['integer', 'positive', 'min', 'max', 'greater', 'less', 'precision'],
+      });
+      if (opts.includes('integer')) rule += `.integer()`;
+      if (opts.includes('positive')) rule += `.positive()`;
+      if (opts.includes('min')) {
+        const min = await input({ message: 'Min value:' });
+        rule += `.min(${min})`;
+      }
+      if (opts.includes('max')) {
+        const max = await input({ message: 'Max value:' });
+        rule += `.max(${max})`;
+      }
+      if (opts.includes('precision')) {
+        const p = await input({ message: 'Precision (decimal places):' });
+        rule += `.precision(${p})`;
+      }
+    }
+
+    if (type === 'array') {
+      const itemsType = await select({
+        message: 'Array items type:',
+        choices: ['string', 'number', 'object', 'ref', 'nested validator'],
+      });
+
+      if (itemsType === 'ref') {
+        const refKey = await input({ message: 'Ref key (e.g., userId):' });
+        refs.add(refKey);
+        rule += `.items(Joi.ref('${refKey}'))`;
+      } else if (itemsType === 'nested validator') {
+        const nested = await buildNestedObject();
+        rule += `.items(${nested})`;
+      } else {
+        rule += `.items(Joi.${itemsType}())`;
+      }
+
+      const arrayRules = await checkbox({
+        message: 'Array rules:',
+        choices: ['min', 'max', 'length', 'unique'],
+      });
+      if (arrayRules.includes('min')) {
+        const min = await input({ message: 'Min items:' });
+        rule += `.min(${min})`;
+      }
+      if (arrayRules.includes('max')) {
+        const max = await input({ message: 'Max items:' });
+        rule += `.max(${max})`;
+      }
+      if (arrayRules.includes('unique')) rule += `.unique()`;
+    }
+
+    if (type === 'object') {
+      const nested = await buildNestedObject();
+      rule = nested;
+    }
+
+    if (type === 'ref') {
+      const refKey = await input({ message: 'Reference key (e.g., user.id):' });
+      refs.add(refKey.split('.')[0]);
+      rule = `Joi.ref('${refKey}')`;
+    }
+
+    // Custom error message
+    const customMsg = await input({ message: 'Custom error message (optional):' });
+    if (customMsg) rule += `.messages({ 'any.required': '${customMsg}', 'string.base': '${customMsg}' })`;
+
+    schemaDef[fieldName] = rule;
+  }
+
+  const code = generateJoiValidatorCode(validatorName, schemaDef, refs);
+  const filePath = path.join(outputDir, `${validatorName}.js`);
+
+  fs.writeFileSync(filePath, code, 'utf8');
+  console.log(`\nValidator created: ${filePath}\n`);
+}
+
+async function buildNestedObject() {
+  let code = 'Joi.object({\n';
+  while (await confirm({ message: 'Add nested field?', default: true })) {
+    const name = await input({ message: 'Field name:' });
+    const type = await select({
+      message: 'Type:',
+      choices: ['string', 'number', 'boolean', 'date', 'array', 'object', 'any'],
+    });
+    let rule = `Joi.${type}()`;
+    if (type === 'array') {
+      const itemType = await select({ message: 'Array items:', choices: ['string', 'number', 'object'] });
+      rule = `Joi.array().items(Joi.${itemType}())`;
+    }
+    if (type === 'object') rule = await buildNestedObject();
+    code += `      ${name}: ${rule},\n`;
+  }
+  code += '    })';
+  return code;
+}
+
+function generateJoiValidatorCode(name, fields, refs) {
+  let code = `'use strict';\n`;
+  code += `const Joi = require('joi');\n\n`;
+  code += `const ${name} = Joi.object({\n`;
+
+  Object.entries(fields).forEach(([field, rule]) => {
+    code += `  ${field}: ${rule},\n`;
+  });
+
+  code += `});\n\n`;
+  code += `module.exports = ${name};\n`;
+
+  return code;
+}
+
+module.exports = { joiValidatorBuilder };