@framers/sql-storage-adapter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Framers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,363 @@
+# SQL Storage Adapter
+
+[![npm version](https://img.shields.io/npm/v/@framers/sql-storage-adapter.svg)](https://www.npmjs.com/package/@framers/sql-storage-adapter)
+[![CI](https://github.com/wearetheframers/sql-storage-adapter/actions/workflows/ci.yml/badge.svg)](https://github.com/wearetheframers/sql-storage-adapter/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/wearetheframers/sql-storage-adapter/branch/master/graph/badge.svg)](https://codecov.io/gh/wearetheframers/sql-storage-adapter)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.6-blue.svg)](https://www.typescriptlang.org/)
+
+> One SQL interface for Node.js, browsers, and mobile apps. Write your database code once, run it anywhere.
+
+**[Documentation](https://wearetheframers.github.io/sql-storage-adapter/)** | **[GitHub](https://github.com/wearetheframers/sql-storage-adapter)** | **[NPM](https://www.npmjs.com/package/@framers/sql-storage-adapter)**
+
+## Why?
+
+Build apps that work across platforms without rewriting database code:
+- 🖥️ **Desktop** (Electron) - fast local storage with better-sqlite3
+- 🌐 **Web** - in-browser SQL with sql.js (WebAssembly)
+- 📱 **Mobile** (Capacitor/React Native) - native SQLite
+- ☁️ **Server** - PostgreSQL or SQLite
+
+```typescript
+import { createDatabase } from '@framers/sql-storage-adapter';
+
+// Auto-picks the best adapter for your environment
+const db = await createDatabase();
+
+// Same code everywhere
+await db.run('INSERT INTO users (name) VALUES (?)', ['Alice']);
+const user = await db.get('SELECT * FROM users WHERE id = ?', [1]);
+```
+
+## Installation
+
+```bash
+npm install @framers/sql-storage-adapter
+
+# Install adapters you need:
+npm install better-sqlite3      # Desktop (Node.js/Electron)
+npm install pg                  # PostgreSQL (servers)
+npm install @capacitor-community/sqlite  # Mobile (Capacitor)
+# sql.js included - no extra install needed
+```
+
+## Quick Start
+
+```typescript
+import { createDatabase } from '@framers/sql-storage-adapter';
+
+// Create database (auto-detects best option)
+const db = await createDatabase();
+
+// Create table
+await db.exec(`
+  CREATE TABLE IF NOT EXISTS todos (
+    id INTEGER PRIMARY KEY,
+    task TEXT NOT NULL,
+    done INTEGER DEFAULT 0
+  )
+`);
+
+// Insert data
+await db.run('INSERT INTO todos (task) VALUES (?)', ['Buy groceries']);
+
+// Query data
+const todos = await db.all('SELECT * FROM todos WHERE done = 0');
+
+// Clean up
+await db.close();
+```
+
+## Core API
+
+```typescript
+// Execute SQL (no results)
+await db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)');
+
+// Run mutation (INSERT/UPDATE/DELETE)
+const result = await db.run('INSERT INTO users (name) VALUES (?)', ['Alice']);
+console.log(result.lastInsertRowid);  // Auto-increment ID
+
+// Get single row
+const user = await db.get<User>('SELECT * FROM users WHERE id = ?', [1]);
+
+// Get all rows
+const users = await db.all<User>('SELECT * FROM users');
+
+// Transactions (automatic commit/rollback)
+await db.transaction(async (tx) => {
+  await tx.run('INSERT INTO users (name) VALUES (?)', ['Bob']);
+  await tx.run('INSERT INTO posts (user_id, title) VALUES (?, ?)', [1, 'Hello']);
+});
+
+// Batch operations (if supported)
+if (db.capabilities.has('batch')) {
+  await db.batch([
+    { statement: 'INSERT INTO users (name) VALUES (?)', parameters: ['Alice'] },
+    { statement: 'INSERT INTO users (name) VALUES (?)', parameters: ['Bob'] }
+  ]);
+}
+
+// Close connection
+await db.close();
+```
+
+## Adapter Selection
+
+Auto-detection order:
+
+```
+🖥️ Node.js:     better-sqlite3 → sql.js
+🌐 Browser:     sql.js
+📱 Mobile:      capacitor-sqlite → sql.js
+☁️ Server:      postgres → better-sqlite3 → sql.js
+```
+
+Override with specific adapter:
+
+```typescript
+// Use PostgreSQL explicitly
+const db = await createDatabase({ 
+  url: 'postgresql://localhost/mydb' 
+});
+
+// Use SQLite explicitly
+const db = await createDatabase({ 
+  file: './app.db' 
+});
+
+// Custom priority
+const db = await createDatabase({
+  priority: ['postgres', 'better-sqlite3'],
+  postgres: { connectionString: process.env.DATABASE_URL },
+  filePath: './fallback.db'
+});
+```
+
+## Auto-Sync & Offline Support
+
+Build offline-first apps with automatic cloud sync:
+
+```typescript
+import { createSyncManager } from '@framers/sql-storage-adapter';
+
+const manager = await createSyncManager({
+  primary: './app.db',                     // Local SQLite
+  remote: process.env.DATABASE_URL,        // Cloud PostgreSQL
+  sync: {
+    mode: 'auto',                          // Auto-sync after writes
+    conflictStrategy: 'last-write-wins'
+  }
+});
+
+// Work offline
+await manager.db.run('INSERT INTO tasks (title) VALUES (?)', ['Buy milk']);
+
+// Sync manually when needed
+const result = await manager.sync();
+console.log(`Synced ${result.recordsSynced} records`);
+```
+
+**Sync Modes:**
+- `manual` - Call `sync()` explicitly (default)
+- `auto` - Syncs after writes (debounced)
+- `periodic` - Syncs every N seconds
+- `realtime` - Syncs immediately on every write
+- `on-reconnect` - Syncs when network returns
+
+**Conflict Strategies:**
+- `last-write-wins` - Newest timestamp wins (default)
+- `local-wins` - Local always wins
+- `remote-wins` - Server is authority
+- `merge` - Custom merge function
+- `keep-both` - Duplicate records
+
+📖 **[Complete Offline Sync Guide](./guides/OFFLINE_SYNC.md)** - 8 real-world examples with mobile optimization
+
+## Cloud Backups
+
+Automatic S3-compatible backups (AWS S3, Cloudflare R2, MinIO):
+
+```typescript
+import { S3Client } from '@aws-sdk/client-s3';
+import { createCloudBackupManager } from '@framers/sql-storage-adapter';
+
+const s3 = new S3Client({
+  region: 'us-east-1',
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!
+  }
+});
+
+const manager = createCloudBackupManager(db, s3, 'my-backups', {
+  interval: 3600000,  // Hourly backups
+  maxBackups: 24,     // Keep 24 backups
+  options: { compression: 'gzip' }
+});
+
+manager.start();  // Auto-backup every hour
+
+// Manual backup
+await manager.backupNow();
+
+// Restore
+await manager.restore('backups/my-database-2024-01-15.json.gz');
+```
+
+## Data Migration
+
+Export, import, and migrate between adapters:
+
+```typescript
+import { 
+  migrateLocalToSupabase,
+  exportAsJSON,
+  importFromJSON 
+} from '@framers/sql-storage-adapter';
+
+// Export to JSON
+const backup = await exportAsJSON(db, { 
+  tables: ['users', 'posts'],
+  includeSchema: true 
+});
+
+// Import from JSON
+await importFromJSON(db, backup, {
+  dropTables: true,
+  batchSize: 100
+});
+
+// Migrate SQLite → PostgreSQL
+const result = await migrateLocalToSupabase(sqliteDb, postgresDb, {
+  verify: true,
+  onConflict: 'replace'
+});
+
+console.log(`Migrated ${result.rowsImported} rows in ${result.duration}ms`);
+```
+
+## PostgreSQL Remote Connections
+
+Connect to hosted databases (AWS RDS, Heroku, Supabase, etc.):
+
+```typescript
+import { connectDatabase } from '@framers/sql-storage-adapter';
+
+// Auto-detect from DATABASE_URL
+const db = await connectDatabase(process.env.DATABASE_URL);
+
+// Or configure explicitly
+const db = await connectDatabase({
+  host: 'db.example.com',
+  database: 'myapp',
+  user: 'dbuser',
+  password: process.env.DB_PASSWORD,
+  ssl: true,
+  max: 20  // Connection pool size
+});
+
+// Same API as SQLite!
+const users = await db.all('SELECT * FROM users');
+```
+
+📖 **[PostgreSQL Remote Guide](./guides/POSTGRES_REMOTE_CONNECTION.md)** - Cloud provider examples & SSL config
+
+## Adapter Comparison
+
+| Adapter | Best For | Speed | Size | Concurrent |
+|---------|----------|-------|------|------------|
+| **PostgreSQL** | Production servers | ⚡⚡⚡ | N/A | ✅ Yes |
+| **better-sqlite3** | Desktop apps | ⚡⚡⚡ | 6 MB | ❌ No |
+| **SQL.js** | Browsers | ⚡ | 2.3 MB | ❌ No |
+| **Capacitor** | Mobile apps | ⚡⚡⚡ | ~1 MB | ❌ No |
+
+## TypeScript Support
+
+Full type safety with generics:
+
+```typescript
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+// Type-safe queries
+const user = await db.get<User>('SELECT * FROM users WHERE id = ?', [1]);
+// user: User | null
+
+const users = await db.all<User>('SELECT * FROM users');
+// users: User[]
+
+// Runtime introspection
+const context = db.context;
+console.log('Adapter:', db.kind);
+console.log('Capabilities:', Array.from(db.capabilities));
+console.log('Max connections:', context.getLimitations().maxConnections);
+```
+
+## Event Monitoring
+
+Track queries and performance:
+
+```typescript
+db.events.on('query:error', (event) => {
+  console.error('Query failed:', event.statement, event.error);
+});
+
+db.events.on('performance:slow-query', (event) => {
+  if (event.duration > 1000) {
+    console.warn(`Slow query (${event.duration}ms):`, event.statement);
+  }
+});
+
+db.events.on('transaction:rollback', (event) => {
+  console.warn('Transaction rolled back:', event.error);
+});
+```
+
+## Examples
+
+Real-world usage in `examples/`:
+- `basic-usage.ts` - Getting started
+- `remote-postgres.ts` - Cloud database connections
+- `electron-app/` - Desktop app with better-sqlite3
+- `browser-extension/` - Chrome extension with SQL.js
+- `full-stack/` - Shared code frontend/backend
+- `offline-sync.ts` - Auto-sync patterns
+- `testing/` - Unit testing strategies
+
+## FAQ
+
+**Q: Which adapter should I use?**  
+Use `createDatabase()` - it auto-picks the best adapter for your environment.
+
+**Q: Can I switch adapters later?**  
+Yes. Use migration functions to move data between adapters.
+
+**Q: Is this production-ready?**  
+Yes. Built on battle-tested libraries (pg, better-sqlite3, sql.js). The adapter layer adds <1% overhead.
+
+**Q: What about schema migrations?**  
+Use any migration tool: [`node-pg-migrate`](https://github.com/salsita/node-pg-migrate), [`prisma`](https://www.prisma.io/), or raw SQL.
+
+**Q: How do I handle conflicts in sync?**  
+Use `conflictStrategy`: `last-write-wins` (default), `local-wins`, `remote-wins`, `merge`, or `keep-both`.
+
+**Q: Can I sync only on WiFi?**  
+Yes. Use `mode: 'manual'` and call `sync()` when `isOnWiFi === true`. See [Offline Sync Guide](./guides/OFFLINE_SYNC.md#1-mobile-app-with-wifi-only-sync).
+
+## Documentation
+
+- **[API Documentation](https://wearetheframers.github.io/sql-storage-adapter/)** - Complete TypeDoc reference
+- **[Offline Sync Guide](./guides/OFFLINE_SYNC.md)** - Comprehensive sync patterns
+- **[PostgreSQL Guide](./guides/POSTGRES_REMOTE_CONNECTION.md)** - Remote database setup
+- **[Architecture](./ARCHITECTURE.md)** - Design decisions
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md)
+
+## License
+
+MIT © [The Framers](https://frame.dev)

package/dist/adapters/baseStorageAdapter.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Abstract base class for SQL storage adapters.
+ *
+ * Provides common functionality and enforces consistent behavior across all adapters.
+ * Follows the Template Method pattern - subclasses implement adapter-specific logic
+ * while the base class handles cross-cutting concerns.
+ *
+ * ## Responsibilities
+ * - Parameter validation and sanitization
+ * - Error handling and standardization
+ * - Lifecycle management (open/close state tracking)
+ * - Performance monitoring
+ * - Logging and diagnostics
+ *
+ * @example Implementing a new adapter
+ * ```typescript
+ * export class MyAdapter extends BaseStorageAdapter {
+ *   protected async doOpen(options?: StorageOpenOptions): Promise<void> {
+ *     // Adapter-specific connection logic
+ *   }
+ *
+ *   protected async doRun(statement: string, parameters?: StorageParameters): Promise<StorageRunResult> {
+ *     // Adapter-specific mutation logic
+ *   }
+ *
+ *   // ... implement other abstract methods
+ * }
+ * ```
+ */
+import type { StorageAdapter, StorageCapability, StorageOpenOptions, StorageParameters, StorageRunResult, BatchOperation, BatchResult, PreparedStatement } from '../types';
+/**
+ * Options for BaseStorageAdapter configuration.
+ */
+export interface BaseAdapterOptions {
+    /** Enable detailed logging (default: false) */
+    verbose?: boolean;
+    /** Validate SQL statements before execution (default: true) */
+    validateSQL?: boolean;
+    /** Track performance metrics (default: true) */
+    trackPerformance?: boolean;
+    /** Max retry attempts for transient errors (default: 3) */
+    maxRetries?: number;
+}
+/**
+ * Performance metrics tracked by the base adapter.
+ */
+export interface AdapterMetrics {
+    /** Total number of queries executed */
+    totalQueries: number;
+    /** Total number of mutations (INSERT/UPDATE/DELETE) */
+    totalMutations: number;
+    /** Total number of transactions */
+    totalTransactions: number;
+    /** Total number of errors */
+    totalErrors: number;
+    /** Average query duration in milliseconds */
+    averageQueryDuration: number;
+    /** Time when adapter was opened */
+    openedAt: Date | null;
+}
+/**
+ * Abstract base class for SQL storage adapters.
+ *
+ * Implements common functionality shared by all adapters:
+ * - State management (open/close tracking)
+ * - Parameter validation
+ * - Error handling and wrapping
+ * - Performance metrics
+ * - Logging and diagnostics
+ */
+export declare abstract class BaseStorageAdapter implements StorageAdapter {
+    abstract readonly kind: string;
+    abstract readonly capabilities: ReadonlySet<StorageCapability>;
+    private state;
+    protected readonly options: Required<BaseAdapterOptions>;
+    private metrics;
+    private queryDurations;
+    private readonly MAX_DURATION_SAMPLES;
+    /**
+     * Creates a new adapter instance.
+     *
+     * @param options - Configuration options for the adapter
+     */
+    constructor(options?: BaseAdapterOptions);
+    /**
+     * Opens the adapter connection.
+     * Handles state management and delegates to subclass implementation.
+     */
+    open(options?: StorageOpenOptions): Promise<void>;
+    /**
+     * Executes a mutation statement (INSERT, UPDATE, DELETE).
+     */
+    run(statement: string, parameters?: StorageParameters): Promise<StorageRunResult>;
+    /**
+     * Retrieves a single row.
+     */
+    get<T = unknown>(statement: string, parameters?: StorageParameters): Promise<T | null>;
+    /**
+     * Retrieves all rows.
+     */
+    all<T = unknown>(statement: string, parameters?: StorageParameters): Promise<T[]>;
+    /**
+     * Executes a SQL script.
+     */
+    exec(script: string): Promise<void>;
+    /**
+     * Executes a transaction.
+     */
+    transaction<T>(fn: (trx: StorageAdapter) => Promise<T>): Promise<T>;
+    /**
+     * Closes the adapter connection.
+     */
+    close(): Promise<void>;
+    /**
+     * Executes a batch of operations (optional).
+     */
+    batch(operations: BatchOperation[]): Promise<BatchResult>;
+    /**
+     * Creates a prepared statement (optional).
+     */
+    prepare<T = unknown>(statement: string): PreparedStatement<T>;
+    /**
+     * Adapter-specific open logic.
+     * Called by base class after state validation.
+     */
+    protected abstract performOpen(options?: StorageOpenOptions): Promise<void>;
+    /**
+     * Adapter-specific mutation logic.
+     */
+    protected abstract performRun(statement: string, parameters?: StorageParameters): Promise<StorageRunResult>;
+    /**
+     * Adapter-specific single-row query logic.
+     */
+    protected abstract performGet<T>(statement: string, parameters?: StorageParameters): Promise<T | null>;
+    /**
+     * Adapter-specific multi-row query logic.
+     */
+    protected abstract performAll<T>(statement: string, parameters?: StorageParameters): Promise<T[]>;
+    /**
+     * Adapter-specific script execution logic.
+     */
+    protected abstract performExec(script: string): Promise<void>;
+    /**
+     * Adapter-specific transaction logic.
+     */
+    protected abstract performTransaction<T>(fn: (trx: StorageAdapter) => Promise<T>): Promise<T>;
+    /**
+     * Adapter-specific close logic.
+     */
+    protected abstract performClose(): Promise<void>;
+    /**
+     * Adapter-specific batch logic (optional).
+     * Only called if adapter declares 'batch' capability.
+     */
+    protected performBatch?(operations: BatchOperation[]): Promise<BatchResult>;
+    /**
+     * Adapter-specific prepared statement logic (optional).
+     * Only called if adapter declares 'prepared' capability.
+     */
+    protected performPrepare?<T>(statement: string): PreparedStatement<T>;
+    /**
+     * Asserts that adapter is in open state.
+     * @throws {Error} If adapter is not open
+     */
+    protected assertOpen(): void;
+    /**
+     * Validates SQL statement.
+     * @throws {Error} If statement is invalid
+     */
+    protected validateStatement(statement: string): void;
+    /**
+     * Wraps an error with adapter context.
+     */
+    protected wrapError(message: string, error: unknown): Error;
+    /**
+     * Logs a message if verbose mode is enabled.
+     */
+    protected log(message: string): void;
+    /**
+     * Tracks query duration for performance metrics.
+     */
+    private trackDuration;
+    /**
+     * Gets current adapter state.
+     */
+    getState(): string;
+    /**
+     * Gets performance metrics.
+     */
+    getMetrics(): Readonly<AdapterMetrics>;
+    /**
+     * Checks if adapter is open.
+     */
+    isOpen(): boolean;
+    /**
+     * Checks if adapter is closed.
+     */
+    isClosed(): boolean;
+    /**
+     * Gets uptime in milliseconds.
+     */
+    getUptime(): number;
+}
+//# sourceMappingURL=baseStorageAdapter.d.ts.map

package/dist/adapters/baseStorageAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseStorageAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/baseStorageAdapter.ts"],"names":[],"mappings":"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"}