@mittwald/cli 1.0.0-alpha.11 → 1.0.0-alpha.14

package/dist/esm/DeleteBaseCommand.js

@@ -1,7 +1,7 @@
 import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { Flags, ux } from "@oclif/core";
 import { ExecRenderBaseCommand } from "./rendering/react/ExecRenderBaseCommand.js";
-import { makeProcessRenderer, processFlags, } from "./rendering/react/process_flags.js";
+import { makeProcessRenderer, processFlags, } from "./rendering/process/process_flags.js";
 import { Success } from "./rendering/react/components/Success.js";
 import { Text } from "ink";
 export class DeleteBaseCommand extends ExecRenderBaseCommand {

package/dist/esm/Helpers.d.ts

@@ -3,4 +3,5 @@ export declare function isUuid(id: string): boolean;
 export declare function isProjectShortId(id: string): boolean;
 export declare function normalizeProjectIdToUuid(apiClient: MittwaldAPIV2Client, uuidOrShortId: string): Promise<string>;
 export declare function normalizeServerIdToUuid(apiClient: MittwaldAPIV2Client, uuidOrShortId: string): Promise<string>;
+export declare function normalizeCustomerIdToUuid(apiClient: MittwaldAPIV2Client, uuidOrShortId: string): Promise<string>;
 export declare function normalizeConversationIdToUuid(apiClient: MittwaldAPIV2Client, uuidOrShortId: string): Promise<string>;

package/dist/esm/Helpers.js

@@ -1,4 +1,4 @@
-import { getConversationUuidFromShortId, getProjectUuidFromShortId, getServerUuidFromShortId, } from "./Translator.js";
+import { getConversationUuidFromShortId, getCustomerUuidFromCustomerNumber, getProjectUuidFromShortId, getServerUuidFromShortId, } from "./Translator.js";
 const uuidRegex = RegExp("^[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}$");
 const projectShortIdRegex = RegExp("p-[0-9a-zA-Z]{6}");
 export function isUuid(id) {
@@ -22,6 +22,12 @@ export async function normalizeServerIdToUuid(apiClient, uuidOrShortId) {
     }
     return await getServerUuidFromShortId(apiClient, uuidOrShortId);
 }
+export async function normalizeCustomerIdToUuid(apiClient, uuidOrShortId) {
+    if (isUuid(uuidOrShortId)) {
+        return uuidOrShortId;
+    }
+    return await getCustomerUuidFromCustomerNumber(apiClient, uuidOrShortId);
+}
 export async function normalizeConversationIdToUuid(apiClient, uuidOrShortId) {
     if (isUuid(uuidOrShortId)) {
         return uuidOrShortId;

package/dist/esm/Translator.d.ts

@@ -1,6 +1,7 @@
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 export declare function getProjectUuidFromShortId(apiClient: MittwaldAPIV2Client, shortId: string): Promise<string>;
 export declare function getServerUuidFromShortId(apiClient: MittwaldAPIV2Client, shortId: string): Promise<string>;
+export declare function getCustomerUuidFromCustomerNumber(apiClient: MittwaldAPIV2Client, shortId: string): Promise<string>;
 export declare function getConversationUuidFromShortId(apiClient: MittwaldAPIV2Client, shortId: string): Promise<string>;
 export declare function getAppNameFromUuid(apiClient: MittwaldAPIV2Client, uuid: string): Promise<string>;
 export declare function getAppVersionFromUuid(apiClient: MittwaldAPIV2Client, appId: string, appVersionId: string): Promise<string>;

package/dist/esm/Translator.js

@@ -25,6 +25,17 @@ export async function getServerUuidFromShortId(apiClient, shortId) {
     }
     throw new Error("Access Denied.");
 }
+export async function getCustomerUuidFromCustomerNumber(apiClient, shortId) {
+    const customers = await apiClient.customer.listCustomers();
+    assertStatus(customers, 200);
+    const foundCustomer = customers.data.find((item) => {
+        return item.customerNumber === shortId;
+    });
+    if (foundCustomer) {
+        return foundCustomer.customerId;
+    }
+    throw new Error("Access Denied.");
+}
 export async function getConversationUuidFromShortId(apiClient, shortId) {
     const conversations = await apiClient.conversation.listConversations();
     assertStatus(conversations, 200);

package/dist/esm/commands/app/install/wordpress.js

@@ -5,7 +5,7 @@ import { getAppVersionUuidFromAppVersion, getLatestAvailableAppVersionForApp, }
 import { assertStatus } from "@mittwald/api-client-commons";
 import { projectFlags, withProjectId } from "../../../lib/project/flags.js";
 import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
-import { makeProcessRenderer, processFlags, } from "../../../rendering/react/process_flags.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
 import { Value } from "../../../rendering/react/components/Value.js";
 import { Text } from "ink";
 import { Success } from "../../../rendering/react/components/Success.js";

package/dist/esm/commands/context/set.js

@@ -1,7 +1,7 @@
 import { Flags } from "@oclif/core";
 import { Context } from "../../lib/context.js";
 import { BaseCommand } from "../../BaseCommand.js";
-import { normalizeProjectIdToUuid, normalizeServerIdToUuid, } from "../../Helpers.js";
+import { normalizeCustomerIdToUuid, normalizeProjectIdToUuid, normalizeServerIdToUuid, } from "../../Helpers.js";
 export class Set extends BaseCommand {
     static summary = "Set context values for the current project, org or server";
     static description = "The context allows you to persistently set values for common parameters, like --project-id or --server-id, so you don't have to specify them on every command.";
@@ -30,8 +30,9 @@ export class Set extends BaseCommand {
             this.log(`Set server ID to ${serverId}`);
         }
         if (flags["org-id"]) {
-            await ctx.setOrgId(flags["org-id"]);
-            this.log(`Set organization ID to ${flags["org-id"]}`);
+            const orgId = await normalizeCustomerIdToUuid(this.apiClient, flags["org-id"]);
+            await ctx.setOrgId(orgId);
+            this.log(`Set organization ID to ${orgId}`);
         }
     }
 }

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

@@ -1,9 +1,20 @@
 import { Simplify } from "@mittwald/api-client-commons";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { SuccessfulResponse } from "../../../types.js";
-import { GeneratedDatabaseListMysqlCharsets, Response } from "../../../generated/database/listMysqlCharsets.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { ListColumns } from "../../../Formatter.js";
 type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2MysqlCharsets.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedDatabaseListMysqlCharsets<ResponseItem> {
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlCharsets.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlCharsets"]>>;
+export declare class Charsets extends ListBaseCommand<typeof Charsets, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
     protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.DatabaseMySqlCharacterSettings[];
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
 }
 export {};

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

@@ -1,6 +1,29 @@
-import { GeneratedDatabaseListMysqlCharsets, } from "../../../generated/database/listMysqlCharsets.js";
-export default class List extends GeneratedDatabaseListMysqlCharsets {
+import { ListBaseCommand } from "../../../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,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.database.listMysqlCharsets({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
     mapData(data) {
+        data.sort((a, b) => a.name.localeCompare(b.name));
         return data;
     }
+    getColumns(data) {
+        return {
+            name: {},
+            collations: {
+                get: (item) => item.collations.join(", "),
+            },
+        };
+    }
 }

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

@@ -0,0 +1,23 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/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/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        collation: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "character-set": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "user-password": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "user-external": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "user-access-level": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<Result>;
+    private getPassword;
+    protected render({ databaseId }: Result): ReactNode;
+}
+export {};

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

@@ -0,0 +1,103 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { projectFlags, withProjectId } from "../../../lib/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.string({
+            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 withProjectId(this.apiClient, this.flags, this.args, this.config);
+        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 p.runStep("creating MySQL database", async () => {
+            const r = await this.apiClient.database.createMysqlDatabase({
+                pathParameters: { projectId },
+                data: {
+                    database: {
+                        projectId,
+                        description,
+                        version,
+                        characterSettings: {
+                            collation,
+                            characterSet,
+                        },
+                    },
+                    user: {
+                        password,
+                        externalAccess,
+                        accessLevel: accessLevel,
+                    },
+                },
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+        const database = await p.runStep("fetching database", async () => {
+            const r = await this.apiClient.database.getMysqlDatabase({
+                pathParameters: { id: db.id },
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        const user = await p.runStep("fetching user", async () => {
+            const r = await this.apiClient.database.getMysqlUser({
+                pathParameters: { id: db.userId },
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        p.complete(_jsxs(Success, { children: ["The database ", _jsx(Value, { children: database.name }), " and the user", " ", _jsx(Value, { children: user.name }), " were successfully created."] }));
+        return { databaseId: db.id, userId: db.userId };
+    }
+    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;
+        }
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { normalizeProjectIdToUuid } from "../../../Helpers.js";
+import { DeleteBaseCommand } from "../../../DeleteBaseCommand.js";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.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 id = await withMySQLId(this.apiClient, this.flags, this.args, this.config);
+        const response = await this.apiClient.database.deleteMysqlDatabase({
+            pathParameters: { id },
+        });
+        assertStatus(response, 200);
+    }
+    mapResourceId(id) {
+        return normalizeProjectIdToUuid(this.apiClient, id);
+    }
+}

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

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

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

@@ -0,0 +1,70 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import * as cp from "child_process";
+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, mysqlConnectionFlags, withMySQLId, } from "../../../lib/database/mysql/flags.js";
+import { getConnectionDetailsWithPassword } from "../../../lib/database/mysql/connect.js";
+export class Dump extends ExecRenderBaseCommand {
+    static summary = "Create a dump of a MySQL database";
+    static flags = {
+        ...processFlags,
+        ...mysqlConnectionFlags,
+        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,
+        }),
+    };
+    static args = { ...mysqlArgs };
+    async exec() {
+        const databaseId = await withMySQLId(this.apiClient, this.flags, this.args, this.config);
+        const p = makeProcessRenderer(this.flags, "Dumping a MySQL database");
+        const { sshUser, sshHost, user, hostname, database, password } = await getConnectionDetailsWithPassword(this.apiClient, databaseId, p, this.flags);
+        const sshArgs = [
+            "-l",
+            sshUser,
+            "-T",
+            sshHost,
+            "mysqldump",
+            "-h",
+            hostname,
+            "-u",
+            user,
+            "-p" + password,
+            database,
+        ];
+        const stream = fs.createWriteStream(this.flags.output);
+        await p.runStep(_jsxs(Text, { children: ["starting mysqldump via SSH on ", _jsx(Value, { children: sshHost }), " as", " ", _jsx(Value, { children: sshUser })] }), () => {
+            const ssh = cp.spawn("ssh", sshArgs, {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let err = "";
+            ssh.stdout.pipe(stream);
+            ssh.stderr.on("data", (data) => {
+                err += data.toString();
+            });
+            return new Promise((res, rej) => {
+                ssh.on("exit", (code) => {
+                    stream.close();
+                    if (code === 0) {
+                        res(undefined);
+                    }
+                    else {
+                        rej(new Error(`ssh+mysqldump exited with code ${code}\n${err}`));
+                    }
+                });
+            });
+        });
+        p.complete(_jsxs(Success, { children: ["Dump of MySQL database ", _jsx(Value, { children: database }), " written to", " ", _jsx(Value, { children: this.flags.output })] }));
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+}

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

@@ -1,3 +1,15 @@
-import { GeneratedDatabaseGetMysqlDatabase } from "../../../generated/database/getMysqlDatabase.js";
-export default class Get extends GeneratedDatabaseGetMysqlDatabase {
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlDatabasesId.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/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
 }
+export {};

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

@@ -1,6 +1,15 @@
-/* eslint-disable */
-/* prettier-ignore */
-/* This file is auto-generated with acg (@mittwald/api-code-generator) */
-import { GeneratedDatabaseGetMysqlDatabase } from "../../../generated/database/getMysqlDatabase.js";
-export default class Get extends GeneratedDatabaseGetMysqlDatabase {
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.js";
+export class Get extends GetBaseCommand {
+    static description = "Get a MySQLDatabase.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = { ...mysqlArgs };
+    async getData() {
+        const id = await withMySQLId(this.apiClient, this.flags, this.args, this.config);
+        return await this.apiClient.database.getMysqlDatabase({
+            pathParameters: { id },
+        });
+    }
 }

package/dist/esm/commands/database/mysql/list.d.ts

@@ -1,10 +1,18 @@
 import { Simplify } from "@mittwald/api-client-commons";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { SuccessfulResponse } from "../../../types.js";
-import { GeneratedDatabaseListMysqlDatabases, Response } from "../../../generated/database/listMysqlDatabases.js";
 import { ListColumns } from "../../../Formatter.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
 type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdMysqlDatabases.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedDatabaseListMysqlDatabases<ResponseItem> {
+export type PathParams = MittwaldAPIV2.Paths.V2ProjectsProjectIdMysqlDatabases.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlDatabases"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any> | import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
+    };
+    getData(): Promise<Response>;
     protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.DatabaseMySqlDatabase[];
     protected getColumns(ignoredData: ResponseItem[]): ListColumns<ResponseItem>;
 }

package/dist/esm/commands/database/mysql/list.js

@@ -1,25 +1,38 @@
-import { GeneratedDatabaseListMysqlDatabases, } from "../../../generated/database/listMysqlDatabases.js";
 import { formatBytes } from "../../../lib/viewhelpers/size.js";
-export default class List extends GeneratedDatabaseListMysqlDatabases {
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { projectFlags, withProjectId } from "../../../lib/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List MySQLDatabases belonging to a Project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await withProjectId(this.apiClient, this.flags, this.args, this.config);
+        return await this.apiClient.database.listMysqlDatabases({
+            pathParameters: { projectId },
+        });
+    }
     mapData(data) {
         return data;
     }
     getColumns(ignoredData) {
         const commonColumns = super.getColumns(ignoredData);
         return {
-            ...commonColumns,
+            id: commonColumns.id,
             name: {
-                header: "name",
+                header: "Name",
                 minWidth: 12,
             },
             version: {
-                header: "version",
+                header: "Version",
             },
             description: {
-                header: "description",
+                header: "Description",
             },
             hostname: {
-                header: "hostname",
+                header: "Hostname",
             },
             status: {
                 header: "Status",
@@ -30,12 +43,8 @@ export default class List extends GeneratedDatabaseListMysqlDatabases {
                     return "ready";
                 },
             },
-            isShared: {
-                header: "isShared",
-                extended: true,
-            },
             characterSet: {
-                header: "Charset",
+                header: "Character Set",
                 get: (row) => row.characterSettings?.characterSet,
                 extended: true,
             },
@@ -45,10 +54,11 @@ export default class List extends GeneratedDatabaseListMysqlDatabases {
                 extended: true,
             },
             size: {
-                header: "size",
+                header: "Size",
                 // there is an error in the API mapping
                 get: (row) => formatBytes(row.size.low),
             },
+            createdAt: commonColumns.createdAt,
         };
     }
 }

package/dist/esm/commands/database/mysql/phpmyadmin.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from "../../../BaseCommand.js";
+export declare class PhpMyAdmin extends BaseCommand {
+    static summary: string;
+    static args: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/esm/commands/database/mysql/phpmyadmin.js

@@ -0,0 +1,25 @@
+import { BaseCommand } from "../../../BaseCommand.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import open from "open";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.js";
+export class PhpMyAdmin extends BaseCommand {
+    static summary = "Open phpMyAdmin for a MySQL database.";
+    static args = { ...mysqlArgs };
+    async run() {
+        const { flags, args } = await this.parse(PhpMyAdmin);
+        const databaseId = await withMySQLId(this.apiClient, flags, args, this.config);
+        const users = await this.apiClient.database.listMysqlUsers({
+            pathParameters: { databaseId },
+        });
+        assertStatus(users, 200);
+        const mainUser = users.data.find((u) => u.mainUser);
+        if (!mainUser) {
+            throw new Error("no main user found.");
+        }
+        const pma = await this.apiClient.database.getMysqlUserPhpMyAdminUrl({
+            pathParameters: { id: mainUser.id },
+        });
+        assertStatus(pma, 200);
+        await open(pma.data.url);
+    }
+}

package/dist/esm/commands/database/mysql/port-forward.d.ts

@@ -0,0 +1,14 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class PortForward extends ExecRenderBaseCommand<typeof PortForward, Record<string, never>> {
+    static summary: string;
+    static flags: {
+        port: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Record<string, never>>;
+    protected render(): ReactNode;
+}

package/dist/esm/commands/database/mysql/port-forward.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import * as cp from "child_process";
+import { Text } from "ink";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.js";
+import { getConnectionDetails } from "../../../lib/database/mysql/connect.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { Flags } from "@oclif/core";
+export class PortForward extends ExecRenderBaseCommand {
+    static summary = "Forward the TCP port of a MySQL database to a local port";
+    static flags = {
+        ...processFlags,
+        port: Flags.integer({
+            summary: "The local TCP port to forward to",
+            default: 3306,
+        }),
+    };
+    static args = { ...mysqlArgs };
+    async exec() {
+        const databaseId = await withMySQLId(this.apiClient, this.flags, this.args, this.config);
+        const p = makeProcessRenderer(this.flags, "Port-forwarding a MySQL database");
+        const { sshUser, sshHost, hostname, database } = await getConnectionDetails(this.apiClient, databaseId, p);
+        const { port } = this.flags;
+        p.complete(_jsxs(Text, { children: ["Forwarding MySQL database ", _jsx(Value, { children: database }), " to local port", " ", _jsx(Value, { children: port }), ". Use CTRL+C to cancel."] }));
+        const sshArgs = [
+            "-T",
+            "-L",
+            `${port}:${hostname}:3306`,
+            "-l",
+            sshUser,
+            sshHost,
+            "cat",
+            "/dev/zero",
+        ];
+        cp.spawnSync("ssh", sshArgs, {
+            stdio: ["ignore", process.stdout, process.stderr],
+        });
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+}