@reventlessdev/reventless-aws 3.0.0-alpha.231 → 3.0.0-alpha.233

package/tests/PgMigrationEntryPoint_IntegrationTest.res

@@ -16,42 +16,33 @@ open JestGlobals
 
 @val external processEnv: dict<string> = "process.env"
 
-// Import the .mjs entry point and call runMigration with the pool injected.
-// Returns "ok" on success. A minimal pgConnection satisfies the guard; the real
-// fields are ignored because `makePool` is injected.
-let runMigrationWithPool: (
-  ReventlessPostgres.PgDriver.pool,
-) => promise<string> = %raw(`
-  async (pool) => {
-    const { runMigration } = await import(
-      "@reventlessdev/reventless-aws/src/adapter/Runtime/PgMigrationEntryPoint.mjs"
-    );
-    const config = {
+// Drive the real ReScript `runMigration` with the pool injected — the guard
+// rejects a HANDLER_CONFIG with no pgConnection; the real fields below are
+// ignored because `~makePool` is injected. Returns "ok" on success.
+let runMigrationWithPool = (pool: ReventlessPostgres.PgDriver.pool): promise<string> =>
+  PgMigrationEntryPoint.runMigration(
+    {
       pgConnection: {
-        host: "ignored", port: 5432, database: "ignored",
-        username: "ignored", secretArn: "ignored",
+        host: "ignored",
+        port: 5432,
+        database: "ignored",
+        username: "ignored",
+        secretArn: "ignored",
       },
-    };
-    return await runMigration(config, { makePool: () => pool });
-  }
-`)
-
-// runMigration with an empty config — the guard must reject a HANDLER_CONFIG
-// that carries no pgConnection (a misconfigured deploy), rather than silently
-// building a bad pool.
-let runMigrationMissingConfigThrows: unit => promise<bool> = %raw(`
-  async () => {
-    const { runMigration } = await import(
-      "@reventlessdev/reventless-aws/src/adapter/Runtime/PgMigrationEntryPoint.mjs"
-    );
-    try { await runMigration({}, {}); return false; }
-    catch { return true; }
-  }
-`)
+    },
+    ~makePool=_ => pool,
+  )
 
 describe("PgMigrationEntryPoint.runMigration", () => {
   testPromise("rejects a HANDLER_CONFIG with no pgConnection", async () => {
-    let threw = await runMigrationMissingConfigThrows()
+    // An empty config carries no pgConnection (a misconfigured deploy); the
+    // guard must reject it rather than silently building a bad pool.
+    let threw = try {
+      let _ = await PgMigrationEntryPoint.runMigration({pgConnection: ?None})
+      false
+    } catch {
+    | _ => true
+    }
     expect(threw)->toBe(true)
   })
 

package/tests/PgMigrationEntryPoint_IntegrationTest.res.mjs

@@ -1,33 +1,31 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as PgDriver$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/PgDriver.res.mjs";
+import * as PgMigrationEntryPoint$ReventlessAws from "../src/adapter/Runtime/PgMigrationEntryPoint.res.mjs";
 import * as EventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/EventLogStorage_Postgres.res.mjs";
 import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/DcbEventLogStorage_Postgres.res.mjs";
 
-let runMigrationWithPool = (async (pool) => {
-    const { runMigration } = await import(
-      "@reventlessdev/reventless-aws/src/adapter/Runtime/PgMigrationEntryPoint.mjs"
-    );
-    const config = {
-      pgConnection: {
-        host: "ignored", port: 5432, database: "ignored",
-        username: "ignored", secretArn: "ignored",
-      },
-    };
-    return await runMigration(config, { makePool: () => pool });
-  });
-
-let runMigrationMissingConfigThrows = (async () => {
-    const { runMigration } = await import(
-      "@reventlessdev/reventless-aws/src/adapter/Runtime/PgMigrationEntryPoint.mjs"
-    );
-    try { await runMigration({}, {}); return false; }
-    catch { return true; }
-  });
+function runMigrationWithPool(pool) {
+  return PgMigrationEntryPoint$ReventlessAws.runMigration({
+    pgConnection: {
+      host: "ignored",
+      port: 5432,
+      database: "ignored",
+      username: "ignored",
+      secretArn: "ignored"
+    }
+  }, param => pool);
+}
 
 globalThis.describe("PgMigrationEntryPoint.runMigration", () => {
   globalThis.test("rejects a HANDLER_CONFIG with no pgConnection", async () => {
-    let threw = await runMigrationMissingConfigThrows();
+    let threw;
+    try {
+      await PgMigrationEntryPoint$ReventlessAws.runMigration({}, undefined);
+      threw = false;
+    } catch (exn) {
+      threw = true;
+    }
     globalThis.expect(threw).toBe(true);
   });
   let url = process.env["PG_URL"];
@@ -58,6 +56,5 @@ globalThis.describe("PgMigrationEntryPoint.runMigration", () => {
 
 export {
   runMigrationWithPool,
-  runMigrationMissingConfigThrows,
 }
-/* runMigrationWithPool Not a pure module */
+/*  Not a pure module */

package/tests/PgQueryResolverEntryPoint_OpsTest.res

@@ -0,0 +1,38 @@
+// Guards the typed cold-start core hoisted out of PgQueryResolverEntryPoint.mjs:
+//   - parseResolverConfig — the {pgConnection, handlers, nodeTypes} shape
+//     written by PgQueryResolver_Builder; a drift here silently drops a
+//     Postgres read model's GraphQL bindings (or its Relay node types) at
+//     cold start.
+
+open JestGlobals
+
+describe("PgQueryResolverEntryPoint_Ops.parseResolverConfig", () => {
+  testSync("empty raw config yields no connection and no handlers", () => {
+    let config = PgQueryResolverEntryPoint_Ops.parseResolverConfig("")
+    expect(config.pgConnection->Option.isNone)->toBe(true)
+    expect(config.handlers->Array.length)->toBe(0)
+    expect(config.nodeTypes->Dict.keysToArray->Array.length)->toBe(0)
+  })
+
+  testSync("null pgConnection decodes to None", () => {
+    let config = PgQueryResolverEntryPoint_Ops.parseResolverConfig(
+      `{"pgConnection":null,"handlers":[]}`,
+    )
+    expect(config.pgConnection->Option.isNone)->toBe(true)
+  })
+
+  testSync("decodes connection, handlers, and node types", () => {
+    let config = PgQueryResolverEntryPoint_Ops.parseResolverConfig(
+      `{"pgConnection":{"host":"db.local","port":5432,"database":"app","username":"master","secretArn":"arn:secret"},"handlers":[{"readModelName":"Products","specModule":"@x/p/src/ReadModel/Products.res.mjs","labelField":"name","includeIdParam":true},{"readModelName":"Orders","specModule":"@x/p/src/ReadModel/Orders.res.mjs","labelField":"id","includeIdParam":false}],"nodeTypes":{"Product":"Products"}}`,
+    )
+    expect(config.pgConnection->Option.map(cc => cc.host))->toEqual(Some("db.local"))
+    expect(config.handlers->Array.length)->toBe(2)
+    let first = config.handlers->Array.getUnsafe(0)
+    expect(first.readModelName)->toBe("Products")
+    expect(first.specModule)->toBe("@x/p/src/ReadModel/Products.res.mjs")
+    expect(first.labelField)->toBe("name")
+    expect(first.includeIdParam)->toBe(true)
+    expect((config.handlers->Array.getUnsafe(1)).includeIdParam)->toBe(false)
+    expect(config.nodeTypes->Dict.get("Product"))->toEqual(Some("Products"))
+  })
+})

package/tests/PgQueryResolverEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as PgQueryResolverEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/PgQueryResolverEntryPoint_Ops.res.mjs";
+
+globalThis.describe("PgQueryResolverEntryPoint_Ops.parseResolverConfig", () => {
+  globalThis.test("empty raw config yields no connection and no handlers", () => {
+    let config = PgQueryResolverEntryPoint_Ops$ReventlessAws.parseResolverConfig("");
+    globalThis.expect(Stdlib_Option.isNone(config.pgConnection)).toBe(true);
+    globalThis.expect(config.handlers.length).toBe(0);
+    globalThis.expect(Object.keys(config.nodeTypes).length).toBe(0);
+  });
+  globalThis.test("null pgConnection decodes to None", () => {
+    let config = PgQueryResolverEntryPoint_Ops$ReventlessAws.parseResolverConfig(`{"pgConnection":null,"handlers":[]}`);
+    globalThis.expect(Stdlib_Option.isNone(config.pgConnection)).toBe(true);
+  });
+  globalThis.test("decodes connection, handlers, and node types", () => {
+    let config = PgQueryResolverEntryPoint_Ops$ReventlessAws.parseResolverConfig(`{"pgConnection":{"host":"db.local","port":5432,"database":"app","username":"master","secretArn":"arn:secret"},"handlers":[{"readModelName":"Products","specModule":"@x/p/src/ReadModel/Products.res.mjs","labelField":"name","includeIdParam":true},{"readModelName":"Orders","specModule":"@x/p/src/ReadModel/Orders.res.mjs","labelField":"id","includeIdParam":false}],"nodeTypes":{"Product":"Products"}}`);
+    globalThis.expect(Stdlib_Option.map(config.pgConnection, cc => cc.host)).toEqual("db.local");
+    globalThis.expect(config.handlers.length).toBe(2);
+    let first = config.handlers[0];
+    globalThis.expect(first.readModelName).toBe("Products");
+    globalThis.expect(first.specModule).toBe("@x/p/src/ReadModel/Products.res.mjs");
+    globalThis.expect(first.labelField).toBe("name");
+    globalThis.expect(first.includeIdParam).toBe(true);
+    globalThis.expect(config.handlers[1].includeIdParam).toBe(false);
+    globalThis.expect(config.nodeTypes["Product"]).toEqual("Products");
+  });
+});
+
+/*  Not a pure module */

package/tests/Platform_AdminScan_OpsTest.res

@@ -0,0 +1,80 @@
+// Guards the pure logic hoisted out of the two admin-query resolver Lambdas'
+// former inline JS strings (Platform_UIFragments, Platform_ComponentDefinitions)
+// into the shared, type-checked Platform_AdminScan_Ops:
+//   - `compareVersions` — a byte-for-byte port of the JS `cmpVer` comparator.
+//   - `latestByName`    — the highest-version-per-plugin-name collapse.
+// The DynamoDB scan itself is an SDK call, not unit-tested here.
+
+open JestGlobals
+
+let cmp = Platform_AdminScan_Ops.compareVersions
+
+describe("Platform_AdminScan_Ops.compareVersions", () => {
+  testSync("orders numeric segments as numbers, not lexically", () => {
+    // Lexical order would put "10" < "9"; numeric order is the opposite.
+    expect(cmp("1.10.0", "1.9.0"))->toBe(1)
+    expect(cmp("1.9.0", "1.10.0"))->toBe(-1)
+  })
+
+  testSync("equal versions compare to 0", () => {
+    expect(cmp("2.3.4", "2.3.4"))->toBe(0)
+  })
+
+  testSync("a longer version outranks its prefix", () => {
+    // "1.2" normalises to ["1","2"]; "1.2.1" adds a segment (1 > missing "").
+    expect(cmp("1.2.1", "1.2"))->toBe(1)
+    expect(cmp("1.2", "1.2.1"))->toBe(-1)
+  })
+
+  testSync("normalises pre-release `-`/`+` separators to `.`", () => {
+    // "1.2.0-1" -> ["1","2","0","1"] outranks "1.2.0" -> ["1","2","0"].
+    expect(cmp("1.2.0-1", "1.2.0"))->toBe(1)
+  })
+
+  testSync("falls back to lexical order for non-numeric segments", () => {
+    expect(cmp("1.2.beta", "1.2.alpha"))->toBe(1)
+    expect(cmp("1.2.alpha", "1.2.beta"))->toBe(-1)
+  })
+})
+
+// A minimal DDB-row (attribute -> JSON value) for the collapse tests.
+let row = pairs => Dict.fromArray(pairs)
+let s = JSON.Encode.string
+
+describe("Platform_AdminScan_Ops.latestByName", () => {
+  // A trivial entry builder that echoes the resolved bare name; drops rows with
+  // no `keep` attribute (exercises the toEntry=None skip path).
+  let nameVersionOf = item => item->Dict.get("name")->Option.flatMap(JSON.Decode.string)
+  let toEntry = (item, ~name) =>
+    switch item->Dict.get("keep") {
+    | Some(_) => Some(JSON.Encode.object(Dict.fromArray([("pluginId", s(name))])))
+    | None => None
+    }
+
+  let pluginIdOf = json =>
+    json->JSON.Decode.object->Option.flatMap(o => o->Dict.get("pluginId"))->Option.flatMap(JSON.Decode.string)
+
+  testSync("keeps only the highest version per bare plugin name", () => {
+    let items = [
+      row([("name", s("Catalog@1.9.0")), ("keep", s("y"))]),
+      row([("name", s("Catalog@1.10.0")), ("keep", s("y"))]),
+      row([("name", s("Catalog@1.2.0")), ("keep", s("y"))]),
+      row([("name", s("Ordering@2.0.0")), ("keep", s("y"))]),
+    ]
+    let out = Platform_AdminScan_Ops.latestByName(items, ~nameVersionOf, ~toEntry)
+    let names = out->Array.filterMap(pluginIdOf)
+    // One entry per bare name.
+    expect(out->Array.length)->toBe(2)
+    expect(names->Array.includes("Catalog"))->toBe(true)
+    expect(names->Array.includes("Ordering"))->toBe(true)
+  })
+
+  testSync("drops rows the entry builder rejects", () => {
+    let items = [
+      row([("name", s("Catalog@1.0.0"))]), // no `keep` -> dropped
+      row([("name", s("Ordering@1.0.0")), ("keep", s("y"))]),
+    ]
+    let out = Platform_AdminScan_Ops.latestByName(items, ~nameVersionOf, ~toEntry)
+    expect(out->Array.filterMap(pluginIdOf))->toEqual(["Ordering"])
+  })
+})

package/tests/Platform_AdminScan_OpsTest.res.mjs

@@ -0,0 +1,127 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Platform_AdminScan_Ops$ReventlessAws from "../src/adapter/Api/Platform_AdminScan_Ops.res.mjs";
+
+globalThis.describe("Platform_AdminScan_Ops.compareVersions", () => {
+  globalThis.test("orders numeric segments as numbers, not lexically", () => {
+    globalThis.expect(Platform_AdminScan_Ops$ReventlessAws.compareVersions("1.10.0", "1.9.0")).toBe(1);
+    globalThis.expect(Platform_AdminScan_Ops$ReventlessAws.compareVersions("1.9.0", "1.10.0")).toBe(-1);
+  });
+  globalThis.test("equal versions compare to 0", () => {
+    globalThis.expect(Platform_AdminScan_Ops$ReventlessAws.compareVersions("2.3.4", "2.3.4")).toBe(0);
+  });
+  globalThis.test("a longer version outranks its prefix", () => {
+    globalThis.expect(Platform_AdminScan_Ops$ReventlessAws.compareVersions("1.2.1", "1.2")).toBe(1);
+    globalThis.expect(Platform_AdminScan_Ops$ReventlessAws.compareVersions("1.2", "1.2.1")).toBe(-1);
+  });
+  globalThis.test("normalises pre-release `-`/`+` separators to `.`", () => {
+    globalThis.expect(Platform_AdminScan_Ops$ReventlessAws.compareVersions("1.2.0-1", "1.2.0")).toBe(1);
+  });
+  globalThis.test("falls back to lexical order for non-numeric segments", () => {
+    globalThis.expect(Platform_AdminScan_Ops$ReventlessAws.compareVersions("1.2.beta", "1.2.alpha")).toBe(1);
+    globalThis.expect(Platform_AdminScan_Ops$ReventlessAws.compareVersions("1.2.alpha", "1.2.beta")).toBe(-1);
+  });
+});
+
+function row(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+function s(prim) {
+  return prim;
+}
+
+globalThis.describe("Platform_AdminScan_Ops.latestByName", () => {
+  let nameVersionOf = item => Stdlib_Option.flatMap(item["name"], Stdlib_JSON.Decode.string);
+  let toEntry = (item, name) => {
+    let match = item["keep"];
+    if (match !== undefined) {
+      return Object.fromEntries([[
+          "pluginId",
+          name
+        ]]);
+    }
+  };
+  let pluginIdOf = json => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o["pluginId"]), Stdlib_JSON.Decode.string);
+  globalThis.test("keeps only the highest version per bare plugin name", () => {
+    let items = [
+      Object.fromEntries([
+        [
+          "name",
+          "Catalog@1.9.0"
+        ],
+        [
+          "keep",
+          "y"
+        ]
+      ]),
+      Object.fromEntries([
+        [
+          "name",
+          "Catalog@1.10.0"
+        ],
+        [
+          "keep",
+          "y"
+        ]
+      ]),
+      Object.fromEntries([
+        [
+          "name",
+          "Catalog@1.2.0"
+        ],
+        [
+          "keep",
+          "y"
+        ]
+      ]),
+      Object.fromEntries([
+        [
+          "name",
+          "Ordering@2.0.0"
+        ],
+        [
+          "keep",
+          "y"
+        ]
+      ])
+    ];
+    let out = Platform_AdminScan_Ops$ReventlessAws.latestByName(items, nameVersionOf, toEntry);
+    let names = Stdlib_Array.filterMap(out, pluginIdOf);
+    globalThis.expect(out.length).toBe(2);
+    globalThis.expect(names.includes("Catalog")).toBe(true);
+    globalThis.expect(names.includes("Ordering")).toBe(true);
+  });
+  globalThis.test("drops rows the entry builder rejects", () => {
+    let items = [
+      Object.fromEntries([[
+          "name",
+          "Catalog@1.0.0"
+        ]]),
+      Object.fromEntries([
+        [
+          "name",
+          "Ordering@1.0.0"
+        ],
+        [
+          "keep",
+          "y"
+        ]
+      ])
+    ];
+    let out = Platform_AdminScan_Ops$ReventlessAws.latestByName(items, nameVersionOf, toEntry);
+    globalThis.expect(Stdlib_Array.filterMap(out, pluginIdOf)).toEqual(["Ordering"]);
+  });
+});
+
+let cmp = Platform_AdminScan_Ops$ReventlessAws.compareVersions;
+
+export {
+  cmp,
+  row,
+  s,
+}
+/*  Not a pure module */

package/tests/ReadModelEntryPoint_OpsTest.res

@@ -0,0 +1,141 @@
+// Guards the typed cold-start core hoisted out of ReadModelEntryPoint.mjs:
+//   - parseHandlerConfig — the HANDLER_CONFIG contract every read-model Lambda
+//     cold-starts on, incl. the optional attribution (comp/plugin) and backend
+//     (pgConnection/stateTopicName) fields.
+//   - injectId / withInjectedId — the id-injection wrap on save/saveBatch;
+//     query resolvers and the live-update publisher read `id` off the row, so
+//     silently dropping the injection would strand every list query.
+
+open JestGlobals
+
+let str = JSON.Encode.string
+let obj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+describe("ReadModelEntryPoint_Ops.parseHandlerConfig", () => {
+  testSync("empty raw config yields no handlers", () => {
+    expect(ReadModelEntryPoint_Ops.parseHandlerConfig("")->Array.length)->toBe(0)
+    expect(ReadModelEntryPoint_Ops.parseHandlerConfig(`{"handlers":[]}`)->Array.length)->toBe(0)
+  })
+
+  testSync("decodes a full entry incl. attribution and Postgres fields", () => {
+    let config = obj([
+      (
+        "handlers",
+        JSON.Encode.array([
+          obj([
+            ("specModule", str("@x/spec/src/ReadModel/Products.res.mjs")),
+            ("mappingsModule", str("@x/spec/src/ReadModel/Products_Projections.res.mjs")),
+            ("queryDbTableName", str("Products-abc")),
+            ("sourceUrn", str("arn:aws:sqs:eu-west-1:1:q")),
+            ("comp", str("EventCollector(ProductsEC)")),
+            ("plugin", str("Catalog")),
+            ("stateTopicName", str("catalogProducts")),
+            (
+              "pgConnection",
+              obj([
+                ("host", str("db.local")),
+                ("port", JSON.Encode.int(5432)),
+                ("database", str("app")),
+                ("username", str("master")),
+                ("secretArn", str("arn:secret")),
+              ]),
+            ),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let entries = ReadModelEntryPoint_Ops.parseHandlerConfig(config)
+    expect(entries->Array.length)->toBe(1)
+    let e = entries->Array.getUnsafe(0)
+    expect(e.specModule)->toBe("@x/spec/src/ReadModel/Products.res.mjs")
+    expect(e.mappingsModule)->toBe("@x/spec/src/ReadModel/Products_Projections.res.mjs")
+    expect(e.queryDbTableName)->toBe("Products-abc")
+    expect(e.sourceUrn)->toBe("arn:aws:sqs:eu-west-1:1:q")
+    expect(e.comp)->toEqual(Some("EventCollector(ProductsEC)"))
+    expect(e.plugin)->toEqual(Some("Catalog"))
+    expect(e.stateTopicName)->toEqual(Some("catalogProducts"))
+    switch e.pgConnection {
+    | Some(cc) => {
+        expect(cc.host)->toBe("db.local")
+        expect(cc.port)->toBe(5432)
+        expect(cc.database)->toBe("app")
+      }
+    | None => JsError.throwWithMessage("expected Some(pgConnection)")
+    }
+  })
+
+  testSync("optional fields default to None; null pgConnection maps to None", () => {
+    let config = obj([
+      (
+        "handlers",
+        JSON.Encode.array([
+          obj([
+            ("specModule", str("a.res.mjs")),
+            ("mappingsModule", str("b.res.mjs")),
+            ("queryDbTableName", str("t")),
+            ("sourceUrn", str("u")),
+            ("pgConnection", JSON.Null),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let e = ReadModelEntryPoint_Ops.parseHandlerConfig(config)->Array.getUnsafe(0)
+    expect(e.comp->Option.isNone)->toBe(true)
+    expect(e.plugin->Option.isNone)->toBe(true)
+    expect(e.stateTopicName->Option.isNone)->toBe(true)
+    expect(e.pgConnection->Option.isNone)->toBe(true)
+  })
+})
+
+describe("ReadModelEntryPoint_Ops.injectId", () => {
+  testSync("injects (and overwrites) id on object states", () => {
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", obj([("name", str("Widget"))])))->toEqual(
+      obj([("name", str("Widget")), ("id", str("p-1"))]),
+    )
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", obj([("id", str("stale"))])))->toEqual(
+      obj([("id", str("p-1"))]),
+    )
+  })
+
+  testSync("passes non-object states through unchanged", () => {
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", str("scalar")))->toEqual(str("scalar"))
+    expect(
+      ReadModelEntryPoint_Ops.injectId("p-1", JSON.Encode.array([str("a")])),
+    )->toEqual(JSON.Encode.array([str("a")]))
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", JSON.Null))->toEqual(JSON.Null)
+  })
+})
+
+describe("ReadModelEntryPoint_Ops.withInjectedId", () => {
+  // Capturing stub operation set — only save/saveBatch matter for the wrap.
+  let makeStub = (saved: array<(string, JSON.t)>): ReventlessCore.QueryDb_Adapter.operations => {
+    load: async _ => Ok([]),
+    loadStream: _ => Stream.fromIterable([]),
+    save: async (id, state, _mode, _ttl) => {
+      saved->Array.push((id, state))
+      Ok()
+    },
+    saveBatch: async items => {
+      items->Array.forEach(((id, state, _ttl)) => saved->Array.push((id, state)))
+      Ok()
+    },
+    count: async (_, _, _) => Ok(0),
+    delete: async (_, _) => Ok(),
+    deleteBatch: async _ => Ok(),
+  }
+
+  test("save and saveBatch write id-injected states", async () => {
+    let saved = []
+    let ops = ReadModelEntryPoint_Ops.withInjectedId(makeStub(saved))
+    let _ = await ops.save("p-1", obj([("name", str("A"))]), ReventlessCore.QueryDb.Any, None)
+    let _ = await ops.saveBatch([
+      ("p-2", obj([("name", str("B"))]), None),
+      ("p-3", str("scalar"), None),
+    ])
+    expect(saved)->toEqual([
+      ("p-1", obj([("name", str("A")), ("id", str("p-1"))])),
+      ("p-2", obj([("name", str("B")), ("id", str("p-2"))])),
+      ("p-3", str("scalar")),
+    ])
+  })
+})