@reventlessdev/reventless-postgres 3.0.0-alpha.5 → 3.0.0-alpha.50

package/src/DcbEventLogStorage_Postgres_Ops.res.mjs

@@ -0,0 +1,380 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
+
+function strategyParam(s) {
+  if (s === "AdvisoryLocks") {
+    return "advisory";
+  } else {
+    return "rows";
+  }
+}
+
+function noTracking(param) {
+  
+}
+
+let selectColumns = "\n  lpad(transaction_id::text, 20, '0') || ':' || lpad(position::text, 20, '0') AS cursor,\n  event_type,\n  tags,\n  data,\n  meta,\n  to_char(recorded_at AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.MS\"Z\"') AS recorded_at\n";
+
+function decodeTag(s) {
+  let i = s.indexOf("=");
+  if (i !== -1) {
+    return {
+      key: s.slice(0, i),
+      value: s.slice(i + 1 | 0, s.length)
+    };
+  } else {
+    return {
+      key: s,
+      value: ""
+    };
+  }
+}
+
+function decodeTags(v) {
+  if (v !== undefined) {
+    if (Array.isArray(v)) {
+      return Stdlib_Array.filterMap(v, x => {
+        if (typeof x === "string") {
+          return decodeTag(x);
+        }
+      });
+    } else {
+      return [];
+    }
+  } else {
+    return [];
+  }
+}
+
+function rowToEvent(row) {
+  let str = key => {
+    let match = row[key];
+    if (typeof match === "string") {
+      return match;
+    } else {
+      return "";
+    }
+  };
+  let metaJson = row["meta"];
+  let meta = metaJson !== undefined ? S.parseJsonOrThrow(metaJson, Message$Reventless.metaSchema) : Stdlib_JsError.throwWithMessage("missing meta column in dcb_event row");
+  return {
+    position: str("cursor"),
+    eventType: str("event_type"),
+    data: Stdlib_Option.getOr(row["data"], null),
+    tags: decodeTags(row["tags"]),
+    meta: meta,
+    recordedAt: str("recorded_at")
+  };
+}
+
+function mkBuilder() {
+  return {
+    params: []
+  };
+}
+
+function param(b, v) {
+  b.params.push(v);
+  return "$" + b.params.length.toString();
+}
+
+function buildReadWhere(b, name, query, after, applyFence) {
+  let parts = [`log_name = ` + param(b, name)];
+  if (applyFence) {
+    parts.push("transaction_id < pg_snapshot_xmin(pg_current_snapshot())");
+  }
+  if (after !== undefined) {
+    let txP = param(b, after[0]);
+    let posP = param(b, after[1]);
+    parts.push(`(transaction_id > ` + txP + `::xid8 OR (transaction_id = ` + txP + `::xid8 AND position > ` + posP + `::bigint))`);
+  }
+  if (query.length !== 0) {
+    let clauseSqls = query.map(clause => {
+      let clauseParts = [];
+      let types = clause.eventTypes;
+      if (types !== undefined && types.length !== 0) {
+        let ph = types.map(t => param(b, t)).join(",");
+        clauseParts.push(`event_type IN (` + ph + `)`);
+      }
+      let tags = clause.tags;
+      if (tags !== undefined && tags.length !== 0) {
+        let arr = tags.map(t => param(b, t.key + "=" + t.value)).join(",");
+        clauseParts.push(`tags @> ARRAY[` + arr + `]::text[]`);
+      }
+      if (clauseParts.length === 0) {
+        return "TRUE";
+      } else {
+        return "(" + clauseParts.join(" AND ") + ")";
+      }
+    });
+    parts.push("(" + clauseSqls.join(" OR ") + ")");
+  }
+  return parts.join(" AND ");
+}
+
+function stripZeros(s) {
+  let t = s.replace(/^0+/, "");
+  if (t === "") {
+    return "0";
+  } else {
+    return t;
+  }
+}
+
+function decodeCursor(pos) {
+  let match = pos.split(":");
+  if (match.length !== 2) {
+    return;
+  }
+  let tx = match[0];
+  let p = match[1];
+  return [
+    stripZeros(tx),
+    stripZeros(p)
+  ];
+}
+
+function isConflict(exn) {
+  let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "");
+  if (msg.includes("dcb_conflict") || msg.includes("duplicate key")) {
+    return true;
+  } else {
+    return msg.includes("23505");
+  }
+}
+
+async function countAll(pool) {
+  let row = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT COUNT(*)::bigint AS c FROM dcb_event", []);
+  if (row === undefined) {
+    return 0;
+  }
+  let match = row["c"];
+  if (match === undefined) {
+    return 0;
+  }
+  switch (typeof match) {
+    case "string" :
+      return Stdlib_Option.getOr(Stdlib_Int.fromString(match, undefined), 0);
+    case "number" :
+      return match | 0;
+    default:
+      return 0;
+  }
+}
+
+function makeOps(pool, name, param, param$1, param$2, param$3, lockStrategyOpt, onAppendedOpt) {
+  let lockStrategy = lockStrategyOpt !== undefined ? lockStrategyOpt : "AdvisoryLocks";
+  let onAppended = onAppendedOpt !== undefined ? onAppendedOpt : noTracking;
+  let currentHead = async () => {
+    let row = await PgDriver$ReventlessPostgres.queryOne(pool, "SELECT lpad(transaction_id::text, 20, '0') || ':' || lpad(position::text, 20, '0') AS head\n         FROM dcb_event\n        WHERE log_name = $1 AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\n        ORDER BY transaction_id DESC, position DESC\n        LIMIT 1", [name]);
+    if (row === undefined) {
+      return;
+    }
+    let match = row["head"];
+    if (typeof match === "string") {
+      return match;
+    }
+  };
+  let runQuery = async (query, after) => {
+    let b = {
+      params: []
+    };
+    let where = buildReadWhere(b, name, query, after, true);
+    let sql = `SELECT ` + selectColumns + ` FROM dcb_event WHERE ` + where + ` ORDER BY transaction_id ASC, position ASC`;
+    return (await PgDriver$ReventlessPostgres.query(pool, sql, b.params)).map(rowToEvent);
+  };
+  let read = async (query, after) => {
+    let afterCols = Stdlib_Option.flatMap(after, decodeCursor);
+    let events = await runQuery(query, afterCols);
+    let head = await currentHead();
+    if (head !== undefined) {
+      return {
+        events: events,
+        headPosition: head
+      };
+    } else {
+      return {
+        events: events
+      };
+    }
+  };
+  let append = async (newEvents, condition) => {
+    let eventsJson = newEvents.map(ev => (Object.fromEntries([
+      [
+        "event_type",
+        ev.eventType
+      ],
+      [
+        "tags",
+        ev.tags.map(t => t.key + "=" + t.value)
+      ],
+      [
+        "data",
+        ev.data
+      ],
+      [
+        "meta",
+        S.reverseConvertToJsonOrThrow(ev.meta, Message$Reventless.metaSchema)
+      ]
+    ])));
+    let conditionParam;
+    if (condition !== undefined) {
+      let queryJson = condition.query.map(clause => {
+        let types = clause.eventTypes;
+        let tags = clause.tags;
+        return Object.fromEntries([
+          [
+            "eventTypes",
+            types !== undefined ? types.map(prim => prim) : null
+          ],
+          [
+            "tags",
+            tags !== undefined ? tags.map(t => t.key + "=" + t.value) : null
+          ]
+        ]);
+      });
+      let fields = [[
+          "query",
+          queryJson
+        ]];
+      let a = condition.after;
+      if (a !== undefined) {
+        fields.push([
+          "after",
+          a
+        ]);
+      }
+      conditionParam = JSON.stringify(Object.fromEntries(fields));
+    } else {
+      conditionParam = null;
+    }
+    try {
+      let rows = await PgDriver$ReventlessPostgres.query(pool, "SELECT dcb_append($1, $2::jsonb, $3::jsonb, $4) AS pos", [
+        name,
+        JSON.stringify(eventsJson),
+        conditionParam,
+        strategyParam(lockStrategy)
+      ]);
+      let match = Stdlib_Option.flatMap(rows[0], r => r["pos"]);
+      if (match === undefined) {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "StorageFailure",
+            _0: "dcb_append returned no position"
+          }
+        };
+      }
+      if (typeof match !== "string") {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "StorageFailure",
+            _0: "dcb_append returned no position"
+          }
+        };
+      }
+      onAppended(Stdlib_Array.filterMap(newEvents, ev => {
+        let match$1 = decodeCursor(match);
+        if (match$1 !== undefined) {
+          return Stdlib_Option.map(Stdlib_Int.fromString(match$1[1], undefined), p => [
+            ev.meta.msgId,
+            p
+          ]);
+        }
+      }));
+      return {
+        TAG: "Ok",
+        _0: match
+      };
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (isConflict(exn)) {
+        return {
+          TAG: "Error",
+          _0: "Conflict"
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "StorageFailure",
+            _0: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "storage error")
+          }
+        };
+      }
+    }
+  };
+  let readStream = (query, after, param) => Stream.paginateEffect(Stdlib_Option.flatMap(after, decodeCursor), cursor => Effect.map(Effect.promise(() => {
+    let b = {
+      params: []
+    };
+    let where = buildReadWhere(b, name, query, cursor, true);
+    let sql = `SELECT ` + selectColumns + `, transaction_id::text AS tx_raw, position::text AS pos_raw FROM dcb_event WHERE ` + where + ` ORDER BY transaction_id ASC, position ASC LIMIT ` + (500).toString();
+    return PgDriver$ReventlessPostgres.query(pool, sql, b.params);
+  }), rows => {
+    let events = rows.map(rowToEvent);
+    let next;
+    if (rows.length < 500) {
+      next = undefined;
+    } else {
+      let lastRow = rows[rows.length - 1 | 0];
+      if (lastRow !== undefined) {
+        let match = lastRow["tx_raw"];
+        let match$1 = lastRow["pos_raw"];
+        next = typeof match === "string" && typeof match$1 === "string" ? Primitive_option.some([
+            match,
+            match$1
+          ]) : undefined;
+      } else {
+        next = undefined;
+      }
+    }
+    return [
+      events,
+      next
+    ];
+  }));
+  let ops = {
+    read: read,
+    append: append,
+    readStream: readStream
+  };
+  return [
+    name,
+    ops
+  ];
+}
+
+let pageSize = 500;
+
+export {
+  strategyParam,
+  noTracking,
+  selectColumns,
+  decodeTag,
+  decodeTags,
+  rowToEvent,
+  mkBuilder,
+  param,
+  buildReadWhere,
+  stripZeros,
+  decodeCursor,
+  pageSize,
+  isConflict,
+  countAll,
+  makeOps,
+}
+/* S Not a pure module */

package/src/EventLogChangeFeed.res

@@ -15,8 +15,11 @@
 // later commit) is never skipped by a checkpointing reader. `global_seq` alone,
 // being an IDENTITY assigned at INSERT, could NOT provide that guarantee.
 
-// Reuse the shared `<a>:<b>` cursor codec from the DCB storage — identical format.
-module Dcb = DcbEventLogStorage_Postgres
+// Reuse the shared `<a>:<b>` cursor codec from the DCB storage — identical
+// format. Point at the runtime-pure `_Ops` module (no `@pulumi/pulumi`): this
+// feed is drained by the deployed change-feed relay Lambda, whose cold-start
+// graph must stay Pulumi-free.
+module Dcb = DcbEventLogStorage_Postgres_Ops
 
 // One classic event as the feed surfaces it. `payload` is the stored event JSON
 // verbatim; a bus/topic relay transforms it into its target shape (e.g. the AWS

package/src/EventLogChangeFeed.res.mjs

@@ -3,7 +3,7 @@
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as PgDriver$ReventlessPostgres from "./PgDriver.res.mjs";
-import * as DcbEventLogStorage_Postgres$ReventlessPostgres from "./DcbEventLogStorage_Postgres.res.mjs";
+import * as DcbEventLogStorage_Postgres_Ops$ReventlessPostgres from "./DcbEventLogStorage_Postgres_Ops.res.mjs";
 
 let selectColumns = "\n  lpad(transaction_id::text, 20, '0') || ':' || lpad(global_seq::text, 20, '0') AS cursor,\n  aggregate_id,\n  seq_nr,\n  payload,\n  msg_id\n";
 
@@ -43,7 +43,7 @@ async function readBatch(pool, logName, after, limitOpt) {
   let limit = limitOpt !== undefined ? limitOpt : 500;
   let params = [logName];
   let where = "log_name = $1 AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())";
-  let match = Stdlib_Option.flatMap(after, DcbEventLogStorage_Postgres$ReventlessPostgres.decodeCursor);
+  let match = Stdlib_Option.flatMap(after, DcbEventLogStorage_Postgres_Ops$ReventlessPostgres.decodeCursor);
   if (match !== undefined) {
     params.push(match[0]);
     params.push(match[1]);
@@ -72,7 +72,7 @@ async function loadCheckpoint(pool, subscriber) {
 }
 
 async function saveCheckpoint(pool, subscriber, cursor) {
-  let match = DcbEventLogStorage_Postgres$ReventlessPostgres.decodeCursor(cursor);
+  let match = DcbEventLogStorage_Postgres_Ops$ReventlessPostgres.decodeCursor(cursor);
   if (match !== undefined) {
     await PgDriver$ReventlessPostgres.query(pool, "INSERT INTO event_log_subscription(subscriber, last_tx, last_global_seq)\n       VALUES ($1, $2::xid8, $3::bigint)\n       ON CONFLICT (subscriber)\n       DO UPDATE SET last_tx = EXCLUDED.last_tx, last_global_seq = EXCLUDED.last_global_seq", [
       subscriber,

package/src/EventLogStorage_Postgres.res

@@ -1,176 +1,18 @@
-// Postgres-backed classic (OCC) event log storage. Direct port of
-// EventLogStorage_Sqlite; the only structural difference is that every operation
-// is async (pg has no synchronous client) and `payload jsonb` returns already
-// parsed, so there is no per-row JSON.parse.
+// Deploy/local wrapper over the runtime-pure EventLogStorage_Postgres_Ops.
 //
-// Schema (PgSchema.res): event_log(log_name, aggregate_id, seq_nr, payload,
-// msg_id, global_seq IDENTITY, PRIMARY KEY(log_name, aggregate_id, seq_nr)).
-//
-// Optimistic concurrency: the append is a single guarded statement —
-//   INSERT ... SELECT ... WHERE $seq = (SELECT COALESCE(MAX(seq_nr),-1)+1 ...)
-// which is atomic and gap-proof. A wrong seq (gap or already-consumed) fails the
-// WHERE → 0 rows → Conflict; two writers racing the same seq collide on the PK →
-// one commits, the loser's unique_violation → Conflict.
+// The runtime ops (and helpers like `countAll`) live in
+// EventLogStorage_Postgres_Ops, which imports NO `@pulumi/pulumi` so the deployed
+// Lambda import graph stays clean (the aggregate entry point pulls the ops in
+// unconditionally at cold start — a deploy-time dep here would fail resolution on
+// real Lambda). This module `include`s that pure module and adds only the
+// deploy-time `EventLog_Adapter` shape (`operations` wrapped in `Pulumi.Output`),
+// keeping the historic `makeStorage` 3-tuple `(name, ops, adapter)` API unchanged.
+// See docs/plans/deployed-lambda-esm-self-containment.md (Rung-3 finding).
 
 open ReventlessCore
+include EventLogStorage_Postgres_Ops
 
-// Injected by reventless-local to feed the projection-checkpoint low-watermark
-// (ProjectionPending, aggregate axis). Standalone/deploy use passes nothing.
-type onAppended = array<(string, int)> => unit
-let noTracking: onAppended = _ => ()
-
-let decodePayload = (row: dict<JSON.t>): JSON.t =>
-  row->Dict.get("payload")->Option.getOr(JSON.Encode.null)
-
-let coerceInt = (v: JSON.t): int =>
-  switch v {
-  | JSON.Number(n) => Float.toInt(n)
-  | JSON.String(s) => s->Int.fromString->Option.getOr(0)
-  | _ => 0
-  }
-
-// Total events across all aggregates. Seeds the event-tap counter at startup so
-// timeline numbering continues across restarts.
-let countAll = async (pool: PgDriver.pool): int =>
-  switch await pool->PgDriver.queryOne("SELECT COUNT(*)::bigint AS c FROM event_log", []) {
-  | Some(row) => row->Dict.get("c")->Option.map(coerceInt)->Option.getOr(0)
-  | None => 0
-  }
-
-let isUniqueViolation = (exn: exn): bool => {
-  let msg = exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("")
-  // pg surfaces the SQLSTATE on `.code`; the message also carries the constraint.
-  msg->String.includes("duplicate key") ||
-  msg->String.includes("unique") ||
-  msg->String.includes("23505")
-}
-
-let makeStorage = (~pool: PgDriver.pool, ~name: string, ~opts as _, ~onAppended=noTracking) => {
-  let appendTracked = async (~track, seqNr: int, id: string, jsons: array<JSON.t>) => {
-    // Empty append is a legitimate no-op (at-least-once retries, idempotent
-    // commands), NOT a conflict — return before the guarded insert whose 0-row
-    // result would otherwise be read as a conflict.
-    if jsons->Array.length == 0 {
-      Ok()
-    } else {
-      try {
-        let rows = await pool->PgDriver.query(
-          "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload, msg_id)
-           SELECT $1, $2, $3::bigint + (ord - 1), value, value->>'msgId'
-             FROM jsonb_array_elements($4::jsonb) WITH ORDINALITY AS t(value, ord)
-            WHERE $3::bigint = (SELECT COALESCE(MAX(seq_nr), -1) + 1
-                                  FROM event_log
-                                 WHERE log_name = $1 AND aggregate_id = $2)
-           RETURNING global_seq, msg_id",
-          [
-            JSON.Encode.string(name),
-            JSON.Encode.string(id),
-            JSON.Encode.int(seqNr),
-            JSON.Encode.string(JSON.stringify(JSON.Array(jsons))),
-          ],
-        )
-        if rows->Array.length == 0 {
-          // WHERE guard rejected the seq — a genuine OCC conflict (gap or stale).
-          Error(EventLog.Conflict)
-        } else {
-          if track {
-            onAppended(
-              rows->Array.filterMap(row =>
-                switch (row->Dict.get("msg_id"), row->Dict.get("global_seq")) {
-                | (Some(JSON.String(msgId)), Some(gseq)) => Some((msgId, coerceInt(gseq)))
-                | _ => None
-                }
-              ),
-            )
-          }
-          Ok()
-        }
-      } catch {
-      | exn =>
-        isUniqueViolation(exn)
-          ? Error(EventLog.Conflict)
-          : Error(
-              EventLog.StorageFailure(
-                exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("storage error"),
-              ),
-            )
-      }
-    }
-  }
-
-  let append: EventLog.append<string, JSON.t> = (seqNr, id, jsons) =>
-    appendTracked(~track=true, seqNr, id, jsons)
-
-  let replayArray = async (id: string, ~fromSeq=0): array<JSON.t> =>
-    (await pool->PgDriver.query(
-      "SELECT payload FROM event_log
-        WHERE log_name = $1 AND aggregate_id = $2 AND seq_nr >= $3::bigint
-        ORDER BY seq_nr ASC",
-      [JSON.Encode.string(name), JSON.Encode.string(id), JSON.Encode.int(fromSeq)],
-    ))->Array.map(decodePayload)
-
-  let replay: EventLog.replay<string, JSON.t> = id => replayArray(id)
-
-  let replayStream = (id, ~fromSeq=?) =>
-    Effect.promise(() => replayArray(id, ~fromSeq?))
-    ->Stream.fromEffect
-    ->Stream.flatMap(arr => Stream.fromIterable(arr))
-
-  let latestSnapshot: EventLog.latestSnapshot<string> = async id =>
-    switch await pool->PgDriver.queryOne(
-      "SELECT seq_nr, state, schema_hash FROM snapshot WHERE log_name = $1 AND aggregate_id = $2",
-      [JSON.Encode.string(name), JSON.Encode.string(id)],
-    ) {
-    | Some(row) =>
-      switch (row->Dict.get("seq_nr"), row->Dict.get("state"), row->Dict.get("schema_hash")) {
-      | (Some(seq), Some(state), Some(JSON.String(schemaHash))) =>
-        Ok(Some({EventLog.seqNr: coerceInt(seq), state, schemaHash}))
-      | _ => Error("snapshot row has unexpected shape")
-      }
-    | None => Ok(None)
-    }
-
-  let writeSnapshot: EventLog.writeSnapshot<string> = async (id, snap) =>
-    try {
-      let _ = await pool->PgDriver.query(
-        "INSERT INTO snapshot(log_name, aggregate_id, seq_nr, state, schema_hash)
-         VALUES ($1, $2, $3::bigint, $4::jsonb, $5)
-         ON CONFLICT (log_name, aggregate_id)
-         DO UPDATE SET seq_nr = EXCLUDED.seq_nr, state = EXCLUDED.state, schema_hash = EXCLUDED.schema_hash",
-        [
-          JSON.Encode.string(name),
-          JSON.Encode.string(id),
-          JSON.Encode.int(snap.EventLog.seqNr),
-          JSON.Encode.string(JSON.stringify(snap.state)),
-          JSON.Encode.string(snap.schemaHash),
-        ],
-      )
-      Ok()
-    } catch {
-    | exn =>
-      Error(exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("snapshot write error"))
-    }
-
-  let appendStream: EventLog.appendStream<string, JSON.t> = (startingSeqNr, id, stream) =>
-    stream
-    ->Stream.runCollect
-    ->Effect.flatMap(jsons =>
-      Effect.promise(() => appendTracked(~track=false, startingSeqNr, id, jsons))->Effect.flatMap(result =>
-        switch result {
-        | Ok() => Effect.succeed()
-        | Error(EventLog.Conflict) => Effect.fail("conflict")
-        | Error(StorageFailure(msg)) => Effect.fail(msg)
-        }
-      )
-    )
-
-  let ops: EventLog_Adapter.operations = {
-    append,
-    replay,
-    replayStream,
-    appendStream,
-    latestSnapshot,
-    writeSnapshot,
-  }
+let makeStorage = (~pool: PgDriver.pool, ~name: string, ~opts, ~onAppended=noTracking) => {
+  let (name, ops) = makeOps(~pool, ~name, ~opts, ~onAppended)
   (name, ops, {EventLog_Adapter.resources: [], operations: Pulumi.Output.make(ops)})
 }