@reventlessdev/reventless-postgres 3.0.0-alpha.10 → 3.0.0-alpha.100

package/src/QueryEnginePostgres.res.mjs

@@ -2,11 +2,10 @@
 
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_Nullable from "@rescript/runtime/lib/es6/Stdlib_Nullable.js";
 import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
 import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
-import * as QueryDbStorage_Postgres$ReventlessPostgres from "./QueryDbStorage_Postgres.res.mjs";
+import * as QueryDbStorage_Postgres_Ops$ReventlessPostgres from "./QueryDbStorage_Postgres_Ops.res.mjs";
 
 function valueToText(v) {
   switch (v.TAG) {
@@ -105,25 +104,25 @@ function subIdSql(b, field, cmp, v) {
 }
 
 function decodeRow(withId, row) {
-  let item = QueryDbStorage_Postgres$ReventlessPostgres.decodeItem(row);
+  let item = QueryDbStorage_Postgres_Ops$ReventlessPostgres.decodeItem(row);
   if (!withId) {
     return item;
   }
   let match = row["partition_key"];
   let pk = typeof match === "string" ? match : "";
-  return QueryDbStorage_Postgres$ReventlessPostgres.withId(item, pk);
+  return QueryDbStorage_Postgres_Ops$ReventlessPostgres.withId(item, pk);
 }
 
 function Make(P) {
   let query = async (readModelName, key, id, subIdConfig, filterConfigs, ascending, limit) => {
-    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let table = QueryDbStorage_Postgres_Ops$ReventlessPostgres.tableName(readModelName);
     let keyStr = key !== undefined ? key : valueToText(id);
     let b = {
       params: []
     };
     let where = [
       `partition_key = ` + param(b, keyStr),
-      QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause
+      QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause
     ];
     if (subIdConfig !== undefined) {
       where.push(subIdSql(b, subIdConfig[0], subIdConfig[1], subIdConfig[2]));
@@ -137,11 +136,11 @@ function Make(P) {
     return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(false, extra));
   };
   let scan = async (readModelName, filterConfigs, limit) => {
-    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let table = QueryDbStorage_Postgres_Ops$ReventlessPostgres.tableName(readModelName);
     let b = {
       params: []
     };
-    let where = [QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause];
+    let where = [QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause];
     filterConfigs.forEach(param => {
       where.push(filterSql(b, param[0], param[1], param[2]));
     });
@@ -149,29 +148,29 @@ function Make(P) {
     return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
   };
   let indexLookup = async (readModelName, field, value) => {
-    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let table = QueryDbStorage_Postgres_Ops$ReventlessPostgres.tableName(readModelName);
     let b = {
       params: []
     };
-    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + col(field) + ` = ` + param(b, value) + ` AND ` + QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + col(field) + ` = ` + param(b, value) + ` AND ` + QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause;
     return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
   };
   let byIds = async (readModelName, ids) => {
     if (ids.length === 0) {
       return [];
     }
-    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let table = QueryDbStorage_Postgres_Ops$ReventlessPostgres.tableName(readModelName);
     let b = {
       params: []
     };
     let idsJson = ids.map(prim => prim);
-    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE partition_key = ANY(` + param(b, idsJson) + `::text[]) AND ` + QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE partition_key = ANY(` + param(b, idsJson) + `::text[]) AND ` + QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause;
     return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
   };
   let idExprC = `COALESCE(item->>'id', partition_key) COLLATE "C"`;
   let jsonTextC = field => col(field) + ` COLLATE "C"`;
-  let listPage = async (readModelName, argsDict, capability, param$1) => {
-    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+  let listPage = async (readModelName, argsDict, capability, param$1, ownerScope) => {
+    let table = QueryDbStorage_Postgres_Ops$ReventlessPostgres.tableName(readModelName);
     let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
     let strNonEmpty = k => Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict[k], Stdlib_JSON.Decode.string), false, s => s.length > 0);
     let hasIds = Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict["ids"], Stdlib_JSON.Decode.array), false, a => a.length !== 0);
@@ -183,7 +182,10 @@ function Make(P) {
     let b = {
       params: []
     };
-    let whereParts = [QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause];
+    let whereParts = [QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause];
+    if (ownerScope !== undefined) {
+      whereParts.push(jsonTextC(ownerScope[0]) + ` = ` + param(b, ownerScope[1]));
+    }
     let valString = v => {
       let s = Stdlib_JSON.Decode.string(v);
       if (s !== undefined) {
@@ -232,8 +234,8 @@ function Make(P) {
     let cursorValueOf = item => Stdlib_Option.getOr(QueryDbListQuery$ReventlessCore.getFieldString(item, cursorField), QueryDbListQuery$ReventlessCore.getId(item));
     return QueryDbListQuery$ReventlessCore.buildConnection(pageItems, hasMore, false, cursorValueOf);
   };
-  let itemsPage = async (readModelName, param$1, id, argsDict) => {
-    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+  let itemsPage = async (readModelName, param$1, id, argsDict, ownerScope) => {
+    let table = QueryDbStorage_Postgres_Ops$ReventlessPostgres.tableName(readModelName);
     let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
     let fstr = k => Stdlib_Option.flatMap(filterDict[k], Stdlib_JSON.Decode.string);
     let orderDesc = Stdlib_Option.mapOr(fstr("order"), false, o => o === "DESC");
@@ -248,8 +250,11 @@ function Make(P) {
     };
     let where = [
       `partition_key = ` + param(b, id),
-      QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause
+      QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause
     ];
+    if (ownerScope !== undefined) {
+      where.push(jsonTextC(ownerScope[0]) + ` = ` + param(b, ownerScope[1]));
+    }
     Stdlib_Option.forEach(fstr("prefix"), p => {
       where.push(`starts_with(sub_key, ` + param(b, p) + `)`);
     });
@@ -304,10 +309,6 @@ function Make(P) {
       }
     };
   };
-  let make = _allQueryDbs => Pulumi.output({
-    scan: scan,
-    query: query
-  });
   return {
     query: query,
     scan: scan,
@@ -316,12 +317,11 @@ function Make(P) {
     idExprC: idExprC,
     jsonTextC: jsonTextC,
     listPage: listPage,
-    itemsPage: itemsPage,
-    make: make
+    itemsPage: itemsPage
   };
 }
 
-let notExpired = QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+let notExpired = QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause;
 
 export {
   valueToText,
@@ -334,4 +334,4 @@ export {
   decodeRow,
   Make,
 }
-/* @pulumi/pulumi Not a pure module */
+/* PgDriver-ReventlessPostgres Not a pure module */

package/tests/PostgresIntegrationTest.res.mjs

@@ -1,377 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
-import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
-import * as PgDriver$ReventlessPostgres from "../src/PgDriver.res.mjs";
-import * as PgSchema$ReventlessPostgres from "../src/PgSchema.res.mjs";
-import * as PgChangeFeed$ReventlessPostgres from "../src/PgChangeFeed.res.mjs";
-import * as EventLogChangeFeed$ReventlessPostgres from "../src/EventLogChangeFeed.res.mjs";
-import * as EventLogStorage_Postgres$ReventlessPostgres from "../src/EventLogStorage_Postgres.res.mjs";
-import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "../src/DcbEventLogStorage_Postgres.res.mjs";
-
-let opts = {};
-
-function jsonObj(pairs) {
-  return Object.fromEntries(pairs);
-}
-
-function stored(eventType, tags, data) {
-  return {
-    eventType: eventType,
-    data: data,
-    tags: tags,
-    meta: Message$ReventlessCore.generateMeta("pg-test", undefined, undefined, undefined, undefined, undefined, undefined, undefined)
-  };
-}
-
-function evJson(msgId, v) {
-  return Object.fromEntries([
-    [
-      "msgId",
-      msgId
-    ],
-    [
-      "v",
-      v
-    ]
-  ]);
-}
-
-let url = process.env["PG_URL"];
-
-if (url !== undefined) {
-  let pool = PgDriver$ReventlessPostgres.makePool({
-    connectionString: url
-  });
-  globalThis.beforeAll(async () => {
-    await PgSchema$ReventlessPostgres.ensureSchema(pool);
-    return await PgSchema$ReventlessPostgres.truncateAll(pool);
-  });
-  globalThis.afterAll(() => {
-    PgDriver$ReventlessPostgres.endPool(pool);
-  });
-  globalThis.describe("classic OCC event log", () => {
-    globalThis.test("append, replay, and conflict on wrong seq", async () => {
-      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "ct-orders", opts, undefined);
-      let ops = match[1];
-      let r0 = await ops.append(0, "agg-1", [
-        evJson("m0", 1),
-        evJson("m1", 2)
-      ]);
-      if (r0.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-      } else {
-        globalThis.expect("append").toBe("ok");
-      }
-      let rStale = await ops.append(0, "agg-1", [evJson("m2", 3)]);
-      if (rStale.TAG === "Ok") {
-        globalThis.expect("stale").toBe("conflict");
-      } else {
-        let tmp = rStale._0;
-        if (typeof tmp !== "object") {
-          globalThis.expect(true).toBe(true);
-        } else {
-          globalThis.expect("stale").toBe("conflict");
-        }
-      }
-      let rGap = await ops.append(5, "agg-1", [evJson("m3", 4)]);
-      if (rGap.TAG === "Ok") {
-        globalThis.expect("gap").toBe("conflict");
-      } else {
-        let tmp$1 = rGap._0;
-        if (typeof tmp$1 !== "object") {
-          globalThis.expect(true).toBe(true);
-        } else {
-          globalThis.expect("gap").toBe("conflict");
-        }
-      }
-      let rNext = await ops.append(2, "agg-1", [evJson("m4", 5)]);
-      if (rNext.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-      } else {
-        globalThis.expect("next").toBe("ok");
-      }
-      let evs = await ops.replay("agg-1");
-      globalThis.expect(evs.length).toBe(3);
-      let rEmpty = await ops.append(3, "agg-1", []);
-      if (rEmpty.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-        return;
-      }
-      globalThis.expect("empty").toBe("ok");
-    });
-  });
-  globalThis.describe("DCB event log", () => {
-    let makeLog = name => DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, name, [], {
-      TAG: "Simple",
-      _0: {
-        key: "k"
-      }
-    }, undefined, opts, undefined, undefined);
-    globalThis.test("append + read round-trips events with tags", async () => {
-      let match = makeLog("dcb-rt");
-      let ops = match[1];
-      let e1 = stored("ItemAdded", [{
-          key: "itemId",
-          value: "x1"
-        }], Object.fromEntries([[
-          "n",
-          "w"
-        ]]));
-      let r = await ops.append([e1], undefined);
-      if (r.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-      } else {
-        globalThis.expect(r._0).toBe("ok");
-      }
-      let read = await ops.read([], undefined);
-      globalThis.expect(read.events.length).toBe(1);
-      let first = read.events[0];
-      globalThis.expect(first.eventType).toBe("ItemAdded");
-      globalThis.expect(first.tags[0].key).toBe("itemId");
-      globalThis.expect(first.tags[0].value).toBe("x1");
-    });
-    globalThis.test("conditional append conflicts when the boundary already has an event", async () => {
-      let match = makeLog("dcb-cond");
-      let ops = match[1];
-      let mk = who => stored("Reserved", [{
-          key: "seatId",
-          value: "s1"
-        }], Object.fromEntries([[
-          "who",
-          who
-        ]]));
-      let r1 = await ops.append([mk("a")], undefined);
-      if (r1.TAG === "Ok") {
-        globalThis.expect(true).toBe(true);
-      } else {
-        globalThis.expect("first").toBe("ok");
-      }
-      let cond_query = [{
-          eventTypes: ["Reserved"],
-          tags: [{
-              key: "seatId",
-              value: "s1"
-            }]
-        }];
-      let cond = {
-        query: cond_query
-      };
-      let r2 = await ops.append([mk("b")], cond);
-      if (r2.TAG === "Ok") {
-        globalThis.expect("second").toBe("conflict");
-        return;
-      }
-      let tmp = r2._0;
-      if (typeof tmp !== "object") {
-        globalThis.expect(true).toBe(true);
-        return;
-      }
-      globalThis.expect("second").toBe("conflict");
-    });
-    let writeSkew = (strategy, logName) => {
-      globalThis.test(`write-skew: exactly one of two concurrent appends wins (` + logName + `)`, async () => {
-        let match = DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, logName, [], {
-          TAG: "Simple",
-          _0: {
-            key: "k"
-          }
-        }, undefined, opts, strategy, undefined);
-        let ops = match[1];
-        let cond_query = [{
-            eventTypes: ["Reserved"],
-            tags: [{
-                key: "seatId",
-                value: "hot"
-              }]
-          }];
-        let cond = {
-          query: cond_query
-        };
-        let mk = who => stored("Reserved", [{
-            key: "seatId",
-            value: "hot"
-          }], Object.fromEntries([[
-            "who",
-            who
-          ]]));
-        let p1 = ops.append([mk("a")], cond);
-        let p2 = ops.append([mk("b")], cond);
-        let r1 = await p1;
-        let r2 = await p2;
-        let isOk = r => r.TAG === "Ok";
-        let isConflict = r => Primitive_object.equal(r, {
-          TAG: "Error",
-          _0: "Conflict"
-        });
-        let oks = [
-          r1,
-          r2
-        ].filter(isOk).length;
-        let conflicts = [
-          r1,
-          r2
-        ].filter(isConflict).length;
-        globalThis.expect(oks).toBe(1);
-        globalThis.expect(conflicts).toBe(1);
-        let read = await ops.read([{
-            tags: [{
-                key: "seatId",
-                value: "hot"
-              }]
-          }], undefined);
-        globalThis.expect(read.events.length).toBe(1);
-      });
-    };
-    writeSkew("AdvisoryLocks", "dcb-skew-advisory");
-    writeSkew("RowLocks", "dcb-skew-rows");
-    globalThis.test("hot tag: N concurrent conditional appends, exactly one wins", async () => {
-      let match = makeLog("dcb-hot");
-      let ops = match[1];
-      let cond_query = [{
-          eventTypes: ["Claimed"],
-          tags: [{
-              key: "prizeId",
-              value: "p1"
-            }]
-        }];
-      let cond = {
-        query: cond_query
-      };
-      let promises = Stdlib_Array.make(12, 0).map((param, i) => ops.append([stored("Claimed", [{
-            key: "prizeId",
-            value: "p1"
-          }], Object.fromEntries([[
-            "who",
-            i
-          ]]))], cond));
-      let results = await Promise.all(promises);
-      let oks = results.filter(r => r.TAG === "Ok").length;
-      globalThis.expect(oks).toBe(1);
-      let read = await ops.read([{
-          tags: [{
-              key: "prizeId",
-              value: "p1"
-            }]
-        }], undefined);
-      globalThis.expect(read.events.length).toBe(1);
-    });
-    globalThis.test("cursors are monotonic and usable as `after`", async () => {
-      let match = makeLog("dcb-cursor");
-      let ops = match[1];
-      let mk = i => stored("Tick", [{
-          key: "streamId",
-          value: "c1"
-        }], Object.fromEntries([[
-          "i",
-          i
-        ]]));
-      await ops.append([mk(0)], undefined);
-      let pos = await ops.append([mk(1)], undefined);
-      let mid;
-      mid = pos.TAG === "Ok" ? pos._0 : "";
-      await ops.append([mk(2)], undefined);
-      let read = await ops.read([{
-          tags: [{
-              key: "streamId",
-              value: "c1"
-            }]
-        }], mid);
-      globalThis.expect(read.events.length).toBe(1);
-      globalThis.expect(read.events[0].eventType).toBe("Tick");
-    });
-  });
-  globalThis.describe("change feed", () => {
-    globalThis.test("drains all events and checkpoints", async () => {
-      let match = DcbEventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "feed-log", [], {
-        TAG: "Simple",
-        _0: {
-          key: "k"
-        }
-      }, undefined, opts, undefined, undefined);
-      let mk = i => stored("Fed", [{
-          key: "id",
-          value: "f"
-        }], Object.fromEntries([[
-          "i",
-          i
-        ]]));
-      await match[1].append([
-        mk(0),
-        mk(1),
-        mk(2)
-      ], undefined);
-      let collected = {
-        contents: 0
-      };
-      let processed = await PgChangeFeed$ReventlessPostgres.drain(pool, "feed-log", "sub-1", undefined, async evs => {
-        collected.contents = collected.contents + evs.length | 0;
-      });
-      globalThis.expect(processed).toBe(3);
-      globalThis.expect(collected.contents).toBe(3);
-      let again = await PgChangeFeed$ReventlessPostgres.drain(pool, "feed-log", "sub-1", undefined, async param => {});
-      globalThis.expect(again).toBe(0);
-    });
-  });
-  globalThis.describe("classic change feed (event_log, B2.5)", () => {
-    globalThis.test("drains classic events in commit order, with fields, then checkpoints", async () => {
-      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "cf-orders", opts, undefined);
-      let ops = match[1];
-      await ops.append(0, "agg-1", [
-        evJson("m0", 1),
-        evJson("m1", 2)
-      ]);
-      await ops.append(0, "agg-2", [evJson("m2", 3)]);
-      let collected = {
-        contents: []
-      };
-      let processed = await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-orders", "cf-sub", undefined, async evs => {
-        collected.contents = collected.contents.concat(evs);
-      });
-      globalThis.expect(processed).toBe(3);
-      globalThis.expect(collected.contents.length).toBe(3);
-      let first = collected.contents[0];
-      globalThis.expect(first.aggregateId).toBe("agg-1");
-      globalThis.expect(first.seqNr).toBe(0);
-      globalThis.expect(first.msgId).toEqual("m0");
-      let cursors = collected.contents.map(e => e.cursor);
-      let increasing = true;
-      for (let i = 1, i_finish = cursors.length; i < i_finish; ++i) {
-        if (cursors[i] <= cursors[i - 1 | 0]) {
-          increasing = false;
-        }
-      }
-      globalThis.expect(increasing).toBe(true);
-      let again = await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-orders", "cf-sub", undefined, async param => {});
-      globalThis.expect(again).toBe(0);
-    });
-    globalThis.test("concurrent appends across aggregates: every event drained exactly once", async () => {
-      let match = EventLogStorage_Postgres$ReventlessPostgres.makeStorage(pool, "cf-concurrent", opts, undefined);
-      let ops = match[1];
-      let promises = Stdlib_Array.make(20, 0).map((param, i) => ops.append(0, "agg-" + i.toString(), [evJson("m" + i.toString(), i)]));
-      await Promise.all(promises);
-      let collected = {
-        contents: []
-      };
-      await EventLogChangeFeed$ReventlessPostgres.drain(pool, "cf-concurrent", "cf-conc-sub", undefined, async evs => {
-        collected.contents = collected.contents.concat(evs);
-      });
-      globalThis.expect(collected.contents.length).toBe(20);
-      let distinctCursors = new Set(collected.contents.map(e => e.cursor));
-      globalThis.expect(distinctCursors.size).toBe(20);
-    });
-  });
-} else {
-  globalThis.test("Postgres integration (skipped — set PG_URL to run)", () => {
-    globalThis.expect(true).toBe(true);
-  });
-}
-
-export {
-  opts,
-  jsonObj,
-  stored,
-  evJson,
-}
-/* url Not a pure module */