@datatruck/cli 0.27.0 → 0.29.0

package/SessionManager/BackupSessionManager.js

@@ -1,218 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackupSessionManager = void 0;
-const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
-const ObjectVault_1 = require("../utils/ObjectVault");
-const SessionManagerAbstract_1 = __importDefault(require("./SessionManagerAbstract"));
-class BackupSessionManager extends SessionManagerAbstract_1.default {
-    sessionVault = new ObjectVault_1.ObjectVault();
-    taskVault = new ObjectVault_1.ObjectVault();
-    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(data) {
-        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
-        this.stopDelayedProgress();
-        for (const driver of drivers) {
-            await driver.onEnd(data);
-        }
-    }
-    async alter(data) {
-        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
-        const write = async () => {
-            for (const driver of drivers) {
-                await driver.onWrite(data);
-            }
-        };
-        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
-            !this.checkProgress(data.data.progress?.relative?.description)) {
-            this.delayProgress(write);
-        }
-        else {
-            this.stopDelayedProgress();
-            await write();
-        }
-        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/SessionManager/RestoreSessionManager.d.ts

@@ -1,47 +0,0 @@
-import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction";
-import { RestoreSessionEntity } from "../Entity/RestoreSessionEntity";
-import { RestoreSessionRepositoryEntity } from "../Entity/RestoreSessionRepositoryEntity";
-import { RestoreSessionTaskEntity } from "../Entity/RestoreSessionTaskEntity";
-import { WriteDataType } from "../SessionDriver/SessionDriverAbstract";
-import { ObjectVault } from "../utils/ObjectVault";
-import { Progress } from "../utils/progress";
-import SessionManagerAbstract from "./SessionManagerAbstract";
-export declare class RestoreSessionManager extends SessionManagerAbstract {
-    sessionVault: ObjectVault<RestoreSessionEntity>;
-    repositoryVault: ObjectVault<RestoreSessionRepositoryEntity>;
-    taskVault: ObjectVault<RestoreSessionTaskEntity>;
-    protected lastProgressDate: number | undefined;
-    protected lastRelativeProgressDescription: string | null | undefined;
-    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: {
-        id: number;
-        progress: Progress;
-    }): Promise<number>;
-    endTask(input: Pick<RestoreSessionTaskEntity, "id" | "error">): Promise<number>;
-    progressRepository(input: {
-        id: number;
-        progress: Progress;
-    }): Promise<number>;
-    endRepository(input: Pick<RestoreSessionRepositoryEntity, "id" | "error">): Promise<number>;
-}

package/SessionManager/RestoreSessionManager.js

@@ -1,218 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestoreSessionManager = void 0;
-const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
-const ObjectVault_1 = require("../utils/ObjectVault");
-const SessionManagerAbstract_1 = __importDefault(require("./SessionManagerAbstract"));
-class RestoreSessionManager extends SessionManagerAbstract_1.default {
-    sessionVault = new ObjectVault_1.ObjectVault();
-    repositoryVault = new ObjectVault_1.ObjectVault();
-    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 ?? [])];
-        this.stopDelayedProgress();
-        for (const driver of drivers) {
-            await driver.onEnd();
-        }
-    }
-    async alter(data) {
-        const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
-        const write = async () => {
-            for (const driver of drivers) {
-                await driver.onWrite(data);
-            }
-        };
-        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
-            !this.checkProgress(data.data.progress?.relative?.description)) {
-            this.delayProgress(write);
-        }
-        else {
-            this.stopDelayedProgress();
-            await write();
-        }
-        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;

package/SessionManager/SessionManagerAbstract.d.ts

@@ -1,18 +0,0 @@
-/// <reference types="node" />
-import { SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
-export type OptionsType = {
-    driver: SessionDriverAbstract;
-    altDrivers?: SessionDriverAbstract[];
-    progressInterval?: number;
-    verbose?: boolean;
-};
-export default abstract class SessionManagerAbstract {
-    readonly options: OptionsType;
-    protected lastProgressDate: number | undefined;
-    protected lastRelativeProgressDescription: string | null | undefined;
-    protected progressTimeout: ReturnType<typeof setTimeout> | undefined;
-    constructor(options: OptionsType);
-    protected stopDelayedProgress(): void;
-    protected delayProgress(cb: () => Promise<any>): void;
-    protected checkProgress(description: string | null | undefined): boolean;
-}

package/SessionManager/SessionManagerAbstract.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class SessionManagerAbstract {
-    options;
-    lastProgressDate;
-    lastRelativeProgressDescription;
-    progressTimeout;
-    constructor(options) {
-        this.options = options;
-    }
-    stopDelayedProgress() {
-        clearTimeout(this.progressTimeout);
-        this.progressTimeout = undefined;
-    }
-    delayProgress(cb) {
-        clearTimeout(this.progressTimeout);
-        this.progressTimeout = setTimeout(async () => {
-            this.progressTimeout = undefined;
-            await cb();
-        }, 1500);
-    }
-    checkProgress(description) {
-        const progressInterval = this.options.progressInterval;
-        if (progressInterval) {
-            const skip = this.lastProgressDate &&
-                description === this.lastRelativeProgressDescription &&
-                Date.now() - this.lastProgressDate < progressInterval;
-            if (skip)
-                return false;
-            this.lastProgressDate = Date.now();
-            this.lastRelativeProgressDescription = description;
-        }
-        return true;
-    }
-}
-exports.default = SessionManagerAbstract;

package/migrations/001-initial.sql

@@ -1,98 +0,0 @@
---------------------------------------------------------------------------------
--- Up
---------------------------------------------------------------------------------
-
-CREATE TABLE "backup_session" (
-	"id"	INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-	"creationDate"	TEXT NOT NULL,
-	"updatingDate"	TEXT,
-
-	"startDate"	TEXT,
-	"endDate"	TEXT,
-	"state"	TEXT,
-	"error"	TEXT,
-	"progress" TEXT,
-
-	"snapshotId"	TEXT NOT NULL,
-	"packageName"	TEXT NOT NULL,
-	-- "componentName"	TEXT NOT NULL,
-	"tags"	TEXT
-);
-
-CREATE TABLE "backup_session_task" (
-	"id"	INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-	"creationDate"	TEXT NOT NULL,
-	"updatingDate"	TEXT,
-
-	"startDate"	TEXT,
-	"endDate"	TEXT,
-	"state"	TEXT,
-	"error"	TEXT,
-	"progress" TEXT,
-
-	"sessionId"	INTEGER NOT NULL,
-	"taskName"	TEXT NOT NULL
-);
-
-CREATE TABLE "backup_session_repository" (
-	"id"	INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-	"creationDate"	TEXT NOT NULL,
-	"updatingDate"	TEXT,
-
-	"startDate"	TEXT,
-	"endDate"	TEXT,
-	"state"	TEXT,
-	"error"	TEXT,
-	"progress" TEXT,
-
-	"sessionId"	INTEGER NOT NULL,
-	"repositoryName"	TEXT NOT NULL,
-	"repositoryType"	TEXT NOT NULL
-);
-
-CREATE TABLE "restore_session" (
-	"id"	INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-	"creationDate"	TEXT NOT NULL,
-	"updatingDate"	TEXT,
-
-	"startDate"	TEXT,
-	"endDate"	TEXT,
-	"state"	TEXT,
-	"error"	TEXT,
-	"progress" TEXT,
-
-	"snapshotId"	TEXT NOT NULL,
-	"packageName"	TEXT NOT NULL -- ,
-	-- "componentName"	TEXT NOT NULL
-);
-
-CREATE TABLE "restore_session_task" (
-	"id"	INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-	"creationDate"	TEXT NOT NULL,
-	"updatingDate"	TEXT,
-
-	"startDate"	TEXT,
-	"endDate"	TEXT,
-	"state"	TEXT,
-	"error"	TEXT,
-	"progress" TEXT,
-
-	"sessionId"	INTEGER NOT NULL,
-	"taskName"	TEXT NOT NULL
-);
-
-CREATE TABLE "restore_session_repository" (
-	"id"	INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-	"creationDate"	TEXT NOT NULL,
-	"updatingDate"	TEXT,
-
-	"startDate"	TEXT,
-	"endDate"	TEXT,
-	"state"	TEXT,
-	"error"	TEXT,
-	"progress" TEXT,
-
-	"sessionId"	INTEGER NOT NULL,
-	"repositoryName"	TEXT NOT NULL,
-	"repositoryType"	TEXT NOT NULL
-);

package/utils/entity.d.ts

@@ -1,4 +0,0 @@
-export declare function makeTableSelector<T>(tableName: string): {
-    (name?: keyof T): string;
-    toString: any;
-};

package/utils/entity.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTableSelector = void 0;
-function makeTableSelector(tableName) {
-    const q = (value) => `\`${value}\``;
-    const cb = (name) => `${q(tableName)}${name ? `.${q(name)}` : ""}`;
-    cb.toString = cb;
-    return cb;
-}
-exports.makeTableSelector = makeTableSelector;