@supalive/core 0.1.4 → 0.1.5

package/dist/src/exports/server.d.ts

@@ -1,3 +1,369 @@
-export * from "../server/index";
-export { SubscriptionManager } from "../server/subscription-manager";
+import { An as RegisterSubscriptionParams, Bn as UpdateSubscriptionReadSetResult, Dn as InvalidateWritesetParams, E as Context, En as AffectedSubscription, Fn as UnregisterSubscriptionResult, In as UnregisterSubscriptionsParams, Ln as UnregisterSubscriptionsResult, Mn as RegisterSubscriptionResult, Nn as UnregisterSubscriptionParams, On as InvalidateWritesetParamsSchema, Pn as UnregisterSubscriptionParamsSchema, Rn as UpdateSubscriptionReadSetParams, Tn as CacheLayer, jn as RegisterSubscriptionParamsSchema, kn as InvalidateWritesetResult, nt as Router, wt as SupaliveDb, zn as UpdateSubscriptionReadSetParamsSchema } from "../../index-CTyXKcq_.js";
+import { t as MySqlDatabase } from "../../mysql-C8SN443m.js";
+import { t as PgDatabase } from "../../postgres-D_gwCHx-.js";
+import { _ as UpstashConfig, f as DatabaseConfig, g as SupaliveServerConfig, h as SubscriptionManagerConfig, u as SubId } from "../../types_server-Ch56y8L3.js";
+import pino, { Level } from "pino";
+import Redis$1 from "ioredis";
+
+//#region src/server/supalive-server.d.ts
+/**
+ * Supalive WebSocket Server
+ */
+declare class SupaliveWebSocketServer<TContext extends Context> {
+  private config;
+  private instanceId;
+  private httpServer;
+  private wss;
+  private cache;
+  private redisSub;
+  private db;
+  private contextRegistry;
+  private router?;
+  private sessions;
+  private serverSubscriptions;
+  private subManagerClient;
+  private stats;
+  constructor(config: SupaliveServerConfig<TContext>);
+  /**
+   * Per-session heartbeat. Fires every `HEARTBEAT_INTERVAL_MS` and does
+   * both jobs on the same tick:
+   *
+   *   1. Inactivity check + ws-protocol ping (dead-TCP detection).
+   *   2. App-level `{type:"ping"}` if the channel has been idle for at
+   *      least one heartbeat interval (client-watchdog refresh).
+   *
+   * The `lastSentAt` gate on (2) preserves the original "only ping when
+   * idle" semantics: a session producing sub:updates faster than the
+   * heartbeat interval never emits a redundant app-ping.
+   */
+  private startSessionHeartbeat;
+  private clearSessionTimers;
+  registerRouter(router: Router<any, TContext>): void;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  getStats(): {
+    instanceId: string;
+    activeConnections: number;
+    totalConnections: number;
+    activeSubscriptions: number;
+  };
+  getInstanceId(): string;
+  private setupWebSocketHandlers;
+  private handleConnection;
+  private handleMessage;
+  private processMessage;
+  private handleAuth;
+  /**
+   * Park a mutation on this session's FIFO queue and resolve when it
+   * eventually drains. The drainer is fire-and-forget: it picks up any
+   * newly enqueued op as long as one drain loop is running on this
+   * session. Callers (handleCall) own the response/error for their own
+   * op via the returned promise.
+   */
+  private enqueueMutation;
+  /**
+   * Drain the per-session mutation queue serially. Only one drain loop
+   * runs at a time per session — re-entrant calls bail immediately, the
+   * loop already in progress will pick up the new op before exiting.
+   */
+  private drainMutationQueue;
+  private handleCall;
+  private handleSubscribe;
+  private handleUnsubscribe;
+  private handleDisconnect;
+  /**
+   * Drives recovery on a sub-manager reconnect. Iterates this app server's
+   * `serverSubscriptions`, reads each subId's registration record from
+   * Redis (`sl:reg:<subId>`), and re-registers it with the sub-manager.
+   *
+   * • If the Redis record is missing, another app-server instance fully
+   *   unregistered the sub during our disconnect. We drop it locally and
+   *   send `sub:gone` to every session that was holding it.
+   * • If the sub-manager reports `recompute: true` (cache-metadata + commit
+   *   log replay detected staleness), we kick a reexec for that sub.
+   *
+   * Returns after all subs have been processed. Only then does the
+   * SubManagerClient flush its buffered invalidate writeSets.
+   */
+  private runSubManagerRecovery;
+  private runAffectedHandler;
+  /**
+   * Removes a subscription from this app server's state and notifies every
+   * session that was holding it. Used during recovery when the central
+   * registration record is gone, or after a `tracked: false` reply from the
+   * sub-manager that we can't reconcile.
+   */
+  private dropSubscriptionLocally;
+  private handleMutationCommit;
+  /**
+   * Route an affected sub to whichever instance can actually run the
+   * recompute:
+   *   • If this instance has a local session for the sub, recompute here
+   *     (fast path) and broadcast the result to every other instance.
+   *   • Otherwise broadcast a `recompute-race` to every instance in
+   *     `notifyInstances`. Each receiver tries to acquire a Redis lock
+   *     keyed by (subId, commitTs); the winner recomputes and publishes
+   *     an `update` via the normal broadcast path, losers no-op.
+   *
+   * If `notifyInstances` is empty (the sub has no live holders), we drop
+   * the message — the next subscribe will recompute fresh state.
+   */
+  private dispatchAffected;
+  private hasLocalSessionFor;
+  private publishRecomputeRace;
+  private reexecuteAffectedQuery;
+  private executeLiveQuery;
+  /**
+   * Resolve the segmentation key used in the subId/cacheKey hash for a
+   * query subscription. Priority:
+   *
+   *   1. Procedure-level `queryIdentity` override:
+   *        - `false`       → identity = `ANONYMOUS_IDENTITY` (cache shared across users)
+   *        - `string`      → that literal
+   *        - `function`    → ctx + input → string | null | undefined
+   *   2. `config.getUserId(serverCtx)` → falls back to ANONYMOUS_IDENTITY if it
+   *      returns null/undefined or isn't configured.
+   */
+  private resolveQueryIdentity;
+  private sendMessage;
+  private sendMessageRaw;
+  private sendError;
+  private subscribeToInstanceChannel;
+  /**
+   * React to a `schema:reload` broadcast: invalidate the in-memory column
+   * type cache for the named tables (or all if omitted) and re-bootstrap
+   * from Postgres so subsequent batched writes see the fresh types. Skips
+   * messages published by this instance (we already have the new types).
+   */
+  private handleSchemaReload;
+  /**
+   * Broadcast a schema-reload signal to every server instance (including
+   * this one — the handler skips self-originated messages, so calling
+   * after a local migration is safe). Pass `tables` to scope the reload;
+   * omit to flush everyone's cache.
+   */
+  publishSchemaReload(tables?: string[]): Promise<void>;
+  private handleRemoteInstanceMessage;
+  private handleRemoteRecomputeRace;
+  private publishSubscriptionUpdate;
+}
+//#endregion
+//#region src/logger.d.ts
+declare const appInstanceId: string;
+declare const isProduction: boolean;
+declare const logger: pino.Logger<never, boolean>;
+declare function logLevelOf(name: string): Level;
+declare function serializeMapValue<K extends string | number | symbol, V>(map: Map<K, V>): Record<K, V>;
+//#endregion
+//#region src/server/subscription-manager.d.ts
+/**
+ * One process per deployment. Routes each subscription operation to one of N
+ * worker threads by hashing subId. Worker threads run in parallel on separate
+ * CPU cores; this dispatcher does no Zod parsing — it reads `subId` directly
+ * from the decoded payload (the internal channel is trusted) and forwards the
+ * raw payload. The worker validates and parses with Zod before executing.
+ */
+declare class SubscriptionManager {
+  private wss;
+  private port;
+  private workers;
+  private pruneInterval;
+  private static readonly PRUNE_INTERVAL_MS;
+  constructor(config: SubscriptionManagerConfig);
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  private pruneCommitLogs;
+  workerCount(): number;
+  workerIndexFor(subId: string): number;
+  private workerFor;
+  private registerMethods;
+  private readSubId;
+  private registerSubscription;
+  private registerSubscriptionBatch;
+  private updateSubscriptionReadSet;
+  private unregisterSubscription;
+  private unregisterSubscriptions;
+  private invalidateWriteset;
+}
+//#endregion
+//#region src/server/subscription-manager-client.d.ts
+/**
+ * Callback the app server registers to process invalidations that were
+ * deferred during a sub-manager outage. When the sub-manager reconnects and
+ * the buffered writeSets are flushed in one batched RPC, the resulting
+ * `affected[]` is handed to this callback — which is expected to do the
+ * same work as the normal per-mutation `reexecuteAffectedQuery` path.
+ */
+type AffectedHandler = (affected: AffectedSubscription[]) => Promise<void>;
+/**
+ * Callback the app server registers to drive recovery on sub-manager
+ * reconnect. Iterates `serverSubscriptions`, reads `sl:reg:<subId>` from
+ * Redis, and re-registers each known sub. Resolves when complete; only then
+ * does the client's buffer flush and gated calls release.
+ */
+type RecoveryDriver = () => Promise<void>;
+interface SubManagerClientOptions {
+  url: string;
+  /**
+   * Maximum number of buffered WriteEntry records held during an outage.
+   * If exceeded, the buffer is dropped — the commit-log replay path during
+   * the next register call will catch up any missed invalidations, at the
+   * cost of a brief recompute spike. Default 50_000 entries.
+   */
+  invalidateBufferLimit?: number;
+}
+/**
+ * RPC client for the (single) sub-manager process.
+ *
+ * Design (Convex-inspired):
+ *   • The sub-manager is in-memory and ephemeral. There is no version
+ *     protocol, no client-side registration registry, no OUT_OF_SYNC
+ *     replay logic. All recovery is driven from the app server using
+ *     state it already has (`serverSubscriptions`) plus registration
+ *     records persisted to Redis at `sl:reg:<subId>`.
+ *
+ *   • Out-of-order `updateSubscriptionReadSet` calls are filtered server
+ *     side using `lastSnapshotTs` (monotonic DB commit timestamp).
+ *
+ *   • On rpc-websockets reconnect, the client:
+ *       1. Transitions to `busy` (any in-flight `invalidateWriteset`
+ *          buffers its writeSet).
+ *       2. Invokes the app server's `recoveryDriver` to re-register all
+ *          known subs.
+ *       3. Flushes the buffer as one batched `invalidateWriteset` RPC and
+ *          hands the resulting `affected[]` to `affectedHandler`.
+ *       4. Transitions to `ready`.
+ *
+ *   • During an extended outage, the buffer is bounded; if exceeded, it
+ *     is dropped and we rely on the commit-log replay built into
+ *     `SubscriptionWorker.register()` to catch each sub up on the next
+ *     re-register.
+ */
+declare class SubManagerClient {
+  private client;
+  private state;
+  private hasConnectedOnce;
+  /** Resolves whenever state transitions to 'ready'. Replaced on each busy→ready cycle. */
+  private readyPromise;
+  private resolveReady;
+  /** Writeset entries accumulated while state === 'busy'. Flushed as one RPC after recovery. */
+  private bufferedWriteSets;
+  private readonly bufferLimit;
+  private bufferDroppedDuringOutage;
+  private recoveryDriver?;
+  private affectedHandler?;
+  constructor(urlOrOptions: string | SubManagerClientOptions);
+  /**
+   * Wire up the app-server-driven recovery. Must be called before any
+   * disconnect/reconnect cycle for buffered writeSets to be flushed and
+   * subscriptions re-registered.
+   */
+  setRecoveryDriver(driver: RecoveryDriver): void;
+  /**
+   * Wire up the handler invoked when batched invalidate results land
+   * after recovery. The handler is expected to drive
+   * `reexecuteAffectedQuery` for each entry.
+   */
+  setAffectedHandler(handler: AffectedHandler): void;
+  registerSubscription(params: RegisterSubscriptionParams): Promise<RegisterSubscriptionResult>;
+  registerSubscriptionBatch(params: RegisterSubscriptionParams[]): Promise<RegisterSubscriptionResult[]>;
+  updateSubscriptionReadSet(params: UpdateSubscriptionReadSetParams): Promise<UpdateSubscriptionReadSetResult>;
+  unregisterSubscription(params: UnregisterSubscriptionParams): Promise<UnregisterSubscriptionResult>;
+  unregisterSubscriptions(params: UnregisterSubscriptionsParams): Promise<UnregisterSubscriptionsResult>;
+  /**
+   * Sends the writeSet to the sub-manager for invalidation, OR buffers it
+   * if the client is currently disconnected / recovering. Returns
+   * `{ affected: [] }` while buffering — the actual `affected` from the
+   * buffered batch is delivered via the registered `affectedHandler`
+   * after recovery completes.
+   */
+  invalidateWriteset(params: InvalidateWritesetParams): Promise<InvalidateWritesetResult>;
+  /**
+   * Single point through which RPCs go. Throws on transport / server error.
+   * `registerSubscription`, `updateSubscriptionReadSet`, and
+   * `unregisterSubscription` are NOT gated on the ready state: during a
+   * disconnect they will fail at the socket layer, and during recovery
+   * (which itself uses these methods) gating would deadlock.
+   */
+  private call;
+  private appendToBuffer;
+  private flushBuffer;
+  private markBusy;
+  private markReady;
+  private handleClose;
+  private handleOpen;
+  private runRecovery;
+  /**
+   * Test/inspection helpers.
+   */
+  /** @internal */
+  isReady(): boolean;
+  /** @internal */
+  bufferSize(): number;
+}
+//#endregion
+//#region src/db/init_db.d.ts
+/**
+ * Default and env override for the per-statement DB timeout. PG enforces
+ * this via `statement_timeout` (server cancels), MySQL via the per-query
+ * `timeout` option (driver issues KILL QUERY). Set 0 to disable.
+ */
+declare const DB_QUERY_TIMEOUT_MS: number;
+type InitDbOptions = {
+  DbConfig: DatabaseConfig;
+  CacheLayer: CacheLayer;
+  forceBootstrapReload?: boolean;
+  workerId?: number;
+};
+declare function initDatabase(options: InitDbOptions): Promise<SupaliveDb>;
+declare function createDatabase(config: DatabaseConfig, workerId?: number): PgDatabase | MySqlDatabase;
+/**
+ * Eagerly load column types into the apply-path cache at server start.
+ * In production, the result is cached in Redis under
+ * `supalive:schema:types:${SUPALIVE_SCHEMA_VERSION ?? "v1"}` so other
+ * instances starting cold can skip the pg_attribute round-trip. In any
+ * other env we go straight to PG every time so local schema iteration
+ * is never blocked by stale Redis state. Migrations should publish a
+ * `schema:reload` message (see {@link publishSchemaReload}) after
+ * applying DDL — every instance picks that up and re-bootstraps.
+ */
+declare function bootstrapDbTypes(db: SupaliveDb, cache: CacheLayer, forceReload?: boolean): Promise<void>;
+type InitCacheLayerOptions = {
+  upstash: UpstashConfig;
+  cacheTtlSeconds?: number;
+  connectionTimeout?: number;
+  commandMaxRetries?: number;
+  commandSubMaxRetries?: number;
+  createSubClient?: boolean;
+};
+declare function initCacheLayer(config: InitCacheLayerOptions): {
+  cacheLayer: CacheLayer;
+  redisSubClient?: Redis$1;
+};
+//#endregion
+//#region src/server/sub_hash.d.ts
+/** Compute stable hash using json-stable-stringify and SHA1. */
+declare function getHashOf(input: unknown): Promise<string>;
+/**
+ * Default identity literal used when neither a procedure-level
+ * `queryIdentity` override nor a per-session user is available.
+ */
+declare const ANONYMOUS_IDENTITY = "anonymous";
+/**
+ * Compute a subscription id from hash of procedure + input + queryIdentity.
+ *
+ * `queryIdentity` is the segmentation key for cache/subscriptions. By default
+ * it is the authenticated user's id (so two users get distinct subscriptions
+ * for the same query), but a procedure may override it to share cache/subs
+ * across users (e.g. for a public, user-independent query).
+ */
+declare function generateSubscriptionId(procedure: string, input: unknown | string, queryIdentity: string): Promise<string>;
+/**
+ * Compute cache key from query name + args + queryIdentity. The identity
+ * participates so that user-specific results don't poison each other's
+ * cache when a procedure does authorize per-user.
+ */
+declare function generateCacheKey(queryName: string, input: unknown | string, queryIdentity: string): Promise<string>;
+//#endregion
+export { ANONYMOUS_IDENTITY, type AffectedSubscription, CacheLayer, DB_QUERY_TIMEOUT_MS, InitCacheLayerOptions, InitDbOptions, type InvalidateWritesetParams, InvalidateWritesetParamsSchema, type InvalidateWritesetResult, type RegisterSubscriptionParams, RegisterSubscriptionParamsSchema, type RegisterSubscriptionResult, type SubId, SubManagerClient, SubscriptionManager, SupaliveWebSocketServer, type UnregisterSubscriptionParams, UnregisterSubscriptionParamsSchema, type UnregisterSubscriptionResult, type UpdateSubscriptionReadSetParams, UpdateSubscriptionReadSetParamsSchema, type UpdateSubscriptionReadSetResult, appInstanceId, bootstrapDbTypes, createDatabase, generateCacheKey, generateSubscriptionId, getHashOf, initCacheLayer, initDatabase, isProduction, logLevelOf, logger, serializeMapValue };
 //# sourceMappingURL=server.d.ts.map

package/dist/src/exports/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/exports/server.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"server.d.ts","names":[],"sources":["../../../src/server/supalive-server.ts","../../../src/logger.ts","../../../src/server/subscription-manager.ts","../../../src/server/subscription-manager-client.ts","../../../src/db/init_db.ts","../../../src/server/sub_hash.ts"],"mappings":"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"}