@framers/sql-storage-adapter 0.7.2 → 0.7.4

package/dist/cjs/features/auth/authJsAdapter.js

@@ -0,0 +1,251 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var authJsAdapter_exports = {};
+__export(authJsAdapter_exports, {
+  authJsTablesSql: () => authJsTablesSql,
+  createAuthJsAdapter: () => createAuthJsAdapter,
+  ensureAuthJsTables: () => ensureAuthJsTables
+});
+module.exports = __toCommonJS(authJsAdapter_exports);
+var import_features = require("../../core/contracts/features.js");
+const PREFIX = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const tablesFor = (options) => {
+  const prefix = options.tablePrefix ?? "auth_";
+  if (!PREFIX.test(prefix)) {
+    throw new Error(`tablePrefix must be letters, digits and underscores, starting with a letter or an underscore; got ${JSON.stringify(prefix)}.`);
+  }
+  return {
+    users: `${prefix}users`,
+    accounts: `${prefix}accounts`,
+    sessions: `${prefix}sessions`,
+    verificationTokens: `${prefix}verification_tokens`
+  };
+};
+function authJsTablesSql(db, options = {}) {
+  const t = tablesFor(options);
+  const d = (0, import_features.createStorageFeatures)(db).dialect;
+  const timestamp = d.columnType("timestamp");
+  return [
+    `CREATE TABLE IF NOT EXISTS ${t.users} (id TEXT PRIMARY KEY, name TEXT, email TEXT UNIQUE, email_verified ${timestamp}, image TEXT)`,
+    `CREATE TABLE IF NOT EXISTS ${t.accounts} (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL REFERENCES ${t.users} (id) ON DELETE CASCADE,
+      type TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      provider_account_id TEXT NOT NULL,
+      refresh_token TEXT,
+      access_token TEXT,
+      expires_at ${d.columnType("bigint")},
+      token_type TEXT,
+      scope TEXT,
+      id_token TEXT,
+      session_state TEXT,
+      UNIQUE (provider, provider_account_id)
+    )`,
+    `CREATE TABLE IF NOT EXISTS ${t.sessions} (session_token TEXT PRIMARY KEY, user_id TEXT NOT NULL REFERENCES ${t.users} (id) ON DELETE CASCADE, expires ${timestamp} NOT NULL)`,
+    `CREATE TABLE IF NOT EXISTS ${t.verificationTokens} (identifier TEXT NOT NULL, token TEXT NOT NULL, expires ${timestamp} NOT NULL, PRIMARY KEY (identifier, token))`,
+    `CREATE INDEX IF NOT EXISTS ${t.accounts}_user_id ON ${t.accounts} (user_id)`,
+    `CREATE INDEX IF NOT EXISTS ${t.sessions}_user_id ON ${t.sessions} (user_id)`
+  ];
+}
+async function ensureAuthJsTables(db, options = {}) {
+  for (const statement of authJsTablesSql(db, options)) {
+    await db.exec(statement);
+  }
+}
+const toDate = (value) => value == null ? null : value instanceof Date ? value : new Date(String(value));
+const toUser = (row) => ({
+  id: String(row.id),
+  name: row.name ?? null,
+  email: row.email,
+  emailVerified: toDate(row.email_verified),
+  image: row.image ?? null
+});
+const toAccount = (row) => {
+  const account = {
+    userId: String(row.user_id),
+    type: row.type,
+    provider: row.provider,
+    providerAccountId: row.provider_account_id
+  };
+  for (const field of ["refresh_token", "access_token", "token_type", "scope", "id_token", "session_state"]) {
+    if (row[field] != null)
+      account[field] = String(row[field]);
+  }
+  if (row.expires_at != null)
+    account.expires_at = Number(row.expires_at);
+  return account;
+};
+const toSession = (row) => ({
+  sessionToken: row.session_token,
+  userId: String(row.user_id),
+  expires: toDate(row.expires)
+});
+const toVerificationToken = (row) => ({
+  identifier: row.identifier,
+  token: row.token,
+  expires: toDate(row.expires)
+});
+const defaultId = () => {
+  const random = globalThis.crypto?.randomUUID;
+  if (!random)
+    throw new Error("crypto.randomUUID() is not available; pass generateId.");
+  return random.call(globalThis.crypto);
+};
+function createAuthJsAdapter(db, options = {}) {
+  const t = tablesFor(options);
+  const generateId = options.generateId ?? defaultId;
+  const getUser = async (id) => {
+    const row = await db.get(`SELECT * FROM ${t.users} WHERE id = ?`, [id]);
+    return row ? toUser(row) : null;
+  };
+  const getSession = async (sessionToken) => {
+    const row = await db.get(`SELECT * FROM ${t.sessions} WHERE session_token = ?`, [sessionToken]);
+    return row ? toSession(row) : null;
+  };
+  return {
+    async createUser(user) {
+      const id = user.id ?? generateId();
+      await db.run(`INSERT INTO ${t.users} (id, name, email, email_verified, image) VALUES (?, ?, ?, ?, ?)`, [
+        id,
+        user.name ?? null,
+        user.email,
+        user.emailVerified ?? null,
+        user.image ?? null
+      ]);
+      return await getUser(id);
+    },
+    getUser,
+    async getUserByEmail(email) {
+      const row = await db.get(`SELECT * FROM ${t.users} WHERE email = ?`, [email]);
+      return row ? toUser(row) : null;
+    },
+    async getUserByAccount({ provider, providerAccountId }) {
+      const row = await db.get(`SELECT u.* FROM ${t.users} u JOIN ${t.accounts} a ON a.user_id = u.id WHERE a.provider = ? AND a.provider_account_id = ?`, [provider, providerAccountId]);
+      return row ? toUser(row) : null;
+    },
+    async updateUser(user) {
+      const fields = [];
+      if ("name" in user)
+        fields.push(["name", user.name ?? null]);
+      if ("email" in user)
+        fields.push(["email", user.email]);
+      if ("emailVerified" in user)
+        fields.push(["email_verified", user.emailVerified ?? null]);
+      if ("image" in user)
+        fields.push(["image", user.image ?? null]);
+      if (fields.length) {
+        await db.run(`UPDATE ${t.users} SET ${fields.map(([column]) => `${column} = ?`).join(", ")} WHERE id = ?`, [
+          ...fields.map(([, value]) => value),
+          user.id
+        ]);
+      }
+      const updated = await getUser(user.id);
+      if (!updated)
+        throw new Error(`No user with id ${JSON.stringify(user.id)} to update.`);
+      return updated;
+    },
+    async deleteUser(userId) {
+      return db.transaction(async (trx) => {
+        const row = await trx.get(`SELECT * FROM ${t.users} WHERE id = ?`, [userId]);
+        await trx.run(`DELETE FROM ${t.sessions} WHERE user_id = ?`, [userId]);
+        await trx.run(`DELETE FROM ${t.accounts} WHERE user_id = ?`, [userId]);
+        await trx.run(`DELETE FROM ${t.users} WHERE id = ?`, [userId]);
+        return row ? toUser(row) : null;
+      });
+    },
+    async linkAccount(account) {
+      await db.run(`INSERT INTO ${t.accounts} (id, user_id, type, provider, provider_account_id, refresh_token, access_token, expires_at, token_type, scope, id_token, session_state)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        generateId(),
+        account.userId,
+        account.type,
+        account.provider,
+        account.providerAccountId,
+        account.refresh_token ?? null,
+        account.access_token ?? null,
+        account.expires_at ?? null,
+        account.token_type ?? null,
+        account.scope ?? null,
+        account.id_token ?? null,
+        account.session_state ?? null
+      ]);
+      return account;
+    },
+    async unlinkAccount({ provider, providerAccountId }) {
+      await db.run(`DELETE FROM ${t.accounts} WHERE provider = ? AND provider_account_id = ?`, [provider, providerAccountId]);
+    },
+    async getAccount(providerAccountId, provider) {
+      const row = await db.get(`SELECT * FROM ${t.accounts} WHERE provider = ? AND provider_account_id = ?`, [
+        provider,
+        providerAccountId
+      ]);
+      return row ? toAccount(row) : null;
+    },
+    async createSession(session) {
+      await db.run(`INSERT INTO ${t.sessions} (session_token, user_id, expires) VALUES (?, ?, ?)`, [
+        session.sessionToken,
+        session.userId,
+        session.expires
+      ]);
+      return { sessionToken: session.sessionToken, userId: session.userId, expires: session.expires };
+    },
+    async getSessionAndUser(sessionToken) {
+      const session = await getSession(sessionToken);
+      if (!session)
+        return null;
+      const user = await getUser(session.userId);
+      return user ? { session, user } : null;
+    },
+    async updateSession(session) {
+      const fields = [];
+      if (session.expires !== void 0)
+        fields.push(["expires", session.expires]);
+      if (session.userId !== void 0)
+        fields.push(["user_id", session.userId]);
+      if (fields.length) {
+        await db.run(`UPDATE ${t.sessions} SET ${fields.map(([column]) => `${column} = ?`).join(", ")} WHERE session_token = ?`, [
+          ...fields.map(([, value]) => value),
+          session.sessionToken
+        ]);
+      }
+      return getSession(session.sessionToken);
+    },
+    async deleteSession(sessionToken) {
+      await db.run(`DELETE FROM ${t.sessions} WHERE session_token = ?`, [sessionToken]);
+    },
+    async createVerificationToken(token) {
+      await db.run(`INSERT INTO ${t.verificationTokens} (identifier, token, expires) VALUES (?, ?, ?)`, [
+        token.identifier,
+        token.token,
+        token.expires
+      ]);
+      return { identifier: token.identifier, token: token.token, expires: token.expires };
+    },
+    async useVerificationToken({ identifier, token }) {
+      const row = await db.get(`DELETE FROM ${t.verificationTokens} WHERE identifier = ? AND token = ? RETURNING identifier, token, expires`, [identifier, token]);
+      return row ? toVerificationToken(row) : null;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authJsTablesSql,
+  createAuthJsAdapter,
+  ensureAuthJsTables
+});

package/dist/cjs/features/backup/cloudBackup.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Cloud backup utilities for S3, R2, and other object storage providers.
+ *
+ * This module provides automatic scheduled backups and restore functionality
+ * for SQL databases using S3-compatible storage (AWS S3, Cloudflare R2, MinIO, etc.).
+ *
+ * Features:
+ * - Automatic scheduled backups with configurable intervals
+ * - Gzip compression to reduce storage costs
+ * - Retention policies (automatic cleanup of old backups)
+ * - JSON and SQL export formats
+ * - Manual backup/restore on demand
+ *
+ * @example
+ * ```typescript
+ * import { S3Client } from '@aws-sdk/client-s3';
+ * import { createCloudBackupManager } from '@framers/sql-storage-adapter';
+ *
+ * const s3Client = new S3Client({ region: 'us-east-1' });
+ * const manager = createCloudBackupManager(db, s3Client, 'my-backups', {
+ *   interval: 3600000,  // 1 hour
+ *   maxBackups: 24,
+ *   options: { compression: 'gzip', format: 'json' }
+ * });
+ *
+ * manager.start();  // Auto-schedule backups
+ * await manager.backupNow();  // Manual backup
+ * await manager.restore('backups/db-2024-01-15.json.gz');
+ * ```
+ *
+ * @module cloudBackup
+ */
+import type { StorageAdapter } from '../../core/contracts/index.js';
+/** Supported backup export formats */
+export type BackupFormat = 'json' | 'sql';
+/** Supported compression algorithms */
+export type CompressionType = 'gzip' | 'none';
+/**
+ * Generic interface for cloud storage providers.
+ *
+ * Implement this interface to support custom storage backends
+ * beyond S3-compatible services.
+ */
+export interface CloudStorageProvider {
+    /**
+     * Upload data to cloud storage
+     * @param key - The storage key/path for the backup
+     * @param data - The backup data (string or Buffer)
+     */
+    upload(key: string, data: string | Buffer): Promise<void>;
+    /**
+     * Download data from cloud storage
+     * @param key - The storage key/path to download
+     * @returns The backup data
+     */
+    download(key: string): Promise<string | Buffer>;
+    /**
+     * List available backups in cloud storage
+     * @param prefix - Optional prefix to filter backups
+     * @returns Array of backup keys
+     */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Delete a backup from cloud storage
+     * @param key - The storage key/path to delete
+     */
+    delete(key: string): Promise<void>;
+}
+/**
+ * Configuration options for backup creation
+ */
+export interface BackupOptions {
+    /** Backup format (json or sql) - default: 'json' */
+    format?: BackupFormat;
+    /** Compression type - default: 'gzip' */
+    compression?: CompressionType;
+    /** Tables to include (undefined = all tables) */
+    tables?: string[];
+    /** Prefix for backup keys - default: 'backups/' */
+    prefix?: string;
+    /** Include timestamp in backup key - default: true */
+    includeTimestamp?: boolean;
+}
+/**
+ * Configuration for automatic scheduled backups
+ */
+export interface ScheduledBackupConfig {
+    /** Backup interval in milliseconds (e.g., 3600000 = 1 hour) */
+    interval: number;
+    /** Maximum number of backups to keep (older backups auto-deleted) */
+    maxBackups?: number;
+    /** Backup creation options */
+    options?: BackupOptions;
+    /** Callback invoked on successful backup */
+    onSuccess?: (key: string) => void;
+    /** Callback invoked on backup error */
+    onError?: (error: Error) => void;
+}
+/**
+ * S3-compatible cloud storage provider.
+ *
+ * Works with AWS S3, Cloudflare R2, MinIO, and other S3-compatible services.
+ * Uses the AWS SDK v3 for S3 operations.
+ *
+ * @example
+ * ```typescript
+ * import { S3Client } from '@aws-sdk/client-s3';
+ *
+ * const s3Client = new S3Client({ region: 'us-east-1' });
+ * const provider = new S3StorageProvider(s3Client, 'my-bucket');
+ *
+ * await provider.upload('backups/test.json', JSON.stringify(data));
+ * const backups = await provider.list('backups/');
+ * ```
+ */
+export declare class S3StorageProvider implements CloudStorageProvider {
+    private client;
+    private bucket;
+    /**
+     * @param client - AWS SDK S3Client instance
+     * @param bucket - S3 bucket name
+     */
+    constructor(client: {
+        send: (command: unknown) => Promise<unknown>;
+    }, bucket: string);
+    upload(key: string, data: string | Buffer): Promise<void>;
+    download(key: string): Promise<string>;
+    list(prefix?: string): Promise<string[]>;
+    delete(key: string): Promise<void>;
+}
+/**
+ * Cloud backup manager for automatic scheduled backups.
+ */
+export declare class CloudBackupManager {
+    private adapter;
+    private storage;
+    private config;
+    private intervalId?;
+    constructor(adapter: StorageAdapter, storage: CloudStorageProvider, config: ScheduledBackupConfig);
+    /**
+     * Create a backup and upload to cloud storage.
+     */
+    backup(options?: BackupOptions): Promise<string>;
+    /**
+     * Restore from a cloud backup.
+     */
+    restore(key: string): Promise<void>;
+    /**
+     * List all backups in cloud storage.
+     */
+    listBackups(prefix?: string): Promise<string[]>;
+    /**
+     * Delete old backups exceeding maxBackups limit.
+     */
+    private cleanupOldBackups;
+    /**
+     * Start automatic scheduled backups.
+     */
+    start(): void;
+    /**
+     * Stop automatic scheduled backups.
+     */
+    stop(): void;
+    /**
+     * Perform a backup immediately (manual trigger).
+     */
+    backupNow(options?: BackupOptions): Promise<string>;
+}
+/**
+ * Create a cloud backup manager with S3-compatible storage.
+ *
+ * This is the main factory function for setting up cloud backups.
+ * It creates an S3StorageProvider and CloudBackupManager configured
+ * with your database and S3-compatible storage.
+ *
+ * @param adapter - The StorageAdapter instance to backup
+ * @param s3Client - AWS SDK S3Client (works with S3, R2, MinIO, etc.)
+ * @param bucket - The S3 bucket name
+ * @param config - Scheduled backup configuration
+ * @returns CloudBackupManager instance ready to start
+ *
+ * @example AWS S3
+ * ```typescript
+ * import { S3Client } from '@aws-sdk/client-s3';
+ * import { createCloudBackupManager } from '@framers/sql-storage-adapter';
+ *
+ * const s3 = new S3Client({ region: 'us-east-1' });
+ * const manager = createCloudBackupManager(db, s3, 'my-bucket', {
+ *   interval: 60 * 60 * 1000, // 1 hour
+ *   maxBackups: 24,
+ *   options: { compression: 'gzip' }
+ * });
+ *
+ * manager.start();
+ * ```
+ *
+ * @example Cloudflare R2
+ * ```typescript
+ * import { S3Client } from '@aws-sdk/client-s3';
+ *
+ * const r2 = new S3Client({
+ *   region: 'auto',
+ *   endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+ *   credentials: {
+ *     accessKeyId: process.env.R2_ACCESS_KEY_ID,
+ *     secretAccessKey: process.env.R2_SECRET_ACCESS_KEY,
+ *   },
+ * });
+ *
+ * const manager = createCloudBackupManager(db, r2, 'backups', {
+ *   interval: 24 * 60 * 60 * 1000, // Daily
+ *   maxBackups: 7
+ * });
+ * ```
+ */
+export declare function createCloudBackupManager(adapter: StorageAdapter, s3Client: {
+    send: (command: unknown) => Promise<unknown>;
+}, bucket: string, config: ScheduledBackupConfig): CloudBackupManager;
+//# sourceMappingURL=cloudBackup.d.ts.map

package/dist/cjs/features/backup/cloudBackup.js

@@ -0,0 +1,209 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cloudBackup_exports = {};
+__export(cloudBackup_exports, {
+  CloudBackupManager: () => CloudBackupManager,
+  S3StorageProvider: () => S3StorageProvider,
+  createCloudBackupManager: () => createCloudBackupManager
+});
+module.exports = __toCommonJS(cloudBackup_exports);
+var import_dataExport = require("../migrations/dataExport.js");
+var import_dataImport = require("../migrations/dataImport.js");
+class S3StorageProvider {
+  /**
+   * @param client - AWS SDK S3Client instance
+   * @param bucket - S3 bucket name
+   */
+  constructor(client, bucket) {
+    this.client = client;
+    this.bucket = bucket;
+  }
+  async upload(key, data) {
+    const { PutObjectCommand } = await Promise.resolve().then(() => __toESM(require("@aws-sdk/client-s3")));
+    await this.client.send(new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      Body: data
+    }));
+  }
+  async download(key) {
+    const { GetObjectCommand } = await Promise.resolve().then(() => __toESM(require("@aws-sdk/client-s3")));
+    const response = await this.client.send(new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    }));
+    if (response.Body.transformToString) {
+      return await response.Body.transformToString();
+    }
+    return response.Body.toString("utf-8");
+  }
+  async list(prefix) {
+    const { ListObjectsV2Command } = await Promise.resolve().then(() => __toESM(require("@aws-sdk/client-s3")));
+    const response = await this.client.send(new ListObjectsV2Command({
+      Bucket: this.bucket,
+      Prefix: prefix
+    }));
+    return response.Contents?.map((obj) => obj.Key).filter((key) => !!key) ?? [];
+  }
+  async delete(key) {
+    const { DeleteObjectCommand } = await Promise.resolve().then(() => __toESM(require("@aws-sdk/client-s3")));
+    await this.client.send(new DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    }));
+  }
+}
+async function compress(data) {
+  const { gzip } = await Promise.resolve().then(() => __toESM(require("zlib")));
+  const { promisify } = await Promise.resolve().then(() => __toESM(require("util")));
+  const gzipAsync = promisify(gzip);
+  return await gzipAsync(Buffer.from(data));
+}
+async function decompress(data) {
+  const { gunzip } = await Promise.resolve().then(() => __toESM(require("zlib")));
+  const { promisify } = await Promise.resolve().then(() => __toESM(require("util")));
+  const gunzipAsync = promisify(gunzip);
+  const decompressed = await gunzipAsync(data);
+  return decompressed.toString("utf-8");
+}
+class CloudBackupManager {
+  constructor(adapter, storage, config) {
+    this.adapter = adapter;
+    this.storage = storage;
+    this.config = config;
+  }
+  /**
+   * Create a backup and upload to cloud storage.
+   */
+  async backup(options = {}) {
+    const format = options.format ?? this.config.options?.format ?? "json";
+    const compression = options.compression ?? this.config.options?.compression ?? "none";
+    const tables = options.tables ?? this.config.options?.tables;
+    const prefix = options.prefix ?? this.config.options?.prefix ?? "backups/";
+    const includeTimestamp = options.includeTimestamp ?? this.config.options?.includeTimestamp ?? true;
+    let data;
+    if (format === "json") {
+      data = await (0, import_dataExport.exportAsJSON)(this.adapter, { tables });
+    } else {
+      data = await (0, import_dataExport.exportAsSQL)(this.adapter, { tables });
+    }
+    let uploadData = data;
+    if (compression === "gzip") {
+      uploadData = await compress(data);
+    }
+    const timestamp = includeTimestamp ? `-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}` : "";
+    const ext = format === "json" ? "json" : "sql";
+    const compExt = compression === "gzip" ? ".gz" : "";
+    const key = `${prefix}backup${timestamp}.${ext}${compExt}`;
+    await this.storage.upload(key, uploadData);
+    if (this.config.maxBackups) {
+      await this.cleanupOldBackups(prefix);
+    }
+    return key;
+  }
+  /**
+   * Restore from a cloud backup.
+   */
+  async restore(key) {
+    const data = await this.storage.download(key);
+    let restored;
+    if (key.endsWith(".gz")) {
+      restored = await decompress(Buffer.from(data));
+    } else {
+      restored = typeof data === "string" ? data : data.toString("utf-8");
+    }
+    if (key.includes(".json")) {
+      await (0, import_dataImport.importFromJSON)(this.adapter, restored);
+    } else {
+      await (0, import_dataImport.importFromSQL)(this.adapter, restored);
+    }
+  }
+  /**
+   * List all backups in cloud storage.
+   */
+  async listBackups(prefix) {
+    const searchPrefix = prefix ?? this.config.options?.prefix ?? "backups/";
+    return await this.storage.list(searchPrefix);
+  }
+  /**
+   * Delete old backups exceeding maxBackups limit.
+   */
+  async cleanupOldBackups(prefix) {
+    if (!this.config.maxBackups)
+      return;
+    const backups = await this.storage.list(prefix);
+    if (backups.length <= this.config.maxBackups)
+      return;
+    const sorted = backups.sort();
+    const toDelete = sorted.slice(0, backups.length - this.config.maxBackups);
+    for (const key of toDelete) {
+      await this.storage.delete(key);
+    }
+  }
+  /**
+   * Start automatic scheduled backups.
+   */
+  start() {
+    if (this.intervalId) {
+      throw new Error("Scheduled backups already started");
+    }
+    this.intervalId = setInterval(async () => {
+      try {
+        const key = await this.backup();
+        this.config.onSuccess?.(key);
+      } catch (error) {
+        this.config.onError?.(error);
+      }
+    }, this.config.interval);
+  }
+  /**
+   * Stop automatic scheduled backups.
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+  }
+  /**
+   * Perform a backup immediately (manual trigger).
+   */
+  async backupNow(options) {
+    return await this.backup(options);
+  }
+}
+function createCloudBackupManager(adapter, s3Client, bucket, config) {
+  const storage = new S3StorageProvider(s3Client, bucket);
+  return new CloudBackupManager(adapter, storage, config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CloudBackupManager,
+  S3StorageProvider,
+  createCloudBackupManager
+});