sst 1.16.0 → 2.0.0-rc.0

package/src/constructs/Construct.ts

@@ -1,77 +0,0 @@
-import { Construct } from "constructs";
-import * as cdk from "aws-cdk-lib";
-import { Function as Fn } from "aws-cdk-lib/aws-lambda";
-import { Stack } from "./Stack.js";
-import { FunctionBindingProps } from "./util/functionBinding.js";
-
-const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
-
-export interface SSTConstructMetadata<
-  T extends string = string,
-  D extends Record<string, any> = Record<string, any>,
-  L extends Record<string, any> = Record<string, any>
-> {
-  type: T;
-  data: D;
-  local?: L;
-}
-
-export interface SSTConstruct extends Construct {
-  id: string;
-  getConstructMetadata(): SSTConstructMetadata;
-  getFunctionBinding(): FunctionBindingProps | undefined;
-}
-
-export function getFunctionRef(fn?: any) {
-  if (!fn) return undefined;
-  if (!(fn instanceof Fn)) return undefined;
-  return {
-    node: fn.node.addr,
-    stack: Stack.of(fn).node.id,
-  };
-}
-
-export function isConstruct(construct: any) {
-  return isSSTConstruct(construct) || isCDKConstruct(construct);
-}
-export function isStackConstruct(construct: any): construct is cdk.Stack {
-  return isCDKConstructOf(construct, "aws-cdk-lib.Stack");
-}
-
-export function isSSTConstruct(construct: any): construct is SSTConstruct {
-  return typeof construct === "object" && "getConstructMetadata" in construct;
-}
-
-export function isSSTDebugStack(construct: any): construct is cdk.Stack {
-  return (
-    isStackConstruct(construct) && construct.constructor.name === "DebugStack"
-  );
-}
-
-export function isCDKConstructOf(
-  construct: any,
-  moduleName: string
-): construct is Construct {
-  // We need to check if construct is an CDK construct. To do that:
-  // - we cannot use the `construct instanceof` check because ie. the PolicyStatement
-  //   instance in the user's app might come from a different npm package version
-  // - we cannot use the `construct.constructor.name` check because the constructor
-  //   name can be prefixed with a number ie. PolicyStatement2
-  //
-  // Therefore we are going to get the constructor's fqn. The constructor for a CDK
-  // construct looks like:
-  //    [class Bucket2 extends BucketBase] {
-  //      [Symbol(jsii.rtti)]: { fqn: '@aws-cdk/aws-s3.Bucket', version: '1.91.0' }
-  //    }
-  // We will check against `fqn`.
-  const fqn = construct?.constructor?.[JSII_RTTI_SYMBOL_1]?.fqn;
-  return typeof fqn === "string" && fqn === moduleName;
-}
-
-export function isCDKConstruct(construct: any): construct is Construct {
-  const fqn = construct?.constructor?.[JSII_RTTI_SYMBOL_1]?.fqn;
-  return (
-    typeof fqn === "string" &&
-    (fqn.startsWith("@aws-cdk/") || fqn.startsWith("aws-cdk-lib"))
-  );
-}

package/src/constructs/Cron.ts

@@ -1,235 +0,0 @@
-import { Construct } from "constructs";
-import * as events from "aws-cdk-lib/aws-events";
-import * as eventsTargets from "aws-cdk-lib/aws-events-targets";
-
-import { getFunctionRef, SSTConstruct } from "./Construct.js";
-import {
-  Function as Func,
-  FunctionInlineDefinition,
-  FunctionDefinition,
-} from "./Function.js";
-import { Permissions } from "./util/permission.js";
-
-export interface CronJobProps {
-  /**
-   * The function that will be executed when the job runs.
-   *
-   * @example
-   * ```js
-   *   new Cron(stack, "Cron", {
-   *     job: {
-   *       function: "src/lambda.main",
-   *     },
-   *   });
-   * ```
-   */
-  function: FunctionDefinition;
-  cdk?: {
-    /**
-     * Override the default settings this construct uses internally to create the events rule.
-     */
-    target?: eventsTargets.LambdaFunctionProps;
-  };
-}
-
-export interface CronProps {
-  /**
-   * The definition of the function to be executed.
-   *
-   * @example
-   * ```js
-   * new Cron(stack, "Cron", {
-   *   job : "src/lambda.main",
-   *   schedule: "rate(5 minutes)",
-   * })
-   * ```
-   */
-  job: FunctionInlineDefinition | CronJobProps;
-  /**
-   * The schedule for the cron job.
-   *
-   * The string format takes a [rate expression](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents-expressions.html).
-   *
-   * ```txt
-   * rate(1 minute)
-   * rate(5 minutes)
-   * rate(1 hour)
-   * rate(5 hours)
-   * rate(1 day)
-   * rate(5 days)
-   * ```
-   * Or as a [cron expression](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html#eb-cron-expressions).
-   *
-   * ```txt
-   * cron(15 10 * * ? *)    // 10:15 AM (UTC) every day.
-   * ```
-   *
-   * @example
-   * ```js
-   * new Cron(stack, "Cron", {
-   *   job: "src/lambda.main",
-   *   schedule: "rate(5 minutes)",
-   * });
-   * ```
-   * ```js
-   * new Cron(stack, "Cron", {
-   *   job: "src/lambda.main",
-   *   schedule: "cron(15 10 * * ? *)",
-   * });
-   * ```
-   */
-  schedule?: `rate(${string})` | `cron(${string})`;
-  /**
-   * Indicates whether the cron job is enabled.
-   * @default true
-   * @example
-   * ```js
-   * new Cron(stack, "Cron", {
-   *   job: "src/lambda.main",
-   *   schedule: "rate(5 minutes)",
-   *   enabled: app.local,
-   * })
-   * ```
-   */
-  enabled?: boolean;
-  cdk?: {
-    /**
-     * Allows you to override default id for this construct.
-     */
-    id?: string;
-    /**
-     * Override the default settings this construct uses internally to create the events rule.
-     */
-    rule?: events.RuleProps;
-  };
-}
-
-/////////////////////
-// Construct
-/////////////////////
-
-/**
- * The `Cron` construct is a higher level CDK construct that makes it easy to create a cron job.
- *
- * @example
- *
- * ```js
- * import { Cron } from "@serverless-stack/resources";
- *
- * new Cron(stack, "Cron", {
- *   schedule: "rate(1 minute)",
- *   job: "src/lambda.main",
- * });
- * ```
- */
-export class Cron extends Construct implements SSTConstruct {
-  public readonly id: string;
-  public readonly cdk: {
-    /**
-     * The internally created CDK EventBridge Rule instance.
-     */
-    rule: events.Rule;
-  };
-  /**
-   * The internally created Function instance that'll be run on schedule.
-   */
-  public readonly jobFunction: Func;
-  private props: CronProps;
-
-  constructor(scope: Construct, id: string, props: CronProps) {
-    super(scope, props.cdk?.id || id);
-
-    this.id = id;
-    this.props = props;
-    this.cdk = {} as any;
-
-    this.createEventsRule();
-    this.jobFunction = this.createRuleTarget();
-  }
-
-  /**
-   * Binds the given list of resources to the cron job.
-   *
-   * @example
-   *
-   * ```js
-   * cron.bind([STRIPE_KEY, bucket]);
-   * ```
-   *
-   */
-  public bind(constructs: SSTConstruct[]) {
-    this.jobFunction.bind(constructs);
-  }
-
-  /**
-   * Attaches the given list of permissions to the cron job. This allows the function to access other AWS resources.
-   *
-   * @example
-   *
-   * ```js
-   * cron.attachPermissions(["s3"]);
-   * ```
-   *
-   */
-  public attachPermissions(permissions: Permissions) {
-    this.jobFunction.attachPermissions(permissions);
-  }
-
-  public getConstructMetadata() {
-    const cfnRule = this.cdk.rule.node.defaultChild as events.CfnRule;
-    return {
-      type: "Cron" as const,
-      data: {
-        schedule: cfnRule.scheduleExpression,
-        ruleName: this.cdk.rule.ruleName,
-        job: getFunctionRef(this.jobFunction),
-      },
-    };
-  }
-
-  /** @internal */
-  public getFunctionBinding() {
-    return undefined;
-  }
-
-  private createEventsRule() {
-    const { cdk, schedule, enabled } = this.props;
-    const id = this.node.id;
-
-    // Configure Schedule
-    if (!schedule && !cdk?.rule?.schedule) {
-      throw new Error(`No schedule defined for the "${id}" Cron`);
-    }
-
-    this.cdk.rule = new events.Rule(this, "Rule", {
-      schedule: schedule && events.Schedule.expression(schedule),
-      enabled: enabled === false ? false : true,
-      ...cdk?.rule,
-    });
-  }
-
-  private createRuleTarget() {
-    const { job } = this.props;
-    const id = this.node.id;
-
-    if (!job) {
-      throw new Error(`No job defined for the "${id}" Cron`);
-    }
-
-    // normalize job
-    let jobFunction, jobProps;
-    if ((job as CronJobProps).function) {
-      jobFunction = (job as CronJobProps).function;
-      jobProps = (job as CronJobProps).cdk?.target;
-    } else {
-      jobFunction = job as FunctionInlineDefinition;
-      jobProps = {};
-    }
-
-    // create function
-    const fn = Func.fromDefinition(this, "Job", jobFunction);
-    this.cdk.rule.addTarget(new eventsTargets.LambdaFunction(fn, jobProps));
-
-    return fn;
-  }
-}

package/src/constructs/DebugApp.ts

@@ -1,97 +0,0 @@
-import { App, StageSynthesisOptions } from "aws-cdk-lib";
-import { CloudAssembly } from "aws-cdk-lib/cx-api";
-import { isStackConstruct, isSSTDebugStack } from "./Construct.js";
-
-/**
- * Deploy props for apps.
- */
-export interface DebugAppDeployProps {
-  /**
-   * The app name, used to prefix stacks.
-   */
-  name: string;
-  /**
-   * The stage to deploy this app to.
-   */
-  stage: string;
-  /**
-   * The region to deploy this app to.
-   */
-  region: string;
-}
-
-/**
- * The DebugApp construct is used internally by SST to create the resources needed to power Live Lambda Development.
- */
-export class DebugApp extends App {
-  /**
-   * The name of the app. This comes from the `name` in your `sst.json`.
-   */
-  public readonly name: string;
-  /**
-   * The stage the app is being deployed to. If this is not specified as the [`--stage`](/packages/cli.md#--stage) option, it'll default to the stage configured during the initial run of the SST CLI.
-   */
-  public readonly stage: string;
-  /**
-   * The region the app is being deployed to. If this is not specified as the [`--region`](/packages/cli.md#--region) option in the SST CLI, it'll default to the `region` in your `sst.json`.
-   */
-  public readonly region: string;
-  /**
-   * The AWS account the app is being deployed to. This comes from the IAM credentials being used to run the SST CLI.
-   */
-  public readonly account: string;
-
-  /**
-   * @internal
-   */
-  constructor(deployProps: DebugAppDeployProps) {
-    super();
-
-    this.name = deployProps.name;
-    this.stage = deployProps.stage;
-    this.region = deployProps.region;
-    this.account = process.env.CDK_DEFAULT_ACCOUNT || "my-account";
-  }
-
-  synth(options: StageSynthesisOptions = {}): CloudAssembly {
-    // Check app has stack
-    const stacks = this.node.children.filter((child) => isSSTDebugStack(child));
-    if (stacks.length > 1) {
-      console.error(
-        `Error: You can only create 1 DebugStack inside the "debugApp()" callback.\n`
-      );
-      process.exit(1);
-    }
-    if (stacks.length === 0) {
-      console.error(
-        `Error: The "debugApp()" callback is not creating a DebugStack.\n`
-      );
-      process.exit(1);
-    }
-
-    for (const child of this.node.children) {
-      if (isStackConstruct(child)) {
-        // Stack names need to be parameterized with the stage name
-        if (
-          !child.stackName.startsWith(`${this.stage}-`) &&
-          !child.stackName.endsWith(`-${this.stage}`) &&
-          child.stackName.indexOf(`-${this.stage}-`) === -1
-        ) {
-          console.error(
-            `Error: Stack "${child.stackName}" is not parameterized with the stage name. The stack name needs to either start with "$stage-", end in "-$stage", or contain the stage name "-$stage-".\n`
-          );
-          process.exit(1);
-        }
-      }
-    }
-
-    return super.synth(options);
-  }
-
-  /**
-   * Use this method to prefix resource names in your stacks to make sure they don't thrash when deployed to different stages in the same AWS account. This method will prefix a given resource name with the stage and app name. Using the format `${stage}-${name}-${logicalName}`.
-   */
-  public logicalPrefixedName(logicalName: string): string {
-    return `${this.stage}-${this.name}-${logicalName}`;
-  }
-}

package/src/constructs/DebugStack.ts

@@ -1,182 +0,0 @@
-import * as path from "path";
-import url from "url";
-import { Construct } from "constructs";
-import * as cdk from "aws-cdk-lib";
-import * as s3 from "aws-cdk-lib/aws-s3";
-import * as iam from "aws-cdk-lib/aws-iam";
-import * as logs from "aws-cdk-lib/aws-logs";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import * as apig from "aws-cdk-lib/aws-apigatewayv2";
-import * as dynamodb from "aws-cdk-lib/aws-dynamodb";
-import { DebugApp } from "./DebugApp.js";
-
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-
-/**
- * Stack properties for the DebugStack.
- */
-export interface DebugStackProps extends cdk.StackProps {
-  /**
-   * S3 bucket to store large websocket payloads.
-   */
-  payloadBucketArn?: string;
-  /**
-   * Lambda function props for WebSocket request handlers.
-   */
-  websocketHandlerRoleArn?: string;
-  cdk?: {
-    /**
-     * Override the settings of the internally created DynamoDB table
-     */
-    table?: Omit<dynamodb.TableProps, "partitionKey" | "sortKey">;
-  };
-}
-
-/**
- * The `DebugStack` construct is used internally to create the resources needed to power Live Lambda Development. Note that, the `DebugStack` construct should only be created inside the [`DebugApp`](DebugApp).
- */
-export class DebugStack extends cdk.Stack {
-  public readonly stage: string;
-  private readonly api: apig.CfnApi;
-  private readonly table: dynamodb.Table;
-  private readonly bucket: s3.IBucket;
-
-  constructor(scope: Construct, id: string, props?: DebugStackProps) {
-    const app = scope.node.root as DebugApp;
-    const stackId = app.logicalPrefixedName(id);
-
-    DebugStack.checkForEnvInProps(id, props);
-
-    super(scope, stackId, {
-      ...props,
-      env: {
-        account: app.account,
-        region: app.region,
-      },
-    });
-
-    this.stage = app.stage;
-
-    // Create connection table
-    this.table = new dynamodb.Table(this, "Table", {
-      partitionKey: { name: "pk", type: dynamodb.AttributeType.STRING },
-      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
-      removalPolicy: cdk.RemovalPolicy.DESTROY,
-      ...props?.cdk?.table,
-    });
-
-    // Create S3 bucket for storing large payloads
-    this.bucket = props?.payloadBucketArn
-      ? s3.Bucket.fromBucketArn(this, "Bucket", props.payloadBucketArn)
-      : new s3.Bucket(this, "Bucket", {
-          lifecycleRules: [
-            {
-              expiration: cdk.Duration.days(1),
-              prefix: "payloads/",
-            },
-          ],
-          encryption: s3.BucketEncryption.S3_MANAGED,
-          removalPolicy: cdk.RemovalPolicy.DESTROY,
-          autoDeleteObjects: true,
-          blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
-        });
-
-    // Create API
-    this.api = new apig.CfnApi(this, "Api", {
-      name: `${this.stackName}-api`,
-      protocolType: "WEBSOCKET",
-      routeSelectionExpression: "$request.body.action",
-    });
-    new apig.CfnStage(this, "ApiStage", {
-      apiId: this.api.ref,
-      autoDeploy: true,
-      stageName: this.stage,
-    });
-
-    // Create API routes
-    const role = props?.websocketHandlerRoleArn
-      ? iam.Role.fromRoleArn(this, "HandlerRole", props.websocketHandlerRoleArn)
-      : undefined;
-    this.addApiRoute("Connect", "$connect", "wsConnect.main", role);
-    this.addApiRoute("Disconnect", "$disconnect", "wsDisconnect.main", role);
-    this.addApiRoute("Default", "$default", "wsDefault.main", role);
-
-    // Stack Output
-    new cdk.CfnOutput(this, "Endpoint", {
-      value: `${this.api.attrApiEndpoint}/${this.stage}`,
-    });
-    new cdk.CfnOutput(this, "BucketArn", {
-      value: this.bucket.bucketArn,
-    });
-    new cdk.CfnOutput(this, "BucketName", {
-      value: this.bucket.bucketName,
-    });
-  }
-
-  private addApiRoute(
-    id: string,
-    routeKey: string,
-    handler: string,
-    role?: iam.IRole
-  ) {
-    // Create execution policy
-    const policyStatement = new iam.PolicyStatement();
-    policyStatement.addAllResources();
-    policyStatement.addActions(
-      "apigateway:*",
-      "dynamodb:*",
-      "execute-api:ManageConnections"
-    );
-
-    // Create Lambda
-    const lambdaFunc = new lambda.Function(this, id, {
-      code: lambda.Code.fromAsset(path.join(__dirname, "../assets/DebugStack")),
-      handler,
-      runtime: lambda.Runtime.NODEJS_16_X,
-      timeout: cdk.Duration.seconds(10),
-      memorySize: 256,
-      logRetention: logs.RetentionDays.ONE_WEEK,
-      logRetentionRole: role,
-      environment: {
-        TABLE_NAME: this.table.tableName,
-      },
-      role,
-      initialPolicy: [policyStatement],
-    });
-    lambdaFunc.addPermission(`${id}Permission`, {
-      principal: new iam.ServicePrincipal("apigateway.amazonaws.com"),
-    });
-
-    // Create API integrations
-    const integration = new apig.CfnIntegration(this, `${id}Integration`, {
-      apiId: this.api.ref,
-      integrationType: "AWS_PROXY",
-      integrationUri: `arn:${this.partition}:apigateway:${this.region}:lambda:path/2015-03-31/functions/${lambdaFunc.functionArn}/invocations`,
-    });
-
-    // Create API routes
-    new apig.CfnRoute(this, `${id}Route`, {
-      apiId: this.api.ref,
-      routeKey,
-      authorizationType: "NONE",
-      target: `integrations/${integration.ref}`,
-    });
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private static checkForEnvInProps(id: string, props?: any) {
-    if (props && props.env) {
-      let envS = "";
-
-      try {
-        envS = " (" + JSON.stringify(props.env) + ")";
-      } catch (e) {
-        // Ignore
-      }
-
-      throw new Error(
-        `Do not set the "env" prop while initializing "${id}" stack${envS}. Use the "AWS_PROFILE" environment variable and "--region" CLI option instead.`
-      );
-    }
-  }
-}