@reventlessdev/reventless-postgres 3.0.0-alpha.6 → 3.0.0-alpha.60

package/lib/bs/src/QueryDbStorage_Postgres_Ops.res

@@ -0,0 +1,229 @@
+// Runtime-pure QueryDb operations for the Postgres backend — JSONB document
+// tables, one per read model.
+//
+// Holds the operation set + all SQL helpers and imports NO `@pulumi/pulumi`
+// (deploy-time only), so the deployed-Lambda runtime can bind ops without dragging
+// a deploy-time dep into its ESM import graph (which fails resolution on real
+// Lambda). The thin `QueryDbStorage_Postgres` wrapper `include`s this and adds the
+// deploy-time `Pulumi.Output`-shaped `storage` record + the `Make` functor.
+// See docs/plans/deployed-lambda-esm-self-containment.md (Rung-3 finding).
+
+open ReventlessCore
+open Reventless.ReadModel
+
+let tableName = (name: string): string => "qdb_" ++ name->String.replaceAll("-", "_")
+
+// Collapse anything outside [A-Za-z0-9_] to _ — predictable, injection-safe idents.
+let sanitizeIdent = (s: string): string =>
+  s->String.replaceRegExp(%re("/[^A-Za-z0-9_]/g"), "_")
+
+let notExpiredClause = "(expires_at IS NULL OR expires_at > extract(epoch from now()))"
+
+// JSONB text extraction for a single top-level field.
+let jsonField = (field: string): string =>
+  `(item->>'${field->String.replaceAll("'", "''")}')`
+
+let compositeExpr = (fields: array<string>, sep: string): string => {
+  let escapedSep = sep->String.replaceAll("'", "''")
+  fields->Array.map(jsonField)->Array.join(` || '${escapedSep}' || `)
+}
+
+let indexExpressions = (idx: indexConfig): (string, option<string>) => {
+  let pkExpr = switch idx.pkFields {
+  | Some(fields) if fields->Array.length > 0 => compositeExpr(fields, idx.pkSep->Option.getOr("/"))
+  | _ =>
+    switch idx.idField {
+    | Some(field) => jsonField(field)
+    | None => jsonField(idx.index)
+    }
+  }
+  let skExpr = switch idx.skFields {
+  | Some(fields) if fields->Array.length > 0 =>
+    Some(compositeExpr(fields, idx.skSep->Option.getOr("/")))
+  | _ =>
+    switch idx.subIdField {
+    | Some(field) => Some(jsonField(field))
+    | None => None
+    }
+  }
+  (pkExpr, skExpr)
+}
+
+let ensureTable = async (~pool, ~table) => {
+  await pool->PgDriver.exec(
+    `CREATE TABLE IF NOT EXISTS ${table} (partition_key text NOT NULL, sub_key text NOT NULL DEFAULT '', item jsonb NOT NULL, expires_at double precision, PRIMARY KEY (partition_key, sub_key))`,
+  )
+}
+
+let ensureIndexes = async (~pool, ~table, ~indexes: array<indexConfig>) => {
+  for i in 0 to indexes->Array.length - 1 {
+    let idx = indexes->Array.getUnsafe(i)
+    let (pkExpr, skExprOpt) = indexExpressions(idx)
+    let indexName = `idx_${table}_${sanitizeIdent(idx.index)}`
+    let cols = switch skExprOpt {
+    | Some(skExpr) => `${pkExpr}, ${skExpr}`
+    | None => pkExpr
+    }
+    await pool->PgDriver.exec(`CREATE INDEX IF NOT EXISTS ${indexName} ON ${table} (${cols})`)
+  }
+}
+
+let decodeItem = (row: dict<JSON.t>): JSON.t =>
+  row->Dict.get("item")->Option.getOr(JSON.Encode.null)
+
+let computeSubKey = (item: JSON.t, subIdField: option<string>): string =>
+  switch subIdField {
+  | None => ""
+  | Some(field) =>
+    switch item->JSON.Decode.object->Option.flatMap(o => o->Dict.get(field)) {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+  }
+
+let withId = (item: JSON.t, partitionKey: string): JSON.t =>
+  switch item->JSON.Decode.object {
+  | Some(obj) if obj->Dict.get("id")->Option.isNone =>
+    let copy = Dict.copy(obj)
+    copy->Dict.set("id", JSON.Encode.string(partitionKey))
+    JSON.Encode.object(copy)
+  | _ => item
+  }
+
+// Plain operation set for a read model's qdb table. Exposed separately from
+// `makeStorage` so the deployed-Lambda runtime (reventless-aws) can bind ops
+// without touching the Pulumi-shaped `storage` record.
+let makeOperations = (
+  ~pool: PgDriver.pool,
+  ~name: string,
+  ~indexes: array<indexConfig>,
+  ~subIdField: option<string>,
+): QueryDb_Adapter.operations => {
+  let table = tableName(name)
+  // Schema setup is async and LAZY: kicked off by the first operation, not at
+  // construction. A deploy-time caller may build the ops on a machine that
+  // cannot reach the database (VPC-private RDS) — only the runtime, which
+  // actually calls an operation, may open a connection. Subsequent operations
+  // await the same promise (table + index creation runs exactly once).
+  let readyRef: ref<option<promise<unit>>> = ref(None)
+  let ready = () =>
+    switch readyRef.contents {
+    | Some(p) => p
+    | None =>
+      let p = {
+        open Promise
+        ensureTable(~pool, ~table)->then(() => ensureIndexes(~pool, ~table, ~indexes))
+      }
+      readyRef := Some(p)
+      p
+    }
+
+  let rowsFor = async (id: string): array<JSON.t> => {
+    await ready()
+    (await pool->PgDriver.query(
+      `SELECT item FROM ${table} WHERE partition_key = $1 AND ${notExpiredClause} ORDER BY sub_key ASC`,
+      [JSON.Encode.string(id)],
+    ))->Array.map(decodeItem)
+  }
+
+  let saveOne = async (id: string, state: JSON.t, ttl: option<int>) => {
+    await ready()
+    let subKey = computeSubKey(state, subIdField)
+    let expiresAt = switch ttl {
+    | Some(t) => JSON.Encode.int(t)
+    | None => JSON.Encode.null
+    }
+    let _ = await pool->PgDriver.query(
+      `INSERT INTO ${table}(partition_key, sub_key, item, expires_at)
+       VALUES ($1, $2, $3::jsonb, $4)
+       ON CONFLICT (partition_key, sub_key)
+       DO UPDATE SET item = EXCLUDED.item, expires_at = EXCLUDED.expires_at`,
+      [
+        JSON.Encode.string(id),
+        JSON.Encode.string(subKey),
+        JSON.Encode.string(JSON.stringify(state)),
+        expiresAt,
+      ],
+    )
+  }
+
+  let load: QueryDb.load<string, JSON.t> = async id => Ok(await rowsFor(id))
+
+  let loadStream: QueryDb.loadStream<string, JSON.t> =
+    id =>
+      Effect.promise(() => rowsFor(id))
+      ->Stream.fromEffect
+      ->Stream.flatMap(arr => Stream.fromIterable(arr))
+
+  let save: QueryDb.save<string, JSON.t> = async (id, state, _saveMode, ttl) => {
+    await saveOne(id, state, ttl)
+    Ok()
+  }
+
+  let saveBatch: QueryDb.saveBatch<string, JSON.t> = async batch => {
+    // pg has no synchronous multi-statement transaction helper here; the upserts
+    // are independent (distinct keys) so a sequential apply is equivalent.
+    for i in 0 to batch->Array.length - 1 {
+      let (id, state, ttl) = batch->Array.getUnsafe(i)
+      await saveOne(id, state, ttl)
+    }
+    Ok()
+  }
+
+  // Mirror DynamoDB's `ADD #field :inc`: read the counter on the partition item
+  // (counters are single-state, sub_key=""), add inc, upsert, return NEW total.
+  let count: QueryDb.count<string> = async (id, fieldName, inc) => {
+    await ready()
+    let existing = (await rowsFor(id))->Array.get(0)->Option.flatMap(JSON.Decode.object)
+    let current =
+      existing
+      ->Option.flatMap(o => o->Dict.get(fieldName))
+      ->Option.flatMap(JSON.Decode.float)
+      ->Option.mapOr(0, Float.toInt)
+    let next = current + inc
+    let obj = switch existing {
+    | Some(o) => Dict.copy(o)
+    | None => Dict.make()
+    }
+    obj->Dict.set("id", JSON.Encode.string(id))
+    obj->Dict.set(fieldName, JSON.Encode.int(next))
+    await saveOne(id, JSON.Encode.object(obj), None)
+    Ok(next)
+  }
+
+  let delete: QueryDb.delete<string> = async (id, subIdOpt) => {
+    await ready()
+    let _ = switch subIdOpt {
+    | None =>
+      await pool->PgDriver.query(
+        `DELETE FROM ${table} WHERE partition_key = $1`,
+        [JSON.Encode.string(id)],
+      )
+    | Some((_, subValue)) =>
+      await pool->PgDriver.query(
+        `DELETE FROM ${table} WHERE partition_key = $1 AND sub_key = $2`,
+        [JSON.Encode.string(id), JSON.Encode.string(subValue)],
+      )
+    }
+    Ok()
+  }
+
+  let deleteBatch: QueryDb.deleteBatch<string> = async ids => {
+    for i in 0 to ids->Array.length - 1 {
+      let (id, subIdOpt) = ids->Array.getUnsafe(i)
+      let _ = await delete(id, subIdOpt)
+    }
+    Ok()
+  }
+
+  let ops: QueryDb_Adapter.operations = {
+    load,
+    loadStream,
+    save,
+    saveBatch,
+    count,
+    delete,
+    deleteBatch,
+  }
+  ops
+}

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

@@ -0,0 +1,222 @@
+// 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 Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+
+function tableName(name) {
+  return "qdb_" + name.replaceAll("-", "_");
+}
+
+function sanitizeIdent(s) {
+  return s.replace(/[^A-Za-z0-9_]/g, "_");
+}
+
+let notExpiredClause = "(expires_at IS NULL OR expires_at > extract(epoch from now()))";
+
+function jsonField(field) {
+  return `(item->>'` + field.replaceAll("'", "''") + `')`;
+}
+
+function compositeExpr(fields, sep) {
+  let escapedSep = sep.replaceAll("'", "''");
+  return fields.map(jsonField).join(` || '` + escapedSep + `' || `);
+}
+
+function indexExpressions(idx) {
+  let fields = idx.pkFields;
+  let pkExpr;
+  let exit = 0;
+  if (fields !== undefined && fields.length !== 0) {
+    pkExpr = compositeExpr(fields, Stdlib_Option.getOr(idx.pkSep, "/"));
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    let field = idx.idField;
+    pkExpr = field !== undefined ? jsonField(field) : jsonField(idx.index);
+  }
+  let fields$1 = idx.skFields;
+  let skExpr;
+  let exit$1 = 0;
+  if (fields$1 !== undefined && fields$1.length !== 0) {
+    skExpr = compositeExpr(fields$1, Stdlib_Option.getOr(idx.skSep, "/"));
+  } else {
+    exit$1 = 1;
+  }
+  if (exit$1 === 1) {
+    let field$1 = idx.subIdField;
+    skExpr = field$1 !== undefined ? jsonField(field$1) : undefined;
+  }
+  return [
+    pkExpr,
+    skExpr
+  ];
+}
+
+async function ensureTable(pool, table) {
+  return await PgDriver$ReventlessPostgres.exec(pool, `CREATE TABLE IF NOT EXISTS ` + table + ` (partition_key text NOT NULL, sub_key text NOT NULL DEFAULT '', item jsonb NOT NULL, expires_at double precision, PRIMARY KEY (partition_key, sub_key))`);
+}
+
+async function ensureIndexes(pool, table, indexes) {
+  for (let i = 0, i_finish = indexes.length; i < i_finish; ++i) {
+    let idx = indexes[i];
+    let match = indexExpressions(idx);
+    let skExprOpt = match[1];
+    let pkExpr = match[0];
+    let indexName = `idx_` + table + `_` + sanitizeIdent(idx.index);
+    let cols = skExprOpt !== undefined ? pkExpr + `, ` + skExprOpt : pkExpr;
+    await PgDriver$ReventlessPostgres.exec(pool, `CREATE INDEX IF NOT EXISTS ` + indexName + ` ON ` + table + ` (` + cols + `)`);
+  }
+}
+
+function decodeItem(row) {
+  return Stdlib_Option.getOr(row["item"], null);
+}
+
+function computeSubKey(item, subIdField) {
+  if (subIdField === undefined) {
+    return "";
+  }
+  let match = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), o => o[subIdField]);
+  if (typeof match === "string") {
+    return match;
+  } else {
+    return "";
+  }
+}
+
+function withId(item, partitionKey) {
+  let obj = Stdlib_JSON.Decode.object(item);
+  if (obj === undefined) {
+    return item;
+  }
+  if (!Stdlib_Option.isNone(obj["id"])) {
+    return item;
+  }
+  let copy = Object.assign({}, obj);
+  copy["id"] = partitionKey;
+  return copy;
+}
+
+function makeOperations(pool, name, indexes, subIdField) {
+  let table = tableName(name);
+  let readyRef = {
+    contents: undefined
+  };
+  let ready = () => {
+    let p = readyRef.contents;
+    if (p !== undefined) {
+      return p;
+    }
+    let p$1 = ensureTable(pool, table).then(() => ensureIndexes(pool, table, indexes));
+    readyRef.contents = p$1;
+    return p$1;
+  };
+  let rowsFor = async id => {
+    await ready();
+    return (await PgDriver$ReventlessPostgres.query(pool, `SELECT item FROM ` + table + ` WHERE partition_key = $1 AND ` + notExpiredClause + ` ORDER BY sub_key ASC`, [id])).map(decodeItem);
+  };
+  let saveOne = async (id, state, ttl) => {
+    await ready();
+    let subKey = computeSubKey(state, subIdField);
+    let expiresAt = ttl !== undefined ? ttl : null;
+    await PgDriver$ReventlessPostgres.query(pool, `INSERT INTO ` + table + `(partition_key, sub_key, item, expires_at)
+       VALUES ($1, $2, $3::jsonb, $4)
+       ON CONFLICT (partition_key, sub_key)
+       DO UPDATE SET item = EXCLUDED.item, expires_at = EXCLUDED.expires_at`, [
+      id,
+      subKey,
+      JSON.stringify(state),
+      expiresAt
+    ]);
+  };
+  let load = async id => ({
+    TAG: "Ok",
+    _0: await rowsFor(id)
+  });
+  let loadStream = id => Stream.flatMap(Stream.fromEffect(Effect.promise(() => rowsFor(id))), arr => Stream.fromIterable(arr));
+  let save = async (id, state, _saveMode, ttl) => {
+    await saveOne(id, state, ttl);
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  let saveBatch = async batch => {
+    for (let i = 0, i_finish = batch.length; i < i_finish; ++i) {
+      let match = batch[i];
+      await saveOne(match[0], match[1], match[2]);
+    }
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  let count = async (id, fieldName, inc) => {
+    await ready();
+    let existing = Stdlib_Option.flatMap((await rowsFor(id))[0], Stdlib_JSON.Decode.object);
+    let current = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(existing, o => o[fieldName]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
+    let next = current + inc | 0;
+    let obj = existing !== undefined ? Object.assign({}, existing) : ({});
+    obj["id"] = id;
+    obj[fieldName] = next;
+    await saveOne(id, obj, undefined);
+    return {
+      TAG: "Ok",
+      _0: next
+    };
+  };
+  let $$delete = async (id, subIdOpt) => {
+    await ready();
+    if (subIdOpt !== undefined) {
+      await PgDriver$ReventlessPostgres.query(pool, `DELETE FROM ` + table + ` WHERE partition_key = $1 AND sub_key = $2`, [
+        id,
+        subIdOpt[1]
+      ]);
+    } else {
+      await PgDriver$ReventlessPostgres.query(pool, `DELETE FROM ` + table + ` WHERE partition_key = $1`, [id]);
+    }
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  let deleteBatch = async ids => {
+    for (let i = 0, i_finish = ids.length; i < i_finish; ++i) {
+      let match = ids[i];
+      await $$delete(match[0], match[1]);
+    }
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  return {
+    load: load,
+    loadStream: loadStream,
+    save: save,
+    saveBatch: saveBatch,
+    count: count,
+    delete: $$delete,
+    deleteBatch: deleteBatch
+  };
+}
+
+export {
+  tableName,
+  sanitizeIdent,
+  notExpiredClause,
+  jsonField,
+  compositeExpr,
+  indexExpressions,
+  ensureTable,
+  ensureIndexes,
+  decodeItem,
+  computeSubKey,
+  withId,
+  makeOperations,
+}
+/* effect/Effect Not a pure module */

package/lib/bs/src/QueryEnginePostgres.res

@@ -63,18 +63,18 @@ let subIdSql = (b: paramBuilder, field: string, cmp: QueryEngine.SubId.comparato
   }
 }
 
-let notExpired = QueryDbStorage_Postgres.notExpiredClause
+let notExpired = QueryDbStorage_Postgres_Ops.notExpiredClause
 
 // Add `id` (from partition_key) when absent — matches allRows/scan in the SQLite
 // engine; partition-key queries return items as stored.
 let decodeRow = (~withId, row: dict<JSON.t>): JSON.t => {
-  let item = QueryDbStorage_Postgres.decodeItem(row)
+  let item = QueryDbStorage_Postgres_Ops.decodeItem(row)
   if withId {
     let pk = switch row->Dict.get("partition_key") {
     | Some(JSON.String(s)) => s
     | _ => ""
     }
-    QueryDbStorage_Postgres.withId(item, pk)
+    QueryDbStorage_Postgres_Ops.withId(item, pk)
   } else {
     item
   }
@@ -90,7 +90,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     ~ascending=?,
     ~limit=?,
   ): array<JSON.t> => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let keyStr = switch key {
     | Some(k) => k
     | None => valueToText(id)
@@ -114,7 +114,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
   }
 
   let scan = async (~readModelName, ~filterConfigs, ~limit): array<JSON.t> => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let b = {params: []}
     let where = [notExpired]
     filterConfigs->Array.forEach(((field, cmp, v)) => where->Array.push(filterSql(b, field, cmp, v)))
@@ -138,7 +138,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
   // (`ensureIndexes`) instead of scanning. String comparison mirrors the
   // resolver's JS path (which only matched string-typed fields).
   let indexLookup = async (~readModelName, field: string, value: string): array<JSON.t> => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let b = {params: []}
     let sql = `SELECT partition_key, item FROM ${table} WHERE ${col(field)} = ${b->param(
         JSON.Encode.string(value),
@@ -154,7 +154,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     if ids->Array.length == 0 {
       []
     } else {
-      let table = QueryDbStorage_Postgres.tableName(readModelName)
+      let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
       let b = {params: []}
       let idsJson = JSON.Encode.array(ids->Array.map(JSON.Encode.string))
       let sql = `SELECT partition_key, item FROM ${table} WHERE partition_key = ANY(${b->param(
@@ -184,7 +184,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     ~capability: GraphQL_FragmentGenerator.serverCapability,
     ~labelField as _,
   ): option<JSON.t> => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let filterDict =
       argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
     let strNonEmpty = k =>
@@ -310,7 +310,7 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     ~id: string,
     ~argsDict: dict<JSON.t>,
   ): JSON.t => {
-    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let table = QueryDbStorage_Postgres_Ops.tableName(readModelName)
     let filterDict =
       argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
     let fstr = k => filterDict->Dict.get(k)->Option.flatMap(JSON.Decode.string)
@@ -380,7 +380,4 @@ module Make = (P: {let pool: PgDriver.pool}) => {
       },
     })
   }
-
-  let make: QueryDb_Adapter.queryEngineMaker = _allQueryDbs =>
-    Pulumi.Output.make({QueryEngine.scan, query})
 }

package/lib/bs/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 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,7 @@ function Make(P) {
     let b = {
       params: []
     };
-    let whereParts = [QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause];
+    let whereParts = [QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause];
     let valString = v => {
       let s = Stdlib_JSON.Decode.string(v);
       if (s !== undefined) {
@@ -233,7 +232,7 @@ function Make(P) {
     return QueryDbListQuery$ReventlessCore.buildConnection(pageItems, hasMore, false, cursorValueOf);
   };
   let itemsPage = async (readModelName, param$1, id, argsDict) => {
-    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    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,7 +247,7 @@ function Make(P) {
     };
     let where = [
       `partition_key = ` + param(b, id),
-      QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause
+      QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause
     ];
     Stdlib_Option.forEach(fstr("prefix"), p => {
       where.push(`starts_with(sub_key, ` + param(b, p) + `)`);
@@ -304,10 +303,6 @@ function Make(P) {
       }
     };
   };
-  let make = _allQueryDbs => Pulumi.output({
-    scan: scan,
-    query: query
-  });
   return {
     query: query,
     scan: scan,
@@ -316,12 +311,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 +328,4 @@ export {
   decodeRow,
   Make,
 }
-/* @pulumi/pulumi Not a pure module */
+/* PgDriver-ReventlessPostgres Not a pure module */