langaro-api 1.0.1 → 1.0.4

package/bin/langaro-api.js

@@ -3,7 +3,6 @@
 const fs = require('fs');
 const path = require('path');
 
-// Load config from langaro-api.config.js at cwd, or use defaults
 function loadConfig() {
   const configPath = path.resolve(process.cwd(), 'langaro-api.config.js');
   if (fs.existsSync(configPath)) {
@@ -13,59 +12,170 @@ function loadConfig() {
   return {};
 }
 
-// ── Commands ──
+// ── Interactive menu (arrow keys) ──
 
-const command = process.argv[2];
+function singleSelect(question, options) {
+  return new Promise((resolve) => {
+    let cursor = 0;
+    // Count how many terminal lines the question occupies (including trailing newlines)
+    const questionLines = question.split('\n').length;
+    const totalLines = questionLines + options.length;
 
-if (command === 'init') {
-  // Project scaffolding
-  const runInit = require('../lib/cli/init');
-  runInit();
-} else if (command === 'new') {
-  // Interactive resource generator
-  const runNew = require('../lib/cli/new');
+    function render() {
+      process.stdout.write(`\x1b[${totalLines}A\x1b[J`);
+      console.log(question);
+      options.forEach((opt, i) => {
+        const pointer = i === cursor ? '\x1b[36m> \x1b[0m' : '  ';
+        const label = i === cursor ? `\x1b[36m${opt.label}\x1b[0m` : opt.label;
+        const desc = opt.desc ? `\x1b[90m — ${opt.desc}\x1b[0m` : '';
+        console.log(`${pointer}${label}${desc}`);
+      });
+    }
+
+    console.log(question);
+    options.forEach((opt, i) => {
+      const pointer = i === cursor ? '\x1b[36m> \x1b[0m' : '  ';
+      const label = i === cursor ? `\x1b[36m${opt.label}\x1b[0m` : opt.label;
+      const desc = opt.desc ? `\x1b[90m — ${opt.desc}\x1b[0m` : '';
+      console.log(`${pointer}${label}${desc}`);
+    });
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+
+    const onKeypress = (key) => {
+      if (key[0] === 27 && key[1] === 91 && key[2] === 65) {
+        cursor = (cursor - 1 + options.length) % options.length;
+        render();
+      } else if (key[0] === 27 && key[1] === 91 && key[2] === 66) {
+        cursor = (cursor + 1) % options.length;
+        render();
+      } else if (key[0] === 13 || key[0] === 10) {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener('data', onKeypress);
+        resolve(options[cursor].value);
+      } else if (key[0] === 113 || key[0] === 3) {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener('data', onKeypress);
+        process.exit(0);
+      }
+    };
+
+    process.stdin.on('data', onKeypress);
+  });
+}
+
+function confirm(question) {
+  return singleSelect(question, [
+    { label: 'Yes, proceed' , value: true },
+    { label: 'No, cancel', value: false },
+  ]);
+}
+
+// ── Command runners ──
+
+function runGenerateTypes() {
+  const { generateTypes } = require('../lib/index');
   const config = loadConfig();
-  runNew(config);
-} else {
-  // Default: generate types
+  generateTypes(config);
+  console.log('[langaro-api] Types + JSDoc annotations generated.');
+}
+
+function runWatch() {
   const { generateTypes, getWatchDirs } = require('../lib/index');
 
-  function run() {
+  function generate() {
     const config = loadConfig();
     generateTypes(config);
     console.log('[langaro-api] Types + JSDoc annotations generated.');
   }
 
-  run();
+  generate();
 
-  // Watch mode
-  if (process.argv.includes('--watch')) {
-    const config = loadConfig();
-    const dirs = getWatchDirs(config);
-
-    let debounceTimer = null;
+  const config = loadConfig();
+  const dirs = getWatchDirs(config);
+  let debounceTimer = null;
 
-    function onChange() {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(() => {
-        try {
-          run();
-        } catch (err) {
-          console.error('[langaro-api] Error:', err.message);
+  dirs.forEach((dir) => {
+    try {
+      fs.watch(dir, { recursive: true }, (eventType, filename) => {
+        if (filename && filename.endsWith('.js')) {
+          if (debounceTimer) clearTimeout(debounceTimer);
+          debounceTimer = setTimeout(() => {
+            try { generate(); } catch (err) { console.error('[langaro-api] Error:', err.message); }
+          }, 300);
         }
-      }, 300);
+      });
+    } catch (err) {
+      console.warn(`[langaro-api] Could not watch ${dir}: ${err.message}`);
     }
+  });
 
-    dirs.forEach((dir) => {
-      try {
-        fs.watch(dir, { recursive: true }, (eventType, filename) => {
-          if (filename && filename.endsWith('.js')) onChange();
-        });
-      } catch (err) {
-        console.warn(`[langaro-api] Could not watch ${dir}: ${err.message}`);
-      }
-    });
+  console.log(`[langaro-api] Watching ${dirs.length} directories for changes...`);
+}
+
+async function runInit() {
+  const ok = await confirm('\n\x1b[33mThis will create project files in the current directory.\x1b[0m Are you sure?\n');
+  if (!ok) { console.log('\nAborted.\n'); process.exit(0); }
+  const init = require('../lib/cli/init');
+  await init();
+}
+
+async function runMigrate() {
+  const ok = await confirm('\n\x1b[33mThis will replace your index.js files with langaro-api loaders.\x1b[0m Are you sure?\n');
+  if (!ok) { console.log('\nAborted.\n'); process.exit(0); }
+  const migrate = require('../lib/cli/migrate');
+  migrate();
+}
+
+async function runNew() {
+  const newCmd = require('../lib/cli/new');
+  const config = loadConfig();
+  await newCmd(config);
+}
+
+// ── Main ──
 
-    console.log(`[langaro-api] Watching ${dirs.length} directories for changes...`);
+async function main() {
+  const command = process.argv[2];
+
+  // Direct commands (for scripts, CI, --watch)
+  if (command === 'init') return runInit();
+  if (command === 'migrate') return runMigrate();
+  if (command === 'new') return runNew();
+  if (command === '--watch') return runWatch();
+  if (command === 'generate' || command === 'types') {
+    runGenerateTypes();
+    return process.exit(0);
+  }
+
+  // No args + non-TTY (e.g. piped, CI): just generate types
+  if (!process.stdin.isTTY) {
+    runGenerateTypes();
+    return process.exit(0);
   }
+
+  // No args + TTY: interactive menu
+  console.log('\n\x1b[36m  langaro-api\x1b[0m\n');
+
+  const choice = await singleSelect('  What would you like to do?\n', [
+    { label: 'Generate types', value: 'types', desc: 'Generate .d.ts files and inject JSDoc annotations' },
+    { label: 'New resource', value: 'new', desc: 'Scaffold a new controller, service, model, or route' },
+    { label: 'Migrate project', value: 'migrate', desc: 'Replace index.js files with langaro-api loaders' },
+    { label: 'Init new project', value: 'init', desc: 'Scaffold a full project from scratch' },
+  ]);
+
+  console.log('');
+
+  if (choice === 'types') { runGenerateTypes(); process.exit(0); }
+  if (choice === 'new') return runNew();
+  if (choice === 'migrate') return runMigrate();
+  if (choice === 'init') return runInit();
+
+  return undefined;
 }
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/lib/cli/init.js

@@ -1,7 +1,8 @@
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
-const { execSync } = require('child_process');
+
+const OWN_VERSION = require('../../package.json').version;
 
 function ask(rl, question, defaultVal) {
   const suffix = defaultVal ? ` (${defaultVal})` : '';
@@ -14,6 +15,10 @@ function ask(rl, question, defaultVal) {
 
 function writeFile(root, filePath, content) {
   const full = path.join(root, filePath);
+  if (fs.existsSync(full)) {
+    console.log(`  \x1b[33mskip\x1b[0m    ${filePath} (already exists)`);
+    return;
+  }
   fs.mkdirSync(path.dirname(full), { recursive: true });
   fs.writeFileSync(full, content);
   console.log(`  \x1b[32mcreated\x1b[0m ${filePath}`);
@@ -75,7 +80,7 @@ function packageJson(name) {
       'knex-extended-crud': '^2.0.31',
       'knex-paginate': '3.2.0',
       'knex-schema-inspector': '^3.0.0',
-      'langaro-api': '^2.0.0',
+      'langaro-api': `^${OWN_VERSION}`,
       lodash: '^4.17.21',
       morgan: '^1.10.0',
       multer: '^1.4.5-lts.1',

package/lib/cli/migrate.js

@@ -0,0 +1,99 @@
+const fs = require('fs');
+const path = require('path');
+
+const INDEX_REPLACEMENTS = {
+  'src/database/models/index.js': `const { loadModels } = require('langaro-api');
+
+module.exports = (knexInstance) => loadModels(knexInstance, __dirname);
+`,
+  'src/database/services/index.js': `const { loadServices } = require('langaro-api');
+
+module.exports = (models, io) => loadServices(models, io, __dirname);
+`,
+  'src/controllers/index.js': `const { loadControllers } = require('langaro-api');
+
+module.exports = (services, Queue, io) => loadControllers(services, Queue, io, __dirname);
+`,
+  'src/routes/index.js': `const { attachRouters } = require('langaro-api');
+
+exports.attachRouters = (express, controllers, services) => {
+  attachRouters(express, controllers, services, __dirname);
+};
+`,
+  'src/jobs/index.js': `const { loadJobs } = require('langaro-api');
+
+module.exports = (services) => loadJobs(services, __dirname);
+`,
+  'src/tasks/index.js': `const { loadTasks } = require('langaro-api');
+
+module.exports = (services, Queue) => loadTasks(services, Queue, __dirname);
+`,
+};
+
+function run() {
+  const root = process.cwd();
+  let replaced = 0;
+  let skipped = 0;
+  let missing = 0;
+
+  console.log('\n\x1b[36mlangaro-api migrate\x1b[0m — Replace index files with langaro-api loaders\n');
+
+  Object.entries(INDEX_REPLACEMENTS).forEach(([relPath, newContent]) => {
+    const fullPath = path.resolve(root, relPath);
+
+    if (!fs.existsSync(fullPath)) {
+      console.log(`  \x1b[33mmissing\x1b[0m  ${relPath} (file not found, skipping)`);
+      missing++;
+      return;
+    }
+
+    const current = fs.readFileSync(fullPath, 'utf8');
+
+    // Already migrated — check if it already uses langaro-api
+    if (current.includes("require('langaro-api')")) {
+      console.log(`  \x1b[90mskip\x1b[0m     ${relPath} (already using langaro-api)`);
+      skipped++;
+      return;
+    }
+
+    // Back up the original
+    const backupPath = `${fullPath}.bak`;
+    fs.writeFileSync(backupPath, current);
+
+    // Replace with the loader version
+    fs.writeFileSync(fullPath, newContent);
+    console.log(`  \x1b[32mreplaced\x1b[0m ${relPath} (backup at ${path.basename(backupPath)})`);
+    replaced++;
+  });
+
+  console.log(`\n  Replaced: ${replaced}, Skipped: ${skipped}, Missing: ${missing}\n`);
+
+  if (replaced > 0) {
+    console.log('\x1b[36mManual step required — update src/config/app.js:\x1b[0m\n');
+    console.log('  Replace these lines:');
+    console.log("    \x1b[31m- const { attachRouters } = require('@/routes');\x1b[0m");
+    console.log("    \x1b[31m- const models = await require('@/database/models')(this.knex);\x1b[0m");
+    console.log("    \x1b[31m- const services = this.services || require('@/database/services')(models.models, io);\x1b[0m");
+    console.log("    \x1b[31m- const controllers = require('@/controllers')(services, Queue, io);\x1b[0m");
+    console.log("    \x1b[31m- require('@/tasks')(services, Queue);\x1b[0m");
+    console.log('');
+    console.log('  With:');
+    console.log("    \x1b[32m+ const { loadModels, loadServices, loadControllers, attachRouters, loadTasks } = require('langaro-api');\x1b[0m");
+    console.log('    \x1b[32m+ const { models } = await loadModels(this.knex);\x1b[0m');
+    console.log('    \x1b[32m+ const services = this.services || loadServices(models, io);\x1b[0m');
+    console.log('    \x1b[32m+ const controllers = loadControllers(services, Queue, io);\x1b[0m');
+    console.log('    \x1b[32m+ loadTasks(services, Queue);\x1b[0m');
+    console.log('');
+    console.log('  And in queues.js replace:');
+    console.log("    \x1b[31m- const jobs = require('@/jobs/index')(services);\x1b[0m");
+    console.log('  With:');
+    console.log("    \x1b[32m+ const { loadJobs } = require('langaro-api');\x1b[0m");
+    console.log('    \x1b[32m+ const jobs = loadJobs(services);\x1b[0m');
+    console.log('');
+    console.log('  Then run \x1b[36mnpx langaro-api\x1b[0m to regenerate types.\n');
+  }
+
+  process.exit(0);
+}
+
+module.exports = run;

package/lib/cli/new.js

@@ -83,59 +83,184 @@ function ask(rl, question) {
   });
 }
 
-function multiSelect(rl, question, options) {
+function singleSelect(question, allOptions) {
   return new Promise((resolve) => {
-    const selected = new Set(options.map((_, i) => i)); // all selected by default
+    const searchable = allOptions.length > 10;
+    let filter = '';
+    let filtered = allOptions;
     let cursor = 0;
+    let lastRenderedLines = 0;
+
+    // Compute how many items we can show based on terminal height
+    // Reserve lines for: question + filter bar + "more above" + "more below" + 1 buffer
+    function getMaxVisible() {
+      const termRows = process.stdout.rows || 24;
+      const overhead = 1 + (searchable ? 1 : 0) + 2 + 1; // question + filter + above/below + buffer
+      return Math.max(3, Math.min(10, termRows - overhead));
+    }
+
+    function getVisible() {
+      const maxVisible = getMaxVisible();
+      if (filtered.length <= maxVisible) return { items: filtered, startIdx: 0 };
+      let start = cursor - Math.floor(maxVisible / 2);
+      if (start < 0) start = 0;
+      if (start + maxVisible > filtered.length) start = filtered.length - maxVisible;
+      return { items: filtered.slice(start, start + maxVisible), startIdx: start };
+    }
+
+    function draw() {
+      if (lastRenderedLines > 0) {
+        // Cap move-up to terminal height to avoid glitches when output scrolled off screen
+        const moveUp = Math.min(lastRenderedLines, (process.stdout.rows || 24) - 1);
+        process.stdout.write(`\x1b[${moveUp}A\x1b[J`);
+      }
+
+      const lines = [];
+      lines.push(question.trimEnd());
+
+      if (searchable) {
+        lines.push(`  \x1b[90mType to filter:\x1b[0m ${filter}\x1b[90m|\x1b[0m`);
+      }
+
+      const { items, startIdx } = getVisible();
+
+      if (startIdx > 0) lines.push(`  \x1b[90m  ... ${startIdx} more above\x1b[0m`);
+
+      items.forEach((opt, i) => {
+        const realIdx = startIdx + i;
+        const pointer = realIdx === cursor ? '\x1b[36m> \x1b[0m' : '  ';
+        const label = realIdx === cursor ? `\x1b[36m${opt.label}\x1b[0m` : opt.label;
+        const desc = opt.desc ? `\x1b[90m — ${opt.desc}\x1b[0m` : '';
+        lines.push(`${pointer}${label}${desc}`);
+      });
+
+      const endIdx = startIdx + items.length;
+      if (endIdx < filtered.length) lines.push(`  \x1b[90m  ... ${filtered.length - endIdx} more below\x1b[0m`);
+
+      if (filtered.length === 0) lines.push('  \x1b[33mNo matches\x1b[0m');
 
-    function render() {
-      // Move cursor up to clear previous render
-      if (cursor !== -1) {
-        process.stdout.write(`\x1b[${options.length + 1}A\x1b[J`);
+      process.stdout.write(`${lines.join('\n')}\n`);
+      lastRenderedLines = lines.length;
+    }
+
+    draw();
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+
+    const onKeypress = (key) => {
+      if (key[0] === 27 && key[1] === 91 && key[2] === 65) {
+        if (filtered.length > 0) cursor = (cursor - 1 + filtered.length) % filtered.length;
+        draw();
+      } else if (key[0] === 27 && key[1] === 91 && key[2] === 66) {
+        if (filtered.length > 0) cursor = (cursor + 1) % filtered.length;
+        draw();
+      } else if (key[0] === 13 || key[0] === 10) {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener('data', onKeypress);
+        if (filtered.length > 0) resolve(filtered[cursor].value);
+        else process.exit(0);
+      } else if (key[0] === 3 || (!searchable && key[0] === 113)) {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener('data', onKeypress);
+        process.exit(0);
+      } else if (searchable && (key[0] === 127 || key[0] === 8)) {
+        filter = filter.slice(0, -1);
+        filtered = allOptions.filter((o) => o.label.toLowerCase().includes(filter.toLowerCase()));
+        cursor = 0;
+        draw();
+      } else if (searchable && key[0] >= 32 && key[0] < 127 && key.length === 1) {
+        filter += String.fromCharCode(key[0]);
+        filtered = allOptions.filter((o) => o.label.toLowerCase().includes(filter.toLowerCase()));
+        cursor = 0;
+        draw();
       }
+    };
 
-      console.log(question);
+    process.stdin.on('data', onKeypress);
+  });
+}
+
+async function fetchTablesFromDatabase() {
+  try {
+    // Resolve modules from the project's node_modules, not langaro-api's
+    const projectRoot = process.cwd();
+    const resolveFrom = (mod) => require(require.resolve(mod, { paths: [projectRoot] }));
+
+    resolveFrom('dotenv').config({ path: path.join(projectRoot, '.env') });
+
+    const {
+      DB_HOST, DB_USER, DB_PASSWORD, DB_NAME, DB_PORT,
+    } = process.env;
+
+    if (!DB_NAME) {
+      console.log('\x1b[33m  Could not connect to database. DB_NAME not found in .env\x1b[0m');
+      return null;
+    }
+
+    const knex = resolveFrom('knex')({
+      client: 'mysql2',
+      connection: {
+        host: DB_HOST, user: DB_USER, password: DB_PASSWORD, database: DB_NAME, port: DB_PORT,
+      },
+    });
+
+    const results = await knex.raw(
+      'SELECT table_name FROM information_schema.tables WHERE table_schema = ?',
+      [DB_NAME],
+    );
+
+    const tables = results[0].map((row) => row.TABLE_NAME).sort();
+    await knex.destroy();
+    return tables;
+  } catch (err) {
+    console.log(`\x1b[33m  Could not connect to database: ${err.message}\x1b[0m`);
+    return null;
+  }
+}
+
+function multiSelect(rl, question, options) {
+  return new Promise((resolve) => {
+    const selected = new Set(options.map((_, i) => i));
+    let cursor = 0;
+    let lastRenderedLines = 0;
+
+    function draw() {
+      if (lastRenderedLines > 0) {
+        const moveUp = Math.min(lastRenderedLines, (process.stdout.rows || 24) - 1);
+        process.stdout.write(`\x1b[${moveUp}A\x1b[J`);
+      }
+      const lines = [];
+      lines.push(question);
       options.forEach((opt, i) => {
         const check = selected.has(i) ? '\x1b[32m[x]\x1b[0m' : '[ ]';
         const pointer = i === cursor ? '\x1b[36m> \x1b[0m' : '  ';
-        console.log(`${pointer}${check} ${opt}`);
+        lines.push(`${pointer}${check} ${opt}`);
       });
+      process.stdout.write(`${lines.join('\n')}\n`);
+      lastRenderedLines = lines.length;
     }
 
-    // Initial render
-    console.log(question);
-    options.forEach((opt, i) => {
-      const check = selected.has(i) ? '\x1b[32m[x]\x1b[0m' : '[ ]';
-      const pointer = i === cursor ? '\x1b[36m> \x1b[0m' : '  ';
-      console.log(`${pointer}${check} ${opt}`);
-    });
+    draw();
 
     process.stdin.setRawMode(true);
     process.stdin.resume();
 
     const onKeypress = (key) => {
-      // Up arrow
       if (key[0] === 27 && key[1] === 91 && key[2] === 65) {
         cursor = (cursor - 1 + options.length) % options.length;
-        render();
-        // Down arrow
+        draw();
       } else if (key[0] === 27 && key[1] === 91 && key[2] === 66) {
         cursor = (cursor + 1) % options.length;
-        render();
-        // Space — toggle selection
+        draw();
       } else if (key[0] === 32) {
-        if (selected.has(cursor)) {
-          selected.delete(cursor);
-        } else {
-          selected.add(cursor);
-        }
-        render();
-        // Enter — confirm
+        if (selected.has(cursor)) selected.delete(cursor);
+        else selected.add(cursor);
+        draw();
       } else if (key[0] === 13 || key[0] === 10) {
         process.stdin.setRawMode(false);
         process.stdin.removeListener('data', onKeypress);
         resolve(options.filter((_, i) => selected.has(i)));
-        // q or Ctrl+C — abort
       } else if (key[0] === 113 || key[0] === 3) {
         process.stdin.setRawMode(false);
         process.stdin.removeListener('data', onKeypress);
@@ -152,24 +277,46 @@ async function run(config = {}) {
   const root = cfg.root || process.cwd();
   const resolve = (dir) => path.resolve(root, dir);
 
-  const rl = createInterface();
-
-  const name = await ask(rl, '\n\x1b[36mResource name\x1b[0m (snake_case, e.g. products, user_invoices): ');
+  // Step 1: Choose how to pick the resource name
+  console.log('');
+  const source = await singleSelect('\x1b[36mHow to pick the resource name?\x1b[0m', [
+    { label: 'Enter manually', value: 'manual', desc: 'Type a snake_case name' },
+    { label: 'Fetch from database', value: 'db', desc: 'Select a table from your database' },
+  ]);
+
+  let name;
+
+  if (source === 'db') {
+    console.log('\n  Connecting to database...');
+    const tables = await fetchTablesFromDatabase();
+
+    if (!tables || tables.length === 0) {
+      console.log('\x1b[31m  No tables found.\x1b[0m Falling back to manual input.\n');
+      const rl = createInterface();
+      name = await ask(rl, '\x1b[36mResource name\x1b[0m (snake_case, e.g. products, user_invoices): ');
+      rl.close();
+    } else {
+      console.log('');
+      const tableOptions = tables.map((t) => ({ label: t, value: t }));
+      name = await singleSelect(`  Found ${tables.length} tables. Select one:`, tableOptions);
+    }
+  } else {
+    const rl = createInterface();
+    name = await ask(rl, '\n\x1b[36mResource name\x1b[0m (snake_case, e.g. products, user_invoices): ');
+    rl.close();
+  }
 
   if (!name) {
     console.log('No name provided. Aborting.');
-    rl.close();
     process.exit(0);
   }
 
   // Validate name
   if (!/^[a-z][a-z0-9_]*$/.test(name)) {
     console.log('\x1b[31mInvalid name.\x1b[0m Use snake_case (e.g. products, user_invoices)');
-    rl.close();
     process.exit(1);
   }
 
-  rl.close();
   console.log('');
 
   const choices = await multiSelect(
@@ -244,7 +391,10 @@ async function run(config = {}) {
   }
 
   if (created.length > 0) {
-    console.log(`\n\x1b[32mDone!\x1b[0m Created ${created.length} file(s). Run \x1b[36mlangaro-api\x1b[0m to regenerate types.\n`);
+    // Auto-regenerate types so the new resource gets IntelliSense immediately
+    const { generateTypes } = require('../index');
+    generateTypes(cfg);
+    console.log(`\n\x1b[32mDone!\x1b[0m Created ${created.length} file(s). Types regenerated.\n`);
   } else {
     console.log('\nNo files created (all already exist).\n');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langaro-api",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Auto-generate TypeScript types, JSDoc annotations, and boilerplate loaders for knex-extended-crud projects",
   "main": "lib/index.js",
   "bin": {