@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/FormatterVsCode.res.mjs

@@ -0,0 +1,546 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Hint$ReventlessGwt from "./Hint.res.mjs";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as ComponentMeta$ReventlessGwt from "./ComponentMeta.res.mjs";
+import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+import * as Protocol$ReventlessVscodeProtocol from "@reventlessdev/reventless-vscode-protocol/src/Protocol.res.mjs";
+
+function write(s) {
+  process.stdout.write(s);
+}
+
+function writeLine(s) {
+  process.stdout.write(s + "\n");
+}
+
+function emit(e) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+  process.stdout.write(s + "\n");
+}
+
+function uriOf(path) {
+  return "file://" + path;
+}
+
+function fileLabelOf(abs) {
+  let base = Nodepath.basename(abs);
+  if (base.endsWith(".res.mjs")) {
+    return base.slice(0, base.length - 8 | 0);
+  } else {
+    return base;
+  }
+}
+
+function relativeToCwd(abs) {
+  return Nodepath.relative(process.cwd(), abs);
+}
+
+let sourceLineCache = {};
+
+function mjsToRes(mjsPath) {
+  if (mjsPath.endsWith(".res.mjs")) {
+    return mjsPath.slice(0, mjsPath.length - 4 | 0);
+  }
+}
+
+function readLinesCached(resPath) {
+  let v = sourceLineCache[resPath];
+  if (v !== undefined) {
+    return Primitive_option.valFromOption(v);
+  }
+  let v$1;
+  try {
+    v$1 = Nodefs.existsSync(resPath) ? Nodefs.readFileSync(resPath, "utf8").split("\n") : undefined;
+  } catch (exn) {
+    v$1 = undefined;
+  }
+  sourceLineCache[resPath] = v$1;
+  return v$1;
+}
+
+function escapeForDouble(s) {
+  return s.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+
+function escapeForSingle(s) {
+  return s.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
+}
+
+function locateInSource(mjsPath, label) {
+  let resPath = mjsToRes(mjsPath);
+  if (resPath === undefined) {
+    return;
+  }
+  let lines = readLinesCached(resPath);
+  if (lines === undefined) {
+    return;
+  }
+  let needleD = "\"" + escapeForDouble(label) + "\"";
+  let needleS = "'" + escapeForSingle(label) + "'";
+  let total = lines.length;
+  let _i = 0;
+  while (true) {
+    let i = _i;
+    if (i >= total) {
+      return;
+    }
+    let line = lines[i];
+    let idxD = line.indexOf(needleD);
+    let idxS = line.indexOf(needleS);
+    let col = idxD !== -1 ? (
+        idxS !== -1 ? (
+            idxD < idxS ? idxD : idxS
+          ) + 1 | 0 : idxD + 1 | 0
+      ) : (
+        idxS !== -1 ? idxS + 1 | 0 : -1
+      );
+    if (col >= 0) {
+      return {
+        file: resPath,
+        line: i + 1 | 0,
+        column: col
+      };
+    }
+    _i = i + 1 | 0;
+    continue;
+  };
+}
+
+function rangeOf(loc) {
+  let pos_line = loc.line - 1 | 0;
+  let pos_character = loc.column - 1 | 0;
+  let pos = {
+    line: pos_line,
+    character: pos_character
+  };
+  return {
+    start: pos,
+    end: pos
+  };
+}
+
+function locationOf(loc) {
+  return {
+    uri: "file://" + loc.file,
+    range: rangeOf(loc)
+  };
+}
+
+function hello() {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "hello",
+    protocol: Protocol$ReventlessVscodeProtocol.protocolVersion
+  });
+  process.stdout.write(s + "\n");
+}
+
+function discoverStart() {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "discoverStart"
+  });
+  process.stdout.write(s + "\n");
+}
+
+function emitDiscoveryItems(files) {
+  files.forEach(param => {
+    let path = param[0];
+    let resPath = mjsToRes(path);
+    let fileUri = resPath !== undefined ? (
+        Nodefs.existsSync(resPath) ? "file://" + resPath : "file://" + path
+      ) : "file://" + path;
+    let component = Stdlib_Option.map(ComponentMeta$ReventlessGwt.componentOfTestFile(path), c => ({
+      kind: c.kind,
+      name: c.name
+    }));
+    let e_3 = fileLabelOf(path);
+    let e_4 = Nodepath.relative(process.cwd(), path);
+    let e_5 = fileUri;
+    let e = {
+      event: "item",
+      id: path,
+      kind: "File",
+      label: e_3,
+      description: e_4,
+      uri: e_5,
+      component: component
+    };
+    let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+    process.stdout.write(s + "\n");
+    let seenDescribes = {};
+    param[1].forEach(t => {
+      let stack = {
+        contents: []
+      };
+      t.describePath.forEach(label => {
+        let parent = stack.contents.length === 0 ? path : path + "::" + stack.contents.join("::");
+        stack.contents = stack.contents.concat([label]);
+        let id = path + "::" + stack.contents.join("::");
+        let match = seenDescribes[id];
+        if (match !== undefined) {
+          return;
+        }
+        seenDescribes[id] = true;
+        let loc = locateInSource(path, label);
+        let e_1 = parent;
+        let e_5 = Stdlib_Option.map(loc, l => "file://" + l.file);
+        let e_6 = Stdlib_Option.map(loc, rangeOf);
+        let e = {
+          event: "item",
+          id: id,
+          parent: e_1,
+          kind: "Suite",
+          label: label,
+          uri: e_5,
+          range: e_6
+        };
+        let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+        process.stdout.write(s + "\n");
+      });
+      let parent = t.describePath.length === 0 ? path : path + "::" + t.describePath.join("::");
+      let testId = path + "::" + t.id;
+      let resLoc = locateInSource(path, t.name);
+      let match = t.location;
+      let loc = resLoc !== undefined ? resLoc : (
+          match !== undefined ? match : undefined
+        );
+      let e_1 = parent;
+      let e_3 = t.name;
+      let e_5 = Stdlib_Option.map(loc, l => "file://" + l.file);
+      let e_6 = Stdlib_Option.map(loc, rangeOf);
+      let e = {
+        event: "item",
+        id: testId,
+        parent: e_1,
+        kind: "Test",
+        label: e_3,
+        uri: e_5,
+        range: e_6
+      };
+      let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+      process.stdout.write(s + "\n");
+    });
+  });
+}
+
+function discoverEnd(total) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "discoverEnd",
+    total: total
+  });
+  process.stdout.write(s + "\n");
+}
+
+function packages(pkgs) {
+  let e = {
+    event: "packages",
+    packages: pkgs.map(p => ({
+      name: p.name,
+      dir: p.dir,
+      build: p.build
+    }))
+  };
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+  process.stdout.write(s + "\n");
+}
+
+function components(comps) {
+  let e = {
+    event: "components",
+    components: comps.map(c => ({
+      kind: c.kind,
+      name: c.name,
+      dir: c.dir,
+      files: c.files
+    }))
+  };
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+  process.stdout.write(s + "\n");
+}
+
+function deadCode(findings) {
+  let e = {
+    event: "deadCode",
+    findings: findings.map(f => ({
+      kind: f.kind,
+      plugin: f.pluginName,
+      component: f.componentName,
+      detail: f.detail
+    }))
+  };
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+  process.stdout.write(s + "\n");
+}
+
+function graph(g) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "graph",
+    nodes: g.nodes,
+    edges: g.edges
+  });
+  process.stdout.write(s + "\n");
+}
+
+function definitions(entries) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "definitions",
+    entries: entries
+  });
+  process.stdout.write(s + "\n");
+}
+
+function buildStart(pkg) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "buildStart",
+    package: pkg
+  });
+  process.stdout.write(s + "\n");
+}
+
+function buildOk(pkg, durationMs) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "buildOk",
+    package: pkg,
+    durationMs: durationMs
+  });
+  process.stdout.write(s + "\n");
+}
+
+function buildFail(pkg, message) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "buildFail",
+    package: pkg,
+    message: message
+  });
+  process.stdout.write(s + "\n");
+}
+
+function buildExternal(pkg) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "buildExternal",
+    package: pkg
+  });
+  process.stdout.write(s + "\n");
+}
+
+function platformStart($$package, dir, domainPort, platformPort) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "platformStart",
+    package: $$package,
+    dir: dir,
+    domainPort: domainPort,
+    platformPort: platformPort
+  });
+  process.stdout.write(s + "\n");
+}
+
+function platformReady(domainEndpoint) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "platformReady",
+    domainEndpoint: domainEndpoint
+  });
+  process.stdout.write(s + "\n");
+}
+
+function domainEvent(payload) {
+  let s = JSON.stringify(payload);
+  process.stdout.write(s + "\n");
+}
+
+function platformLog(line) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "platformLog",
+    line: line
+  });
+  process.stdout.write(s + "\n");
+}
+
+function platformStop(code) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "platformStop",
+    code: code
+  });
+  process.stdout.write(s + "\n");
+}
+
+function runStart(total, filter) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "runStart",
+    total: total,
+    filter: filter
+  });
+  process.stdout.write(s + "\n");
+}
+
+function testStart(id) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "testStart",
+    id: id
+  });
+  process.stdout.write(s + "\n");
+}
+
+function testPass(id, durationMs) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "testPass",
+    id: id,
+    durationMs: durationMs
+  });
+  process.stdout.write(s + "\n");
+}
+
+function testSkip(id, reason) {
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "testSkip",
+    id: id,
+    reason: reason
+  });
+  process.stdout.write(s + "\n");
+}
+
+function messagePayload(t) {
+  let m = t.mismatch;
+  if (m === undefined) {
+    return {
+      message: "failed"
+    };
+  }
+  let hint = Hint$ReventlessGwt.forMismatch(t.slice, m);
+  let match;
+  switch (m.TAG) {
+    case "ErrorMismatch" :
+      let actual = m.actual;
+      let actStr = actual !== undefined ? "Error(" + RenderRescript$ReventlessGwt.render(undefined, actual) + ")" : "Ok(" + RenderRescript$ReventlessGwt.renderMany(m.actualEvents) + ")";
+      match = [
+        "Error(" + RenderRescript$ReventlessGwt.render(undefined, m.expected) + ")",
+        actStr
+      ];
+      break;
+    case "StateMismatch" :
+      match = [
+        RenderRescript$ReventlessGwt.renderOption(m.expected),
+        RenderRescript$ReventlessGwt.renderOption(m.actual)
+      ];
+      break;
+    case "NoEventExpected" :
+      match = [
+        "[]",
+        RenderRescript$ReventlessGwt.renderMany(m.actual)
+      ];
+      break;
+    case "TodoMismatch" :
+      match = [
+        Outcome$ReventlessGwt.format(m),
+        ""
+      ];
+      break;
+    case "AppendConditionMismatch" :
+      match = [
+        RenderRescript$ReventlessGwt.render(undefined, m.expected),
+        RenderRescript$ReventlessGwt.render(undefined, m.actual)
+      ];
+      break;
+    case "TranslateError" :
+      match = [
+        m.expected,
+        Stdlib_Option.getOr(m.actual, "(none)")
+      ];
+      break;
+    case "Throw" :
+      match = [
+        "",
+        m.error
+      ];
+      break;
+    default:
+      match = [
+        RenderRescript$ReventlessGwt.renderMany(m.expected),
+        RenderRescript$ReventlessGwt.renderMany(m.actual)
+      ];
+  }
+  let location = Stdlib_Option.map(t.location, loc => locationOf(Stdlib_Option.getOr(locateInSource(loc.file, t.name), loc)));
+  return {
+    message: hint.message,
+    kind: Outcome$ReventlessGwt.kindName(m),
+    expected: match[0],
+    actual: match[1],
+    location: location
+  };
+}
+
+function testFail(t, id) {
+  let e_1 = t.durationMs;
+  let e_2 = [messagePayload(t)];
+  let e = {
+    event: "testFail",
+    id: id,
+    durationMs: e_1,
+    messages: e_2
+  };
+  let s = Protocol$ReventlessVscodeProtocol.toJsonLine(e);
+  process.stdout.write(s + "\n");
+}
+
+function runEnd(s) {
+  let s$1 = Protocol$ReventlessVscodeProtocol.toJsonLine({
+    event: "runEnd",
+    passed: s.passed,
+    failed: s.failed,
+    skipped: s.skipped,
+    durationMs: s.durationMs
+  });
+  process.stdout.write(s$1 + "\n");
+}
+
+let P;
+
+let protocolVersion = Protocol$ReventlessVscodeProtocol.protocolVersion;
+
+export {
+  P,
+  write,
+  writeLine,
+  emit,
+  uriOf,
+  fileLabelOf,
+  relativeToCwd,
+  sourceLineCache,
+  mjsToRes,
+  readLinesCached,
+  escapeForDouble,
+  escapeForSingle,
+  locateInSource,
+  rangeOf,
+  locationOf,
+  protocolVersion,
+  hello,
+  discoverStart,
+  emitDiscoveryItems,
+  discoverEnd,
+  packages,
+  components,
+  deadCode,
+  graph,
+  definitions,
+  buildStart,
+  buildOk,
+  buildFail,
+  buildExternal,
+  platformStart,
+  platformReady,
+  domainEvent,
+  platformLog,
+  platformStop,
+  runStart,
+  testStart,
+  testPass,
+  testSkip,
+  messagePayload,
+  testFail,
+  runEnd,
+}
+/* node:fs Not a pure module */

package/src/Hint.res

@@ -0,0 +1,119 @@
+// Maps each `Outcome.mismatch` variant to a fix-locus hint.
+//
+// Single source of truth for the `(kind, locus, branch, message)` mapping
+// referenced by the human formatter, the JSON envelope, and the AI loop.
+// See `docs/analysis/given-when-then-specifications.md` §3.2 (locus table)
+// and §3.3 (JSON `hint` field).
+//
+// `locus` is a dotted pointer like "CategoryBehavior.decide" filled in by
+// the DSL at `then*` call time when the slice module name is in scope. If the
+// DSL can't provide it (e.g. Projection has no single "locus" function name
+// the user controls), `locus` falls back to a generic pointer.
+
+type t = {
+  locus: string,
+  branch: option<string>,
+  message: string,
+}
+
+// The constructor name of an encoded variant, if any: a payload-less variant is
+// a bare string; a variant with a payload is an object carrying "TAG".
+let variantTag = (j: JSON.t): option<string> =>
+  switch j {
+  | String(s) => Some(s)
+  | Object(dict) =>
+    switch dict->Dict.get("TAG") {
+    | Some(String(s)) => Some(s)
+    | _ => None
+    }
+  | _ => None
+  }
+
+// Generic fallback mapping, parameterised by the slice module name when the
+// caller can supply one. Branch specificity lives in the DSLs (they can pass
+// a richer hint through `withLocus` below).
+let forMismatch = (~slice="<slice>", m: Outcome.mismatch): t =>
+  switch m {
+  | EventsMismatch(_) => {
+      locus: `${slice}.decide`,
+      branch: None,
+      message: "decide() returned different events than expected. Check the event payload and count.",
+    }
+  | ErrorMismatch({actual: None}) => {
+      locus: `${slice}.decide`,
+      branch: None,
+      message: "decide() returned Ok([...]) but the test expected Error.",
+    }
+  | ErrorMismatch({expected, actual: Some(actual)}) => {
+      // Same constructor, different payload is the common case (e.g. a wrong
+      // field value) — don't mislabel it as a different variant.
+      let message = switch (variantTag(expected), variantTag(actual)) {
+      | (Some(e), Some(a)) if e == a =>
+        `decide() returned Error(${e}) as expected, but with a different payload.`
+      | _ => "decide() returned a different Error variant than expected."
+      }
+      {
+        locus: `${slice}.decide`,
+        branch: None,
+        message,
+      }
+    }
+  | StateMismatch(_) => {
+      locus: `${slice}.evolve`,
+      branch: None,
+      message: "evolve() produced a different state than expected. Check the fold and missing event branches.",
+    }
+  | NoEventExpected(_) => {
+      locus: `${slice}.decide`,
+      branch: None,
+      message: "decide() emitted events but the test expected none — possible idempotency miss.",
+    }
+  | TodoMismatch(_) => {
+      locus: `${slice}.collect / ${slice}.resolve`,
+      branch: None,
+      message: "The automation slice's TODO projection diverged from the expected set.",
+    }
+  | AppendConditionMismatch(_) => {
+      locus: `${slice}.commandSchema`,
+      branch: None,
+      message: "DCB optimistic-concurrency condition drift — likely a missing `@s.matches(DcbTag.string)` annotation on a command field, or the expected condition documented in the test disagrees with what the runtime would build.",
+    }
+  | TranslateError(_) => {
+      locus: `${slice}.translate`,
+      branch: None,
+      message: "The translation slice returned a different result than expected.",
+    }
+  | QueryRowsMismatch(_) => {
+      locus: `${slice}.config`,
+      branch: None,
+      message: "The read-model query returned wrong rows — likely a missing index, sub-id, or resolver.",
+    }
+  | PublishedActionsMismatch(_) => {
+      locus: `${slice}.mapOutgoingEvent / ${slice}.mapIncomingEvent`,
+      branch: None,
+      message: "The ExtensionPoint mapping / Extension delegate published a different set of events or commands than expected. Check the variant match arms and the one-to-many fan-out.",
+    }
+  | Throw({error}) => {
+      locus: `${slice}`,
+      branch: None,
+      message: `The slice threw an exception: ${error}`,
+    }
+  }
+
+// Convert to the JSON shape documented in §3.3.
+let toJson = (h: t): JSON.t => {
+  let obj = Dict.make()
+  obj->Dict.set("locus", JSON.Encode.string(h.locus))
+  obj->Dict.set(
+    "branch",
+    h.branch->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+  )
+  obj->Dict.set("message", JSON.Encode.string(h.message))
+  JSON.Encode.object(obj)
+}
+
+let format = (h: t) =>
+  switch h.branch {
+  | None => `hint: ${h.message}\n      Look at ${h.locus}.`
+  | Some(b) => `hint: ${h.message}\n      Look at ${h.locus}'s branch ${b}.`
+  }