@sst-community/sst 4.19.0 → 5.0.0-alpha.1

package/platform/src/components/cloudflare/astro.ts

@@ -0,0 +1,355 @@
+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";
+import { isALteB } from "../../util/compare-semver.js";
+import { getPackageVersion } from "../../util/package.js";
+import {
+  validateFrameworkConfig,
+  validateNoWranglerFile,
+} from "./helpers/validation.js";
+
+export interface AstroArgs extends SsrSiteArgs {
+  /**
+   * Configure how this component works in `sst dev`.
+   *
+   * :::note
+   * In `sst dev` your Astro site is run in dev mode; it's not deployed.
+   * :::
+   *
+   * Instead of deploying your Astro site, 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 Astro site is located.  This path is relative to your `sst.config.ts`.
+   *
+   * By default it assumes your Astro site is in the root of your SST app.
+   * @default `"."`
+   *
+   * @example
+   *
+   * If your Astro site is in a package in your monorepo.
+   *
+   * ```js
+   * {
+   *   path: "packages/web"
+   * }
+   * ```
+   */
+  path?: SsrSiteArgs["path"];
+  /**
+   * [Link resources](/docs/linking/) to your Astro site. This will:
+   *
+   * 1. Grant the permissions needed to access the resources.
+   * 2. Allow you to access them in your site using `sst/resource`.
+   *
+   * @example
+   *
+   * Takes a list of resources to link to the function.
+   *
+   * ```js
+   * {
+   *   link: [bucket, stripeKey]
+   * }
+   * ```
+   *
+   * Access linked resources in your site with
+   * [`sst/resource`](/docs/reference/sdk/#sstresource). This works in both
+   * `sst dev` and after deploy.
+   *
+   * ```astro
+   * ---
+   * import { Resource } from "sst/resource";
+   *
+   * const files = await Resource.MyBucket.list();
+   * ---
+   * ```
+   *
+   */
+  link?: SsrSiteArgs["link"];
+  /**
+   * Set [environment variables](https://docs.astro.build/en/guides/environment-variables/) in your Astro site.
+   *
+   * :::tip
+   * You can also `link` resources to your Astro site and access them in a type-safe way with the [SDK](/docs/reference/sdk/). We recommend linking since it's more secure.
+   * :::
+   *
+   * Recall that in Astro, you need to prefix your environment variables with `PUBLIC_` to access them on the client-side. [Read more here](https://docs.astro.build/en/guides/environment-variables/).
+   *
+   * @example
+   * ```js
+   * {
+   *   environment: {
+   *     API_URL: api.url,
+   *     // Accessible on the client-side
+   *     PUBLIC_STRIPE_PUBLISHABLE_KEY: "pk_test_123"
+   *   }
+   * }
+   * ```
+   */
+  environment?: SsrSiteArgs["environment"];
+  /**
+   * Set a custom domain for your Astro site.
+   *
+   * @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 Astro site.
+   *
+   * @default `"npm run build"`
+   *
+   * @example
+   *
+   * If you want to use a different build command.
+   * ```js
+   * {
+   *   buildCommand: "yarn build"
+   * }
+   * ```
+   */
+  buildCommand?: SsrSiteArgs["buildCommand"];
+}
+
+/**
+ * The `Astro` component lets you deploy an [Astro](https://astro.build) site to Cloudflare.
+ *
+ * :::caution
+ * Features like `sst dev` support and `sst/resource` bindings require Astro v6 or newer.
+ * :::
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * Deploy the Astro site that's in the project root.
+ *
+ * ```js title="sst.config.ts"
+ * new sst.cloudflare.Astro("MyWeb");
+ * ```
+ *
+ * #### Change the path
+ *
+ * Deploys the Astro site in the `my-astro-app/` directory.
+ *
+ * ```js {2} title="sst.config.ts"
+ * new sst.cloudflare.Astro("MyWeb", {
+ *   path: "my-astro-app/"
+ * });
+ * ```
+ *
+ * #### Add a custom domain
+ *
+ * Set a custom domain for your Astro site.
+ *
+ * ```js {2} title="sst.config.ts"
+ * new sst.cloudflare.Astro("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.Astro("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.Astro("MyWeb", {
+ *   domain: {
+ *     name: "app1.my-app.com",
+ *     aliases: ["app2.my-app.com"]
+ *   }
+ * });
+ * ```
+ *
+ * #### Link resources
+ *
+ * [Link resources](/docs/linking/) to your Astro site. 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.Astro("MyWeb", {
+ *   link: [bucket]
+ * });
+ * ```
+ *
+ * Add this to your `astro.config.mjs` for SST to work correctly.
+ *
+ * ```js title="astro.config.mjs"
+ * import { defineConfig } from "astro/config";
+ * import cloudflare from "@astrojs/cloudflare";
+ *
+ * export default defineConfig({
+ *   adapter: cloudflare({
+ *     configPath: process.env.SST_WRANGLER_PATH,
+ *   }),
+ * });
+ * ```
+ *
+ * Use `sst/resource` for linked resources.
+ *
+ * ```astro title="src/pages/index.astro"
+ * ---
+ * import { Resource } from "sst/resource";
+ *
+ * const files = await Resource.MyBucket.list();
+ * ---
+ * ```
+ *
+ * [Check out the full example](/docs/examples/#cloudflare-astro).
+ */
+export class Astro extends SsrSite {
+  constructor(
+    name: string,
+    args: AstroArgs = {},
+    opts: ComponentResourceOptions = {},
+  ) {
+    super(__pulumiType, name, args, opts);
+  }
+
+  protected validate(sitePath: string): void {
+    // Only validate configPath requirement for Astro v6+
+    // If version cannot be determined, default to v6+ (validate)
+    const astroVersion = getPackageVersion(sitePath, "astro");
+    const isV6Plus = !astroVersion || isALteB("6.0.0", astroVersion);
+
+    if (isV6Plus) {
+      validateFrameworkConfig({
+        sitePath,
+        configName: "astro.config",
+        componentName: "Astro",
+      });
+    }
+    validateNoWranglerFile(sitePath, "Astro");
+  }
+
+  protected buildPlan(outputPath: Output<string>): Output<Plan> {
+    return outputPath.apply(async (outputPath) => {
+      const distPath = path.join(outputPath, "dist");
+      const legacyServer = path.join(distPath, "_worker.js", "index.js");
+      if (await existsAsync(legacyServer)) {
+        // Astro v5 writes both the Worker bundle and assets into `dist/`.
+        const ignorePath = path.join(distPath, ".assetsignore");
+        const ignorePatterns = (await existsAsync(ignorePath))
+          ? (await fs.readFile(ignorePath, "utf-8")).split("\n")
+          : [];
+        let dirty = false;
+        ["_worker.js", "_routes.json"].forEach((pattern) => {
+          if (ignorePatterns.includes(pattern)) return;
+          ignorePatterns.push(pattern);
+          dirty = true;
+        });
+
+        if (dirty) {
+          await fs.appendFile(ignorePath, "\n_worker.js\n_routes.json");
+        }
+
+        return {
+          server: "./dist/_worker.js/index.js",
+          assets: "./dist",
+        };
+      }
+
+      const wranglerPath = path.join(distPath, "server", "wrangler.json");
+      if (await existsAsync(wranglerPath)) {
+        type WranglerConfig = {
+          main?: string;
+          assets?: {
+            directory?: string;
+          };
+        };
+
+        const serverPath = path.dirname(wranglerPath);
+        const wrangler = JSON.parse(
+          await fs.readFile(wranglerPath, "utf-8"),
+        ) as WranglerConfig;
+        const main = wrangler.main ?? "entry.mjs";
+        const serverEntry = path.resolve(serverPath, main);
+        const assetsDirectory = wrangler.assets?.directory;
+        const assetsPath = assetsDirectory
+          ? path.resolve(serverPath, assetsDirectory)
+          : path.join(distPath, "client");
+
+        if (await existsAsync(serverEntry)) {
+          return {
+            server: toRelativePath(serverEntry),
+            assets: toRelativePath(assetsPath),
+          };
+        }
+      }
+
+      throw new VisibleError(
+        `SSR server bundle not found in the build output at:\n` +
+          `  "${path.resolve(distPath)}".\n\n` +
+          `Expected either Astro v5 output in \`dist/_worker.js/index.js\` or Astro v6+ output in \`dist/server/wrangler.json\`.\n` +
+          `If your Astro project is entirely pre-rendered, use the \`sst.cloudflare.StaticSite\` component instead of \`sst.cloudflare.Astro\`.`,
+      );
+
+      function toRelativePath(filePath: string) {
+        const relative = path.relative(outputPath, filePath);
+        return relative.startsWith(".") ? relative : `./${relative}`;
+      }
+    });
+  }
+
+  /**
+   * The URL of the Astro site.
+   *
+   * 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:Astro";
+// @ts-expect-error
+Astro.__pulumiType = __pulumiType;

package/platform/src/components/cloudflare/auth.ts

@@ -0,0 +1,69 @@
+import {
+  ComponentResourceOptions,
+  Output,
+  output,
+  secret,
+} from "@pulumi/pulumi";
+import { Component, Transform } from "../component";
+import { Link } from "../link";
+import { WorkerArgs, Worker } from "./worker";
+import { PrivateKey } from "@pulumi/tls";
+import { BucketPolicyArgs } from "@pulumi/aws/s3";
+
+export interface AuthArgs {
+  authenticator: WorkerArgs;
+  transform?: {
+    bucketPolicy?: Transform<BucketPolicyArgs>;
+  };
+}
+
+export class Auth extends Component implements Link.Linkable {
+  private readonly _key: PrivateKey;
+  private readonly _authenticator: Output<Worker>;
+
+  constructor(name: string, args: AuthArgs, opts?: ComponentResourceOptions) {
+    super(__pulumiType, name, args, opts);
+
+    this._key = new PrivateKey(`${name}Keypair`, {
+      algorithm: "RSA",
+    });
+
+    this._authenticator = output(args.authenticator).apply((args) => {
+      return new Worker(`${name}Authenticator`, {
+        ...args,
+        url: true,
+        environment: {
+          ...args.environment,
+          AUTH_PRIVATE_KEY: secret(this.key.privateKeyPemPkcs8),
+          AUTH_PUBLIC_KEY: secret(this.key.publicKeyPem),
+        },
+      });
+    });
+  }
+
+  public get key() {
+    return this._key;
+  }
+
+  public get authenticator() {
+    return this._authenticator;
+  }
+
+  public get url() {
+    return this._authenticator.url!;
+  }
+
+  /** @internal */
+  public getSSTLink(): Link.Definition {
+    return {
+      properties: {
+        url: this._authenticator.url,
+        publicKey: secret(this.key.publicKeyPem),
+      },
+    };
+  }
+}
+
+const __pulumiType = "sst:cloudflare:Auth";
+// @ts-expect-error
+Auth.__pulumiType = __pulumiType;

package/platform/src/components/cloudflare/binding.ts

@@ -0,0 +1,132 @@
+/**
+ * The Cloudflare Binding Linkable helper is used to define the Cloudflare bindings included
+ * with the [`sst.Linkable`](/docs/component/linkable/) component.
+ *
+ * @example
+ *
+ * ```ts
+ * sst.cloudflare.binding({
+ *   type: "r2BucketBindings",
+ *   properties: {
+ *     bucketName: "my-bucket"
+ *   }
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+import { Input } from "../input";
+
+export interface AiBinding {
+  type: "aiBindings";
+  properties: Record<string, never>;
+}
+
+export interface KvBinding {
+  type: "kvNamespaceBindings";
+  properties: {
+    namespaceId: Input<string>;
+  };
+}
+export interface SecretTextBinding {
+  type: "secretTextBindings";
+  properties: {
+    text: Input<string>;
+  };
+}
+export interface ServiceBinding {
+  type: "serviceBindings";
+  properties: {
+    service: Input<string>;
+  };
+}
+export interface PlainTextBinding {
+  type: "plainTextBindings";
+  properties: {
+    text: Input<string>;
+  };
+}
+export interface QueueBinding {
+  type: "queueBindings";
+  properties: {
+    queueName: Input<string>;
+  };
+}
+export interface R2BucketBinding {
+  type: "r2BucketBindings";
+  properties: {
+    bucketName: Input<string>;
+  };
+}
+
+export interface D1DatabaseBinding {
+  type: "d1DatabaseBindings";
+  properties: {
+    id: Input<string>;
+  };
+}
+
+export interface HyperdriveBinding {
+  type: "hyperdriveBindings";
+  properties: {
+    id: Input<string>;
+  };
+}
+
+export interface DurableObjectNamespaceBinding {
+  type: "durableObjectNamespaceBindings";
+  properties: {
+    className: Input<string>;
+    scriptName?: Input<string>;
+    environment?: Input<string>;
+  };
+}
+
+export interface VersionMetadataBinding {
+  type: "versionMetadataBindings";
+  properties: Record<string, never>;
+}
+
+export interface WorkflowBinding {
+  type: "workflowBindings";
+  properties: {
+    workflowName: Input<string>;
+    className: Input<string>;
+    scriptName: Input<string>;
+  };
+}
+
+export interface RateLimitBinding {
+  type: "rateLimitBindings";
+  properties: {
+    namespaceId: Input<string>;
+    simple: Input<{
+      limit: Input<number>;
+      period: Input<number>;
+    }>;
+  };
+}
+
+export type Binding =
+  | AiBinding
+  | KvBinding
+  | SecretTextBinding
+  | ServiceBinding
+  | PlainTextBinding
+  | QueueBinding
+  | R2BucketBinding
+  | D1DatabaseBinding
+  | HyperdriveBinding
+  | VersionMetadataBinding
+  | WorkflowBinding
+  | DurableObjectNamespaceBinding
+  | RateLimitBinding;
+
+export function binding<T extends Binding["type"]>(input: Binding & {}) {
+  return {
+    type: "cloudflare.binding" as const,
+    binding: input.type as T,
+    properties: input.properties as Extract<Binding, { type: T }>["properties"],
+  };
+}

package/platform/src/components/cloudflare/bucket.ts

@@ -0,0 +1,142 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import * as cloudflare from "@pulumi/cloudflare";
+import { Component, Transform, transform } from "../component";
+import { Link } from "../link.js";
+import { binding } from "./binding.js";
+import { DEFAULT_ACCOUNT_ID } from "./account-id";
+import type { Input } from "../input";
+
+export interface BucketArgs {
+  /**
+   * The Cloudflare account ID to use for this R2 Bucket.
+   * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+   * @internal
+   */
+  accountId?: Input<string>;
+  /**
+   * [Transform](/docs/components/#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the R2 Bucket resource.
+     */
+    bucket?: Transform<cloudflare.R2BucketArgs>;
+  };
+}
+
+/**
+ * The `Bucket` component lets you add a [Cloudflare R2 Bucket](https://developers.cloudflare.com/r2/) to
+ * your app.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * ```ts title="sst.config.ts"
+ * const bucket = new sst.cloudflare.Bucket("MyBucket");
+ * ```
+ *
+ * #### Link to a worker
+ *
+ * You can link the bucket to a worker.
+ *
+ * ```ts {3} title="sst.config.ts"
+ * new sst.cloudflare.Worker("MyWorker", {
+ *   handler: "./index.ts",
+ *   link: [bucket],
+ *   url: true
+ * });
+ * ```
+ *
+ * Once linked, you can use the SDK to interact with the bucket.
+ *
+ * ```ts title="index.ts" {3}
+ * import { Resource } from "sst";
+ *
+ * await Resource.MyBucket.list();
+ * ```
+ */
+export class Bucket extends Component implements Link.Linkable {
+  private bucket: cloudflare.R2Bucket;
+
+  constructor(
+    name: string,
+    args?: BucketArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    const parent = this;
+
+    const bucket = createBucket();
+
+    this.bucket = bucket;
+
+    function createBucket() {
+      return new cloudflare.R2Bucket(
+        ...transform(
+          args?.transform?.bucket,
+          `${name}Bucket`,
+          {
+            name: "",
+            accountId: args?.accountId ?? DEFAULT_ACCOUNT_ID,
+          },
+          { parent },
+        ),
+      );
+    }
+  }
+
+  /**
+   * When you link a bucket to a worker, you can interact with it using these
+   * [Bucket methods](https://developers.cloudflare.com/r2/api/workers/workers-api-reference/#bucket-method-definitions).
+   *
+   * @example
+   * ```ts title="index.ts" {3}
+   * import { Resource } from "sst";
+   *
+   * await Resource.MyBucket.list();
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        name: this.bucket.name,
+      },
+      include: [
+        binding({
+          type: "r2BucketBindings",
+          properties: {
+            bucketName: this.bucket.name,
+          },
+        }),
+      ],
+    };
+  }
+
+  /**
+   * The generated name of the R2 Bucket.
+   */
+  public get name() {
+    return this.bucket.name;
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The Cloudflare R2 Bucket.
+       */
+      bucket: this.bucket,
+    };
+  }
+}
+
+const __pulumiType = "sst:cloudflare:Bucket";
+// @ts-expect-error
+Bucket.__pulumiType = __pulumiType;