@triophore/falcon-cli 1.0.0

package/dev/generateSequelizeFiles.js

@@ -0,0 +1,167 @@
+// generateSequelizeFiles.js
+const fs = require('fs');
+const path = require('path');
+
+function generateModelFile(config) {
+  const { name, schema, associations, options } = config;
+  const modelName = name;
+  const tableName = options.tableName;
+
+  let code = `const { DataTypes } = require('sequelize');\n\n`;
+  code += `module.exports = (sequelize) => {\n`;
+  code += `  const ${modelName} = sequelize.define('${modelName}', {\n`;
+
+  for (const [field, def] of Object.entries(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.defaultValue !== undefined) {
+      code += `      defaultValue: ${formatDefault(def.defaultValue)},\n`;
+    }
+    code = code.replace(/,\n$/, '\n'); // remove last comma
+    code += `    },\n`;
+  }
+
+  code += `  }, {\n`;
+  code += `    tableName: '${tableName}',\n`;
+  code += `    timestamps: ${options.timestamps},\n`;
+  code += `    paranoid: ${options.paranoid},\n`;
+  code += `    freezeTableName: true\n`;
+  code += `  });\n\n`;
+
+  // Associations
+  if (associations.length > 0) {
+    code += `  // Associations\n`;
+    associations.forEach(assoc => {
+      if (assoc.type === 'belongsTo') {
+        code += `  ${modelName}.belongsTo(sequelize.models.${assoc.targetModel}, { foreignKey: '${assoc.foreignKey}', as: '${assoc.as}' });\n`;
+      } else if (assoc.type === 'hasMany') {
+        code += `  ${modelName}.hasMany(sequelize.models.${assoc.targetModel}, { foreignKey: '${assoc.foreignKey}', as: '${assoc.as}' });\n`;
+      }
+    });
+  }
+
+  code += `\n  return ${modelName};\n};\n`;
+
+  return code;
+}
+
+function generateMigrationFile(config) {
+  const timestamp = new Date().toISOString().replace(/[-:T.]/g, '').slice(0, 14);
+  const migrationName = `create-${config.tableName}`;
+  const fileName = `${timestamp}-${migrationName}.js`;
+
+  let code = `'use strict';\n\n`;
+  code += `module.exports = {\n`;
+  code += `  up: async (queryInterface, Sequelize) => {\n`;
+  code += `    await queryInterface.createTable('${config.tableName}', {\n`;
+
+  // Add id
+  code += `      id: {\n`;
+  code += `        allowNull: false,\n`;
+  code += `        autoIncrement: true,\n`;
+  code += `        primaryKey: true,\n`;
+  code += `        type: Sequelize.INTEGER\n`;
+  code += `      },\n`;
+
+  // Add fields
+  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.defaultValue !== undefined) {
+      code += `        defaultValue: ${formatDefault(def.defaultValue)},\n`;
+    }
+    code = code.replace(/,\n$/, '\n');
+    code += `      },\n`;
+  }
+
+  // Timestamps
+  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`;
+
+  // Add indexes
+  code += `\n    // Indexes\n`;
+  for (const [field, def] of Object.entries(config.schema)) {
+    if (def.unique) {
+      code += `    await queryInterface.addIndex('${config.tableName}', ['${field}'], { unique: true });\n`;
+    }
+  }
+
+  // Foreign keys
+  const fks = config.associations.filter(a => a.type === 'belongsTo');
+  if (fks.length > 0) {
+    code += `\n    // Foreign Keys\n`;
+    for (const fk of fks) {
+      code += `    await queryInterface.addConstraint('${config.tableName}', {\n`;
+      code += `      fields: ['${fk.foreignKey}'],\n`;
+      code += `      type: 'foreign key',\n`;
+      code += `      name: 'fk_${config.tableName}_${fk.foreignKey}',\n`;
+      code += `      references: { table: '${fk.targetModel.toLowerCase()}s', field: 'id' },\n`;
+      code += `      onDelete: 'SET NULL',\n`;
+      code += `      onUpdate: 'CASCADE'\n`;
+      code += `    });\n`;
+    }
+  }
+
+  code += `  },\n\n`;
+
+  code += `  down: async (queryInterface) => {\n`;
+  code += `    await queryInterface.dropTable('${config.tableName}');\n`;
+  code += `  }\n};\n`;
+
+  return { fileName, code };
+}
+
+function formatType(type, enumValues) {
+  if (type.includes('[]')) {
+    const base = type.replace('[]', '');
+    return `Sequelize.ARRAY(Sequelize.${base})`;
+  }
+  if (type.includes('(')) {
+    const [base, len] = type.split('(');
+    return `Sequelize.${base}(${len}`;
+  }
+  if (type === 'ENUM') {
+    return `Sequelize.ENUM(${enumValues.map(v => `'${v}'`).join(', ')})`;
+  }
+  return `Sequelize.${type}`;
+}
+
+function formatDefault(val) {
+  if (val === 'sequelize.fn("NOW")') return `Sequelize.fn('NOW')`;
+  if (val === true) return 'true';
+  if (val === false) return 'false';
+  if (!isNaN(val)) return val;
+  return `'${val}'`;
+}
+
+function exportFiles(config) {
+  const modelDir = 'models';
+  const migrationDir = 'migrations';
+
+  if (!fs.existsSync(modelDir)) fs.mkdirSync(modelDir);
+  if (!fs.existsSync(migrationDir)) fs.mkdirSync(migrationDir);
+
+  // Model
+  const modelCode = generateModelFile(config);
+  fs.writeFileSync(path.join(modelDir, `${config.name}.js`), modelCode);
+
+  // Migration
+  const { fileName, code } = generateMigrationFile(config);
+  fs.writeFileSync(path.join(migrationDir, fileName), code);
+
+  console.log(`Model: ${modelDir}/${config.name}.js`);
+  console.log(`Migration: ${migrationDir}/${fileName}`);
+}
+
+module.exports = { exportFiles };

package/dev/interactiveJoiBuilder.js

@@ -0,0 +1,177 @@
+// interactiveJoiBuilder.js
+const {
+  input,
+  confirm,
+  select,
+  checkbox,
+} = require('@inquirer/prompts');
+const fs = require('fs');
+const path = require('path');
+
+async function interactiveJoiBuilder() {
+  console.log('\nJoi Schema Builder\n');
+
+  const schemaName = await input({
+    message: 'Schema name (e.g., UserSchema):',
+    default: 'MySchema',
+  });
+
+  const schema = {};
+  console.log('\nAdd fields:\n');
+
+  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.trim() && !schema[v] ? true : 'Invalid or duplicate name',
+    });
+
+    const type = await select({
+      message: `Type for "${fieldName}":`,
+      choices: [
+        { name: 'string', value: 'string' },
+        { name: 'number', value: 'number' },
+        { name: 'boolean', value: 'boolean' },
+        { name: 'date', value: 'date' },
+        { name: 'array', value: 'array' },
+        { name: 'object', value: 'object' },
+        { name: 'any', value: 'any' },
+      ],
+    });
+
+    const field = { type };
+
+    // Required
+    const required = await confirm({ message: 'Required?', default: false });
+    if (required) field.required = true;
+
+    // Default
+    const hasDefault = await confirm({ message: 'Set default value?', default: false });
+    if (hasDefault) {
+      if (type === 'boolean') {
+        field.default = await confirm({ message: 'Default TRUE?', default: true });
+      } else if (type === 'date') {
+        const now = await confirm({ message: 'Default to now?', default: true });
+        field.default = now ? 'Date.now()' : await input({ message: 'Default value (JS):' });
+      } else {
+        field.default = await input({ message: 'Default value (JS literal):' });
+      }
+    }
+
+    // Type-specific rules
+    if (type === 'string') {
+      const stringRules = await checkbox({
+        message: 'String rules:',
+        choices: [
+          { name: 'email', value: 'email' },
+          { name: 'trim', value: 'trim' },
+          { name: 'lowercase', value: 'lowercase' },
+          { name: 'uppercase', value: 'uppercase' },
+          { name: 'alphanum', value: 'alphanum' },
+          { name: 'uuid', value: 'uuid' },
+        ],
+      });
+      stringRules.forEach(r => field[r] = true);
+
+      const min = await input({ message: 'Min length (or leave empty):' });
+      const max = await input({ message: 'Max length (or leave empty):' });
+      if (min) field.min = +min;
+      if (max) field.max = +max;
+
+      const hasRegex = await confirm({ message: 'Add regex pattern?', default: false });
+      if (hasRegex) {
+        const pattern = await input({ message: 'Regex (e.g., ^[a-z]+$):' });
+        field.regex = pattern;
+      }
+
+      const hasEnum = await confirm({ message: 'Use allowed values (enum)?', default: false });
+      if (hasEnum) {
+        const values = await input({ message: 'Comma-separated values:' });
+        field.enum = values.split(',').map(v => v.trim()).filter(Boolean);
+      }
+    }
+
+    if (type === 'number') {
+      const numberRules = await checkbox({
+        message: 'Number rules:',
+        choices: [
+          { name: 'integer', value: 'integer' },
+          { name: 'positive', value: 'positive' },
+          { name: 'negative', value: 'negative' },
+        ],
+      });
+      numberRules.forEach(r => field[r] = true);
+
+      const min = await input({ message: 'Min value:' });
+      const max = await input({ message: 'Max value:' });
+      if (min) field.min = +min;
+      if (max) field.max = +max;
+    }
+
+    if (type === 'array') {
+      const itemType = await select({
+        message: 'Array item type:',
+        choices: ['string', 'number', 'object', 'any'].map(t => ({ name: t, value: t })),
+      });
+      field.items = { type: itemType };
+
+      const min = await input({ message: 'Min items:' });
+      const max = await input({ message: 'Max items:' });
+      if (min) field.min = +min;
+      if (max) field.max = +max;
+
+      const unique = await confirm({ message: 'Unique items?', default: false });
+      if (unique) field.unique = true;
+    }
+
+    if (type === 'object') {
+      console.log(`\nDefine nested object for "${fieldName}":\n`);
+      field.properties = await buildNestedObject();
+    }
+
+    schema[fieldName] = field;
+  }
+
+  return { name: schemaName, schema };
+}
+
+// Recursive nested object builder
+async function buildNestedObject() {
+  const props = {};
+  while (true) {
+    const add = await confirm({ message: 'Add nested field?', default: true });
+    if (!add) break;
+
+    const name = await input({ message: 'Field name:' });
+    const type = await select({
+      message: 'Type:',
+      choices: ['string', 'number', 'boolean', 'date', 'array', 'object', 'any'].map(t => ({ name: t, value: t })),
+    });
+
+    const field = { type };
+    const required = await confirm({ message: 'Required?', default: false });
+    if (required) field.required = true;
+
+    if (type === 'string') {
+      const rules = await checkbox({
+        message: 'Rules:',
+        choices: ['email', 'trim', 'lowercase'],
+      });
+      rules.forEach(r => field[r] = true);
+    }
+
+    if (type === 'object') {
+      field.properties = await buildNestedObject();
+    }
+
+    props[name] = field;
+  }
+  return props;
+}
+
+module.exports = { interactiveJoiBuilder };

package/dev/ra.js

@@ -0,0 +1,22 @@
+// run.js
+const { interactiveModelBuilder } = require('./interactiveModelBuilder');
+const { generateAllFiles } = require('./generateAllFiles');
+const { createModelFromJson } = require('./createModelFromJson');
+const { createJoiSchemaFromJson } = require('./createJoiSchemaFromJson');
+
+(async () => {
+  try {
+    const config = await interactiveModelBuilder();
+    console.log('\nConfig:'.green, JSON.stringify(config, null, 2));
+
+    generateAllFiles(config);
+
+    // Optional: test
+    const result = createModelFromJson(config);
+    const joi = createJoiSchemaFromJson({ schema: config.joi });
+    console.log('\nJoi schema ready! Use:'.cyan, `joi.validate(data)`);
+
+  } catch (err) {
+    console.error('Cancelled:', err.message);
+  }
+})();

package/dev/rj.js

@@ -0,0 +1,18 @@
+// run.js
+const { interactiveJoiBuilder } = require('./interactiveJoiBuilder');
+const { generateJoiFile } = require('./generateJoiFile');
+
+(async () => {
+  try {
+    console.clear();
+    const config = await interactiveJoiBuilder();
+    console.log('\nGenerated Joi Config:'.green);
+    console.log(JSON.stringify(config, null, 2));
+
+    generateJoiFile(config, './joi-schemas');
+
+    console.log('\nJoi schema generated and saved!'.green);
+  } catch (err) {
+    console.error('Cancelled or error:'.red, err.message);
+  }
+})();

package/dev/run.js

@@ -0,0 +1,16 @@
+const { buildMongooseSchemaInteractive } = require('./buildSchemaInteractive');
+
+(async () => {
+  try {
+    const schemaJson = await buildMongooseSchemaInteractive();
+    console.log('\nGenerated Schema JSON:'.green);
+    console.log(JSON.stringify(schemaJson, null, 2));
+
+    // Optional: Save to file
+    const fs = require('fs');
+    fs.writeFileSync(`${schemaJson.name}.schema.json`, JSON.stringify(schemaJson, null, 2));
+    console.log(`\nSaved to ${schemaJson.name}.schema.json`.green);
+  } catch (err) {
+    console.error('Cancelled or error:', err.message);
+  }
+})();

package/dev/run_seq.js

@@ -0,0 +1,18 @@
+// run.js
+const { buildSequelizeSchemaInteractive } = require('./buildSequelizeSchemaInteractive');
+const { exportFiles } = require('./generateSequelizeFiles');
+
+(async () => {
+  try {
+    console.clear();
+    const config = await buildSequelizeSchemaInteractive();
+    console.log('\nGenerated Config:'.green);
+    console.log(JSON.stringify(config, null, 2));
+
+    exportFiles(config);
+
+    console.log('\nAll files generated successfully!'.green);
+  } catch (err) {
+    console.error('Cancelled or error:'.red, err.message);
+  }
+})();

package/dev/tracker.js

@@ -0,0 +1,23 @@
+class Tracker {
+  constructor(fpath) {
+    this.fpath = fpath;
+  }
+
+  async check_tracker_exists() {
+    return require("fs").existsSync(fpath);
+  }
+
+  async check_tracker_valid() {
+    try {
+      JSON.parse(fstring);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async check_tracker_read() {
+    return require("fs").readFileSync(fpath);
+  }
+}
+module.exports.Tracker = Tracker;

package/editJsConfig.js

@@ -0,0 +1,188 @@
+// editJsConfig.js
+const fs = require('fs');
+const path = require('path');
+const acorn = require('acorn');
+const estraverse = require('estraverse');
+const escodegen = require('escodegen');
+
+/**
+ * READ: Get the current settings object from JS file
+ * @param {string} filePath
+ * @returns {Object} settings object
+ */
+function getJsConfigProperties(filePath) {
+  const fullPath = path.resolve(filePath);
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`File not found: ${fullPath}`);
+  }
+
+  const code = fs.readFileSync(fullPath, 'utf8');
+  const ast = acorn.parse(code, {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    locations: true,
+  });
+
+  let settingsValue = null;
+
+  estraverse.traverse(ast, {
+    enter(node) {
+      if (
+        node.type === 'AssignmentExpression' &&
+        node.left.type === 'MemberExpression' &&
+        node.left.object.name === 'module' &&
+        node.left.property.name === 'exports' &&
+        node.right.type === 'MemberExpression' &&
+        node.right.property.name === 'settings'
+      ) {
+        settingsValue = evaluateObjectExpression(node.right.object);
+        this.break(); // Stop traversal
+      }
+    }
+  });
+
+  if (settingsValue === null) {
+    throw new Error('Could not find module.exports.settings');
+  }
+
+  return settingsValue;
+}
+
+/**
+ * EDIT: Edit a nested property and save file
+ * @param {string} filePath
+ * @param {string} propPath - e.g., 'crud.exclude', 'routes'
+ * @param {any} newValue
+ * @returns {boolean}
+ */
+function editJsConfig(filePath, propPath, newValue) {
+  try {
+    const fullPath = path.resolve(filePath);
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`File not found: ${fullPath}`);
+    }
+
+    const code = fs.readFileSync(fullPath, 'utf8');
+    const ast = acorn.parse(code, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      locations: true,
+    });
+
+    let modified = false;
+    const pathParts = propPath.split('.');
+
+    estraverse.traverse(ast, {
+      enter(node) {
+        if (
+          node.type === 'AssignmentExpression' &&
+          node.left.type === 'MemberExpression' &&
+          node.left.object.name === 'module' &&
+          node.left.property.name === 'exports' &&
+          node.right.type === 'MemberExpression' &&
+          node.right.property.name === 'settings'
+        ) {
+          modified = editNestedProperty(node.right.object, pathParts, newValue);
+        }
+      }
+    });
+
+    if (!modified) {
+      throw new Error(`Property "${propPath}" not found`);
+    }
+
+    const newCode = escodegen.generate(ast, {
+      format: {
+        indent: { style: '    ' },
+        newline: '\n',
+        quotes: 'double',
+        semicolons: true,
+      },
+    });
+
+    fs.writeFileSync(fullPath, newCode, 'utf8');
+    console.log(`Updated: ${propPath}`);
+    return true;
+  } catch (err) {
+    console.error('Edit error:', err.message);
+    return false;
+  }
+}
+
+// ── Helper: Evaluate ObjectExpression → JS Object
+function evaluateObjectExpression(node) {
+  if (node.type !== 'ObjectExpression') return null;
+
+  const obj = {};
+  for (const prop of node.properties) {
+    if (prop.type !== 'Property' || prop.key.type !== 'Identifier') continue;
+
+    const key = prop.key.name;
+    const valueNode = prop.value;
+
+    switch (valueNode.type) {
+      case 'Literal':
+        obj[key] = valueNode.value;
+        break;
+      case 'ArrayExpression':
+        obj[key] = valueNode.elements.map(el => el.type === 'Literal' ? el.value : null);
+        break;
+      case 'ObjectExpression':
+        obj[key] = evaluateObjectExpression(valueNode);
+        break;
+      default:
+        obj[key] = null; // Unsupported
+    }
+  }
+  return obj;
+}
+
+// ── Helper: Edit nested property in AST
+function editNestedProperty(node, pathParts, newValue) {
+  if (pathParts.length === 0 || node.type !== 'ObjectExpression') return false;
+
+  const currentKey = pathParts[0];
+
+  for (const prop of node.properties) {
+    if (
+      prop.type === 'Property' &&
+      prop.key.type === 'Identifier' &&
+      prop.key.name === currentKey
+    ) {
+      if (pathParts.length === 1) {
+        prop.value = createLiteralNode(newValue);
+        return true;
+      } else {
+        return editNestedProperty(prop.value, pathParts.slice(1), newValue);
+      }
+    }
+  }
+  return false;
+}
+
+// ── Helper: Convert JS value → AST node
+function createLiteralNode(value) {
+  if (Array.isArray(value)) {
+    return {
+      type: 'ArrayExpression',
+      elements: value.map(v => createLiteralNode(v)),
+    };
+  }
+  if (value === null || typeof value !== 'object') {
+    return { type: 'Literal', value };
+  }
+  return {
+    type: 'ObjectExpression',
+    properties: Object.entries(value).map(([k, v]) => ({
+      type: 'Property',
+      key: { type: 'Identifier', name: k },
+      value: createLiteralNode(v),
+      kind: 'init',
+    })),
+  };
+}
+
+module.exports = {
+  getJsConfigProperties,
+  editJsConfig,
+};