@kairos-es/store-postgres 0.0.0

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

@@ -0,0 +1,116 @@
+/**
+ * The JSON/JSONB transport for the Postgres engine: the wire shapes and the
+ * (de)serialisers that carry an event batch / query items ACROSS the boundary into
+ * the append functions, and map a raw driver row BACK to a core `SequencedEvent`.
+ * Extracted from `store.ts` (the write side) and `internal/readPlan.ts` (the read
+ * side) so the transport concept lives in ONE module rather than being split
+ * across the write path and the read-plan compiler — the module name now predicts
+ * where transport code lives, and the two per-column type maps (`EventJson`,
+ * `EventRow`) sit next to each other rather than in two files.
+ *
+ * The 5-column event contract stays single-sourced on `EventColumnName`
+ * (`internal/matchSql.ts`), the one column-NAME descriptor: both type maps here
+ * are mapped types over it, so a column rename in `EVENT_COLUMNS` is a COMPILE
+ * error in this module, never a silent transport drift the lax read boundary
+ * (ADR-0006) would only surface as corrupt data under test.
+ *
+ * The read boundary (`rowToSequenced`) is the trusted, deliberately-lax
+ * deserialisation point (ADR-0006 store-laxness); the write boundary
+ * (`toEventJson`) serialises `data` as base64 text and domain time as an ISO
+ * string, both restored in SQL.
+ */
+import type { DcbEvent, Query, SequencedEvent } from '@kairos-es/core';
+import type { EventColumnName } from './matchSql.js';
+/**
+ * Serialise a value to a JSON STRING for transport as a `::jsonb`-cast bound
+ * parameter.
+ *
+ * WHY not `sql.json(value)`: `@effect/sql-pg`'s `json` helper binds the RAW
+ * value, and node-postgres serialises a JS *array* bound param as a Postgres
+ * ARRAY literal (`{…}`), not JSON — so `sql.json([...])::jsonb` fails with a
+ * `22P02` invalid-JSON error (an array literal is not valid JSON). Passing a
+ * pre-stringified JSON string and casting `::jsonb` sends plain text that
+ * Postgres parses as JSON, which round-trips reliably for both objects and
+ * arrays. Kept as a named helper so every JSON-transport call site is consistent
+ * and the reasoning lives in one place.
+ */
+export declare const jsonbText: (value: unknown) => string;
+/** The JSON shape of one query item: types OR-filter, tags AND-superset. */
+export interface QueryItemJson {
+    readonly types: ReadonlyArray<string>;
+    readonly tags: ReadonlyArray<string>;
+}
+/** Serialise a `Query`'s items into their transport JSON shape. */
+export declare const toQueryItemsJson: (query: Query) => ReadonlyArray<QueryItemJson>;
+/**
+ * The per-column TS types of the transport JSON shape — one entry per
+ * `EVENT_COLUMNS` name. `data` is base64 TEXT and `occurred_at` an ISO string
+ * (both restored in SQL: `decode(…, 'base64')` / `timestamptz`); the rest map
+ * straight across. Kept as a plain map so `EventJson` below is a mapped type over
+ * the ONE column descriptor rather than a hand-restated column list.
+ */
+interface EventJsonColumns {
+    readonly type: string;
+    readonly data: string;
+    readonly tags: ReadonlyArray<string>;
+    readonly uuid: string;
+    readonly occurred_at: string;
+}
+/**
+ * The JSON shape of one event as sent to the append functions, as a mapped type
+ * over the shared `EventColumnName` descriptor (`internal/matchSql.ts`). `data`
+ * is base64 text (restored to `bytea` by `decode(…, 'base64')` in plpgsql);
+ * `occurred_at` is an ISO string parsed by `timestamptz`. Because the keys come
+ * from the same descriptor that builds the `jsonb_to_recordset(new_events)`
+ * column list, the two cannot drift — rename a column in `EVENT_COLUMNS` and this
+ * mapped type stops compiling (the old key is gone from `EventJsonColumns`).
+ */
+export type EventJson = {
+    readonly [K in EventColumnName]: EventJsonColumns[K];
+};
+/** Serialise one core `DcbEvent` into its transport JSON shape. */
+export declare const toEventJson: (event: DcbEvent) => EventJson;
+/**
+ * The per-column TS types of a raw driver row — one entry per `EVENT_COLUMNS`
+ * name. These are node-postgres's decoded JS types: `data` a `Buffer` (or null
+ * for a payload-less event), `occurred_at` a JS `Date`, `tags` a `string[]`. `id`
+ * (the `bigserial` position) is NOT here — it is prepended by the read projection
+ * and absent from the events recordset, so it sits outside the shared descriptor.
+ */
+interface EventRowColumns {
+    readonly type: string;
+    readonly data: Uint8Array | null;
+    readonly tags: ReadonlyArray<string>;
+    readonly uuid: string;
+    readonly occurred_at: Date;
+}
+/**
+ * A raw row from the main table as node-postgres returns it, as `id` plus a
+ * mapped type over the shared `EventColumnName` descriptor. `id` is `int8`, which
+ * the driver hands back as a decimal STRING (JS `number` is unsafe past 2^53).
+ * The payload columns cannot drift from the read projection: a rename in
+ * `EVENT_COLUMNS` breaks this mapped type.
+ */
+export type EventRow = {
+    readonly id: string;
+} & {
+    readonly [K in EventColumnName]: EventRowColumns[K];
+};
+/**
+ * Map a raw main-table row to a core `SequencedEvent`. `data` NULL → empty bytes
+ * (a payload-less event round-trips to a zero-length `Uint8Array`); `occurred_at`
+ * Date → `DateTime.Utc`; `id` string → branded `Position`.
+ *
+ * The branded scalars (`type`, `tags`, `uuid`, `position`) are minted by trusted
+ * `as`-cast, NOT by re-running `EventType.make` / `Tag.make` etc. This is
+ * deliberate: these bytes were validated at write time, and the store schema is
+ * intentionally LAX on read (ADR-0006 store-laxness — hand-assembled or pre-ADR
+ * events must remain readable), so re-validating here could REJECT a legitimately
+ * stored value and break that contract. It mirrors the in-memory oracle, which
+ * likewise mints branded positions by cast at its trusted allocation boundary
+ * (`inMemory.ts`). The read boundary is the analogous trusted deserialisation
+ * point.
+ */
+export declare const rowToSequenced: (row: EventRow) => SequencedEvent;
+export {};
+//# sourceMappingURL=transport.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,17 @@
+import { DcbEventStore } from '@kairos-es/core';
+import { Layer } from 'effect';
+import { PgClientDirect, PgClientPooled } from './clients.js';
+import { type PostgresStoreConfig } from './config.js';
+/**
+ * The Postgres `DcbEventStore` layer factory. Builds the engine over
+ * `PgClientPooled` (reads/append/notify) and `PgClientDirect` (the subscribe
+ * listener). The caller wires those two client layers — pointing `PgClientDirect`
+ * at a direct (non-pooler) endpoint on Neon, or at the same URL as `PgClientPooled`
+ * everywhere else.
+ *
+ * `ensureSchema(config)` must have been run (by the caller's migrator or at
+ * boot) before the layer is used; the layer itself performs no DDL, so it stays
+ * a pure runtime dependency requiring only the two clients.
+ */
+export declare const layer: (config?: PostgresStoreConfig) => Layer.Layer<DcbEventStore, never, PgClientPooled | PgClientDirect>;
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/store.ts"],"names":[],"mappings":"AAoDA,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"}

package/dist/esm/clients.js

@@ -0,0 +1,51 @@
+/**
+ * The TWO store-owned Postgres clients — the "Neon trap" mitigation (ADR-0002).
+ *
+ * `@effect/sql-pg` exposes a single `PgClient` (and `SqlClient`) tag; a
+ * `PgClient.layer` claims BOTH. If we built two `PgClient.layer`s they would
+ * collide on that one tag — the second would shadow the first. So instead we
+ * define two DISTINCT `Context.Tag`s, each HOLDING a `PgClient` value:
+ *
+ * - `PgClientPooled` — the pooled client used for reads, the append function,
+ *   and `notify`. Backed by a `pg.Pool`; connections are recycled per query.
+ * - `PgClientDirect` — a client used ONLY by `subscribe`'s `listen`. Its
+ *   built-in `listen` constructs a STANDALONE `pg.Client` from the pool's
+ *   `options`, inheriting the pool's host. On a Neon POOLED endpoint
+ *   (`…-pooler…`) that standalone connection lands on the PgBouncer front door,
+ *   which SILENTLY DROPS `LISTEN`/`NOTIFY` — the subscription would simply never
+ *   wake. Pointing `PgClientDirect` at Neon's DIRECT (non-pooler) endpoint fixes
+ *   it. `subscribe` is the ONLY method that touches `PgClientDirect`.
+ *
+ * For a plain (non-Neon) Postgres both tags point at the same URL; the split
+ * costs nothing there. The two-tag design is what makes the Neon fix a
+ * deployment-time wiring choice rather than a code change.
+ */
+import { Reactivity } from '@effect/experimental';
+import { PgClient } from '@effect/sql-pg';
+import { Context, Layer } from 'effect';
+/**
+ * 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 class PgClientPooled extends /*#__PURE__*/Context.Tag('@kairos-es/store-postgres/PgClientPooled')() {}
+/**
+ * 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 class PgClientDirect extends /*#__PURE__*/Context.Tag('@kairos-es/store-postgres/PgClientDirect')() {}
+/**
+ * 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 const pooledLayer = config => Layer.scoped(PgClientPooled, PgClient.make(config)).pipe(Layer.provide(Reactivity.layer));
+/**
+ * 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 const directLayer = config => Layer.scoped(PgClientDirect, PgClient.make(config)).pipe(Layer.provide(Reactivity.layer));
+//# sourceMappingURL=clients.js.map

package/dist/esm/clients.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clients.js","names":["Reactivity","PgClient","Context","Layer","PgClientPooled","Tag","PgClientDirect","pooledLayer","config","scoped","make","pipe","provide","layer","directLayer"],"sources":["../../src/clients.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAASA,UAAU,QAAQ,sBAAsB;AAEjD,SAASC,QAAQ,QAAQ,gBAAgB;AACzC,SAASC,OAAO,EAAEC,KAAK,QAAQ,QAAQ;AAEvC;;;;;AAKA,OAAM,MAAOC,cAAe,sBAAQF,OAAO,CAACG,GAAG,CAC7C,0CAA0C,CAC3C,EAAqC;AAEtC;;;;AAIA,OAAM,MAAOC,cAAe,sBAAQJ,OAAO,CAACG,GAAG,CAC7C,0CAA0C,CAC3C,EAAqC;AAEtC;;;;;;;AAOA,OAAO,MAAME,WAAW,GACtBC,MAA+B,IAE/BL,KAAK,CAACM,MAAM,CAACL,cAAc,EAAEH,QAAQ,CAACS,IAAI,CAACF,MAAM,CAAC,CAAC,CAACG,IAAI,CACtDR,KAAK,CAACS,OAAO,CAACZ,UAAU,CAACa,KAAK,CAAC,CAChC;AAEH;;;;;AAKA,OAAO,MAAMC,WAAW,GACtBN,MAA+B,IAE/BL,KAAK,CAACM,MAAM,CAACH,cAAc,EAAEL,QAAQ,CAACS,IAAI,CAACF,MAAM,CAAC,CAAC,CAACG,IAAI,CACtDR,KAAK,CAACS,OAAO,CAACZ,UAAU,CAACa,KAAK,CAAC,CAChC","ignoreList":[]}

package/dist/esm/config.js

@@ -0,0 +1,87 @@
+/**
+ * Public configuration for a Postgres `DcbEventStore`.
+ *
+ * A store is defined entirely by its `{ schema, tablePrefix }` naming pair plus
+ * a `lockTimeout`. Everything else — table/index/function names, the NOTIFY
+ * channel, the lock scope — is DERIVED from these (see `internal/ddl.ts`), so
+ * one config value is one completely isolated store. There is deliberately NO
+ * lockless option here: the exclusive-lock serialisation is not negotiable on the
+ * production surface — the lockless variant is a test-fixture-only seam, living in
+ * an internal module reachable only from the test graph.
+ *
+ * The config is a `Schema`, not a bare interface, so that malformed input fails
+ * LOUDLY at construction (`layer`/`ensureSchema` decode through it) rather than
+ * late and obscurely on the first DDL or append — the same fail-at-the-boundary
+ * discipline core applies to `Tag`/`ReadLimit`. It rejects: an empty or dotted
+ * `schema`/`tablePrefix` atom (a dot would break the qualified-name dot-split),
+ * a negative/non-finite `lockTimeout`, and — via `oversizedIdentifier` — any
+ * `{ schema, tablePrefix }` whose derived names would exceed Postgres's 63-byte
+ * identifier limit and be silently truncated.
+ */
+import { subscriptionTuningFields } from '@kairos-es/core';
+import { Schema } from 'effect';
+import { oversizedIdentifier } from "./internal/ddl.js";
+/**
+ * A single Postgres identifier atom: non-empty and dot-free. Dots are barred
+ * because `schema`/`tablePrefix` are composed into qualified names that
+ * `sql(identifier)` dot-splits, so an embedded dot would silently re-partition
+ * the name into the wrong schema/object.
+ */
+const IdentifierAtom = /*#__PURE__*/Schema.String.pipe(/*#__PURE__*/Schema.nonEmptyString(), /*#__PURE__*/Schema.pattern(/^[^.]+$/, {
+  identifier: 'PostgresIdentifierAtom',
+  description: 'a non-empty identifier atom containing no "."'
+}));
+/**
+ * Configuration for a Postgres store instance.
+ *
+ * - `schema` — the Postgres schema that owns the store's objects (default
+ *   `public`). `ensureSchema` creates it defensively.
+ * - `tablePrefix` — the base name for the store's tables/indexes/functions
+ *   (default `dcb_events`). Two stores with different prefixes (or schemas)
+ *   cohabit one database without interference.
+ * - `lockTimeout` — seconds passed to `set_config('lock_timeout', …, true)`
+ *   inside every append, bounding how long a blocked writer waits on the
+ *   exclusive lock. `0` (the default) means wait indefinitely — parity with the
+ *   in-memory semaphore's unbounded wait, so the shared contract suite behaves
+ *   identically across engines. A non-zero timeout that fires (`55P03`) is a
+ *   Postgres-only outcome surfaced OFF the shared `append` contract (a defect),
+ *   never as `AppendConditionFailed` — the in-memory oracle cannot produce it.
+ * - `pollInterval` — MILLISECONDS a live `subscribe` waits for a NOTIFY wake
+ *   before re-reading from its cursor anyway, defaulting to core's
+ *   `DEFAULT_POLL_INTERVAL_MILLIS`. Because this engine HAS a wake source, the
+ *   value bounds worst-case live-tail latency rather than being it — only a
+ *   subscriber no NOTIFY reaches waits the whole interval; lower it (e.g. in tests)
+ *   to poll faster. See `packages/core/src/SubscribeMachine.ts` for what the poll
+ *   guarantees and what a wake source is for.
+ * - `catchUpPageSize` — the `subscribe` reconcile page size, defaulting to core's
+ *   `DEFAULT_CATCH_UP_PAGE_SIZE`: how many events a single catch-up/live read
+ *   fetches before looping.
+ */
+export const PostgresStoreConfig = /*#__PURE__*/Schema.Struct({
+  // `exact: true` keeps the decoded type at `key?: T` (never `T | undefined`),
+  // matching the repo's `exactOptionalPropertyTypes` discipline — an absent key,
+  // not an explicit `undefined`.
+  schema: Schema.optionalWith(IdentifierAtom, {
+    exact: true
+  }),
+  tablePrefix: Schema.optionalWith(IdentifierAtom, {
+    exact: true
+  }),
+  lockTimeout: Schema.optionalWith(Schema.Number.pipe(Schema.nonNegative(), Schema.finite()), {
+    exact: true
+  }),
+  // The two subscribe knobs are core's field definitions, not this engine's: see
+  // `subscriptionTuningFields`.
+  ...subscriptionTuningFields
+}).pipe(/*#__PURE__*/
+// Cross-field guard: the derived table/index/function/channel names must all
+// fit Postgres's 63-byte identifier limit. Returning the message string fails
+// the decode with it; `undefined`/`true` passes.
+Schema.filter(config => oversizedIdentifier(config) ?? true));
+/**
+ * Decode an unknown value into a validated `PostgresStoreConfig`, throwing a
+ * `ParseError` on any violation. Used by `layer`/`ensureSchema` so a bad config
+ * fails at construction time.
+ */
+export const decodePostgresStoreConfig = /*#__PURE__*/Schema.decodeUnknownSync(PostgresStoreConfig);
+//# sourceMappingURL=config.js.map

package/dist/esm/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":["subscriptionTuningFields","Schema","oversizedIdentifier","IdentifierAtom","String","pipe","nonEmptyString","pattern","identifier","description","PostgresStoreConfig","Struct","schema","optionalWith","exact","tablePrefix","lockTimeout","Number","nonNegative","finite","filter","config","decodePostgresStoreConfig","decodeUnknownSync"],"sources":["../../src/config.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;AAoBA,SAASA,wBAAwB,QAAQ,iBAAiB;AAC1D,SAASC,MAAM,QAAQ,QAAQ;AAC/B,SAASC,mBAAmB,QAAQ,mBAAgB;AAEpD;;;;;;AAMA,MAAMC,cAAc,gBAAGF,MAAM,CAACG,MAAM,CAACC,IAAI,cACvCJ,MAAM,CAACK,cAAc,EAAE,eACvBL,MAAM,CAACM,OAAO,CAAC,SAAS,EAAE;EACxBC,UAAU,EAAE,wBAAwB;EACpCC,WAAW,EAAE;CACd,CAAC,CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMC,mBAAmB,gBAAGT,MAAM,CAACU,MAAM,CAAC;EAC/C;EACA;EACA;EACAC,MAAM,EAAEX,MAAM,CAACY,YAAY,CAACV,cAAc,EAAE;IAAEW,KAAK,EAAE;EAAI,CAAE,CAAC;EAC5DC,WAAW,EAAEd,MAAM,CAACY,YAAY,CAACV,cAAc,EAAE;IAAEW,KAAK,EAAE;EAAI,CAAE,CAAC;EACjEE,WAAW,EAAEf,MAAM,CAACY,YAAY,CAC9BZ,MAAM,CAACgB,MAAM,CAACZ,IAAI,CAACJ,MAAM,CAACiB,WAAW,EAAE,EAAEjB,MAAM,CAACkB,MAAM,EAAE,CAAC,EACzD;IAAEL,KAAK,EAAE;EAAI,CAAE,CAChB;EACD;EACA;EACA,GAAGd;CACJ,CAAC,CAACK,IAAI;AACL;AACA;AACA;AACAJ,MAAM,CAACmB,MAAM,CAAEC,MAAM,IAAKnB,mBAAmB,CAACmB,MAAM,CAAC,IAAI,IAAI,CAAC,CAC/D;AAGD;;;;;AAKA,OAAO,MAAMC,yBAAyB,gBACpCrB,MAAM,CAACsB,iBAAiB,CAACb,mBAAmB,CAAC","ignoreList":[]}

package/dist/esm/ensureSchema.js

@@ -0,0 +1,45 @@
+/**
+ * `ensureSchema` — the idempotent DDL migration building block (ADR-0002).
+ *
+ * This is deliberately NOT a migrator. It is a single `Effect<void, SqlError,
+ * SqlClient>` that creates (or refreshes) every object a store owns: both
+ * tables, both indexes, and both plpgsql functions. It requires the GENERIC
+ * `SqlClient` tag — NOT `PgClientPooled` — precisely so a consumer can drop it
+ * straight into THEIR OWN migrator, e.g.:
+ *
+ * ```ts
+ * Migrator.fromRecord({
+ *   '0001_kairos_store_dcb_events': ensureSchema(config),
+ * })
+ * ```
+ *
+ * or simply run it once at boot. We ship no `FileSystem`/`Path`/`ChildProcess`
+ * dependency and no `PgMigrator`; migration ORCHESTRATION belongs to the
+ * consumer, this package only provides the idempotent PAYLOAD.
+ *
+ * Idempotence: every statement is `CREATE … IF NOT EXISTS` or `CREATE OR REPLACE
+ * FUNCTION`, so re-running against an existing store is a no-op. Names come from
+ * `sql(identifier)` (via the pre-quoted builder in `internal/ddl.ts`); the DDL
+ * bodies carry no bound values (pure schema), and the append functions keep
+ * their runtime VALUES as bound parameters, never interpolated.
+ */
+import { SqlClient } from '@effect/sql';
+import { Effect } from 'effect';
+import { decodePostgresStoreConfig } from "./config.js";
+import { resolveNames, runDdl } from "./internal/ddl.js";
+/**
+ * Produce the migration payload for `config`. Resolves the object names once and
+ * runs the ordered idempotent DDL against whatever `SqlClient` the caller's
+ * migrator (or boot code) provides.
+ */
+export const ensureSchema = config => Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  // Decode through the config schema (same guard as `layer`) so a malformed
+  // config fails at construction rather than mid-migration.
+  const names = resolveNames(decodePostgresStoreConfig(config));
+  // Sequentially, in dependency order (tables → indexes → FK → functions).
+  yield* Effect.all(runDdl(sql, names), {
+    discard: true
+  });
+});
+//# sourceMappingURL=ensureSchema.js.map

package/dist/esm/ensureSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureSchema.js","names":["SqlClient","Effect","decodePostgresStoreConfig","resolveNames","runDdl","ensureSchema","config","gen","sql","names","all","discard"],"sources":["../../src/ensureSchema.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAASA,SAAS,QAAuB,aAAa;AACtD,SAASC,MAAM,QAAQ,QAAQ;AAC/B,SAASC,yBAAyB,QAAkC,aAAU;AAC9E,SAASC,YAAY,EAAEC,MAAM,QAAQ,mBAAgB;AAErD;;;;;AAKA,OAAO,MAAMC,YAAY,GACvBC,MAA2B,IAE3BL,MAAM,CAACM,GAAG,CAAC,aAAS;EAClB,MAAMC,GAAG,GAAG,OAAOR,SAAS,CAACA,SAAS;EACtC;EACA;EACA,MAAMS,KAAK,GAAGN,YAAY,CAACD,yBAAyB,CAACI,MAAM,CAAC,CAAC;EAC7D;EACA,OAAOL,MAAM,CAACS,GAAG,CAACN,MAAM,CAACI,GAAG,EAAEC,KAAK,CAAC,EAAE;IAAEE,OAAO,EAAE;EAAI,CAAE,CAAC;AAC1D,CAAC,CAAC","ignoreList":[]}

package/dist/esm/index.js

@@ -0,0 +1,40 @@
+/**
+ * @kairos-es/store-postgres — the Postgres `DcbEventStore` backend.
+ *
+ * A single store is one `{ schema, tablePrefix }` naming pair (`PostgresStoreConfig`);
+ * every object it owns is derived from that pair, so multiple isolated stores
+ * cohabit one database. The engine is the two-table B-tree + exclusive-lock
+ * conditional append of ADR-0002, with JSON transport and a two-client Layer to
+ * survive Neon's pooled LISTEN/NOTIFY drop.
+ *
+ * Wiring, end to end:
+ *
+ * ```ts
+ * import { PgClient } from '@effect/sql-pg'
+ * import {
+ *   ensureSchema,
+ *   layer,
+ *   pooledLayer,
+ *   directLayer,
+ * } from '@kairos-es/store-postgres'
+ *
+ * const config = { schema: 'public', tablePrefix: 'dcb_events' }
+ *
+ * // 1. Register `ensureSchema(config)` in YOUR migrator (or run it at boot).
+ * // 2. Provide the two clients (same URL off Neon; a direct endpoint for
+ * //    `directLayer` on Neon), then the store layer over them.
+ * const clients = Layer.merge(
+ *   pooledLayer({ url: Redacted.make(poolUrl) }),
+ *   directLayer({ url: Redacted.make(directUrl) }),
+ * )
+ * const store = layer(config).pipe(Layer.provide(clients))
+ * ```
+ *
+ * The store `layer` performs NO DDL: it depends only on the two client tags and
+ * assumes `ensureSchema` has run. `ensureSchema` requires the generic `SqlClient`
+ * tag so it slots into any migrator; the runtime uses the store-owned tags.
+ */
+export { directLayer, PgClientDirect, PgClientPooled, pooledLayer } from "./clients.js";
+export { ensureSchema } from "./ensureSchema.js";
+export { layer } from "./store.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["directLayer","PgClientDirect","PgClientPooled","pooledLayer","ensureSchema","layer"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SACEA,WAAW,EACXC,cAAc,EACdC,cAAc,EACdC,WAAW,QACN,cAAW;AAElB,SAASC,YAAY,QAAQ,mBAAgB;AAC7C,SAASC,KAAK,QAAQ,YAAS","ignoreList":[]}