@go-go-scope/persistence-sqlite-bun 2.0.0

package/README.md

@@ -0,0 +1,83 @@
+# @go-go-scope/persistence-sqlite-bun
+
+Bun-native SQLite persistence adapter for go-go-scope using `bun:sqlite`. This adapter provides optimal performance when running under Bun by leveraging its native SQLite implementation.
+
+## Installation
+
+```bash
+# For Bun projects
+bun add @go-go-scope/persistence-sqlite-bun
+```
+
+## Usage
+
+```typescript
+import { Database } from 'bun:sqlite'
+import { scope } from 'go-go-scope'
+import { BunSQLiteAdapter } from '@go-go-scope/persistence-sqlite-bun'
+
+// Create a database (in-memory or file-based)
+const db = new Database(':memory:')
+// or: const db = new Database('/path/to/app.db')
+
+// Create the adapter
+const persistence = new BunSQLiteAdapter(db, { 
+  keyPrefix: 'myapp:' // optional prefix for keys
+})
+
+// Use with scope
+await using s = scope({ persistence })
+
+// Acquire distributed lock
+const lock = await s.acquireLock('resource:123', 30000)
+if (!lock) {
+  throw new Error('Could not acquire lock')
+}
+
+// Lock automatically expires after TTL
+// Optional: release early
+await lock.release()
+```
+
+## Features
+
+- **Distributed Locks**: In-memory with TTL support
+- **Circuit Breaker State**: Persistent state storage
+- **Native Performance**: Uses Bun's `bun:sqlite` for maximum speed
+- **API Compatibility**: Same interface as other persistence adapters
+
+## Why Use This Adapter?
+
+| Feature | `sqlite3` | `bun:sqlite` (this adapter) |
+|---------|-----------|----------------------------|
+| Performance | Good | **Excellent** |
+| Bun-native | No | **Yes** |
+| Bundle size | Larger | **Smaller** |
+| Dependencies | Native bindings | **Built-in** |
+
+## API
+
+### Constructor
+
+```typescript
+new BunSQLiteAdapter(db: Database, options?: { keyPrefix?: string })
+```
+
+- `db`: Bun SQLite Database instance
+- `options.keyPrefix`: Optional prefix for all keys
+
+### Methods
+
+See the main [go-go-scope documentation](../../docs) for full persistence API details.
+
+## Testing
+
+```bash
+# Run Bun compatibility tests
+cd packages/go-go-scope
+bun test tests/bun-compatibility.test.ts
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,68 @@
+import { LockProvider, CircuitBreakerStateProvider, PersistenceAdapter, PersistenceAdapterOptions, LockHandle, CircuitBreakerPersistedState } from 'go-go-scope';
+
+/**
+ * Bun-native SQLite persistence adapter for go-go-scope
+ *
+ * Provides distributed locks and circuit breaker state using Bun's native
+ * `bun:sqlite` module. This is faster than the sqlite3-based adapter under Bun.
+ *
+ * @example
+ * ```typescript
+ * import { Database } from 'bun:sqlite'
+ * import { BunSQLiteAdapter } from '@go-go-scope/persistence-sqlite-bun'
+ *
+ * const db = new Database('/tmp/app.db')
+ * const persistence = new BunSQLiteAdapter(db, { keyPrefix: 'myapp:' })
+ *
+ * await using s = scope({ persistence })
+ *
+ * // Acquire a lock with 30 second TTL
+ * const lock = await s.acquireLock('resource:123', 30000)
+ * if (!lock) {
+ *   throw new Error('Could not acquire lock')
+ * }
+ *
+ * // Lock automatically expires after TTL
+ * // Optional: release early with await lock.release()
+ * ```
+ */
+
+interface BunDatabase {
+    run(sql: string, params?: unknown[]): {
+        changes: number;
+        lastInsertRowid: number;
+    };
+    query<T = unknown>(sql: string): {
+        get(...params: unknown[]): T | null;
+        all(...params: unknown[]): T[];
+        run(...params: unknown[]): {
+            changes: number;
+            lastInsertRowid: number;
+        };
+    };
+    close(): void;
+}
+/**
+ * Bun-native SQLite persistence adapter
+ */
+declare class BunSQLiteAdapter implements LockProvider, CircuitBreakerStateProvider, PersistenceAdapter {
+    private readonly db;
+    private readonly keyPrefix;
+    private readonly locks;
+    private connected;
+    constructor(db: BunDatabase, options?: PersistenceAdapterOptions);
+    private prefix;
+    private generateOwner;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    acquire(key: string, ttl: number, owner?: string): Promise<LockHandle | null>;
+    extend(key: string, ttl: number, owner: string): Promise<boolean>;
+    forceRelease(key: string): Promise<void>;
+    getState(key: string): Promise<CircuitBreakerPersistedState | null>;
+    setState(key: string, state: CircuitBreakerPersistedState): Promise<void>;
+    recordFailure(key: string, maxFailures: number): Promise<number>;
+    recordSuccess(key: string): Promise<void>;
+}
+
+export { BunSQLiteAdapter };

package/dist/index.mjs

@@ -0,0 +1,148 @@
+class BunSQLiteAdapter {
+  db;
+  keyPrefix;
+  locks = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.keyPrefix = options.keyPrefix ?? "";
+  }
+  prefix(key) {
+    return this.keyPrefix ? `${this.keyPrefix}${key}` : key;
+  }
+  generateOwner() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  }
+  // ============================================================================
+  // Persistence Adapter
+  // ============================================================================
+  async connect() {
+    this.db.run(`
+			CREATE TABLE IF NOT EXISTS go_goscope_circuit (
+				key TEXT PRIMARY KEY,
+				state TEXT NOT NULL,
+				failure_count INTEGER NOT NULL DEFAULT 0,
+				last_failure_time INTEGER,
+				last_success_time INTEGER,
+				updated_at INTEGER NOT NULL
+			)
+		`);
+    this.connected = true;
+  }
+  async disconnect() {
+    this.db.close();
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  // ============================================================================
+  // Lock Provider (In-Memory with Cleanup)
+  // ============================================================================
+  async acquire(key, ttl, owner) {
+    const fullKey = this.prefix(`lock:${key}`);
+    const lockOwner = owner ?? this.generateOwner();
+    const now = Date.now();
+    for (const [k, v] of this.locks.entries()) {
+      if (v.expiry < now) {
+        this.locks.delete(k);
+      }
+    }
+    if (this.locks.has(fullKey)) {
+      return null;
+    }
+    this.locks.set(fullKey, { owner: lockOwner, expiry: now + ttl });
+    const handle = {
+      release: async () => {
+        const lock = this.locks.get(fullKey);
+        if (lock?.owner === lockOwner) {
+          this.locks.delete(fullKey);
+        }
+      },
+      extend: async (newTtl) => {
+        return this.extend(key, newTtl, lockOwner);
+      },
+      isValid: async () => {
+        const lock = this.locks.get(fullKey);
+        return lock?.owner === lockOwner && lock.expiry > Date.now();
+      }
+    };
+    return handle;
+  }
+  async extend(key, ttl, owner) {
+    const fullKey = this.prefix(`lock:${key}`);
+    const lock = this.locks.get(fullKey);
+    if (!lock || lock.owner !== owner) {
+      return false;
+    }
+    lock.expiry = Date.now() + ttl;
+    return true;
+  }
+  async forceRelease(key) {
+    const fullKey = this.prefix(`lock:${key}`);
+    this.locks.delete(fullKey);
+  }
+  // ============================================================================
+  // Circuit Breaker State Provider
+  // ============================================================================
+  async getState(key) {
+    const fullKey = this.prefix(`circuit:${key}`);
+    const stmt = this.db.query(
+      "SELECT state, failure_count, last_failure_time, last_success_time FROM go_goscope_circuit WHERE key = ?"
+    );
+    const row = stmt.get(fullKey);
+    if (!row) return null;
+    return {
+      state: row.state,
+      failureCount: row.failure_count,
+      lastFailureTime: row.last_failure_time ?? void 0,
+      lastSuccessTime: row.last_success_time ?? void 0
+    };
+  }
+  async setState(key, state) {
+    const fullKey = this.prefix(`circuit:${key}`);
+    const now = Date.now();
+    this.db.run(
+      `
+				INSERT INTO go_goscope_circuit (key, state, failure_count, last_failure_time, last_success_time, updated_at)
+				VALUES (?, ?, ?, ?, ?, ?)
+				ON CONFLICT(key) DO UPDATE SET
+					state = excluded.state,
+					failure_count = excluded.failure_count,
+					last_failure_time = excluded.last_failure_time,
+					last_success_time = excluded.last_success_time,
+					updated_at = excluded.updated_at
+			`,
+      [
+        fullKey,
+        state.state,
+        state.failureCount,
+        state.lastFailureTime ?? null,
+        state.lastSuccessTime ?? null,
+        now
+      ]
+    );
+  }
+  async recordFailure(key, maxFailures) {
+    const state = await this.getState(key) ?? {
+      state: "closed",
+      failureCount: 0
+    };
+    state.failureCount++;
+    state.lastFailureTime = Date.now();
+    if (state.failureCount >= maxFailures) {
+      state.state = "open";
+    }
+    await this.setState(key, state);
+    return state.failureCount;
+  }
+  async recordSuccess(key) {
+    await this.setState(key, {
+      state: "closed",
+      failureCount: 0,
+      lastSuccessTime: Date.now()
+    });
+  }
+}
+
+export { BunSQLiteAdapter };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@go-go-scope/persistence-sqlite-bun",
+  "version": "2.0.0",
+  "description": "Bun-native SQLite persistence adapter for go-go-scope - uses bun:sqlite for optimal performance",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "lint": "biome check --write src/",
+    "test": "echo 'Run tests with: bun test src/index.test.ts'",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "bun",
+    "sqlite",
+    "persistence",
+    "distributed-locks",
+    "circuit-breaker",
+    "go-go-scope",
+    "bun:sqlite"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "author": "thelinuxlich",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thelinuxlich/go-go-scope.git",
+    "directory": "packages/persistence-sqlite-bun"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "go-go-scope": "workspace:*"
+  },
+  "peerDependencies": {
+    "bun": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "bun": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.3",
+    "@types/node": "^24",
+    "pkgroll": "^2.26.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}