bunderstack-sync 0.17.0-beta.2 → 0.17.0-beta.3

package/src/sync-client.ts

@@ -1,97 +0,0 @@
-import type { QueryClient } from '@tanstack/react-query'
-import {
-  createClient,
-  type AnyBunderstackApp,
-  type BunderstackClient,
-  type InferInsert,
-  type InferSchema,
-  type InferSelect,
-  type InferTables,
-} from 'bunderstack-query'
-
-import { createTableCollection, type TableCollection } from './collection'
-import { createSyncRealtimeClient, type SyncRealtimeTarget } from './realtime-sync'
-
-export type RowFor<TSchema extends Record<string, unknown>, K extends keyof TSchema> =
-  [InferSelect<TSchema[K]>] extends [never]
-    ? { id: string | number }
-    : InferSelect<TSchema[K]> extends { id: string | number }
-      ? InferSelect<TSchema[K]>
-      : { id: string | number }
-
-export type CreateFor<TSchema extends Record<string, unknown>, K extends keyof TSchema> =
-  [InferInsert<TSchema[K]>] extends [never]
-    ? Partial<RowFor<TSchema, K>>
-    : InferInsert<TSchema[K]>
-
-export type SyncClientOptions = {
-  baseUrl?: string
-  fetch?: (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ) => Promise<Response>
-  queryClient: QueryClient
-  realtime?: boolean
-}
-
-export type BunderstackSyncClient<TApp extends AnyBunderstackApp> = {
-  [K in InferTables<TApp>]: TableCollection<
-    RowFor<InferSchema<TApp>, K>,
-    CreateFor<InferSchema<TApp>, K>,
-    Partial<RowFor<InferSchema<TApp>, K>>
-  >
-} & {
-  files: BunderstackClient<TApp>['files']
-  realtime: { close(): void; subscribe(tables: string[]): Promise<void> } | undefined
-}
-
-export function createSyncClient<TApp extends AnyBunderstackApp>(
-  options: SyncClientOptions,
-): BunderstackSyncClient<TApp> {
-  const api = createClient<TApp>(options)
-  const materialized = new Map<string, SyncRealtimeTarget>()
-  const realtimeHandles = new Map<string, { close(): void }>()
-  const tables = new Map<string, unknown>()
-  const realtimeEnabled = options.realtime ?? typeof window !== 'undefined'
-
-  const result = new Proxy({} as BunderstackSyncClient<TApp>, {
-    get(_target, property) {
-      if (typeof property !== 'string') return undefined
-      if (property === 'files') return api.files
-      if (property === 'realtime') {
-        return realtimeEnabled
-          ? {
-              close: () => realtimeHandles.forEach((handle) => handle.close()),
-              subscribe: async (names: string[]) => {
-                for (const name of names) void (result as any)[name]
-              },
-            }
-          : undefined
-      }
-      if (['then', 'toJSON', 'constructor', '$$typeof'].includes(property)) return undefined
-      const cached = tables.get(property)
-      if (cached) return cached
-      const collection = createTableCollection({
-        tableName: property,
-        procedures: (api as any)[property],
-        queryClient: options.queryClient,
-      })
-      tables.set(property, collection)
-      materialized.set(property, collection)
-      if (realtimeEnabled) {
-        realtimeHandles.set(
-          property,
-          createSyncRealtimeClient({
-            api: api as any,
-            queryClient: options.queryClient,
-            tables: [property],
-            resolve: (table) => materialized.get(table),
-            resolveAll: () => materialized.values(),
-          }),
-        )
-      }
-      return collection
-    },
-  })
-  return result
-}

package/src/update-queue.ts

@@ -1,93 +0,0 @@
-/** Per-key coalescing queue for high-frequency row updates.
- *
- * Cursor-shaped workloads call `collection.update()` many times a second. Sent
- * one-for-one, each call is a request, a database write and a broadcast. This
- * queue holds a single merged slot per row key: while a request is in flight,
- * further updates for that key merge into the slot and go out as one follow-up
- * once it lands. Request frequency settles at `min(update rate, 1/RTT)` without
- * a tuned throttle constant, and the optimistic UI is untouched — only the
- * network is coalesced.
- */
-
-type Waiter = {
-  resolve: () => void
-  reject: (error: unknown) => void
-}
-
-type Slot = {
-  changes: Record<string, unknown>
-  waiters: Waiter[]
-  /** Promise of the running drain loop; never rejects. */
-  done: Promise<void> | null
-}
-
-export type UpdateQueueConfig<TKey, TRow> = {
-  /** Sends one merged batch of changes and resolves with the canonical row. */
-  send: (key: TKey, changes: Record<string, unknown>) => Promise<TRow>
-  /** Called with the server's row before the batch's waiters resolve. Awaited,
-   * so a handler that needs to recover (refetch) finishes first. */
-  onResult: (row: TRow) => void | Promise<void>
-}
-
-export type UpdateQueue<TKey> = {
-  /** Queues changes for `key`. Resolves once a request carrying them lands. */
-  enqueue: (key: TKey, changes: Record<string, unknown>) => Promise<void>
-  /** Drops changes still queued for `key` (resolving their waiters) and waits
-   * for any in-flight request to land. For operations that supersede pending
-   * updates and must not race them — a delete of the same row. */
-  settle: (key: TKey) => Promise<void>
-}
-
-export function createUpdateQueue<TKey, TRow>(
-  config: UpdateQueueConfig<TKey, TRow>,
-): UpdateQueue<TKey> {
-  const slots = new Map<TKey, Slot>()
-
-  async function drain(key: TKey, slot: Slot) {
-    while (Object.keys(slot.changes).length > 0) {
-      // Taking changes and waiters as one snapshot is what guarantees a waiter
-      // resolves only after a request that carried its own changes.
-      const changes = slot.changes
-      const waiters = slot.waiters
-      slot.changes = {}
-      slot.waiters = []
-      try {
-        await config.onResult(await config.send(key, changes))
-        for (const waiter of waiters) waiter.resolve()
-      } catch (error) {
-        // Replaying queued changes on top of a failed base would diverge from
-        // the server silently, so the whole key is rolled back instead.
-        const queued = slot.waiters
-        slot.changes = {}
-        slot.waiters = []
-        for (const waiter of [...waiters, ...queued]) waiter.reject(error)
-      }
-    }
-    slots.delete(key)
-  }
-
-  return {
-    enqueue(key, changes) {
-      let slot = slots.get(key)
-      if (!slot) {
-        slot = { changes: {}, waiters: [], done: null }
-        slots.set(key, slot)
-      }
-      Object.assign(slot.changes, changes)
-      const promise = new Promise<void>((resolve, reject) => {
-        slot!.waiters.push({ resolve, reject })
-      })
-      if (!slot.done) slot.done = drain(key, slot)
-      return promise
-    },
-    settle(key) {
-      const slot = slots.get(key)
-      if (!slot) return Promise.resolve()
-      const waiters = slot.waiters
-      slot.changes = {}
-      slot.waiters = []
-      for (const waiter of waiters) waiter.resolve()
-      return slot.done ?? Promise.resolve()
-    },
-  }
-}