Migrate to v1.0

Goals

The v1 SST constructs were restructured with the following goals in mind:

Consistent interfaces for:
- Customizing underlying AWS resources
  SST provides a convenient way for you to configure commonly used properties. Like the custom domain and access log for the Api. But it also allows you to configure other CDK properties in a more consistent way by using the new cdk prop. For example:
```
const api = new sst.Api(stack, "Api", {
  cdk: {
    httpApi: {
      disableExecuteApiEndpoint: true,
    },
  }
});
```
- Accessing underlying AWS resource names and ARNs
  Similarly, you can access the internally created CDK constructs in a consistent way using the cdk attribute. For example:
```
api.cdk.httpApi;        // cdk.apigatewayv2.HttpApi construct
api.cdk.accessLogGroup; // cdk.logs.LogGroup construct
```

Reduce the need for CDK imports

Unless you are customizing the underlying CDK constructs, you no longer need to have CDK packages as a dependency. For example, configuring CORS required you to depend on the aws-cdk-lib and the @aws-cdk/aws-apigatewayv2-alpha:

import { Duration } from "aws-cdk-lib";
import { CorsHttpMethod } from "@aws-cdk/aws-apigatewayv2-alpha";

new sst.Api(stack, "Api", {
  cors: {
    allowMethods: [CorsHttpMethod.GET],
    maxAge: Duration.days(5),
  },
});

Now you can just do.

new sst.Api(stack, "Api", {
  cors: {
    allowMethods: ["GET"],
    maxAge: "3 Days",
  },
});

And the string values are auto-completed in your IDE.

Complete support for inline TS Docs
v1 SST constructs also come with TS Docs. So you can see helpful docs in your IDE and the new construct docs are also auto-generated from them.

Cross stack reference made easy

v1 introduces the concept of Functional Stack. It has a couple of advantages over the previous class constructor way of creating stacks:

Definition is more concise;
Support async tasks in creating stacks;
Most importantly, cross stack references are made easier and fully type safe.

Here is how you used to reference an S3 bucket from another stack:

// In BucketStack.ts
import { App, Bucket, Stack } from "@serverless-stack/resources";

export class BucketStack extends Stack {
  public readonly bucket: Bucket;

  constructor(scope: App, id: string) {
    super(scope, id);

    this.bucket = new Bucket(this, "MyBucket");
  }
}

// In index.ts
const bucketStack = new BucketStack(app, "bucket");
new ApiStack(app, "api", bucketStack.bucket);

// In ApiStack.ts
import { Api, App, Bucket, Stack } from "@serverless-stack/resources";

export class ApiStack extends Stack {
  constructor(scope: App, id: string, bucket: Bucket) {
    super(scope, id, props);

    bucket;
  }
}

Now you can just do.

// In BucketStack.ts
import { Bucket, StackContext } from "@serverless-stack/resources";

export function BucketStack({ stack }: StackContext) {
  const bucket = new Bucket(stack, "MyBucket");
  return { bucket };
}

// In index.ts
app
  .stack(BucketStack)
  .stack(ApiStack);

// In ApiStack.ts
import { Bucket, StackContext, use } from "@serverless-stack/resources";
import { BucketStack } from "./BucketStack";

export function ApiStack({ stack }: StackContext) {
  const { bucket } = use(BucketStack)
}

Laying the foundation for full typesafety

Upgrade Steps

Estimated time: 15 minutes

Prerequisite: Update SST to v0.59.0 or later

Run npx sst update 1.0.2
For each SST construct used in your app, find its corresponding section in the Changelog below, and follow the steps to update.
Ensure that all the constructs have been updated:
- For TS projects (ie. using index.ts), run npx tsc --noEmit or yarn run tsc --noEmit to ensure there are no type errors.
- For JS projects (ie. using index.js), run npx sst build or yarn sst build to ensure there are no build warnings.
As a final check, run npx sst diff prior to deploying and review the proposed changes.

Changelog

App Changelog

app.setDefaultRemovalPolicy(): argument type cdk.RemovalPolicy ⇒ "destroy" | "retain" | "snapshot"

// from
app.setDefaultRemovalPolicy(cdk.RemovalPolicy.DESTROY);
// to
app.setDefaultRemovalPolicy("destroy");

Stack Changelog (optional)

You can optionally adopt Functional stack.

Adding stack to app

stacks/index.ts
// from
import { MyStack } from "./MyStack";
new MyStack(app, "my-stack");

// to
import { MyStack } from "./MyStack";
app.stack(MyStack);

Defining stack

stacks/ApiStack.ts
// from
import { Api, App, Stack, StackProps } from "@serverless-stack/resources";

export class ApiStack extends Stack {
  constructor(scope: App, id: string, props: StackProps) {
    super(scope, id, props);

    new Api(this, "Api");
  }
}

// to
import { Api, StackContext } from "@serverless-stack/resources";

export function ApiStack({ stack }: StackContext) {
  new Api(stack, "Api");
}

Permissions Changelog

Type PermissionType.ALL ⇒ "*"

// from
permissions: PermissionType.ALL
// to
permissions: "*"

Function Changelog

Constructor

runtime: default updated to "nodejs14.x"
runtime: type string | cdk.lambda.Runtime ⇒ string
timeout: type number | cdk.Duration ⇒ number | sst.Duration
tracing: type cdk.lambda.Tracing ⇒ "active" | "disabled" | "pass_through"

// from
{
  runtime: cdk.lambda.Runtime.lambda.Runtime.NODEJS_14_X,
  timeout: cdk.Duration.seconds(10),
  tracing: cdk.lambda.Tracing.ACTIVE,
}
// to
{
  runtime: "nodejs14.x",
  timeout: "10 seconds",
  tracing: "active",
}

Api Changelog

Constructor

Moved httpApi ⇒ cdk.httpApi
Moved stages ⇒ cdk.httpStages

// from
{
  httpApi,
  stages,
}
// to
{
  cdk: {
    httpApi,
    httpStages,
  },
}

CORS

cors.allowMethods: type CorsHttpMethod[] ⇒ string[]
cors.maxAge: type cdk.Duration ⇒ string

// from
{
  cors: {
    allowMethods: [CorsHttpMethod.GET],
    maxAge: cdk.Duration.days(3),
  },
}
// to
{
  cors: {
    allowMethods: ["GET"],
    maxAge: "3 Days",
  },
}

Access log

accessLog.retention: type cdk.logs.RetentionDays ⇒ string

// from
{
  accessLog: {
    retention: cdk.logs.RetentionDays.TWO_WEEKS,
  }
}
// to
{
  accessLog: {
    retention: "two_weeks",
  }
}

Custom domain

Moved customDomain.domainName (if type is cdk.apigatewayv2.DomainName) ⇒ customDomain.cdk.domainName
Moved customDomain.hostedZone (if type is cdk.route53.HostedZone) ⇒ customDomain.cdk.hostedZone
Moved customDomain.acmCertificate (if type is cdk.certificatemanager.Certificate) ⇒ customDomain.cdk.certificate

// from
{
  customDomain: {
    domainName,     // type is `cdk.apigatewayv2.DomainName`
    hostedZone,     // type is `cdk.route53.HostedZone`
    acmCertificate, // type is `cdk.certificatemanager.Certificate`
  }
}
// to
{
  customDomain: {
    cdk: {
      domainName,
      hostedZone,
      acmCertificate,
    }
  }
}

Default settings

Moved defaultFunctionProps ⇒ ApiProps.defaults.function
Moved defaultAuthorizer ⇒ ApiProps.defaults.authorizer (See Authorizer)
Moved defaultAuthorizationType ⇒ removed (See Authorizer)
Moved defaultAuthorizationScopes ⇒ ApiProps.defaults.authorizationScopes
Moved defaultPayloadFormatVersion ⇒ ApiProps.defaults.payloadFormatVersion
Moved defaultThrottlingBurstLimit ⇒ ApiProps.defaults.throttle.burst
Moved defaultThrottlingRateLimit ⇒ ApiProps.defaults.throttle.rate

// from
{
  defaultFunctionProps: { timeout: 10 },
  defaultAuthorizer: authorizer,
  defaultAuthorizationType: ApiAuthorizationType.CUSTOM,
  defaultAuthorizationScopes: [...],
  defaultPayloadFormatVersion: cdk.apigatewayv2.PayloadFormatVersion.V2,
  defaultThrottlingBurstLimit: 1000,
  defaultThrottlingRateLimit: 1000,
}
// to
{
  defaults: {
    function: { timeout: 10 },
    authorizer: "lambda",
    authorizationScopes: [...],
    payloadFormatVersion: "2.0",
    throttle: {
      burst: 1000,
      rate: 1000,
    },
  }
}

Authorizers

NONE authorizer

// from
new Api(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.NONE,
  routes: {
    "GET  /notes": "list.main",
    "POST /notes": {
      function: "create.main",
      authorizationType: ApiAuthorizationType.NONE,
    }
  },
});

// to
new Api(stack, "Api", {
  defaults: {
    authorizer: "none",
  },
  routes: {
    "GET  /notes": "list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "none",
    }
  },
});

IAM authorizer

// from
new Api(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.AWS_IAM,
  routes: {
    "GET  /notes": "list.main",
    "POST /notes": {
      function: "create.main",
      authorizationType: ApiAuthorizationType.AWS_IAM,
    }
  },
});

// to
new Api(stack, "Api", {
  defaults: {
    authorizer: "iam",
  },
  routes: {
    "GET  /notes": "list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "iam",
    }
  },
});

JWT authorizer

Note that, use the previously defined HttpJwtAuthorizer name (ie. MyAuthorizer) as the authorizers key to ensure the authorizer resources does not get recreated.

// from
import { HttpJwtAuthorizer } from "@aws-cdk/aws-apigatewayv2-authorizers-alpha";

const authorizer = new HttpJwtAuthorizer("MyAuthorizer", "https://myorg.us.auth0.com", {
  jwtAudience: ["UsGRQJJz5sDfPQDs6bhQ9Oc3hNISuVif"],
});

new Api(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.JWT,
  defaultAuthorizer: authorizer,
  defaultAuthorizationScopes: ["user.id", "user.email"],
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: authorizer
      authorizationType: ApiAuthorizationType.JWT,
    }
  },
});

// to
new Api(stack, "Api", {
  authorizers: {
    MyAuthorizer: {
      type: "jwt",
      jwt: {
        issuer: "https://myorg.us.auth0.com",
        audience: ["UsGRQJJz5sDfPQDs6bhQ9Oc3hNISuVif"],
      }
    },
  },
  defaults: {
    authorizer: "MyAuthorizer",
    authorizationScopes: ["user.id", "user.email"],
  },
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "MyAuthorizer",
      authorizationScopes: ["user.id", "user.email"],
    }
  },
}

User Pool authorizer

Note that, use the previously defined HttpUserPoolAuthorizer name (ie. MyAuthorizer) as the authorizers key to ensure the authorizer resources does not get recreated.

// from
import { HttpUserPoolAuthorizer } from "@aws-cdk/aws-apigatewayv2-authorizers-alpha";

const authorizer = new HttpUserPoolAuthorizer("MyAuthorizer", userPool, {
  userPoolClients: [userPoolClient],
});

new Api(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.JWT,
  defaultAuthorizer: authorizer,
  defaultAuthorizationScopes: ["user.id", "user.email"],
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: authorizer
      authorizationType: ApiAuthorizationType.JWT,
      authorizationScopes: ["user.id", "user.email"],
    }
  },
});

// to
new Api(stack, "Api", {
  authorizers: {
    MyAuthorizer: {
      type: "user_pool",
      userPool: {
        id: userPool.userPoolId,
        clientIds: [userPoolClient.userPoolClientId],
      }
    },
  },
  defaults: {
    authorizer: "MyAuthorizer",
    authorizationScopes: ["user.id", "user.email"],
  },
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "MyAuthorizer",
      authorizationScopes: ["user.id", "user.email"],
    }
  },
}

Lambda authorizer

Note that, use the previously defined HttpLambdaAuthorizer name (ie. MyAuthorizer) as the authorizers key to ensure the authorizer resources does not get recreated.

// from
import { Duration } from "aws-cdk-lib";
import { HttpLambdaAuthorizer } from "@aws-cdk/aws-apigatewayv2-authorizers-alpha";

const authHandler = new Function(stack, "AuthHandler", {
  handler: "src/authorizer.main",
});

const authorizer = new HttpLambdaAuthorizer("MyAuthorizer", authHandler, {
  authorizerName: "LambdaAuthorizer",
  resultsCacheTtl: Duration.seconds(30),
});

new Api(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.CUSTOM,
  defaultAuthorizer: authorizer,
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: authorizer
      authorizationType: ApiAuthorizationType.CUSTOM,
    }
  },
});

// to
const authHandler = new Function(stack, "AuthHandler", {
  handler: "src/authorizer.main",
});

new Api(stack, "Api", {
  authorizers: {
    MyAuthorizer: {
      type: "lambda",
      function: authHandler,
      resultsCacheTtl: "30 seconds",
    },
  },
  defaults: {
    authorizer: "MyAuthorizer",
  },
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "MyAuthorizer",
    }
  },
}

Routes

Function routes: Always use full props format

// from
routes: {
  "GET /notes": {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
routes: {
  "GET /notes": {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

ALB routes: moved albListener ⇒ cdk.albListener
ALB routes: moved method ⇒ cdk.integration.method
ALB routes: moved vpcLink ⇒ cdk.integration.vpcLink

// from
routes: {
  "GET /notes": {
    albListener,
    method,
    vpcLink,
  }
}

// to
routes: {
  "GET /notes": {
    type: "alb",
    cdk: {
      albListener
      integration: {
        method,
        vpcLink,
      }
    }
  }
}

HTTP Proxy routes: moved method ⇒ cdk.integration.method

// from
routes: {
  "GET /notes": {
    url: "http://domain.com",
    method,
  }
}

// to
routes: {
  "GET /notes": {
    type: "url",
    url: "http://domain.com",
    cdk: {
      integration: {
        method,
      }
    }
  }
}

Properties

Moved httpApi ⇒ cdk.httpApi
Moved accessLogGroup ⇒ cdk.accessLogGroup
Moved apiGatewayDomain ⇒ cdk.domainName
Moved acmCertificate ⇒ cdk.certificate

// from
const api = new Api(stack, "Api", { ... });
api.httpApi;
api.accessLogGroup;
api.apiGatewayDomain;
api.acmCertificate;

// to
const api = new Api(stack, "Api", { ... });
api.cdk.httpApi;
api.cdk.accessLogGroup;
api.cdk.domainName;
api.cdk.certificate;

GraphQLApi Changelog

Refer to the changes in Api Changelog
defaults.payloadFormatVersion: default updated to "2.0"

To set payloadFormationVersion to "1.0":

new GraphQLApi(stack, "Api", {
  defaults: {
    payloadFormationVersion: "1.0",
  }
});

WebSocketApi Changelog

Constructor

Moved webSocketApi ⇒ cdk.webSocketApi
Moved webSocketStage ⇒ cdk.webSocketStage

// from
{
  webSocketApi,
  webSocketStage,
}
// to
{
  cdk: {
    webSocketApi,
    webSocketStage,
  },
}

Access log

accessLog.retention: type cdk.logs.RetentionDays ⇒ string

// from
{
  accessLog: {
    retention: cdk.logs.RetentionDays.TWO_WEEKS,
  }
}
// to
{
  accessLog: {
    retention: "two_weeks",
  }
}

Custom domain

Moved customDomain.domainName (if type is cdk.apigatewayv2.DomainName) ⇒ customDomain.cdk.domainName
Moved customDomain.hostedZone (if type is cdk.route53.HostedZone) ⇒ customDomain.cdk.hostedZone
Moved customDomain.acmCertificate (if type is cdk.certificatemanager.Certificate) ⇒ customDomain.cdk.certificate

// from
{
  customDomain: {
    domainName,     // value is type `cdk.apigatewayv2.DomainName`
    hostedZone,     // value is type `cdk.route53.HostedZone`
    acmCertificate, // value is type `cdk.certificatemanager.Certificate`
  }
}
// to
{
  customDomain: {
    cdk: {
      domainName,
      hostedZone,
      acmCertificate,
    }
  }
}

Default settings

Moved defaultFunctionProps ⇒ WebSocketApiProps.defaults.function

// from
{
  defaultFunctionProps: {
    timeout: 10
  },
}
// to
{
  defaults: {
    function: {
      timeout: 10
    },
  }
}

Authorizers

NONE authorizer

// from
new WebSocketApi(stack, "Api", {
  authorizationType: WebSocketApiAuthorizationType.NONE,
  routes: {
    $connect: "src/connect.main",
    $default: "src/default.main",
    $disconnect: "src/disconnect.main",
  },
});

// to
new WebSocketApi(stack, "Api", {
  authorizer: "none",
  routes: {
    $connect: "src/connect.main",
    $default: "src/default.main",
    $disconnect: "src/disconnect.main",
  },
});

IAM authorizer

// from
new WebSocketApi(stack, "Api", {
  authorizationType: WebSocketApiAuthorizationType.IAM,
  routes: {
    $connect: "src/connect.main",
    $default: "src/default.main",
    $disconnect: "src/disconnect.main",
  },
});

// to
new WebSocketApi(stack, "Api", {
  authorizer: "iam",
  routes: {
    $connect: "src/connect.main",
    $default: "src/default.main",
    $disconnect: "src/disconnect.main",
  },
});

Lambda authorizer

// from
import { WebSocketLambdaAuthorizer } from "@aws-cdk/aws-apigatewayv2-authorizers-alpha";

const authHandler = new Function(stack, "AuthHandler", {
  handler: "src/authorizer.main",
});

const authorizer = new WebSocketLambdaAuthorizer("Authorizer", authorizer, {
  authorizerName: "LambdaAuthorizer",
});

new WebSocketApi(stack, "Api", {
  authorizationType: WebSocketApiAuthorizationType.CUSTOM,
  defaultAuthorizer: authorizer,
  routes: {
    $connect: "src/connect.main",
    $default: "src/default.main",
    $disconnect: "src/disconnect.main",
  },
});

// to
const authHandler = new Function(stack, "AuthHandler", {
  handler: "src/authorizer.main",
});

new WebSocketApi(stack, "Api", {
  authorizer: {
    type: "lambda",
    function: authHandler,
  },
  routes: {
    $connect: "src/connect.main",
    $default: "src/default.main",
    $disconnect: "src/disconnect.main",
  },
});

Routes

Function routes: Always use full props format

// from
routes: {
  sendMessage: {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
routes: {
  sendMessage: {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

Properties

Moved webSocketApi ⇒ cdk.webSocketApi
Moved webSocketStage ⇒ cdk.webSocketStage
Moved accessLogGroup ⇒ cdk.accessLogGroup
Moved apiGatewayDomain ⇒ cdk.domainName
Moved acmCertificate ⇒ cdk.certificate

// from
const api = new WebSocketApi(stack, "Api", { ... });
api.webSocketApi;
api.webSocketStage;
api.accessLogGroup;
api.apiGatewayDomain;
api.acmCertificate;

// to
const api = new WebSocketApi(stack, "Api", { ... });
api.cdk.webSocketApi;
api.cdk.webSocketStage;
api.cdk.accessLogGroup;
api.cdk.domainName;
api.cdk.certificate;

AppSyncApi Changelog

Constructor

Moved graphqlApi.schema ⇒ schema
Moved graphqlApi (other props) ⇒ cdk.graphqlApi

// from
{
  graphqlApi: {
    schema: "path/to/schema.graphql";
    name: "My GraphQL API",
    xrayEnabled: false,
  },
}
// to
{
  schema: "path/to/schema.graphql";
  cdk: {
    graphqlApi: {
      name: "My GraphQL API",
      xrayEnabled: false,
    }
  },
}

Data sources

Function data sources: Always use full props format

// from
dataSources: {
  notesDs: {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
dataSources: {
  notesDs: {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

Function data sources: moved options.name ⇒ name
Function data sources: moved options.description ⇒ description

// from
dataSources: {
  notesDS: {
    function: "src/notes.main",
    options: {
      name: "My Data Source",
      description: "This is my Data Source",
    },
  },
},

// to
dataSources: {
  notesDS: {
    function: "src/notes.main",
    name: "My Data Source",
    description: "This is my Data Source",
  },
},

DynamoDB data sources: moved options.name ⇒ name
DynamoDB data sources: moved options.description ⇒ description
DynamoDB data sources: moved table (if type is cdk.dynamodb.Table) ⇒ cdk.dataSource.table

// from
dataSources: {
  notesDS: {
    table: dynamodb.Table.fromTableArn(stack, "ImportedTable", ...),
    options: {
      name: "My Data Source",
      description: "This is my Data Source",
    },
  },
},

// to
dataSources: {
  notesDS: {
    type: "dynamodb",
    name: "My Data Source",
    description: "This is my Data Source",
    cdk: {
      dataSource: {
        table: dynamodb.Table.fromTableArn(stack, "ImportedTable", ...),
      },
    },
  },
},

RDS data sources: moved options.name ⇒ name
RDS data sources: moved options.description ⇒ description
RDS data sources: moved serverlessCluster (if type is sst.RDS) ⇒ rds
RDS data sources: moved serverlessCluster (if type is cdk.rds.ServerlessCluster) ⇒ cdk.dataSource.serverlessCluster
RDS data sources: moved secretStore ⇒ cdk.dataSource.secretStore
RDS data sources: moved databaseName ⇒ cdk.dataSource.databaseName

// from
dataSources: {
  notesDS: {
    serverlessCluster,
    secretStore,
    databaseName,
    options: {
      name: "My Data Source",
      description: "This is my Data Source",
    },
  },
},

// to
dataSources: {
  notesDS: {
    type: "rds",
    name: "My Data Source",
    description: "This is my Data Source",
    cdk: {
      dataSource: {
        serverlessCluster,
        secretStore,
        databaseName,
      },
    },
  },
},

HTTP data sources: moved options.name ⇒ name
HTTP data sources: moved options.description ⇒ description
HTTP data sources: moved options.authorizationConfig ⇒ cdk.dataSource.authorizationConfig

// from
dataSources: {
  notesDS: {
    endpoint: "https://states.amazonaws.com",
    options: {
      name: "My Data Source",
      description: "This is my Data Source",
      authorizationConfig: {
        signingRegion: "us-east-1",
        signingServiceName: "states",
      },
    },
  },
},

// to
dataSources: {
  notesDS: {
    type: "http",
    endpoint: "https://states.amazonaws.com",
    name: "My Data Source",
    description: "This is my Data Source",
    cdk: {
      dataSource: {
        authorizationConfig: {
          signingRegion: "us-east-1",
          signingServiceName: "states",
        },
      },
    },
  },
},

#### Resolvers
- Always use full props format

```js
// from
resolvers: {
  "Query listNotes": {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
resolvers: {
  "Query listNotes": {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

Moved resolverProps ⇒ cdk.resolver

// from
resolvers: {
  "Query listNotes": {
    table: notesTable,
    resolverProps: {
      requestMappingTemplate: MappingTemplate.dynamoDbScanTable(),
      responseMappingTemplate: MappingTemplate.dynamoDbResultList(),
    },
  },
},

// to
resolvers: {
  "Query listNotes": {
    type: "dynamodb",
    table: notesTable,
    cdk: {
      resolver: {
        requestMappingTemplate: MappingTemplate.dynamoDbScanTable(),
        responseMappingTemplate: MappingTemplate.dynamoDbResultList(),
      },
    },
  },
},

Properties

Moved graphqlApi ⇒ cdk.graphqlApi

// from
const api = new AppSyncApi(stack, "Api", { ... });
api.graphqlApi;

// to
const api = new AppSyncApi(stack, "Api", { ... });
api.cdk.graphqlApi;

ApiGatewayV1 Changelog

Constructor

Moved restApi ⇒ cdk.restApi
Moved importedPaths ⇒ cdk.importedPaths

// from
{
  restApi,
  importedPaths,
}
// to
{
  cdk: {
    restApi,
    importedPaths,
  },
}

Access log

accessLog.retention: type cdk.logs.RetentionDays ⇒ string

// from
{
  accessLog: {
    retention: cdk.logs.RetentionDays.TWO_WEEKS,
  }
}
// to
{
  accessLog: {
    retention: "two_weeks",
  }
}

Custom domain

Moved customDomain.domainName (if type is cdk.apigateway.DomainName) ⇒ customDomain.cdk.domainName
Moved customDomain.hostedZone (if type is cdk.route53.HostedZone) ⇒ customDomain.cdk.hostedZone
Moved customDomain.acmCertificate (if type is cdk.certificatemanager.Certificate) ⇒ customDomain.cdk.certificate
customDomain.endpointType: type cdk.apigateway.EndpointType ⇒ "edge | regional | private"
customDomain.securityPolicy: type cdk.apigateway.SecurityPolicy ⇒ "TLS 1.0 | TLS 1.2"
customDomain.mtls.bucket: type cdk.s3.Bucket ⇒ sst.Bucket

// from
{
  customDomain: {
    domainName,     // type is `cdk.apigateway.DomainName`
    hostedZone,     // type is `cdk.route53.HostedZone`
    acmCertificate, // type is `cdk.certificatemanager.Certificate`
    endpointType: cdk.apigatway.EndpointType.REGIONAL,
    securityPolicy: cdk.apigatway.SecurityPolicy.TLS_1_0,
    mtls: {
      bucket,
    },
  }
}
// to
{
  customDomain: {
    endpointType: "regional",
    securityPolicy: "TLS 1.0",
    mtls: {
      bucket: new Bucket(stack, "mtlsBucket", {
        cdk: { bucket },
      }),
    },
    cdk: {
      domainName,
      hostedZone,
      acmCertificate,
    }
  }
}

Default settings

Moved defaultFunctionProps ⇒ ApiProps.defaults.function
Moved defaultAuthorizer ⇒ ApiProps.defaults.authorizer (See Authorizer)
Moved defaultAuthorizationType ⇒ removed (See Authorizer)
Moved defaultAuthorizationScopes ⇒ ApiProps.defaults.authorizationScopes

// from
{
  defaultFunctionProps: { timeout: 10 },
  defaultAuthorizer: authorizer,
  defaultAuthorizationType: cdk.apig.AuthorizationType.COGNITO,
  defaultAuthorizationScopes: [...],
}
// to
{
  defaults: {
    function: { timeout: 10 },
    authorizer: "user_pools",
    authorizationScopes: [...],
  }
}

Authorizers

resultsCacheTtl: default 5 minutes ⇒ 0 seconds (not caching by default)
NONE authorizer

// from
new ApiGatewayV1(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.NONE,
  routes: {
    "GET  /notes": "list.main",
    "POST /notes": {
      function: "create.main",
      authorizationType: ApiAuthorizationType.NONE,
    }
  },
});

// to
new ApiGatewayV1(stack, "Api", {
  defaults: {
    authorizer: "none",
  },
  routes: {
    "GET  /notes": "list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "none",
    }
  },
});

IAM authorizer

// from
new ApiGatewayV1(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.IAM,
  routes: {
    "GET  /notes": "list.main",
    "POST /notes": {
      function: "create.main",
      authorizationType: ApiAuthorizationType.IAM,
    }
  },
});

// to
new ApiGatewayV1(stack, "Api", {
  defaults: {
    authorizer: "iam",
  },
  routes: {
    "GET  /notes": "list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "iam",
    }
  },
});

User Pools authorizer

// from
import { CognitoUserPoolsAuthorizer } from "@aws-cdk/aws-apigatewayv";

const authorizer = new CognitoUserPoolsAuthorizer(stack, "Authorizer", {
  cognitoUserPools: [userPool],
});

new ApiGatewayV1Api(stack, "Api", {
  defaultAuthorizationType: apigateway.AuthorizationType.COGNITO,
  defaultAuthorizer: authorizer,
  defaultAuthorizationScopes: ["user.id", "user.email"],
  routes: {
    "GET /notes": "src/list.main",
  },
});

// to
new ApiGatewayV1Api(stack, "Api", {
  authorizers: {
    Authorizer: {
      type: "user_pools",
      userPoolIds: [userPool.userPoolId],
    }
  },
  defaults: {
    authorizer: "Authorizer",
    authorizationScopes: ["user.id", "user.email"],
  },
  routes: {
    "GET /notes": "src/list.main",
  },
});

Lambda TOKEN authorizer

// from
import { Duration } from "aws-cdk-lib";
import { IdentitySource, TokenAuthorizer } from "@aws-cdk/aws-apigateway";

const authHandler = new Function(stack, "Authhandler", {
  handler: "src/authorizer.main",
}),

const authorizer = new TokenAuthorizer(stack, "Authorizer", {
  handler: authHandler,
  resultsCacheTtl: Duration.seconds(30),
  identitySource: IdentitySource.header("Authorization"),
});

new ApiGatewayV1Api(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.CUSTOM,
  defaultAuthorizer: authorizer,
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: authorizer,
      authorizationType: ApiAuthorizationType.CUSTOM,
    }
  },
});

// to
import { RequestAuthorizer } from "@aws-cdk/aws-apigateway";

const authHandler = new Function(stack, "AuthHandler", {
  handler: "src/authorizer.main",
});

new ApiGatewayV1Api(stack, "Api", {
  authorizers: {
    Authorizer: {
      type: "lambda_token",
      function: authHandler,
      resultsCacheTtl: "30 seconds",
      identitySource: IdentitySource.header("Authorization"),
    },
  },
  defaults: {
    authorizer: "Authorizer",
  },
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "Authorizer",
    }
  },
}

Lambda REQUEST authorizer

// from
import { Duration } from "aws-cdk-lib";
import { IdentitySource, RequestAuthorizer } from "@aws-cdk/aws-apigateway";

const authHandler = new Function(stack, "Authhandler", {
  handler: "src/authorizer.main",
}),

const authorizer = new RequestAuthorizer(stack, "Authorizer", {
  handler: authHandler,
  resultsCacheTtl: Duration.seconds(30),
  identitySources: [IdentitySource.header("Authorization")],
});

new ApiGatewayV1Api(stack, "Api", {
  defaultAuthorizationType: ApiAuthorizationType.CUSTOM,
  defaultAuthorizer: authorizer,
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: authorizer,
      authorizationType: ApiAuthorizationType.CUSTOM,
    }
  },
});

// to
import { RequestAuthorizer } from "@aws-cdk/aws-apigateway";

const authHandler = new Function(stack, "AuthHandler", {
  handler: "src/authorizer.main",
});

new ApiGatewayV1Api(stack, "Api", {
  authorizers: {
    Authorizer: {
      type: "lambda_request",
      function: authHandler,
      resultsCacheTtl: "30 seconds",
      identitySources: [IdentitySource.header("Authorization")],
    },
  },
  defaults: {
    authorizer: "Authorizer",
  },
  routes: {
    "GET /notes": "src/list.main",
    "POST /notes": {
      function: "create.main",
      authorizer: "Authorizer",
    }
  },
}

Routes

Always use full props format

// from
routes: {
  "GET /notes": {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
routes: {
  "GET /notes": {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

Moved methodOptions ⇒ cdk.method
Moved integrationOptions ⇒ cdk.integration

// from
routes: {
  "GET /notes": {
    function: "lambda.main",
    methodOptions,
    integrationOptions,
  }
}

// to
routes: {
  "GET /notes": {
    function: "lambda.main",
    cdk: {
      method,
      integration,
    }
  }
}

Properties

Moved restApi ⇒ cdk.restApi
Moved accessLogGroup ⇒ cdk.accessLogGroup
Moved apiGatewayDomain ⇒ cdk.domainName
Moved acmCertificate ⇒ cdk.certificate

// from
const api = new ApiGatewayV1Api(stack, "Api", { ... });
api.restApi;
api.accessLogGroup;
api.apiGatewayDomain;
api.acmCertificate;

// to
const api = new ApiGatewayV1Api(stack, "Api", { ... });
api.cdk.restApi;
api.cdk.accessLogGroup;
api.cdk.domainName;
api.cdk.certificate;

Auth Changelog

Constructor

Moved cognito.userPool.signInAliases ⇒ login
Moved cognito.userPool.xxxx ⇒ cdk.userPool.xxxx
Moved cognito.userPoolClient ⇒ cdk.userPoolClient
Moved cognito.triggers ⇒ triggers
Moved cognito.defaultFunctionProps ⇒ defaults.function

// from
{
  cognito: {
    userPool: {
      signInAliases: { email: true, phone: true }
      mfa: cognito.Mfa.OPTIONAL,
    },
    userPoolClient,
    triggers: {
      preAuthentication: "src/preAuthentication.main",
    },
    defaultFunctionProps: {
      timeout: 10,
    },
  },
}

// to
{
  login: ["email", "phone"],
  triggers: {
    preAuthentication: "src/preAuthentication.main",
  },
  defaults: {
    function: {
      timeout: 10,
    },
  },
  cdk: {
    userPool: {
      mfa: cognito.Mfa.OPTIONAL,
    },
    userPoolClient,
  },
}

Identity pool

Moved identityPool ⇒ identityPoolFederation.cdk.cfnIdentityPool
Moved apple ⇒ identityPoolFederation.apple
Moved auth0 ⇒ identityPoolFederation.auth0
Moved google ⇒ identityPoolFederation.google
Moved facebook ⇒ identityPoolFederation.facebook
Moved twitter ⇒ identityPoolFederation.twitter
Moved amazon ⇒ identityPoolFederation.amazon

// from
{
  auth0: { domain, clientId },
  apple: { servicesId },
  google: { clientId },
  facebook: { appId },
  twitter: { consumerKey, consumerSecret },
  amazon: { appId },
  identityPool,
}

// to
{
  identityPoolFederation: {
    auth0: { domain, clientId },
    apple: { servicesId },
    google: { clientId },
    facebook: { appId },
    twitter: { consumerKey, consumerSecret },
    amazon: { appId },
  },
  cdk: {
    identityPool,
  },
}

Note that, for backward compatibility, Identity Pool federation is enabled by default. You can disable it by setting identityPoolFederation to false. Once disabled, the previously created Cognito Identity Pool will be removed on the next deploy.

Properties

Moved cognitoUserPool ⇒ cdk.userPool
Moved cognitoUserPoolClient ⇒ cdk.userPoolClient
Moved cognitoCfnIdentityPool ⇒ cdk.cfnIdentityPool
Moved iamAuthRole ⇒ cdk.authRole
Moved iamUnauthRole ⇒ cdk.unauthRole

// from
const auth = new Auth(stack, "Auth", { ... });
auth.cognitoUserPool;
auth.cognitoUserPoolClient;
auth.cognitoCfnIdentityPool;
auth.iamAuthRole;
auth.iamUnauthRole;

// to
const auth = new Auth(stack, "Auth", { ... });
auth.cdk.userPool;
auth.cdk.userPoolClient;
auth.cdk.cfnIdentityPool;
auth.cdk.authRole;
auth.cdk.unauthRole;

Bucket Changelog

Constructor

Moved s3Bucket ⇒ cdk.bucket

// from
{
  s3Bucket,
}
// to
{
  cdk: {
    bucket,
  },
}

Notifications

notifications: structure changed from Array[] ⇒ Object{}

// from
notifications: [
  "src/notification1.main",
  "src/notification2.main",
]

// to
notifications: {
  "0": "src/notification1.main",
  "1": "src/notification2.main",
}

Function notifications: Always use full props format

// from
notifications: {
  myNotification: {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
notifications: {
  myNotification: {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

Moved notificationProps.filters ⇒ filters
Moved notificationProps.events ⇒ events
events: type s3.EventType[] ⇒ string[]

// from
new Bucket(stack, "Bucket", {
  notifications: [{
    function: "lambda.main",
    notificationProps: {
      events: [EventType.OBJECT_CREATED],
      filters: [{ prefix: "imports/" }, { suffix: ".jpg" }],
    },
  }],
});

// to
new Bucket(stack, "Bucket", {
  notifications: {
    myNotification: {
      function: "lambda.main",
      events: ["object_created"],
      filters: [{ prefix: "imports/" }, { suffix: ".jpg" }],
    }
  },
});

Properties

Moved s3Bucket ⇒ cdk.bucket

// from
const bucket = new Bucket(stack, "Bucket", { ... });
bucket.s3Bucket;

// to
const bucket = new Bucket(stack, "Bucket", { ... });
bucket.cdk.bucket;

addNotifications(): structure changed from Array[] ⇒ Object{}

bucket.addNotifications(stack, [
  "src/function1.main",
  "src/function2.main",
]);

//to
bucket.addNotifications(stack, {
  "0": "src/function1.main",
  "1": "src/function2.main",
});

attachPermissionsToNotification(): 1st argument integer ⇒ string (name of the notification)

// from
bucket.attachPermissionsToNotification(0, [...]);
//to
bucket.attachPermissionsToNotification("myNotification", [...]);

Cron Changelog

Constructor

Moved eventsRule ⇒ cdk.rule

// from
{
  eventsRule,
}
// to
{
  cdk: {
    rule,
  },
}

Moved schedule (if type is cdk.events.CronOptions) ⇒ cdk.rule.schedule

// from
new Cron(this, "Cron", {
  schedule: { minute: "0", hour: "4" },
  job: "src/lambda.main",
});

// to
new Cron(this, "Cron", {
  job: "src/lambda.main",
  cdk: {
    rule: {
      schedule: { minute: "0", hour: "4" },
    },
  },
});

Job: moved jobProps ⇒ cdk.target

// from
new Cron(this, "Cron", {
  schedule: "rate(1 minute)",
  job: {
    function: "src/lambda.main",
    jobProps: {
      event: RuleTargetInput.fromObject({
        key: "value"
      }),
    },
  },
});

// to
new Cron(this, "Cron", {
  schedule: "rate(1 minute)",
  job: "src/lambda.main",
  cdk: {
    target: {
      event: RuleTargetInput.fromObject({
        key: "value"
      }),
    },
  },
});

Job

Always use full props format

// from
job: {
  handler: "lambda.main",
  timeout: 10,
}

// to
job: {
  function: {
    handler: "lambda.main",
    timeout: 10,
  }
}

Properties

Moved eventsRule ⇒ cdk.rule

// from
const cron = new Cron(stack, "Cron", { ... });
cron.eventsRule;

// to
const cron = new Cron(stack, "Cron", { ... });
cron.cdk.rule;

EventBus Changelog

Constructor

Moved eventBridgeEventBus ⇒ cdk.eventBus

// from
{
  eventBridgeEventBus,
}
// to
{
  cdk: {
    eventBus,
  },
}

Rules

Moved description ⇒ cdk.rule.description
Moved enabled ⇒ cdk.rule.enabled
Moved ruleName ⇒ cdk.rule.ruleName
Moved schedule ⇒ cdk.rule.schedule

new EventBus(stack, "Bus", {
  rules: {
    rule1: {
      description,
      enabled,
      ruleName,
      schedule,
    },
  },
});

// to
new EventBus(stack, "Bus", {
  rules: {
    rule1: {
      cdk: {
        description,
        enabled,
        ruleName,
        schedule,
      }
    },
  },
});

Targets

targets: structure changed from Array[] ⇒ Object{}

// from
targets: [
  "src/target1.main"
  "src/target2.main"
]

// to
targets: {
  "0": "src/target1.main",
  "1": "src/target2.main",
}

Always use full props format

// from
targets: {
  myTarget: {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
targets: {
  myTarget: {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

Moved targetProps ⇒ cdk.target

// from
new EventBus(stack, "Bus", {
  rules: {
    rule1: {
      targets: {
        target1: {
          targetProps
        },
      },
    },
  },
});

// to
new EventBus(stack, "Bus", {
  rules: {
    rule1: {
      targets: {
        target1: {
          cdk: {
            target
          }
        },
      },
    },
  },
});

Properties

Moved eventsRule ⇒ cdk.rule

// from
const bus = new EventBus(stack, "Bus", { ... });
bus.eventBus;

// to
const bus = new EventBus(stack, "Bus", { ... });
bus.cdk.eventBus;

attachPermissionsToTarget(): 2nd argument type integer ⇒ string (name of the target)

bus.attachPermissionsToTarget("myRule", 0, [...]);
//to
bus.attachPermissionsToTarget("myRule", "myTarget", [...]);

KinesisStream Changelog

Constructor

Moved kinesisStream ⇒ cdk.stream

// from
{
  kinesisStream,
}
// to
{
  cdk: {
    stream,
  },
}

Default settings

Moved defaultFunctionProps ⇒ KinesisStreamProps.defaults.function

// from
{
  defaultFunctionProps: {
    timeout: 10
  },
}
// to
{
  defaults: {
    function: {
      timeout: 10
    },
  }
}

Consumers

Always use full props format

// from
consumers: {
  myConsumer: {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
consumers: {
  myConsumer: {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

Moved consumerProps ⇒ cdk.eventSource

// from
{
  consumerProps: {
    startingPosition: StartingPosition.LATEST,
  }
}
// to
{
  cdk: {
    eventSource: {
      startingPosition: StartingPosition.LATEST,
    },
  },
}

Properties

Moved kinesisStream ⇒ cdk.stream

// from
const stream = new KinesisStream(stack, "Stream", { ... });
stream.kinesisStream;

// to
const stream = new KinesisStream(stack, "Stream", { ... });
stream.cdk.stream;

Queue Changelog

Constructor

Moved sqsQueue ⇒ cdk.queue

// from
{
  sqsQueue,
}
// to
{
  cdk: {
    queue,
  },
}

Consumer

Always use full props format

// from
consumer: {
  handler: "lambda.main",
  timeout: 10,
}

// to
consumer: {
  function: {
    handler: "lambda.main",
    timeout: 10,
  }
}

Moved consumerProps ⇒ cdk.eventSource

// from
{
  consumerProps: {
    batchSize: 5,
  }
}
// to
{
  cdk: {
    eventSource: {
      batchSize: 5,
    },
  },
}

Properties

Moved eventsRule ⇒ cdk.rule

// from
const queue = new Queue(stack, "Queue", { ... });
queue.sqsQueue;

// to
const queue = new Queue(stack, "Queue", { ... });
queue.cdk.queue;

RDS Changelog

Constructor

Moved rdsServerlessCluster ⇒ cdk.cluster

// from
{
  rdsServerlessCluster,
}
// to
{
  cdk: {
    cluster,
  },
}

Properties

Moved rdsServerlessCluster ⇒ cdk.cluster

// from
const rds = new RDS(stack, "Database", { ... });
rds.rdsServerlessCluster;

// to
const rds = new RDS(stack, "Database", { ... });
rds.cdk.cluster;

Table Changelog

Constructor

Moved dynamodbTable ⇒ cdk.table

// from
{
  dynamodbTable,
}
// to
{
  cdk: {
    table,
  },
}

fields: type TableFieldType ⇒ string

// from
const table = new Table(this, "Notes", {
  fields: {
    noteId: TableFieldType.STRING,
    age: TableFieldType.NUMBER,
    key: TableFieldType.BINARY,
  },
});

// to
const table = new Table(this, "Notes", {
  fields: {
    noteId: "string",
    age: "number",
    key: "binary",
  },
});

stream: type cdk.dynamodb.StreamViewType ⇒ string

// from
import { StreamViewType } from "aws-cdk-lib/aws-dynamodb";

const table = new Table(this, "Notes", {
  stream: StreamViewType.NEW_IMAGE,
});
// to
const table = new Table(this, "Notes", {
  stream: "new_image",
});

Global Secondary Indexes

globalIndexes[].indexProps.projectionType ⇒ globalIndexes[].projection
globalIndexes[].indexProps.nonKeyAttributes ⇒ globalIndexes[].projection
globalIndexes[].indexProps.readCapacity ⇒ globalIndexes[].cdk.index.readCapacity
globalIndexes[].indexProps.writeCapacity ⇒ globalIndexes[].cdk.index.writeCapacity

// from
{
  myGlobalIndex1: {
    partitionKey: "userId",
    sortKey: "time",
    indexProps: {
      projectionType: cdk.dynamodb.ProjectionType.ALL,
      readCapacity: 20,
      writeCapacity: 10,
    },
  },
  myGlobalIndex2: {
    partitionKey: "userId",
    sortKey: "time",
    indexProps: {
      projectionType: cdk.dynamodb.ProjectionType.INCLUDE,
      nonKeyAttributes: ["key1", "key2"],
    },
  },
},

// to
{
  myGlobalIndex1: {
    partitionKey: "userId",
    sortKey: "time",
    projection: "all",
    cdk: {
      index: {
        readCapacity: 20,
        writeCapacity: 10,
      }
    }
  },
},
{
  myGlobalIndex2: {
    partitionKey: "userId",
    sortKey: "time",
    projection: ["key1", "key2"],
  },
},

Local Secondary Indexes

localIndexes[].indexProps.projectionType ⇒ localIndexes[].projection
localIndexes[].indexProps.nonKeyAttributes ⇒ localIndexes[].projection

// from
{
  myLocalIndex1: {
    sortKey: "time",
    indexProps: {
      projectionType: cdk.dynamodb.ProjectionType.ALL,
    },
  },
  myLocalIndex2: {
    sortKey: "time",
    indexProps: {
      projectionType: cdk.dynamodb.ProjectionType.INCLUDE,
      nonKeyAttributes: ["key1", "key2"],
    },
  },
}

// to
{
  myLocalIndex1: {
    sortKey: "time",
    projection: "all",
  },
  myLocalIndex2: {
    sortKey: "time",
    projection: ["key1", "key2"],
  },
},

Consumers

Always use full props format

// from
consumers: {
  myConsumer: {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
consumers: {
  myConsumer: {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

QueueProps.consumers[ANY].consumerProps ⇒ QueueProps.consumers[ANY].cdk.eventSource

// from
{
  consumerProps: {
    startingPosition: StartingPosition.LATEST,
  }
}
// to
{
  cdk: {
    eventSource: {
      startingPosition: StartingPosition.LATEST,
    },
  },
}

Properties

Moved dynamodbTable ⇒ cdk.table

// from
const table = new Table(stack, "Table", { ... });
table.dynamodbTable;

// to
const table = new Table(stack, "Table", { ... });
table.cdk.table;

Topic Changelog

Constructor

Moved snsTopic ⇒ cdk.topic

// from
{
  snsTopic,
}
// to
{
  cdk: {
    topic,
  },
}

Subscribers

subscribers: structure changed from Array[] ⇒ Object{}

// from
subscribers: [
  "src/subscriber1.main"
  "src/subscriber2.main"
]

// to
subscribers: {
  "0": "src/subscriber1.main",
  "1": "src/subscriber2.main",
}

Always use full props format

// from
subscribers: {
  mySubscriber: {
    handler: "lambda.main",
    timeout: 10,
  }
}

// to
subscribers: {
  mySubscriber: {
    function: {
      handler: "lambda.main",
      timeout: 10,
    }
  }
}

Moved subscriberProps ⇒ cdk.subscription

// from
new Topic(stack, "Topic", {
  subscribers: {
    mySubscriber: {
      subscriberProps: { ... }
    },
  },
});

// to
new Topic(stack, "Topic", {
  subscribers: {
    mySubscriber: {
      cdk: {
        subscription: { ...  }
      }
    },
  },
});

Properties

Moved snsTopic ⇒ cdk.topic
Moved snsSubscriptions ⇒ subscriptions

// from
const topic = new Topic(stack, "Topic", { ... });
topic.snsTopic;
topic.snsSubscriptions;

// to
const topic = new Topic(stack, "Topic", { ... });
topic.cdk.topic;
topic.subscriptions;

addSubscribers(): structure change from Array[] ⇒ Object{}.

topic.addSubscribers(stack, [
  "src/subscriber1.main",
  "src/subscriber2.main",
]);

//to
topic.addSubscribers(stack, {
  "0": "src/subscriber1.main",
  "1": "src/subscriber2.main",
});

attachPermissionsToSubscriber(): 1st argument type integer ⇒ string (name of the subscriber)

// from
topic.attachPermissionsToSubscriber(0, [...]);
//to
topic.attachPermissionsToSubscriber("mySubscriber", [...]);

StaticSite/ReactStaticSite/ViteStaticSite Changelog

Constructor

Moved s3Bucket ⇒ cdk.bucket
Moved cfDistribution ⇒ cdk.distribution

// from
{
  s3Bucket,
  cfDistribution,
}
// to
{
  cdk: {
    bucket,
    distribution,
  },
}

errorPage: type StaticSiteErrorOptions ⇒ string

// from
{
  errorPage: StaticSiteErrorOptions.REDIRECT_TO_INDEX_PAGE,
}
// to
{
  errorPage: "redirect_to_index_page",
}

Moved customDomain.hostedZone (if type is cdk.route53.HostedZone) ⇒ customDomain.cdk.hostedZone
Moved customDomain.certificate (if type is cdk.certificatemanager.Certificate) ⇒ customDomain.cdk.certificate

// from
{
  customDomain: {
    hostedZone,     // type is `cdk.route53.HostedZone`
    acmCertificate, // type is `cdk.certificatemanager.Certificate`
  }
}
// to
{
  customDomain: {
    cdk: {
      hostedZone,
      acmCertificate,
    }
  }
}

Properties

Moved s3Bucket ⇒ cdk.bucket
Moved cfDistribution ⇒ cdk.distribution
Moved hostedZone ⇒ cdk.hostedZone
Moved acmCertificate ⇒ cdk.certificate

// from
const site = new StaticSite(stack, "Site", { ... });
site.s3Bucket;
site.cfDistribution;
site.hostedZone;
site.acmCertificate;

// to
const site = new StaticSite(stack, "Site", { ... });
site.cdk.bucket
site.cdk.distribution
site.cdk.hostedZone
site.cdk.certificate

NextjsSite Changelog

Constructor

Moved s3Bucket ⇒ cdk.bucket
Moved cfDistribution ⇒ cdk.distribution
Moved cfCachePolicies ⇒ cdk.cachePolicies
Moved sqsRegenerationQueue ⇒ cdk.regenerationQueue

// from
{
  s3Bucket,
  cfDistribution,
  cfCachePolicies,
  sqsRegenerationQueue,
}
// to
{
  cdk: {
    bucket,
    distribution,
    cachePolicies,
    regenerationQueue,
  },
}

Moved customDomain.hostedZone (if type is cdk.route53.HostedZone) ⇒ customDomain.cdk.hostedZone
Moved customDomain.certificate (if type is cdk.certificatemanager.Certificate) ⇒ customDomain.cdk.certificate

// from
{
  customDomain: {
    hostedZone,     // type is `cdk.route53.HostedZone`
    acmCertificate, // type is `cdk.certificatemanager.Certificate`
  }
}
// to
{
  customDomain: {
    cdk: {
      hostedZone,
      acmCertificate,
    }
  }
}

Properties

Moved s3Bucket ⇒ cdk.bucket
Moved sqsRegenerationQueue ⇒ cdk.regenerationQueue
Moved cfDistribution ⇒ cdk.distribution
Moved hostedZone ⇒ cdk.hostedZone
Moved acmCertificate ⇒ cdk.certificate

// from
const site = new NextjsSite(stack, "Site", { ... });
site.s3Bucket;
site.sqsRegenerationQueue;
site.cfDistribution;
site.hostedZone;
site.acmCertificate;

// to
const site = new NextjsSite(stack, "Site", { ... });
site.cdk.bucket
site.cdk.regenerationQueue
site.cdk.distribution
site.cdk.hostedZone
site.cdk.certificate

Eslint Changelog

SST no longer directly integrates with eslint. Linting is better configured externally and run as a separate step in CI.

To setup eslint in your project first make sure you remove references to SST's eslint config

// Delete these lines in package.json
{
  "eslintConfig": {
    "extends": [
      "serverless-stack"
    ]
  }
}

From there you can follow eslint's getting started guide

Jest Changelog

SST no longer directly integrates with jest. Testing is better configured externally and run as a separate step in CI.

Remove all references to sst test in your package.json scripts

From there you can follow jest's getting started guide

Script Changelog

Default settings

Moved defaultFunctionProps ⇒ ScriptProps.defaults.function

// from
{
  defaultFunctionProps: {
    timeout: 10
  },
}
// to
{
  defaults: {
    function: {
      timeout: 10
    },
  }
}

Goals​

Upgrade Steps​

Changelog​

App Changelog​

Stack Changelog (optional)​

Adding stack to app​

Defining stack​

Permissions Changelog​

Function Changelog​

Constructor​

Api Changelog​

Constructor​

CORS​

Access log​

Custom domain​

Default settings​

Authorizers​

Routes​

Properties​

GraphQLApi Changelog​

WebSocketApi Changelog​

Constructor​

Access log​

Custom domain​

Default settings​

Authorizers​

Routes​

Properties​

AppSyncApi Changelog​

Constructor​

Data sources​

Properties​

ApiGatewayV1 Changelog​

Constructor​

Access log​

Custom domain​

Default settings​

Authorizers​

Routes​

Properties​

Auth Changelog​

Constructor​

Identity pool​

Properties​

Bucket Changelog​

Constructor​

Notifications​

Properties​

Cron Changelog​

Constructor​

Job​

Properties​

EventBus Changelog​

Constructor​

Rules​

Targets​

Properties​

KinesisStream Changelog​

Constructor​

Default settings​

Consumers​

Properties​

Queue Changelog​

Constructor​

Consumer​

Properties​

RDS Changelog​

Constructor​

Properties​

Table Changelog​

Constructor​

Global Secondary Indexes​

Local Secondary Indexes​

Consumers​

Properties​

Topic Changelog​

Constructor​

Subscribers​

Properties​

StaticSite/ReactStaticSite/ViteStaticSite Changelog​

Goals

Upgrade Steps

Changelog

App Changelog

Stack Changelog (optional)

Adding stack to app

Defining stack

Permissions Changelog

Function Changelog

Constructor

Api Changelog

Constructor

CORS

Access log

Custom domain

Default settings

Authorizers

Routes

Properties

GraphQLApi Changelog

WebSocketApi Changelog

Constructor

Access log

Custom domain

Default settings

Authorizers

Routes

Properties

AppSyncApi Changelog

Constructor

Data sources

Properties

ApiGatewayV1 Changelog

Constructor

Access log

Custom domain

Default settings

Authorizers

Routes

Properties

Auth Changelog

Constructor

Identity pool

Properties

Bucket Changelog

Constructor

Notifications

Properties

Cron Changelog

Constructor

Job

Properties

EventBus Changelog

Constructor

Rules

Targets

Properties

KinesisStream Changelog

Constructor

Default settings

Consumers

Properties

Queue Changelog

Constructor

Consumer

Properties

RDS Changelog

Constructor

Properties

Table Changelog

Constructor

Global Secondary Indexes

Local Secondary Indexes

Consumers

Properties

Topic Changelog

Constructor

Subscribers

Properties

StaticSite/ReactStaticSite/ViteStaticSite Changelog