sqlite-cloud-backup 0.1.0

package/dist/index.js

@@ -0,0 +1,795 @@
+// src/core/db-manager.ts
+import Database from "better-sqlite3";
+import fs3 from "fs";
+import path from "path";
+
+// src/utils/checksum.ts
+import crypto from "crypto";
+import fs from "fs";
+var ChecksumUtil = class {
+  /**
+   * Calculate SHA-256 checksum of a file
+   */
+  static async calculateFileChecksum(filePath) {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash("sha256");
+      const stream = fs.createReadStream(filePath);
+      stream.on("data", (data) => hash.update(data));
+      stream.on("end", () => resolve(hash.digest("hex")));
+      stream.on("error", reject);
+    });
+  }
+  /**
+   * Calculate SHA-256 checksum of a buffer
+   */
+  static calculateBufferChecksum(buffer) {
+    return crypto.createHash("sha256").update(buffer).digest("hex");
+  }
+  /**
+   * Verify file integrity
+   */
+  static async verifyChecksum(filePath, expectedChecksum) {
+    const actualChecksum = await this.calculateFileChecksum(filePath);
+    return actualChecksum === expectedChecksum;
+  }
+};
+
+// src/utils/file-operations.ts
+import fs2 from "fs";
+var FileOperations = class {
+  /**
+   * Ensure directory exists, create if not
+   */
+  static ensureDir(dirPath) {
+    if (!fs2.existsSync(dirPath)) {
+      fs2.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+  /**
+   * Copy file atomically
+   */
+  static async copyFile(source, destination) {
+    const tempDest = `${destination}.tmp`;
+    await fs2.promises.copyFile(source, tempDest);
+    await fs2.promises.rename(tempDest, destination);
+  }
+};
+
+// src/core/db-manager.ts
+var DatabaseManager = class {
+  db = null;
+  dbPath;
+  metadataPath;
+  logger;
+  constructor(dbPath, logger) {
+    this.dbPath = dbPath;
+    this.logger = logger;
+    const dbDir = path.dirname(dbPath);
+    const dbName = path.basename(dbPath, path.extname(dbPath));
+    this.metadataPath = path.join(dbDir, ".sqlite-cloud-backup", dbName, "metadata.json");
+    FileOperations.ensureDir(path.dirname(this.metadataPath));
+  }
+  /**
+   * Open database connection
+   */
+  open() {
+    if (!fs3.existsSync(this.dbPath)) {
+      throw new Error(`Database not found: ${this.dbPath}`);
+    }
+    this.db = new Database(this.dbPath, { readonly: false });
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  /**
+   * Get database file as buffer
+   */
+  async getBuffer() {
+    this.close();
+    return fs3.promises.readFile(this.dbPath);
+  }
+  /**
+   * Calculate current database checksum
+   */
+  async getChecksum() {
+    this.close();
+    return ChecksumUtil.calculateFileChecksum(this.dbPath);
+  }
+  /**
+   * Replace database with buffer
+   */
+  async replaceWithBuffer(buffer) {
+    this.close();
+    const tempPath = `${this.dbPath}.tmp`;
+    await fs3.promises.writeFile(tempPath, buffer);
+    await fs3.promises.rename(tempPath, this.dbPath);
+    this.logger.info("Database replaced from cloud");
+  }
+  /**
+   * Get local metadata
+   */
+  async getLocalMetadata() {
+    if (!fs3.existsSync(this.metadataPath)) {
+      return {
+        lastSyncTimestamp: 0,
+        lastSyncChecksum: ""
+      };
+    }
+    const content = await fs3.promises.readFile(this.metadataPath, "utf-8");
+    return JSON.parse(content);
+  }
+  /**
+   * Update local metadata
+   */
+  async updateLocalMetadata(metadata) {
+    const current = await this.getLocalMetadata();
+    const updated = { ...current, ...metadata };
+    await fs3.promises.writeFile(
+      this.metadataPath,
+      JSON.stringify(updated, null, 2)
+    );
+  }
+  /**
+   * Get modification time of database file
+   */
+  async getModifiedTime() {
+    const stats = await fs3.promises.stat(this.dbPath);
+    return stats.mtimeMs;
+  }
+};
+
+// src/core/sync-engine.ts
+var SyncEngine = class {
+  dbManager;
+  provider;
+  logger;
+  constructor(dbManager, provider, logger) {
+    this.dbManager = dbManager;
+    this.provider = provider;
+    this.logger = logger;
+  }
+  /**
+   * Push local database to cloud
+   */
+  async pushToCloud() {
+    const startTime = Date.now();
+    try {
+      const buffer = await this.dbManager.getBuffer();
+      const originalSize = buffer.length;
+      const checksum = ChecksumUtil.calculateBufferChecksum(buffer);
+      await this.provider.uploadFile("current.db", buffer);
+      const metadata = {
+        dbName: "current",
+        lastSyncTimestamp: Date.now(),
+        lastSyncType: "push",
+        checksum,
+        version: 1
+      };
+      await this.provider.updateMetadata(metadata);
+      await this.dbManager.updateLocalMetadata({
+        lastSyncTimestamp: metadata.lastSyncTimestamp,
+        lastSyncChecksum: checksum
+      });
+      const result = {
+        success: true,
+        type: "push",
+        timestamp: Date.now(),
+        localChecksum: checksum,
+        cloudChecksum: checksum,
+        bytesTransferred: buffer.length,
+        duration: Date.now() - startTime
+      };
+      this.logger.info(`Push successful: ${originalSize} bytes`);
+      return result;
+    } catch (error) {
+      this.logger.error("Push failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Pull database from cloud to local
+   */
+  async pullFromCloud() {
+    const startTime = Date.now();
+    try {
+      const exists = await this.provider.fileExists("current.db");
+      if (!exists) {
+        throw new Error("No cloud version found");
+      }
+      const buffer = await this.provider.downloadFile("current.db");
+      const checksum = ChecksumUtil.calculateBufferChecksum(buffer);
+      const cloudMetadata = await this.provider.getMetadata("current.db");
+      if (cloudMetadata && cloudMetadata.checksum !== checksum) {
+        throw new Error("Checksum mismatch - data corruption detected");
+      }
+      await this.dbManager.replaceWithBuffer(buffer);
+      await this.dbManager.updateLocalMetadata({
+        lastSyncTimestamp: Date.now(),
+        lastSyncChecksum: checksum
+      });
+      const result = {
+        success: true,
+        type: "pull",
+        timestamp: Date.now(),
+        localChecksum: checksum,
+        cloudChecksum: checksum,
+        bytesTransferred: buffer.length,
+        duration: Date.now() - startTime
+      };
+      this.logger.info(`Pull successful: ${buffer.length} bytes`);
+      return result;
+    } catch (error) {
+      this.logger.error("Pull failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Bidirectional sync - simple version for v0.1
+   */
+  async sync() {
+    const startTime = Date.now();
+    try {
+      const cloudExists = await this.provider.fileExists("current.db");
+      if (!cloudExists) {
+        this.logger.info("No cloud version found, pushing local database");
+        return await this.pushToCloud();
+      }
+      const localChecksum = await this.dbManager.getChecksum();
+      const cloudMetadata = await this.provider.getMetadata("current.db");
+      if (!cloudMetadata) {
+        this.logger.info("No cloud metadata, pushing local database");
+        return await this.pushToCloud();
+      }
+      if (localChecksum === cloudMetadata.checksum) {
+        const result = {
+          success: true,
+          type: "bidirectional",
+          timestamp: Date.now(),
+          localChecksum,
+          cloudChecksum: cloudMetadata.checksum,
+          bytesTransferred: 0,
+          duration: Date.now() - startTime
+        };
+        this.logger.info("Already in sync");
+        return result;
+      }
+      const localModified = await this.dbManager.getModifiedTime();
+      if (localModified > cloudMetadata.modifiedAt) {
+        this.logger.info("Local is newer, pushing");
+        return await this.pushToCloud();
+      } else {
+        this.logger.info("Cloud is newer, pulling");
+        return await this.pullFromCloud();
+      }
+    } catch (error) {
+      this.logger.error("Sync failed", error);
+      throw error;
+    }
+  }
+};
+
+// src/providers/google-drive/google-drive-provider.ts
+import { google } from "googleapis";
+
+// src/providers/base-provider.ts
+var BaseProvider = class {
+};
+
+// src/providers/google-drive/google-drive-provider.ts
+import { Readable } from "stream";
+var GoogleDriveProvider = class extends BaseProvider {
+  drive;
+  oauth2Client;
+  rootFolderId = null;
+  logger;
+  dbName;
+  constructor(credentials, dbName, logger) {
+    super();
+    this.logger = logger;
+    this.dbName = dbName;
+    this.oauth2Client = new google.auth.OAuth2(
+      credentials.clientId,
+      credentials.clientSecret,
+      credentials.redirectUri
+    );
+    this.oauth2Client.setCredentials({
+      refresh_token: credentials.refreshToken
+    });
+    this.drive = google.drive({ version: "v3", auth: this.oauth2Client });
+  }
+  /**
+   * Initialize folder structure
+   */
+  async ensureRootFolder() {
+    if (this.rootFolderId) return this.rootFolderId;
+    const response = await this.drive.files.list({
+      q: "name='.sqlite-cloud-backup' and mimeType='application/vnd.google-apps.folder' and trashed=false",
+      fields: "files(id, name)",
+      spaces: "drive"
+    });
+    if (response.data.files && response.data.files.length > 0) {
+      this.rootFolderId = response.data.files[0].id;
+    } else {
+      const folder = await this.drive.files.create({
+        requestBody: {
+          name: ".sqlite-cloud-backup",
+          mimeType: "application/vnd.google-apps.folder"
+        },
+        fields: "id"
+      });
+      this.rootFolderId = folder.data.id;
+    }
+    const dbFolderId = await this.ensureDbFolder();
+    return dbFolderId;
+  }
+  async ensureDbFolder() {
+    const response = await this.drive.files.list({
+      q: `name='${this.dbName}' and mimeType='application/vnd.google-apps.folder' and '${this.rootFolderId}' in parents and trashed=false`,
+      fields: "files(id, name)"
+    });
+    if (response.data.files && response.data.files.length > 0) {
+      return response.data.files[0].id;
+    }
+    const folder = await this.drive.files.create({
+      requestBody: {
+        name: this.dbName,
+        mimeType: "application/vnd.google-apps.folder",
+        parents: [this.rootFolderId]
+      },
+      fields: "id"
+    });
+    return folder.data.id;
+  }
+  async uploadFile(fileName, buffer) {
+    const folderId = await this.ensureRootFolder();
+    const existing = await this.findFile(fileName);
+    const media = {
+      mimeType: "application/x-sqlite3",
+      body: Readable.from(buffer)
+    };
+    if (existing) {
+      await this.drive.files.update({
+        fileId: existing.id,
+        media,
+        fields: "id"
+      });
+      this.logger.info(`Updated file in Google Drive: ${fileName}`);
+    } else {
+      await this.drive.files.create({
+        requestBody: {
+          name: fileName,
+          parents: [folderId]
+        },
+        media,
+        fields: "id"
+      });
+      this.logger.info(`Uploaded file to Google Drive: ${fileName}`);
+    }
+  }
+  async downloadFile(fileName) {
+    const file = await this.findFile(fileName);
+    if (!file) {
+      throw new Error(`File not found: ${fileName}`);
+    }
+    const response = await this.drive.files.get(
+      { fileId: file.id, alt: "media" },
+      { responseType: "arraybuffer" }
+    );
+    this.logger.info(`Downloaded file from Google Drive: ${fileName}`);
+    return Buffer.from(response.data);
+  }
+  async fileExists(fileName) {
+    const file = await this.findFile(fileName);
+    return file !== null;
+  }
+  async getMetadata(_fileName) {
+    const metadataFile = await this.findFile("metadata.json");
+    if (!metadataFile) return null;
+    const buffer = await this.downloadFile("metadata.json");
+    const metadata = JSON.parse(buffer.toString("utf-8"));
+    return {
+      checksum: metadata.checksum,
+      modifiedAt: metadata.lastSyncTimestamp,
+      size: 0
+      // Not tracked in metadata
+    };
+  }
+  async updateMetadata(metadata) {
+    const buffer = Buffer.from(JSON.stringify(metadata, null, 2));
+    await this.uploadFile("metadata.json", buffer);
+  }
+  async deleteFile(fileName) {
+    const file = await this.findFile(fileName);
+    if (file) {
+      await this.drive.files.delete({ fileId: file.id });
+      this.logger.info(`Deleted file from Google Drive: ${fileName}`);
+    }
+  }
+  async findFile(fileName) {
+    const folderId = await this.ensureRootFolder();
+    const response = await this.drive.files.list({
+      q: `name='${fileName}' and '${folderId}' in parents and trashed=false`,
+      fields: "files(id, name, modifiedTime)"
+    });
+    return response.data.files?.[0] || null;
+  }
+};
+
+// src/providers/google-drive/oauth-flow.ts
+import http from "http";
+import { URL } from "url";
+import open from "open";
+var OAuthFlow = class {
+  logger;
+  server = null;
+  redirectUri = "http://localhost:3000/oauth/callback";
+  scopes = ["https://www.googleapis.com/auth/drive.file"];
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Start OAuth flow - opens browser and waits for callback
+   */
+  async authenticate(clientId, clientSecret) {
+    this.logger.info("Starting OAuth flow...");
+    const authCode = await this.startLocalServerAndWaitForCode(clientId);
+    const tokens = await this.exchangeCodeForTokens(authCode, clientId, clientSecret);
+    this.logger.info("OAuth authentication successful");
+    return tokens;
+  }
+  /**
+   * Start local HTTP server and wait for OAuth callback
+   */
+  async startLocalServerAndWaitForCode(clientId) {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => {
+        const url = new URL(req.url || "", `http://localhost:3000`);
+        if (url.pathname === "/oauth/callback") {
+          const code = url.searchParams.get("code");
+          const error = url.searchParams.get("error");
+          if (error) {
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end("<h1>Authentication Failed</h1><p>You can close this window.</p>");
+            this.stopServer();
+            reject(new Error(`OAuth error: ${error}`));
+            return;
+          }
+          if (code) {
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end("<h1>Authentication Successful!</h1><p>You can close this window and return to the app.</p>");
+            this.stopServer();
+            resolve(code);
+            return;
+          }
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end("<h1>Invalid Request</h1><p>No authorization code received.</p>");
+          this.stopServer();
+          reject(new Error("No authorization code received"));
+        } else {
+          res.writeHead(404);
+          res.end();
+        }
+      });
+      this.server.listen(3e3, () => {
+        this.logger.info("Local OAuth server started on http://localhost:3000");
+        const authUrl = this.buildAuthUrl(clientId);
+        this.logger.info("Opening browser for authentication...");
+        open(authUrl).catch((err) => {
+          this.logger.error("Failed to open browser", err);
+          this.logger.info(`Please open this URL manually: ${authUrl}`);
+        });
+      });
+      setTimeout(() => {
+        this.stopServer();
+        reject(new Error("OAuth flow timed out after 5 minutes"));
+      }, 5 * 60 * 1e3);
+    });
+  }
+  /**
+   * Build Google OAuth authorization URL
+   */
+  buildAuthUrl(clientId) {
+    const params = new URLSearchParams({
+      client_id: clientId,
+      redirect_uri: this.redirectUri,
+      response_type: "code",
+      scope: this.scopes.join(" "),
+      access_type: "offline",
+      prompt: "consent"
+      // Force to get refresh token
+    });
+    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+  }
+  /**
+   * Exchange authorization code for tokens
+   */
+  async exchangeCodeForTokens(code, clientId, clientSecret) {
+    this.logger.info("Exchanging authorization code for tokens...");
+    const response = await fetch("https://oauth2.googleapis.com/token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        code,
+        client_id: clientId,
+        client_secret: clientSecret,
+        redirect_uri: this.redirectUri,
+        grant_type: "authorization_code"
+      }).toString()
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to exchange code for tokens: ${error}`);
+    }
+    const data = await response.json();
+    return {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token,
+      expiry_date: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+    };
+  }
+  /**
+   * Stop the local server
+   */
+  stopServer() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+      this.logger.info("Local OAuth server stopped");
+    }
+  }
+};
+
+// src/providers/google-drive/token-storage.ts
+import fs4 from "fs/promises";
+import path2 from "path";
+
+// src/utils/logger.ts
+var Logger = class {
+  level;
+  constructor(level = "info") {
+    this.level = level;
+  }
+  shouldLog(level) {
+    const levels = ["debug", "info", "warn", "error"];
+    return levels.indexOf(level) >= levels.indexOf(this.level);
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      console.debug(`[DEBUG] ${message}`, meta || "");
+    }
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      console.info(`[INFO] ${message}`, meta || "");
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      console.warn(`[WARN] ${message}`, meta || "");
+    }
+  }
+  error(message, error) {
+    if (this.shouldLog("error")) {
+      console.error(`[ERROR] ${message}`, error || "");
+    }
+  }
+};
+
+// src/providers/google-drive/token-storage.ts
+var TokenStorage = class {
+  logger;
+  tokenDir;
+  tokenFile;
+  constructor(dbPath, logLevel = "info") {
+    this.logger = new Logger(logLevel);
+    const dbDir = path2.dirname(dbPath);
+    this.tokenDir = path2.join(dbDir, ".sqlite-cloud-backup");
+    this.tokenFile = path2.join(this.tokenDir, "tokens.json");
+  }
+  async hasTokens() {
+    try {
+      await fs4.access(this.tokenFile);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getTokens() {
+    try {
+      const data = await fs4.readFile(this.tokenFile, "utf-8");
+      const tokens = JSON.parse(data);
+      this.logger.debug("Retrieved stored tokens");
+      return tokens;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        this.logger.warn("Failed to read tokens", error);
+      }
+      return null;
+    }
+  }
+  async saveTokens(tokens) {
+    try {
+      await fs4.mkdir(this.tokenDir, { recursive: true });
+      await fs4.writeFile(
+        this.tokenFile,
+        JSON.stringify(tokens, null, 2),
+        "utf-8"
+      );
+      this.logger.debug("Saved tokens to storage");
+    } catch (error) {
+      this.logger.error("Failed to save tokens", error);
+      throw new Error("Failed to save authentication tokens");
+    }
+  }
+  async clearTokens() {
+    try {
+      await fs4.unlink(this.tokenFile);
+      this.logger.debug("Cleared stored tokens");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        this.logger.warn("Failed to clear tokens", error);
+      }
+    }
+  }
+};
+
+// src/index.ts
+import path3 from "path";
+var SqliteCloudBackup = class {
+  dbManager;
+  provider;
+  syncEngine;
+  logger;
+  oauthFlow;
+  tokenStorage;
+  credentials;
+  dbPath;
+  constructor(config) {
+    this.logger = new Logger(config.options?.logLevel ?? "info");
+    this.dbPath = config.dbPath;
+    this.credentials = config.credentials;
+    this.oauthFlow = new OAuthFlow(this.logger);
+    this.tokenStorage = new TokenStorage(config.dbPath, config.options?.logLevel ?? "info");
+    this.dbManager = new DatabaseManager(config.dbPath, this.logger);
+    this.provider = this.createProvider(config);
+    this.syncEngine = new SyncEngine(
+      this.dbManager,
+      this.provider,
+      this.logger
+    );
+  }
+  createProvider(config) {
+    const dbName = path3.basename(config.dbPath, path3.extname(config.dbPath));
+    switch (config.provider) {
+      case "google-drive":
+        return new GoogleDriveProvider(
+          config.credentials,
+          dbName,
+          this.logger
+        );
+      default:
+        throw new Error(`Unsupported provider: ${config.provider}`);
+    }
+  }
+  /**
+   * Check if user needs authentication
+   */
+  async needsAuthentication() {
+    if (this.credentials.refreshToken) {
+      return false;
+    }
+    return !await this.tokenStorage.hasTokens();
+  }
+  /**
+   * Ensure user is authenticated, trigger OAuth flow if needed
+   */
+  async ensureAuthenticated() {
+    if (this.credentials.refreshToken) {
+      this.logger.debug("Using provided refresh token");
+      return;
+    }
+    const storedTokens = await this.tokenStorage.getTokens();
+    if (storedTokens) {
+      this.logger.debug("Using stored refresh token");
+      this.credentials.refreshToken = storedTokens.refreshToken;
+      const dbName = path3.basename(this.dbPath, path3.extname(this.dbPath));
+      this.provider = new GoogleDriveProvider(
+        this.credentials,
+        dbName,
+        this.logger
+      );
+      this.syncEngine = new SyncEngine(
+        this.dbManager,
+        this.provider,
+        this.logger
+      );
+      return;
+    }
+    this.logger.info("No authentication found, starting OAuth flow...");
+    await this.authenticate();
+  }
+  /**
+   * Trigger OAuth authentication flow
+   */
+  async authenticate() {
+    this.logger.info("Starting OAuth authentication flow...");
+    const tokens = await this.oauthFlow.authenticate(
+      this.credentials.clientId,
+      this.credentials.clientSecret
+    );
+    await this.tokenStorage.saveTokens({
+      refreshToken: tokens.refresh_token,
+      accessToken: tokens.access_token,
+      expiryDate: tokens.expiry_date
+    });
+    this.credentials.refreshToken = tokens.refresh_token;
+    const dbName = path3.basename(this.dbPath, path3.extname(this.dbPath));
+    this.provider = new GoogleDriveProvider(
+      this.credentials,
+      dbName,
+      this.logger
+    );
+    this.syncEngine = new SyncEngine(
+      this.dbManager,
+      this.provider,
+      this.logger
+    );
+    this.logger.info("Authentication successful");
+  }
+  /**
+   * Check if user is authenticated
+   */
+  async isAuthenticated() {
+    return !await this.needsAuthentication();
+  }
+  /**
+   * Logout and clear stored tokens
+   */
+  async logout() {
+    await this.tokenStorage.clearTokens();
+    this.credentials.refreshToken = void 0;
+    this.logger.info("Logged out successfully");
+  }
+  /**
+   * Push local database to cloud
+   */
+  async pushToCloud() {
+    await this.ensureAuthenticated();
+    return this.syncEngine.pushToCloud();
+  }
+  /**
+   * Pull database from cloud to local
+   */
+  async pullFromCloud() {
+    await this.ensureAuthenticated();
+    return this.syncEngine.pullFromCloud();
+  }
+  /**
+   * Bidirectional sync
+   */
+  async sync() {
+    await this.ensureAuthenticated();
+    return this.syncEngine.sync();
+  }
+  /**
+   * Cleanup and shutdown
+   */
+  async shutdown() {
+    this.dbManager.close();
+    this.logger.info("SqliteCloudBackup shutdown complete");
+  }
+};
+var index_default = SqliteCloudBackup;
+export {
+  SqliteCloudBackup,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map