sst 1.16.0 → 2.0.0-rc.0

package/src/constructs/Script/cfn-response.ts

@@ -1,116 +0,0 @@
-/* eslint-disable max-len */
-/* eslint-disable no-console */
-import url from "url";
-import { httpRequest } from "./outbound.js";
-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) {
-      // 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.
-      await submitResponse("FAILED", event, {
-        reason: includeStackTraces ? e.stack : e.message,
-      });
-    }
-  };
-}
-
-export class Retry extends Error {}

package/src/constructs/Script/index.ts

@@ -1,103 +0,0 @@
-import * as cfnResponse from "./cfn-response.js";
-import { invokeFunction } from "./outbound.js";
-import { log } from "./util.js";
-
-export const handler = cfnResponse.safeHandler(async (
-  cfnRequest: AWSLambda.CloudFormationCustomResourceEvent
-) => {
-  log("onEventHandler", cfnRequest);
-
-  // Invoke user function on Create and on Update
-  const fnCreate = cfnRequest.ResourceProperties.UserCreateFunction;
-  const fnUpdate = cfnRequest.ResourceProperties.UserUpdateFunction;
-  const fnDelete = cfnRequest.ResourceProperties.UserDeleteFunction;
-  const fnParams = JSON.parse(cfnRequest.ResourceProperties.UserParams);
-  if (cfnRequest.RequestType === "Create" && fnCreate) {
-    await invokeUserFunction(fnCreate, { params: fnParams });
-  } else if (cfnRequest.RequestType === "Update" && fnUpdate) {
-    await invokeUserFunction(fnUpdate, { params: fnParams });
-  } else if (cfnRequest.RequestType === "Delete" && fnDelete) {
-    await invokeUserFunction(fnDelete, { params: fnParams });
-  }
-
-  // Build response
-  return cfnResponse.submitResponse("SUCCESS", {
-    ...cfnRequest,
-    PhysicalResourceId: defaultPhysicalResourceId(cfnRequest),
-  });
-});
-
-async function invokeUserFunction(functionName: string, payload: any) {
-  log(`executing user function ${functionName} with payload`, payload);
-
-  const resp = await invokeFunction({
-    FunctionName: functionName,
-    Payload: JSON.stringify(payload),
-  });
-
-  log("user function response:", resp, typeof resp);
-
-  if (resp.FunctionError) {
-    log("user function threw an error:", resp.FunctionError);
-
-    const jsonPayload = parseJsonPayload(resp.Payload);
-
-    // Note: custom resources have a response limit of 4k. Limit the
-    //       error message to 1000 characters.
-    const errorMessage = (jsonPayload.errorMessage || "error").substring(
-      0,
-      1000
-    );
-
-    // append a reference to the log group.
-    const message = [
-      errorMessage,
-      "",
-      `Logs: /aws/lambda/${functionName}`, // cloudwatch log group
-      "",
-    ].join("\n");
-
-    const e = new Error(message);
-
-    // the output that goes to CFN is what's in `stack`, not the error message.
-    // if we have a remote trace, construct a nice message with log group information
-    if (jsonPayload.trace) {
-      // skip first trace line because it's the message
-      e.stack = [message, ...jsonPayload.trace.slice(1)].join("\n");
-    }
-
-    throw e;
-  }
-}
-
-function parseJsonPayload(payload: any): any {
-  if (!payload) {
-    return {};
-  }
-  const text = payload.toString();
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    throw new Error(
-      `return values from user-handlers must be JSON objects. got: "${text}"`
-    );
-  }
-}
-
-function defaultPhysicalResourceId(
-  req: AWSLambda.CloudFormationCustomResourceEvent
-): string {
-  switch (req.RequestType) {
-    case "Create":
-      return req.RequestId;
-
-    case "Update":
-    case "Delete":
-      return req.PhysicalResourceId;
-
-    default:
-      throw new Error(
-        `Invalid "RequestType" in request "${JSON.stringify(req)}"`
-      );
-  }
-}

package/src/constructs/Script/outbound.ts

@@ -1,59 +0,0 @@
-/* istanbul ignore file */
-import * as https from "https";
-import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-const AWS = require("aws-sdk");
-import type { StepFunctions, Lambda } from "aws-sdk";
-import type { ConfigurationOptions } from "aws-sdk/lib/config-base";
-
-const FRAMEWORK_HANDLER_TIMEOUT = 900000; // 15 minutes
-
-// In order to honor the overall maximum timeout set for the target process,
-// the default 2 minutes from AWS SDK has to be overriden:
-// https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Config.html#httpOptions-property
-const awsSdkConfig: ConfigurationOptions = {
-  httpOptions: { timeout: FRAMEWORK_HANDLER_TIMEOUT },
-};
-
-async function defaultHttpRequest(
-  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);
-    }
-  });
-}
-
-let sfn: StepFunctions;
-let lambda: Lambda;
-
-async function defaultStartExecution(
-  req: StepFunctions.StartExecutionInput
-): Promise<StepFunctions.StartExecutionOutput> {
-  if (!sfn) {
-    sfn = new AWS.StepFunctions(awsSdkConfig);
-  }
-
-  return sfn.startExecution(req).promise();
-}
-
-async function defaultInvokeFunction(
-  req: Lambda.InvocationRequest
-): Promise<Lambda.InvocationResponse> {
-  if (!lambda) {
-    lambda = new AWS.Lambda(awsSdkConfig);
-  }
-
-  return lambda.invoke(req).promise();
-}
-
-export const startExecution = defaultStartExecution;
-export const invokeFunction = defaultInvokeFunction;
-export const httpRequest = defaultHttpRequest;

package/src/constructs/Script/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/src/constructs/Script/util.ts

@@ -1,19 +0,0 @@
-/* eslint-disable no-console */
-
-export function getEnv(name: string): string {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(`The environment variable "${name}" is not defined`);
-  }
-  return value;
-}
-
-export function log(title: any, ...args: any[]) {
-  console.log(
-    "[provider-framework]",
-    title,
-    ...args.map((x) =>
-      typeof x === "object" ? JSON.stringify(x, undefined, 2) : x
-    )
-  );
-}

package/src/constructs/Script.ts

@@ -1,270 +0,0 @@
-import path from "path";
-import url from "url";
-import { Construct } from "constructs";
-import * as cdk from "aws-cdk-lib";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import { App } from "./App.js";
-import {
-  Function as Fn,
-  FunctionProps,
-  FunctionDefinition,
-} from "./Function.js";
-import { SSTConstruct } from "./Construct.js";
-import { Permissions } from "./util/permission.js";
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-
-export interface ScriptProps {
-  /**
-   * An object of input parameters to be passed to the script. Made available in the `event` object of the function.
-   *
-   * @example
-   * ```js
-   * import { Script } from "@serverless-stack/resources";
-   *
-   * new Script(stack, "Script", {
-   *   onCreate: "src/script.create",
-   *   params: {
-   *     hello: "world",
-   *   },
-   * });
-   * ```
-   */
-  params?: Record<string, any>;
-  defaults?: {
-    /**
-     * The default function props to be applied to all the Lambda functions in the API. The `environment`, `permissions` and `layers` properties will be merged with per route definitions if they are defined.
-     *
-     * @example
-     * ```js
-     * new Script(stack, "Api", {
-     *   defaults: {
-     *     function: {
-     *       timeout: 20,
-     *     }
-     *   }
-     * });
-     * ```
-     */
-    function?: FunctionProps;
-  };
-  /**
-   * Creates the function that runs when the Script is created.
-   *
-   * @example
-   * ```js
-   * new Script(stack, "Api", {
-   *   onCreate: "src/function.handler",
-   * })
-   * ```
-   */
-  onCreate?: FunctionDefinition;
-  /**
-   * Creates the function that runs on every deploy after the Script is created
-   *
-   * @example
-   * ```js
-   * new Script(stack, "Api", {
-   *   onUpdate: "src/function.handler",
-   * })
-   * ```
-   */
-  onUpdate?: FunctionDefinition;
-  /**
-   * Create the function that runs when the Script is deleted from the stack.
-   *
-   * @example
-   * ```js
-   * new Script(stack, "Api", {
-   *   onDelete: "src/function.handler",
-   * })
-   * ```
-   */
-  onDelete?: FunctionDefinition;
-}
-
-/////////////////////
-// Construct
-/////////////////////
-
-/**
- * The `Script` construct is a higher level CDK construct that makes it easy to run a script in a Lambda function during the deployment process.
- *
- * @example
- *
- * ```js
- * import { Script } from "@serverless-stack/resources";
- *
- * new Script(stack, "Script", {
- *   onCreate: "src/function.create",
- *   onUpdate: "src/function.update",
- *   onDelete: "src/function.delete",
- * });
- * ```
- */
-export class Script extends Construct {
-  /**
-   * The internally created onCreate `Function` instance.
-   */
-  public readonly createFunction?: Fn;
-  /**
-   * The internally created onUpdate `Function` instance.
-   */
-  public readonly updateFunction?: Fn;
-  /**
-   * The internally created onDelete `Function` instance.
-   */
-  public readonly deleteFunction?: Fn;
-  protected readonly props: ScriptProps;
-
-  constructor(scope: Construct, id: string, props: ScriptProps) {
-    super(scope, id);
-    if ((props as any).function) this.checkDeprecatedFunction();
-
-    // Validate deprecated "function" prop
-
-    // Validate at least 1 function is provided
-    if (!props.onCreate && !props.onUpdate && !props.onDelete) {
-      throw new Error(
-        `Need to provide at least one of "onCreate", "onUpdate", or "onDelete" functions for the "${this.node.id}" Script`
-      );
-    }
-
-    const root = scope.node.root as App;
-    this.props = props;
-
-    this.createFunction = this.createUserFunction("onCreate", props.onCreate);
-    this.updateFunction = this.createUserFunction("onUpdate", props.onUpdate);
-    this.deleteFunction = this.createUserFunction("onDelete", props.onDelete);
-    const crFunction = this.createCustomResourceFunction();
-    this.createCustomResource(root, crFunction);
-  }
-
-  /**
-   * Binds additional resources to the script
-   *
-   * @example
-   * ```js
-   * script.bind([STRIPE_KEY, bucket]);
-   * ```
-   */
-  public bind(constructs: SSTConstruct[]): void {
-    this.createFunction?.bind(constructs);
-    this.updateFunction?.bind(constructs);
-    this.deleteFunction?.bind(constructs);
-  }
-
-  /**
-   * Grants additional permissions to the script
-   *
-   * @example
-   * ```js
-   * script.attachPermissions(["s3"]);
-   * ```
-   */
-  public attachPermissions(permissions: Permissions): void {
-    this.createFunction?.attachPermissions(permissions);
-    this.updateFunction?.attachPermissions(permissions);
-    this.deleteFunction?.attachPermissions(permissions);
-  }
-
-  protected createUserFunction(
-    type: string,
-    fnDef?: FunctionDefinition
-  ): Fn | undefined {
-    if (!fnDef) {
-      return;
-    }
-
-    // function is construct => return function directly
-    if (fnDef instanceof Fn) {
-      // validate live dev is not enabled
-      if (fnDef._isLiveDevEnabled) {
-        throw new Error(
-          `Live Lambda Dev cannot be enabled for functions in the Script construct. Set the "enableLiveDev" prop for the function to "false".`
-        );
-      }
-
-      return Fn.fromDefinition(
-        this,
-        `${type}Function`,
-        fnDef,
-        this.props.defaults?.function,
-        `The "defaults.function" cannot be applied if an instance of a Function construct is passed in. Make sure to define the "${type}" function using FunctionProps, so the Script construct can apply the "defaults.function" to them.`
-      );
-    }
-
-    // function is string => create function
-    else if (typeof fnDef === "string") {
-      return Fn.fromDefinition(
-        this,
-        `${type}Function`,
-        {
-          handler: fnDef,
-          enableLiveDev: false,
-        },
-        {
-          timeout: 900,
-          ...this.props.defaults?.function,
-        }
-      );
-    }
-
-    // function is props => create function
-    return Fn.fromDefinition(
-      this,
-      `${type}Function`,
-      {
-        ...fnDef,
-        enableLiveDev: false,
-      },
-      {
-        timeout: 900,
-        ...this.props.defaults?.function,
-      }
-    );
-  }
-
-  private createCustomResourceFunction(): lambda.Function {
-    const handler = new lambda.Function(this, "ScriptHandler", {
-      code: lambda.Code.fromAsset(path.join(__dirname, "Script")),
-      runtime: lambda.Runtime.NODEJS_16_X,
-      handler: "index.handler",
-      timeout: cdk.Duration.minutes(15),
-      memorySize: 1024,
-    });
-    this.createFunction?.grantInvoke(handler);
-    this.updateFunction?.grantInvoke(handler);
-    this.deleteFunction?.grantInvoke(handler);
-
-    return handler;
-  }
-
-  private createCustomResource(app: App, crFunction: lambda.Function): void {
-    // Note: "BuiltAt" is set to current timestamp to ensure the Custom
-    //       Resource function is run on every update.
-    //
-    //       Do not use the current timestamp in Live mode, b/c we want the
-    //       this custom resource to remain the same in CloudFormation template
-    //       when rebuilding infrastructure. Otherwise, there will always be
-    //       a change when rebuilding infrastructure b/c the "BuildAt" property
-    //       changes on each build.
-    const builtAt = app.local ? app.debugStartedAt : Date.now();
-    new cdk.CustomResource(this, "ScriptResource", {
-      serviceToken: crFunction.functionArn,
-      resourceType: "Custom::SSTScript",
-      properties: {
-        UserCreateFunction: this.createFunction?.functionName,
-        UserUpdateFunction: this.updateFunction?.functionName,
-        UserDeleteFunction: this.deleteFunction?.functionName,
-        UserParams: JSON.stringify(this.props.params || {}),
-        BuiltAt: builtAt,
-      },
-    });
-  }
-
-  private checkDeprecatedFunction(): void {
-    throw new Error(
-      `The "function" property has been replaced by "onCreate" and "onUpdate". More details on upgrading - https://docs.sst.dev/constructs/Script#upgrading-to-v0460`
-    );
-  }
-}

package/src/constructs/Secret.ts

@@ -1,66 +0,0 @@
-import { Construct } from "constructs";
-import { App } from "./App.js";
-import { SSTConstruct } from "./Construct.js";
-import { ENVIRONMENT_PLACEHOLDER, getParameterPath, getParameterFallbackPath, FunctionBindingProps } from "./util/functionBinding.js";
-
-/**
- * The `Secret` construct is a higher level CDK construct that makes it easy to manage app secrets.
- *
- * @example
- * ### Using the minimal config
- *
- * ```js
- * import { Config } from "@serverless-stack/resources";
- *
- * new Config.Secret(stack, "STRIPE_KEY");
- * ```
- */
-export class Secret extends Construct implements SSTConstruct {
-  public readonly id: string;
-  public readonly name: string;
-
-  constructor(scope: Construct, id: string) {
-    super(scope, id);
-    this.id = id;
-    this.name = id;
-  }
-
-  /** @internal */
-  public getConstructMetadata() {
-    return {
-      type: "Secret" as const,
-      data: {
-        name: this.name,
-      },
-    };
-  }
-
-  /** @internal */
-  public getFunctionBinding(): FunctionBindingProps {
-    const app = this.node.root as App;
-    return {
-      clientPackage: "config",
-      variables: {
-        value: {
-          environment: ENVIRONMENT_PLACEHOLDER,
-          // SSM parameters will be created manually via CLI
-          parameter: undefined,
-        },
-      },
-      permissions: {
-        "ssm:GetParameters": [
-          `arn:aws:ssm:${app.region}:${app.account}:parameter${getParameterPath(this, "value")}`,
-          `arn:aws:ssm:${app.region}:${app.account}:parameter${getParameterFallbackPath(this, "value")}`
-        ],
-      },
-    };
-  }
-
-  public static create<T extends string[]>(scope: Construct, ...parameters: T) {
-    const result: Record<string, Secret> = {};
-    for (const name of parameters) {
-      result[name] = new Secret(scope, name);
-    }
-    return result as { [key in T[number]]: Secret };
-  }
-}