@mittwald/cli 1.2.5 → 1.3.0

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

@@ -0,0 +1,30 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListColumns } from "../../rendering/formatter/Table.js";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+type ResponseItem = {
+    id: string;
+    kind: "mysql" | "redis";
+    name: string;
+    version: string;
+    description: string;
+    hostname: string;
+    isReady: boolean;
+    createdAt: string;
+};
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlDatabases"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/interfaces").OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-header": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-truncate": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-relative-dates": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "csv-separator": import("@oclif/core/interfaces").OptionFlag<"," | ";">;
+    };
+    getData(): Promise<ResponseItem[]>;
+    protected getColumns(ignoredData: ResponseItem[]): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/database/list.js

@@ -0,0 +1,68 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List all kinds of databases belonging to a project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        const databases = [];
+        const mysqlResponse = await this.apiClient.database.listMysqlDatabases({
+            projectId,
+        });
+        assertStatus(mysqlResponse, 200);
+        const redisResponse = await this.apiClient.database.listRedisDatabases({
+            projectId,
+        });
+        assertStatus(redisResponse, 200);
+        databases.push(...mysqlResponse.data.map((d) => ({ ...d, kind: "mysql" })), ...redisResponse.data.map((d) => ({
+            ...d,
+            kind: "redis",
+            isReady: true,
+        })));
+        return databases;
+    }
+    getColumns(ignoredData) {
+        const { id, name, createdAt } = super.getColumns(ignoredData, {
+            shortIdKey: "name",
+        });
+        return {
+            id,
+            name,
+            version: {
+                header: "Version",
+                get(row) {
+                    if (row.kind === "mysql") {
+                        return `MySQL ${row.version}`;
+                    }
+                    else if (row.kind === "redis") {
+                        return `Redis ${row.version}`;
+                    }
+                    else {
+                        return "Unknown";
+                    }
+                },
+            },
+            description: {
+                header: "Description",
+            },
+            hostname: {
+                header: "Hostname",
+            },
+            status: {
+                header: "Status",
+                get: (row) => {
+                    if (!row.isReady) {
+                        return "pending";
+                    }
+                    return "ready";
+                },
+            },
+            createdAt,
+        };
+    }
+}

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

@@ -10,6 +10,7 @@ export declare class Dump extends ExecRenderBaseCommand<typeof Dump, Record<stri
         "ssh-identity-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         "temporary-user": import("@oclif/core/interfaces").BooleanFlag<boolean>;
         "mysql-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "mysql-charset": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static args: {

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

@@ -68,5 +68,14 @@ function DumpSuccess({ database, output, }) {
     return (_jsxs(Success, { children: ["Dump of MySQL database ", _jsx(Value, { children: database }), " written to", " ", _jsx(Value, { children: output })] }));
 }
 function buildMySqlDumpArgs(d) {
-    return ["-h", d.hostname, "-u", d.user, `-p${d.password}`, d.database];
+    return [
+        "-h",
+        d.hostname,
+        "-u",
+        d.user,
+        `-p${d.password}`,
+        "--default-character-set",
+        d.charset,
+        d.database,
+    ];
 }

package/dist/commands/database/mysql/import.d.ts

@@ -10,6 +10,7 @@ export declare class Import extends ExecRenderBaseCommand<typeof Import, Record<
         "ssh-identity-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         "temporary-user": import("@oclif/core/interfaces").BooleanFlag<boolean>;
         "mysql-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "mysql-charset": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static args: {

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

@@ -1,6 +1,6 @@
 import { Simplify } from "@mittwald/api-client-commons";
 import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
-import { ListColumns } from "../../../rendering/formatter/ListFormatter.js";
+import { ListColumns } from "../../../rendering/formatter/Table.js";
 import { ListBaseCommand } from "../../../lib/basecommands/ListBaseCommand.js";
 type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdMysqlDatabases.Get.Responses.$200.Content.ApplicationJson[number]>;
 type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlDatabases"]>>;

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

@@ -26,7 +26,7 @@ export class PortForward extends ExecRenderBaseCommand {
     async exec() {
         const databaseId = await withMySQLId(this.apiClient, this.flags, this.args);
         const p = makeProcessRenderer(this.flags, "Port-forwarding a MySQL database");
-        const { sshUser, sshHost, hostname, database } = await getConnectionDetails(this.apiClient, databaseId, this.flags["ssh-user"], p);
+        const { sshUser, sshHost, hostname, database } = await getConnectionDetails(this.apiClient, databaseId, this.flags["ssh-user"], undefined, p);
         const { port } = this.flags;
         p.complete(_jsxs(Text, { children: ["Forwarding MySQL database ", _jsx(Value, { children: database }), " to local port", " ", _jsx(Value, { children: port }), ". Use CTRL+C to cancel."] }));
         const sshArgs = buildSSHClientFlags(sshUser, sshHost, this.flags, {

package/dist/commands/database/mysql/shell.d.ts

@@ -5,6 +5,7 @@ export declare class Shell extends ExecRenderBaseCommand<typeof Shell, Record<st
     static description: string;
     static flags: {
         "mysql-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "mysql-charset": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         "ssh-user": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         "ssh-identity-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/lib/basecommands/ListBaseCommand.d.ts

@@ -24,7 +24,7 @@ export declare abstract class ListBaseCommand<T extends typeof BaseCommand, TIte
     protected sorter?: SorterFunction<TItem>;
     init(): Promise<void>;
     run(): Promise<void>;
-    protected abstract getData(): Promise<TAPIResponse>;
+    protected abstract getData(): Promise<TAPIResponse | TItem[]>;
     protected mapData(data: SuccessfulResponse<TAPIResponse, 200>["data"]): TItem[] | Promise<TItem[]>;
     protected getColumns(data: TItem[], opts?: ColumnOpts<TItem>): ListColumns<TItem>;
 }

package/dist/lib/basecommands/ListBaseCommand.js

@@ -21,8 +21,14 @@ export class ListBaseCommand extends ExtendedBaseCommand {
     }
     async run() {
         const response = await this.getData();
-        assertStatus(response, 200);
-        const data = await this.mapData(response.data);
+        let data;
+        if (!Array.isArray(response)) {
+            assertStatus(response, 200);
+            data = await this.mapData(response.data);
+        }
+        else {
+            data = response;
+        }
         this.formatter.log(data, this.getColumns(data), this.flags);
     }
     mapData(data) {

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

@@ -159,7 +159,7 @@ export function provideSupportedFlags(requestedFlagNames, appName) {
     return flagsToReturn;
 }
 export async function autofillFlags(apiClient, process, necessaryFlags, flags, projectId, appName, defaults) {
-    const ownUser = await apiClient.user.getOwnAccount();
+    const ownUser = await apiClient.user.getUser({ userId: "self" });
     assertStatus(ownUser, 200);
     // Version
     if (necessaryFlags.includes("version") && !flags.version) {

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

@@ -1,7 +1,7 @@
 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();
+        const r = await apiClient.user.getUser({ userId: "self" });
         assertStatus(r, 200);
         return r.data;
     });

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

@@ -4,6 +4,7 @@ import { MittwaldAPIV2Client } from "@mittwald/api-client";
 type Project = MittwaldAPIV2.Components.Schemas.ProjectProject;
 export interface MySQLConnectionFlags {
     "mysql-password": string | undefined;
+    "mysql-charset": string | undefined;
     "temporary-user"?: boolean;
     "ssh-user"?: string;
 }
@@ -14,6 +15,7 @@ export interface MySQLConnectionDetails {
     sshHost: string;
     sshUser: string;
     project: Project;
+    charset: string;
 }
 export type MySQLConnectionDetailsWithPassword = MySQLConnectionDetails & {
     password: string;
@@ -27,5 +29,5 @@ export type MySQLConnectionDetailsWithPassword = MySQLConnectionDetails & {
  */
 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 declare function getConnectionDetails(apiClient: MittwaldAPIV2Client, databaseId: string, sshUser: string | undefined, characterSet: string | undefined, p: ProcessRenderer): Promise<MySQLConnectionDetails>;
 export {};

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

@@ -19,12 +19,13 @@ export async function runWithConnectionDetails(apiClient, databaseId, p, flags,
 export async function getConnectionDetailsWithPassword(apiClient, databaseId, p, flags) {
     const password = flags["temporary-user"] ? "" : await getPassword(p, flags);
     const sshUser = flags["ssh-user"];
+    const characterSet = flags["mysql-charset"];
     return {
-        ...(await getConnectionDetails(apiClient, databaseId, sshUser, p)),
+        ...(await getConnectionDetails(apiClient, databaseId, sshUser, characterSet, p)),
         password,
     };
 }
-export async function getConnectionDetails(apiClient, databaseId, sshUser, p) {
+export async function getConnectionDetails(apiClient, databaseId, sshUser, characterSet, p) {
     const database = await getDatabase(apiClient, p, databaseId);
     const databaseUser = await getDatabaseUser(apiClient, p, databaseId);
     const project = await getProject(apiClient, p, database);
@@ -35,6 +36,7 @@ export async function getConnectionDetails(apiClient, databaseId, sshUser, p) {
         user: databaseUser.name,
         sshHost: sshConnectionData.host,
         sshUser: sshConnectionData.user,
+        charset: characterSet ?? database.characterSettings.characterSet,
         project,
     };
 }

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

@@ -1,10 +1,12 @@
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 export declare const mysqlConnectionFlags: {
     "mysql-password": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    "mysql-charset": 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>;
+    "mysql-charset": 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>>;

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

@@ -12,6 +12,10 @@ NOTE: This is a security risk, as the password will be visible in the process li
         required: false,
         env: "MYSQL_PWD",
     }),
+    "mysql-charset": Flags.string({
+        summary: "the character set to use for the MySQL connection",
+        description: "The character set that should be used for the MySQL connection. If omitted, the database's default character set will be used (for newer databases, this should be utf8mb4 in most cases, but really might be anything).",
+    }),
 };
 export const mysqlConnectionFlagsWithTempUser = {
     ...mysqlConnectionFlags,

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

@@ -36,7 +36,7 @@ export function generateRandomPassword(length = 32) {
     const lowercase = "abcdefghijklmnopqrstuvwxyz";
     const uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     const digits = "0123456789";
-    const specialChars = "#!~%^*_+-=?{}()<>|.,;";
+    const specialChars = "_";
     const allChars = lowercase + uppercase + digits + specialChars;
     // Ensure the password includes at least one of each required character type
     const passwordArray = [

package/dist/lib/resources/login/useOwnAccount.d.ts

@@ -1,11 +1,24 @@
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 export default function useOwnAccount(client: MittwaldAPIV2Client): {
+    avatarRef?: string | undefined;
+    customerMemberships?: {
+        [k: string]: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.UserCustomerMembership;
+    } | undefined;
     email?: string | undefined;
-    mfaDetails?: {
-        mfaConfirmed?: boolean;
-        mfaInitialized?: boolean;
+    employeeInformation?: {
+        department: string;
+    } | undefined;
+    isEmployee?: boolean | undefined;
+    mfa?: {
+        active: boolean;
+        setup: boolean;
     } | undefined;
     passwordUpdatedAt?: string | undefined;
-    person?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CommonsPerson | undefined;
-    userId?: string | undefined;
+    person: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CommonsPerson;
+    phoneNumber?: string | undefined;
+    projectMemberships?: {
+        [k: string]: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.UserProjectMembership;
+    } | undefined;
+    registeredAt?: string | undefined;
+    userId: string;
 };

package/dist/lib/resources/login/useOwnAccount.js

@@ -1,7 +1,7 @@
 import { assertStatus } from "@mittwald/api-client";
 import { usePromise } from "@mittwald/react-use-promise";
 export default function useOwnAccount(client) {
-    const result = usePromise(() => client.user.getOwnAccount(), []);
+    const result = usePromise(() => client.user.getUser({ userId: "self" }), []);
     assertStatus(result, 200);
     return result.data;
 }

package/dist/lib/resources/ssh/appinstall.js

@@ -13,7 +13,7 @@ export async function getSSHConnectionForAppInstallation(client, appInstallation
     });
     assertStatus(projectResponse, 200);
     if (sshUser === undefined) {
-        const userResponse = await client.user.getOwnAccount();
+        const userResponse = await client.user.getUser({ userId: "self" });
         assertStatus(userResponse, 200);
         sshUser = userResponse.data.email;
     }

package/dist/lib/resources/ssh/project.js

@@ -3,7 +3,7 @@ export async function getSSHConnectionForProject(client, projectId, sshUser) {
     const projectResponse = await client.project.getProject({ projectId });
     assertStatus(projectResponse, 200);
     if (sshUser === undefined) {
-        const userResponse = await client.user.getOwnAccount();
+        const userResponse = await client.user.getUser({ userId: "self" });
         assertStatus(userResponse, 200);
         sshUser = userResponse.data.email;
     }

package/dist/lib/units/Duration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/units/Duration.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "@jest/globals";
+import Duration from "./Duration.js";
+describe("Duration class", () => {
+    describe("Static factory methods", () => {
+        test("fromZero should return a Duration of 0 milliseconds", () => {
+            const duration = Duration.fromZero();
+            expect(duration.milliseconds).toBe(0);
+        });
+        test("fromMilliseconds should return a Duration with the given milliseconds", () => {
+            const duration = Duration.fromMilliseconds(500);
+            expect(duration.milliseconds).toBe(500);
+        });
+        test("fromSeconds should return a Duration with the given seconds converted to milliseconds", () => {
+            const duration = Duration.fromSeconds(2);
+            expect(duration.milliseconds).toBe(2000);
+        });
+        test("fromString should parse valid duration strings", () => {
+            const duration = Duration.fromString("2s");
+            expect(duration.milliseconds).toBe(2000);
+        });
+        test("fromString should throw an error for invalid input", () => {
+            expect(() => Duration.fromString("invalid")).toThrow("could not parse duration: invalid");
+        });
+    });
+    describe("Instance methods", () => {
+        test("seconds should return duration in seconds", () => {
+            const duration = Duration.fromMilliseconds(3000);
+            expect(duration.seconds).toBe(3);
+        });
+        test("from should return a Date object offset by the duration", () => {
+            const baseDate = new Date("2023-01-01T00:00:00Z");
+            const duration = Duration.fromSeconds(10);
+            expect(duration.from(baseDate)).toEqual(new Date("2023-01-01T00:00:10Z"));
+        });
+        test("fromNow should return a future Date object", () => {
+            const duration = Duration.fromSeconds(5);
+            const now = new Date();
+            const future = duration.fromNow();
+            expect(future.getTime()).toBeGreaterThan(now.getTime());
+        });
+        test("add should correctly add two durations", () => {
+            const duration1 = Duration.fromSeconds(10);
+            const duration2 = Duration.fromSeconds(5);
+            const result = duration1.add(duration2);
+            expect(result.milliseconds).toBe(15000);
+        });
+        test("compare should return correct comparison results", () => {
+            const duration1 = Duration.fromSeconds(10);
+            const duration2 = Duration.fromSeconds(5);
+            expect(duration1.compare(duration2)).toBeGreaterThan(0);
+            expect(duration2.compare(duration1)).toBeLessThan(0);
+            expect(duration1.compare(duration1)).toBe(0);
+        });
+        test("toString should return formatted duration string", () => {
+            expect(Duration.fromMilliseconds(500).toString()).toBe("500ms");
+            expect(Duration.fromSeconds(3).toString()).toBe("3s");
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
   "author": {
@@ -59,7 +59,7 @@
     "marked": "^12.0.0",
     "marked-terminal": "^6.0.0",
     "open": "^10.0.3",
-    "parse-duration": "^1.1.0",
+    "parse-duration": "^2.0.1",
     "pretty-bytes": "^6.1.0",
     "react": "^18.2.0",
     "semver": "^7.5.4",