@absolutejs/sync 0.0.1 → 0.2.0

package/README.md

@@ -1,28 +1,40 @@
 # @absolutejs/sync
 
-Two small, composable primitives for live data in [Elysia](https://elysiajs.com)
-and the AbsoluteJS ecosystem:
+Reactive data primitives for [Elysia](https://elysiajs.com) and the AbsoluteJS
+ecosystem — kill polling and keep a remote store off your hot path, **on your own
+database and ORM** (Drizzle _or_ Prisma, any DB they support).
 
-- **`createReactiveHub` + `sync` plugin** — push-on-change over SSE so clients stop
-  polling. A widget subscribes to the topics its data depends on; a mutation
-  publishes those topics; subscribers refetch (or read the pushed payload) the
-  instant data changes.
+- **`createReactiveHub` + `sync` plugin** — push-on-change over SSE. A view
+  subscribes to the topics its data depends on; a mutation publishes those topics;
+  subscribers refetch (or read the pushed payload) the instant data changes.
+- **ORM adapters (`/drizzle`, `/prisma`)** — _derive_ those topics automatically
+  from a query, so you stop hand-naming them. A read maps to a `table` topic (or a
+  `table:key` row topic for a primary-key lookup); a mutation publishes the matching
+  topics.
+- **`createLiveQuery`** — a client query that hydrates once, then refetches whenever
+  one of its topics fires. Framework-agnostic (`get` + `subscribe`).
+- **Sync engine (`/engine`, `/postgres`)** — row-level reactive query results:
+  hydrate a collection once, then maintain it from `{ added, removed, changed }`
+  diffs over a WebSocket, with optimistic mutations, an offline queue, and access
+  control. CDC catches out-of-band writes; aggregations are incremental.
 - **`createWriteBehindCache`** — an in-memory hot cache with write-behind
   persistence, so a latency-sensitive hot path doesn't pay a round-trip to a remote
   store on every read/write.
 
-It is **not a sync engine.** Convex, ElectricSQL, and Zero are whole backends —
-read-set tracking, OCC/MVCC, a transaction log, client SQLite replicas. This package
-does **not** rebuild any of that. It's a thin reactive layer over the store and
-transport you already have: pair it with **Drizzle _or_ Prisma** (or any store) and
-your existing SSE/WebSocket. Dependencies are explicit (you name topics), not
-auto-tracked from query read sets. If you want a full local-first sync engine, reach
-for one of the above; if you just want to delete your polling loop and keep a remote
-DB off your hot path, reach for this.
+Unlike Convex, ElectricSQL, or Zero, it does **not** own or replicate your database
+— it stays a _library_ over the store, ORM, and transport you already have. Tier 1/2
+keep granularity deliberately coarse (table/row topics, refetch on change); the Tier
+3 engine adds true row-level diffs and optimistic writes. Single-table filtered
+queries are matched incrementally; joins (inner and left), aggregations, and
+top-N ordering are maintained incrementally through a composable operator graph
+(`query(...).filter().join().leftJoin().groupBy().orderBy()`).
 
-> Status: early (`0.0.1`). In-memory hub, write-behind cache, Elysia SSE plugin, and
-> a browser subscriber. Durable/transport adapters land in a companion
-> `-adapters` package as the API settles.
+> Status: early (`0.0.1`). Tier 1 (hub, SSE plugin, browser subscriber,
+> write-behind cache), Tier 2 (Drizzle + Prisma topic adapters, `createLiveQuery`),
+> and Tier 3 (sync engine: collections, WebSocket diff transport, optimistic
+> mutations + offline queue, CDC for Postgres/MySQL/SQLite, incremental
+> aggregations + joins, and a declarative operator graph) are in place.
+> Everything ships as subpaths of this one package.
 
 ## Install
 
@@ -30,7 +42,8 @@ DB off your hot path, reach for this.
 bun add @absolutejs/sync
 ```
 
-`elysia` is an optional peer (only needed for the `sync` plugin).
+`elysia` is an optional peer (only needed for the `sync` plugin). The Drizzle adapter
+expects `drizzle-orm` if you use it; the Prisma adapter needs no Prisma import at all.
 
 ## Reactive push — kill the polling loop
 
@@ -66,6 +79,153 @@ const sub = createSyncSubscriber({
 // sub.close() when the view unmounts
 ```
 
+`resolveTopics` on the plugin lets you derive a connection's topics from the session
+or auth instead of trusting the client's `?topics=`.
+
+## ORM auto-reactivity — stop hand-naming topics
+
+The adapters turn a query into the topics it touches, so reads and writes line up
+automatically. Same function names for both ORMs; pick the matching subpath.
+
+```ts
+// server — Drizzle
+import { eq } from 'drizzle-orm';
+import { deriveReadTopics, publishWhere } from '@absolutejs/sync/drizzle';
+
+new Elysia()
+	.use(sync({ hub }))
+	.get('/api/orders', () => db.select().from(orders)) // list -> topic "orders"
+	.patch('/api/orders/:id', async ({ params, body }) => {
+		const id = Number(params.id);
+		await db.update(orders).set(body).where(eq(orders.id, id));
+		publishWhere(hub, orders, eq(orders.id, id), { op: 'update' });
+		// publishes "orders" and "orders:<id>"
+	});
+```
+
+```ts
+// browser — createLiveQuery + Prisma topic derivation (just a model name, no deps)
+import { createLiveQuery, jsonFetcher } from '@absolutejs/sync/client';
+import { deriveReadTopics } from '@absolutejs/sync/prisma';
+
+const orders = createLiveQuery({
+	topics: deriveReadTopics('order').topics, // ['order']
+	fetcher: jsonFetcher('/api/orders')
+});
+
+orders.subscribe((state) => render(state.data)); // refetches on every order change
+// orders.close() when the view unmounts
+```
+
+`createLiveQuery` is a small observable store: `get()` for the current
+`{ data, error, loading, fetching }`, `subscribe(listener)` for changes (plugs
+straight into React's `useSyncExternalStore`), plus `refetch()` and `close()`. It
+supersedes overlapping fetches (last write wins), re-hydrates on reconnect, and takes
+`initialData` (SSR seed), `manual`, and `debounceMs`.
+
+What the adapters derive:
+
+- `deriveReadTopics(orders)` → `{ topics: ['orders'], rowLevel: false }`
+- `deriveReadTopics(orders, eq(orders.id, 5))` → `{ topics: ['orders:5'], rowLevel: true }`
+- anything more complex (joins, `and`/`or`, ranges, `in`, non-key columns) falls back
+  to the table topic — over-invalidating rather than missing an update.
+- Write side: `publishChange` (explicit keys), `publishRows` (keys from a mutation's
+  returned/created records), `publishWhere` (keys from an update/delete filter).
+
+The Prisma adapter parses Prisma's plain `where`/result objects, so it needs no
+`@prisma/client` import; the Drizzle adapter reads the schema's table objects.
+
+## Live collections — the sync engine (Tier 3)
+
+Row-level reactive results: the client holds a collection and the server pushes
+`{ added, removed, changed }` diffs over a WebSocket, instead of refetching. Define
+a collection once (the filter powers both the DB hydrate and the incremental
+matcher), expose it over `syncSocket`, and drive changes from mutations.
+
+```ts
+// server
+import { Elysia } from 'elysia';
+import { syncSocket } from '@absolutejs/sync';
+import { createSyncEngine, defineMutation } from '@absolutejs/sync/engine';
+import { prismaCollection } from '@absolutejs/sync/prisma';
+
+// `transaction` runs every mutation in your DB's transaction (any ORM), so its
+// writes are ACID and the diff is emitted only after the commit.
+const engine = createSyncEngine({
+	transaction: (run) => prisma.$transaction(run)
+});
+
+engine.register(
+	prismaCollection({
+		name: 'orders',
+		where: (params) => ({ userId: params.userId, status: 'open' }), // written once
+		find: (where) => prisma.order.findMany({ where }),
+		authorize: (params, ctx) => params.userId === ctx.userId // never leak rows
+	})
+);
+
+// Teach the engine how to persist the table once — now writes auto-emit. The
+// third arg is the transaction handle, so the write joins the mutation's tx.
+engine.registerWriter('orders', {
+	insert: (data, ctx, tx) =>
+		tx.order.create({ data: { ...data, userId: ctx.userId } }),
+	update: (data, _ctx, tx) =>
+		tx.order.update({ where: { id: data.id }, data }),
+	delete: (row, _ctx, tx) => tx.order.delete({ where: { id: row.id } })
+});
+
+engine.registerMutation(
+	defineMutation({
+		name: 'createOrder',
+		// Persists AND goes live in one step — you can't forget to emit, and the
+		// diff carries the stored row (db-assigned id). Commits atomically.
+		handler: (args, ctx, actions) => actions.insert('orders', args)
+	})
+);
+
+new Elysia()
+	.use(
+		syncSocket({
+			engine,
+			resolveContext: (data) => ({ userId: data.userId })
+		})
+	)
+	.listen(3000);
+```
+
+```ts
+// browser
+import { createSyncCollection } from '@absolutejs/sync/client';
+
+const orders = createSyncCollection({
+	url: 'ws://localhost:3000/sync/ws',
+	collection: 'orders',
+	params: { userId }
+});
+
+orders.subscribe((state) => render(state.data)); // live: diff-driven, auto-reconnect
+
+// optimistic write — instant UI, reconciled (or rolled back) by the server
+await orders.mutate({
+	name: 'createOrder',
+	args: { total: 42 },
+	optimistic: (draft) => draft.set({ id: tempId, total: 42, status: 'open' })
+});
+```
+
+- **Incremental vs refetch.** A single-table filtered collection is matched
+  incrementally (only the changed rows move). Joins/aggregations and filters the
+  matcher can't evaluate fall back to a correct re-hydrate. `createAggregate`
+  (`/engine`) maintains `count`/`sum`/`avg`/`min`/`max` + `groupBy` incrementally.
+- **Out-of-band writes.** Writes that bypass mutations are caught by a
+  `ChangeSource` — e.g. `postgresChangeSource` (`/postgres`) over `LISTEN/NOTIFY`,
+  wired with `engine.connectSource(...)` and the trigger SQL from
+  `postgresNotifyTrigger`.
+- **Offline.** Pending mutations replay on reconnect; pass `storage`
+  (e.g. `localStorageMutationStorage`) to also survive a reload.
+- **Access control is mandatory.** Each collection's `authorize` gates subscribe and
+  its filter scopes rows, so a change to a row a caller can't see never reaches them.
+
 ## Write-behind cache — keep a remote store off your hot path
 
 ```ts
@@ -90,12 +250,109 @@ it, ~3 store round-trips every 20ms ran the voice pipeline far slower than real
 
 ## API
 
-| Export | What it is |
-| --- | --- |
-| `createReactiveHub()` | In-memory topic pub/sub (`publish`, `subscribe`, `subscriberCount`). |
-| `sync({ hub, path?, resolveTopics?, heartbeatMs? })` | Elysia plugin: SSE stream of hub events. |
-| `createSyncSubscriber({ topics, onEvent, url? })` | Browser SSE client (from `@absolutejs/sync/client`). |
-| `createWriteBehindCache({ load, persist, remove?, debounceMs?, evict?, onPersistError? })` | In-memory cache + write-behind persistence. |
+### `@absolutejs/sync`
+
+| Export                                                                                     | What it is                                                           |
+| ------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
+| `createReactiveHub()`                                                                      | In-memory topic pub/sub (`publish`, `subscribe`, `subscriberCount`). |
+| `sync({ hub, path?, resolveTopics?, heartbeatMs? })`                                       | Elysia plugin: SSE stream of hub events.                             |
+| `syncSocket({ engine, path?, resolveContext? })`                                           | Elysia WebSocket plugin for the sync engine.                         |
+| `createWriteBehindCache({ load, persist, remove?, debounceMs?, evict?, onPersistError? })` | In-memory cache + write-behind persistence.                          |
+
+### `@absolutejs/sync/client`
+
+| Export                                            | What it is                                                                                                                                                         |
+| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `createSyncSubscriber({ topics, onEvent, url? })` | Browser SSE client.                                                                                                                                                |
+| `createLiveQuery({ topics, fetcher, ... })`       | Hydrate-once, refetch-on-event observable query store.                                                                                                             |
+| `jsonFetcher(url, init?)`                         | Default `fetcher`: GET + JSON parse, forwards the abort signal.                                                                                                    |
+| `createSyncCollection({ url, collection, ... })`  | Live diff-driven collection store with optimistic `mutate`.                                                                                                        |
+| `createSyncClient({ url })`                       | One socket, many collections (`client.collection(...)`). Applies a multi-collection mutation's diffs as one **consistent frame** — no torn cross-collection paint. |
+| `localStorageMutationStorage(key)`                | `localStorage`-backed offline queue for `createSyncCollection`.                                                                                                    |
+
+### Framework bindings — `@absolutejs/sync/{react,vue,svelte,angular}`
+
+Idiomatic wrappers over `createSyncCollection`, one per framework, so a live
+collection is one call. Each returns the same `{ data, status, error, mutate }`
+and is SSR-safe (the socket opens on the client only).
+
+| Subpath    | Export                                   | What it is                                           |
+| ---------- | ---------------------------------------- | ---------------------------------------------------- |
+| `/react`   | `useSyncCollection(options)`             | React hook (re-renders on diffs).                    |
+| `/vue`     | `useSyncCollection(options)`             | Vue composable (reactive refs).                      |
+| `/svelte`  | `createSyncCollectionStore(options)`     | Svelte readable store (`$store` → state) + `mutate`. |
+| `/angular` | `SyncCollectionService.connect(options)` | Angular service returning signals.                   |
+
+```tsx
+// React
+import { useSyncCollection } from '@absolutejs/sync/react';
+
+const { data, status, mutate } = useSyncCollection<Order>({
+	url: 'ws://localhost:3000/sync/ws',
+	collection: 'orders',
+	params: { userId }
+});
+
+mutate({
+	name: 'createOrder',
+	args: { total: 42 },
+	optimistic: (draft) => draft.set({ id: tempId, total: 42 } as Order)
+});
+```
+
+### `@absolutejs/sync/engine`
+
+| Export                                                                            | What it is                                                                                                                                                                                                             |
+| --------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `createSyncEngine()`                                                              | Registry + view syncer: `register`, `subscribe`, `applyChange`, `connectSource`, `registerMutation`, `registerWriter`, `runMutation`.                                                                                  |
+| `defineCollection({ name, hydrate, key?, match?, authorize?, tables? })`          | Define a syncable collection.                                                                                                                                                                                          |
+| `defineMutation({ name, handler, authorize? })`                                   | Define a server mutation. Its `handler` gets `actions.insert/update/delete` (write through a registered `TableWriter` → persists + emits in one step) plus `actions.change` (escape hatch). Changes commit atomically. |
+| `registerWriter(table, { insert, update, delete })`                               | Teach the engine how to persist a table (any ORM), so writes auto-emit — you can't write without going live.                                                                                                           |
+| `createAggregate({ key, groupBy?, value? })`                                      | Incremental count/sum/avg/min/max by group.                                                                                                                                                                            |
+| `createMaterializedView({ key, match, equals? })`                                 | The predicate-matching IVM primitive (`apply`/`reset` → diffs).                                                                                                                                                        |
+| `createPollingChangeSource({ poll, intervalMs?, startSeq?, onProcessed? })`       | DB-agnostic CDC `ChangeSource` that tails a changelog (outbox) table.                                                                                                                                                  |
+| `engine.connectCluster(bus)` + `createInMemoryClusterBus()`                       | Horizontal scale: fan changes across server instances over a `ClusterBus` (BYO Redis/Postgres; in-memory bus for dev).                                                                                                 |
+| `createPresenceHub()` + `syncSocket({ engine, presence })`                        | Ephemeral room-scoped presence (online / typing / cursors) over the same socket — not persisted, auto-cleaned on disconnect.                                                                                           |
+| `query(source).filter().map().join().leftJoin().groupBy().orderBy()`              | Declarative incremental query builder (the operator graph).                                                                                                                                                            |
+| `defineGraphCollection({ name, query, key, authorize? })`                         | Run a `query` as a live collection.                                                                                                                                                                                    |
+| `defineReactiveQuery({ name, run, key })` + `registerReactive` / `registerReader` | Read-set-tracked query: `run(ctx)` reads via `ctx.db` (`all`/`get`/`where`) and re-runs only when the rows/ranges it read change — no `match`, no manual emit.                                                         |
+
+### `@absolutejs/sync/postgres`
+
+| Export                                                       | What it is                                                       |
+| ------------------------------------------------------------ | ---------------------------------------------------------------- |
+| `postgresChangeSource({ listen, channel?, parse? })`         | CDC `ChangeSource` over `LISTEN/NOTIFY` (bring your own client). |
+| `postgresNotifyTrigger({ tables, channel?, functionName? })` | SQL to install the notify triggers (run once).                   |
+
+### `@absolutejs/sync/mysql`
+
+| Export                                                       | What it is                                                                  |
+| ------------------------------------------------------------ | --------------------------------------------------------------------------- |
+| `mysqlChangelogSchema({ tables, changelogTable?, prefix? })` | SQL to install the changelog table + triggers (run once).                   |
+| `createPollingChangeSource({ poll, ... })`                   | Tail the changelog (re-exported from the engine).                           |
+| `mysqlBinlogChangeSource({ subscribe, normalize? })`         | Higher-throughput CDC over the binlog (bring your own reader, e.g. zongji). |
+| `normalizeBinlogEvent(event)`                                | Pure: a binlog row event → engine changes.                                  |
+
+### `@absolutejs/sync/sqlite`
+
+| Export                                                        | What it is                                                |
+| ------------------------------------------------------------- | --------------------------------------------------------- |
+| `sqliteChangelogSchema({ tables, changelogTable?, prefix? })` | SQL to install the changelog table + triggers (run once). |
+| `createPollingChangeSource({ poll, ... })`                    | Tail the changelog (re-exported from the engine).         |
+
+### `@absolutejs/sync/drizzle` and `@absolutejs/sync/prisma`
+
+| Export                                                                | What it is                                                  |
+| --------------------------------------------------------------------- | ----------------------------------------------------------- |
+| `deriveReadTopics(table\|model, where?, options?)`                    | Topics a read depends on (`{ topics, rowLevel }`).          |
+| `publishChange(hub, table\|model, { keys?, op? })`                    | Publish the table topic + a row topic per key.              |
+| `publishRows(hub, table\|model, rows, { keyField?/keyColumn?, op? })` | Publish topics for returned/created records.                |
+| `publishWhere(hub, table\|model, where, { ..., op? })`                | Publish topics for an update/delete filter.                 |
+| `tableTopic` / `keyTopic`                                             | The shared topic vocabulary both sides speak.               |
+| `prismaCollection({ name, where, find, ... })` (prisma)               | A sync-engine collection; one `where` → hydrate + matcher.  |
+| `matchesWhere(where, row)` (prisma)                                   | Evaluate a Prisma `where` against a row (the matcher).      |
+| `drizzleCollection({ name, table, where, find, ... })` (drizzle)      | Same one-`where`→hydrate+matcher, for Drizzle.              |
+| `matchesDrizzleWhere(table, where, row)` (drizzle)                    | Evaluate a Drizzle SQL `where` against a row (the matcher). |
 
 ## License
 

package/dist/adapters/drizzle/collection.d.ts

@@ -0,0 +1,27 @@
+import type { SQL, Table } from 'drizzle-orm';
+import type { CollectionContext, CollectionDefinition } from '../../engine/collection';
+import type { RowKey } from '../../engine/types';
+export type DrizzleCollectionOptions<T, P = void, Ctx = CollectionContext> = {
+    /** Collection name clients subscribe to. */
+    name: string;
+    /** The Drizzle table this collection reads (drives change routing + key). */
+    table: Table;
+    /** The query filter, written once — powers both hydrate and the matcher. */
+    where: (params: P, ctx: Ctx) => SQL;
+    /** Run the read for `where` (your `db.select()...`), returning the rows. */
+    find: (where: SQL, params: P, ctx: Ctx) => Promise<Iterable<T>> | Iterable<T>;
+    /** Row identity. Defaults to the table's single primary key (else `row.id`). */
+    key?: (row: T) => RowKey;
+    /** Key column JS property, if not the table's primary key. */
+    keyColumn?: string;
+    /** Access control; return false (or throw) to deny the subscription. */
+    authorize?: (params: P, ctx: Ctx) => boolean | Promise<boolean>;
+};
+/**
+ * A sync-engine collection from one Drizzle query — the Drizzle counterpart to
+ * `prismaCollection`. You write the `where` once: it drives the DB read
+ * (`hydrate`) AND the incremental `match` (via {@link matchesDrizzleWhere}), so
+ * the two can't drift and you never hand-maintain a separate predicate. A filter
+ * the matcher can't evaluate falls back to a refetch, never a wrong result.
+ */
+export declare const drizzleCollection: <T, P = void, Ctx = CollectionContext>(options: DrizzleCollectionOptions<T, P, Ctx>) => CollectionDefinition<T, P, Ctx>;

package/dist/adapters/drizzle/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Drizzle adapter for @absolutejs/sync (Tier 2 — ORM auto-reactivity).
+ *
+ * Derives reactive-hub topics from a Drizzle schema so you stop hand-naming
+ * them: a read subscribes to the topics it depends on ({@link deriveReadTopics})
+ * and a mutation publishes the topics it invalidates ({@link publishChange} and
+ * friends). Both speak the same {@link tableTopic}/{@link keyTopic} vocabulary,
+ * so reads and writes always line up.
+ *
+ * Granularity is deliberately coarse and DB-agnostic: table-level by default,
+ * narrowing to a single row when a filter is a simple primary-key equality.
+ */
+export { keyTopic, tableTopic } from './topics';
+export { drizzleCollection } from './collection';
+export type { DrizzleCollectionOptions } from './collection';
+export { matchesDrizzleWhere, UnsupportedDrizzleFilterError } from './predicate';
+export { deriveReadTopics } from './read';
+export type { DeriveReadTopicsOptions, DerivedReadTopics } from './read';
+export { publishChange, publishRows, publishWhere } from './write';
+export type { ChangeOp, ChangePayload, PublishChangeOptions, PublishRowsOptions, PublishWhereOptions } from './write';

package/dist/adapters/drizzle/index.js

@@ -0,0 +1,265 @@
+// @bun
+// src/adapters/drizzle/topics.ts
+import {
+  Column,
+  getTableColumns,
+  getTableName,
+  is,
+  Param,
+  SQL
+} from "drizzle-orm";
+var tableTopic = (table) => getTableName(table);
+var keyTopic = (table, key) => `${getTableName(table)}:${key}`;
+var resolveKeyColumn = (table, keyColumn) => {
+  const columns = getTableColumns(table);
+  if (keyColumn !== undefined) {
+    const column = columns[keyColumn];
+    return column === undefined ? undefined : { property: keyColumn, column: column.name };
+  }
+  const primaries = Object.entries(columns).filter(([, column]) => column.primary);
+  const primary = primaries.length === 1 ? primaries[0] : undefined;
+  return primary === undefined ? undefined : { property: primary[0], column: primary[1].name };
+};
+var extractKeyFromWhere = (table, where, keyColumn) => {
+  const resolved = resolveKeyColumn(table, keyColumn);
+  if (resolved === undefined) {
+    return;
+  }
+  const chunks = where.queryChunks;
+  if (!Array.isArray(chunks)) {
+    return;
+  }
+  let column;
+  let param;
+  let tooComplex = false;
+  let operator = "";
+  for (const chunk of chunks) {
+    if (is(chunk, SQL)) {
+      return;
+    }
+    if (is(chunk, Column)) {
+      if (column !== undefined) {
+        tooComplex = true;
+      }
+      column = chunk;
+    } else if (is(chunk, Param)) {
+      if (param !== undefined) {
+        tooComplex = true;
+      }
+      param = chunk;
+    } else {
+      const value2 = chunk.value;
+      if (Array.isArray(value2)) {
+        operator += value2.join("");
+      }
+    }
+  }
+  if (tooComplex || column === undefined || param === undefined) {
+    return;
+  }
+  if (operator.trim() !== "=") {
+    return;
+  }
+  if (column.name !== resolved.column) {
+    return;
+  }
+  if (getTableName(column.table) !== getTableName(table)) {
+    return;
+  }
+  const value = param.value;
+  return typeof value === "string" || typeof value === "number" ? value : undefined;
+};
+var extractRowKeys = (table, rows, keyColumn) => {
+  const resolved = resolveKeyColumn(table, keyColumn);
+  if (resolved === undefined) {
+    return [];
+  }
+  const keys = [];
+  for (const row of rows) {
+    const value = row[resolved.property];
+    if (typeof value === "string" || typeof value === "number") {
+      keys.push(value);
+    }
+  }
+  return keys;
+};
+// src/adapters/drizzle/collection.ts
+import { getTableName as getTableName2 } from "drizzle-orm";
+
+// src/adapters/drizzle/predicate.ts
+import { Column as Column2, getTableColumns as getTableColumns2, is as is2, Param as Param2, SQL as SQL2 } from "drizzle-orm";
+
+class UnsupportedDrizzleFilterError extends Error {
+  constructor(detail) {
+    super(`Cannot evaluate Drizzle filter "${detail}" incrementally`);
+    this.name = "UnsupportedDrizzleFilterError";
+  }
+}
+var isDate = (value) => value instanceof Date;
+var equals = (value, operand) => {
+  if (operand === null) {
+    return value === null || value === undefined;
+  }
+  if (isDate(value) && isDate(operand)) {
+    return value.getTime() === operand.getTime();
+  }
+  return value === operand;
+};
+var order = (value) => isDate(value) ? value.getTime() : value;
+var compare = (value, operand) => {
+  const a = order(value);
+  const b = order(operand);
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+};
+var comparable = (value) => value !== null && value !== undefined;
+var classify = (chunks) => {
+  const cols = [];
+  const params = [];
+  const arrays = [];
+  const sqls = [];
+  const ops = [];
+  for (const chunk of chunks) {
+    if (is2(chunk, SQL2)) {
+      sqls.push(chunk);
+    } else if (is2(chunk, Column2)) {
+      cols.push(chunk);
+    } else if (is2(chunk, Param2)) {
+      params.push(chunk.value);
+    } else if (Array.isArray(chunk)) {
+      arrays.push(chunk.map((element) => is2(element, Param2) ? element.value : element));
+    } else {
+      const raw = chunk.value;
+      const text = (Array.isArray(raw) ? raw.join("") : String(raw ?? "")).trim();
+      if (text !== "" && text !== "(" && text !== ")") {
+        ops.push(text);
+      }
+    }
+  }
+  return { arrays, cols, ops, params, sqls };
+};
+var evaluateLeaf = (column, op, params, arrays, row, propFor) => {
+  const prop = propFor(column);
+  if (prop === undefined) {
+    throw new UnsupportedDrizzleFilterError(`column ${column.name}`);
+  }
+  const value = row[prop];
+  const operand = params[0];
+  switch (op) {
+    case "=":
+      return equals(value, operand);
+    case "<>":
+      return !equals(value, operand);
+    case ">":
+      return comparable(value) && compare(value, operand) > 0;
+    case ">=":
+      return comparable(value) && compare(value, operand) >= 0;
+    case "<":
+      return comparable(value) && compare(value, operand) < 0;
+    case "<=":
+      return comparable(value) && compare(value, operand) <= 0;
+    case "in":
+      return (arrays[0] ?? []).some((item) => equals(value, item));
+    case "not in":
+      return !(arrays[0] ?? []).some((item) => equals(value, item));
+    case "is null":
+      return value === null || value === undefined;
+    case "is not null":
+      return value !== null && value !== undefined;
+    default:
+      throw new UnsupportedDrizzleFilterError(op);
+  }
+};
+var evaluateCondition = (node, row, propFor) => {
+  const { cols, params, arrays, sqls, ops } = classify(node.queryChunks);
+  if (ops.length === 1 && ops[0] === "not" && sqls.length === 1 && cols.length === 0) {
+    return !evaluateCondition(sqls[0], row, propFor);
+  }
+  if (cols.length === 0 && sqls.length === 1 && ops.length === 0) {
+    return evaluateCondition(sqls[0], row, propFor);
+  }
+  if (cols.length === 0 && sqls.length >= 2 && ops.length > 0) {
+    const connective = ops[0];
+    if ((connective === "and" || connective === "or") && ops.every((op) => op === connective)) {
+      const results = sqls.map((sql) => evaluateCondition(sql, row, propFor));
+      return connective === "and" ? results.every(Boolean) : results.some(Boolean);
+    }
+    throw new UnsupportedDrizzleFilterError(ops.join(" "));
+  }
+  if (cols.length === 1 && sqls.length === 0 && ops.length === 1) {
+    return evaluateLeaf(cols[0], ops[0], params, arrays, row, propFor);
+  }
+  throw new UnsupportedDrizzleFilterError(ops.join(" ") || "unrecognized condition");
+};
+var matchesDrizzleWhere = (table, where, row) => {
+  const nameToProp = new Map;
+  for (const [prop, column] of Object.entries(getTableColumns2(table))) {
+    nameToProp.set(column.name, prop);
+  }
+  return evaluateCondition(where, row, (column) => nameToProp.get(column.name));
+};
+
+// src/adapters/drizzle/collection.ts
+var drizzleCollection = (options) => {
+  const keyProp = resolveKeyColumn(options.table, options.keyColumn)?.property;
+  const key = options.key ?? ((row) => keyProp !== undefined ? row[keyProp] : row.id);
+  return {
+    name: options.name,
+    tables: [getTableName2(options.table)],
+    hydrate: (params, ctx) => options.find(options.where(params, ctx), params, ctx),
+    match: (row, params, ctx) => matchesDrizzleWhere(options.table, options.where(params, ctx), row),
+    key,
+    authorize: options.authorize
+  };
+};
+// src/adapters/drizzle/read.ts
+var deriveReadTopics = (table, where, options = {}) => {
+  const key = where === undefined ? undefined : extractKeyFromWhere(table, where, options.keyColumn);
+  if (key === undefined) {
+    return { topics: [tableTopic(table)], rowLevel: false };
+  }
+  return { topics: [keyTopic(table, key)], rowLevel: true };
+};
+// src/adapters/drizzle/write.ts
+var publishChange = (hub, table, options = {}) => {
+  const name = tableTopic(table);
+  const keys = options.keys === undefined ? [] : [...new Set(options.keys)];
+  const payload = { table: name, op: options.op, keys };
+  const topics = [
+    ...new Set([name, ...keys.map((key) => keyTopic(table, key))])
+  ];
+  for (const topic of topics) {
+    hub.publish(topic, payload);
+  }
+  return topics;
+};
+var publishRows = (hub, table, rows, options = {}) => publishChange(hub, table, {
+  keys: extractRowKeys(table, rows, options.keyColumn),
+  op: options.op
+});
+var publishWhere = (hub, table, where, options = {}) => {
+  const key = extractKeyFromWhere(table, where, options.keyColumn);
+  return publishChange(hub, table, {
+    keys: key === undefined ? [] : [key],
+    op: options.op
+  });
+};
+export {
+  tableTopic,
+  publishWhere,
+  publishRows,
+  publishChange,
+  matchesDrizzleWhere,
+  keyTopic,
+  drizzleCollection,
+  deriveReadTopics,
+  UnsupportedDrizzleFilterError
+};
+
+//# debugId=A28CA296A764961764756E2164756E21
+//# sourceMappingURL=index.js.map