lakesync 0.1.5 → 0.1.8

package/dist/compactor.d.ts

@@ -1,5 +1,5 @@
 import { H as HLCTimestamp, R as Result, L as LakeSyncError, F as FlushError } from './result-CojzlFE2.js';
-import { T as TableSchema } from './types-GGBfZBKQ.js';
+import { T as TableSchema } from './types-BdGBv2ba.js';
 import { L as LakeAdapter } from './types-DSC_EiwR.js';
 
 /** Configuration for checkpoint generation */

package/dist/compactor.js

@@ -1,10 +1,10 @@
 import {
   encodeSyncResponse
-} from "./chunk-L4ZL5JA7.js";
+} from "./chunk-KVSWLIJR.js";
 import {
   readParquetToDeltas,
   writeDeltasToParquet
-} from "./chunk-46CKACNC.js";
+} from "./chunk-SSICS5KI.js";
 import {
   Err,
   FlushError,
@@ -12,8 +12,8 @@ import {
   LakeSyncError,
   Ok,
   rowKey
-} from "./chunk-7UBS6MFH.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-LDFFCG2K.js";
+import "./chunk-DGUM43GV.js";
 
 // ../compactor/src/checkpoint-generator.ts
 var DEFAULT_CHECKPOINT_CONFIG = {

package/dist/connector-jira.d.ts

@@ -1,6 +1,6 @@
 import { L as LakeSyncError, R as Result } from './result-CojzlFE2.js';
-import { B as BaseSourcePoller, P as PushTarget } from './base-poller-CBvhdvcj.js';
-import { T as TableSchema } from './types-GGBfZBKQ.js';
+import { B as BaseSourcePoller, P as PushTarget } from './base-poller-Bj9kX9dv.js';
+import { T as TableSchema } from './types-BdGBv2ba.js';
 import './hlc-DiD8QNG3.js';
 
 /** HTTP error from the Jira REST API. */

package/dist/connector-jira.js

@@ -8,9 +8,9 @@ import {
   mapIssue,
   mapProject,
   testConnection
-} from "./chunk-SZSGSTVZ.js";
-import "./chunk-7UBS6MFH.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-PYRS74YP.js";
+import "./chunk-LDFFCG2K.js";
+import "./chunk-DGUM43GV.js";
 export {
   JIRA_TABLE_SCHEMAS,
   JiraApiError,

package/dist/connector-salesforce.d.ts

@@ -1,6 +1,6 @@
 import { L as LakeSyncError, R as Result } from './result-CojzlFE2.js';
-import { B as BaseSourcePoller, P as PushTarget } from './base-poller-CBvhdvcj.js';
-import { T as TableSchema } from './types-GGBfZBKQ.js';
+import { B as BaseSourcePoller, P as PushTarget } from './base-poller-Bj9kX9dv.js';
+import { T as TableSchema } from './types-BdGBv2ba.js';
 import './hlc-DiD8QNG3.js';
 
 /** HTTP error from the Salesforce REST API. */

package/dist/connector-salesforce.js

@@ -9,9 +9,9 @@ import {
   mapLead,
   mapOpportunity,
   testConnection
-} from "./chunk-TVLTXHW6.js";
-import "./chunk-7UBS6MFH.js";
-import "./chunk-7D4SUZUM.js";
+} from "./chunk-QNITY4F6.js";
+import "./chunk-LDFFCG2K.js";
+import "./chunk-DGUM43GV.js";
 export {
   SALESFORCE_TABLE_SCHEMAS,
   SalesforceApiError,

package/dist/{coordinator-DN8D8C7W.d.ts → coordinator-NXy6tA0h.d.ts}

@@ -1,8 +1,8 @@
 import { L as LakeSyncError, R as Result, H as HLCTimestamp } from './result-CojzlFE2.js';
 import { A as Action, i as ActionPush, j as ActionResponse, d as ActionDiscovery, k as ActionResult, e as ActionErrorResult } from './types-Bs-QyOe-.js';
 import { H as HLC } from './hlc-DiD8QNG3.js';
-import { a as ConnectorDescriptor } from './registry-BN_9spxE.js';
-import { R as RowDelta, S as SyncPush, b as SyncPull, c as SyncResponse } from './types-GGBfZBKQ.js';
+import { a as ConnectorDescriptor } from './registry-BcspAtZI.js';
+import { R as RowDelta, S as SyncPush, e as SyncPull, f as SyncResponse } from './types-BdGBv2ba.js';
 
 /** Configuration for opening a local database */
 interface DbConfig {
@@ -253,10 +253,21 @@ interface SyncTransport {
 
 /** Controls which operations syncOnce() / startAutoSync() performs */
 type SyncMode = "full" | "pushOnly" | "pullOnly";
+/** Readable snapshot of the coordinator's current sync state. */
+interface SyncState {
+    /** Whether a sync cycle is currently in progress. */
+    syncing: boolean;
+    /** Last successful sync time, or null if never synced. */
+    lastSyncTime: Date | null;
+    /** HLC timestamp of the last successfully synced delta. */
+    lastSyncedHlc: HLCTimestamp;
+}
 /** Events emitted by SyncCoordinator */
 interface SyncEvents {
     /** Fired after remote deltas are applied locally. Count is the number of deltas applied. */
     onChange: (count: number) => void;
+    /** Fired when a sync cycle (push + pull) begins. */
+    onSyncStart: () => void;
     /** Fired after a successful sync cycle (push + pull) completes. */
     onSyncComplete: () => void;
     /** Fired when a sync error occurs. */
@@ -290,6 +301,9 @@ interface SyncCoordinatorConfig {
  *
  * Uses a {@link SyncTransport} abstraction to communicate with the gateway,
  * allowing both in-process (LocalTransport) and remote (HttpTransport) usage.
+ *
+ * Delegates auto-sync scheduling to {@link AutoSyncScheduler} and action
+ * processing to {@link ActionProcessor}.
  */
 declare class SyncCoordinator {
     readonly tracker: SyncTracker;
@@ -301,15 +315,11 @@ declare class SyncCoordinator {
     private readonly _clientId;
     private readonly maxRetries;
     private readonly syncMode;
-    private readonly autoSyncIntervalMs;
-    private readonly realtimeHeartbeatMs;
     private lastSyncedHlc;
     private _lastSyncTime;
-    private syncIntervalId;
-    private visibilityHandler;
     private syncing;
-    private readonly actionQueue;
-    private readonly maxActionRetries;
+    private readonly autoSyncScheduler;
+    private readonly actionProcessor;
     private listeners;
     constructor(db: LocalDB, transport: SyncTransport, config?: SyncCoordinatorConfig);
     /** Register an event listener */
@@ -317,6 +327,8 @@ declare class SyncCoordinator {
     /** Remove an event listener */
     off<K extends keyof SyncEvents>(event: K, listener: SyncEvents[K]): void;
     private emit;
+    /** Readable snapshot of the current sync state. */
+    get state(): SyncState;
     /** Push pending deltas to the gateway via the transport */
     pushToGateway(): Promise<void>;
     /**
@@ -344,11 +356,9 @@ declare class SyncCoordinator {
     get lastSyncTime(): Date | null;
     /**
      * Start auto-sync: periodic interval + visibility change handler.
-     * Synchronises (push + pull) on tab focus and every 10 seconds.
+     * Synchronises (push + pull) on tab focus and every N seconds.
      */
     startAutoSync(): void;
-    /** Register a visibility change listener to sync on tab focus. */
-    private setupVisibilitySync;
     /**
      * Perform initial sync via checkpoint download.
      *
@@ -379,10 +389,7 @@ declare class SyncCoordinator {
     /**
      * Process pending actions from the action queue.
      *
-     * Peeks at pending entries, sends them to the gateway via
-     * `transport.executeAction()`, and acks/nacks based on the result.
-     * Dead-letters entries after `maxActionRetries` failures.
-     * Triggers an immediate `syncOnce()` on success to pull fresh state.
+     * Delegates to the ActionProcessor if one is configured.
      */
     processActionQueue(): Promise<void>;
     /**
@@ -403,4 +410,4 @@ declare class SyncCoordinator {
     stopAutoSync(): void;
 }
 
-export { type ActionQueue as A, type CheckpointResponse as C, DbError as D, LocalDB as L, type QueueEntry as Q, type SyncQueue as S, type Transaction as T, type SyncCoordinatorConfig as a, SyncCoordinator as b, type SyncTransport as c, type ActionQueueEntry as d, type ActionQueueEntryStatus as e, type DbConfig as f, type QueueEntryStatus as g, type SyncEvents as h, type SyncMode as i, SyncTracker as j };
+export { type ActionQueue as A, type CheckpointResponse as C, DbError as D, LocalDB as L, type QueueEntry as Q, type SyncQueue as S, type Transaction as T, type SyncCoordinatorConfig as a, SyncCoordinator as b, type SyncTransport as c, type ActionQueueEntry as d, type ActionQueueEntryStatus as e, type DbConfig as f, type QueueEntryStatus as g, type SyncEvents as h, type SyncMode as i, type SyncState as j, SyncTracker as k };

package/dist/{db-types-B6_JKQWK.d.ts → db-types-CfLMUBfW.d.ts}

@@ -1,5 +1,5 @@
 import { R as Result, A as AdapterError, H as HLCTimestamp } from './result-CojzlFE2.js';
-import { R as RowDelta, T as TableSchema } from './types-GGBfZBKQ.js';
+import { R as RowDelta, T as TableSchema } from './types-BdGBv2ba.js';
 
 /** Configuration for a database adapter connection. */
 interface DatabaseAdapterConfig {

package/dist/gateway-server.d.ts

@@ -1,14 +1,40 @@
-export { A as AuthClaims, a as AuthError, v as verifyToken } from './auth-CAVutXzx.js';
-import { D as DatabaseAdapter } from './db-types-B6_JKQWK.js';
-import { S as SyncGateway } from './gateway-CvO7Xy3T.js';
-import { R as RowDelta, c as SyncResponse } from './types-GGBfZBKQ.js';
+import { A as AuthClaims } from './auth-CAVutXzx.js';
+export { a as AuthError, v as verifyToken } from './auth-CAVutXzx.js';
+import { IncomingMessage, ServerResponse, Server } from 'node:http';
+import { D as DatabaseAdapter } from './db-types-CfLMUBfW.js';
+import { C as ConfigStore, d as SyncGateway, c as HandlerResult } from './request-handler-pUvL7ozF.js';
+import { R as RowDelta, f as SyncResponse } from './types-BdGBv2ba.js';
 import { L as LakeAdapter } from './types-DSC_EiwR.js';
 import { H as HLCTimestamp } from './result-CojzlFE2.js';
 import './types-Bs-QyOe-.js';
-import './base-poller-CBvhdvcj.js';
+import './types-BrcD1oJg.js';
+import './base-poller-Bj9kX9dv.js';
 import './hlc-DiD8QNG3.js';
 import './nessie-client-DrNikVXy.js';
 
+/** Result of authentication: either authenticated claims or an error. */
+type AuthResult = {
+    authenticated: true;
+    claims: AuthClaims;
+} | {
+    authenticated: false;
+    status: number;
+    message: string;
+};
+/**
+ * Extract the Bearer token from an Authorization header.
+ * Returns the raw token string, or null if missing/malformed.
+ */
+declare function extractBearerToken(req: IncomingMessage): string | null;
+/**
+ * Authenticate an HTTP request.
+ *
+ * When `jwtSecret` is undefined, auth is disabled and all requests pass.
+ * Otherwise validates the Bearer token, checks gateway ID, and enforces
+ * admin role for admin actions.
+ */
+declare function authenticateRequest(req: IncomingMessage, routeGatewayId: string, routeAction: string, jwtSecret: string | undefined): Promise<AuthResult>;
+
 /**
  * Interface for distributed locking across gateway-server instances.
  *
@@ -22,10 +48,21 @@ interface DistributedLock {
     release(key: string): Promise<void>;
 }
 /**
- * Database-backed distributed lock using an advisory lock row.
+ * Database-backed distributed lock using advisory lock semantics.
+ *
+ * Uses the adapter's `ensureSchema` + `insertDeltas` to maintain a
+ * dedicated `__lakesync_locks` table. Lock entries are isolated from
+ * regular sync data — they use a reserved table prefix that sync
+ * queries should never match.
  *
- * Uses a `lakesync_locks` table with columns: key, holder, expires_at.
- * Lock acquisition is atomic via INSERT ... ON CONFLICT or UPDATE WHERE expires_at < NOW().
+ * Acquire is atomic: the adapter's upsert semantics (INSERT ON CONFLICT
+ * or equivalent) ensure only one instance can hold a lock. Release
+ * is best-effort — the TTL provides a safety net against holder crashes.
+ *
+ * Note: This implementation piggybacks on the DatabaseAdapter interface
+ * because the adapter abstraction doesn't expose raw SQL. For adapters
+ * that support native advisory locks (e.g. Postgres pg_advisory_lock),
+ * prefer a specialised implementation of {@link DistributedLock}.
  */
 declare class AdapterBasedLock implements DistributedLock {
     private readonly adapter;
@@ -33,9 +70,63 @@ declare class AdapterBasedLock implements DistributedLock {
     constructor(adapter: DatabaseAdapter, instanceId?: string);
     acquire(key: string, ttlMs: number): Promise<boolean>;
     release(key: string): Promise<void>;
-    private makeLockDelta;
+    /**
+     * Create an HLC-format timestamp from wall clock time.
+     *
+     * Uses the standard 48-bit wall + 16-bit counter encoding.
+     */
+    private makeHlc;
 }
 
+/**
+ * Manages connector registration, adapter creation, and poller lifecycle.
+ *
+ * Encapsulates the if/else chains for different connector types and
+ * handles clean-up on unregistration.
+ */
+declare class ConnectorManager {
+    private readonly configStore;
+    private readonly gateway;
+    private readonly adapters;
+    private readonly pollers;
+    constructor(configStore: ConfigStore, gateway: SyncGateway);
+    /**
+     * Register a connector from raw JSON body.
+     *
+     * Validates via shared handler, creates adapter/poller as appropriate,
+     * registers with the gateway.
+     */
+    register(raw: string): Promise<HandlerResult>;
+    /**
+     * Unregister a connector by name.
+     *
+     * Stops poller, closes adapter, and unregisters from gateway.
+     */
+    unregister(name: string): Promise<HandlerResult>;
+    /**
+     * List registered connectors with live polling status.
+     */
+    list(): Promise<HandlerResult>;
+    /** Stop all pollers and close all adapters. */
+    stopAll(): Promise<void>;
+    private rollbackRegistration;
+}
+
+/** Configuration for CORS header generation. */
+interface CorsConfig {
+    /** Allowed origins. When empty/omitted, all origins are reflected. */
+    allowedOrigins?: string[];
+}
+/**
+ * Build CORS response headers for the given origin.
+ *
+ * When `allowedOrigins` is set, only listed origins receive CORS headers.
+ * When omitted, the request origin is reflected (or `*` if no origin header).
+ */
+declare function corsHeaders(origin: string | null | undefined, config: CorsConfig): Record<string, string>;
+/** Handle CORS preflight (OPTIONS) request. Returns true if handled. */
+declare function handlePreflight(method: string, res: ServerResponse, corsH: Record<string, string>): boolean;
+
 /** Generic query function — abstracts any SQL database. */
 type QueryFn = (sql: string, params?: unknown[]) => Promise<Record<string, unknown>[]>;
 /** Configuration for a single polling ingest source. */
@@ -148,6 +239,20 @@ declare class SqlitePersistence implements DeltaPersistence {
     close(): void;
 }
 
+/** Matched route information. */
+interface RouteMatch {
+    gatewayId: string;
+    action: string;
+    /** Extra route parameters (e.g. connector name from DELETE path). */
+    connectorName?: string;
+}
+/**
+ * Match a request pathname and method against the route table.
+ *
+ * Returns the matched route or null if no route matches.
+ */
+declare function matchRoute(pathname: string, method: string): RouteMatch | null;
+
 /** Configuration for the self-hosted gateway server. */
 interface GatewayServerConfig {
     /** Port to listen on (default 3000). */
@@ -183,9 +288,9 @@ interface GatewayServerConfig {
 /**
  * Self-hosted HTTP gateway server wrapping {@link SyncGateway}.
  *
- * Provides the same route surface as the Cloudflare Workers gateway-worker
- * but runs as a standalone Node/Bun HTTP server. Supports optional JWT
- * authentication, CORS, periodic flush, and SQLite-based buffer persistence.
+ * Composes extracted modules: cors-middleware, auth-middleware, router,
+ * ws-manager, and connector-manager. Request handling follows the
+ * pipeline: cors -> auth -> route -> handler.
  *
  * @example
  * ```ts
@@ -199,83 +304,45 @@ interface GatewayServerConfig {
  * ```
  */
 declare class GatewayServer {
-    private gateway;
-    private config;
+    private readonly gateway;
+    private readonly config;
+    private readonly configStore;
+    private readonly persistence;
+    private readonly connectors;
+    private readonly sharedBuffer;
     private httpServer;
+    private wsManager;
     private flushTimer;
-    private configStore;
-    private persistence;
     private resolvedPort;
-    private wss;
-    private wsClients;
     private pollers;
-    private connectorAdapters;
-    private connectorPollers;
-    private sharedBuffer;
     constructor(config: GatewayServerConfig);
     /**
      * Start the HTTP server and periodic flush timer.
      *
-     * Rehydrates unflushed deltas from the persistence layer before
-     * accepting connections.
+     * Rehydrates unflushed deltas from the persistence layer directly
+     * into the buffer (bypassing push validation) before accepting
+     * connections.
      */
     start(): Promise<void>;
-    /**
-     * Handle HTTP -> WebSocket upgrade.
-     *
-     * Authenticates via Bearer token in Authorization header or `?token=` query param.
-     */
-    private handleUpgrade;
-    /**
-     * Handle an incoming WebSocket message (binary protobuf).
-     */
-    private handleWsMessage;
-    /**
-     * Build sync rules context from WebSocket client claims.
-     */
-    private buildWsSyncRulesContext;
-    /**
-     * Broadcast ingested deltas to all connected WebSocket clients except the sender.
-     */
-    private broadcastDeltas;
-    private broadcastDeltasAsync;
-    /** Stop the server and clear the flush timer. */
+    /** Stop the server, pollers, connectors, and WebSocket connections. */
     stop(): Promise<void>;
     /** The port the server is listening on (available after start). */
     get port(): number;
     /** The underlying SyncGateway instance for direct access. */
     get gatewayInstance(): SyncGateway;
     private handleRequest;
-    /**
-     * Handle `POST /sync/:gatewayId/push` -- ingest client deltas.
-     */
     private handlePush;
-    /**
-     * Handle `GET /sync/:gatewayId/pull` -- retrieve deltas since a given HLC.
-     */
     private handlePull;
-    /**
-     * Handle `POST /sync/:gatewayId/action` -- execute imperative actions.
-     */
     private handleAction;
-    /** Handle `GET /sync/:gatewayId/actions` -- describe available action handlers. */
     private handleDescribeActions;
-    /** Handle `POST /admin/flush/:gatewayId` -- manual flush. */
     private handleFlush;
-    /** Handle `POST /admin/schema/:gatewayId` -- save table schema. */
     private handleSaveSchemaRoute;
-    /** Handle `POST /admin/sync-rules/:gatewayId` -- save sync rules. */
     private handleSaveSyncRulesRoute;
-    /** Handle `POST /admin/connectors/:gatewayId` -- register a new connector. */
-    private handleRegisterConnector;
-    /** Handle `DELETE /admin/connectors/:gatewayId/:name` -- unregister a connector. */
-    private handleUnregisterConnector;
-    /** Handle `GET /admin/connectors/:gatewayId` -- list registered connectors. */
+    private handleRegisterConnectorRoute;
+    private handleUnregisterConnectorRoute;
     private handleListConnectorsRoute;
-    /** Handle `GET /admin/metrics/:gatewayId` -- return buffer stats and process memory. */
     private handleMetricsRoute;
     private periodicFlush;
-    private corsHeaders;
 }
 
 /**
@@ -303,4 +370,31 @@ declare class SharedBuffer {
     mergePull(localResult: SyncResponse, sinceHlc: HLCTimestamp): Promise<SyncResponse>;
 }
 
-export { AdapterBasedLock, type CursorStrategy, type DeltaPersistence, type DiffStrategy, type DistributedLock, GatewayServer, type GatewayServerConfig, type IngestSourceConfig, type IngestTableConfig, MemoryPersistence, type QueryFn, SharedBuffer, SourcePoller, SqlitePersistence };
+/**
+ * Manages WebSocket connections, message handling, and broadcasting.
+ *
+ * Decouples the WebSocket protocol from the HTTP server lifecycle.
+ */
+declare class WebSocketManager {
+    private readonly gateway;
+    private readonly configStore;
+    private readonly gatewayId;
+    private readonly jwtSecret;
+    private readonly wss;
+    private readonly clients;
+    constructor(gateway: SyncGateway, configStore: ConfigStore, gatewayId: string, jwtSecret: string | undefined);
+    /** Attach upgrade listener to an HTTP server. */
+    attach(httpServer: Server): void;
+    /**
+     * Broadcast ingested deltas to all connected WebSocket clients except the sender.
+     */
+    broadcastDeltas(deltas: RowDelta[], serverHlc: HLCTimestamp, excludeClientId: string): void;
+    /** Close all connections and shut down the WebSocket server. */
+    close(): void;
+    private handleUpgrade;
+    private handleMessage;
+    private buildSyncRulesContext;
+    private broadcastDeltasAsync;
+}
+
+export { AdapterBasedLock, AuthClaims, type AuthResult, ConnectorManager, type CorsConfig, type CursorStrategy, type DeltaPersistence, type DiffStrategy, type DistributedLock, GatewayServer, type GatewayServerConfig, type IngestSourceConfig, type IngestTableConfig, MemoryPersistence, type QueryFn, type RouteMatch, SharedBuffer, SourcePoller, SqlitePersistence, WebSocketManager, authenticateRequest, corsHeaders, extractBearerToken, handlePreflight, matchRoute };