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

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

@@ -0,0 +1,207 @@
+import { all, ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import * as cf from "@pulumi/cloudflare";
+import * as cloudflare from "@pulumi/cloudflare";
+import { Component, Transform, transform } from "../component";
+import { WorkerArgs } from "./worker";
+import { DEFAULT_ACCOUNT_ID } from "./account-id.js";
+import { Input } from "../input.js";
+import { WorkerBuilder, workerBuilder } from "./helpers/worker-builder";
+import { VisibleError } from "../error";
+
+export interface CronArgs {
+  /**
+   * The worker that'll be executed when the cron job runs.
+   * @deprecated Use `worker` instead.
+   *
+   * @example
+   *
+   * ```ts
+   * {
+   *   job: "src/cron.ts"
+   * }
+   * ```
+   *
+   * You can pass in the full worker props.
+   *
+   * ```ts
+   * {
+   *   job: {
+   *     handler: "src/cron.ts",
+   *     link: [bucket]
+   *   }
+   * }
+   * ```
+   */
+  job?: Input<string | WorkerArgs>;
+  /**
+   * The worker that'll be executed when the cron job runs.
+   *
+   * @example
+   *
+   * ```ts
+   * {
+   *   worker: "src/cron.ts"
+   * }
+   * ```
+   *
+   * You can pass in the full worker props.
+   *
+   * ```ts
+   * {
+   *   worker: {
+   *     handler: "src/cron.ts",
+   *     link: [bucket]
+   *   }
+   * }
+   * ```
+   */
+  worker?: Input<string | WorkerArgs>;
+  /**
+   * The schedule for the cron job.
+   *
+   * :::note
+   * The cron job continues to run even after you exit `sst dev`.
+   * :::
+   *
+   * @example
+   *
+   * You can use a [cron expression](https://developers.cloudflare.com/workers/configuration/cron-triggers/#supported-cron-expressions).
+   *
+   * ```ts
+   * {
+   *   schedules: ["* * * * *"]
+   *   // schedules: ["*\/30 * * * *"]
+   *   // schedules: ["45 * * * *"]
+   *   // schedules: ["0 17 * * sun"]
+   *   // schedules: ["10 7 * * mon-fri"]
+   *   // schedules: ["0 15 1 * *"]
+   *   // schedules: ["59 23 LW * *"]
+   * }
+   * ```
+   */
+  schedules: Input<string[]>;
+  /**
+   * The Cloudflare account ID to use for this Cron and its worker.
+   * 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 Worker Cron Trigger resource.
+     */
+    trigger?: Transform<cloudflare.WorkerCronTriggerArgs>;
+  };
+}
+
+/**
+ * The `Cron` component lets you add cron jobs to your app using Cloudflare.
+ * It uses [Cloudflare Cron Triggers](https://developers.cloudflare.com/workers/configuration/cron-triggers/).
+ *
+ * @example
+ * #### Minimal example
+ *
+ * Create a worker file that exposes a `scheduled` handler:
+ *
+ * ```ts title="cron.ts"
+ * export default {
+ *   async scheduled() {
+ *     console.log("Running on a schedule");
+ *   },
+ * };
+ * ```
+ *
+ * Pass in a `schedules` and a `worker` that'll be executed.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.cloudflare.Cron("MyCronJob", {
+ *   worker: "cron.ts",
+ *   schedules: ["* * * * *"]
+ * });
+ * ```
+ *
+ * #### Customize the worker
+ *
+ * ```js title="sst.config.ts"
+ * new sst.cloudflare.Cron("MyCronJob", {
+ *   schedules: ["* * * * *"],
+ *   worker: {
+ *     handler: "cron.ts",
+ *     link: [bucket]
+ *   }
+ * });
+ * ```
+ */
+export class Cron extends Component {
+  private worker: WorkerBuilder;
+  private trigger: Output<cf.WorkerCronTrigger>;
+
+  constructor(name: string, args: CronArgs, opts?: ComponentResourceOptions) {
+    super(__pulumiType, name, args, opts);
+
+    const parent = this;
+
+    const workerArgs = normalizeWorker();
+    const worker = createWorker();
+    const trigger = createTrigger();
+    this.worker = worker;
+    this.trigger = trigger;
+
+    function normalizeWorker() {
+      if (args.job && args.worker)
+        throw new VisibleError(
+          `You cannot provide both "job" and "worker" in the "${name}" Cron component. The "job" property has been deprecated. Use "worker" instead.`,
+        );
+      return args.worker ?? args.job;
+    }
+
+    function createWorker() {
+      if (!workerArgs)
+        throw new VisibleError(
+          `You must provide a "worker" for the "${name}" Cron component.`,
+        );
+      return workerBuilder(`${name}Handler`, workerArgs, undefined, undefined, args.accountId);
+    }
+
+    function createTrigger() {
+      return all([args.schedules]).apply(([schedules]) => {
+        return new cloudflare.WorkersCronTrigger(
+          ...transform(
+            args.transform?.trigger,
+            `${name}Trigger`,
+            {
+              accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+              scriptName: worker.script.scriptName,
+              schedules: schedules.map((s) => ({ cron: s })),
+            },
+            { parent },
+          ),
+        );
+      });
+    }
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The Cloudflare Worker.
+       */
+      worker: this.worker.script,
+      /**
+       * The Cloudflare Worker Cron Trigger.
+       */
+      trigger: this.trigger,
+    };
+  }
+}
+
+const __pulumiType = "sst:cloudflare:Cron";
+// @ts-expect-error
+Cron.__pulumiType = __pulumiType;

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

@@ -0,0 +1,230 @@
+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 ".";
+import type { Input } from "../input";
+
+export interface D1Args {
+  /**
+   * The Cloudflare account ID to use for this D1 database.
+   * 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 D1 resource.
+     */
+    database?: Transform<cloudflare.D1DatabaseArgs>;
+  };
+}
+
+interface D1Ref {
+  ref: boolean;
+  database: cloudflare.D1Database;
+}
+
+/**
+ * The `D1` component lets you add a [Cloudflare D1 database](https://developers.cloudflare.com/d1/) to
+ * your app.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * ```ts title="sst.config.ts"
+ * const db = new sst.cloudflare.D1("MyDatabase");
+ * ```
+ *
+ * #### Link to a worker
+ *
+ * You can link the db to a worker.
+ *
+ * ```ts {3} title="sst.config.ts"
+ * new sst.cloudflare.Worker("MyWorker", {
+ *   handler: "./index.ts",
+ *   link: [db],
+ *   url: true
+ * });
+ * ```
+ *
+ * Once linked, you can use the SDK to interact with the db.
+ *
+ * ```ts title="index.ts" {1} "Resource.MyDatabase.prepare"
+ * import { Resource } from "sst";
+ *
+ * await Resource.MyDatabase.prepare(
+ *   "SELECT id FROM todo ORDER BY id DESC LIMIT 1",
+ * ).first();
+ * ```
+ */
+export class D1 extends Component implements Link.Linkable {
+  private database: cloudflare.D1Database;
+
+  constructor(name: string, args?: D1Args, opts?: ComponentResourceOptions) {
+    super(__pulumiType, name, args, opts);
+
+    if (args && "ref" in args) {
+      const ref = args as D1Ref;
+      this.database = ref.database;
+      return;
+    }
+
+    const parent = this;
+    const db = createDB();
+
+    this.database = db;
+
+    function createDB() {
+      return new cloudflare.D1Database(
+        ...transform(
+          args?.transform?.database,
+          `${name}Database`,
+          {
+            name: "",
+            accountId: args?.accountId ?? DEFAULT_ACCOUNT_ID,
+          },
+          { parent },
+        ),
+      );
+    }
+  }
+
+  /**
+   * When you link a D1 database, the database will be available to the worker and you can
+   * query it using its [API methods](https://developers.cloudflare.com/d1/build-with-d1/d1-client-api/).
+   *
+   * @example
+   * ```ts title="index.ts" {1} "Resource.MyDatabase.prepare"
+   * import { Resource } from "sst";
+   *
+   * await Resource.MyDatabase.prepare(
+   *   "SELECT id FROM todo ORDER BY id DESC LIMIT 1",
+   * ).first();
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        databaseId: this.databaseId,
+      },
+      include: [
+        binding({
+          type: "d1DatabaseBindings",
+          properties: {
+            id: this.databaseId,
+          },
+        }),
+      ],
+    };
+  }
+
+  /**
+   * The generated ID of the D1 database.
+   */
+  public get databaseId() {
+    // Pulumi returns "accountId/databaseId" for imported databases
+    return this.database.id.apply((id) =>
+      id.includes("/") ? id.split("/")[1] : id,
+    );
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The Cloudflare D1 database.
+       */
+      database: this.database,
+    };
+  }
+
+  /**
+   * Reference an existing D1 Database with the given database ID. This is
+   * useful when you create a D1 in one stage and want to share it in another.
+   * It avoids having to create a new D1 Database in the other stage.
+   *
+   * :::tip
+   * You can use the `static get` method to share D1 Databases across stages.
+   * :::
+   *
+   * @param name The name of the component.
+   * @param args The database ID and optional account ID of the existing D1 Database.
+   *
+   * @example
+   * Imagine you create a D1 Database in the `dev` stage. And in your personal
+   * stage `giorgio`, instead of creating a new database, you want to share the
+   * same database from `dev`.
+   *
+   * ```ts title="sst.config.ts"
+   * const d1 = $app.stage === "giorgio"
+   *   ? sst.cloudflare.D1.get("MyD1", { databaseId: "my-database-id" })
+   *   : new sst.cloudflare.D1("MyD1");
+   * ```
+   *
+   * Here `my-database-id` is the ID of the D1 Database created in the `dev`
+   * stage. You can find it by outputting the D1 Database in the `dev` stage.
+   *
+   * ```ts title="sst.config.ts"
+   * return {
+   *   d1
+   * };
+   * ```
+   */
+  public static get(
+    name: string,
+    args: { databaseId: string; accountId?: string },
+    opts?: ComponentResourceOptions,
+  ): D1;
+  /**
+   * @deprecated Use the object-based `args` signature instead: `get(name, { databaseId }, opts)`.
+   */
+  public static get(
+    name: string,
+    databaseId: string,
+    opts?: ComponentResourceOptions,
+  ): D1;
+
+  public static get(
+    name: string,
+    argsOrDatabaseId: { databaseId: string; accountId?: string } | string,
+    opts?: ComponentResourceOptions,
+  ) {
+    if (typeof argsOrDatabaseId === "string") {
+    const database = cloudflare.D1Database.get(
+      `${name}Database`,
+      `${DEFAULT_ACCOUNT_ID}/${argsOrDatabaseId}`,
+      undefined,
+      opts,
+    );
+    return new D1(name, {
+      ref: true,
+      database,
+    } as D1Args);
+    }
+    const database = cloudflare.D1Database.get(
+      `${name}Database`,
+      `${argsOrDatabaseId.accountId ?? DEFAULT_ACCOUNT_ID}/${argsOrDatabaseId.databaseId}`,
+      undefined,
+      opts,
+    );
+    return new D1(name, {
+      ref: true,
+      database,
+    } as D1Args);
+  }
+}
+
+const __pulumiType = "sst:cloudflare:D1";
+// @ts-expect-error
+D1.__pulumiType = __pulumiType;

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

@@ -0,0 +1,253 @@
+/**
+ * The Cloudflare DNS Adapter is used to create DNS records to manage domains hosted on
+ * [Cloudflare DNS](https://developers.cloudflare.com/dns/).
+ *
+ * :::note
+ * You need to [add the Cloudflare provider](/docs/providers/#install) to use this adapter.
+ * :::
+ *
+ * This needs the Cloudflare provider. To add it run:
+ *
+ * ```bash
+ * sst add cloudflare
+ * ```
+ *
+ * This adapter is passed in as `domain.dns` when setting a custom domain, where `example.com`
+ * is hosted on Cloudflare.
+ *
+ * ```ts
+ * {
+ *   domain: {
+ *     name: "example.com",
+ *     dns: sst.cloudflare.dns()
+ *   }
+ * }
+ * ```
+ *
+ * Specify the zone ID.
+ *
+ * ```ts
+ * {
+ *   domain: {
+ *     name: "example.com",
+ *     dns: sst.cloudflare.dns({
+ *       zone: "415e6f4653b6d95b775d350f32119abb"
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+import * as cloudflare from "@pulumi/cloudflare";
+import { AliasRecord, Dns, Record } from "../dns";
+import { logicalName } from "../naming";
+import { ZoneLookup } from "./providers/zone-lookup";
+import { ComponentResourceOptions, output } from "@pulumi/pulumi";
+import { Transform, transform } from "../component";
+import { Input } from "../input";
+import { DEFAULT_ACCOUNT_ID } from "./account-id";
+import { DnsRecord as OverridableDnsRecord } from "./providers/dns-record";
+
+export interface DnsArgs {
+  /**
+   * The ID of the Cloudflare zone to create the record in.
+   *
+   * @example
+   * ```js
+   * {
+   *   zone: "415e6f4653b6d95b775d350f32119abb"
+   * }
+   * ```
+   */
+  zone?: Input<string>;
+  /**
+   * The Cloudflare account ID to use for zone lookups.
+   * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+   * @internal
+   */
+  accountId?: Input<string>;
+  /**
+   * Configure ALIAS DNS records as [proxy records](https://developers.cloudflare.com/learning-paths/get-started-free/onboarding/proxy-dns-records/).
+   *
+   * :::tip
+   * Proxied records help prevent DDoS attacks and allow you to use Cloudflare's global
+   * content delivery network (CDN) for caching.
+   * :::
+   *
+   * @default `false`
+   * @example
+   * ```js
+   * {
+   *   proxy: true
+   * }
+   * ```
+   */
+  proxy?: Input<boolean>;
+  /**
+   * [Transform](/docs/components#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the Cloudflare record resource.
+     */
+    record?: Transform<cloudflare.RecordArgs>;
+  };
+}
+
+export function dns(args: DnsArgs = {}) {
+  return {
+    provider: "cloudflare",
+    createAlias,
+    createCaa,
+    createRecord,
+  } satisfies Dns;
+
+  function lookupZone(
+    namePrefix: string,
+    recordType: string,
+    recordName: string,
+    opts: ComponentResourceOptions,
+  ) {
+    if (args.zone) {
+      const zone = cloudflare.getZoneOutput({
+        zoneId: args.zone,
+      });
+      return {
+        id: output(args.zone),
+        name: zone.name,
+      };
+    }
+
+    const zone = new ZoneLookup(
+      `${namePrefix}${recordType}${recordName}ZoneLookup`,
+      {
+        accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+        domain: recordName.replace(/\.$/, ""),
+      },
+      opts,
+    );
+
+    return {
+      id: zone.zoneId,
+      name: zone.zoneName,
+    };
+  }
+
+  function createAlias(
+    namePrefix: string,
+    record: AliasRecord,
+    opts: ComponentResourceOptions,
+  ) {
+    return handleCreate(
+      namePrefix,
+      {
+        name: record.name,
+        type: "CNAME",
+        value: record.aliasName,
+        isAlias: true,
+      },
+      opts,
+    );
+  }
+
+  function createCaa(
+    namePrefix: string,
+    recordName: string,
+    opts: ComponentResourceOptions,
+  ) {
+    const zone = lookupZone(namePrefix, "CAA", recordName, opts);
+
+    // Need to use the OverridableDnsRecord instead of the cloudflare.Record because
+    // "allowOverride" does not work properly. When CAA records exist, the Terraform
+    // provider will do a look up on existing records and only ignore the error if
+    // there is exactly one match. But in our cases, there are two matches:
+    // 1. CAA 0 issue "amazonaws.com"
+    // 2. CAA 0 issuewild "amazonaws.com"
+    // There can also be others ie. CAA 0 issue "letsencrypt.org"
+    // So we need to use the OverridableDnsRecord to properly ignore existing records.
+    return [
+      new OverridableDnsRecord(
+        `${namePrefix}CAA${recordName}Record`,
+        {
+          zoneId: zone.id,
+          type: "CAA",
+          name: zone.name,
+          accountId: args.accountId,
+          data: {
+            flags: "0",
+            tag: "issue",
+            value: "amazonaws.com",
+          },
+        },
+        opts,
+      ),
+      new OverridableDnsRecord(
+        `${namePrefix}CAAWildcard${recordName}Record`,
+        {
+          zoneId: zone.id,
+          type: "CAA",
+          name: zone.name,
+          accountId: args.accountId,
+          data: {
+            flags: "0",
+            tag: "issuewild",
+            value: "amazonaws.com",
+          },
+        },
+        opts,
+      ),
+    ];
+  }
+
+  function createRecord(
+    namePrefix: string,
+    record: Record,
+    opts: ComponentResourceOptions,
+  ) {
+    return handleCreate(namePrefix, record, opts);
+  }
+
+  function handleCreate(
+    namePrefix: string,
+    record: Record & { isAlias?: boolean },
+    opts: ComponentResourceOptions,
+  ) {
+    return output(record).apply((record) => {
+      const zone = lookupZone(namePrefix, record.type, record.name, opts);
+      const proxy = output(args.proxy).apply(
+        (proxy) => (proxy && record.isAlias) ?? false,
+      );
+      const nameSuffix = logicalName(record.name);
+      const type = record.type.toUpperCase();
+      return new cloudflare.DnsRecord(
+        ...transform(
+          args.transform?.record,
+          `${namePrefix}${record.type}Record${nameSuffix}`,
+          {
+            zoneId: zone.id,
+            proxied: output(proxy),
+            type,
+            name: record.name,
+            ...(type === "TXT"
+              ? {
+                  content: record.value.startsWith(`"`)
+                    ? record.value
+                    : `"${record.value}"`,
+                }
+              : {
+                  content: record.value,
+                }),
+            ...(record.priority !== undefined
+              ? { priority: record.priority }
+              : {}),
+            ttl: output(proxy).apply((proxy) => (proxy ? 1 : 60)),
+          },
+          opts,
+        ),
+      );
+    });
+  }
+}