remult-sqlite-s3 0.1.0

package/dist/index.js

@@ -0,0 +1,1109 @@
+import { SqlDatabase } from 'remult';
+import { SqliteCoreDataProvider } from 'remult/remult-sqlite-core-js';
+import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, HeadObjectCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
+import { createHash, randomUUID } from 'crypto';
+import { hostname } from 'os';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, unlinkSync, statSync } from 'fs';
+import { dirname } from 'path';
+import Database from 'better-sqlite3';
+
+// src/index.ts
+var S3Operations = class {
+  client;
+  bucket;
+  keyPrefix;
+  maxRetries;
+  constructor(config, maxRetries = 3) {
+    const clientConfig = {
+      region: config.region
+    };
+    if (config.endpoint) {
+      clientConfig.endpoint = config.endpoint;
+    }
+    if (config.credentials) {
+      clientConfig.credentials = {
+        accessKeyId: config.credentials.accessKeyId,
+        secretAccessKey: config.credentials.secretAccessKey
+      };
+    }
+    if (config.forcePathStyle) {
+      clientConfig.forcePathStyle = true;
+    }
+    this.client = new S3Client(clientConfig);
+    this.bucket = config.bucket;
+    this.keyPrefix = config.keyPrefix.replace(/\/$/, "");
+    this.maxRetries = maxRetries;
+  }
+  getFullKey(key) {
+    return `${this.keyPrefix}/${key}`;
+  }
+  /**
+   * Get an object from S3
+   */
+  async get(key) {
+    return this.withRetry(async () => {
+      try {
+        const response = await this.client.send(
+          new GetObjectCommand({
+            Bucket: this.bucket,
+            Key: this.getFullKey(key)
+          })
+        );
+        if (!response.Body) {
+          return null;
+        }
+        const chunks = [];
+        for await (const chunk of response.Body) {
+          chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+      } catch (error) {
+        if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
+          return null;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Get object as JSON
+   */
+  async getJson(key) {
+    const data = await this.get(key);
+    if (!data) return null;
+    return JSON.parse(data.toString("utf-8"));
+  }
+  /**
+   * Put an object to S3
+   */
+  async put(key, data) {
+    return this.withRetry(async () => {
+      await this.client.send(
+        new PutObjectCommand({
+          Bucket: this.bucket,
+          Key: this.getFullKey(key),
+          Body: typeof data === "string" ? Buffer.from(data, "utf-8") : data
+        })
+      );
+    });
+  }
+  /**
+   * Put JSON object to S3
+   */
+  async putJson(key, data) {
+    await this.put(key, JSON.stringify(data, null, 2));
+  }
+  /**
+   * Delete an object from S3
+   */
+  async delete(key) {
+    return this.withRetry(async () => {
+      await this.client.send(
+        new DeleteObjectCommand({
+          Bucket: this.bucket,
+          Key: this.getFullKey(key)
+        })
+      );
+    });
+  }
+  /**
+   * Check if an object exists
+   */
+  async exists(key) {
+    try {
+      await this.client.send(
+        new HeadObjectCommand({
+          Bucket: this.bucket,
+          Key: this.getFullKey(key)
+        })
+      );
+      return true;
+    } catch (error) {
+      if (error.name === "NotFound" || error.$metadata?.httpStatusCode === 404) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * List objects with a prefix
+   */
+  async list(prefix) {
+    return this.withRetry(async () => {
+      const keys = [];
+      let continuationToken;
+      do {
+        const response = await this.client.send(
+          new ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: this.getFullKey(prefix),
+            ContinuationToken: continuationToken
+          })
+        );
+        if (response.Contents) {
+          for (const obj of response.Contents) {
+            if (obj.Key) {
+              const relativeKey = obj.Key.substring(this.keyPrefix.length + 1);
+              keys.push(relativeKey);
+            }
+          }
+        }
+        continuationToken = response.NextContinuationToken;
+      } while (continuationToken);
+      return keys;
+    });
+  }
+  /**
+   * Conditional put - only succeeds if key doesn't exist
+   * Used for lock acquisition
+   */
+  async putIfNotExists(key, data) {
+    try {
+      const exists = await this.exists(key);
+      if (exists) {
+        return false;
+      }
+      await this.put(key, data);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Conditional update - only succeeds if current content matches expected
+   * Used for lock refresh
+   */
+  async updateIfMatch(key, expectedContent, newContent) {
+    try {
+      const current = await this.get(key);
+      if (!current || current.toString("utf-8") !== expectedContent) {
+        return false;
+      }
+      await this.put(key, newContent);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Execute with retry logic
+   */
+  async withRetry(fn) {
+    let lastError = null;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (error.$metadata?.httpStatusCode >= 400 && error.$metadata?.httpStatusCode < 500 && error.$metadata?.httpStatusCode !== 429) {
+          throw error;
+        }
+        const delay = Math.min(1e3 * Math.pow(2, attempt) + Math.random() * 1e3, 3e4);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Close the S3 client
+   */
+  destroy() {
+    this.client.destroy();
+  }
+};
+var LOCK_KEY = "lock.json";
+var S3Lock = class {
+  s3;
+  lockId;
+  holder;
+  generation = "";
+  ttl;
+  refreshInterval;
+  refreshTimer = null;
+  acquired = false;
+  forceLock;
+  onEvent;
+  verbose;
+  constructor(s3, config, onEvent, verbose = false) {
+    this.s3 = s3;
+    this.lockId = randomUUID();
+    this.holder = `${hostname()}-${process.pid}-${this.lockId.substring(0, 8)}`;
+    this.ttl = config.lockTtl;
+    this.refreshInterval = config.lockRefresh;
+    this.forceLock = config.forceLock;
+    this.onEvent = onEvent;
+    this.verbose = verbose;
+  }
+  /**
+   * Acquire the lock
+   * Returns the current generation ID if successful
+   */
+  async acquire() {
+    this.log("Attempting to acquire lock...");
+    const existingLock = await this.s3.getJson(LOCK_KEY);
+    if (existingLock) {
+      const expiresAt = new Date(existingLock.expiresAt).getTime();
+      const now = Date.now();
+      if (expiresAt > now && !this.forceLock) {
+        throw new Error(
+          `Database is locked by another process: ${existingLock.holder} (expires in ${Math.round((expiresAt - now) / 1e3)}s)`
+        );
+      }
+      if (this.forceLock && expiresAt > now) {
+        this.log(`Force taking over lock from ${existingLock.holder}`);
+      } else {
+        this.log(`Taking over expired lock from ${existingLock.holder}`);
+      }
+      this.generation = existingLock.generation;
+    }
+    if (!this.generation) {
+      this.generation = randomUUID();
+      this.log(`Creating new generation: ${this.generation}`);
+    }
+    const lockInfo = {
+      lockId: this.lockId,
+      holder: this.holder,
+      acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: new Date(Date.now() + this.ttl).toISOString(),
+      generation: this.generation
+    };
+    await this.s3.putJson(LOCK_KEY, lockInfo);
+    const verifyLock = await this.s3.getJson(LOCK_KEY);
+    if (!verifyLock || verifyLock.lockId !== this.lockId) {
+      throw new Error("Failed to acquire lock - race condition detected");
+    }
+    this.acquired = true;
+    this.startRefresh();
+    this.onEvent({ type: "lock_acquired", lockId: this.lockId });
+    this.log(`Lock acquired: ${this.holder}`);
+    return this.generation;
+  }
+  /**
+   * Release the lock
+   */
+  async release() {
+    if (!this.acquired) return;
+    this.stopRefresh();
+    try {
+      const currentLock = await this.s3.getJson(LOCK_KEY);
+      if (currentLock && currentLock.lockId === this.lockId) {
+        await this.s3.delete(LOCK_KEY);
+        this.log("Lock released");
+      }
+    } catch (error) {
+      this.log(`Error releasing lock: ${error}`);
+    }
+    this.acquired = false;
+  }
+  /**
+   * Check if we still hold the lock
+   */
+  async isValid() {
+    if (!this.acquired) return false;
+    try {
+      const currentLock = await this.s3.getJson(LOCK_KEY);
+      return currentLock?.lockId === this.lockId;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get current generation
+   */
+  getGeneration() {
+    return this.generation;
+  }
+  /**
+   * Set generation (used during recovery)
+   */
+  setGeneration(generation) {
+    this.generation = generation;
+  }
+  /**
+   * Create a new generation (used when starting fresh)
+   */
+  async newGeneration() {
+    this.generation = randomUUID();
+    if (this.acquired) {
+      const lockInfo = {
+        lockId: this.lockId,
+        holder: this.holder,
+        acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        expiresAt: new Date(Date.now() + this.ttl).toISOString(),
+        generation: this.generation
+      };
+      await this.s3.putJson(LOCK_KEY, lockInfo);
+    }
+    return this.generation;
+  }
+  startRefresh() {
+    this.refreshTimer = setInterval(async () => {
+      try {
+        await this.refresh();
+      } catch (error) {
+        this.log(`Lock refresh failed: ${error}`);
+        this.onEvent({ type: "lock_lost", reason: String(error) });
+        this.stopRefresh();
+        this.acquired = false;
+      }
+    }, this.refreshInterval);
+  }
+  stopRefresh() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+  }
+  async refresh() {
+    if (!this.acquired) return;
+    const currentLock = await this.s3.getJson(LOCK_KEY);
+    if (!currentLock || currentLock.lockId !== this.lockId) {
+      throw new Error("Lock was taken by another process");
+    }
+    const lockInfo = {
+      ...currentLock,
+      expiresAt: new Date(Date.now() + this.ttl).toISOString()
+    };
+    await this.s3.putJson(LOCK_KEY, lockInfo);
+    this.log("Lock refreshed");
+  }
+  log(message) {
+    if (this.verbose) {
+      console.log(`[S3Lock] ${message}`);
+    }
+  }
+};
+var WALManager = class {
+  s3;
+  dbPath;
+  walPath;
+  generation;
+  walThreshold;
+  onEvent;
+  verbose;
+  walIndex = 0;
+  lastUploadedOffset = 0;
+  pendingUpload = null;
+  constructor(s3, dbPath, generation, config, onEvent, verbose = false) {
+    this.s3 = s3;
+    this.dbPath = dbPath;
+    this.walPath = `${dbPath}-wal`;
+    this.generation = generation;
+    this.walThreshold = config.walThreshold;
+    this.onEvent = onEvent;
+    this.verbose = verbose;
+  }
+  /**
+   * Set the generation ID
+   */
+  setGeneration(generation) {
+    this.generation = generation;
+    this.walIndex = 0;
+    this.lastUploadedOffset = 0;
+  }
+  /**
+   * Set the starting WAL index (used during recovery)
+   */
+  setWalIndex(index) {
+    this.walIndex = index;
+  }
+  /**
+   * Check if WAL needs to be synced based on threshold
+   */
+  needsSync() {
+    if (!existsSync(this.walPath)) {
+      return false;
+    }
+    try {
+      const stat = statSync(this.walPath);
+      const pendingBytes = stat.size - this.lastUploadedOffset;
+      return pendingBytes >= this.walThreshold;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the current WAL size
+   */
+  getWalSize() {
+    if (!existsSync(this.walPath)) {
+      return 0;
+    }
+    try {
+      return statSync(this.walPath).size;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Sync WAL to S3 (non-blocking in async mode)
+   */
+  async syncAsync() {
+    if (this.pendingUpload) {
+      await this.pendingUpload;
+    }
+    if (!this.needsSync()) {
+      return;
+    }
+    this.pendingUpload = this.uploadWalSegment();
+    this.pendingUpload.catch((error) => {
+      this.log(`Async WAL upload failed: ${error}`);
+      this.onEvent({
+        type: "sync_error",
+        error,
+        context: "wal_upload",
+        willRetry: true
+      });
+    }).finally(() => {
+      this.pendingUpload = null;
+    });
+  }
+  /**
+   * Sync WAL to S3 (blocking)
+   */
+  async sync() {
+    if (this.pendingUpload) {
+      await this.pendingUpload;
+    }
+    if (!existsSync(this.walPath)) {
+      return;
+    }
+    await this.uploadWalSegment();
+  }
+  /**
+   * Force sync all pending WAL data
+   */
+  async flush() {
+    if (this.pendingUpload) {
+      await this.pendingUpload;
+    }
+    if (!existsSync(this.walPath)) {
+      return;
+    }
+    const stat = statSync(this.walPath);
+    if (stat.size > this.lastUploadedOffset) {
+      await this.uploadWalSegment();
+    }
+  }
+  /**
+   * Wait for any pending uploads to complete
+   */
+  async waitForPending() {
+    if (this.pendingUpload) {
+      await this.pendingUpload;
+    }
+  }
+  async uploadWalSegment() {
+    if (!existsSync(this.walPath)) {
+      return;
+    }
+    const walData = readFileSync(this.walPath);
+    const currentSize = walData.length;
+    if (currentSize <= this.lastUploadedOffset) {
+      return;
+    }
+    const segment = walData.subarray(this.lastUploadedOffset);
+    const checksum = createHash("sha256").update(segment).digest("hex");
+    this.walIndex++;
+    const indexStr = this.walIndex.toString().padStart(10, "0");
+    const segmentKey = `generations/${this.generation}/wal/${indexStr}.wal`;
+    await this.s3.put(segmentKey, segment);
+    const meta = {
+      generation: this.generation,
+      index: this.walIndex,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      size: segment.length,
+      checksum,
+      startOffset: this.lastUploadedOffset,
+      endOffset: currentSize
+    };
+    await this.s3.putJson(`generations/${this.generation}/wal/${indexStr}.meta.json`, meta);
+    this.lastUploadedOffset = currentSize;
+    this.log(`Uploaded WAL segment ${this.walIndex} (${segment.length} bytes)`);
+    this.onEvent({
+      type: "wal_uploaded",
+      generation: this.generation,
+      index: this.walIndex,
+      size: segment.length
+    });
+  }
+  log(message) {
+    if (this.verbose) {
+      console.log(`[WALManager] ${message}`);
+    }
+  }
+};
+var RecoveryManager = class {
+  s3;
+  dbPath;
+  onEvent;
+  verbose;
+  constructor(s3, dbPath, onEvent, verbose = false) {
+    this.s3 = s3;
+    this.dbPath = dbPath;
+    this.onEvent = onEvent;
+    this.verbose = verbose;
+  }
+  /**
+   * Find the latest generation in S3 that has a valid snapshot
+   */
+  async findLatestGeneration() {
+    const generations = await this.s3.list("generations/");
+    const genSet = /* @__PURE__ */ new Set();
+    for (const key of generations) {
+      const match = key.match(/^generations\/([^/]+)\//);
+      if (match) {
+        genSet.add(match[1]);
+      }
+    }
+    if (genSet.size === 0) {
+      return null;
+    }
+    let latestGen = null;
+    let latestTime = 0;
+    for (const gen of genSet) {
+      const hasSnapshot = await this.s3.exists(`generations/${gen}/snapshot.db`);
+      if (!hasSnapshot) {
+        this.log(`Skipping generation ${gen} - no snapshot`);
+        continue;
+      }
+      const genInfo = await this.s3.getJson(`generations/${gen}/generation.json`);
+      if (genInfo) {
+        const createdAt = new Date(genInfo.createdAt).getTime();
+        if (createdAt > latestTime) {
+          latestTime = createdAt;
+          latestGen = gen;
+        }
+      }
+    }
+    return latestGen;
+  }
+  /**
+   * Recover database from S3
+   * Returns the generation ID and highest WAL index
+   */
+  async recover(generation) {
+    this.log(`Starting recovery for generation: ${generation}`);
+    this.onEvent({ type: "recovery_started", generation });
+    const dir = dirname(this.dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.cleanupLocalFiles();
+    const snapshotMeta = await this.s3.getJson(
+      `generations/${generation}/snapshot.meta.json`
+    );
+    if (!snapshotMeta) {
+      throw new Error(`No snapshot metadata found for generation ${generation}`);
+    }
+    const snapshotData = await this.s3.get(`generations/${generation}/snapshot.db`);
+    if (!snapshotData) {
+      throw new Error(`No snapshot found for generation ${generation}`);
+    }
+    const checksum = createHash("sha256").update(snapshotData).digest("hex");
+    if (checksum !== snapshotMeta.checksum) {
+      throw new Error(
+        `Snapshot checksum mismatch: expected ${snapshotMeta.checksum}, got ${checksum}`
+      );
+    }
+    writeFileSync(this.dbPath, snapshotData);
+    this.log(`Restored snapshot (${snapshotData.length} bytes)`);
+    const walFiles = await this.s3.list(`generations/${generation}/wal/`);
+    const walMetas = [];
+    for (const key of walFiles) {
+      if (key.endsWith(".meta.json")) {
+        const meta = await this.s3.getJson(key);
+        if (meta) {
+          walMetas.push(meta);
+        }
+      }
+    }
+    walMetas.sort((a, b) => a.index - b.index);
+    let highestWalIndex = 0;
+    const walPath = `${this.dbPath}-wal`;
+    for (const meta of walMetas) {
+      const indexStr = meta.index.toString().padStart(10, "0");
+      const walData = await this.s3.get(`generations/${generation}/wal/${indexStr}.wal`);
+      if (!walData) {
+        this.log(`Warning: WAL segment ${meta.index} not found, stopping recovery`);
+        break;
+      }
+      const walChecksum = createHash("sha256").update(walData).digest("hex");
+      if (walChecksum !== meta.checksum) {
+        this.log(`Warning: WAL segment ${meta.index} checksum mismatch, stopping recovery`);
+        break;
+      }
+      appendFileSync(walPath, walData);
+      highestWalIndex = meta.index;
+      this.log(`Applied WAL segment ${meta.index} (${walData.length} bytes)`);
+    }
+    this.log(`Recovery completed: ${walMetas.length} WAL segments applied`);
+    this.onEvent({
+      type: "recovery_completed",
+      generation,
+      segments: walMetas.length
+    });
+    return {
+      generation,
+      walIndex: highestWalIndex,
+      recovered: true
+    };
+  }
+  /**
+   * Check if local database exists and is valid
+   */
+  localDatabaseExists() {
+    return existsSync(this.dbPath);
+  }
+  /**
+   * Clean up local database files
+   */
+  cleanupLocalFiles() {
+    const files = [
+      this.dbPath,
+      `${this.dbPath}-wal`,
+      `${this.dbPath}-shm`
+    ];
+    for (const file of files) {
+      if (existsSync(file)) {
+        try {
+          unlinkSync(file);
+        } catch (error) {
+          this.log(`Warning: Could not delete ${file}: ${error}`);
+        }
+      }
+    }
+  }
+  log(message) {
+    if (this.verbose) {
+      console.log(`[Recovery] ${message}`);
+    }
+  }
+};
+var S3SyncManager = class {
+  s3;
+  lock;
+  walManager;
+  recoveryManager;
+  db;
+  dbPath;
+  sqliteOptions;
+  syncConfig;
+  onEvent;
+  verbose;
+  generation = "";
+  snapshotTimer = null;
+  closed = false;
+  constructor(options) {
+    this.dbPath = options.dbPath;
+    this.sqliteOptions = options.sqliteOptions;
+    this.syncConfig = options.sync;
+    this.onEvent = options.onEvent;
+    this.verbose = options.verbose;
+    this.s3 = new S3Operations(options.s3, options.sync.maxRetries);
+    this.lock = new S3Lock(this.s3, options.sync, options.onEvent, options.verbose);
+    this.recoveryManager = new RecoveryManager(this.s3, this.dbPath, options.onEvent, options.verbose);
+  }
+  /**
+   * Initialize the sync manager
+   * - Acquire lock
+   * - Recover from S3 if needed
+   * - Open database
+   * - Start sync timers
+   */
+  async initialize() {
+    this.log("Initializing S3SyncManager...");
+    const lockGeneration = await this.lock.acquire();
+    const latestGeneration = await this.recoveryManager.findLatestGeneration();
+    let recovered = false;
+    if (latestGeneration) {
+      if (!this.recoveryManager.localDatabaseExists()) {
+        this.log("No local database found, recovering from S3...");
+        const result = await this.recoveryManager.recover(latestGeneration);
+        this.generation = result.generation;
+        recovered = true;
+        this.lock.setGeneration(this.generation);
+      } else {
+        this.generation = lockGeneration;
+        this.log("Local database exists, using existing generation");
+      }
+    } else {
+      this.generation = await this.lock.newGeneration();
+      this.log("No S3 data found, starting new generation");
+    }
+    this.walManager = new WALManager(
+      this.s3,
+      this.dbPath,
+      this.generation,
+      this.syncConfig,
+      this.onEvent,
+      this.verbose
+    );
+    const dir = dirname(this.dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath, this.sqliteOptions);
+    this.db.pragma("journal_mode = WAL");
+    await this.createGenerationInfo();
+    if (!latestGeneration || recovered) {
+      await this.snapshot();
+    }
+    this.startSnapshotTimer();
+    this.log(`Initialized with generation: ${this.generation}`);
+    this.onEvent({ type: "initialized", generation: this.generation, recovered });
+    return this.db;
+  }
+  /**
+   * Called after write operations
+   */
+  async onWrite() {
+    if (this.closed) return;
+    if (this.syncConfig.mode === "sync") {
+      await this.snapshot();
+    }
+  }
+  /**
+   * Force sync WAL to S3
+   */
+  async syncWal() {
+    if (this.closed) return;
+    await this.snapshot();
+  }
+  /**
+   * Force full sync (WAL + check for snapshot)
+   */
+  async sync() {
+    if (this.closed) return;
+    await this.walManager.flush();
+    if (this.walManager.getWalSize() > this.syncConfig.walThreshold * 10) {
+      await this.snapshot();
+    }
+  }
+  /**
+   * Create a full snapshot
+   */
+  async snapshot() {
+    if (this.closed) return;
+    this.log("Creating snapshot...");
+    await this.walManager.flush();
+    this.db.pragma("wal_checkpoint(TRUNCATE)");
+    const dbData = readFileSync(this.dbPath);
+    const checksum = createHash("sha256").update(dbData).digest("hex");
+    await this.s3.put(`generations/${this.generation}/snapshot.db`, dbData);
+    const meta = {
+      generation: this.generation,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      size: dbData.length,
+      checksum
+    };
+    await this.s3.putJson(`generations/${this.generation}/snapshot.meta.json`, meta);
+    await this.updateGenerationInfo();
+    this.log(`Snapshot created (${dbData.length} bytes)`);
+    this.onEvent({
+      type: "snapshot_uploaded",
+      generation: this.generation,
+      size: dbData.length
+    });
+  }
+  /**
+   * Close the sync manager
+   */
+  async close() {
+    if (this.closed) return;
+    this.log("Closing S3SyncManager...");
+    this.stopSnapshotTimer();
+    await this.walManager.waitForPending();
+    try {
+      await this.snapshot();
+      this.log("Final snapshot completed");
+    } catch (error) {
+      this.log(`Error during final snapshot: ${error}`);
+    }
+    this.closed = true;
+    if (this.db) {
+      this.db.close();
+      this.log("Database closed");
+    }
+    await this.lock.release();
+    this.log("Lock released");
+    this.s3.destroy();
+    this.log("S3SyncManager closed");
+  }
+  /**
+   * Get the current generation
+   */
+  getGeneration() {
+    return this.generation;
+  }
+  async createGenerationInfo() {
+    const info = {
+      id: this.generation,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      snapshotIndex: 0,
+      walIndex: 0
+    };
+    await this.s3.putJson(`generations/${this.generation}/generation.json`, info);
+  }
+  async updateGenerationInfo() {
+    const existing = await this.s3.getJson(
+      `generations/${this.generation}/generation.json`
+    );
+    const info = {
+      id: this.generation,
+      createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      snapshotIndex: (existing?.snapshotIndex ?? 0) + 1,
+      walIndex: existing?.walIndex ?? 0
+    };
+    await this.s3.putJson(`generations/${this.generation}/generation.json`, info);
+  }
+  startSnapshotTimer() {
+    this.snapshotTimer = setInterval(async () => {
+      try {
+        await this.snapshot();
+      } catch (error) {
+        this.log(`Scheduled snapshot failed: ${error}`);
+        this.onEvent({
+          type: "sync_error",
+          error,
+          context: "scheduled_snapshot",
+          willRetry: true
+        });
+      }
+    }, this.syncConfig.snapshotInterval);
+  }
+  stopSnapshotTimer() {
+    if (this.snapshotTimer) {
+      clearInterval(this.snapshotTimer);
+      this.snapshotTimer = null;
+    }
+  }
+  log(message) {
+    if (this.verbose) {
+      console.log(`[S3SyncManager] ${message}`);
+    }
+  }
+};
+
+// src/provider.ts
+var BetterSqlite3S3SqlResult = class {
+  constructor(result) {
+    this.result = result;
+    this.rows = result;
+  }
+  rows;
+  getColumnKeyInResultForIndexInSelect(index) {
+    if (this.result.length === 0) return "";
+    return Object.keys(this.result[0])[index];
+  }
+};
+var BetterSqlite3S3Command = class {
+  constructor(db, syncManager, syncMode = "async") {
+    this.db = db;
+    this.syncManager = syncManager;
+    this.syncMode = syncMode;
+  }
+  values = {};
+  i = 0;
+  /** @deprecated use `param` instead */
+  addParameterAndReturnSqlToken(val) {
+    return this.param(val);
+  }
+  param(val) {
+    if (val instanceof Date) {
+      val = val.valueOf();
+    }
+    if (typeof val === "boolean") {
+      val = val ? 1 : 0;
+    }
+    const key = ":" + this.i++;
+    this.values[key.substring(1)] = val;
+    return key;
+  }
+  async execute(sql) {
+    const stmt = this.db.prepare(sql);
+    if (stmt.reader) {
+      const rows = stmt.all(this.values);
+      return new BetterSqlite3S3SqlResult(rows);
+    } else {
+      stmt.run(this.values);
+      if (this.syncManager) {
+        if (this.syncMode === "sync") {
+          await this.syncManager.syncWal();
+        } else {
+          this.syncManager.onWrite().catch(console.error);
+        }
+      }
+      return new BetterSqlite3S3SqlResult([]);
+    }
+  }
+};
+var BetterSqlite3S3DataProvider = class extends SqliteCoreDataProvider {
+  db;
+  syncManager;
+  options;
+  initialized = false;
+  initPromise = null;
+  constructor(options) {
+    super(
+      () => {
+        this.ensureInitialized();
+        return new BetterSqlite3S3Command(this.db, this.syncManager, this.options.sync.mode);
+      },
+      async () => {
+        await this.close();
+      }
+    );
+    this.options = this.applyDefaults(options);
+  }
+  /**
+   * Async initialization - must be called before use
+   */
+  async init() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this.doInit();
+    return this.initPromise;
+  }
+  async doInit() {
+    this.syncManager = new S3SyncManager({
+      dbPath: this.options.file,
+      sqliteOptions: this.options.sqliteOptions,
+      s3: this.options.s3,
+      sync: this.options.sync,
+      onEvent: this.options.onEvent,
+      verbose: this.options.verbose
+    });
+    this.db = await this.syncManager.initialize();
+    this.initialized = true;
+  }
+  /**
+   * Get the underlying database (for advanced use cases)
+   */
+  get rawDatabase() {
+    this.ensureInitialized();
+    return this.db;
+  }
+  /**
+   * Get the sync manager (for manual sync control)
+   */
+  get sync() {
+    this.ensureInitialized();
+    return this.syncManager;
+  }
+  /**
+   * Force sync to S3
+   */
+  async forceSync() {
+    this.ensureInitialized();
+    await this.syncManager.sync();
+  }
+  /**
+   * Force a full snapshot
+   */
+  async snapshot() {
+    this.ensureInitialized();
+    await this.syncManager.snapshot();
+  }
+  /**
+   * Close the database and release resources
+   */
+  async close() {
+    if (!this.initialized) return;
+    await this.syncManager.close();
+    this.initialized = false;
+  }
+  /**
+   * Check if the provider is initialized
+   */
+  get isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get the current generation ID
+   */
+  get generation() {
+    this.ensureInitialized();
+    return this.syncManager.getGeneration();
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error(
+        "BetterSqlite3S3DataProvider not initialized. Call init() before using."
+      );
+    }
+  }
+  applyDefaults(options) {
+    const prefix = options.s3.keyPrefix ? `${options.s3.keyPrefix.replace(/\/$/, "")}/${options.s3.databaseName}` : options.s3.databaseName;
+    return {
+      file: options.file,
+      sqliteOptions: options.sqliteOptions ?? {},
+      s3: {
+        bucket: options.s3.bucket,
+        databaseName: options.s3.databaseName,
+        keyPrefix: prefix,
+        region: options.s3.region ?? "us-east-1",
+        endpoint: options.s3.endpoint,
+        credentials: options.s3.credentials,
+        forcePathStyle: options.s3.forcePathStyle
+      },
+      sync: {
+        mode: options.sync?.mode ?? "async",
+        walThreshold: options.sync?.walThreshold ?? 1024 * 1024,
+        // 1MB
+        snapshotInterval: options.sync?.snapshotInterval ?? 5 * 60 * 1e3,
+        // 5 min
+        maxRetries: options.sync?.maxRetries ?? 3,
+        lockTtl: options.sync?.lockTtl ?? 60 * 1e3,
+        // 60s
+        lockRefresh: options.sync?.lockRefresh ?? 30 * 1e3,
+        // 30s
+        forceLock: options.sync?.forceLock ?? false
+      },
+      onEvent: options.onEvent ?? (() => {
+      }),
+      verbose: options.verbose ?? false
+    };
+  }
+};
+
+// src/index.ts
+function createS3DataProvider(options) {
+  let provider;
+  let dataProvider;
+  let initPromise;
+  return async () => {
+    if (dataProvider) return dataProvider;
+    if (initPromise) return initPromise;
+    initPromise = (async () => {
+      provider = new BetterSqlite3S3DataProvider(options);
+      await provider.init();
+      dataProvider = new SqlDatabase(provider);
+      let shuttingDown = false;
+      const shutdown = async (signal) => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        if (options.verbose) {
+          console.log(`[remult-sqlite-s3] ${signal} received, closing...`);
+        }
+        try {
+          await provider?.close();
+          if (options.verbose) {
+            console.log("[remult-sqlite-s3] Shutdown complete");
+          }
+        } catch (error) {
+          console.error("[remult-sqlite-s3] Shutdown error:", error);
+        }
+        process.exit(0);
+      };
+      process.on("SIGTERM", () => shutdown("SIGTERM"));
+      process.on("SIGINT", () => shutdown("SIGINT"));
+      return dataProvider;
+    })();
+    return initPromise;
+  };
+}
+
+export { BetterSqlite3S3DataProvider, S3SyncManager, createS3DataProvider };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map