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

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

@@ -0,0 +1,319 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import * as cf from "@pulumi/cloudflare";
+import { Component, Transform, transform } from "../component";
+import { Link } from "../link";
+import { Input } from "../input";
+import { binding } from "./binding";
+import { DEFAULT_ACCOUNT_ID } from "./account-id";
+import { Worker, WorkerArgs } from "./worker";
+
+export interface WorkflowArgs {
+  /**
+   * Path to the handler file that exports the class that extends `WorkflowEntrypoint`.
+   *
+   * The handler path is relative to the root of your repo or the `sst.config.ts`.
+   *
+   * @example
+   *
+   * ```js
+   * {
+   *   handler: "src/workflow.ts"
+   * }
+   * ```
+   */
+  handler: Input<string>;
+  /**
+   * The name of the class in your handler file that extends `WorkflowEntrypoint`.
+   *
+   * Cloudflare Workflows are defined as classes that extend the
+   * [`WorkflowEntrypoint`](https://developers.cloudflare.com/workflows/build/workers-api/#workflowentrypoint)
+   * class. You must specify the name of the class so SST can bind to it.
+   *
+   * :::caution
+   * The class must be exported as a named export, not as `export default`.
+   * :::
+   *
+   * @example
+   *
+   * Given this handler file:
+   *
+   * ```ts title="src/workflow.ts"
+   * import { WorkflowEntrypoint } from "cloudflare:workers";
+   *
+   * export class OrderProcessor extends WorkflowEntrypoint<Env, Params> {
+   *   async run(event, step) {
+   *     // ...
+   *   }
+   * }
+   * ```
+   *
+   * You would set:
+   *
+   * ```js
+   * {
+   *   className: "OrderProcessor"
+   * }
+   * ```
+   */
+  className: Input<string>;
+  /**
+   * [Link resources](/docs/linking/) to your workflow. This will:
+   *
+   * 1. Make them available on `this.env` inside your workflow class.
+   * 2. Allow you to access them in your workflow using the [SDK](/docs/reference/sdk/).
+   *
+   * @example
+   *
+   * Takes a list of components to link to the workflow.
+   *
+   * ```js
+   * {
+   *   link: [bucket, db]
+   * }
+   * ```
+   */
+  link?: Input<any[]>;
+  /**
+   * Key-value pairs that are set as environment variables on the workflow's Worker.
+   *
+   * They can be accessed in your workflow through `this.env.<key>`.
+   *
+   * @example
+   *
+   * ```js
+   * {
+   *   environment: {
+   *     DEBUG: "true"
+   *   }
+   * }
+   * ```
+   */
+  environment?: Input<Record<string, Input<string>>>;
+  /**
+   * The Cloudflare account ID to use for this Workflow.
+   * 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 underlying Worker that hosts the workflow class.
+     */
+    worker?: Transform<WorkerArgs>;
+    /**
+     * Transform the Workflow resource.
+     */
+    workflow?: Transform<cf.WorkflowArgs>;
+  };
+}
+
+/**
+ * The `Workflow` component lets you add [Cloudflare Workflows](https://developers.cloudflare.com/workflows/)
+ * to your app.
+ *
+ * :::caution
+ * Workflow `console.log` output doesn't stream in real time during `sst dev`.
+ * :::
+ *
+ * A Workflow is a durable, multi-step function that runs on Cloudflare Workers. You
+ * define it as a class that extends `WorkflowEntrypoint` and pass it to this component.
+ *
+ * @example
+ * #### Minimal example
+ *
+ * Define a workflow class:
+ *
+ * ```ts title="src/workflow.ts"
+ * import { WorkflowEntrypoint, WorkflowEvent, WorkflowStep } from "cloudflare:workers";
+ *
+ * export class OrderProcessor extends WorkflowEntrypoint<Env, { orderId: string }> {
+ *   async run(event: WorkflowEvent<{ orderId: string }>, step: WorkflowStep) {
+ *     await step.do("validate", async () => {});
+ *     await step.sleep("cooldown", "10 seconds");
+ *     await step.do("charge", async () => {});
+ *   }
+ * }
+ * ```
+ *
+ * Then register it with SST:
+ *
+ * ```ts title="sst.config.ts"
+ * const processor = new sst.cloudflare.Workflow("OrderProcessor", {
+ *   handler: "src/workflow.ts",
+ *   className: "OrderProcessor",
+ * });
+ * ```
+ *
+ * #### Trigger from a Worker
+ *
+ * Link the workflow to a Worker to get a native Cloudflare
+ * [`Workflow`](https://developers.cloudflare.com/workflows/build/workers-api/#workflow)
+ * binding:
+ *
+ * ```ts title="sst.config.ts" {4}
+ * new sst.cloudflare.Worker("Api", {
+ *   handler: "src/api.ts",
+ *   url: true,
+ *   link: [processor],
+ * });
+ * ```
+ *
+ * Then invoke it from your worker code:
+ *
+ * ```ts title="src/api.ts"
+ * import { Resource } from "sst";
+ *
+ * export default {
+ *   async fetch(req: Request) {
+ *     const instance = await Resource.OrderProcessor.create({
+ *       params: { orderId: "ord_123" },
+ *     });
+ *     return Response.json({ id: instance.id });
+ *   },
+ * };
+ * ```
+ *
+ * #### Give the workflow access to other resources
+ *
+ * ```ts title="sst.config.ts"
+ * const bucket = new sst.cloudflare.Bucket("Orders");
+ *
+ * const processor = new sst.cloudflare.Workflow("OrderProcessor", {
+ *   handler: "src/workflow.ts",
+ *   className: "OrderProcessor",
+ *   link: [bucket],
+ * });
+ * ```
+ *
+ */
+export class Workflow extends Component implements Link.Linkable {
+  private worker: Worker;
+  private workflow: cf.Workflow;
+
+  constructor(
+    name: string,
+    args: WorkflowArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    const parent = this;
+
+    const worker = createWorker();
+    const workflow = createWorkflow();
+
+    this.worker = worker;
+    this.workflow = workflow;
+
+    function createWorker() {
+      return new Worker(
+        ...transform(
+          args.transform?.worker,
+          `${name}Script`,
+          {
+            handler: args.handler,
+            link: args.link,
+            environment: args.environment,
+          },
+          { parent },
+        ),
+      );
+    }
+
+    function createWorkflow() {
+      return new cf.Workflow(
+        ...transform(
+          args.transform?.workflow,
+          `${name}Workflow`,
+          {
+            accountId: args.accountId ?? DEFAULT_ACCOUNT_ID,
+            workflowName: "",
+            className: args.className,
+            scriptName: worker.nodes.worker.scriptName,
+          },
+          { parent },
+        ),
+      );
+    }
+  }
+
+  /**
+   * The name of the Cloudflare Workflow.
+   */
+  public get workflowName() {
+    return this.workflow.workflowName;
+  }
+
+  /**
+   * The name of the workflow class.
+   */
+  public get className() {
+    return this.workflow.className;
+  }
+
+  /**
+   * The name of the Worker script that hosts the workflow class.
+   */
+  public get scriptName() {
+    return this.workflow.scriptName;
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The Cloudflare Worker that hosts the workflow class.
+       */
+      worker: this.worker,
+      /**
+       * The Cloudflare Workflow resource.
+       */
+      workflow: this.workflow,
+    };
+  }
+
+  /**
+   * When you link a workflow to a worker, it automatically creates a
+   * [Workflow binding](https://developers.cloudflare.com/workflows/build/workers-api/#call-workflows-from-workers)
+   * on the worker. This lets you trigger, inspect, and manage workflow instances
+   * from your worker code.
+   *
+   * @example
+   * ```ts title="src/api.ts"
+   * import { Resource } from "sst";
+   *
+   * const instance = await Resource.MyWorkflow.create({ params: { hello: "world" } });
+   * ```
+   *
+   * @internal
+   */
+  getSSTLink() {
+    return {
+      properties: {
+        workflowName: this.workflow.workflowName,
+        className: this.workflow.className,
+        scriptName: this.workflow.scriptName,
+      },
+      include: [
+        binding({
+          type: "workflowBindings",
+          properties: {
+            workflowName: this.workflow.workflowName,
+            className: this.workflow.className,
+            scriptName: this.workflow.scriptName,
+          },
+        }),
+      ],
+    };
+  }
+}
+
+const __pulumiType = "sst:cloudflare:Workflow";
+// @ts-expect-error
+Workflow.__pulumiType = __pulumiType;

package/platform/src/components/component.ts

@@ -0,0 +1,242 @@
+import {
+  ComponentResource,
+  ComponentResourceOptions,
+  Inputs,
+  runtime,
+  output,
+  asset as pulumiAsset,
+  Input,
+  all,
+  Output,
+  ResourceTransformationArgs,
+} from "@pulumi/pulumi";
+import { nameResource, registerNamingRule } from "./naming.js";
+import type { NamingRule } from "./naming-rules.js";
+import { takeoverOf } from "./takeover.js";
+import { VisibleError } from "./error.js";
+import path from "path";
+import { statSync } from "fs";
+
+export { type Transform, transform, mergeArgs } from "./transform.js";
+export type { NamingRule } from "./naming-rules.js";
+
+// Previously, `this.api.id` was used as the ID. `this.api.id` was of type Output<string>
+// the value evaluates to the mistake id.
+// In the future version, we will release a breaking change to fix this.
+export const outputId =
+  "Calling [toString] on an [Output<T>] is not supported.\n\nTo get the value of an Output<T> as an Output<string> consider either:\n1: o.apply(v => `prefix${v}suffix`)\n2: pulumi.interpolate `prefix${v}suffix`\n\nSee https://www.pulumi.com/docs/concepts/inputs-outputs for more details.\nThis function may throw in a future version of @pulumi/pulumi.";
+
+/**
+ * Helper type to inline nested types
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+/**
+ * The class every component extends. It names the component's resources and
+ * applies `$transform`.
+ *
+ * To write a component, extend what `component()` returns instead. It adds
+ * parts to this class.
+ */
+export class Component extends ComponentResource {
+  /** @internal */
+  protected readonly componentType: string;
+  /** The name the component was created with. */
+  protected readonly componentName: string;
+
+  constructor(
+    type: string,
+    name: string,
+    args?: Inputs,
+    opts?: ComponentResourceOptions,
+  ) {
+    const transforms = ComponentTransforms.get(type) ?? [];
+    for (const transform of transforms) {
+      transform({ name, props: args, opts });
+    }
+
+    // `this` is not available to the transformations below until `super`
+    // returns, so they reach the component through this variable.
+    let self: Component | undefined;
+
+    super(type, name, {}, {
+      ...opts,
+      // A deployed component this one takes over from becomes this one.
+      // Pulumi carries the alias over to its children.
+      aliases: [...(opts?.aliases ?? []), ...takeoverAliases(new.target, opts)],
+      transformations: [
+        // Ensure logical and physical names are prefixed
+        (args) => nameResource({ type, name }, args),
+        // Set child resources `retainOnDelete` if set on component
+        (args) => ({
+          props: args.props,
+          opts: {
+            ...args.opts,
+            retainOnDelete: args.opts.retainOnDelete ?? opts?.retainOnDelete,
+          },
+        }),
+        // Tell the component about each resource created directly under it
+        (args) => {
+          if (self && args.opts.parent === self) self.childCreated?.(args);
+          return undefined;
+        },
+        ...(opts?.transformations ?? []),
+      ],
+    });
+
+    self = this;
+    this.componentType = type;
+    this.componentName = name;
+  }
+
+  /**
+   * Called for each resource created directly under this component.
+   *
+   * @internal
+   */
+  protected childCreated?(child: ResourceTransformationArgs): void;
+
+  /**
+   * Say how resources of a type get their physical name when they are created
+   * inside a component. SST already knows the types its own components use.
+   *
+   * @example
+   * ```ts
+   * sst.Component.naming("aws:kms/alias:Alias", false);
+   * sst.Component.naming("aws:athena/workgroup:Workgroup", {
+   *   field: "name",
+   *   max: 128,
+   * });
+   * ```
+   */
+  public static naming(type: string, rule: NamingRule) {
+    registerNamingRule(type, rule);
+  }
+
+  /** @internal */
+  protected registerVersion(input: {
+    new: number;
+    old?: number;
+    message?: string;
+    forceUpgrade?: `v${number}`;
+  }) {
+    // Check component version
+    const oldVersion = input.old;
+    const newVersion = input.new ?? 1;
+    if (oldVersion) {
+      const className = this.componentType.replaceAll(":", ".");
+      // Invalid forceUpgrade value
+      if (input.forceUpgrade && input.forceUpgrade !== `v${newVersion}`) {
+        throw new VisibleError(
+          [
+            `The value of "forceUpgrade" does not match the version of "${className}" component.`,
+            `Set "forceUpgrade" to "v${newVersion}" to upgrade to the new version.`,
+          ].join("\n"),
+        );
+      }
+      // Version upgraded without forceUpgrade
+      if (oldVersion < newVersion && !input.forceUpgrade) {
+        throw new VisibleError(input.message ?? "");
+      }
+      // Version downgraded
+      if (oldVersion > newVersion) {
+        throw new VisibleError(
+          [
+            `It seems you are trying to use an older version of "${className}".`,
+            `You need to recreate this component to rollback - https://sst-community.github.io/sst/docs/components/#versioning`,
+          ].join("\n"),
+        );
+      }
+    }
+
+    // Set version
+    if (newVersion > 1) {
+      new Version(this.componentName, newVersion, { parent: this });
+    }
+  }
+}
+
+// The addresses of the component this one takes over from, when that one
+// has another type: the same address with the old type. When the component is also given an old name or
+// parent, as a part that moved is, the old type goes with each of those too.
+// Pulumi reads every alias on its own, so two that each say one thing don't
+// add up to the address that had both.
+function takeoverAliases(component: Function, opts?: ComponentResourceOptions) {
+  const from = takeoverOf(component)?.from;
+  if (!from) return [];
+  const moved = (opts?.aliases ?? []).flatMap((alias) =>
+    typeof alias === "object" &&
+    !Output.isInstance(alias) &&
+    !(alias instanceof Promise) &&
+    alias.type === undefined
+      ? [{ ...alias, type: from }]
+      : [],
+  );
+  return [...moved, { type: from }];
+}
+
+const ComponentTransforms = new Map<string, any[]>();
+export function $transform<T, Args, Options>(
+  resource: { new (name: string, args: Args, opts?: Options): T },
+  cb: (args: Args, opts: Options, name: string) => void,
+) {
+  // @ts-expect-error
+  const type = resource.__pulumiType;
+  // A component is given its args before it creates anything
+  if (type.startsWith("sst:") || resource.prototype instanceof Component) {
+    let transforms = ComponentTransforms.get(type);
+    if (!transforms) {
+      transforms = [];
+      ComponentTransforms.set(type, transforms);
+    }
+    transforms.push((input: any) => {
+      cb(input.props, input.opts, input.name);
+      return input;
+    });
+    return;
+  }
+  runtime.registerStackTransformation((input) => {
+    if (input.type !== type) return;
+    cb(input.props as any, input.opts as any, input.name);
+    return input;
+  });
+}
+
+export function $asset(assetPath: string) {
+  const fullPath = path.isAbsolute(assetPath)
+    ? assetPath
+    : path.join($cli.paths.root, assetPath);
+
+  try {
+    return statSync(fullPath).isDirectory()
+      ? new pulumiAsset.FileArchive(fullPath)
+      : new pulumiAsset.FileAsset(fullPath);
+  } catch (e) {
+    throw new VisibleError(`Asset not found: ${fullPath}`);
+  }
+}
+
+export function $lazy<T>(fn: () => T) {
+  return output(undefined)
+    .apply(async () => output(fn()))
+    .apply((x) => x);
+}
+
+export function $print(...msg: Input<any>[]) {
+  return all(msg).apply((msg) => console.log(...msg));
+}
+
+export class Version extends ComponentResource {
+  constructor(target: string, version: number, opts: ComponentResourceOptions) {
+    super("sst:sst:Version", target + "Version", {}, opts);
+    this.registerOutputs({ target, version });
+  }
+}
+
+export type ComponentVersion = { major: number; minor: number };
+export function parseComponentVersion(version: string): ComponentVersion {
+  const [major, minor] = version.split(".");
+  return { major: parseInt(major), minor: parseInt(minor) };
+}

package/platform/src/components/core.ts

@@ -0,0 +1,43 @@
+// What SST's components share, without the components for each provider.
+// Nothing here loads a provider, so a file that imports `sst/components`
+// loads only the providers of the groups it imports too, like
+// `sst/components/aws`. The `sst` global is this and every group (index.ts).
+
+export * from "./secret";
+export * from "./linkable";
+export { takeover, type Takeover, type OldAddress } from "./takeover";
+export { Component, type NamingRule, type Transform } from "./component";
+export {
+  component,
+  type ComponentClass,
+  deferred,
+  many,
+  named,
+  optional,
+  type ComponentArgs,
+  type V5Args,
+  type DeferredPart,
+  type Existing,
+  type LinkDefinition,
+  type ManyPart,
+  type ManyTransform,
+  type NamedPart,
+  type Nodes,
+  type OptionalPart,
+  type PartTransform,
+  type PartialArgs,
+  type Parts,
+  type Transforms,
+} from "./parts-component";
+/**
+ * experimental packages, you may be fired for using
+ */
+export * as x from "./experimental/index";
+
+import { Link } from "./link";
+
+/**
+ * @deprecated
+ * Use sst.Linkable.wrap instead.
+ */
+export const linkable = Link.linkable;

package/platform/src/components/cpu.ts

@@ -0,0 +1,10 @@
+export type Cpu = `${number} ${"vCPU"}`;
+
+export function toNumber(cpu: Cpu) {
+  const [count, unit] = cpu.split(" ");
+  const countNum = parseFloat(count);
+  if (unit === "vCPU") {
+    return countNum * 1024;
+  }
+  throw new Error(`Invalid CPU ${cpu}`);
+}

package/platform/src/components/dns.ts

@@ -0,0 +1,82 @@
+/**
+ * The DNS Adapter lets you manage DNS records for domains hosted on different providers.
+ *
+ * @packageDocumentation
+ */
+
+import { ComponentResourceOptions, Output, Resource } from "@pulumi/pulumi";
+import { Input } from "./input";
+
+export interface Record {
+  /**
+   * The name of the record.
+   */
+  name: Input<string>;
+  /**
+   * The type of the record.
+   */
+  type: Input<string>;
+  /**
+   * The value of the record.
+   */
+  value: Input<string>;
+  /**
+   * The priority of the record. Only applies to `MX` records.
+   */
+  priority?: Input<number>;
+}
+
+export interface AliasRecord {
+  /**
+   * The name of the record.
+   */
+  name: Input<string>;
+  /**
+   * The domain name for the alias target.
+   */
+  aliasName: Input<string>;
+  /**
+   * The Route 53 hosted zone ID for the alias target.
+   */
+  aliasZone: Input<string>;
+}
+
+type CreateRecord = (
+  namePrefix: string,
+  record: Record,
+  opts: ComponentResourceOptions,
+) => Output<Resource>;
+
+type CreateAliasRecord = (
+  namePrefix: string,
+  record: AliasRecord,
+  opts: ComponentResourceOptions,
+) => Output<Resource> | Output<Resource>[];
+
+type CreateCaaRecord = (
+  namePrefix: string,
+  recordName: string,
+  opts: ComponentResourceOptions,
+) => Resource[] | Output<Resource>[] | undefined;
+
+type AwsDns = {
+  provider: "aws";
+  createRecord: CreateRecord;
+  createAlias: CreateAliasRecord;
+  createCaa: CreateCaaRecord;
+};
+
+type CloudflareDns = {
+  provider: "cloudflare";
+  createRecord: CreateRecord;
+  createAlias: CreateAliasRecord;
+  createCaa: CreateCaaRecord;
+};
+type VercelDns = {
+  provider: "vercel";
+  createRecord: CreateRecord;
+  createAlias: CreateAliasRecord;
+  createCaa: CreateCaaRecord;
+};
+
+export type Dns = AwsDns | CloudflareDns | VercelDns;