sst 2.1.26 → 2.1.28

package/cli/commands/plugins/kysely.js

@@ -5,18 +5,15 @@ import * as fs from "fs/promises";
 import { DatabaseMetadata, EnumCollection, PostgresDialect, MysqlDialect, Serializer, Transformer, } from "kysely-codegen";
 import { Context } from "../../../context/context.js";
 import { useBus } from "../../../bus.js";
-import { useProject } from "../../../project.js";
 import { Logger } from "../../../logger.js";
-import { useAWSClient, useAWSCredentials, } from "../../../credentials.js";
+import { useAWSClient, } from "../../../credentials.js";
 export const useKyselyTypeGenerator = Context.memo(async () => {
     let databases = [];
     const bus = useBus();
-    const project = useProject();
     async function generate(db) {
         if (!db.types)
             return;
         Logger.debug("Generating types for", db.migratorID);
-        const credentials = await useAWSCredentials();
         const k = new Kysely({
             dialect: new DataApiDialect({
                 mode: db.engine.includes("postgres") ? "postgres" : "mysql",
@@ -93,7 +90,7 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
         const db = databases.find((db) => db.migratorID === evt.properties.functionID);
         if (!db)
             return;
-        generate(db);
+        generate(db).catch(() => { });
     });
     Logger.debug("Loaded kyseley type generator");
 });

package/constructs/Api.d.ts

@@ -2,10 +2,11 @@ import { Construct } from "constructs";
 import * as acm from "aws-cdk-lib/aws-certificatemanager";
 import * as apig from "@aws-cdk/aws-apigatewayv2-alpha";
 import * as apigAuthorizers from "@aws-cdk/aws-apigatewayv2-authorizers-alpha";
-import * as apigIntegrations from "@aws-cdk/aws-apigatewayv2-integrations-alpha";
+import { HttpUrlIntegrationProps, HttpAlbIntegrationProps, HttpNlbIntegrationProps } from "@aws-cdk/aws-apigatewayv2-integrations-alpha";
 import * as elb from "aws-cdk-lib/aws-elasticloadbalancingv2";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import * as logs from "aws-cdk-lib/aws-logs";
+import { HttpAwsIntegrationProps } from "./cdk/HttpAwsIntegration.js";
 import { SSTConstruct } from "./Construct.js";
 import { Function as Fn, FunctionProps, FunctionInlineDefinition, FunctionDefinition } from "./Function.js";
 import { FunctionBindingProps } from "./util/functionBinding.js";
@@ -16,6 +17,8 @@ import * as apigV2Domain from "./util/apiGatewayV2Domain.js";
 import * as apigV2AccessLog from "./util/apiGatewayV2AccessLog.js";
 declare const PayloadFormatVersions: readonly ["1.0", "2.0"];
 export type ApiPayloadFormatVersion = (typeof PayloadFormatVersions)[number];
+export interface CdkHttpAwsIntegrationProps extends HttpAwsIntegrationProps {
+}
 export type ApiAuthorizer = ApiUserPoolAuthorizer | ApiJwtAuthorizer | ApiLambdaAuthorizer;
 interface ApiBaseAuthorizer {
     /**
@@ -394,7 +397,7 @@ export interface ApiProps<Authorizers extends Record<string, ApiAuthorizer> = Re
         httpStages?: Omit<apig.HttpStageProps, "httpApi">[];
     };
 }
-export type ApiRouteProps<AuthorizerKeys> = FunctionInlineDefinition | ApiFunctionRouteProps<AuthorizerKeys> | ApiHttpRouteProps<AuthorizerKeys> | ApiAlbRouteProps<AuthorizerKeys> | ApiNlbRouteProps<AuthorizerKeys> | ApiGraphQLRouteProps<AuthorizerKeys>;
+export type ApiRouteProps<AuthorizerKeys> = FunctionInlineDefinition | ApiFunctionRouteProps<AuthorizerKeys> | ApiAwsRouteProps<AuthorizerKeys> | ApiHttpRouteProps<AuthorizerKeys> | ApiAlbRouteProps<AuthorizerKeys> | ApiNlbRouteProps<AuthorizerKeys> | ApiGraphQLRouteProps<AuthorizerKeys>;
 interface ApiBaseRouteProps<AuthorizerKeys = string> {
     authorizer?: "none" | "iam" | (string extends AuthorizerKeys ? Omit<AuthorizerKeys, "none" | "iam"> : AuthorizerKeys);
     authorizationScopes?: string[];
@@ -432,6 +435,37 @@ export interface ApiFunctionRouteProps<AuthorizersKeys = string> extends ApiBase
         function?: lambda.IFunction;
     };
 }
+/**
+ * Specify a function route handler and configure additional options
+ *
+ * @example
+ * ```js
+ * api.addRoutes(stack, {
+ *   "GET /notes/{id}": {
+ *     type: "aws",
+ *     cdk: {
+ *       integration: {
+ *         subtype: "EventBridge-PutEvents",
+ *         parameterMapping: ParameterMapping.fromObject({
+ *           Source: MappingValue.custom("$request.body.source"),
+ *           DetailType: MappingValue.custom("$request.body.detailType"),
+ *           Detail: MappingValue.custom("$request.body.detail"),
+ *         }),
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export interface ApiAwsRouteProps<AuthorizersKeys> extends ApiBaseRouteProps<AuthorizersKeys> {
+    /**
+     * This is a constant
+     */
+    type: "aws";
+    cdk: {
+        integration: Omit<CdkHttpAwsIntegrationProps, "credentials">;
+    };
+}
 /**
  * Specify a route handler that forwards to another URL
  *
@@ -458,7 +492,7 @@ export interface ApiHttpRouteProps<AuthorizersKeys> extends ApiBaseRouteProps<Au
         /**
          * Override the underlying CDK integration
          */
-        integration: apigIntegrations.HttpUrlIntegrationProps;
+        integration: HttpUrlIntegrationProps;
     };
 }
 /**
@@ -483,7 +517,7 @@ export interface ApiAlbRouteProps<AuthorizersKeys> extends ApiBaseRouteProps<Aut
          * The listener to the application load balancer used for the integration.
          */
         albListener: elb.IApplicationListener;
-        integration?: apigIntegrations.HttpAlbIntegrationProps;
+        integration?: HttpAlbIntegrationProps;
     };
 }
 /**
@@ -508,7 +542,7 @@ export interface ApiNlbRouteProps<AuthorizersKeys> extends ApiBaseRouteProps<Aut
          * The listener to the application load balancer used for the integration.
          */
         nlbListener: elb.INetworkListener;
-        integration?: apigIntegrations.HttpNlbIntegrationProps;
+        integration?: HttpNlbIntegrationProps;
     };
 }
 /**
@@ -732,7 +766,7 @@ export declare class Api<Authorizers extends Record<string, ApiAuthorizer> = Rec
                 output: string | undefined;
                 commands: string[] | undefined;
             } | {
-                type: "lambda_function" | "url" | "alb" | "nlb";
+                type: "lambda_function" | "aws" | "url" | "alb" | "nlb";
                 route: string;
                 fn?: undefined;
                 schema?: undefined;
@@ -746,6 +780,7 @@ export declare class Api<Authorizers extends Record<string, ApiAuthorizer> = Rec
     private createHttpApi;
     private addAuthorizers;
     private addRoute;
+    private createAwsProxyIntegration;
     private createHttpIntegration;
     private createAlbIntegration;
     private createNlbIntegration;

package/constructs/Api.js

@@ -1,9 +1,11 @@
 import { Construct } from "constructs";
 import * as cdkLib from "aws-cdk-lib";
 import * as cognito from "aws-cdk-lib/aws-cognito";
+import { Role, ServicePrincipal, PolicyDocument, PolicyStatement, } from "aws-cdk-lib/aws-iam";
 import * as apig from "@aws-cdk/aws-apigatewayv2-alpha";
 import * as apigAuthorizers from "@aws-cdk/aws-apigatewayv2-authorizers-alpha";
-import * as apigIntegrations from "@aws-cdk/aws-apigatewayv2-integrations-alpha";
+import { HttpUrlIntegration, HttpAlbIntegration, HttpNlbIntegration, HttpLambdaIntegration, } from "@aws-cdk/aws-apigatewayv2-integrations-alpha";
+import { HttpAwsIntegration, } from "./cdk/HttpAwsIntegration.js";
 import { Stack } from "./Stack.js";
 import { getFunctionRef, isCDKConstruct } from "./Construct.js";
 import { Function as Fn, } from "./Function.js";
@@ -438,6 +440,12 @@ export class Api extends Construct {
                     this.createFunctionIntegration(scope, routeKey, routeProps, postfixName),
                 ];
             }
+            if (routeValue.type === "aws") {
+                return [
+                    routeValue,
+                    this.createAwsProxyIntegration(scope, routeKey, routeValue, postfixName),
+                ];
+            }
             if (routeValue.type === "alb") {
                 return [
                     routeValue,
@@ -476,7 +484,7 @@ export class Api extends Construct {
             }
             if ("handler" in routeValue)
                 throw new Error(`Function definition must be nested under the "function" key in the route props for "${routeKey}". ie. { function: { handler: "myfunc.handler" } }`);
-            throw new Error(`Invalid route type for "${routeKey}". Must be one of: alb, nlb, url, or function`);
+            throw new Error(`Invalid route type "${routeValue.type}" for "${routeKey}".`);
         })();
         const { authorizationType, authorizer, authorizationScopes } = this.buildRouteAuth(routeProps);
         const route = new apig.HttpRoute(scope, `Route_${postfixName}`, {
@@ -502,11 +510,45 @@ export class Api extends Construct {
             cfnRoute.authorizationType = "NONE";
         }
     }
+    createAwsProxyIntegration(scope, routeKey, routeProps, postfixName) {
+        // Create IAM role for API Gateway to call the AWS services
+        const [service, serviceApi] = routeProps.cdk.integration.subtype.split("-");
+        const servicePrefix = {
+            EventBridge: "events",
+            SQS: "sqs",
+            AppConfig: "appconfig",
+            Kinesis: "kinesis",
+            StepFunctions: "states",
+        }[service];
+        const role = new Role(scope, `IntegrationRole_${postfixName}`, {
+            assumedBy: new ServicePrincipal("apigateway.amazonaws.com"),
+            inlinePolicies: {
+                Policy: new PolicyDocument({
+                    statements: [
+                        new PolicyStatement({
+                            actions: [`${servicePrefix}:${serviceApi}`],
+                            resources: ["*"],
+                        }),
+                    ],
+                }),
+            },
+        });
+        // Create integration
+        const integration = new HttpAwsIntegration(`Integration_${postfixName}`, {
+            ...routeProps.cdk.integration,
+            credentials: apig.IntegrationCredentials.fromRole(role),
+        });
+        // Store route
+        this.routesData[routeKey] = {
+            type: "aws",
+        };
+        return integration;
+    }
     createHttpIntegration(scope, routeKey, routeProps, postfixName) {
         ///////////////////
         // Create integration
         ///////////////////
-        const integration = new apigIntegrations.HttpUrlIntegration(`Integration_${postfixName}`, routeProps.url, routeProps.cdk?.integration);
+        const integration = new HttpUrlIntegration(`Integration_${postfixName}`, routeProps.url, routeProps.cdk?.integration);
         // Store route
         this.routesData[routeKey] = {
             type: "url",
@@ -518,7 +560,7 @@ export class Api extends Construct {
         ///////////////////
         // Create integration
         ///////////////////
-        const integration = new apigIntegrations.HttpAlbIntegration(`Integration_${postfixName}`, routeProps.cdk?.albListener, routeProps.cdk?.integration);
+        const integration = new HttpAlbIntegration(`Integration_${postfixName}`, routeProps.cdk?.albListener, routeProps.cdk?.integration);
         // Store route
         this.routesData[routeKey] = {
             type: "alb",
@@ -530,7 +572,7 @@ export class Api extends Construct {
         ///////////////////
         // Create integration
         ///////////////////
-        const integration = new apigIntegrations.HttpNlbIntegration(`Integration_${postfixName}`, routeProps.cdk?.nlbListener, routeProps.cdk?.integration);
+        const integration = new HttpNlbIntegration(`Integration_${postfixName}`, routeProps.cdk?.nlbListener, routeProps.cdk?.integration);
         // Store route
         this.routesData[routeKey] = {
             type: "nlb",
@@ -576,7 +618,7 @@ export class Api extends Construct {
         ///////////////////
         // Create integration
         ///////////////////
-        const integration = new apigIntegrations.HttpLambdaIntegration(`Integration_${postfixName}`, lambda, {
+        const integration = new HttpLambdaIntegration(`Integration_${postfixName}`, lambda, {
             payloadFormatVersion: integrationPayloadFormatVersion,
         });
         // Store route
@@ -615,7 +657,7 @@ export class Api extends Construct {
         ///////////////////
         // Create integration
         ///////////////////
-        const integration = new apigIntegrations.HttpLambdaIntegration(`Integration_${postfixName}`, lambda, {
+        const integration = new HttpLambdaIntegration(`Integration_${postfixName}`, lambda, {
             payloadFormatVersion: integrationPayloadFormatVersion,
         });
         // Store route

package/constructs/cdk/HttpAwsIntegration.d.ts

@@ -0,0 +1,32 @@
+import { HttpIntegrationSubtype, HttpRouteIntegrationBindOptions, HttpRouteIntegrationConfig, HttpRouteIntegration, ParameterMapping, IntegrationCredentials } from "@aws-cdk/aws-apigatewayv2-alpha";
+/**
+ * Properties to initialize a new `HttpProxyIntegration`.
+ */
+export interface HttpAwsIntegrationProps {
+    /**
+     * Specifies the AWS service action to invoke
+     */
+    readonly subtype: HttpIntegrationSubtype;
+    /**
+     * Specifies how to transform HTTP requests before sending them to the backend
+     */
+    readonly parameterMapping: ParameterMapping;
+    /**
+     * The credentials with which to invoke the integration.
+     *
+     * @default - no credentials, use resource-based permissions on supported AWS services
+     */
+    readonly credentials: IntegrationCredentials;
+}
+/**
+ * The HTTP Proxy integration resource for HTTP API
+ */
+export declare class HttpAwsIntegration extends HttpRouteIntegration {
+    private readonly props;
+    /**
+     * @param id id of the underlying integration construct
+     * @param props properties to configure the integration
+     */
+    constructor(id: string, props: HttpAwsIntegrationProps);
+    bind(_: HttpRouteIntegrationBindOptions): HttpRouteIntegrationConfig;
+}

package/constructs/cdk/HttpAwsIntegration.js

@@ -0,0 +1,24 @@
+import { HttpIntegrationType, HttpRouteIntegration, PayloadFormatVersion, } from "@aws-cdk/aws-apigatewayv2-alpha";
+/**
+ * The HTTP Proxy integration resource for HTTP API
+ */
+export class HttpAwsIntegration extends HttpRouteIntegration {
+    props;
+    /**
+     * @param id id of the underlying integration construct
+     * @param props properties to configure the integration
+     */
+    constructor(id, props) {
+        super(id);
+        this.props = props;
+    }
+    bind(_) {
+        return {
+            payloadFormatVersion: PayloadFormatVersion.VERSION_1_0,
+            type: HttpIntegrationType.AWS_PROXY,
+            subtype: this.props.subtype,
+            parameterMapping: this.props.parameterMapping,
+            credentials: this.props.credentials,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.1.26",
+  "version": "2.1.28",
   "bin": {
     "sst": "cli/sst.js"
   },

package/sst.mjs

@@ -6329,18 +6329,15 @@ var init_kysely = __esm({
     "use strict";
     init_context();
     init_bus();
-    init_project();
     init_logger();
     init_credentials();
     useKyselyTypeGenerator = Context.memo(async () => {
       let databases = [];
       const bus = useBus();
-      const project = useProject();
       async function generate2(db) {
         if (!db.types)
           return;
         Logger.debug("Generating types for", db.migratorID);
-        const credentials = await useAWSCredentials();
         const k = new Kysely({
           dialect: new DataApiDialect({
             mode: db.engine.includes("postgres") ? "postgres" : "mysql",
@@ -6413,7 +6410,8 @@ var init_kysely = __esm({
         );
         if (!db)
           return;
-        generate2(db);
+        generate2(db).catch(() => {
+        });
       });
       Logger.debug("Loaded kyseley type generator");
     });
@@ -6758,7 +6756,7 @@ var env = (program2) => program2.command(
     const fs19 = await import("fs/promises");
     const { SiteEnv } = await Promise.resolve().then(() => (init_site_env(), site_env_exports));
     const { spawnSync } = await import("child_process");
-    const { useAWSCredentials: useAWSCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+    const { useAWSCredentials: useAWSCredentials3 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
     let spinner;
     while (true) {
@@ -6774,7 +6772,7 @@ var env = (program2) => program2.command(
       const sites = await SiteEnv.values();
       const env2 = sites[process.cwd()] || {};
       const project = useProject2();
-      const credentials = await useAWSCredentials2();
+      const credentials = await useAWSCredentials3();
       const joined = args.command?.join(" ");
       if (!joined)
         throw new VisibleError(
@@ -7139,11 +7137,11 @@ var bind = (program2) => program2.command(
   async (args) => {
     const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
     const { spawnSync } = await import("child_process");
-    const { useAWSCredentials: useAWSCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+    const { useAWSCredentials: useAWSCredentials3 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
     const env2 = await Config2.env();
     const project = useProject2();
-    const credentials = await useAWSCredentials2();
+    const credentials = await useAWSCredentials3();
     const joined = args.command?.join(" ");
     if (!joined)
       throw new VisibleError("Command is required, e.g. sst bind env");