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

package/dist/commands/backup/schedule/update.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
+import { Args } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import { Success } from "../../../rendering/react/components/Success.js";
+import assertSuccess from "../../../lib/apiutil/assert_success.js";
+import { backupScheduleFlagDefinitions } from "../../../lib/resources/backup/schedule/flags.js";
+export default class Update extends ExecRenderBaseCommand {
+    static description = "Update an existing backup schedule";
+    static args = {
+        "backup-schedule-id": Args.string({
+            description: "Define the backup schedule that is to be updated",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...processFlags,
+        description: backupScheduleFlagDefinitions.description(),
+        schedule: backupScheduleFlagDefinitions.schedule(),
+        ttl: backupScheduleFlagDefinitions.ttl(),
+    };
+    async exec() {
+        const process = makeProcessRenderer(this.flags, "Updating backup schedule");
+        const projectBackupScheduleId = this.args["backup-schedule-id"];
+        const { description, schedule, ttl } = this.flags;
+        const backupScheduleUpdatePayload = {};
+        if (description) {
+            backupScheduleUpdatePayload.description = description;
+        }
+        if (schedule) {
+            backupScheduleUpdatePayload.schedule = schedule;
+        }
+        if (ttl) {
+            backupScheduleUpdatePayload.ttl = ttl;
+        }
+        if (Object.keys(backupScheduleUpdatePayload).length == 0) {
+            await process.complete(_jsx(Success, { children: "Nothing to change. Have a good day!" }));
+            return;
+        }
+        else {
+            await process.runStep("Updating backup schedule", async () => {
+                const response = await this.apiClient.backup.updateProjectBackupSchedule({
+                    projectBackupScheduleId,
+                    data: backupScheduleUpdatePayload,
+                });
+                assertSuccess(response);
+            });
+            await process.complete(_jsx(Success, { children: "Your backup schedule has successfully been updated." }));
+            return;
+        }
+    }
+    render() {
+        return true;
+    }
+}

package/dist/commands/context/get.d.ts

@@ -0,0 +1,10 @@
+import { RenderBaseCommand } from "../../lib/basecommands/RenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Get extends RenderBaseCommand<typeof Get> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/interfaces").Flag<any>;
+    };
+    protected render(): ReactNode;
+}

package/dist/commands/context/get.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RenderBaseCommand } from "../../lib/basecommands/RenderBaseCommand.js";
+import { SingleResult } from "../../rendering/react/components/SingleResult.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import { Note } from "../../rendering/react/components/Note.js";
+import { Box, Text } from "ink";
+import { Set } from "./set.js";
+import { RenderJson } from "../../rendering/react/json/RenderJson.js";
+import { useRenderContext } from "../../rendering/react/context.js";
+import { LocalFilename } from "../../rendering/react/components/LocalFilename.js";
+import Context from "../../lib/context/Context.js";
+const ContextSourceValue = ({ source }) => {
+    switch (source.type) {
+        case "user":
+            return (_jsx(ContextSourceKnownValue, { name: "user configuration", source: source }));
+        case "terraform":
+            return (_jsx(ContextSourceKnownValue, { name: "terraform state file", source: source, relative: true }));
+        case "ddev":
+            return (_jsx(ContextSourceKnownValue, { name: "DDEV configuration", source: source, relative: true }));
+        default:
+            return _jsx(ContextSourceUnknown, {});
+    }
+};
+const ContextSourceKnownValue = ({ name, source, relative }) => {
+    return (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: name }), ", in", " ", _jsx(LocalFilename, { filename: source.identifier, relative: relative })] }));
+};
+const ContextSourceUnknown = () => {
+    return _jsx(Text, { color: "yellow", children: "unknown" });
+};
+const ContextSource = ({ source }) => {
+    return (_jsxs(Text, { color: "gray", children: ["(source: ", _jsx(ContextSourceValue, { source: source }), ")"] }));
+};
+const GetContext = ({ ctx }) => {
+    const rows = {};
+    const { renderAsJson } = useRenderContext();
+    const values = {};
+    let hasTerraformSource = false;
+    let hasDDEVSource = false;
+    for (const key of [
+        "project-id",
+        "server-id",
+        "org-id",
+        "installation-id",
+    ]) {
+        const value = usePromise(ctx.getContextValue.bind(ctx), [key]);
+        if (value) {
+            rows[`--${key}`] = (_jsxs(Text, { children: [_jsx(Value, { children: value.value }), " ", _jsx(ContextSource, { source: value.source })] }));
+            values[key] = value;
+            hasTerraformSource =
+                hasTerraformSource || value.source.type === "terraform";
+            hasDDEVSource = hasDDEVSource || value.source.type === "ddev";
+        }
+        else {
+            rows[`--${key}`] = _jsx(Value, { notSet: true });
+        }
+    }
+    if (renderAsJson) {
+        return _jsx(RenderJson, { name: "context", data: values });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(SingleResult, { title: "Current CLI context", rows: rows }) }), hasTerraformSource && _jsx(TerraformHint, {}), hasDDEVSource && _jsx(DDEVHint, {}), _jsx(ContextSetHint, {})] }));
+};
+const TerraformHint = () => (_jsx(Note, { marginBottom: 1, children: "You are in a directory that contains a terraform state file; some of the context values were read from there." }));
+const DDEVHint = () => (_jsx(Note, { marginBottom: 1, children: "You are in a directory that contains a DDEV project; some of the context values were read from there." }));
+const ContextSetHint = () => (_jsxs(Note, { marginBottom: 1, children: ["Use the ", _jsx(Value, { children: "mw context set" }), " command to set one of the values listed above."] }));
+export class Get extends RenderBaseCommand {
+    static summary = "Print an overview of currently set context parameters";
+    static description = Set.description;
+    static flags = { ...RenderBaseCommand.buildFlags() };
+    render() {
+        const ctx = new Context(this.apiClient, this.config);
+        return _jsx(GetContext, { ctx: ctx });
+    }
+}

package/dist/commands/context/reset.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+export declare class Reset extends BaseCommand {
+    static summary: string;
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/context/reset.js

@@ -0,0 +1,9 @@
+import Context from "../../lib/context/Context.js";
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+export class Reset extends BaseCommand {
+    static summary = "Reset context values";
+    static description = "This command resets any values for common parameters that you've previously set with 'context set'.";
+    async run() {
+        await new Context(this.apiClient, this.config).reset();
+    }
+}

package/dist/commands/context/set.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+export declare class Set extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "server-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "org-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "installation-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/context/set.js

@@ -0,0 +1,42 @@
+import { Flags } from "@oclif/core";
+import Context from "../../lib/context/Context.js";
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+export class Set extends BaseCommand {
+    static summary = "Set context values for the current project, org or server";
+    static description = "The context allows you to persistently set values for common parameters, like --project-id or --server-id, so you don't have to specify them on every command.";
+    static flags = {
+        "project-id": Flags.string({
+            description: "ID or short ID of a project",
+        }),
+        "server-id": Flags.string({
+            description: "ID or short ID of a server",
+        }),
+        "org-id": Flags.string({
+            description: "ID or short ID of an organization",
+        }),
+        "installation-id": Flags.string({
+            description: "ID or short ID of an app installation",
+            aliases: ["app-id", "app-installation-id"],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Set);
+        const ctx = new Context(this.apiClient, this.config);
+        if (flags["project-id"]) {
+            const projectId = await ctx.setProjectId(flags["project-id"]);
+            this.log(`Set project ID to ${projectId}`);
+        }
+        if (flags["server-id"]) {
+            const serverId = await ctx.setServerId(flags["server-id"]);
+            this.log(`Set server ID to ${serverId}`);
+        }
+        if (flags["org-id"]) {
+            const orgId = await ctx.setOrgId(flags["org-id"]);
+            this.log(`Set organization ID to ${orgId}`);
+        }
+        if (flags["installation-id"]) {
+            const installationId = await ctx.setAppInstallationId(flags["installation-id"]);
+            this.log(`Set installation ID to ${installationId}`);
+        }
+    }
+}

package/dist/commands/conversation/categories.d.ts

@@ -0,0 +1,21 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListColumns } from "../../rendering/formatter/ListFormatter.js";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ConversationCategories.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["conversation"]["listCategories"]>>;
+export default class Categories extends ListBaseCommand<typeof Categories, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        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<Response>;
+    protected getColumns(): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/conversation/categories.js

@@ -0,0 +1,21 @@
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+export default class Categories extends ListBaseCommand {
+    static description = "Get all conversation categories.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    getData() {
+        return this.apiClient.conversation.listCategories();
+    }
+    getColumns() {
+        return {
+            id: {
+                header: "ID",
+                minWidth: 36,
+                extended: true,
+            },
+            name: {},
+        };
+    }
+}

package/dist/commands/conversation/close.d.ts

@@ -0,0 +1,8 @@
+import { ExtendedBaseCommand } from "../../lib/basecommands/ExtendedBaseCommand.js";
+export default class Close extends ExtendedBaseCommand<typeof Close> {
+    static description: string;
+    static args: {
+        "conversation-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/conversation/close.js

@@ -0,0 +1,20 @@
+import { ux } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { conversationArgs, withConversationId, } from "../../lib/resources/conversation/flags.js";
+import { ExtendedBaseCommand } from "../../lib/basecommands/ExtendedBaseCommand.js";
+export default class Close extends ExtendedBaseCommand {
+    static description = "Close a conversation";
+    static args = {
+        ...conversationArgs,
+    };
+    async run() {
+        const conversationId = await withConversationId(this.apiClient, Close, this.flags, this.args, this.config);
+        ux.action.start(`closing conversation ${conversationId}`);
+        const response = await this.apiClient.conversation.setConversationStatus({
+            conversationId,
+            data: { status: "closed" },
+        });
+        assertStatus(response, 200);
+        ux.action.stop();
+    }
+}

package/dist/commands/conversation/create.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+export default class Create extends BaseCommand {
+    static description: string;
+    static flags: {
+        title: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        category: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "message-from": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        editor: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private getCategoryId;
+    run(): Promise<void>;
+}

package/dist/commands/conversation/create.js

@@ -0,0 +1,50 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+import { Flags, ux } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { messageFlags, retrieveMessage, } from "../../lib/resources/conversation/message_input.js";
+export default class Create extends BaseCommand {
+    static description = "Create a new conversation";
+    static flags = {
+        ...BaseCommand.baseFlags,
+        ...messageFlags,
+        title: Flags.string({
+            description: "Title of the conversation",
+            required: true,
+        }),
+        category: Flags.string({
+            description: "Category of the conversation; use the 'conversation categories' command to list available categories",
+            default: "general",
+        }),
+    };
+    async getCategoryId(name) {
+        const categoryResponse = await this.apiClient.conversation.listCategories();
+        assertStatus(categoryResponse, 200);
+        const category = categoryResponse.data.find((c) => c.name === name);
+        if (!category) {
+            throw new Error(`category ${name} not found`);
+        }
+        return category.categoryId;
+    }
+    async run() {
+        const { flags } = await this.parse(Create);
+        const messageContent = await retrieveMessage(flags);
+        const categoryId = await this.getCategoryId(flags.category);
+        ux.action.start("creating conversation");
+        const conversationResponse = await this.apiClient.conversation.createConversation({
+            data: {
+                title: flags.title,
+                categoryId,
+            },
+        });
+        assertStatus(conversationResponse, 201);
+        ux.action.stop();
+        const conversationId = conversationResponse.data.conversationId;
+        ux.action.start(`saving message for ${conversationId}`);
+        const response = await this.apiClient.conversation.createMessage({
+            conversationId,
+            data: { messageContent },
+        });
+        assertStatus(response, 201);
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListColumns } from "../../rendering/formatter/ListFormatter.js";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2Conversations.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["conversation"]["listConversations"]>>;
+export default class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        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<Response>;
+    protected getColumns(): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/conversation/list.js

@@ -0,0 +1,33 @@
+import { formatRelativeDate } from "../../rendering/textformat/formatDate.js";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+export default class List extends ListBaseCommand {
+    static description = "Get all conversations the authenticated user has created or has access to.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        return await this.apiClient.conversation.listConversations();
+    }
+    getColumns() {
+        return {
+            conversationId: {
+                header: "UUID",
+                minWidth: 36,
+                extended: true,
+            },
+            shortId: {
+                header: "ID",
+                minWidth: 8,
+            },
+            status: {},
+            title: {},
+            created: {
+                header: "Created",
+                get: (row) => formatRelativeDate(new Date(`${row.createdAt}`)) +
+                    " by " +
+                    (row.createdBy ? row.createdBy.clearName : "unknown"),
+            },
+        };
+    }
+}

package/dist/commands/conversation/reply.d.ts

@@ -0,0 +1,13 @@
+import { ExtendedBaseCommand } from "../../lib/basecommands/ExtendedBaseCommand.js";
+export default class Reply extends ExtendedBaseCommand<typeof Reply> {
+    static description: string;
+    static args: {
+        "conversation-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        message: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "message-from": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        editor: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/conversation/reply.js

@@ -0,0 +1,25 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { messageFlags, retrieveMessage, } from "../../lib/resources/conversation/message_input.js";
+import { conversationArgs, withConversationId, } from "../../lib/resources/conversation/flags.js";
+import { ExtendedBaseCommand } from "../../lib/basecommands/ExtendedBaseCommand.js";
+import { ux } from "@oclif/core";
+export default class Reply extends ExtendedBaseCommand {
+    static description = "Reply to a conversation";
+    static args = { ...conversationArgs };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        ...messageFlags,
+    };
+    async run() {
+        const conversationId = await withConversationId(this.apiClient, Reply, this.flags, this.args, this.config);
+        const messageContent = await retrieveMessage(this.flags);
+        ux.action.start(`replying to ${conversationId}`);
+        const response = await this.apiClient.conversation.createMessage({
+            conversationId,
+            data: { messageContent },
+        });
+        assertStatus(response, 201);
+        ux.action.stop();
+    }
+}

package/dist/commands/conversation/show.d.ts

@@ -0,0 +1,9 @@
+import { ExtendedBaseCommand } from "../../lib/basecommands/ExtendedBaseCommand.js";
+export default class Show extends ExtendedBaseCommand<typeof Show> {
+    static description: string;
+    static args: {
+        "conversation-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    run(): Promise<void>;
+    private loadConversationWithMessages;
+}

package/dist/commands/conversation/show.js

@@ -0,0 +1,97 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { formatRelativeDate } from "../../rendering/textformat/formatDate.js";
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+import chalk from "chalk";
+import { conversationArgs, withConversationId, } from "../../lib/resources/conversation/flags.js";
+import { ExtendedBaseCommand } from "../../lib/basecommands/ExtendedBaseCommand.js";
+import { printHeader } from "../../rendering/formatter/printHeader.js";
+import { printKeyValues } from "../../rendering/formatter/printKeyValues.js";
+function printStatusChange(text, date) {
+    console.log(chalk.gray(`${text}, ${formatRelativeDate(date)}`));
+}
+function printMessageAuthor(msg) {
+    console.log(chalk.whiteBright.underline(`${msg.createdBy?.clearName}, ${formatRelativeDate(msg.createdAt)}`));
+}
+async function printMessageContent(msg) {
+    const rendered = (await marked(msg.messageContent ?? "")).trim();
+    console.log(rendered);
+    console.log();
+}
+function isMessage(msg) {
+    return msg.type === "MESSAGE";
+}
+function isStatusUpdate(msg) {
+    return msg.type === "STATUS_UPDATE";
+}
+function printStatusUpdate(responseItem) {
+    switch (responseItem.messageContent) {
+        case "CONVERSATION_CREATED":
+            printStatusChange("CREATED", responseItem.createdAt);
+            break;
+        case "STATUS_OPEN":
+            printStatusChange("REOPENED", responseItem.createdAt);
+            break;
+        case "STATUS_CLOSED":
+            printStatusChange("CLOSED", responseItem.createdAt);
+            break;
+        default:
+            printStatusChange(responseItem.messageContent, responseItem.createdAt);
+            break;
+    }
+    console.log();
+}
+async function printResponseItem(responseItem) {
+    if (isMessage(responseItem)) {
+        printMessageAuthor(responseItem);
+        await printMessageContent(responseItem);
+    }
+    if (isStatusUpdate(responseItem)) {
+        printStatusUpdate(responseItem);
+    }
+}
+function getConversationMetadata(conversation) {
+    return {
+        Title: conversation.title,
+        ID: conversation.shortId,
+        Opened: `${formatRelativeDate(conversation.createdAt)} by ${conversation.createdBy ? conversation.createdBy.clearName : "Unknown User"}`,
+        Status: conversation.status,
+    };
+}
+function printConversationMetadata(conversation) {
+    printHeader("Conversation metadata");
+    printKeyValues(getConversationMetadata(conversation));
+    console.log();
+}
+async function printConversationMessages(responseItems) {
+    printHeader("Messages");
+    marked.setOptions({
+        renderer: new TerminalRenderer(),
+    });
+    for (const responseItem of responseItems) {
+        await printResponseItem(responseItem);
+    }
+}
+export default class Show extends ExtendedBaseCommand {
+    static description = "Show a conversation and message history";
+    static args = { ...conversationArgs };
+    async run() {
+        const conversationId = await withConversationId(this.apiClient, Show, this.flags, this.args, this.config);
+        const [conversation, responseItems] = await this.loadConversationWithMessages(conversationId);
+        printConversationMetadata(conversation);
+        await printConversationMessages(responseItems);
+    }
+    async loadConversationWithMessages(conversationId) {
+        const [conversationResponse, messagesResponse] = await Promise.all([
+            this.apiClient.conversation.getConversation({
+                conversationId,
+            }),
+            this.apiClient.conversation.listMessagesByConversation({
+                conversationId,
+            }),
+        ]);
+        assertStatus(conversationResponse, 200);
+        assertStatus(messagesResponse, 200);
+        return [conversationResponse.data, messagesResponse.data];
+    }
+}