sst 1.16.0 → 2.0.0-rc.0

package/src/constructs/deferred_task.ts

@@ -1,53 +0,0 @@
-import { cpus } from "os";
-import { createAppContext } from "./context.js";
-
-type Task = () => Promise<void>;
-
-export const useDeferredTasks = createAppContext(() => {
-  const tasks: Task[] = [];
-
-  return {
-    add(task: Task) {
-      tasks.push(task);
-    },
-    async run() {
-      const coreNum = cpus().length;
-      const concurrency = Math.max(
-        1,
-        process.env.SST_BUILD_CONCURRENCY
-          ? parseInt(process.env.SST_BUILD_CONCURRENCY, 10)
-          : coreNum - 1
-      );
-      let remaining = tasks.length;
-
-      return new Promise((resolve, reject) => {
-        const runTask = () => {
-          // Get task
-          const task = tasks.shift();
-          if (!task) {
-            // all tasks completed
-            if (remaining === 0) {
-              resolve(true);
-            }
-            return;
-          }
-
-          // Run task
-          task()
-            .then(() => {
-              remaining--;
-              runTask();
-            })
-            .catch(e => {
-              reject(e);
-            });
-        };
-
-        // Run tasks in parallel
-        for (let i = 0; i < concurrency; i++) {
-          runTask();
-        }
-      });
-    }
-  };
-});

package/src/constructs/descs.d.ts

@@ -1 +0,0 @@
-declare module "zip-local";

package/src/constructs/index.ts

@@ -1,39 +0,0 @@
-export * from "./App.js";
-export * from "./Auth.js";
-export * from "./Api.js";
-export * from "./Job.js";
-export * from "./RDS.js";
-export * from "./Cognito.js";
-export * from "./Cron.js";
-export * from "./Queue.js";
-export * from "./Stack.js";
-export * from "./Table.js";
-export * from "./Topic.js";
-export * from "./Bucket.js";
-export * from "./Script.js";
-export * from "./EventBus.js";
-export * from "./Function.js";
-export * from "./GraphQLApi.js";
-export * from "./AppSyncApi.js";
-export * from "./DebugStack.js";
-export * from "./WebSocketApi.js";
-export * from "./KinesisStream.js";
-export * from "./ApiGatewayV1Api.js";
-
-export * from "./NextjsSite.js";
-export * from "./RemixSite.js";
-export * from "./StaticSite.js";
-export * from "./ViteStaticSite.js";
-export * from "./ReactStaticSite.js";
-
-export * from "./util/size.js";
-export * from "./util/duration.js";
-export * from "./util/permission.js";
-export * as Config from "./Config.js";
-export * as Metadata from "./Metadata.js";
-
-export * from "./DebugApp.js";
-export * from "./DebugStack.js";
-
-export { use, dependsOn, getStack } from "./FunctionalStack.js";
-export type { StackContext } from "./FunctionalStack.js";

package/src/constructs/nextjs-site/cross-region-helper.ts

@@ -1,189 +0,0 @@
-import path from "path";
-import crypto from "crypto";
-import url from "url";
-import { Construct } from "constructs";
-import * as cdk from "aws-cdk-lib";
-import * as iam from "aws-cdk-lib/aws-iam";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-
-export function getOrCreateBucket(scope: Construct): cdk.CustomResource {
-  // Do not recreate if exist
-  const providerId = "EdgeLambdaBucketProvider";
-  const resId = "EdgeLambdaBucket";
-  const stack = cdk.Stack.of(scope);
-  const existingResource = stack.node.tryFindChild(resId) as cdk.CustomResource;
-  if (existingResource) {
-    return existingResource;
-  }
-
-  // Create provider
-  const provider = new lambda.Function(stack, providerId, {
-    code: lambda.Code.fromAsset(path.join(__dirname, "custom-resource")),
-    handler: "s3-bucket.handler",
-    runtime: lambda.Runtime.NODEJS_16_X,
-    timeout: cdk.Duration.minutes(15),
-    memorySize: 1024,
-    initialPolicy: [
-      new iam.PolicyStatement({
-        effect: iam.Effect.ALLOW,
-        actions: ["s3:*"],
-        resources: ["*"],
-      }),
-    ],
-  });
-
-  // Create custom resource
-  const resource = new cdk.CustomResource(stack, resId, {
-    serviceToken: provider.functionArn,
-    resourceType: "Custom::SSTEdgeLambdaBucket",
-    properties: {
-      BucketNamePrefix: `${stack.stackName}-${resId}`,
-    },
-  });
-
-  return resource;
-}
-
-export function createFunction(
-  scope: Construct,
-  name: string,
-  role: iam.Role,
-  bucketName: string,
-  functionParams: any
-): cdk.CustomResource {
-  // Do not recreate if exist
-  const providerId = "EdgeLambdaProvider";
-  const resId = `${name}EdgeLambda`;
-  const stack = cdk.Stack.of(scope);
-  let provider = stack.node.tryFindChild(providerId) as lambda.Function;
-
-  // Create provider if not already created
-  if (!provider) {
-    provider = new lambda.Function(stack, providerId, {
-      code: lambda.Code.fromAsset(path.join(__dirname, "custom-resource")),
-      handler: "edge-lambda.handler",
-      runtime: lambda.Runtime.NODEJS_16_X,
-      timeout: cdk.Duration.minutes(15),
-      memorySize: 1024,
-      initialPolicy: [
-        new iam.PolicyStatement({
-          effect: iam.Effect.ALLOW,
-          actions: ["lambda:*", "s3:*"],
-          resources: ["*"],
-        }),
-      ],
-    });
-    if (provider.role) {
-      role.grantPassRole(provider.role);
-    }
-  }
-
-  // Create custom resource
-  const resource = new cdk.CustomResource(scope, resId, {
-    serviceToken: provider.functionArn,
-    resourceType: "Custom::SSTEdgeLambda",
-    properties: {
-      FunctionNamePrefix: `${cdk.Stack.of(scope).stackName}-${resId}`,
-      FunctionBucket: bucketName,
-      FunctionParams: functionParams,
-    },
-  });
-
-  return resource;
-}
-
-export function createVersion(
-  scope: Construct,
-  name: string,
-  functionArn: string
-): cdk.CustomResource {
-  // Do not recreate if exist
-  const providerId = "EdgeLambdaVersionProvider";
-  const resId = `${name}EdgeLambdaVersion`;
-  const stack = cdk.Stack.of(scope);
-  let provider = stack.node.tryFindChild(providerId) as lambda.Function;
-
-  // Create provider if not already created
-  if (!provider) {
-    provider = new lambda.Function(stack, providerId, {
-      code: lambda.Code.fromAsset(path.join(__dirname, "custom-resource")),
-      handler: "edge-lambda-version.handler",
-      runtime: lambda.Runtime.NODEJS_16_X,
-      timeout: cdk.Duration.minutes(15),
-      memorySize: 1024,
-      initialPolicy: [
-        new iam.PolicyStatement({
-          effect: iam.Effect.ALLOW,
-          actions: ["lambda:*"],
-          resources: ["*"],
-        }),
-      ],
-    });
-  }
-
-  // Create custom resource
-  return new cdk.CustomResource(scope, resId, {
-    serviceToken: provider.functionArn,
-    resourceType: "Custom::SSTEdgeLambdaVersion",
-    properties: {
-      FunctionArn: functionArn,
-    },
-  });
-}
-
-export function updateVersionLogicalId(
-  functionCR: cdk.CustomResource,
-  versionCR: cdk.CustomResource
-) {
-  // Override the version's logical ID with a lazy string which includes the
-  // hash of the function itself, so a new version resource is created when
-  // the function configuration changes.
-  const cfn = versionCR.node.defaultChild as cdk.CfnResource;
-  const originalLogicalId = cdk.Stack.of(versionCR).resolve(
-    cfn.logicalId
-  ) as string;
-  cfn.overrideLogicalId(
-    cdk.Lazy.uncachedString({
-      produce: () => {
-        const hash = calculateHash(functionCR);
-        const logicalId = trimFromStart(originalLogicalId, 255 - 32);
-        return `${logicalId}${hash}`;
-      },
-    })
-  );
-}
-
-function trimFromStart(s: string, maxLength: number) {
-  const desiredLength = Math.min(maxLength, s.length);
-  const newStart = s.length - desiredLength;
-  return s.substring(newStart);
-}
-
-function calculateHash(resource: cdk.CustomResource): string {
-  // render the cloudformation resource from this function
-  // config is of the shape:
-  // {
-  //  Resources: {
-  //    LogicalId: {
-  //      Type: 'Function',
-  //      Properties: { ... }
-  // }}}
-  const cfnResource = resource.node.defaultChild as cdk.CfnResource;
-  const config = cdk.Stack.of(resource).resolve(
-    (cfnResource as any)._toCloudFormation()
-  );
-  const resources = config.Resources;
-  const resourceKeys = Object.keys(resources);
-  if (resourceKeys.length !== 1) {
-    throw new Error(
-      `Expected one rendered CloudFormation resource but found ${resourceKeys.length}`
-    );
-  }
-  const logicalId = resourceKeys[0];
-  const properties = resources[logicalId].Properties.FunctionParams;
-
-  const hash = crypto.createHash("md5");
-  hash.update(JSON.stringify(properties));
-  return hash.digest("hex");
-}

package/src/constructs/nextjs-site/custom-resource/cfn-response.ts

@@ -1,146 +0,0 @@
-/* eslint-disable max-len */
-/* eslint-disable no-console */
-import https from "https";
-import url from "url";
-import { log } from "./util.js";
-
-export const CREATE_FAILED_PHYSICAL_ID_MARKER =
-  "AWSCDK::CustomResourceProviderFramework::CREATE_FAILED";
-export const MISSING_PHYSICAL_ID_MARKER =
-  "AWSCDK::CustomResourceProviderFramework::MISSING_PHYSICAL_ID";
-
-export interface CloudFormationResponseOptions {
-  readonly reason?: string;
-  readonly noEcho?: boolean;
-}
-
-export interface CloudFormationEventContext {
-  StackId: string;
-  RequestId: string;
-  PhysicalResourceId?: string;
-  LogicalResourceId: string;
-  ResponseURL: string;
-  Data?: any;
-}
-
-export async function submitResponse(
-  status: "SUCCESS" | "FAILED",
-  event: CloudFormationEventContext,
-  options: CloudFormationResponseOptions = {}
-) {
-  const json: AWSLambda.CloudFormationCustomResourceResponse = {
-    Status: status,
-    Reason: options.reason || status,
-    StackId: event.StackId,
-    RequestId: event.RequestId,
-    PhysicalResourceId: event.PhysicalResourceId || MISSING_PHYSICAL_ID_MARKER,
-    LogicalResourceId: event.LogicalResourceId,
-    NoEcho: options.noEcho,
-    Data: event.Data,
-  };
-
-  log("submit response to cloudformation", json);
-
-  const responseBody = JSON.stringify(json);
-
-  const parsedUrl = url.parse(event.ResponseURL);
-  await httpRequest(
-    {
-      hostname: parsedUrl.hostname,
-      path: parsedUrl.path,
-      method: "PUT",
-      headers: {
-        "content-type": "",
-        "content-length": responseBody.length,
-      },
-    },
-    responseBody
-  );
-}
-
-export const includeStackTraces = true; // for unit tests
-
-export function safeHandler(block: (event: any) => Promise<void>) {
-  return async (event: any) => {
-    // ignore DELETE event when the physical resource ID is the marker that
-    // indicates that this DELETE is a subsequent DELETE to a failed CREATE
-    // operation.
-    if (
-      event.RequestType === "Delete" &&
-      event.PhysicalResourceId === CREATE_FAILED_PHYSICAL_ID_MARKER
-    ) {
-      log("ignoring DELETE event caused by a failed CREATE event");
-      await submitResponse("SUCCESS", event);
-      return;
-    }
-
-    try {
-      await block(event);
-    } catch (e: any) {
-      log(e);
-
-      // tell waiter state machine to retry
-      if (e instanceof Retry) {
-        log("retry requested by handler");
-        throw e;
-      }
-
-      if (!event.PhysicalResourceId) {
-        // special case: if CREATE fails, which usually implies, we usually don't
-        // have a physical resource id. in this case, the subsequent DELETE
-        // operation does not have any meaning, and will likely fail as well. to
-        // address this, we use a marker so the provider framework can simply
-        // ignore the subsequent DELETE.
-        if (event.RequestType === "Create") {
-          log(
-            "CREATE failed, responding with a marker physical resource id so that the subsequent DELETE will be ignored"
-          );
-          event.PhysicalResourceId = CREATE_FAILED_PHYSICAL_ID_MARKER;
-        } else {
-          // otherwise, if PhysicalResourceId is not specified, something is
-          // terribly wrong because all other events should have an ID.
-          log(
-            `ERROR: Malformed event. "PhysicalResourceId" is required: ${JSON.stringify(
-              event
-            )}`
-          );
-        }
-      }
-
-      // this is an actual error, fail the activity altogether and exist.
-      // append a reference to the log group.
-      const reason = [
-        e.message,
-        `Logs: https://${
-          process.env.AWS_REGION
-        }.console.aws.amazon.com/cloudwatch/home?region=${
-          process.env.AWS_REGION
-        }#logsV2:log-groups/log-group/${encodeURIComponent(
-          process.env.AWS_LAMBDA_LOG_GROUP_NAME as string
-        )}/log-events/${encodeURIComponent(
-          process.env.AWS_LAMBDA_LOG_STREAM_NAME as string
-        )}`,
-      ].join("\n");
-
-      await submitResponse("FAILED", event, { reason });
-    }
-  };
-}
-
-export class Retry extends Error {}
-
-async function httpRequest(
-  options: https.RequestOptions,
-  responseBody: string
-) {
-  return new Promise((resolve, reject) => {
-    try {
-      const request = https.request(options, resolve);
-      request.on("error", reject);
-      request.write(responseBody);
-      request.end();
-    } catch (e) {
-      reject(e);
-    }
-  });
-}

package/src/constructs/nextjs-site/custom-resource/edge-lambda-version.ts

@@ -1,162 +0,0 @@
-import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-const AWS = require("aws-sdk");
-AWS.config.logger = console;
-
-import { log } from "./util.js";
-import * as cfnResponse from "./cfn-response.js";
-const lambda = new AWS.Lambda({ region: "us-east-1" });
-const LIVE_ALIAS = "live";
-
-export const handler = cfnResponse.safeHandler(async (
-  cfnRequest: AWSLambda.CloudFormationCustomResourceEvent
-) => {
-  log("onEventHandler", cfnRequest);
-
-  // Process request
-  let PhysicalResourceId;
-  let Data;
-  const functionArn = cfnRequest.ResourceProperties.FunctionArn;
-  const functionName = functionArn.split(":").pop();
-  switch (cfnRequest.RequestType) {
-    case "Create": {
-      const ret = await createVersion(functionName);
-      const version = ret.Version as string;
-      await createAlias(functionName, version);
-      PhysicalResourceId = `${functionArn}:${version}`;
-      Data = { Version: version };
-      break;
-    }
-    case "Update": {
-      PhysicalResourceId = cfnRequest.PhysicalResourceId;
-      Data = { Version: cfnRequest.PhysicalResourceId.split(":").pop() };
-      break;
-    }
-    case "Delete": {
-      await deleteOldVersions(functionName);
-      PhysicalResourceId = cfnRequest.PhysicalResourceId;
-      break;
-    }
-    default:
-      throw new Error("Unsupported request type");
-  }
-
-  // Build response
-  return cfnResponse.submitResponse("SUCCESS", {
-    ...cfnRequest,
-    PhysicalResourceId,
-    Data,
-  });
-});
-
-async function createVersion(functionName: string) {
-  log(`createVersion() called with functionName`, functionName);
-
-  const resp = await lambda
-    .publishVersion({
-      FunctionName: functionName,
-    })
-    .promise();
-
-  log(`response`, resp);
-
-  return { Version: resp.Version };
-}
-
-async function createAlias(functionName: string, version: string) {
-  log(
-    `createAlias() called with functionName`,
-    functionName,
-    "version",
-    version
-  );
-
-  let resp;
-
-  // Update alias
-  try {
-    log("updateAlias");
-    resp = await lambda
-      .updateAlias({
-        Name: LIVE_ALIAS,
-        FunctionName: functionName,
-        FunctionVersion: version,
-      })
-      .promise();
-
-    log("response", resp);
-  } catch (e: any) {
-    // If alias has not be created, create the alias
-    if (
-      e.code === "ResourceNotFoundException" &&
-      e.message.startsWith("Alias not found")
-    ) {
-      log("updateAlias");
-      resp = await lambda
-        .createAlias({
-          Name: LIVE_ALIAS,
-          FunctionName: functionName,
-          FunctionVersion: version,
-        })
-        .promise();
-
-      log("response", resp);
-      return;
-    }
-    throw e;
-  }
-}
-
-async function deleteOldVersions(functionName: string) {
-  log(`deleteOldVersions() called with functionName`, functionName);
-
-  let resp;
-  try {
-    // Get LIVE_ALIAS version
-    resp = await lambda
-      .getAlias({
-        FunctionName: functionName,
-        Name: LIVE_ALIAS,
-      })
-      .promise();
-    log(`getAlias`, resp);
-    const liveVersion = resp.FunctionVersion;
-
-    // Get all versions
-    resp = await lambda
-      .listVersionsByFunction({
-        FunctionName: functionName,
-        MaxItems: 50,
-      })
-      .promise();
-    log(`listVersionsByFunction`, resp);
-    const versionObjs = resp.Versions || [];
-
-    // Remove non LIVE_ALIAS versions
-    for (let i = 0, l = versionObjs.length; i < l; i++) {
-      const version = versionObjs[i].Version;
-      if (version === liveVersion) {
-        log("deleteVersion", version, "skipped");
-        continue;
-      }
-
-      try {
-        log("deleteVersion", version, "do");
-        resp = await lambda
-          .deleteFunction({
-            FunctionName: functionName,
-            Qualifier: version,
-          })
-          .promise();
-        log("response", resp);
-      } catch (e) {
-        // Supress error because a version can fail to remove if still in use.
-        log(`deleteVersion error`, e);
-      }
-    }
-  } catch (e) {
-    // Supress error because it is fine if a specific version fails to remove.
-    // All versions will be removed upon removing the function.
-    log(`deleteOldVersions error`, e);
-  }
-}