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

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

@@ -0,0 +1,222 @@
+import fs from "fs";
+import path from "path";
+
+export type WranglerCompatibility = {
+  date: string;
+  flags: string[];
+};
+
+export type WranglerLinkInclude = {
+  type: string;
+  binding?: string;
+  properties?: Record<string, unknown>;
+};
+
+export type WranglerLink = {
+  name: string;
+  include: WranglerLinkInclude[];
+  properties?: Record<string, unknown>;
+};
+
+export function createWranglerConfig(input: {
+  appName: string;
+  appStage: string;
+  name: string;
+  frameworkConfig?: Record<string, any>;
+  compatibility: WranglerCompatibility;
+  environment?: Record<string, string>;
+  links?: WranglerLink[];
+  accountId?: string;
+}) {
+  const config: Record<string, any> = {
+    ...(input.frameworkConfig ?? {}),
+    name: sanitizeWranglerName(`sst-${input.appStage}-${input.name}`),
+    compatibility_date: input.compatibility.date,
+    compatibility_flags: input.compatibility.flags,
+  };
+
+  if (input.accountId) {
+    config.account_id = input.accountId;
+  }
+
+  const vars: Record<string, string> = {
+    ...(input.environment ?? {}),
+    SST_RESOURCE_App: JSON.stringify({
+      name: input.appName,
+      stage: input.appStage,
+    }),
+  };
+  const kvNamespaces: Record<string, any>[] = [];
+  const r2Buckets: Record<string, any>[] = [];
+  const d1Databases: Record<string, any>[] = [];
+  const hyperdrives: Record<string, any>[] = [];
+  const services: Record<string, any>[] = [];
+  const queueProducers: Record<string, any>[] = [];
+  const workflows: Record<string, any>[] = [];
+  const rateLimits: Record<string, any>[] = [];
+  let ai: Record<string, any> | undefined;
+  let versionMetadata: Record<string, any> | undefined;
+
+  for (const link of input.links ?? []) {
+    const binding = link.include.find(
+      (item) => item.type === "cloudflare.binding",
+    );
+    // Links without a native Cloudflare binding (Secret, sst.aws.*, custom
+    // Linkable, etc.) are surfaced as JSON-stringified vars so they match
+    // the `secret_text` deploy path handled in `worker.ts buildBindings`.
+    if (!binding) {
+      vars[`SST_RESOURCE_${link.name}`] = JSON.stringify(link.properties ?? {});
+      continue;
+    }
+
+    const properties = binding.properties ?? {};
+    switch (binding.binding) {
+      case "aiBindings":
+        ai = {
+          binding: link.name,
+          remote: true,
+        };
+        break;
+      case "kvNamespaceBindings":
+        kvNamespaces.push({
+          binding: link.name,
+          id: stringValue(properties.namespaceId),
+          remote: true,
+        });
+        break;
+      case "secretTextBindings":
+      case "plainTextBindings":
+        vars[link.name] = stringValue(properties.text);
+        break;
+      case "serviceBindings":
+        services.push({
+          binding: link.name,
+          service: stringValue(properties.service),
+          remote: true,
+        });
+        break;
+      case "queueBindings":
+        queueProducers.push({
+          binding: link.name,
+          queue: stringValue(properties.queueName),
+          remote: true,
+        });
+        break;
+      case "r2BucketBindings":
+        r2Buckets.push({
+          binding: link.name,
+          bucket_name: stringValue(properties.bucketName),
+          remote: true,
+        });
+        break;
+      case "d1DatabaseBindings":
+        d1Databases.push({
+          binding: link.name,
+          database_id: stringValue(properties.id),
+          remote: true,
+        });
+        break;
+      case "hyperdriveBindings":
+        hyperdrives.push({
+          binding: link.name,
+          id: stringValue(properties.id),
+        });
+        break;
+      case "versionMetadataBindings":
+        versionMetadata = {
+          binding: link.name,
+        };
+        break;
+      case "workflowBindings":
+        workflows.push({
+          binding: link.name,
+          name: stringValue(properties.workflowName),
+          class_name: stringValue(properties.className),
+          script_name: stringValue(properties.scriptName),
+          remote: true,
+        });
+        break;
+      case "rateLimitBindings":
+        rateLimits.push({
+          name: link.name,
+          namespace_id: stringValue(properties.namespaceId),
+          simple: properties.simple,
+        });
+        break;
+    }
+  }
+
+  if (Object.keys(vars).length > 0) {
+    config.vars = vars;
+  }
+  if (kvNamespaces.length > 0) {
+    config.kv_namespaces = kvNamespaces;
+  }
+  if (r2Buckets.length > 0) {
+    config.r2_buckets = r2Buckets;
+  }
+  if (d1Databases.length > 0) {
+    config.d1_databases = d1Databases;
+  }
+  if (hyperdrives.length > 0) {
+    config.hyperdrive = hyperdrives;
+  }
+  if (services.length > 0) {
+    config.services = services;
+  }
+  if (queueProducers.length > 0) {
+    config.queues = {
+      producers: queueProducers,
+    };
+  }
+  if (ai) {
+    config.ai = ai;
+  }
+  if (versionMetadata) {
+    config.version_metadata = versionMetadata;
+  }
+  if (workflows.length > 0) {
+    config.workflows = workflows;
+  }
+  if (rateLimits.length > 0) {
+    config.rate_limits = rateLimits;
+  }
+
+  return config;
+}
+
+export function writeWranglerConfig(args: {
+  workDir: string;
+  stage: string;
+  name: string;
+  config: Record<string, any>;
+}) {
+  const wranglerPath = path.join(
+    args.workDir,
+    "wrangler",
+    args.stage,
+    `${args.name}.jsonc`,
+  );
+  const contents = JSON.stringify(args.config, null, 2);
+
+  fs.mkdirSync(path.dirname(wranglerPath), { recursive: true });
+  if (
+    !fs.existsSync(wranglerPath) ||
+    fs.readFileSync(wranglerPath, "utf-8") !== contents
+  ) {
+    fs.writeFileSync(wranglerPath, contents);
+  }
+
+  return wranglerPath;
+}
+
+function stringValue(input: unknown) {
+  return typeof input === "string" ? input : "";
+}
+
+const wranglerNameRegex = /[^a-z0-9-]+/g;
+
+function sanitizeWranglerName(input: string) {
+  const value = input.toLowerCase().replaceAll(wranglerNameRegex, "-");
+  return value.replace(/^-+|-+$/g, "") || "sst";
+}

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

@@ -0,0 +1,402 @@
+import { ComponentResourceOptions, Input, output } from "@pulumi/pulumi";
+import * as cloudflare from "@pulumi/cloudflare";
+import { Component, Transform, transform } from "../component";
+import { Link } from "../link";
+import { binding } from "./binding";
+import { DEFAULT_ACCOUNT_ID } from "./account-id";
+import { DurationHours, toSeconds } from "../duration";
+
+export interface HyperdriveGetArgs {
+  /**
+   * The ID of the existing Hyperdrive config.
+   */
+  hyperdriveId: string;
+  /**
+   * The Cloudflare account ID the Hyperdrive config belongs to.
+   * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+   * @internal
+   */
+  accountId?: string;
+}
+
+interface HyperdriveRef {
+  ref: true;
+  hyperdrive: cloudflare.HyperdriveConfig;
+}
+
+export interface HyperdriveArgs {
+  /**
+   * Configure caching for SQL queries sent through Hyperdrive.
+   *
+   * :::tip
+   * Caching is enabled by default. Pass `false` to disable it.
+   * :::
+   *
+   * @example
+   * Disable caching.
+   * ```js
+   * {
+   *   caching: false
+   * }
+   * ```
+   *
+   * Customize cache durations.
+   * ```js
+   * {
+   *   caching: {
+   *     maxAge: "30 minutes",
+   *     staleWhileRevalidate: "30 seconds"
+   *   }
+   * }
+   * ```
+   */
+  caching?: Input<
+    | false
+    | {
+        /**
+         * The maximum duration items should persist in the cache. Can be up to 1 hour.
+         *
+         * @default `"60 seconds"`
+         *
+         * @example
+         * ```js
+         * {
+         *   caching: {
+         *     maxAge: "30 minutes"
+         *   }
+         * }
+         * ```
+         */
+        maxAge?: Input<DurationHours>;
+        /**
+         * The duration the cache may serve a stale response while it's being revalidated.
+         *
+         * @default `"15 seconds"`
+         *
+         * @example
+         * ```js
+         * {
+         *   caching: {
+         *     staleWhileRevalidate: "30 seconds"
+         *   }
+         * }
+         * ```
+         */
+        staleWhileRevalidate?: Input<DurationHours>;
+      }
+  >;
+  /**
+   * Configure mTLS authentication when connecting to the origin database.
+   */
+  mtls?: Input<{
+    /**
+     * Define CA certificate ID obtained after uploading CA cert.
+     */
+    caCertificateId?: Input<string>;
+    /**
+     * Define mTLS certificate ID obtained after uploading client cert.
+     */
+    mtlsCertificateId?: Input<string>;
+    /**
+     * Set SSL mode to 'require', 'verify-ca', or 'verify-full' to verify the CA.
+     */
+    sslmode?: Input<string>;
+  }>;
+  /**
+   * The (soft) maximum number of connections the Hyperdrive is allowed to make to the origin database.
+   */
+  connectionLimit?: Input<number>;
+  /**
+   * The connection details for the origin database Hyperdrive connects to.
+   */
+  origin: Input<{
+    /**
+     * Defines the Client ID of the Access token to use when connecting to the origin database.
+     */
+    accessClientId?: Input<string>;
+    /**
+     * Defines the Client Secret of the Access Token to use when connecting to the origin database. The API never returns this write-only value.
+     */
+    accessClientSecret?: Input<string>;
+    /**
+     * Set the name of your origin database.
+     */
+    database: Input<string>;
+    /**
+     * Defines the host (hostname or IP) of your origin database.
+     */
+    host: Input<string>;
+    /**
+     * Set the password needed to access your origin database. The API never returns this write-only value.
+     */
+    password: Input<string>;
+    /**
+     * Defines the port of your origin database. Defaults to 5432 for PostgreSQL or 3306 for MySQL if not specified.
+     */
+    port?: Input<number>;
+    /**
+     * Specifies the URL scheme used to connect to your origin database.
+     */
+    scheme: Input<"postgres" | "mysql">;
+    /**
+     * Set the user of your origin database.
+     */
+    user: Input<string>;
+  }>;
+
+  /**
+   * The Cloudflare account ID to use for this Hyperdrive.
+   * 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 Hyperdrive config resource.
+     */
+    hyperdrive?: Transform<cloudflare.HyperdriveConfigArgs>;
+  };
+}
+
+/**
+ * The `Hyperdrive` component lets you add a [Cloudflare Hyperdrive](https://developers.cloudflare.com/hyperdrive/) to
+ * your app.
+ *
+ * Hyperdrive can connect Workers to PostgreSQL and MySQL databases.
+ * Set `origin.scheme` to `"postgres"` or `"mysql"`.
+ *
+ * @example
+ *
+ * #### PostgreSQL example
+ *
+ * ```ts title="sst.config.ts"
+ * const hyperdrive = new sst.cloudflare.Hyperdrive("PostgresDatabase", {
+ *   origin: {
+ *     database: "app",
+ *     host: "db.example.com",
+ *     password: "secret",
+ *     scheme: "postgres",
+ *     user: "postgres",
+ *   },
+ * })
+ * ```
+ *
+ * [Check out the PlanetScale](/docs/examples/#cloudflare-hyperdrive-planetscale)
+ * or the [AWS RDS Postgres](/docs/examples/#cloudflare-hyperdrive-with-aws-postgres) examples for a complete guide.
+ *
+ * #### MySQL example
+ *
+ * ```ts title="sst.config.ts"
+ * const hyperdrive = new sst.cloudflare.Hyperdrive("MySQLDatabase", {
+ *   origin: {
+ *     database: "app",
+ *     host: "db.example.com",
+ *     password: "secret",
+ *     scheme: "mysql",
+ *     user: "root",
+ *   },
+ * })
+ * ```
+ *
+ * #### Link to a worker
+ *
+ * You can link Hyperdrive to a worker.
+ *
+ * ```ts {3} title="sst.config.ts"
+ * new sst.cloudflare.Worker("MyWorker", {
+ *   handler: "./index.ts",
+ *   link: [hyperdrive],
+ *   url: true,
+ * })
+ * ```
+ *
+ * Once linked, you can use the SDK to access the Hyperdrive binding in your worker.
+ *
+ * ```ts title="index.ts" {4}
+ * import postgres from "postgres"
+ * import { Resource } from "sst/resource"
+ *
+ * const sql = postgres(Resource.PostgresDatabase.connectionString)
+ * ```
+ *
+ * It also works with MySQL:
+ *
+ * ```ts title="index.ts" {4}
+ * import mysql from "mysql2/promise"
+ * import { Resource } from "sst/resource"
+ *
+ * const db = await mysql.createConnection(Resource.MySQLDatabase.connectionString)
+ * ```
+ */
+export class Hyperdrive extends Component implements Link.Linkable {
+  private hyperdrive: cloudflare.HyperdriveConfig;
+
+  constructor(
+    name: string,
+    args: HyperdriveArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    if (args && "ref" in args) {
+      const ref = args as unknown as HyperdriveRef;
+      this.hyperdrive = ref.hyperdrive;
+      return;
+    }
+
+    const parent = this;
+
+    const origin = output(args.origin);
+    const caching = normalizeCaching();
+
+    this.hyperdrive = new cloudflare.HyperdriveConfig(
+      ...transform(
+        args.transform?.hyperdrive,
+        `${name}Hyperdrive`,
+        {
+          accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+          caching,
+          mtls: args.mtls,
+          name: "",
+          origin,
+          originConnectionLimit: args.connectionLimit,
+        },
+        { parent },
+      ),
+    );
+
+    function normalizeCaching() {
+      if (args.caching === undefined) return undefined;
+      return output(args.caching).apply((c) => {
+        if (c === false) return { disabled: true };
+        return {
+          maxAge: c.maxAge ? toSeconds(c.maxAge) : undefined,
+          staleWhileRevalidate: c.staleWhileRevalidate
+            ? toSeconds(c.staleWhileRevalidate)
+            : undefined,
+        };
+      });
+    }
+  }
+
+  /**
+   * When you link Hyperdrive to a worker, the Hyperdrive binding will be available in the
+   * worker and you can use its `connectionString` to connect with a PostgreSQL or MySQL client.
+   *
+   * @example
+   * ```ts title="index.ts" {3}
+   * import postgres from "postgres"
+   * import { Resource } from "sst"
+   *
+   * const sql = postgres(Resource.PostgresDatabase.connectionString)
+   * ```
+   *
+   * For MySQL:
+   *
+   * ```ts title="index.ts" {3}
+   * import mysql from "mysql2/promise"
+   * import { Resource } from "sst"
+   *
+   * const db = await mysql.createConnection(Resource.MySQLDatabase.connectionString)
+   * ```
+   *
+   * @internal
+   */
+  public getSSTLink() {
+    return {
+      properties: {
+        id: this.id,
+      },
+      include: [
+        binding({
+          type: "hyperdriveBindings",
+          properties: {
+            id: this.id,
+          },
+        }),
+      ],
+    };
+  }
+
+  /**
+   * The generated ID of the Hyperdrive config.
+   */
+  public get id() {
+    // Pulumi returns "accountId/hyperdriveId" for imported resources.
+    return this.hyperdrive.id.apply((id) =>
+      id.includes("/") ? id.split("/")[1] : id,
+    );
+  }
+
+  /**
+   * The generated name of the Hyperdrive config.
+   */
+  public get name() {
+    return this.hyperdrive.name;
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The Cloudflare Hyperdrive config.
+       */
+      hyperdrive: this.hyperdrive,
+    };
+  }
+
+  /**
+   * Reference an existing Hyperdrive config with the given ID. This is useful when you
+   * create a Hyperdrive config in one stage and want to share it in another.
+   *
+   * :::tip
+   * You can use the `static get` method to share Hyperdrive configs across stages.
+   * :::
+   *
+   * @param name The name of the component.
+   * @param args The arguments to get the Hyperdrive config.
+   * @param opts Resource options.
+   *
+   * @example
+   * Imagine you create a Hyperdrive config in the `dev` stage. And in your personal stage
+   * `frank`, instead of creating a new one, you want to share the same one from `dev`.
+   *
+   * ```ts title="sst.config.ts"
+   * const hyperdrive = $app.stage === "frank"
+   *   ? sst.cloudflare.Hyperdrive.get("MyDatabase", {
+   *       hyperdriveId: "a1b2c3d4e5f6",
+   *     })
+   *   : new sst.cloudflare.Hyperdrive("MyDatabase", { ... });
+   * ```
+   */
+  public static get(
+    name: string,
+    args: HyperdriveGetArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    const hyperdrive = cloudflare.HyperdriveConfig.get(
+      `${name}Hyperdrive`,
+      `${args.accountId ?? DEFAULT_ACCOUNT_ID}/${args.hyperdriveId}`,
+      undefined,
+      opts,
+    );
+    return new Hyperdrive(
+      name,
+      {
+        ref: true,
+        hyperdrive,
+      } as unknown as HyperdriveArgs,
+      opts,
+    );
+  }
+}
+
+const __pulumiType = "sst:cloudflare:Hyperdrive";
+// @ts-expect-error
+Hyperdrive.__pulumiType = __pulumiType;

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

@@ -0,0 +1,25 @@
+export * from "./bucket";
+export * from "./kv";
+export * from "./d1";
+export * from "./dns";
+export * from "./durable-object";
+export * from "./static-site";
+export * from "./static-site-v2";
+export * from "./worker";
+export * from "./account-id";
+export * from "./auth";
+export * from "./queue";
+export * from "./cron";
+export * from "./ai";
+export * from "./hyperdrive";
+export * from "./astro";
+export * from "./react-router";
+export * from "./tan-stack-start";
+export * from "./workflow";
+export * from "./rate-limit";
+export { binding } from "./binding.js";
+
+/**
+ * experimental packages, you may be fired for using
+ */
+export * as x from "./experimental/index";