@webtypen/webframez-core 0.3.55 → 0.3.56

package/dist/Backup/BackupManager.d.ts

@@ -1,4 +1,4 @@
-import { BackupCleanupOptions, BackupCleanupResult, BackupConfig, BackupOutputConfig, BackupRetentionConfig, BackupRunOptions, BackupRunResult, BackupTypeConfig } from "./BackupTypes";
+import { BackupCleanupOptions, BackupCleanupResult, BackupConfig, BackupOutputConfig, BackupRetentionConfig, BackupRestorePoint, BackupRestoreResult, BackupRunOptions, BackupRunResult, BackupTypeConfig } from "./BackupTypes";
 type ResolvedBackupTypeConfig = BackupTypeConfig & {
     workDir: string;
     outputDir: string;
@@ -24,9 +24,29 @@ export declare class BackupManager {
     private resolveOutputs;
     private collectFilesFromSource;
     private copyFiles;
+    private buildFileIndex;
+    private fileIndexChanged;
+    private incrementalEnabled;
+    private assertIncrementalSupported;
+    private chooseOutputForRead;
+    private listRestorePointsForOutput;
+    listRestorePoints(key: string, options?: {
+        channels?: string[];
+    }): Promise<BackupRestorePoint[]>;
+    private isFullIncrementalRun;
+    private buildBackupManifest;
+    private writeContentManifest;
     private backupDatabase;
     private buildArtifact;
     run(key: string, options?: BackupRunOptions): Promise<BackupRunResult>;
+    private downloadRestoreArtifact;
+    private restoreChain;
+    private extractArtifact;
+    restore(key: string, targetDir: string | undefined, options?: {
+        backupId?: string;
+        channels?: string[];
+        dryRun?: boolean;
+    }): Promise<BackupRestoreResult>;
     cleanup(key: string, options?: BackupCleanupOptions): Promise<BackupCleanupResult[]>;
 }
 export {};

package/dist/Backup/BackupManager.js

@@ -15,12 +15,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackupManager = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+const extract_zip_1 = __importDefault(require("extract-zip"));
 const Config_1 = require("../Config");
 const DBConnection_1 = require("../Database/DBConnection");
 const BackupOutputDrivers_1 = require("./BackupOutputDrivers");
 const BackupPathUtils_1 = require("./Utils/BackupPathUtils");
 const GlobMatcher_1 = require("./Utils/GlobMatcher");
 const ZipWriter_1 = require("./Utils/ZipWriter");
+const AutomationSchedule_1 = require("../Queue/AutomationSchedule");
 function statSize(filepath) {
     const stats = fs_1.default.statSync(filepath);
     if (!stats.isDirectory()) {
@@ -39,6 +43,47 @@ function mergeRetention(defaults, typeRetention, outputRetention) {
 function normalizeArray(value) {
     return value && Array.isArray(value) ? value : [];
 }
+function safeReadJson(filepath) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(filepath, "utf-8"));
+    }
+    catch (e) {
+        return null;
+    }
+}
+function sha256File(filepath) {
+    const hash = crypto_1.default.createHash("sha256");
+    hash.update(fs_1.default.readFileSync(filepath));
+    return hash.digest("hex");
+}
+function restorePointCreatedAt(point) {
+    return point.createdAt instanceof Date ? point.createdAt : new Date(point.createdAt);
+}
+function normalizeManifest(input, entry) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!input) {
+        return null;
+    }
+    const manifest = input.backupManifest || input;
+    const backupKey = manifest.backupKey || input.key || (entry === null || entry === void 0 ? void 0 : entry.backupKey);
+    const backupId = manifest.backupId || input.id || (entry === null || entry === void 0 ? void 0 : entry.backupId);
+    if (!backupKey || !backupId) {
+        return null;
+    }
+    return Object.assign(Object.assign({}, manifest), { backupKey: backupKey, backupId: backupId, kind: manifest.kind || input.kind || "normal", chainId: manifest.chainId || input.chainId, parentBackupId: manifest.parentBackupId || input.parentBackupId, createdAt: manifest.createdAt || input.startedAt || ((_b = (_a = entry === null || entry === void 0 ? void 0 : entry.createdAt) === null || _a === void 0 ? void 0 : _a.toISOString) === null || _b === void 0 ? void 0 : _b.call(_a)) || new Date().toISOString(), artifact: manifest.artifact || ((_c = input.artifact) === null || _c === void 0 ? void 0 : _c.filename) || input.artifact || (entry === null || entry === void 0 ? void 0 : entry.filename), artifactType: manifest.artifactType || ((_d = input.artifact) === null || _d === void 0 ? void 0 : _d.type) || "zip", files: {
+            upserted: ((_e = manifest.files) === null || _e === void 0 ? void 0 : _e.upserted) || [],
+            deleted: ((_f = manifest.files) === null || _f === void 0 ? void 0 : _f.deleted) || [],
+            fileIndex: ((_g = manifest.files) === null || _g === void 0 ? void 0 : _g.fileIndex) || {},
+        } });
+}
+function assertInside(targetRoot, relative) {
+    const target = path_1.default.resolve(targetRoot, relative);
+    const root = path_1.default.resolve(targetRoot);
+    if (target !== root && !target.startsWith(root + path_1.default.sep)) {
+        throw new Error(`Refusing to restore unsafe path '${relative}'.`);
+    }
+    return target;
+}
 class BackupManager {
     log(options, message, payload) {
         if ((options === null || options === void 0 ? void 0 : options.silent) || !(options === null || options === void 0 ? void 0 : options.log)) {
@@ -150,11 +195,13 @@ class BackupManager {
                 return;
             }
             included += 1;
+            const stats = fs_1.default.statSync(filepath);
             files.push({
                 source: filepath,
                 relative: relative,
                 target: (0, BackupPathUtils_1.normalizeBackupPath)(path_1.default.join(toBase, relative)),
-                size: fs_1.default.statSync(filepath).size,
+                size: stats.size,
+                mtimeMs: stats.mtimeMs,
             });
             if (visited % interval === 0) {
                 this.log(options, `Scanned ${visited} file(s), included ${included}`);
@@ -193,6 +240,160 @@ class BackupManager {
             }
         }
     }
+    buildFileIndex(files, checksum) {
+        const index = {};
+        for (const file of files) {
+            index[file.target] = Object.assign({ path: file.target, size: file.size, mtimeMs: Math.round(file.mtimeMs) }, (checksum ? { checksum: sha256File(file.source) } : {}));
+        }
+        return index;
+    }
+    fileIndexChanged(current, previous, checksum) {
+        if (!previous) {
+            return true;
+        }
+        if (current.size !== previous.size) {
+            return true;
+        }
+        if (checksum) {
+            return current.checksum !== previous.checksum;
+        }
+        return Math.round(current.mtimeMs || 0) !== Math.round(previous.mtimeMs || 0);
+    }
+    incrementalEnabled(backupType) {
+        var _a;
+        return ((_a = backupType.incremental) === null || _a === void 0 ? void 0 : _a.enabled) === true;
+    }
+    assertIncrementalSupported(key, backupType) {
+        if (!this.incrementalEnabled(backupType)) {
+            return;
+        }
+        if (!backupType.zip) {
+            throw new Error(`Incremental backup '${key}' requires zip=true.`);
+        }
+        if (normalizeArray(backupType.databases).length > 0) {
+            throw new Error(`Incremental backup '${key}' supports file-only backup types in v1.`);
+        }
+    }
+    chooseOutputForRead(backupType, channels) {
+        const outputs = this.resolveOutputs(backupType, channels);
+        if (outputs.length < 1) {
+            return null;
+        }
+        return outputs[0];
+    }
+    listRestorePointsForOutput(key, output) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const driver = BackupOutputDrivers_1.BackupOutputDrivers.get(output.driver);
+            if (!driver.listArtifacts || !driver.readManifest) {
+                return [];
+            }
+            const entries = yield driver.listArtifacts(output, {
+                backupKey: key,
+                backupId: (0, BackupPathUtils_1.backupTimestampId)(),
+                log: () => null,
+            });
+            const points = [];
+            for (const entry of entries) {
+                const rawManifest = yield driver.readManifest(output, entry, {
+                    backupKey: key,
+                    backupId: (0, BackupPathUtils_1.backupTimestampId)(),
+                    log: () => null,
+                });
+                const manifest = normalizeManifest(rawManifest, entry);
+                if (!manifest || manifest.backupKey !== key) {
+                    continue;
+                }
+                points.push(Object.assign(Object.assign({}, entry), { backupKey: manifest.backupKey, backupId: manifest.backupId, kind: manifest.kind || "normal", chainId: manifest.chainId, parentBackupId: manifest.parentBackupId, createdAt: new Date(manifest.createdAt || entry.createdAt), manifest: manifest }));
+            }
+            return points.sort((a, b) => restorePointCreatedAt(b).getTime() - restorePointCreatedAt(a).getTime());
+        });
+    }
+    listRestorePoints(key, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const backupType = this.resolveType(key);
+            const output = this.chooseOutputForRead(backupType, options === null || options === void 0 ? void 0 : options.channels);
+            if (!output) {
+                throw new Error(`Backup type '${key}' has no matching output channels.`);
+            }
+            return this.listRestorePointsForOutput(key, output);
+        });
+    }
+    isFullIncrementalRun(backupType, previousPoint, options) {
+        var _a;
+        if (options === null || options === void 0 ? void 0 : options.full) {
+            return true;
+        }
+        if (!previousPoint) {
+            return true;
+        }
+        return (0, AutomationSchedule_1.matchesAutomationExecutions)((_a = backupType.incremental) === null || _a === void 0 ? void 0 : _a.fullExecutions, options === null || options === void 0 ? void 0 : options.scheduledAt);
+    }
+    buildBackupManifest(key, id, createdAt, artifactFilename, backupType, fileEntries, options) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentIndex = this.buildFileIndex(fileEntries, ((_a = backupType.incremental) === null || _a === void 0 ? void 0 : _a.checksum) === true);
+            const currentByTarget = new Map(fileEntries.map((entry) => [entry.target, entry]));
+            if (!this.incrementalEnabled(backupType)) {
+                return {
+                    manifest: {
+                        backupKey: key,
+                        backupId: id,
+                        kind: "normal",
+                        createdAt: createdAt.toISOString(),
+                        artifact: artifactFilename,
+                        artifactType: backupType.zip ? "zip" : "directory",
+                        files: {
+                            upserted: fileEntries.map((entry) => (Object.assign(Object.assign({}, currentIndex[entry.target]), { source: entry.source }))),
+                            deleted: [],
+                            fileIndex: currentIndex,
+                        },
+                    },
+                    filesToCopy: fileEntries,
+                    previousPoint: null,
+                };
+            }
+            const stateOutput = this.chooseOutputForRead(backupType, options === null || options === void 0 ? void 0 : options.channels);
+            const restorePoints = stateOutput ? yield this.listRestorePointsForOutput(key, stateOutput) : [];
+            const previousPoint = restorePoints.find((point) => point.kind === "full" || point.kind === "incremental") || null;
+            const full = this.isFullIncrementalRun(backupType, previousPoint, options);
+            const previousIndex = ((_c = (_b = previousPoint === null || previousPoint === void 0 ? void 0 : previousPoint.manifest) === null || _b === void 0 ? void 0 : _b.files) === null || _c === void 0 ? void 0 : _c.fileIndex) || {};
+            const upserted = Object.values(currentIndex)
+                .filter((entry) => { var _a; return full || this.fileIndexChanged(entry, previousIndex[entry.path], ((_a = backupType.incremental) === null || _a === void 0 ? void 0 : _a.checksum) === true); })
+                .map((entry) => { var _a; return (Object.assign(Object.assign({}, entry), { source: (_a = currentByTarget.get(entry.path)) === null || _a === void 0 ? void 0 : _a.source })); });
+            const deleted = full
+                ? []
+                : Object.keys(previousIndex)
+                    .filter((entryPath) => !currentIndex[entryPath])
+                    .sort();
+            const upsertedPaths = new Set(upserted.map((entry) => entry.path));
+            const filesToCopy = full ? fileEntries : fileEntries.filter((entry) => upsertedPaths.has(entry.target));
+            const chainId = full ? id : (previousPoint === null || previousPoint === void 0 ? void 0 : previousPoint.chainId) || (previousPoint === null || previousPoint === void 0 ? void 0 : previousPoint.backupId) || id;
+            return {
+                manifest: {
+                    backupKey: key,
+                    backupId: id,
+                    kind: full ? "full" : "incremental",
+                    chainId: chainId,
+                    parentBackupId: full ? undefined : previousPoint === null || previousPoint === void 0 ? void 0 : previousPoint.backupId,
+                    createdAt: createdAt.toISOString(),
+                    artifact: artifactFilename,
+                    artifactType: "zip",
+                    files: {
+                        upserted: upserted,
+                        deleted: deleted,
+                        fileIndex: currentIndex,
+                    },
+                },
+                filesToCopy: filesToCopy,
+                previousPoint: previousPoint,
+            };
+        });
+    }
+    writeContentManifest(contentDir, manifest) {
+        const manifestPath = path_1.default.join(contentDir, ".webframez-backup", "manifest.json");
+        fs_1.default.mkdirSync(path_1.default.dirname(manifestPath), { recursive: true });
+        fs_1.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 4), "utf-8");
+    }
     backupDatabase(source, contentDir, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const to = (0, BackupPathUtils_1.normalizeBackupPath)(source.to || `database/${source.connection || "default"}`);
@@ -252,9 +453,12 @@ class BackupManager {
         return __awaiter(this, void 0, void 0, function* () {
             const backupType = this.resolveType(key);
             this.ensureActive(key, backupType);
+            this.assertIncrementalSupported(key, backupType);
             this.log(options, `Starting backup '${key}'`);
             const now = new Date();
             const id = (0, BackupPathUtils_1.backupTimestampId)(now);
+            const filename = (0, BackupPathUtils_1.formatBackupFilename)(backupType.filename, { key, date: now, id });
+            const artifactFilename = backupType.zip ? `${filename}.zip` : filename;
             const workRoot = (0, BackupPathUtils_1.resolveProjectPath)(backupType.workDir);
             const workRunDir = path_1.default.join(workRoot, `${key}_${id}`);
             const contentDir = path_1.default.join(workRunDir, "content");
@@ -277,11 +481,23 @@ class BackupManager {
             const fileEntries = normalizeArray(backupType.files).flatMap((source) => this.collectFilesFromSource(source, options));
             const fileSize = fileEntries.reduce((sum, entry) => sum + entry.size, 0);
             this.log(options, `Collected ${fileEntries.length} file(s)`, { size: fileSize });
-            result.files = fileEntries.map((entry) => ({
+            const incremental = yield this.buildBackupManifest(key, id, now, artifactFilename, backupType, fileEntries, options);
+            result.kind = incremental.manifest.kind;
+            result.chainId = incremental.manifest.chainId;
+            result.parentBackupId = incremental.manifest.parentBackupId;
+            result.backupManifest = incremental.manifest;
+            result.files = incremental.filesToCopy.map((entry) => ({
                 from: entry.source,
                 to: entry.target,
                 size: entry.size,
             }));
+            if (this.incrementalEnabled(backupType)) {
+                this.log(options, `Prepared ${incremental.manifest.kind} backup`, {
+                    upserted: incremental.manifest.files.upserted.length,
+                    deleted: incremental.manifest.files.deleted.length,
+                    parentBackupId: incremental.manifest.parentBackupId,
+                });
+            }
             if (options === null || options === void 0 ? void 0 : options.dryRun) {
                 this.log(options, "Dry run enabled; skipping artifact and output writes");
                 result.outputs = outputs.map((output) => ({
@@ -300,8 +516,9 @@ class BackupManager {
             fs_1.default.rmSync(workRunDir, { recursive: true, force: true });
             fs_1.default.mkdirSync(contentDir, { recursive: true });
             try {
-                this.log(options, `Copying ${fileEntries.length} file(s) into backup work directory`);
-                this.copyFiles(fileEntries, contentDir, options);
+                this.log(options, `Copying ${incremental.filesToCopy.length} file(s) into backup work directory`);
+                this.copyFiles(incremental.filesToCopy, contentDir, options);
+                this.writeContentManifest(contentDir, incremental.manifest);
                 this.log(options, "File copy finished");
                 for (const source of normalizeArray(backupType.databases)) {
                     this.log(options, `Backing up database '${source.connection || "default"}'`);
@@ -313,6 +530,7 @@ class BackupManager {
                     this.log(options, `Database '${source.connection || "default"}' backup finished`);
                 }
                 result.artifact = this.buildArtifact(key, backupType, workRunDir, contentDir, now, id, options);
+                result.artifact.manifest = incremental.manifest;
                 const manifestPath = path_1.default.join(workRunDir, `${result.artifact.filename}.run-manifest.json`);
                 result.manifestPath = manifestPath;
                 for (const output of outputs) {
@@ -369,6 +587,114 @@ class BackupManager {
             }
         });
     }
+    downloadRestoreArtifact(output, point, targetPath, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const driver = BackupOutputDrivers_1.BackupOutputDrivers.get(output.driver);
+            if (!driver.downloadArtifact) {
+                throw new Error(`Backup output driver '${output.driver}' does not support restore downloads.`);
+            }
+            return driver.downloadArtifact(output, point, targetPath, {
+                backupKey: key,
+                backupId: point.backupId,
+                log: () => null,
+            });
+        });
+    }
+    restoreChain(points, target) {
+        if (target.kind === "normal") {
+            return [target];
+        }
+        const chainId = target.chainId || target.backupId;
+        const targetCreatedAt = restorePointCreatedAt(target).getTime();
+        const chain = points
+            .filter((point) => (point.chainId || point.backupId) === chainId)
+            .filter((point) => restorePointCreatedAt(point).getTime() <= targetCreatedAt)
+            .sort((a, b) => restorePointCreatedAt(a).getTime() - restorePointCreatedAt(b).getTime());
+        if (chain.length < 1 || chain[0].kind !== "full") {
+            throw new Error(`Could not find base full backup for incremental backup '${target.backupId}'.`);
+        }
+        if (!chain.find((point) => point.backupId === target.backupId)) {
+            throw new Error(`Could not build restore chain for backup '${target.backupId}'.`);
+        }
+        return chain;
+    }
+    extractArtifact(artifactPath, targetDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, extract_zip_1.default)(artifactPath, { dir: path_1.default.resolve(targetDir) });
+            fs_1.default.rmSync(path_1.default.join(targetDir, ".webframez-backup"), { recursive: true, force: true });
+        });
+    }
+    restore(key, targetDir, options) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const backupType = this.resolveType(key);
+            const output = this.chooseOutputForRead(backupType, options === null || options === void 0 ? void 0 : options.channels);
+            if (!output) {
+                throw new Error(`Backup type '${key}' has no matching output channels.`);
+            }
+            const driver = BackupOutputDrivers_1.BackupOutputDrivers.get(output.driver);
+            if (!driver.listArtifacts || !driver.readManifest || !driver.downloadArtifact) {
+                throw new Error(`Backup output driver '${output.driver}' does not support restore.`);
+            }
+            const restorePoints = yield this.listRestorePointsForOutput(key, output);
+            if (!(options === null || options === void 0 ? void 0 : options.backupId)) {
+                return {
+                    backupKey: key,
+                    driver: output.driver,
+                    dryRun: options === null || options === void 0 ? void 0 : options.dryRun,
+                    restorePoints: restorePoints,
+                };
+            }
+            if (!targetDir || targetDir.trim() === "") {
+                throw new Error("Restore target directory is required.");
+            }
+            const targetPoint = restorePoints.find((point) => point.backupId === options.backupId);
+            if (!targetPoint) {
+                throw new Error(`Backup '${options.backupId}' was not found for '${key}'.`);
+            }
+            const targetPath = path_1.default.resolve(targetDir);
+            if (fs_1.default.existsSync(targetPath) && fs_1.default.readdirSync(targetPath).length > 0) {
+                throw new Error(`Restore target directory must be new or empty: ${targetPath}`);
+            }
+            const chain = this.restoreChain(restorePoints, targetPoint);
+            const result = {
+                backupKey: key,
+                backupId: targetPoint.backupId,
+                targetDir: targetPath,
+                driver: output.driver,
+                dryRun: options === null || options === void 0 ? void 0 : options.dryRun,
+                chain: chain,
+                restored: [],
+                deleted: [],
+            };
+            if (options === null || options === void 0 ? void 0 : options.dryRun) {
+                return result;
+            }
+            fs_1.default.mkdirSync(targetPath, { recursive: true });
+            const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "webframez-backup-restore-"));
+            try {
+                for (const point of chain) {
+                    const artifactPath = path_1.default.join(tempDir, point.filename);
+                    yield this.downloadRestoreArtifact(output, point, artifactPath, key);
+                    yield this.extractArtifact(artifactPath, targetPath);
+                    (_a = result.restored) === null || _a === void 0 ? void 0 : _a.push({
+                        artifact: point.filename,
+                        backupId: point.backupId,
+                        kind: point.kind,
+                    });
+                    for (const deletedPath of ((_c = (_b = point.manifest) === null || _b === void 0 ? void 0 : _b.files) === null || _c === void 0 ? void 0 : _c.deleted) || []) {
+                        const deleteTarget = assertInside(targetPath, (0, BackupPathUtils_1.normalizeBackupPath)(deletedPath));
+                        fs_1.default.rmSync(deleteTarget, { recursive: true, force: true });
+                        (_d = result.deleted) === null || _d === void 0 ? void 0 : _d.push((0, BackupPathUtils_1.normalizeBackupPath)(deletedPath));
+                    }
+                }
+            }
+            finally {
+                fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            }
+            return result;
+        });
+    }
     cleanup(key, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {

package/dist/Backup/BackupTypes.d.ts

@@ -10,6 +10,11 @@ export type BackupFileSourceConfig = {
     exclude?: string[];
     optional?: boolean;
 };
+export type BackupIncrementalConfig = {
+    enabled?: boolean;
+    fullExecutions?: any[];
+    checksum?: boolean;
+};
 export type BackupDatabaseSourceConfig = {
     connection?: string;
     to?: string;
@@ -18,6 +23,7 @@ export type BackupDatabaseSourceConfig = {
 export type BackupOutputConfig = {
     driver: string;
     path?: string;
+    groupByDate?: boolean;
     retention?: BackupRetentionConfig;
     [key: string]: any;
 };
@@ -36,6 +42,7 @@ export type BackupDefaultsConfig = {
     zipCompressionLevel?: number;
     cleanupWorkDir?: boolean;
     retention?: BackupRetentionConfig;
+    incremental?: BackupIncrementalConfig;
 };
 export type BackupTypeConfig = BackupDefaultsConfig & {
     is_active?: boolean;
@@ -55,6 +62,7 @@ export type BackupArtifact = {
     filename: string;
     size: number;
     type: "zip" | "directory" | "manifest";
+    manifest?: BackupRunManifest;
 };
 export type BackupOutputResult = {
     driver: string;
@@ -69,6 +77,56 @@ export type BackupCleanupEntry = {
     createdAt: Date;
     size: number;
     reason: string;
+    payload?: any;
+};
+export type BackupFileIndexEntry = {
+    path: string;
+    size: number;
+    mtimeMs?: number;
+    checksum?: string;
+};
+export type BackupRunManifestFileChange = BackupFileIndexEntry & {
+    source?: string;
+};
+export type BackupRunManifest = {
+    backupKey: string;
+    backupId: string;
+    kind: "normal" | "full" | "incremental";
+    chainId?: string;
+    parentBackupId?: string;
+    createdAt: string;
+    artifact: string;
+    artifactType: "zip" | "directory" | "manifest";
+    files: {
+        upserted: BackupRunManifestFileChange[];
+        deleted: string[];
+        fileIndex: {
+            [path: string]: BackupFileIndexEntry;
+        };
+    };
+};
+export type BackupRestorePoint = BackupCleanupEntry & {
+    backupKey: string;
+    backupId: string;
+    kind: "normal" | "full" | "incremental";
+    chainId?: string;
+    parentBackupId?: string;
+    manifest?: BackupRunManifest | any;
+};
+export type BackupRestoreResult = {
+    backupKey: string;
+    backupId?: string;
+    targetDir?: string;
+    dryRun?: boolean;
+    driver?: string;
+    restorePoints?: BackupRestorePoint[];
+    chain?: BackupRestorePoint[];
+    restored?: Array<{
+        artifact: string;
+        backupId: string;
+        kind: string;
+    }>;
+    deleted?: string[];
 };
 export type BackupCleanupResult = {
     driver: string;
@@ -81,6 +139,9 @@ export type BackupCleanupResult = {
 export type BackupRunResult = {
     key: string;
     id: string;
+    kind?: "normal" | "full" | "incremental";
+    chainId?: string;
+    parentBackupId?: string;
     startedAt: string;
     endedAt: string;
     dryRun: boolean;
@@ -98,9 +159,12 @@ export type BackupRunResult = {
         to: string;
         payload?: any;
     }>;
+    backupManifest?: BackupRunManifest;
 };
 export type BackupRunOptions = {
     dryRun?: boolean;
+    full?: boolean;
+    scheduledAt?: Date | string;
     channels?: string[];
     silent?: boolean;
     logInterval?: number;

package/dist/Backup/Jobs/BackupRunJob.js

@@ -14,6 +14,7 @@ const BaseQueueJob_1 = require("../../Queue/BaseQueueJob");
 const BackupManager_1 = require("../BackupManager");
 class BackupRunJob extends BaseQueueJob_1.BaseQueueJob {
     handle(job) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const backupKey = job && job.payload ? job.payload.backupKey : null;
             if (!backupKey || typeof backupKey !== "string") {
@@ -22,6 +23,8 @@ class BackupRunJob extends BaseQueueJob_1.BaseQueueJob {
             this.log(`Starting backup '${backupKey}'`);
             const result = yield new BackupManager_1.BackupManager().run(backupKey, {
                 channels: job.payload.channels,
+                full: job.payload.full === true,
+                scheduledAt: (_a = job.automation_execution) === null || _a === void 0 ? void 0 : _a.scheduled_at,
                 log: (message, payload) => this.log(message, payload),
             });
             this.log(`Backup '${backupKey}' finished`, {

package/dist/Backup/OutputDrivers/BaseBackupOutputDriver.d.ts

@@ -1,4 +1,4 @@
-import { BackupArtifact, BackupCleanupOptions, BackupCleanupResult, BackupOutputConfig, BackupOutputResult, BackupRetentionConfig } from "../BackupTypes";
+import { BackupArtifact, BackupCleanupOptions, BackupCleanupResult, BackupCleanupEntry, BackupOutputConfig, BackupOutputResult, BackupRetentionConfig } from "../BackupTypes";
 export type BackupOutputDriverContext = {
     backupKey: string;
     backupId: string;
@@ -8,4 +8,7 @@ export type BackupOutputDriverContext = {
 export interface BaseBackupOutputDriver {
     write(artifact: BackupArtifact, output: BackupOutputConfig, context: BackupOutputDriverContext): Promise<BackupOutputResult>;
     cleanup(output: BackupOutputConfig, context: BackupOutputDriverContext, options?: BackupCleanupOptions): Promise<BackupCleanupResult>;
+    listArtifacts?(output: BackupOutputConfig, context: BackupOutputDriverContext): Promise<BackupCleanupEntry[]> | BackupCleanupEntry[];
+    readManifest?(output: BackupOutputConfig, entry: BackupCleanupEntry, context: BackupOutputDriverContext): Promise<any> | any;
+    downloadArtifact?(output: BackupOutputConfig, entry: BackupCleanupEntry, targetPath: string, context: BackupOutputDriverContext): Promise<string> | string;
 }

package/dist/Backup/OutputDrivers/LocalBackupOutputDriver.d.ts

@@ -2,11 +2,18 @@ import { BackupArtifact, BackupCleanupEntry, BackupCleanupOptions, BackupCleanup
 import { BaseBackupOutputDriver, BackupOutputDriverContext } from "./BaseBackupOutputDriver";
 type LocalBackupEntry = BackupCleanupEntry & {
     manifestPath?: string;
+    payload?: any;
 };
 export declare class LocalBackupOutputDriver implements BaseBackupOutputDriver {
     private outputPath;
+    private targetDir;
+    private listDirs;
     write(artifact: BackupArtifact, output: BackupOutputConfig, context: BackupOutputDriverContext): Promise<BackupOutputResult>;
+    listArtifacts(output: BackupOutputConfig, context: BackupOutputDriverContext): LocalBackupEntry[];
     list(output: BackupOutputConfig, context: BackupOutputDriverContext): LocalBackupEntry[];
+    readManifest(output: BackupOutputConfig, entry: LocalBackupEntry): any;
+    downloadArtifact(output: BackupOutputConfig, entry: LocalBackupEntry, targetPath: string): string;
+    private protectIncrementalChains;
     cleanup(output: BackupOutputConfig, context: BackupOutputDriverContext, options?: BackupCleanupOptions): Promise<BackupCleanupResult>;
 }
 export {};