sst 2.31.0 → 2.32.1

package/constructs/App.js

@@ -264,28 +264,28 @@ export class App extends CDKApp {
                     const functions = useFunctions();
                     const sourcemaps = functions.sourcemaps.forStack(child.stackName);
                     if (sourcemaps.length) {
-                        const policy = new Policy(child, "FunctionSourcemapUploaderPolicy", {
+                        const policy = new Policy(child, "SourcemapUploaderPolicy", {
                             statements: [
                                 new PolicyStatement({
                                     effect: Effect.ALLOW,
                                     actions: ["s3:GetObject", "s3:PutObject"],
                                     resources: [
-                                        sourcemaps[0].bucket.bucketArn + "/*",
+                                        sourcemaps[0].srcBucket.bucketArn + "/*",
                                         `arn:${child.partition}:s3:::${bootstrap.bucket}/*`,
                                     ],
                                 }),
                             ],
                         });
                         child.customResourceHandler.role?.attachInlinePolicy(policy);
-                        const resource = new CustomResource(child, "FunctionSourcemapUploader", {
+                        const resource = new CustomResource(child, "SourcemapUploader", {
                             serviceToken: child.customResourceHandler.functionArn,
-                            resourceType: "Custom::FunctionSourcemapUploader",
+                            resourceType: "Custom::SourcemapUploader",
                             properties: {
                                 app: this.name,
                                 stage: this.stage,
-                                bootstrap: bootstrap.bucket,
-                                bucket: sourcemaps[0].bucket.bucketName,
-                                functions: sourcemaps.map((s) => [s.func.functionArn, s.key]),
+                                tarBucket: bootstrap.bucket,
+                                srcBucket: sourcemaps[0].srcBucket.bucketName,
+                                sourcemaps: sourcemaps.map((s) => [s.tarKey, s.srcKey]),
                             },
                         });
                         resource.node.addDependency(policy);

package/constructs/AppSyncApi.d.ts

@@ -546,5 +546,6 @@ export declare class AppSyncApi extends Construct implements SSTConstruct {
     private normalizeResolverKey;
     private buildMappingTemplate;
     private buildDataSourceKey;
+    private isSameStack;
 }
 export {};

package/constructs/AppSyncApi.js

@@ -11,11 +11,12 @@ export async function weakImport(pkg) {
 const { print, buildSchema } = await weakImport("graphql");
 const { mergeTypeDefs } = await weakImport("@graphql-tools/merge");
 import { Construct } from "constructs";
+import { Stack } from "./Stack.js";
 import * as appSyncApiDomain from "./util/appSyncApiDomain.js";
 import { getFunctionRef, isCDKConstruct } from "./Construct.js";
 import { Function as Fn, } from "./Function.js";
 import { useProject } from "../project.js";
-import { GraphqlApi, MappingTemplate as CDKMappingTemplate, SchemaFile, Definition, } from "aws-cdk-lib/aws-appsync";
+import { GraphqlApi, MappingTemplate as CDKMappingTemplate, Resolver, SchemaFile, Definition, LambdaDataSource, DynamoDbDataSource, RdsDataSource, OpenSearchDataSource, HttpDataSource, NoneDataSource, } from "aws-cdk-lib/aws-appsync";
 /////////////////////
 // Construct
 /////////////////////
@@ -327,58 +328,110 @@ export class AppSyncApi extends Construct {
         // Lambda function
         if (Fn.isInlineDefinition(dsValue)) {
             lambda = Fn.fromDefinition(scope, `Lambda_${dsKey}`, dsValue, this.props.defaults?.function, `Cannot define defaults.function when a Function is passed in to the "${dsKey} data source`);
-            dataSource = this.cdk.graphqlApi.addLambdaDataSource(dsKey, lambda);
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addLambdaDataSource(dsKey, lambda)
+                : new LambdaDataSource(scope, dsKey, {
+                    api: this.cdk.graphqlApi,
+                    lambdaFunction: lambda,
+                });
         }
         // DynamoDb ds
         else if (dsValue.type === "dynamodb") {
-            dataSource = this.cdk.graphqlApi.addDynamoDbDataSource(dsKey, dsValue.table
+            const dsTable = dsValue.table
                 ? dsValue.table.cdk.table
-                : dsValue.cdk?.dataSource?.table, {
+                : dsValue.cdk?.dataSource?.table;
+            const dsOptions = {
                 name: dsValue.name,
                 description: dsValue.description,
-            });
+            };
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addDynamoDbDataSource(dsKey, dsTable, dsOptions)
+                : new DynamoDbDataSource(scope, dsKey, {
+                    api: this.cdk.graphqlApi,
+                    table: dsTable,
+                    ...dsOptions,
+                });
         }
         // RDS ds
         else if (dsValue.type === "rds") {
-            dataSource = this.cdk.graphqlApi.addRdsDataSource(dsKey, dsValue.rds
+            const dsCluster = dsValue.rds
                 ? dsValue.rds.cdk.cluster
-                : dsValue.cdk?.dataSource?.serverlessCluster, dsValue.rds
+                : dsValue.cdk?.dataSource?.serverlessCluster;
+            const dsSecret = dsValue.rds
                 ? dsValue.rds.cdk.cluster.secret
-                : dsValue.cdk?.dataSource?.secretStore, dsValue.rds
+                : dsValue.cdk?.dataSource?.secretStore;
+            const dsDatabaseName = dsValue.rds
                 ? dsValue.databaseName || dsValue.rds.defaultDatabaseName
-                : dsValue.cdk?.dataSource?.databaseName, {
+                : dsValue.cdk?.dataSource?.databaseName;
+            const dsOptions = {
                 name: dsValue.name,
                 description: dsValue.description,
-            });
+            };
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addRdsDataSource(dsKey, dsCluster, dsSecret, dsDatabaseName, dsOptions)
+                : new RdsDataSource(scope, dsKey, {
+                    api: this.cdk.graphqlApi,
+                    serverlessCluster: dsCluster,
+                    secretStore: dsSecret,
+                    databaseName: dsDatabaseName,
+                    ...dsOptions,
+                });
         }
         // OpenSearch ds
         else if (dsValue.type === "open_search") {
-            dataSource = this.cdk.graphqlApi.addOpenSearchDataSource(dsKey, dsValue.cdk?.dataSource?.domain, {
+            const dsOptions = {
                 name: dsValue.name,
                 description: dsValue.description,
-            });
+            };
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addOpenSearchDataSource(dsKey, dsValue.cdk?.dataSource?.domain, dsOptions)
+                : new OpenSearchDataSource(scope, dsKey, {
+                    api: this.cdk.graphqlApi,
+                    domain: dsValue.cdk?.dataSource?.domain,
+                    ...dsOptions,
+                });
         }
         // Http ds
         else if (dsValue.type === "http") {
-            dataSource = this.cdk.graphqlApi.addHttpDataSource(dsKey, dsValue.endpoint, {
+            const dsOptions = {
                 name: dsValue.name,
                 description: dsValue.description,
-            });
+            };
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addHttpDataSource(dsKey, dsValue.endpoint, dsOptions)
+                : new HttpDataSource(scope, dsKey, {
+                    api: this.cdk.graphqlApi,
+                    endpoint: dsValue.endpoint,
+                    ...dsOptions,
+                });
         }
         // Http ds
         else if (dsValue.type === "none") {
-            dataSource = this.cdk.graphqlApi.addNoneDataSource(dsKey, {
+            const dsOptions = {
                 name: dsValue.name,
                 description: dsValue.description,
-            });
+            };
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addNoneDataSource(dsKey, dsOptions)
+                : new NoneDataSource(scope, dsKey, {
+                    api: this.cdk.graphqlApi,
+                    ...dsOptions,
+                });
         }
         // Lambda ds
         else {
             lambda = Fn.fromDefinition(scope, `Lambda_${dsKey}`, dsValue.function, this.props.defaults?.function, `Cannot define defaults.function when a Function is passed in to the "${dsKey} data source`);
-            dataSource = this.cdk.graphqlApi.addLambdaDataSource(dsKey, lambda, {
+            const dsOptions = {
                 name: dsValue.name,
                 description: dsValue.description,
-            });
+            };
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addLambdaDataSource(dsKey, lambda, dsOptions)
+                : new LambdaDataSource(scope, dsKey, {
+                    api: this.cdk.graphqlApi,
+                    lambdaFunction: lambda,
+                    ...dsOptions,
+                });
         }
         this.dataSourcesByDsKey[dsKey] = dataSource;
         if (lambda) {
@@ -423,7 +476,12 @@ export class AppSyncApi extends Construct {
             resValue = resValue;
             lambda = Fn.fromDefinition(scope, `Lambda_${typeName}_${fieldName}`, resValue.function, this.props.defaults?.function, `Cannot define defaults.function when a Function is passed in to the "${resKey} resolver`);
             dataSourceKey = this.buildDataSourceKey(typeName, fieldName);
-            dataSource = this.cdk.graphqlApi.addLambdaDataSource(dataSourceKey, lambda);
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addLambdaDataSource(dataSourceKey, lambda)
+                : new LambdaDataSource(scope, dataSourceKey, {
+                    api: this.cdk.graphqlApi,
+                    lambdaFunction: lambda,
+                });
             resolverProps = {
                 requestMappingTemplate: this.buildMappingTemplate(resValue.requestMapping),
                 responseMappingTemplate: this.buildMappingTemplate(resValue.responseMapping),
@@ -446,7 +504,12 @@ export class AppSyncApi extends Construct {
             resValue = resValue;
             lambda = Fn.fromDefinition(scope, `Lambda_${typeName}_${fieldName}`, resValue, this.props.defaults?.function, `Cannot define defaults.function when a Function is passed in to the "${resKey} resolver`);
             dataSourceKey = this.buildDataSourceKey(typeName, fieldName);
-            dataSource = this.cdk.graphqlApi.addLambdaDataSource(dataSourceKey, lambda);
+            dataSource = this.isSameStack(scope)
+                ? this.cdk.graphqlApi.addLambdaDataSource(dataSourceKey, lambda)
+                : new LambdaDataSource(scope, dataSourceKey, {
+                    api: this.cdk.graphqlApi,
+                    lambdaFunction: lambda,
+                });
             resolverProps = {};
         }
         if (lambda) {
@@ -461,12 +524,20 @@ export class AppSyncApi extends Construct {
         ///////////////////
         // Create resolver
         ///////////////////
-        const resolver = this.cdk.graphqlApi.createResolver(`${typeName}${fieldName}Resolver`, {
-            dataSource,
-            typeName,
-            fieldName,
-            ...resolverProps,
-        });
+        const resolver = this.isSameStack(scope)
+            ? this.cdk.graphqlApi.createResolver(`${typeName}${fieldName}Resolver`, {
+                dataSource,
+                typeName,
+                fieldName,
+                ...resolverProps,
+            })
+            : new Resolver(scope, `${typeName}${fieldName}Resolver`, {
+                api: this.cdk.graphqlApi,
+                dataSource,
+                typeName,
+                fieldName,
+                ...resolverProps,
+            });
         this.resolversByResKey[resKey] = resolver;
         return lambda;
     }
@@ -492,4 +563,7 @@ export class AppSyncApi extends Construct {
     buildDataSourceKey(typeName, fieldName) {
         return `LambdaDS_${typeName}_${fieldName}`;
     }
+    isSameStack(scope) {
+        return Stack.of(this) === Stack.of(scope);
+    }
 }

package/constructs/Distribution.d.ts

@@ -94,15 +94,6 @@ export interface DistributionProps {
      * ```
      */
     customDomain?: string | DistributionDomainProps;
-    /**
-     * The SSR function is deployed to Lambda in a single region. Alternatively, you can enable this option to deploy to Lambda@Edge.
-     * @default false
-     */
-    /**
-     * While deploying, SST waits for the CloudFront cache invalidation process to finish. This ensures that the new content will be served once the deploy command finishes. However, this process can sometimes take more than 5 mins. For non-prod environments it might make sense to pass in `false`. That'll skip waiting for the cache to invalidate and speed up the deploy process.
-     * @default false
-     */
-    waitForInvalidation?: boolean;
     scopeOverride?: IConstruct;
     cdk: {
         distribution: CdkDistributionProps | IDistribution;
@@ -132,7 +123,11 @@ export declare class Distribution extends Construct {
         hostedZone: IHostedZone | undefined;
         certificate: ICertificate | undefined;
     };
-    createInvalidation(buildId?: string, paths?: string[]): CustomResource;
+    createInvalidation(props?: {
+        version?: string;
+        paths?: string[];
+        wait?: boolean;
+    }): CustomResource;
     private validateCloudFrontDistributionSettings;
     private validateCustomDomainSettings;
     private lookupHostedZone;

package/constructs/Distribution.js

@@ -70,7 +70,8 @@ export class Distribution extends Construct {
             certificate: this.certificate,
         };
     }
-    createInvalidation(buildId, paths) {
+    createInvalidation(props) {
+        const { version, paths, wait } = props ?? {};
         const stack = Stack.of(this);
         const policy = new Policy(this.scope, "CloudFrontInvalidatorPolicy", {
             statements: [
@@ -91,10 +92,11 @@ export class Distribution extends Construct {
             serviceToken: stack.customResourceHandler.functionArn,
             resourceType: "Custom::CloudFrontInvalidator",
             properties: {
-                buildId: buildId || Date.now().toString(),
+                version: version ||
+                    Date.now().toString(16) + Math.random().toString(16).slice(2),
                 distributionId: this.distribution.distributionId,
-                paths: paths ?? ["/*"],
-                waitForInvalidation: this.props.waitForInvalidation,
+                paths: [...new Set(paths ?? ["/*"])],
+                wait: wait ?? false,
             },
         });
         resource.node.addDependency(policy);

package/constructs/Function.d.ts

@@ -693,14 +693,14 @@ export declare class Function extends CDKFunction implements SSTConstruct {
 export declare const useFunctions: () => {
     sourcemaps: {
         add(stack: string, source: {
-            bucket: IBucket;
-            key: string;
-            func: Function;
+            srcBucket: IBucket;
+            srcKey: string;
+            tarKey: string;
         }): void;
         forStack(stack: string): {
-            bucket: IBucket;
-            key: string;
-            func: Function;
+            srcBucket: IBucket;
+            srcKey: string;
+            tarKey: string;
         }[];
     };
     fromID(id: string): FunctionProps | undefined;

package/constructs/Function.js

@@ -211,7 +211,7 @@ export class Function extends CDKFunction {
                             ...(props.container?.buildArgs
                                 ? { buildArgs: props.container.buildArgs }
                                 : {}),
-                            exclude: [".sst"],
+                            exclude: [".sst/dist", ".sst/artifacts"],
                             ignoreMode: IgnoreMode.GLOB,
                         }),
                         handler: CDKHandler.FROM_IMAGE,
@@ -257,9 +257,9 @@ export class Function extends CDKFunction {
                     });
                     await fs.rm(result.sourcemap);
                     useFunctions().sourcemaps.add(stack.stackName, {
-                        bucket: asset.bucket,
-                        key: asset.s3ObjectKey,
-                        func: this,
+                        srcBucket: asset.bucket,
+                        srcKey: asset.s3ObjectKey,
+                        tarKey: this.functionArn,
                     });
                 }
                 // Update code

package/constructs/Job.js

@@ -214,7 +214,7 @@ export class Job extends Construct {
                         : Platform.custom("linux/amd64"),
                     file: container?.file,
                     buildArgs: container?.buildArgs,
-                    exclude: [".sst"],
+                    exclude: [".sst/dist", ".sst/artifacts"],
                     ignoreMode: IgnoreMode.GLOB,
                 });
                 image.repository?.grantPull(this.job.role);

package/constructs/NextjsSite.d.ts

@@ -123,7 +123,11 @@ type NextjsSiteNormalizedProps = NextjsSiteProps & SsrSiteNormalizedProps;
  */
 export declare class NextjsSite extends SsrSite {
     props: NextjsSiteNormalizedProps;
-    private routes?;
+    private _routes?;
+    private routesManifest?;
+    private appPathRoutesManifest?;
+    private appPathsManifest?;
+    private pagesManifest?;
     constructor(scope: Construct, id: string, props?: NextjsSiteProps);
     static buildDefaultServerCachePolicyProps(): CachePolicyProps;
     protected plan(bucket: Bucket): {
@@ -335,10 +339,18 @@ export declare class NextjsSite extends SsrSite {
         };
     };
     private wrapServerFunction;
+    private removeSourcemaps;
     private useRoutes;
+    private useRoutesManifest;
+    private useAppPathRoutesManifest;
+    private useAppPathsManifest;
+    private usePagesManifest;
     private getBuildId;
+    private getSourcemapForAppRoute;
+    private getSourcemapForPagesRoute;
     private isPerRouteLoggingEnabled;
     private disableDefaultLogging;
+    private uploadSourcemaps;
     private static buildCloudWatchRouteName;
     private static buildCloudWatchRouteHash;
     static _test: {