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

package/platform/src/components/cloudflare/providers/zone-lookup.ts

@@ -0,0 +1,85 @@
+import { CustomResourceOptions, Input, Output, dynamic } from "@pulumi/pulumi";
+import { cfFetch } from "../helpers/fetch.js";
+
+interface Inputs {
+  accountId: string;
+  domain: string;
+}
+
+interface Outputs {
+  zoneId: string;
+  zoneName: string;
+}
+
+export interface ZoneLookupInputs {
+  accountId: Input<Inputs["accountId"]>;
+  domain: Input<Inputs["domain"]>;
+}
+
+export interface ZoneLookup {
+  zoneId: Output<Outputs["zoneId"]>;
+  zoneName: Output<Outputs["zoneName"]>;
+}
+
+class Provider implements dynamic.ResourceProvider {
+  async create(inputs: Inputs): Promise<dynamic.CreateResult<Outputs>> {
+    const { zoneId, zoneName } = await this.lookup(inputs);
+    return { id: zoneId, outs: { zoneId, zoneName } };
+  }
+
+  async update(
+    id: string,
+    olds: Inputs,
+    news: Inputs,
+  ): Promise<dynamic.UpdateResult<Outputs>> {
+    const { zoneId, zoneName } = await this.lookup(news);
+    return { outs: { zoneId, zoneName } };
+  }
+
+  async lookup(
+    inputs: Inputs,
+    page = 1,
+  ): Promise<{ zoneId: string; zoneName: string }> {
+    try {
+      const qs = new URLSearchParams({
+        per_page: "50",
+        page: String(page),
+        "account.id": inputs.accountId,
+      }).toString();
+      const ret = await cfFetch<{ name: string; id: string }[]>(
+        `/zones?${qs}`,
+        { headers: { "Content-Type": "application/json" } },
+      );
+      const zone = ret.result.find(
+        // ensure `example.com` does not match `myexample.com`
+        (z) => inputs.domain === z.name || inputs.domain.endsWith(`.${z.name}`),
+      );
+      if (zone) return { zoneId: zone.id, zoneName: zone.name };
+
+      if (ret.result.length < ret.result_info!.per_page)
+        throw new Error(
+          `Could not find hosted zone for domain ${inputs.domain}`,
+        );
+
+      return this.lookup(inputs, page + 1);
+    } catch (error: any) {
+      console.log(error);
+      throw error;
+    }
+  }
+}
+
+export class ZoneLookup extends dynamic.Resource {
+  constructor(
+    name: string,
+    args: ZoneLookupInputs,
+    opts?: CustomResourceOptions,
+  ) {
+    super(
+      new Provider(),
+      `${name}.sst.cloudflare.ZoneLookup`,
+      { ...args, zoneId: undefined, zoneName: undefined },
+      opts,
+    );
+  }
+}

package/platform/src/components/cloudflare/queue-worker-subscriber.ts

@@ -0,0 +1,192 @@
+import { ComponentResourceOptions, Input, output } from "@pulumi/pulumi";
+import * as cloudflare from "@pulumi/cloudflare";
+import { Component, Transform, transform } from "../component";
+import {
+  DurationMinutes,
+  DurationSeconds,
+  toMilliseconds,
+} from "../duration";
+import { WorkerBuilder, workerBuilder } from "./helpers/worker-builder";
+import { WorkerArgs } from "./worker";
+import { DEFAULT_ACCOUNT_ID } from "./account-id";
+
+export interface QueueWorkerSubscriberArgs {
+  /**
+   * The queue to use.
+   */
+  queue: Input<{
+    /**
+     * The ID of the queue.
+     */
+    id: Input<string>;
+  }>;
+  /**
+   * The subscriber worker.
+   */
+  subscriber: Input<string | WorkerArgs>;
+  /**
+   * The Cloudflare account ID to use for this subscriber and its consumer.
+   * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+   * @internal
+  */
+  accountId?: Input<string>;
+  /**
+   * The dead letter queue to send messages that fail processing.
+   *
+   * When `dlq` is configured, `dlq.queue` is required.
+   */
+  dlq?: {
+    /**
+     * The name of the dead letter queue.
+     */
+    queue: Input<string>;
+    /**
+     * The number of times the main queue will retry the message before sending it to the dead-letter queue.
+     * @default `3`
+     */
+    retry?: Input<number>;
+    /**
+     * The number of seconds to delay before making the message available for another attempt.
+     * @default `0 seconds`
+     */
+    retryDelay?: Input<DurationSeconds>;
+  };
+  /**
+   * Maximum number of concurrent consumers that may consume from this Queue.
+   * @default `null`
+   */
+  maxConcurrency?: Input<number>;
+  /**
+   * The maximum number of messages to include in a batch.
+   * @default `10`
+   */
+  batch?: {
+    /**
+     * The maximum number of events that will be processed together in a single invocation
+     * of the consumer function.
+     *
+     * Value must be between 1 and 100.
+     *
+     * :::note
+     * When `size` is set to a value greater than 10, `window` must be set to at least `1 second`.
+     * :::
+     *
+     * @default `10`
+     */
+    size?: Input<number>;
+    /**
+     * The maximum amount of time to wait for collecting events before sending the batch to
+     * the consumer function, even if the batch size hasn't been reached.
+     *
+     * Value must be between 0 seconds and 60 seconds.
+     * @default `"5 seconds"`
+     */
+    window?: Input<DurationMinutes>;
+  };
+  /**
+   * [Transform](/docs/components/#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the Worker resource.
+     */
+    worker?: Transform<WorkerArgs>;
+    /**
+     * Transform the Consumer resource.
+     */
+    consumer?: Transform<cloudflare.QueueConsumerArgs>;
+  };
+}
+
+/**
+ * The `QueueWorkerSubscriber` component is internally used by the `Queue` component to
+ * add a consumer to [Cloudflare Queues](https://developers.cloudflare.com/queues/).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by `Queue.subscribe()`.
+ */
+export class QueueWorkerSubscriber extends Component {
+  private readonly _worker: WorkerBuilder;
+  private readonly consumer: cloudflare.QueueConsumer;
+
+  constructor(
+    name: string,
+    args: QueueWorkerSubscriberArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    const self = this;
+    const queue = output(args.queue);
+    const accountId = args.accountId ?? DEFAULT_ACCOUNT_ID;
+    const worker = createWorker();
+    const batchSize = output(args.batch?.size ?? 10);
+    const window = output(args.batch?.window ?? "5 seconds");
+    const retryDelay = output(args.dlq?.retryDelay ?? "0 seconds");
+    const consumer = createConsumer();
+
+    this._worker = worker;
+    this.consumer = consumer;
+
+    function createWorker() {
+      return workerBuilder(
+        `${name}Function`,
+        args.subscriber,
+        args.transform?.worker,
+        { parent: self },
+        accountId,
+      );
+    }
+
+    function createConsumer() {
+      return new cloudflare.QueueConsumer(
+        ...transform(
+          args.transform?.consumer,
+          `${name}Consumer`,
+          {
+            accountId: accountId,
+            deadLetterQueue: args.dlq?.queue,
+            queueId: queue.id,
+            scriptName: worker.script.scriptName,
+            settings: {
+              batchSize,
+              maxConcurrency: args.maxConcurrency,
+              maxRetries: args.dlq?.retry,
+              retryDelay: retryDelay.apply((v) => toMilliseconds(v)),
+              maxWaitTimeMs: window.apply((v) => toMilliseconds(v)),
+            },
+            type: "worker",
+          },
+          { parent: self },
+        ),
+      );
+    }
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    const self = this;
+    return {
+      /**
+       * The Worker that'll process messages from the queue.
+       */
+      get worker() {
+        return self._worker.apply((worker) => worker.getWorker());
+      },
+      /**
+       * The Cloudflare Queue Consumer.
+       */
+      consumer: this.consumer,
+    };
+  }
+}
+
+const __pulumiType = "sst:cloudflare:QueueWorkerSubscriber";
+// @ts-expect-error
+QueueWorkerSubscriber.__pulumiType = __pulumiType;

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

@@ -0,0 +1,310 @@
+import { ComponentResourceOptions, Input } 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 { WorkerArgs } from "./worker";
+import { VisibleError } from "../error";
+import { QueueWorkerSubscriber } from "./queue-worker-subscriber";
+import { DurationMinutes, DurationSeconds } from "../duration";
+
+export interface QueueArgs {
+  /**
+   * The Cloudflare account ID to use for this Queue.
+   * Overrides the default account ID set via `CLOUDFLARE_DEFAULT_ACCOUNT_ID`.
+   * @internal
+   */
+  accountId?: Input<string>;
+  /**
+   * The dead letter queue to send messages that fail processing.
+   *
+   * When `dlq` is configured, `dlq.queue` is required.
+   */
+  dlq?: {
+    /**
+     * The name of the dead letter queue.
+     */
+    queue: Input<string>;
+    /**
+     * The number of times the main queue will retry the message before sending it to the dead-letter queue.
+     * @default `3`
+     */
+    retry?: Input<number>;
+    /**
+     * The number of seconds to delay before making the message available for another attempt.
+     * @default `0 seconds`
+     */
+    retryDelay?: Input<DurationSeconds>;
+  };
+  /**
+   * Maximum number of concurrent consumers that may consume from this Queue.
+   * @default `null`
+   */
+  maxConcurrency?: Input<number>;
+  /**
+   * [Transform](/docs/components/#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the Queue resource.
+     */
+    queue?: Transform<cloudflare.QueueArgs>;
+  };
+}
+
+export interface QueueSubscribeArgs {
+  /**
+   * The maximum number of messages to include in a batch.
+   * @default `10`
+   */
+  batch?: {
+    /**
+     * The maximum number of events that will be processed together in a single invocation
+     * of the consumer function.
+     *
+     * Value must be between 1 and 100.
+     *
+     * :::note
+     * When `size` is set to a value greater than 10, `window` must be set to at least `1 second`.
+     * :::
+     *
+     * @default `10`
+     * @example
+     * Set batch size to 1. This will process events individually.
+     * ```js
+     * {
+     *   batch: {
+     *     size: 1
+     *   }
+     * }
+     * ```
+     */
+    size?: Input<number>;
+    /**
+     * The maximum amount of time to wait for collecting events before sending the batch to
+     * the consumer function, even if the batch size hasn't been reached.
+     *
+     * Value must be between 0 seconds and 60 seconds.
+     * @default `"5 seconds"`
+     * @example
+     * ```js
+     * {
+     *   batch: {
+     *     window: "5 seconds"
+     *   }
+     * }
+     * ```
+     */
+    window?: Input<DurationMinutes>;
+  };
+  /**
+   * [Transform](/docs/components/#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the Worker resource.
+     */
+    worker?: Transform<WorkerArgs>;
+    /**
+     * Transform the Consumer resource.
+     */
+    consumer?: Transform<cloudflare.QueueConsumerArgs>;
+  };
+}
+
+/**
+ * The `Queue` component lets you add a [Cloudflare Queue](https://developers.cloudflare.com/queues/) to
+ * your app.
+ *
+ * @example
+ * #### Create a Queue
+ *
+ * ```ts title="sst.config.ts"
+ * const queue = new sst.cloudflare.Queue("MyQueue");
+ * ```
+ *
+ * #### Subscribe to the Queue
+ *
+ * Create a worker file that exposes a default handler for queue messages:
+ *
+ * ```ts title="consumer.ts"
+ * export default {
+ *   async queue(batch, env) {
+ *     for (const message of batch.messages) {
+ *       console.log("Processing message:", message.body);
+ *     }
+ *   },
+ * };
+ * ```
+ *
+ * Subscribe to the queue with a consumer worker.
+ *
+ * ```ts title="sst.config.ts"
+ * queue.subscribe("consumer.ts");
+ * ```
+ *
+ * #### Link to the Queue
+ *
+ * You can link other workers to the queue.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.cloudflare.Worker("MyWorker", {
+ *   handler: "producer.ts",
+ *   link: [queue],
+ *   url: true,
+ * });
+ * ```
+ *
+ * #### Subscribe with full worker props
+ *
+ * ```ts title="sst.config.ts"
+ * const bucket = new sst.cloudflare.Bucket("MyBucket");
+ *
+ * queue.subscribe({
+ *   handler: "consumer.ts",
+ *   link: [bucket],
+ * });
+ * ```
+ */
+export class Queue extends Component implements Link.Linkable {
+  private queue: cloudflare.Queue;
+  private isSubscribed = false;
+  private constructorName: string;
+  private constructorArgs?: QueueArgs;
+  private constructorOpts?: ComponentResourceOptions;
+
+  constructor(name: string, args?: QueueArgs, opts?: ComponentResourceOptions) {
+    super(__pulumiType, name, args, opts);
+
+    const parent = this;
+    this.constructorName = name;
+    this.constructorArgs = args;
+    this.constructorOpts = opts;
+
+    const queue = create();
+
+    this.queue = queue;
+
+    function create() {
+      return new cloudflare.Queue(
+        ...transform(
+          args?.transform?.queue,
+          `${name}Queue`,
+          {
+            queueName: "",
+            accountId: args?.accountId ?? DEFAULT_ACCOUNT_ID,
+          },
+          { parent },
+        ),
+      );
+    }
+  }
+
+  /**
+   * Subscribe to the queue with a worker.
+   *
+   * @param subscriber The worker that'll process messages from the queue.
+   * @param args Configure the subscription.
+   * @param opts Component resource options.
+   *
+   * @example
+   *
+   * Subscribe to the queue with a worker file.
+   *
+   * ```ts title="sst.config.ts"
+   * queue.subscribe("consumer.ts");
+   * ```
+   *
+   * Pass in full worker props.
+   *
+   * ```ts title="sst.config.ts"
+   * const bucket = new sst.cloudflare.Bucket("MyBucket");
+   *
+   * queue.subscribe({
+   *   handler: "consumer.ts",
+   *   link: [bucket],
+   * });
+   * ```
+   *
+   * Configure batch settings.
+   *
+   * ```ts title="sst.config.ts"
+   * queue.subscribe("consumer.ts", {
+   *   batch: {
+   *     size: 10,
+   *     window: "20 seconds",
+   *   },
+   * });
+   * ```
+   */
+  public subscribe(
+    subscriber: Input<string | WorkerArgs>,
+    args?: QueueSubscribeArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    if (this.isSubscribed) {
+      throw new VisibleError(
+        `Cannot subscribe to the "${this.constructorName}" queue multiple times. A Cloudflare Queue can only have one consumer.`,
+      );
+    }
+
+    this.isSubscribed = true;
+
+    const parent = this;
+    const name = this.constructorName;
+
+    return new QueueWorkerSubscriber(
+      `${name}Subscriber`,
+      {
+        queue: { id: this.queue.id },
+        subscriber,
+        accountId: this.constructorArgs?.accountId,
+        dlq: this.constructorArgs?.dlq,
+        maxConcurrency: this.constructorArgs?.maxConcurrency,
+        batch: args?.batch,
+        transform: args?.transform,
+      },
+      { ...opts, provider: this.constructorOpts?.provider },
+    );
+  }
+
+  getSSTLink() {
+    return {
+      properties: {},
+      include: [
+        binding({
+          type: "queueBindings",
+          properties: {
+            queueName: this.queue.queueName,
+          },
+        }),
+      ],
+    };
+  }
+
+  /**
+   * The generated id of the queue
+   */
+  public get id() {
+    return this.queue.id;
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The Cloudflare queue.
+       */
+      queue: this.queue,
+    };
+  }
+}
+
+const __pulumiType = "sst:cloudflare:Queue";
+// @ts-expect-error
+Queue.__pulumiType = __pulumiType;