@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/Query_GWT.res.mjs

@@ -0,0 +1,367 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
+
+function FromReadModel(Spec) {
+  return {
+    name: Spec.name,
+    stateSchema: Spec.stateSchema,
+    config: Spec.config,
+    subIdConfig: Spec.subIdConfig
+  };
+}
+
+function FromStateViewSlice(Spec) {
+  return {
+    name: Spec.name,
+    stateSchema: Spec.stateSchema,
+    config: Spec.config,
+    subIdConfig: Spec.subIdConfig
+  };
+}
+
+function Make(Spec) {
+  S.enableJson();
+  let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+  let encState = s => S.reverseConvertToJsonOrThrow(s, Spec.stateSchema);
+  let givenStore = pairs => pairs.map(param => ({
+    id: param[0],
+    subId: undefined,
+    state: param[1]
+  }));
+  let givenCompositeStore = triples => triples.map(param => ({
+    id: param[0],
+    subId: param[1],
+    state: param[2]
+  }));
+  let whenQueryById = (s, id) => Stdlib_Array.findMap(s, r => {
+    if (r.id === id) {
+      return Primitive_option.some(r.state);
+    }
+  });
+  let whenQueryByCompositeId = (s, param) => {
+    let subId = param.subId;
+    let id = param.id;
+    if (Spec.subIdConfig !== undefined) {
+      return {
+        TAG: "Ok",
+        _0: Stdlib_Array.findMap(s, r => {
+          if (r.id === id && Primitive_object.equal(r.subId, subId)) {
+            return Primitive_option.some(r.state);
+          }
+        })
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "QueryRowsMismatch",
+          expected: [`composite-id lookup requires subIdConfig = Some({subIdField, getSubId}) in ` + Spec.name + `.config`],
+          actual: []
+        }
+      };
+    }
+  };
+  let indexCovers = (indexName, field) => Spec.config.indexes.some(idx => {
+    if (idx.index !== indexName) {
+      return false;
+    }
+    if (Primitive_object.equal(idx.idField, field)) {
+      return true;
+    }
+    let fields = idx.pkFields;
+    if (fields !== undefined) {
+      return fields.includes(field);
+    } else {
+      return false;
+    }
+  });
+  let whenQuery = (s, args) => {
+    let name = args.index;
+    let indexError = name !== undefined && !indexCovers(name, args.by) ? ({
+        TAG: "QueryRowsMismatch",
+        expected: [`index "` + name + `" covering field "` + args.by + `" is missing from ` + Spec.name + `.config.indexes`],
+        actual: []
+      }) : undefined;
+    if (indexError !== undefined) {
+      return {
+        TAG: "Error",
+        _0: indexError
+      };
+    }
+    let field = args.by;
+    let expected = args.value;
+    let matches = s.filter(r => {
+      let json = S.reverseConvertToJsonOrThrow(r.state, Spec.stateSchema);
+      let v = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[field]);
+      if (v === undefined) {
+        return false;
+      }
+      let actualStr;
+      switch (typeof v) {
+        case "boolean" :
+          actualStr = v ? "true" : "false";
+          break;
+        case "string" :
+          actualStr = v;
+          break;
+        case "number" :
+          actualStr = v.toString();
+          break;
+        default:
+          actualStr = JSON.stringify(v);
+      }
+      return actualStr === expected;
+    });
+    let p = args.filter;
+    let afterFilter = p !== undefined ? matches.filter(r => p(r.state)) : matches;
+    let n = args.limit;
+    let afterLimit = n !== undefined ? afterFilter.slice(0, n) : afterFilter;
+    return {
+      TAG: "Ok",
+      _0: afterLimit.map(r => r.state)
+    };
+  };
+  let thenRow = (actual, expected) => {
+    if (Primitive_object.equal(actual, expected)) {
+      return Outcome$ReventlessGwt.pass;
+    }
+    let actualJson = Stdlib_Option.mapOr(actual, [], s => [S.reverseConvertToJsonOrThrow(s, Spec.stateSchema)]);
+    let expectedJson = Stdlib_Option.mapOr(expected, [], s => [S.reverseConvertToJsonOrThrow(s, Spec.stateSchema)]);
+    return Outcome$ReventlessGwt.fail({
+      TAG: "QueryRowsMismatch",
+      expected: expectedJson,
+      actual: actualJson
+    });
+  };
+  let thenRows = (result, expected) => {
+    if (result.TAG !== "Ok") {
+      return Outcome$ReventlessGwt.fail(result._0);
+    }
+    let actual = result._0;
+    if (Primitive_object.equal(actual, expected)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "QueryRowsMismatch",
+        expected: expected.map(encState),
+        actual: actual.map(encState)
+      });
+    }
+  };
+  let thenRowCount = (result, expected) => {
+    if (result.TAG !== "Ok") {
+      return Outcome$ReventlessGwt.fail(result._0);
+    }
+    let actual = result._0;
+    if (actual.length === expected) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "QueryRowsMismatch",
+        expected: [`row count = ` + expected.toString()],
+        actual: [`row count = ` + actual.length.toString()]
+      });
+    }
+  };
+  let thenRowFromComposite = (result, expected) => {
+    if (result.TAG === "Ok") {
+      return thenRow(result._0, expected);
+    } else {
+      return Outcome$ReventlessGwt.fail(result._0);
+    }
+  };
+  return {
+    Spec: Spec,
+    describe: JestBind$ReventlessGwt.describe,
+    test: test,
+    givenStore: givenStore,
+    givenCompositeStore: givenCompositeStore,
+    whenQueryById: whenQueryById,
+    whenQueryByCompositeId: whenQueryByCompositeId,
+    whenQuery: whenQuery,
+    thenRow: thenRow,
+    thenRows: thenRows,
+    thenRowCount: thenRowCount,
+    thenRowFromComposite: thenRowFromComposite
+  };
+}
+
+function MakeResolver(Primary) {
+  return Target => {
+    S.enableJson();
+    let sliceName = Primary.name + `→` + Target.name;
+    let test = (name, body) => JestBind$ReventlessGwt.test(sliceName, name, body);
+    let givenStores = (primary, target) => ({
+      primary: primary,
+      target: target
+    });
+    let encTarget = s => S.reverseConvertToJsonOrThrow(s, Target.stateSchema);
+    let encTargets = arr => arr.map(encTarget);
+    let resolverFor = field => Primary.config.idResolvers.find(r => r.source.idField === field);
+    let resolverManyFor = field => Primary.config.idsResolvers.find(r => r.source.idsField === field);
+    let missing = msg => ({
+      TAG: "QueryRowsMismatch",
+      expected: [msg],
+      actual: []
+    });
+    let readField = (state, field) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(S.reverseConvertToJsonOrThrow(state, Primary.stateSchema)), d => d[field]);
+    let jsonToStr = v => {
+      switch (typeof v) {
+        case "string" :
+          return v;
+        case "number" :
+          return v.toString();
+        default:
+          return JSON.stringify(v);
+      }
+    };
+    let lookupTarget = (target, fkId) => Stdlib_Array.findMap(target, param => {
+      if (Primitive_object.equal(param[0], fkId)) {
+        return Primitive_option.some(param[1]);
+      }
+    });
+    let whenResolve = (scenario, field, primaryId) => {
+      let match = resolverFor(field);
+      if (match === undefined) {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "QueryRowsMismatch",
+            expected: [`@resolves on field "` + field + `" is missing from ` + Primary.name + `.config.idResolvers`],
+            actual: []
+          }
+        };
+      }
+      let pstate = Stdlib_Array.findMap(scenario.primary, param => {
+        if (param[0] === primaryId) {
+          return Primitive_option.some(param[1]);
+        }
+      });
+      if (pstate === undefined) {
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      }
+      let fk = readField(Primitive_option.valFromOption(pstate), field);
+      if (fk !== undefined) {
+        return {
+          TAG: "Ok",
+          _0: lookupTarget(scenario.target, jsonToStr(fk))
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      }
+    };
+    let whenResolveMany = (scenario, field, primaryId) => {
+      let match = resolverManyFor(field);
+      if (match === undefined) {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "QueryRowsMismatch",
+            expected: [`@resolvesMany on field "` + field + `" is missing from ` + Primary.name + `.config.idsResolvers`],
+            actual: []
+          }
+        };
+      }
+      let pstate = Stdlib_Array.findMap(scenario.primary, param => {
+        if (param[0] === primaryId) {
+          return Primitive_option.some(param[1]);
+        }
+      });
+      if (pstate === undefined) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      let match$1 = readField(Primitive_option.valFromOption(pstate), field);
+      if (match$1 !== undefined) {
+        if (Array.isArray(match$1)) {
+          return {
+            TAG: "Ok",
+            _0: Stdlib_Array.filterMap(match$1.map(jsonToStr), fkId => lookupTarget(scenario.target, fkId))
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        }
+      } else {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+    };
+    let thenResolved = (result, expected) => {
+      if (result.TAG !== "Ok") {
+        return Outcome$ReventlessGwt.fail(result._0);
+      }
+      let actual = result._0;
+      if (Primitive_object.equal(actual, expected)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "QueryRowsMismatch",
+          expected: Stdlib_Option.mapOr(expected, [], s => [S.reverseConvertToJsonOrThrow(s, Target.stateSchema)]),
+          actual: Stdlib_Option.mapOr(actual, [], s => [S.reverseConvertToJsonOrThrow(s, Target.stateSchema)])
+        });
+      }
+    };
+    let thenResolvedMany = (result, expected) => {
+      if (result.TAG !== "Ok") {
+        return Outcome$ReventlessGwt.fail(result._0);
+      }
+      let actual = result._0;
+      if (Primitive_object.equal(actual, expected)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "QueryRowsMismatch",
+          expected: expected.map(encTarget),
+          actual: actual.map(encTarget)
+        });
+      }
+    };
+    return {
+      describe: JestBind$ReventlessGwt.describe,
+      sliceName: sliceName,
+      test: test,
+      givenStores: givenStores,
+      encTarget: encTarget,
+      encTargets: encTargets,
+      resolverFor: resolverFor,
+      resolverManyFor: resolverManyFor,
+      missing: missing,
+      readField: readField,
+      jsonToStr: jsonToStr,
+      lookupTarget: lookupTarget,
+      whenResolve: whenResolve,
+      whenResolveMany: whenResolveMany,
+      thenResolved: thenResolved,
+      thenResolvedMany: thenResolvedMany
+    };
+  };
+}
+
+export {
+  FromReadModel,
+  FromStateViewSlice,
+  Make,
+  MakeResolver,
+}
+/* S Not a pure module */

package/src/RenderRescript.res

@@ -0,0 +1,125 @@
+// Renders a JSON value (produced by sury `Message.encode`) into ReScript
+// source syntax — e.g. the JSON `{"TAG":"CategoryAdded","_0":{"name":"X"}}`
+// becomes the string `CategoryAdded({name: "X"})`.
+//
+// A fully schema-driven renderer would walk `S.t<'a>` and recover every
+// constructor name / record field type. Here we lean on sury's default JS
+// representation instead:
+//
+//   - Payload-less variants encode to a bare string ("VariantName").
+//   - Single-argument variants encode to `{TAG: "Name", _0: x}`.
+//   - Multi-argument variants encode to `{TAG: "Name", _0: x, _1: y, ...}`.
+//   - Inline-record variants (`Name({a, b})`) are FLATTENED by ReScript: the
+//     record fields sit beside TAG as `{TAG: "Name", a: ..., b: ...}`, NOT under
+//     `_0`. These render back as `Name({a: ..., b: ...})`.
+//   - Plain records encode to `{field: value, ...}`.
+//   - Arrays/tuples encode to JSON arrays.
+//
+// That's enough to produce readable failure diagnostics for every GWT DSL
+// shipped so far. A later pass can replace this with a sury-schema walker
+// for the last 10% of cases (abstract or sealed types, custom schemas).
+
+let escapeString = (s: string) => {
+  let escaped =
+    s
+    ->String.replaceAll("\\", "\\\\")
+    ->String.replaceAll("\"", "\\\"")
+    ->String.replaceAll("\n", "\\n")
+    ->String.replaceAll("\r", "\\r")
+    ->String.replaceAll("\t", "\\t")
+  "\"" ++ escaped ++ "\""
+}
+
+let indent = (level: int) => String.repeat("  ", level)
+
+let rec render = (~level=0, j: JSON.t): string =>
+  switch j {
+  | Null => "None"
+  | Boolean(true) => "true"
+  | Boolean(false) => "false"
+  | String(s) => escapeString(s)
+  | Number(n) => Float.toString(n)
+  | Array(arr) => renderArray(~level, arr)
+  | Object(dict) => renderObject(~level, dict)
+  }
+
+and renderArray = (~level, arr: array<JSON.t>) =>
+  switch arr {
+  | [] => "[]"
+  | _ =>
+    let inner = arr->Array.map(render(~level=level + 1, _))->Array.join(", ")
+    "[" ++ inner ++ "]"
+  }
+
+and renderRecord = (~level, keys: array<string>, dict: Dict.t<JSON.t>) => {
+  let fields =
+    keys
+    ->Array.map(k => {
+      let v = dict->Dict.getUnsafe(k)
+      k ++ ": " ++ render(~level=level + 1, v)
+    })
+    ->Array.join(", ")
+  "{" ++ fields ++ "}"
+}
+
+and renderObject = (~level, dict: Dict.t<JSON.t>) => {
+  let keys = dict->Dict.keysToArray
+  switch dict->Dict.get("TAG") {
+  | Some(tagJson) =>
+    let tagName = switch tagJson {
+    | String(s) => s
+    | _ => "?"
+    }
+    // Positional args are `_0`, `_1`, …; an inline-record variant instead
+    // flattens its record fields beside TAG (no `_`-prefixed keys).
+    let positional = keys->Array.filter(k => k != "TAG" && String.startsWith(k, "_"))
+    let inlineFields = keys->Array.filter(k => k != "TAG" && !String.startsWith(k, "_"))
+    switch positional {
+    | [] =>
+      switch inlineFields {
+      | [] => tagName
+      | _ => tagName ++ "(" ++ renderRecord(~level, inlineFields, dict) ++ ")"
+      }
+    | ["_0"] =>
+      switch dict->Dict.get("_0") {
+      | Some(p) => tagName ++ "(" ++ render(~level=level + 1, p) ++ ")"
+      | None => tagName
+      }
+    | _ =>
+      let ordered = positional->Array.toSorted((a, b) => {
+        let parseTail = k =>
+          String.slice(k, ~start=1, ~end=String.length(k))
+          ->Int.fromString
+          ->Option.getOr(0)
+        Int.compare(parseTail(a), parseTail(b))
+      })
+      let parts =
+        ordered
+        ->Array.map(k => render(~level=level + 1, dict->Dict.getUnsafe(k)))
+        ->Array.join(", ")
+      tagName ++ "(" ++ parts ++ ")"
+    }
+  | None =>
+    switch keys {
+    | [] => "{}"
+    | _ => renderRecord(~level, keys, dict)
+    }
+  }
+}
+
+let renderMany = (arr: array<JSON.t>): string =>
+  switch arr {
+  | [] => "[]"
+  | [one] => "[" ++ render(one) ++ "]"
+  | _ =>
+    let inner =
+      arr->Array.map(v => indent(1) ++ render(~level=1, v))->Array.join(",\n")
+    "[\n" ++ inner ++ ",\n]"
+  }
+
+// Render an optional JSON as either a ReScript value or the sentinel "None".
+let renderOption = (o: option<JSON.t>): string =>
+  switch o {
+  | Some(j) => render(j)
+  | None => "None"
+  }

package/src/RenderRescript.res.mjs

@@ -0,0 +1,141 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function escapeString(s) {
+  let escaped = s.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("\t", "\\t");
+  return "\"" + escaped + "\"";
+}
+
+function indent(level) {
+  return "  ".repeat(level);
+}
+
+function render(levelOpt, j) {
+  let level = levelOpt !== undefined ? levelOpt : 0;
+  if (j === null) {
+    return "None";
+  }
+  if (Array.isArray(j)) {
+    return renderArray(level, j);
+  }
+  switch (typeof j) {
+    case "boolean" :
+      if (j) {
+        return "true";
+      } else {
+        return "false";
+      }
+    case "string" :
+      return escapeString(j);
+    case "number" :
+      return j.toString();
+    case "object" :
+      return renderObject(level, j);
+  }
+}
+
+function renderArray(level, arr) {
+  if (arr.length === 0) {
+    return "[]";
+  }
+  let inner = arr.map(__x => render(level + 1 | 0, __x)).join(", ");
+  return "[" + inner + "]";
+}
+
+function renderRecord(level, keys, dict) {
+  let fields = keys.map(k => {
+    let v = dict[k];
+    return k + ": " + render(level + 1 | 0, v);
+  }).join(", ");
+  return "{" + fields + "}";
+}
+
+function renderObject(level, dict) {
+  let keys = Object.keys(dict);
+  let tagJson = dict["TAG"];
+  if (tagJson === undefined) {
+    if (keys.length !== 0) {
+      return renderRecord(level, keys, dict);
+    } else {
+      return "{}";
+    }
+  }
+  let tagName;
+  tagName = typeof tagJson === "string" ? tagJson : "?";
+  let positional = keys.filter(k => {
+    if (k !== "TAG") {
+      return k.startsWith("_");
+    } else {
+      return false;
+    }
+  });
+  let inlineFields = keys.filter(k => {
+    if (k !== "TAG") {
+      return !k.startsWith("_");
+    } else {
+      return false;
+    }
+  });
+  let len = positional.length;
+  if (len !== 1) {
+    if (len === 0) {
+      if (inlineFields.length !== 0) {
+        return tagName + "(" + renderRecord(level, inlineFields, dict) + ")";
+      } else {
+        return tagName;
+      }
+    }
+  } else {
+    let match = positional[0];
+    if (match === "_0") {
+      let p = dict["_0"];
+      if (p !== undefined) {
+        return tagName + "(" + render(level + 1 | 0, p) + ")";
+      } else {
+        return tagName;
+      }
+    }
+  }
+  let ordered = positional.toSorted((a, b) => {
+    let parseTail = k => Stdlib_Option.getOr(Stdlib_Int.fromString(k.slice(1, k.length), undefined), 0);
+    return Primitive_int.compare(parseTail(a), parseTail(b));
+  });
+  let parts = ordered.map(k => render(level + 1 | 0, dict[k])).join(", ");
+  return tagName + "(" + parts + ")";
+}
+
+function renderMany(arr) {
+  let len = arr.length;
+  if (len !== 1) {
+    if (len === 0) {
+      return "[]";
+    }
+    let inner = arr.map(v => "  ".repeat(1) + render(1, v)).join(",\n");
+    return "[\n" + inner + ",\n]";
+  }
+  let one = arr[0];
+  return "[" + render(undefined, one) + "]";
+}
+
+function renderOption(o) {
+  if (o !== undefined) {
+    return render(undefined, o);
+  } else {
+    return "None";
+  }
+}
+
+export {
+  escapeString,
+  indent,
+  render,
+  renderArray,
+  renderRecord,
+  renderObject,
+  renderMany,
+  renderOption,
+}
+/* No side effect */

package/src/RunnerTypes.res

@@ -0,0 +1,68 @@
+// Shared data types between the runner loop and formatters.
+
+type testStatus = Pass | Fail | Skip
+
+type testResult = {
+  id: string,
+  name: string,
+  describePath: array<string>,
+  status: testStatus,
+  durationMs: float,
+  location: option<Collector.location>,
+  slice: option<string>,
+  mismatch: option<Outcome.mismatch>,
+  skipReason: option<string>,
+}
+
+type fileResult = {
+  path: string,
+  tests: array<testResult>,
+}
+
+type summary = {
+  total: int,
+  passed: int,
+  failed: int,
+  skipped: int,
+  files: int,
+  durationMs: float,
+  startedAt: string,
+}
+
+type runResult = {
+  summary: summary,
+  files: array<fileResult>,
+}
+
+let statusString = (s: testStatus) =>
+  switch s {
+  | Pass => "pass"
+  | Fail => "fail"
+  | Skip => "skip"
+  }
+
+let summaryOf = (files: array<fileResult>, durationMs: float, startedAt: string): summary => {
+  let total = ref(0)
+  let passed = ref(0)
+  let failed = ref(0)
+  let skipped = ref(0)
+  files->Array.forEach(f =>
+    f.tests->Array.forEach(t => {
+      total := total.contents + 1
+      switch t.status {
+      | Pass => passed := passed.contents + 1
+      | Fail => failed := failed.contents + 1
+      | Skip => skipped := skipped.contents + 1
+      }
+    })
+  )
+  {
+    total: total.contents,
+    passed: passed.contents,
+    failed: failed.contents,
+    skipped: skipped.contents,
+    files: files->Array.length,
+    durationMs,
+    startedAt,
+  }
+}