remult-sqlite-github 0.1.0

package/dist/index.js

@@ -0,0 +1,1068 @@
+import { SqlDatabase } from 'remult';
+import { BetterSqlite3DataProvider } from 'remult/remult-better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import * as zlib from 'zlib';
+import { promisify } from 'util';
+import Database from 'better-sqlite3';
+
+// src/index.ts
+var GITHUB_API_BASE = "https://api.github.com";
+var GitHubOperations = class {
+  config;
+  maxRetries;
+  cachedToken = null;
+  tokenExpiry = 0;
+  onEvent;
+  verbose;
+  constructor(config, maxRetries = 3, onEvent, verbose = false) {
+    this.config = config;
+    this.maxRetries = maxRetries;
+    this.onEvent = onEvent;
+    this.verbose = verbose;
+  }
+  /**
+   * Get a file from the repository
+   */
+  async getFile(path3) {
+    const fullPath = this.getFullPath(path3);
+    const url = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}/contents/${fullPath}?ref=${this.config.branch}`;
+    const response = await this.withRetry(() => this.fetch(url));
+    if (response.status === 404) {
+      return null;
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Failed to get file ${path3}: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    if (data.content) {
+      const content = Buffer.from(data.content, "base64");
+      return {
+        content,
+        sha: data.sha,
+        size: data.size
+      };
+    }
+    if (data.sha && data.size > 0) {
+      return this.getBlob(data.sha, data.size);
+    }
+    return null;
+  }
+  /**
+   * Get a large file using the blob API
+   */
+  async getBlob(sha, size) {
+    const url = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}/git/blobs/${sha}`;
+    const response = await this.withRetry(() => this.fetch(url));
+    if (!response.ok) {
+      throw new Error(
+        `Failed to get blob ${sha}: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    const content = Buffer.from(data.content, "base64");
+    return {
+      content,
+      sha,
+      size
+    };
+  }
+  /**
+   * Create or update a file in the repository
+   * Returns the new commit SHA
+   */
+  async putFile(path3, content, message, sha) {
+    const fullPath = this.getFullPath(path3);
+    const url = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}/contents/${fullPath}`;
+    const body = {
+      message,
+      content: content.toString("base64"),
+      branch: this.config.branch
+    };
+    if (sha) {
+      body.sha = sha;
+    }
+    const response = await this.withRetry(
+      () => this.fetch(url, {
+        method: "PUT",
+        body: JSON.stringify(body)
+      }),
+      true
+      // Allow conflict retry
+    );
+    if (response.status === 409) {
+      throw new ConflictError(
+        `Conflict updating ${path3}: file was modified concurrently`
+      );
+    }
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to put file ${path3}: ${response.status} ${response.statusText} - ${errorText}`
+      );
+    }
+    const data = await response.json();
+    this.emitEvent({
+      type: "commit_created",
+      sha: data.commit.sha,
+      message
+    });
+    return data.content.sha;
+  }
+  /**
+   * Delete a file from the repository
+   */
+  async deleteFile(path3, sha, message) {
+    const fullPath = this.getFullPath(path3);
+    const url = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}/contents/${fullPath}`;
+    const response = await this.withRetry(
+      () => this.fetch(url, {
+        method: "DELETE",
+        body: JSON.stringify({
+          message,
+          sha,
+          branch: this.config.branch
+        })
+      })
+    );
+    if (!response.ok && response.status !== 404) {
+      throw new Error(
+        `Failed to delete file ${path3}: ${response.status} ${response.statusText}`
+      );
+    }
+  }
+  /**
+   * List files in a directory
+   */
+  async listFiles(path3) {
+    const fullPath = this.getFullPath(path3);
+    const url = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}/contents/${fullPath}?ref=${this.config.branch}`;
+    const response = await this.withRetry(() => this.fetch(url));
+    if (response.status === 404) {
+      return [];
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Failed to list files at ${path3}: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    if (!Array.isArray(data)) {
+      return [
+        {
+          name: data.name,
+          path: data.path,
+          sha: data.sha,
+          size: data.size,
+          type: data.type
+        }
+      ];
+    }
+    return data.map(
+      (item) => ({
+        name: item.name,
+        path: item.path,
+        sha: item.sha,
+        size: item.size,
+        type: item.type
+      })
+    );
+  }
+  /**
+   * Check current rate limit status
+   */
+  async checkRateLimit() {
+    const url = `${GITHUB_API_BASE}/rate_limit`;
+    const response = await this.fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to check rate limit: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      remaining: data.resources.core.remaining,
+      resetAt: new Date(data.resources.core.reset * 1e3),
+      limit: data.resources.core.limit
+    };
+  }
+  /**
+   * Ensure the branch exists, create if it doesn't
+   * For empty repos, we skip branch creation since files can be pushed directly
+   */
+  async ensureBranch() {
+    const url = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}/branches/${this.config.branch}`;
+    const response = await this.fetch(url);
+    if (response.ok) {
+      return;
+    }
+    if (response.status !== 404) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to check branch '${this.config.branch}': ${response.status} ${response.statusText}. ${errorText}`
+      );
+    }
+    const repoUrl = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}`;
+    const repoResponse = await this.fetch(repoUrl);
+    if (!repoResponse.ok) {
+      const errorText = await repoResponse.text();
+      throw new Error(
+        `Failed to get repository info for '${this.config.owner}/${this.config.repo}': ${repoResponse.status} ${repoResponse.statusText}. ${errorText}`
+      );
+    }
+    const repoData = await repoResponse.json();
+    const defaultBranch = repoData.default_branch;
+    const refUrl = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}/git/refs/heads/${defaultBranch}`;
+    const refResponse = await this.fetch(refUrl);
+    if (!refResponse.ok) {
+      if (refResponse.status === 409 || refResponse.status === 404) {
+        this.log(
+          `Repository appears to be empty. Branch '${this.config.branch}' will be created on first snapshot.`
+        );
+        return;
+      }
+      const errorText = await refResponse.text();
+      throw new Error(
+        `Failed to get default branch ref: ${refResponse.status} ${refResponse.statusText}. ${errorText}`
+      );
+    }
+    if (this.config.branch === defaultBranch) {
+      return;
+    }
+    const refData = await refResponse.json();
+    const sha = refData.object.sha;
+    const createUrl = `${GITHUB_API_BASE}/repos/${this.config.owner}/${this.config.repo}/git/refs`;
+    const createResponse = await this.fetch(createUrl, {
+      method: "POST",
+      body: JSON.stringify({
+        ref: `refs/heads/${this.config.branch}`,
+        sha
+      })
+    });
+    if (!createResponse.ok && createResponse.status !== 422) {
+      const errorText = await createResponse.text();
+      throw new Error(
+        `Failed to create branch '${this.config.branch}': ${createResponse.status} ${createResponse.statusText}. ${errorText}`
+      );
+    }
+    this.log(`Created branch: ${this.config.branch}`);
+  }
+  /**
+   * Get the full path including configured prefix
+   */
+  getFullPath(path3) {
+    if (!this.config.path) {
+      return path3;
+    }
+    return `${this.config.path}/${path3}`.replace(/\/+/g, "/");
+  }
+  /**
+   * Make an authenticated fetch request
+   */
+  async fetch(url, options = {}) {
+    const token = await this.getAuthToken();
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      ...options.headers
+    };
+    if (options.body) {
+      headers["Content-Type"] = "application/json";
+    }
+    return fetch(url, {
+      ...options,
+      headers
+    });
+  }
+  /**
+   * Get authentication token (PAT or GitHub App installation token)
+   */
+  async getAuthToken() {
+    if (this.config.token) {
+      return this.config.token;
+    }
+    if (this.cachedToken && Date.now() < this.tokenExpiry) {
+      return this.cachedToken;
+    }
+    if (!this.config.appId || !this.config.privateKey || !this.config.installationId) {
+      throw new Error(
+        "Either token or GitHub App credentials (appId, privateKey, installationId) must be provided"
+      );
+    }
+    const jwt = this.generateJWT(this.config.appId, this.config.privateKey);
+    const response = await fetch(
+      `${GITHUB_API_BASE}/app/installations/${this.config.installationId}/access_tokens`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+          Accept: "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28"
+        }
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to get installation token: ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    this.cachedToken = data.token;
+    this.tokenExpiry = Date.now() + 55 * 60 * 1e3;
+    return this.cachedToken;
+  }
+  /**
+   * Generate a JWT for GitHub App authentication
+   */
+  generateJWT(appId, privateKey) {
+    const now = Math.floor(Date.now() / 1e3);
+    const payload = {
+      iat: now - 60,
+      // Issued 60 seconds ago to account for clock drift
+      exp: now + 10 * 60,
+      // Expires in 10 minutes
+      iss: appId.toString()
+    };
+    const header = { alg: "RS256", typ: "JWT" };
+    const encodedHeader = this.base64UrlEncode(JSON.stringify(header));
+    const encodedPayload = this.base64UrlEncode(JSON.stringify(payload));
+    const signatureInput = `${encodedHeader}.${encodedPayload}`;
+    const signature = crypto.createSign("RSA-SHA256").update(signatureInput).sign(privateKey, "base64url");
+    return `${signatureInput}.${signature}`;
+  }
+  /**
+   * Base64 URL encode a string
+   */
+  base64UrlEncode(str) {
+    return Buffer.from(str).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  /**
+   * Execute a function with retry logic and exponential backoff
+   */
+  async withRetry(fn, allowConflict = false) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const result = await fn();
+        if (result instanceof Response) {
+          await this.handleRateLimitHeaders(result);
+        }
+        return result;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof ConflictError && !allowConflict) {
+          throw error;
+        }
+        if (error instanceof Error && error.message.includes("rate limit")) {
+          const rateLimit = await this.checkRateLimit();
+          const waitTime = Math.max(
+            0,
+            rateLimit.resetAt.getTime() - Date.now()
+          );
+          this.emitEvent({
+            type: "rate_limit_hit",
+            resetAt: rateLimit.resetAt,
+            remaining: rateLimit.remaining
+          });
+          if (waitTime > 0 && waitTime < 6e4) {
+            this.log(`Rate limited, waiting ${waitTime}ms`);
+            await this.sleep(waitTime);
+            continue;
+          }
+        }
+        this.emitEvent({
+          type: "sync_error",
+          error: lastError,
+          context: "github_operation",
+          willRetry: attempt < this.maxRetries
+        });
+        if (attempt < this.maxRetries) {
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          this.log(`Retry attempt ${attempt + 1} after ${delay}ms`);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError || new Error("Unknown error");
+  }
+  /**
+   * Handle rate limit headers from response
+   */
+  async handleRateLimitHeaders(response) {
+    const remaining = parseInt(
+      response.headers.get("x-ratelimit-remaining") || "1000",
+      10
+    );
+    const resetTimestamp = parseInt(
+      response.headers.get("x-ratelimit-reset") || "0",
+      10
+    );
+    if (remaining === 0 && resetTimestamp > 0) {
+      const resetAt = new Date(resetTimestamp * 1e3);
+      const waitTime = Math.max(0, resetAt.getTime() - Date.now());
+      this.emitEvent({
+        type: "rate_limit_hit",
+        resetAt,
+        remaining: 0
+      });
+      if (waitTime > 0 && waitTime < 6e4) {
+        this.log(`Rate limit exhausted, waiting ${waitTime}ms`);
+        await this.sleep(waitTime);
+      }
+    }
+  }
+  /**
+   * Sleep for the specified duration
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Emit an event if handler is registered
+   */
+  emitEvent(event) {
+    if (this.onEvent) {
+      this.onEvent(event);
+    }
+  }
+  /**
+   * Log a message if verbose mode is enabled
+   */
+  log(message) {
+    if (this.verbose) {
+      console.log(`[github-operations] ${message}`);
+    }
+  }
+};
+var ConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConflictError";
+  }
+};
+var gunzip2 = promisify(zlib.gunzip);
+var SNAPSHOT_DB_NAME = "snapshot.db";
+var SNAPSHOT_DB_GZ_NAME = "snapshot.db.gz";
+var SNAPSHOT_META_NAME = "snapshot.meta.json";
+var RecoveryManager = class {
+  github;
+  dbPath;
+  onEvent;
+  verbose;
+  constructor(github, dbPath, onEvent, verbose = false) {
+    this.github = github;
+    this.dbPath = dbPath;
+    this.onEvent = onEvent;
+    this.verbose = verbose;
+  }
+  /**
+   * Check if local database exists
+   */
+  localDatabaseExists() {
+    return fs.existsSync(this.dbPath);
+  }
+  /**
+   * Find the latest snapshot in the repository
+   */
+  async findLatestSnapshot() {
+    try {
+      const compressedFile = await this.github.getFile(SNAPSHOT_DB_GZ_NAME);
+      if (compressedFile) {
+        return {
+          path: SNAPSHOT_DB_GZ_NAME,
+          sha: compressedFile.sha,
+          compressed: true
+        };
+      }
+      const uncompressedFile = await this.github.getFile(SNAPSHOT_DB_NAME);
+      if (uncompressedFile) {
+        return {
+          path: SNAPSHOT_DB_NAME,
+          sha: uncompressedFile.sha,
+          compressed: false
+        };
+      }
+      return null;
+    } catch (error) {
+      this.log(`Error finding snapshot: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Recover database from GitHub snapshot
+   */
+  async recover() {
+    this.emitEvent({
+      type: "recovery_started",
+      branch: ""
+      // Branch is handled by GitHubOperations
+    });
+    try {
+      const snapshot = await this.findLatestSnapshot();
+      if (!snapshot) {
+        this.log("No snapshot found in repository");
+        return { recovered: false };
+      }
+      this.log(`Found snapshot: ${snapshot.path}`);
+      const file = await this.github.getFile(snapshot.path);
+      if (!file) {
+        this.log("Failed to download snapshot");
+        return { recovered: false };
+      }
+      let dbContent;
+      if (snapshot.compressed) {
+        this.log("Decompressing snapshot...");
+        dbContent = await gunzip2(file.content);
+      } else {
+        dbContent = file.content;
+      }
+      const dir = path.dirname(this.dbPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.dbPath, dbContent);
+      this.log(`Database recovered to ${this.dbPath}`);
+      await this.getSnapshotMetadata();
+      this.emitEvent({
+        type: "recovery_completed",
+        sha: file.sha
+      });
+      return {
+        recovered: true,
+        sha: file.sha,
+        size: dbContent.length,
+        compressed: snapshot.compressed
+      };
+    } catch (error) {
+      this.log(`Recovery error: ${error}`);
+      this.emitEvent({
+        type: "sync_error",
+        error: error instanceof Error ? error : new Error(String(error)),
+        context: "recovery",
+        willRetry: false
+      });
+      return { recovered: false };
+    }
+  }
+  /**
+   * Get snapshot metadata from repository
+   */
+  async getSnapshotMetadata() {
+    try {
+      const file = await this.github.getFile(SNAPSHOT_META_NAME);
+      if (!file) {
+        return null;
+      }
+      return JSON.parse(file.content.toString("utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get the current snapshot SHA from the repository
+   */
+  async getCurrentSnapshotSha() {
+    const snapshot = await this.findLatestSnapshot();
+    return snapshot?.sha || null;
+  }
+  /**
+   * Emit an event if handler is registered
+   */
+  emitEvent(event) {
+    if (this.onEvent) {
+      this.onEvent(event);
+    }
+  }
+  /**
+   * Log a message if verbose mode is enabled
+   */
+  log(message) {
+    if (this.verbose) {
+      console.log(`[recovery] ${message}`);
+    }
+  }
+};
+
+// src/sync/sync-manager.ts
+var gzip2 = promisify(zlib.gzip);
+var SNAPSHOT_DB_NAME2 = "snapshot.db";
+var SNAPSHOT_DB_GZ_NAME2 = "snapshot.db.gz";
+var SNAPSHOT_META_NAME2 = "snapshot.meta.json";
+var GitHubSyncManager = class {
+  options;
+  github;
+  recovery;
+  db = null;
+  hasChanges = false;
+  currentSha = null;
+  snapshotTimer = null;
+  isInitialized = false;
+  isClosed = false;
+  constructor(options) {
+    this.options = options;
+    this.github = new GitHubOperations(
+      options.github,
+      options.sync.maxRetries,
+      options.onEvent,
+      options.verbose
+    );
+    this.recovery = new RecoveryManager(
+      this.github,
+      options.dbPath,
+      options.onEvent,
+      options.verbose
+    );
+  }
+  /**
+   * Initialize the sync manager: recover from GitHub if needed, open database
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      return this.db;
+    }
+    this.log("Initializing sync manager...");
+    await this.github.ensureBranch();
+    let recovered = false;
+    if (!this.recovery.localDatabaseExists()) {
+      this.log("Local database not found, attempting recovery from GitHub...");
+      const result = await this.recovery.recover();
+      recovered = result.recovered;
+      if (recovered) {
+        this.currentSha = await this.recovery.getCurrentSnapshotSha();
+      }
+    } else {
+      this.log("Local database exists, fetching current SHA...");
+      this.currentSha = await this.recovery.getCurrentSnapshotSha();
+    }
+    this.db = this.openDatabase();
+    if (this.options.sync.snapshotInterval > 0) {
+      this.startSnapshotTimer();
+    }
+    this.isInitialized = true;
+    this.emitEvent({
+      type: "initialized",
+      recovered
+    });
+    return this.db;
+  }
+  /**
+   * Open the SQLite database with configured options
+   */
+  openDatabase() {
+    const dir = path.dirname(this.options.dbPath);
+    if (dir && !fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+      this.log(`Created directory: ${dir}`);
+    }
+    const sqliteOptions = this.options.sqliteOptions || {};
+    const db = new Database(this.options.dbPath);
+    if (this.options.sync.enableWal) {
+      db.pragma("journal_mode = WAL");
+    }
+    if (sqliteOptions.foreignKeys !== false) {
+      db.pragma("foreign_keys = ON");
+    }
+    if (sqliteOptions.busyTimeout) {
+      db.pragma(`busy_timeout = ${sqliteOptions.busyTimeout}`);
+    }
+    if (sqliteOptions.pragmas) {
+      for (const [key, value] of Object.entries(sqliteOptions.pragmas)) {
+        db.pragma(`${key} = ${value}`);
+      }
+    }
+    this.log("Database opened successfully");
+    return db;
+  }
+  /**
+   * Called after database writes to track changes
+   */
+  async onWrite() {
+    this.hasChanges = true;
+  }
+  /**
+   * Create a snapshot and upload to GitHub
+   */
+  async snapshot() {
+    if (this.isClosed) {
+      return;
+    }
+    if (this.options.sync.snapshotOnChange && !this.hasChanges) {
+      this.log("No changes detected, skipping snapshot");
+      return;
+    }
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    this.log("Creating snapshot...");
+    try {
+      if (this.options.sync.enableWal) {
+        this.db.pragma("wal_checkpoint(TRUNCATE)");
+      }
+      const dbContent = fs.readFileSync(this.options.dbPath);
+      const checksum = crypto.createHash("sha256").update(dbContent).digest("hex");
+      let uploadContent;
+      let filename;
+      const compressed = this.options.sync.compression;
+      if (compressed) {
+        uploadContent = await gzip2(dbContent);
+        filename = SNAPSHOT_DB_GZ_NAME2;
+        this.log(`Compressed ${dbContent.length} -> ${uploadContent.length} bytes`);
+      } else {
+        uploadContent = dbContent;
+        filename = SNAPSHOT_DB_NAME2;
+      }
+      await this.uploadWithConflictRetry(filename, uploadContent, checksum, compressed);
+      this.hasChanges = false;
+      this.emitEvent({
+        type: "snapshot_uploaded",
+        sha: this.currentSha,
+        size: uploadContent.length,
+        compressed
+      });
+      this.log(`Snapshot uploaded successfully (${uploadContent.length} bytes)`);
+    } catch (error) {
+      this.emitEvent({
+        type: "sync_error",
+        error: error instanceof Error ? error : new Error(String(error)),
+        context: "snapshot",
+        willRetry: false
+      });
+      throw error;
+    }
+  }
+  /**
+   * Upload file with automatic conflict resolution
+   */
+  async uploadWithConflictRetry(filename, content, checksum, compressed, retries = 3) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const newSha = await this.github.putFile(
+          filename,
+          content,
+          `Update database snapshot`,
+          this.currentSha || void 0
+        );
+        this.currentSha = newSha;
+        const metadata = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          size: content.length,
+          checksum,
+          compressed
+        };
+        const existingMeta = await this.github.getFile(SNAPSHOT_META_NAME2);
+        await this.github.putFile(
+          SNAPSHOT_META_NAME2,
+          Buffer.from(JSON.stringify(metadata, null, 2)),
+          `Update snapshot metadata`,
+          existingMeta?.sha
+        );
+        const oldFilename = compressed ? SNAPSHOT_DB_NAME2 : SNAPSHOT_DB_GZ_NAME2;
+        try {
+          const oldFile = await this.github.getFile(oldFilename);
+          if (oldFile) {
+            await this.github.deleteFile(
+              oldFilename,
+              oldFile.sha,
+              `Remove old snapshot format`
+            );
+          }
+        } catch {
+        }
+        return;
+      } catch (error) {
+        if (error instanceof ConflictError && attempt < retries - 1) {
+          this.log(`Conflict detected, refetching SHA and retrying (attempt ${attempt + 1})`);
+          this.currentSha = await this.recovery.getCurrentSnapshotSha();
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  /**
+   * Force an immediate sync (alias for snapshot)
+   */
+  async forceSync() {
+    const originalOnChange = this.options.sync.snapshotOnChange;
+    this.options.sync.snapshotOnChange = false;
+    try {
+      await this.snapshot();
+    } finally {
+      this.options.sync.snapshotOnChange = originalOnChange;
+    }
+  }
+  /**
+   * Close the sync manager and perform final sync
+   */
+  async close() {
+    if (this.isClosed) {
+      return;
+    }
+    this.log("Closing sync manager...");
+    this.isClosed = true;
+    if (this.snapshotTimer) {
+      clearInterval(this.snapshotTimer);
+      this.snapshotTimer = null;
+    }
+    if (this.hasChanges && this.db) {
+      try {
+        await this.snapshot();
+      } catch (error) {
+        this.log(`Error during final snapshot: ${error}`);
+      }
+    }
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.log("Sync manager closed");
+  }
+  /**
+   * Start the automatic snapshot timer
+   */
+  startSnapshotTimer() {
+    this.snapshotTimer = setInterval(() => {
+      this.snapshot().catch((error) => {
+        this.log(`Snapshot error: ${error}`);
+      });
+    }, this.options.sync.snapshotInterval);
+    if (this.snapshotTimer.unref) {
+      this.snapshotTimer.unref();
+    }
+  }
+  /**
+   * Get the raw database instance
+   */
+  get database() {
+    return this.db;
+  }
+  /**
+   * Check if there are pending changes
+   */
+  get hasPendingChanges() {
+    return this.hasChanges;
+  }
+  /**
+   * Check if the manager is initialized
+   */
+  get initialized() {
+    return this.isInitialized;
+  }
+  /**
+   * Emit an event if handler is registered
+   */
+  emitEvent(event) {
+    if (this.options.onEvent) {
+      this.options.onEvent(event);
+    }
+  }
+  /**
+   * Log a message if verbose mode is enabled
+   */
+  log(message) {
+    if (this.options.verbose) {
+      console.log(`[sync-manager] ${message}`);
+    }
+  }
+};
+
+// src/provider.ts
+var DEFAULT_SYNC_CONFIG = {
+  snapshotInterval: 30 * 1e3,
+  // 30 seconds
+  snapshotOnChange: true,
+  enableWal: false,
+  walThreshold: 1024 * 1024,
+  // 1MB
+  maxRetries: 3,
+  compression: false
+};
+var BetterSqlite3GitHubDataProvider = class {
+  syncManager;
+  _isInitialized = false;
+  initPromise = null;
+  innerProvider = null;
+  constructor(options) {
+    const githubConfig = {
+      owner: options.github.owner,
+      repo: options.github.repo,
+      branch: options.github.branch || "main",
+      path: options.github.path || "",
+      token: options.github.token,
+      appId: options.github.appId,
+      privateKey: options.github.privateKey,
+      installationId: options.github.installationId
+    };
+    const syncConfig = {
+      ...DEFAULT_SYNC_CONFIG,
+      ...options.sync
+    };
+    const managerOptions = {
+      dbPath: options.file,
+      github: githubConfig,
+      sqliteOptions: options.sqliteOptions,
+      sync: syncConfig,
+      onEvent: options.onEvent,
+      verbose: options.verbose || false
+    };
+    this.syncManager = new GitHubSyncManager(managerOptions);
+  }
+  /**
+   * Initialize the data provider
+   * This must be called before using the provider
+   */
+  async init() {
+    if (this._isInitialized) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.doInit();
+    await this.initPromise;
+  }
+  async doInit() {
+    const db = await this.syncManager.initialize();
+    this.innerProvider = new BetterSqlite3DataProvider(db);
+    this._isInitialized = true;
+  }
+  /**
+   * Ensure the provider is initialized
+   */
+  async ensureInitialized() {
+    if (!this._isInitialized) {
+      await this.init();
+    }
+  }
+  getProvider() {
+    if (!this.innerProvider) {
+      throw new Error(
+        "Provider not initialized. Call init() before using the provider."
+      );
+    }
+    return this.innerProvider;
+  }
+  // SqlImplementation interface methods
+  getLimitSqlSyntax(limit, offset) {
+    return this.getProvider().getLimitSqlSyntax(limit, offset);
+  }
+  createCommand() {
+    const command = this.getProvider().createCommand();
+    const originalExecute = command.execute.bind(command);
+    const syncManager = this.syncManager;
+    const isWriteOp = this.isWriteOperation.bind(this);
+    command.execute = async (sql) => {
+      const result = await originalExecute(sql);
+      if (isWriteOp(sql)) {
+        await syncManager.onWrite();
+      }
+      return result;
+    };
+    return command;
+  }
+  async transaction(action) {
+    await this.ensureInitialized();
+    return this.getProvider().transaction(action);
+  }
+  async entityIsUsedForTheFirstTime(entity) {
+    await this.ensureInitialized();
+    return this.getProvider().entityIsUsedForTheFirstTime(entity);
+  }
+  async end() {
+    await this.close();
+  }
+  // Passthrough properties from inner provider
+  get orderByNullsFirst() {
+    return this.innerProvider?.orderByNullsFirst;
+  }
+  get afterMutation() {
+    return this.innerProvider?.afterMutation;
+  }
+  get supportsJsonColumnType() {
+    return this.innerProvider?.supportsJsonColumnType;
+  }
+  get doesNotSupportReturningSyntax() {
+    return this.innerProvider?.doesNotSupportReturningSyntax ?? true;
+  }
+  // Additional methods from SqliteCoreDataProvider that may be called
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async ensureSchema(entities) {
+    await this.ensureInitialized();
+    return this.getProvider().ensureSchema(entities);
+  }
+  wrapIdentifier(name) {
+    return this.getProvider().wrapIdentifier(name);
+  }
+  addColumnSqlSyntax(x, dbName, isAlterTable) {
+    return this.getProvider().addColumnSqlSyntax(x, dbName, isAlterTable);
+  }
+  /**
+   * Check if a SQL statement is a write operation
+   */
+  isWriteOperation(sql) {
+    const upperSql = sql.trim().toUpperCase();
+    return upperSql.startsWith("INSERT") || upperSql.startsWith("UPDATE") || upperSql.startsWith("DELETE") || upperSql.startsWith("CREATE") || upperSql.startsWith("DROP") || upperSql.startsWith("ALTER");
+  }
+  /**
+   * Force an immediate sync to GitHub
+   */
+  async forceSync() {
+    await this.ensureInitialized();
+    await this.syncManager.forceSync();
+  }
+  /**
+   * Create a snapshot and upload to GitHub
+   */
+  async snapshot() {
+    await this.ensureInitialized();
+    await this.syncManager.snapshot();
+  }
+  /**
+   * Close the provider and perform final sync
+   */
+  async close() {
+    await this.syncManager.close();
+    this._isInitialized = false;
+    this.initPromise = null;
+    this.innerProvider = null;
+  }
+  /**
+   * Get the raw better-sqlite3 database instance
+   */
+  get rawDatabase() {
+    return this.syncManager.database;
+  }
+  /**
+   * Get the sync manager instance
+   */
+  get sync() {
+    return this.syncManager;
+  }
+  /**
+   * Check if the provider is initialized
+   */
+  get isInitialized() {
+    return this._isInitialized;
+  }
+};
+
+// src/index.ts
+function createGitHubDataProvider(options) {
+  let provider = null;
+  let sqlDatabase = null;
+  return async () => {
+    if (sqlDatabase) {
+      return sqlDatabase;
+    }
+    provider = new BetterSqlite3GitHubDataProvider(options);
+    await provider.init();
+    sqlDatabase = new SqlDatabase(provider);
+    return sqlDatabase;
+  };
+}
+
+export { BetterSqlite3GitHubDataProvider, ConflictError, GitHubOperations, GitHubSyncManager, createGitHubDataProvider };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map