@mostajs/orm-cli 0.6.4 → 0.7.0

package/bin/fix-mongo-id.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+// fix-mongo-id.mjs — codemod : repair Mongo-era residue left in app code after a
+// project migrates from Mongoose to @mostajs/orm (data-plug). The ORM normalizer
+// maps `_id`→`id` and ids are plain STRINGS for every dialect (mongo included),
+// so two classes of stale code must be repaired :
+//
+//   1. Identifier reads   `obj._id`              → `obj.id`
+//   2. ObjectId wrapping   `new ObjectId(x)`      → `x`
+//                          `mongoose.Types.ObjectId(x)` → `x`
+//
+// @author Dr Hamid MADANI <drmdh@msn.com>
+// License: AGPL-3.0-or-later
+//
+// Usage (invoked by bin/mostajs.sh as `mostajs fix-ids`) :
+//
+//   node fix-mongo-id.mjs                 # dry-run (default, safe — lists sites)
+//   node fix-mongo-id.mjs --apply         # rewrite files (+ .mongoid.bak backups)
+//   node fix-mongo-id.mjs --file X         # restrict to a single file
+//   node fix-mongo-id.mjs --project P      # root to scan (default: cwd)
+//   node fix-mongo-id.mjs --map old:new    # extra member rename (repeatable)
+//   node fix-mongo-id.mjs --no-objectid    # skip ObjectId() unwrapping
+//   node fix-mongo-id.mjs --include-mongoose  # also touch files importing mongoose
+//   node fix-mongo-id.mjs --restore        # restore from .mongoid.bak backups
+//
+// Conservative by design :
+//   - Member rename touches ACCESS only : `.​_id`, `?._id`, `['_id']`, `["_id"]`.
+//     A bare `_id:` object *key* (a Mongoose schema declaration) is left intact.
+//   - ObjectId unwrap removes the constructor wrapper but KEEPS the inner
+//     expression : `new ObjectId(req.params.id)` → `req.params.id`.
+//     `ObjectId.isValid(...)` and `import { ObjectId }` lines are NOT rewritten
+//     (semantics differ) — they are reported for manual review.
+//   - Files importing `mongoose` (likely real Mongo models) are skipped + reported.
+//   - Original file is saved as <path>.mongoid.bak. Re-runs are idempotent.
+
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, renameSync, copyFileSync } from 'node:fs';
+import { join, resolve, relative, extname } from 'node:path';
+
+// ---------- CLI ----------
+const argv = process.argv.slice(2);
+const flag = (name) => argv.includes(`--${name}`);
+const val  = (name) => { const i = argv.indexOf(`--${name}`); return i >= 0 ? argv[i + 1] : null; };
+const vals = (name) => argv.reduce((acc, a, i) => (a === `--${name}` && argv[i + 1] ? [...acc, argv[i + 1]] : acc), []);
+
+const APPLY            = flag('apply');
+const RESTORE          = flag('restore');
+const ONE_FILE         = val('file');
+const ROOT             = resolve(val('project') ?? process.cwd());
+const QUIET            = flag('quiet');
+const INCLUDE_MONGOOSE = flag('include-mongoose');
+const NO_OBJECTID      = flag('no-objectid');
+
+const log = (...a) => { if (!QUIET) console.log(...a); };
+const c   = { cyan: s => `\x1b[36m${s}\x1b[0m`, yellow: s => `\x1b[33m${s}\x1b[0m`, green: s => `\x1b[32m${s}\x1b[0m`, red: s => `\x1b[31m${s}\x1b[0m`, bold: s => `\x1b[1m${s}\x1b[0m`, dim: s => `\x1b[2m${s}\x1b[0m` };
+
+// ---------- Rename map (member access) ----------
+const renameMap = new Map([['_id', 'id']]);
+for (const m of vals('map')) {
+  const [from, to] = m.split(':');
+  if (!from || !to) { console.error(c.red(`Bad --map "${m}" — expected old:new`)); process.exit(1); }
+  renameMap.set(from, to);
+}
+const RISKY = [...renameMap.keys()].filter((k) => /^[a-z][a-zA-Z]*$/.test(k) && k.length <= 6 && k !== 'id');
+
+// ---------- Walk ----------
+const SKIP_DIRS = new Set(['node_modules', '.next', '.svelte-kit', 'dist', 'build', '.turbo', '.vercel', '.cache', 'coverage', '.git', '.vscode', '.idea']);
+const EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.svelte']);
+const BAK = '.mongoid.bak';
+
+function* walk(dir) {
+  let entries;
+  try { entries = readdirSync(dir); } catch { return; }
+  for (const name of entries) {
+    if (SKIP_DIRS.has(name)) continue;
+    const p = join(dir, name);
+    let st;
+    try { st = statSync(p); } catch { continue; }
+    if (st.isDirectory()) yield* walk(p);
+    else if (EXTENSIONS.has(extname(name)) || name.endsWith(BAK)) yield p;
+  }
+}
+
+// ---------- Member access rename ( ._id → .id ) ----------
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+function memberPatterns(from, to) {
+  const f = escape(from);
+  return [
+    { re: new RegExp(`(\\??\\.)${f}\\b`, 'g'), build: (g1) => `${g1}${to}` },           // .foo / ?.foo
+    { re: new RegExp(`\\[(['"])${f}\\1\\]`, 'g'), build: (q) => `[${q}${to}${q}]` },     // ['foo'] / ["foo"]
+  ];
+}
+
+function renameMembers(src) {
+  let out = src, count = 0;
+  for (const [from, to] of renameMap) {
+    for (const { re, build } of memberPatterns(from, to)) {
+      out = out.replace(re, (_m, g1) => { count++; return build(g1); });
+    }
+  }
+  return { out, count };
+}
+
+// ---------- ObjectId unwrap ( new ObjectId(x) → x ) ----------
+// Matches the constructor head, with or without `new`, and the mongoose paths
+// `mongoose.Types.ObjectId(` / `Types.ObjectId(`. NOT `ObjectId.isValid(` (the
+// `.isValid` sits between `ObjectId` and `(`, so the head regex can't match it).
+const RX_OBJID_CTOR_HEAD = /(?:new\s+)?(?:mongoose\.)?(?:Types\.)?ObjectId\s*\(/g;
+
+function unwrapObjectId(src) {
+  if (NO_OBJECTID) return { out: src, count: 0 };
+  let out = '', last = 0, count = 0;
+  const re = new RegExp(RX_OBJID_CTOR_HEAD.source, 'g');
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const open = m.index + m[0].length - 1;   // index of the '('
+    let depth = 1, j = open + 1;
+    for (; j < src.length && depth > 0; j++) {
+      const ch = src[j];
+      if (ch === '(') depth++;
+      else if (ch === ')') depth--;
+    }
+    if (depth !== 0) continue;                 // unbalanced — leave as-is
+    const close = j - 1;
+    const inner = src.slice(open + 1, close).trim();
+    out += src.slice(last, m.index) + inner;
+    last = close + 1;
+    count++;
+    re.lastIndex = last;
+  }
+  out += src.slice(last);
+  return { out, count };
+}
+
+// ---------- Per-file analysis ----------
+const RX_MONGOOSE      = /\b(?:from\s+['"]mongoose['"]|require\(\s*['"]mongoose['"]\s*\)|new\s+(?:mongoose\.)?Schema\s*\()/;
+const RX_OBJID_ISVALID = /\bObjectId\.isValid\s*\(/;
+const RX_OBJID_IMPORT  = /\bimport\b[^;\n]*\bObjectId\b[^;\n]*\bfrom\b[^;\n]*['"](?:mongodb|bson|mongoose)['"]/;
+
+function analyze(src, rel) {
+  const r1 = renameMembers(src);
+  const r2 = unwrapObjectId(r1.out);
+  const idCount = r1.count, objCount = r2.count;
+  // Manual-review notes (reported, never auto-edited).
+  const manual = [];
+  src.split('\n').forEach((line, i) => {
+    if (RX_OBJID_ISVALID.test(line)) manual.push({ ln: i + 1, text: line.trim().slice(0, 100), why: 'ObjectId.isValid — replace with a string check' });
+    if (RX_OBJID_IMPORT.test(line))  manual.push({ ln: i + 1, text: line.trim().slice(0, 100), why: 'ObjectId import — likely unused after unwrap, remove' });
+  });
+  // Sample hit lines (from the ORIGINAL source) for the report.
+  const hitLines = [];
+  src.split('\n').forEach((line, i) => {
+    let hit = false;
+    for (const [from, to] of renameMap) for (const { re } of memberPatterns(from, to)) { re.lastIndex = 0; if (re.test(line)) hit = true; }
+    if (!NO_OBJECTID && RX_OBJID_CTOR_HEAD.test(line) && !RX_OBJID_ISVALID.test(line)) hit = true;
+    if (hit) hitLines.push({ ln: i + 1, text: line.trim().slice(0, 100) });
+  });
+  return { rel, rewritten: r2.out, idCount, objCount, manual, hitLines };
+}
+
+// ---------- Restore ----------
+function restoreBackups() {
+  const restored = [];
+  for (const p of walk(ROOT)) {
+    if (!p.endsWith(BAK)) continue;
+    const original = p.slice(0, -BAK.length);
+    const rel = relative(ROOT, original);
+    if (APPLY) { renameSync(p, original); log(`  ${c.green('✓')} restored ${c.dim(rel)}`); }
+    else        { log(`  ${c.yellow('•')} would restore ${c.dim(rel)}`); }
+    restored.push(original);
+  }
+  return restored;
+}
+
+// ---------- Main ----------
+if (RESTORE) {
+  log(c.bold('▶ Restoring .mongoid.bak files' + (APPLY ? '' : c.yellow(' (dry-run, use --apply)'))));
+  const r = restoreBackups();
+  log(`\n${r.length} file(s) ${APPLY ? 'restored' : 'would be restored'}`);
+  process.exit(0);
+}
+
+log(c.bold(`▶ mostajs fix-ids — scanning ${c.cyan(ROOT)}`));
+log(c.dim(`  member renames : ${[...renameMap].map(([f, t]) => `${f}→${t}`).join('  ')}`));
+log(c.dim(`  ObjectId unwrap : ${NO_OBJECTID ? 'disabled (--no-objectid)' : 'new ObjectId(x) → x'}`));
+if (RISKY.length) log(c.yellow(`  ⚠ blunt member rename(s): ${RISKY.join(', ')} — renames EVERY occurrence; review the dry-run.`));
+log('');
+
+const candidates = [];
+const manualOnly = [];
+const skippedMongoose = [];
+const iter = ONE_FILE ? [resolve(ROOT, ONE_FILE)] : walk(ROOT);
+for (const p of iter) {
+  if (p.endsWith(BAK)) continue;
+  let src;
+  try { src = readFileSync(p, 'utf8'); } catch { continue; }
+  const rel = relative(ROOT, p);
+  const a = analyze(src, rel);
+  if (a.idCount === 0 && a.objCount === 0 && a.manual.length === 0) continue;
+  if (RX_MONGOOSE.test(src) && !INCLUDE_MONGOOSE) { skippedMongoose.push(rel); continue; }
+  if (a.idCount === 0 && a.objCount === 0) { manualOnly.push({ path: p, ...a }); continue; }
+  candidates.push({ path: p, src, ...a });
+}
+
+const totalId  = candidates.reduce((n, ca) => n + ca.idCount, 0);
+const totalObj = candidates.reduce((n, ca) => n + ca.objCount, 0);
+
+if (candidates.length === 0 && manualOnly.length === 0) {
+  log(c.green('  Nothing to fix.'));
+  if (skippedMongoose.length) { log(''); log(c.yellow(`  ${skippedMongoose.length} mongoose file(s) skipped (use --include-mongoose):`)); for (const r of skippedMongoose) log(c.dim(`    • ${r}`)); }
+  process.exit(0);
+}
+
+if (candidates.length) {
+  log(c.bold(`Found ${totalId} stale id read(s) + ${totalObj} ObjectId wrap(s) in ${candidates.length} file(s):`));
+  for (const ca of candidates) {
+    log(`  ${c.green('→')} ${ca.rel}  ${c.dim(`(_id:${ca.idCount}  ObjectId:${ca.objCount})`)}`);
+    for (const h of ca.hitLines.slice(0, 6)) log(c.dim(`      ${h.ln}: ${h.text}`));
+    if (ca.hitLines.length > 6) log(c.dim(`      … +${ca.hitLines.length - 6} more`));
+  }
+  log('');
+}
+
+// Manual-review notes (across all files that have them).
+const allManual = [...candidates, ...manualOnly].filter((f) => f.manual.length);
+if (allManual.length) {
+  log(c.yellow('Manual review (NOT auto-rewritten):'));
+  for (const f of allManual) for (const mn of f.manual) log(c.dim(`    ${f.rel}:${mn.ln}  ${c.yellow(mn.why)}\n      ${mn.text}`));
+  log('');
+}
+
+if (skippedMongoose.length) {
+  log(c.yellow(`${skippedMongoose.length} mongoose file(s) skipped (real Mongo models keep _id):`));
+  for (const r of skippedMongoose) log(c.dim(`    • ${r}`));
+  log(c.dim('  Force with --include-mongoose if these are actually data-plug call-sites.'));
+  log('');
+}
+
+if (!APPLY) {
+  log(c.yellow('Dry-run — no files written. Re-run with --apply to execute.'));
+  process.exit(0);
+}
+
+if (candidates.length === 0) { log(c.green('Nothing to auto-rewrite (manual items only).')); process.exit(0); }
+
+// ---------- Apply ----------
+log(c.bold('Applying rewrites :'));
+for (const ca of candidates) {
+  const bak = ca.path + BAK;
+  if (!existsSync(bak)) copyFileSync(ca.path, bak);
+  writeFileSync(ca.path, ca.rewritten);
+  log(`  ${c.green('✓')} fixed ${ca.rel}  ${c.dim(`(backup: ${relative(ROOT, bak)})`)}`);
+}
+
+log('');
+log(c.bold(c.green(`✓ Repaired ${totalId} id read(s) + ${totalObj} ObjectId wrap(s) in ${candidates.length} file(s).`)));
+if (allManual.length) log(c.yellow(`  ${allManual.reduce((n, f) => n + f.manual.length, 0)} manual item(s) still need review (see above).`));
+log('');
+log(`Review the diff, then rebuild your front/app.`);
+log(`To undo all : ${c.cyan('mostajs fix-ids --restore --apply')}`);

package/bin/mongo-introspect.mjs

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+// mongo-introspect.mjs — reverse-engineer a LIVE MongoDB into EntitySchema[].
+// The "migrer" half of the Mongo → @mostajs/orm story : connect to the database,
+// sample documents per collection, infer field types, and emit the same
+// `.mostajs/generated/entities.json` that `mostajs convert` produces — so a Mongo
+// project with no Prisma/OpenAPI schema can still adopt data-plug.
+//
+// The ORM normalizes `_id`→`id` (string) for every dialect, so `_id`/`__v` are
+// dropped here and ObjectId-typed fields are emitted as `string`.
+//
+// @author Dr Hamid MADANI <drmdh@msn.com>
+// License: AGPL-3.0-or-later
+//
+// Usage (invoked by bin/mostajs.sh as `mostajs mongo-introspect`) :
+//
+//   node mongo-introspect.mjs --uri mongodb://user:pw@host:27017/db?authSource=admin
+//   node mongo-introspect.mjs --sample 500 --out .mostajs/generated/entities.json
+//   (falls back to $SGBD_URI / $DB_DIALECT from the environment / .mostajs config)
+
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const argv = process.argv.slice(2);
+const val  = (n, d) => { const i = argv.indexOf(`--${n}`); return i >= 0 ? argv[i + 1] : d; };
+const flag = (n) => argv.includes(`--${n}`);
+
+const ROOT    = resolve(val('project', process.cwd()));
+const URI     = val('uri', process.env.SGBD_URI || '');
+const SAMPLE  = Math.max(1, Number(val('sample', '200')) || 200);
+const OUT     = resolve(val('out', `${ROOT}/.mostajs/generated/entities.json`));
+const QUIET   = flag('quiet');
+const VERSION = '0.7.0';
+
+const c = { red: s => `\x1b[31m${s}\x1b[0m`, yellow: s => `\x1b[33m${s}\x1b[0m`, green: s => `\x1b[32m${s}\x1b[0m`, cyan: s => `\x1b[36m${s}\x1b[0m`, bold: s => `\x1b[1m${s}\x1b[0m`, dim: s => `\x1b[2m${s}\x1b[0m` };
+const log = (...a) => { if (!QUIET) console.log(...a); };
+
+if (!URI) {
+  console.error(c.red('✗ No MongoDB URI. Pass --uri or set SGBD_URI (menu 2 → import).'));
+  process.exit(2);
+}
+
+// ── Resolve mongoose from the project (the mongo driver @mostajs/orm uses) ──
+let mongoose;
+const cliDir = resolve(new URL('..', import.meta.url).pathname);
+for (const base of [ROOT, cliDir, process.cwd()]) {
+  try { mongoose = (await import(pathToFileURL(require.resolve('mongoose', { paths: [base] })).href)).default; break; }
+  catch { /* next */ }
+}
+if (!mongoose) {
+  console.error(c.red('✗ mongoose not installed in the project.'));
+  console.error(`  Install it : ${c.cyan('npm i mongoose')}   (it is the driver @mostajs/orm uses for MongoDB)`);
+  process.exit(2);
+}
+
+// ── Type inference ─────────────────────────────────────────────────────────
+function isObjectId(v) {
+  return v && typeof v === 'object' &&
+    (v._bsontype === 'ObjectID' || v._bsontype === 'ObjectId' ||
+     (v.constructor && v.constructor.name === 'ObjectId'));
+}
+function scalarType(v) {
+  if (v === null || v === undefined) return null;
+  if (typeof v === 'string') return 'string';
+  if (typeof v === 'number') return 'number';
+  if (typeof v === 'boolean') return 'boolean';
+  if (v instanceof Date) return 'date';
+  if (isObjectId(v)) return 'string';          // normalized to string id
+  if (Array.isArray(v)) return 'array';
+  if (typeof v === 'object') return 'json';
+  return 'string';
+}
+// Reconcile a set of observed types into a single FieldType.
+function reconcile(types) {
+  const s = new Set([...types].filter(Boolean));
+  if (s.size === 0) return 'string';
+  if (s.size === 1) return [...s][0];
+  if (s.has('json') || s.has('array')) return 'json';
+  if (s.has('string')) return 'string';        // string + number → string
+  return 'json';
+}
+
+function pascal(s) {
+  return s.replace(/[_\-.\s]+/g, ' ').trim()
+    .replace(/\s+(.)/g, (_, ch) => ch.toUpperCase())
+    .replace(/^(.)/, (_, ch) => ch.toUpperCase());
+}
+function singular(n) {
+  // Don't mangle words that merely END in 's' but aren't plurals
+  // (Status, Address, Analysis, Series, OS…). Naive de-pluralization otherwise.
+  if (/(ss|us|is|os| news|series|species)$/i.test(n)) return n;
+  if (/ies$/i.test(n)) return n.slice(0, -3) + 'y';
+  if (/(ches|shes|xes|zes|ses)$/i.test(n)) return n.slice(0, -2);
+  if (/s$/i.test(n)) return n.slice(0, -1);
+  return n;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+log(c.bold(`▶ mostajs mongo-introspect — ${c.cyan(URI.replace(/\/\/[^@]*@/, '//***@'))}`));
+log(c.dim(`  sampling up to ${SAMPLE} doc(s) per collection`));
+log('');
+
+await mongoose.connect(URI, { serverSelectionTimeoutMS: 8000 });
+const db = mongoose.connection.db;
+const collInfos = (await db.listCollections().toArray())
+  .filter((ci) => ci.type !== 'view' && !ci.name.startsWith('system.'));
+
+const entities = [];
+for (const ci of collInfos) {
+  const name = ci.name;
+  const docs = await db.collection(name).find({}).limit(SAMPLE).toArray();
+  if (docs.length === 0) {
+    log(`  ${c.yellow('○')} ${name}  ${c.dim('(empty — skipped)')}`);
+    continue;
+  }
+  // Aggregate field stats.
+  const stat = new Map();   // field → { present, nulls, types:Set, elemTypes:Set }
+  for (const doc of docs) {
+    for (const [k, v] of Object.entries(doc)) {
+      if (k === '_id' || k === '__v') continue;
+      const st = stat.get(k) ?? { present: 0, nulls: 0, types: new Set(), elem: new Set() };
+      st.present++;
+      if (v === null || v === undefined) st.nulls++;
+      st.types.add(scalarType(v));
+      if (Array.isArray(v) && v.length) st.elem.add(scalarType(v[0]));
+      stat.set(k, st);
+    }
+  }
+
+  const fields = {};
+  let hasCreated = false, hasUpdated = false;
+  for (const [k, st] of stat) {
+    const type = reconcile(st.types);
+    if (k === 'createdAt' && type === 'date') { hasCreated = true; continue; }
+    if (k === 'updatedAt' && type === 'date') { hasUpdated = true; continue; }
+    const def = { type };
+    if (st.present === docs.length && st.nulls === 0) def.required = true;
+    if (type === 'array') { const e = reconcile(st.elem); if (e) def.arrayOf = e; }
+    fields[k] = def;
+  }
+
+  // Real indexes → IndexDef (skip the default _id_ index).
+  const indexes = [];
+  try {
+    for (const ix of await db.collection(name).indexes()) {
+      if (ix.name === '_id_' || !ix.key) continue;
+      const f = {};
+      for (const [col, dir] of Object.entries(ix.key)) {
+        if (col === '_id') continue;
+        f[col] = dir === -1 ? 'desc' : (dir === 1 ? 'asc' : 'asc');
+      }
+      if (Object.keys(f).length) indexes.push({ fields: f, ...(ix.unique ? { unique: true } : {}) });
+    }
+  } catch { /* indexes() can fail on some deployments — non-fatal */ }
+
+  entities.push({
+    name: pascal(singular(name)),
+    collection: name,
+    fields,
+    relations: {},
+    indexes,
+    timestamps: hasCreated && hasUpdated,
+  });
+  log(`  ${c.green('✓')} ${name} → ${c.bold(pascal(singular(name)))}  ${c.dim(`(${Object.keys(fields).length} fields, ${indexes.length} index, ${docs.length} sampled)`)}`);
+}
+
+await mongoose.disconnect();
+
+if (entities.length === 0) {
+  console.error(c.yellow('\n  No non-empty collections found — nothing written.'));
+  process.exit(0);
+}
+
+// ── Write entities.json (+ .ts, same layout as `mostajs convert`) ──
+mkdirSync(dirname(OUT), { recursive: true });
+const jsonFile = OUT.endsWith('.json') ? OUT : OUT.replace(/\.ts$/, '.json');
+const tsFile = jsonFile.replace(/\.json$/, '.ts');
+writeFileSync(jsonFile, JSON.stringify(entities, null, 2));
+const header = `// Auto-generated by @mostajs/orm-cli mongo-introspect v${VERSION}\n` +
+  `// Source : live MongoDB (sampled ${SAMPLE} docs/collection)\n` +
+  `// DO NOT EDIT BY HAND — regenerate with: mostajs mongo-introspect\n\n` +
+  `import type { EntitySchema } from "@mostajs/orm";\n\n` +
+  `export const entities: EntitySchema[] = ${JSON.stringify(entities, null, 2)};\n\n` +
+  `export const entityByName: Record<string, EntitySchema> = Object.fromEntries(\n` +
+  `  entities.map(e => [e.name, e])\n);\n`;
+writeFileSync(tsFile, header);
+
+log('');
+log(c.bold(c.green(`✓ ${entities.length} entit(y/ies) → ${jsonFile}`)));
+log('');
+log('Next :');
+log(`  1. ${c.cyan('mostajs validate')}                 # lint the inferred schema`);
+log(`  2. ${c.cyan('mostajs fix-ids --apply')}           # repair app code (_id / ObjectId)`);
+log(`  3. ${c.cyan('mostajs')} → menu 3                  # init dialects / DDL on the target DB`);