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

package/dist/lib/resources/app/versions.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { gt } from "semver";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { Text } from "ink";
+import { getAppInstallationFromUuid, getAppNameFromUuid } from "./uuid.js";
+import { compare } from "semver";
+export async function normalizeToAppVersionUuid(apiClient, version, process, appUuid) {
+    let appVersion;
+    if (version && version !== "latest") {
+        appVersion = await getAppVersionUuidFromAppVersion(apiClient, appUuid, version);
+    }
+    else {
+        appVersion = await getLatestAvailableAppVersionForApp(apiClient, appUuid);
+    }
+    if (!appVersion) {
+        throw new Error(`${await getAppNameFromUuid(apiClient, appUuid)} version ${version} does not seem to exist for the mStudio.`);
+    }
+    process.addInfo(_jsxs(Text, { children: ["installing version: ", _jsx(Value, { children: appVersion.externalVersion })] }));
+    return appVersion;
+}
+// Get latest available Internal App Version for App UUID
+export async function getLatestAvailableAppVersionForApp(apiClient, appId) {
+    const versions = await apiClient.app.listAppversions({
+        appId,
+    });
+    assertStatus(versions, 200);
+    if (versions.data.length === 0) {
+        return undefined;
+    }
+    let latestVersion = "0.0.0";
+    for (const version of versions.data) {
+        if (gt(version.internalVersion, latestVersion)) {
+            latestVersion = version.internalVersion;
+        }
+    }
+    return versions.data.find((item) => item.internalVersion === latestVersion);
+}
+export async function getAllUpgradeCandidatesFromAppInstallationId(apiClient, appInstallationId) {
+    const currentAppInstallation = await getAppInstallationFromUuid(apiClient, appInstallationId), updateCandidates = await apiClient.app.listUpdateCandidatesForAppversion({
+        appId: currentAppInstallation.appId,
+        baseAppVersionId: currentAppInstallation.appVersion.current,
+    });
+    assertStatus(updateCandidates, 200);
+    return sortArrayByExternalVersion(updateCandidates.data);
+}
+export async function getLatestAvailableTargetAppVersionForAppVersionUpgradeCandidates(apiClient, appId, baseAppVersionId) {
+    const versions = await apiClient.app.listUpdateCandidatesForAppversion({
+        appId,
+        baseAppVersionId,
+    });
+    assertStatus(versions, 200);
+    if (versions.data.length === 0) {
+        return undefined;
+    }
+    let latestVersion;
+    for (const version of versions.data) {
+        if (gt(version.internalVersion, latestVersion?.internalVersion ?? "0.0.0")) {
+            latestVersion = version;
+        }
+    }
+    return latestVersion;
+}
+export async function getAvailableTargetAppVersionFromExternalVersion(apiClient, appId, baseAppVersionId, targetExternalVersion) {
+    const versions = await apiClient.app.listUpdateCandidatesForAppversion({
+        appId,
+        baseAppVersionId,
+    });
+    assertStatus(versions, 200);
+    return versions.data.find((item) => item.externalVersion === targetExternalVersion);
+}
+export async function getAppVersionUuidFromAppVersion(apiClient, appId, appVersion) {
+    const versions = await apiClient.app.listAppversions({
+        appId,
+    });
+    if (!appVersion) {
+        return getLatestAvailableAppVersionForApp(apiClient, appId);
+    }
+    assertStatus(versions, 200);
+    return versions.data.find((item) => item.internalVersion === appVersion ||
+        item.externalVersion === appVersion);
+}
+export function sortArrayByExternalVersion(versions) {
+    return versions.sort((a, b) => compare(b.externalVersion, a.externalVersion));
+}

package/dist/lib/resources/app/wait.d.ts

@@ -0,0 +1,4 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../../rendering/process/process.js";
+import Duration from "../../units/Duration.js";
+export declare function waitUntilAppStateHasNormalized(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, appInstallationId: string, label: string, timeout: Duration): Promise<void>;

package/dist/lib/resources/app/wait.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { waitUntil } from "../../wait.js";
+import { Text } from "ink";
+export async function waitUntilAppStateHasNormalized(apiClient, process, appInstallationId, label, timeout) {
+    const stepWaiting = process.addStep(_jsx(Text, { children: label }));
+    await waitUntil(async () => {
+        const installationResponse = await apiClient.app.getAppinstallation({
+            appInstallationId,
+        });
+        if (installationResponse.status === 200 &&
+            installationResponse.data.appVersion.current ==
+                installationResponse.data.appVersion.desired) {
+            return true;
+        }
+    }, timeout);
+    stepWaiting.complete();
+}

package/dist/lib/resources/backup/flags.d.ts

@@ -0,0 +1,5 @@
+export declare const backupFlags: import("../../context/FlagSetBuilder.js").ContextFlags<"backup">, backupArgs: import("../../context/FlagSetBuilder.js").ContextArgs<"backup">, withBackupId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, command: "flag" | "arg" | import("../../context/FlagSetBuilder.js").CommandType<"backup">, flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}, cfg: import("@oclif/core").Config) => Promise<string>;

package/dist/lib/resources/backup/flags.js

@@ -0,0 +1,4 @@
+import FlagSetBuilder from "../../context/FlagSetBuilder.js";
+export const { flags: backupFlags, args: backupArgs, withId: withBackupId, } = new FlagSetBuilder("backup", "b", {
+    retrieveFromContext: false,
+}).build();

package/dist/lib/resources/backup/schedule/flags.d.ts

@@ -0,0 +1,14 @@
+export declare const backupScheduleFlagDefinitions: {
+    description: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    schedule: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    ttl: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+};

package/dist/lib/resources/backup/schedule/flags.js

@@ -0,0 +1,18 @@
+import { Flags } from "@oclif/core";
+export const backupScheduleFlagDefinitions = {
+    description: Flags.custom({
+        summary: "Set the description for the backup schedule.",
+        description: "Set the description for the given backup schedule to be displayed in mStudio and with the list command.",
+    }),
+    schedule: Flags.custom({
+        summary: "Set the interval at which the backup should be scheduled.",
+        description: "Must be specified as a cron schedule expression. " +
+            "Cannot be scheduled more often than once per hour. " +
+            "Defines the interval at which the backup creation will be executed.",
+    }),
+    ttl: Flags.custom({
+        summary: "Define the backup retention period in days for backups created.",
+        description: "Must be specified as an amount of days between 7 and 400 in the format [amount]d - e.g. '7d' for 7 days. " +
+            "This will define the number of days the backup will be kept.",
+    }),
+};

package/dist/lib/resources/conversation/flags.d.ts

@@ -0,0 +1,6 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare const conversationFlags: import("../../context/FlagSetBuilder.js").ContextFlags<"conversation">, conversationArgs: import("../../context/FlagSetBuilder.js").ContextArgs<"conversation">, withConversationId: (apiClient: MittwaldAPIV2Client, command: "flag" | "arg" | import("../../context/FlagSetBuilder.js").CommandType<"conversation">, flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}, cfg: import("@oclif/core").Config) => Promise<string>;

package/dist/lib/resources/conversation/flags.js

@@ -0,0 +1,12 @@
+import { assertStatus } from "@mittwald/api-client";
+import FlagSetBuilder from "../../context/FlagSetBuilder.js";
+import { contextIDNormalizers } from "../../context/Context.js";
+async function normalize(apiClient, conversationId) {
+    const conversation = await apiClient.conversation.getConversation({
+        conversationId,
+    });
+    assertStatus(conversation, 200);
+    return conversation.data.conversationId;
+}
+contextIDNormalizers["conversation-id"] = normalize;
+export const { flags: conversationFlags, args: conversationArgs, withId: withConversationId, } = new FlagSetBuilder("conversation", "c", { normalize }).build();

package/dist/lib/resources/conversation/message_input.d.ts

@@ -0,0 +1,10 @@
+export declare const messageFlags: {
+    message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    "message-from": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    editor: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+};
+export declare function retrieveMessage(flags: {
+    message?: string;
+    "message-from"?: string;
+    editor: string;
+}): Promise<string | undefined>;

package/dist/lib/resources/cronjob/destination.d.ts

@@ -0,0 +1,4 @@
+import type { MittwaldAPIV2Client } from "@mittwald/api-client";
+type CronjobCreationData = Parameters<MittwaldAPIV2Client["cronjob"]["createCronjob"]>[0]["data"];
+export declare function buildCronjobDestination(url: string | undefined, command: string | undefined, interpreter: string | undefined): CronjobCreationData["destination"];
+export {};

package/dist/lib/resources/cronjob/destination.js

@@ -0,0 +1,22 @@
+export function buildCronjobDestination(url, command, interpreter) {
+    if (url) {
+        return { url };
+    }
+    if (command && interpreter) {
+        return {
+            interpreter: mapInterpreterToFullPath(interpreter),
+            path: command,
+        };
+    }
+    throw new Error("Url or command and interpreter combination could not be parsed.");
+}
+function mapInterpreterToFullPath(interpreter) {
+    switch (interpreter) {
+        case "bash":
+            return "/bin/bash";
+        case "php":
+            return "/usr/bin/php";
+        default:
+            throw new Error("Interpreter shorthand '" + interpreter + "' could not be mapped.");
+    }
+}

package/dist/lib/resources/cronjob/flags.d.ts

@@ -0,0 +1,26 @@
+export declare const cronjobFlagDefinitions: {
+    description: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    interval: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    email: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    url: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    command: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    interpreter: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+};

package/dist/lib/resources/cronjob/flags.js

@@ -0,0 +1,28 @@
+import { Flags } from "@oclif/core";
+export const cronjobFlagDefinitions = {
+    description: Flags.custom({
+        summary: "Set cron job description.",
+        description: "This will be displayed as the cron jobs 'name' of the cron job in mStudio.",
+    }),
+    interval: Flags.custom({
+        summary: "Set the interval for cron jobs to run.",
+        description: "Must be specified as a cron schedule expression. Defines the interval at which the cron job will be executed.",
+    }),
+    email: Flags.custom({
+        summary: "Set the target email to which error messages will be sent.",
+        description: "If a cron job fails, a detailed error message will be sent to this email address.",
+    }),
+    url: Flags.custom({
+        summary: "Set the URL to use when running a cron job.",
+        description: "Define a URL with protocol to which a request will be dispatched when the cron job is executed. For example: 'https://my-website.com/cron-job'. Not required if a command and interpreter is defined.",
+    }),
+    command: Flags.custom({
+        summary: "Specify the file and arguments to be executed when the cron job is run.",
+        description: " Specifies a file to be executed with the specified interpreter. Additional arguments can be appended to the command to be passed to the script. Not required if a URL is given.",
+    }),
+    interpreter: Flags.custom({
+        options: ["bash", "php"],
+        summary: "Set the interpreter to be used for execution.",
+        description: "Must be either 'bash' or 'php'. Define the interpreter to be used to execute the previously defined command. The interpreter should match the corresponding command or script.",
+    }),
+};

package/dist/lib/resources/database/common.d.ts

@@ -0,0 +1,9 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../../rendering/process/process.js";
+type ProjectProject = MittwaldAPIV2.Components.Schemas.ProjectProject;
+type SignupAccount = MittwaldAPIV2.Components.Schemas.SignupAccount;
+export declare function getUser(apiClient: MittwaldAPIV2Client, p: ProcessRenderer): Promise<SignupAccount>;
+export declare function getProject(apiClient: MittwaldAPIV2Client, p: ProcessRenderer, database: {
+    projectId: string;
+}): Promise<ProjectProject>;
+export {};

package/dist/lib/resources/database/common.js

@@ -0,0 +1,17 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+export async function getUser(apiClient, p) {
+    return await p.runStep("fetching user", async () => {
+        const r = await apiClient.user.getOwnAccount();
+        assertStatus(r, 200);
+        return r.data;
+    });
+}
+export async function getProject(apiClient, p, database) {
+    return await p.runStep("fetching project", async () => {
+        const r = await apiClient.project.getProject({
+            projectId: database.projectId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    });
+}

package/dist/lib/resources/database/mysql/connect.d.ts

@@ -0,0 +1,31 @@
+import { ProcessRenderer } from "../../../../rendering/process/process.js";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+type Project = MittwaldAPIV2.Components.Schemas.ProjectProject;
+export interface MySQLConnectionFlags {
+    "mysql-password": string | undefined;
+    "temporary-user"?: boolean;
+    "ssh-user"?: string;
+}
+export interface MySQLConnectionDetails {
+    hostname: string;
+    database: string;
+    user: string;
+    sshHost: string;
+    sshUser: string;
+    project: Project;
+}
+export type MySQLConnectionDetailsWithPassword = MySQLConnectionDetails & {
+    password: string;
+};
+/**
+ * Runs a callback function with connection details for a MySQL database.
+ *
+ * Depending on the flags, this function will either use the credentials
+ * provided in the flags (or prompt for a password), or create a temporary user
+ * for the operation, which will be cleaned up afterwards.
+ */
+export declare function runWithConnectionDetails<TRes>(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer, flags: MySQLConnectionFlags, cb: (connectionDetails: MySQLConnectionDetailsWithPassword) => Promise<TRes>): Promise<TRes>;
+export declare function getConnectionDetailsWithPassword(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer, flags: MySQLConnectionFlags): Promise<MySQLConnectionDetailsWithPassword>;
+export declare function getConnectionDetails(apiClient: MittwaldAPIV2Client, databaseId: string, sshUser: string | undefined, p: ProcessRenderer): Promise<MySQLConnectionDetails>;
+export {};

package/dist/lib/resources/database/mysql/connect.js

@@ -0,0 +1,68 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { getProject } from "../common.js";
+import { getSSHConnectionForProject } from "../../ssh/project.js";
+import { withTemporaryUser } from "./temp_user.js";
+/**
+ * Runs a callback function with connection details for a MySQL database.
+ *
+ * Depending on the flags, this function will either use the credentials
+ * provided in the flags (or prompt for a password), or create a temporary user
+ * for the operation, which will be cleaned up afterwards.
+ */
+export async function runWithConnectionDetails(apiClient, databaseId, p, flags, cb) {
+    const connectionDetails = await getConnectionDetailsWithPassword(apiClient, databaseId, p, flags);
+    if (flags["temporary-user"]) {
+        return withTemporaryUser(apiClient, databaseId, p, async (user, password) => cb({ ...connectionDetails, user: user.name, password }));
+    }
+    return cb(connectionDetails);
+}
+export async function getConnectionDetailsWithPassword(apiClient, databaseId, p, flags) {
+    const password = flags["temporary-user"] ? "" : await getPassword(p, flags);
+    const sshUser = flags["ssh-user"];
+    return {
+        ...(await getConnectionDetails(apiClient, databaseId, sshUser, p)),
+        password,
+    };
+}
+export async function getConnectionDetails(apiClient, databaseId, sshUser, p) {
+    const database = await getDatabase(apiClient, p, databaseId);
+    const databaseUser = await getDatabaseUser(apiClient, p, databaseId);
+    const project = await getProject(apiClient, p, database);
+    const sshConnectionData = await getSSHConnectionForProject(apiClient, database.projectId, sshUser);
+    return {
+        hostname: database.hostname,
+        database: database.name,
+        user: databaseUser.name,
+        sshHost: sshConnectionData.host,
+        sshUser: sshConnectionData.user,
+        project,
+    };
+}
+async function getPassword(p, flags) {
+    if (flags["mysql-password"]) {
+        return flags["mysql-password"];
+    }
+    return await p.addInput("enter password for MySQL user", true);
+}
+async function getDatabase(apiClient, p, mysqlDatabaseId) {
+    return await p.runStep("fetching database", async () => {
+        const r = await apiClient.database.getMysqlDatabase({
+            mysqlDatabaseId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    });
+}
+async function getDatabaseUser(apiClient, p, databaseId) {
+    return await p.runStep("fetching main user", async () => {
+        const r = await apiClient.database.listMysqlUsers({
+            mysqlDatabaseId: databaseId,
+        });
+        assertStatus(r, 200);
+        const mainUser = r.data.find((u) => u.mainUser);
+        if (!mainUser) {
+            throw new Error("No main user found");
+        }
+        return mainUser;
+    });
+}

package/dist/lib/resources/database/mysql/flags.d.ts

@@ -0,0 +1,16 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare const mysqlConnectionFlags: {
+    "mysql-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+};
+export declare const mysqlConnectionFlagsWithTempUser: {
+    "temporary-user": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    "mysql-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+};
+export declare const mysqlArgs: {
+    "database-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+};
+export declare function withMySQLId(apiClient: MittwaldAPIV2Client, flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}): Promise<string>;

package/dist/lib/resources/database/mysql/flags.js

@@ -0,0 +1,48 @@
+import { Args, Flags } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+export const mysqlConnectionFlags = {
+    "mysql-password": Flags.string({
+        char: "p",
+        summary: "the password to use for the MySQL user (env: MYSQL_PWD)",
+        description: `\
+The password to use for the MySQL user. If not provided, the environment variable MYSQL_PWD will be used. If that is not set either, the command will interactively ask for the password.
+
+NOTE: This is a security risk, as the password will be visible in the process list of your system, and will be visible in your Shell history. It is recommended to use the environment variable instead.\
+      `,
+        required: false,
+        env: "MYSQL_PWD",
+    }),
+};
+export const mysqlConnectionFlagsWithTempUser = {
+    ...mysqlConnectionFlags,
+    "temporary-user": Flags.boolean({
+        summary: "create a temporary user for the dump",
+        description: "Create a temporary user for this operation. This user will be deleted after the operation has completed. This is useful if you want to work with a database that is not accessible from the outside.\n\nIf this flag is disabled, you will need to specify the password of the default user; either via the --mysql-password flag or via the MYSQL_PWD environment variable.",
+        default: true,
+        required: false,
+        allowNo: true,
+    }),
+};
+export const mysqlArgs = {
+    "database-id": Args.string({
+        description: "The ID or name of the database",
+        required: true,
+    }),
+};
+function getIdCandidate(flags, args) {
+    if (args["database-id"] && typeof args["database-id"] === "string") {
+        return args["database-id"];
+    }
+    if (flags["database-id"] && typeof flags["database-id"] === "string") {
+        return flags["database-id"];
+    }
+    throw new Error("No ID given");
+}
+export async function withMySQLId(apiClient, flags, args) {
+    const mysqlDatabaseId = getIdCandidate(flags, args);
+    const response = await apiClient.database.getMysqlDatabase({
+        mysqlDatabaseId,
+    });
+    assertStatus(response, 200);
+    return response.data.id;
+}

package/dist/lib/resources/database/mysql/temp_user.d.ts

@@ -0,0 +1,13 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../../../rendering/process/process.js";
+type DatabaseMySqlUser = MittwaldAPIV2.Components.Schemas.DatabaseMySqlUser;
+/**
+ * Runs a callback function with a temporary user for a database operation.
+ *
+ * Note: This is implemented with a callback parameter, because this function
+ * also handles the cleanup of the temporary user after the callback has been
+ * executed.
+ */
+export declare function withTemporaryUser<TRes>(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer, cb: (tempUser: DatabaseMySqlUser, password: string) => Promise<TRes>): Promise<TRes>;
+export {};

package/dist/lib/resources/database/mysql/temp_user.js

@@ -0,0 +1,52 @@
+import { assertStatus } from "@mittwald/api-client";
+import { randomBytes } from "crypto";
+import assertSuccess from "../../../apiutil/assert_success.js";
+async function createTemporaryUser(apiClient, databaseId, password) {
+    const createResponse = await apiClient.database.createMysqlUser({
+        mysqlDatabaseId: databaseId,
+        data: {
+            accessLevel: "full", // needed for "PROCESS" privilege
+            externalAccess: false,
+            password,
+            databaseId,
+            description: "Temporary user for exporting/importing database",
+        },
+    });
+    assertStatus(createResponse, 201);
+    return createResponse.data.id;
+}
+async function retrieveTemporaryUser(apiClient, mysqlUserId) {
+    const userResponse = await apiClient.database.getMysqlUser({
+        mysqlUserId,
+    });
+    assertStatus(userResponse, 200);
+    return userResponse.data;
+}
+function generateRandomPassword() {
+    return randomBytes(32).toString("base64");
+}
+/**
+ * Runs a callback function with a temporary user for a database operation.
+ *
+ * Note: This is implemented with a callback parameter, because this function
+ * also handles the cleanup of the temporary user after the callback has been
+ * executed.
+ */
+export async function withTemporaryUser(apiClient, databaseId, p, cb) {
+    const password = generateRandomPassword();
+    const user = await p.runStep("creating temporary user", async () => {
+        const mysqlUserId = await createTemporaryUser(apiClient, databaseId, password);
+        return await retrieveTemporaryUser(apiClient, mysqlUserId);
+    });
+    try {
+        return await cb(user, password);
+    }
+    finally {
+        await p.runStep("removing temporary user", async () => {
+            const response = await apiClient.database.deleteMysqlUser({
+                mysqlUserId: user.id,
+            });
+            assertSuccess(response);
+        });
+    }
+}

package/dist/lib/resources/database/mysql/user/flags.d.ts

@@ -0,0 +1,22 @@
+export declare const mysqlUserFlagDefinitions: {
+    "database-id": import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: true;
+    }>;
+    "access-level": import("@oclif/core/interfaces").FlagDefinition<"full" | "readonly", import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    description: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    password: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+    "access-ip-mask": import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
+};

package/dist/lib/resources/database/mysql/user/flags.js

@@ -0,0 +1,25 @@
+import { Flags } from "@oclif/core";
+export const mysqlUserFlagDefinitions = {
+    "database-id": Flags.custom({
+        required: true,
+        summary: "MySQL database ID to create a user for.",
+        description: "Can be specified as UUID or shortId. The user will be created for the specified database.",
+    }),
+    "access-level": Flags.custom({
+        options: ["readonly", "full"],
+        summary: "Set the access level permissions for the SFTP user.",
+        description: "Must be specified as either readonly or full. Grant the user either read-only or full file read and write access to files.",
+    }),
+    description: Flags.custom({
+        summary: "Set the description for the MySQL user.",
+        description: "Set the description for the specified MySQL user to be displayed in mStudio and with the list command.",
+    }),
+    password: Flags.custom({
+        summary: "Password used for authentication",
+        description: "Specify a password to use for authentication when connecting to the database with this user.",
+    }),
+    "access-ip-mask": Flags.custom({
+        summary: "IP to restrict external access to.",
+        description: "If specified as IPv4, external access will be restricted to only the specified IP addresses when external access is enabled.",
+    }),
+};

package/dist/lib/resources/database/redis/connect.d.ts

@@ -0,0 +1,8 @@
+import { ProcessRenderer } from "../../../../rendering/process/process.js";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getConnectionDetails(apiClient: MittwaldAPIV2Client, databaseId: string, sshUserOverride: string | undefined, p: ProcessRenderer): Promise<{
+    hostname: string;
+    database: string;
+    sshHost: string;
+    sshUser: string;
+}>;

package/dist/lib/resources/database/redis/connect.js

@@ -0,0 +1,21 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { getSSHConnectionForProject } from "../../ssh/project.js";
+export async function getConnectionDetails(apiClient, databaseId, sshUserOverride, p) {
+    const database = await getDatabase(apiClient, p, databaseId);
+    const { user: sshUser, host: sshHost } = await getSSHConnectionForProject(apiClient, database.projectId, sshUserOverride);
+    return {
+        hostname: database.hostname,
+        database: database.name,
+        sshHost,
+        sshUser,
+    };
+}
+async function getDatabase(apiClient, p, redisDatabaseId) {
+    return await p.runStep("fetching database", async () => {
+        const r = await apiClient.database.getRedisDatabase({
+            redisDatabaseId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    });
+}

package/dist/lib/resources/database/redis/flags.d.ts

@@ -0,0 +1,10 @@
+import { Config } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare const redisArgs: {
+    "database-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+};
+export declare function withRedisId(apiClient: MittwaldAPIV2Client, flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}, cfg: Config): Promise<string>;