@mittwald/cli 1.0.0-alpha.19 → 1.0.0-alpha.21

package/dist/esm/lib/app/flags.js

@@ -1,7 +1,196 @@
-import { Args } from "@oclif/core";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getDefaultIngressForProject } from "../project/ingress.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { getProjectShortIdFromUuid } from "../project/shortId.js";
+import { Text } from "ink";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { projectFlags } from "../project/flags.js";
+import { processFlags, } from "../../rendering/process/process_flags.js";
+import { Flags, Args } from "@oclif/core";
+import { generatePasswordWithSpecialChars } from "../password.js";
 export const appInstallationFlags = {
     "installation-id": Args.string({
         description: "ID of the app installation to get",
         required: true,
     }),
 };
+function buildFlagsWithDescription(appName) {
+    return {
+        version: Flags.string({
+            required: true,
+            summary: `Version of ${appName} to be installed.`,
+            description: `Specify the Version in which your ${appName} will be installed. 
+      If none is given the ${appName} will be installed in the latest available version.`,
+            default: "latest",
+        }),
+        host: Flags.string({
+            required: false,
+            summary: `Host to initially configure your ${appName} installation with; needs to be created separately.`,
+            description: `Specify a host which will be used during the installation and as an initial host for the ${appName} configuration.
+      If not given the default host for the given Project will be used. 
+      This does not change the target of the used Host and can be changed later by configuring the Host and your ${appName} installation.`,
+        }),
+        "admin-user": Flags.string({
+            required: false,
+            summary: "Username for your administrator-user.",
+            description: `Username of the first administrator-user which will be created during the ${appName} installation. 
+      If not given an adequate username will be created from your mStudio Account Data.
+      After the installation is finished the Username can be changed and additional administrator-users can be created.`,
+        }),
+        "admin-email": Flags.string({
+            required: false,
+            summary: "E-Mail-Address of your administrator-user.",
+            description: `E-Mail-Address that will correlate to the first administrator-user which will be created during the ${appName} installation.
+      If not given your mStudio Account-E-Mail-Address will be used. This E-Mail-Address can be changed after the installation is finished.`,
+        }),
+        "admin-pass": Flags.string({
+            required: false,
+            summary: "Password of your administrator-user.",
+            description: `Password that will correlate to the first administrator-user which will be created during the ${appName} installation.
+      If not given a random secure Password will be generated and sent to stdout. This Password can be changed after the installation is finished`,
+        }),
+        "admin-firstname": Flags.string({
+            required: false,
+            summary: "Firstname of your administrator-user.",
+            description: `Firstname that will correlate to the first administrator-user which will be created during the ${appName} installation.
+      If none is given your mStudio Account-Firstname will be used. This Firstname can be changed after the installation is finished`,
+        }),
+        "admin-lastname": Flags.string({
+            required: false,
+            summary: "Lastname of your administrator-user.",
+            description: `Lastname that will correlate to the first administrator-user which will be created during the ${appName} installation.
+      If none is given your mStudio Account-Firstname will be used. This Lastname can be changed after the installation is finished`,
+        }),
+        "site-title": Flags.string({
+            required: false,
+            summary: `Site Title for your ${appName} installation.`,
+            description: `Site Title which will be displayed in the Tab and at the top of the Frontend of your ${appName} installation.
+      It is also the Title shown in the App-Overview in the mStudio.
+      If none is given the Software Name and the given Project will be used. The Title can be changed after the installation is finished`,
+        }),
+        "shop-email": Flags.string({
+            required: false,
+            summary: `E-Mail-Address your ${appName} will be working with.`,
+            description: `The E-Mail-Address your ${appName} shop will be using for correspondence..
+      If not given your mStudio Account-E-Mail-Address will be used. This E-Mail-Address can be changed after the installation is finished.`,
+        }),
+        "shop-lang": Flags.string({
+            required: false,
+            summary: `Language your ${appName} will be working with.`,
+            description: `The default Language your ${appName} shop will be using.
+      The Front- and Backend will be displayed using the given language.
+      If not given will default to German(de_DE). The language can be changed after the installation is finished.`,
+        }),
+        "shop-currency": Flags.string({
+            required: false,
+            summary: `Currency your ${appName} will be working with.`,
+            description: `The default Currency your ${appName} shop communicates prices and calculates transactions with.
+      If not given will default to EUR(€). The currency can be changed after the installation is finished.`,
+        }),
+        "install-mode": Flags.string({
+            required: true,
+            summary: `The installation variant your ${appName} will be installed with.`,
+            description: `${appName} can be installed in one of two different ways.  your ${appName} shop communicates prices and calculates transactions with.
+      Either as a composer project or in a more manual fashion using the source directory and the ${appName} console install wizard.
+      If not given will default to composer installation. This can not be changed later.`,
+            options: ["composer", "symlink"],
+            default: "composer",
+        }),
+        wait: Flags.boolean({
+            char: "w",
+            description: `Wait for your ${appName} to be ready.`,
+        }),
+    };
+}
+export function provideSupportedFlags(requestedFlagNames, appName) {
+    const availableFlags = buildFlagsWithDescription(appName);
+    const supportedFlags = requestedFlagNames.reduce((collector, currentValue) => {
+        return {
+            ...collector,
+            [currentValue]: availableFlags[currentValue],
+        };
+    }, {});
+    const flagsToReturn = {
+        ...projectFlags,
+        ...processFlags,
+        ...supportedFlags,
+        json: Flags.boolean({}),
+    };
+    return flagsToReturn;
+}
+export async function autofillFlags(apiClient, process, necessaryFlags, flags, projectId, appName) {
+    const ownUser = await apiClient.user.getOwnAccount();
+    assertStatus(ownUser, 200);
+    // Version
+    if (necessaryFlags.includes("version") && !flags.version) {
+        flags.version = "latest";
+    }
+    // Host
+    if (necessaryFlags.includes("host") && !flags.host) {
+        flags.host =
+            "https://" + (await getDefaultIngressForProject(apiClient, projectId));
+        process.addInfo(_jsxs(Text, { children: ["Using default Host ", _jsx(Value, { children: flags["host"] })] }));
+    }
+    // Title
+    if (necessaryFlags.includes("site-title") && !flags["site-title"]) {
+        flags["site-title"] =
+            appName + " " + (await getProjectShortIdFromUuid(apiClient, projectId));
+    }
+    // Admin User
+    if (necessaryFlags.includes("admin-user") && !flags["admin-user"]) {
+        if (ownUser.data.person) {
+            flags["admin-user"] =
+                ownUser.data.person.firstName.charAt(0).toLowerCase() +
+                    ownUser.data.person.lastName.toLowerCase();
+        }
+        else {
+            flags["admin-user"] = await getProjectShortIdFromUuid(apiClient, projectId);
+        }
+        process.addInfo(_jsxs(Text, { children: ["Using generated Admin User: ", _jsx(Value, { children: flags["admin-user"] })] }));
+    }
+    // Admin Pass
+    if (necessaryFlags.includes("admin-pass") && !flags["admin-pass"]) {
+        flags["admin-pass"] = generatePasswordWithSpecialChars();
+        process.addInfo(_jsxs(Text, { children: ["Using generated random Admin Pass: ", _jsx(Value, { children: flags["admin-pass"] })] }));
+    }
+    // Admin Firstname
+    if (necessaryFlags.includes("admin-firstname") && !flags["admin-firstname"]) {
+        if (ownUser.data.person) {
+            flags["admin-firstname"] = ownUser.data.person.firstName;
+        }
+        else {
+            flags["admin-firstname"] = "Max";
+        }
+        process.addInfo(_jsxs(Text, { children: ["Using mStudio firstname as Admin firstname (", _jsx(Value, { children: flags["admin-firstname"] }), ")"] }));
+    }
+    // Admin Lastname
+    if (necessaryFlags.includes("admin-lastname") && !flags["admin-lastname"]) {
+        if (ownUser.data.person) {
+            flags["admin-lastname"] = ownUser.data.person.lastName;
+        }
+        else {
+            flags["admin-lastname"] = "Mustermann";
+        }
+        process.addInfo(_jsxs(Text, { children: ["Using mStudio lastname as Admin lastname (", _jsx(Value, { children: flags["admin-lastname"] }), ")"] }));
+    }
+    // Admin E-Mail
+    if (necessaryFlags.includes("admin-email") && !flags["admin-email"]) {
+        flags["admin-email"] = ownUser.data.email;
+        process.addInfo(_jsxs(Text, { children: ["Using mStudio email as Admin email (", _jsx(Value, { children: flags["admin-email"] }), ")"] }));
+    }
+    // Shop E-Mail
+    if (necessaryFlags.includes("shop-email") && !flags["shop-email"]) {
+        flags["shop-email"] = ownUser.data.email;
+        process.addInfo(_jsxs(Text, { children: ["Using mStudio email as Shop email (", _jsx(Value, { children: flags["shop-email"] }), ")"] }));
+    }
+    // Shop Language Code
+    if (necessaryFlags.includes("shop-lang") && !flags["shop-lang"]) {
+        flags["shop-lang"] = "de-DE";
+        process.addInfo(_jsx(Text, { children: "Using default shop language 'de_DE'." }));
+    }
+    // Shop Currency
+    if (necessaryFlags.includes("shop-currency") && !flags["shop-currency"]) {
+        flags["shop-currency"] = "EUR";
+        process.addInfo(_jsx(Text, { children: "Using default shop currency '\u20AC'." }));
+    }
+}

package/dist/esm/lib/app/install.d.ts

@@ -0,0 +1,4 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+import AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+export declare function triggerAppInstallation(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, projectId: string, flags: Record<string, string>, appVersion: AppAppVersion): Promise<string[]>;

package/dist/esm/lib/app/install.js

@@ -0,0 +1,20 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+export async function triggerAppInstallation(apiClient, process, projectId, flags, appVersion) {
+    const [appInstallationId, eventId] = await process.runStep("starting installation", async () => {
+        const result = await apiClient.app.requestAppinstallation({
+            pathParameters: { projectId },
+            data: {
+                appVersionId: appVersion.id,
+                description: flags["site-title"],
+                updatePolicy: "none",
+                userInputs: Object.keys(flags).map((k) => ({
+                    name: k.replace("-", "_"),
+                    value: flags[k],
+                })),
+            },
+        });
+        assertStatus(result, 201);
+        return [result.data.id, result.headers["etag"]];
+    });
+    return [appInstallationId, eventId];
+}

package/dist/esm/lib/app/{appVersionHelpers.d.ts → versions.d.ts}

@@ -1,5 +1,8 @@
 import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+import { ProcessRenderer } from "../../rendering/process/process.js";
 type AppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+export declare function normalizeToAppVersionUuid(apiClient: MittwaldAPIV2Client, version: string, process: ProcessRenderer, appUuid: string): Promise<AppAppVersion>;
 export declare function getLatestAvailableAppVersionForApp(apiClient: MittwaldAPIV2Client, appId: string): Promise<AppVersion | undefined>;
 export declare function getAppVersionUuidFromAppVersion(apiClient: MittwaldAPIV2Client, appId: string, appVersion: string | undefined): Promise<AppVersion | undefined>;
 export {};

package/dist/esm/lib/app/{appVersionHelpers.js → versions.js}

@@ -1,5 +1,23 @@
+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 { getAppNameFromUuid } from "./uuid.js";
+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({

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

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+export declare function waitUntilAppIsInstalled(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, appInstallationId: string, eventId: string): Promise<void>;

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

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { waitUntil } from "../wait.js";
+import { Text } from "ink";
+export async function waitUntilAppIsInstalled(apiClient, process, appInstallationId, eventId) {
+    const stepWaiting = process.addStep(_jsx(Text, { children: "waiting for app installation to be ready" }));
+    await waitUntil(async () => {
+        const installationResponse = await apiClient.app.getAppinstallation({
+            pathParameters: { appInstallationId },
+            // TODO: Remove once @mittwald/api-client supports this
+            headers: { "if-event-reached": eventId }, // eslint-disable-line
+        });
+        if (installationResponse.status === 200 &&
+            installationResponse.data.appVersion.current ==
+                installationResponse.data.appVersion.desired) {
+            return true;
+        }
+    });
+    stepWaiting.complete();
+}

package/dist/esm/lib/context_flags.d.ts

@@ -2,17 +2,28 @@ import { Config } from "@oclif/core";
 import { Arg, ArgOutput, FlagOutput, OptionFlag } from "@oclif/core/lib/interfaces/parser.js";
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 import { AlphabetLowercase } from "@oclif/core/lib/interfaces/index.js";
-type ContextFlags = {
-    [k: string]: OptionFlag<unknown>;
+type FlagIDType<N extends string> = `${N}-id`;
+type ContextFlags<N extends string, TID extends string = FlagIDType<N>> = {
+    [k in TID]: OptionFlag<string>;
 };
-type ContextArgs = {
-    [k: string]: Arg<unknown>;
+type ContextArgs<N extends string, TID extends string = FlagIDType<N>> = {
+    [k in TID]: Arg<string>;
 };
-export type FlagSet = {
-    flags: ContextFlags;
-    args: ContextArgs;
-    withId: (apiClient: MittwaldAPIV2Client, flags: FlagOutput, args: ArgOutput, cfg: Config) => Promise<string>;
+type CommandType<N extends string, TID extends string = FlagIDType<N>> = {
+    flags: {
+        [k in TID]: OptionFlag<string>;
+    };
+} | {
+    args: {
+        [k in TID]: Arg<string>;
+    };
+};
+export type FlagSet<TName extends string> = {
+    name: TName;
+    flags: ContextFlags<TName>;
+    args: ContextArgs<TName>;
+    withId: (apiClient: MittwaldAPIV2Client, command: CommandType<TName> | "flag" | "arg", flags: FlagOutput, args: ArgOutput, cfg: Config) => Promise<string>;
 };
 export type NormalizeFn = (apiClient: MittwaldAPIV2Client, id: string) => string | Promise<string>;
-export declare function makeFlagSet(name: string, char: AlphabetLowercase, normalize?: NormalizeFn): FlagSet;
+export declare function makeFlagSet<TName extends string>(name: TName, char: AlphabetLowercase, normalize?: NormalizeFn): FlagSet<TName>;
 export {};

package/dist/esm/lib/context_flags.js

@@ -1,5 +1,15 @@
 import { Args, Flags } from "@oclif/core";
 import { Context } from "./context.js";
+class MissingFlagError extends Error {
+    constructor(name, flagName) {
+        super(`No ${name} ID given. Please specify one with --${flagName} or set a default ${name} with 'mittwald context set --${flagName} <${flagName}>'`);
+    }
+}
+class MissingArgError extends Error {
+    constructor(name, flagName) {
+        super(`No ${name} ID given. Please specify one as positional argument or set a default ${name} with 'mittwald context set --${flagName} <${flagName}>'`);
+    }
+}
 export function makeFlagSet(name, char, normalize = (_, id) => id) {
     const flagName = `${name}-id`;
     const flags = {
@@ -24,7 +34,7 @@ export function makeFlagSet(name, char, normalize = (_, id) => id) {
         }
         return undefined;
     };
-    const withId = async (apiClient, flags, args, cfg) => {
+    const withId = async (apiClient, commandType, flags, args, cfg) => {
         const idInput = idFromArgsOrFlag(flags, args);
         if (idInput) {
             return normalize(apiClient, idInput);
@@ -33,9 +43,22 @@ export function makeFlagSet(name, char, normalize = (_, id) => id) {
         if (idFromContext) {
             return idFromContext;
         }
-        throw new Error(`No ${name} ID given. Please specify one with --${flagName} or set a default server with 'mittwald context set --${flagName} <${flagName}>'`);
+        if (commandType === "flag") {
+            throw new MissingFlagError(name, flagName);
+        }
+        if (commandType === "arg") {
+            throw new MissingArgError(name, flagName);
+        }
+        if ("flags" in commandType && flagName in commandType.flags) {
+            throw new MissingFlagError(name, flagName);
+        }
+        if ("args" in commandType && flagName in commandType.args) {
+            throw new MissingArgError(name, flagName);
+        }
+        throw new Error(`No ${name} ID given. Please consult the --help page of this command or set a default ${name} with 'mittwald context set --${flagName} <${flagName}>'`);
     };
     return {
+        name,
         flags,
         args,
         withId,

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

@@ -35,7 +35,7 @@ export async function withMySQLId(apiClient, flags, args, cfg) {
     if (isUuid(candidate)) {
         return candidate;
     }
-    const projectId = await withProjectId(apiClient, flags, args, cfg);
+    const projectId = await withProjectId(apiClient, "flag", flags, args, cfg);
     const databases = await apiClient.database.listMysqlDatabases({
         pathParameters: { projectId },
     });

package/dist/esm/lib/database/redis/flags.js

@@ -22,7 +22,7 @@ export async function withRedisId(apiClient, flags, args, cfg) {
     if (isUuid(candidate)) {
         return candidate;
     }
-    const projectId = await withProjectId(apiClient, flags, args, cfg);
+    const projectId = await withProjectId(apiClient, "flag", flags, args, cfg);
     const databases = await apiClient.database.listRedisDatabases({
         pathParameters: { projectId },
     });

package/dist/esm/lib/expires.d.ts

@@ -0,0 +1,11 @@
+export type ExpireFlags = {
+    expires: string;
+};
+export declare function expireFlags(resourceName: string): {
+    expires: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};
+export declare function expireFlagsRequired(resourceName: string): {
+    expires: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};
+export declare function expirationDateFromFlagsOptional(flags: Partial<ExpireFlags>): Date | undefined;
+export declare function expirationDateFromFlags(flags: ExpireFlags): Date;

package/dist/esm/lib/expires.js

@@ -0,0 +1,31 @@
+import { Flags } from "@oclif/core";
+import parseDuration from "parse-duration";
+export function expireFlags(resourceName) {
+    return {
+        expires: Flags.string({
+            description: `An interval after which the ${resourceName} expires (examples: 30m, 30d, 1y).`,
+        }),
+    };
+}
+export function expireFlagsRequired(resourceName) {
+    return {
+        expires: Flags.string({
+            description: `An interval after which the ${resourceName} expires (examples: 30m, 30d, 1y).`,
+            required: true,
+        }),
+    };
+}
+export function expirationDateFromFlagsOptional(flags) {
+    if (!flags.expires) {
+        return undefined;
+    }
+    return expirationDateFromFlags(flags);
+}
+export function expirationDateFromFlags(flags) {
+    const d = new Date();
+    const i = parseDuration(flags.expires);
+    if (!i) {
+        throw new Error("could not parse duration: " + flags.expires);
+    }
+    return new Date(d.getTime() + i);
+}

package/dist/esm/lib/handleError.js

@@ -1,6 +1,5 @@
-import oclif from "@oclif/core";
 import { ApiClientError } from "@mittwald/api-client-commons";
-import { CLIError, ExitError } from "@oclif/core/lib/errors/index.js";
+import { ExitError } from "@oclif/core/lib/errors/index.js";
 import { renderError } from "../rendering/react/error.js";
 export const handleError = (error) => {
     if (!isUnexpectedError(error)) {
@@ -11,24 +10,8 @@ export const handleError = (error) => {
         process.exit(error.oclif.exit);
         return;
     }
-    if (error instanceof CLIError) {
-        renderError(error);
-        process.exit(1);
-        return;
-    }
-    if (error instanceof ApiClientError) {
-        const responseJson = JSON.stringify(error.response?.data, undefined, 2);
-        const errorMessage = `\
-${error.message}
-
-Response:
-─────────
-${responseJson}`;
-        error = new Error(errorMessage, {
-            cause: error,
-        });
-    }
-    oclif.Errors.handle(error);
+    renderError(error);
+    process.exit(1);
 };
 export function isUnexpectedError(err) {
     return !isValidationError(err);

package/dist/esm/lib/org/flags.d.ts

@@ -1,5 +1,13 @@
 export declare const orgFlags: {
-    [k: string]: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
+    "org-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
 }, orgArgs: {
-    [k: string]: import("@oclif/core/lib/interfaces/parser.js").Arg<unknown>;
-}, withOrgId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;
+    "org-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+}, withOrgId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, command: "flag" | "arg" | ({
+    flags: {
+        "org-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+    };
+} | {
+    args: {
+        "org-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+    };
+}), flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;

package/dist/esm/lib/password.d.ts

@@ -0,0 +1,2 @@
+export declare function generatePassword(length?: number): string;
+export declare function generatePasswordWithSpecialChars(length?: number, amountSpecialChars?: number): string;

package/dist/esm/lib/password.js

@@ -0,0 +1,20 @@
+import crypto from "crypto";
+const passwordAllowedSpecialChars = ["%", "_", "-", "+", "&"];
+const defaultPasswordLength = 32;
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - 1) + min);
+}
+function getRandomSpecialCharacter() {
+    return passwordAllowedSpecialChars[randomInt(0, passwordAllowedSpecialChars.length - 1)];
+}
+export function generatePassword(length = defaultPasswordLength) {
+    return crypto.randomBytes(length).toString("base64").substring(0, length);
+}
+export function generatePasswordWithSpecialChars(length = defaultPasswordLength, amountSpecialChars = Math.floor(length / 8)) {
+    const passwordCharacters = generatePassword(length).split("");
+    for (let i = 0; i < amountSpecialChars; i++) {
+        passwordCharacters[randomInt(1, passwordCharacters.length - 1)] =
+            getRandomSpecialCharacter();
+    }
+    return passwordCharacters.join("");
+}

package/dist/esm/lib/project/flags.d.ts

@@ -1,5 +1,13 @@
 export declare const projectFlags: {
-    [k: string]: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
+    "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
 }, projectArgs: {
-    [k: string]: import("@oclif/core/lib/interfaces/parser.js").Arg<unknown>;
-}, withProjectId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;
+    "project-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+}, withProjectId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, command: "flag" | "arg" | ({
+    flags: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+    };
+} | {
+    args: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+    };
+}), flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;

package/dist/esm/lib/project/hooks.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import ProjectProject = MittwaldAPIV2.Components.Schemas.ProjectProject;
+export declare function useProject(projectId: string): ProjectProject;

package/dist/esm/lib/project/hooks.js

@@ -0,0 +1,11 @@
+import { useRenderContext } from "../../rendering/react/context.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import { assertStatus } from "@mittwald/api-client-commons";
+export function useProject(projectId) {
+    const { apiClient } = useRenderContext();
+    const project = usePromise((id) => apiClient.project.getProject({
+        pathParameters: { id },
+    }), [projectId]);
+    assertStatus(project, 200);
+    return project.data;
+}

package/dist/esm/lib/project/ingress.d.ts

@@ -0,0 +1,2 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getDefaultIngressForProject(apiClient: MittwaldAPIV2Client, projectId: string): Promise<string>;

package/dist/esm/lib/project/ingress.js

@@ -0,0 +1,16 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { normalizeProjectIdToUuid } from "../../Helpers.js";
+export async function getDefaultIngressForProject(apiClient, projectId) {
+    const projectUuid = await normalizeProjectIdToUuid(apiClient, projectId);
+    const projectIngresses = await apiClient.domain.ingressListForProject({
+        pathParameters: { projectId: projectUuid },
+    });
+    assertStatus(projectIngresses, 200);
+    const foundIngress = projectIngresses.data.find((item) => {
+        return item.isDefault === true;
+    });
+    if (foundIngress) {
+        return foundIngress.hostname;
+    }
+    throw new Error(`Given ID ${projectUuid} does not seem to be valid`);
+}

package/dist/esm/lib/project/shortId.d.ts

@@ -0,0 +1,2 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getProjectShortIdFromUuid(apiClient: MittwaldAPIV2Client, uuid: string): Promise<string>;

package/dist/esm/lib/project/shortId.js

@@ -0,0 +1,11 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+export async function getProjectShortIdFromUuid(apiClient, uuid) {
+    const project = await apiClient.project.getProject({
+        pathParameters: { id: uuid },
+    });
+    assertStatus(project, 200);
+    if (project.data.shortId) {
+        return project.data.shortId;
+    }
+    throw new Error(`Given ID ${uuid} does not seem to be valid`);
+}

package/dist/esm/lib/projectbackup/hooks.d.ts

@@ -0,0 +1,5 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+import BackupProjectBackupSchedule = MittwaldAPIV2.Components.Schemas.BackupProjectBackupSchedule;
+export declare function useProjectBackup(projectBackupId: string): BackupProjectBackup;
+export declare function useProjectBackupSchedule(projectBackupScheduleId: string): BackupProjectBackupSchedule;

package/dist/esm/lib/projectbackup/hooks.js

@@ -0,0 +1,19 @@
+import { useRenderContext } from "../../rendering/react/context.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import { assertStatus } from "@mittwald/api-client-commons";
+export function useProjectBackup(projectBackupId) {
+    const { apiClient } = useRenderContext();
+    const projectBackup = usePromise((id) => apiClient.backup.getProjectBackup({
+        pathParameters: { projectBackupId: id },
+    }), [projectBackupId]);
+    assertStatus(projectBackup, 200);
+    return projectBackup.data;
+}
+export function useProjectBackupSchedule(projectBackupScheduleId) {
+    const { apiClient } = useRenderContext();
+    const projectBackupSchedule = usePromise((id) => apiClient.backup.getProjectBackupSchedule({
+        pathParameters: { projectBackupScheduleId: id },
+    }), [projectBackupScheduleId]);
+    assertStatus(projectBackupSchedule, 200);
+    return projectBackupSchedule.data;
+}

package/dist/esm/lib/server/flags.d.ts

@@ -1,5 +1,13 @@
 export declare const serverFlags: {
-    [k: string]: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
+    "server-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
 }, serverArgs: {
-    [k: string]: import("@oclif/core/lib/interfaces/parser.js").Arg<unknown>;
-}, withServerId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;
+    "server-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+}, withServerId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, command: "flag" | "arg" | ({
+    flags: {
+        "server-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+    };
+} | {
+    args: {
+        "server-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+    };
+}), flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;