@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res

@@ -0,0 +1,339 @@
+// SQLite-backed QueryDb storage.
+//
+// One table per registered QueryDb (`qdb_<name>`). Columns:
+//   partition_key TEXT
+//   sub_key       TEXT
+//   item          TEXT (JSON.stringify of the item)
+//   expires_at    INTEGER NULL (unix epoch seconds; null = never expires)
+//   PRIMARY KEY (partition_key, sub_key)
+//
+// TTL: every read clause carries `(expires_at IS NULL OR expires_at > <now>)`.
+// Lazy expiry — no background sweeper. Expired rows linger on disk until they
+// are next read (where they are filtered out) or overwritten by a new save.
+//
+// GSI: each declared `indexConfig` creates a SQLite index on the JSON column
+// using `json_extract(item, '$.<field>')`. Composite keys (`pkFields` /
+// `skFields` joined by `pkSep`/`skSep`) become a single computed expression.
+// The DynamoDB `projectionType` is recorded for documentation but the SQLite
+// covering-index distinction is irrelevant — every column is on the same row.
+
+open ReventlessCore
+open Reventless.ReadModel
+
+let tableName = (name: string): string => "qdb_" ++ name->String.replaceAll("-", "_")
+
+// SQL identifier sanitisation — collapse anything outside [A-Za-z0-9_] to _.
+// Keeps generated index names predictable and injection-safe.
+let sanitizeIdent = (s: string): string =>
+  s
+  ->String.split("")
+  ->Array.map(ch => {
+    let code = ch->String.codePointAt(0)->Option.getOr(0)
+    let isAlphaNum =
+      (code >= 48 && code <= 57) ||
+      (code >= 65 && code <= 90) ||
+      (code >= 97 && code <= 122) ||
+      code == 95
+    isAlphaNum ? ch : "_"
+  })
+  ->Array.join("")
+
+let ensureSchema = (~db, ~table) =>
+  db->SqliteDriver.exec(
+    `CREATE TABLE IF NOT EXISTS ${table} (partition_key TEXT NOT NULL, sub_key TEXT NOT NULL DEFAULT '', item TEXT NOT NULL, expires_at INTEGER, PRIMARY KEY (partition_key, sub_key))`,
+  )
+
+// Best-effort migration for tables created by an earlier (Phase 2) version
+// that did not have the expires_at column. Safe no-op when column already
+// exists. Wrapped in try/catch since some sqlite versions throw on duplicate.
+let ensureExpiresColumn = (~db, ~table) =>
+  try db->SqliteDriver.exec(`ALTER TABLE ${table} ADD COLUMN expires_at INTEGER`) catch {
+  | _ => ()
+  }
+
+// Build the json_extract expression for a single field path.
+let jsonField = (field: string): string => `json_extract(item, '$.${field}')`
+
+// Composite-key indexes are concatenations: json_extract(...) || sep || json_extract(...) || ...
+let compositeExpr = (fields: array<string>, sep: string): string => {
+  let escapedSep = sep->String.replaceAll("'", "''")
+  fields->Array.map(jsonField)->Array.join(` || '${escapedSep}' || `)
+}
+
+// Determine the index's partition expression and (optional) sort expression.
+// Uses pkFields if present, else falls back to idField; same for sub key.
+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)
+}
+
+// Create one SQLite index per declared GSI. Idempotent via IF NOT EXISTS.
+let ensureIndexes = (~db, ~table, ~indexes: array<indexConfig>) =>
+  indexes->Array.forEach(idx => {
+    let (pkExpr, skExprOpt) = indexExpressions(idx)
+    let indexName = `idx_${table}_${sanitizeIdent(idx.index)}`
+    let cols = switch skExprOpt {
+    | Some(skExpr) => `${pkExpr}, ${skExpr}`
+    | None => pkExpr
+    }
+    db->SqliteDriver.exec(`CREATE INDEX IF NOT EXISTS ${indexName} ON ${table} (${cols})`)
+  })
+
+let decodeItem = (row: dict<JSON.t>): JSON.t =>
+  switch row->Dict.get("item") {
+  | Some(JSON.String(s)) =>
+    switch JSON.parseOrThrow(s) {
+    | json => json
+    | exception _ => JSON.Encode.null
+    }
+  | _ => JSON.Encode.null
+  }
+
+let computeSubKey = (item: JSON.t, subIdField: option<string>): string =>
+  switch subIdField {
+  | None => ""
+  | Some(field) =>
+    switch item->JSON.Decode.object {
+    | Some(obj) =>
+      switch obj->Dict.get(field) {
+      | Some(JSON.String(s)) => s
+      | _ => ""
+      }
+    | None => ""
+    }
+  }
+
+let withId = (item: JSON.t, partitionKey: string): JSON.t =>
+  switch item->JSON.Decode.object {
+  | Some(obj) =>
+    if obj->Dict.get("id")->Option.isSome {
+      item
+    } else {
+      let copy = Dict.make()
+      obj->Dict.toArray->Array.forEach(((k, v)) => copy->Dict.set(k, v))
+      copy->Dict.set("id", JSON.Encode.string(partitionKey))
+      JSON.Encode.object(copy)
+    }
+  | None => item
+  }
+
+type busCallbacks = {
+  publishStateChange: (~name: string, ~descriptor: JSON.t) => unit,
+  registerQueryDb: (string, QueryDb_Adapter.operations) => unit,
+  registerQueryDbScan: (string, unit => array<JSON.t>) => unit,
+  registerQueryDbStream: (string, unit => Stream.t<JSON.t, string, unit>) => unit,
+}
+
+// SQL fragment that excludes expired rows. Uses unix-epoch seconds via
+// strftime; SQLite evaluates it on every row, which is fine at dev scale.
+let notExpiredClause = "(expires_at IS NULL OR expires_at > strftime('%s','now'))"
+
+let makeStorage = (
+  ~db: SqliteDriver.t,
+  ~bus: busCallbacks,
+  ~name,
+  ~indexes: array<indexConfig>,
+  ~subIdField: option<string>,
+): QueryDb_Adapter.storage => {
+  let table = tableName(name)
+  ensureSchema(~db, ~table)
+  ensureExpiresColumn(~db, ~table)
+  ensureIndexes(~db, ~table, ~indexes)
+
+  let upsertStmt = db->SqliteDriver.prepare(
+    `INSERT INTO ${table}(partition_key, sub_key, item, expires_at) VALUES(?,?,?,?) ON CONFLICT(partition_key, sub_key) DO UPDATE SET item = excluded.item, expires_at = excluded.expires_at`,
+  )
+  let selectByPartitionStmt = db->SqliteDriver.prepare(
+    `SELECT partition_key, sub_key, item FROM ${table} WHERE partition_key = ? AND ${notExpiredClause} ORDER BY sub_key ASC`,
+  )
+  let deleteByPartitionStmt = db->SqliteDriver.prepare(
+    `DELETE FROM ${table} WHERE partition_key = ?`,
+  )
+  let deleteBySubKeyStmt = db->SqliteDriver.prepare(
+    `DELETE FROM ${table} WHERE partition_key = ? AND sub_key = ?`,
+  )
+  let scanAllStmt = db->SqliteDriver.prepare(
+    `SELECT partition_key, sub_key, item FROM ${table} WHERE ${notExpiredClause} ORDER BY partition_key, sub_key`,
+  )
+
+  let rowsFor = (id: string): array<JSON.t> =>
+    selectByPartitionStmt
+    ->SqliteDriver.all([JSON.Encode.string(id)])
+    ->Array.map(decodeItem)
+
+  let allRows = (): array<JSON.t> =>
+    scanAllStmt
+    ->SqliteDriver.all([])
+    ->Array.map(row => {
+      let item = decodeItem(row)
+      let partition = switch row->Dict.get("partition_key") {
+      | Some(JSON.String(s)) => s
+      | _ => ""
+      }
+      withId(item, partition)
+    })
+
+  let saveOne = (id: string, state: JSON.t, ttl: option<int>) => {
+    let subKey = computeSubKey(state, subIdField)
+    let expiresAt = switch ttl {
+    | Some(t) => JSON.Encode.int(t)
+    | None => JSON.Encode.null
+    }
+    upsertStmt->SqliteDriver.run([
+      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(rowsFor(id))
+
+  let loadStream: QueryDb.loadStream<string, JSON.t> = id => rowsFor(id)->Stream.fromIterable
+
+  // Entity key matches the AWS StateTopic Lambda output (Phase 1):
+  // single-key tables → partition value; composite tables → `pk-sk`.
+  let entityKeyFor = (id: string, subKey: string): string =>
+    switch subIdField {
+    | Some(_) => id ++ "-" ++ subKey
+    | None => id
+    }
+
+  let publishUpdated = (id: string, state: JSON.t) => {
+    let subKey = computeSubKey(state, subIdField)
+    let descriptor = LocalBus.makeStateChangeDescriptor(
+      ~changeKind="Updated",
+      ~id=entityKeyFor(id, subKey),
+      ~state=Some(state),
+    )
+    bus.publishStateChange(~name, ~descriptor)
+  }
+
+  let publishRemoved = (id: string, subKey: string) => {
+    let descriptor = LocalBus.makeStateChangeDescriptor(
+      ~changeKind="Removed",
+      ~id=entityKeyFor(id, subKey),
+      ~state=None,
+    )
+    bus.publishStateChange(~name, ~descriptor)
+  }
+
+  // Read all (id, sub_key) tuples that a partition-level delete would remove.
+  let rowKeysForPartition = (id: string): array<string> =>
+    selectByPartitionStmt
+    ->SqliteDriver.all([JSON.Encode.string(id)])
+    ->Array.map(row =>
+      switch row->Dict.get("sub_key") {
+      | Some(JSON.String(s)) => s
+      | _ => ""
+      }
+    )
+
+  let save: QueryDb.save<string, JSON.t> = async (id, state, _saveMode, ttl) => {
+    saveOne(id, state, ttl)
+    publishUpdated(id, state)
+    Ok()
+  }
+
+  let saveBatch: QueryDb.saveBatch<string, JSON.t> = async batch => {
+    db->SqliteDriver.transaction(() =>
+      batch->Array.forEach(((id, state, ttl)) => saveOne(id, state, ttl))
+    )
+    batch->Array.forEach(((id, state, _)) => publishUpdated(id, state))
+    Ok()
+  }
+
+  let count: QueryDb.count<string> = async (_id, _fieldName, inc) => Ok(inc)
+
+  let deleteOne = (id: string, subIdOpt) =>
+    switch subIdOpt {
+    | None => deleteByPartitionStmt->SqliteDriver.run([JSON.Encode.string(id)])
+    | Some((_, subValue)) =>
+      deleteBySubKeyStmt->SqliteDriver.run([
+        JSON.Encode.string(id),
+        JSON.Encode.string(subValue),
+      ])
+    }
+
+  let delete: QueryDb.delete<string> = async (id, subIdOpt) => {
+    let removedSubKeys = switch subIdOpt {
+    | None => rowKeysForPartition(id)
+    | Some((_, subValue)) => [subValue]
+    }
+    deleteOne(id, subIdOpt)
+    removedSubKeys->Array.forEach(sk => publishRemoved(id, sk))
+    Ok()
+  }
+
+  let deleteBatch: QueryDb.deleteBatch<string> = async ids => {
+    let removed: array<(string, string)> = []
+    ids->Array.forEach(((id, subIdOpt)) => {
+      switch subIdOpt {
+      | None => rowKeysForPartition(id)->Array.forEach(sk => removed->Array.push((id, sk)))
+      | Some((_, subValue)) => removed->Array.push((id, subValue))
+      }
+    })
+    db->SqliteDriver.transaction(() => ids->Array.forEach(((id, s)) => deleteOne(id, s)))
+    removed->Array.forEach(((id, sk)) => publishRemoved(id, sk))
+    Ok()
+  }
+
+  let ops: QueryDb_Adapter.operations = {
+    load,
+    loadStream,
+    save,
+    saveBatch,
+    count,
+    delete,
+    deleteBatch,
+  }
+
+  bus.registerQueryDb(name, ops)
+  bus.registerQueryDbScan(name, () => allRows())
+  bus.registerQueryDbStream(name, () => allRows()->Stream.fromIterable)
+
+  {
+    resources: [],
+    dataSourceName: ""->Pulumi.Output.make,
+    operations: Pulumi.Output.make(ops),
+  }
+}
+
+module Make = (Bus: LocalBus.T, DbProvider: {let db: SqliteDriver.t}) => {
+  type api = unit
+  type role = unit
+
+  let busCallbacks = {
+    publishStateChange: Bus.publishStateChange,
+    registerQueryDb: Bus.registerQueryDb,
+    registerQueryDbScan: Bus.registerQueryDbScan,
+    registerQueryDbStream: Bus.registerQueryDbStream,
+  }
+
+  let make: QueryDb_Adapter.storageMaker<unit, unit> = (
+    ~name,
+    ~indexes,
+    ~subIdField=?,
+    ~ttl as _=?,
+    ~api as _,
+    ~apiRole as _,
+    ~opts as _,
+  ) => makeStorage(~db=DbProvider.db, ~bus=busCallbacks, ~name, ~indexes, ~subIdField)
+}

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs

@@ -0,0 +1,318 @@
+// 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 Stream from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as LocalBus$ReventlessLocal from "../LocalBus.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+
+function tableName(name) {
+  return "qdb_" + name.replaceAll("-", "_");
+}
+
+function sanitizeIdent(s) {
+  return s.split("").map(ch => {
+    let code = Stdlib_Option.getOr(ch.codePointAt(0), 0);
+    let isAlphaNum = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95;
+    if (isAlphaNum) {
+      return ch;
+    } else {
+      return "_";
+    }
+  }).join("");
+}
+
+function ensureSchema(db, table) {
+  SqliteDriver$ReventlessLocal.exec(db, `CREATE TABLE IF NOT EXISTS ` + table + ` (partition_key TEXT NOT NULL, sub_key TEXT NOT NULL DEFAULT '', item TEXT NOT NULL, expires_at INTEGER, PRIMARY KEY (partition_key, sub_key))`);
+}
+
+function ensureExpiresColumn(db, table) {
+  try {
+    return SqliteDriver$ReventlessLocal.exec(db, `ALTER TABLE ` + table + ` ADD COLUMN expires_at INTEGER`);
+  } catch (exn) {
+    return;
+  }
+}
+
+function jsonField(field) {
+  return `json_extract(item, '$.` + field + `')`;
+}
+
+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
+  ];
+}
+
+function ensureIndexes(db, table, indexes) {
+  indexes.forEach(idx => {
+    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;
+    SqliteDriver$ReventlessLocal.exec(db, `CREATE INDEX IF NOT EXISTS ` + indexName + ` ON ` + table + ` (` + cols + `)`);
+  });
+}
+
+function decodeItem(row) {
+  let match = row["item"];
+  if (match === undefined) {
+    return null;
+  }
+  if (typeof match !== "string") {
+    return null;
+  }
+  try {
+    return JSON.parse(match);
+  } catch (exn) {
+    return null;
+  }
+}
+
+function computeSubKey(item, subIdField) {
+  if (subIdField === undefined) {
+    return "";
+  }
+  let obj = Stdlib_JSON.Decode.object(item);
+  if (obj === undefined) {
+    return "";
+  }
+  let match = obj[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.isSome(obj["id"])) {
+    return item;
+  }
+  let copy = {};
+  Object.entries(obj).forEach(param => {
+    copy[param[0]] = param[1];
+  });
+  copy["id"] = partitionKey;
+  return copy;
+}
+
+let notExpiredClause = "(expires_at IS NULL OR expires_at > strftime('%s','now'))";
+
+function makeStorage(db, bus, name, indexes, subIdField) {
+  let table = tableName(name);
+  ensureSchema(db, table);
+  ensureExpiresColumn(db, table);
+  ensureIndexes(db, table, indexes);
+  let upsertStmt = SqliteDriver$ReventlessLocal.prepare(db, `INSERT INTO ` + table + `(partition_key, sub_key, item, expires_at) VALUES(?,?,?,?) ON CONFLICT(partition_key, sub_key) DO UPDATE SET item = excluded.item, expires_at = excluded.expires_at`);
+  let selectByPartitionStmt = SqliteDriver$ReventlessLocal.prepare(db, `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE partition_key = ? AND ` + notExpiredClause + ` ORDER BY sub_key ASC`);
+  let deleteByPartitionStmt = SqliteDriver$ReventlessLocal.prepare(db, `DELETE FROM ` + table + ` WHERE partition_key = ?`);
+  let deleteBySubKeyStmt = SqliteDriver$ReventlessLocal.prepare(db, `DELETE FROM ` + table + ` WHERE partition_key = ? AND sub_key = ?`);
+  let scanAllStmt = SqliteDriver$ReventlessLocal.prepare(db, `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE ` + notExpiredClause + ` ORDER BY partition_key, sub_key`);
+  let rowsFor = id => SqliteDriver$ReventlessLocal.all(selectByPartitionStmt, [id]).map(decodeItem);
+  let allRows = () => SqliteDriver$ReventlessLocal.all(scanAllStmt, []).map(row => {
+    let item = decodeItem(row);
+    let match = row["partition_key"];
+    let partition = typeof match === "string" ? match : "";
+    return withId(item, partition);
+  });
+  let saveOne = (id, state, ttl) => {
+    let subKey = computeSubKey(state, subIdField);
+    let expiresAt = ttl !== undefined ? ttl : null;
+    SqliteDriver$ReventlessLocal.run(upsertStmt, [
+      id,
+      subKey,
+      JSON.stringify(state),
+      expiresAt
+    ]);
+  };
+  let load = async id => ({
+    TAG: "Ok",
+    _0: rowsFor(id)
+  });
+  let loadStream = id => Stream.fromIterable(rowsFor(id));
+  let entityKeyFor = (id, subKey) => {
+    if (subIdField !== undefined) {
+      return id + "-" + subKey;
+    } else {
+      return id;
+    }
+  };
+  let publishUpdated = (id, state) => {
+    let subKey = computeSubKey(state, subIdField);
+    let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", entityKeyFor(id, subKey), state);
+    bus.publishStateChange(name, descriptor);
+  };
+  let publishRemoved = (id, subKey) => {
+    let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Removed", entityKeyFor(id, subKey), undefined);
+    bus.publishStateChange(name, descriptor);
+  };
+  let rowKeysForPartition = id => SqliteDriver$ReventlessLocal.all(selectByPartitionStmt, [id]).map(row => {
+    let match = row["sub_key"];
+    if (typeof match === "string") {
+      return match;
+    } else {
+      return "";
+    }
+  });
+  let save = async (id, state, _saveMode, ttl) => {
+    saveOne(id, state, ttl);
+    publishUpdated(id, state);
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  let saveBatch = async batch => {
+    SqliteDriver$ReventlessLocal.transaction(db, () => {
+      batch.forEach(param => saveOne(param[0], param[1], param[2]));
+    });
+    batch.forEach(param => publishUpdated(param[0], param[1]));
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  let count = async (_id, _fieldName, inc) => ({
+    TAG: "Ok",
+    _0: inc
+  });
+  let deleteOne = (id, subIdOpt) => {
+    if (subIdOpt !== undefined) {
+      return SqliteDriver$ReventlessLocal.run(deleteBySubKeyStmt, [
+        id,
+        subIdOpt[1]
+      ]);
+    } else {
+      return SqliteDriver$ReventlessLocal.run(deleteByPartitionStmt, [id]);
+    }
+  };
+  let $$delete = async (id, subIdOpt) => {
+    let removedSubKeys = subIdOpt !== undefined ? [subIdOpt[1]] : rowKeysForPartition(id);
+    deleteOne(id, subIdOpt);
+    removedSubKeys.forEach(sk => publishRemoved(id, sk));
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  let deleteBatch = async ids => {
+    let removed = [];
+    ids.forEach(param => {
+      let subIdOpt = param[1];
+      let id = param[0];
+      if (subIdOpt !== undefined) {
+        removed.push([
+          id,
+          subIdOpt[1]
+        ]);
+      } else {
+        rowKeysForPartition(id).forEach(sk => {
+          removed.push([
+            id,
+            sk
+          ]);
+        });
+      }
+    });
+    SqliteDriver$ReventlessLocal.transaction(db, () => {
+      ids.forEach(param => deleteOne(param[0], param[1]));
+    });
+    removed.forEach(param => publishRemoved(param[0], param[1]));
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  let ops = {
+    load: load,
+    loadStream: loadStream,
+    save: save,
+    saveBatch: saveBatch,
+    count: count,
+    delete: $$delete,
+    deleteBatch: deleteBatch
+  };
+  bus.registerQueryDb(name, ops);
+  bus.registerQueryDbScan(name, () => allRows());
+  bus.registerQueryDbStream(name, () => Stream.fromIterable(allRows()));
+  return {
+    resources: [],
+    dataSourceName: Pulumi.output(""),
+    operations: Pulumi.output(ops)
+  };
+}
+
+function Make(Bus) {
+  return DbProvider => {
+    let busCallbacks_publishStateChange = Bus.publishStateChange;
+    let busCallbacks_registerQueryDb = Bus.registerQueryDb;
+    let busCallbacks_registerQueryDbScan = Bus.registerQueryDbScan;
+    let busCallbacks_registerQueryDbStream = Bus.registerQueryDbStream;
+    let busCallbacks = {
+      publishStateChange: busCallbacks_publishStateChange,
+      registerQueryDb: busCallbacks_registerQueryDb,
+      registerQueryDbScan: busCallbacks_registerQueryDbScan,
+      registerQueryDbStream: busCallbacks_registerQueryDbStream
+    };
+    let make = (name, indexes, subIdField, param, param$1, param$2, param$3) => makeStorage(DbProvider.db, busCallbacks, name, indexes, subIdField);
+    return {
+      busCallbacks: busCallbacks,
+      make: make
+    };
+  };
+}
+
+export {
+  tableName,
+  sanitizeIdent,
+  ensureSchema,
+  ensureExpiresColumn,
+  jsonField,
+  compositeExpr,
+  indexExpressions,
+  ensureIndexes,
+  decodeItem,
+  computeSubKey,
+  withId,
+  notExpiredClause,
+  makeStorage,
+  Make,
+}
+/* effect/Stream Not a pure module */

package/src/adapter/QueryDb/SortKey_Filter.res

@@ -0,0 +1,48 @@
+// Pure sort key filtering for sub-ID queries.
+// Applies DynamoDB-style sort key conditions to an already-sorted item list.
+// Used by QueryDbResolvers_GraphQL for {name}ById queries.
+
+type result = {
+  items: array<JSON.t>,
+  nextToken: option<string>,
+}
+
+/** Extract the sort key string from a JSON item using the given field name. */
+let getSk = (item, skField) =>
+  item->JSON.Decode.object->Option.flatMap(d => d->Dict.get(skField))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+
+/** Apply sort key conditions, ordering, and pagination to a list of JSON items.
+    - `items` must already be sorted ascending by sort key.
+    - Returns filtered+paginated items and an optional `nextToken` for the next page. */
+let apply = (
+  ~items: array<JSON.t>,
+  ~skField: string,
+  ~prefix: option<string>=?,
+  ~from: option<string>=?,
+  ~to_: option<string>=?,
+  ~eq: option<string>=?,
+  ~reverse: bool=false,
+  ~limit: option<int>=?,
+  ~offset: int=0,
+) => {
+  let filtered = items->Array.filter(item => {
+    let sk = getSk(item, skField)
+    let okPrefix = prefix->Option.map(p => sk->String.startsWith(p))->Option.getOr(true)
+    let okFrom   = from->Option.map(f => sk >= f)->Option.getOr(true)
+    let okTo     = to_->Option.map(t => sk <= t)->Option.getOr(true)
+    let okEq     = eq->Option.map(e => sk == e)->Option.getOr(true)
+    okPrefix && okFrom && okTo && okEq
+  })
+  let ordered = if reverse { filtered->Array.toReversed } else { filtered }
+  let sliced = ordered->Array.slice(~start=offset, ~end=ordered->Array.length)
+  let (page, hasMore) = switch limit {
+  | Some(n) => (sliced->Array.slice(~start=0, ~end=n), sliced->Array.length > n)
+  | None => (sliced, false)
+  }
+  let nextToken = if hasMore {
+    Some(Int.toString(offset + page->Array.length))
+  } else {
+    None
+  }
+  { items: page, nextToken }
+}