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

package/platform/src/components/aws/apigatewayv1-api-key.ts

@@ -0,0 +1,90 @@
+import { apigateway } from "@pulumi/aws";
+import { ComponentResourceOptions, Input } from "@pulumi/pulumi";
+import { Component } from "../component";
+import { ApiGatewayV1ApiKeyArgs } from "./apigatewayv1";
+import { Link } from "../link";
+
+export interface ApiKeyArgs extends ApiGatewayV1ApiKeyArgs {
+  /**
+   * The API Gateway REST API to use for the API key.
+   */
+  apiId: Input<string>;
+  /**
+   * The API Gateway Usage Plan to use for the API key.
+   */
+  usagePlanId: Input<string>;
+}
+
+/**
+ * The `ApiGatewayV1ApiKey` component is internally used by the `ApiGatewayV1UsagePlan` component
+ * to add API keys to [Amazon API Gateway REST API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `addApiKey` method of the `ApiGatewayV1UsagePlan` component.
+ */
+export class ApiGatewayV1ApiKey extends Component implements Link.Linkable {
+  private readonly key: apigateway.ApiKey;
+
+  constructor(
+    name: string,
+    args: ApiKeyArgs,
+    opts: ComponentResourceOptions = {},
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    const self = this;
+
+    this.key = new apigateway.ApiKey(
+      `${name}ApiKey`,
+      {
+        value: args.value,
+      },
+      { parent: self },
+    );
+
+    new apigateway.UsagePlanKey(
+      `${name}UsagePlanKey`,
+      {
+        keyId: this.key.id,
+        keyType: "API_KEY",
+        usagePlanId: args.usagePlanId,
+      },
+      { parent: self },
+    );
+  }
+
+  /**
+   * The API key value.
+   */
+  public get value() {
+    return this.key.value;
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The API Gateway API Key.
+       */
+      apiKey: this.key,
+    };
+  }
+
+  /** @internal */
+  public getSSTLink() {
+    return {
+      properties: {
+        value: this.value,
+      },
+    };
+  }
+}
+
+const __pulumiType = "sst:aws:ApiGatewayV1ApiKey";
+// @ts-expect-error
+ApiGatewayV1ApiKey.__pulumiType = __pulumiType;

package/platform/src/components/aws/apigatewayv1-authorizer.ts

@@ -0,0 +1,178 @@
+import {
+  ComponentResourceOptions,
+  Input,
+  Output,
+  interpolate,
+  output,
+} from "@pulumi/pulumi";
+import { Component, transform } from "../component";
+import { VisibleError } from "../error";
+import { ApiGatewayV1AuthorizerArgs } from "./apigatewayv1";
+import { apigateway, lambda } from "@pulumi/aws";
+import { FunctionBuilder, functionBuilder } from "./helpers/function-builder";
+
+export interface AuthorizerArgs extends ApiGatewayV1AuthorizerArgs {
+  /**
+   * The API Gateway to use for the route.
+   */
+  api: Input<{
+    /**
+     * The name of the API Gateway.
+     */
+    name: Input<string>;
+    /**
+     * The ID of the API Gateway.
+     */
+    id: Input<string>;
+    /**
+     * The execution ARN of the API Gateway.
+     */
+    executionArn: Input<string>;
+  }>;
+}
+
+/**
+ * The `ApiGatewayV1Authorizer` component is internally used by the `ApiGatewayV1` component
+ * to add authorizers to [Amazon API Gateway REST API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `addAuthorizer` method of the `ApiGatewayV1` component.
+ */
+export class ApiGatewayV1Authorizer extends Component {
+  private readonly authorizer: apigateway.Authorizer;
+  private readonly fn?: FunctionBuilder;
+
+  constructor(
+    name: string,
+    args: AuthorizerArgs,
+    opts: ComponentResourceOptions = {},
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    const self = this;
+
+    const api = output(args.api);
+
+    validateSingleAuthorizer();
+    const type = getType();
+
+    const fn = createFunction();
+    const authorizer = createAuthorizer();
+    createPermission();
+
+    this.fn = fn;
+    this.authorizer = authorizer;
+
+    function validateSingleAuthorizer() {
+      const authorizers = [
+        args.requestFunction,
+        args.tokenFunction,
+        args.userPools,
+      ].filter((e) => e);
+
+      if (authorizers.length === 0)
+        throw new VisibleError(
+          `Please provide one of "requestFunction", "tokenFunction", or "userPools" for the ${args.name} authorizer.`,
+        );
+
+      if (authorizers.length > 1) {
+        throw new VisibleError(
+          `Please provide only one of "requestFunction", "tokenFunction", or "userPools" for the ${args.name} authorizer.`,
+        );
+      }
+    }
+
+    function getType() {
+      if (args.tokenFunction) return "TOKEN";
+      if (args.requestFunction) return "REQUEST";
+      if (args.userPools) return "COGNITO_USER_POOLS";
+    }
+
+    function createFunction() {
+      const fn = args.tokenFunction ?? args.requestFunction;
+      if (!fn) return;
+
+      return functionBuilder(
+        `${name}Handler`,
+        fn,
+        {
+          description: interpolate`${api.name} authorizer`,
+        },
+        undefined,
+        { parent: self },
+      );
+    }
+
+    function createPermission() {
+      if (!fn) return;
+
+      return new lambda.Permission(
+        `${name}Permission`,
+        {
+          action: "lambda:InvokeFunction",
+          function: fn.arn,
+          qualifier: fn.qualifier.apply((qualifier) => qualifier!),
+          principal: "apigateway.amazonaws.com",
+          sourceArn: interpolate`${api.executionArn}/authorizers/${authorizer.id}`,
+        },
+        { parent: self },
+      );
+    }
+
+    function createAuthorizer() {
+      return new apigateway.Authorizer(
+        ...transform(
+          args.transform?.authorizer,
+          `${name}Authorizer`,
+          {
+            restApi: api.id,
+            type,
+            name: args.name,
+            providerArns: args.userPools,
+            authorizerUri: fn?.targetInvokeArn,
+            authorizerResultTtlInSeconds: args.ttl,
+            identitySource: args.identitySource,
+          },
+          { parent: self },
+        ),
+      );
+    }
+  }
+
+  /**
+   * The ID of the authorizer.
+   */
+  public get id() {
+    return this.authorizer.id;
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    const self = this;
+    return {
+      /**
+       * The API Gateway Authorizer.
+       */
+      authorizer: this.authorizer,
+      /**
+       * The Lambda function used by the authorizer.
+       */
+      get function() {
+        if (!self.fn)
+          throw new VisibleError(
+            "Cannot access `nodes.function` because the data source does not use a Lambda function.",
+          );
+        return self.fn.apply((fn) => fn.getFunction());
+      },
+    };
+  }
+}
+
+const __pulumiType = "sst:aws:ApiGatewayV1Authorizer";
+// @ts-expect-error
+ApiGatewayV1Authorizer.__pulumiType = __pulumiType;

package/platform/src/components/aws/apigatewayv1-base-route.ts

@@ -0,0 +1,78 @@
+import { Input, Output, interpolate, output } from "@pulumi/pulumi";
+import { Component, transform } from "../component";
+import { apigateway } from "@pulumi/aws";
+import { ApiGatewayV1RouteArgs } from "./apigatewayv1";
+
+export interface ApiGatewayV1BaseRouteArgs extends ApiGatewayV1RouteArgs {
+  /**
+   * The API Gateway to use for the route.
+   */
+  api: Input<{
+    /**
+     * The name of the API Gateway.
+     */
+    name: Input<string>;
+    /**
+     * The ID of the API Gateway.
+     */
+    id: Input<string>;
+    /**
+     * The execution ARN of the API Gateway.
+     */
+    executionArn: Input<string>;
+  }>;
+  /**
+   * The route method.
+   */
+  method: string;
+  /**
+   * The route path.
+   */
+  path: string;
+  /**
+   * The route resource ID.
+   */
+  resourceId: Input<string>;
+}
+
+export function createMethod(
+  name: string,
+  args: ApiGatewayV1BaseRouteArgs,
+  parent: Component,
+) {
+  const { api, method, resourceId, auth, apiKey } = args;
+
+  const authArgs = output(auth).apply((auth) => {
+    if (!auth) return { authorization: "NONE" };
+    if (auth.iam) return { authorization: "AWS_IAM" };
+    if (auth.custom)
+      return { authorization: "CUSTOM", authorizerId: auth.custom };
+    if (auth.cognito)
+      return {
+        authorization: "COGNITO_USER_POOLS",
+        authorizerId: auth.cognito.authorizer,
+        authorizationScopes: auth.cognito.scopes,
+      };
+    return { authorization: "NONE" };
+  });
+
+  return authArgs.apply(
+    (authArgs) =>
+      new apigateway.Method(
+        ...transform(
+          args.transform?.method,
+          `${name}Method`,
+          {
+            restApi: output(api).id,
+            resourceId: resourceId,
+            httpMethod: method,
+            authorization: authArgs.authorization,
+            authorizerId: authArgs.authorizerId,
+            authorizationScopes: authArgs.authorizationScopes,
+            apiKeyRequired: apiKey,
+          },
+          { parent },
+        ),
+      ),
+  );
+}

package/platform/src/components/aws/apigatewayv1-integration-route.ts

@@ -0,0 +1,92 @@
+import {
+  ComponentResourceOptions,
+  Input,
+  Output,
+  output,
+} from "@pulumi/pulumi";
+import { Component, transform } from "../component";
+import { ApiGatewayV1IntegrationArgs } from "./apigatewayv1";
+import { apigateway } from "@pulumi/aws";
+import {
+  ApiGatewayV1BaseRouteArgs,
+  createMethod,
+} from "./apigatewayv1-base-route";
+
+export interface Args extends ApiGatewayV1BaseRouteArgs {
+  /**
+   * The route integration.
+   */
+  integration: ApiGatewayV1IntegrationArgs;
+}
+
+/**
+ * The `ApiGatewayV1IntegrationRoute` component is internally used by the `ApiGatewayV1` component
+ * to add routes to your [API Gateway REST API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `routeIntegration` method of the `ApiGatewayV1` component.
+ */
+export class ApiGatewayV1IntegrationRoute extends Component {
+  private readonly method: Output<apigateway.Method>;
+  private readonly integration: apigateway.Integration;
+
+  constructor(name: string, args: Args, opts?: ComponentResourceOptions) {
+    super(__pulumiType, name, args, opts);
+
+    const self = this;
+    const api = output(args.api);
+
+    const method = createMethod(name, args, self);
+    const integration = createIntegration();
+
+    this.method = method;
+    this.integration = integration;
+
+    function createIntegration() {
+      return new apigateway.Integration(
+        ...transform(
+          args.transform?.integration,
+          `${name}Integration`,
+          {
+            restApi: api.id,
+            resourceId: args.resourceId,
+            httpMethod: method.httpMethod,
+            ...args.integration,
+            type: output(args.integration.type).apply((v) =>
+              v.toUpperCase().replaceAll("-", "_"),
+            ),
+            passthroughBehavior:
+              args.integration.passthroughBehavior &&
+              output(args.integration.passthroughBehavior).apply((v) =>
+                v.toUpperCase().replaceAll("-", "_"),
+              ),
+          },
+          { parent: self },
+        ),
+      );
+    }
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The API Gateway REST API integration.
+       */
+      integration: this.integration,
+      /**
+       * The API Gateway REST API method.
+       */
+      method: this.method,
+    };
+  }
+}
+
+const __pulumiType = "sst:aws:ApiGatewayV1IntegrationRoute";
+// @ts-expect-error
+ApiGatewayV1IntegrationRoute.__pulumiType = __pulumiType;

package/platform/src/components/aws/apigatewayv1-lambda-route.ts

@@ -0,0 +1,152 @@
+import {
+  all,
+  ComponentResourceOptions,
+  Input,
+  Output,
+  interpolate,
+  output,
+} from "@pulumi/pulumi";
+import { Component, Transform, transform } from "../component";
+import { FunctionArgs } from "./function.js";
+import { apigateway, lambda } from "@pulumi/aws";
+import {
+  ApiGatewayV1BaseRouteArgs,
+  createMethod,
+} from "./apigatewayv1-base-route";
+import { FunctionBuilder, functionBuilder } from "./helpers/function-builder";
+
+export interface Args extends ApiGatewayV1BaseRouteArgs {
+  /**
+   * The route function.
+   */
+  handler: Input<string | FunctionArgs>;
+  /**
+   * @internal
+   */
+  handlerTransform?: Transform<FunctionArgs>;
+}
+
+/**
+ * The `ApiGatewayV1LambdaRoute` component is internally used by the `ApiGatewayV1` component
+ * to add routes to your [API Gateway REST API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `route` method of the `ApiGatewayV1` component.
+ */
+export class ApiGatewayV1LambdaRoute extends Component {
+  private readonly fn: FunctionBuilder;
+  private readonly permission: lambda.Permission;
+  private readonly method: Output<apigateway.Method>;
+  private readonly integration: apigateway.Integration;
+
+  constructor(name: string, args: Args, opts?: ComponentResourceOptions) {
+    super(__pulumiType, name, args, opts);
+
+    const self = this;
+    const api = output(args.api);
+    const fnStreaming = output(args.handler).apply((handler) =>
+      handler && typeof handler === "object" && "streaming" in handler
+        ? handler.streaming
+        : undefined,
+    );
+    const streaming = all([output(args.streaming), fnStreaming]).apply(
+      ([routeStreaming, fnStreaming]) => routeStreaming ?? fnStreaming ?? false,
+    );
+
+    const method = createMethod(name, args, self);
+    const fn = createFunction();
+    const permission = createPermission();
+    const integration = createIntegration();
+
+    this.fn = fn;
+    this.permission = permission;
+    this.method = method;
+    this.integration = integration;
+
+    function createFunction() {
+      const { method, path } = args;
+
+      return functionBuilder(
+        `${name}Handler`,
+        args.handler,
+        {
+          description: interpolate`${api.name} route ${method} ${path}`,
+          streaming,
+        },
+        args.handlerTransform,
+        { parent: self },
+      );
+    }
+
+    function createPermission() {
+      return new lambda.Permission(
+        `${name}Permissions`,
+        {
+          action: "lambda:InvokeFunction",
+          function: fn.arn,
+          qualifier: fn.qualifier.apply((qualifier) => qualifier!),
+          principal: "apigateway.amazonaws.com",
+          sourceArn: interpolate`${api.executionArn}/*`,
+        },
+        { parent: self },
+      );
+    }
+
+    function createIntegration() {
+      return new apigateway.Integration(
+        ...transform(
+          args.transform?.integration,
+          `${name}Integration`,
+          {
+            restApi: api.id,
+            resourceId: args.resourceId,
+            httpMethod: method.httpMethod,
+            integrationHttpMethod: "POST",
+            type: "AWS_PROXY",
+            uri: all([streaming, fn]).apply(([s, fn]) =>
+              s ? fn.targetResponseStreamingInvokeArn : fn.targetInvokeArn,
+            ),
+            responseTransferMode: streaming.apply((s) =>
+              s ? "STREAM" : "BUFFERED",
+            ),
+          },
+          { parent: self, dependsOn: [permission] },
+        ),
+      );
+    }
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    const self = this;
+    return {
+      /**
+       * The Lambda function.
+       */
+      get function() {
+        return self.fn.apply((fn) => fn.getFunction());
+      },
+      /**
+       * The Lambda permission.
+       */
+      permission: this.permission,
+      /**
+       * The API Gateway REST API integration.
+       */
+      integration: this.integration,
+      /**
+       * The API Gateway REST API method.
+       */
+      method: this.method,
+    };
+  }
+}
+
+const __pulumiType = "sst:aws:ApiGatewayV1LambdaRoute";
+// @ts-expect-error
+ApiGatewayV1LambdaRoute.__pulumiType = __pulumiType;

package/platform/src/components/aws/apigatewayv1-usage-plan.ts

@@ -0,0 +1,109 @@
+import { apigateway } from "@pulumi/aws";
+import { ComponentResourceOptions, Input, output } from "@pulumi/pulumi";
+import { Component } from "../component";
+import {
+  ApiGatewayV1ApiKeyArgs,
+  ApiGatewayV1UsagePlanArgs,
+} from "./apigatewayv1";
+import { ApiGatewayV1ApiKey } from "./apigatewayv1-api-key";
+
+export interface UsagePlanArgs extends ApiGatewayV1UsagePlanArgs {
+  /**
+   * The API Gateway REST API to use for the usage plan.
+   */
+  apiId: Input<string>;
+  /**
+   * The stage of the API Gateway REST API.
+   */
+  apiStage: Input<string>;
+}
+
+/**
+ * The `ApiGatewayV1UsagePlan` component is internally used by the `ApiGatewayV1` component
+ * to add usage plans to [Amazon API Gateway REST API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `addUsagePlan` method of the `ApiGatewayV1` component.
+ */
+export class ApiGatewayV1UsagePlan extends Component {
+  private constructorArgs: UsagePlanArgs;
+  private constructorOpts: ComponentResourceOptions;
+  private readonly plan: apigateway.UsagePlan;
+
+  constructor(
+    name: string,
+    args: UsagePlanArgs,
+    opts: ComponentResourceOptions = {},
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    const self = this;
+
+    this.plan = new apigateway.UsagePlan(
+      `${name}UsagePlan`,
+      {
+        apiStages: [{ apiId: args.apiId, stage: args.apiStage }],
+        quotaSettings:
+          args.quota &&
+          output(args.quota).apply((quota) => ({
+            limit: quota.limit,
+            period: quota.period.toUpperCase(),
+            offset: quota.offset,
+          })),
+        throttleSettings:
+          args.throttle &&
+          output(args.throttle).apply((throttle) => ({
+            burstLimit: throttle.burst,
+            rateLimit: throttle.rate,
+          })),
+      },
+      { parent: self },
+    );
+
+    this.constructorArgs = args;
+    this.constructorOpts = opts;
+  }
+
+  /**
+   * The underlying [resources](/docs/components/#nodes) this component creates.
+   */
+  public get nodes() {
+    return {
+      /**
+       * The API Gateway Usage Plan.
+       */
+      usagePlan: this.plan,
+    };
+  }
+
+  /**
+   * Add an API key to the API Gateway usage plan.
+   *
+   * @param name The name of the API key.
+   * @param args Configure the API key.
+   * @example
+   * ```js title="sst.config.ts"
+   * plan.addApiKey("MyKey", {
+   *   value: "d41d8cd98f00b204e9800998ecf8427e",
+   * });
+   * ```
+   */
+  public addApiKey(name: string, args?: ApiGatewayV1ApiKeyArgs) {
+    return new ApiGatewayV1ApiKey(
+      name,
+      {
+        apiId: this.constructorArgs.apiId,
+        usagePlanId: this.plan.id,
+        ...args,
+      },
+      { provider: this.constructorOpts.provider },
+    );
+  }
+}
+
+const __pulumiType = "sst:aws:ApiGatewayV1UsagePlan";
+// @ts-expect-error
+ApiGatewayV1UsagePlan.__pulumiType = __pulumiType;