@datatruck/cli 0.32.1 → 0.32.3

package/lib/Task/ScriptTask.d.ts

@@ -0,0 +1,30 @@
+import { PackageConfig } from "../Config/PackageConfig";
+import { PreSnapshot } from "../Repository/RepositoryAbstract";
+import { ProcessEnv } from "../utils/process";
+import { SpawnStep } from "../utils/spawnSteps";
+import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
+type NodeData = {
+    dtt: {
+        snapshot: PreSnapshot;
+        package: PackageConfig;
+        snapshotPath: string;
+    };
+};
+export type ScriptTaskConfig = {
+    env?: ProcessEnv;
+    backupSteps: SpawnStep[];
+    restoreSteps: SpawnStep[];
+};
+export declare function scriptTaskCode<Data extends Record<string, any>>(cb: (data: NodeData & Data) => void): string;
+export declare const scriptTaskName = "script";
+export declare class ScriptTask extends TaskAbstract<ScriptTaskConfig> {
+    protected verbose?: boolean;
+    backup(data: TaskBackupData): Promise<{
+        snapshotPath: string;
+    }>;
+    prepareRestore(data: TaskPrepareRestoreData): Promise<{
+        snapshotPath: string;
+    }>;
+    restore(data: TaskRestoreData): Promise<void>;
+}
+export {};

package/lib/Task/ScriptTask.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptTask = exports.scriptTaskName = exports.scriptTaskCode = void 0;
+const spawnSteps_1 = require("../utils/spawnSteps");
+const temp_1 = require("../utils/temp");
+const TaskAbstract_1 = require("./TaskAbstract");
+function scriptTaskCode(cb) {
+    return `(${cb.toString()})(...arguments);`;
+}
+exports.scriptTaskCode = scriptTaskCode;
+exports.scriptTaskName = "script";
+class ScriptTask extends TaskAbstract_1.TaskAbstract {
+    verbose;
+    async backup(data) {
+        const config = this.config;
+        const snapshotPath = data.package.path ??
+            (await (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "backup", "snapshot"));
+        await (0, spawnSteps_1.runSpawnSteps)(config.backupSteps, {
+            data: {
+                dtt: {
+                    snapshot: data.snapshot,
+                    snapshotPath: snapshotPath,
+                    package: data.package,
+                },
+            },
+            env: config.env,
+            cwd: snapshotPath,
+            verbose: data.options.verbose,
+            tempDir: () => (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "backup", "nodeStep"),
+        });
+        return { snapshotPath };
+    }
+    async prepareRestore(data) {
+        return {
+            snapshotPath: data.package.restorePath ??
+                (await (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "restore", "snapshot")),
+        };
+    }
+    async restore(data) {
+        const config = this.config;
+        await (0, spawnSteps_1.runSpawnSteps)(config.restoreSteps, {
+            data: {
+                dtt: {
+                    snapshot: data.snapshot,
+                    snapshotPath: data.snapshotPath,
+                    package: data.package,
+                },
+            },
+            env: config.env,
+            verbose: data.options.verbose,
+            tempDir: () => (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "restore", "nodeStep"),
+        });
+    }
+}
+exports.ScriptTask = ScriptTask;

package/{Task → lib/Task}/SqlDumpTaskAbstract.d.ts

@@ -1,12 +1,11 @@
 import { exec } from "../utils/process";
 import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
-import { JSONSchema7, JSONSchema7Definition } from "json-schema";
-export type TargetDatabaseType = {
+export type TargetDatabase = {
     name: string;
     charset?: string;
     collate?: string;
 };
-export type SqlDumpTaskConfigType = {
+export type SqlDumpTaskConfig = {
     password: string | {
         path: string;
     };
@@ -18,17 +17,16 @@ export type SqlDumpTaskConfigType = {
      * @default true
      */
     storedPrograms?: boolean;
-    targetDatabase?: TargetDatabaseType;
+    targetDatabase?: TargetDatabase;
     includeTables?: string[];
     excludeTables?: string[];
     oneFileByTable?: boolean;
 };
-export declare const sqlDumpTaskDefinition: (props?: Record<string, JSONSchema7Definition>) => JSONSchema7;
-export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskConfigType> extends TaskAbstract<TConfig> {
+export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskConfig> extends TaskAbstract<TConfig> {
     protected verbose?: boolean;
     fetchPassword(): Promise<string | null>;
     fetchValues(query: string): Promise<string[]>;
-    abstract onCreateDatabase(database: TargetDatabaseType): Promise<void>;
+    abstract onCreateDatabase(database: TargetDatabase): Promise<void>;
     abstract onDatabaseIsEmpty(databaseName: string): Promise<boolean>;
     abstract onFetchTableNames(database: string): Promise<string[]>;
     abstract onExecQuery(query: string): ReturnType<typeof exec>;

package/{Task → lib/Task}/SqlDumpTaskAbstract.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqlDumpTaskAbstract = exports.sqlDumpTaskDefinition = void 0;
+exports.SqlDumpTaskAbstract = void 0;
 const AppError_1 = require("../Error/AppError");
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const cli_1 = require("../utils/cli");
 const config_1 = require("../utils/datatruck/config");
 const fs_1 = require("../utils/fs");
@@ -13,47 +12,6 @@ const assert_1 = require("assert");
 const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
-const sqlDumpTaskDefinition = (props = {}) => ({
-    type: "object",
-    required: ["password", "hostname", "username", "database"],
-    additionalProperties: false,
-    properties: {
-        ...props,
-        password: {
-            anyOf: [
-                {
-                    type: "string",
-                },
-                {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["path"],
-                    properties: {
-                        path: { type: "string" },
-                    },
-                },
-            ],
-        },
-        hostname: { type: "string" },
-        port: { type: "integer" },
-        username: { type: "string" },
-        database: { type: "string" },
-        targetDatabase: {
-            type: "object",
-            required: ["name"],
-            properties: {
-                name: { type: "string" },
-                charset: { type: "string" },
-                collate: { type: "string" },
-            },
-        },
-        storedPrograms: { type: "boolean" },
-        includeTables: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        excludeTables: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        oneFileByTable: { type: "boolean" },
-    },
-});
-exports.sqlDumpTaskDefinition = sqlDumpTaskDefinition;
 function serializeSqlFile(input) {
     if (input.database && input.table) {
         return `${input.database}.${input.table}.table.sql`;

package/{Task → lib/Task}/TaskAbstract.d.ts

@@ -1,10 +1,10 @@
 import { BackupActionOptions } from "../Action/BackupAction";
 import { RestoreActionOptions } from "../Action/RestoreAction";
-import { PackageConfigType } from "../Config/PackageConfig";
+import { PackageConfig } from "../Config/PackageConfig";
 import { PreSnapshot } from "../Repository/RepositoryAbstract";
 import { Progress } from "../utils/progress";
 type TaskCommonData = {
-    package: PackageConfigType;
+    package: PackageConfig;
     snapshot: PreSnapshot;
 };
 export type TaskBackupData = TaskCommonData & {

package/lib/cli.d.ts

@@ -0,0 +1,4 @@
+import { OptionsMap } from "./Factory/CommandFactory";
+export declare function buildArgs<TCommand extends keyof OptionsMap>(input: TCommand, options: OptionsMap[TCommand]): any[];
+export declare function parseArgs(args: string[]): void;
+export declare function exec<TCommand extends keyof OptionsMap>(input: TCommand, options: OptionsMap[TCommand]): Promise<void>;

package/lib/config.schema.d.ts

@@ -0,0 +1,2 @@
+declare const configSchema: any;
+export { configSchema };

package/lib/config.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchema = void 0;
+// @ts-ignore
+const config_schema_json_1 = __importDefault(require("../config.schema.json"));
+const configSchema = config_schema_json_1.default;
+exports.configSchema = configSchema;

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+export type { Config } from "./Config/Config";
+export type { PackageConfig } from "./Config/PackageConfig";
+export type { PackageRepositoryConfig } from "./Config/PackageRepositoryConfig";
+export type { PrunePolicyConfig } from "./Config/PrunePolicyConfig";
+export type { RepositoryConfig } from "./Config/RepositoryConfig";
+export { type ResticRepositoryConfig } from "./Repository/ResticRepository";
+export { type DatatruckRepositoryConfig } from "./Repository/DatatruckRepository";
+export { type GitRepositoryConfig } from "./Repository/GitRepository";
+export type { TaskConfig } from "./Config/TaskConfig";
+export { type GitTaskConfig } from "./Task/GitTask";
+export { type MariadbTaskConfig } from "./Task/MariadbTask";
+export { type MssqlTaskConfig } from "./Task/MssqlTask";
+export { type MysqlDumpTaskConfig } from "./Task/MysqlDumpTask";
+export { type PostgresqlDumpTaskConfig } from "./Task/PostgresqlDumpTask";
+export { type ScriptTaskConfig } from "./Task/ScriptTask";
+export { BackupAction, type BackupActionOptions } from "./Action/BackupAction";
+export { CleanCacheAction, type CleanCacheActionOptions, } from "./Action/CleanCacheAction";
+export { ConfigAction, type ConfigActionOptions } from "./Action/ConfigAction";
+export { CopyAction, type CopyActionOptions } from "./Action/CopyAction";
+export { InitAction, type InitActionOptions } from "./Action/InitAction";
+export { PruneAction, type PruneActionsOptions } from "./Action/PruneAction";
+export { RestoreAction, type RestoreActionOptions, } from "./Action/RestoreAction";
+export { SnapshotsAction, type SnapshotsActionOptions, } from "./Action/SnapshotsAction";
+export { parseArgs } from "./cli";

package/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = exports.SnapshotsAction = exports.RestoreAction = exports.PruneAction = exports.InitAction = exports.CopyAction = exports.ConfigAction = exports.CleanCacheAction = exports.BackupAction = void 0;
+var BackupAction_1 = require("./Action/BackupAction");
+Object.defineProperty(exports, "BackupAction", { enumerable: true, get: function () { return BackupAction_1.BackupAction; } });
+var CleanCacheAction_1 = require("./Action/CleanCacheAction");
+Object.defineProperty(exports, "CleanCacheAction", { enumerable: true, get: function () { return CleanCacheAction_1.CleanCacheAction; } });
+var ConfigAction_1 = require("./Action/ConfigAction");
+Object.defineProperty(exports, "ConfigAction", { enumerable: true, get: function () { return ConfigAction_1.ConfigAction; } });
+var CopyAction_1 = require("./Action/CopyAction");
+Object.defineProperty(exports, "CopyAction", { enumerable: true, get: function () { return CopyAction_1.CopyAction; } });
+var InitAction_1 = require("./Action/InitAction");
+Object.defineProperty(exports, "InitAction", { enumerable: true, get: function () { return InitAction_1.InitAction; } });
+var PruneAction_1 = require("./Action/PruneAction");
+Object.defineProperty(exports, "PruneAction", { enumerable: true, get: function () { return PruneAction_1.PruneAction; } });
+var RestoreAction_1 = require("./Action/RestoreAction");
+Object.defineProperty(exports, "RestoreAction", { enumerable: true, get: function () { return RestoreAction_1.RestoreAction; } });
+var SnapshotsAction_1 = require("./Action/SnapshotsAction");
+Object.defineProperty(exports, "SnapshotsAction", { enumerable: true, get: function () { return SnapshotsAction_1.SnapshotsAction; } });
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "parseArgs", { enumerable: true, get: function () { return cli_1.parseArgs; } });

package/{utils → lib/utils}/DataFormat.d.ts

@@ -1,7 +1,7 @@
 import { Streams } from "./stream";
 import { Header } from "tty-table";
-export type FormatType = "json" | "list" | "pjson" | "table" | "yaml" | "custom" | "tpl";
-export declare const dataFormats: FormatType[];
+export type DataFormatType = "json" | "list" | "pjson" | "table" | "yaml" | "custom" | "tpl";
+export declare const dataFormats: DataFormatType[];
 export declare class DataFormat {
     readonly options: {
         streams?: Partial<Streams>;
@@ -28,10 +28,10 @@ export declare class DataFormat {
     protected formatToYaml(): any;
     protected formatToTable(): string;
     protected formatToList(): string;
-    log(format: FormatType, options?: {
+    log(format: DataFormatType, options?: {
         tpl?: Record<string, () => string>;
     }): void;
-    format(format: FormatType, options?: {
+    format(format: DataFormatType, options?: {
         tpl?: Record<string, () => string>;
     }): any;
 }

package/{utils → lib/utils}/Git.d.ts

@@ -8,22 +8,22 @@ export declare class Git {
         dir: string;
         log?: boolean;
     });
-    exec(args: string[], settings?: ExecSettingsInterface, cwd?: boolean): Promise<import("./process").ExecResultType>;
+    exec(args: string[], settings?: ExecSettingsInterface, cwd?: boolean): Promise<import("./process").ExecResult>;
     canBeInit(repo: string): Promise<boolean>;
     clone(options: {
         repo: string;
         branch?: string;
         orphan?: boolean;
-    }): Promise<import("./process").ExecResultType>;
+    }): Promise<import("./process").ExecResult>;
     checkout(options: {
         branchName: string;
         orphan?: boolean;
-    }): Promise<import("./process").ExecResultType>;
+    }): Promise<import("./process").ExecResult>;
     checkBranch(options: {
         name: string;
         repo?: string;
     }): Promise<boolean>;
-    removeAll(): Promise<import("./process").ExecResultType>;
+    removeAll(): Promise<import("./process").ExecResult>;
     haveChanges(): Promise<boolean>;
     fetchCommitId(tag: string): Promise<string>;
     getTags(names?: string[]): Promise<{
@@ -31,8 +31,8 @@ export declare class Git {
         message?: string | undefined;
     }[]>;
     addTag(name: string, message?: string): Promise<void>;
-    pushTags(): Promise<import("./process").ExecResultType>;
+    pushTags(): Promise<import("./process").ExecResult>;
     push(options: {
         branchName: string;
-    }): Promise<import("./process").ExecResultType>;
+    }): Promise<import("./process").ExecResult>;
 }

package/{utils → lib/utils}/Restic.d.ts

@@ -1,14 +1,14 @@
-import { ExecResultType, ExecSettingsInterface } from "./process";
-import { UriType } from "./string";
-export type RepositoryType = {
+import { ExecResult, ExecSettingsInterface, ProcessEnv } from "./process";
+import { Uri } from "./string";
+export type ResticRepositoryUri = {
     name?: string;
-    env?: Record<string, string>;
+    env?: ProcessEnv;
     password?: string | {
         path: string;
     };
     backend: "local" | "rest" | "sftp" | "s3" | "azure" | "gs" | "rclone";
-} & Omit<UriType, "password">;
-export type BackupStreamType = {
+} & Omit<Uri, "password">;
+export type ResticBackupStream = {
     message_type: "status";
     seconds_elapsed?: number;
     percent_done: number;
@@ -45,10 +45,10 @@ export declare class Restic {
         log?: boolean;
         env: Record<string, string>;
     });
-    static formatRepository(input: RepositoryType, hidePassword?: boolean): Promise<string>;
+    static formatRepository(input: ResticRepositoryUri, hidePassword?: boolean): Promise<string>;
     exec(args: string[], settings?: ExecSettingsInterface, options?: {
         cwd?: string;
-    }): Promise<ExecResultType>;
+    }): Promise<ExecResult>;
     checkRepository(): Promise<boolean>;
     forget(options: {
         snapshotId?: string;
@@ -89,13 +89,13 @@ export declare class Restic {
         excludeFile?: string[];
         parent?: string;
         allowEmptySnapshot?: boolean;
-        onStream?: (data: BackupStreamType) => void;
+        onStream?: (data: ResticBackupStream) => void;
         createEmptyDir?: () => Promise<string>;
-    }): Promise<ExecResultType>;
+    }): Promise<ExecResult>;
     copy(options: {
         id: string;
-        onStream?: (data: BackupStreamType) => Promise<void>;
-    }): Promise<ExecResultType>;
+        onStream?: (data: ResticBackupStream) => Promise<void>;
+    }): Promise<ExecResult>;
     restore(options: {
         id: string;
         target: string;
@@ -103,6 +103,6 @@ export declare class Restic {
          * @default 30_000
          */
         progressInterval?: number | false;
-        onStream?: (data: BackupStreamType) => Promise<void>;
-    }): Promise<ExecResultType>;
+        onStream?: (data: ResticBackupStream) => Promise<void>;
+    }): Promise<ExecResult>;
 }

package/{utils → lib/utils}/datatruck/config.d.ts

@@ -1,36 +1,36 @@
-import { ConfigType } from "../../Config/Config";
-import type { PackageConfigType } from "../../Config/PackageConfig";
-import { RepositoryConfigEnabledActionType, RepositoryConfigType } from "../../Config/RepositoryConfig";
-export declare function findRepositoryOrFail(config: ConfigType, repositoryName: string): RepositoryConfigType;
-export declare function findPackageOrFail(config: ConfigType, packageName: string): PackageConfigType;
-export declare function ensureSameRepositoryType(a: RepositoryConfigType, b: RepositoryConfigType): void;
-export declare function filterRepository(repository: RepositoryConfigType, action?: RepositoryConfigEnabledActionType): boolean;
-export declare function filterPackages(config: ConfigType, options: {
+import { Config } from "../../Config/Config";
+import type { PackageConfig } from "../../Config/PackageConfig";
+import { RepositoryConfigEnabledAction, RepositoryConfig } from "../../Config/RepositoryConfig";
+export declare function findRepositoryOrFail(config: Config, repositoryName: string): RepositoryConfig;
+export declare function findPackageOrFail(config: Config, packageName: string): PackageConfig;
+export declare function ensureSameRepositoryType(a: RepositoryConfig, b: RepositoryConfig): void;
+export declare function filterRepository(repository: RepositoryConfig, action?: RepositoryConfigEnabledAction): boolean;
+export declare function filterPackages(config: Config, options: {
     packageNames?: string[];
     packageTaskNames?: string[];
     repositoryNames?: string[];
     repositoryTypes?: string[];
-    sourceAction?: RepositoryConfigEnabledActionType;
-}): PackageConfigType[];
-type ResolvePackagePathParamsType = ResolvePackageParamsType & {
+    sourceAction?: RepositoryConfigEnabledAction;
+}): PackageConfig[];
+type ResolvePackagePathParams = ResolvePackageParams & {
     packageName: string;
     path: string | undefined;
 };
-export declare function resolvePackagePath(value: string, params: ResolvePackagePathParamsType): string;
-export type ResolveDatabaseNameParamsType = ResolvePackageParamsType & {
+export declare function resolvePackagePath(value: string, params: ResolvePackagePathParams): string;
+export type ResolveDatabaseNameParams = ResolvePackageParams & {
     packageName: string;
     database: string | undefined;
 };
-export declare function resolveDatabaseName(value: string, params: ResolveDatabaseNameParamsType): string;
-type ResolvePackageParamsType = {
+export declare function resolveDatabaseName(value: string, params: ResolveDatabaseNameParams): string;
+type ResolvePackageParams = {
     snapshotId: string;
     snapshotDate: string;
     action: "backup" | "restore";
 };
-export declare function resolvePackage(pkg: PackageConfigType, params: ResolvePackageParamsType): PackageConfigType;
-export declare function resolvePackages(packages: PackageConfigType[], params: ResolvePackageParamsType): PackageConfigType[];
+export declare function resolvePackage(pkg: PackageConfig, params: ResolvePackageParams): PackageConfig;
+export declare function resolvePackages(packages: PackageConfig[], params: ResolvePackageParams): PackageConfig[];
 export declare const pkgPathParams: {
-    [name in "temp" | Exclude<keyof ResolvePackagePathParamsType, "path">]: string;
+    [name in "temp" | Exclude<keyof ResolvePackagePathParams, "path">]: string;
 };
 export declare const pkgIncludeParams: {
     action: string;
@@ -47,10 +47,10 @@ export declare const pkgExcludeParams: {
     snapshotDate: string;
 };
 export declare const pkgRestorePathParams: {
-    [name in "temp" | keyof ResolvePackagePathParamsType]: string;
+    [name in "temp" | keyof ResolvePackagePathParams]: string;
 };
 export declare const dbNameParams: {
-    [name in keyof ResolveDatabaseNameParamsType]: string;
+    [name in keyof ResolveDatabaseNameParams]: string;
 };
 export declare const params: {
     pkgPath: {

package/lib/utils/datatruck/paths.d.ts

@@ -0,0 +1,17 @@
+import { PackageConfig } from "../../Config/PackageConfig";
+import { PreSnapshot } from "../../Repository/RepositoryAbstract";
+import { SpawnStep } from "../spawnSteps";
+export type ParsePathsOptions = {
+    cwd?: string;
+    verbose?: boolean;
+    data?: Record<string, any>;
+    tempDir?: () => Promise<string>;
+};
+export declare function parsePaths(values: (string | SpawnStep)[], options: ParsePathsOptions): Promise<string[]>;
+export type BackupPathsOptions = {
+    package: PackageConfig;
+    snapshot: PreSnapshot;
+    path: string;
+    verbose?: boolean;
+};
+export declare function parseBackupPaths(paths: (string | SpawnStep)[], options: BackupPathsOptions): Promise<string[]>;

package/{utils → lib/utils}/datatruck/paths.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBackupPaths = exports.parsePaths = void 0;
-const steps_1 = require("../steps");
+const spawnSteps_1 = require("../spawnSteps");
 async function parsePaths(values, options) {
     let paths = [];
     for (const value of values) {
@@ -9,7 +9,7 @@ async function parsePaths(values, options) {
             paths.push(value);
         }
         else {
-            await (0, steps_1.runSteps)(value, {
+            await (0, spawnSteps_1.runSpawnSteps)(value, {
                 tempDir: options.tempDir,
                 verbose: options.verbose,
                 onLine: (path) => paths.push(path),
@@ -23,7 +23,7 @@ async function parseBackupPaths(paths, options) {
     return parsePaths(paths, {
         cwd: options.path,
         verbose: options.verbose,
-        vars: {
+        data: {
             package: options.package,
             snapshot: options.snapshot,
             path: options.path,

package/{utils → lib/utils}/datatruck/repository-server.d.ts

@@ -34,5 +34,5 @@ export declare const headerKey: {
 export declare function createDatatruckRepositoryServer(inOptions: Omit<DatatruckRepositoryServerOptions, "listen">, config?: {
     log?: boolean;
     configPath?: string;
-}): import("node:http").Server<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+}): import("http").Server<typeof IncomingMessage, typeof import("http").ServerResponse>;
 export {};

package/{utils → lib/utils}/datatruck/snapshot.d.ts

@@ -1,7 +1,7 @@
 import { SnapshotGroupByType } from "../../Action/SnapshotsAction";
 import { Snapshot } from "../../Repository/RepositoryAbstract";
-import { FilterByLastOptionsType } from "../date";
-export declare function groupAndFilter<TSnapshot extends Snapshot>(snapshots: TSnapshot[], groupKeys?: SnapshotGroupByType[], inFilter?: FilterByLastOptionsType | ((group: TSnapshot[]) => FilterByLastOptionsType | string)): {
+import { FilterByLastOptions } from "../date";
+export declare function groupAndFilter<TSnapshot extends Snapshot>(snapshots: TSnapshot[], groupKeys?: SnapshotGroupByType[], inFilter?: FilterByLastOptions | ((group: TSnapshot[]) => FilterByLastOptions | string)): {
     item: TSnapshot;
     reasons: string[];
 }[];

package/{utils → lib/utils}/date.d.ts

@@ -1,4 +1,4 @@
-export type FilterByLastOptionsType = {
+export type FilterByLastOptions = {
     last?: number;
     lastMinutely?: number;
     lastHourly?: number;
@@ -16,10 +16,10 @@ export type KeepObject = {
     keepMonthly?: number;
     keepYearly?: number;
 };
-export declare function createFilterByLastOptions(keep: KeepObject): FilterByLastOptionsType;
+export declare function createFilterByLastOptions(keep: KeepObject): FilterByLastOptions;
 export declare function filterByLast<TItem extends {
     date: string;
-}>(items: TItem[], options: FilterByLastOptionsType): {
+}>(items: TItem[], options: FilterByLastOptions): {
     item: TItem;
     reasons: string[];
 }[];

package/{utils → lib/utils}/exit.d.ts

@@ -1,6 +1,6 @@
-type EventNameType = "exit" | "SIGINT" | "SIGUSR1" | "SIGUSR2" | "SIGTERM" | "uncaughtException";
-export declare function triggerExitEvent(eventName: EventNameType, ...args: any[]): void;
+type ExitEventName = "exit" | "SIGINT" | "SIGUSR1" | "SIGUSR2" | "SIGTERM" | "uncaughtException";
+export declare function triggerExitEvent(eventName: ExitEventName, ...args: any[]): void;
 export declare function enableExitEvents(): void;
 export declare function disableExitEvents(): void;
-export declare function onExit(cb: (eventName: EventNameType, ...args: any[]) => void, priority?: number): () => boolean;
+export declare function onExit(cb: (eventName: ExitEventName, ...args: any[]) => void, priority?: number): () => boolean;
 export {};

package/{utils → lib/utils}/mysql.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { ChildProcess } from "child_process";
 export type MysqlCliOptions = {
     password: string | {
@@ -14,7 +15,7 @@ export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
     options: MysqlCliOptions;
     initSharedDir: (sharedDir?: string) => Promise<string>;
     args: () => Promise<string[]>;
-    run: (query: string, database?: string, extra?: string[], onSpawn?: ((p: ChildProcess) => void) | undefined) => Promise<import("./process").ExecResultType>;
+    run: (query: string, database?: string, extra?: string[], onSpawn?: ((p: ChildProcess) => void) | undefined) => Promise<import("./process").ExecResult>;
     execute: (query: string, params?: any[]) => Promise<void>;
     insert: (tableName: string, item: Record<string, any>) => Promise<void>;
     changeDatabase: (name: string) => Promise<void>;
@@ -28,14 +29,14 @@ export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
         onProgress?: ((data: {
             totalBytes: number;
         }) => void) | undefined;
-    }) => Promise<[void, import("./process").ExecResultType]>;
+    }) => Promise<[void, import("./process").ExecResult]>;
     assertDumpFile: typeof assertDumpFile;
     fetchTableNames: (database: string, include?: string[], exclude?: string[]) => Promise<string[]>;
     importFile: (input: {
         path: string;
         database: string;
         onSpawn?: ((p: ChildProcess) => void) | undefined;
-    }) => Promise<import("./process").ExecResultType>;
+    }) => Promise<import("./process").ExecResult>;
     isDatabaseEmpty: (database: string) => Promise<boolean>;
     createDatabase: (database: {
         name: string;
@@ -52,6 +53,6 @@ export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
         database: string;
         table: string;
         onSpawn?: ((p: ChildProcess) => void) | undefined;
-    }) => Promise<import("./process").ExecResultType>;
+    }) => Promise<import("./process").ExecResult>;
     fetchVariable: (name: string) => Promise<string | undefined>;
 }>;

package/{utils → lib/utils}/mysql.js

@@ -147,8 +147,8 @@ async function createMysqlCli(options) {
             input.database,
             "--lock-tables=false",
             "--skip-add-drop-table=false",
-            "--fields-terminated-by=0x09",
-            "--lines-terminated-by=0x0a",
+            "--fields-terminated-by=0x09", // \t
+            "--lines-terminated-by=0x0a", // \n
             "-T",
             input.sharedPath,
             ...(input.items || []),