@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/OutboundTranslation_GWT.res.mjs

@@ -0,0 +1,186 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+
+function Make(Spec) {
+  S.enableJson();
+  let test = (name, timeout, body) => JestBind$ReventlessGwt.testPromise(Spec.name, name, timeout, body);
+  let testSync = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+  let encItems = arr => arr.map(param => [
+    param[0],
+    Message$ReventlessCore.encode(param[1], Spec.outboundItemSchema)
+  ]);
+  let givenEvent = e => e;
+  let whenCollect = e => Spec.collect(e);
+  let thenTodos = (actual, expected) => {
+    if (Primitive_object.equal(actual, expected)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "TodoMismatch",
+        expected: encItems(expected),
+        actual: encItems(actual)
+      });
+    }
+  };
+  let givenTodo = (id, item) => [
+    id,
+    item
+  ];
+  let whenTranslateMocked = async (param, mock) => {
+    let item = param[1];
+    let id = param[0];
+    let result = await mock(id, item);
+    return {
+      id: id,
+      item: item,
+      result: result,
+      retries: 0
+    };
+  };
+  let whenTranslateRetrying = async (param, maxRetries, mock) => {
+    let item = param[1];
+    let id = param[0];
+    let result = {
+      contents: await mock(id, item)
+    };
+    let retries = 0;
+    let failed = () => {
+      let match = result.contents;
+      return match.TAG !== "Ok";
+    };
+    while (failed() && retries < maxRetries) {
+      retries = retries + 1 | 0;
+      result.contents = await mock(id, item);
+    };
+    return {
+      id: id,
+      item: item,
+      result: result.contents,
+      retries: retries
+    };
+  };
+  let commandPairJson = (id, cmd) => {
+    let d = {};
+    d["id"] = id;
+    d["command"] = Message$ReventlessCore.encode(cmd, Spec.inboundCommandSchema);
+    return d;
+  };
+  let thenCommand = async (pending, expectedId, expectedCmd) => {
+    let match = await pending;
+    let result = match.result;
+    if (result.TAG !== "Ok") {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "TranslateError",
+        expected: "(command)",
+        actual: result._0
+      });
+    }
+    let match$1 = result._0;
+    if (match$1 === undefined) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: [commandPairJson(expectedId, expectedCmd)],
+        actual: []
+      });
+    }
+    let cmd = match$1[1];
+    let id = match$1[0];
+    if (id === expectedId && Primitive_object.equal(cmd, expectedCmd)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: [commandPairJson(expectedId, expectedCmd)],
+        actual: [commandPairJson(id, cmd)]
+      });
+    }
+  };
+  let thenNoCommand = async pending => {
+    let match = await pending;
+    let result = match.result;
+    if (result.TAG !== "Ok") {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "TranslateError",
+        expected: "(no command)",
+        actual: result._0
+      });
+    }
+    let match$1 = result._0;
+    if (match$1 !== undefined) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "NoEventExpected",
+        actual: [commandPairJson(match$1[0], match$1[1])]
+      });
+    } else {
+      return Outcome$ReventlessGwt.pass;
+    }
+  };
+  let thenRetryRecorded = async (pending, expectedRetries) => {
+    let match = await pending;
+    let retries = match.retries;
+    if (retries === expectedRetries) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "StateMismatch",
+        key: "retries",
+        expected: expectedRetries,
+        actual: retries
+      });
+    }
+  };
+  let statusToString = s => {
+    if (s === "Pending") {
+      return "#Pending";
+    } else {
+      return "#Completed";
+    }
+  };
+  let thenTodoStatus = async (pending, expectedId, expectedStatus) => {
+    let match = await pending;
+    let id = match.id;
+    let actualStatus;
+    actualStatus = match.result.TAG === "Ok" ? "Completed" : "Pending";
+    if (id === expectedId && actualStatus === expectedStatus) {
+      return Outcome$ReventlessGwt.pass;
+    }
+    let encOne = (rid, rstatus) => {
+      let d = {};
+      d["id"] = rid;
+      d["status"] = statusToString(rstatus);
+      return d;
+    };
+    return Outcome$ReventlessGwt.fail({
+      TAG: "StateMismatch",
+      key: id,
+      expected: encOne(expectedId, expectedStatus),
+      actual: encOne(id, actualStatus)
+    });
+  };
+  return {
+    Spec: Spec,
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    testSync: testSync,
+    givenEvent: givenEvent,
+    whenCollect: whenCollect,
+    thenTodos: thenTodos,
+    givenTodo: givenTodo,
+    whenTranslateMocked: whenTranslateMocked,
+    whenTranslateRetrying: whenTranslateRetrying,
+    thenCommand: thenCommand,
+    thenNoCommand: thenNoCommand,
+    thenRetryRecorded: thenRetryRecorded,
+    thenTodoStatus: thenTodoStatus
+  };
+}
+
+export {
+  Make,
+}
+/* S Not a pure module */

package/src/Outcome.res

@@ -0,0 +1,161 @@
+// The `Outcome` algebra — Stage 2 of the reventless-gwt plan.
+//
+// Every `then*` combinator in every GWT DSL returns `Outcome.outcome`
+// (`result<unit, mismatch>`). The runner, the human formatter, the AI loop,
+// and the IDE all consume the same `Outcome` value, just rendered differently.
+//
+// See `docs/analysis/given-when-then-specifications.md` §3.2 for the canonical
+// shape and §3.3 for the JSON rendering. Stage 7 adds sury-aware rendering and
+// structural `fieldDiff`. Stage 4 added `AppendConditionMismatch`.
+
+type mismatch =
+  | EventsMismatch({expected: array<JSON.t>, actual: array<JSON.t>})
+  | ErrorMismatch({
+      expected: JSON.t,
+      actual: option<JSON.t>,
+      actualEvents: array<JSON.t>,
+    })
+  | StateMismatch({key: string, expected: option<JSON.t>, actual: option<JSON.t>})
+  | NoEventExpected({actual: array<JSON.t>})
+  | TodoMismatch({expected: array<(string, JSON.t)>, actual: array<(string, JSON.t)>})
+  | AppendConditionMismatch({expected: JSON.t, actual: JSON.t})
+  | TranslateError({expected: string, actual: option<string>})
+  | QueryRowsMismatch({expected: array<JSON.t>, actual: array<JSON.t>})
+  // The set of published actions (events/commands) emitted by an ExtensionPoint
+  // mapping or an Extension delegate diverged from the expectation. Supports
+  // one-to-many fan-out (one inbound message → N published actions). Used by
+  // `Delegate_GWT` and the cross-plugin `Flow_GWT` boundary steps.
+  | PublishedActionsMismatch({expected: array<JSON.t>, actual: array<JSON.t>})
+  | Throw({error: string, stack: string})
+
+type outcome = result<unit, mismatch>
+
+let pass: outcome = Ok()
+let fail = (m): outcome => Error(m)
+
+let kindName = (m: mismatch) =>
+  switch m {
+  | EventsMismatch(_) => "EventsMismatch"
+  | ErrorMismatch(_) => "ErrorMismatch"
+  | StateMismatch(_) => "StateMismatch"
+  | NoEventExpected(_) => "NoEventExpected"
+  | TodoMismatch(_) => "TodoMismatch"
+  | AppendConditionMismatch(_) => "AppendConditionMismatch"
+  | TranslateError(_) => "TranslateError"
+  | QueryRowsMismatch(_) => "QueryRowsMismatch"
+  | PublishedActionsMismatch(_) => "PublishedActionsMismatch"
+  | Throw(_) => "Throw"
+  }
+
+let stringifyJson = (j: JSON.t) => JSON.stringify(j, ~space=2)
+let stringifyOptJson = (j: option<JSON.t>) =>
+  switch j {
+  | Some(v) => stringifyJson(v)
+  | None => "(none)"
+  }
+let stringifyJsonArray = (arr: array<JSON.t>) =>
+  "[" ++ arr->Array.map(stringifyJson)->Array.join(", ") ++ "]"
+
+let format = (m: mismatch) =>
+  switch m {
+  | EventsMismatch({expected, actual}) =>
+    `EventsMismatch:\n  expected: ${stringifyJsonArray(expected)}\n  actual:   ${stringifyJsonArray(
+        actual,
+      )}`
+  | ErrorMismatch({expected, actual, actualEvents}) =>
+    `ErrorMismatch:\n  expected error: ${stringifyJson(expected)}\n  actual error:   ${stringifyOptJson(
+        actual,
+      )}\n  actual events:  ${stringifyJsonArray(actualEvents)}`
+  | StateMismatch({key, expected, actual}) =>
+    `StateMismatch (key: ${key}):\n  expected: ${stringifyOptJson(
+        expected,
+      )}\n  actual:   ${stringifyOptJson(actual)}`
+  | NoEventExpected({actual}) =>
+    `NoEventExpected: expected no events, got:\n  ${stringifyJsonArray(actual)}`
+  | TodoMismatch({expected, actual}) => {
+      let fmt = arr =>
+        arr
+        ->Array.map(((id, j)) => `(${id}, ${stringifyJson(j)})`)
+        ->Array.join(", ")
+      `TodoMismatch:\n  expected: [${fmt(expected)}]\n  actual:   [${fmt(actual)}]`
+    }
+  | AppendConditionMismatch({expected, actual}) =>
+    `AppendConditionMismatch:\n  expected: ${stringifyJson(expected)}\n  actual:   ${stringifyJson(
+        actual,
+      )}`
+  | TranslateError({expected, actual}) =>
+    `TranslateError:\n  expected: ${expected}\n  actual:   ${actual->Option.getOr("(none)")}`
+  | QueryRowsMismatch({expected, actual}) =>
+    `QueryRowsMismatch:\n  expected: ${stringifyJsonArray(expected)}\n  actual:   ${stringifyJsonArray(
+        actual,
+      )}`
+  | PublishedActionsMismatch({expected, actual}) =>
+    `PublishedActionsMismatch:\n  expected: ${stringifyJsonArray(expected)}\n  actual:   ${stringifyJsonArray(
+        actual,
+      )}`
+  | Throw({error, stack}) => `Throw: ${error}\n${stack}`
+  }
+
+// Structured JSON payload per §3.3 of the analysis.
+// Closed schema — consumers switch on the `kind` discriminator.
+// Stage 7 enriches with `rendered` strings and `fieldDiff`.
+let toJson = (m: mismatch): JSON.t => {
+  let obj = Dict.make()
+  obj->Dict.set("kind", JSON.Encode.string(kindName(m)))
+  let jsonArr = arr => JSON.Encode.array(arr)
+  let optJson = o => o->Option.getOr(JSON.Encode.null)
+  switch m {
+  | EventsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", jsonArr(expected))
+      obj->Dict.set("actual", jsonArr(actual))
+    }
+  | ErrorMismatch({expected, actual, actualEvents}) => {
+      obj->Dict.set("expected", expected)
+      obj->Dict.set("actual", optJson(actual))
+      obj->Dict.set("actualEvents", jsonArr(actualEvents))
+    }
+  | StateMismatch({key, expected, actual}) => {
+      obj->Dict.set("key", JSON.Encode.string(key))
+      obj->Dict.set("expected", optJson(expected))
+      obj->Dict.set("actual", optJson(actual))
+    }
+  | NoEventExpected({actual}) => obj->Dict.set("actual", jsonArr(actual))
+  | TodoMismatch({expected, actual}) => {
+      let pairArr = pairs =>
+        pairs
+        ->Array.map(((id, v)) => {
+          let d = Dict.make()
+          d->Dict.set("id", JSON.Encode.string(id))
+          d->Dict.set("value", v)
+          JSON.Encode.object(d)
+        })
+        ->jsonArr
+      obj->Dict.set("expected", pairArr(expected))
+      obj->Dict.set("actual", pairArr(actual))
+    }
+  | AppendConditionMismatch({expected, actual}) => {
+      obj->Dict.set("expected", expected)
+      obj->Dict.set("actual", actual)
+    }
+  | TranslateError({expected, actual}) => {
+      obj->Dict.set("expected", JSON.Encode.string(expected))
+      obj->Dict.set(
+        "actual",
+        actual->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+      )
+    }
+  | QueryRowsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", jsonArr(expected))
+      obj->Dict.set("actual", jsonArr(actual))
+    }
+  | PublishedActionsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", jsonArr(expected))
+      obj->Dict.set("actual", jsonArr(actual))
+    }
+  | Throw({error, stack}) => {
+      obj->Dict.set("error", JSON.Encode.string(error))
+      obj->Dict.set("stack", JSON.Encode.string(stack))
+    }
+  }
+  JSON.Encode.object(obj)
+}

package/src/Outcome.res.mjs

@@ -0,0 +1,140 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function fail(m) {
+  return {
+    TAG: "Error",
+    _0: m
+  };
+}
+
+function kindName(m) {
+  switch (m.TAG) {
+    case "EventsMismatch" :
+      return "EventsMismatch";
+    case "ErrorMismatch" :
+      return "ErrorMismatch";
+    case "StateMismatch" :
+      return "StateMismatch";
+    case "NoEventExpected" :
+      return "NoEventExpected";
+    case "TodoMismatch" :
+      return "TodoMismatch";
+    case "AppendConditionMismatch" :
+      return "AppendConditionMismatch";
+    case "TranslateError" :
+      return "TranslateError";
+    case "QueryRowsMismatch" :
+      return "QueryRowsMismatch";
+    case "PublishedActionsMismatch" :
+      return "PublishedActionsMismatch";
+    case "Throw" :
+      return "Throw";
+  }
+}
+
+function stringifyJson(j) {
+  return JSON.stringify(j, undefined, 2);
+}
+
+function stringifyOptJson(j) {
+  if (j !== undefined) {
+    return JSON.stringify(j, undefined, 2);
+  } else {
+    return "(none)";
+  }
+}
+
+function stringifyJsonArray(arr) {
+  return "[" + arr.map(stringifyJson).join(", ") + "]";
+}
+
+function format(m) {
+  switch (m.TAG) {
+    case "EventsMismatch" :
+      return `EventsMismatch:\n  expected: ` + stringifyJsonArray(m.expected) + `\n  actual:   ` + stringifyJsonArray(m.actual);
+    case "ErrorMismatch" :
+      return `ErrorMismatch:\n  expected error: ` + JSON.stringify(m.expected, undefined, 2) + `\n  actual error:   ` + stringifyOptJson(m.actual) + `\n  actual events:  ` + stringifyJsonArray(m.actualEvents);
+    case "StateMismatch" :
+      return `StateMismatch (key: ` + m.key + `):\n  expected: ` + stringifyOptJson(m.expected) + `\n  actual:   ` + stringifyOptJson(m.actual);
+    case "NoEventExpected" :
+      return `NoEventExpected: expected no events, got:\n  ` + stringifyJsonArray(m.actual);
+    case "TodoMismatch" :
+      let fmt = arr => arr.map(param => `(` + param[0] + `, ` + JSON.stringify(param[1], undefined, 2) + `)`).join(", ");
+      return `TodoMismatch:\n  expected: [` + fmt(m.expected) + `]\n  actual:   [` + fmt(m.actual) + `]`;
+    case "AppendConditionMismatch" :
+      return `AppendConditionMismatch:\n  expected: ` + JSON.stringify(m.expected, undefined, 2) + `\n  actual:   ` + JSON.stringify(m.actual, undefined, 2);
+    case "TranslateError" :
+      return `TranslateError:\n  expected: ` + m.expected + `\n  actual:   ` + Stdlib_Option.getOr(m.actual, "(none)");
+    case "QueryRowsMismatch" :
+      return `QueryRowsMismatch:\n  expected: ` + stringifyJsonArray(m.expected) + `\n  actual:   ` + stringifyJsonArray(m.actual);
+    case "PublishedActionsMismatch" :
+      return `PublishedActionsMismatch:\n  expected: ` + stringifyJsonArray(m.expected) + `\n  actual:   ` + stringifyJsonArray(m.actual);
+    case "Throw" :
+      return `Throw: ` + m.error + `\n` + m.stack;
+  }
+}
+
+function toJson(m) {
+  let obj = {};
+  obj["kind"] = kindName(m);
+  switch (m.TAG) {
+    case "ErrorMismatch" :
+      obj["expected"] = m.expected;
+      obj["actual"] = Stdlib_Option.getOr(m.actual, null);
+      obj["actualEvents"] = m.actualEvents;
+      break;
+    case "StateMismatch" :
+      obj["key"] = m.key;
+      obj["expected"] = Stdlib_Option.getOr(m.expected, null);
+      obj["actual"] = Stdlib_Option.getOr(m.actual, null);
+      break;
+    case "NoEventExpected" :
+      obj["actual"] = m.actual;
+      break;
+    case "TodoMismatch" :
+      let pairArr = pairs => pairs.map(param => {
+        let d = {};
+        d["id"] = param[0];
+        d["value"] = param[1];
+        return d;
+      });
+      obj["expected"] = pairArr(m.expected);
+      obj["actual"] = pairArr(m.actual);
+      break;
+    case "TranslateError" :
+      obj["expected"] = m.expected;
+      obj["actual"] = Stdlib_Option.mapOr(m.actual, null, prim => prim);
+      break;
+    case "EventsMismatch" :
+    case "AppendConditionMismatch" :
+    case "QueryRowsMismatch" :
+    case "PublishedActionsMismatch" :
+      obj["expected"] = m.expected;
+      obj["actual"] = m.actual;
+      break;
+    case "Throw" :
+      obj["error"] = m.error;
+      obj["stack"] = m.stack;
+      break;
+  }
+  return obj;
+}
+
+let pass = {
+  TAG: "Ok",
+  _0: undefined
+};
+
+export {
+  pass,
+  fail,
+  kindName,
+  stringifyJson,
+  stringifyOptJson,
+  stringifyJsonArray,
+  format,
+  toJson,
+}
+/* No side effect */

package/src/PackageScan.res

@@ -0,0 +1,80 @@
+// Derives the set of workspace packages that own GWT test files, so a watch
+// session knows which packages to keep compiling (`pnpm run start` →
+// `rescript build -w`). Given the absolute test-file paths from `Discovery`,
+// each is mapped to its nearest ancestor `package.json` that declares a
+// `start` script; results are deduplicated by directory.
+//
+// This is the input both the `packages` NDJSON event (FormatterVsCode) and the
+// watch-mode build manager (ProcessManager) consume — computed fresh per run so
+// it never drifts when a plugin is added or removed.
+
+type pkg = {
+  // Package name from package.json (may be "" if absent).
+  name: string,
+  // Absolute directory containing the owning package.json.
+  dir: string,
+  // The `start` script's command (the ReScript watch command), informational.
+  build: string,
+}
+
+@module("node:fs") external _existsSync: string => bool = "existsSync"
+@module("node:fs") external _readFileSync: (string, string) => string = "readFileSync"
+@module("node:path") external dirname: string => string = "dirname"
+@module("node:path") external join: (string, string) => string = "join"
+
+// Reads name + `start` command from a package.json, if it declares one.
+let readPackage = (pkgJsonPath: string): option<(string, string)> =>
+  try {
+    let json = JSON.parseOrThrow(_readFileSync(pkgJsonPath, "utf8"))
+    switch json {
+    | Object(obj) =>
+      let name = switch obj->Dict.get("name") {
+      | Some(String(n)) => n
+      | _ => ""
+      }
+      switch obj->Dict.get("scripts") {
+      | Some(Object(scripts)) =>
+        switch scripts->Dict.get("start") {
+        | Some(String(cmd)) => Some((name, cmd))
+        | _ => None
+        }
+      | _ => None
+      }
+    | _ => None
+    }
+  } catch {
+  | _ => None
+  }
+
+// Walks up from `dir` to the nearest package.json declaring a `start` script.
+let rec findOwning = (dir: string): option<pkg> => {
+  let pkgJson = join(dir, "package.json")
+  let here = _existsSync(pkgJson) ? readPackage(pkgJson) : None
+  switch here {
+  | Some((name, build)) => Some({name, dir, build})
+  | None => {
+      let parent = dirname(dir)
+      parent == dir ? None : findOwning(parent)
+    }
+  }
+}
+
+// Maps test files → deduplicated owning packages (declaration order preserved).
+let scan = (testFiles: array<string>): array<pkg> => {
+  let seen = Dict.make()
+  let out = []
+  testFiles->Array.forEach(file =>
+    switch findOwning(dirname(file)) {
+    | Some(pkg) =>
+      switch seen->Dict.get(pkg.dir) {
+      | Some(_) => ()
+      | None => {
+          seen->Dict.set(pkg.dir, true)
+          out->Array.push(pkg)
+        }
+      }
+    | None => ()
+    }
+  )
+  out
+}

package/src/PackageScan.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+
+function readPackage(pkgJsonPath) {
+  try {
+    let json = JSON.parse(Nodefs.readFileSync(pkgJsonPath, "utf8"));
+    if (typeof json !== "object" || json === null || Array.isArray(json)) {
+      return;
+    }
+    let match = json["name"];
+    let name = typeof match === "string" ? match : "";
+    let match$1 = json["scripts"];
+    if (match$1 === undefined) {
+      return;
+    }
+    if (typeof match$1 !== "object" || match$1 === null || Array.isArray(match$1)) {
+      return;
+    }
+    let match$2 = match$1["start"];
+    if (typeof match$2 === "string") {
+      return [
+        name,
+        match$2
+      ];
+    } else {
+      return;
+    }
+  } catch (exn) {
+    return;
+  }
+}
+
+function findOwning(_dir) {
+  while (true) {
+    let dir = _dir;
+    let pkgJson = Nodepath.join(dir, "package.json");
+    let here = Nodefs.existsSync(pkgJson) ? readPackage(pkgJson) : undefined;
+    if (here !== undefined) {
+      return {
+        name: here[0],
+        dir: dir,
+        build: here[1]
+      };
+    }
+    let parent = Nodepath.dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    _dir = parent;
+    continue;
+  };
+}
+
+function scan(testFiles) {
+  let seen = {};
+  let out = [];
+  testFiles.forEach(file => {
+    let pkg = findOwning(Nodepath.dirname(file));
+    if (pkg === undefined) {
+      return;
+    }
+    let match = seen[pkg.dir];
+    if (match !== undefined) {
+      return;
+    } else {
+      seen[pkg.dir] = true;
+      out.push(pkg);
+      return;
+    }
+  });
+  return out;
+}
+
+export {
+  readPackage,
+  findOwning,
+  scan,
+}
+/* node:fs Not a pure module */