@datatruck/cli 0.34.0 → 0.34.2

package/lib/utils/async.js

@@ -9,7 +9,7 @@ async function runParallel(options) {
     await promise_pool_1.PromisePool.for(options.items)
         .withConcurrency(options.concurrency)
         .process(async (item, index, pool) => {
-        const controller = {};
+        const controller = new AbortController();
         buffer.set(item, controller);
         try {
             await options.onChange({
@@ -29,7 +29,7 @@ async function runParallel(options) {
             pool.stop();
             for (const [, $controller] of buffer.entries())
                 try {
-                    $controller.stop?.();
+                    $controller.abort();
                 }
                 catch (_) { }
         }

package/lib/utils/{DataFormat.d.ts → data-format.d.ts}

@@ -1,10 +1,10 @@
-import { Streams } from "./stream";
+import { StdStreams } from "./stream";
 import { Header } from "tty-table";
 export type DataFormatType = "json" | "list" | "pjson" | "table" | "yaml" | "custom" | "tpl";
 export declare const dataFormats: DataFormatType[];
 export declare class DataFormat {
     readonly options: {
-        streams?: Partial<Streams>;
+        streams?: Partial<StdStreams>;
         json: any;
         list?: () => string[];
         table?: {
@@ -12,9 +12,9 @@ export declare class DataFormat {
             rows: () => (string | number | null | undefined)[][];
         };
     };
-    protected streams: Streams;
+    protected streams: StdStreams;
     constructor(options: {
-        streams?: Partial<Streams>;
+        streams?: Partial<StdStreams>;
         json: any;
         list?: () => string[];
         table?: {

package/lib/utils/{DataFormat.js → data-format.js}

@@ -24,7 +24,7 @@ class DataFormat {
     streams;
     constructor(options) {
         this.options = options;
-        this.streams = (0, stream_1.createStreams)(options.streams);
+        this.streams = (0, stream_1.createStdStreams)(options.streams);
     }
     getJson() {
         return this.options.json;

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

@@ -8,7 +8,7 @@ import { PruneCommand } from "../../commands/PruneCommand";
 import { RestoreCommand } from "../../commands/RestoreCommand";
 import { SnapshotsCommand } from "../../commands/SnapshotsCommand";
 import { StartServerCommand } from "../../commands/StartServerCommand";
-import { Streams } from "../stream";
+import { StdStreams } from "../stream";
 export declare const datatruckCommandMap: {
     config: typeof ConfigCommand;
     init: typeof InitCommand;
@@ -23,7 +23,7 @@ export declare const datatruckCommandMap: {
 export type DatatruckCommandMap = typeof datatruckCommandMap;
 export type InferDatatruckCommandOptions<T extends keyof DatatruckCommandMap> = InstanceType<DatatruckCommandMap[T]>["inputOptions"];
 export type InferDatatruckCommandResult<T extends keyof DatatruckCommandMap, R = Awaited<ReturnType<InstanceType<DatatruckCommandMap[T]>["exec"]>>> = "result" extends keyof R ? R["result"] : undefined;
-export declare function createCommand<T extends keyof DatatruckCommandMap>(name: T, globalOptions: GlobalOptions<true>, options: InferDatatruckCommandOptions<T>, streams?: Partial<Streams>, configPath?: string): BackupCommand | CopyCommand | PruneCommand | CleanCacheCommand | ConfigCommand | InitCommand | RestoreCommand | SnapshotsCommand | StartServerCommand;
+export declare function createCommand<T extends keyof DatatruckCommandMap>(name: T, globalOptions: GlobalOptions<true>, options: InferDatatruckCommandOptions<T>, streams?: Partial<StdStreams>, configPath?: string): BackupCommand | CopyCommand | PruneCommand | CleanCacheCommand | ConfigCommand | InitCommand | RestoreCommand | SnapshotsCommand | StartServerCommand;
 export declare function createCommands(globalOptions: GlobalOptions<true>): {
     [K in keyof DatatruckCommandMap as `${K}`]: (options: InferDatatruckCommandOptions<K>) => Promise<InferDatatruckCommandResult<K>>;
 };

package/lib/utils/datatruck/config-type.d.ts

@@ -1,5 +1,5 @@
 import type { PruneActionsOptions } from "../../actions/PruneAction";
-import type { DataFormatType } from "../DataFormat";
+import type { DataFormatType } from "../data-format";
 import type { ReportStep } from "../reportSteps";
 import type { SpawnStep } from "../spawnSteps";
 import type { PackageRepositoryConfig, RepositoryConfigEnabledAction, RepositoryConfig } from "./config-repository-type";

package/lib/utils/datatruck/cron-server.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCronServer = void 0;
 const ConfigAction_1 = require("../../actions/ConfigAction");
+const async_process_1 = require("../async-process");
 const cli_1 = require("../cli");
 const cron_1 = require("../cron");
-const process_1 = require("../process");
 const string_1 = require("../string");
 const watcher_1 = require("../watcher");
 const command_1 = require("./command");
@@ -33,7 +33,7 @@ function createCronServer(options, config) {
             const command = new Command({ config: { packages: [], repositories: [] } }, {});
             const cliOptions = (0, cli_1.stringifyOptions)(command.optionsConfig(), action.options);
             const [node, bin] = process.argv;
-            await (0, process_1.exec)(node, [bin, "-c", config.configPath, action.name, ...cliOptions], {}, { log: config.verbose });
+            await async_process_1.AsyncProcess.exec(node, [bin, "-c", config.configPath, action.name, ...cliOptions], { $log: config.verbose });
             if (config.log)
                 console.info(`< [job] ${index} - ${action.name}`);
         }

package/lib/utils/fs.d.ts

@@ -3,7 +3,7 @@
 /// <reference types="node" />
 import { Progress } from "./progress";
 import { Entry, Options } from "fast-glob";
-import { ReadStream, Stats } from "fs";
+import { Stats } from "fs";
 import { WriteStream } from "fs";
 import { Interface } from "readline";
 export declare const isWSLSystem: boolean;
@@ -38,7 +38,6 @@ export declare function writeGitIgnoreList(options: {
     paths: NodeJS.ReadableStream | string[];
     outDir: string;
 }): Promise<string>;
-export declare function waitForClose(stream: WriteStream | ReadStream): Promise<void>;
 export declare function copyFileWithStreams(source: string, target: string): Promise<unknown>;
 export declare function updateFileStats(path: string, fileInfo: Stats): Promise<void>;
 export declare function isNotFoundError(error: unknown): boolean;

package/lib/utils/fs.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.asFile = exports.groupFiles = exports.ensureFreeDiskSpace = exports.checkFreeDiskSpace = exports.fetchDiskStats = exports.initEmptyDir = exports.tryRm = exports.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.createProgress = exports.cpy = exports.readTextFile = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.fastFolderSizeAsync = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.include = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureExistsDir = exports.ensureSingleFile = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
+exports.asFile = exports.groupFiles = exports.ensureFreeDiskSpace = exports.checkFreeDiskSpace = exports.fetchDiskStats = exports.initEmptyDir = exports.tryRm = exports.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.createProgress = exports.cpy = exports.readTextFile = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.fastFolderSizeAsync = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.include = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureExistsDir = exports.ensureSingleFile = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
 const pkg_1 = require("../pkg");
 const bytes_1 = require("./bytes");
 const math_1 = require("./math");
+const stream_1 = require("./stream");
 const string_1 = require("./string");
 const temp_1 = require("./temp");
 const async_1 = require("async");
@@ -246,14 +247,6 @@ async function writeGitIgnoreList(options) {
     return path;
 }
 exports.writeGitIgnoreList = writeGitIgnoreList;
-async function waitForClose(stream) {
-    return new Promise((resolve, reject) => {
-        stream.on("close", resolve);
-        stream.on("error", reject);
-        return stream;
-    });
-}
-exports.waitForClose = waitForClose;
 async function copyFileWithStreams(source, target) {
     const r = (0, fs_1.createReadStream)(source);
     const w = (0, fs_2.createWriteStream)(target);
@@ -520,7 +513,7 @@ function createWriteStreamPool(options) {
             }
             await Promise.all(items
                 .filter((item) => !item.finished)
-                .map((item) => waitForClose(item.stream)));
+                .map((item) => (0, stream_1.waitForClose)(item.stream)));
         },
     };
 }

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

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

package/lib/utils/{Git.js → git.js}

@@ -1,25 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Git = void 0;
+const async_process_1 = require("./async-process");
 const fs_1 = require("./fs");
-const process_1 = require("./process");
 class Git {
     options;
     constructor(options) {
         this.options = options;
     }
-    async exec(args, settings, cwd) {
-        return await (0, process_1.exec)("git", args, { cwd: cwd === false ? undefined : this.options.dir }, {
-            log: this.options.log,
-            ...(settings ?? {}),
+    createProcess(args, options = {}) {
+        return new async_process_1.AsyncProcess("git", args, {
+            $log: this.options.log,
+            cwd: this.options.dir,
+            ...options,
         });
     }
+    async exec(args, options) {
+        return await this.createProcess(args, options).waitForClose();
+    }
+    async stdout(args, options) {
+        return await this.createProcess(args, options).stdout.fetch();
+    }
     async canBeInit(repo) {
         return ((0, fs_1.isLocalDir)(repo) &&
             (!(await (0, fs_1.existsDir)(repo)) || !(await (0, fs_1.readDir)(repo)).length));
     }
     async clone(options) {
-        return await this.exec([
+        await this.exec([
             "clone",
             ...(/^\w+\:\/\//.test(options.repo) ? ["--depth=1"] : []),
             ...(options.orphan ? ["--orphan"] : []),
@@ -31,42 +38,41 @@ class Git {
         ]);
     }
     async checkout(options) {
-        return await this.exec([
+        await this.exec([
             "checkout",
             ...(options.orphan ? ["--orphan"] : []),
             options.branchName,
         ]);
     }
     async checkBranch(options) {
-        const result = await this.exec([
+        const stdout = await this.stdout([
             "ls-remote",
             "--exit-code",
             ...(options.repo ? [options.repo] : ["--heads", "origin"]),
         ], {
-            stdout: { save: true },
-            onExitCodeError: () => false,
-        }, options.repo ? false : true);
-        return result.stdout
+            ...(options.repo && {
+                cwd: undefined,
+            }),
+            cwd: options.repo ? undefined : this.options.dir,
+            $exitCode: false,
+        });
+        return stdout
             .split(/\r?\n/g)
             .some((line) => line.endsWith(`refs/heads/${options.name}`));
     }
     async removeAll() {
-        return await this.exec(["rm", "--force", "--ignore-unmatch", "*"]);
+        await this.exec(["rm", "--force", "--ignore-unmatch", "*"]);
     }
     async haveChanges() {
-        const statusResult = await this.exec(["status", "-s"], {
-            stdout: { save: true },
-        });
-        return !!statusResult.stdout.trim().length;
+        const stdout = await this.stdout(["status", "-s"]);
+        return !!stdout.trim().length;
     }
     async fetchCommitId(tag) {
-        return (await this.exec(["rev-list", "-n", "1", tag], { stdout: { save: true } })).stdout?.trim();
+        return (await this.stdout(["rev-list", "-n", "1", tag])).trim();
     }
     async getTags(names) {
-        const result = await this.exec(["tag", "-n", ...(names ?? [])], {
-            stdout: { save: true },
-        });
-        return result.stdout.split(/\r?\n/).reduce((result, value) => {
+        const stdout = await this.stdout(["tag", "-n", ...(names ?? [])]);
+        return stdout.split(/\r?\n/).reduce((result, value) => {
             value = value.trim();
             if (!value.length)
                 return result;
@@ -91,15 +97,10 @@ class Git {
         }
     }
     async pushTags() {
-        return await this.exec(["push", "--tags"]);
+        await this.exec(["push", "--tags"]);
     }
     async push(options) {
-        return await this.exec([
-            "push",
-            "--progress",
-            "origin",
-            options.branchName,
-        ]);
+        await this.exec(["push", "--progress", "origin", options.branchName]);
     }
 }
 exports.Git = Git;

package/lib/utils/list.d.ts

@@ -1,10 +1,10 @@
 import { Timer } from "./date";
 import { ProgressManager } from "./progress";
-import { Streams } from "./stream";
+import { StdStreams } from "./stream";
 import { Listr, ListrGetRendererClassFromValue, ListrLogger, ListrTask, ListrTaskWrapper } from "listr2";
 export declare class List3Logger<Levels extends string = string> extends ListrLogger<Levels> {
     constructor(options?: {
-        streams?: Partial<Streams>;
+        streams?: Partial<StdStreams>;
     });
 }
 export type Listr3Context = Record<string, Record<string, any>>;
@@ -41,7 +41,7 @@ export type Listr3TaskResult<T extends Listr3Context> = {
 export type Listr3TaskResultEnd<T extends Listr3Context> = Listr3TaskResult<T> | List3SummaryResult;
 export declare class Listr3<T extends Listr3Context> extends Listr<void, "default", "simple"> {
     readonly $options: {
-        streams?: Streams;
+        streams?: StdStreams;
         progressManager?: ProgressManager;
     };
     readonly resultMap: Record<string, Listr3TaskResult<T>>;
@@ -49,7 +49,7 @@ export declare class Listr3<T extends Listr3Context> extends Listr<void, "defaul
     readonly logger: List3Logger;
     protected execTimer: Timer;
     constructor($options: {
-        streams?: Streams;
+        streams?: StdStreams;
         progressManager?: ProgressManager;
     });
     private serializeKeyIndex;

package/lib/utils/list.js

@@ -7,7 +7,7 @@ const stream_1 = require("./stream");
 const listr2_1 = require("listr2");
 class List3Logger extends listr2_1.ListrLogger {
     constructor(options = {}) {
-        const streams = (0, stream_1.createStreams)(options.streams);
+        const streams = (0, stream_1.createStdStreams)(options.streams);
         super({
             processOutput: new listr2_1.ProcessOutput(streams.stdout, streams.stderr),
         });

package/lib/utils/mysql.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-import { ChildProcess } from "child_process";
 export type MysqlCliOptions = {
     password: string | {
         path: string;
@@ -15,7 +14,6 @@ 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").ExecResult>;
     execute: (query: string, params?: any[]) => Promise<void>;
     insert: (tableName: string, item: Record<string, any>) => Promise<void>;
     changeDatabase: (name: string) => Promise<void>;
@@ -25,18 +23,18 @@ export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
         database: string;
         items?: string[] | undefined;
         onlyStoredPrograms?: boolean | undefined;
-        onSpawn?: ((p: ChildProcess) => void) | undefined;
+        controller?: AbortController | undefined;
         onProgress?: ((data: {
             totalBytes: number;
         }) => void) | undefined;
-    }) => Promise<[void, import("./process").ExecResult]>;
+    }) => Promise<void>;
     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").ExecResult>;
+        controller?: AbortController;
+    }) => Promise<void>;
     isDatabaseEmpty: (database: string) => Promise<boolean>;
     createDatabase: (database: {
         name: string;
@@ -45,14 +43,14 @@ export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
     csvDump: (input: {
         database: string;
         sharedPath: string;
-        items?: string[] | undefined;
-        onSpawn?: ((p: ChildProcess) => void) | undefined;
+        items?: string[];
+        controller?: AbortController;
     }) => Promise<void>;
     importCsvFile: (input: {
         path: string;
         database: string;
         table: string;
-        onSpawn?: ((p: ChildProcess) => void) | undefined;
-    }) => Promise<import("./process").ExecResult>;
+        controller?: AbortController;
+    }) => Promise<void>;
     fetchVariable: (name: string) => Promise<string | undefined>;
 }>;

package/lib/utils/mysql.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMysqlCli = exports.assertDumpFile = void 0;
+const async_process_1 = require("./async-process");
 const cli_1 = require("./cli");
 const error_1 = require("./datatruck/error");
 const fs_1 = require("./fs");
@@ -8,7 +9,6 @@ const process_1 = require("./process");
 const string_1 = require("./string");
 const temp_1 = require("./temp");
 const crypto_1 = require("crypto");
-const fs_2 = require("fs");
 const promises_1 = require("fs/promises");
 const promise_1 = require("mysql2/promise");
 const os_1 = require("os");
@@ -68,22 +68,6 @@ async function createMysqlCli(options) {
     async function args() {
         return [`--defaults-file=${await createSqlConfig()}`];
     }
-    async function run(query, database, extra = [], onSpawn) {
-        return await (0, process_1.exec)("mysql", [
-            ...(await args()),
-            ...(database ? [database] : []),
-            ...(extra || []),
-            "-e",
-            flatQuery(query),
-            "-N",
-            "--silent",
-        ], undefined, {
-            onSpawn,
-            log: options.verbose,
-            stderr: { toExitCode: true },
-            stdout: { save: true },
-        });
-    }
     async function fetchAll(query, params) {
         const [rows] = await sql.query(query, params);
         return rows;
@@ -103,46 +87,35 @@ async function createMysqlCli(options) {
             .filter((0, string_1.createMatchFilter)(include, exclude));
     }
     async function dump(input) {
-        const stream = (0, fs_2.createWriteStream)(input.output);
-        return await Promise.all([
-            new Promise((resolve, reject) => {
-                stream.on("close", resolve);
-                stream.on("error", reject);
-            }),
-            await (0, process_1.exec)("mysqldump", [
-                ...(await args()),
-                input.database,
-                "--lock-tables=false",
-                "--skip-add-drop-table=false",
-                ...(input.onlyStoredPrograms
-                    ? [
-                        "--routines",
-                        "--events",
-                        "--skip-triggers",
-                        "--no-create-info",
-                        "--no-data",
-                        "--no-create-db",
-                        "--skip-opt",
-                    ]
-                    : []),
-                ...(input.items || []),
-            ], null, {
-                stderr: { toExitCode: true },
-                onSpawn: input.onSpawn,
-                pipe: {
-                    stream,
-                    onWriteProgress: input.onProgress,
-                },
-                log: {
-                    exec: options.verbose,
-                    stderr: options.verbose,
-                    allToStderr: true,
-                },
-            }),
-        ]);
+        const process = new async_process_1.AsyncProcess("mysqldump", [
+            ...(await args()),
+            input.database,
+            "--lock-tables=false",
+            "--skip-add-drop-table=false",
+            ...(input.onlyStoredPrograms
+                ? [
+                    "--routines",
+                    "--events",
+                    "--skip-triggers",
+                    "--no-create-info",
+                    "--no-data",
+                    "--no-create-db",
+                    "--skip-opt",
+                ]
+                : []),
+            ...(input.items || []),
+        ], {
+            $controller: input.controller,
+            $log: {
+                exec: options.verbose,
+                stderr: options.verbose,
+                allToStderr: true,
+            },
+        });
+        await process.stdout.pipe(input.output, input.onProgress);
     }
     async function csvDump(input) {
-        await (0, process_1.exec)("mysqldump", [
+        const process = new async_process_1.AsyncProcess("mysqldump", [
             ...(await args()),
             input.database,
             "--lock-tables=false",
@@ -152,18 +125,18 @@ async function createMysqlCli(options) {
             "-T",
             input.sharedPath,
             ...(input.items || []),
-        ], null, {
-            stderr: { toExitCode: true },
-            onSpawn: input.onSpawn,
-            log: {
+        ], {
+            $controller: input.controller,
+            $log: {
                 exec: options.verbose,
                 stderr: options.verbose,
                 allToStderr: true,
             },
         });
+        await process.waitForClose();
     }
     async function importFile(input) {
-        return await (0, process_1.exec)("mysql", [
+        const process = new async_process_1.AsyncProcess("mysql", [
             ...(await args()),
             `--init-command=SET ${[
                 "autocommit=0",
@@ -171,30 +144,39 @@ async function createMysqlCli(options) {
                 "foreign_key_checks=0",
             ].join(",")};`,
             input.database,
-        ], null, {
-            onSpawn: input.onSpawn,
-            pipe: {
-                stream: (0, fs_2.createReadStream)(input.path),
-                onReadProgress: (data) => {
-                    if (options.verbose)
-                        (0, process_1.logExecStdout)({
-                            data: JSON.stringify(data),
-                            colorize: true,
-                            stderr: true,
-                            lineSalt: true,
-                        });
-                },
-            },
-            stderr: { toExitCode: true },
-            log: options.verbose,
+        ], {
+            $log: options.verbose,
+            $controller: input.controller,
         });
+        await process.stdin.pipe(input.path, options.verbose
+            ? (data) => (0, process_1.logStdout)({
+                data: JSON.stringify(data),
+                colorize: true,
+                stderr: true,
+                lineSalt: true,
+            })
+            : undefined);
     }
     async function importCsvFile(input) {
-        return run(`
+        const query = `
       LOAD DATA LOCAL INFILE ${JSON.stringify(input.path.replaceAll("\\", "/"))}
       INTO TABLE ${input.table}
       FIELDS TERMINATED BY '\\t'
-      LINES TERMINATED BY '\\n'`, input.database, ["--local-infile"], input.onSpawn);
+      LINES TERMINATED BY '\\n'
+    `;
+        const process = new async_process_1.AsyncProcess("mysql", [
+            ...(await args()),
+            input.database,
+            "--local-infile",
+            "-e",
+            flatQuery(query),
+            "-N",
+            "--silent",
+        ], {
+            $controller: input.controller,
+            $log: options.verbose,
+        });
+        await process.waitForClose();
     }
     async function isDatabaseEmpty(database) {
         const [row] = await fetchAll(`
@@ -278,7 +260,6 @@ async function createMysqlCli(options) {
         options,
         initSharedDir,
         args,
-        run,
         execute,
         insert,
         changeDatabase,