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

package/src/QueryDbStorage_Postgres.res

@@ -1,239 +1,16 @@
-// Postgres-backed QueryDb storage — JSONB document tables, one per read model.
+// Deploy/local wrapper over the runtime-pure QueryDbStorage_Postgres_Ops.
 //
-// Implements the clean QueryDb_Adapter.storageMaker (the shape
-// QueryDbStorage_DynamoDb implements): no in-process bus. The reventless-local
-// bridge that publishes state-changes to live GraphQL subscriptions wraps this
-// at integration time (Phase E), the way QueryDbStorage_Sqlite wraps its data
-// access today.
-//
-// Table `qdb_<name>`: partition_key text, sub_key text, item jsonb, expires_at
-// double precision (unix epoch seconds; null = never), PRIMARY KEY
-// (partition_key, sub_key). `item jsonb` returns already parsed. TTL is lazy —
-// every read carries `(expires_at IS NULL OR expires_at > epoch_now)`.
-//
-// GSI: each declared indexConfig becomes an expression index on `item->>'field'`
-// (composite keys concatenated with the configured separator). projectionType is
-// irrelevant in a relational store (every column is on the same row).
+// `makeOperations` + all SQL helpers live in QueryDbStorage_Postgres_Ops, which
+// imports NO `@pulumi/pulumi` so the deployed-Lambda runtime binds ops without
+// dragging a deploy-time dep into its ESM import graph. This module `include`s
+// that pure module (so every existing `QueryDbStorage_Postgres.*` reference keeps
+// working) and adds only the deploy-time `Pulumi.Output`-shaped `storage` record
+// and the `Make` provider 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
-}
+include QueryDbStorage_Postgres_Ops
 
 let makeStorage = (
   ~pool: PgDriver.pool,
@@ -260,6 +37,6 @@ module Make = (P: {let pool: PgDriver.pool}) => {
     ~ttl as _=?,
     ~api as _,
     ~apiRole as _,
-    ~opts as _,
+    ~owner as _, ~opts as _,
   ) => makeStorage(~pool=P.pool, ~name, ~indexes, ~subIdField)
 }

package/src/QueryDbStorage_Postgres.res.mjs

@@ -1,225 +1,46 @@
 // 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 Pulumi from "@pulumi/pulumi";
-import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+import * as QueryDbStorage_Postgres_Ops$ReventlessPostgres from "./QueryDbStorage_Postgres_Ops.res.mjs";
 
-function tableName(name) {
-  return "qdb_" + name.replaceAll("-", "_");
+function makeStorage(pool, name, indexes, subIdField) {
+  return {
+    resources: [],
+    dataSourceName: Pulumi.output(""),
+    operations: Pulumi.output(QueryDbStorage_Postgres_Ops$ReventlessPostgres.makeOperations(pool, name, indexes, subIdField))
+  };
 }
 
-function sanitizeIdent(s) {
-  return s.replace(/[^A-Za-z0-9_]/g, "_");
+function Make(P) {
+  let make = (name, indexes, subIdField, param, param$1, param$2, param$3, param$4) => makeStorage(P.pool, name, indexes, subIdField);
+  return {
+    make: make
+  };
 }
 
-let notExpiredClause = "(expires_at IS NULL OR expires_at > extract(epoch from now()))";
+let tableName = QueryDbStorage_Postgres_Ops$ReventlessPostgres.tableName;
 
-function jsonField(field) {
-  return `(item->>'` + field.replaceAll("'", "''") + `')`;
-}
+let sanitizeIdent = QueryDbStorage_Postgres_Ops$ReventlessPostgres.sanitizeIdent;
 
-function compositeExpr(fields, sep) {
-  let escapedSep = sep.replaceAll("'", "''");
-  return fields.map(jsonField).join(` || '` + escapedSep + `' || `);
-}
+let notExpiredClause = QueryDbStorage_Postgres_Ops$ReventlessPostgres.notExpiredClause;
 
-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
-  ];
-}
+let jsonField = QueryDbStorage_Postgres_Ops$ReventlessPostgres.jsonField;
 
-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))`);
-}
+let compositeExpr = QueryDbStorage_Postgres_Ops$ReventlessPostgres.compositeExpr;
 
-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 + `)`);
-  }
-}
+let indexExpressions = QueryDbStorage_Postgres_Ops$ReventlessPostgres.indexExpressions;
 
-function decodeItem(row) {
-  return Stdlib_Option.getOr(row["item"], null);
-}
+let ensureTable = QueryDbStorage_Postgres_Ops$ReventlessPostgres.ensureTable;
 
-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 "";
-  }
-}
+let ensureIndexes = QueryDbStorage_Postgres_Ops$ReventlessPostgres.ensureIndexes;
 
-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;
-}
+let decodeItem = QueryDbStorage_Postgres_Ops$ReventlessPostgres.decodeItem;
 
-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
-  };
-}
+let computeSubKey = QueryDbStorage_Postgres_Ops$ReventlessPostgres.computeSubKey;
 
-function makeStorage(pool, name, indexes, subIdField) {
-  return {
-    resources: [],
-    dataSourceName: Pulumi.output(""),
-    operations: Pulumi.output(makeOperations(pool, name, indexes, subIdField))
-  };
-}
+let withId = QueryDbStorage_Postgres_Ops$ReventlessPostgres.withId;
 
-function Make(P) {
-  let make = (name, indexes, subIdField, param, param$1, param$2, param$3) => makeStorage(P.pool, name, indexes, subIdField);
-  return {
-    make: make
-  };
-}
+let makeOperations = QueryDbStorage_Postgres_Ops$ReventlessPostgres.makeOperations;
 
 export {
   tableName,
@@ -237,4 +58,4 @@ export {
   makeStorage,
   Make,
 }
-/* effect/Effect Not a pure module */
+/* @pulumi/pulumi Not a pure module */