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

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

@@ -0,0 +1,61 @@
+export * from "./alb.js";
+export * from "./analog.js";
+export * from "./apigatewayv1.js";
+export * from "./apigatewayv2.js";
+export * from "./apigateway-websocket.js";
+export * from "./app-sync.js";
+export * from "./astro.js";
+export * from "./aurora.js";
+export * from "./auth.js";
+export * from "./bucket.js";
+export * from "./bus.js";
+export * from "./cluster.js";
+export * from "./cognito-identity-pool.js";
+export * from "./cognito-user-pool.js";
+export * from "./cron.js";
+export * from "./cron-v2.js";
+export * from "./dns.js";
+export * from "./dsql.js";
+export * from "./dynamo.js";
+export * from "./efs.js";
+export * from "./email.js";
+export * from "./function.js";
+export * from "./kinesis-stream.js";
+export * from "./microvm.js";
+export * from "./nextjs.js";
+export * from "./opencontrol.js";
+export * from "./open-search.js";
+export * from "./postgres.js";
+export * from "./mysql.js";
+export * from "./queue.js";
+export * from "./realtime.js";
+export * from "./react.js";
+export * from "./redis.js";
+export * from "./remix.js";
+export * from "./router.js";
+export * from "./service.js";
+export * from "./sns-topic.js";
+export * from "./solid-start.js";
+export * from "./step-functions.js";
+export * from "./tan-stack-start.js";
+export * from "./task.js";
+export * from "./nuxt.js";
+export * from "./static-site.js";
+export * from "./svelte-kit.js";
+export * from "./vector.js";
+export * from "./vpc.js";
+export * from "./workflow.js";
+export { linkable } from "./linkable.js";
+export { permission, iamStatements } from "./permission.js";
+export { functionPart } from "./helpers/function-part.js";
+export { iamEdit } from "./iam-edit.js";
+
+// internal components
+export * from "./cdn.js";
+export * from "./dns-validated-certificate.js";
+
+// The V5 components, as `sst.aws.v5`
+export * as v5 from "./v5/index.js";
+
+// How the V5 components take over from the ones they replace
+import "./takeover/index.js";

package/platform/src/components/aws/kinesis-stream-lambda-subscriber.ts

@@ -0,0 +1,122 @@
+import { lambda } from "@pulumi/aws";
+import { type ComponentResourceOptions, output } from "@pulumi/pulumi";
+import { Component, transform } from "../component";
+import { Input } from "../input.js";
+import { FunctionArgs } from "./function.js";
+import { KinesisStreamLambdaSubscriberArgs } from "./kinesis-stream.js";
+import { FunctionBuilder, functionBuilder } from "./helpers/function-builder";
+
+export interface Args extends KinesisStreamLambdaSubscriberArgs {
+  /**
+   * The Kinesis stream to use.
+   */
+  stream: Input<{
+    /**
+     * The ARN of the stream.
+     */
+    arn: Input<string>;
+  }>;
+  /**
+   * The subscriber function.
+   */
+  subscriber: Input<string | FunctionArgs>;
+}
+
+/**
+ * The `KinesisStreamLambdaSubscriber` component is internally used by the `KinesisStream` component to
+ * add a consumer to [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `subscribe` method of the `KinesisStream` component.
+ */
+export class KinesisStreamLambdaSubscriber extends Component {
+  private readonly fn: FunctionBuilder;
+  private readonly eventSourceMapping: lambda.EventSourceMapping;
+  constructor(name: string, args: Args, opts?: ComponentResourceOptions) {
+    super(__pulumiType, name, args, opts);
+
+    const self = this;
+    const stream = output(args.stream);
+    const fn = createFunction();
+    const eventSourceMapping = createEventSourceMapping();
+
+    this.fn = fn;
+    this.eventSourceMapping = eventSourceMapping;
+
+    function createFunction() {
+      return output(args.subscriber).apply((subscriber) => {
+        return functionBuilder(
+          `${name}Function`,
+          subscriber,
+          {
+            description: `Subscribed to ${name}`,
+            permissions: [
+              {
+                actions: [
+                  "kinesis:DescribeStream",
+                  "kinesis:DescribeStreamSummary",
+                  "kinesis:GetRecords",
+                  "kinesis:GetShardIterator",
+                  "kinesis:ListShards",
+                  "kinesis:ListStreams",
+                  "kinesis:SubscribeToShard",
+                ],
+                resources: [stream.arn],
+              },
+            ],
+          },
+          undefined,
+          { parent: self },
+        );
+      });
+    }
+
+    function createEventSourceMapping() {
+      return new lambda.EventSourceMapping(
+        ...transform(
+          args.transform?.eventSourceMapping,
+          `${name}EventSourceMapping`,
+          {
+            eventSourceArn: stream.arn,
+            functionName: fn.targetArn,
+            startingPosition: "LATEST",
+            filterCriteria: args.filters && {
+              filters: output(args.filters).apply((filters) =>
+                filters.map((filter) => ({
+                  pattern: JSON.stringify(filter),
+                })),
+              ),
+            },
+          },
+          { parent: self },
+        ),
+      );
+    }
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    const self = this;
+    return {
+      /**
+       * The Lambda function that'll be notified.
+       */
+      get function() {
+        return self.fn.apply((fn) => fn.getFunction());
+      },
+      /**
+       * The Lambda event source mapping.
+       */
+      eventSourceMapping: self.eventSourceMapping,
+    };
+  }
+}
+
+const __pulumiType = "sst:aws:KinesisStreamLambdaSubscriber";
+// @ts-expect-error
+KinesisStreamLambdaSubscriber.__pulumiType = __pulumiType;

package/platform/src/components/aws/kinesis-stream.ts

@@ -0,0 +1,416 @@
+import { ComponentResourceOptions, Output, all, output } from "@pulumi/pulumi";
+import { kinesis, lambda } from "@pulumi/aws";
+import { Component, Transform, transform } from "../component.js";
+import { Input } from "../input.js";
+import { Link } from "../link.js";
+import { hashStringToPrettyString, logicalName } from "../naming.js";
+import { FunctionArgs, FunctionArn } from "./function.js";
+import { KinesisStreamLambdaSubscriber } from "./kinesis-stream-lambda-subscriber.js";
+import { parseKinesisStreamArn } from "./helpers/arn.js";
+import { permission } from "./permission.js";
+import { isFunctionSubscriber } from "./helpers/subscriber.js";
+
+export interface KinesisStreamArgs {
+  /**
+   * [Transform](/docs/components#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the Kinesis stream resource.
+     */
+    stream?: Transform<kinesis.StreamArgs>;
+  };
+}
+
+export interface KinesisStreamLambdaSubscriberArgs {
+  /**
+   * Filter the events that'll be processed by the `subscribers` functions.
+   *
+   * :::tip
+   * You can pass in up to 5 different filters.
+   * :::
+   *
+   * You can pass in up to 5 different filter policies. These will logically ORed together. Meaning that if any single policy matches, the record will be processed. Learn more about the [filter rule syntax](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html#filtering-syntax).
+   *
+   * @example
+   * For example, if your Kinesis stream contains events in this JSON format.
+   * ```js
+   * {
+   *   record: 12345,
+   *   order: {
+   *     type: "buy",
+   *     stock: "ANYCO",
+   *     quantity: 1000
+   *   }
+   * }
+   * ```
+   *
+   * To process only those events where the `type` is `buy`.
+   * ```js
+   * {
+   *   filters: [
+   *     {
+   *       data: {
+   *         order: {
+   *           type: ["buy"],
+   *         },
+   *       },
+   *     },
+   *   ],
+   * }
+   * ```
+   *
+   */
+  filters?: Input<Input<Record<string, any>>[]>;
+  /**
+   * [Transform](/docs/components#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the Lambda Event Source Mapping resource.
+     */
+    eventSourceMapping?: Transform<lambda.EventSourceMappingArgs>;
+  };
+}
+
+/**
+ * The `KinesisStream` component lets you add an [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) to your app.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * ```ts title="sst.config.ts"
+ * const stream = new sst.aws.KinesisStream("MyStream");
+ * ```
+ *
+ * #### Subscribe to a stream
+ *
+ * ```ts title="sst.config.ts"
+ * stream.subscribe("MySubscriber", "src/subscriber.handler");
+ * ```
+ *
+ * #### Link the stream to a resource
+ *
+ * You can link the stream to other resources, like a function or your Next.js app.
+ *
+ * ```ts {2} title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [stream]
+ * });
+ * ```
+ *
+ * Once linked, you can write to the stream from your function code.
+ *
+ * ```ts title="app/page.tsx" {1,7}
+ * import { Resource } from "sst";
+ * import { KinesisClient, PutRecordCommand } from "@aws-sdk/client-kinesis";
+ *
+ * const client = new KinesisClient();
+ *
+ * await client.send(new PutRecordCommand({
+ *   StreamName: Resource.MyStream.name,
+ *   Data: JSON.stringify({ foo: "bar" }),
+ *   PartitionKey: "myKey",
+ * }));
+ * ```
+ */
+export class KinesisStream extends Component implements Link.Linkable {
+  private constructorName: string;
+  private constructorOpts: ComponentResourceOptions;
+  private stream: kinesis.Stream;
+
+  constructor(
+    name: string,
+    args: KinesisStreamArgs = {},
+    opts: ComponentResourceOptions = {},
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    const parent = this;
+    const stream = createStream();
+    this.stream = stream;
+    this.constructorName = name;
+    this.constructorOpts = opts;
+
+    function createStream() {
+      return new kinesis.Stream(
+        ...transform(
+          args?.transform?.stream,
+          `${name}Stream`,
+          {
+            streamModeDetails: {
+              streamMode: "ON_DEMAND",
+            },
+          },
+          { parent },
+        ),
+      );
+    }
+  }
+
+  /**
+   * Subscribe to the Kinesis stream.
+   *
+   * @param name The name of the subscriber.
+   * @param subscriber The function that'll be notified.
+   * @param args Configure the subscription.
+   *
+   * @example
+   *
+   * ```js title="sst.config.ts"
+   * stream.subscribe("MySubscriber", "src/subscriber.handler");
+   * ```
+   *
+   * Add a filter to the subscription.
+   *
+   * ```js title="sst.config.ts"
+   * stream.subscribe("MySubscriber", "src/subscriber.handler", {
+   *   filters: [
+   *     {
+   *       data: {
+   *         order: {
+   *           type: ["buy"],
+   *         },
+   *       },
+   *     },
+   *   ],
+   * });
+   * ```
+   *
+   * Customize the subscriber function.
+   *
+   * ```js title="sst.config.ts"
+   * stream.subscribe("MySubscriber", {
+   *   handler: "src/subscriber.handler",
+   *   timeout: "60 seconds"
+   * });
+   * ```
+   *
+   * Or pass in the ARN of an existing Lambda function.
+   *
+   * ```js title="sst.config.ts"
+   * stream.subscribe("MySubscriber", "arn:aws:lambda:us-east-1:123456789012:function:my-function");
+   * ```
+   */
+  public subscribe(
+    name: string,
+    subscriber: Input<string | FunctionArgs | FunctionArn>,
+    args?: KinesisStreamLambdaSubscriberArgs,
+  ): Output<KinesisStreamLambdaSubscriber>;
+  /**
+   * @deprecated The subscribe function now requires a `name` parameter as the first argument.
+   * To migrate, remove the current subscriber, deploy the changes, and then add the subscriber
+   * back with the new `name` argument.
+   */
+  public subscribe(
+    subscriber: Input<string | FunctionArgs | FunctionArn>,
+    args?: KinesisStreamLambdaSubscriberArgs,
+  ): Output<KinesisStreamLambdaSubscriber>;
+  public subscribe(nameOrSubscriber: any, subscriberOrArgs?: any, args?: any) {
+    return isFunctionSubscriber(subscriberOrArgs).apply((v) =>
+      v
+        ? KinesisStream._subscribe(
+            nameOrSubscriber, // name
+            this.constructorName,
+            this.nodes.stream.arn,
+            subscriberOrArgs, // subscriber
+            args,
+            { provider: this.constructorOpts.provider },
+          )
+        : KinesisStream._subscribeV1(
+            this.constructorName,
+            this.nodes.stream.arn,
+            nameOrSubscriber, // subscriber
+            subscriberOrArgs, // args
+            { provider: this.constructorOpts.provider },
+          ),
+    );
+  }
+
+  /**
+   * Subscribe to the Kinesis stream that was not created in your app.
+   *
+   * @param name The name of the subscriber.
+   * @param streamArn The ARN of the Kinesis Stream to subscribe to.
+   * @param subscriber The function that'll be notified.
+   * @param args Configure the subscription.
+   *
+   * @example
+   *
+   * For example, let's say you have the ARN of an existing Kinesis stream.
+   *
+   * ```js title="sst.config.ts"
+   * const streamArn = "arn:aws:kinesis:us-east-1:123456789012:stream/MyStream";
+   * ```
+   *
+   * You can subscribe to it by passing in the ARN.
+   *
+   * ```js title="sst.config.ts"
+   * sst.aws.KinesisStream.subscribe("MySubscriber", streamArn, "src/subscriber.handler");
+   * ```
+   *
+   * Add a filter to the subscription.
+   *
+   * ```js title="sst.config.ts"
+   * sst.aws.KinesisStream.subscribe("MySubscriber", streamArn, "src/subscriber.handler", {
+   *   filters: [
+   *     {
+   *       data: {
+   *         order: {
+   *           type: ["buy"],
+   *         },
+   *       },
+   *     },
+   *   ],
+   * });
+   * ```
+   *
+   * Customize the subscriber function.
+   *
+   * ```js title="sst.config.ts"
+   * sst.aws.KinesisStream.subscribe("MySubscriber", streamArn, {
+   *   handler: "src/subscriber.handler",
+   *   timeout: "60 seconds"
+   * });
+   * ```
+   */
+  public static subscribe(
+    name: string,
+    streamArn: Input<string>,
+    subscriber: Input<string | FunctionArgs | FunctionArn>,
+    args?: KinesisStreamLambdaSubscriberArgs,
+  ): Output<KinesisStreamLambdaSubscriber>;
+  /**
+   * @deprecated The subscribe function now requires a `name` parameter as the first argument.
+   * To migrate, remove the current subscriber, deploy the changes, and then add the subscriber
+   * back with the new `name` argument.
+   */
+  public static subscribe(
+    streamArn: Input<string>,
+    subscriber: Input<string | FunctionArgs | FunctionArn>,
+    args?: KinesisStreamLambdaSubscriberArgs,
+  ): Output<KinesisStreamLambdaSubscriber>;
+  public static subscribe(
+    nameOrStreamArn: any,
+    streamArnOrSubscriber: any,
+    subscriberOrArgs?: any,
+    args?: any,
+  ) {
+    return isFunctionSubscriber(subscriberOrArgs).apply((v) =>
+      v
+        ? output(streamArnOrSubscriber).apply((streamArn) =>
+            this._subscribe(
+              nameOrStreamArn, // name
+              logicalName(parseKinesisStreamArn(streamArn).streamName),
+              streamArn,
+              subscriberOrArgs, // subscriber
+              args,
+            ),
+          )
+        : output(nameOrStreamArn).apply((streamArn) =>
+            this._subscribeV1(
+              logicalName(parseKinesisStreamArn(streamArn).streamName),
+              streamArn,
+              streamArnOrSubscriber, // subscriber
+              subscriberOrArgs, // args
+            ),
+          ),
+    );
+  }
+
+  private static _subscribe(
+    subscriberName: string,
+    name: string,
+    streamArn: Input<string>,
+    subscriber: Input<string | FunctionArgs | FunctionArn>,
+    args: KinesisStreamLambdaSubscriberArgs = {},
+    opts: ComponentResourceOptions = {},
+  ) {
+    return output(args).apply(
+      (args) =>
+        new KinesisStreamLambdaSubscriber(
+          `${name}Subscriber${subscriberName}`,
+          {
+            stream: { arn: streamArn },
+            subscriber,
+            ...args,
+          },
+          opts,
+        ),
+    );
+  }
+
+  private static _subscribeV1(
+    name: string,
+    streamArn: Input<string>,
+    subscriber: Input<string | FunctionArgs | FunctionArn>,
+    args: KinesisStreamLambdaSubscriberArgs = {},
+    opts: ComponentResourceOptions = {},
+  ) {
+    return all([streamArn, subscriber, args]).apply(
+      ([streamArn, subscriber, args]) => {
+        const suffix = logicalName(
+          hashStringToPrettyString(
+            [
+              streamArn,
+              JSON.stringify(args.filters ?? {}),
+              typeof subscriber === "string" ? subscriber : subscriber.handler,
+            ].join(""),
+            6,
+          ),
+        );
+        return new KinesisStreamLambdaSubscriber(
+          `${name}Subscriber${suffix}`,
+          {
+            stream: { arn: streamArn },
+            subscriber,
+            ...args,
+          },
+          opts,
+        );
+      },
+    );
+  }
+
+  public get name() {
+    return this.stream.name;
+  }
+
+  public get arn() {
+    return this.stream.arn;
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The Amazon Kinesis Data Stream.
+       */
+      stream: this.stream,
+    };
+  }
+
+  /** @internal */
+  getSSTLink() {
+    return {
+      properties: {
+        name: this.stream.name,
+      },
+      include: [
+        permission({
+          actions: ["kinesis:*"],
+          resources: [this.nodes.stream.arn],
+        }),
+      ],
+    };
+  }
+}
+
+const __pulumiType = "sst:aws:KinesisStream";
+// @ts-expect-error
+KinesisStream.__pulumiType = __pulumiType;

package/platform/src/components/aws/linkable.ts

@@ -0,0 +1,32 @@
+import { VisibleError } from "../error";
+import { FunctionPermissionArgs } from "./function.js";
+
+export const URL_UNAVAILABLE = "http://url-unavailable-in-dev.mode";
+
+/** @deprecated
+ * instead try
+ * ```
+ * sst.Linkable.wrap(MyResource, (resource) => ({
+ *   properties: { ... },
+ *   with: [
+ *     sst.aws.permission({ actions: ["foo:*"], resources: [resource.arn] })
+ *   ]
+ * }))
+ * ```
+ */
+export function linkable<T>(
+  obj: { new (...args: any[]): T },
+  cb: (resource: T) => FunctionPermissionArgs[],
+) {
+  throw new VisibleError(
+    [
+      "sst.aws.linkable is deprecated. Use sst.Linkable.wrap instead.",
+      "sst.Linkable.wrap(MyResource, (resource) => ({",
+      "  properties: { ... },",
+      "  with: [",
+      '    sst.aws.permission({ actions: ["foo:*"], resources: [resource.arn] })',
+      "  ]",
+      "}))",
+    ].join("\n"),
+  );
+}

package/platform/src/components/aws/logging.ts

@@ -0,0 +1,25 @@
+export const RETENTION = {
+  "1 day": 1,
+  "3 days": 3,
+  "5 days": 5,
+  "1 week": 7,
+  "2 weeks": 14,
+  "1 month": 30,
+  "2 months": 60,
+  "3 months": 90,
+  "4 months": 120,
+  "5 months": 150,
+  "6 months": 180,
+  "1 year": 365,
+  "13 months": 400,
+  "18 months": 545,
+  "2 years": 731,
+  "3 years": 1096,
+  "5 years": 1827,
+  "6 years": 2192,
+  "7 years": 2557,
+  "8 years": 2922,
+  "9 years": 3288,
+  "10 years": 3653,
+  forever: 0,
+};