@datatruck/cli 0.0.1

package/lib/SessionDriver/SqliteSessionDriver.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSessionDriver = void 0;
+const EntityDecorator_1 = require("../Decorator/EntityDecorator");
+const BackupSessionEntity_1 = require("../Entity/BackupSessionEntity");
+const BackupSessionRepositoryEntity_1 = require("../Entity/BackupSessionRepositoryEntity");
+const RestoreSessionEntity_1 = require("../Entity/RestoreSessionEntity");
+const RestoreSessionRepositoryEntity_1 = require("../Entity/RestoreSessionRepositoryEntity");
+const cli_util_1 = require("../util/cli-util");
+const entity_util_1 = require("../util/entity-util");
+const process_util_1 = require("../util/process-util");
+const SessionDriverAbstract_1 = require("./SessionDriverAbstract");
+const assert_1 = require("assert");
+const os_1 = require("os");
+const path_1 = require("path");
+const sqlite_1 = require("sqlite");
+const sqlite3_1 = __importDefault(require("sqlite3"));
+class SqliteSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract {
+    constructor() {
+        super(...arguments);
+        this.idMap = {};
+    }
+    async onInit() {
+        this.db = await (0, sqlite_1.open)({
+            filename: process.env["DATATRUCK_SQLITE_DB"] ??
+                (0, path_1.join)((0, os_1.homedir)(), "datatruck.sqlite"),
+            driver: sqlite3_1.default.Database,
+        });
+        await this.db.migrate({
+            migrationsPath: __dirname + "/../../migrations",
+        });
+    }
+    buildInsertStm(tableName, values) {
+        const keys = Object.keys(values);
+        const columnNames = keys.map((v) => `\`${v}\``).join(", ");
+        const paramNames = keys.map((v) => `:${v}`).join(", ");
+        return `INSERT INTO ${tableName} (${columnNames}) VALUES (${paramNames})`;
+    }
+    buildUpdateStm(tableName, values, pkColumnName = "id") {
+        const set = Object.keys(values)
+            .filter((v) => v !== pkColumnName)
+            .map((v) => `\`${v}\` = :${v}`)
+            .join(", ");
+        return `UPDATE ${tableName} SET ${set} WHERE ${pkColumnName} = :${pkColumnName}`;
+    }
+    async exec(query, cb) {
+        if (this.options.verbose) {
+            (0, cli_util_1.logExec)("query");
+            (0, process_util_1.logExecStdout)({ data: query, lineSalt: true });
+        }
+        const result = await cb();
+        if (this.options.verbose)
+            (0, process_util_1.logExecStdout)({ data: JSON.stringify(result, null, 2), lineSalt: true });
+        return result;
+    }
+    async onRead(data, type) {
+        const sessionMeta = (0, EntityDecorator_1.EntityDecoratorHandler)(type === SessionDriverAbstract_1.EntityEnum.BackupSession
+            ? BackupSessionEntity_1.BackupSessionEntity
+            : RestoreSessionEntity_1.RestoreSessionEntity);
+        const sessionRepositoryMeta = (0, EntityDecorator_1.EntityDecoratorHandler)(type === SessionDriverAbstract_1.EntityEnum.BackupSession
+            ? BackupSessionRepositoryEntity_1.BackupSessionRepositoryEntity
+            : RestoreSessionRepositoryEntity_1.RestoreSessionRepositoryEntity);
+        const sessionTable = (0, entity_util_1.makeTableSelector)(sessionMeta.get().tableName);
+        const repoTable = (0, entity_util_1.makeTableSelector)(sessionRepositoryMeta.get().tableName);
+        const where = {};
+        if (data.packageNames)
+            where[sessionTable("packageName")] = data.packageNames;
+        if (data.repositoryNames)
+            where[repoTable("repositoryName")] = data.repositoryNames;
+        if (data.packageNames)
+            where[sessionTable("packageName")] = data.packageNames;
+        if (type === SessionDriverAbstract_1.EntityEnum.BackupSession && data.tags)
+            data.tags.map((tag) => `(',' || ${sessionTable("tags")} || ',') LIKE '%,${tag},%' `);
+        let query = `
+      SELECT
+        ${sessionTable("id")},
+        ${sessionTable("snapshotId")},
+        ${sessionTable("creationDate")},
+        ${sessionTable("state")},
+        ${sessionTable("packageName")},
+        ${repoTable("repositoryName")},
+        ${repoTable("repositoryType")},
+        COALESCE(${repoTable("error")}, ${sessionTable("error")}) AS error
+      FROM 
+        ${sessionTable}
+      LEFT JOIN ${repoTable} ON
+        ${repoTable("sessionId")} = ${sessionTable("id")}
+      ORDER BY
+        ${sessionTable("id")} DESC
+    `;
+        if (data.limit)
+            query += `LIMIT ${data.limit}`;
+        return await this.exec(query, async () => await this.db.all(query));
+    }
+    setMapId(entity, id, value) {
+        if (!this.idMap[entity])
+            this.idMap[entity] = {};
+        const map = this.idMap[entity];
+        (0, assert_1.ok)(map);
+        map[id] = value;
+    }
+    getMapId(entity, id) {
+        const result = this.idMap[entity]?.[id];
+        if (!result)
+            throw new Error(`Entity id not found: ${entity}-${id}`);
+        return result;
+    }
+    static getEntityTable(entity) {
+        return {
+            [SessionDriverAbstract_1.EntityEnum.BackupSession]: "backup_session",
+            [SessionDriverAbstract_1.EntityEnum.BackupSessionRepository]: "backup_session_repository",
+            [SessionDriverAbstract_1.EntityEnum.BackupSessionTask]: "backup_session_task",
+            [SessionDriverAbstract_1.EntityEnum.RestoreSession]: "restore_session",
+            [SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository]: "restore_session_repository",
+            [SessionDriverAbstract_1.EntityEnum.RestoreSessionTask]: "restore_session_task",
+        }[entity];
+    }
+    static getParentEntity(entity) {
+        return {
+            [SessionDriverAbstract_1.EntityEnum.BackupSession]: SessionDriverAbstract_1.EntityEnum.BackupSession,
+            [SessionDriverAbstract_1.EntityEnum.BackupSessionRepository]: SessionDriverAbstract_1.EntityEnum.BackupSession,
+            [SessionDriverAbstract_1.EntityEnum.BackupSessionTask]: SessionDriverAbstract_1.EntityEnum.BackupSession,
+            [SessionDriverAbstract_1.EntityEnum.RestoreSession]: SessionDriverAbstract_1.EntityEnum.RestoreSession,
+            [SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository]: SessionDriverAbstract_1.EntityEnum.RestoreSession,
+            [SessionDriverAbstract_1.EntityEnum.RestoreSessionTask]: SessionDriverAbstract_1.EntityEnum.RestoreSession,
+        }[entity];
+    }
+    async onWrite(data) {
+        const tableName = SqliteSessionDriver.getEntityTable(data.entity);
+        let stm;
+        let object = data.data;
+        const id = object.id;
+        if (data.action === SessionDriverAbstract_1.ActionEnum.Init) {
+            // @ts-expect-error
+            object = { ...object, id: null };
+            stm = this.buildInsertStm(tableName, object);
+        }
+        else {
+            object = { ...object, id: this.getMapId(data.entity, id) };
+            if ("sessionId" in object) {
+                const parentEntity = SqliteSessionDriver.getParentEntity(data.entity);
+                object.sessionId = this.getMapId(parentEntity, object.sessionId);
+            }
+            stm = this.buildUpdateStm(tableName, object);
+        }
+        const params = Object.keys(object).reduce((result, name) => {
+            result[`:${name}`] = object[name];
+            return result;
+        }, {});
+        try {
+            const result = await this.exec(stm, async () => await this.db.run(stm, params));
+            if (data.action === SessionDriverAbstract_1.ActionEnum.Init &&
+                typeof result.lastID === "number") {
+                this.setMapId(data.entity, id, result.lastID);
+            }
+        }
+        catch (error) {
+            console.error({
+                query: stm,
+                params: params,
+            });
+            throw new Error(error.message);
+        }
+    }
+}
+exports.SqliteSessionDriver = SqliteSessionDriver;

package/lib/SessionManager/BackupSessionManager.d.ts

@@ -0,0 +1,44 @@
+import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction";
+import { BackupSessionEntity } from "../Entity/BackupSessionEntity";
+import { BackupSessionRepositoryEntity } from "../Entity/BackupSessionRepositoryEntity";
+import { BackupSessionTaskEntity } from "../Entity/BackupSessionTaskEntity";
+import { WriteDataType, SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
+import { ObjectVault } from "../util/ObjectVault";
+export declare type OptionsType = {
+    driver: SessionDriverAbstract;
+    altDrivers?: SessionDriverAbstract[];
+    verbose?: boolean;
+};
+export declare class BackupSessionManager {
+    readonly options: OptionsType;
+    sessionVault: ObjectVault<BackupSessionEntity>;
+    taskVault: ObjectVault<BackupSessionTaskEntity>;
+    repositoryVault: ObjectVault<BackupSessionRepositoryEntity>;
+    constructor(options: OptionsType);
+    findId(data: {
+        packageName: string;
+    }): number;
+    findTaskId(data: {
+        packageName: string;
+        taskName: string;
+    }): number;
+    findRepositoryId(data: {
+        packageName: string;
+        repositoryName: string;
+    }): number;
+    initDrivers(): Promise<void>;
+    endDrivers(): Promise<void>;
+    protected alter(data: WriteDataType): Promise<number>;
+    readAll(options: BackupSessionsActionOptionsType): Promise<import("../SessionDriver/SessionDriverAbstract").ReadResultType[]>;
+    init(input: Pick<BackupSessionEntity, "packageName" | "snapshotId" | "tags">): Promise<number>;
+    initTask(input: Pick<BackupSessionTaskEntity, "sessionId" | "taskName">): Promise<number>;
+    initRepository(input: Pick<BackupSessionRepositoryEntity, "repositoryName" | "sessionId" | "repositoryType">): Promise<number>;
+    start(input: Pick<BackupSessionEntity, "id">): Promise<number>;
+    end(input: Pick<BackupSessionEntity, "id" | "error">): Promise<number>;
+    startTask(input: Pick<BackupSessionTaskEntity, "id">): Promise<number>;
+    progressTask(input: Pick<BackupSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    endTask(input: Pick<BackupSessionTaskEntity, "id" | "error">): Promise<number>;
+    startRepository(input: Pick<BackupSessionRepositoryEntity, "id">): Promise<number>;
+    progressRepository(input: Pick<BackupSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    endRepository(input: Pick<BackupSessionRepositoryEntity, "id" | "error">): Promise<number>;
+}

package/lib/SessionManager/BackupSessionManager.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupSessionManager = void 0;
+const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
+const ObjectVault_1 = require("../util/ObjectVault");
+class BackupSessionManager {
+    constructor(options) {
+        this.options = options;
+        this.sessionVault = new ObjectVault_1.ObjectVault();
+        this.taskVault = new ObjectVault_1.ObjectVault();
+        this.repositoryVault = new ObjectVault_1.ObjectVault();
+    }
+    findId(data) {
+        return this.sessionVault.getId([data.packageName]);
+    }
+    findTaskId(data) {
+        const sessionId = this.findId(data);
+        return this.taskVault.getId([sessionId, data.taskName]);
+    }
+    findRepositoryId(data) {
+        const sessionId = this.findId(data);
+        return this.repositoryVault.getId([sessionId, data.repositoryName]);
+    }
+    async initDrivers() {
+        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        for (const driver of drivers) {
+            await driver.onInit();
+        }
+    }
+    async endDrivers() {
+        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        for (const driver of drivers) {
+            await driver.onEnd();
+        }
+    }
+    async alter(data) {
+        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        for (const driver of drivers) {
+            await driver.onWrite(data);
+        }
+        return data.data.id;
+    }
+    async readAll(options) {
+        return this.options.driver?.onRead(options, SessionDriverAbstract_1.EntityEnum.BackupSession);
+    }
+    async init(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Init,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSession,
+            data: this.sessionVault.add({
+                keys: [input.packageName],
+                handler: (id) => ({
+                    ...input,
+                    id: id,
+                    creationDate: new Date().toISOString(),
+                    state: null,
+                }),
+            }),
+        });
+    }
+    async initTask(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Init,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSessionTask,
+            sessionData: this.sessionVault.get(input.sessionId),
+            data: this.taskVault.add({
+                keys: [input.sessionId, input.taskName],
+                handler: (id) => ({
+                    ...input,
+                    id: id,
+                    creationDate: new Date().toISOString(),
+                    state: null,
+                }),
+            }),
+        });
+    }
+    async initRepository(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Init,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSessionRepository,
+            sessionData: this.sessionVault.get(input.sessionId),
+            data: this.repositoryVault.add({
+                keys: [input.sessionId, input.repositoryName],
+                handler: (id) => ({
+                    ...input,
+                    id: id,
+                    creationDate: new Date().toISOString(),
+                    state: null,
+                }),
+            }),
+        });
+    }
+    async start(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Start,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSession,
+            data: {
+                ...this.sessionVault.get(input.id),
+                ...input,
+                startDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+                state: "started",
+            },
+        });
+    }
+    async end(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.End,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSession,
+            data: {
+                ...this.sessionVault.get(input.id),
+                ...input,
+                endDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+                state: "ended",
+            },
+        });
+    }
+    async startTask(input) {
+        const object = this.taskVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Start,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSessionTask,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                state: "started",
+                startDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+            },
+        });
+    }
+    async progressTask(input) {
+        const object = this.taskVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Progress,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSessionTask,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                updatingDate: new Date().toISOString(),
+            },
+        });
+    }
+    async endTask(input) {
+        const object = this.taskVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.End,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSessionTask,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                endDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+                state: "ended",
+            },
+        });
+    }
+    async startRepository(input) {
+        const object = this.repositoryVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Start,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSessionRepository,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                startDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+                state: "started",
+            },
+        });
+    }
+    async progressRepository(input) {
+        const object = this.repositoryVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Progress,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSessionRepository,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                updatingDate: new Date().toISOString(),
+            },
+        });
+    }
+    async endRepository(input) {
+        const object = this.repositoryVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.End,
+            entity: SessionDriverAbstract_1.EntityEnum.BackupSessionRepository,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                endDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+                state: "ended",
+            },
+        });
+    }
+}
+exports.BackupSessionManager = BackupSessionManager;

package/lib/SessionManager/RestoreSessionManager.d.ts

@@ -0,0 +1,44 @@
+import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction";
+import { RestoreSessionEntity } from "../Entity/RestoreSessionEntity";
+import { RestoreSessionRepositoryEntity } from "../Entity/RestoreSessionRepositoryEntity";
+import { RestoreSessionTaskEntity } from "../Entity/RestoreSessionTaskEntity";
+import { WriteDataType, SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
+import { ObjectVault } from "../util/ObjectVault";
+export declare type OptionsType = {
+    driver: SessionDriverAbstract;
+    altDrivers?: SessionDriverAbstract[];
+    verbose?: boolean;
+};
+export declare class RestoreSessionManager {
+    readonly options: OptionsType;
+    sessionVault: ObjectVault<RestoreSessionEntity>;
+    repositoryVault: ObjectVault<RestoreSessionRepositoryEntity>;
+    taskVault: ObjectVault<RestoreSessionTaskEntity>;
+    constructor(options: OptionsType);
+    findId(data: {
+        packageName: string;
+    }): number;
+    findTaskId(data: {
+        packageName: string;
+        taskName: string;
+    }): number;
+    findRepositoryId(data: {
+        packageName: string;
+        repositoryName: string;
+    }): number;
+    initDrivers(): Promise<void>;
+    endDrivers(): Promise<void>;
+    protected alter(data: WriteDataType): Promise<number>;
+    readAll(options: BackupSessionsActionOptionsType): Promise<import("../SessionDriver/SessionDriverAbstract").ReadResultType[]>;
+    init(input: Pick<RestoreSessionEntity, "packageName" | "snapshotId">): Promise<number>;
+    initTask(input: Pick<RestoreSessionTaskEntity, "sessionId" | "taskName">): Promise<number>;
+    initRepository(input: Pick<RestoreSessionRepositoryEntity, "sessionId" | "repositoryName" | "repositoryType">): Promise<number>;
+    start(input: Pick<RestoreSessionEntity, "id">): Promise<number>;
+    end(input: Pick<RestoreSessionEntity, "id" | "error">): Promise<number>;
+    startTask(input: Pick<RestoreSessionTaskEntity, "id">): Promise<number>;
+    startRepository(input: Pick<RestoreSessionRepositoryEntity, "id">): Promise<number>;
+    progressTask(input: Pick<RestoreSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    endTask(input: Pick<RestoreSessionTaskEntity, "id" | "error">): Promise<number>;
+    progressRepository(input: Pick<RestoreSessionRepositoryEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    endRepository(input: Pick<RestoreSessionRepositoryEntity, "id" | "error">): Promise<number>;
+}

package/lib/SessionManager/RestoreSessionManager.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestoreSessionManager = void 0;
+const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
+const ObjectVault_1 = require("../util/ObjectVault");
+class RestoreSessionManager {
+    constructor(options) {
+        this.options = options;
+        this.sessionVault = new ObjectVault_1.ObjectVault();
+        this.repositoryVault = new ObjectVault_1.ObjectVault();
+        this.taskVault = new ObjectVault_1.ObjectVault();
+    }
+    findId(data) {
+        return this.sessionVault.getId([data.packageName]);
+    }
+    findTaskId(data) {
+        const sessionId = this.findId(data);
+        return this.taskVault.getId([sessionId, data.taskName]);
+    }
+    findRepositoryId(data) {
+        const sessionId = this.findId(data);
+        return this.repositoryVault.getId([sessionId, data.repositoryName]);
+    }
+    async initDrivers() {
+        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        for (const driver of drivers) {
+            await driver.onInit();
+        }
+    }
+    async endDrivers() {
+        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        for (const driver of drivers) {
+            await driver.onEnd();
+        }
+    }
+    async alter(data) {
+        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        for (const driver of drivers) {
+            await driver.onWrite(data);
+        }
+        return data.data.id;
+    }
+    async readAll(options) {
+        return this.options.driver.onRead(options, SessionDriverAbstract_1.EntityEnum.RestoreSession);
+    }
+    async init(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Init,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSession,
+            data: this.sessionVault.add({
+                keys: [input.packageName],
+                handler: (id) => ({
+                    ...input,
+                    id: id,
+                    creationDate: new Date().toISOString(),
+                    state: null,
+                }),
+            }),
+        });
+    }
+    async initTask(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Init,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSessionTask,
+            sessionData: this.sessionVault.get(input.sessionId),
+            data: this.taskVault.add({
+                keys: [input.sessionId, input.taskName],
+                handler: (id) => ({
+                    ...input,
+                    id: id,
+                    taskName: input.taskName,
+                    creationDate: new Date().toISOString(),
+                    state: null,
+                }),
+            }),
+        });
+    }
+    async initRepository(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Init,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository,
+            sessionData: this.sessionVault.get(input.sessionId),
+            data: this.repositoryVault.add({
+                keys: [input.sessionId, input.repositoryName],
+                handler: (id) => ({
+                    ...input,
+                    id: id,
+                    creationDate: new Date().toISOString(),
+                    state: null,
+                }),
+            }),
+        });
+    }
+    async start(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Start,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSession,
+            data: {
+                ...this.sessionVault.get(input.id),
+                ...input,
+                startDate: new Date().toISOString(),
+                state: "started",
+            },
+        });
+    }
+    async end(input) {
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.End,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSession,
+            data: {
+                ...this.sessionVault.get(input.id),
+                ...input,
+                endDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+                state: "ended",
+            },
+        });
+    }
+    async startTask(input) {
+        const object = this.taskVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Start,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSessionTask,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                state: "started",
+                startDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+            },
+        });
+    }
+    async startRepository(input) {
+        const object = this.repositoryVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Start,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                state: "started",
+                startDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+            },
+        });
+    }
+    async progressTask(input) {
+        const object = this.taskVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Progress,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSessionTask,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                updatingDate: new Date().toISOString(),
+            },
+        });
+    }
+    async endTask(input) {
+        const object = this.taskVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.End,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSessionTask,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                endDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+                state: "ended",
+            },
+        });
+    }
+    async progressRepository(input) {
+        const object = this.repositoryVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.Progress,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                updatingDate: new Date().toISOString(),
+            },
+        });
+    }
+    async endRepository(input) {
+        const object = this.repositoryVault.get(input.id);
+        return await this.alter({
+            action: SessionDriverAbstract_1.ActionEnum.End,
+            entity: SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository,
+            sessionData: this.sessionVault.get(object.sessionId),
+            data: {
+                ...object,
+                ...input,
+                endDate: new Date().toISOString(),
+                updatingDate: new Date().toISOString(),
+                state: "ended",
+            },
+        });
+    }
+}
+exports.RestoreSessionManager = RestoreSessionManager;