dbkeeper 1.0.0

package/dist/core/runBackup.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBackup = runBackup;
+const fs = __importStar(require("fs"));
+const retention_1 = require("./retention");
+const mail_1 = require("../notify/mail");
+const logger_1 = require("./logger");
+/**
+ * Core backup orchestrator.
+ *
+ * Accepts adapters by interface — never imports mongo.ts or gdrive.ts directly.
+ * This is the key extension point: swap in any DatabaseAdapter / StorageAdapter
+ * to support new databases or storage backends without changing this file.
+ *
+ * Safe rotation order (hard requirement):
+ *   1. dump   → create local backup file
+ *   2. upload → push to remote storage
+ *   3. verify → confirm the remote file ID exists
+ *   4. retain → delete old backups (ONLY after upload is confirmed)
+ *   5. notify → send success / failure email
+ *
+ * If any step before retention fails, we stop immediately:
+ *   - Nothing is deleted from remote storage
+ *   - A failure email is sent (if configured)
+ */
+async function runBackup(config, dbAdapter, storageAdapter) {
+    const timestamp = new Date();
+    let localFilePath = null;
+    try {
+        // -----------------------------------------------------------------------
+        // Step 1: Dump database
+        // -----------------------------------------------------------------------
+        logger_1.logger.info('=== dbkeeper: starting backup ===');
+        const dumpResult = await dbAdapter.dump(config.database);
+        localFilePath = dumpResult.filePath;
+        logger_1.logger.info(`Dump complete: ${localFilePath} (${dumpResult.sizeBytes} bytes)`);
+        // -----------------------------------------------------------------------
+        // Step 2: Upload to storage
+        // -----------------------------------------------------------------------
+        logger_1.logger.info('Uploading backup…');
+        const uploadResult = await storageAdapter.upload(localFilePath, config.storage);
+        logger_1.logger.info(`Upload complete. Remote ID: ${uploadResult.remoteId}`);
+        // -----------------------------------------------------------------------
+        // Step 3: Verify the upload (confirm the remote ID is non-empty)
+        // -----------------------------------------------------------------------
+        if (!uploadResult.remoteId || uploadResult.remoteId.trim() === '') {
+            throw new Error('Upload verification failed: storage adapter returned an empty remote ID.');
+        }
+        logger_1.logger.info('Upload verified ✓');
+        // -----------------------------------------------------------------------
+        // Step 4: Apply retention (ONLY now that upload is confirmed safe)
+        // -----------------------------------------------------------------------
+        const existingFiles = await storageAdapter.list(config.storage);
+        const { toDelete, remainingCount } = (0, retention_1.applyRetention)(existingFiles, config.retention.keep);
+        let deletedCount = 0;
+        for (const file of toDelete) {
+            logger_1.logger.info(`Retention: deleting old backup ${file.remoteId} (created ${file.createdAt.toISOString()})`);
+            await storageAdapter.delete(file.remoteId, config.storage);
+            deletedCount++;
+        }
+        if (deletedCount > 0) {
+            logger_1.logger.info(`Retention: deleted ${deletedCount} old backup(s). ${remainingCount} remain.`);
+        }
+        else {
+            logger_1.logger.info(`Retention: no deletions needed. ${remainingCount} backup(s) in storage.`);
+        }
+        // -----------------------------------------------------------------------
+        // Step 5: Notify success
+        // -----------------------------------------------------------------------
+        const success = {
+            ok: true,
+            filePath: localFilePath,
+            sizeBytes: dumpResult.sizeBytes,
+            remoteId: uploadResult.remoteId,
+            deletedCount,
+            remainingCount,
+            timestamp,
+        };
+        await (0, mail_1.sendSuccessEmail)(config, success);
+        logger_1.logger.info('=== dbkeeper: backup completed successfully ===');
+        return success;
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        logger_1.logger.error(`=== dbkeeper: backup FAILED — ${error.message} ===`);
+        const failure = { ok: false, error, timestamp };
+        await (0, mail_1.sendFailureEmail)(config, failure);
+        return failure;
+    }
+    finally {
+        // Always clean up the local temp archive, regardless of success/failure
+        if (localFilePath && fs.existsSync(localFilePath)) {
+            try {
+                // Remove the parent temp directory (which contains only the archive)
+                const tmpDir = require('path').dirname(localFilePath);
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+                logger_1.logger.info(`Cleaned up local temp dir: ${tmpDir}`);
+            }
+            catch {
+                // Non-fatal: temp file cleanup failure should not mask a real error
+            }
+        }
+    }
+}

package/dist/database/mongo.d.ts

@@ -0,0 +1,10 @@
+import { DatabaseAdapter } from '../types';
+/**
+ * MongoDB database adapter.
+ *
+ * Uses `mongodump` (must be on PATH) to create a BSON dump of the database,
+ * then compresses it into a `.tar.gz` archive using the `archiver` package.
+ *
+ * Implements {@link DatabaseAdapter}.
+ */
+export declare const mongoAdapter: DatabaseAdapter;

package/dist/database/mongo.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoAdapter = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const archiver_1 = require("archiver");
+const logger_1 = require("../core/logger");
+/**
+ * MongoDB database adapter.
+ *
+ * Uses `mongodump` (must be on PATH) to create a BSON dump of the database,
+ * then compresses it into a `.tar.gz` archive using the `archiver` package.
+ *
+ * Implements {@link DatabaseAdapter}.
+ */
+exports.mongoAdapter = {
+    async dump(config) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dbkeeper-'));
+        const dumpDir = path.join(tmpDir, 'dump');
+        const archivePath = path.join(tmpDir, `backup-mongo-${timestamp}.tar.gz`);
+        logger_1.logger.info(`[mongo] Starting mongodump → ${dumpDir}`);
+        // -----------------------------------------------------------------------
+        // 1. Run mongodump
+        // -----------------------------------------------------------------------
+        const result = (0, child_process_1.spawnSync)('mongodump', ['--uri', config.uri, '--out', dumpDir], { stdio: 'pipe', encoding: 'utf8' });
+        if (result.error) {
+            throw new Error(`[mongo] Failed to spawn mongodump. Is mongodump installed and on PATH?\n` +
+                result.error.message);
+        }
+        if (result.status !== 0) {
+            const stderr = result.stderr ?? '';
+            throw new Error(`[mongo] mongodump exited with code ${result.status}:\n${stderr}`);
+        }
+        logger_1.logger.info('[mongo] mongodump completed. Compressing…');
+        // -----------------------------------------------------------------------
+        // 2. Compress the dump directory into a tar.gz
+        // -----------------------------------------------------------------------
+        await compressDirectory(dumpDir, archivePath);
+        const { size } = fs.statSync(archivePath);
+        logger_1.logger.info(`[mongo] Archive ready: ${archivePath} (${formatBytes(size)})`);
+        // Clean up the raw dump dir — we only need the archive going forward
+        fs.rmSync(dumpDir, { recursive: true, force: true });
+        return { filePath: archivePath, sizeBytes: size };
+    },
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function compressDirectory(sourceDir, destPath) {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(destPath);
+        const archive = new archiver_1.TarArchive({ gzip: true, gzipOptions: { level: 9 } });
+        output.on('close', resolve);
+        archive.on('error', reject);
+        archive.pipe(output);
+        archive.directory(sourceDir, false); // false = don't add parent dir prefix
+        archive.finalize();
+    });
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * dbkeeper — public programmatic API
+ *
+ * Usage (TypeScript):
+ *   import { runBackup, mongoAdapter, gdriveAdapter } from 'dbkeeper';
+ *
+ * Usage (CommonJS):
+ *   const { runBackup, mongoAdapter, gdriveAdapter } = require('dbkeeper');
+ */
+export { runBackup } from './core/runBackup';
+export { mongoAdapter } from './database/mongo';
+export { gdriveAdapter } from './storage/gdrive';
+export { loadConfig } from './config/loadConfig';
+export { applyRetention } from './core/retention';
+export { logger } from './core/logger';
+export type { BackupConfig, BackupResult, BackupSuccess, BackupFailure, DatabaseAdapter, StorageAdapter, DatabaseConfig, StorageConfig, MongoDatabaseConfig, GDriveStorageConfig, RetentionConfig, NotificationsConfig, } from './types';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * dbkeeper — public programmatic API
+ *
+ * Usage (TypeScript):
+ *   import { runBackup, mongoAdapter, gdriveAdapter } from 'dbkeeper';
+ *
+ * Usage (CommonJS):
+ *   const { runBackup, mongoAdapter, gdriveAdapter } = require('dbkeeper');
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.applyRetention = exports.loadConfig = exports.gdriveAdapter = exports.mongoAdapter = exports.runBackup = void 0;
+var runBackup_1 = require("./core/runBackup");
+Object.defineProperty(exports, "runBackup", { enumerable: true, get: function () { return runBackup_1.runBackup; } });
+var mongo_1 = require("./database/mongo");
+Object.defineProperty(exports, "mongoAdapter", { enumerable: true, get: function () { return mongo_1.mongoAdapter; } });
+var gdrive_1 = require("./storage/gdrive");
+Object.defineProperty(exports, "gdriveAdapter", { enumerable: true, get: function () { return gdrive_1.gdriveAdapter; } });
+var loadConfig_1 = require("./config/loadConfig");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return loadConfig_1.loadConfig; } });
+var retention_1 = require("./core/retention");
+Object.defineProperty(exports, "applyRetention", { enumerable: true, get: function () { return retention_1.applyRetention; } });
+var logger_1 = require("./core/logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });

package/dist/notify/mail.d.ts

@@ -0,0 +1,11 @@
+import { BackupConfig, BackupSuccess, BackupFailure } from '../types';
+/**
+ * Sends a success email if `config.notifications.success` is true.
+ * Never throws — email failures are logged but do not fail the backup run.
+ */
+export declare function sendSuccessEmail(config: BackupConfig, result: BackupSuccess): Promise<void>;
+/**
+ * Sends a failure email if `config.notifications.failure` is true.
+ * Never throws — email failures are logged but do not mask the original error.
+ */
+export declare function sendFailureEmail(config: BackupConfig, result: BackupFailure): Promise<void>;

package/dist/notify/mail.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSuccessEmail = sendSuccessEmail;
+exports.sendFailureEmail = sendFailureEmail;
+const nodemailer_1 = __importDefault(require("nodemailer"));
+const logger_1 = require("../core/logger");
+/**
+ * Sends a success email if `config.notifications.success` is true.
+ * Never throws — email failures are logged but do not fail the backup run.
+ */
+async function sendSuccessEmail(config, result) {
+    if (!config.notifications.success)
+        return;
+    const subject = `✅ dbkeeper — backup succeeded (${result.timestamp.toISOString()})`;
+    const text = [
+        `Backup completed successfully.`,
+        ``,
+        `  Database:        ${config.database.type}`,
+        `  File:            ${result.filePath.split(/[\\/]/).pop()}`,
+        `  Size:            ${formatBytes(result.sizeBytes)}`,
+        `  Storage:         ${config.storage.type}`,
+        `  Remote ID:       ${result.remoteId}`,
+        `  Backups kept:    ${result.remainingCount}`,
+        `  Backups deleted: ${result.deletedCount}`,
+        `  Timestamp:       ${result.timestamp.toISOString()}`,
+    ].join('\n');
+    await sendMail(config, subject, text);
+}
+/**
+ * Sends a failure email if `config.notifications.failure` is true.
+ * Never throws — email failures are logged but do not mask the original error.
+ */
+async function sendFailureEmail(config, result) {
+    if (!config.notifications.failure)
+        return;
+    const subject = `❌ dbkeeper — backup FAILED (${result.timestamp.toISOString()})`;
+    const text = [
+        `Backup failed.`,
+        ``,
+        `  Error:     ${result.error.message}`,
+        `  Timestamp: ${result.timestamp.toISOString()}`,
+        ``,
+        `Stack trace:`,
+        result.error.stack ?? '(no stack available)',
+    ].join('\n');
+    await sendMail(config, subject, text);
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+async function sendMail(config, subject, text) {
+    try {
+        const smtp = config.notifications.smtp;
+        // If no SMTP block is provided, fall back to a JSON-logger so
+        // self-hosted setups without a mail server don't crash.
+        if (!smtp) {
+            logger_1.logger.warn('[mail] No SMTP config provided — printing email to console instead.\n' +
+                `Subject: ${subject}\n\n${text}`);
+            return;
+        }
+        const transporter = nodemailer_1.default.createTransport({
+            host: smtp.host,
+            port: smtp.port ?? 587,
+            secure: smtp.secure ?? false,
+            auth: smtp.auth,
+        });
+        await transporter.sendMail({
+            from: smtp.auth?.user ?? 'dbkeeper@noreply.local',
+            to: config.notifications.to,
+            subject,
+            text,
+        });
+        logger_1.logger.info(`[mail] Email sent to ${config.notifications.to}: "${subject}"`);
+    }
+    catch (err) {
+        // Non-fatal: log the email send error, but never propagate it
+        logger_1.logger.error(`[mail] Failed to send email: ${err.message}`);
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}

package/dist/storage/gdrive.d.ts

@@ -0,0 +1,11 @@
+import { StorageAdapter } from '../types';
+/**
+ * Google Drive storage adapter.
+ *
+ * Uses a service-account JSON key (path supplied in config) to authenticate
+ * with the Drive v3 API.  All backup files are scoped to a single Drive
+ * folder supplied via `config.folderId`.
+ *
+ * Implements {@link StorageAdapter}.
+ */
+export declare const gdriveAdapter: StorageAdapter;

package/dist/storage/gdrive.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gdriveAdapter = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const googleapis_1 = require("googleapis");
+const logger_1 = require("../core/logger");
+/**
+ * Google Drive storage adapter.
+ *
+ * Uses a service-account JSON key (path supplied in config) to authenticate
+ * with the Drive v3 API.  All backup files are scoped to a single Drive
+ * folder supplied via `config.folderId`.
+ *
+ * Implements {@link StorageAdapter}.
+ */
+exports.gdriveAdapter = {
+    // -------------------------------------------------------------------------
+    // upload
+    // -------------------------------------------------------------------------
+    async upload(filePath, config) {
+        const drive = await buildDriveClient(config.credentialsPath);
+        const fileName = path.basename(filePath);
+        const fileSize = fs.statSync(filePath).size;
+        logger_1.logger.info(`[gdrive] Uploading "${fileName}" (${formatBytes(fileSize)}) to folder ${config.folderId}`);
+        const response = await drive.files.create({
+            requestBody: {
+                name: fileName,
+                parents: [config.folderId],
+            },
+            media: {
+                mimeType: 'application/gzip',
+                body: fs.createReadStream(filePath),
+            },
+            fields: 'id, name, size',
+        });
+        const remoteId = response.data.id;
+        if (!remoteId) {
+            throw new Error('[gdrive] Upload succeeded but Drive returned no file ID');
+        }
+        logger_1.logger.info(`[gdrive] Upload complete. Remote ID: ${remoteId}`);
+        return { remoteId };
+    },
+    // -------------------------------------------------------------------------
+    // list
+    // -------------------------------------------------------------------------
+    async list(config) {
+        const drive = await buildDriveClient(config.credentialsPath);
+        logger_1.logger.info(`[gdrive] Listing backup files in folder ${config.folderId}`);
+        // Drive API paginates at 1000; for typical backup retention (≤100s of files)
+        // a single page is always sufficient. Add pagination if you ever use keep > 900.
+        const response = await drive.files.list({
+            q: `'${config.folderId}' in parents and trashed = false`,
+            fields: 'files(id, name, createdTime)',
+            orderBy: 'createdTime asc',
+            pageSize: 1000,
+        });
+        const files = response.data.files ?? [];
+        return files
+            .filter((f) => f.id && f.createdTime)
+            .map((f) => ({
+            remoteId: f.id,
+            createdAt: new Date(f.createdTime),
+        }));
+    },
+    // -------------------------------------------------------------------------
+    // delete
+    // -------------------------------------------------------------------------
+    async delete(remoteId, config) {
+        const drive = await buildDriveClient(config.credentialsPath);
+        logger_1.logger.info(`[gdrive] Deleting remote file: ${remoteId}`);
+        await drive.files.delete({ fileId: remoteId });
+        logger_1.logger.info(`[gdrive] Deleted: ${remoteId}`);
+    },
+};
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+async function buildDriveClient(credentialsPath) {
+    const resolvedPath = path.resolve(credentialsPath);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`[gdrive] Service account key not found at "${resolvedPath}".\n` +
+            `Set credentialsPath in your backup.config.js to the correct path.`);
+    }
+    const raw = fs.readFileSync(resolvedPath, 'utf8');
+    const credentials = JSON.parse(raw);
+    const auth = new googleapis_1.google.auth.GoogleAuth({
+        credentials,
+        scopes: ['https://www.googleapis.com/auth/drive'],
+    });
+    return googleapis_1.google.drive({ version: 'v3', auth });
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Adapter contract for database engines.
+ * Implement this interface to add a new database type (e.g. Postgres, MySQL).
+ */
+export interface DatabaseAdapter {
+    dump(config: DatabaseConfig): Promise<{
+        filePath: string;
+        sizeBytes: number;
+    }>;
+}
+/**
+ * Adapter contract for storage backends.
+ * Implement this interface to add a new storage provider (e.g. S3, Dropbox).
+ */
+export interface StorageAdapter {
+    upload(filePath: string, config: StorageConfig): Promise<{
+        remoteId: string;
+    }>;
+    list(config: StorageConfig): Promise<{
+        remoteId: string;
+        createdAt: Date;
+    }[]>;
+    delete(remoteId: string, config: StorageConfig): Promise<void>;
+}
+export interface MongoDatabaseConfig {
+    type: 'mongo';
+    uri: string;
+}
+export type DatabaseConfig = MongoDatabaseConfig;
+export interface GDriveStorageConfig {
+    type: 'gdrive';
+    credentialsPath: string;
+    folderId: string;
+}
+export type StorageConfig = GDriveStorageConfig;
+export interface RetentionConfig {
+    /** Number of most-recent backups to keep, or "unlimited" to never delete. */
+    keep: number | 'unlimited';
+}
+export interface NotificationsConfig {
+    /** Send an email when a backup succeeds. */
+    success: boolean;
+    /** Send an email when a backup fails. */
+    failure: boolean;
+    /** Recipient email address. */
+    to: string;
+    /** Nodemailer SMTP transport options — see https://nodemailer.com/smtp/ */
+    smtp?: {
+        host: string;
+        port?: number;
+        secure?: boolean;
+        auth?: {
+            user: string;
+            pass: string;
+        };
+    };
+}
+export interface BackupConfig {
+    database: DatabaseConfig;
+    storage: StorageConfig;
+    retention: RetentionConfig;
+    notifications: NotificationsConfig;
+}
+export interface BackupSuccess {
+    ok: true;
+    filePath: string;
+    sizeBytes: number;
+    remoteId: string;
+    deletedCount: number;
+    remainingCount: number;
+    timestamp: Date;
+}
+export interface BackupFailure {
+    ok: false;
+    error: Error;
+    timestamp: Date;
+}
+export type BackupResult = BackupSuccess | BackupFailure;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });