@sst-community/sst 4.21.1 → 5.0.0-alpha.2

package/platform/src/components/cloudflare/durable-object.ts

@@ -0,0 +1,144 @@
+import { ComponentResourceOptions, output, type Output } from "@pulumi/pulumi";
+import { Component } from "../component.js";
+import { Link } from "../link.js";
+import type { Input } from "../input.js";
+import { binding } from "./binding.js";
+
+export interface DurableObjectArgs {
+  /**
+   * The name of the class in your worker handler file that extends `DurableObject`.
+   *
+   * @example
+   * ```js
+   * {
+   *   className: "Counter"
+   * }
+   * ```
+   */
+  className: Input<string>;
+}
+
+/**
+ * Use the `DurableObject` component to register a
+ * [Cloudflare Durable Object](https://developers.cloudflare.com/durable-objects/)
+ * for a worker.
+ *
+ * Create the Durable Object and then link it to a `sst.cloudflare.Worker`. SST
+ * adds the Durable Object binding automatically. The `className` must match the
+ * exported Durable Object class name in your worker code.
+ *
+ * Durable Objects require migrations on the worker. Use the Worker's
+ * `migrations` field like Wrangler's top-level `migrations` config: keep the
+ * full ordered history there, and SST uses it to build the Cloudflare migration
+ * payload for the Worker.
+ *
+ * On the first deploy, add the class with `newSqliteClasses`. If you later
+ * rename the class, keep the original migration and add a new migration with a
+ * unique tag and `renamedClasses`.
+ *
+ * @example
+ *
+ * ```ts title="sst.config.ts"
+ * const counter = new sst.cloudflare.DurableObject("Counter", {
+ *   className: "Counter",
+ * });
+ *
+ * new sst.cloudflare.Worker("Api", {
+ *   handler: "src/worker.ts",
+ *   link: [counter],
+ *   migrations: [{
+ *     tag: "v1",
+ *     newSqliteClasses: [counter.className],
+ *   }],
+ *   url: true,
+ * });
+ * ```
+ *
+ * To rename a deployed class from `Counter` to `CounterV2`, update `className`
+ * and the exported class name, then append a migration.
+ *
+ * ```ts title="sst.config.ts"
+ * const counter = new sst.cloudflare.DurableObject("Counter", {
+ *   className: "CounterV2",
+ * });
+ *
+ * new sst.cloudflare.Worker("Api", {
+ *   handler: "src/worker.ts",
+ *   link: [counter],
+ *   migrations: [
+ *     {
+ *       tag: "v1",
+ *       newSqliteClasses: ["Counter"],
+ *     },
+ *     {
+ *       tag: "v2",
+ *       renamedClasses: [{ from: "Counter", to: counter.className }],
+ *     },
+ *   ],
+ *   url: true,
+ * });
+ * ```
+ *
+ * ```ts title="src/worker.ts"
+ * import { Resource } from "sst";
+ * import { DurableObject } from "cloudflare:workers";
+ *
+ * export default {
+ *   async fetch() {
+ *     const stub = Resource.Counter.getByName("global");
+ *     return stub.fetch("https://counter/");
+ *   },
+ * };
+ *
+ * export class Counter extends DurableObject {
+ *   async fetch() {
+ *     return new Response("hello from the durable object");
+ *   }
+ * }
+ * ```
+ */
+export class DurableObject extends Component implements Link.Linkable {
+  /**
+   * The exported Durable Object class name.
+   */
+  public readonly className: Output<string>;
+
+  constructor(
+    name: string,
+    args: DurableObjectArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    super(__pulumiType, name, args, opts);
+    this.className = output(args.className);
+  }
+
+  /**
+   * When you link a Durable Object to a worker, SST adds a Cloudflare Durable
+   * Object namespace binding.
+   *
+   * @internal
+   */
+  public getSSTLink() {
+    const properties = {
+      className: this.className,
+    };
+
+    return {
+      properties,
+      include: [
+        binding({
+          type: "durableObjectNamespaceBindings",
+          properties,
+        }),
+        {
+          type: "cloudflare.durableObject",
+          ...properties,
+        },
+      ],
+    };
+  }
+}
+
+const __pulumiType = "sst:cloudflare:DurableObject";
+// @ts-expect-error
+DurableObject.__pulumiType = __pulumiType;

package/platform/src/components/cloudflare/experimental/index.ts

@@ -0,0 +1,3 @@
+export * from "../astro";
+export * from "./solid-start";
+export * from "./static-site";

package/platform/src/components/cloudflare/experimental/solid-start.ts

@@ -0,0 +1,288 @@
+import fs from "fs/promises";
+import path from "path";
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { VisibleError } from "../../error.js";
+import { Plan, SsrSite, SsrSiteArgs } from "../ssr-site.js";
+import { existsAsync } from "../../../util/fs.js";
+
+export interface SolidStartArgs extends SsrSiteArgs {
+  /**
+   * Configure how this component works in `sst dev`.
+   *
+   * :::note
+   * In `sst dev` your SolidStart app is run in dev mode; it's not deployed.
+   * :::
+   *
+   * Instead of deploying your SolidStart app, this starts it in dev mode. It's run
+   * as a separate process in the `sst dev` multiplexer. Read more about
+   * [`sst dev`](/docs/reference/cli/#dev).
+   *
+   * To disable dev mode, pass in `false`.
+   */
+  dev?: SsrSiteArgs["dev"];
+  /**
+   * Path to the directory where your SolidStart app is located.  This path is relative to your `sst.config.ts`.
+   *
+   * By default it assumes your SolidStart app is in the root of your SST app.
+   * @default `"."`
+   *
+   * @example
+   *
+   * If your SolidStart app is in a package in your monorepo.
+   *
+   * ```js
+   * {
+   *   path: "packages/web"
+   * }
+   * ```
+   */
+  path?: SsrSiteArgs["path"];
+  /**
+   * [Link resources](/docs/linking/) to your SolidStart app. This will:
+   *
+   * 1. Grant the permissions needed to access the resources.
+   * 2. Allow you to access it in your site using the [SDK](/docs/reference/sdk/).
+   *
+   * @example
+   *
+   * Takes a list of resources to link to the function.
+   *
+   * ```js
+   * {
+   *   link: [bucket, stripeKey]
+   * }
+   * ```
+   *
+   * You can access the linked resources as bindings in your SolidStart app.
+   */
+  link?: SsrSiteArgs["link"];
+  /**
+   * Set environment variables in your SolidStart app. These are made available:
+   *
+   * 1. In `vinxi build`, they are loaded into `process.env`.
+   * 2. Locally while running `vinxi dev` through `sst dev`.
+   *
+   * :::tip
+   * You can also `link` resources to your SolidStart app and access them in a type-safe way with the [SDK](/docs/reference/sdk/). We recommend linking since it's more secure.
+   * :::
+   *
+   * @example
+   * ```js
+   * {
+   *   environment: {
+   *     API_URL: api.url,
+   *     STRIPE_PUBLISHABLE_KEY: "pk_test_123"
+   *   }
+   * }
+   * ```
+   *
+   * You can access the environment variables in your SolidStart app as follows:
+   */
+  environment?: SsrSiteArgs["environment"];
+  /**
+   * Set a custom domain for your SolidStart app.
+   *
+   * @example
+   *
+   * ```js
+   * {
+   *   domain: "my-app.com"
+   * }
+   * ```
+   *
+   * Redirect alternate domains to the main domain.
+   *
+   * ```js
+   * {
+   *   domain: {
+   *     name: "my-app.com",
+   *     redirects: ["www.my-app.com"]
+   *   }
+   * }
+   * ```
+   *
+   * Or keep visitors on alternate domains with aliases.
+   *
+   * ```js
+   * {
+   *   domain: {
+   *     name: "app1.my-app.com",
+   *     aliases: ["app2.my-app.com"]
+   *   }
+   * }
+   * ```
+   */
+  domain?: SsrSiteArgs["domain"];
+  /**
+   * The command used internally to build your SolidStart app.
+   *
+   * @default `"npm run build"`
+   *
+   * @example
+   *
+   * If you want to use a different build command.
+   * ```js
+   * {
+   *   buildCommand: "yarn build"
+   * }
+   * ```
+   */
+  buildCommand?: SsrSiteArgs["buildCommand"];
+}
+
+/**
+ * The `SolidStart` component lets you deploy a [SolidStart](https://start.solidjs.com) app to Cloudflare.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * Deploy the SolidStart app that's in the project root.
+ *
+ * ```js title="sst.config.ts"
+ * new sst.cloudflare.SolidStart("MyWeb");
+ * ```
+ *
+ * #### Change the path
+ *
+ * Deploys the SolidStart app in the `my-solid-start-app/` directory.
+ *
+ * ```js {2} title="sst.config.ts"
+ * new sst.cloudflare.SolidStart("MyWeb", {
+ *   path: "my-solid-start-app/"
+ * });
+ * ```
+ *
+ * #### Add a custom domain
+ *
+ * Set a custom domain for your SolidStart app.
+ *
+ * ```js {2} title="sst.config.ts"
+ * new sst.cloudflare.SolidStart("MyWeb", {
+ *   domain: "my-app.com"
+ * });
+ * ```
+ *
+ * #### Redirect www to apex domain
+ *
+ * Redirect `www.my-app.com` to `my-app.com`.
+ *
+ * ```js {4} title="sst.config.ts"
+ * new sst.cloudflare.SolidStart("MyWeb", {
+ *   domain: {
+ *     name: "my-app.com",
+ *     redirects: ["www.my-app.com"]
+ *   }
+ * });
+ * ```
+ *
+ * #### Add domain aliases
+ *
+ * Allow visitors to use alternate domains without redirecting.
+ *
+ * ```js {4} title="sst.config.ts"
+ * new sst.cloudflare.SolidStart("MyWeb", {
+ *   domain: {
+ *     name: "app1.my-app.com",
+ *     aliases: ["app2.my-app.com"]
+ *   }
+ * });
+ * ```
+ *
+ * #### Link resources
+ *
+ * [Link resources](/docs/linking/) to your SolidStart app. This will grant permissions
+ * to the resources and allow you to access it in your site.
+ *
+ * ```ts {4} title="sst.config.ts"
+ * const bucket = new sst.cloudflare.Bucket("MyBucket");
+ *
+ * new sst.cloudflare.SolidStart("MyWeb", {
+ *   link: [bucket]
+ * });
+ * ```
+ *
+ * You can use the [SDK](/docs/reference/sdk/) to access the linked resources
+ * in your SolidStart app.
+ *
+ * ```ts title="src/app.tsx"
+ * import { Resource } from "sst";
+ *
+ * console.log(Resource.MyBucket.name);
+ * ```
+ */
+export class SolidStart extends SsrSite {
+  constructor(
+    name: string,
+    args: SolidStartArgs = {},
+    opts: ComponentResourceOptions = {},
+  ) {
+    super(__pulumiType, name, args, opts);
+  }
+
+  protected buildPlan(outputPath: Output<string>): Output<Plan> {
+    return outputPath.apply(async (outputPath) => {
+      // Make sure aws-lambda preset is used in nitro.json
+      const nitro = JSON.parse(
+        await fs.readFile(
+          path.join(outputPath, ".output", "nitro.json"),
+          "utf-8",
+        ),
+      );
+
+      if (!["cloudflare-module"].includes(nitro.preset)) {
+        throw new VisibleError(
+          `SolidStart's nitro.config.ts must be configured to use the "cloudflare-module" preset. It is currently set to "${nitro.preset}".`,
+        );
+      }
+
+      // Make sure the server bundle is in the dist directory
+      if (
+        !(await existsAsync(
+          path.join(outputPath, ".output", "server", "index.mjs"),
+        ))
+      ) {
+        throw new VisibleError(
+          `SSR server bundle "index.mjs" not found in the build output at:\n` +
+            `  "${path.resolve(outputPath, ".output", "server")}".\n\n` +
+            `If your SolidStart project is entirely pre-rendered, use the \`sst.cloudflare.StaticSite\` component instead of \`sst.cloudflare.SolidStart\`.`,
+        );
+      }
+
+      // Ensure `.assetsignore` file exists and contains `server`
+      const ignorePath = path.join(outputPath, ".output", ".assetsignore");
+      const ignorePatterns = (await existsAsync(ignorePath))
+        ? (await fs.readFile(ignorePath, "utf-8")).split("\n")
+        : [];
+      let dirty = false;
+      ["server"].forEach((pattern) => {
+        if (ignorePatterns.includes(pattern)) return;
+        ignorePatterns.push(pattern);
+        dirty = true;
+      });
+
+      if (dirty) {
+        await fs.appendFile(ignorePath, "\nserver");
+      }
+
+      return {
+        server: "./.output/server/index.mjs",
+        assets: "./.output/public",
+      };
+    });
+  }
+
+  /**
+   * The URL of the SolidStart app.
+   *
+   * If the `domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated Worker URL.
+   */
+  public get url() {
+    return super.url;
+  }
+}
+
+const __pulumiType = "sst:cloudflare:SolidStart";
+// @ts-expect-error
+SolidStart.__pulumiType = __pulumiType;

package/platform/src/components/cloudflare/experimental/static-site.ts

@@ -0,0 +1,4 @@
+// Re-export from the main cloudflare module for backwards compatibility
+// sst.cloudflare.x.StaticSite still works but is deprecated
+export { StaticSiteV2 as StaticSite } from "../static-site-v2.js";
+export type { StaticSiteV2Args as StaticSiteArgs } from "../static-site-v2.js";

package/platform/src/components/cloudflare/helpers/compatibility.ts

@@ -0,0 +1,44 @@
+import { all, output } from "@pulumi/pulumi";
+import type { Input } from "../../input.js";
+
+export const DEFAULT_COMPATIBILITY_DATE = "2025-05-05";
+export const DEFAULT_COMPATIBILITY_FLAGS = ["nodejs_compat"];
+
+type CompatibilityArgs = {
+  compatibility?: Input<{
+    date?: Input<string>;
+    flags?: Input<Input<string>[]>;
+  }>;
+  transform?: {
+    worker?:
+      | {
+          compatibilityDate?: Input<string>;
+          compatibilityFlags?: Input<Input<string>[]>;
+        }
+      | ((...args: any[]) => undefined);
+  };
+};
+
+export function normalizeCompatibility(args?: CompatibilityArgs) {
+  const compatibility = output(args?.compatibility);
+  const workerTransform =
+    typeof args?.transform?.worker === "function"
+      ? undefined
+      : args?.transform?.worker;
+  return output({
+    date: all([
+      compatibility.apply((value) => value?.date),
+      workerTransform?.compatibilityDate,
+    ]).apply(
+      ([argValue, transformValue]) =>
+        transformValue ?? argValue ?? DEFAULT_COMPATIBILITY_DATE,
+    ),
+    flags: all([
+      compatibility.apply((value) => value?.flags),
+      workerTransform?.compatibilityFlags,
+    ]).apply(
+      ([argValue, transformValue]) =>
+        transformValue ?? argValue ?? DEFAULT_COMPATIBILITY_FLAGS,
+    ),
+  });
+}

package/platform/src/components/cloudflare/helpers/fetch.ts

@@ -0,0 +1,81 @@
+// More examples here on how to parse responses from Cloudflare API
+// https://github.com/cloudflare/workers-sdk/blob/main/packages/wrangler/src/routes.ts
+
+const CLOUDFLARE_API_BASE_URL =
+  process.env.CLOUDFLARE_API_BASE_URL ?? "https://api.cloudflare.com/client/v4";
+// Read when a request is made, not when this file loads, so SST's components
+// load without the app's globals, as in a test
+const apiToken = () =>
+  $app.providers?.cloudflare?.apiToken || process.env.CLOUDFLARE_API_TOKEN;
+
+export interface FetchError {
+  code: number;
+  message: string;
+  error_chain?: FetchError[];
+}
+
+export interface FetchResult<ResultType> {
+  success: boolean;
+  result: ResultType;
+  errors: FetchError[];
+  messages?: string[];
+  result_info?: {
+    page: number;
+    per_page: number;
+    count: number;
+    total_count: number;
+  };
+}
+
+export async function cfFetch<ResultType>(
+  resource: string,
+  init: RequestInit = {},
+) {
+  const maxRetries = 3;
+  let lastError: Error | undefined;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const ret = await fetch(`${CLOUDFLARE_API_BASE_URL}${resource}`, {
+        ...init,
+        headers: {
+          Authorization: `Bearer ${apiToken()}`,
+          ...init.headers,
+        },
+      });
+
+      const json = (await ret.json()) as FetchResult<ResultType>;
+      // ie.
+      // {
+      //   "result": {
+      //     "subdomain": "wangfanjie"
+      //   },
+      //   "success": true,
+      //   "errors": [],
+      //   "messages": []
+      // }
+      if (json.success) {
+        return json;
+      }
+
+      lastError = new Error(
+        `A request to the Cloudflare API (${resource}) failed.`,
+      );
+      // @ts-expect-error attach the errors to the error object
+      lastError.errors = json.errors;
+      // @ts-expect-error attach the messages to the error object
+      lastError.messages = json.messages;
+    } catch (error: any) {
+      lastError = error;
+    }
+
+    // Retry with exponential backoff
+    if (attempt < maxRetries) {
+      await new Promise((resolve) =>
+        setTimeout(resolve, Math.pow(2, attempt) * 200),
+      );
+    }
+  }
+
+  throw lastError;
+}

package/platform/src/components/cloudflare/helpers/validation.ts

@@ -0,0 +1,74 @@
+import fs from "fs";
+import path from "path";
+import { VisibleError } from "../../error.js";
+
+/**
+ * Validates that no wrangler configuration file exists in the site directory.
+ * SST manages wrangler configuration automatically and user-provided files can cause conflicts.
+ */
+export function validateNoWranglerFile(sitePath: string, componentName: string): void {
+  const wranglerFiles = ["wrangler.toml", "wrangler.json", "wrangler.jsonc"];
+
+  for (const file of wranglerFiles) {
+    const filePath = path.join(sitePath, file);
+    if (fs.existsSync(filePath)) {
+      throw new VisibleError(
+        [
+          `Found ${file} in "${path.resolve(sitePath)}" for ${componentName}.`,
+          "",
+          "Remove it to avoid interfering with SST managed wrangler configurations:",
+          `https://sst-community.github.io/sst/docs/cloudflare/#cloudflare-vite-plugin`,
+        ].join("\n"),
+      );
+    }
+  }
+}
+
+/**
+ * Validates that the framework config file contains the required SST_WRANGLER_PATH configuration.
+ * This ensures linked resources work correctly in Cloudflare SSR sites.
+ */
+export function validateFrameworkConfig(input: {
+  sitePath: string;
+  configName: string;
+  componentName: string;
+}): void {
+  const { sitePath, configName, componentName } = input;
+
+  const extensions = [".ts", ".js", ".mjs"];
+  const configDir = sitePath;
+
+  // Find the config file
+  let configPath: string | undefined;
+  for (const ext of extensions) {
+    const candidate = path.join(configDir, `${configName}${ext}`);
+    if (fs.existsSync(candidate)) {
+      configPath = candidate;
+      break;
+    }
+  }
+
+  if (!configPath) {
+    throw new VisibleError(
+      `Could not find config file for ${componentName} in "${path.resolve(configDir)}".\nExpected one of: ${extensions.map(e => `${configName}${e}`).join(", ")}.`
+    );
+  }
+
+  // Read and check for SST_WRANGLER_PATH pattern
+  const content = fs.readFileSync(configPath, "utf-8");
+  const hasWranglerPath = /configPath\s*[:=]\s*process\.env\.SST_WRANGLER_PATH/.test(content);
+
+  if (!hasWranglerPath) {
+    throw new VisibleError(
+      [
+        `Missing required configuration for ${componentName}.`,
+        "",
+        `The Cloudflare adapter must be configured with:`,
+        `  configPath: process.env.SST_WRANGLER_PATH,`,
+        "",
+        `This is required for linked resources to work correctly:`,
+        `https://sst-community.github.io/sst/docs/cloudflare/#cloudflare-vite-plugin`,
+      ].join("\n")
+    );
+  }
+}

package/platform/src/components/cloudflare/helpers/worker-builder.ts

@@ -0,0 +1,57 @@
+import {
+  ComponentResourceOptions,
+  Input,
+  Output,
+  output,
+} from "@pulumi/pulumi";
+import { transform, Transform } from "../../component";
+import { Worker, WorkerArgs } from "../worker";
+import * as cloudflare from "@pulumi/cloudflare";
+
+export type WorkerBuilder = Output<{
+  getWorker: () => Worker;
+  script: cloudflare.WorkerScript;
+}>;
+
+export function workerBuilder(
+  name: string,
+  definition: Input<string | WorkerArgs>,
+  argsTransform?: Transform<WorkerArgs>,
+  opts?: ComponentResourceOptions,
+  accountId?: Input<string>,
+): WorkerBuilder {
+  return output(definition).apply((definition) => {
+    if (typeof definition === "string") {
+      // Case 1: The definition is a handler
+      const worker = new Worker(
+        ...transform(argsTransform, name, { accountId, handler: definition }, opts || {}),
+      );
+      return {
+        getWorker: () => worker,
+        script: worker.nodes.worker,
+      };
+    }
+
+    // Case 2: The definition is a WorkerArgs
+    else if (definition.handler) {
+      const worker = new Worker(
+        ...transform(
+          argsTransform,
+          name,
+          {
+            accountId,
+            ...definition,
+          },
+          opts || {},
+        ),
+      );
+
+      return {
+        getWorker: () => worker,
+        script: worker.nodes.worker,
+      };
+    }
+
+    throw new Error(`Invalid worker definition for the "${name}" Worker`);
+  });
+}