@mittwald/cli 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/lib/app/versions.js

@@ -0,0 +1,49 @@
+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({
+        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);
+}
+// App Version UUID from App Version irellevant if internal or external
+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);
+}

package/dist/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): Promise<void>;

package/dist/lib/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 waitUntilAppIsInstalled(apiClient, process, appInstallationId) {
+    const stepWaiting = process.addStep(_jsx(Text, { children: "waiting for app installation to be ready" }));
+    await waitUntil(async () => {
+        const installationResponse = await apiClient.app.getAppinstallation({
+            appInstallationId,
+        });
+        if (installationResponse.status === 200 &&
+            installationResponse.data.appVersion.current ==
+                installationResponse.data.appVersion.desired) {
+            return true;
+        }
+    });
+    stepWaiting.complete();
+}

package/dist/lib/assert_success.d.ts

@@ -0,0 +1,3 @@
+import { Response } from "@mittwald/api-client-commons";
+export declare function assertSuccess<T extends Response>(response: T): void;
+export default assertSuccess;

package/dist/lib/assert_success.js

@@ -0,0 +1,7 @@
+import { ApiClientError } from "@mittwald/api-client-commons";
+export function assertSuccess(response) {
+    if (response.status >= 300) {
+        throw ApiClientError.fromResponse(`Unexpected response status (expected <300, got: ${response.status})`, response);
+    }
+}
+export default assertSuccess;

package/dist/lib/auth/token.d.ts

@@ -0,0 +1,13 @@
+import { Config } from "@oclif/core";
+/**
+ * Gets the filename in which the CLI should store the API token.
+ *
+ * @param config The CLI configuration object.
+ */
+export declare function getTokenFilename(config: Config): string;
+/**
+ * Reads the API token from the environment or the configuration file.
+ *
+ * @param config The CLI configuration object.
+ */
+export declare function readApiToken(config: Config): Promise<string | undefined>;

package/dist/lib/auth/token.js

@@ -0,0 +1,44 @@
+import path from "path";
+import fs from "fs/promises";
+import { isNotFound } from "../fsutil.js";
+/**
+ * Gets the filename in which the CLI should store the API token.
+ *
+ * @param config The CLI configuration object.
+ */
+export function getTokenFilename(config) {
+    return path.join(config.configDir, "token");
+}
+/**
+ * Reads the API token from the environment or the configuration file.
+ *
+ * @param config The CLI configuration object.
+ */
+export async function readApiToken(config) {
+    return (readApiTokenFromEnvironment() ?? (await readApiTokenFromConfig(config)));
+}
+/** Reads the API token from the MITTWALD_API_TOKEN environment variable. */
+function readApiTokenFromEnvironment() {
+    const token = process.env.MITTWALD_API_TOKEN;
+    if (token === undefined) {
+        return undefined;
+    }
+    return token.trim();
+}
+/**
+ * Reads the API token from the configuration file.
+ *
+ * @param config The CLI configuration object.
+ */
+async function readApiTokenFromConfig(config) {
+    try {
+        const tokenFileContents = await fs.readFile(getTokenFilename(config), "utf-8");
+        return tokenFileContents.trim();
+    }
+    catch (err) {
+        if (isNotFound(err)) {
+            return undefined;
+        }
+        throw err;
+    }
+}

package/dist/lib/bytes.d.ts

@@ -0,0 +1 @@
+export declare function parseBytes(input: string): number;

package/dist/lib/bytes.js

@@ -0,0 +1,16 @@
+export function parseBytes(input) {
+    const numeric = parseInt(input.replace(/[^0-9]/g, ""), 10);
+    if (`${numeric}` == input) {
+        return numeric;
+    }
+    if (input.toLowerCase().endsWith("gi")) {
+        return numeric * (1 << 30);
+    }
+    if (input.toLowerCase().endsWith("mi")) {
+        return numeric * (1 << 20);
+    }
+    if (input.toLowerCase().endsWith("ki")) {
+        return numeric * (1 << 10);
+    }
+    throw new Error("unsupported byte unit; supported are 'gi', 'mi', 'ki'");
+}

package/dist/lib/context.d.ts

@@ -0,0 +1,40 @@
+import { Config } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export type ContextNames = "project" | "server" | "org" | "installation" | "domain" | "dnszone";
+export type ContextKey<N extends ContextNames = ContextNames> = `${N}-id`;
+export type ContextMap = Partial<Record<ContextKey, ContextValue>>;
+export type ContextMapUpdate = Partial<Record<ContextKey, string>>;
+export type ContextValueSource = {
+    type: string;
+    identifier: string;
+};
+export type ContextValue = {
+    value: string;
+    source: ContextValueSource;
+};
+export interface ContextProvider {
+    name: string;
+    getOverrides(): Promise<ContextMap>;
+}
+export interface WritableContextProvider extends ContextProvider {
+    update(data: ContextMapUpdate): Promise<void>;
+    reset(): Promise<void>;
+}
+export declare class Context {
+    private readonly contextData;
+    readonly providers: ContextProvider[];
+    constructor(apiClient: MittwaldAPIV2Client, config: Config);
+    private initializeContextData;
+    reset(): Promise<void>;
+    private persist;
+    private setContextValue;
+    getContextValue(key: ContextKey): Promise<ContextValue | undefined>;
+    setProjectId: (id: string) => Promise<void>;
+    setServerId: (id: string) => Promise<void>;
+    setOrgId: (id: string) => Promise<void>;
+    setAppInstallationId: (id: string) => Promise<void>;
+    projectId: () => Promise<ContextValue | undefined>;
+    serverId: () => Promise<ContextValue | undefined>;
+    orgId: () => Promise<ContextValue | undefined>;
+    appInstallationId: () => Promise<ContextValue | undefined>;
+}

package/dist/lib/context.js

@@ -0,0 +1,58 @@
+import { TerraformContextProvider } from "./context_terraform.js";
+import { UserContextProvider } from "./context_user.js";
+import { DDEVContextProvider } from "./context_ddev.js";
+function isWritable(p) {
+    return "update" in p;
+}
+export class Context {
+    contextData;
+    providers;
+    constructor(apiClient, config) {
+        this.providers = [
+            new UserContextProvider(config),
+            new TerraformContextProvider(),
+            new DDEVContextProvider(apiClient),
+        ];
+        this.contextData = this.initializeContextData();
+    }
+    async initializeContextData() {
+        const contextData = {};
+        for (const provider of this.providers) {
+            const overrides = await provider.getOverrides();
+            Object.assign(contextData, overrides);
+        }
+        return contextData;
+    }
+    async reset() {
+        for (const provider of this.providers) {
+            if (isWritable(provider)) {
+                await provider.reset();
+            }
+        }
+    }
+    async persist(data) {
+        for (const provider of this.providers) {
+            if (isWritable(provider)) {
+                await provider.update(data);
+            }
+        }
+    }
+    async setContextValue(key, value) {
+        return await this.persist({ [key]: value });
+    }
+    async getContextValue(key) {
+        const data = await this.contextData;
+        if (key in data) {
+            return data[key];
+        }
+        return undefined;
+    }
+    setProjectId = (id) => this.setContextValue("project-id", id);
+    setServerId = (id) => this.setContextValue("server-id", id);
+    setOrgId = (id) => this.setContextValue("org-id", id);
+    setAppInstallationId = (id) => this.setContextValue("installation-id", id);
+    projectId = () => this.getContextValue("project-id");
+    serverId = () => this.getContextValue("server-id");
+    orgId = () => this.getContextValue("org-id");
+    appInstallationId = () => this.getContextValue("installation-id");
+}

package/dist/lib/context_ddev.d.ts

@@ -0,0 +1,20 @@
+import { ContextMap, ContextProvider } from "./context.js";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+/**
+ * DDEVContextProvider is a ContextProvider that reads context overrides from
+ * local DDEV configuration files; it looks for a .ddev directory in the current
+ * working directory or any of its parent directories and reads any
+ * configuration yaml files from it.
+ */
+export declare class DDEVContextProvider implements ContextProvider {
+    name: string;
+    private apiClient;
+    constructor(apiClient: MittwaldAPIV2Client);
+    getOverrides(): Promise<ContextMap>;
+    private fillOverridesFromAppInstallationId;
+    /**
+     * Find the .ddev directory in the current working directory or any of its
+     * parent directories.
+     */
+    private findDDEVConfigDir;
+}

package/dist/lib/context_ddev.js

@@ -0,0 +1,81 @@
+import { cwd } from "process";
+import path from "path";
+import fs from "fs/promises";
+import yaml from "js-yaml";
+import { assertStatus } from "@mittwald/api-client";
+import { pathExists } from "./fsutil.js";
+/**
+ * DDEVContextProvider is a ContextProvider that reads context overrides from
+ * local DDEV configuration files; it looks for a .ddev directory in the current
+ * working directory or any of its parent directories and reads any
+ * configuration yaml files from it.
+ */
+export class DDEVContextProvider {
+    name = "ddev";
+    apiClient;
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async getOverrides() {
+        const ddevConfigDir = await this.findDDEVConfigDir();
+        if (!ddevConfigDir) {
+            return {};
+        }
+        const configs = [
+            "config.yaml",
+            ...(await findDDEVConfigFiles(ddevConfigDir)),
+        ];
+        let overrides = {};
+        for (const config of configs) {
+            const configPath = path.join(ddevConfigDir, config);
+            const contents = await fs.readFile(configPath, "utf-8");
+            const parsed = yaml.load(contents);
+            const source = { type: "ddev", identifier: configPath };
+            for (const env of parsed.web_environment ?? []) {
+                const [name, valueInput] = env.split("=", 2);
+                if (name === "MITTWALD_APP_INSTALLATION_ID") {
+                    overrides = {
+                        ...overrides,
+                        ...(await this.fillOverridesFromAppInstallationId(source, valueInput)),
+                    };
+                }
+            }
+        }
+        return overrides;
+    }
+    async fillOverridesFromAppInstallationId(source, appInstallationId) {
+        const response = await this.apiClient.app.getAppinstallation({
+            appInstallationId,
+        });
+        assertStatus(response, 200);
+        const out = {
+            "installation-id": { value: response.data.id, source },
+        };
+        if (response.data.projectId) {
+            out["project-id"] = {
+                value: response.data.projectId,
+                source,
+            };
+        }
+        return out;
+    }
+    /**
+     * Find the .ddev directory in the current working directory or any of its
+     * parent directories.
+     */
+    async findDDEVConfigDir() {
+        let currentDir = cwd();
+        while (currentDir !== "/") {
+            const ddevDir = path.join(currentDir, ".ddev", "config.yaml");
+            if (await pathExists(ddevDir)) {
+                return path.dirname(ddevDir);
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return undefined;
+    }
+}
+async function findDDEVConfigFiles(dir) {
+    const configFilePattern = /^config\.*\.ya?ml$/;
+    return (await fs.readdir(dir)).filter((e) => configFilePattern.test(e));
+}

package/dist/lib/context_flags.d.ts

@@ -0,0 +1,47 @@
+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";
+import { ContextKey, ContextNames } from "./context.js";
+export type ContextFlags<N extends ContextNames, TID extends string = ContextKey<N>> = {
+    [k in TID]: OptionFlag<string>;
+};
+export type ContextArgs<N extends ContextNames, TID extends string = ContextKey<N>> = {
+    [k in TID]: Arg<string>;
+};
+export type CommandType<N extends ContextNames, TID extends string = ContextKey<N>> = {
+    flags: {
+        [k in TID]: OptionFlag<string>;
+    };
+} | {
+    args: {
+        [k in TID]: Arg<string>;
+    };
+};
+export declare class MissingFlagError extends Error {
+    constructor(name: string, flagName: string);
+}
+export declare class MissingArgError extends Error {
+    constructor(name: string, flagName: string);
+}
+export type FlagSet<TName extends ContextNames> = {
+    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 FlagSetOptions = {
+    normalize: NormalizeFn;
+    displayName: string;
+};
+export type NormalizeFn = (apiClient: MittwaldAPIV2Client, id: string) => string | Promise<string>;
+export declare function makeMissingContextInputError<TName extends ContextNames>(commandType: {
+    flags: {
+        [k in ContextKey<TName>]: OptionFlag<string>;
+    };
+} | {
+    args: {
+        [k in ContextKey<TName>]: Arg<string>;
+    };
+} | "flag" | "arg", name: TName, flagName: `${TName}-id`, contextSupport?: boolean): Error;
+export declare function makeFlagSet<TName extends ContextNames>(name: TName, char: AlphabetLowercase, opts?: Partial<FlagSetOptions>): FlagSet<TName>;

package/dist/lib/context_flags.js

@@ -0,0 +1,75 @@
+import { Args, Flags } from "@oclif/core";
+import { Context } from "./context.js";
+export 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}>'`);
+    }
+}
+export 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 makeMissingContextInputError(commandType, name, flagName, contextSupport = true) {
+    if (commandType === "flag") {
+        return new MissingFlagError(name, flagName);
+    }
+    if (commandType === "arg") {
+        return new MissingArgError(name, flagName);
+    }
+    if ("flags" in commandType && flagName in commandType.flags) {
+        return new MissingFlagError(name, flagName);
+    }
+    if ("args" in commandType && flagName in commandType.args) {
+        return new MissingArgError(name, flagName);
+    }
+    if (contextSupport) {
+        return 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 new Error(`No ${name} ID given. Please consult the --help page of this command.`);
+}
+export function makeFlagSet(name, char, opts = {}) {
+    const { displayName = name, normalize = (_, id) => id } = opts;
+    const article = displayName.match(/^[aeiou]/i) ? "an" : "a";
+    const flagName = `${name}-id`;
+    const flags = {
+        [flagName]: Flags.string({
+            char,
+            required: false,
+            summary: `ID or short ID of ${article} ${displayName}; this flag is optional if a default ${displayName} is set in the context`,
+            description: `May contain a short ID or a full ID of ${article} ${displayName}; you can also use the "<%= config.bin %> context set --${flagName}=<VALUE>" command to persistently set a default ${displayName} for all commands that accept this flag.`,
+            default: undefined,
+        }),
+    };
+    const args = {
+        [flagName]: Args.string({
+            description: `ID or short ID of ${article} ${displayName}; this argument is optional if a default ${displayName} is set in the context`,
+        }),
+    };
+    const idFromArgsOrFlag = (flags, args) => {
+        if (args[flagName]) {
+            return args[flagName];
+        }
+        if (flags[flagName]) {
+            return flags[flagName];
+        }
+        return undefined;
+    };
+    const withId = async (apiClient, commandType, flags, args, cfg) => {
+        const idInput = idFromArgsOrFlag(flags, args);
+        if (idInput) {
+            return normalize(apiClient, idInput);
+        }
+        const idFromContext = await new Context(apiClient, cfg).getContextValue(flagName);
+        if (idFromContext) {
+            return idFromContext.value;
+        }
+        throw makeMissingContextInputError(commandType, name, flagName);
+    };
+    return {
+        name,
+        flags,
+        args,
+        withId,
+    };
+}

package/dist/lib/context_terraform.d.ts

@@ -0,0 +1,6 @@
+import { ContextMap, ContextProvider } from "./context.js";
+export declare class TerraformContextProvider implements ContextProvider {
+    readonly name = "terraform";
+    getOverrides(): Promise<ContextMap>;
+    private findTerraformStateFile;
+}

package/dist/lib/context_terraform.js

@@ -0,0 +1,55 @@
+import fs from "fs/promises";
+import { cwd } from "process";
+import path from "path";
+import { pathExists } from "./fsutil.js";
+function overrideIDFromState(state, type) {
+    const instances = state.resources?.find((r) => r.type === type)?.instances;
+    if (instances === undefined) {
+        return undefined;
+    }
+    // If the context cannot be determined unambiguously, don't use the Terraform
+    // state at all.
+    if (instances.length > 1) {
+        return undefined;
+    }
+    const id = instances[0]?.attributes?.id;
+    return typeof id === "string" ? id : undefined;
+}
+export class TerraformContextProvider {
+    name = "terraform";
+    async getOverrides() {
+        const file = await this.findTerraformStateFile();
+        if (!file) {
+            return {};
+        }
+        const contents = await fs.readFile(file, "utf-8");
+        const state = JSON.parse(contents);
+        const overrides = {};
+        const source = { type: "terraform", identifier: file };
+        const projectID = overrideIDFromState(state, "mittwald_project");
+        if (projectID) {
+            overrides["project-id"] = { value: projectID, source };
+        }
+        const serverID = overrideIDFromState(state, "mittwald_server");
+        if (serverID) {
+            overrides["server-id"] = { value: serverID, source };
+        }
+        const appID = overrideIDFromState(state, "mittwald_app");
+        if (appID) {
+            overrides["installation-id"] = { value: appID, source };
+        }
+        return overrides;
+    }
+    // Iterate through all parent directories and look for a terraform state file.
+    async findTerraformStateFile() {
+        let currentDir = cwd();
+        while (currentDir !== "/") {
+            const stateFile = path.join(currentDir, "terraform.tfstate");
+            if (await pathExists(stateFile)) {
+                return stateFile;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return undefined;
+    }
+}

package/dist/lib/context_user.d.ts

@@ -0,0 +1,11 @@
+import { ContextKey, ContextMap, ContextProvider, WritableContextProvider } from "./context.js";
+import { Config } from "@oclif/core";
+export declare class UserContextProvider implements ContextProvider, WritableContextProvider {
+    private readonly config;
+    name: string;
+    constructor(config: Config);
+    private get contextFile();
+    getOverrides(): Promise<ContextMap>;
+    reset(): Promise<void>;
+    update(updatedData: Record<ContextKey, string>): Promise<void>;
+}

package/dist/lib/context_user.js

@@ -0,0 +1,56 @@
+import fs from "fs/promises";
+import path from "path";
+function isNotExists(e) {
+    return e instanceof Error && "code" in e && e.code === "ENOENT";
+}
+export class UserContextProvider {
+    config;
+    name = "user";
+    constructor(config) {
+        this.config = config;
+    }
+    get contextFile() {
+        return path.join(this.config.configDir, "context.json");
+    }
+    async getOverrides() {
+        try {
+            const contents = await fs.readFile(this.contextFile, "utf-8");
+            const rawValues = JSON.parse(contents);
+            const source = { type: "user", identifier: this.contextFile };
+            return Object.fromEntries(Object.entries(rawValues).map(([k, v]) => [k, { value: v, source }]));
+        }
+        catch (e) {
+            if (isNotExists(e)) {
+                return {};
+            }
+            throw e;
+        }
+    }
+    async reset() {
+        try {
+            await fs.unlink(this.contextFile);
+        }
+        catch (e) {
+            if (isNotExists(e)) {
+                return;
+            }
+            throw e;
+        }
+    }
+    async update(updatedData) {
+        const data = await this.getOverrides();
+        const source = { type: "user", identifier: this.contextFile };
+        for (const k of Object.keys(updatedData)) {
+            data[k] = { value: updatedData[k], source };
+        }
+        const output = {};
+        for (const k of Object.keys(data)) {
+            const val = data[k]?.value;
+            if (val !== undefined) {
+                output[k] = val;
+            }
+        }
+        await fs.mkdir(this.config.configDir, { recursive: true });
+        await fs.writeFile(path.join(this.config.configDir, "context.json"), JSON.stringify(output), "utf-8");
+    }
+}

package/dist/lib/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/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;
+    });
+}