@hamak/smart-data-dico 1.9.2 → 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() {