@lostgradient/weft 0.10.0 → 0.11.0

package/dist/storage/postgres-key-value-storage.js

@@ -0,0 +1,204 @@
+import { normalizeDeleteRangeOptions } from "./delete-range.js";
+import {
+  assertStorageBatchOperationCount
+} from "./interface.js";
+import { conditionsHold, writeBatchNetEffect } from "./neon-batch.js";
+import {
+  affectedRowCount,
+  resolveBatchNetEffect,
+  toBytea,
+  toStorageValue
+} from "./neon-value-mapping.js";
+import {
+  buildPostgresCreateSchema,
+  buildPostgresKeyValueQueries,
+  buildPostgresPrefixRangeParameters,
+  PG_BEGIN_READ_COMMITTED,
+  PG_BEGIN_READ_ONLY,
+  PG_BEGIN_SERIALIZABLE,
+  PG_COMMIT,
+  PG_ROLLBACK,
+  resolvePostgresTableReference
+} from "./postgres-key-value-queries.js";
+import { assertReadOnlyQuery } from "./read-only-query.js";
+import { scopedStorage } from "./scoped-storage.js";
+const RETRYABLE_TRANSACTION_FAILURES = new Set(["40001", "40P01"]), MAX_SERIALIZATION_RETRIES = 5;
+function isRetryableTransactionFailure(error) {
+  if (typeof error !== "object" || error === null || !("code" in error))
+    return !1;
+  const code = error.code;
+  return typeof code === "string" && RETRYABLE_TRANSACTION_FAILURES.has(code);
+}
+
+export class PostgresKeyValueStorage {
+  #pool;
+  #queries;
+  #schema;
+  #initializationPromise;
+  #ownsPool;
+  #poolShutdown;
+  constructor(options, poolFactory) {
+    this.#ownsPool = options.pool === void 0;
+    if (options.pool === void 0) {
+      if (options.url === void 0)
+        throw Error("PostgresKeyValueStorage requires either a `url` to build a pool from, or a pre-built `pool`; neither was provided.");
+      this.#pool = poolFactory(options.url);
+    } else
+      this.#pool = options.pool;
+    this.#schema = options.schema;
+    const tableReference = resolvePostgresTableReference({
+      schema: options.schema,
+      table: options.table
+    });
+    this.#queries = buildPostgresKeyValueQueries(tableReference);
+  }
+  capabilities() {
+    return {
+      persistence: "remote",
+      readAfterWrite: "linearizable",
+      scanConsistency: "snapshot",
+      atomicBatch: !0,
+      conditionalBatch: !0,
+      boundedRangeDelete: !0
+    };
+  }
+  #ensureTable() {
+    this.#initializationPromise ??= this.#initialize().catch((error) => {
+      this.#initializationPromise = void 0;
+      throw error;
+    });
+    return this.#initializationPromise;
+  }
+  async#initialize() {
+    if (this.#schema !== void 0)
+      await this.#pool.query(buildPostgresCreateSchema(this.#schema));
+    await this.#pool.query(this.#queries.createTable);
+    await this.#assertKeyCollation();
+  }
+  async#assertKeyCollation() {
+    const collation = (await this.#pool.query(this.#queries.selectKeyCollation, [
+      this.#queries.tableReference
+    ])).rows[0]?.collation;
+    if (collation === "C")
+      return;
+    const found = collation === void 0 ? "no such table" : typeof collation === "string" ? `"${collation}"` : "an unexpected collation value";
+    throw Error(`Postgres storage requires the ${this.#queries.tableReference} table's "key" column to use COLLATE "C" (found ${found}). A table created without COLLATE "C" sorts keys by the database locale, which breaks Weft's lexicographic prefix scans. Use a fresh table, or recreate it as: CREATE TABLE ${this.#queries.tableReference} (key TEXT COLLATE "C" PRIMARY KEY, value BYTEA NOT NULL).`);
+  }
+  async get(key) {
+    await this.#ensureTable();
+    const row = (await this.#pool.query(this.#queries.selectValueByKey, [key])).rows[0];
+    if (row === void 0)
+      return null;
+    const raw = row.value;
+    if (raw === null || raw === void 0)
+      return null;
+    return toStorageValue(raw);
+  }
+  async put(key, value) {
+    await this.#ensureTable();
+    await this.#pool.query(this.#queries.upsertValueByKey, [key, toBytea(value)]);
+  }
+  async delete(key) {
+    await this.#ensureTable();
+    await this.#pool.query(this.#queries.deleteValueByKey, [key]);
+  }
+  async has(key) {
+    await this.#ensureTable();
+    return (await this.#pool.query(this.#queries.selectKeyPresence, [key])).rows.length > 0;
+  }
+  async deletePrefix(prefix) {
+    await this.#ensureTable();
+    const [rangeStart, rangeEnd] = buildPostgresPrefixRangeParameters(prefix), result = await this.#pool.query(this.#queries.deleteKeysByPrefix, [rangeStart, rangeEnd]);
+    return affectedRowCount(result);
+  }
+  async deleteRange(prefix, options) {
+    await this.#ensureTable();
+    const normalized = normalizeDeleteRangeOptions(options), { parameters, sql } = this.#queries.keyRangeDelete(prefix, normalized), result = await this.#pool.query(sql, parameters);
+    return affectedRowCount(result);
+  }
+  async* scan(prefix, options = {}) {
+    await this.#ensureTable();
+    const { parameters, sql } = this.#queries.keyValueRangeSelect(prefix, options), result = await this.#pool.query(sql, parameters);
+    for (const row of result.rows)
+      yield [row.key, toStorageValue(row.value)];
+  }
+  async* keys(prefix, options = {}) {
+    await this.#ensureTable();
+    const { parameters, sql } = this.#queries.keyRangeSelect(prefix, options), result = await this.#pool.query(sql, parameters);
+    for (const row of result.rows)
+      yield row.key;
+  }
+  async count(prefix) {
+    await this.#ensureTable();
+    const [rangeStart, rangeEnd] = buildPostgresPrefixRangeParameters(prefix), result = await this.#pool.query(this.#queries.countKeysByPrefix, [rangeStart, rangeEnd]);
+    return Number(result.rows[0]?.count ?? 0);
+  }
+  scoped(prefix) {
+    return scopedStorage(this, prefix);
+  }
+  async#withTransaction(beginStatement, runner, shouldCommit = () => !0) {
+    const client = await this.#pool.connect();
+    try {
+      await client.query(beginStatement);
+      try {
+        const result = await runner(client);
+        await client.query(shouldCommit(result) ? PG_COMMIT : PG_ROLLBACK);
+        return result;
+      } catch (error) {
+        await client.query(PG_ROLLBACK).catch(() => {});
+        throw error;
+      }
+    } finally {
+      client.release();
+    }
+  }
+  async batch(operations) {
+    assertStorageBatchOperationCount("batch operations", operations.length);
+    if (operations.length === 0)
+      return;
+    await this.#ensureTable();
+    await this.#withTransaction(PG_BEGIN_READ_COMMITTED, async (client) => {
+      await writeBatchNetEffect(client, this.#queries, resolveBatchNetEffect(operations));
+    });
+  }
+  async conditionalBatch(conditions, operations) {
+    assertStorageBatchOperationCount("conditionalBatch conditions", conditions.length);
+    assertStorageBatchOperationCount("conditionalBatch operations", operations.length);
+    await this.#ensureTable();
+    const netEffect = resolveBatchNetEffect(operations);
+    let lastError;
+    for (let attempt = 0;attempt < MAX_SERIALIZATION_RETRIES; attempt += 1)
+      try {
+        return await this.#withTransaction(PG_BEGIN_SERIALIZABLE, async (client) => {
+          if (!await conditionsHold(client, this.#queries, conditions))
+            return !1;
+          await writeBatchNetEffect(client, this.#queries, netEffect);
+          return !0;
+        }, (committed) => committed);
+      } catch (error) {
+        if (!isRetryableTransactionFailure(error))
+          throw error;
+        lastError = error;
+      }
+    throw Error(`conditionalBatch exhausted ${MAX_SERIALIZATION_RETRIES} attempts after retryable transaction failures`, { cause: lastError });
+  }
+  async query(sql, parameters) {
+    await this.#ensureTable();
+    assertReadOnlyQuery(sql);
+    return this.#withTransaction(PG_BEGIN_READ_ONLY, async (client) => {
+      return (await client.query(sql, parameters ?? [])).rows;
+    });
+  }
+  #endPoolOnce() {
+    if (!this.#ownsPool)
+      return Promise.resolve();
+    this.#poolShutdown ??= this.#pool.end();
+    return this.#poolShutdown;
+  }
+  [Symbol.dispose]() {
+    this.#endPoolOnce().catch(() => {});
+  }
+  async[Symbol.asyncDispose]() {
+    await this.#endPoolOnce();
+  }
+}

package/dist/storage/postgres.d.ts

@@ -0,0 +1,59 @@
+import { PostgresKeyValueStorage, type PostgresKeyValueStorageOptions, type PostgresPool, type PostgresPoolClient } from './postgres-key-value-storage.ts';
+export type { PostgresPool, PostgresPoolClient };
+/**
+ * Configuration for connecting to a standard Postgres database over the ordinary
+ * wire protocol via the `pg` (node-postgres) driver. Alias of the shared
+ * {@link PostgresKeyValueStorageOptions}; `url` is optional and required only when
+ * no `pool` is supplied.
+ *
+ * @example
+ * ```ts
+ * import { PostgresStorage, type PostgresStorageOptions } from '@lostgradient/weft/storage/postgres';
+ *
+ * const options: PostgresStorageOptions = {
+ *   url: 'postgresql://user:password@localhost:5432/weft',
+ * };
+ * await using storage = new PostgresStorage(options);
+ * ```
+ */
+export type PostgresStorageOptions = PostgresKeyValueStorageOptions;
+/**
+ * Storage adapter backed by a standard Postgres server over the ordinary wire
+ * protocol via the `pg` (node-postgres) driver. A thin
+ * {@link PostgresKeyValueStorage} subclass whose only job is to supply the `pg`
+ * default pool factory; all storage behavior (SQL, value mapping,
+ * transactions/retry, schema/table qualification) lives in the driver-agnostic
+ * base. Implements the same `Storage` interface as the SQLite adapters over a
+ * single `kv(key TEXT COLLATE "C", value BYTEA)` table.
+ *
+ * Use this instead of {@link NeonStorage} when connecting to a self-hosted or
+ * managed Postgres over TCP — including sharing the same database as your
+ * application's tables by pointing `schema` at a dedicated Weft schema. The Neon
+ * serverless (WebSocket) driver is not required and never imported.
+ *
+ * **Endpoint assumption.** `capabilities()` reports `readAfterWrite:
+ * 'linearizable'`, which holds for the **primary** endpoint. A read-replica
+ * connection string would violate that guarantee — point this adapter at the
+ * primary.
+ *
+ * @example
+ * ```ts
+ * import { PostgresStorage } from '@lostgradient/weft/storage/postgres';
+ * import { Engine } from '@lostgradient/weft';
+ *
+ * await using storage = new PostgresStorage({
+ *   url: process.env['DATABASE_URL']!,
+ * });
+ * await using engine = new Engine({ storage });
+ * ```
+ */
+export declare class PostgresStorage extends PostgresKeyValueStorage {
+    /**
+     * @param options Connection configuration ({@link PostgresStorageOptions}).
+     * @param poolFactory Internal seam for constructing the owned pool from `url`.
+     *   Defaults to lazily importing the real `pg` `Pool`; tests inject a fake to
+     *   exercise owned-pool teardown without a network. Used only when no `pool` is
+     *   supplied; an injected `pool` stays caller-owned.
+     */
+    constructor(options: PostgresStorageOptions, poolFactory?: (url: string) => PostgresPool);
+}

package/dist/storage/postgres.js

@@ -0,0 +1,15 @@
+// @bun
+var $_=Object.defineProperty;var M_=(_)=>_;function H_(_,E){this[_]=M_.bind(null,E)}var b_=(_,E)=>{for(var W in E)$_(_,W,{get:E[W],enumerable:!0,configurable:!0,set:H_.bind(E,W)})};var M=(_,E)=>()=>(_&&(E=_(_=0)),E);var U_=import.meta.require,x_=(_,E,W)=>{if(E!=null){if(typeof E!=="object"&&typeof E!=="function")throw TypeError('Object expected to be assigned to "using" declaration');let X;if(W)X=E[Symbol.asyncDispose];if(X===void 0)X=E[Symbol.dispose];if(typeof X!=="function")throw TypeError("Object not disposable");_.push([W,X,E])}else if(W)_.push([W]);return E},I_=(_,E,W)=>{let X=(F)=>E=W?new SuppressedError(F,E,"An error was suppressed during disposal"):(W=!0,F),J=(F)=>{while(F=_.pop())try{var Q=F[1]&&F[1].call(F[2]);if(F[0])return Promise.resolve(Q).then(J,(Z)=>(X(Z),J()))}catch(Z){X(Z)}if(W)throw E};return J()};function N(_,E,W){if(!_.capabilities()[E])throw Error(`Feature "${W}" requires storage capability "${E}", but this storage backend does not provide it.`)}function V_(_){let E=_.capabilities(),W=[];if(E.persistence!=="local"&&E.persistence!=="remote")W.push(`persistence must be "local" or "remote" (got "${E.persistence}")`);if(E.readAfterWrite!=="linearizable")W.push(`readAfterWrite must be "linearizable" (got "${E.readAfterWrite}")`);if(E.scanConsistency!=="snapshot")W.push(`scanConsistency must be "snapshot" (got "${E.scanConsistency}")`);if(!E.atomicBatch)W.push("atomicBatch must be true");if(!E.conditionalBatch)W.push("conditionalBatch must be true");if(W.length>0)throw Error(`Storage is not durable enough for recovery: ${W.join("; ")}.`)}var C="default";async function h(_,E){return await _.get(E)!==null}async function*U(_,E,W){for await(let[X]of _.scan(E,W))yield X}async function b(_,E){let W=0;for await(let X of U(_,E))W++;return W}async function x(_,E){let W=[];for await(let X of U(_,E))W.push({type:"delete",key:X});if(W.length===0)return 0;return await _.batch(W),W.length}async function I(_,E,W){let X=[];for await(let J of U(_,E,W))X.push({type:"delete",key:J});if(X.length===0)return 0;return await _.batch(X),X.length}var j_;var y=M(()=>{j_=["actrec:","archive:","async-act:","attr:","audit:bulk:","blob:","budget:","budget-charged:","ev:","fleet-event-by-workflow:","fleet-event:","fleet-event-tail","idx:","lease:","liveness:","offload:","op:","review:","schedule:","schedule-due:","schedule-run:","sig:","sigres:","sigseq:","start-idem:","state:","tag:","tool-effect:","upd:","upk:","upr:","wf:","wf-cleanup:","wf-cleanup-needed:","wf-concurrency:","wf-concurrency-holder:","wf-deadline:","wf-delayed:","wf-finalizer-state:","wf-has-services:","wf-headers:","wf-idx-","wf-teardown:","wf-teardown-deadletter:","wf-teardown-needed:","wf-terminal:"]});function $(_,E){if(E>A)throw new g(_,E)}function u(_){return _.length>0?_.slice(0,-1)+String.fromCharCode(_.charCodeAt(_.length-1)+1):"\xFF"}function l_(_,E={}){if(E.gt!==void 0&&_<=E.gt)return!1;if(E.gte!==void 0&&_<E.gte)return!1;if(E.lt!==void 0&&_>=E.lt)return!1;if(E.lte!==void 0&&_>E.lte)return!1;return!0}function k(_,E){if(_===null||E===null)return _===E;if(_.byteLength!==E.byteLength)return!1;for(let W=0;W<_.byteLength;W++)if(_[W]!==E[W])return!1;return!0}async function c(_,E){if(_.has)return _.has(E);return h(_,E)}function w(_,E,W){if(_.keys)return _.keys(E,W);return U(_,E,W)}async function f(_,E){if(_.count)return _.count(E);return b(_,E)}async function d(_,E){if(_.deletePrefix)return _.deletePrefix(E);return x(_,E)}async function p_(_,E){$("batch operations",E.length),await _.batch(E)}async function l(_,E,W){if($("conditionalBatch conditions",E.length),$("conditionalBatch operations",W.length),N(_,"conditionalBatch","storageConditionalBatch"),!_.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return _.conditionalBatch(E,W)}function Y(_){return encodeURIComponent(_)}function a_(_){return decodeURIComponent(_)}function s_(_){try{return decodeURIComponent(_)}catch{return null}}var A=1e4,d_=1e4,g,G=(_)=>String(_).padStart(16,"0"),B_="0",L_="1",m=(_,E,W,X)=>`sig:${Y(_)}:${Y(E)}:${X}:${Y(W)}`,n_;var V=M(()=>{y();g=class g extends Error{code="StorageBatchOperationLimitExceededError";cap=A;count;target;constructor(_,E){super(`${_} count ${E} exceeds MAX_BATCH_OPERATIONS (${A}).`);this.name="StorageBatchOperationLimitExceededError",this.target=_,this.count=E}};n_={workflow:(_)=>`wf:${Y(_)}`,checkpoint:(_)=>`wf:${Y(_)}:ckpt`,checkpointHistory:(_,E)=>`wf:${Y(_)}:ckpt:${String(E).padStart(10,"0")}`,timelinePrefix:(_)=>`wf:${Y(_)}:timeline:`,timeline:(_,E)=>`wf:${Y(_)}:timeline:${String(E).padStart(10,"0")}`,schedule:(_)=>`schedule:${Y(_)}`,scheduleTick:(_,E)=>`schedule-due:${String(_).padStart(16,"0")}:${Y(E)}`,scheduleRun:(_)=>`schedule-run:${Y(_)}`,operation:(_,E,W)=>`op:${_}:${G(E)}:${W}`,operationInflight:(_)=>`op:inflight:${_}`,operationQueued:(_)=>`op:queued:${_}`,operationResolved:(_)=>`op:resolved:${_}`,operationDeadLetterPrefix:()=>"op:dead-letter:",operationDeadLetter:(_)=>`op:dead-letter:${_}`,bulkOperationAuditPrefix:()=>"audit:bulk:",bulkOperationAudit:(_,E,W)=>`audit:bulk:${G(_)}:${Y(E)}:${Y(W)}`,operationResolvedByTimePrefix:()=>"op:resolved-by-time:",operationResolvedByTime:(_,E)=>`op:resolved-by-time:${G(_)}:${Y(E)}`,asyncActivity:(_,E)=>`async-act:v1:${Y(_)}:${Y(E)}`,asyncActivityResolution:(_,E)=>`async-act:v1:${Y(_)}:${Y(E)}:resolution`,activityReconciliationPrefix:(_)=>`actrec:v1:${Y(_)}:`,activityReconciliation:(_,E,W)=>`actrec:v1:${Y(_)}:${Y(E)}:${W}`,eventPrefix:(_)=>`ev:${Y(_)}:`,event:(_,E)=>`ev:${Y(_)}:${String(E).padStart(10,"0")}`,eventHead:(_)=>`ev:${Y(_)}:head`,eventWatermark:(_)=>`ev:${Y(_)}:watermark`,fleetEventPrefix:()=>"fleet-event:",fleetEvent:(_)=>`fleet-event:${String(_).padStart(10,"0")}`,fleetEventTail:()=>"fleet-event-tail",fleetEventByWorkflowPrefix:(_)=>`fleet-event-by-workflow:${Y(_)}:`,fleetEventByWorkflow:(_,E)=>`fleet-event-by-workflow:${Y(_)}:${String(E).padStart(10,"0")}`,signal:(_,E,W)=>m(_,E,W,L_),startSignal:(_,E,W)=>m(_,E,W,B_),signalSequence:(_)=>`sigseq:v1:${Y(_)}`,signalAcceptedResponsePrefix:(_)=>`sigres:v1:${Y(_)}:`,signalAcceptedResponse:(_,E,W)=>`sigres:v1:${Y(_)}:${Y(E)}:${Y(W)}`,deadline:(_,E)=>`wf-deadline:${G(_)}:${Y(E)}`,terminalCleanup:(_,E)=>`wf-cleanup:${G(_)}:${Y(E)}`,teardownTimer:(_,E)=>`wf-teardown:${G(_)}:${Y(E)}`,delayedStart:(_,E)=>`wf-delayed:${G(_)}:${Y(E)}`,terminalWorkflowPrefix:()=>"wf-terminal:",terminalWorkflow:(_,E)=>`wf-terminal:${G(_)}:${Y(E)}`,attribute:(_)=>`attr:${Y(_)}`,attributeIndex:(_,E,W)=>`idx:${_}:${E}:${Y(W)}`,tagIndex:(_,E)=>`tag:${Y(_)}:${Y(E)}`,updatePrefix:(_)=>`upd:${Y(_)}:`,update:(_,E)=>`upd:${Y(_)}:${E}`,updateResponse:(_)=>`upr:${_}`,updateIdempotency:(_,E)=>`upk:${Y(_)}:${E}`,startIdempotency:(_)=>`start-idem:${Y(_)}`,startIdempotencySignalId:(_)=>`start-idem:${_}`,livenessPrefix:()=>"liveness:",liveness:(_)=>`liveness:${Y(_)}`,leasePrefix:()=>"lease:",leaseEpoch:()=>"lease:epoch",leaseHolder:()=>"lease:holder",budget:(_,E,W)=>`budget:${_}:${E}:${W}`,review:(_,E)=>`review:${Y(_)}:${E}`,workflowHeaders:(_)=>`wf-headers:${Y(_)}`,childCancellationPrefix:(_)=>`child-cancel:${Y(_)}:`,childCancellation:(_,E)=>`child-cancel:${Y(_)}:${Y(E)}`,terminalCleanupNeeded:(_)=>`wf-cleanup-needed:${Y(_)}`,workflowConcurrency:(_,E)=>`wf-concurrency:${Y(_)}:${Y(E)}`,workflowConcurrencyHolder:(_)=>`wf-concurrency-holder:${Y(_)}`,workflowHasServices:(_)=>`wf-has-services:${Y(_)}`,finalizerState:(_)=>`wf-finalizer-state:${Y(_)}`,teardownOwed:(_)=>`wf-teardown-needed:${Y(_)}`,teardownDeadLetter:(_)=>`wf-teardown-deadletter:${Y(_)}`,offload:(_,E)=>`offload:${Y(_)}:${E}`,archive:(_,E)=>`archive:${Y(_)}:${E}`,stateExecution:(_,E)=>`state:execution:${Y(_)}:${Y(E)}`,stateWorkflow:(_,E)=>`state:workflow-scope:${C}:${Y(_)}:${Y(E)}`,streamChunkPrefix:(_,E)=>`blob:${Y(_)}:${E}:chunk:`,streamChunk:(_,E,W)=>`blob:${Y(_)}:${E}:chunk:${String(W).padStart(10,"0")}`,streamTail:(_,E)=>`blob:${Y(_)}:${E}:tail`,streamMetadata:(_,E)=>`blob:${Y(_)}:${E}:meta`,budgetCharged:(_)=>`budget-charged:${_}`,toolEffect:(_,E,W)=>`tool-effect:${Y(_)}:${E}:${W}`,workflowVisibilityStatus:(_,E)=>`wf-idx-status:${Y(_)}:${Y(E)}`,workflowVisibilityType:(_,E)=>`wf-idx-type:${Y(_)}:${Y(E)}`,workflowVisibilityCreated:(_,E)=>`wf-idx-created:${G(_)}:${Y(E)}`,workflowVisibilityUpdated:(_,E)=>`wf-idx-updated:${G(_)}:${Y(E)}`,workflowVisibilityDeadline:(_,E)=>`wf-idx-deadline:${G(_)}:${Y(E)}`,workflowVisibilityManifest:(_)=>`wf-idx-manifest:${Y(_)}`,workflowVisibilityMetaVersion:()=>"wf-idx-meta:version",workflowVisibilityMetaBuiltAt:()=>"wf-idx-meta:built-at",workflowVisibilityMetaCursor:()=>"wf-idx-meta:cursor"}});function D_(_){if(_===void 0)return;if(typeof _!=="number"||!Number.isInteger(_)||_<0)throw Error("deleteRange limit must be a finite non-negative integer");return _===0?0:_}function j(_){let E={},W=!1;for(let J of["gt","gte","lt","lte"]){let F=_[J];if(F===void 0)continue;if(typeof F!=="string")throw Error("deleteRange bounds must be strings");E[J]=F,W=!0}if(!W)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let X=D_(_.limit);if(X!==void 0)E.limit=X;return E}async function p(_,E,W){let X=j(W);if(_.deleteRange)return _.deleteRange(E,X);return I(_,E,X)}var S=()=>{};function T(_){return _.replaceAll(/:+$/g,"")}function N_(_,E){let W=T(_),X=T(E);if(W.length===0)return X;if(X.length===0)return W;return`${W}:${X}`}function a(_,E){return new K(_,E)}var K;var s=M(()=>{S();V();K=class K{#_;#E;constructor(_,E){this.#_=_,this.#E=T(E)}#W(_){if(this.#E.length===0)return _;return _.length===0?`${this.#E}:`:`${this.#E}:${_}`}#Y(_){if(this.#E.length===0)return _;return _.slice(this.#E.length+1)}#F(_={}){let E={};if(_.limit!==void 0)E.limit=_.limit;if(_.reverse!==void 0)E.reverse=_.reverse;if(_.gt!==void 0)E.gt=this.#W(_.gt);if(_.gte!==void 0)E.gte=this.#W(_.gte);if(_.lt!==void 0)E.lt=this.#W(_.lt);if(_.lte!==void 0)E.lte=this.#W(_.lte);return E}#J(_){let E={};if(_.limit!==void 0)E.limit=_.limit;if(_.gt!==void 0)E.gt=this.#W(_.gt);if(_.gte!==void 0)E.gte=this.#W(_.gte);if(_.lt!==void 0)E.lt=this.#W(_.lt);if(_.lte!==void 0)E.lte=this.#W(_.lte);return E}capabilities(){return this.#_.capabilities()}scoped(_){return new K(this.#_,N_(this.#E,_))}async get(_){return this.#_.get(this.#W(_))}async put(_,E){await this.#_.put(this.#W(_),E)}async delete(_){await this.#_.delete(this.#W(_))}async*scan(_,E){for await(let[W,X]of this.#_.scan(this.#W(_),this.#F(E)))yield[this.#Y(W),X]}async batch(_){$("batch operations",_.length),await this.#_.batch(_.map((E)=>{if(E.type==="put")return{type:"put",key:this.#W(E.key),value:E.value};return{type:"delete",key:this.#W(E.key)}}))}async conditionalBatch(_,E){return l(this.#_,_.map((W)=>({key:this.#W(W.key),expectedValue:W.expectedValue})),E.map((W)=>{if(W.type==="put")return{type:"put",key:this.#W(W.key),value:W.value};return{type:"delete",key:this.#W(W.key)}}))}async has(_){return c(this.#_,this.#W(_))}async deletePrefix(_){return d(this.#_,this.#W(_))}async deleteRange(_,E){let W=this.#J(j(E));return p(this.#_,this.#W(_),W)}async*keys(_,E){for await(let W of w(this.#_,this.#W(_),this.#F(E)))yield this.#Y(W)}async count(_){return f(this.#_,this.#W(_))}[Symbol.dispose](){this.#_[Symbol.dispose]()}}});function z_(_){return _.trim().replace(/;+\s*$/u,"").trim()}function O_(_){return T_.test(_)}function Q_(_){let E=z_(_);if(E.length===0)throw Error("Storage query must not be empty.");if(E.includes(";"))throw Error("Storage query must contain exactly one read-only statement.");if(K_.test(E))return;if(S_.test(E)&&O_(E))return;throw Error("Storage query only supports read-only SELECT and PRAGMA statements.")}var S_,T_,K_;var Z_=M(()=>{S_=/^PRAGMA\b/iu,T_=/^PRAGMA\s+(?:[A-Z_][A-Z0-9_]*\.)?[A-Z_][A-Z0-9_]*\s*$/iu,K_=/^SELECT\b/iu});function n(_,E){let W,X,J=!1,F=()=>{if(J)throw Error(`${E.storageName} pool has been disposed and cannot be reused. Construct a new adapter.`);return W??=E.loadPool(_).catch((Q)=>{throw W=void 0,A_(Q,E)}),W};return{query:async(Q,Z)=>{return(await F()).query(Q,Z)},connect:async()=>{return(await F()).connect()},end:async()=>{return J=!0,X??=(async()=>{if(W===void 0)return;await(await W.catch(()=>{return}))?.end()})(),X}}}var C_=/cannot find module|module_not_found|failed to resolve|could not resolve/i;function A_(_,E){let W=_ instanceof Error?_.message:String(_);if(C_.test(W))return Error(`${E.storageName} requires the optional peer dependency "${E.driverName}". Install it in your application with: bun add ${E.driverName} (or npm install ${E.driverName}).`,{cause:_});return _ instanceof Error?_:Error(W)}S();V();V();function z(_){return _.rowCount??_.affectedRows??_.rows.length}function B(_){if(_ instanceof Uint8Array)return new Uint8Array(_);return new Uint8Array(_)}function L(_){return Buffer.from(_)}function O(_){let E=new Map,W=new Set;for(let X of _)if(X.type==="put")W.delete(X.key),E.set(X.key,X.value);else E.delete(X.key),W.add(X.key);return{puts:E,deletes:W}}async function i(_,E,W){if(W.length===0)return!0;let X=W.map((Q)=>Q.key),J=await _.query(E.selectValuesByKeys,[X]),F=new Map;for(let Q of J.rows){let Z=Q.value;if(Z!==null&&Z!==void 0)F.set(Q.key,B(Z))}for(let Q of W){let Z=F.get(Q.key)??null;if(!k(Z,Q.expectedValue))return!1}return!0}async function v(_,E,W){if(W.puts.size>0){let X=[],J=[];for(let[F,Q]of W.puts)X.push(F),J.push(L(Q));await _.query(E.upsertValuesByKeys,[X,J])}if(W.deletes.size>0)await _.query(E.deleteValuesByKeys,[[...W.deletes]])}V();var r="kv",t=/^[a-z_][a-z0-9_]*$/i;function R(_,E){if(!t.test(_))throw Error(`Postgres storage ${E} name "${_}" is not a valid Postgres identifier. Use only letters, digits, and underscores, starting with a letter or underscore (matching ${t.source}).`)}function e(_){let{schema:E,table:W}=_;if(E===void 0&&W===void 0)return r;let X=W??r;if(R(X,"table"),E===void 0)return`"${X}"`;return R(E,"schema"),`"${E}"."${X}"`}function D(_){return[_,u(_)]}function __(_,E){let{gt:W,gte:X,lt:J,lte:F}=E,Q=D(_),Z=["key >= $1 AND key < $2"];if(W!==void 0)Q.push(W),Z.push(`key > $${Q.length}`);if(X!==void 0)Q.push(X),Z.push(`key >= $${Q.length}`);if(J!==void 0)Q.push(J),Z.push(`key < $${Q.length}`);if(F!==void 0)Q.push(F),Z.push(`key <= $${Q.length}`);return{conditions:Z,parameters:Q}}function o(_,E={}){let{limit:W,reverse:X}=E,{conditions:J,parameters:F}=__(_,E),Q=X?"DESC":"ASC",Z="";if(W!==void 0)F.push(W),Z=` LIMIT $${F.length}`;return{parameters:F,whereOrderLimit:`WHERE ${J.join(" AND ")} ORDER BY key ${Q}${Z}`}}function E_(_){let E=`CREATE TABLE IF NOT EXISTS ${_} (
+  key TEXT COLLATE "C" PRIMARY KEY,
+  value BYTEA NOT NULL
+)`,W=`
+  SELECT COALESCE(co.collname, 'default') AS collation
+  FROM pg_attribute a
+  LEFT JOIN pg_collation co ON co.oid = a.attcollation
+  WHERE a.attrelid = to_regclass($1) AND a.attname = 'key' AND a.attnum > 0
+`;return{tableReference:_,createTable:E,selectKeyCollation:`
+  SELECT COALESCE(co.collname, 'default') AS collation
+  FROM pg_attribute a
+  LEFT JOIN pg_collation co ON co.oid = a.attcollation
+  WHERE a.attrelid = to_regclass($1) AND a.attname = 'key' AND a.attnum > 0
+`,selectValueByKey:`SELECT value FROM ${_} WHERE key = $1`,upsertValueByKey:`INSERT INTO ${_} (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value`,deleteValueByKey:`DELETE FROM ${_} WHERE key = $1`,selectKeyPresence:`SELECT 1 AS present FROM ${_} WHERE key = $1 LIMIT 1`,countKeysByPrefix:`SELECT COUNT(*) AS count FROM ${_} WHERE key >= $1 AND key < $2`,deleteKeysByPrefix:`DELETE FROM ${_} WHERE key >= $1 AND key < $2`,selectValuesByKeys:`SELECT key, value FROM ${_} WHERE key = ANY($1)`,upsertValuesByKeys:`INSERT INTO ${_} (key, value) SELECT * FROM unnest($1::text[], $2::bytea[]) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value`,deleteValuesByKeys:`DELETE FROM ${_} WHERE key = ANY($1)`,keyValueRangeSelect(X,J={}){let{parameters:F,whereOrderLimit:Q}=o(X,J);return{parameters:F,sql:`SELECT key, value FROM ${_} ${Q}`}},keyRangeSelect(X,J={}){let{parameters:F,whereOrderLimit:Q}=o(X,J);return{parameters:F,sql:`SELECT key FROM ${_} ${Q}`}},keyRangeDelete(X,J){let{conditions:F,parameters:Q}=__(X,J),Z=F.join(" AND ");if(J.limit===void 0)return{parameters:Q,sql:`DELETE FROM ${_} WHERE ${Z}`};return Q.push(J.limit),{parameters:Q,sql:`DELETE FROM ${_} WHERE key IN (SELECT key FROM ${_} WHERE ${Z} ORDER BY key ASC LIMIT $${Q.length})`}}}}var W_="BEGIN ISOLATION LEVEL SERIALIZABLE",X_="BEGIN ISOLATION LEVEL READ COMMITTED",Y_="BEGIN READ ONLY",F_="COMMIT",q="ROLLBACK";function J_(_){return R(_,"schema"),`CREATE SCHEMA IF NOT EXISTS "${_}"`}Z_();s();var v_=new Set(["40001","40P01"]),G_=5;function R_(_){if(typeof _!=="object"||_===null||!("code"in _))return!1;let E=_.code;return typeof E==="string"&&v_.has(E)}class P{#_;#E;#W;#Y;#F;#J;constructor(_,E){if(this.#F=_.pool===void 0,_.pool===void 0){if(_.url===void 0)throw Error("PostgresKeyValueStorage requires either a `url` to build a pool from, or a pre-built `pool`; neither was provided.");this.#_=E(_.url)}else this.#_=_.pool;this.#W=_.schema;let W=e({schema:_.schema,table:_.table});this.#E=E_(W)}capabilities(){return{persistence:"remote",readAfterWrite:"linearizable",scanConsistency:"snapshot",atomicBatch:!0,conditionalBatch:!0,boundedRangeDelete:!0}}#X(){return this.#Y??=this.#G().catch((_)=>{throw this.#Y=void 0,_}),this.#Y}async#G(){if(this.#W!==void 0)await this.#_.query(J_(this.#W));await this.#_.query(this.#E.createTable),await this.#$()}async#$(){let E=(await this.#_.query(this.#E.selectKeyCollation,[this.#E.tableReference])).rows[0]?.collation;if(E==="C")return;let W=E===void 0?"no such table":typeof E==="string"?`"${E}"`:"an unexpected collation value";throw Error(`Postgres storage requires the ${this.#E.tableReference} table's "key" column to use COLLATE "C" (found ${W}). A table created without COLLATE "C" sorts keys by the database locale, which breaks Weft's lexicographic prefix scans. Use a fresh table, or recreate it as: CREATE TABLE ${this.#E.tableReference} (key TEXT COLLATE "C" PRIMARY KEY, value BYTEA NOT NULL).`)}async get(_){await this.#X();let W=(await this.#_.query(this.#E.selectValueByKey,[_])).rows[0];if(W===void 0)return null;let X=W.value;if(X===null||X===void 0)return null;return B(X)}async put(_,E){await this.#X(),await this.#_.query(this.#E.upsertValueByKey,[_,L(E)])}async delete(_){await this.#X(),await this.#_.query(this.#E.deleteValueByKey,[_])}async has(_){return await this.#X(),(await this.#_.query(this.#E.selectKeyPresence,[_])).rows.length>0}async deletePrefix(_){await this.#X();let[E,W]=D(_),X=await this.#_.query(this.#E.deleteKeysByPrefix,[E,W]);return z(X)}async deleteRange(_,E){await this.#X();let W=j(E),{parameters:X,sql:J}=this.#E.keyRangeDelete(_,W),F=await this.#_.query(J,X);return z(F)}async*scan(_,E={}){await this.#X();let{parameters:W,sql:X}=this.#E.keyValueRangeSelect(_,E),J=await this.#_.query(X,W);for(let F of J.rows)yield[F.key,B(F.value)]}async*keys(_,E={}){await this.#X();let{parameters:W,sql:X}=this.#E.keyRangeSelect(_,E),J=await this.#_.query(X,W);for(let F of J.rows)yield F.key}async count(_){await this.#X();let[E,W]=D(_),X=await this.#_.query(this.#E.countKeysByPrefix,[E,W]);return Number(X.rows[0]?.count??0)}scoped(_){return a(this,_)}async#Q(_,E,W=()=>!0){let X=await this.#_.connect();try{await X.query(_);try{let J=await E(X);return await X.query(W(J)?F_:q),J}catch(J){throw await X.query(q).catch(()=>{}),J}}finally{X.release()}}async batch(_){if($("batch operations",_.length),_.length===0)return;await this.#X(),await this.#Q(X_,async(E)=>{await v(E,this.#E,O(_))})}async conditionalBatch(_,E){$("conditionalBatch conditions",_.length),$("conditionalBatch operations",E.length),await this.#X();let W=O(E),X;for(let J=0;J<G_;J+=1)try{return await this.#Q(W_,async(F)=>{if(!await i(F,this.#E,_))return!1;return await v(F,this.#E,W),!0},(F)=>F)}catch(F){if(!R_(F))throw F;X=F}throw Error(`conditionalBatch exhausted ${G_} attempts after retryable transaction failures`,{cause:X})}async query(_,E){return await this.#X(),Q_(_),this.#Q(Y_,async(W)=>{return(await W.query(_,E??[])).rows})}#Z(){if(!this.#F)return Promise.resolve();return this.#J??=this.#_.end(),this.#J}[Symbol.dispose](){this.#Z().catch(()=>{})}async[Symbol.asyncDispose](){await this.#Z()}}function q_(_){return n(_,{driverName:"pg",storageName:"PostgresStorage",loadPool:(E)=>import("pg").then(({default:W})=>new W.Pool({connectionString:E}))})}class P_ extends P{constructor(_,E=q_){super(_,E)}}export{P_ as PostgresStorage};