@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/tests/QueryGwtTest.res.mjs

@@ -0,0 +1,314 @@
+// 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 Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as Query_GWT$ReventlessGwt from "../src/Query_GWT.res.mjs";
+
+S.enableJson();
+
+let name = "Categories";
+
+let moduleUrl = "";
+
+let stateSchema = S.schema(s => ({
+  categoryId: s.m(S.string),
+  name: s.m(S.string),
+  archived: s.m(S.bool)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, [{
+    index: "byName",
+    type_: "S",
+    idField: "name",
+    projectionType: "ALL"
+  }]);
+
+let CategoriesReadModel = {
+  Id: undefined,
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let CategoriesQuery = Query_GWT$ReventlessGwt.Make(Query_GWT$ReventlessGwt.FromReadModel({
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+}));
+
+CategoriesQuery.describe("Categories ReadModel queries", () => {
+  CategoriesQuery.test("primary-id lookup returns the row", () => CategoriesQuery.thenRow(CategoriesQuery.whenQueryById(CategoriesQuery.givenStore([
+    [
+      "c1",
+      {
+        categoryId: "c1",
+        name: "Electronics",
+        archived: false
+      }
+    ],
+    [
+      "c2",
+      {
+        categoryId: "c2",
+        name: "Books",
+        archived: true
+      }
+    ]
+  ]), "c1"), {
+    categoryId: "c1",
+    name: "Electronics",
+    archived: false
+  }));
+  CategoriesQuery.test("by-name (GSI) returns matching rows", () => CategoriesQuery.thenRows(CategoriesQuery.whenQuery(CategoriesQuery.givenStore([
+    [
+      "c1",
+      {
+        categoryId: "c1",
+        name: "Electronics",
+        archived: false
+      }
+    ],
+    [
+      "c2",
+      {
+        categoryId: "c2",
+        name: "Books",
+        archived: true
+      }
+    ]
+  ]), {
+    by: "name",
+    value: "Electronics",
+    index: "byName"
+  }), [{
+      categoryId: "c1",
+      name: "Electronics",
+      archived: false
+    }]));
+  CategoriesQuery.test("missing index produces QueryRowsMismatch", () => {
+    let outcome = CategoriesQuery.thenRows(CategoriesQuery.whenQuery(CategoriesQuery.givenStore([[
+        "c1",
+        {
+          categoryId: "c1",
+          name: "Electronics",
+          archived: false
+        }
+      ]]), {
+      by: "name",
+      value: "Electronics",
+      index: "byArchived"
+    }), []);
+    if (outcome.TAG === "Ok") {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "Throw",
+        error: "expected failure, got pass",
+        stack: ""
+      });
+    }
+    let other = outcome._0;
+    if (other.TAG === "QueryRowsMismatch") {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "Throw",
+        error: "expected QueryRowsMismatch, got: " + Outcome$ReventlessGwt.kindName(other),
+        stack: ""
+      });
+    }
+  });
+  CategoriesQuery.test("filter narrows results after the index scan", () => CategoriesQuery.thenRows(CategoriesQuery.whenQuery(CategoriesQuery.givenStore([
+    [
+      "c1",
+      {
+        categoryId: "c1",
+        name: "Books",
+        archived: false
+      }
+    ],
+    [
+      "c2",
+      {
+        categoryId: "c2",
+        name: "Books",
+        archived: true
+      }
+    ]
+  ]), {
+    by: "name",
+    value: "Books",
+    index: "byName",
+    filter: r => !r.archived
+  }), [{
+      categoryId: "c1",
+      name: "Books",
+      archived: false
+    }]));
+  CategoriesQuery.test("limit truncates results and thenRowCount verifies", () => CategoriesQuery.thenRowCount(CategoriesQuery.whenQuery(CategoriesQuery.givenStore(Stdlib_Array.fromInitializer(10, i => {
+    let id = "c" + i.toString();
+    let state = {
+      categoryId: id,
+      name: "Books",
+      archived: false
+    };
+    return [
+      id,
+      state
+    ];
+  })), {
+    by: "name",
+    value: "Books",
+    index: "byName",
+    limit: 3
+  }), 3));
+  CategoriesQuery.test("composite-id lookup without subIdConfig fails", () => {
+    let outcome = CategoriesQuery.thenRowFromComposite(CategoriesQuery.whenQueryByCompositeId(CategoriesQuery.givenStore([]), {
+      id: "c1",
+      subId: "v1"
+    }), undefined);
+    if (outcome.TAG === "Ok") {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "Throw",
+        error: "expected failure, got pass",
+        stack: ""
+      });
+    }
+    let other = outcome._0;
+    if (other.TAG === "QueryRowsMismatch") {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "Throw",
+        error: "expected QueryRowsMismatch, got: " + Outcome$ReventlessGwt.kindName(other),
+        stack: ""
+      });
+    }
+  });
+});
+
+let name$1 = "OrdersView";
+
+let moduleUrl$1 = "";
+
+let stateSchema$1 = S.schema(s => ({
+  orderId: s.m(S.string),
+  customerId: s.m(S.string),
+  total: s.m(S.int)
+}));
+
+let consumedEventSchema = S.schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(S.string),
+  customerId: s.m(S.string),
+  total: s.m(S.int)
+}));
+
+function project(event) {
+  let orderId = event.orderId;
+  return [{
+      TAG: "Set",
+      _0: orderId,
+      _1: {
+        orderId: orderId,
+        customerId: event.customerId,
+        total: event.total
+      }
+    }];
+}
+
+let config$1 = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let subIdConfig = {
+  subIdField: "customerId",
+  getSubId: s => s.customerId
+};
+
+let OrdersView = {
+  name: name$1,
+  moduleUrl: moduleUrl$1,
+  stateSchema: stateSchema$1,
+  consumedEventSchema: consumedEventSchema,
+  project: project,
+  config: config$1,
+  subIdConfig: subIdConfig,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let OrdersQuery = Query_GWT$ReventlessGwt.Make(Query_GWT$ReventlessGwt.FromStateViewSlice({
+  name: name$1,
+  moduleUrl: moduleUrl$1,
+  stateSchema: stateSchema$1,
+  consumedEventSchema: consumedEventSchema,
+  config: config$1,
+  subIdConfig: subIdConfig,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+}));
+
+OrdersQuery.describe("OrdersView StateViewSlice queries", () => {
+  OrdersQuery.test("composite-id lookup returns the row", () => OrdersQuery.thenRowFromComposite(OrdersQuery.whenQueryByCompositeId(OrdersQuery.givenCompositeStore([
+    [
+      "ord-1",
+      "cust-a",
+      {
+        orderId: "ord-1",
+        customerId: "cust-a",
+        total: 100
+      }
+    ],
+    [
+      "ord-2",
+      "cust-b",
+      {
+        orderId: "ord-2",
+        customerId: "cust-b",
+        total: 200
+      }
+    ]
+  ]), {
+    id: "ord-1",
+    subId: "cust-a"
+  }), {
+    orderId: "ord-1",
+    customerId: "cust-a",
+    total: 100
+  }));
+  OrdersQuery.test("composite-id lookup with wrong subId returns None", () => OrdersQuery.thenRowFromComposite(OrdersQuery.whenQueryByCompositeId(OrdersQuery.givenCompositeStore([[
+      "ord-1",
+      "cust-a",
+      {
+        orderId: "ord-1",
+        customerId: "cust-a",
+        total: 100
+      }
+    ]]), {
+    id: "ord-1",
+    subId: "cust-z"
+  }), undefined));
+});
+
+export {
+  CategoriesReadModel,
+  CategoriesQuery,
+  OrdersView,
+  OrdersQuery,
+}
+/*  Not a pure module */

package/tests/QueryResolverGwtTest.res

@@ -0,0 +1,71 @@
+// Worked example for Query_GWT.MakeResolver — cross-spec (`@resolves` /
+// `@resolvesMany`) GraphQL resolvers. An Orders read model carries a foreign
+// productId (and a productIds array) that resolve into a Products read model;
+// the resolver DSL follows those keys across the spec boundary.
+
+S.enableJson()
+
+module RM = Reventless.ReadModel
+
+module ProductRow = {
+  let name = "ProductRow"
+
+  @schema
+  type state = {productId: string, name: string, price: float}
+
+  let config = RM.config()
+  let subIdConfig = None
+}
+
+module OrderRow = {
+  let name = "OrderRow"
+
+  @schema
+  type state = {orderId: string, productId: string, productIds: array<string>}
+
+  let config = RM.config(
+    ~idResolvers=[
+      {
+        source: {RM.idField: "productId", subId: NoSubId, resolvedField: Single("product")},
+        target: {RM.tableName: "ProductRow", idField: Id},
+      },
+    ],
+    ~idsResolvers=[
+      {
+        source: {RM.idsField: "productIds", resolvedField: "products"},
+        target: {RM.tableName: "ProductRow"},
+      },
+    ],
+  )
+  let subIdConfig = None
+}
+
+module R = Query_GWT.MakeResolver(OrderRow, ProductRow)
+
+let book: ProductRow.state = {productId: "p1", name: "Book", price: 9.99}
+let pen: ProductRow.state = {productId: "p2", name: "Pen", price: 1.5}
+let order: OrderRow.state = {orderId: "order1", productId: "p1", productIds: ["p1", "p2"]}
+
+let stores = () => R.givenStores([("order1", order)], [("p1", book), ("p2", pen)])
+
+R.describe("Cross-spec resolvers (MakeResolver)", () => {
+  R.test("@resolves follows productId into the Products table", () =>
+    stores()
+    ->R.whenResolve(~field="productId", "order1")
+    ->R.thenResolved(Some(book))
+  )
+
+  R.test("@resolvesMany follows productIds into multiple Products rows", () =>
+    stores()
+    ->R.whenResolveMany(~field="productIds", "order1")
+    ->R.thenResolvedMany([book, pen])
+  )
+
+  R.test("resolving an unknown foreign key returns no row", () =>
+    R.givenStores([("order2", {OrderRow.orderId: "order2", productId: "px", productIds: []})], [
+      ("p1", book),
+    ])
+    ->R.whenResolve(~field="productId", "order2")
+    ->R.thenResolved(None)
+  )
+})

package/tests/QueryResolverGwtTest.res.mjs

@@ -0,0 +1,136 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Query_GWT$ReventlessGwt from "../src/Query_GWT.res.mjs";
+
+S.enableJson();
+
+let stateSchema = S.schema(s => ({
+  productId: s.m(S.string),
+  name: s.m(S.string),
+  price: s.m(S.float)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let ProductRow = {
+  name: "ProductRow",
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let stateSchema$1 = S.schema(s => ({
+  orderId: s.m(S.string),
+  productId: s.m(S.string),
+  productIds: s.m(S.array(S.string))
+}));
+
+let config$1 = ReadModel$Reventless.config([{
+    source: {
+      idField: "productId",
+      subId: "NoSubId",
+      resolvedField: {
+        TAG: "Single",
+        _0: "product"
+      }
+    },
+    target: {
+      tableName: "ProductRow",
+      idField: "Id"
+    }
+  }], [{
+    source: {
+      idsField: "productIds",
+      resolvedField: "products"
+    },
+    target: {
+      tableName: "ProductRow"
+    }
+  }], undefined);
+
+let OrderRow = {
+  name: "OrderRow",
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let R = Query_GWT$ReventlessGwt.MakeResolver(OrderRow)(ProductRow);
+
+let book = {
+  productId: "p1",
+  name: "Book",
+  price: 9.99
+};
+
+let pen = {
+  productId: "p2",
+  name: "Pen",
+  price: 1.5
+};
+
+let order_productIds = [
+  "p1",
+  "p2"
+];
+
+let order = {
+  orderId: "order1",
+  productId: "p1",
+  productIds: order_productIds
+};
+
+function stores() {
+  return R.givenStores([[
+      "order1",
+      order
+    ]], [
+    [
+      "p1",
+      book
+    ],
+    [
+      "p2",
+      pen
+    ]
+  ]);
+}
+
+R.describe("Cross-spec resolvers (MakeResolver)", () => {
+  R.test("@resolves follows productId into the Products table", () => R.thenResolved(R.whenResolve(stores(), "productId", "order1"), book));
+  R.test("@resolvesMany follows productIds into multiple Products rows", () => R.thenResolvedMany(R.whenResolveMany(stores(), "productIds", "order1"), [
+    book,
+    pen
+  ]));
+  R.test("resolving an unknown foreign key returns no row", () => R.thenResolved(R.whenResolve(R.givenStores([[
+      "order2",
+      {
+        orderId: "order2",
+        productId: "px",
+        productIds: []
+      }
+    ]], [[
+      "p1",
+      book
+    ]]), "productId", "order2"), undefined));
+});
+
+let RM;
+
+export {
+  RM,
+  ProductRow,
+  OrderRow,
+  R,
+  book,
+  pen,
+  order,
+  stores,
+}
+/*  Not a pure module */