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

package/lib/bs/src/QueryEnginePostgres.res.mjs

@@ -1,9 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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 QueryDbStorage_Postgres$ReventlessPostgres from "./QueryDbStorage_Postgres.res.mjs";
+import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
+import * as QueryDbStorage_Postgres_Ops$ReventlessPostgres from "./QueryDbStorage_Postgres_Ops.res.mjs";
 
 function valueToText(v) {
   switch (v.TAG) {
@@ -102,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]));
@@ -134,29 +136,192 @@ 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]));
     });
     let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + where.join(" AND ") + ` ORDER BY partition_key, sub_key LIMIT ` + param(b, limit);
     return (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
   };
-  let make = _allQueryDbs => Pulumi.output({
-    scan: scan,
-    query: query
-  });
+  let indexLookup = async (readModelName, field, value) => {
+    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_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_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_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, 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);
+    let last = Stdlib_Option.flatMap(argsDict["last"], Stdlib_JSON.Decode.float);
+    let before = Stdlib_Option.flatMap(argsDict["before"], Stdlib_JSON.Decode.string);
+    if (strNonEmpty("search") || strNonEmpty("searchPrefix") || hasIds || Stdlib_Option.isSome(last) || Stdlib_Option.isSome(before)) {
+      return;
+    }
+    let b = {
+      params: []
+    };
+    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) {
+        return s;
+      } else {
+        return Stdlib_Option.map(Stdlib_JSON.Decode.float(v), f => f.toString());
+      }
+    };
+    capability.filterFields.forEach(f => {
+      let v = filterDict[f.name + "Eq"];
+      if (v !== undefined && v !== null) {
+        whereParts.push(jsonTextC(f.name) + ` = ` + param(b, Stdlib_Option.getOr(valString(v), "")));
+      }
+      if (!f.range) {
+        return;
+      }
+      let v$1 = filterDict[f.name + "From"];
+      if (v$1 !== undefined && v$1 !== null) {
+        whereParts.push(jsonTextC(f.name) + ` >= ` + param(b, Stdlib_Option.getOr(valString(v$1), "")));
+      }
+      let v$2 = filterDict[f.name + "To"];
+      if (v$2 !== undefined && v$2 !== null) {
+        whereParts.push(jsonTextC(f.name) + ` <= ` + param(b, Stdlib_Option.getOr(valString(v$2), "")));
+        return;
+      }
+    });
+    let orderByDict = Stdlib_Option.flatMap(argsDict["orderBy"], Stdlib_JSON.Decode.object);
+    let orderByField = Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["field"]), Stdlib_JSON.Decode.string);
+    let isDesc = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["direction"]), Stdlib_JSON.Decode.string), "ASC") === "DESC";
+    let cursorExpr = orderByField !== undefined ? jsonTextC(orderByField) : idExprC;
+    let c = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+    if (c !== undefined) {
+      whereParts.push(cursorExpr + ` ` + (
+        isDesc ? "<" : ">"
+      ) + ` ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(c)));
+    }
+    let orderClause = orderByField !== undefined ? jsonTextC(orderByField) + ` ` + (
+        isDesc ? "DESC" : "ASC"
+      ) + `, ` + idExprC + ` ASC` : idExprC + ` ASC`;
+    let pageSize = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0), QueryDbListQuery$ReventlessCore.defaultListPageSize);
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + whereParts.join(" AND ") + ` ORDER BY ` + orderClause + ` LIMIT ` + param(b, pageSize + 1 | 0);
+    let rows = (await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params)).map(extra => decodeRow(true, extra));
+    let hasMore = rows.length > pageSize;
+    let pageItems = rows.slice(0, pageSize);
+    let cursorField = Stdlib_Option.getOr(orderByField, "id");
+    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, 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");
+    let last = Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["last"], Stdlib_JSON.Decode.float), prim => prim | 0);
+    let first = Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0);
+    let after = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+    let before = Stdlib_Option.flatMap(argsDict["before"], Stdlib_JSON.Decode.string);
+    let isBackward = Stdlib_Option.isSome(last);
+    let sk = `sub_key COLLATE "C"`;
+    let b = {
+      params: []
+    };
+    let where = [
+      `partition_key = ` + param(b, id),
+      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) + `)`);
+    });
+    Stdlib_Option.forEach(fstr("from"), f => {
+      where.push(sk + ` >= ` + param(b, f));
+    });
+    Stdlib_Option.forEach(fstr("to"), t => {
+      where.push(sk + ` <= ` + param(b, t));
+    });
+    Stdlib_Option.forEach(fstr("eq"), e => {
+      where.push(sk + ` = ` + param(b, e));
+    });
+    if (isBackward) {
+      if (before !== undefined) {
+        where.push(sk + ` < ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(before)));
+      }
+    } else if (after !== undefined) {
+      where.push(sk + ` > ` + param(b, QueryDbListQuery$ReventlessCore.decodeCursor(after)));
+    }
+    let fetchDesc = isBackward ? !orderDesc : orderDesc;
+    let pageSize = Stdlib_Option.getOr(isBackward ? last : first, QueryDbListQuery$ReventlessCore.defaultListPageSize);
+    let sql = `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE ` + where.join(" AND ") + ` ORDER BY ` + sk + ` ` + (
+      fetchDesc ? "DESC" : "ASC"
+    ) + ` LIMIT ` + param(b, pageSize + 1 | 0);
+    let rows = await PgDriver$ReventlessPostgres.query(P.pool, sql, b.params);
+    let hasMore = rows.length > pageSize;
+    let taken = rows.slice(0, pageSize);
+    let logical = isBackward ? taken.toReversed() : taken;
+    let pageItems = logical.map(extra => decodeRow(false, extra));
+    let subKeyOf = row => {
+      let match = row["sub_key"];
+      if (typeof match === "string") {
+        return match;
+      } else {
+        return "";
+      }
+    };
+    let cursors = logical.map(subKeyOf);
+    let edges = pageItems.map((item, i) => ({
+      node: item,
+      cursor: QueryDbListQuery$ReventlessCore.encodeCursor(cursors[i])
+    }));
+    let startCursor = Stdlib_Option.map(cursors[0], QueryDbListQuery$ReventlessCore.encodeCursor);
+    let endCursor = Stdlib_Option.map(cursors[cursors.length - 1 | 0], QueryDbListQuery$ReventlessCore.encodeCursor);
+    return {
+      edges: edges,
+      pageInfo: {
+        hasNextPage: !isBackward && hasMore,
+        hasPreviousPage: isBackward && hasMore,
+        startCursor: Stdlib_Nullable.fromOption(startCursor),
+        endCursor: Stdlib_Nullable.fromOption(endCursor)
+      }
+    };
+  };
   return {
     query: query,
     scan: scan,
-    make: make
+    indexLookup: indexLookup,
+    byIds: byIds,
+    idExprC: idExprC,
+    jsonTextC: jsonTextC,
+    listPage: listPage,
+    itemsPage: itemsPage
   };
 }
 
-let notExpired = QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+let notExpired = QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause;
 
 export {
   valueToText,
@@ -169,4 +334,4 @@ export {
   decodeRow,
   Make,
 }
-/* @pulumi/pulumi Not a pure module */
+/* PgDriver-ReventlessPostgres Not a pure module */

package/lib/bs/tests/PostgresIntegrationTest.res

@@ -233,4 +233,72 @@ switch processEnv->Dict.get("PG_URL") {
       expect(again)->toBe(0)
     })
   })
+
+  describe("classic change feed (event_log, B2.5)", () => {
+    testPromise("drains classic events in commit order, with fields, then checkpoints", async () => {
+      let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(~pool, ~name="cf-orders", ~opts)
+      let _ = await ops.append(0, "agg-1", [evJson("m0", 1), evJson("m1", 2)])
+      let _ = await ops.append(0, "agg-2", [evJson("m2", 3)])
+
+      let collected = ref([])
+      let processed = await EventLogChangeFeed.drain(
+        pool,
+        ~logName="cf-orders",
+        ~subscriber="cf-sub",
+        ~handle=async evs => collected := collected.contents->Array.concat(evs),
+      )
+      expect(processed)->toBe(3)
+      expect(collected.contents->Array.length)->toBe(3)
+
+      // Fields round-trip from the stored row.
+      let first = collected.contents->Array.getUnsafe(0)
+      expect(first.aggregateId)->toBe("agg-1")
+      expect(first.seqNr)->toBe(0)
+      expect(first.msgId)->toEqual(Some("m0"))
+
+      // Cursors are strictly increasing in drain order.
+      let cursors = collected.contents->Array.map(e => e.cursor)
+      let increasing = ref(true)
+      for i in 1 to cursors->Array.length - 1 {
+        if cursors->Array.getUnsafe(i) <= cursors->Array.getUnsafe(i - 1) {
+          increasing := false
+        }
+      }
+      expect(increasing.contents)->toBe(true)
+
+      // Second drain from the saved checkpoint sees nothing new.
+      let again = await EventLogChangeFeed.drain(
+        pool,
+        ~logName="cf-orders",
+        ~subscriber="cf-sub",
+        ~handle=async _ => (),
+      )
+      expect(again)->toBe(0)
+    })
+
+    testPromise("concurrent appends across aggregates: every event drained exactly once", async () => {
+      let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(~pool, ~name="cf-concurrent", ~opts)
+      let n = 20
+      // One event per aggregate, all dispatched before awaiting — genuinely
+      // concurrent on the pool, so global_seq is assigned in interleaved/undefined
+      // commit order. The xmin fence must still drain every event exactly once.
+      let promises =
+        Array.make(~length=n, 0)->Array.mapWithIndex((_, i) =>
+          ops.append(0, "agg-" ++ Int.toString(i), [evJson("m" ++ Int.toString(i), i)])
+        )
+      let _ = await Promise.all(promises)
+
+      let collected = ref([])
+      let _ = await EventLogChangeFeed.drain(
+        pool,
+        ~logName="cf-concurrent",
+        ~subscriber="cf-conc-sub",
+        ~handle=async evs => collected := collected.contents->Array.concat(evs),
+      )
+      // No skips: all N events present. No dupes: N distinct cursors.
+      expect(collected.contents->Array.length)->toBe(n)
+      let distinctCursors = collected.contents->Array.map(e => e.cursor)->Set.fromArray
+      expect(distinctCursors->Set.size)->toBe(n)
+    })
+  })
 }

package/lib/bs/tests/PostgresIntegrationTest.res.mjs

@@ -6,6 +6,7 @@ import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Mess
 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";
 
@@ -313,6 +314,54 @@ if (url !== undefined) {
       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);