@reventlessdev/reventless-local 3.0.0-alpha.233 → 3.0.0-alpha.235

package/tests/adapter/QueryDbListResolverTest.res

@@ -574,3 +574,153 @@ describe("QueryDb by-index resolver", () => {
     }
   })
 })
+
+// ─────────────────────────────────────────────────────────────
+// Sub-id view — the `{name}Items` door
+// ─────────────────────────────────────────────────────────────
+
+// The door only exists when a view declares a sub-id, and no fixture declared one
+// alongside a union field, so it was the last door in the mechanism plan's table
+// carrying a union nowhere.
+
+@schema
+type lineState = {
+  orderId: @s.matches(Reventless.DcbTag.string) string,
+  lineNo: string,
+  label: string,
+  geolocation?: geolocation,
+}
+
+let lineStateSchemaWithAnnotations =
+  lineStateSchema->S.Metadata.set(
+    ~id=Reventless.StateAnnotations.stateAnnotationsId,
+    {
+      ids: ["orderId"],
+      compositeIds: [],
+      subIds: ["lineNo"],
+      compositeSubIds: [],
+      indexes: [],
+      hidden: [],
+      summary: [],
+      drillTargets: [],
+      drillTargetKeys: [],
+      collapsed: [],
+      scan: [],
+      scanSort: [],
+      semantic: [],
+      metric: [],
+      lifecycle: None,
+      groupBy: None,
+      visibility: None,
+      live: None,
+      retired: None,
+    },
+  )
+
+let buildSubIdFixture = async (~name: string) => {
+  module Bus = LocalBus.Make()
+  module Storage = LocalQueryDbStorage.Make(Bus)
+  module Resolvers = QueryDbResolvers_GraphQL.Make(Bus)
+
+  module Spec = {
+    module Id = Reventless.Id.StringPure
+    let name = name
+    let moduleUrl: string = %raw(`import.meta.url`)
+    @schema
+    type state = lineState
+    let config = Reventless.ReadModel.config()
+    let subIdConfig = Some({
+      Reventless.ReadModel.subIdField: "lineNo",
+      getSubId: (state: lineState) => state.lineNo,
+    })
+    let authorization: Reventless.Authorization.permission = AllowAuthenticated
+    let visibility: Reventless.Visibility.t = Public
+  }
+
+  module QDbResolversAdapter = ReventlessCore.QueryDb_Adapter.NoResolvers(Storage)
+  module Maker = ReventlessCore.QueryDb_Builder.Make(Spec, Storage, QDbResolversAdapter)
+
+  ReventlessCore.Plugin_Helpers.queryFieldNamesRegistry->Dict.set(
+    name,
+    {
+      singleFieldName: name,
+      listFieldName: name ++ "s",
+      returnTypeName: name,
+      pluralTypeName: "[" ++ name ++ "]",
+      includeIdParam: true,
+      connectionSpec: true,
+    },
+  )
+  ReventlessCore.Plugin_Helpers.stateSchemaRegistry->Dict.set(
+    name,
+    lineStateSchemaWithAnnotations->S.castToUnknown,
+  )
+
+  let queryDb = Maker.make(~api=(), ~apiRole=())
+  let ops = await queryDb->ReventlessCore.Component.operations->TestRunner.resolve
+
+  let _: ReventlessCore.QueryDb_Adapter.resolvers = Resolvers.make(
+    ~name,
+    ~api=(),
+    ~apiRole=(),
+    ~dataSourceName=""->Pulumi.Output.make,
+    ~indexes=[],
+    ~subIdField=Some("lineNo"),
+    ~idResolverConfigs=[],
+    ~idsResolverConfigs=[],
+    ~authorization=Reventless.Authorization.AllowAuthenticated,
+    ~opts=({}: Pulumi.CustomResourceOptions.t),
+  )
+
+  // Two lines under one order: the first carries the union, the second leaves the
+  // optional field absent.
+  let _ = await ops.save(
+    "o-1",
+    {orderId: "o-1", lineNo: "l-1", label: "First", geolocation: Located({lat: 48.2082, lng: 16.3738})},
+    Init,
+    None,
+  )
+  let _ = await ops.save("o-1", {orderId: "o-1", lineNo: "l-2", label: "Second"}, Init, None)
+
+  switch DomainGraphQL_Server.getQueryResolver(name ++ "Items") {
+  | Some(r) => r
+  | None => JsError.throwWithMessage("items resolver not registered: " ++ name ++ "Items")
+  }
+}
+
+describe("QueryDb sub-id resolver — the Items door", () => {
+  beforeEach(() => {
+    DomainGraphQL_Server.reset()
+  })
+
+  testPromise("answers the sub-items of one id, as edges", async () => {
+    let resolver = await buildSubIdFixture(~name="ItemA")
+    let response = await resolver(JSON.Encode.null, argsOf([("id", strJson("o-1"))]), emptyCtx)
+    let edges = getEdges(response)
+    expect(edges->Array.length)->toBe(2)
+    expect(edgeNodeField(edges->Array.getUnsafe(0), "lineNo"))->toBe("l-1")
+  })
+
+  // The gap this fixture exists to close, mirroring the by-index case above: a
+  // union reaching a caller through the Items door with the member type the
+  // write-time stamp put on it. Without it the member resolves to null and takes
+  // its non-nullable parent, so the row leaves the connection rather than erroring.
+  testPromise("carries a union field's member type through", async () => {
+    let resolver = await buildSubIdFixture(~name="ItemB")
+    let response = await resolver(JSON.Encode.null, argsOf([("id", strJson("o-1"))]), emptyCtx)
+    let first = getEdges(response)->Array.getUnsafe(0)
+    let geo = edgeNodeJson(first, "geolocation")->Option.flatMap(JSON.Decode.object)
+    expect(geo->Option.flatMap(o => o->Dict.get("__typename"))->Option.flatMap(JSON.Decode.string))
+    ->toEqual(Some("GeolocationLocated"))
+    expect(geo->Option.flatMap(o => o->Dict.get("lat"))->Option.flatMap(JSON.Decode.float))
+    ->toEqual(Some(48.2082))
+  })
+
+  testPromise("leaves an absent union absent", async () => {
+    let resolver = await buildSubIdFixture(~name="ItemC")
+    let response = await resolver(JSON.Encode.null, argsOf([("id", strJson("o-1"))]), emptyCtx)
+    let second = getEdges(response)->Array.getUnsafe(1)
+    expect(edgeNodeField(second, "label"))->toBe("Second")
+    expect(edgeNodeJson(second, "geolocation")->Option.isNone)->toBe(true)
+  })
+})

package/tests/adapter/QueryDbListResolverTest.res.mjs

@@ -648,6 +648,136 @@ globalThis.describe("QueryDb by-index resolver", () => {
   });
 });
 
+let lineStateSchema = Sury.$schema(s => ({
+  orderId: s.m(DcbTag$Reventless.string),
+  lineNo: s.m(Sury.string),
+  label: s.m(Sury.string),
+  geolocation: s.m(Sury.$option(geolocationSchema$1))
+}));
+
+let lineStateSchemaWithAnnotations = Sury.$Metadata_set(lineStateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
+  ids: ["orderId"],
+  compositeIds: [],
+  subIds: ["lineNo"],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: [],
+  scanSort: [],
+  semantic: [],
+  metric: [],
+  lifecycle: undefined,
+  groupBy: undefined,
+  visibility: undefined,
+  live: undefined,
+  retired: undefined
+});
+
+async function buildSubIdFixture(name) {
+  let Bus = LocalBus$ReventlessLocal.Make({});
+  let Storage = LocalQueryDbStorage$ReventlessLocal.Make(Bus);
+  let Resolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
+  let moduleUrl = import.meta.url;
+  let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+  let subIdConfig = {
+    subIdField: "lineNo",
+    getSubId: state => state.lineNo
+  };
+  let QDbResolversAdapter = QueryDb_Adapter$ReventlessCore.NoResolvers({
+    make: Storage.make
+  });
+  let Maker = QueryDb_Builder$ReventlessCore.Make({
+    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: lineStateSchema,
+    config: config,
+    subIdConfig: subIdConfig,
+    authorization: "AllowAuthenticated",
+    visibility: "Public"
+  })({
+    make: Storage.make
+  })(QDbResolversAdapter);
+  Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[name] = {
+    singleFieldName: name,
+    listFieldName: name + "s",
+    returnTypeName: name,
+    pluralTypeName: "[" + name + "]",
+    includeIdParam: true,
+    connectionSpec: true
+  };
+  Plugin_Helpers$ReventlessCore.stateSchemaRegistry[name] = lineStateSchemaWithAnnotations;
+  let queryDb = Maker.make(undefined, undefined, undefined, undefined, undefined);
+  let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(queryDb));
+  Resolvers.make(name, undefined, undefined, Pulumi.output(""), [], "lineNo", [], [], "AllowAuthenticated", {});
+  await ops.save("o-1", {
+    orderId: "o-1",
+    lineNo: "l-1",
+    label: "First",
+    geolocation: {
+      TAG: "Located",
+      lat: 48.2082,
+      lng: 16.3738
+    }
+  }, "Init", undefined);
+  await ops.save("o-1", {
+    orderId: "o-1",
+    lineNo: "l-2",
+    label: "Second"
+  }, "Init", undefined);
+  let r = DomainGraphQL_Server$ReventlessLocal.getQueryResolver(name + "Items");
+  if (r !== undefined) {
+    return r;
+  } else {
+    return Stdlib_JsError.throwWithMessage("items resolver not registered: " + name + "Items");
+  }
+}
+
+globalThis.describe("QueryDb sub-id resolver — the Items door", () => {
+  globalThis.beforeEach(() => DomainGraphQL_Server$ReventlessLocal.reset());
+  globalThis.test("answers the sub-items of one id, as edges", async () => {
+    let resolver = await buildSubIdFixture("ItemA");
+    let response = await resolver(null, Object.fromEntries([[
+        "id",
+        "o-1"
+      ]]), emptyCtx);
+    let edges = getEdges(response);
+    globalThis.expect(edges.length).toBe(2);
+    globalThis.expect(edgeNodeField(edges[0], "lineNo")).toBe("l-1");
+  });
+  globalThis.test("carries a union field's member type through", async () => {
+    let resolver = await buildSubIdFixture("ItemB");
+    let response = await resolver(null, Object.fromEntries([[
+        "id",
+        "o-1"
+      ]]), emptyCtx);
+    let first = getEdges(response)[0];
+    let geo = Stdlib_Option.flatMap(edgeNodeJson(first, "geolocation"), Stdlib_JSON.Decode.object);
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(geo, o => o["__typename"]), Stdlib_JSON.Decode.string)).toEqual("GeolocationLocated");
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(geo, o => o["lat"]), Stdlib_JSON.Decode.float)).toEqual(48.2082);
+  });
+  globalThis.test("leaves an absent union absent", async () => {
+    let resolver = await buildSubIdFixture("ItemC");
+    let response = await resolver(null, Object.fromEntries([[
+        "id",
+        "o-1"
+      ]]), emptyCtx);
+    let second = getEdges(response)[1];
+    globalThis.expect(edgeNodeField(second, "label")).toBe("Second");
+    globalThis.expect(Stdlib_Option.isNone(edgeNodeJson(second, "geolocation"))).toBe(true);
+  });
+});
+
 export {
   geolocationSchema$1 as geolocationSchema,
   rowStateSchema,
@@ -667,5 +797,8 @@ export {
   pageInfoBool,
   pageInfoString,
   buildFixture,
+  lineStateSchema,
+  lineStateSchemaWithAnnotations,
+  buildSubIdFixture,
 }
 /*  Not a pure module */

package/tests/adapter/QueryDbResolvedFieldsTest.res

@@ -0,0 +1,253 @@
+// Behavioural tests for the in-memory cross-table field resolvers
+// (`@resolves` / `@resolvesMany`). An Orders view carries a foreign `productId`
+// and a `productIds` array; both follow into a Products view's rows.
+//
+// The rows handed back are the TARGET's, so the target's `@retired` rule narrows
+// them — the same reading the AppSync response bakes in. A nested field takes no
+// `includeRetired` argument, so a retired row never travels through one.
+
+@@warning("-44")
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+@schema
+type productRow = {productId: string, name: string, archived: bool}
+
+@schema
+type orderRow = {orderId: string, productId: string, productIds: array<string>}
+
+let annotations = (~retired: option<Reventless.StateAnnotations.retiredSpec>) => {
+  Reventless.StateAnnotations.ids: [],
+  compositeIds: [],
+  subIds: [],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: [],
+  scanSort: [],
+  semantic: [],
+  metric: [],
+  lifecycle: None,
+  groupBy: None,
+  visibility: None,
+  live: None,
+  retired,
+}
+
+let ctxFor = (~groups: array<string>): JSON.t =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      (
+        "request",
+        JSON.Encode.object(Dict.fromArray([("headers", JSON.Encode.object(Dict.make()))])),
+      ),
+      (
+        "identity",
+        (
+          {
+            ...Reventless.Identity.anonymous,
+            userId: "test-user",
+            username: "test-user",
+            groups,
+          }: Reventless.Identity.t
+        )->Obj.magic,
+      ),
+    ]),
+  )
+
+let plainCtx = ctxFor(~groups=["User"])
+
+let noArgs: JSON.t = JSON.Encode.object(Dict.make())
+
+let getString = (json: JSON.t, key: string): option<string> =>
+  json->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.string)
+
+let names = (json: JSON.t): array<string> =>
+  json->JSON.Decode.array->Option.getOr([])->Array.filterMap(item => item->getString("name"))
+
+// One Bus carrying both views, resolvers registered for the Orders view with the
+// two configs the PPX writes from `@resolves` / `@resolvesMany`.
+let buildFixture = async (~suffix: string, ~retired: option<Reventless.StateAnnotations.retiredSpec>) => {
+  module Bus = LocalBus.Make()
+  module Storage = LocalQueryDbStorage.Make(Bus)
+  module Resolvers = QueryDbResolvers_GraphQL.Make(Bus)
+
+  let productsName = "Products" ++ suffix
+  let ordersName = "Orders" ++ suffix
+  let orderTypeName = "Shop_Order" ++ suffix
+
+  module ProductsSpec = {
+    module Id = Reventless.Id.StringPure
+    let name = productsName
+    let moduleUrl: string = %raw(`import.meta.url`)
+    @schema
+    type state = productRow
+    let config = Reventless.ReadModel.config()
+    let subIdConfig = None
+    let authorization: Reventless.Authorization.permission = AllowAuthenticated
+    let visibility: Reventless.Visibility.t = Public
+  }
+
+  module OrdersSpec = {
+    module Id = Reventless.Id.StringPure
+    let name = ordersName
+    let moduleUrl: string = %raw(`import.meta.url`)
+    @schema
+    type state = orderRow
+    let config = Reventless.ReadModel.config(
+      ~idResolvers=[
+        {
+          source: {
+            Reventless.ReadModel.idField: "productId",
+            subId: NoSubId,
+            resolvedField: Single("product"),
+          },
+          target: {Reventless.ReadModel.tableName: productsName, idField: Id},
+        },
+      ],
+      ~idsResolvers=[
+        {
+          source: {Reventless.ReadModel.idsField: "productIds", resolvedField: "products"},
+          target: {Reventless.ReadModel.tableName: productsName},
+        },
+      ],
+    )
+    let subIdConfig = None
+    let authorization: Reventless.Authorization.permission = AllowAuthenticated
+    let visibility: Reventless.Visibility.t = Public
+  }
+
+  module NoResolvers = ReventlessCore.QueryDb_Adapter.NoResolvers(Storage)
+  module ProductsDb = ReventlessCore.QueryDb_Builder.Make(ProductsSpec, Storage, NoResolvers)
+  module OrdersDb = ReventlessCore.QueryDb_Builder.Make(OrdersSpec, Storage, NoResolvers)
+
+  let register = (~viewName, ~returnTypeName) =>
+    ReventlessCore.Plugin_Helpers.queryFieldNamesRegistry->Dict.set(
+      viewName,
+      {
+        singleFieldName: returnTypeName,
+        listFieldName: returnTypeName ++ "s",
+        returnTypeName,
+        pluralTypeName: returnTypeName ++ "s",
+        includeIdParam: true,
+        connectionSpec: true,
+      },
+    )
+  register(~viewName=productsName, ~returnTypeName="Shop_Product" ++ suffix)
+  register(~viewName=ordersName, ~returnTypeName=orderTypeName)
+  ReventlessCore.Plugin_Helpers.stateSchemaRegistry->Dict.set(
+    productsName,
+    productRowSchema
+    ->S.Metadata.set(
+      ~id=Reventless.StateAnnotations.stateAnnotationsId,
+      annotations(~retired),
+    )
+    ->S.castToUnknown,
+  )
+
+  let productsDb = ProductsDb.make(~api=(), ~apiRole=())
+  let productOps = await productsDb->ReventlessCore.Component.operations->TestRunner.resolve
+  let ordersDb = OrdersDb.make(~api=(), ~apiRole=())
+  let orderOps = await ordersDb->ReventlessCore.Component.operations->TestRunner.resolve
+
+  let _: ReventlessCore.QueryDb_Adapter.resolvers = Resolvers.make(
+    ~name=ordersName,
+    ~api=(),
+    ~apiRole=(),
+    ~dataSourceName=""->Pulumi.Output.make,
+    ~indexes=[],
+    ~subIdField=None,
+    ~idResolverConfigs=OrdersSpec.config.idResolvers,
+    ~idsResolverConfigs=OrdersSpec.config.idsResolvers,
+    ~authorization=Reventless.Authorization.AllowAuthenticated,
+    ~opts=({}: Pulumi.CustomResourceOptions.t),
+  )
+
+  let _ = await productOps.save("p-1", {productId: "p-1", name: "Book", archived: false}, Init, None)
+  let _ = await productOps.save("p-2", {productId: "p-2", name: "Pen", archived: true}, Init, None)
+  let _ = await orderOps.save(
+    "o-1",
+    {orderId: "o-1", productId: "p-1", productIds: ["p-1", "gone", "p-2"]},
+    Init,
+    None,
+  )
+
+  let resolverFor = field =>
+    switch DomainGraphQL_Server.getFieldResolver(~typeName=orderTypeName, field) {
+    | Some(r) => r
+    | None => JsError.throwWithMessage("field resolver not registered: " ++ field)
+    }
+
+  let order = JSON.Encode.object(
+    Dict.fromArray([
+      ("orderId", JSON.Encode.string("o-1")),
+      ("productId", JSON.Encode.string("p-1")),
+      (
+        "productIds",
+        ["p-1", "gone", "p-2"]->Array.map(JSON.Encode.string)->JSON.Encode.array,
+      ),
+    ]),
+  )
+
+  (resolverFor, order)
+}
+
+describe("QueryDb cross-table field resolvers", () => {
+  beforeEach(() => {
+    DomainGraphQL_Server.reset()
+  })
+
+  testPromise("@resolves follows the foreign key into the target's row", async () => {
+    let (resolverFor, order) = await buildFixture(~suffix="A", ~retired=None)
+    let product = await resolverFor("product")(order, noArgs, plainCtx)
+    expect((product->getString("name"), product->getString("id")))->toEqual((
+      Some("Book"),
+      Some("p-1"),
+    ))
+  })
+
+  testPromise("@resolvesMany batch-follows the id array", async () => {
+    let (resolverFor, order) = await buildFixture(~suffix="B", ~retired=None)
+    let products = await resolverFor("products")(order, noArgs, plainCtx)
+    // "gone" names no row and drops out rather than becoming a null, matching
+    // BatchGetItem and the by-ids door built on it.
+    expect(products->names)->toEqual(["Book", "Pen"])
+  })
+
+  testPromise("a foreign key naming no row resolves to nothing", async () => {
+    let (resolverFor, _) = await buildFixture(~suffix="C", ~retired=None)
+    let orphan = JSON.Encode.object(
+      Dict.fromArray([("productId", JSON.Encode.string("nope"))]),
+    )
+    let product = await resolverFor("product")(orphan, noArgs, plainCtx)
+    expect(product)->toBe(JSON.Encode.null)
+  })
+
+  // The narrowing is the target's: Products declares the retirement, Orders
+  // declares the field, and the caller reading through Orders is answered by
+  // the Products rule.
+  testPromise("a retired target row is withheld from both forms", async () => {
+    let retired: Reventless.StateAnnotations.retiredSpec = {
+      field: "archived",
+      label: "",
+      showWhenFalse: false,
+      values: None,
+      namedWhenRetired: false,
+    }
+    let (resolverFor, order) = await buildFixture(~suffix="D", ~retired=Some(retired))
+    let products = await resolverFor("products")(order, noArgs, plainCtx)
+    expect(products->names)->toEqual(["Book"])
+
+    let archivedOnly = JSON.Encode.object(
+      Dict.fromArray([("productId", JSON.Encode.string("p-2"))]),
+    )
+    let product = await resolverFor("product")(archivedOnly, noArgs, plainCtx)
+    expect(product)->toBe(JSON.Encode.null)
+  })
+})