convex 1.36.0 → 1.37.0

package/src/cli/envDefault.ts

@@ -1,4 +1,4 @@
-import { Command } from "@commander-js/extra-typings";
+import { Command, Option } from "@commander-js/extra-typings";
 import {
   envGet,
   envList,
@@ -14,120 +14,134 @@ import {
   DeploymentType,
   fetchTeamAndProject,
 } from "./lib/api.js";
-import { Context } from "../bundler/context.js";
+import { Context, oneoffContext } from "../bundler/context.js";
 import { selectEnvDeployment } from "./env.js";
+import { getProjectDetails } from "./lib/deploymentSelection.js";
 
-const envDefaultSet = new Command("set")
-  .usage("[options] <name> <value>")
-  .arguments("[name] [value]")
-  .summary("Set a default variable")
-  .description(
-    "Set default environment variables for your project's deployment type.\n\n" +
-      "  npx convex env default set NAME 'value'\n" +
-      "  npx convex env default set NAME # omit a value to set one interactively\n" +
-      "  npx convex env default set NAME --from-file value.txt\n" +
-      "  npx convex env default set --from-file .env.defaults\n" +
-      "When setting multiple values, it will refuse all changes if any " +
-      "variables are already set to different values by default. " +
-      "Pass --force to overwrite the provided values.\n" +
-      "The deployment type is determined by the current deployment (local maps to dev).\n",
-  )
-  .option(
-    "--from-file <file>",
-    "Read environment variables from a .env file. Without --force, fails if any existing variable has a different value.",
-  )
-  .option(
-    "--force",
-    "When setting multiple variables, overwrite existing environment variable values instead of failing on mismatch.",
-  )
-  .configureHelp({ showGlobalOptions: true })
-  .allowExcessArguments(false)
-  .action(async (name, value, cmdOptions, cmd) => {
-    const options = cmd.optsWithGlobals() as DeploymentSelectionOptions;
-    const { ctx, deployment } = await selectEnvDeployment(options);
-    await ensureHasConvexDependency(ctx, "env default set");
-    const backend = await resolveDefaultEnvBackend(
-      ctx,
-      deployment.deploymentFields,
-    );
-    const didAnything = await envSet(ctx, backend, name, value, cmdOptions);
-    if (didAnything === false) {
-      cmd.outputHelp({ error: true });
-      return await ctx.crash({
-        exitCode: 1,
-        errorType: "fatal",
-        printedMessage: "error: No environment variables specified to be set.",
-      });
-    }
-  });
+type EnvDefaultExtraOptions = {
+  type?: string;
+  project?: string;
+};
 
-const envDefaultGet = new Command("get")
-  .arguments("<name>")
-  .summary("Print a default variable's value")
-  .description(
-    "Print a default variable's value: `npx convex env default get NAME`\n" +
-      "The deployment type is determined by the current deployment (local maps to dev).",
-  )
-  .configureHelp({ showGlobalOptions: true })
-  .allowExcessArguments(false)
-  .action(async (envVarName, _options, cmd) => {
-    const options = cmd.optsWithGlobals() as DeploymentSelectionOptions;
-    const { ctx, deployment } = await selectEnvDeployment(options);
-    await ensureHasConvexDependency(ctx, "env default get");
-    const backend = await resolveDefaultEnvBackend(
-      ctx,
-      deployment.deploymentFields,
-    );
-    await envGet(ctx, backend, envVarName);
-  });
-
-const envDefaultRemove = new Command("remove")
-  .alias("rm")
-  .alias("unset")
-  .arguments("<name>")
-  .summary("Unset a default variable")
-  .description(
-    "Unset a default variable: `npx convex env default remove NAME`\n" +
-      "If the variable doesn't exist, the command doesn't do anything and succeeds.\n" +
-      "The deployment type is determined by the current deployment (local maps to dev).",
-  )
-  .configureHelp({ showGlobalOptions: true })
-  .allowExcessArguments(false)
-  .action(async (name, _options, cmd) => {
-    const options = cmd.optsWithGlobals() as DeploymentSelectionOptions;
-    const { ctx, deployment } = await selectEnvDeployment(options);
-    await ensureHasConvexDependency(ctx, "env default remove");
-    const backend = await resolveDefaultEnvBackend(
-      ctx,
-      deployment.deploymentFields,
-    );
-    await envRemove(ctx, backend, name);
-  });
+function addEnvDefaultOptions<T extends Command<any, any>>(cmd: T): T {
+  return cmd
+    .addOption(
+      new Option(
+        "--type <type>",
+        "Manage default env vars for the given deployment type (dev, preview, prod) instead of inferring from the current deployment.",
+      ),
+    )
+    .addOption(
+      new Option(
+        "--project <project>",
+        "Select a project manually. Accepts `team-slug:project-slug` or just `project-slug` (team inferred from your current project). Requires --type.",
+      ),
+    ) as T;
+}
 
-const envDefaultList = new Command("list")
-  .summary("List all default variables")
-  .description(
-    "List all default variables: `npx convex env default list`\n" +
-      "The deployment type is determined by the current deployment (local maps to dev).",
-  )
-  .configureHelp({ showGlobalOptions: true })
-  .allowExcessArguments(false)
-  .action(async (_options, cmd) => {
-    const options = cmd.optsWithGlobals() as DeploymentSelectionOptions;
-    const { ctx, deployment } = await selectEnvDeployment(options);
-    await ensureHasConvexDependency(ctx, "env default list");
-    const backend = await resolveDefaultEnvBackend(
-      ctx,
-      deployment.deploymentFields,
-    );
-    await envList(ctx, backend);
-  });
+const envDefaultSet = addEnvDefaultOptions(
+  new Command("set")
+    .usage("[options] <name> <value>")
+    .arguments("[name] [value]")
+    .summary("Set a default variable")
+    .description(
+      "Set default environment variables for your project's deployment type.\n\n" +
+        "  npx convex env default set NAME 'value'\n" +
+        "  npx convex env default set NAME # omit a value to set one interactively\n" +
+        "  npx convex env default set NAME --from-file value.txt\n" +
+        "  npx convex env default set --from-file .env.defaults\n" +
+        "When setting multiple values, it will refuse all changes if any " +
+        "variables are already set to different values by default. " +
+        "Pass --force to overwrite the provided values.\n" +
+        "The deployment type is determined by the current deployment (local maps to dev), or by --type if provided.\n",
+    )
+    .option(
+      "--from-file <file>",
+      "Read environment variables from a .env file. Without --force, fails if any existing variable has a different value.",
+    )
+    .option(
+      "--force",
+      "When setting multiple variables, overwrite existing environment variable values instead of failing on mismatch.",
+    )
+    .configureHelp({ showGlobalOptions: true })
+    .allowExcessArguments(false),
+).action(async (name, value, cmdOptions, cmd) => {
+  const options = cmd.optsWithGlobals() as DeploymentSelectionOptions &
+    EnvDefaultExtraOptions;
+  const { ctx, backend } = await resolveEnvDefaultBackend(options);
+  await ensureHasConvexDependency(ctx, "env default set");
+  const didAnything = await envSet(ctx, backend, name, value, cmdOptions);
+  if (didAnything === false) {
+    cmd.outputHelp({ error: true });
+    return await ctx.crash({
+      exitCode: 1,
+      errorType: "fatal",
+      printedMessage: "error: No environment variables specified to be set.",
+    });
+  }
+});
+
+const envDefaultGet = addEnvDefaultOptions(
+  new Command("get")
+    .arguments("<name>")
+    .summary("Print a default variable's value")
+    .description(
+      "Print a default variable's value: `npx convex env default get NAME`\n" +
+        "The deployment type is determined by the current deployment (local maps to dev), or by --type if provided.",
+    )
+    .configureHelp({ showGlobalOptions: true })
+    .allowExcessArguments(false),
+).action(async (envVarName, _options, cmd) => {
+  const options = cmd.optsWithGlobals() as DeploymentSelectionOptions &
+    EnvDefaultExtraOptions;
+  const { ctx, backend } = await resolveEnvDefaultBackend(options);
+  await ensureHasConvexDependency(ctx, "env default get");
+  await envGet(ctx, backend, envVarName);
+});
+
+const envDefaultRemove = addEnvDefaultOptions(
+  new Command("remove")
+    .alias("rm")
+    .alias("unset")
+    .arguments("<name>")
+    .summary("Unset a default variable")
+    .description(
+      "Unset a default variable: `npx convex env default remove NAME`\n" +
+        "If the variable doesn't exist, the command doesn't do anything and succeeds.\n" +
+        "The deployment type is determined by the current deployment (local maps to dev), or by --type if provided.",
+    )
+    .configureHelp({ showGlobalOptions: true })
+    .allowExcessArguments(false),
+).action(async (name, _options, cmd) => {
+  const options = cmd.optsWithGlobals() as DeploymentSelectionOptions &
+    EnvDefaultExtraOptions;
+  const { ctx, backend } = await resolveEnvDefaultBackend(options);
+  await ensureHasConvexDependency(ctx, "env default remove");
+  await envRemove(ctx, backend, name);
+});
+
+const envDefaultList = addEnvDefaultOptions(
+  new Command("list")
+    .summary("List all default variables")
+    .description(
+      "List all default variables: `npx convex env default list`\n" +
+        "The deployment type is determined by the current deployment (local maps to dev), or by --type if provided.",
+    )
+    .configureHelp({ showGlobalOptions: true })
+    .allowExcessArguments(false),
+).action(async (_options, cmd) => {
+  const options = cmd.optsWithGlobals() as DeploymentSelectionOptions &
+    EnvDefaultExtraOptions;
+  const { ctx, backend } = await resolveEnvDefaultBackend(options);
+  await ensureHasConvexDependency(ctx, "env default list");
+  await envList(ctx, backend);
+});
 
 export const envDefault = new Command("default")
   .summary("Manage project-level default environment variables")
   .description(
     "Manage default environment variables for your project.\n\n" +
-      "The default environment variables read and written to by this command are the ones for the deployment type of the current deployment (i.e. dev in most cases).\n\n" +
+      "The default environment variables read and written to by this command are the ones for the deployment type of the current deployment (i.e. dev in most cases), unless --type is provided.\n\n" +
       "  Set a default variable: `npx convex env default set NAME 'value'`\n" +
       "  Unset a default variable: `npx convex env default remove NAME`\n" +
       "  List all default variables: `npx convex env default list`\n" +
@@ -139,12 +153,112 @@ export const envDefault = new Command("default")
   .addCommand(envDefaultList)
   .helpCommand(false);
 
+type ParsedProjectOption =
+  | { kind: "teamAndProject"; teamSlug: string; projectSlug: string }
+  | { kind: "projectOnly"; projectSlug: string };
+
+async function resolveEnvDefaultBackend(
+  options: DeploymentSelectionOptions & EnvDefaultExtraOptions,
+): Promise<{ ctx: Context; backend: EnvVarBackend }> {
+  const dtypeOverride = normalizeTypeOption(options.type);
+
+  if (options.project !== undefined) {
+    const parsedProject = parseProjectOption(options.project);
+    if (parsedProject === null) {
+      const ctx = await oneoffContext(options);
+      return await ctx.crash({
+        exitCode: 1,
+        errorType: "fatal",
+        printedMessage:
+          "error: --project must be `team-slug:project-slug` or `project-slug`.",
+      });
+    }
+    if (dtypeOverride === undefined) {
+      const ctx = await oneoffContext(options);
+      return await ctx.crash({
+        exitCode: 1,
+        errorType: "fatal",
+        printedMessage: "error: --project requires --type to also be set.",
+      });
+    }
+
+    let ctx: Context;
+    let resolved: { teamSlug: string; projectSlug: string };
+    if (parsedProject.kind === "teamAndProject") {
+      ctx = await oneoffContext(options);
+      resolved = {
+        teamSlug: parsedProject.teamSlug,
+        projectSlug: parsedProject.projectSlug,
+      };
+    } else {
+      const selected = await selectEnvDeployment(options);
+      ctx = selected.ctx;
+      if (selected.deployment.deploymentFields === null) {
+        return await ctx.crash({
+          exitCode: 1,
+          errorType: "fatal",
+          printedMessage:
+            "error: --project <project-slug> requires a current cloud deployment to infer the team from. Use `team-slug:project-slug` to specify the team explicitly.",
+        });
+      }
+      const { team } = await fetchTeamAndProject(
+        ctx,
+        selected.deployment.deploymentFields.deploymentName,
+      );
+      resolved = { teamSlug: team, projectSlug: parsedProject.projectSlug };
+    }
+
+    const details = await getProjectDetails(ctx, {
+      kind: "teamAndProjectSlugs",
+      teamSlug: resolved.teamSlug,
+      projectSlug: resolved.projectSlug,
+    });
+    return {
+      ctx,
+      backend: defaultEnvBackend(ctx, details.id, dtypeOverride),
+    };
+  }
+
+  const { ctx, deployment } = await selectEnvDeployment(options);
+  const backend = await resolveDefaultEnvBackend(
+    ctx,
+    deployment.deploymentFields,
+    dtypeOverride,
+  );
+  return { ctx, backend };
+}
+
+function normalizeTypeOption(
+  type: string | undefined,
+): CloudDeploymentType | undefined {
+  if (type === undefined) return undefined;
+  if (type === "development") return "dev";
+  if (type === "production") return "prod";
+  return type as CloudDeploymentType;
+}
+
+function parseProjectOption(value: string): ParsedProjectOption | null {
+  const parts = value.split(":");
+  if (parts.length === 1 && parts[0].length > 0) {
+    return { kind: "projectOnly", projectSlug: parts[0] };
+  }
+  if (parts.length === 2 && parts[0].length > 0 && parts[1].length > 0) {
+    return {
+      kind: "teamAndProject",
+      teamSlug: parts[0],
+      projectSlug: parts[1],
+    };
+  }
+  return null;
+}
+
 export async function resolveDefaultEnvBackend(
   ctx: Context,
   deploymentFields: {
     deploymentName: string;
     deploymentType: DeploymentType;
   } | null,
+  dtypeOverride?: CloudDeploymentType,
 ): Promise<EnvVarBackend> {
   if (deploymentFields === null) {
     return await ctx.crash({
@@ -162,7 +276,8 @@ export async function resolveDefaultEnvBackend(
         "Default environment variables are not available for anonymous deployments.",
     });
   }
-  const dtype = resolveDefaultEnvDtype(deploymentFields.deploymentType);
+  const dtype =
+    dtypeOverride ?? resolveDefaultEnvDtype(deploymentFields.deploymentType);
   const { projectId } = await fetchTeamAndProject(
     ctx,
     deploymentFields.deploymentName,

package/src/cli/generatedApi.ts

@@ -486,7 +486,7 @@ export interface components {
             name: string;
         };
         /** @enum {string} */
-        WorkOSProductionState: "active" | "inactive";
+        WorkOSProductionState: "active" | "inactive" | "suspended" | "deleting";
         WorkOSTeamHealthResponse: {
             teamInfo?: null | components["schemas"]["WorkOSTeamInfo"];
             /** @description Whether a WorkOS team has been provisioned for this Convex team */

package/src/cli/lib/command.ts

@@ -216,7 +216,7 @@ Command.prototype.addDeploymentSelectionOptions = function (
         "--deployment <deployment>",
         action +
           " a specific deployment. Accepts:\n" +
-          "• a deployment name (e.g. joyful-capybara-123)" +
+          "• a deployment name (e.g. joyful-capybara-123)\n" +
           "• a deployment reference (e.g. dev/james, staging)\n" +
           "• `dev` (for your personal dev deployment)\n" +
           "• `prod` (for your project’s default production deployment)\n" +

package/src/cli/lib/generatedFunctionLogsApi.ts

@@ -35,6 +35,7 @@ export interface components {
             usageStats: components["schemas"]["UsageStatsJson"];
             /** Format: double */
             userExecutionTime?: number | null;
+            willRetry: boolean;
         } | {
             componentPath?: string | null;
             executionId: string;

package/src/cli/lib/login.ts

@@ -1,6 +1,7 @@
 import { errors, BaseClient, custom } from "openid-client";
 import {
   bigBrainAPI,
+  bigBrainFetch,
   logAndHandleFetchError,
   throwingFetch,
   isWebContainer,
@@ -427,6 +428,72 @@ export async function performLogin(
       printedMessage: null,
     });
   }
+
+  if (vercel) {
+    await promptJoinVercelTeams(ctx);
+  }
+}
+
+type PotentialVercelTeam = {
+  teamId: number;
+  teamName: string;
+  teamSlug: string;
+  planId: string;
+  planName: string;
+  pricingNotice: string | null;
+};
+
+// After `--vercel` login, surface any Vercel-marketplace teams the user has
+// access to but isn't yet a member of, and prompt to join each.
+async function promptJoinVercelTeams(ctx: Context): Promise<void> {
+  const fetch = bigBrainFetch(ctx);
+  let teams: PotentialVercelTeam[];
+  try {
+    const res = await fetch(
+      new URL("vercel/potential_teams", `${provisionHost}/`),
+    );
+    if (!res.ok) {
+      logVerbose(
+        `vercel/potential_teams returned ${res.status}; skipping team-join prompt`,
+      );
+      return;
+    }
+    teams = await res.json();
+  } catch (err) {
+    logVerbose(`Failed to fetch potential Vercel teams: ${String(err)}`);
+    return;
+  }
+  if (teams.length === 0) return;
+
+  for (const [index, team] of teams.entries()) {
+    const displayName = team.teamName.replace(/ \(Vercel\)$/, "");
+    const counter = teams.length > 1 ? `[${index + 1}/${teams.length}] ` : "";
+    const lines = [
+      chalkStderr.bold(`${counter}You've been invited to join ${displayName}`) +
+        ` (${team.planName}) through the Vercel marketplace.`,
+    ];
+    if (team.pricingNotice) {
+      lines.push(chalkStderr.yellow(team.pricingNotice));
+    }
+    lines.push(`Join "${displayName}"?`);
+    const join = await promptYesNo(ctx, {
+      message: `${lines.join("\n")}`,
+      default: true,
+    });
+    if (!join) continue;
+    try {
+      await fetch(
+        new URL(
+          `vercel/potential_teams/${team.teamId}/join`,
+          `${provisionHost}/`,
+        ),
+        { method: "POST" },
+      );
+      logFinishedStep(`Joined ${displayName}`);
+    } catch (err) {
+      logFailure(`Failed to join ${displayName}: ${String(err)}`);
+    }
+  }
 }
 
 /// There are fields like version, but we keep them opaque

package/src/cli/lib/usage.ts

@@ -1,10 +1,10 @@
 import { chalkStderr } from "chalk";
 import { Context } from "../../bundler/context.js";
-import { logWarning } from "../../bundler/log.js";
+import { logVerbose, logWarning } from "../../bundler/log.js";
 import { teamDashboardUrl } from "./dashboard.js";
 import { fetchTeamAndProject } from "./api.js";
 import { isAnonymousDeployment } from "./deployment.js";
-import { bigBrainAPI } from "./utils/utils.js";
+import { bigBrainAPIMaybeThrows } from "./utils/utils.js";
 
 async function warn(
   ctx: Context,
@@ -19,7 +19,7 @@ async function warn(
 }
 
 async function teamUsageState(ctx: Context, teamId: number) {
-  const { usageState } = (await bigBrainAPI({
+  const { usageState } = (await bigBrainAPIMaybeThrows({
     ctx,
     method: "GET",
     path: "dashboard/teams/" + teamId + "/usage/team_usage_state",
@@ -31,7 +31,7 @@ async function teamUsageState(ctx: Context, teamId: number) {
 }
 
 async function teamSpendingLimitsState(ctx: Context, teamId: number) {
-  const response = (await bigBrainAPI({
+  const response = (await bigBrainAPIMaybeThrows({
     ctx,
     method: "GET",
     path: "dashboard/teams/" + teamId + "/get_spending_limits",
@@ -59,12 +59,22 @@ export async function usageStateWarning(
   ) {
     return;
   }
+
   const { teamId, team } = await fetchTeamAndProject(ctx, targetDeployment);
 
-  const [usageState, spendingLimitsState] = await Promise.all([
-    teamUsageState(ctx, teamId),
-    teamSpendingLimitsState(ctx, teamId),
-  ]);
+  let usageState: Awaited<ReturnType<typeof teamUsageState>>;
+  let spendingLimitsState: Awaited<ReturnType<typeof teamSpendingLimitsState>>;
+  try {
+    [usageState, spendingLimitsState] = await Promise.all([
+      teamUsageState(ctx, teamId),
+      teamSpendingLimitsState(ctx, teamId),
+    ]);
+  } catch (err) {
+    // Non-fatal: usage warnings are advisory, so don't block `convex dev`
+    // if these endpoints error.
+    logVerbose("Skipping usage state warning:", err);
+    return;
+  }
   if (spendingLimitsState === "Disabled") {
     await warn(ctx, {
       title:

package/src/cli/lib/workos/environmentApi.test.ts

@@ -0,0 +1,107 @@
+import { test, expect, describe, beforeEach, vi } from "vitest";
+import { Context } from "../../../bundler/context.js";
+import { createCORSOrigin, createRedirectURI } from "./environmentApi.js";
+
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+const ctx: Context = {
+  crash: vi.fn(async (args: { printedMessage: string | null }) => {
+    throw new Error(args.printedMessage ?? "crash");
+  }),
+} as unknown as Context;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("createRedirectURI", () => {
+  test("returns modified: true on a successful response", async () => {
+    mockFetch.mockResolvedValue(new Response(null, { status: 201 }));
+    await expect(
+      createRedirectURI(ctx, "key", "http://localhost:5173"),
+    ).resolves.toEqual({ modified: true });
+  });
+
+  test("returns modified: false when the URI already exists", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(
+        `{"message":"Redirect URI 'http://localhost:5173' already exists.","error":"Unprocessable Entity"}`,
+        { status: 422 },
+      ),
+    );
+    await expect(
+      createRedirectURI(ctx, "key", "http://localhost:5173"),
+    ).resolves.toEqual({ modified: false });
+    expect(ctx.crash).not.toHaveBeenCalled();
+  });
+
+  test("crashes with the body for a non-duplicate 422", async () => {
+    const body = `{"message":"Redirect URI 'test' is invalid.","error":"Unprocessable Entity"}`;
+    mockFetch.mockResolvedValue(new Response(body, { status: 422 }));
+    await expect(createRedirectURI(ctx, "key", "test")).rejects.toThrow(
+      `Failed to create redirect URI: 422 ${body}`,
+    );
+    expect(ctx.crash).toHaveBeenCalledWith(
+      expect.objectContaining({
+        exitCode: 1,
+        errorType: "fatal",
+        printedMessage: `Failed to create redirect URI: 422 ${body}`,
+      }),
+    );
+  });
+
+  test("crashes with the body for non-422 errors", async () => {
+    const body = `{"message":"Unauthorized"}`;
+    mockFetch.mockResolvedValue(new Response(body, { status: 401 }));
+    await expect(createRedirectURI(ctx, "key", "http://x")).rejects.toThrow(
+      `Failed to create redirect URI: 401 ${body}`,
+    );
+  });
+});
+
+describe("createCORSOrigin", () => {
+  test("returns modified: true on a successful response", async () => {
+    mockFetch.mockResolvedValue(new Response(null, { status: 201 }));
+    await expect(
+      createCORSOrigin(ctx, "key", "http://localhost:5173"),
+    ).resolves.toEqual({ modified: true });
+  });
+
+  test("returns modified: false on duplicate_cors_origin", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(`{"code":"duplicate_cors_origin","message":"..."}`, {
+        status: 409,
+      }),
+    );
+    await expect(
+      createCORSOrigin(ctx, "key", "http://localhost:5173"),
+    ).resolves.toEqual({ modified: false });
+    expect(ctx.crash).not.toHaveBeenCalled();
+  });
+
+  test("returns modified: false when the origin already exists", async () => {
+    mockFetch.mockResolvedValue(
+      new Response(`{"message":"CORS origin already exists."}`, {
+        status: 409,
+      }),
+    );
+    await expect(
+      createCORSOrigin(ctx, "key", "http://localhost:5173"),
+    ).resolves.toEqual({ modified: false });
+    expect(ctx.crash).not.toHaveBeenCalled();
+  });
+
+  test("crashes with the body for a non-duplicate 409", async () => {
+    const body = `{"message":"Some other conflict."}`;
+    mockFetch.mockResolvedValue(new Response(body, { status: 409 }));
+    await expect(createCORSOrigin(ctx, "key", "http://x")).rejects.toThrow(
+      `Failed to create CORS origin: 409 ${body}`,
+    );
+    expect(ctx.crash).toHaveBeenCalledWith(
+      expect.objectContaining({
+        printedMessage: `Failed to create CORS origin: 409 ${body}`,
+      }),
+    );
+  });
+});