@triophore/falcon-cli 1.0.0

package/dev/buildSequelizeSchemaInteractive.js

@@ -0,0 +1,128 @@
+// buildSequelizeSchemaInteractive.js
+const {
+  input,
+  confirm,
+  select,
+  checkbox,
+} = require('@inquirer/prompts');
+
+async function buildSequelizeSchemaInteractive() {
+  console.log('\nSequelize Model + Migration Builder\n');
+
+  const modelName = await input({
+    message: 'Model name (singular, e.g., User):',
+    validate: v => v.trim() ? true : 'Required',
+  });
+
+  const tableName = await input({
+    message: 'Table name (or press Enter to use model name):',
+    default: modelName.toLowerCase() + 's',
+  });
+
+  const useTimestamps = await confirm({
+    message: 'Add timestamps (createdAt, updatedAt)?',
+    default: true,
+  });
+
+  const useParanoid = await confirm({
+    message: 'Enable soft deletes (deletedAt)?',
+    default: false,
+  });
+
+  const schema = {};
+  const associations = [];
+  const options = {
+    timestamps: useTimestamps,
+    paranoid: useParanoid,
+    tableName: tableName.trim() || undefined,
+    freezeTableName: true,
+  };
+
+  // ── Fields
+  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 dataType = await select({
+      message: `Data type for "${fieldName}":`,
+      choices: [
+        'STRING', 'TEXT', 'INTEGER', 'BIGINT', 'FLOAT', 'DOUBLE',
+        'BOOLEAN', 'DATE', 'DATEONLY', 'JSON', 'ARRAY', 'ENUM'
+      ].map(t => ({ name: t, value: t })),
+    });
+
+    const field = { type: dataType };
+
+    const allowNull = await confirm({ message: 'Allow NULL?', default: true });
+    if (!allowNull) field.allowNull = false;
+
+    const unique = await confirm({ message: 'Unique?', default: false });
+    if (unique) field.unique = true;
+
+    // Default value
+    const hasDefault = await confirm({ message: 'Set default?', default: false });
+    if (hasDefault) {
+      if (dataType === 'BOOLEAN') {
+        field.defaultValue = await confirm({ message: 'Default TRUE?', default: true });
+      } else if (dataType === 'DATE') {
+        field.defaultValue = await confirm({ message: 'Default NOW?', default: true })
+          ? 'sequelize.fn("NOW")'
+          : await input({ message: 'Default (JS):' });
+      } else if (dataType === 'ENUM') {
+        const vals = await input({ message: 'Enum values (comma-separated):' });
+        field.values = vals.split(',').map(v => v.trim()).filter(Boolean);
+        const def = await input({ message: 'Default value:' });
+        field.defaultValue = def.trim();
+      } else {
+        const def = await input({ message: 'Default value (JS):' });
+        field.defaultValue = def;
+      }
+    }
+
+    // String length
+    if (dataType === 'STRING') {
+      const len = await input({ message: 'Length (default 255):', default: '255' });
+      if (len !== '255') field.type = `STRING(${len})`;
+    }
+
+    // Array items
+    if (dataType === 'ARRAY') {
+      const itemType = await select({
+        message: 'Array item type:',
+        choices: ['STRING', 'INTEGER', 'FLOAT', 'BOOLEAN', 'DATE'].map(t => ({ name: t, value: t })),
+      });
+      field.type = `${itemType}[]`;
+    }
+
+    schema[fieldName] = field;
+  }
+
+  // ── Associations
+  while (true) {
+    const addAssoc = await confirm({ message: 'Add association?', default: false });
+    if (!addAssoc) break;
+
+    const type = await select({
+      message: 'Association type:',
+      choices: [
+        { name: 'belongsTo', value: 'belongsTo' },
+        { name: 'hasMany', value: 'hasMany' },
+      ],
+    });
+
+    const targetModel = await input({ message: 'Target model name:' });
+    const foreignKey = await input({ message: 'Foreign key (in this table):', default: `${targetModel}Id` });
+    const as = await input({ message: 'Alias (as):', default: targetModel.toLowerCase() });
+
+    associations.push({ type, targetModel, foreignKey, as });
+  }
+
+  return { name: modelName, tableName: tableName.trim(), schema, associations, options };
+}
+
+module.exports = { buildSequelizeSchemaInteractive };

package/dev/createJoiSchemaFromJson.js

@@ -0,0 +1,137 @@
+// createJoiSchemaFromJson.js
+const Joi = require('joi');
+
+/**
+ * Converts custom JSON schema → Joi schema
+ * @param {Object} config - Your JSON config
+ * @returns {Joi.ObjectSchema}
+ */
+function createJoiSchemaFromJson(config) {
+  if (!config || !config.schema) {
+    throw new Error('Config must have "schema"');
+  }
+
+  const schemaDef = config.schema;
+  const joiDef = {};
+
+  for (const [fieldName, field] of Object.entries(schemaDef)) {
+    let joiField = null;
+
+    const type = (field.type || '').toLowerCase();
+
+    // Base type
+    switch (type) {
+      case 'string':
+        joiField = Joi.string();
+        if (field.trim) joiField = joiField.trim();
+        if (field.lowercase) joiField = joiField.lowercase();
+        if (field.uppercase) joiField = joiField.uppercase();
+        if (field.email) joiField = joiField.email();
+        if (field.min) joiField = joiField.min(field.min);
+        if (field.max) joiField = joiField.max(field.max);
+        if (field.regex) joiField = joiField.pattern(new RegExp(field.regex));
+        if (field.enum) joiField = joiField.valid(...field.enum);
+        break;
+
+      case 'number':
+        joiField = Joi.number();
+        if (field.min !== undefined) joiField = joiField.min(field.min);
+        if (field.max !== undefined) joiField = joiField.max(field.max);
+        if (field.integer) joiField = joiField.integer();
+        break;
+
+      case 'boolean':
+        joiField = Joi.boolean();
+        break;
+
+      case 'date':
+        joiField = Joi.date();
+        if (field.min) joiField = joiField.min(field.min);
+        if (field.max) joiField = joiField.max(field.max);
+        break;
+
+      case 'array':
+        const items = convertItem(field.items || { type: 'string' });
+        joiField = Joi.array().items(items);
+        if (field.min) joiField = joiField.min(field.min);
+        if (field.max) joiField = joiField.max(field.max);
+        if (field.unique) joiField = joiField.unique();
+        break;
+
+      case 'object':
+        joiField = Joi.object(createNestedJoi(field.properties || {}));
+        break;
+
+      case 'objectid':
+        joiField = field.ref
+          ? Joi.any().meta({ ref: field.ref }) // custom tag
+          : Joi.string().length(24).hex(); // MongoID
+        break;
+
+      case 'mixed':
+      default:
+        joiField = Joi.any();
+    }
+
+    // Required
+    if (field.required) {
+      joiField = joiField.required();
+    } else {
+      joiField = joiField.optional();
+    }
+
+    // Default
+    if (field.default !== undefined) {
+      const def = field.default === 'now' ? new Date() : field.default;
+      joiField = joiField.default(def);
+    }
+
+    joiDef[fieldName] = joiField;
+  }
+
+  return Joi.object(joiDef).options({ stripUnknown: true });
+}
+
+// Helper: recursive nested object
+function createNestedJoi(properties) {
+  const nested = {};
+  for (const [key, field] of Object.entries(properties)) {
+    nested[key] = convertFieldToJoi(field);
+  }
+  return nested;
+}
+
+// Convert single field (used in array items & nested)
+function convertFieldToJoi(field) {
+  const type = (field.type || '').toLowerCase();
+  let joi = null;
+
+  switch (type) {
+    case 'string': joi = Joi.string(); break;
+    case 'number': joi = Joi.number(); break;
+    case 'boolean': joi = Joi.boolean(); break;
+    case 'date': joi = Joi.date(); break;
+    case 'objectid': joi = Joi.string().hex().length(24); break;
+    case 'array':
+      const items = convertFieldToJoi(field.items || { type: 'string' });
+      joi = Joi.array().items(items);
+      break;
+    case 'object':
+      joi = Joi.object(createNestedJoi(field.properties || {}));
+      break;
+    default: joi = Joi.any();
+  }
+
+  if (field.required) joi = joi.required();
+  if (field.default !== undefined) joi = joi.default(field.default === 'now' ? new Date() : field.default);
+  if (field.enum) joi = joi.valid(...field.enum);
+
+  return joi;
+}
+
+// Helper for array items
+function convertItem(item) {
+  return convertFieldToJoi(item);
+}
+
+module.exports = { createJoiSchemaFromJson };

package/dev/createModelFromJson.js

@@ -0,0 +1,280 @@
+// interactiveUnifiedBuilder.js
+const {
+  input,
+  confirm,
+  select,
+  checkbox,
+} = require('@inquirer/prompts');
+const fs = require('fs');
+const path = require('path');
+
+async function interactiveUnifiedBuilder(baseDir) {
+  console.log('\nUnified Model Builder (Mongoose / Sequelize)\n');
+
+  // Ensure base directory exists
+  if (!fs.existsSync(baseDir)) {
+    console.log(`Creating base directory: ${baseDir}`);
+    fs.mkdirSync(baseDir, { recursive: true });
+  }
+
+  // Define subdirectories
+  const mongoDir = path.join(baseDir, 'mongo');
+  const sequelizeDir = path.join(baseDir, 'sequelize');
+
+  // Create mongo and sequelize folders if they don't exist
+  [mongoDir, sequelizeDir].forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      console.log(`Creating directory: ${dir}`);
+      fs.mkdirSync(dir, { 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 migration only for Sequelize
+  let migration = null;
+  if (dbType === 'sequelize') {
+    migration = generateMigration(config);
+  }
+
+  return {
+    config,
+    migration, // { fileName, code } or null
+  };
+}
+
+// Load model names from directory
+function loadModelsFromDir(dir) {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+
+  return fs.readdirSync(dir)
+    .filter(file => file.endsWith('.json'))
+    .map(file => {
+      try {
+        const filePath = path.join(dir, file);
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return content.name || path.basename(file, '.json');
+      } catch (err) {
+        console.warn(`Failed to read ${file}:`, err.message);
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+// Nested object builder
+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 Migration String (Sequelize only)
+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/dev/generateAllFiles.js

@@ -0,0 +1,45 @@
+// generateAllFiles.js
+const fs = require('fs');
+const path = require('path');
+const { createModelFromJson } = require('./createModelFromJson');
+const { createJoiSchemaFromJson } = require('./createJoiSchemaFromJson');
+
+function generateAllFiles(config) {
+  const baseDir = 'generated';
+  const modelDir = path.join(baseDir, config.type);
+  const joiDir = path.join(baseDir, 'joi');
+  const migDir = path.join(baseDir, 'migrations');
+
+  [baseDir, modelDir, joiDir, migDir].forEach(dir => {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  });
+
+  // 1. Model (Mongoose or Sequelize)
+  const result = createModelFromJson(config);
+  const modelPath = path.join(modelDir, `${config.name}.js`);
+  fs.writeFileSync(modelPath, generateModelCode(result));
+
+  // 2. Joi Schema
+  const joiSchema = createJoiSchemaFromJson({ schema: config.joi });
+  const joiCode = `const Joi = require('joi');\nmodule.exports = ${joiSchema.toString().replace('Joi.object()', 'Joi.object')};`;
+  fs.writeFileSync(path.join(joiDir, `${config.name}.js`), joiCode);
+
+  // 3. Migration (Sequelize only)
+  if (config.type === 'sequelize' && result.migration) {
+    fs.writeFileSync(path.join(migDir, result.migration.fileName), result.migration.code);
+  }
+
+  console.log(`Model: ${modelPath}`);
+  console.log(`Joi: ${joiDir}/${config.name}.js`);
+  if (result.migration) console.log(`Migration: ${migDir}/${result.migration.fileName}`);
+}
+
+function generateModelCode(result) {
+  if (result.type === 'mongoose') {
+    return `const mongoose = require('mongoose');\nconst schema = new mongoose.Schema(${JSON.stringify(result.schema.tree, null, 2)}, { timestamps: true });\nmodule.exports = mongoose.model('${result.modelName}', schema);`;
+  } else {
+    return `const { DataTypes } = require('sequelize');\nmodule.exports = (sequelize) => {\n  return sequelize.define('${result.modelName}', ${JSON.stringify(result.Model.rawAttributes, null, 2)}, { tableName: '${result.Model.getTableName()}', timestamps: true });\n};`;
+  }
+}
+
+module.exports = { generateAllFiles };

package/dev/generateJoiFile.js

@@ -0,0 +1,95 @@
+// generateJoiFile.js
+const fs = require('fs');
+const path = require('path');
+const Joi = require('joi');
+
+function generateJoiFile(config, outputDir = './joi') {
+  const { name, schema } = config;
+
+  // Build Joi schema
+  const joiSchema = buildJoiSchema(schema);
+
+  // Generate code
+  let code = `const Joi = require('joi');\n\n`;
+  code += `const ${name} = ${joiSchema.toString().replace(/Joi\.object\(\)/g, 'Joi.object')}\n\n`;
+  code += `module.exports = ${name};\n`;
+
+  // Ensure directory
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Write file
+  const filePath = path.join(outputDir, `${name}.js`);
+  fs.writeFileSync(filePath, code);
+
+  console.log(`Joi schema saved: ${filePath}`);
+}
+
+function buildJoiSchema(def) {
+  const schema = {};
+
+  for (const [key, field] of Object.entries(def)) {
+    let joiField;
+
+    switch (field.type) {
+      case 'string':
+        joiField = Joi.string();
+        if (field.email) joiField = joiField.email();
+        if (field.trim) joiField = joiField.trim();
+        if (field.lowercase) joiField = joiField.lowercase();
+        if (field.uppercase) joiField = joiField.uppercase();
+        if (field.alphanum) joiField = joiField.alphanum();
+        if (field.uuid) joiField = joiField.uuid();
+        if (field.min) joiField = joiField.min(field.min);
+        if (field.max) joiField = joiField.max(field.max);
+        if (field.regex) joiField = joiField.pattern(new RegExp(field.regex));
+        if (field.enum) joiField = joiField.valid(...field.enum);
+        break;
+
+      case 'number':
+        joiField = Joi.number();
+        if (field.integer) joiField = joiField.integer();
+        if (field.positive) joiField = joiField.positive();
+        if (field.negative) joiField = joiField.negative();
+        if (field.min) joiField = joiField.min(field.min);
+        if (field.max) joiField = joiField.max(field.max);
+        break;
+
+      case 'boolean':
+        joiField = Joi.boolean();
+        break;
+
+      case 'date':
+        joiField = Joi.date();
+        break;
+
+      case 'array':
+        const items = buildJoiSchema({ item: field.items }).item;
+        joiField = Joi.array().items(items);
+        if (field.min) joiField = joiField.min(field.min);
+        if (field.max) joiField = joiField.max(field.max);
+        if (field.unique) joiField = joiField.unique();
+        break;
+
+      case 'object':
+        joiField = Joi.object(buildJoiSchema(field.properties));
+        break;
+
+      default:
+        joiField = Joi.any();
+    }
+
+    if (field.required) joiField = joiField.required();
+    if (field.default !== undefined) {
+      const def = field.default === 'Date.now()' ? Date.now : field.default;
+      joiField = joiField.default(def);
+    }
+
+    schema[key] = joiField;
+  }
+
+  return Joi.object(schema);
+}
+
+module.exports = { generateJoiFile };