@reventlessdev/reventless-postgres 3.0.0-alpha.1

package/src/QueryDbStorage_Postgres.res.mjs

@@ -0,0 +1,225 @@
+// 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";
+
+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 makeStorage(pool, name, indexes, subIdField) {
+  let table = tableName(name);
+  let ready = ensureTable(pool, table).then(() => ensureIndexes(pool, table, indexes));
+  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
+    };
+  };
+  let ops = {
+    load: load,
+    loadStream: loadStream,
+    save: save,
+    saveBatch: saveBatch,
+    count: count,
+    delete: $$delete,
+    deleteBatch: deleteBatch
+  };
+  return {
+    resources: [],
+    dataSourceName: Pulumi.output(""),
+    operations: Pulumi.output(ops)
+  };
+}
+
+function Make(P) {
+  let make = (name, indexes, subIdField, param, param$1, param$2, param$3) => makeStorage(P.pool, name, indexes, subIdField);
+  return {
+    make: make
+  };
+}
+
+export {
+  tableName,
+  sanitizeIdent,
+  notExpiredClause,
+  jsonField,
+  compositeExpr,
+  indexExpressions,
+  ensureTable,
+  ensureIndexes,
+  decodeItem,
+  computeSubKey,
+  withId,
+  makeStorage,
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/QueryEnginePostgres.res

@@ -0,0 +1,127 @@
+// Postgres QueryEngine — compiles the QueryEngine query/scan AST to SQL over the
+// `qdb_<name>` JSONB tables (QueryDbStorage_Postgres). The reventless-local
+// LocalQueryEngine reads from in-process bus registries and ignores filters; this
+// one pushes filters down to SQL, the way a production engine must.
+
+open ReventlessCore
+open Reventless
+
+let valueToText = (v: QueryEngine.value): string =>
+  switch v {
+  | QueryEngine.String(s) => s
+  | QueryEngine.Int(i) => i->Int.toString
+  | QueryEngine.Bool(b) => b ? "true" : "false"
+  }
+
+let isNumeric = (v: QueryEngine.value): bool =>
+  switch v {
+  | QueryEngine.Int(_) => true
+  | _ => false
+  }
+
+type paramBuilder = {mutable params: array<JSON.t>}
+let param = (b: paramBuilder, v: JSON.t): string => {
+  b.params->Array.push(v)
+  "$" ++ Int.toString(b.params->Array.length)
+}
+
+let col = (field: string): string => `(item->>'${field->String.replaceAll("'", "''")}')`
+
+// One Filter.config → SQL predicate, appending any bound params.
+let filterSql = (b: paramBuilder, field: string, cmp: QueryEngine.Filter.comparator, v: QueryEngine.value): string => {
+  let c = col(field)
+  let bind = () => b->param(JSON.Encode.string(valueToText(v)))
+  let cmpSql = op =>
+    isNumeric(v) ? `${c}::numeric ${op} ${bind()}::numeric` : `${c} ${op} ${bind()}`
+  switch cmp {
+  | QueryEngine.Filter.Equal => cmpSql("=")
+  | Unequal => cmpSql("<>")
+  | LessOrEqual => cmpSql("<=")
+  | Less => cmpSql("<")
+  | GreaterOrEqual => cmpSql(">=")
+  | Greater => cmpSql(">")
+  | Exists => `(item ? '${field->String.replaceAll("'", "''")}')`
+  | NotExists => `NOT (item ? '${field->String.replaceAll("'", "''")}')`
+  | Contains => `strpos(${c}, ${bind()}) > 0`
+  | NotContains => `(${c} IS NULL OR strpos(${c}, ${bind()}) = 0)`
+  | BeginsWith => `starts_with(${c}, ${bind()})`
+  }
+}
+
+let subIdSql = (b: paramBuilder, field: string, cmp: QueryEngine.SubId.comparator, v: QueryEngine.value): string => {
+  let c = col(field)
+  let bind = () => b->param(JSON.Encode.string(valueToText(v)))
+  let cmpSql = op => isNumeric(v) ? `${c}::numeric ${op} ${bind()}::numeric` : `${c} ${op} ${bind()}`
+  switch cmp {
+  | QueryEngine.SubId.Equal => cmpSql("=")
+  | Unequal => cmpSql("<>")
+  | LessOrEqual => cmpSql("<=")
+  | Less => cmpSql("<")
+  | GreaterOrEqual => cmpSql(">=")
+  | Greater => cmpSql(">")
+  | BeginsWith => `starts_with(${c}, ${bind()})`
+  }
+}
+
+let notExpired = QueryDbStorage_Postgres.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)
+  if withId {
+    let pk = switch row->Dict.get("partition_key") {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+    QueryDbStorage_Postgres.withId(item, pk)
+  } else {
+    item
+  }
+}
+
+module Make = (P: {let pool: PgDriver.pool}) => {
+  let query = async (
+    ~readModelName,
+    ~key=?,
+    ~id: QueryEngine.value,
+    ~subIdConfig=?,
+    ~filterConfigs=?,
+    ~ascending=?,
+    ~limit=?,
+  ): array<JSON.t> => {
+    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let keyStr = switch key {
+    | Some(k) => k
+    | None => valueToText(id)
+    }
+    let b = {params: []}
+    let where = [`partition_key = ${b->param(JSON.Encode.string(keyStr))}`, notExpired]
+    switch subIdConfig {
+    | Some((field, cmp, v)) => where->Array.push(subIdSql(b, field, cmp, v))
+    | None => ()
+    }
+    filterConfigs
+    ->Option.getOr([])
+    ->Array.forEach(((field, cmp, v)) => where->Array.push(filterSql(b, field, cmp, v)))
+    let dir = ascending->Option.getOr(true) ? "ASC" : "DESC"
+    let limitClause = switch limit {
+    | Some(n) => ` LIMIT ${b->param(JSON.Encode.int(n))}`
+    | None => ""
+    }
+    let sql = `SELECT partition_key, item FROM ${table} WHERE ${where->Array.join(" AND ")} ORDER BY sub_key ${dir}${limitClause}`
+    (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=false, ...))
+  }
+
+  let scan = async (~readModelName, ~filterConfigs, ~limit): array<JSON.t> => {
+    let table = QueryDbStorage_Postgres.tableName(readModelName)
+    let b = {params: []}
+    let where = [notExpired]
+    filterConfigs->Array.forEach(((field, cmp, v)) => where->Array.push(filterSql(b, field, cmp, v)))
+    let sql = `SELECT partition_key, item FROM ${table} WHERE ${where->Array.join(" AND ")} ORDER BY partition_key, sub_key LIMIT ${b->param(JSON.Encode.int(limit))}`
+    (await P.pool->PgDriver.query(sql, b.params))->Array.map(decodeRow(~withId=true, ...))
+  }
+
+  let make: QueryDb_Adapter.queryEngineMaker = _allQueryDbs =>
+    Pulumi.Output.make({QueryEngine.scan, query})
+}

package/src/QueryEnginePostgres.res.mjs

@@ -0,0 +1,172 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+import * as QueryDbStorage_Postgres$ReventlessPostgres from "./QueryDbStorage_Postgres.res.mjs";
+
+function valueToText(v) {
+  switch (v.TAG) {
+    case "String" :
+      return v._0;
+    case "Int" :
+      return v._0.toString();
+    case "Bool" :
+      if (v._0) {
+        return "true";
+      } else {
+        return "false";
+      }
+  }
+}
+
+function isNumeric(v) {
+  switch (v.TAG) {
+    case "Int" :
+      return true;
+    case "String" :
+    case "Bool" :
+      return false;
+  }
+}
+
+function param(b, v) {
+  b.params.push(v);
+  return "$" + b.params.length.toString();
+}
+
+function col(field) {
+  return `(item->>'` + field.replaceAll("'", "''") + `')`;
+}
+
+function filterSql(b, field, cmp, v) {
+  let c = col(field);
+  let cmpSql = op => {
+    if (isNumeric(v)) {
+      return c + `::numeric ` + op + ` ` + param(b, valueToText(v)) + `::numeric`;
+    } else {
+      return c + ` ` + op + ` ` + param(b, valueToText(v));
+    }
+  };
+  switch (cmp) {
+    case "Equal" :
+      return cmpSql("=");
+    case "Unequal" :
+      return cmpSql("<>");
+    case "LessOrEqual" :
+      return cmpSql("<=");
+    case "Less" :
+      return cmpSql("<");
+    case "GreaterOrEqual" :
+      return cmpSql(">=");
+    case "Greater" :
+      return cmpSql(">");
+    case "Exists" :
+      return `(item ? '` + field.replaceAll("'", "''") + `')`;
+    case "NotExists" :
+      return `NOT (item ? '` + field.replaceAll("'", "''") + `')`;
+    case "Contains" :
+      return `strpos(` + c + `, ` + param(b, valueToText(v)) + `) > 0`;
+    case "NotContains" :
+      return `(` + c + ` IS NULL OR strpos(` + c + `, ` + param(b, valueToText(v)) + `) = 0)`;
+    case "BeginsWith" :
+      return `starts_with(` + c + `, ` + param(b, valueToText(v)) + `)`;
+  }
+}
+
+function subIdSql(b, field, cmp, v) {
+  let c = col(field);
+  let cmpSql = op => {
+    if (isNumeric(v)) {
+      return c + `::numeric ` + op + ` ` + param(b, valueToText(v)) + `::numeric`;
+    } else {
+      return c + ` ` + op + ` ` + param(b, valueToText(v));
+    }
+  };
+  switch (cmp) {
+    case "Equal" :
+      return cmpSql("=");
+    case "Unequal" :
+      return cmpSql("<>");
+    case "LessOrEqual" :
+      return cmpSql("<=");
+    case "Less" :
+      return cmpSql("<");
+    case "GreaterOrEqual" :
+      return cmpSql(">=");
+    case "Greater" :
+      return cmpSql(">");
+    case "BeginsWith" :
+      return `starts_with(` + c + `, ` + param(b, valueToText(v)) + `)`;
+  }
+}
+
+function decodeRow(withId, row) {
+  let item = QueryDbStorage_Postgres$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);
+}
+
+function Make(P) {
+  let query = async (readModelName, key, id, subIdConfig, filterConfigs, ascending, limit) => {
+    let table = QueryDbStorage_Postgres$ReventlessPostgres.tableName(readModelName);
+    let keyStr = key !== undefined ? key : valueToText(id);
+    let b = {
+      params: []
+    };
+    let where = [
+      `partition_key = ` + param(b, keyStr),
+      QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause
+    ];
+    if (subIdConfig !== undefined) {
+      where.push(subIdSql(b, subIdConfig[0], subIdConfig[1], subIdConfig[2]));
+    }
+    Stdlib_Option.getOr(filterConfigs, []).forEach(param => {
+      where.push(filterSql(b, param[0], param[1], param[2]));
+    });
+    let dir = Stdlib_Option.getOr(ascending, true) ? "ASC" : "DESC";
+    let limitClause = limit !== undefined ? ` LIMIT ` + param(b, limit) : "";
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + where.join(" AND ") + ` ORDER BY sub_key ` + dir + limitClause;
+    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 b = {
+      params: []
+    };
+    let where = [QueryDbStorage_Postgres$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
+  });
+  return {
+    query: query,
+    scan: scan,
+    make: make
+  };
+}
+
+let notExpired = QueryDbStorage_Postgres$ReventlessPostgres.notExpiredClause;
+
+export {
+  valueToText,
+  isNumeric,
+  param,
+  col,
+  filterSql,
+  subIdSql,
+  notExpired,
+  decodeRow,
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */