or3-provider-sqlite 0.0.4 → 0.0.7

package/dist/runtime/server/rate-limit/sqlite-provider.js

@@ -1,8 +1,12 @@
-import { getRawDb } from "../db/kysely.js";
+import { getRawDb, isD1Driver } from "../db/kysely.js";
+import { d1All } from "../db/d1.js";
 export class SqliteRateLimitProvider {
   name = "sqlite";
   async checkAndRecord(key, config) {
     requireConfig(config);
+    if (isD1Driver()) {
+      return this.checkAndRecordInD1(key, config);
+    }
     const now = Date.now();
     const db = getRawDb();
     return db.transaction(() => {
@@ -43,6 +47,9 @@ export class SqliteRateLimitProvider {
   }
   async getStats(key, config) {
     requireConfig(config);
+    if (isD1Driver()) {
+      return this.getStatsInD1(key, config);
+    }
     const now = Date.now();
     const row = getRawDb().prepare(
       `SELECT count, window_started_at, expires_at
@@ -61,6 +68,68 @@ export class SqliteRateLimitProvider {
       resetMs: Math.max(0, row.expires_at - now)
     };
   }
+  async checkAndRecordInD1(key, config) {
+    const now = Date.now();
+    const [row] = await d1All(
+      `INSERT INTO rate_limits (key, count, window_started_at, expires_at)
+             VALUES (?, 1, ?, ?)
+             ON CONFLICT(key) DO UPDATE SET
+                count = CASE
+                    WHEN rate_limits.expires_at <= ? THEN 1
+                    WHEN rate_limits.count < ? THEN rate_limits.count + 1
+                    ELSE ?
+                END,
+                window_started_at = CASE
+                    WHEN rate_limits.expires_at <= ? THEN excluded.window_started_at
+                    ELSE rate_limits.window_started_at
+                END,
+                expires_at = CASE
+                    WHEN rate_limits.expires_at <= ? THEN excluded.expires_at
+                    ELSE rate_limits.expires_at
+                END
+             RETURNING count, window_started_at, expires_at`,
+      key,
+      now,
+      now + config.windowMs,
+      now,
+      config.maxRequests,
+      config.maxRequests + 1,
+      now,
+      now
+    );
+    if (!row) throw new Error("D1 rate-limit upsert did not return a row.");
+    if (row.count > config.maxRequests) {
+      return {
+        allowed: false,
+        remaining: 0,
+        retryAfterMs: Math.max(0, row.expires_at - now)
+      };
+    }
+    return {
+      allowed: true,
+      remaining: config.maxRequests - row.count
+    };
+  }
+  async getStatsInD1(key, config) {
+    const now = Date.now();
+    const [row] = await d1All(
+      `SELECT count, window_started_at, expires_at
+             FROM rate_limits WHERE key = ?`,
+      key
+    );
+    if (!row || row.expires_at <= now) {
+      return {
+        limit: config.maxRequests,
+        remaining: config.maxRequests,
+        resetMs: config.windowMs
+      };
+    }
+    return {
+      limit: config.maxRequests,
+      remaining: Math.max(0, config.maxRequests - row.count),
+      resetMs: Math.max(0, row.expires_at - now)
+    };
+  }
 }
 export const sqliteRateLimitProvider = new SqliteRateLimitProvider();
 function requireConfig(config) {

package/dist/runtime/server/sync/maintenance-state.d.ts

@@ -0,0 +1,26 @@
+import type { SyncMaintenanceState } from '~~/server/sync/gateway/types';
+/**
+ * Retention window used by maintenance GC. No OR3_SYNC_* retention knob exists
+ * today, so we deliberately do NOT invent a new env var; we use the maximum
+ * bounded window allowed by the gateway (365 days) and document it here.
+ */
+export declare const SYNC_MAINTENANCE_RETENTION_SECONDS: number;
+export declare function getSyncMaintenanceState(): SyncMaintenanceState;
+export declare function beginSyncMaintenanceRun(): void;
+export declare function completeSyncMaintenanceRun(input: {
+    lastRun: string;
+    backlog: number;
+}): void;
+export declare function failSyncMaintenanceRun(error: string): void;
+export declare function getCachedSyncMaintenanceBacklog(): number | undefined;
+/**
+ * Count change-log entries eligible for GC across all workspaces: older than
+ * the retention window AND behind every active device cursor for their
+ * workspace. Cursors idle for a whole retention window intentionally do not
+ * block collection because those clients snapshot-bootstrap on return.
+ * Cached with a short TTL. Pass `force` after a GC pass so the recorded
+ * backlog reflects the post-GC state.
+ */
+export declare function computeSyncMaintenanceBacklog(retentionSeconds: number, force?: boolean): number;
+/** Test-only reset. */
+export declare function _resetSyncMaintenanceStateForTest(): void;

package/dist/runtime/server/sync/maintenance-state.js

@@ -0,0 +1,66 @@
+import { canRunSyncHistoryGc } from "./history-gc-policy.js";
+import { getRawDb } from "../db/kysely.js";
+export const SYNC_MAINTENANCE_RETENTION_SECONDS = 365 * 24 * 60 * 60;
+const BACKLOG_TTL_MS = 6e4;
+let state = { enabled: true, state: "idle" };
+let backlogCache;
+export function getSyncMaintenanceState() {
+  return { ...state, enabled: canRunSyncHistoryGc() };
+}
+export function beginSyncMaintenanceRun() {
+  state = { ...state, state: "running" };
+}
+export function completeSyncMaintenanceRun(input) {
+  state = {
+    ...state,
+    state: "idle",
+    lastRun: input.lastRun,
+    backlog: input.backlog,
+    lastError: void 0
+  };
+}
+export function failSyncMaintenanceRun(error) {
+  state = { ...state, state: "failed", lastError: error };
+}
+export function getCachedSyncMaintenanceBacklog() {
+  if (backlogCache && Date.now() - backlogCache.at < BACKLOG_TTL_MS) {
+    return backlogCache.value;
+  }
+  return void 0;
+}
+export function computeSyncMaintenanceBacklog(retentionSeconds, force = false) {
+  if (!force) {
+    const cached = getCachedSyncMaintenanceBacklog();
+    if (cached !== void 0) return cached;
+  }
+  const backlog = countEligibleChangeLog(retentionSeconds);
+  backlogCache = { value: backlog, at: Date.now() };
+  state = { ...state, backlog };
+  return backlog;
+}
+function countEligibleChangeLog(retentionSeconds) {
+  try {
+    const raw = getRawDb();
+    const cutoff = Math.floor(Date.now() / 1e3) - retentionSeconds;
+    const row = raw.prepare(
+      `WITH active_cursors AS (
+                    SELECT workspace_id, MIN(last_seen_version) AS min_version
+                    FROM device_cursors
+                    WHERE updated_at >= ?
+                    GROUP BY workspace_id
+                 )
+                 SELECT COUNT(*) AS cnt
+                 FROM change_log cl
+                 LEFT JOIN active_cursors ac ON ac.workspace_id = cl.workspace_id
+                 WHERE cl.created_at < ?
+                   AND (ac.min_version IS NULL OR cl.server_version <= ac.min_version)`
+    ).get(cutoff, cutoff);
+    return row.cnt;
+  } catch {
+    return 0;
+  }
+}
+export function _resetSyncMaintenanceStateForTest() {
+  state = { enabled: true, state: "idle" };
+  backlogCache = void 0;
+}

package/dist/runtime/server/sync/sqlite-sync-gateway-adapter.d.ts

@@ -1,12 +1,12 @@
 /**
  * SQLite implementation of SyncGatewayAdapter.
  *
- * Handles push/pull/updateCursor/gc using Kysely + better-sqlite3.
- * Uses raw DB transactions via better-sqlite3 for push atomicity
- * (BEGIN IMMEDIATE prevents concurrent server_version races).
+ * Handles push/pull/updateCursor/gc using the selected native SQLite runtime.
+ * Local runtimes use raw BEGIN IMMEDIATE transactions; Cloudflare D1 uses
+ * native atomic batches for its asynchronous binding.
  */
 import type { H3Event } from 'h3';
-import type { CanonicalStorageQueryRequest, CanonicalStorageQueryResponse, SyncGatewayAdapter, UploadIntentConsumptionRequest, UploadIntentReservationRequest } from '~~/server/sync/gateway/types';
+import type { CanonicalStorageQueryRequest, CanonicalStorageQueryResponse, SyncGatewayAdapter, SyncMaintenanceState, UploadIntentConsumptionRequest, UploadIntentReservationRequest } from '~~/server/sync/gateway/types';
 import type { PullRequest, PullResponse, PushBatch, PushResult, SnapshotRequest, SnapshotResponse } from '~~/shared/sync/types';
 export declare class SqliteSyncGatewayAdapter implements SyncGatewayAdapter {
     id: string;
@@ -44,5 +44,16 @@ export declare class SqliteSyncGatewayAdapter implements SyncGatewayAdapter {
         };
         retentionSeconds: number;
     }): Promise<void>;
+    private reserveUploadIntentInD1;
+    private snapshotInD1;
+    private updateCursorInD1;
+    private pushInD1;
+    listWorkspaceIds(): Promise<string[]>;
+    getMaintenanceState(): SyncMaintenanceState;
+    beginMaintenanceRun(): void;
+    completeMaintenanceRun(input: {
+        lastRun: string;
+    }): void;
+    failMaintenanceRun(error: string): void;
 }
 export declare function createSqliteSyncGatewayAdapter(): SyncGatewayAdapter;