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

package/dist/esm/commands/project/backup/download.d.ts

@@ -0,0 +1,27 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+import { ProcessRenderer } from "../../../rendering/process/process.js";
+import { AxiosResponseHeaders, RawAxiosResponseHeaders } from "@mittwald/api-client-commons";
+type Result = {
+    outputFilename: string;
+};
+export declare class Download extends ExecRenderBaseCommand<typeof Download, Result> {
+    static description: string;
+    static args: {
+        "backup-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        output: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        format: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        password: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "generate-password": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "prompt-password": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        resume: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected getPassword(p: ProcessRenderer): Promise<string | undefined>;
+    protected exec(): Promise<Result>;
+    protected getFilename(headers: RawAxiosResponseHeaders | AxiosResponseHeaders): string;
+    protected render(executionResult: Result): ReactNode;
+}
+export {};

package/dist/esm/commands/project/backup/download.js

@@ -0,0 +1,177 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { Args, Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import crypto from "crypto";
+import { Text } from "ink";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { assertStatus, } from "@mittwald/api-client-commons";
+import { waitUntil } from "../../../lib/wait.js";
+import axios from "axios";
+import * as fs from "fs";
+import { formatBytes } from "../../../lib/viewhelpers/size.js";
+import { Success } from "../../../rendering/react/components/Success.js";
+export class Download extends ExecRenderBaseCommand {
+    static description = "Download a backup to your local disk";
+    static args = {
+        "backup-id": Args.string({
+            required: true,
+            description: "the ID of the Backup to download.",
+        }),
+    };
+    static flags = {
+        ...processFlags,
+        output: Flags.string({
+            description: "the file to write the backup to; if omitted, the filename will be determined by the server.",
+        }),
+        format: Flags.string({
+            description: "the file format to download the backup in.",
+            options: ["tar", "zip"],
+            default: "tar",
+        }),
+        password: Flags.string({
+            summary: "the password to encrypt the backup with.",
+            description: `\
+        CAUTION #1: this is not stored anywhere.
+        CAUTION #2: it is dangerous to use this option, as the password might be stored in your shell history.`,
+            exclusive: ["generate-password", "prompt-password"],
+        }),
+        "generate-password": Flags.boolean({
+            summary: "generate a random password to encrypt the backup with.",
+            description: "CAUTION: this is not stored anywhere.",
+            exclusive: ["password", "prompt-password"],
+        }),
+        "prompt-password": Flags.boolean({
+            summary: "prompt for a password to encrypt the backup with.",
+            description: "CAUTION: this is not stored anywhere.",
+            exclusive: ["password", "generate-password"],
+        }),
+        resume: Flags.boolean({
+            summary: "resume a previously interrupted download.",
+            dependsOn: ["output"],
+        }),
+    };
+    async getPassword(p) {
+        if (this.flags.password) {
+            return this.flags.password;
+        }
+        if (this.flags["generate-password"]) {
+            const password = await p.runStep("generating password", async () => {
+                return crypto.randomBytes(32).toString("ascii").substring(0, 32);
+            });
+            p.addInfo(_jsxs(Text, { children: ["generated password: ", _jsx(Value, { children: password })] }));
+            return password;
+        }
+        if (this.flags["prompt-password"]) {
+            return await p.addInput(_jsx(Text, { children: "enter backup password" }), true);
+        }
+        return undefined;
+    }
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Downloading backup");
+        const projectBackupId = this.args["backup-id"];
+        const { format } = this.flags;
+        const password = await this.getPassword(p);
+        const backup = await p.runStep("fetching backup", async () => {
+            const r = await this.apiClient.backup.getProjectBackup({
+                pathParameters: { projectBackupId },
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        if (backup.export && backup.export.phase !== "Expired") {
+            p.addInfo(_jsx(Text, { children: "backup download is already prepared" }));
+        }
+        else {
+            await p.runStep("preparing backup download", async () => {
+                const r = await this.apiClient.backup.createProjectBackupExport({
+                    pathParameters: { projectBackupId },
+                    data: {
+                        format: format,
+                        password,
+                    },
+                });
+                assertStatus(r, 204);
+            });
+        }
+        const backupExport = await p.runStep("waiting for backup download to be ready", () => {
+            return waitUntil(async () => {
+                const r = await this.apiClient.backup.getProjectBackup({
+                    pathParameters: { projectBackupId },
+                });
+                assertStatus(r, 200);
+                if (r.data.export?.phase === "Completed") {
+                    return r.data.export;
+                }
+                return null;
+            }, 3600);
+        });
+        if (!backupExport.downloadURL) {
+            throw new Error("backup download is not ready");
+        }
+        const reqConfig = { responseType: "stream" };
+        if (this.flags.resume &&
+            this.flags.output &&
+            fs.existsSync(this.flags.output)) {
+            const stat = fs.statSync(this.flags.output);
+            const range = `bytes=${stat.size}-`;
+            reqConfig.headers = { Range: range };
+            p.addInfo(_jsxs(Text, { children: ["resuming download starting at ", _jsx(Value, { children: stat.size }), " bytes"] }));
+        }
+        const downloadStep = p.addStep("downloading backup");
+        const resp = await axios(backupExport.downloadURL, reqConfig);
+        const size = parseInt(resp.headers["content-length"] || "0", 10);
+        let downloaded = 0;
+        const outputFilename = this.getFilename(resp.headers);
+        const outputStream = fs.createWriteStream(outputFilename, {
+            flags: this.flags.resume ? "a" : undefined,
+        });
+        resp.data.on("data", (chunk) => {
+            downloaded += chunk.length;
+            downloadStep.progress(formatBytes(downloaded, {
+                minimumFractionDigits: 2,
+                maximumFractionDigits: 2,
+            }) +
+                " of " +
+                formatBytes(size, {
+                    minimumFractionDigits: 2,
+                    maximumFractionDigits: 2,
+                }));
+            outputStream.write(chunk);
+        });
+        await new Promise((res) => {
+            resp.data.on("end", () => {
+                downloadStep.complete();
+                res();
+            });
+            resp.data.on("error", (err) => {
+                downloadStep.error(err);
+                res();
+            });
+        });
+        p.complete(_jsxs(Success, { children: ["The backup was successfully downloaded to", " ", _jsx(Value, { children: outputFilename })] }));
+        return { outputFilename };
+    }
+    getFilename(headers) {
+        if (this.flags.output) {
+            return this.flags.output;
+        }
+        const disposition = headers["content-disposition"];
+        if (disposition) {
+            const match = disposition.match(/filename=("?)(.*)\1/);
+            if (match) {
+                return match[2];
+            }
+        }
+        if (this.flags.format === "tar") {
+            return "backup.tar.gz";
+        }
+        return "backup.zip";
+    }
+    render(executionResult) {
+        if (this.flags.quiet) {
+            return executionResult.outputFilename;
+        }
+        return undefined;
+    }
+}

package/dist/esm/commands/project/backup/get.d.ts

@@ -1,3 +1,12 @@
-import { GeneratedBackupGetProjectBackup } from "../../../generated/backup/getProjectBackup.js";
-export default class Get extends GeneratedBackupGetProjectBackup {
+import { RenderBaseCommand } from "../../../rendering/react/RenderBaseCommand.js";
+import { ReactNode } from "react";
+export default class Get extends RenderBaseCommand<typeof Get> {
+    static description: string;
+    static args: {
+        "backup-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    protected render(): ReactNode;
 }

package/dist/esm/commands/project/backup/get.js

@@ -1,6 +1,27 @@
-/* eslint-disable */
-/* prettier-ignore */
-/* This file is auto-generated with acg (@mittwald/api-code-generator) */
-import { GeneratedBackupGetProjectBackup } from "../../../generated/backup/getProjectBackup.js";
-export default class Get extends GeneratedBackupGetProjectBackup {
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RenderBaseCommand } from "../../../rendering/react/RenderBaseCommand.js";
+import { useProjectBackup } from "../../../lib/projectbackup/hooks.js";
+import { Args } from "@oclif/core";
+import { ProjectBackupDetails } from "../../../rendering/react/components/ProjectBackup/ProjectBackupDetails.js";
+import { RenderJson } from "../../../rendering/react/json/RenderJson.js";
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+import { Box } from "ink";
+export default class Get extends RenderBaseCommand {
+    static description = "show details of a backup.";
+    static args = {
+        "backup-id": Args.string({
+            required: true,
+            description: "The ID of the Backup to show.",
+        }),
+    };
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    render() {
+        const projectBackup = useProjectBackup(this.args["backup-id"]);
+        if (this.flags.output === "json") {
+            return _jsx(RenderJson, { name: "projectBackup", data: projectBackup });
+        }
+        return (_jsx(Box, { marginBottom: 1, children: _jsx(ProjectBackupDetails, { projectBackup: projectBackup }) }));
+    }
 }

package/dist/esm/commands/project/backup/list.d.ts

@@ -1,19 +1,19 @@
-import { Simplify } from "@mittwald/api-client-commons";
-import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { Response, Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
 import { SuccessfulResponse } from "../../../types.js";
 import { ListBaseCommand } from "../../../ListBaseCommand.js";
 import { ListColumns } from "../../../Formatter.js";
-type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdBackups.Get.Responses.$200.Content.ApplicationJson[number]>;
-export type PathParams = MittwaldAPIV2.Paths.V2ProjectsProjectIdBackups.Get.Parameters.Path;
-export type Response = Awaited<ReturnType<MittwaldAPIV2Client["backup"]["listProjectBackups"]>>;
-export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+import BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+type ListResponse = Response<BackupProjectBackup[]>;
+type ListItem = Simplify<BackupProjectBackup>;
+export declare class List extends ListBaseCommand<typeof List, ListItem, ListResponse> {
     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>;
     };
-    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): ResponseItem[] | Promise<ResponseItem[]>;
-    getData(): Promise<Response>;
-    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
+    protected mapData(data: SuccessfulResponse<ListResponse, 200>["data"]): ListItem[] | Promise<ListItem[]>;
+    getData(): Promise<ListResponse>;
+    protected getColumns(data: ListItem[]): ListColumns<ListItem>;
 }
 export {};

package/dist/esm/commands/project/backupschedule/list.d.ts

@@ -1,13 +1,19 @@
 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 { GeneratedBackupListProjectBackupSchedules, Response } from "../../../generated/backup/listProjectBackupSchedules.js";
-import { PathParams } from "../../../generated/backup/listProjectBackups.js";
 import { ListColumns } from "../../../Formatter.js";
-type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdBackupSchedules.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedBackupListProjectBackupSchedules<ResponseItem> {
-    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.BackupProjectBackupSchedule[];
-    protected mapParams(input: PathParams): Promise<PathParams>;
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import BackupProjectBackupSchedule = MittwaldAPIV2.Components.Schemas.BackupProjectBackupSchedule;
+type ResponseItem = Simplify<BackupProjectBackupSchedule>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["backup"]["listProjectBackupSchedules"]>>;
+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"]): BackupProjectBackupSchedule[];
     protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
 }
 export {};

package/dist/esm/commands/project/backupschedule/list.js

@@ -1,13 +1,21 @@
-import { GeneratedBackupListProjectBackupSchedules, } from "../../../generated/backup/listProjectBackupSchedules.js";
-import { normalizeProjectIdToUuid } from "../../../Helpers.js";
-export default class List extends GeneratedBackupListProjectBackupSchedules {
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { projectFlags, withProjectId } from "../../../lib/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List backup schedules belonging to a given 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.backup.listProjectBackupSchedules({
+            pathParameters: { projectId },
+        });
+    }
     mapData(data) {
         return data;
     }
-    async mapParams(input) {
-        input.projectId = await normalizeProjectIdToUuid(this.apiClient, input.projectId);
-        return super.mapParams(input);
-    }
     getColumns(data) {
         const baseColumns = super.getColumns(data);
         return {

package/dist/esm/commands/project/create.d.ts

@@ -6,8 +6,9 @@ export default class Create extends ExecRenderBaseCommand<typeof Create, {
     static description: string;
     static flags: {
         description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        wait: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         "update-context": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        wait: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "wait-timeout": 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>;
     };
     protected exec(): Promise<{

package/dist/esm/commands/project/create.js

@@ -7,22 +7,19 @@ import { Text } from "ink";
 import { Success } from "../../rendering/react/components/Success.js";
 import { Value } from "../../rendering/react/components/Value.js";
 import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
-import { waitUntil } from "../../lib/wait.js";
+import { waitFlags, waitUntil } from "../../lib/wait.js";
 import { Context } from "../../lib/context.js";
 export default class Create extends ExecRenderBaseCommand {
     static description = "Get the details of a project";
     static flags = {
         ...serverFlags,
         ...processFlags,
+        ...waitFlags,
         description: Flags.string({
             char: "d",
             required: true,
             description: "A description for the project.",
         }),
-        wait: Flags.boolean({
-            char: "w",
-            description: "Wait for the project to be ready.",
-        }),
         "update-context": Flags.boolean({
             description: "Update the CLI context to use the newly created project",
         }),
@@ -52,7 +49,7 @@ export default class Create extends ExecRenderBaseCommand {
                     projectResponse.data.readiness === "ready") {
                     return true;
                 }
-            });
+            }, this.flags["wait-timeout"]);
             stepWaiting.complete();
         }
         if (flags["update-context"]) {

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

@@ -0,0 +1,21 @@
+import { ArgOutput, OutputFlags } from "@oclif/core/lib/interfaces/parser.js";
+import { AvailableFlagName, RelevantFlagInput } from "./flags.js";
+import React from "react";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { Config } from "@oclif/core";
+export interface AppInstallationResult {
+    appInstallationId: string;
+}
+export declare class AppInstaller<TFlagName extends AvailableFlagName> {
+    readonly appId: string;
+    readonly appName: string;
+    readonly appSupportedFlags: readonly TFlagName[];
+    readonly description: string;
+    private static makeDescription;
+    constructor(appId: string, appName: string, appSupportedFlags: readonly TFlagName[]);
+    get flags(): RelevantFlagInput<readonly TFlagName[]>;
+    exec(apiClient: MittwaldAPIV2Client, args: ArgOutput, flags: OutputFlags<RelevantFlagInput<(TFlagName | "version" | "wait")[]>>, config: Config): Promise<AppInstallationResult>;
+    render(result: AppInstallationResult, flags: {
+        quiet: boolean;
+    }): React.ReactNode;
+}

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

@@ -0,0 +1,49 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { makeProcessRenderer } from "../../rendering/process/process_flags.js";
+import { withProjectId } from "../project/flags.js";
+import { autofillFlags, provideSupportedFlags, } from "./flags.js";
+import { normalizeToAppVersionUuid } from "./versions.js";
+import { triggerAppInstallation } from "./install.js";
+import { waitUntilAppIsInstalled } from "./wait.js";
+import { Success } from "../../rendering/react/components/Success.js";
+export class AppInstaller {
+    appId;
+    appName;
+    appSupportedFlags;
+    description;
+    static makeDescription(appName) {
+        return `Creates new ${appName} Installation.`;
+    }
+    constructor(appId, appName, appSupportedFlags) {
+        this.appId = appId;
+        this.appName = appName;
+        this.appSupportedFlags = appSupportedFlags;
+        this.description = AppInstaller.makeDescription(appName);
+    }
+    get flags() {
+        return provideSupportedFlags(this.appSupportedFlags, this.appName);
+    }
+    async exec(apiClient, args, flags, config) {
+        const process = makeProcessRenderer(flags, `Installing ${this.appName}`);
+        const projectId = await withProjectId(apiClient, flags, args, config);
+        await autofillFlags(apiClient, process, this.appSupportedFlags, flags, projectId, this.appName);
+        const appVersion = await normalizeToAppVersionUuid(apiClient, flags.version, process, this.appId);
+        const [appInstallationId, eventId] = await triggerAppInstallation(apiClient, process, projectId, flags, appVersion);
+        let successText;
+        if (flags.wait) {
+            await waitUntilAppIsInstalled(apiClient, process, appInstallationId, eventId);
+            successText = `Your ${this.appName} installation is now complete. Have fun! 🎉`;
+        }
+        else {
+            successText = `Your ${this.appName} installation has started. Have fun when it's ready! 🎉`;
+        }
+        process.complete(_jsx(Success, { children: successText }));
+        return { appInstallationId };
+    }
+    render(result, flags) {
+        if (flags.quiet) {
+            return result.appInstallationId;
+        }
+        return undefined;
+    }
+}

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

@@ -1,3 +1,28 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+import { ProcessFlags } from "../../rendering/process/process_flags.js";
+import { BooleanFlag, FlagInput, OptionFlag, OutputFlags } from "@oclif/core/lib/interfaces/parser.js";
 export declare const appInstallationFlags: {
     "installation-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
 };
+export type AvailableFlagName = keyof AvailableFlags;
+interface AvailableFlags {
+    version: OptionFlag<string>;
+    host: OptionFlag<string | undefined>;
+    "admin-user": OptionFlag<string | undefined>;
+    "admin-email": OptionFlag<string | undefined>;
+    "admin-pass": OptionFlag<string | undefined>;
+    "admin-firstname": OptionFlag<string | undefined>;
+    "admin-lastname": OptionFlag<string | undefined>;
+    "site-title": OptionFlag<string | undefined>;
+    "shop-email": OptionFlag<string | undefined>;
+    "shop-lang": OptionFlag<string | undefined>;
+    "shop-currency": OptionFlag<string | undefined>;
+    "install-mode": OptionFlag<string>;
+    wait: BooleanFlag<boolean | undefined>;
+}
+export type RelevantFlags<TFlags extends readonly AvailableFlagName[]> = ProcessFlags & Pick<AvailableFlags, TFlags[number]>;
+export type RelevantFlagInput<TFlags extends readonly AvailableFlagName[]> = FlagInput<RelevantFlags<TFlags>>;
+export declare function provideSupportedFlags<TFlagNames extends readonly AvailableFlagName[]>(requestedFlagNames: TFlagNames, appName: string): RelevantFlagInput<TFlagNames>;
+export declare function autofillFlags(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, necessaryFlags: readonly AvailableFlagName[], flags: Partial<OutputFlags<RelevantFlagInput<AvailableFlagName[]>>>, projectId: string, appName: string): Promise<void>;
+export {};