@reventlessdev/reventless-spec 3.0.0-alpha.127 → 3.0.0-alpha.129

package/src/semantic/Template.res.mjs

@@ -0,0 +1,545 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Bytes$Reventless from "./Bytes.res.mjs";
+import * as Money$Reventless from "./Money.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Percent$Reventless from "./Percent.res.mjs";
+import * as Duration$Reventless from "./Duration.res.mjs";
+import * as GeoPoint$Reventless from "./GeoPoint.res.mjs";
+import * as Semantic$Reventless from "./Semantic.res.mjs";
+import * as DateRange$Reventless from "./DateRange.res.mjs";
+import * as Sensitive$Reventless from "../components/Sensitive.res.mjs";
+
+let rawFormatter = "raw";
+
+let formatters = [
+  rawFormatter,
+  Semantic$Reventless.Id.money,
+  Semantic$Reventless.Id.percent,
+  Semantic$Reventless.Id.bytes,
+  Semantic$Reventless.Id.duration,
+  Semantic$Reventless.Id.dateRange,
+  Semantic$Reventless.Id.geoPoint
+];
+
+let segmentGrammar = /^[A-Za-z0-9_]+$/;
+
+let whitespace = /\s+/g;
+
+function parsePath(raw, insideEach) {
+  let text = raw.trim();
+  if (text === "") {
+    return {
+      TAG: "Error",
+      _0: "a tag with no path"
+    };
+  }
+  let relative = text.startsWith(".");
+  if (relative && !insideEach) {
+    return {
+      TAG: "Error",
+      _0: `"` + text + `" is item-relative, and there is no item outside an "each"`
+    };
+  }
+  let body = relative ? text.slice(1) : text;
+  let segments = body === "" ? [] : body.split(".");
+  if (segments.every(segment => segmentGrammar.test(segment))) {
+    return {
+      TAG: "Ok",
+      _0: {
+        text: text,
+        relative: relative,
+        segments: segments
+      }
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: `"` + text + `" is not a path — segments are letters, digits and underscores, separated by dots`
+    };
+  }
+}
+
+function tokenize(source) {
+  let tokens = [];
+  let rest = source;
+  let failure;
+  let running = true;
+  while (running) {
+    let current = rest;
+    let start = current.indexOf("{{");
+    if (start !== -1) {
+      let before = current.slice(0, start);
+      if (before !== "") {
+        tokens.push({
+          TAG: "TextToken",
+          _0: before
+        });
+      }
+      let after = current.slice(start + 2 | 0);
+      let stop = after.indexOf("}}");
+      if (stop !== -1) {
+        tokens.push({
+          TAG: "TagToken",
+          _0: after.slice(0, stop).replace(whitespace, " ").trim()
+        });
+        rest = after.slice(stop + 2 | 0);
+      } else {
+        failure = `an opening "{{" with no closing "}}"`;
+        running = false;
+      }
+    } else {
+      if (current !== "") {
+        tokens.push({
+          TAG: "TextToken",
+          _0: current
+        });
+      }
+      running = false;
+    }
+  };
+  let message = failure;
+  if (message !== undefined) {
+    return {
+      TAG: "Error",
+      _0: message
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: tokens
+    };
+  }
+}
+
+function blockWord(kind) {
+  if (kind === "IfBlock") {
+    return "if";
+  } else {
+    return "each";
+  }
+}
+
+function parse(source) {
+  let message = tokenize(source);
+  if (message.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: message._0
+    };
+  }
+  let root = [];
+  let stack = [];
+  let failure = {
+    contents: undefined
+  };
+  let fail = message => {
+    if (Stdlib_Option.isNone(failure.contents)) {
+      failure.contents = message;
+      return;
+    }
+  };
+  let body = () => {
+    let frame = stack.at(-1);
+    if (frame !== undefined) {
+      return frame.body;
+    } else {
+      return root;
+    }
+  };
+  let insideEach = () => stack.some(frame => frame.kind === "EachBlock");
+  let addField = (rawPath, formatter) => {
+    let message = parsePath(rawPath, insideEach());
+    if (message.TAG !== "Ok") {
+      return fail(message._0);
+    }
+    body().push({
+      TAG: "Field",
+      path: message._0,
+      formatter: formatter
+    });
+  };
+  let openBlock = (kind, rawPath) => {
+    if (kind === "EachBlock" && insideEach()) {
+      return fail(`an "each" inside an "each" — iteration is one level deep`);
+    }
+    let message = parsePath(rawPath, insideEach());
+    if (message.TAG !== "Ok") {
+      return fail(message._0);
+    }
+    stack.push({
+      kind: kind,
+      path: message._0,
+      body: []
+    });
+  };
+  message._0.forEach(token => {
+    if (!Stdlib_Option.isNone(failure.contents)) {
+      return;
+    }
+    if (token.TAG === "TextToken") {
+      body().push({
+        TAG: "Text",
+        _0: token._0
+      });
+      return;
+    }
+    let tag = token._0;
+    if (tag.startsWith("#")) {
+      let rest = tag.slice(1).trim();
+      let at = rest.indexOf(" ");
+      if (at === -1) {
+        return fail(`"{{# ` + rest + ` }}" opens a block with no path`);
+      }
+      let word = rest.slice(0, at);
+      switch (word) {
+        case "each" :
+          return openBlock("EachBlock", rest.slice(at + 1 | 0));
+        case "if" :
+          return openBlock("IfBlock", rest.slice(at + 1 | 0));
+        default:
+          return fail(`"` + word + `" is not a block — "if" and "each" are`);
+      }
+    } else {
+      if (tag.startsWith("/")) {
+        let word$1 = tag.slice(1).trim();
+        let frame = stack.pop();
+        if (frame === undefined) {
+          return fail(`a closing "{{/ ` + word$1 + ` }}" with nothing open`);
+        }
+        if (blockWord(frame.kind) !== word$1) {
+          return fail(`"{{/ ` + word$1 + ` }}" closes a "` + blockWord(frame.kind) + `"`);
+        }
+        let match = frame.kind;
+        let tmp;
+        tmp = match === "IfBlock" ? ({
+            TAG: "If",
+            path: frame.path,
+            body: frame.body
+          }) : ({
+            TAG: "Each",
+            path: frame.path,
+            body: frame.body
+          });
+        body().push(tmp);
+        return;
+      }
+      let match$1 = tag.split("|");
+      let len = match$1.length;
+      if (len >= 3) {
+        return fail(`"` + tag + `" names more than one formatter`);
+      }
+      switch (len) {
+        case 0 :
+          return fail(`"` + tag + `" names more than one formatter`);
+        case 1 :
+          let rawPath = match$1[0];
+          return addField(rawPath, undefined);
+        case 2 :
+          let rawPath$1 = match$1[0];
+          let name = match$1[1];
+          let formatter = name.trim();
+          if (formatters.includes(formatter)) {
+            return addField(rawPath$1, formatter);
+          } else {
+            return fail(`"` + formatter + `" is not a formatter — one of ` + formatters.join(", "));
+          }
+      }
+    }
+  });
+  let message$1 = failure.contents;
+  if (message$1 !== undefined) {
+    return {
+      TAG: "Error",
+      _0: message$1
+    };
+  }
+  let frame = stack.at(-1);
+  if (frame !== undefined) {
+    return {
+      TAG: "Error",
+      _0: `"{{# ` + blockWord(frame.kind) + ` ` + frame.path.text + ` }}" was never closed`
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: root
+    };
+  }
+}
+
+let nothing = {
+  value: undefined,
+  schema: undefined
+};
+
+function missing(path) {
+  return `[missing: ` + path.text + `]`;
+}
+
+function withheld(path) {
+  return `[withheld: ` + path.text + `]`;
+}
+
+function unwrap(schema) {
+  return Stdlib_Option.getOr(Semantic$Reventless.unwrapOptional(schema), schema);
+}
+
+function propertyOf(schema, name) {
+  let match = Stdlib_Option.getOr(Semantic$Reventless.unwrapOptional(schema), schema);
+  if (match.type === "object") {
+    return match.properties[name];
+  }
+}
+
+function elementOf(schema) {
+  let match = Stdlib_Option.getOr(Semantic$Reventless.unwrapOptional(schema), schema);
+  if (match.type !== "array") {
+    return;
+  }
+  let item = match.additionalItems;
+  if (item === "strip" || item === "strict") {
+    return;
+  } else {
+    return item;
+  }
+}
+
+function step(scope, segment) {
+  let match = scope.value;
+  let tmp;
+  tmp = typeof match === "object" && match !== null && !Array.isArray(match) ? match[segment] : undefined;
+  return {
+    value: tmp,
+    schema: Stdlib_Option.flatMap(scope.schema, __x => propertyOf(__x, segment))
+  };
+}
+
+function resolve(path, root, item) {
+  return Stdlib_Array.reduce(path.segments, path.relative ? Stdlib_Option.getOr(item, nothing) : root, step);
+}
+
+function lookup(payload, dotted) {
+  return Stdlib_Array.reduce(dotted.split("."), {
+    value: payload,
+    schema: undefined
+  }, step).value;
+}
+
+function isWithheld(schema) {
+  if (schema === undefined) {
+    return false;
+  }
+  if (Sensitive$Reventless.isFieldSensitive(schema)) {
+    return true;
+  }
+  let match = Semantic$Reventless.getFrom(schema);
+  if (match !== undefined) {
+    return Sensitive$Reventless.impliedBySemantic(match.id);
+  } else {
+    return false;
+  }
+}
+
+function parseSafely(json, schema) {
+  try {
+    return Primitive_option.some(S.parseOrThrow(json, schema));
+  } catch (exn) {
+    return;
+  }
+}
+
+function formatBySemantic(json, id) {
+  if (id === Semantic$Reventless.Id.money) {
+    return Stdlib_Option.map(parseSafely(json, Money$Reventless.schema), Money$Reventless.format);
+  } else if (id === Semantic$Reventless.Id.dateRange) {
+    return Stdlib_Option.map(parseSafely(json, DateRange$Reventless.schema), DateRange$Reventless.format);
+  } else if (id === Semantic$Reventless.Id.geoPoint) {
+    return Stdlib_Option.map(parseSafely(json, GeoPoint$Reventless.schema), GeoPoint$Reventless.format);
+  } else if (typeof json === "number") {
+    if (id === Semantic$Reventless.Id.percent) {
+      return Percent$Reventless.format(json);
+    } else if (id === Semantic$Reventless.Id.bytes) {
+      return Bytes$Reventless.format(json);
+    } else if (id === Semantic$Reventless.Id.duration) {
+      return Duration$Reventless.format(json | 0);
+    } else {
+      return;
+    }
+  } else {
+    return;
+  }
+}
+
+function scalar(value) {
+  if (value === null) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  switch (typeof value) {
+    case "boolean" :
+      if (value) {
+        return "true";
+      } else {
+        return "false";
+      }
+    case "string" :
+      return value;
+    case "number" :
+      return value.toString();
+    case "object" :
+      return JSON.stringify(value);
+  }
+}
+
+function truthy(value) {
+  if (value === undefined) {
+    return false;
+  }
+  if (value === null) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return value.length !== 0;
+  }
+  switch (typeof value) {
+    case "boolean" :
+      return value;
+    case "string" :
+      return value !== "";
+    case "number" :
+      return value !== 0.0;
+    case "object" :
+      return true;
+  }
+}
+
+function renderField(path, formatter, root, item) {
+  let scope = resolve(path, root, item);
+  if (isWithheld(scope.schema)) {
+    return withheld(path);
+  }
+  let value = scope.value;
+  if (value === undefined) {
+    return missing(path);
+  }
+  if (value === null) {
+    return missing(path);
+  }
+  if (formatter !== undefined) {
+    if (formatter === rawFormatter) {
+      return scalar(value);
+    } else {
+      return Stdlib_Option.getOr(formatBySemantic(value, formatter), scalar(value));
+    }
+  }
+  let match = Stdlib_Option.flatMap(scope.schema, Semantic$Reventless.getFrom);
+  if (match !== undefined) {
+    return Stdlib_Option.getOr(formatBySemantic(value, match.id), scalar(value));
+  } else {
+    return scalar(value);
+  }
+}
+
+function renderNodes(nodes, root, item, out) {
+  nodes.forEach(node => {
+    switch (node.TAG) {
+      case "Text" :
+        out.push(node._0);
+        return;
+      case "Field" :
+        out.push(renderField(node.path, node.formatter, root, item));
+        return;
+      case "If" :
+        if (truthy(resolve(node.path, root, item).value)) {
+          return renderNodes(node.body, root, item, out);
+        } else {
+          return;
+        }
+      case "Each" :
+        let body = node.body;
+        let path = node.path;
+        let scope = resolve(path, root, item);
+        if (isWithheld(scope.schema)) {
+          out.push(withheld(path));
+          return;
+        }
+        let match = scope.value;
+        if (Array.isArray(match)) {
+          let element = Stdlib_Option.flatMap(scope.schema, elementOf);
+          let total = match.length;
+          let shown = total > 100 ? 100 : total;
+          for (let index = 0; index < shown; ++index) {
+            renderNodes(body, root, {
+              value: match[index],
+              schema: element
+            }, out);
+          }
+          if (total > shown) {
+            out.push(`[… ` + (total - shown | 0).toString() + ` more]`);
+            return;
+          } else {
+            return;
+          }
+        }
+        out.push(missing(path));
+        return;
+        break;
+    }
+  });
+}
+
+function render(template, payload, schema) {
+  let out = [];
+  renderNodes(template, {
+    value: payload,
+    schema: schema
+  }, undefined, out);
+  return out.join("");
+}
+
+function renderSource(source, payload, schema) {
+  return Stdlib_Result.map(parse(source), template => render(template, payload, schema));
+}
+
+let variantSchema = Semantic$Reventless.unionVariant;
+
+let maxItems = 100;
+
+export {
+  rawFormatter,
+  formatters,
+  segmentGrammar,
+  whitespace,
+  parsePath,
+  tokenize,
+  blockWord,
+  parse,
+  nothing,
+  missing,
+  withheld,
+  maxItems,
+  unwrap,
+  propertyOf,
+  elementOf,
+  step,
+  resolve,
+  lookup,
+  isWithheld,
+  parseSafely,
+  formatBySemantic,
+  scalar,
+  truthy,
+  renderField,
+  renderNodes,
+  render,
+  renderSource,
+  variantSchema,
+}
+/* S Not a pure module */

package/src/types/Message.res

@@ -141,22 +141,23 @@ type commandJson = {
 
 // ── Schema-migration-on-read ──────────────────────────────────────────────────
 // Nested `@schema` types (notably `pluginDefinition`/`pluginStructure`) gain fields
-// over time — `kind`, `chapter`, `events`, `extensionPoints`, `apiExposed`, … Because
-// those types are JSON-encoded inside union-variant payloads, every optional field must
-// use the `js_nullable` (`T | null`) encoding: it is the only JSON-safe optional form,
-// since `S.option`/`nullableAsOption` carry `undefined`, which fails sury's
-// `jsonableValidation` inside a union variant. That encoding is *present-required on
-// decode*, so ONE message persisted before a field was added SuryError-bricks decode. For
-// an aggregate that rehydrates from its own event log (the Plugin lifecycle aggregate),
-// that single event then freezes EVERY later heartbeat/redetect/connect on that instance
-// — a silent lifecycle freeze with no error surfaced near the operator.
+// over time — `kind`, `chapter`, `events`, `extensionPoints`, `apiExposed`, … A field
+// that is not optional is *present-required on decode*, so ONE message persisted before
+// it was added SuryError-bricks decode. For an aggregate that rehydrates from its own
+// event log (the Plugin lifecycle aggregate), that single event then freezes EVERY later
+// heartbeat/redetect/connect on that instance — a silent lifecycle freeze with no error
+// surfaced near the operator.
 //
 // We heal on read. Strict decode stays the fast path (unchanged for every current
 // message); only when it throws do we schema-guide the raw JSON and retry once. The fill
 // walks the target sury schema and inserts, for any absent field, the value that field's
-// schema expects: `null` for a `T | null` union (→ `None`), `[]` for a missing array, the
+// schema expects: `null` for a `T | null` union (→ `None`), nothing at all for an
+// `option` (a union admitting `undefined` — also `None`), `[]` for a missing array, the
 // first variant of a mandatory enum (`kind` → `Domain`), a filled `{}` for a missing
-// nested object, and a zero value for a missing scalar. It descends only into values
+// nested object, and a zero value for a missing scalar. The `undefined` arm mirrors the
+// `null` one and must precede the enum/object guesses below it: an absent `option<enum>`
+// would otherwise heal to that enum's first variant and an absent `option<record>` to a
+// filled `{}`, turning `None` into a `Some` of an invented value. It descends only into values
 // actually present, matches tagged-union members by their `TAG` const, is purely additive
 // (clones via a JSON round-trip; never re-encodes through the schema), is idempotent on
 // valid data, and falls back to the ORIGINAL error when the fill doesn't resolve the
@@ -229,6 +230,7 @@ let fillMissingDefaults: (S.t<'a>, JSON.t, array<string>) => JSON.t = %raw(`func
         var has=schema.has||{};
         if(value===undefined){
           if(has.null) return null;
+          if(has.undefined) return undefined;
           var c=firstConst(schema.anyOf); if(c!==undefined) return c;
           var obj=(schema.anyOf||[]).find(function(s){return s.type==="object";}); if(obj) return fill(obj,{},path);
           return undefined;
@@ -273,7 +275,7 @@ let parseJsonTolerant = (json, schema) =>
             ->Int.toString} missing scalar field(s): ${scalarFills->Array.join(
               ", ",
             )}. A required scalar was added to a persisted type after this message was ` ++
-          `written; the value above is fabricated, not recovered. Prefer a js_nullable (T | null) field.`,
+          `written; the value above is fabricated, not recovered. Prefer an optional field.`,
         )
       }
       value

package/src/types/Message.res.mjs

@@ -87,6 +87,7 @@ let fillMissingDefaults = (function(schema, json, scalarFills){
         var has=schema.has||{};
         if(value===undefined){
           if(has.null) return null;
+          if(has.undefined) return undefined;
           var c=firstConst(schema.anyOf); if(c!==undefined) return c;
           var obj=(schema.anyOf||[]).find(function(s){return s.type==="object";}); if(obj) return fill(obj,{},path);
           return undefined;
@@ -126,7 +127,7 @@ function parseJsonTolerant(json, schema) {
       throw firstErr;
     }
     if (scalarFills.length !== 0) {
-      console.warn(`[reventless] decoded a stored message by inventing ` + scalarFills.length.toString() + ` missing scalar field(s): ` + scalarFills.join(", ") + `. A required scalar was added to a persisted type after this message was written; the value above is fabricated, not recovered. Prefer a js_nullable (T | null) field.`);
+      console.warn(`[reventless] decoded a stored message by inventing ` + scalarFills.length.toString() + ` missing scalar field(s): ` + scalarFills.join(", ") + `. A required scalar was added to a persisted type after this message was written; the value above is fabricated, not recovered. Prefer an optional field.`);
     }
     return value;
   }