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

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

@@ -0,0 +1,218 @@
+import { ComponentResourceOptions } 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 type { Input } from "../input";
+
+export interface KvArgs {
+  /**
+   * The Cloudflare account ID to use for this KV namespace.
+   * 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 KV namespace resource.
+     */
+    namespace?: Transform<cloudflare.WorkersKvNamespaceArgs>;
+  };
+}
+
+export interface KvGetArgs {
+  /**
+   * The ID of the existing KV namespace.
+   */
+  namespaceId: string;
+  /**
+   * The Cloudflare account ID the namespace belongs to.
+   * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+   * @internal
+  */
+  accountId?: string;
+}
+
+interface KvRef {
+  ref: true;
+  namespace: cloudflare.WorkersKvNamespace;
+}
+
+/**
+ * The `Kv` component lets you add a [Cloudflare KV storage namespace](https://developers.cloudflare.com/kv/) to
+ * your app.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * ```ts title="sst.config.ts"
+ * const storage = new sst.cloudflare.Kv("MyStorage");
+ * ```
+ *
+ * #### Link to a worker
+ *
+ * You can link KV to a worker.
+ *
+ * ```ts {3} title="sst.config.ts"
+ * new sst.cloudflare.Worker("MyWorker", {
+ *   handler: "./index.ts",
+ *   link: [storage],
+ *   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.MyStorage.get("someKey");
+ * ```
+ */
+export class Kv extends Component implements Link.Linkable {
+  private namespace: cloudflare.WorkersKvNamespace;
+
+  constructor(name: string, args?: KvArgs, opts?: ComponentResourceOptions) {
+    super(__pulumiType, name, args, opts);
+
+    const parent = this;
+
+    if (args && "ref" in args) {
+      const ref = args as unknown as KvRef;
+      this.namespace = ref.namespace;
+      return;
+    }
+
+    const namespace = createNamespace();
+
+    this.namespace = namespace;
+
+    function createNamespace() {
+      return new cloudflare.WorkersKvNamespace(
+        ...transform(
+          args?.transform?.namespace,
+          `${name}Namespace`,
+          {
+            title: "",
+            accountId: args?.accountId ?? DEFAULT_ACCOUNT_ID,
+          },
+          { parent },
+        ),
+      );
+    }
+  }
+
+  /**
+   * Reference an existing KV namespace with the given name. This is useful when you
+   * create a KV namespace in one stage and want to share it in another.
+   *
+   * :::tip
+   * You can use the `static get` method to share KV namespaces across stages.
+   * :::
+   *
+   * @param name The name of the component.
+   * @param args The arguments to get the KV namespace.
+   * @param opts Resource options.
+   *
+   * @example
+   * Imagine you create a KV namespace in the `dev` stage. And in your personal stage `frank`,
+   * instead of creating a new namespace, you want to share the same one from `dev`.
+   *
+   * ```ts title="sst.config.ts"
+   * const storage = $app.stage === "frank"
+   *   ? sst.cloudflare.Kv.get("MyStorage", {
+   *       namespaceId: "a1b2c3d4e5f6",
+   *     })
+   *   : new sst.cloudflare.Kv("MyStorage");
+   * ```
+   */
+  public static get(
+    name: string,
+    args: KvGetArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    const namespace = cloudflare.WorkersKvNamespace.get(
+      `${name}Namespace`,
+      `${args.accountId ?? DEFAULT_ACCOUNT_ID}/${args.namespaceId}`,
+      undefined,
+      opts,
+    );
+    return new Kv(
+      name,
+      {
+        ref: true,
+        namespace,
+      } as unknown as KvArgs,
+      opts,
+    );
+  }
+
+  /**
+   * When you link a KV storage, the storage will be available to the worker and you can
+   * interact with it using its [API methods](https://developers.cloudflare.com/kv/api/).
+   *
+   * @example
+   * ```ts title="index.ts" {3}
+   * import { Resource } from "sst";
+   *
+   * await Resource.MyStorage.get("someKey");
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        namespaceId: this.namespaceId,
+      },
+      include: [
+        binding({
+          type: "kvNamespaceBindings",
+          properties: {
+            namespaceId: this.namespaceId,
+          },
+        }),
+      ],
+    };
+  }
+
+  /**
+   * The generated ID of the KV namespace.
+   * @deprecated Use `namespaceId` instead.
+   */
+  public get id() {
+    return this.namespaceId;
+  }
+
+  /**
+   * The generated ID of the KV namespace.
+   */
+  public get namespaceId() {
+    // Pulumi returns "accountId/namespaceId" for imported namespaces
+    return this.namespace.id.apply((id) =>
+      id.includes("/") ? id.split("/")[1] : id,
+    );
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The Cloudflare KV namespace.
+       */
+      namespace: this.namespace,
+    };
+  }
+}
+
+const __pulumiType = "sst:cloudflare:Kv";
+// @ts-expect-error
+Kv.__pulumiType = __pulumiType;

package/platform/src/components/cloudflare/providers/dns-record.ts

@@ -0,0 +1,43 @@
+import { CustomResourceOptions, Input, Output, dynamic } from "@pulumi/pulumi";
+import { rpc } from "../../rpc/rpc.js";
+import { DEFAULT_ACCOUNT_ID } from "../account-id";
+
+export interface DnsRecordInputs {
+  zoneId: Input<string>;
+  type: Input<string>;
+  name: Input<string>;
+  value?: Input<string>;
+  data?: Input<{
+    flags: Input<string>;
+    tag: Input<string>;
+    value: Input<string>;
+  }>;
+  proxied?: Input<boolean>;
+  accountId?: Input<string>;
+}
+
+export interface DnsRecord {
+  recordId: Output<string>;
+}
+
+export class DnsRecord extends dynamic.Resource {
+  constructor(
+    name: string,
+    args: DnsRecordInputs,
+    opts?: CustomResourceOptions,
+  ) {
+    super(
+      new rpc.Provider("Cloudflare.DnsRecord"),
+      `${name}.sst.cloudflare.DnsRecord`,
+      {
+        ...args,
+        recordId: undefined,
+        accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+        apiToken:
+          $app.providers?.cloudflare?.apiToken ||
+          process.env.CLOUDFLARE_API_TOKEN!,
+      },
+      opts,
+    );
+  }
+}

package/platform/src/components/cloudflare/providers/kv-data.ts

@@ -0,0 +1,107 @@
+import fs from "fs";
+import { CustomResourceOptions, Input, dynamic } from "@pulumi/pulumi";
+import { cfFetch } from "../helpers/fetch.js";
+
+interface KvDataEntry {
+  source: string;
+  key: string;
+  hash: string;
+  contentType: string;
+  cacheControl?: string;
+}
+
+export interface KvDataInputs {
+  accountId: Input<Inputs["accountId"]>;
+  namespaceId: Input<Inputs["namespaceId"]>;
+  entries: Input<Inputs["entries"]>;
+}
+
+interface Inputs {
+  accountId: string;
+  namespaceId: string;
+  entries: KvDataEntry[];
+}
+
+class Provider implements dynamic.ResourceProvider {
+  async create(inputs: Inputs): Promise<dynamic.CreateResult> {
+    await this.upload(inputs.accountId, inputs.namespaceId, inputs.entries, []);
+    return { id: "data" };
+  }
+
+  async update(
+    id: string,
+    olds: Inputs,
+    news: Inputs,
+  ): Promise<dynamic.UpdateResult> {
+    await this.upload(
+      news.accountId,
+      news.namespaceId,
+      news.entries,
+      news.namespaceId === olds.namespaceId ? olds.entries : [],
+    );
+    return {};
+  }
+
+  async upload(
+    accountId: string,
+    namespaceId: string,
+    entries: KvDataEntry[],
+    oldEntries: KvDataEntry[],
+  ) {
+    const oldFilesMap = new Map(oldEntries.map((f) => [f.key, f]));
+
+    const changedEntries = entries.filter((entry) => {
+      const old = oldFilesMap.get(entry.key);
+      return (
+        old?.hash !== entry.hash ||
+        old?.contentType !== entry.contentType ||
+        old?.cacheControl !== entry.cacheControl
+      );
+    });
+
+    // Split into HTML and non-HTML to upload non-HTML first.
+    // This avoids a race condition where the CDN serves new HTML
+    // referencing assets that haven't been uploaded yet.
+    const htmlEntries = changedEntries.filter((e) => e.key.endsWith(".html"));
+    const nonHtmlEntries = changedEntries.filter(
+      (e) => !e.key.endsWith(".html"),
+    );
+
+    const uploadEntry = async (entry: KvDataEntry) => {
+      const formData = new FormData();
+      formData.append(
+        "metadata",
+        JSON.stringify({
+          contentType: entry.contentType,
+          cacheControl: entry.cacheControl,
+        }),
+      );
+      //formData.append("value", fs.createReadStream(entry.source));
+      formData.append(
+        "value",
+        await fs.promises.readFile(entry.source, "base64"),
+      );
+      try {
+        await cfFetch(
+          `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${entry.key}`,
+          {
+            method: "PUT",
+            body: formData,
+          },
+        );
+      } catch (error: any) {
+        console.log(error);
+        throw error;
+      }
+    };
+
+    await Promise.all(nonHtmlEntries.map(uploadEntry));
+    await Promise.all(htmlEntries.map(uploadEntry));
+  }
+}
+
+export class KvData extends dynamic.Resource {
+  constructor(name: string, args: KvDataInputs, opts?: CustomResourceOptions) {
+    super(new Provider(), `${name}.sst.cloudflare.KvPairs`, args, opts);
+  }
+}

package/platform/src/components/cloudflare/providers/worker-assets.ts

@@ -0,0 +1,41 @@
+import { CustomResourceOptions, Input, Output, dynamic } from "@pulumi/pulumi";
+import { rpc } from "../../rpc/rpc.js";
+import { DEFAULT_ACCOUNT_ID } from "../account-id";
+
+export interface WorkerAssetsInputs {
+  directory: Input<string>;
+  scriptName: Input<string>;
+  manifest: Input<
+    Record<string, { hash: string; size: number; contentType: string }>
+  >;
+  accountId?: Input<string>;
+}
+
+export interface WorkerAssets {
+  jwt: Output<string>;
+  scriptName: Output<string>;
+}
+
+export class WorkerAssets extends dynamic.Resource {
+  constructor(
+    name: string,
+    args: WorkerAssetsInputs,
+    opts?: CustomResourceOptions,
+  ) {
+    super(
+      new rpc.Provider("Cloudflare.WorkerAssets"),
+      `${name}.sst.cloudflare.WorkerAssets`,
+      {
+        ...args,
+        jwt: undefined,
+        accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+        apiToken:
+          $app.providers?.cloudflare?.apiToken ||
+          process.env.CLOUDFLARE_API_TOKEN!,
+        // always trigger an update b/c a new completion token is required
+        timestamp: Date.now(),
+      },
+      opts,
+    );
+  }
+}

package/platform/src/components/cloudflare/providers/worker-placement.ts

@@ -0,0 +1,93 @@
+import { CustomResourceOptions, Input, Output, dynamic } from "@pulumi/pulumi";
+import { cfFetch } from "../helpers/fetch.js";
+import { DEFAULT_ACCOUNT_ID } from "../account-id.js";
+
+interface Inputs {
+  accountId: string;
+  scriptName: string;
+  etag?: string;
+  mode?: string;
+  region?: string;
+  host?: string;
+  hostname?: string;
+}
+
+export interface WorkerPlacementInputs {
+  accountId?: Input<Inputs["accountId"]>;
+  scriptName: Input<Inputs["scriptName"]>;
+  etag?: Input<Inputs["etag"]>;
+  mode?: Input<Inputs["mode"]>;
+  region?: Input<Inputs["region"]>;
+  host?: Input<Inputs["host"]>;
+  hostname?: Input<Inputs["hostname"]>;
+}
+
+export interface WorkerPlacement {
+  scriptName: Output<string>;
+}
+
+function buildPlacement(inputs: Inputs) {
+  if (inputs.mode) return { mode: inputs.mode };
+  if (inputs.region) return { region: inputs.region };
+  if (inputs.host) return { host: inputs.host };
+  if (inputs.hostname) return { hostname: inputs.hostname };
+  return {};
+}
+
+class Provider implements dynamic.ResourceProvider {
+  async create(inputs: Inputs): Promise<dynamic.CreateResult> {
+    await this.patch(inputs, buildPlacement(inputs));
+    return {
+      id: inputs.scriptName,
+      outs: { scriptName: inputs.scriptName },
+    };
+  }
+
+  async update(
+    id: string,
+    olds: Inputs,
+    news: Inputs,
+  ): Promise<dynamic.UpdateResult> {
+    await this.patch(news, buildPlacement(news));
+    return {
+      outs: { scriptName: news.scriptName },
+    };
+  }
+
+  async delete(id: string, inputs: Inputs) {
+    await this.patch(inputs, {});
+  }
+
+  async patch(inputs: Inputs, placement: Partial<Record<string, string>>) {
+    const accountId = inputs.accountId || DEFAULT_ACCOUNT_ID;
+    const formData = new FormData();
+    formData.append(
+      "settings",
+      new Blob([JSON.stringify({ placement })], {
+        type: "application/json",
+      }),
+    );
+    await cfFetch(
+      `/accounts/${accountId}/workers/scripts/${inputs.scriptName}/settings`,
+      {
+        method: "PATCH",
+        body: formData,
+      },
+    );
+  }
+}
+
+export class WorkerPlacement extends dynamic.Resource {
+  constructor(
+    name: string,
+    args: WorkerPlacementInputs,
+    opts?: CustomResourceOptions,
+  ) {
+    super(
+      new Provider(),
+      `${name}.sst.cloudflare.WorkerPlacement`,
+      { ...args, scriptName: args.scriptName },
+      opts,
+    );
+  }
+}

package/platform/src/components/cloudflare/providers/worker-script.ts

@@ -0,0 +1,47 @@
+/**
+ * @deprecated This component was meant to be used instead of WorkersScript to handle
+ * large file content. This was because WorkersScript used to serialize the content
+ * into the state, causing the state to grow very large. Cloudflare provider has
+ * since been updated to use the new `contentFile` and `contentSha256` properties
+ * to handle large file content.
+ */
+import { CustomResourceOptions, Output, dynamic } from "@pulumi/pulumi";
+import { rpc } from "../../rpc/rpc.js";
+import { DEFAULT_ACCOUNT_ID } from "../account-id.js";
+import { WorkersScriptArgs } from "@pulumi/cloudflare";
+import { Input } from "../../input.js";
+
+export interface WorkerScriptInputs extends Omit<WorkersScriptArgs, "content"> {
+  content: Input<{
+    filename: Input<string>;
+    hash: Input<string>;
+  }>;
+}
+
+export interface WorkerScript {
+  scriptName: Output<string>;
+}
+
+export class WorkerScript extends dynamic.Resource {
+  constructor(
+    name: string,
+    args: WorkerScriptInputs,
+    opts?: CustomResourceOptions,
+  ) {
+    super(
+      new rpc.Provider("Cloudflare.WorkerScript"),
+      `${name}.sst.cloudflare.WorkerScript`,
+      {
+        ...args,
+        accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+        apiToken:
+          $app.providers?.cloudflare?.apiToken ||
+          process.env.CLOUDFLARE_API_TOKEN!,
+      },
+      {
+        ...opts,
+        replaceOnChanges: ["scriptName"],
+      },
+    );
+  }
+}

package/platform/src/components/cloudflare/providers/worker-url.ts

@@ -0,0 +1,109 @@
+import { CustomResourceOptions, Input, Output, dynamic } from "@pulumi/pulumi";
+import { cfFetch } from "../helpers/fetch.js";
+
+interface Inputs {
+  accountId: string;
+  scriptName: string;
+  enabled: boolean;
+  etag?: string;
+}
+
+interface Outputs {
+  url: string | undefined;
+}
+
+export interface WorkerUrlInputs {
+  accountId: Input<Inputs["accountId"]>;
+  scriptName: Input<Inputs["scriptName"]>;
+  enabled: Input<Inputs["enabled"]>;
+  etag?: Input<Inputs["etag"]>;
+}
+
+export interface WorkerUrl {
+  url: Output<Outputs["url"]>;
+}
+
+class Provider implements dynamic.ResourceProvider {
+  async create(inputs: Inputs): Promise<dynamic.CreateResult> {
+    const url = await this.process(inputs);
+    return {
+      id: inputs.scriptName,
+      outs: url ? { url } : {},
+    };
+  }
+
+  async update(
+    id: string,
+    olds: Inputs,
+    news: Inputs,
+  ): Promise<dynamic.UpdateResult> {
+    const url = await this.process(news);
+    return {
+      outs: url ? { url } : {},
+    };
+  }
+
+  async process(inputs: Inputs) {
+    if (inputs.enabled === false) {
+      await this.setEnabledFlag(inputs);
+      return undefined;
+    }
+
+    const [userSubdomain] = await Promise.all([
+      this.getWorkerDevSubdomain(inputs),
+      this.setEnabledFlag(inputs),
+    ]);
+    return `${inputs.scriptName}.${userSubdomain}.workers.dev`;
+  }
+
+  async getWorkerDevSubdomain(inputs: Inputs) {
+    try {
+      const ret = await cfFetch<{ subdomain: string }>(
+        `/accounts/${inputs.accountId}/workers/subdomain`,
+        {
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+      return ret.result.subdomain;
+    } catch (error: any) {
+      console.log(error);
+      throw error;
+    }
+  }
+
+  async setEnabledFlag(inputs: Inputs) {
+    try {
+      await cfFetch(
+        `/accounts/${inputs.accountId}/workers/scripts/${inputs.scriptName}/subdomain`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ enabled: inputs.enabled }),
+        },
+      );
+      // Add a delay when the subdomain is first created.
+      // This is to prevent an issue where a negative cache-hit
+      // causes the subdomain to be unavailable for 30 seconds.
+      // This is a temporary measure until we fix this on the edge.
+      await new Promise((resolve) => setTimeout(resolve, 3000));
+    } catch (error: any) {
+      console.log(error);
+      throw error;
+    }
+  }
+}
+
+export class WorkerUrl extends dynamic.Resource {
+  constructor(
+    name: string,
+    args: WorkerUrlInputs,
+    opts?: CustomResourceOptions,
+  ) {
+    super(
+      new Provider(),
+      `${name}.sst.cloudflare.WorkerUrl`,
+      { ...args, url: undefined },
+      opts,
+    );
+  }
+}