@datatruck/cli 0.26.2 → 0.28.0

package/Factory/CommandFactory.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandConstructorFactory = exports.makeParseLog = exports.runAndParse = exports.createActionInterface = exports.exec = exports.CommandFactory = exports.CommandEnum = void 0;
+exports.CommandConstructorFactory = exports.createActionInterface = exports.exec = exports.CommandFactory = exports.CommandEnum = void 0;
 const BackupCommand_1 = require("../Command/BackupCommand");
-const BackupSessionsCommand_1 = require("../Command/BackupSessionsCommand");
 const CleanCacheCommand_1 = require("../Command/CleanCacheCommand");
 const ConfigCommand_1 = require("../Command/ConfigCommand");
+const CopyCommand_1 = require("../Command/CopyCommand");
 const InitCommand_1 = require("../Command/InitCommand");
 const PruneCommand_1 = require("../Command/PruneCommand");
 const RestoreCommand_1 = require("../Command/RestoreCommand");
-const RestoreSessionsCommand_1 = require("../Command/RestoreSessionsCommand");
 const SnapshotsCommand_1 = require("../Command/SnapshotsCommand");
+const StartServerCommand_1 = require("../Command/StartServerCommand");
 const AppError_1 = require("../Error/AppError");
+const stream_1 = require("stream");
 var CommandEnum;
 (function (CommandEnum) {
     CommandEnum["config"] = "config";
@@ -18,70 +19,48 @@ var CommandEnum;
     CommandEnum["snapshots"] = "snapshots";
     CommandEnum["prune"] = "prune";
     CommandEnum["backup"] = "backup";
-    CommandEnum["backupSessions"] = "backup-sessions";
     CommandEnum["restore"] = "restore";
-    CommandEnum["restoreSessions"] = "restore-sessions";
+    CommandEnum["copy"] = "copy";
     CommandEnum["cleanCache"] = "clean-cache";
+    CommandEnum["startServer"] = "start-server";
 })(CommandEnum || (exports.CommandEnum = CommandEnum = {}));
-function CommandFactory(type, globalOptions, options) {
+function CommandFactory(type, globalOptions, options, streams) {
     const constructor = CommandConstructorFactory(type);
-    return new constructor(globalOptions, options);
+    return new constructor(globalOptions, options, streams);
 }
 exports.CommandFactory = CommandFactory;
-async function exec(type, globalOptions, options) {
-    return await CommandFactory(type, globalOptions, options).onExec();
+async function exec(type, globalOptions, options, streams) {
+    return await CommandFactory(type, globalOptions, options, streams).onExec();
 }
 exports.exec = exec;
 function createActionInterface(globalOptions) {
     const object = {};
     for (const type of Object.values(CommandEnum)) {
         object[type] = async (options) => {
-            const run = () => exec(type, { ...globalOptions, outputFormat: "json", verbose: 1 }, options);
-            let exitCode;
-            let log;
-            if (["config", "init", "snapshots"].includes(type)) {
-                const parsed = await runAndParse(type, run);
-                exitCode = parsed.exitCode;
-                log = parsed.log;
+            let stdoutData = "";
+            const stdout = new stream_1.Writable({
+                write(chunk, encoding, callback) {
+                    stdoutData += chunk.toString();
+                    process.stdout.write(chunk, encoding, callback);
+                },
+            }).on("data", (chunk) => (stdoutData += chunk.toString()));
+            const end = () => !stdout.closed &&
+                new Promise((resolve) => stdout.end().on("close", resolve));
+            try {
+                const exitCode = await exec(type, { ...globalOptions, outputFormat: "json", verbose: 1 }, options, { stdout });
+                if (exitCode !== 0)
+                    throw new Error(`Invalid exit code: ${exitCode}`);
+                await end();
+                return JSON.parse(stdoutData);
             }
-            else {
-                exitCode = await run();
+            finally {
+                await end();
             }
-            if (exitCode !== 0)
-                throw new Error(`Invalid exit code: ${exitCode}`);
-            return log;
         };
     }
     return object;
 }
 exports.createActionInterface = createActionInterface;
-async function runAndParse(type, run) {
-    const parseLog = makeParseLog(type);
-    try {
-        const exitCode = await run();
-        return { exitCode, log: parseLog() };
-    }
-    catch (error) {
-        try {
-            parseLog();
-        }
-        catch (_) { }
-        throw error;
-    }
-}
-exports.runAndParse = runAndParse;
-function makeParseLog(type) {
-    const data = [];
-    const consoleLog = console.log;
-    console.log = console.info = (...items) => {
-        data.push(...items);
-    };
-    return function parseLog() {
-        console.log = console.info = consoleLog;
-        return JSON.parse(data.flat().join("\n"));
-    };
-}
-exports.makeParseLog = makeParseLog;
 function CommandConstructorFactory(type) {
     if (type === CommandEnum.config) {
         return ConfigCommand_1.ConfigCommand;
@@ -98,18 +77,18 @@ function CommandConstructorFactory(type) {
     else if (type === CommandEnum.backup) {
         return BackupCommand_1.BackupCommand;
     }
-    else if (type === CommandEnum.backupSessions) {
-        return BackupSessionsCommand_1.BackupSessionsCommand;
-    }
     else if (type === CommandEnum.restore) {
         return RestoreCommand_1.RestoreCommand;
     }
-    else if (type === CommandEnum.restoreSessions) {
-        return RestoreSessionsCommand_1.RestoreSessionsCommand;
+    else if (type === CommandEnum.copy) {
+        return CopyCommand_1.CopyCommand;
     }
     else if (type === CommandEnum.cleanCache) {
         return CleanCacheCommand_1.CleanCacheCommand;
     }
+    else if (type === CommandEnum.startServer) {
+        return StartServerCommand_1.StartServerCommand;
+    }
     else {
         throw new AppError_1.AppError(`Invalid command type: ${type}`);
     }

package/Factory/RepositoryFactory.d.ts

@@ -1,3 +1,3 @@
 import type { RepositoryConfigType } from "../Config/RepositoryConfig";
 import type { RepositoryAbstract } from "../Repository/RepositoryAbstract";
-export declare function RepositoryFactory(repository: RepositoryConfigType): RepositoryAbstract<any>;
+export declare function createRepo(repository: RepositoryConfigType): RepositoryAbstract<any>;

package/Factory/RepositoryFactory.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RepositoryFactory = void 0;
+exports.createRepo = void 0;
 const AppError_1 = require("../Error/AppError");
 const DatatruckRepository_1 = require("../Repository/DatatruckRepository");
 const GitRepository_1 = require("../Repository/GitRepository");
 const ResticRepository_1 = require("../Repository/ResticRepository");
-function RepositoryFactory(repository) {
+function createRepo(repository) {
     const type = repository.type;
     if (type === GitRepository_1.gitRepositoryName) {
         return new GitRepository_1.GitRepository(repository);
@@ -20,4 +20,4 @@ function RepositoryFactory(repository) {
         throw new AppError_1.AppError(`Invalid repository type: ${type}`);
     }
 }
-exports.RepositoryFactory = RepositoryFactory;
+exports.createRepo = createRepo;

package/Factory/TaskFactory.d.ts

@@ -1,3 +1,3 @@
 import { TaskConfigType } from "../Config/TaskConfig";
 import type { TaskAbstract } from "../Task/TaskAbstract";
-export declare function TaskFactory(task: TaskConfigType): TaskAbstract;
+export declare function createTask(task: TaskConfigType): TaskAbstract;

package/Factory/TaskFactory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskFactory = void 0;
+exports.createTask = void 0;
 const AppError_1 = require("../Error/AppError");
 const GitTask_1 = require("../Task/GitTask");
 const MariadbTask_1 = require("../Task/MariadbTask");
@@ -8,7 +8,7 @@ const MssqlTask_1 = require("../Task/MssqlTask");
 const MysqlDumpTask_1 = require("../Task/MysqlDumpTask");
 const PostgresqlDumpTask_1 = require("../Task/PostgresqlDumpTask");
 const ScriptTask_1 = require("../Task/ScriptTask");
-function TaskFactory(task) {
+function createTask(task) {
     if (task.name === GitTask_1.gitTaskName) {
         return new GitTask_1.GitTask(task.config ?? {});
     }
@@ -31,4 +31,4 @@ function TaskFactory(task) {
         throw new AppError_1.AppError(`Invalid task name: ${task["name"]}`);
     }
 }
-exports.TaskFactory = TaskFactory;
+exports.createTask = createTask;

package/Repository/DatatruckRepository.d.ts

@@ -1,5 +1,5 @@
 import { CompressOptions } from "../utils/tar";
-import { RepositoryAbstract, BackupDataType, InitDataType, RestoreDataType, SnapshotsDataType, SnapshotResultType, PruneDataType, CopyBackupType } from "./RepositoryAbstract";
+import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
 import type { JSONSchema7 } from "json-schema";
 export type MetaDataType = {
     id: string;
@@ -11,10 +11,11 @@ export type MetaDataType = {
     size: number;
     tarStats?: Record<string, {
         files: number;
+        size: number;
     }>;
 };
 export type DatatruckRepositoryConfigType = {
-    outPath: string;
+    backend: string;
     compress?: boolean | CompressOptions;
 };
 type PackObject = {
@@ -33,10 +34,11 @@ export declare const datatruckRepositoryDefinition: JSONSchema7;
 export declare const datatruckPackageRepositoryDefinition: JSONSchema7;
 export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRepositoryConfigType> {
     static zipBasenameTpl: string;
-    static buildSnapshotName(data: {
-        snapshotId: string;
-        snapshotDate: string;
-        packageName: string;
+    static buildSnapshotName(snapshot: {
+        id: string;
+        date: string;
+    }, pkg: {
+        name: string;
     }): string;
     static parseSnapshotName(name: string): {
         snapshotDate: string;
@@ -44,15 +46,14 @@ export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRep
         snapshotShortId: string;
         sourcePath: string;
     } | null;
-    protected buildMetaPath(snapshotName: string, packageName: string): string;
-    static parseMetaData(path: string): Promise<MetaDataType | undefined>;
-    static stringifyMetaData(data: MetaDataType): string;
-    onGetSource(): string;
-    onInit(data: InitDataType): Promise<void>;
-    onPrune(data: PruneDataType): Promise<void>;
-    onSnapshots(data: SnapshotsDataType): Promise<SnapshotResultType[]>;
-    onBackup(data: BackupDataType<DatatruckPackageRepositoryConfigType>): Promise<void>;
-    onCopyBackup(data: CopyBackupType<DatatruckRepositoryConfigType>): Promise<void>;
-    onRestore(data: RestoreDataType<DatatruckPackageRepositoryConfigType>): Promise<void>;
+    static parseMetaData(data: string): Promise<MetaDataType>;
+    getSource(): string;
+    fetchDiskStats(config: DatatruckRepositoryConfigType): Promise<import("../utils/fs").DiskStats>;
+    init(data: RepoInitData): Promise<void>;
+    prune(data: RepoPruneData): Promise<void>;
+    fetchSnapshots(data: RepoFetchSnapshotsData): Promise<Snapshot[]>;
+    backup(data: RepoBackupData<DatatruckPackageRepositoryConfigType>): Promise<void>;
+    copy(data: RepoCopyData<DatatruckRepositoryConfigType>): Promise<void>;
+    restore(data: RepoRestoreData<DatatruckPackageRepositoryConfigType>): Promise<void>;
 }
 export {};