@kairos-es/store-postgres 0.0.0

package/dist/esm/internal/ddl.js

@@ -0,0 +1,424 @@
+import { allowedTypesPredicate, eventRecordsetColumns, qualifiedRows, taggedMatchChain } from "./matchSql.js";
+/** Default schema when the config omits one. */
+export const DEFAULT_SCHEMA = 'public';
+/** Default table prefix when the config omits one. */
+export const DEFAULT_TABLE_PREFIX = 'dcb_events';
+/**
+ * Postgres truncates any identifier to 63 bytes (`NAMEDATALEN - 1`) with only a
+ * notice. Two configs whose derived names share a 63-byte prefix would then
+ * collide silently: `CREATE INDEX IF NOT EXISTS` sees a name-match and SKIPS
+ * creating the second store's index (an invisible performance cliff), and two
+ * NOTIFY channels truncate into one (cross-store wakes, defeating cohabitation).
+ */
+const MAX_IDENTIFIER_BYTES = 63;
+/** UTF-8 byte length (identifiers are bytes, not chars, to Postgres). */
+const utf8ByteLength = value => new TextEncoder().encode(value).length;
+/**
+ * The single-atom identifiers Postgres actually materialises for a config —
+ * every table/index/function base name plus the NOTIFY channel. `schema.prefix`
+ * qualified names are two atoms to Postgres (`schema` and the table name), so
+ * each atom is measured separately, not the dotted whole.
+ */
+const derivedAtoms = config => {
+  const schema = config.schema ?? DEFAULT_SCHEMA;
+  const tablePrefix = config.tablePrefix ?? DEFAULT_TABLE_PREFIX;
+  return [['schema', schema], ['events table', tablePrefix], ['tag table', `${tablePrefix}_tags`], ['main index', `${tablePrefix}_idx_id_type`], ['tag index', `${tablePrefix}_idx_tag_main_id`], ['append function', `${tablePrefix}_append`], ['unconditional append function', `${tablePrefix}_append_unconditional`], ['NOTIFY channel', `${schema}_${tablePrefix}`.replace(/\./g, '_')]];
+};
+/**
+ * The first derived identifier that exceeds 63 bytes, as a human-readable
+ * message, or `undefined` when every name fits. Shared by `resolveNames` (which
+ * throws) and the `PostgresStoreConfig` schema filter (which fails validation),
+ * so the byte bound is enforced identically at both the name-derivation and the
+ * config-decode boundary.
+ */
+export const oversizedIdentifier = config => {
+  for (const [label, atom] of derivedAtoms(config)) {
+    const bytes = utf8ByteLength(atom);
+    if (bytes > MAX_IDENTIFIER_BYTES) {
+      return `the ${label} identifier "${atom}" is ${bytes} bytes, over Postgres's ${MAX_IDENTIFIER_BYTES}-byte limit; it would be silently truncated, risking a cross-store index-skip or NOTIFY-channel collision`;
+    }
+  }
+  return undefined;
+};
+/**
+ * Derive every owned object name from `{ schema, tablePrefix }`. The index and
+ * function *base* names are unqualified prefixes (`<prefix>_…`) because an index
+ * name is scoped to its table's schema and a function is created in `<schema>`;
+ * the tables and functions carry the schema explicitly so `sql(identifier)`
+ * dot-splits them.
+ *
+ * Throws at construction if any derived identifier would be silently truncated
+ * (see `oversizedIdentifier` / `MAX_IDENTIFIER_BYTES`) — a loud failure at the
+ * single choke point beats an invisible index-skip or channel collision later.
+ */
+export const resolveNames = config => {
+  const problem = oversizedIdentifier(config);
+  if (problem !== undefined) {
+    throw new Error(`resolveNames: ${problem}`);
+  }
+  const schema = config.schema ?? DEFAULT_SCHEMA;
+  const tablePrefix = config.tablePrefix ?? DEFAULT_TABLE_PREFIX;
+  return {
+    schema,
+    tablePrefix,
+    mainTable: `${schema}.${tablePrefix}`,
+    tagTable: `${schema}.${tablePrefix}_tags`,
+    mainIndex: `${tablePrefix}_idx_id_type`,
+    tagIndex: `${tablePrefix}_idx_tag_main_id`,
+    appendFn: `${schema}.${tablePrefix}_append`,
+    appendUnconditionalFn: `${schema}.${tablePrefix}_append_unconditional`,
+    channel: `${schema}_${tablePrefix}`.replace(/\./g, '_')
+  };
+};
+/**
+ * Quote a possibly-qualified identifier for embedding inside a plpgsql body as
+ * literal text. Splits on `.` and double-quotes each atom, mirroring what
+ * `sql(identifier)` emits, so the body's table references and the runtime's
+ * `sql(identifier)` references resolve to exactly the same object. Any embedded
+ * `"` is doubled per SQL identifier-quoting rules.
+ */
+export const quoteQualified = name => name.split('.').map(atom => `"${atom.replace(/"/g, '""')}"`).join('.');
+/**
+ * A quoted single-atom identifier (no dot-splitting) — used where a bare name is
+ * required, e.g. index/schema names.
+ */
+const quoteAtom = name => `"${name.replace(/"/g, '""')}"`;
+/**
+ * A single-quoted SQL string LITERAL (not an identifier). Used for the
+ * `pg_notify(channel, payload)` channel argument, which is a `text` VALUE, not
+ * an identifier — double-quoting it there would (wrongly) parse as a column
+ * reference. Embedded single quotes are doubled per SQL string-literal rules.
+ */
+const quoteLiteral = value => `'${value.replace(/'/g, "''")}'`;
+/**
+ * The autovacuum storage parameters, ported verbatim from upstream
+ * `postgres_tt.py`: the event log is append-heavy and effectively immutable, so
+ * vacuum is tuned to run rarely (huge thresholds) while analyze stays keen
+ * (small thresholds) to keep the planner's row estimates fresh for the tag-first
+ * CTE. Applied identically to both tables.
+ */
+const AUTOVACUUM_WITH = 'autovacuum_enabled = true, ' + 'autovacuum_vacuum_threshold = 100000000, ' + 'autovacuum_vacuum_scale_factor = 0.5, ' + 'autovacuum_analyze_threshold = 1000, ' + 'autovacuum_analyze_scale_factor = 0.01';
+/**
+ * The `LOCK TABLE <main> IN EXCLUSIVE MODE;` clause — the serialisation point of
+ * the whole engine. `EXCLUSIVE` blocks other writers (and other conditional
+ * appends) but lets readers proceed, so the check-then-insert of one append
+ * cannot interleave with another's: exactly-one-wins holds by construction, with
+ * no dependence on isolation level or unique constraints.
+ *
+ * It is a SEPARATE, OMITTABLE fragment purely so the test-only lockless twin can
+ * drop it. Production always includes it.
+ */
+const lockClause = names => `LOCK TABLE ${quoteQualified(names.mainTable)} IN EXCLUSIVE MODE;`;
+/**
+ * The shared insert → tag fan-out → NOTIFY body, emitting into a local
+ * `new_head bigint` and then `RETURN QUERY SELECT new_head`. Written as explicit
+ * sequential statements (not one mega-CTE) so control flow is obvious and the
+ * `pg_notify` fires unconditionally after a successful insert rather than
+ * depending on a data-modifying CTE being referenced.
+ *
+ * A single `INSERT … SELECT … FROM jsonb_to_recordset(…) ORDER BY ordinality`
+ * preserves batch order, and `RETURNING id, tags` is captured into a temp
+ * result set so the tag fan-out and the head can both read it. `data` arrives as
+ * a base64 text field and is `decode(…, 'base64')`-restored to `bytea`.
+ */
+const insertFanoutNotify = (names, options = {}) => {
+  const main = quoteQualified(names.mainTable);
+  const tag = quoteQualified(names.tagTable);
+  const channel = quoteLiteral(names.channel);
+  // `notify` is an OMITTABLE fragment (like the lock): production always
+  // notifies; the poll-only delivery test `CREATE OR REPLACE`s a NOTIFY-suppressed
+  // UNCONDITIONAL twin over its own prefix to prove the periodic poll — not
+  // NOTIFY — is the delivery guarantee. The conditional body never suppresses it.
+  const notify = options.notify ?? true ? `
+  -- Wake subscribers only if we actually inserted rows. NOTIFY is a payload-less
+  -- signal in spirit; a constant '1' payload is sent purely because the built-in
+  -- ref-counted listen client drops empty-payload notifications — the TS side
+  -- treats every notification as an opaque wake and ignores the payload.
+  IF new_head IS NOT NULL THEN
+    PERFORM pg_notify(${channel}, '1');
+  END IF;` : '';
+  return `  WITH ne AS (
+    SELECT type, data, tags, uuid, occurred_at, ordinality
+    FROM ROWS FROM(
+      jsonb_to_recordset(new_events) AS (${eventRecordsetColumns})
+    ) WITH ORDINALITY
+  ),
+  inserted AS (
+    INSERT INTO ${main} (type, data, tags, uuid, occurred_at)
+    SELECT ne.type, decode(ne.data, 'base64'), ne.tags, ne.uuid,
+           ne.occurred_at
+    FROM ne
+    ORDER BY ne.ordinality
+    RETURNING id, tags
+  ),
+  fanned AS (
+    INSERT INTO ${tag} (tag, main_id)
+    SELECT unnest(inserted.tags), inserted.id
+    FROM inserted
+    RETURNING main_id
+  )
+  -- fanned is a DATA-MODIFYING CTE: Postgres runs it exactly once to completion
+  -- whether or not the primary query reads its output, so the tag fan-out
+  -- happens even though nothing selects from it — and so a count(*) over it
+  -- would add nothing but work.
+  SELECT MAX(inserted.id)
+  INTO new_head
+  FROM inserted;
+${notify}`;
+};
+/**
+ * Build the body of the CONDITIONAL append function (lock → check → insert →
+ * notify), ported from upstream `dcb_conditional_append_tt` with the
+ * JSON-transport divergence (ADR-0002).
+ *
+ * Module-private: the ONLY caller is `appendFunctionStatement`, which owns the
+ * full `CREATE OR REPLACE` wrapper. Keeping the body builders unexported means a
+ * caller cannot re-introduce a hand-rolled wrapper (the drift this consolidation
+ * removes) — the wrapper is single-sourced.
+ */
+const conditionalAppendBody = (names, options = {}) => {
+  const main = quoteQualified(names.mainTable);
+  const tag = quoteQualified(names.tagTable);
+  const lock = options.lock ?? true ? `  ${lockClause(names)}\n` : '';
+  // The conditional body always notifies — `insertFanoutNotify` defaults to it,
+  // and there is deliberately no `notify` seam here: only the unconditional twin
+  // is ever notify-suppressed, by the poll-only delivery test.
+  // The tagged branch shares its match SQL with the TS read path via one builder
+  // (`internal/matchSql.ts`) — plpgsql parameter tokens here (`query_items`,
+  // `COALESCE(after_id,0)`), bound `$n` on the read side. The wildcard/tagless
+  // branches are conflict-only (the read dispatches those shapes in TS) and reuse
+  // `qi` + the shared allowed-types predicate.
+  //
+  // No compiler reaches any of this. Core's `ServableQueryShape` appears nowhere in
+  // the body text, so a member added to that union is invisible here, where
+  // `internal/readPlan.ts`'s exhaustive `switch` stops compiling — and what stands
+  // in for the compiler is the generality the body comment below claims. Worth
+  // naming is why that claim holds: the three contributions partition a query by
+  // its ITEMS — none at all, an item carrying no tags, an item carrying tags —
+  // which between them cover every `Query` value the grammar can express, so a new
+  // SHAPE changes which SQL the read compiles without changing what this body has
+  // to match. The exposure is the GRAMMAR itself: a new `QueryItem` field, or a new
+  // meaning for an existing one, is something this body ignores rather than fails
+  // on, and no `switch` over the shape union would have caught that either.
+  const after = 'COALESCE(after_id, 0)';
+  return `
+DECLARE
+  conflict_exists boolean;
+  new_head bigint;
+BEGIN
+  -- lock_timeout is set per-call by the caller via set_config(..., is_local),
+  -- so the same function honours the configured timeout without recompilation.
+${lock}  -- Conflict check, reduced to EXISTS/LIMIT 1: does ANY event after
+  -- COALESCE(after_id, 0) satisfy the guard query (items OR'd; within an item,
+  -- types OR-filter AND tags AND-superset)? Three contributions, OR'd:
+  --   * the WILDCARD (empty query_items) - any event after after_id conflicts;
+  --   * TAGLESS items (empty tags, maybe types) - a type-only / match-all item,
+  --     matched by type = ANY(types) (or any type when types is empty);
+  --   * TAGGED items - the shared tag-first match chain, identical to the read.
+  -- The servable grammar (assertServableQuery) guarantees a tagless item only
+  -- appears as the whole single-item query or the wildcard, but the check is
+  -- written generically so plain-data assembly cannot surprise it.
+  WITH ${taggedMatchChain({
+    queryItemsExpr: 'query_items',
+    afterExpr: after,
+    main,
+    tag
+  })},
+  -- Wildcard: no items at all means "match everything".
+  wildcard_conflict AS (
+    SELECT 1
+    FROM ${main} m
+    WHERE NOT EXISTS (SELECT 1 FROM qi)
+      AND m.id > ${after}
+    LIMIT 1
+  ),
+  -- Tagless items: match by type (or any type when the item has no types).
+  tagless_conflict AS (
+    SELECT 1
+    FROM qi
+    JOIN ${main} m ON m.id > ${after}
+    WHERE (qi.tags IS NULL OR array_length(qi.tags, 1) IS NULL)
+      AND ${allowedTypesPredicate('qi.types')}
+    LIMIT 1
+  ),
+  -- Tagged items: distinct-tag-count AND-superset matching (the shared source).
+  tagged_conflict AS (
+    SELECT 1
+    ${qualifiedRows({
+    main,
+    afterExpr: after
+  })}
+    LIMIT 1
+  )
+  SELECT
+    EXISTS (SELECT 1 FROM wildcard_conflict)
+    OR EXISTS (SELECT 1 FROM tagless_conflict)
+    OR EXISTS (SELECT 1 FROM tagged_conflict)
+  INTO conflict_exists;
+
+  IF NOT conflict_exists THEN
+    -- No conflict: insert the batch, fan tags out, wake subscribers, return head.
+${insertFanoutNotify(names)}
+    RETURN QUERY SELECT new_head WHERE new_head IS NOT NULL;
+  END IF;
+  -- conflict_exists = true falls through, returning zero rows = a conflict.
+  RETURN;
+END;
+`;
+};
+/**
+ * Build the body of the UNCONDITIONAL append function: no conflict check, but the
+ * SAME `LOCK TABLE … IN EXCLUSIVE MODE` as the conditional twin.
+ *
+ * WHY the lock (a deliberate divergence from upstream's lock-free twin, ADR-0002):
+ * `bigserial` ids are allocated NON-transactionally, so two lock-free
+ * unconditional writers can allocate ids 5 and 6 and COMMIT them in reverse
+ * order. Commit-order then diverges from id-order, and two invariants the rest of
+ * the engine leans on silently break:
+ *
+ *   1. a `subscribe` poll that lands between the two commits sees id 6, advances
+ *      its strict `> cursor` past 6, and PERMANENTLY skips id 5 when it commits
+ *      milliseconds later — silent event loss on the live tail;
+ *   2. a no-limit read taken while the lower id is in flight returns `head` PAST
+ *      an id no snapshot can yet see, so a decision model appending under
+ *      `{ after: head }` never examines that id as a conflict — an escaped guard.
+ *
+ * The check-free FAST PATH is preserved (no conflict CTE); only the lock is
+ * added. It restores commit-order = id-order for EVERY append, making ADR-0002's
+ * "every append participates in the same mechanism by construction" true in the
+ * strong sense. The cost — unconditional writers serialise with all other writers
+ * — is exactly the write ceiling ADR-0002 already accepts and marks benchmarkable.
+ *
+ * `options.lock` is the same OMITTABLE-fragment seam as `conditionalAppendBody`:
+ * production defaults to `true`; the commit-order repro passes `{ lock: false }`
+ * over its own prefix to prove the subscribe-skip / head-overtake scenario
+ * genuinely reproduces the bug when the lock is absent (non-vacuity), exactly as
+ * the lockless meta-test does for the conditional path.
+ *
+ * `options.notify` is the analogous seam for the poll-only delivery test — a
+ * NOTIFY-suppressed twin (`{ notify: false }`) proves the periodic poll (not
+ * NOTIFY) is the delivery guarantee. Production always notifies.
+ *
+ * Module-private, like `conditionalAppendBody`: reached only via
+ * `appendFunctionStatement`.
+ */
+const unconditionalAppendBody = (names, options = {}) => {
+  const lock = options.lock ?? true ? `  ${lockClause(names)}\n` : '';
+  // Pass the `notify` option straight through — no unwrap-then-rewrap;
+  // `insertFanoutNotify` owns the default.
+  return `
+DECLARE
+  new_head bigint;
+BEGIN
+${lock}${insertFanoutNotify(names, options)}
+  RETURN QUERY SELECT new_head WHERE new_head IS NOT NULL;
+END;
+`;
+};
+/**
+ * Build ONE complete `CREATE OR REPLACE FUNCTION … RETURNS SETOF bigint LANGUAGE
+ * plpgsql AS $kairos$…$kairos$` statement for an append function. This is the
+ * single source of the wrapper — its qualified name, argument SIGNATURE, and
+ * `$kairos$`-delimited body — consumed by `ddlStatements` (production, both twins)
+ * AND by the test installers that `CREATE OR REPLACE` a lockless / notify-
+ * suppressed twin over their own prefix.
+ *
+ * WHY one builder: `ddlStatements` plus three test twins previously hand-restated
+ * this wrapper, several with string-INTERPOLATED identifiers this module's own
+ * doctrine forbids (`"${schema}"."${prefix}_append"` rather than
+ * `quoteQualified(names.appendFn)`). A drift in the SIGNATURE across those copies
+ * is a silent footgun: `CREATE OR REPLACE` with a changed argument list creates a
+ * new OVERLOAD instead of replacing, leaving the original production function live
+ * under test. Single-sourcing name + signature makes a twin unable to diverge —
+ * a twin `CREATE OR REPLACE`s exactly the function `ddlStatements` created.
+ */
+export const appendFunctionStatement = (names, options) => {
+  // Only the qualified name, the argument SIGNATURE, and the body differ between
+  // the twins; the `CREATE OR REPLACE … RETURNS SETOF bigint … $kairos$…$kairos$`
+  // wrapper is one template, emitted once rather than restated per arm of the
+  // ternary below.
+  const [qualifiedName, argList, body] = options.kind === 'conditional' ? [names.appendFn, 'query_items jsonb, after_id bigint, new_events jsonb', conditionalAppendBody(names, options)] : [names.appendUnconditionalFn, 'new_events jsonb', unconditionalAppendBody(names, options)];
+  return `CREATE OR REPLACE FUNCTION ${quoteQualified(qualifiedName)}(
+       ${argList}
+     ) RETURNS SETOF bigint
+     LANGUAGE plpgsql AS $kairos$${body}$kairos$;`;
+};
+/**
+ * The full ordered list of idempotent DDL statements that create/refresh a
+ * store's objects. Each entry is a `sql.unsafe` statement string; VALUES are not
+ * involved (pure DDL), and every identifier is pre-quoted via `quoteQualified`
+ * to match the runtime's `sql(identifier)` resolution.
+ *
+ * Ordering matters: tables before their indexes and before the tag table's FK,
+ * functions last (they reference the tables). Everything is `IF NOT EXISTS` /
+ * `CREATE OR REPLACE`, so re-running is a no-op — the migration payload is safe
+ * to register in any migrator or to run directly.
+ */
+export const ddlStatements = names => {
+  const main = quoteQualified(names.mainTable);
+  const tag = quoteQualified(names.tagTable);
+  const schema = quoteAtom(names.schema);
+  const mainIndex = quoteAtom(names.mainIndex);
+  const tagIndex = quoteAtom(names.tagIndex);
+  return [
+  // The schema may already exist (e.g. `public`); create it defensively so a
+  // custom schema does not require a separate provisioning step.
+  `CREATE SCHEMA IF NOT EXISTS ${schema};`,
+  // Main event table. `id bigserial` gives strictly-increasing (NOT gapless)
+  // positions — a rolled-back insert permanently consumes its id, which is
+  // fine: ordering is by id alone and the store is never made gapless.
+  // `data` is NULLABLE (a payload-less event is valid); `occurred_at` is
+  // informational domain time, never an ordering key.
+  `CREATE TABLE IF NOT EXISTS ${main} (
+       id bigserial,
+       type text NOT NULL,
+       data bytea,
+       tags text[] NOT NULL,
+       uuid text NOT NULL,
+       occurred_at timestamptz NOT NULL
+     ) WITH (${AUTOVACUUM_WITH});`,
+  // Covering unique index: uniqueness on id plus INCLUDE(type) so the read
+  // path's id→type lookups are index-only.
+  `CREATE UNIQUE INDEX IF NOT EXISTS ${mainIndex}
+       ON ${main} (id) INCLUDE (type);`,
+  // Junction tag table: one row per (tag, event) OCCURRENCE, under NO
+  // uniqueness constraint — the fan-out is a plain `unnest(tags)`, so an event
+  // whose own `tags` list repeats a tag lands TWO rows here. That is not a
+  // defect to close by constraining the table: a repeated tag is legal on an
+  // event and carries no information, so refusing it would break parity with
+  // the in-memory oracle over a physical-design decision the contract knows
+  // nothing about. The match side absorbs it instead, by counting DISTINCT tags
+  // per event — `internal/matchSql.ts` owns what that buys and what it obliges
+  // the requirement count to be.
+  //
+  // The `main_id … REFERENCES` FK ties a tag row to its event; it is a VERBATIM
+  // port of upstream `postgres_tt.py` (its junction DDL carries the same
+  // `main_id bigint REFERENCES {events_table} (id)`), not an addition —
+  // ADR-0002 adopts that design. Both inserts run in one
+  // statement/transaction so the referenced main row is always visible to the
+  // tag insert. Same autovacuum tuning as the main table.
+  `CREATE TABLE IF NOT EXISTS ${tag} (
+       tag text,
+       main_id bigint REFERENCES ${main} (id)
+     ) WITH (${AUTOVACUUM_WITH});`,
+  // Composite B-tree (tag, main_id): the tag-first CTE probes by tag then
+  // joins by main_id, so this index serves both the conflict check and reads.
+  `CREATE INDEX IF NOT EXISTS ${tagIndex}
+       ON ${tag} (tag, main_id);`,
+  // Conditional append (production): lock → check → insert → notify.
+  appendFunctionStatement(names, {
+    kind: 'conditional'
+  }),
+  // Unconditional twin: lock → insert → notify, no conflict check.
+  appendFunctionStatement(names, {
+    kind: 'unconditional'
+  })];
+};
+/**
+ * Run the ordered DDL against the generic `SqlClient`. Kept here (not in the
+ * public `ensureSchema`) so the same builder feeds both the public migration
+ * payload and any internal test setup. Each statement is a separate `sql.unsafe`
+ * call so a driver that rejects multi-statement strings still works.
+ */
+export const runDdl = (sql, names) => ddlStatements(names).map(statement => sql.unsafe(statement));
+//# sourceMappingURL=ddl.js.map

package/dist/esm/internal/ddl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl.js","names":["allowedTypesPredicate","eventRecordsetColumns","qualifiedRows","taggedMatchChain","DEFAULT_SCHEMA","DEFAULT_TABLE_PREFIX","MAX_IDENTIFIER_BYTES","utf8ByteLength","value","TextEncoder","encode","length","derivedAtoms","config","schema","tablePrefix","replace","oversizedIdentifier","label","atom","bytes","undefined","resolveNames","problem","Error","mainTable","tagTable","mainIndex","tagIndex","appendFn","appendUnconditionalFn","channel","quoteQualified","name","split","map","join","quoteAtom","quoteLiteral","AUTOVACUUM_WITH","lockClause","names","insertFanoutNotify","options","main","tag","notify","conditionalAppendBody","lock","after","queryItemsExpr","afterExpr","unconditionalAppendBody","appendFunctionStatement","qualifiedName","argList","body","kind","ddlStatements","runDdl","sql","statement","unsafe"],"sources":["../../../src/internal/ddl.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/internal/matchSql.js

@@ -0,0 +1,176 @@
+/**
+ * Single source of truth for the tag-first match SQL.
+ *
+ * The servable-query matching semantics — the tagged AND-superset match with
+ * distinct-tag counting, the allowed-types filter, the exclusive `after` bound —
+ * were hand-duplicated between the TS read path (`store.ts`) and the plpgsql
+ * conflict check (`ddl.ts`): two SQL dialect-copies, in two files, that drift
+ * independently (the read's wildcard mis-routing of a degenerate empty item was
+ * one such drift). This module emits the shared fragments ONCE, parameterised by:
+ *
+ * - the PLACEHOLDER TOKENS each call site binds — plpgsql parameter names
+ *   (`query_items`, `COALESCE(after_id, 0)`) for the conflict body vs bound
+ *   `$n` placeholders for the runtime `sql.unsafe(text, params)` read; and
+ * - the PROJECTION — full rows (read) vs an `EXISTS`/`LIMIT 1` probe (conflict),
+ *   which each call site wraps around the shared `qualifiedRows` source.
+ *
+ * The `jsonb_to_recordset` event column list also lives here as ONE descriptor,
+ * so the write recordset (`ddl.ts`) and the read projection cannot disagree.
+ *
+ * Table names arrive PRE-QUOTED (via `quoteQualified` in `ddl.ts`), so this
+ * module never quotes identifiers itself and stays free of the naming logic.
+ * Every fragment assumes the main events table is aliased `m`.
+ */
+/**
+ * The event payload columns shared by the write recordset and every read
+ * projection, as `[name, recordsetType]` pairs. `id` (the `bigserial` position)
+ * is prepended by the read projection and absent from the events recordset.
+ *
+ * `as const` freezes it into a tuple of literal names so `EventColumnName` (below)
+ * can derive the exact column-name union — the whole point of the "one descriptor"
+ * story: the TS transport shapes in `internal/transport.ts` are mapped types over
+ * that union, so a column rename here is a COMPILE error there, not a silent drift
+ * the lax read boundary (ADR-0006) would only surface as corrupt data under test.
+ */
+const EVENT_COLUMNS = [['type', 'text'], ['data', 'text'], ['tags', 'text[]'], ['uuid', 'text'], ['occurred_at', 'timestamptz']];
+/**
+ * The `jsonb_to_recordset(new_events) AS (…)` column definitions —
+ * `type text, data text, tags text[], uuid text, occurred_at timestamptz`. The
+ * transport `data` is base64 TEXT (restored to `bytea` by `decode(…, 'base64')`
+ * at insert), which is why it is `text` here, not `bytea`.
+ */
+export const eventRecordsetColumns = /*#__PURE__*/EVENT_COLUMNS.map(([name, type]) => `${name} ${type}`).join(', ');
+/**
+ * The read projection column list (`id` + the event columns), optionally
+ * prefixed with a table alias (`'m.'`). Sourced from the one descriptor so it
+ * cannot drift from the recordset.
+ */
+export const readColumns = (prefix = '') => [`${prefix}id`, ...EVENT_COLUMNS.map(([name]) => `${prefix}${name}`)].join(', ');
+/**
+ * The allowed-types filter for a candidate row aliased `m`: an item with no
+ * types matches ANY type; otherwise the event's type must be one of them.
+ * `typesCol` is the `text[]` column holding the item's types — `q.allowed_types`
+ * for a tagged match, `qi.types` for a tagless one.
+ */
+export const allowedTypesPredicate = typesCol => `(array_length(${typesCol}, 1) IS NULL OR array_length(${typesCol}, 1) = 0 OR m.type = ANY(${typesCol}))`;
+/**
+ * The tag-first match CTE chain shared by the read and conflict paths: expand
+ * the query items (`qi`), join the tag junction, count DISTINCT matched tags per
+ * (event, item), and keep events matching an item's FULL tag superset. Returns
+ * `qi, initial_matches, matched_groups, qualified_ids` — the caller follows it
+ * with a projection CTE selecting from `qualified_ids`.
+ *
+ * ## Both sides of the count are SET SIZES, and that is the whole invariant
+ *
+ * `qualified_ids` compares two numbers, and the ONE thing an edit here must
+ * preserve is that they count the same kind of thing: `matched_tag_count` is the
+ * number of DISTINCT tags the event carried out of the item's requirement, so
+ * `required_tag_count` is the size of that requirement AS A SET and never the
+ * length of the list it arrived as. A query item may list one tag twice — no
+ * constructor de-duplicates, `assertServableQuery` admits it and
+ * `classifyServableQuery` routes it here — and the in-memory oracle folds an
+ * item's tags into a superset test that a repeat cannot change. Comparing a
+ * de-duplicated 1 against a list length of 2 refused such a match: the READ
+ * returned nothing and, because the plpgsql conflict body composes this same
+ * chain, the GUARD found no conflict and the append it should have refused
+ * succeeded — an optimistic-concurrency check that escaped silently.
+ *
+ * The asymmetry has two repairs — de-duplicate both sides, or expand both — and
+ * only the first is available here. The matched side CANNOT become a plain row
+ * count, because this engine's junction holds one row per (tag, event) OCCURRENCE
+ * and not per pair, so an event whose own `tags` list repeats a tag has two rows
+ * there and a row count would refuse a single-tag item against it. `ddl.ts` states
+ * that property on the junction, and it is what `COUNT(DISTINCT tag)` is here to
+ * absorb; the requirement is de-duplicated to meet it.
+ *
+ * `required_tag_count` is therefore computed in `qi`, once per ITEM, rather than
+ * in the group that consumes it — the chain groups per (event, item), so a
+ * subquery in `matched_groups` would be re-evaluated per matched event. It is
+ * `count(*)` over a `SELECT DISTINCT` rather than `count(DISTINCT …)` because the
+ * latter drops a NULL element: a `[tag, NULL]` requirement would shrink to 1,
+ * meet a single matched tag and match, where the oracle's superset test cannot be
+ * satisfied by a NULL and refuses it.
+ *
+ * The `array_length(qi.tags, 1) >= 1` guard excludes tagless items from the
+ * tagged branch (load-bearing for the conflict body, which also has a separate
+ * tagless branch; a no-op for the read, whose tagged shape is all-tagged). It
+ * reads the item's own array because it is a test of the item's SHAPE — tagged or
+ * tagless — and not part of the match arithmetic above.
+ */
+export const taggedMatchChain = tokens => `qi AS (
+    SELECT types, tags, ordinality,
+           -- Both sides of the match compare DISTINCT-TAG counts: this is the
+           -- requirement's SET size, never the length of the list it arrived as.
+           (SELECT count(*) FROM (SELECT DISTINCT req.tag FROM unnest(tags) AS req(tag)) d)
+             AS required_tag_count
+    FROM ROWS FROM(
+      jsonb_to_recordset(${tokens.queryItemsExpr}) AS (types text[], tags text[])
+    ) WITH ORDINALITY
+  ),
+  initial_matches AS (
+    SELECT t.main_id, qi.ordinality, qi.required_tag_count,
+           qi.types AS allowed_types, t.tag
+    FROM qi
+    JOIN ${tokens.tag} t ON t.tag = ANY(qi.tags)
+    WHERE t.main_id > ${tokens.afterExpr}
+      AND array_length(qi.tags, 1) >= 1
+  ),
+  matched_groups AS (
+    SELECT main_id, ordinality, required_tag_count, allowed_types,
+           COUNT(DISTINCT tag) AS matched_tag_count
+    FROM initial_matches
+    GROUP BY main_id, ordinality, required_tag_count, allowed_types
+  ),
+  qualified_ids AS (
+    SELECT main_id, allowed_types
+    FROM matched_groups
+    WHERE matched_tag_count = required_tag_count
+  )`;
+/**
+ * The shared qualified-rows source: join `qualified_ids` back to the main table
+ * (aliased `m`), re-apply the exclusive `after` bound, and filter by allowed
+ * types. The read wraps this in an ordered/limited `DISTINCT m.id` CTE; the
+ * conflict wraps it in a `SELECT 1 … LIMIT 1` existence probe.
+ */
+export const qualifiedRows = tokens => `FROM qualified_ids q
+    JOIN ${tokens.main} m ON m.id = q.main_id
+    WHERE m.id > ${tokens.afterExpr}
+      AND ${allowedTypesPredicate('q.allowed_types')}`;
+/** The wildcard read (no items): every event after the bound, ordered/limited. */
+export const wildcardReadSql = main => `SELECT ${readColumns()}
+   FROM ${main}
+   WHERE id > $1
+   ORDER BY id ASC
+   LIMIT $2`;
+/** The type-only read (single tagless item): filter by `type = ANY($2)`. */
+export const typeOnlyReadSql = main => `SELECT ${readColumns()}
+   FROM ${main}
+   WHERE id > $1 AND type = ANY($2)
+   ORDER BY id ASC
+   LIMIT $3`;
+/**
+ * The tagged read: the shared match chain, then a `filtered_ids` CTE that orders
+ * and limits the qualified ids by position, then a full-row select. Bound params
+ * are `$1` = query-items jsonb, `$2` = exclusive `after`, `$3` = limit (`NULL` =
+ * no limit).
+ */
+export const taggedReadSql = (main, tag) => `WITH ${taggedMatchChain({
+  queryItemsExpr: '$1::jsonb',
+  afterExpr: '$2',
+  main,
+  tag
+})},
+  filtered_ids AS (
+    SELECT DISTINCT m.id
+    ${qualifiedRows({
+  main,
+  afterExpr: '$2'
+})}
+    ORDER BY m.id ASC
+    LIMIT $3
+  )
+  SELECT ${readColumns('m.')}
+  FROM ${main} m
+  WHERE m.id IN (SELECT id FROM filtered_ids)
+  ORDER BY m.id ASC`;
+//# sourceMappingURL=matchSql.js.map

package/dist/esm/internal/matchSql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchSql.js","names":["EVENT_COLUMNS","eventRecordsetColumns","map","name","type","join","readColumns","prefix","allowedTypesPredicate","typesCol","taggedMatchChain","tokens","queryItemsExpr","tag","afterExpr","qualifiedRows","main","wildcardReadSql","typeOnlyReadSql","taggedReadSql"],"sources":["../../../src/internal/matchSql.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;;;;;;AAWA,MAAMA,aAAa,GAAG,CACpB,CAAC,MAAM,EAAE,MAAM,CAAC,EAChB,CAAC,MAAM,EAAE,MAAM,CAAC,EAChB,CAAC,MAAM,EAAE,QAAQ,CAAC,EAClB,CAAC,MAAM,EAAE,MAAM,CAAC,EAChB,CAAC,aAAa,EAAE,aAAa,CAAC,CAG/B;AAYD;;;;;;AAMA,OAAO,MAAMC,qBAAqB,gBAAWD,aAAa,CAACE,GAAG,CAC5D,CAAC,CAACC,IAAI,EAAEC,IAAI,CAAC,KAAK,GAAGD,IAAI,IAAIC,IAAI,EAAE,CACpC,CAACC,IAAI,CAAC,IAAI,CAAC;AAEZ;;;;;AAKA,OAAO,MAAMC,WAAW,GAAGA,CAACC,MAAM,GAAG,EAAE,KACrC,CAAC,GAAGA,MAAM,IAAI,EAAE,GAAGP,aAAa,CAACE,GAAG,CAAC,CAAC,CAACC,IAAI,CAAC,KAAK,GAAGI,MAAM,GAAGJ,IAAI,EAAE,CAAC,CAAC,CAACE,IAAI,CACxE,IAAI,CACL;AAEH;;;;;;AAMA,OAAO,MAAMG,qBAAqB,GAAIC,QAAgB,IACpD,iBAAiBA,QAAQ,gCAAgCA,QAAQ,4BAA4BA,QAAQ,IAAI;AAc3G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,OAAO,MAAMC,gBAAgB,GAAIC,MAAmB,IAClD;;;;;;;2BAOyBA,MAAM,CAACC,cAAc;;;;;;;WAOrCD,MAAM,CAACE,GAAG;wBACGF,MAAM,CAACG,SAAS;;;;;;;;;;;;;IAapC;AAEJ;;;;;;AAMA,OAAO,MAAMC,aAAa,GACxBJ,MAA+C,IAE/C;WACSA,MAAM,CAACK,IAAI;mBACHL,MAAM,CAACG,SAAS;YACvBN,qBAAqB,CAAC,iBAAiB,CAAC,EAAE;AAEtD;AACA,OAAO,MAAMS,eAAe,GAAID,IAAY,IAC1C,UAAUV,WAAW,EAAE;UACfU,IAAI;;;YAGF;AAEZ;AACA,OAAO,MAAME,eAAe,GAAIF,IAAY,IAC1C,UAAUV,WAAW,EAAE;UACfU,IAAI;;;YAGF;AAEZ;;;;;;AAMA,OAAO,MAAMG,aAAa,GAAGA,CAACH,IAAY,EAAEH,GAAW,KACrD,QAAQH,gBAAgB,CAAC;EAAEE,cAAc,EAAE,WAAW;EAAEE,SAAS,EAAE,IAAI;EAAEE,IAAI;EAAEH;AAAG,CAAE,CAAC;;;MAGjFE,aAAa,CAAC;EAAEC,IAAI;EAAEF,SAAS,EAAE;AAAI,CAAE,CAAC;;;;WAInCR,WAAW,CAAC,IAAI,CAAC;SACnBU,IAAI;;oBAEO","ignoreList":[]}