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

package/platform/src/components/duration.ts

@@ -0,0 +1,67 @@
+export type Duration = `${number} ${
+  | "second"
+  | "seconds"
+  | "minute"
+  | "minutes"
+  | "hour"
+  | "hours"
+  | "day"
+  | "days"}`;
+
+export type DurationSeconds = `${number} ${"second" | "seconds"}`;
+
+export type DurationMinutes = `${number} ${
+  | "second"
+  | "seconds"
+  | "minute"
+  | "minutes"}`;
+
+export type DurationHours = `${number} ${
+  | "second"
+  | "seconds"
+  | "minute"
+  | "minutes"
+  | "hour"
+  | "hours"}`;
+
+export type DurationDays = `${number} ${"day" | "days"}`;
+
+export function toSeconds(
+  duration: Duration | DurationMinutes | DurationSeconds | DurationDays,
+) {
+  const [count, unit] = duration.split(" ");
+  const countNum = parseInt(count);
+  const unitLower = unit.toLowerCase();
+  if (unitLower.startsWith("second")) {
+    return countNum;
+  } else if (unitLower.startsWith("minute")) {
+    return countNum * 60;
+  } else if (unitLower.startsWith("hour")) {
+    return countNum * 3600;
+  } else if (unitLower.startsWith("day")) {
+    return countNum * 86400;
+  }
+
+  throw new Error(`Invalid duration ${duration}`);
+}
+
+export function toMilliseconds(
+  duration: Duration | DurationMinutes | DurationSeconds | DurationDays,
+) {
+  return toSeconds(duration) * 1000;
+}
+
+export function toDays(duration: Duration) {
+  const [count, unit] = duration.split(" ");
+  const countNum = parseInt(count);
+  const unitLower = unit.toLowerCase();
+
+  if (unitLower.startsWith("day")) {
+    return countNum;
+  }
+
+  const DAYS_IN_SECONDS = 86400;
+  const seconds = toSeconds(duration);
+  const result = seconds / DAYS_IN_SECONDS;
+  return Math.ceil(result);
+}

package/platform/src/components/error.ts

@@ -0,0 +1,5 @@
+export class VisibleError extends Error {
+  constructor(...message: string[]) {
+    super(message.join("\n"));
+  }
+}

package/platform/src/components/esbuild.ts

@@ -0,0 +1,15 @@
+import type { BuildOptions } from "esbuild";
+
+export type EsbuildOptions = Pick<
+  BuildOptions,
+  | "target"
+  | "sourcemap"
+  | "keepNames"
+  | "define"
+  | "banner"
+  | "external"
+  | "inject"
+  | "nodePaths"
+  | "mainFields"
+  | "conditions"
+>;

package/platform/src/components/experimental/dev-command.ts

@@ -0,0 +1,127 @@
+import { ComponentResourceOptions, output } from "@pulumi/pulumi";
+import { Component } from "../component";
+import { Link } from "../link.js";
+import { Input } from "../input";
+
+export interface DevCommandArgs {
+  dev?: {
+    /**
+     * The command that `sst dev` runs to start this in dev mode.
+     * @default `"npm run dev"`
+     */
+    command?: Input<string>;
+    /**
+     * Configure if you want to automatically start this when `sst dev` starts. You can still
+     * start it manually later.
+     * @default `true`
+     */
+    autostart?: Input<boolean>;
+    /**
+     * Change the directory from where the `command` is run.
+     * @default The project root.
+     */
+    directory?: Input<string>;
+    /**
+     * The title of the tab in the multiplexer.
+     *
+     * @default The name of the component.
+     */
+    title?: Input<string>;
+  };
+  /**
+   * [Link resources](/docs/linking/) to your command. This will allow you to access it in your
+   * command using the [SDK](/docs/reference/sdk/).
+   *
+   * @example
+   *
+   * Takes a list of resources to link.
+   *
+   * ```js
+   * {
+   *   link: [bucket, stripeKey]
+   * }
+   * ```
+   */
+  link?: Input<any[]>;
+  /**
+   * Set environment variables for this command.
+   *
+   * @example
+   * ```js
+   * {
+   *   environment: {
+   *     API_URL: api.url,
+   *     STRIPE_PUBLISHABLE_KEY: "pk_test_123"
+   *   }
+   * }
+   * ```
+   */
+  environment?: Input<Record<string, Input<string>>>;
+  /**
+   * @internal
+   */
+  aws?: {
+    role: Input<string>;
+  };
+}
+
+/**
+ * The `DevCommand` lets you run a command in a separate pane when you run `sst dev`.
+ *
+ * :::note
+ * This is an experimental feature and the API may change in the future.
+ * :::
+ *
+ * The `sst dev` CLI starts a multiplexer with panes for separate processes. This component allows you to add a process to it.
+ *
+ * :::tip
+ * This component does not do anything on deploy.
+ * :::
+ *
+ * This component only works in `sst dev`. It does not do anything in `sst deploy`.
+ *
+ * #### Example
+ *
+ * For example, you can use this to run Drizzle Studio locally.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.x.DevCommand("Studio", {
+ *   link: [rds],
+ *   dev: {
+ *     autostart: true,
+ *     command: "npx drizzle-kit studio",
+ *   },
+ * });
+ * ```
+ *
+ * Here `npx drizzle-kit studio` will be run in `sst dev` and will show up under the **Studio** tab. It'll also have access to the links from `rds`.
+ */
+export class DevCommand extends Component {
+  constructor(
+    name: string,
+    args: DevCommandArgs,
+    opts?: ComponentResourceOptions,
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    this.registerOutputs({
+      _dev: {
+        links: output(args.link || [])
+          .apply(Link.build)
+          .apply((links) => links.map((link) => link.name)),
+        environment: args.environment,
+        title: args.dev?.title,
+        directory: args.dev?.directory,
+        autostart: args.dev?.autostart !== false,
+        command: args.dev?.command,
+        aws: {
+          role: args.aws?.role,
+        },
+      },
+    });
+  }
+}
+
+const __pulumiType = "sst:sst:DevCommand";
+// @ts-expect-error
+DevCommand.__pulumiType = __pulumiType;

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

@@ -0,0 +1 @@
+export * from "./dev-command.js";

package/platform/src/components/groups.ts

@@ -0,0 +1,9 @@
+// The components for each provider, which the `sst` global has as `sst.aws`
+// and so on (index.ts), and a file imports as `sst/components/aws`. Each
+// group loads the providers its components use. A test is given the groups
+// whose providers are installed (`sst/testing`).
+export const groups = {
+  aws: () => import("./aws/index"),
+  cloudflare: () => import("./cloudflare/index"),
+  vercel: () => import("./vercel/index"),
+};

package/platform/src/components/index.ts

@@ -0,0 +1,9 @@
+// The `sst` global: what SST's components share, and the components for each
+// provider. A file imports the same from `sst/components` and from each
+// group, like `sst/components/aws`. A new group goes here, in groups.ts, in
+// the CLI's PlatformModules (pkg/js) and in the vitest alias
+// (testing/vitest.ts), and tests check that they agree.
+export * from "./core.js";
+export * as aws from "./aws/index.js";
+export * as cloudflare from "./cloudflare/index.js";
+export * as vercel from "./vercel/index.js";

package/platform/src/components/input.ts

@@ -0,0 +1,2 @@
+import type { Input as PulumiInput } from "@pulumi/pulumi";
+export type Input<T> = PulumiInput<T>;

package/platform/src/components/link.ts

@@ -0,0 +1,201 @@
+import {
+  Input,
+  Output,
+  runtime,
+  output,
+  all,
+  ComponentResource,
+} from "@pulumi/pulumi";
+import { VisibleError } from "./error.js";
+import { Linkable } from "./linkable.js";
+
+export namespace Link {
+  function normalizeType(type: string) {
+    return type.replaceAll(":", ".");
+  }
+
+  export interface Definition<
+    Properties extends Record<string, any> = Record<string, any>,
+  > {
+    properties: Properties;
+    include?: {
+      type: string;
+      [key: string]: any;
+    }[];
+  }
+
+  export class Ref extends ComponentResource {
+    constructor(target: string, type: string, properties: any, include?: any) {
+      super(
+        "sst:sst:LinkRef",
+        target + "LinkRef",
+        {
+          properties,
+          include,
+        },
+        {},
+      );
+      this.registerOutputs({
+        target: target,
+        include,
+        properties: {
+          type: normalizeType(type),
+          ...properties,
+        },
+      });
+    }
+  }
+
+  export function reset() {
+    const links = new Set<string>();
+    // Ensure component names are unique
+    runtime.registerStackTransformation((args) => {
+      const isLinkable =
+        args.type.startsWith("sst:") ||
+        Linkable.wrappedResources.has(args.type);
+      if (isLinkable && !args.opts.parent) {
+        const lcname = args.name.toLowerCase();
+
+        // Reserve "App" (case-insensitive) for Resource.App's app name and stage.
+        if (lcname === "app") {
+          throw new VisibleError(
+            `Component name "${args.name}" conflicts with "Resource.App", which stores the app name and stage. Choose a name other than "App" (case-insensitive) for your "${args.type}" component.`,
+          );
+        }
+
+        // Ensure linkable resources have unique names. This includes all SST components
+        // and non-SST components that are linkable.
+        if (links.has(lcname)) {
+          throw new VisibleError(`Component name ${args.name} is not unique.`);
+        }
+        links.add(lcname);
+      }
+      return {
+        opts: args.opts,
+        props: args.props,
+      };
+    });
+
+    // Create link refs
+    runtime.registerStackTransformation((args) => {
+      const resource = args.resource;
+      process.nextTick(() => {
+        if (Link.isLinkable(resource) && !args.opts.parent) {
+          try {
+            const link = resource.getSSTLink();
+            new Ref(args.name, args.type, link.properties, link.include);
+          } catch (e) {}
+        }
+      });
+      return {
+        opts: args.opts,
+        props: args.props,
+      };
+    });
+  }
+
+  export interface Linkable {
+    urn: Output<string>;
+    getSSTLink(): Definition;
+  }
+
+  export function isLinkable(obj: any): obj is Linkable {
+    return "getSSTLink" in obj;
+  }
+
+  export function build(links: any[]) {
+    return links
+      .map((link) => {
+        if (!link)
+          throw new VisibleError(
+            "An undefined link was passed into a `link` array.",
+          );
+        return link;
+      })
+      .filter((l) => isLinkable(l))
+      .map((l: Linkable) => {
+        const link = l.getSSTLink();
+        return all([l.urn, link]).apply(([urn, link]) => ({
+          name: urn.split("::").at(-1)!,
+          properties: {
+            ...link.properties,
+            type: normalizeType(urn.split("::").at(-2)!),
+          },
+        }));
+      });
+  }
+
+  export function getProperties(links?: Input<any[]>) {
+    const linkProperties = output(links ?? []).apply((links) =>
+      links
+        .map((link) => {
+          if (!link)
+            throw new VisibleError(
+              "An undefined link was passed into a `link` array.",
+            );
+          return link;
+        })
+        .filter((l) => isLinkable(l))
+        .map((l: Linkable) => ({
+          urn: l.urn,
+          properties: l.getSSTLink().properties,
+        })),
+    );
+
+    return output(linkProperties).apply((e) =>
+      Object.fromEntries(
+        e.map(({ urn, properties }) => {
+          const name = urn.split("::").at(-1)!;
+          const data = {
+            ...properties,
+            type: normalizeType(urn.split("::").at(-2)!),
+          };
+          return [name, data];
+        }),
+      ),
+    );
+  }
+
+  export function propertiesToEnv(
+    properties: ReturnType<typeof getProperties>,
+  ) {
+    return output(properties).apply((properties) => {
+      const env = Object.fromEntries(
+        Object.entries(properties).map(([key, value]) => {
+          return [`SST_RESOURCE_${key}`, JSON.stringify(value)];
+        }),
+      );
+      env["SST_RESOURCE_App"] = JSON.stringify({
+        name: $app.name,
+        stage: $app.stage,
+      });
+      return env;
+    });
+  }
+
+  export function getInclude<T>(
+    type: string,
+    input?: Input<any[]>,
+  ): Output<T[]> {
+    if (!input) return output([]);
+    return output(input).apply((links) => {
+      return links.filter(isLinkable).flatMap((l: Linkable) => {
+        const link = l.getSSTLink();
+        return (link.include || []).filter((i) => i.type === type) as T[];
+      });
+    });
+  }
+
+  /** @deprecated
+   * Use sst.Linkable.wrap instead.
+   */
+  export function linkable<T>(
+    obj: { new (...args: any[]): T },
+    cb: (resource: T) => Definition,
+  ) {
+    console.warn("sst.linkable is deprecated. Use sst.Linkable.wrap instead.");
+    obj.prototype.getSSTLink = function () {
+      return cb(this);
+    };
+  }
+}