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

package/platform/src/components/takeover.ts

@@ -0,0 +1,131 @@
+import {
+  Input,
+  Resource,
+  all,
+  getProject,
+  getStack,
+  interpolate,
+  rootStackResource,
+} from "@pulumi/pulumi";
+import type { Parts } from "./parts";
+
+/**
+ * Where a resource lived before, when that isn't where it lives now.
+ */
+export interface OldAddress {
+  /** The name the resource had. */
+  name: Input<string>;
+  /**
+   * The component it was in, when that was a different component from the one
+   * it's in now. `false` when it wasn't in a component at all: it was created
+   * at the top of the app, beside the component.
+   */
+  parent?:
+    | false
+    | {
+        type: string;
+        name: Input<string>;
+        /**
+         * The component that one was created next to, under the same parent.
+         * Leave it out when it was at the top of the app whatever it was
+         * created for.
+         */
+        beside?: Resource;
+      };
+}
+
+/**
+ * How a component takes over from the one it replaces, so that switching to
+ * it keeps the resources that are already deployed.
+ *
+ * A deployed component with the same type and name becomes this component.
+ * Each of its resources is matched to the part with the same key. List a part
+ * under `moved` when it used to have a different key, or lived in a different
+ * component.
+ */
+export interface Takeover<P extends Parts, C = unknown> {
+  /**
+   * The type of the component this one takes over from, when that isn't this
+   * component's own type.
+   */
+  from?: string;
+  moved?: {
+    [K in keyof P]?:
+      | string
+      | ((
+          component: C,
+          /** The component's name, and the part's id for a `many` part. */
+          part: { name: string; id?: string },
+        ) => OldAddress | OldAddress[] | undefined);
+  };
+}
+
+// By class and not by type: a component and the one that replaces it can
+// have the same type
+const takeovers = new Map<Function, Takeover<any, any>>();
+
+/**
+ * Say how a component takes over from the one it replaces. This lives apart
+ * from the component, so the component's own code doesn't carry the layout of
+ * what came before it.
+ *
+ * @example
+ * ```ts
+ * takeover(Redis, {
+ *   moved: {
+ *     // The key this part had
+ *     secret: "proxySecret",
+ *   },
+ * });
+ * ```
+ *
+ * @param component The component that takes over.
+ * @param how The parts that moved, and the type it takes over from when that's another type.
+ */
+export function takeover<P extends Parts, C>(
+  component: {
+    new (...args: any[]): C;
+    readonly __pulumiType: string;
+    readonly __parts?: P;
+  },
+  how: Takeover<P, C>,
+) {
+  takeovers.set(component, how);
+}
+
+/**
+ * How a component's class takes over, or the class it extends.
+ * @internal
+ */
+export function takeoverOf(
+  component: Function | undefined,
+): Takeover<Parts, any> | undefined {
+  for (let cls = component; cls; cls = Object.getPrototypeOf(cls)) {
+    const how = takeovers.get(cls);
+    if (how) return how;
+  }
+}
+
+/** The Pulumi alias for an old address. */
+export function aliasOf(old: OldAddress) {
+  // Pulumi reads a parent that's set but empty as "it had no parent"
+  if (old.parent === false)
+    return { name: old.name, parent: rootStackResource };
+  if (!old.parent) return { name: old.name };
+
+  const { type, name, beside } = old.parent;
+  if (!beside)
+    return {
+      name: old.name,
+      parent: interpolate`urn:pulumi:${getStack()}::${getProject()}::${type}::${name}`,
+    };
+  // The same address as `beside`, with the last type and the name swapped
+  return {
+    name: old.name,
+    parent: all([beside.urn, name]).apply(([urn, name]) => {
+      const [stack, project, types] = urn.split("::");
+      const chain = [...types.split("$").slice(0, -1), type].join("$");
+      return [stack, project, chain, name].join("::");
+    }),
+  };
+}

package/platform/src/components/transform.ts

@@ -0,0 +1,107 @@
+import {
+  type CustomResourceOptions,
+  type OutputInstance,
+  type Resource,
+  Output,
+  output,
+} from "@pulumi/pulumi";
+
+export type Transform<T> =
+  | Partial<T>
+  | ((args: T, opts: CustomResourceOptions, name: string) => undefined);
+
+export function transform<T extends object>(
+  transform: Transform<T> | undefined,
+  name: string,
+  args: T,
+  opts: CustomResourceOptions,
+) {
+  // Case: transform is a function
+  if (typeof transform === "function") {
+    transform(args, opts, name);
+    return [name, args, opts] as const;
+  }
+
+  // Case: no transform
+  // Case: transform is an argument
+  return [name, { ...args, ...transform }, opts] as const;
+}
+
+/**
+ * A part's args with every level optional: what the object form of a part's
+ * transform takes. It follows how `mergeArgs()` merges. A nested object is
+ * merged key by key, so it can be given in part. Anything else is replaced,
+ * so it's given whole.
+ */
+export type PartialArgs<T> = T extends Whole
+  ? T
+  : T extends object
+    ? { [K in keyof T]?: PartialArgs<T[K]> }
+    : T;
+
+// What a transform replaces as a whole. (An asset or archive is too, but its
+// type has no members, so every object would match it.)
+type Whole =
+  | readonly any[]
+  | ((...args: any[]) => any)
+  | Promise<any>
+  | OutputInstance<any>
+  | Resource;
+
+/**
+ * The transform for one of a component's parts: args to merge into the
+ * defaults, or a function that changes the args and options.
+ */
+export type PartTransform<T> =
+  | PartialArgs<T>
+  | ((args: T, opts: CustomResourceOptions, name: string) => undefined);
+
+/**
+ * Applies a transform to one of a component's parts. Unlike `transform()`,
+ * the object form is merged into nested defaults instead of replacing them.
+ */
+export function transformPart<T extends object>(
+  transform: PartTransform<T> | undefined,
+  name: string,
+  args: T,
+  opts: CustomResourceOptions,
+) {
+  if (typeof transform === "function") {
+    transform(args, opts, name);
+    return [name, args, opts] as const;
+  }
+  return [name, mergeArgs(args, transform), opts] as const;
+}
+
+/**
+ * Merges the object form of a transform into a resource's default args.
+ *
+ * Nested objects are merged key by key, so setting one nested value keeps its
+ * siblings. Everything else replaces the default: arrays, strings, numbers,
+ * outputs, assets and resources. To replace a nested object outright, use the
+ * function form of the transform.
+ */
+export function mergeArgs<T>(base: T, patch: PartialArgs<T> | undefined): T {
+  if (patch === undefined) return base;
+  if (!isPlainObject(patch)) return patch as T;
+
+  if (Output.isInstance(base)) {
+    // The default is only known later; merge once it resolves.
+    return (base as Output<unknown>).apply((resolved) =>
+      output(isPlainObject(resolved) ? mergeArgs(resolved, patch) : patch),
+    ) as T;
+  }
+  if (!isPlainObject(base)) return patch as T;
+
+  const merged: Record<string, unknown> = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    merged[key] = mergeArgs(merged[key], value as any);
+  }
+  return merged as T;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}

package/platform/src/components/vercel/account-id.ts

@@ -0,0 +1 @@
+export const DEFAULT_TEAM_ID = process.env.VERCEL_TEAM_ID!;

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

@@ -0,0 +1,171 @@
+/**
+ * The Vercel DNS Adapter is used to create DNS records to manage domains hosted on [Vercel](https://vercel.com/docs/projects/domains/working-with-domains).
+ *
+ * :::note
+ * You need to [add the Vercel provider](/docs/all-providers#directory) to use this adapter.
+ * :::
+ *
+ * This adapter is passed in as `domain.dns` when setting a custom domain; where `example.com`
+ * is hosted on Vercel.
+ *
+ * ```ts
+ * {
+ *   domain: {
+ *     name: "example.com",
+ *     dns: sst.vercel.dns({
+ *       domain: "example.com"
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * #### Configure provider
+ *
+ * 1. To use this component, add the `vercel` provider to your app.
+ *
+ *    ```bash
+ *    sst add vercel
+ *    ```
+ *
+ * 2. If you don't already have a Vercel Access Token, [follow this guide](https://vercel.com/guides/how-do-i-use-a-vercel-api-access-token#creating-an-access-token) to create one.
+ *
+ * 3. Add a `VERCEL_API_TOKEN` environment variable with the access token value. If the domain
+ * belongs to a team, also add a `VERCEL_TEAM_ID` environment variable with the Team ID. You can
+ * find your Team ID inside your team's general project settings in the Vercel dashboard.
+ *
+ * @packageDocumentation
+ */
+
+import { DnsRecord, DnsRecordArgs } from "@pulumiverse/vercel";
+import { DnsRecord as OverridableDnsRecord } from "./providers/dns-record";
+import { AliasRecord, Dns, Record } from "../dns";
+import { logicalName } from "../naming";
+import { ComponentResourceOptions, all } from "@pulumi/pulumi";
+import { Transform, transform } from "../component";
+import { Input } from "../input";
+import { DEFAULT_TEAM_ID } from "./account-id";
+
+export interface DnsArgs {
+  /**
+   * The domain name in your Vercel account to create the record in.
+   *
+   * @example
+   * ```js
+   * {
+   *   domain: "example.com"
+   * }
+   * ```
+   */
+  domain: Input<string>;
+  /**
+   * [Transform](/docs/components#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the Vercel record resource.
+     */
+    record?: Transform<DnsRecordArgs>;
+  };
+}
+
+export function dns(args: DnsArgs) {
+  return {
+    provider: "vercel",
+    createAlias,
+    createCaa,
+    createRecord,
+  } satisfies Dns;
+
+  function createAlias(
+    namePrefix: string,
+    record: AliasRecord,
+    opts: ComponentResourceOptions,
+  ) {
+    return createRecord(
+      namePrefix,
+      {
+        name: record.name,
+        // Cannot set CNAME record on the apex domain
+        type: all([args.domain, record.name]).apply(([domain, recordName]) =>
+          recordName.startsWith(domain) ? "ALIAS" : "CNAME",
+        ),
+        value: record.aliasName,
+      },
+      opts,
+    );
+  }
+
+  function createCaa(
+    namePrefix: string,
+    recordName: string,
+    opts: ComponentResourceOptions,
+  ) {
+    // Need to use the OverridableDnsRecord instead of the vercel.DnsRecord to
+    // ignore existing CAA records. This is because the CAA records are not
+    // removed.
+    return [
+      new OverridableDnsRecord(
+        `${namePrefix}CaaRecord`,
+        {
+          domain: args.domain,
+          name: args.domain,
+          type: "CAA",
+          value: `0 issue "amazonaws.com"`,
+        },
+        opts,
+      ),
+      new OverridableDnsRecord(
+        `${namePrefix}CaaWildcardRecord`,
+        {
+          domain: args.domain,
+          name: args.domain,
+          type: "CAA",
+          value: `0 issuewild "amazonaws.com"`,
+        },
+        opts,
+      ),
+    ];
+  }
+
+  function createRecord(
+    namePrefix: string,
+    record: Record,
+    opts: ComponentResourceOptions,
+  ) {
+    return all([args.domain, record]).apply(([domain, record]) => {
+      const nameSuffix = logicalName(record.name);
+      const recordName = validateRecordName();
+      const dnsRecord = createRecord();
+      return dnsRecord;
+
+      function validateRecordName() {
+        const recordName = record.name.replace(/\.$/, "");
+        if (!recordName.endsWith(domain))
+          throw new Error(
+            `Record name "${recordName}" is not a subdomain of "${domain}".`,
+          );
+        return recordName.slice(0, -(domain.length + 1));
+      }
+
+      function createRecord() {
+        return new DnsRecord(
+          ...transform(
+            args.transform?.record,
+            `${namePrefix}${record.type}Record${nameSuffix}`,
+            {
+              domain: args.domain,
+              type: record.type,
+              name: recordName,
+              value: record.value,
+              mxPriority: record.priority,
+              teamId: DEFAULT_TEAM_ID,
+              ttl: 60,
+            },
+            opts,
+          ),
+        );
+      }
+    });
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from "./account-id";
+export * from "./dns";

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

@@ -0,0 +1,34 @@
+import { CustomResourceOptions, Input, Output, dynamic } from "@pulumi/pulumi";
+import { rpc } from "../../rpc/rpc.js";
+
+export interface DnsRecordInputs {
+  domain: Input<string>;
+  type: Input<string>;
+  name: Input<string>;
+  value: Input<string>;
+  mxPriority?: Input<number>;
+}
+
+export interface DnsRecord {
+  recordId: Output<string>;
+}
+
+export class DnsRecord extends dynamic.Resource {
+  constructor(
+    name: string,
+    args: DnsRecordInputs,
+    opts?: CustomResourceOptions,
+  ) {
+    super(
+      new rpc.Provider("Vercel.DnsRecord"),
+      `${name}.sst.vercel.DnsRecord`,
+      {
+        ...args,
+        recordId: undefined,
+        teamId: process.env.VERCEL_TEAM_ID,
+        apiToken: process.env.VERCEL_API_TOKEN!,
+      },
+      opts,
+    );
+  }
+}