@mittwald/cli 1.0.0-alpha.9 → 1.0.0-beta.2

package/dist/commands/cronjob/list.js

@@ -0,0 +1,40 @@
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { formatRelativeDate } from "../../rendering/textformat/formatDate.js";
+export class List extends ListBaseCommand {
+    static description = "List cron jobs belonging to a project.";
+    static aliases = ["project:cronjob:list"];
+    static deprecateAliases = true;
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        return await this.apiClient.cronjob.listCronjobs({ projectId });
+    }
+    getColumns(data) {
+        const { id, shortId, createdAt } = super.getColumns(data);
+        return {
+            id,
+            shortId,
+            interval: {},
+            description: {},
+            lastExecution: {
+                header: "Last execution",
+                get: (r) => {
+                    if (!r.latestExecution) {
+                        return "-";
+                    }
+                    return (r.latestExecution.status +
+                        ", " +
+                        // API specs are broken
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        formatRelativeDate(r.latestExecution.start));
+                },
+            },
+            createdAt,
+        };
+    }
+}

package/dist/commands/cronjob/update.d.ts

@@ -0,0 +1,25 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+import Duration from "../../lib/units/Duration.js";
+type UpdateResult = void;
+export default class Update extends ExecRenderBaseCommand<typeof Update, UpdateResult> {
+    static description: string;
+    static args: {
+        "cronjob-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        interval: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        email: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        command: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        interpreter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        enable: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        disable: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<Duration | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    protected render(): ReactNode;
+}
+export {};

package/dist/commands/cronjob/update.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { Args, Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { cronjobFlagDefinitions } from "../../lib/resources/cronjob/flags.js";
+import { buildCronjobDestination } from "../../lib/resources/cronjob/destination.js";
+import Duration from "../../lib/units/Duration.js";
+export default class Update extends ExecRenderBaseCommand {
+    static description = "Update an existing cron job";
+    static args = {
+        "cronjob-id": Args.string({
+            description: "ID of the cron job to be updated.",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...processFlags,
+        description: cronjobFlagDefinitions.description(),
+        interval: cronjobFlagDefinitions.interval(),
+        email: cronjobFlagDefinitions.email(),
+        url: cronjobFlagDefinitions.url({
+            exclusive: ["command"],
+        }),
+        command: cronjobFlagDefinitions.command({
+            exclusive: ["url"],
+            dependsOn: ["interpreter"],
+        }),
+        interpreter: cronjobFlagDefinitions.interpreter({
+            dependsOn: ["command"],
+        }),
+        enable: Flags.boolean({
+            exclusive: ["disable"],
+            summary: "Enable the cron job.",
+            description: "Set the status of the cron job to inactive. Automatic execution will be disabled.",
+        }),
+        disable: Flags.boolean({
+            exclusive: ["enable"],
+            summary: "Disable the cron job.",
+            description: "Set the status of the cron job to active. Automatic execution will be enabled.",
+        }),
+        timeout: Duration.relativeFlag({
+            summary: "Timeout after which the process will be killed.",
+            description: "Common duration formats are supported (for example, '1h', '30m', '30s'). " +
+                "Defines the amount of time after which a running cron job will be killed. " +
+                "If an email address is defined, an error message will be sent.",
+            required: false,
+        }),
+    };
+    async exec() {
+        const process = makeProcessRenderer(this.flags, "Updating cron job");
+        const { "cronjob-id": cronjobId } = this.args;
+        const currentCronjob = await this.apiClient.cronjob.getCronjob({
+            cronjobId,
+        });
+        assertSuccess(currentCronjob);
+        const { description, interval, email, timeout, url, interpreter, command, enable, disable, } = this.flags;
+        if (Object.keys(this.flags).length == 0) {
+            await process.complete(_jsx(Success, { children: "Nothing to change. Have a good day!" }));
+            return;
+        }
+        await process.runStep("Updating cron job", async () => {
+            const response = await this.apiClient.cronjob.updateCronjob({
+                cronjobId,
+                data: {
+                    destination: url || command
+                        ? buildCronjobDestination(url, command, interpreter)
+                        : undefined,
+                    active: enable ? true : disable ? false : undefined,
+                    description,
+                    timeout: timeout?.seconds,
+                    email,
+                    interval,
+                },
+            });
+            assertSuccess(response);
+        });
+        await process.complete(_jsx(Success, { children: "Your cron job has successfully been updated." }));
+    }
+    render() {
+        return true;
+    }
+}

package/dist/commands/database/mysql/charsets.d.ts

@@ -0,0 +1,22 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../../lib/basecommands/ListBaseCommand.js";
+import { ListColumns } from "../../../rendering/formatter/ListFormatter.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2MysqlCharsets.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlCharsets"]>>;
+export declare class Charsets extends ListBaseCommand<typeof Charsets, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-header": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-truncate": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-relative-dates": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "csv-separator": import("@oclif/core/interfaces").OptionFlag<"," | ";">;
+    };
+    protected sorter: (a: ResponseItem, b: ResponseItem) => number;
+    getData(): Promise<Response>;
+    protected getColumns(): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/database/mysql/charsets.js

@@ -0,0 +1,20 @@
+import { ListBaseCommand } from "../../../lib/basecommands/ListBaseCommand.js";
+export class Charsets extends ListBaseCommand {
+    static description = "List available MySQL character sets and collations, optionally filtered by a MySQLVersion.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    sorter = (a, b) => a.name.localeCompare(b.name);
+    async getData() {
+        return await this.apiClient.database.listMysqlCharsets({});
+    }
+    getColumns() {
+        return {
+            name: {},
+            collations: {
+                get: (item) => item.collations.join(", "),
+            },
+        };
+    }
+}

package/dist/commands/database/mysql/create.d.ts

@@ -0,0 +1,25 @@
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type Result = {
+    databaseId: string;
+    userId: string;
+};
+export declare class Create extends ExecRenderBaseCommand<typeof Create, Result> {
+    static summary: string;
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        collation: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "character-set": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "user-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "user-external": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "user-access-level": import("@oclif/core/interfaces").OptionFlag<"full" | "readonly", import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+    };
+    protected exec(): Promise<Result>;
+    private createMySQLDatabase;
+    private getPassword;
+    protected render({ databaseId }: Result): ReactNode;
+}
+export {};

package/dist/commands/database/mysql/create.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { projectFlags } from "../../../lib/resources/project/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import { Text } from "ink";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+export class Create extends ExecRenderBaseCommand {
+    static summary = "Create a new MySQL database";
+    static flags = {
+        ...projectFlags,
+        ...processFlags,
+        description: Flags.string({
+            char: "d",
+            summary: "a description for the database",
+            required: true,
+        }),
+        version: Flags.string({
+            summary: "the MySQL version to use",
+            description: 'Use the "database mysql versions" command to list available versions',
+            required: true,
+        }),
+        collation: Flags.string({
+            summary: "the collation to use",
+            default: "utf8mb4_unicode_ci",
+        }),
+        "character-set": Flags.string({
+            summary: "the character set to use",
+            default: "utf8mb4",
+        }),
+        "user-password": Flags.string({
+            summary: "the password to use for the default user (env: MYSQL_PWD)",
+            env: "MYSQL_PWD",
+        }),
+        "user-external": Flags.boolean({
+            summary: "enable external access for default user",
+            default: false,
+        }),
+        "user-access-level": Flags.custom({
+            summary: "the access level preset for the default user",
+            options: ["full", "readonly"],
+            default: "full",
+        })(),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Creating a new MySQL database");
+        const projectId = await this.withProjectId(Create);
+        const { description, version, collation, "character-set": characterSet, "user-external": externalAccess, "user-access-level": accessLevel, } = this.flags;
+        const password = await this.getPassword(p);
+        const db = await this.createMySQLDatabase(p, projectId, {
+            description,
+            version,
+            characterSettings: {
+                collation,
+                characterSet,
+            },
+        }, {
+            password,
+            externalAccess,
+            accessLevel,
+        });
+        const database = await p.runStep("fetching database", async () => {
+            const response = await this.apiClient.database.getMysqlDatabase({
+                mysqlDatabaseId: db.id,
+            });
+            assertStatus(response, 200);
+            return response.data;
+        });
+        const user = await p.runStep("fetching user", async () => {
+            const response = await this.apiClient.database.getMysqlUser({
+                mysqlUserId: db.userId,
+            });
+            assertStatus(response, 200);
+            return response.data;
+        });
+        await p.complete(_jsx(DatabaseCreateSuccess, { database: database, user: user }));
+        return { databaseId: db.id, userId: db.userId };
+    }
+    async createMySQLDatabase(p, projectId, database, user) {
+        return await p.runStep("creating MySQL database", async () => {
+            const r = await this.apiClient.database.createMysqlDatabase({
+                projectId,
+                data: {
+                    database: { projectId, ...database },
+                    user,
+                },
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+    }
+    async getPassword(p) {
+        if (this.flags["user-password"]) {
+            return this.flags["user-password"];
+        }
+        return await p.addInput(_jsx(Text, { children: "enter password for default user" }), true);
+    }
+    render({ databaseId }) {
+        if (this.flags.quiet) {
+            return databaseId;
+        }
+    }
+}
+function DatabaseCreateSuccess({ database, user, }) {
+    return (_jsxs(Success, { children: ["The database ", _jsx(Value, { children: database.name }), " and the user", " ", _jsx(Value, { children: user.name }), " were successfully created."] }));
+}

package/dist/commands/database/mysql/create.test.js

@@ -0,0 +1,117 @@
+import nock from "nock";
+import { runCommand } from "@oclif/test";
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
+describe("database:mysql:create", () => {
+    const projectId = "339d6458-839f-4809-a03d-78700069690c";
+    const databaseId = "83e0cb85-dcf7-4968-8646-87a63980ae91";
+    const userId = "a8c1eb2a-aa4d-4daf-8e21-9d91d56559ca";
+    const password = "secret";
+    const description = "Test";
+    const createFlags = [
+        "--project-id",
+        projectId,
+        "--version",
+        "8.0",
+        "--description",
+        description,
+        "--user-password",
+        password,
+    ];
+    let originalEnv;
+    beforeEach(() => {
+        originalEnv = { ...process.env };
+        process.env["MITTWALD_API_TOKEN"] = "foo";
+        nock.disableNetConnect();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        nock.cleanAll();
+    });
+    // Skipped, to be fixed later
+    it.skip("creates a database and prints database and user name", async () => {
+        const scope = nock("https://api.mittwald.de");
+        scope.get(`/v2/projects/${projectId}`).reply(200, {
+            id: projectId,
+        });
+        scope
+            .post(`/v2/projects/${projectId}/mysql-databases`, {
+            database: {
+                projectId,
+                description,
+                version: "8.0",
+                characterSettings: {
+                    collation: "utf8mb4_unicode_ci",
+                    characterSet: "utf8mb4",
+                },
+            },
+            user: {
+                password,
+                externalAccess: false,
+                accessLevel: "full",
+            },
+        })
+            .reply(201, { id: databaseId, userId });
+        scope.get(`/v2/mysql-databases/${databaseId}`).reply(200, {
+            id: databaseId,
+            name: "mysql_xxxxxx",
+        });
+        scope.get(`/v2/mysql-users/${userId}`).reply(200, {
+            id: userId,
+            name: "dbu_xxxxxx",
+        });
+        const { stdout, stderr, error } = await runCommand([
+            "database:mysql:create",
+            ...createFlags,
+        ]);
+        console.log("foo");
+        setTimeout(() => scope.done(), 5000);
+        expect(stdout).toContain("The database mysql_xxxxxx");
+        expect(stdout).toContain("the user dbu_xxxxxx");
+        expect(stderr).toEqual("");
+        expect(error).toBeUndefined();
+    });
+    // Skipped, to be fixed later
+    it.skip("retries fetching user until successful", async () => {
+        const scope = nock("https://api.mittwald.de");
+        scope.get(`/v2/projects/${projectId}`).reply(200, {
+            id: projectId,
+        });
+        scope
+            .post(`/v2/projects/${projectId}/mysql-databases`, {
+            database: {
+                projectId,
+                description,
+                version: "8.0",
+                characterSettings: {
+                    collation: "utf8mb4_unicode_ci",
+                    characterSet: "utf8mb4",
+                },
+            },
+            user: {
+                password,
+                externalAccess: false,
+                accessLevel: "full",
+            },
+        })
+            .reply(201, { id: databaseId, userId });
+        scope.get(`/v2/mysql-databases/${databaseId}`).reply(200, {
+            id: databaseId,
+            name: "mysql_xxxxxx",
+        });
+        scope.get(`/v2/mysql-users/${userId}`).times(3).reply(403);
+        scope.get(`/v2/mysql-users/${userId}`).reply(200, {
+            id: userId,
+            name: "dbu_xxxxxx",
+        });
+        const { stdout, stderr, error } = await runCommand([
+            "database:mysql:create",
+            ...createFlags,
+        ]);
+        console.log("foo");
+        setTimeout(() => scope.done(), 5000);
+        expect(stdout).toContain("The database mysql_xxxxxx");
+        expect(stdout).toContain("the user dbu_xxxxxx");
+        expect(stderr).toEqual("");
+        expect(error).toBeUndefined();
+    });
+});

package/dist/commands/database/mysql/delete.d.ts

@@ -0,0 +1,13 @@
+import { DeleteBaseCommand } from "../../../lib/basecommands/DeleteBaseCommand.js";
+export default class Delete extends DeleteBaseCommand<typeof Delete> {
+    static description: string;
+    static resourceName: string;
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected deleteResource(): Promise<void>;
+}

package/dist/commands/database/mysql/delete.js

@@ -0,0 +1,16 @@
+import { DeleteBaseCommand } from "../../../lib/basecommands/DeleteBaseCommand.js";
+import { mysqlArgs, withMySQLId, } from "../../../lib/resources/database/mysql/flags.js";
+import assertSuccess from "../../../lib/apiutil/assert_success.js";
+export default class Delete extends DeleteBaseCommand {
+    static description = "Delete a MySQL database";
+    static resourceName = "MySQL database";
+    static flags = { ...DeleteBaseCommand.baseFlags };
+    static args = { ...mysqlArgs };
+    async deleteResource() {
+        const mysqlDatabaseId = await withMySQLId(this.apiClient, this.flags, this.args);
+        const response = await this.apiClient.database.deleteMysqlDatabase({
+            mysqlDatabaseId,
+        });
+        assertSuccess(response);
+    }
+}

package/dist/commands/database/mysql/dump.d.ts

@@ -0,0 +1,21 @@
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Dump extends ExecRenderBaseCommand<typeof Dump, Record<string, never>> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        gzip: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "ssh-user": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "ssh-identity-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "temporary-user": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "mysql-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Record<string, never>>;
+    protected render(): ReactNode;
+    private getOutputStream;
+}

package/dist/commands/database/mysql/dump.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import { Text } from "ink";
+import { Value } from "../../../rendering/react/components/Value.js";
+import * as fs from "fs";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { mysqlArgs, mysqlConnectionFlagsWithTempUser, withMySQLId, } from "../../../lib/resources/database/mysql/flags.js";
+import { runWithConnectionDetails } from "../../../lib/resources/database/mysql/connect.js";
+import { executeViaSSH } from "../../../lib/resources/ssh/exec.js";
+import shellEscape from "shell-escape";
+import { sshConnectionFlags } from "../../../lib/resources/ssh/flags.js";
+import { sshUsageDocumentation } from "../../../lib/resources/ssh/doc.js";
+export class Dump extends ExecRenderBaseCommand {
+    static summary = "Create a dump of a MySQL database";
+    static description = "This command creates a dump of a MySQL database via mysqldump and saves it to a local file.\n\n" +
+        sshUsageDocumentation;
+    static flags = {
+        ...processFlags,
+        ...mysqlConnectionFlagsWithTempUser,
+        ...sshConnectionFlags,
+        output: Flags.string({
+            char: "o",
+            summary: 'the output file to write the dump to ("-" for stdout)',
+            description: 'The output file to write the dump to. You can specify "-" or "/dev/stdout" to write the dump directly to STDOUT; in this case, you might want to use the --quiet/-q flag to supress all other output, so that you can pipe the mysqldump for further processing.',
+            required: true,
+        }),
+        gzip: Flags.boolean({
+            summary: "compress the dump with gzip",
+            aliases: ["gz"],
+            description: "Compress the dump with gzip. This is useful for large databases, as it can significantly reduce the size of the dump.",
+            default: false,
+            required: false,
+        }),
+    };
+    static args = { ...mysqlArgs };
+    async exec() {
+        const databaseId = await withMySQLId(this.apiClient, this.flags, this.args);
+        const p = makeProcessRenderer(this.flags, "Dumping a MySQL database");
+        const databaseName = await runWithConnectionDetails(this.apiClient, databaseId, p, this.flags, async (connectionDetails) => {
+            const { project } = connectionDetails;
+            const mysqldumpArgs = buildMySqlDumpArgs(connectionDetails);
+            let cmd = { command: "mysqldump", args: mysqldumpArgs };
+            if (this.flags.gzip) {
+                const escapedArgs = shellEscape(mysqldumpArgs);
+                cmd = {
+                    shell: `set -e -o pipefail > /dev/null ; mysqldump ${escapedArgs} | gzip`,
+                };
+            }
+            await p.runStep(_jsxs(Text, { children: ["starting mysqldump via SSH on project", " ", _jsx(Value, { children: project.shortId })] }), () => executeViaSSH(this.apiClient, this.flags, { projectId: connectionDetails.project.id }, cmd, { input: null, output: this.getOutputStream() }));
+            return connectionDetails.database;
+        });
+        await p.complete(_jsx(DumpSuccess, { database: databaseName, output: this.flags.output }));
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+    getOutputStream() {
+        if (this.flags.output === "-") {
+            return process.stdout;
+        }
+        return fs.createWriteStream(this.flags.output);
+    }
+}
+function DumpSuccess({ database, output, }) {
+    return (_jsxs(Success, { children: ["Dump of MySQL database ", _jsx(Value, { children: database }), " written to", " ", _jsx(Value, { children: output })] }));
+}
+function buildMySqlDumpArgs(d) {
+    return ["-h", d.hostname, "-u", d.user, `-p${d.password}`, d.database];
+}

package/dist/commands/database/mysql/get.d.ts

@@ -0,0 +1,15 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../../lib/basecommands/GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlDatabasesMysqlDatabaseId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["database"]["getMysqlDatabase"]>>;
+export declare abstract class Get extends GetBaseCommand<typeof Get, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/interfaces").Flag<any>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+}
+export {};

package/dist/commands/database/mysql/get.js

@@ -0,0 +1,15 @@
+import { GetBaseCommand } from "../../../lib/basecommands/GetBaseCommand.js";
+import { mysqlArgs, withMySQLId, } from "../../../lib/resources/database/mysql/flags.js";
+export class Get extends GetBaseCommand {
+    static description = "Get a MySQLDatabase.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = { ...mysqlArgs };
+    async getData() {
+        const mysqlDatabaseId = await withMySQLId(this.apiClient, this.flags, this.args);
+        return await this.apiClient.database.getMysqlDatabase({
+            mysqlDatabaseId,
+        });
+    }
+}

package/dist/commands/database/mysql/import.d.ts

@@ -0,0 +1,21 @@
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Import extends ExecRenderBaseCommand<typeof Import, Record<string, never>> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        input: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        gzip: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "ssh-user": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "ssh-identity-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "temporary-user": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "mysql-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Record<string, never>>;
+    protected render(): ReactNode;
+    private getInputStream;
+}