@dforge-core/metadata 0.0.31 → 0.0.32

package/CHANGELOG.md

@@ -5,6 +5,57 @@ All notable changes to `@dforge-core/metadata` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this package adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.0.32] — 2026-09-28
+
+### Added
+
+- **`translations.schema.json`** for `translations/<locale>.json` (#1299): every section
+  the installer reads (`entities` with `fields` / `columnGroups` / `constraints` and option
+  translations, `domains`, `folders`, `views`, `menus`, `settings`, `roles`, `reports`,
+  `actions`, `print_templates`) plus the new `messages` block. Strict at every level, so
+  the mistakes install ignores silently are errors: a misspelled or singular section
+  (`entity`, `menu`), nested menu `items`, `description` where `desc` is meant. Type:
+  `TranslationsFile`.
+- **`extractMessages(doc)`** (`@dforge-core/metadata/dsl`): the `info` / `warn` / `error` /
+  `exit` calls of a script, classified `literal` / `concatenated` / `dynamic`, with their
+  placeholder-value names — the list the server's `ActionDslCompiler` extracts. A shared
+  fixture (`test/fixtures/dsl-messages.json`) runs in both test suites.
+- **Message rules in `checkDsl`:** `dsl/message-placeholder` (a `{name}` the call gives no
+  value) always; `dsl/message-concatenated` and `dsl/message-untranslated` when the host
+  passes the new `DslContext.messageTranslations`.
+
+### Fixed
+
+- **String escapes are read as JavaScript reads them.** The lexer unescaped only `\n`, `\t`
+  and `\r`, so `'\u00e9'` came out as `u00e9`. It now handles `\uXXXX`, `\u{…}`, `\xHH`,
+  `\b`, `\f`, `\v`, `\0` and line continuations.
+
+- **`auditHistory` levels are `basic` / `fields` / `full`.** `manifest.schema.json` and
+  `ManifestDef` listed `none` / `minimal` / `full`, which the platform never accepted: the
+  install failed on the entity table's check constraint. `basic` logs each insert, update
+  and delete; `fields` adds the changed values; `full` also stores display names. Omit the
+  property to turn audit off. The levels are one type, `AuditHistoryLevel`.
+- **`entity.schema.json` accepts `auditHistory`.** The per-entity override of the
+  manifest default was missing from the schema, so editors flagged it as an unknown
+  property. `EntityDef.auditHistory` is added to match.
+
+### Changed
+
+- **DSL message built-ins take placeholder values** (`DSL_BUILTINS`, #1299):
+  `info(message, values?, opts?)`, `warn(message, values?, opts?)`, `error(message, values?)`,
+  `exit(message?, level?, values?)`. The message is looked up in the module's `messages`
+  translations and `{name}` placeholders are filled from `values`; record links move to
+  `opts`. `exit()` levels are documented as `info` / `warning` / `danger` / `success` — the
+  doc said `warn`, which the client does not recognise.
+- **`entity.schema.json` documents `params.currency` and `params.currencyColumn`.** A
+  `currency` field can name a column of the same entity that holds the ISO code per
+  record, instead of one fixed code (#1220).
+- **`entity.schema.json` documents nav placeholders in `refFilter`.** A condition value
+  `@[ref].[field]` reads a field through a Reference column of the current record, e.g.
+  `@[purchase_order].[supplier_id]` on an order line (#1279).
+
 ## [0.0.31] — 2026-09-24
 
 ### Changed

package/dist/dsl/index.d.ts

@@ -18,7 +18,8 @@ declare function stringValue(token: Token): string;
 /**
  * The literal text of one template chunk, delimiters removed. A chunk opens on
  * a backtick or on the `}` that closed the hole before it, and closes on a
- * backtick, on the `${` of the next hole, or on the end of the file.
+ * backtick, on the `${` of the next hole, or on the end of the file. A line
+ * break in it reads as \n, as JavaScript reads a template written with CRLF.
  */
 declare function templateChunkValue(token: Token): string;
 
@@ -152,6 +153,20 @@ declare const BUILTIN_BY_NAME: Map<string, Builtin>;
 /** Bare identifiers the runtime injects — no parentheses. */
 declare const BUILTIN_VALUES: Record<string, string>;
 
+type DslMessageKind = "literal" | "concatenated" | "dynamic";
+interface DslMessage {
+    builtin: "info" | "warn" | "error" | "exit";
+    kind: DslMessageKind;
+    /** The message text for `literal`, exactly as the runtime receives it; otherwise undefined. */
+    text?: string;
+    /** Keys of the placeholder-values object; empty without one, null when it is not an object literal. */
+    valueNames: string[] | null;
+    /** The first argument. */
+    span: Span;
+}
+/** Message calls in `execute:` and `onBeforeStart:`, in source order. */
+declare function extractMessages(doc: DslDocument): DslMessage[];
+
 type DslSeverity = "error" | "warning" | "info";
 /** One reported problem. `rule` is stable — hosts filter and suppress on it. */
 interface DslIssue {
@@ -236,16 +251,23 @@ interface DslContext {
      * none: pass `null`, not the fragment. See `EntityShape.columns`.
      */
     currentEntity?: EntityShape | null;
+    /**
+     * Each non-English locale the manifest lists in `supportedLocales` → the
+     * `messages` block of its `translations/<locale>.json` (`{}` when the file has
+     * none). Absent, the untranslated and concatenated message rules stand down,
+     * exactly as install only reports them for a module that declares locales.
+     */
+    messageTranslations?: Record<string, Record<string, string>>;
 }
 
 /**
  * Check a DSL body. Returns [] for a clean script.
  *
  * Issues come back in source-feature order (field reads, params, execution
- * mode, block spelling, built-ins, top-level returns, inline assignments)
+ * mode, block spelling, built-ins, top-level returns, inline assignments, messages)
  * rather than sorted by position — a host that wants them in file order can
  * sort on `start`.
  */
 declare function checkDsl(text: string, ctx?: DslContext): DslIssue[];
 
-export { BLOCK_KINDS, BUILTINS, BUILTIN_BY_NAME, BUILTIN_VALUES, type BlockKind, type Builtin, type CallRef, type ColumnLookup, type DslBlock, type DslContext, type DslDocument, type DslIssue, type DslParam, type DslSeverity, type EntityShape, type FieldRef, type GlobalRef, type Span, type StringArg, type Token, type TokenKind, checkDsl, parseDsl, stringValue, templateChunkValue, tokenize };
+export { BLOCK_KINDS, BUILTINS, BUILTIN_BY_NAME, BUILTIN_VALUES, type BlockKind, type Builtin, type CallRef, type ColumnLookup, type DslBlock, type DslContext, type DslDocument, type DslIssue, type DslMessage, type DslMessageKind, type DslParam, type DslSeverity, type EntityShape, type FieldRef, type GlobalRef, type Span, type StringArg, type Token, type TokenKind, checkDsl, extractMessages, parseDsl, stringValue, templateChunkValue, tokenize };

package/dist/dsl/index.js

@@ -273,24 +273,48 @@ function stringValue(token) {
 }
 function templateChunkValue(token) {
   if (token.kind !== "template") return token.text;
-  const body = token.text.slice(1);
+  const body = token.text.slice(1).replace(/\r\n?/g, "\n");
   if (body.endsWith("${")) return unescape(body.slice(0, -2));
   if (body.endsWith("`")) return unescape(body.slice(0, -1));
   return unescape(body);
 }
 function unescape(body) {
-  return body.replace(/\\(.)/g, (_, ch) => {
-    switch (ch) {
-      case "n":
-        return "\n";
-      case "t":
-        return "	";
-      case "r":
-        return "\r";
-      default:
-        return ch;
-    }
-  });
+  return body.replace(
+    /\\(u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|\r\n|[\s\S])/g,
+    (_, esc) => {
+      switch (esc[0]) {
+        case "n":
+          return "\n";
+        case "t":
+          return "	";
+        case "r":
+          return "\r";
+        case "b":
+          return "\b";
+        case "f":
+          return "\f";
+        case "v":
+          return "\v";
+        case "0":
+          return "\0";
+        case "\r":
+        case "\n":
+        case "\u2028":
+        case "\u2029":
+          return "";
+        case "u":
+        case "x":
+          if (esc.length > 1) {
+            const hex = esc[1] === "{" ? esc.slice(2, -1) : esc.slice(1);
+            const cp = parseInt(hex, 16);
+            return cp <= 1114111 ? String.fromCodePoint(cp) : esc;
+          }
+          return esc;
+        default:
+          return esc;
+      }
+    }
+  );
 }
 
 // src/dsl/parse.ts
@@ -435,10 +459,10 @@ function templateArg(tokens, start) {
   for (let j = start; j < tokens.length; j++) {
     const t = tokens[j];
     if (t.kind !== "template") continue;
-    const opens = t.text.startsWith("`");
-    if (opens) depth++;
+    const opens2 = t.text.startsWith("`");
+    if (opens2) depth++;
     if (depth === 1) {
-      if (!opens) parts.push(" ");
+      if (!opens2) parts.push(" ");
       parts.push(templateChunkValue(t));
       last = t;
       endIndex = j;
@@ -761,22 +785,27 @@ var BUILTINS = [
   // Messaging
   {
     name: "error",
-    signature: "error(message)",
+    signature: "error(message, values?)",
     returns: "never",
-    doc: "Abort the action and show an error. Rolls back all changes."
+    doc: "Abort the action and show an error. Rolls back all changes. The text is looked up in the module's `messages` translations; `{name}` placeholders are filled from `values`."
+  },
+  {
+    name: "warn",
+    signature: "warn(message, values?, opts?)",
+    returns: "void",
+    doc: "Show a warning and continue. The text is looked up in the module's `messages` translations; `{name}` placeholders are filled from `values`."
   },
-  { name: "warn", signature: "warn(message)", returns: "void", doc: "Show a warning and continue." },
   {
     name: "info",
-    signature: "info(message)",
+    signature: "info(message, values?, opts?)",
     returns: "void",
-    doc: "Show an informational message \u2014 a receipt for work the action did, not a way to publish a computed value."
+    doc: "Show an informational message \u2014 a receipt for work the action did, not a way to publish a computed value. The text is looked up in the module's `messages` translations; `{name}` placeholders are filled from `values`. `opts.links` adds record links."
   },
   {
     name: "exit",
-    signature: "exit(message?, level?)",
+    signature: "exit(message?, level?, values?)",
     returns: "never",
-    doc: "Stop the script early **without** error, keeping changes made so far. Level `'info'` (default) or `'warn'`. This is the DSL's early return \u2014 the block compiles to a bare script, so a `return` outside a function is a syntax error wherever it sits."
+    doc: "Stop the script early **without** error, keeping changes made so far. Level `'info'` (default), `'warning'`, `'danger'` or `'success'`. The message is looked up in the module's `messages` translations; `{name}` placeholders are filled from `values`. This is the DSL's early return \u2014 the block compiles to a bare script, so a `return` outside a function is a syntax error wherever it sits."
   },
   {
     name: "notify",
@@ -890,6 +919,172 @@ var BUILTIN_VALUES = {
   old: "Pre-change values, in a trigger-invoked action \u2014 read with `old[field]`. Read-only."
 };
 
+// src/dsl/messages.ts
+var VALUES_INDEX = /* @__PURE__ */ new Map([
+  ["info", 1],
+  ["warn", 1],
+  ["error", 1],
+  ["exit", 2]
+]);
+function extractMessages(doc) {
+  const out = [];
+  const { tokens } = doc;
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const t = tokens[i];
+    const valuesIndex = VALUES_INDEX.get(t.text);
+    if (t.kind !== "ident" || valuesIndex === void 0 || tokens[i + 1].text !== "(") continue;
+    if (tokens[i - 1]?.text === ".") continue;
+    const block = doc.blocks.find((b) => t.start >= b.body.start && t.start < b.body.end)?.kind;
+    if (block !== "execute" && block !== "onBeforeStart") continue;
+    const args = splitArgs(tokens, i + 1);
+    if (!args[0]?.length) continue;
+    const [kind, text] = classify(args[0]);
+    const valuesArg = args[valuesIndex];
+    out.push({
+      builtin: t.text,
+      kind,
+      text,
+      valueNames: valuesArg ? valueNames(valuesArg) : [],
+      span: { start: args[0][0].start, end: args[0][args[0].length - 1].end }
+    });
+  }
+  return out;
+}
+function splitArgs(tokens, open) {
+  const args = [];
+  let current = [];
+  let depth = 0;
+  for (let j = open + 1; j < tokens.length; j++) {
+    const t = tokens[j];
+    if (t.kind === "comment") continue;
+    if (depth === 0 && t.kind === "punct" && closes(t)) break;
+    if (depth === 0 && t.kind === "punct" && t.text === ",") {
+      args.push(current);
+      current = [];
+      continue;
+    }
+    depth += depthDelta(t);
+    current.push(t);
+  }
+  if (current.length > 0) args.push(current);
+  return args;
+}
+var isWholeTemplate = (t) => t.kind === "template" && t.text.length > 1 && t.text.startsWith("`") && t.text.endsWith("`");
+function classify(arg) {
+  const t = unwrap(arg);
+  if (t.length === 1 && t[0].kind === "string") return ["literal", stringValue(t[0])];
+  if (t.length === 1 && isWholeTemplate(t[0])) return ["literal", templateChunkValue(t[0])];
+  return [joinsText(t) ? "concatenated" : "dynamic"];
+}
+function joinsText(tokens) {
+  const t = unwrap(tokens);
+  if (t.length === 1 && t[0].kind === "string" || isTemplate(t)) return true;
+  let depth = 0;
+  let root = -1;
+  for (let j = 0; j < t.length; j++) {
+    const tok = t[j];
+    if (depth === 0) {
+      if (isLooserThanPlus(t, j)) return false;
+      if (tok.kind === "punct" && (tok.text === "+" || tok.text === "-") && endsOperand(t[j - 1])) root = j;
+    }
+    depth += depthDelta(tok);
+  }
+  if (root < 0 || t[root].text === "-") return false;
+  return joinsText(t.slice(0, root)) || joinsText(t.slice(root + 1));
+}
+var LOOSER_THAN_PLUS = /* @__PURE__ */ new Set([
+  "?",
+  ":",
+  "&&",
+  "||",
+  "=",
+  "==",
+  "!=",
+  "===",
+  "!==",
+  "<",
+  ">",
+  "<=",
+  ">=",
+  "&",
+  "|",
+  "^",
+  ",",
+  "=>",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "%="
+]);
+function isLooserThanPlus(t, j) {
+  const tok = t[j];
+  if (tok.kind === "ident") return tok.text === "in" || tok.text === "instanceof";
+  if (tok.kind !== "punct" || !LOOSER_THAN_PLUS.has(tok.text)) return false;
+  return !(tok.text === "?" && t[j + 1]?.text === ".");
+}
+function endsOperand(prev) {
+  if (!prev) return false;
+  switch (prev.kind) {
+    case "number":
+    case "string":
+    case "regex":
+      return true;
+    case "ident":
+      return !["return", "typeof", "void", "delete", "new", "in", "instanceof", "case"].includes(prev.text);
+    case "template":
+      return prev.text.endsWith("`");
+    case "punct":
+      return [")", "]", "}", "++", "--"].includes(prev.text);
+    default:
+      return false;
+  }
+}
+function isTemplate(tokens) {
+  if (tokens[0]?.kind !== "template" || !tokens[0].text.startsWith("`")) return false;
+  let depth = 0;
+  for (let j = 0; j < tokens.length; j++) {
+    depth += depthDelta(tokens[j]);
+    if (depth === 0) return j === tokens.length - 1;
+  }
+  return false;
+}
+var opens = (t) => t.kind === "punct" ? "([{".includes(t.text) : t.kind === "template" && t.text.endsWith("${");
+var closes = (t) => t.kind === "punct" ? ")]}".includes(t.text) : t.kind === "template" && t.text.startsWith("}");
+var depthDelta = (t) => Number(opens(t)) - Number(closes(t));
+function unwrap(tokens) {
+  while (tokens[0]?.text === "(" && isGroup(tokens)) tokens = tokens.slice(1, -1);
+  return tokens;
+}
+function isGroup(tokens) {
+  if (tokens.length < 2 || !opens(tokens[0])) return false;
+  let depth = 0;
+  for (let j = 0; j < tokens.length; j++) {
+    depth += depthDelta(tokens[j]);
+    if (depth === 0) return j === tokens.length - 1;
+  }
+  return false;
+}
+function valueNames(arg) {
+  const t = unwrap(arg);
+  if (t[0]?.text !== "{" || !isGroup(t)) return null;
+  const names = [];
+  let depth = 0;
+  for (let j = 0; j < t.length; j++) {
+    const tok = t[j];
+    const at = depth;
+    depth += depthDelta(tok);
+    if (at !== 1 || tok.kind !== "ident" && tok.kind !== "string") continue;
+    const prev = t[j - 1].text;
+    const next = t[j + 1]?.text;
+    if ((prev === "{" || prev === ",") && (next === ":" || next === "," || next === "}")) {
+      const name = tok.kind === "string" ? stringValue(tok) : tok.text;
+      if (name !== "links") names.push(name);
+    }
+  }
+  return names;
+}
+
 // src/dsl/check.ts
 function checkDsl(text, ctx = {}) {
   const parsed = parseDsl(text);
@@ -1230,8 +1425,38 @@ function checkDsl(text, ctx = {}) {
     }
   }
   out.push(...inlineAssignmentIssues(parsed, positionAt));
+  const locales = Object.entries(ctx.messageTranslations ?? {});
+  for (const m of extractMessages(parsed)) {
+    if (m.kind === "concatenated" && locales.length > 0) {
+      add(
+        m.span,
+        `This ${m.builtin}() message joins text and values, so it cannot be translated. Put the values in {placeholders}: ${m.builtin}('Only {n} left', ${m.builtin === "exit" ? "'warning', " : ""}{ n: qty }).`,
+        "warning",
+        "dsl/message-concatenated"
+      );
+    }
+    if (m.text === void 0) continue;
+    if (m.valueNames && m.valueNames.length > 0) {
+      for (const name of placeholders(m.text)) {
+        if (!m.valueNames.includes(name))
+          add(m.span, `{${name}} has no value in this call, so it shows as written.`, "warning", "dsl/message-placeholder");
+      }
+    }
+    const missing = locales.filter(([, messages]) => !(Object.hasOwn(messages, m.text) && messages[m.text]?.trim())).map(([locale]) => locale);
+    if (missing.length > 0) {
+      add(
+        m.span,
+        `No ${missing.join(", ")} translation for this message \u2014 add it to "messages" in translations/<locale>.json, keyed by the exact text.`,
+        "warning",
+        "dsl/message-untranslated"
+      );
+    }
+  }
   return out;
 }
+function placeholders(text) {
+  return [...new Set([...text.matchAll(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g)].map((x) => x[1]))];
+}
 function columnMatcher(columns) {
   if (!columns) return () => true;
   if (typeof columns.keys !== "function")
@@ -1428,6 +1653,7 @@ export {
   BUILTIN_BY_NAME,
   BUILTIN_VALUES,
   checkDsl,
+  extractMessages,
   parseDsl,
   stringValue,
   templateChunkValue,