@kairos-es/store-postgres 1.0.0-alpha.3 → 1.0.0-alpha.5

package/src/store.ts

@@ -40,7 +40,6 @@
  * (`packages/core/src/SubscribeMachine.ts`), shared by every engine, and this
  * module only hands it a `fetch` and a `listen` built from the two clients.
  */
-import type { SqlClient, SqlError } from '@effect/sql'
 import type {
   DcbEvent,
   Position,
@@ -61,6 +60,7 @@ import {
   subscribeStream,
 } from '@kairos-es/core'
 import { type Array as Arr, Effect, Layer, type Scope, Stream } from 'effect'
+import type { SqlClient, SqlError } from 'effect/sql'
 import { PgClientDirect, PgClientPooled } from './clients'
 import { decodePostgresStoreConfig, type PostgresStoreConfig } from './config'
 import {
@@ -138,15 +138,19 @@ const make = (
      * Nor would such a parameter be load-bearing for the REPEATABLE READ
      * transaction this runs inside, which is the trap worth naming, since a
      * closed-over client LOOKS like it must escape to its own snapshot.
-     * `@effect/sql` resolves a statement's connection when the statement RUNS,
-     * from the FIBRE CONTEXT rather than from the client value: `withTransaction`
-     * acquires one connection and `Effect.locally`s it into
-     * `FiberRef.currentContext` under its `TransactionConnection` tag, and every
-     * statement a client builds resolves through a `getConnection` that reads
-     * that tag first, falling back to the pool acquirer only when it is absent
-     * (`@effect/sql@0.52` `src/internal/client.ts`). A statement therefore joins
-     * a transaction by being RUN inside it, and passing the client along the call
-     * chain neither adds to that nor is required by it. `read-postgres`'s
+     * `effect/sql` resolves a statement's connection when the statement RUNS,
+     * from the FIBRE CONTEXT: `withTransaction` acquires one connection and
+     * provides it under that client's OWN `TransactionConnection` key — one key
+     * per `SqlClient` instance — and every statement that client builds resolves
+     * through a `getConnection` that reads that key first, falling back to the
+     * pool only when it is absent (`effect/sql`'s `SqlClient.make`). So a
+     * statement joins a transaction by being RUN inside it AND by being built from
+     * the SAME client value that opened it; a statement from any other client,
+     * even one over the same database, runs on its own pooled connection outside
+     * the transaction. Here every statement in the frame — the isolation `SET`,
+     * the row fetch and this `MAX(id)` — comes from `pooled`, the client that
+     * opened it, so all three share its connection and its snapshot, and passing
+     * the client along the call chain would add nothing. `read-postgres`'s
      * `pinnedConnection` test observes the same fact from the SERVER: two
      * statements issued inside one transaction report one `pg_backend_pid()`.
      *
@@ -154,7 +158,7 @@ const make = (
      * supports: it carries no mutable state and recompiles on every execution.
      */
     const globalHead: Effect.Effect<Position, SqlError.SqlError> = pooled<{
-      readonly max: string | null
+      readonly max: bigint | string | null
     }>`
       SELECT MAX(id) AS max FROM ${pooled(names.mainTable)}
     `.pipe(
@@ -251,7 +255,7 @@ const make = (
      * One row of an append function's result: the new head (`MAX(id)`), or NULL /
      * zero rows for the empty/conflict cases the callers interpret.
      */
-    type AppendHeadRow = { readonly max: string | null }
+    type AppendHeadRow = { readonly max: bigint | string | null }
 
     /**
      * The ONE transaction frame every append rides: open a transaction, apply the
@@ -266,7 +270,7 @@ const make = (
       select: Effect.Effect<ReadonlyArray<AppendHeadRow>, SqlError.SqlError>,
     ): Effect.Effect<ReadonlyArray<AppendHeadRow>, SqlError.SqlError> =>
       pooled.withTransaction(
-        setLocalLockTimeout(pooled, lockTimeout).pipe(Effect.zipRight(select)),
+        setLocalLockTimeout(pooled, lockTimeout).pipe(Effect.andThen(select)),
       )
 
     const append = (
@@ -344,22 +348,23 @@ const make = (
     /**
      * Wire core's subscribe machine to the live clients: `fetch` is the
      * per-subscription compiled read plan run against the pooled client and mapped
-     * to `SequencedEvent`s; `listen` is the direct client's ref-counted, non-pooled
-     * LISTEN on this store's channel (the Neon-safe path — `clients.ts` owns why
-     * there are two clients at all). The plan is compiled ONCE here so the poll
-     * loop re-binds only the cursor.
+     * to `SequencedEvent`s; `listen` is the direct client's LISTEN on this store's
+     * channel (the Neon-safe path — `clients.ts` owns why there are two clients at
+     * all), which reserves one of that client's connections for as long as the
+     * subscription's wake fibre runs and drains its notification queue as a
+     * stream. The plan is compiled ONCE here so the poll loop re-binds only the
+     * cursor.
      *
      * The wake source is `NOTIFY`, and it is a LATENCY optimisation only: the
-     * machine's periodic position-based poll is what makes delivery correct, which
-     * matters more here than the general argument for it suggests. The
-     * `@effect/sql-pg` listen client SWALLOWS connection errors and does not
-     * auto-reconnect, so a dropped LISTEN typically goes quiet rather than
-     * erroring — the machine's listen-side retry then never fires, and the poll is
-     * the ONLY thing that recovers the subscription. The same silence is what a
-     * Neon pooled endpoint produces if `PgClientDirect` is misconfigured: the
-     * pooler drops `LISTEN`/`NOTIFY` without complaint and delivery degrades to
-     * poll-rate rather than failing, which is why that trap is a deployment-time
-     * wiring choice and not a runtime error.
+     * machine's periodic position-based poll is what makes delivery correct. A
+     * listening connection that DROPS fails its queue with the `SqlError` it died
+     * of, so the machine's listen-side retry re-subscribes on a fresh connection
+     * — but the notifications sent while it was down are gone, and only the poll
+     * recovers the events they announced. And some failures are silent: a Neon
+     * pooled endpoint, if `PgClientDirect` is misconfigured, accepts `LISTEN` and
+     * then never delivers a `NOTIFY`, so delivery degrades to poll-rate rather
+     * than failing, which is why that trap is a deployment-time wiring choice and
+     * not a runtime error.
      *
      * `E` is `SqlError.SqlError` — both seams fail with it, so the machine's single
      * error parameter carries it straight through to `makeContractStore`.
@@ -375,7 +380,9 @@ const make = (
             runFetch(pooled, plan, from, limit).pipe(
               Effect.map((rows) => rows.map(rowToSequenced)),
             ),
-          listen: direct.listen(names.channel),
+          listen: Stream.unwrap(
+            Effect.map(direct.listen(names.channel), Stream.fromQueue),
+          ),
           pollInterval,
           catchUpPageSize,
         },

package/dist/dts/clients.d.ts

@@ -1,34 +0,0 @@
-import type { SqlError } from '@effect/sql';
-import { PgClient } from '@effect/sql-pg';
-import { Context, Layer } from 'effect';
-declare const PgClientPooled_base: Context.TagClass<PgClientPooled, "@kairos-es/store-postgres/PgClientPooled", PgClient.PgClient>;
-/**
- * The pooled client tag: reads, the append function, and `notify`. Holds a
- * `PgClient` value rather than being a `PgClient.layer`, so it never collides
- * with the direct client on the shared `PgClient`/`SqlClient` tag.
- */
-export declare class PgClientPooled extends PgClientPooled_base {
-}
-declare const PgClientDirect_base: Context.TagClass<PgClientDirect, "@kairos-es/store-postgres/PgClientDirect", PgClient.PgClient>;
-/**
- * The direct (non-pooler) client tag: the `subscribe` listener ONLY. Point this
- * at a direct endpoint on Neon so `LISTEN`/`NOTIFY` is not dropped by the pooler.
- */
-export declare class PgClientDirect extends PgClientDirect_base {
-}
-/**
- * Build a `PgClientPooled` layer from a `PgClient` config. We construct the
- * client via `PgClient.make` (scoped) and place it in our OWN tag, then provide
- * `Reactivity.layer` (which `PgClient.make` requires) — exactly what the
- * built-in `PgClient.layer` does internally, minus the collision-prone claim on
- * the shared `PgClient` tag.
- */
-export declare const pooledLayer: (config: PgClient.PgClientConfig) => Layer.Layer<PgClientPooled, SqlError.SqlError>;
-/**
- * Build a `PgClientDirect` layer from a `PgClient` config. Same construction as
- * `pooledLayer`; the two differ only in which endpoint the caller points them
- * at (and that only matters on Neon).
- */
-export declare const directLayer: (config: PgClient.PgClientConfig) => Layer.Layer<PgClientDirect, SqlError.SqlError>;
-export {};
-//# sourceMappingURL=clients.d.ts.map

package/dist/dts/clients.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../src/clients.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;;AAEvC;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,mBAEE;CAAG;;AAEzC;;;GAGG;AACH,qBAAa,cAAe,SAAQ,mBAEE;CAAG;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,QAAQ,CAAC,cAAc,KAC9B,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAG7C,CAAA;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,QAAQ,CAAC,cAAc,KAC9B,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAG7C,CAAA"}

package/dist/dts/ensureSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ensureSchema.d.ts","sourceRoot":"","sources":["../../src/ensureSchema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAG9E;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACvB,QAAQ,mBAAmB,KAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,SAAS,CAQzD,CAAA"}

package/dist/dts/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,EACL,WAAW,EACX,cAAc,EACd,cAAc,EACd,WAAW,GACZ,MAAM,WAAW,CAAA;AAClB,YAAY,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA"}

package/dist/dts/internal/matchSql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchSql.d.ts","sourceRoot":"","sources":["../../../src/internal/matchSql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;GAUG;AACH,QAAA,MAAM,aAAa,kKAQlB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAExB,CAAA;AAEZ;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,eAAW,KAAG,MAGvC,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,UAAU,MAAM,KAAG,MACkD,CAAA;AAE3G,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,qCAAqC;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,WAAW,KAAG,MA6BnD,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GACxB,QAAQ,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,CAAC,KAC9C,MAImD,CAAA;AAEtD,kFAAkF;AAClF,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAKnC,CAAA;AAEZ,4EAA4E;AAC5E,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAKnC,CAAA;AAEZ;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,KAAK,MAAM,KAAG,MAWtC,CAAA"}

package/dist/dts/internal/transport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../src/internal/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAY,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,MAA+B,CAAA;AAE1E,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACrC;AAED,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,GAAI,OAAO,KAAK,KAAG,aAAa,CAAC,aAAa,CAItE,CAAA;AAEL;;;;;;GAMG;AACH,UAAU,gBAAgB;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,EAAE,CAAC,IAAI,eAAe,GAAG,gBAAgB,CAAC,CAAC,CAAC;CAAE,CAAA;AAEhF,mEAAmE;AACnE,eAAO,MAAM,WAAW,GAAI,OAAO,QAAQ,KAAG,SAQ5C,CAAA;AAEF;;;;;;GAMG;AACH,UAAU,eAAe;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAA;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAC/C,QAAQ,EAAE,CAAC,IAAI,eAAe,GAAG,eAAe,CAAC,CAAC,CAAC;CACpD,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,QAAQ,KAAG,cAS7C,CAAA"}

package/dist/dts/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/store.ts"],"names":[],"mappings":"AAkDA,OAAO,EAGL,aAAa,EAQd,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAA6B,KAAK,EAAsB,MAAM,QAAQ,CAAA;AAC7E,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1D,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAoU9E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,GAChB,SAAQ,mBAAwB,KAC/B,KAAK,CAAC,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,cAAc,GAAG,cAAc,CASnE,CAAA"}