allez-orm 1.0.12 → 1.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allez-orm",
-  "version": "1.0.12",
+  "version": "1.0.15",
   "description": "AllezORM: lightweight browser SQLite ORM (sql.js) + schema generator CLI",
   "type": "module",
   "bin": {

package/tools/allez-orm.mjs

@@ -7,17 +7,17 @@
  *  - Optional "stamps": created_at, updated_at, deleted_at
  *  - Optional unique / not-null markers
  *  - Optional ON DELETE behavior for *all* FKs via --onDelete=
- *  - Auto index per FK column in extraSQL (emitted as backticked strings)
+ *  - (No extraSQL output by default)
  *  - Auto-create stub schemas for FK target tables if missing
  *
  * New:
- *  - from-json <file>: bulk-generate schemas from a JSON config
+ *  - from-json <file>: bulk-generate schemas from a JSON config (fields can be objects or string tokens)
  *  - --print-json-schema: output the JSON Schema used for validation
  *
  * Usage:
- *   node tools/allez-orm.mjs create table <name> [fields...] [--dir=schemas_cli] [--stamps] [-f|--force] [--onDelete=cascade|restrict|setnull|noaction]
- *   node tools/allez-orm.mjs from-json <config.json> [--dir=schemas_cli] [-f|--force]
- *   node tools/allez-orm.mjs --print-json-schema
+ *   allez-orm create table <name> [fields...] [--dir=schemas_cli] [--stamps] [-f|--force] [--onDelete=cascade|restrict|setnull|noaction]
+ *   allez-orm from-json <config.json> [--dir=schemas_cli] [-f|--force]
+ *   allez-orm --print-json-schema
  */
 
 import fs from "node:fs";
@@ -86,7 +86,6 @@ function parseOptions(args) {
     }
   }
 
-  // env var ALLEZ_FORCE=1 is honored (does not break positional parsing)
   if (process.env.ALLEZ_FORCE === "1") out.force = true;
 
   out.cmd = positional[0] || null;
@@ -122,26 +121,32 @@ const CONFIG_JSON_SCHEMA = JSON.stringify({
         properties: {
           name: { type: "string", minLength: 1 },
           stamps: { type: "boolean" },
+          // Accept either rich field objects or simple string tokens.
           fields: {
             type: "array",
             items: {
-              type: "object",
-              additionalProperties: false,
-              required: ["name"],
-              properties: {
-                name: { type: "string" },
-                type: { type: "string" },           // TEXT (default), INTEGER, etc
-                unique: { type: "boolean" },
-                notnull: { type: "boolean" },
-                fk: {
-                  type: ["object", "null"],
+              anyOf: [
+                {
+                  type: "object",
                   additionalProperties: false,
+                  required: ["name"],
                   properties: {
-                    table: { type: "string" },
-                    column: { type: "string", default: "id" }
+                    name: { type: "string" },
+                    type: { type: "string" },
+                    unique: { type: "boolean" },
+                    notnull: { type: "boolean" },
+                    fk: {
+                      type: ["object", "null"],
+                      additionalProperties: false,
+                      properties: {
+                        table: { type: "string" },
+                        column: { type: "string", default: "id" }
+                      }
+                    }
                   }
-                }
-              }
+                },
+                { type: "string" } // token form: "email:text!+->users"
+              ]
             }
           }
         },
@@ -167,7 +172,6 @@ if (!opts.cmd) {
 if (opts.cmd === "from-json") {
   if (!opts.jsonFile) die("from-json requires a <config.json> path");
   runFromJson(opts).catch(e => die(e.stack || String(e)));
-  // will exit inside
 } else if (opts.cmd === "create" && opts.sub === "table" && opts.table) {
   fs.mkdirSync(opts.dir, { recursive: true });
   generateOne({
@@ -188,16 +192,15 @@ if (opts.cmd === "from-json") {
 
 async function generateOne({ outDir, name, stamps, onDelete, force, fieldTokens }) {
   const outFile = path.join(outDir, `${name}.schema.js`);
-  if (fs.existsSync(outFile) && !force) {
+  if (!force && fs.existsSync(outFile)) {
     die(`Refusing to overwrite existing file: ${outFile}\n(use -f or ALLEZ_FORCE=1)`);
   }
 
-  // Parse tokens into field descriptors
+  // Parse tokens -> field descriptors
   const fields = fieldTokens.map(parseFieldToken).filter(Boolean);
 
   // Ensure id PK
-  const hasId = fields.some(f => f.name === "id");
-  if (!hasId) {
+  if (!fields.some(f => f.name === "id")) {
     fields.unshift({ name: "id", type: "INTEGER", notnull: true, unique: false, fk: null, pk: true });
   }
 
@@ -210,31 +213,20 @@ async function generateOne({ outDir, name, stamps, onDelete, force, fieldTokens
     );
   }
 
-  // SQL
-  const columnLines = fields.map(f => sqlForColumn(f, onDelete));
+  // Fast column assembly
+  const onDel = onDelete ? ({ cascade:"CASCADE", restrict:"RESTRICT", setnull:"SET NULL", noaction:"NO ACTION" })[onDelete] : null;
+  const columnLines = fields.map(f => sqlForColumn(f, onDel));
 
-  // FK indexes
-  const extraSQL = [];
-  for (const f of fields) {
-    if (f.fk) {
-      extraSQL.push(
-        `\`CREATE INDEX IF NOT EXISTS idx_${name}_${f.name}_fk ON ${name}(${f.name});\``
-      );
-    }
-  }
-
-  // module text
-  const moduleText = `// ${name}.schema.js (generated by tools/allez-orm.mjs)
+  // Module text — no extraSQL emitted
+  const moduleText =
+`// ${name}.schema.js (generated by tools/allez-orm.mjs)
 const ${camel(name)}Schema = {
   table: "${name}",
   version: 1,
   createSQL: \`
 CREATE TABLE IF NOT EXISTS ${name} (
   ${columnLines.join(",\n  ")}
-);\`,
-  extraSQL: [
-    ${extraSQL.join("\n    ")}
-  ]
+);\`
 };
 export default ${camel(name)}Schema;
 `;
@@ -243,24 +235,21 @@ export default ${camel(name)}Schema;
   fs.writeFileSync(outFile, moduleText, "utf8");
   console.log(`Wrote ${outFile}`);
 
-  // stub FK targets
-  const fkTargets = Array.from(new Set(fields.filter(f => f.fk).map(f => f.fk.table)))
-    .filter(t => t && t !== name);
-
+  // Stub FK targets (only if not self & missing)
+  const fkTargets = new Set();
+  for (const f of fields) if (f.fk && f.fk.table && f.fk.table !== name) fkTargets.add(f.fk.table);
   for (const t of fkTargets) {
     const stubPath = path.join(outDir, `${t}.schema.js`);
     if (!fs.existsSync(stubPath)) {
-      const stub = `// ${t}.schema.js (generated by tools/allez-orm.mjs - stub for FK target)
+      const stub =
+`// ${t}.schema.js (generated by tools/allez-orm.mjs - stub for FK target)
 const ${camel(t)}Schema = {
   table: "${t}",
   version: 1,
   createSQL: \`
 CREATE TABLE IF NOT EXISTS ${t} (
   id INTEGER PRIMARY KEY AUTOINCREMENT
-);\`,
-  extraSQL: [
-    
-  ]
+);\`
 };
 export default ${camel(t)}Schema;
 `;
@@ -270,28 +259,57 @@ export default ${camel(t)}Schema;
   }
 }
 
-function sqlForColumn(f, onDelete) {
+function sqlForColumn(f, onDelUpper) {
   if (f.pk) return `id INTEGER PRIMARY KEY AUTOINCREMENT`;
   let s = `${f.name} ${f.type}`;
-  // ordering (UNIQUE then NOT NULL) matches tests
+  // Keep order: UNIQUE then NOT NULL (matches tests/expectations)
   if (f.unique) s += ` UNIQUE`;
   if (f.notnull) s += ` NOT NULL`;
   if (f.fk) {
     s += ` REFERENCES ${f.fk.table}(${f.fk.column || "id"})`;
-    if (onDelete) {
-      const map = { cascade: "CASCADE", restrict: "RESTRICT", setnull: "SET NULL", noaction: "NO ACTION" };
-      s += ` ON DELETE ${map[onDelete]}`;
-    }
+    if (onDelUpper) s += ` ON DELETE ${onDelUpper}`;
   }
   return s;
 }
 
 function parseFieldToken(tok) {
-  // Accept "col[:type][!][+][->target]" OR "col:type,unique,notnull"
-  const ret = { name: "", type: "TEXT", notnull: false, unique: false, fk: null };
-  if (!tok) return null;
+  // Accept:
+  //   - token string "col[:type][!][+][->target]" or "col:type,unique,notnull"
+  //   - object {name,type,unique,notnull,fk:{table,column}}
+  if (tok == null) return null;
+
+  // Fast path: token is already string
+  if (typeof tok === "string") {
+    return parseTokenString(tok);
+  }
 
+  // Object form -> tokenize once, then reuse the same parser
+  if (typeof tok === "object") {
+    const name = String(tok.name ?? tok.Name ?? "").trim();
+    if (!name) return null;
+    const type = String(tok.type ?? tok.Type ?? "TEXT").trim().toLowerCase();
+    const unique = !!(tok.unique ?? tok.Unique);
+    const notnull = !!(tok.notnull ?? tok.notNull ?? tok.NotNull);
+    const fkRaw = tok.fk ?? tok.FK;
+    const fkTable = fkRaw ? (fkRaw.table ?? fkRaw.Table) : null;
+    const fkCol = fkRaw ? (fkRaw.column ?? fkRaw.Column ?? "id") : "id";
+
+    let token = `${name}:${type}`;
+    if (notnull) token += "!";
+    if (unique)  token += "+";
+    if (fkTable) token += `->${fkTable}`;
+
+    const parsed = parseTokenString(token);
+    if (fkTable) parsed.fk.column = fkCol; // preserve non-id if provided
+    return parsed;
+  }
+
+  return null;
+}
+
+function parseTokenString(tok) {
   // Split on "," for attribute list
+  const ret = { name: "", type: "TEXT", notnull: false, unique: false, fk: null };
   let main = tok;
   let flags = [];
   if (tok.includes(",")) {
@@ -305,14 +323,12 @@ function parseFieldToken(tok) {
   let type = null;
   let fkTarget = null;
 
-  // ->target
   const fkIdx = main.indexOf("->");
   if (fkIdx >= 0) {
     fkTarget = main.slice(fkIdx + 2).trim();
     name = main.slice(0, fkIdx);
   }
 
-  // :type
   const typeIdx = name.indexOf(":");
   if (typeIdx >= 0) {
     type = name.slice(typeIdx + 1).trim();   // may contain !/+
@@ -321,7 +337,7 @@ function parseFieldToken(tok) {
     type = null;
   }
 
-  // flags from both name and type segments
+  // flags may appear on either side
   const nameHasBang = /!/.test(name);
   const nameHasPlus = /\+/.test(name);
   const typeHasBang = type ? /!/.test(type) : false;
@@ -330,7 +346,6 @@ function parseFieldToken(tok) {
   if (nameHasBang || typeHasBang) ret.notnull = true;
   if (nameHasPlus || typeHasPlus) ret.unique = true;
 
-  // Clean trailing !/+ off name and type
   name = name.replace(/[!+]+$/,"").trim();
   if (type) {
     type = type.replace(/[!+]+$/,"").trim();
@@ -351,48 +366,66 @@ function parseFieldToken(tok) {
 
 function camel(s){return s.replace(/[-_](.)/g,(_,c)=>c.toUpperCase());}
 
-// ---------------- from-json implementation ----------------
+// ---------------- from-json implementation (resilient & fast) ----------------
+
+function pick(obj, ...keys) {
+  for (const k of keys) { if (obj && obj[k] !== undefined) return obj[k]; }
+  return undefined;
+}
 
 async function runFromJson(cliOpts) {
   const file = path.resolve(cliOpts.jsonFile);
   if (!fs.existsSync(file)) die(`Config not found: ${file}`);
 
-  const raw = fs.readFileSync(file, "utf8");
   let cfg;
-  try { cfg = JSON.parse(raw); } catch (e) { die(`Invalid JSON: ${e.message}`); }
+  try {
+    cfg = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (e) {
+    die(`Invalid JSON: ${e.message}`);
+  }
 
-  // light validation against our schema
-  // (kept minimal to avoid bundling a validator)
-  if (!cfg || !Array.isArray(cfg.tables)) die(`Config must have a "tables" array.`);
+  // allow OutDir/DefaultOnDelete/Tables
+  const outDir = cliOpts.dir || pick(cfg, "outDir", "OutDir") || "schemas_cli";
+  const defaultOnDelete = pick(cfg, "defaultOnDelete", "DefaultOnDelete") ?? null;
 
-  const outDir = cliOpts.dir || cfg.outDir || "schemas_cli";
-  const defaultOnDelete = cfg.defaultOnDelete ?? null;
+  const tables = pick(cfg, "tables", "Tables");
+  if (!Array.isArray(tables)) die(`Config must have an array at "tables" (or "Tables").`);
 
   fs.mkdirSync(outDir, { recursive: true });
 
-  for (const t of cfg.tables) {
-    if (!t || !t.name || !Array.isArray(t.fields)) {
-      die(`Each table requires { name, fields[] }`);
-    }
-    // convert config fields -> tokens for existing generator
-    const tokens = [];
-    for (const f of t.fields) {
-      let token = f.name;
-      const type = (f.type || "TEXT").toLowerCase();
-
-      token += `:${type}`;
-      if (f.notnull) token += `!`;
-      if (f.unique) token += `+`;
-      if (f.fk && f.fk.table) {
-        token += `->${f.fk.table}`;
-      }
-      tokens.push(token);
-    }
+  for (let i = 0; i < tables.length; i++) {
+    const t = tables[i] || {};
+    const tName = pick(t, "name", "Name");
+    if (!tName || typeof tName !== "string") die(`Table at index ${i} is missing "name".`);
+
+    const tStamps = !!pick(t, "stamps", "Stamps");
+
+    // Accept fields/Fields/columns/Columns; items can be objects or string tokens
+    let fieldsList = pick(t, "fields", "Fields", "columns", "Columns");
+    if (!Array.isArray(fieldsList)) die(`Table "${tName}" must have "fields" array.`);
+
+    // Normalize to token strings for speed (object items are converted once)
+    const tokens = fieldsList.map(f => {
+      if (typeof f === "string") return f;
+      const name = pick(f, "name", "Name");
+      if (!name) die(`Table "${tName}" has a field without "name".`);
+      const type = String(pick(f, "type", "Type") ?? "TEXT").toLowerCase();
+      const unique = !!pick(f, "unique", "Unique");
+      const notnull = !!pick(f, "notnull", "notNull", "NotNull");
+      const fk = pick(f, "fk", "FK");
+      const fkTable = fk ? pick(fk, "table", "Table") : null;
+
+      let tok = `${name}:${type}`;
+      if (notnull) tok += "!";
+      if (unique)  tok += "+";
+      if (fkTable) tok += `->${fkTable}`;
+      return tok;
+    });
 
     await generateOne({
       outDir,
-      name: t.name,
-      stamps: !!t.stamps,
+      name: tName,
+      stamps: tStamps,
       onDelete: defaultOnDelete || null,
       force: cliOpts.force,
       fieldTokens: tokens