@hamak/smart-data-dico 1.9.1 → 1.9.3

package/backend/dist/validate.mjs

@@ -10082,6 +10082,65 @@ function validateDerivedTypes(types) {
 }
 __name(validateDerivedTypes, "validateDerivedTypes");
 
+// backend/src/models/ormVocabulary.ts
+var ORM_VOCABULARY = {
+  entity: [
+    { key: "orm.package", kind: "string", label: "Java package", mapsTo: "class package (FQN)" },
+    { key: "orm.className", kind: "string", label: "Class name", mapsTo: "class name override" },
+    { key: "orm.embeddable", kind: "flag", label: "Embeddable", mapsTo: "@Embeddable" },
+    { key: "orm.mappedSuperclass", kind: "flag", label: "Mapped superclass", mapsTo: "@MappedSuperclass" },
+    { key: "orm.extends", kind: "entityRef", label: "Extends (supertype)", mapsTo: "inheritance \u2014 extends parent entity" },
+    { key: "orm.inheritanceStrategy", kind: "enum", values: ["SINGLE_TABLE", "JOINED", "TABLE_PER_CLASS"], label: "Inheritance strategy", mapsTo: "@Inheritance (on root)" },
+    { key: "orm.discriminatorColumn", kind: "string", label: "Discriminator column", mapsTo: "@DiscriminatorColumn (root)" },
+    { key: "orm.discriminatorValue", kind: "string", label: "Discriminator value", mapsTo: "@DiscriminatorValue (subclass)" },
+    { key: "orm.idClass", kind: "string", label: "Id class", mapsTo: "@IdClass (composite key)" },
+    { key: "orm.embeddedId", kind: "string", label: "Embedded id", mapsTo: "@EmbeddedId (composite key)" }
+  ],
+  attribute: [
+    { key: "orm.javaType", kind: "string", label: "Java type", mapsTo: "field Java type override" },
+    { key: "orm.generatedValue", kind: "enum", values: ["IDENTITY", "SEQUENCE", "TABLE", "UUID", "AUTO", "NONE"], label: "Generated value", mapsTo: "@GeneratedValue" },
+    { key: "orm.sequenceName", kind: "string", label: "Sequence name", mapsTo: "@SequenceGenerator(name)" },
+    { key: "orm.allocationSize", kind: "int", label: "Allocation size", mapsTo: "@SequenceGenerator(allocationSize)" },
+    { key: "orm.enumerated", kind: "enum", values: ["STRING", "ORDINAL"], label: "Enumerated", mapsTo: "@Enumerated (enum attrs)" },
+    { key: "orm.enumType", kind: "string", label: "Enum type", mapsTo: "generated Java enum class" },
+    { key: "orm.version", kind: "flag", label: "Version", mapsTo: "@Version" },
+    { key: "orm.transient", kind: "flag", label: "Transient", mapsTo: "@Transient" },
+    { key: "orm.lob", kind: "flag", label: "Lob", mapsTo: "@Lob" },
+    { key: "orm.temporal", kind: "enum", values: ["DATE", "TIME", "TIMESTAMP"], label: "Temporal", mapsTo: "@Temporal" },
+    { key: "orm.converter", kind: "string", label: "Converter", mapsTo: "@Convert(converter)" },
+    { key: "orm.elementCollection", kind: "flag", label: "Element collection", mapsTo: "@ElementCollection" },
+    { key: "orm.embedded", kind: "flag", label: "Embedded", mapsTo: "@Embedded" }
+  ],
+  relationship: [
+    { key: "orm.fetch", kind: "enum", values: ["LAZY", "EAGER"], label: "Fetch", mapsTo: "fetch type" },
+    { key: "orm.cascade", kind: "enumList", values: ["ALL", "PERSIST", "MERGE", "REMOVE", "REFRESH", "DETACH"], label: "Cascade", mapsTo: "cascade types" },
+    { key: "orm.orphanRemoval", kind: "flag", label: "Orphan removal", mapsTo: "orphanRemoval" },
+    { key: "orm.optional", kind: "flag", label: "Optional", mapsTo: "optional" },
+    { key: "orm.mappedBy", kind: "string", label: "Mapped by", mapsTo: "mappedBy (inverse side)" },
+    { key: "orm.owningEnd", kind: "string", label: "Owning end", mapsTo: "owning side role" },
+    { key: "orm.joinTable", kind: "string", label: "Join table", mapsTo: "@JoinTable(name) for many-to-many" },
+    { key: "orm.joinColumns", kind: "string", label: "Join columns", mapsTo: "@JoinTable joinColumns" },
+    { key: "orm.inverseJoinColumns", kind: "string", label: "Inverse join columns", mapsTo: "@JoinTable inverseJoinColumns" }
+  ]
+};
+var ORM_KEYS = {
+  entity: new Set(ORM_VOCABULARY.entity.map((d) => d.key)),
+  attribute: new Set(ORM_VOCABULARY.attribute.map((d) => d.key)),
+  relationship: new Set(ORM_VOCABULARY.relationship.map((d) => d.key))
+};
+var allDefs = [
+  ...ORM_VOCABULARY.entity,
+  ...ORM_VOCABULARY.attribute,
+  ...ORM_VOCABULARY.relationship
+];
+var ORM_ENUM_VALUES = Object.fromEntries(
+  allDefs.filter((d) => d.kind === "enum" && d.values).map((d) => [d.key, d.values])
+);
+var ORM_CASCADE_VALUES = allDefs.find((d) => d.key === "orm.cascade")?.values ?? [];
+var ORM_FLAG_KEYS = new Set(
+  allDefs.filter((d) => d.kind === "flag").map((d) => d.key)
+);
+
 // backend/src/scripts/validateDico.ts
 var WS2 = wsId("dictionaries");
 var Report = class {
@@ -10237,7 +10296,137 @@ function collectAttributes(attrs, acc) {
   }
 }
 __name(collectAttributes, "collectAttributes");
-function checkPackageModel(pkg, model, globalEntityUuids, globalAttrUuids, report) {
+function checkOrmMetadata(scope, metadata, ownerDesc, label, identifier, report, ctx) {
+  const entries = (metadata || []).filter((m) => m.name.startsWith("orm."));
+  if (entries.length === 0) return;
+  const byName = new Map(entries.map((e) => [e.name, e.value]));
+  for (const m of entries) {
+    const key = m.name;
+    if (!ORM_KEYS[scope].has(key)) {
+      report.warn("orm.unknownKey", `Unknown or misplaced ORM key '${key}' on ${ownerDesc} (not a known ${scope}-level orm.* key)`, label, identifier);
+      continue;
+    }
+    const v = m.value;
+    if (key === "orm.cascade") {
+      const tokens = Array.isArray(v) ? v.map(String) : String(v).split(",").map((s) => s.trim()).filter(Boolean);
+      for (const tok of tokens) {
+        if (!ORM_CASCADE_VALUES.includes(tok)) {
+          report.error("orm.value", `ORM '${key}' on ${ownerDesc}: '${tok}' is not a valid cascade type (${ORM_CASCADE_VALUES.join("|")})`, label, identifier);
+        }
+      }
+    } else if (ORM_ENUM_VALUES[key]) {
+      if (!ORM_ENUM_VALUES[key].includes(String(v))) {
+        report.error("orm.value", `ORM '${key}' on ${ownerDesc}: '${v}' is not one of ${ORM_ENUM_VALUES[key].join("|")}`, label, identifier);
+      }
+    } else if (ORM_FLAG_KEYS.has(key) && typeof v !== "boolean") {
+      report.warn("orm.flag", `ORM flag '${key}' on ${ownerDesc} should be a boolean, got '${v}'`, label, identifier);
+    }
+  }
+  if (scope === "entity" && byName.has("orm.extends")) {
+    const ref = String(byName.get("orm.extends"));
+    if (ref && !ctx.globalEntityUuids.has(ref) && !ctx.globalEntityNames.has(ref)) {
+      report.error("orm.reference", `ORM 'orm.extends' on ${ownerDesc} references '${ref}', which is not an entity in the project`, label, identifier);
+    }
+  }
+  if (scope === "attribute" && byName.get("orm.version") === true && byName.get("orm.transient") === true) {
+    report.error("orm.conflict", `${ownerDesc} marks both orm.version and orm.transient`, label, identifier);
+  }
+  if (scope === "entity" && byName.get("orm.embeddable") === true && byName.has("orm.extends")) {
+    report.error("orm.conflict", `${ownerDesc} is orm.embeddable but also declares orm.extends (an @Embeddable cannot extend an @Entity)`, label, identifier);
+  }
+  if (scope === "attribute" && byName.has("orm.enumerated") && ctx.attrType && ctx.attrType !== "enum") {
+    report.warn("orm.enumerated", `orm.enumerated on ${ownerDesc} but the attribute type is '${ctx.attrType}', not 'enum'`, label, identifier);
+  }
+}
+__name(checkOrmMetadata, "checkOrmMetadata");
+function checkOrmInheritance(models, report) {
+  const byUuid = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const { pkg, model } of models) {
+    const fileOf = model.ownership;
+    for (const e of model.entities) {
+      const label = fileOf.entityByName.get(e.name) || fileOf.entityByUuid.get(e.uuid) || pkg;
+      const node = { entity: e, label };
+      if (e.uuid) byUuid.set(e.uuid, node);
+      if (e.name) byName.set(e.name, node);
+    }
+  }
+  const meta = /* @__PURE__ */ __name((e, key) => (e.metadata || []).find((m) => m.name === key)?.value, "meta");
+  const idOf = /* @__PURE__ */ __name((e) => e.uuid || e.name, "idOf");
+  const parentOf = /* @__PURE__ */ __name((e) => {
+    const ref = meta(e, "orm.extends");
+    if (ref === void 0 || ref === null || ref === "") return void 0;
+    const s = String(ref);
+    return byUuid.get(s) || byName.get(s);
+  }, "parentOf");
+  const reportedCycle = /* @__PURE__ */ new Set();
+  for (const node of /* @__PURE__ */ new Set([...byUuid.values(), ...byName.values()])) {
+    const e = node.entity;
+    if (meta(e, "orm.extends") === void 0) continue;
+    const path4 = /* @__PURE__ */ new Set([idOf(e)]);
+    let cur = e;
+    let steps = 0;
+    while (cur && steps++ < 100) {
+      const p = parentOf(cur);
+      if (!p) break;
+      const pid = idOf(p.entity);
+      if (path4.has(pid)) {
+        if (!reportedCycle.has(pid)) {
+          reportedCycle.add(pid);
+          report.error(
+            "orm.inheritanceCycle",
+            `ORM inheritance cycle via orm.extends through entity '${p.entity.name}'`,
+            p.label,
+            p.entity.uuid
+          );
+        }
+        break;
+      }
+      path4.add(pid);
+      cur = p.entity;
+    }
+    if (meta(e, "orm.inheritanceStrategy") !== void 0) {
+      report.warn(
+        "orm.inheritance",
+        `Entity '${e.name}' declares both orm.extends and orm.inheritanceStrategy \u2014 the strategy belongs on the root supertype`,
+        node.label,
+        e.uuid
+      );
+    }
+    const parent = parentOf(e);
+    if (parent && meta(parent.entity, "orm.embeddable") === true) {
+      report.error(
+        "orm.conflict",
+        `Entity '${e.name}' orm.extends '${parent.entity.name}', which is orm.embeddable (an @Embeddable cannot be a superclass)`,
+        node.label,
+        e.uuid
+      );
+    }
+    if (meta(e, "orm.discriminatorValue") !== void 0) {
+      let hasDisc = false;
+      let a = parentOf(e);
+      const guard = /* @__PURE__ */ new Set([idOf(e)]);
+      while (a && !guard.has(idOf(a.entity))) {
+        guard.add(idOf(a.entity));
+        if (meta(a.entity, "orm.discriminatorColumn") !== void 0) {
+          hasDisc = true;
+          break;
+        }
+        a = parentOf(a.entity);
+      }
+      if (!hasDisc) {
+        report.warn(
+          "orm.inheritance",
+          `Entity '${e.name}' sets orm.discriminatorValue but no ancestor declares orm.discriminatorColumn`,
+          node.label,
+          e.uuid
+        );
+      }
+    }
+  }
+}
+__name(checkOrmInheritance, "checkOrmInheritance");
+function checkPackageModel(pkg, model, globalEntityUuids, globalEntityNames, globalAttrUuids, report) {
   const fileOf = model.ownership;
   for (const entity of model.entities) {
     const label = fileOf.entityByName.get(entity.name) || fileOf.entityByUuid.get(entity.uuid) || pkg;
@@ -10271,6 +10460,11 @@ function checkPackageModel(pkg, model, globalEntityUuids, globalAttrUuids, repor
         globalAttrUuids.set(attr.uuid, `${label} (entity '${entity.name}', attribute '${attr.name}')`);
       }
     }
+    const ormCtx = { globalEntityUuids, globalEntityNames };
+    checkOrmMetadata("entity", entity.metadata, `entity '${entity.name}'`, label, entity.uuid, report, ormCtx);
+    for (const attr of allAttrs) {
+      checkOrmMetadata("attribute", attr.metadata, `attribute '${attr.name}' on entity '${entity.name}'`, label, attr.uuid, report, { ...ormCtx, attrType: String(attr.type) });
+    }
   }
   for (const rel of model.relationships) {
     const label = fileOf.relationshipByUuid.get(rel.uuid) || pkg;
@@ -10303,6 +10497,7 @@ function checkPackageModel(pkg, model, globalEntityUuids, globalAttrUuids, repor
         );
       }
     }
+    checkOrmMetadata("relationship", rel.metadata, `relationship '${rel.uuid}'`, label, rel.uuid, report, { globalEntityUuids, globalEntityNames });
   }
   const allRules = [
     ...model.rules,
@@ -10520,12 +10715,17 @@ async function validateProject(root, report) {
     report.warn("loader.unavailable", `App loader cross-check failed: ${e.message}`, root);
   }
   const globalEntityUuids = /* @__PURE__ */ new Set();
+  const globalEntityNames = /* @__PURE__ */ new Set();
   for (const { model } of models) {
-    for (const e of model.entities) if (e.uuid) globalEntityUuids.add(e.uuid);
+    for (const e of model.entities) {
+      if (e.uuid) globalEntityUuids.add(e.uuid);
+      if (e.name) globalEntityNames.add(e.name);
+    }
   }
   for (const { pkg, model } of models) {
-    checkPackageModel(pkg, model, globalEntityUuids, globalAttrUuids, report);
+    checkPackageModel(pkg, model, globalEntityUuids, globalEntityNames, globalAttrUuids, report);
   }
+  checkOrmInheritance(models, report);
 }
 __name(validateProject, "validateProject");
 async function main() {

package/bin/cli.js

@@ -2,7 +2,8 @@
 
 import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'node:path';
-import { existsSync, mkdirSync, cpSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync } from 'fs';
+import { homedir } from 'node:os';
 import { spawn, spawnSync } from 'child_process';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -140,56 +141,86 @@ if (existsSync(bundledServer)) {
 
 const frontendDist = join(PKG_ROOT, 'frontend', 'dist');
 
-console.log(`
+// In-app "Open project" can't hot-swap the boot-time data dir, so the server
+// persists the new project here and exits with RESTART_EXIT_CODE; we respawn
+// it with DATA_DIR set to that path. SDD_MANAGED=1 tells the server it's safe
+// to use this restart path.
+const RESTART_EXIT_CODE = 75;
+const ACTIVE_PROJECT_FILE = join(homedir(), '.dico-app', 'active-project');
+
+let currentChild = null;
+let browserOpened = false;
+
+function startServer(dir) {
+  console.log(`
   Smart Data Dictionary
 
   Port:       ${port}
-  Data:       ${dataDir}
+  Data:       ${dir}
   Profile:    ${process.env.PROFILE || 'local'}
   Frontend:   ${existsSync(frontendDist) ? 'bundled' : 'dev (use frontend dev server on :3000)'}
 `);
 
-const child = spawn(bin, binArgs, {
-  cwd: PKG_ROOT,
-  env: {
-    ...process.env,
-    PORT: port,
-    NODE_ENV: 'production',
-    PROFILE: process.env.PROFILE || 'local',
-    DATA_DIR: dataDir,
-    SDD_FRONTEND_DIST: frontendDist,
-  },
-  stdio: 'inherit',
-});
-
-child.on('error', (err) => {
-  console.error('Failed to start server:', err.message);
-  process.exit(1);
-});
-
-child.on('exit', (code) => process.exit(code || 0));
-
-// Open browser after short delay
-if (!flags.noOpen) {
-  setTimeout(async () => {
-    const url = `http://localhost:${port}`;
-    console.log(`Opening ${url} ...`);
-    try {
-      const { exec } = await import('child_process');
-      const cmd = process.platform === 'darwin' ? 'open' :
-                  process.platform === 'win32' ? 'start' : 'xdg-open';
-      exec(`${cmd} ${url}`);
-    } catch {
-      console.log(`Open ${url} in your browser`);
+  const child = spawn(bin, binArgs, {
+    cwd: PKG_ROOT,
+    env: {
+      ...process.env,
+      PORT: port,
+      NODE_ENV: 'production',
+      PROFILE: process.env.PROFILE || 'local',
+      DATA_DIR: dir,
+      SDD_FRONTEND_DIST: frontendDist,
+      SDD_MANAGED: '1',
+    },
+    stdio: 'inherit',
+  });
+  currentChild = child;
+
+  child.on('error', (err) => {
+    console.error('Failed to start server:', err.message);
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    if (code === RESTART_EXIT_CODE) {
+      // Project switch requested — read the new dir and respawn.
+      let nextDir = dir;
+      try {
+        const persisted = readFileSync(ACTIVE_PROJECT_FILE, 'utf-8').trim();
+        if (persisted) nextDir = persisted;
+      } catch { /* keep current dir */ }
+      console.log(`\nSwitching project → ${nextDir}\n`);
+      startServer(nextDir);
+      return;
     }
-  }, 3000);
+    process.exit(code || 0);
+  });
+
+  // Open the browser once, on the first start only (not on project-switch restarts).
+  if (!flags.noOpen && !browserOpened) {
+    browserOpened = true;
+    setTimeout(async () => {
+      const url = `http://localhost:${port}`;
+      console.log(`Opening ${url} ...`);
+      try {
+        const { exec } = await import('child_process');
+        const cmd = process.platform === 'darwin' ? 'open' :
+                    process.platform === 'win32' ? 'start' : 'xdg-open';
+        exec(`${cmd} ${url}`);
+      } catch {
+        console.log(`Open ${url} in your browser`);
+      }
+    }, 3000);
+  }
 }
 
+startServer(dataDir);
+
 process.on('SIGINT', () => {
   console.log('\nShutting down...');
-  child.kill('SIGINT');
+  if (currentChild) currentChild.kill('SIGINT');
 });
 
 process.on('SIGTERM', () => {
-  child.kill('SIGTERM');
+  if (currentChild) currentChild.kill('SIGTERM');
 });