every-plugin 2.10.0 → 3.0.0-rc.0

package/src/build/ui/generated-config.ts

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import path from "node:path";
+import { findBosConfigPath } from "../rspack/compose";
+
+const UI_DIR = "ui";
+const GENERATED_CONFIG_DIR = ".every-plugin";
+const GENERATED_UI_CONFIG = "ui.rsbuild.config.generated.mjs";
+
+/**
+ * Folder-form UI source: a `ui/` directory with route files but no own
+ * package.json — the plugin workspace owns the build (single-workspace
+ * plugin, one dev process, one deploy train). Workspace-form ui sources
+ * (own package.json + scripts) are NOT managed here.
+ */
+export function hasFolderFormUi(cwd: string): boolean {
+  const uiDir = path.join(cwd, UI_DIR);
+  return (
+    fs.existsSync(path.join(uiDir, "src", "routes")) &&
+    !fs.existsSync(path.join(uiDir, "package.json"))
+  );
+}
+
+function generatedUiConfig(pluginId: string): string {
+  return `import path from "node:path";
+import { createUiRsbuildConfig } from "every-plugin/build/ui";
+import pkg from "../package.json";
+
+const workspaceRoot = path.resolve(import.meta.dirname, "..", "ui");
+
+export default createUiRsbuildConfig({
+  workspaceRoot,
+  pkg,
+  role: "consumer",
+  manifestName: ${JSON.stringify(pluginId)},
+  devPort: Number(process.env.BOS_UI_PORT) || 0,
+  webEntry: "./ui/src/routeConfig.gen.ts",
+  webExposes: { "./routeConfig": "./ui/src/routeConfig.gen.ts" },
+  nodeEntry: "./ui/src/routeConfig.gen.ts",
+  nodeExposes: { "./routeConfig": "./ui/src/routeConfig.gen.ts" },
+  routesDirectory: "./ui/src/routes",
+});
+`;
+}
+
+/**
+ * Canonical config-layout derivation: the composition key for a plugin
+ * workspace — the `<key>` of the `plugins/<key>` directory relative to the
+ * nearest `bos.config.json`. The dev server and the generated ui config
+ * both key off this; no consumer keeps a private copy.
+ */
+export function pluginLayoutKey(cwd: string): string | null {
+  const bosConfigPath = findBosConfigPath(cwd);
+  const relativeWorkspace = bosConfigPath
+    ? path.relative(path.dirname(bosConfigPath), cwd)
+    : undefined;
+  const [workspaceGroup, layoutKey] = relativeWorkspace?.split(path.sep) ?? [];
+  return workspaceGroup === "plugins" && layoutKey ? layoutKey : null;
+}
+
+/**
+ * Synthesize the rsbuild config for a folder-form ui source (the plugin
+ * build contract, not per-plugin config — mirrors the rspack generated
+ * config). Returns the config file path, or null when the workspace has no
+ * folder-form ui source.
+ */
+export function ensureGeneratedUiRsbuildConfig(cwd: string): string | null {
+  if (!hasFolderFormUi(cwd)) return null;
+  // The manifest's name derives ONLY from the plugins/<key> layout key
+  // (ADR 0008 §2) — a non-derivable key fails the build loudly, never the
+  // container-name fallback that mis-keyed manifests.
+  const pluginId = pluginLayoutKey(cwd);
+  if (!pluginId) {
+    throw new Error(
+      `[every-plugin] cannot derive the ui's composition key from ${cwd} — no authored config (bos.app.ts / bos.config.json) found above a plugins/<key> directory. The manifest name is the layout key; the container name is never a fallback.`,
+    );
+  }
+  const outDir = path.join(cwd, GENERATED_CONFIG_DIR);
+  fs.mkdirSync(outDir, { recursive: true });
+  const outPath = path.join(outDir, GENERATED_UI_CONFIG);
+  const next = generatedUiConfig(pluginId);
+  if (!fs.existsSync(outPath) || fs.readFileSync(outPath, "utf8") !== next) {
+    fs.writeFileSync(outPath, next);
+  }
+  return outPath;
+}
+
+const CORE_UI_MARKERS = {
+  routes: "src/routes",
+  contract: "src/contract.ts",
+};
+
+/**
+ * Workspace-form core ui: the workspace IS the ui (own package.json, route
+ * tree) and is not plugin-shaped — the /api counterpart of the plugin
+ * workspace form. The entry stub is NOT a marker: it is generated
+ * (ADR 0023), so a fresh clone has no bootstrap stubs until the first
+ * generation pass.
+ */
+export function hasCoreUiWorkspace(cwd: string = process.cwd()): boolean {
+  return (
+    fs.existsSync(path.join(cwd, CORE_UI_MARKERS.routes)) &&
+    !fs.existsSync(path.join(cwd, CORE_UI_MARKERS.contract)) &&
+    !fs.existsSync(path.join(cwd, "plugin.dev.ts"))
+  );
+}
+
+function generatedCoreUiConfig(): string {
+  return `import { defineConfig } from "@rsbuild/core";
+import { readAuthoredConfigInput } from "everything-dev/config";
+import { createCoreUiRsbuildConfig } from "every-plugin/build/ui";
+
+export default defineConfig(async () =>
+  createCoreUiRsbuildConfig(await readAuthoredConfigInput()),
+);
+`;
+}
+
+/**
+ * Synthesize the rsbuild config for a workspace-form core ui with no local
+ * `rsbuild.config.ts` — the /api generated-config model. A local file is an
+ * override and wins untouched. Returns the workspace-relative config path,
+ * or null when the workspace is not a core ui (or has a local config).
+ */
+export function ensureGeneratedCoreUiRsbuildConfig(cwd: string = process.cwd()): string | null {
+  if (!hasCoreUiWorkspace(cwd)) return null;
+  if (fs.existsSync(path.join(cwd, "rsbuild.config.ts"))) return null;
+  const outDir = path.join(cwd, GENERATED_CONFIG_DIR);
+  fs.mkdirSync(outDir, { recursive: true });
+  const outPath = path.join(outDir, GENERATED_UI_CONFIG);
+  fs.writeFileSync(outPath, generatedCoreUiConfig());
+  console.log("[every-plugin] rsbuild.config.ts not found — using the core ui build factory.");
+  return path.join(GENERATED_CONFIG_DIR, GENERATED_UI_CONFIG);
+}

package/src/build/ui/hash-artifacts-plugin.ts

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { RsbuildPlugin } from "@rsbuild/core";
+import {
+  BuildEntryReportSchema,
+  findHashedEntry,
+  MF_MANIFEST_FILENAME,
+  planArtifactCopies,
+  STYLE_FILENAME,
+} from "../artifact-names";
+
+export interface HashArtifactsPluginOptions {
+  /** The container entry's base name in this environment's dist root. */
+  entryBase: string;
+  /** Absolute dist root this environment wrote (web: `dist`, node: `dist/ssr`). */
+  distRoot: string;
+}
+
+function listFiles(dir: string, out: string[] = []): string[] {
+  for (const entry of fs
+    .readdirSync(dir, { withFileTypes: true })
+    .sort((a, b) => a.name.localeCompare(b.name))) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) listFiles(full, out);
+    else out.push(path.relative(dir, full).split(path.sep).join("/"));
+  }
+  return out;
+}
+
+/**
+ * Emits the additive hashed copies for one environment's dist root (ticket:
+ * atomic-deploys 01). The entry itself is hashed by the build (filename
+ * template); this plugin adds immutable hashed copies of the fixed-name
+ * browser artifacts (mf-manifest.json at the root, style.css under
+ * static/css), and `build-report.json` for the deploy leg. Idempotent under
+ * watch: same bytes → same hashed names.
+ */
+export function hashArtifactsPlugin(options: HashArtifactsPluginOptions): RsbuildPlugin {
+  return {
+    name: "hash-artifacts",
+    setup(api) {
+      api.onAfterEnvironmentCompile(() => {
+        const distRoot = options.distRoot;
+        if (!fs.existsSync(distRoot)) return;
+
+        const resolveExisting = (name: string): string | null => {
+          const candidates = [
+            path.join(distRoot, name),
+            path.join(distRoot, "static", "css", name),
+          ];
+          return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+        };
+
+        const assetNames = listFiles(distRoot);
+        const entry = findHashedEntry(assetNames, options.entryBase);
+        if (!entry) return;
+
+        const contents: Record<string, string> = {};
+        for (const fixedName of [MF_MANIFEST_FILENAME, STYLE_FILENAME]) {
+          const from = resolveExisting(fixedName);
+          if (from) contents[fixedName] = fs.readFileSync(from, "utf8");
+        }
+
+        const plan = planArtifactCopies({ assetNames, entryBase: options.entryBase, contents });
+        if (!plan) return;
+
+        for (const copy of plan.copies) {
+          const from = resolveExisting(copy.from);
+          if (!from) throw new Error(`[hash-artifacts] planned copy source missing: ${copy.from}`);
+          fs.copyFileSync(from, path.join(distRoot, copy.to));
+        }
+        fs.writeFileSync(
+          path.join(distRoot, "build-report.json"),
+          `${JSON.stringify(BuildEntryReportSchema.parse(plan.report), null, 2)}\n`,
+        );
+      });
+    },
+  };
+}

package/src/build/ui/index.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared build surface for ui plugins (dual MF targets).
+ *
+ * Shared dependencies (react, react-dom, the orpc client/contract pair, the
+ * TanStack query/router pair, lingui, and the everything-dev session/i18n
+ * subpath modules) come from the SharedDependencySpec — the canonical list in
+ * `every-plugin/shared-deps-spec` — resolved from the building workspace's
+ * installed versions so a mismatch fails the build instead of loading a
+ * second React. Consumers (plugin remotes) set `import: false` — no bundled
+ * fallback copy, the provider (core ui) provides through the share scope
+ * only.
+ *
+ * `CORE_UI_DEPLOY_FIELDS` names the bos.config.json fields the publish
+ * writes deploy URLs back to.
+ *
+ * A ui source's rsbuild.config.ts mirrors ui/rsbuild.config.ts with these
+ * helpers: the web target is an MF remote exposing `./routeConfig` (the
+ * generated import map); the node target is a commonjs container exposing
+ * `./routeConfig` with the `@module-federation/node` runtime plugin and
+ * `autoCodeSplitting` off.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import type { RsbuildPlugin } from "@rsbuild/core";
+import { PLUGIN_UI_SHARED_EXPOSES } from "../../ui/manifest/contract";
+import { type UiManifestGenPluginOptions, uiManifestGenPlugin } from "./manifest-plugin";
+
+export { type CoreUiRsbuildConfigInput, createCoreUiRsbuildConfig } from "./factory";
+export {
+  ensureGeneratedCoreUiRsbuildConfig,
+  ensureGeneratedUiRsbuildConfig,
+  hasCoreUiWorkspace,
+  hasFolderFormUi,
+} from "./generated-config";
+export {
+  type HashArtifactsPluginOptions,
+  hashArtifactsPlugin,
+} from "./hash-artifacts-plugin";
+export {
+  createUiRsbuildConfig,
+  sanitizeContainerName,
+  type UiRsbuildConfigOptions,
+} from "./rsbuild-config";
+export { CORE_UI_STUBS, emitCoreUiStubs } from "./stubs";
+export type { UiManifestGenPluginOptions };
+export { uiManifestGenPlugin };
+
+export interface UiDeployFields {
+  urlField: string;
+  integrityField: string;
+  ssrUrlField?: string;
+  ssrIntegrityField?: string;
+}
+
+/** Core shell field paths — unchanged from the v1 remote. */
+export const CORE_UI_DEPLOY_FIELDS: UiDeployFields = {
+  urlField: "app.ui.production",
+  integrityField: "app.ui.integrity",
+  ssrUrlField: "app.ui.ssr",
+  ssrIntegrityField: "app.ui.ssrIntegrity",
+};
+
+/** Canonical exposes every manifest-composed ui source ships. */
+export { PLUGIN_UI_SHARED_EXPOSES };
+
+/**
+ * Part of the plugin build contract, not per-plugin config: container chunks
+ * must resolve against the origin that served the remote entry. rsbuild's MF
+ * manifest stamps an absolute dev-server publicPath into metaData — rewrite
+ * it to `auto` after the node environment compiles so runtime resolution
+ * stays origin-relative.
+ */
+export function restoreManifestPublicPath(distRoot: string): RsbuildPlugin {
+  return {
+    name: "restore-manifest-public-path",
+    setup(api) {
+      api.onAfterEnvironmentCompile(({ environment, stats }) => {
+        if (!stats || stats.hasErrors() || environment.name !== "node") return;
+        const manifestPath = path.resolve(distRoot, "mf-manifest.json");
+        if (!fs.existsSync(manifestPath)) return;
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        if (manifest.metaData?.publicPath && manifest.metaData.publicPath !== "auto") {
+          manifest.metaData.publicPath = "auto";
+          fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+        }
+      });
+    },
+  };
+}
+
+export {
+  CORE_UI_PLUGIN_KEY,
+  MANIFEST_FILENAME,
+  ROUTE_CONFIG_FILENAME,
+  UI_REMOTE_ENTRY_FILENAME,
+  UI_REMOTE_SERVER_ENTRY_FILENAME,
+} from "../../ui/manifest/contract";

package/src/build/ui/manifest-plugin.ts

@@ -0,0 +1,54 @@
+import type { RsbuildPlugin } from "@rsbuild/core";
+import { generateUiManifest } from "../../ui/manifest/generator";
+
+/**
+ * Rsbuild plugin that keeps a ui source's generated artifacts fresh during
+ * builds and dev watch: manifest.gen.json + routeConfig.gen.ts are
+ * regenerated in plugin setup (before any environment compiles, so the
+ * `./routeConfig` MF expose resolves), and again on every build/dev-compile
+ * start. The stock routeTree write is redirected to a scratch path —
+ * TanStackRouterRspack owns src/routeTree.gen.ts (its autoCodeSplitting
+ * options differ from the manifest pass).
+ */
+
+export interface UiManifestGenPluginOptions {
+  workspaceRoot: string;
+  pluginName: string;
+}
+
+const inFlight = new Map<string, Promise<unknown>>();
+
+/** rsbuild builds environments in parallel and each setup runs the generator — concurrent runs share one pass. */
+function runOnce(key: string, run: () => Promise<unknown>): Promise<unknown> {
+  const existing = inFlight.get(key);
+  if (existing) return existing;
+  const promise = run().finally(() => {
+    inFlight.delete(key);
+  });
+  inFlight.set(key, promise);
+  return promise;
+}
+
+export function uiManifestGenPlugin(options: UiManifestGenPluginOptions): RsbuildPlugin {
+  const run = () =>
+    runOnce(`${options.workspaceRoot}::${options.pluginName}`, () =>
+      generateUiManifest({
+        workspaceRoot: options.workspaceRoot,
+        pluginName: options.pluginName,
+        emitRouteTree: false,
+      }),
+    );
+
+  return {
+    name: "ui-manifest-gen",
+    async setup(api) {
+      await run();
+      api.onBeforeBuild(async () => {
+        await run();
+      });
+      api.onBeforeDevCompile(async () => {
+        await run();
+      });
+    },
+  };
+}

package/src/build/ui/rsbuild-config.ts

@@ -0,0 +1,256 @@
+import path from "node:path";
+import { pluginModuleFederation } from "@module-federation/rsbuild-plugin";
+import { defineConfig, type EnvironmentConfig, type RsbuildConfig, rspack } from "@rsbuild/core";
+import { pluginReact } from "@rsbuild/plugin-react";
+import { TanStackRouterRspack } from "@tanstack/router-plugin/rspack";
+import { FixMfDataUriPlugin } from "../../build/rspack";
+import { createUiSharedDeps } from "../../shared-deps-spec";
+import { sanitizeContainerName } from "../../ui/manifest/contract";
+import { isBuildInvocation, uiEntryFilename } from "../artifact-names";
+import { hashArtifactsPlugin } from "./hash-artifacts-plugin";
+import { MANIFEST_FILENAME, restoreManifestPublicPath } from "./index";
+import { uiManifestGenPlugin } from "./manifest-plugin";
+
+/**
+ * The full dual-environment rsbuild config for a manifest-composed ui source
+ * (ADR 0008 §7 — the plugin build contract, not per-plugin config). The core
+ * ui and every plugin ui source build from this one factory: `web` emits the
+ * browser remote, `node` the commonjs SSR container; shared deps are strict
+ * singletons in the given role.
+ */
+export interface UiRsbuildConfigOptions {
+  /** the ui source root — contains package.json, src/, and the routes dir */
+  workspaceRoot: string;
+  /** the ui workspace's package.json (shared-dep version resolution) */
+  pkg: {
+    name: string;
+    version?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+  /** core provides the shared singletons; plugin remotes consume (`import: false`) */
+  role: "provider" | "consumer";
+  /** the composition key written into manifest.gen.json (the config-side key) */
+  manifestName: string;
+  devPort: number;
+  webEntry: string;
+  webExposes: Record<string, string>;
+  nodeEntry: string;
+  nodeExposes: Record<string, string>;
+  copy?: Array<{
+    from: string;
+    to: string;
+    globOptions?: { ignore?: string[] };
+  }>;
+  define?: Record<string, string>;
+  /** routes dir relative to the rsbuild cwd — folder-form ui sources live at
+   * `ui/src/routes` while the build runs from the plugin root */
+  routesDirectory?: string;
+}
+
+export { sanitizeContainerName };
+
+/**
+ * The node environment never owns the routeTree write: the web env's
+ * generator produces identical content, and both environments resolve the
+ * same on-disk tree. Redirecting the node write to scratch removes the
+ * concurrent-writers race on src/routeTree.gen.ts (the generator's
+ * "Cannot overwrite" retry noise).
+ */
+const NODE_ROUTE_TREE_SCRATCH = "./node_modules/.cache/manifest-compose/routeTree.node.gen.ts";
+
+export function createUiRsbuildConfig(options: UiRsbuildConfigOptions): RsbuildConfig {
+  const {
+    workspaceRoot,
+    pkg,
+    role,
+    manifestName,
+    devPort,
+    webEntry,
+    webExposes,
+    nodeEntry,
+    nodeExposes,
+    copy = [],
+    define,
+    routesDirectory,
+  } = options;
+  const workspaceRootAbsolute = path.resolve(workspaceRoot);
+  const normalizedName = sanitizeContainerName(pkg.name);
+  const manifestGen = () =>
+    uiManifestGenPlugin({ workspaceRoot: workspaceRootAbsolute, pluginName: manifestName });
+  const uiSharedDeps = createUiSharedDeps({ role, workspaceRoot: workspaceRootAbsolute });
+
+  const isBuild = isBuildInvocation();
+
+  const webEnvironment: EnvironmentConfig = {
+    plugins: [
+      pluginReact(),
+      manifestGen(),
+      pluginModuleFederation(
+        {
+          name: normalizedName,
+          filename: uiEntryFilename({ isBuild }),
+          dts: false,
+          exposes: webExposes,
+          shared: uiSharedDeps,
+        },
+        { environment: "web" },
+      ),
+      ...(isBuild
+        ? [
+            hashArtifactsPlugin({
+              entryBase: "remoteEntry",
+              distRoot: path.join(workspaceRootAbsolute, "dist"),
+            }),
+          ]
+        : []),
+    ],
+    source: { entry: { index: webEntry }, ...(define ? { define } : {}) },
+    resolve: { alias: { "@": path.join(workspaceRootAbsolute, "src") } },
+    tools: {
+      rspack: (config) => {
+        const cssPlugin = config.plugins?.find((p) => p instanceof rspack.CssExtractRspackPlugin) as
+          | { options?: Record<string, string> }
+          | undefined;
+        if (cssPlugin) {
+          cssPlugin.options ??= {};
+          cssPlugin.options.chunkFilename = "static/css/async/[name].[contenthash].css";
+        }
+        Object.assign(config, {
+          target: "web",
+          output: {
+            ...config.output,
+            publicPath: "auto",
+            uniqueName: normalizedName,
+            chunkFilename: "static/js/async/[name].[contenthash].js",
+            crossOriginLoading: "anonymous",
+          },
+          resolve: {
+            ...config.resolve,
+            fallback: { bufferutil: false, "utf-8-validate": false },
+          },
+          infrastructureLogging: { level: "error" },
+          stats: "errors-warnings",
+          plugins: [
+            ...(config.plugins ?? []),
+            TanStackRouterRspack({
+              target: "react",
+              autoCodeSplitting: true,
+              routeFileIgnorePattern: "\\.(test|spec)\\.(ts|tsx)$",
+              ...(routesDirectory ? { routesDirectory } : {}),
+            }),
+            new FixMfDataUriPlugin(),
+          ],
+        });
+        return config;
+      },
+    },
+    output: {
+      // Absolute: the ui source root owns dist even when the build cwd is the
+      // parent plugin workspace (folder-form ui sources).
+      distPath: {
+        root: path.join(workspaceRootAbsolute, "dist"),
+        css: "static/css",
+        js: "static/js",
+      },
+      assetPrefix: "auto",
+      filename: { js: "[name].js", css: "style.css" },
+      copy: [
+        ...copy,
+        { from: path.join(workspaceRootAbsolute, "src", MANIFEST_FILENAME), to: "./" },
+      ],
+    },
+  };
+
+  // Dev without SSR skips the node environment: it exists for the host's dev
+  // SSR container and nothing else. Builds always emit both.
+  const includeNodeEnv =
+    process.env.BOS_SSR === "1" ||
+    process.env.DEPLOY === "true" ||
+    process.env.NODE_ENV !== "development";
+
+  const nodeEnvironment: EnvironmentConfig = {
+    plugins: [
+      pluginReact(),
+      manifestGen(),
+      pluginModuleFederation(
+        {
+          name: normalizedName,
+          filename: uiEntryFilename({ isBuild, server: true }),
+          dts: false,
+          exposes: nodeExposes,
+          shared: uiSharedDeps,
+        },
+        { target: "node", environment: "node" },
+      ),
+      restoreManifestPublicPath(path.resolve(workspaceRootAbsolute, "dist", "ssr")),
+      ...(isBuild
+        ? [
+            hashArtifactsPlugin({
+              entryBase: "remoteEntry.server",
+              distRoot: path.resolve(workspaceRootAbsolute, "dist", "ssr"),
+            }),
+          ]
+        : []),
+    ],
+    source: { entry: { index: nodeEntry } },
+    resolve: {
+      alias: {
+        "@": path.join(workspaceRootAbsolute, "src"),
+        "@tanstack/react-devtools": false,
+        "@tanstack/react-router-devtools": false,
+      },
+    },
+    tools: {
+      rspack: (config) => {
+        Object.assign(config, {
+          output: { ...config.output, uniqueName: `${normalizedName}_server` },
+          resolve: {
+            ...config.resolve,
+            fallback: { bufferutil: false, "utf-8-validate": false },
+          },
+          externals: [/^node:/],
+          infrastructureLogging: { level: "error" },
+          stats: "errors-warnings",
+          plugins: [
+            ...(config.plugins ?? []),
+            TanStackRouterRspack({
+              target: "react",
+              autoCodeSplitting: false,
+              routeFileIgnorePattern: "\\.(test|spec)\\.(ts|tsx)$",
+              generatedRouteTree: NODE_ROUTE_TREE_SCRATCH,
+              ...(routesDirectory ? { routesDirectory } : {}),
+            }),
+            new FixMfDataUriPlugin(),
+          ],
+        });
+        return config;
+      },
+    },
+    // Absolute, like the web dist above — the node container must land in the
+    // ui source root's dist/ssr where the host's local container server looks.
+    output: { distPath: { root: path.join(workspaceRootAbsolute, "dist", "ssr") } },
+  };
+
+  return defineConfig({
+    environments: {
+      web: webEnvironment,
+      ...(includeNodeEnv ? { node: nodeEnvironment } : {}),
+    },
+    dev: {
+      lazyCompilation: false,
+      progressBar: false,
+      writeToDisk: true,
+      client: { overlay: false },
+    },
+    server: {
+      port: Number(process.env.PORT) || devPort,
+      printUrls: ({ urls }) => urls.filter((url) => url.includes("localhost")),
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+      },
+    },
+  });
+}