sst 1.16.0 → 2.0.0-rc.0

package/{dist/constructs → constructs}/Function.js

@@ -1,13 +1,11 @@
 /* eslint-disable @typescript-eslint/ban-types */
 // Note: disabling ban-type rule so we don't get an error referencing the class Function
 import path from "path";
-import fs from "fs-extra";
 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";
 import * as logs from "aws-cdk-lib/aws-logs";
 import * as ssm from "aws-cdk-lib/aws-ssm";
-import { Runtime, } from "@serverless-stack/core";
 import { Stack } from "./Stack.js";
 import { Job } from "./Job.js";
 import { Secret } from "./Config.js";
@@ -21,6 +19,8 @@ import url from "url";
 import { useDeferredTasks } from "./deferred_task.js";
 import { useWarning } from "./util/warning.js";
 import { useProject } from "../app.js";
+import { useRuntimeHandlers } from "../runtime/handlers.js";
+import { createAppContext } from "./context.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const supportedRuntimes = {
     nodejs: lambda.Runtime.NODEJS,
@@ -31,6 +31,7 @@ const supportedRuntimes = {
     "nodejs12.x": lambda.Runtime.NODEJS_12_X,
     "nodejs14.x": lambda.Runtime.NODEJS_14_X,
     "nodejs16.x": lambda.Runtime.NODEJS_16_X,
+    "nodejs18.x": lambda.Runtime.NODEJS_18_X,
     "python2.7": lambda.Runtime.PYTHON_2_7,
     "python3.6": lambda.Runtime.PYTHON_3_6,
     "python3.7": lambda.Runtime.PYTHON_3_7,
@@ -59,6 +60,12 @@ const supportedRuntimes = {
  * ```
  */
 export class Function extends lambda.Function {
+    id;
+    _isLiveDevEnabled;
+    /** @internal */
+    _disableBind;
+    functionUrl;
+    props;
     constructor(scope, id, props) {
         const app = scope.node.root;
         const stack = Stack.of(scope);
@@ -77,7 +84,6 @@ export class Function extends lambda.Function {
                 : props.functionName({ stack, functionProps: props }));
         const handler = props.handler;
         const timeout = Function.normalizeTimeout(props.timeout);
-        const srcPath = Function.normalizeSrcPath(props.srcPath || ".");
         const runtime = Function.normalizeRuntime(props.runtime);
         const architecture = (() => {
             if (props.architecture === "arm_64")
@@ -91,7 +97,6 @@ export class Function extends lambda.Function {
         const tracing = lambda.Tracing[(props.tracing || "active").toUpperCase()];
         const logRetention = props.logRetention &&
             logs.RetentionDays[props.logRetention.toUpperCase()];
-        let bundle = props.bundle;
         const isLiveDevEnabled = props.enableLiveDev === false ? false : true;
         // Validate handler
         if (!handler) {
@@ -101,30 +106,13 @@ export class Function extends lambda.Function {
         const isNodeRuntime = runtime.startsWith("nodejs");
         const isPythonRuntime = runtime.startsWith("python");
         const isJavaRuntime = runtime.startsWith("java");
-        if (isNodeRuntime) {
-            bundle = bundle === undefined ? true : props.bundle;
-            if (!bundle && srcPath === ".") {
-                throw new Error(`Bundle cannot be disabled for the "${id}" function since the "srcPath" is set to the project root. Read more here — https://github.com/serverless-stack/sst/issues/78`);
-            }
-        }
-        else if (isPythonRuntime) {
-            bundle = bundle === undefined ? {} : props.bundle;
-            if (srcPath === ".") {
-                throw new Error(`Cannot set the "srcPath" to the project root for the "${id}" function.`);
-            }
-        }
-        const localId = path.posix
-            .join(scope.node.path, id)
-            .replace(/\$/g, "-")
-            .replace(/\//g, "-")
-            .replace(/\./g, "-");
         // Handle local development (ie. sst start)
         // - set runtime to nodejs12.x for non-Node runtimes (b/c the stub is in Node)
         // - set retry to 0. When the debugger is disconnected, the Cron construct
         //   will still try to periodically invoke the Lambda, and the requests would
         //   fail and retry. So when launching `sst start`, a couple of retry requests
         //   from recent failed request will be received. And this behavior is confusing.
-        if (isLiveDevEnabled && app.mode === "start") {
+        if (isLiveDevEnabled && app.mode === "dev") {
             // If debugIncreaseTimeout is enabled:
             //   set timeout to 900s. This will give people more time to debug the function
             //   without timing out the request. Note API Gateway requests have a maximum
@@ -147,17 +135,13 @@ export class Function extends lambda.Function {
                 ephemeralStorageSize: diskSize,
                 timeout,
                 tracing,
-                environment: {
-                    ...(props.environment || {}),
-                    SST_DEBUG_SRC_PATH: srcPath,
-                    SST_DEBUG_SRC_HANDLER: handler,
-                    SST_FUNCTION_ID: localId,
-                },
+                environment: props.environment,
                 layers: [],
                 logRetention,
                 retryAttempts: 0,
                 ...(debugOverrideProps || {}),
             });
+            this.addEnvironment("SST_FUNCTION_ID", this.node.addr);
             this.attachPermissions([
                 new iam.PolicyStatement({
                     actions: ["iot:*"],
@@ -205,41 +189,30 @@ export class Function extends lambda.Function {
             });
             useDeferredTasks().add(async () => {
                 // Build function
-                const bundled = await Runtime.Handler.bundle({
-                    id: localId,
-                    root: app.appPath,
-                    handler,
-                    runtime,
-                    srcPath,
-                    bundle: props.bundle,
-                });
-                // Python builder returns AssetCode instead of directory
-                const code = (() => {
-                    if ("directory" in bundled) {
-                        Function.copyFiles(bundle, srcPath, bundled.directory);
-                        return lambda.AssetCode.fromAsset(bundled.directory);
-                    }
-                    return bundled.asset;
-                })();
+                const result = await useRuntimeHandlers().build(this.node.addr, "deploy");
+                if (result.type === "error")
+                    throw new Error(`Failed to build function "${props.handler}"`);
+                const code = lambda.AssetCode.fromAsset(result.out);
                 // Update function's code
                 const codeConfig = code.bind(this);
                 const cfnFunction = this.node.defaultChild;
                 cfnFunction.runtime = supportedRuntimes[runtime].toString();
-                if (isJavaRuntime && bundle) {
-                    const providedRuntime = bundle
-                        .experimentalUseProvidedRuntime;
-                    if (providedRuntime) {
-                        cfnFunction.runtime = providedRuntime;
-                    }
+                /*
+                if (isJavaRuntime) {
+                  const providedRuntime = (bundle as FunctionBundleJavaProps)
+                    .experimentalUseProvidedRuntime;
+                  if (providedRuntime) {
+                    cfnFunction.runtime = providedRuntime;
+                  }
                 }
+                */
                 cfnFunction.code = {
                     s3Bucket: codeConfig.s3Location?.bucketName,
                     s3Key: codeConfig.s3Location?.objectKey,
                     s3ObjectVersion: codeConfig.s3Location?.objectVersion,
                 };
-                cfnFunction.handler = bundled.handler;
-                // TODO: Uncommnet this
-                // code.bindToResource(cfnFunction);
+                cfnFunction.handler = result.handler;
+                code.bindToResource(cfnFunction);
             });
         }
         this.id = id;
@@ -262,14 +235,8 @@ export class Function extends lambda.Function {
         this.addConfig(props.config || []);
         this.bind(props.bind || []);
         this.createUrl();
-        app.registerLambdaHandler({
-            bundle: props.bundle,
-            handler,
-            runtime,
-            srcPath,
-        });
         this._isLiveDevEnabled = isLiveDevEnabled;
-        this.localId = localId;
+        useFunctions().add(this.node.addr, props);
     }
     /**
      * The AWS generated URL of the Function.
@@ -286,7 +253,6 @@ export class Function extends lambda.Function {
      * ```
      */
     bind(constructs) {
-        const app = this.node.root;
         constructs.forEach((c) => {
             // Bind environment
             const env = bindEnvironment(c);
@@ -353,10 +319,8 @@ export class Function extends lambda.Function {
         return {
             type: "Function",
             data: {
-                localId: this.localId,
-                srcPath: this.props.srcPath,
-                handler: this.props.handler,
                 arn: this.functionArn,
+                localId: this.node.addr,
                 secrets: [...(config || []), ...(bind || [])]
                     .filter((c) => c instanceof Secret)
                     .map((c) => c.name),
@@ -428,7 +392,7 @@ export class Function extends lambda.Function {
         return cdk.Duration.seconds(timeout || 10);
     }
     static normalizeRuntime(runtime) {
-        runtime = runtime || "nodejs14.x";
+        runtime = runtime || "nodejs18.x";
         if (!supportedRuntimes[runtime]) {
             throw new Error(`The specified runtime is not supported for sst.Function. Only NodeJS, Python, Go, and .NET runtimes are currently supported.`);
         }
@@ -437,24 +401,6 @@ export class Function extends lambda.Function {
     static normalizeSrcPath(srcPath) {
         return srcPath.replace(/\/+$/, "");
     }
-    static copyFiles(bundle, srcPath, buildPath) {
-        if (!bundle)
-            return;
-        if (typeof bundle === "boolean")
-            return;
-        if (!bundle.copyFiles)
-            return;
-        bundle.copyFiles.forEach((entry) => {
-            const fromPath = path.join(srcPath, entry.from);
-            if (!fs.existsSync(fromPath))
-                throw new Error(`Tried to copy nonexistent file from "${path.resolve(fromPath)}" - check copyFiles entry "${entry.from}"`);
-            const to = entry.to || entry.from;
-            if (path.isAbsolute(to))
-                throw new Error(`Copy destination path "${to}" must be relative`);
-            const toPath = path.join(buildPath, to);
-            fs.copySync(fromPath, toPath);
-        });
-    }
     static handleImportedLayer(scope, layer) {
         const layerStack = Stack.of(layer);
         const currentStack = Stack.of(scope);
@@ -558,3 +504,17 @@ export class Function extends lambda.Function {
         };
     }
 }
+export const useFunctions = createAppContext(() => {
+    const functions = {};
+    return {
+        fromID(id) {
+            return functions[id];
+        },
+        add(name, props) {
+            functions[name] = props;
+        },
+        get all() {
+            return functions;
+        },
+    };
+});

package/{dist/constructs → constructs}/FunctionalStack.js

@@ -6,6 +6,11 @@ export function stack(app, fn, props) {
     const exists = getExports(app).has(fn);
     if (exists)
         throw new Error(`StackDuplicates: Attempting to initialize stack ${id} several times`);
+    class EmptyStack extends Stack {
+        constructor(scope, id, props) {
+            super(scope, id, props);
+        }
+    }
     const stack = new EmptyStack(app, id, props);
     getStacks(app).set(fn, stack);
     const ctx = {
@@ -55,8 +60,3 @@ export function getStack(stack) {
         throw new Error(`StackWrongOrder: Initialize "${stack.name}" stack before "${currentStack?.name}" stack`);
     return stacks.get(stack);
 }
-class EmptyStack extends Stack {
-    constructor(scope, id, props) {
-        super(scope, id, props);
-    }
-}

package/{dist/constructs → constructs}/GraphQLApi.d.ts

@@ -75,7 +75,17 @@ export declare class GraphQLApi extends Api {
                 output: string | undefined;
                 commands: string[] | undefined;
             } | {
-                type: "url" | "alb" | "lambda_function";
+                type: "graphql";
+                route: string;
+                fn: {
+                    node: string;
+                    stack: string;
+                } | undefined;
+                schema: string | undefined;
+                output: string | undefined;
+                commands: string[] | undefined;
+            } | {
+                type: "lambda_function" | "url" | "alb";
                 route: string;
                 fn?: undefined;
                 schema?: undefined;

package/{dist/constructs → constructs}/GraphQLApi.js

@@ -15,6 +15,9 @@ import { Api } from "./Api.js";
  * ```
  */
 export class GraphQLApi extends Api {
+    codegen;
+    lambdaIntegration;
+    rootPath;
     constructor(scope, id, props) {
         if ("routes" in props || !props.server) {
             throw new Error(`Please use the "server" option instead of the "routes" to configure the handler for the "${id}" GraphQLApi`);

package/{dist/constructs → constructs}/Job.d.ts

@@ -19,20 +19,6 @@ export interface JobProps {
      *```
      */
     handler: string;
-    /**
-     * Root directory of the project, typically where package.json is located. Set if using a monorepo with multiple subpackages
-     *
-     * @default Defaults to the same directory as sst.json
-     *
-     * @example
-     * ```js
-     * new Job(stack, "MyJob", {
-     *   srcPath: "services",
-     *   handler: "job.handler",
-     * })
-     *```
-     */
-    srcPath?: string;
     /**
      * The amount of memory in MB allocated.
      *

package/{dist/constructs → constructs}/Job.js

@@ -1,12 +1,11 @@
 // import path from "path";
 import url from "url";
 import path from "path";
-import fs from "fs-extra";
+import fs from "fs/promises";
 import { Construct } from "constructs";
 import * as iam from "aws-cdk-lib/aws-iam";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import * as codebuild from "aws-cdk-lib/aws-codebuild";
-import { Runtime } from "@serverless-stack/core";
 import { Function } from "./Function.js";
 import { toCdkDuration } from "./util/duration.js";
 import { attachPermissionsToRole } from "./util/permission.js";
@@ -14,6 +13,7 @@ import { bindEnvironment, bindPermissions } from "./util/functionBinding.js";
 import { useDeferredTasks } from "./deferred_task.js";
 import { useWarning } from "./util/warning.js";
 import { useProject } from "../app.js";
+import { useRuntimeHandlers } from "../runtime/handlers.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 /////////////////////
 // Construct
@@ -33,6 +33,12 @@ const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
  * ```
  */
 export class Job extends Construct {
+    id;
+    localId;
+    props;
+    job;
+    isLiveDevEnabled;
+    _jobInvoker;
     constructor(scope, id, props) {
         super(scope, props.cdk?.id || id);
         const app = this.node.root;
@@ -175,54 +181,54 @@ export class Job extends Construct {
         });
     }
     buildCodeBuildProjectCode() {
-        const { handler, srcPath: srcPathRaw } = this.props;
-        const srcPath = Function.normalizeSrcPath(srcPathRaw || ".");
-        const bundle = { format: "esm" };
         const app = this.node.root;
         // Handle remove (ie. sst remove)
-        if (app.skipBuild) {
+        if (app.mode !== "deploy") {
             // do nothing
         }
         // Handle build
         else {
             useDeferredTasks().add(async () => {
                 // Build function
+                /*
                 const bundled = await Runtime.Handler.bundle({
-                    id: this.localId,
-                    root: app.appPath,
-                    handler,
-                    runtime: "nodejs16.x",
-                    srcPath,
-                    bundle,
-                });
+                  id: this.localId,
+                  root: app.appPath,
+                  handler,
+                  runtime: "nodejs16.x",
+                  srcPath,
+                  bundle
+                })!;
+                */
+                // TODO: Fix
+                const bundle = await useRuntimeHandlers().build(this.node.addr, "deploy");
+                // handle copy files
+                // create wrapper that calls the handler
+                if (bundle.type === "error")
+                    throw new Error(`Failed to build job "${this.props.handler}"`);
+                const parsed = path.parse(bundle.handler);
+                await fs.writeFile(path.join(bundle.out, "handler-wrapper.js"), [
+                    `console.log("")`,
+                    `console.log("//////////////////////")`,
+                    `console.log("// Start of the job //")`,
+                    `console.log("//////////////////////")`,
+                    `console.log("")`,
+                    `import { ${parsed.ext.substring(1)} } from "./${path.join(parsed.dir, parsed.name)}.mjs";`,
+                    `const event = JSON.parse(process.env.SST_PAYLOAD);`,
+                    `const result = await ${parsed.name}(event);`,
+                    `console.log("")`,
+                    `console.log("----------------------")`,
+                    `console.log("")`,
+                    `console.log("Result:", result);`,
+                    `console.log("")`,
+                    `console.log("//////////////////////")`,
+                    `console.log("//  End of the job  //")`,
+                    `console.log("//////////////////////")`,
+                    `console.log("")`,
+                ].join("\n"));
+                const code = lambda.AssetCode.fromAsset(bundle.out);
+                this.updateCodeBuildProjectCode(code, "handler-wrapper.js");
                 // This should always be true b/c runtime is always Node.js
-                if ("directory" in bundled) {
-                    // handle copy files
-                    Function.copyFiles(bundle, srcPath, bundled.directory);
-                    // create wrapper that calls the handler
-                    const [file, module] = bundled.handler.split(".");
-                    await fs.writeFile(path.join(bundled.directory, "handler-wrapper.js"), [
-                        `console.log("")`,
-                        `console.log("//////////////////////")`,
-                        `console.log("// Start of the job //")`,
-                        `console.log("//////////////////////")`,
-                        `console.log("")`,
-                        `import { ${module} } from "./${file}.js";`,
-                        `const event = JSON.parse(process.env.SST_PAYLOAD);`,
-                        `const result = await ${module}(event);`,
-                        `console.log("")`,
-                        `console.log("----------------------")`,
-                        `console.log("")`,
-                        `console.log("Result:", result);`,
-                        `console.log("")`,
-                        `console.log("//////////////////////")`,
-                        `console.log("//  End of the job  //")`,
-                        `console.log("//////////////////////")`,
-                        `console.log("")`,
-                    ].join("\n"));
-                    const code = lambda.AssetCode.fromAsset(bundled.directory);
-                    this.updateCodeBuildProjectCode(code, "handler-wrapper.js");
-                }
             });
         }
     }
@@ -252,14 +258,13 @@ export class Job extends Construct {
         ]);
     }
     createLocalInvoker() {
-        const { srcPath, handler, config, environment, permissions } = this.props;
+        const { handler, config, environment, permissions } = this.props;
         // Note: make the invoker function the same ID as the Job
         //       construct so users can identify the invoker function
         //       in the Console.
         const fn = new Function(this, this.node.id, {
-            srcPath,
             handler,
-            bundle: { format: "esm" },
+            nodejs: { format: "esm" },
             runtime: "nodejs16.x",
             timeout: 10,
             memorySize: 1024,
@@ -274,8 +279,7 @@ export class Job extends Construct {
     }
     createCodeBuildInvoker() {
         return new Function(this, this.node.id, {
-            srcPath: path.resolve(path.join(__dirname, "../dist/support/job-invoker")),
-            handler: "index.main",
+            handler: path.join(__dirname, "../dist/support/job-invoke/index.main"),
             runtime: "nodejs16.x",
             timeout: 10,
             memorySize: 1024,
@@ -289,7 +293,7 @@ export class Job extends Construct {
                     resources: [this.job.projectArn],
                 }),
             ],
-            bundle: {
+            nodejs: {
                 format: "esm",
             },
         });

package/{dist/constructs → constructs}/KinesisStream.js

@@ -23,11 +23,14 @@ import { Function as Fn, } from "./Function.js";
  * ```
  */
 export class KinesisStream extends Construct {
+    id;
+    cdk;
+    functions = {};
+    bindingForAllConsumers = [];
+    permissionsAttachedForAllConsumers = [];
+    props;
     constructor(scope, id, props) {
         super(scope, props?.cdk?.id || id);
-        this.functions = {};
-        this.bindingForAllConsumers = [];
-        this.permissionsAttachedForAllConsumers = [];
         this.id = id;
         this.props = props || {};
         this.cdk = {};

package/{dist/constructs → constructs}/Metadata.d.ts

@@ -1,4 +1,4 @@
-import { SSTConstruct } from "./Construct";
+import { SSTConstruct } from "./Construct.js";
 declare type ExtractMetadata<T extends SSTConstruct> = ReturnType<T["getConstructMetadata"]> & {
     id: string;
     addr: string;

package/constructs/NextjsSite.d.ts

@@ -0,0 +1,33 @@
+import { Construct } from "constructs";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
+import { SsrSite, SsrSiteProps } from "./SsrSite.js";
+export interface NextjsSiteProps extends Omit<SsrSiteProps, "edge"> {
+}
+/**
+ * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
+ * @example
+ * Deploys a Next.js app in the `my-next-app` directory.
+ *
+ * ```js
+ * new NextjsSite(stack, "web", {
+ *   path: "my-next-app/",
+ * });
+ * ```
+ */
+export declare class NextjsSite extends SsrSite {
+    constructor(scope: Construct, id: string, props: NextjsSiteProps);
+    protected initBuildConfig(): {
+        serverBuildOutputFile: string;
+        clientBuildOutputDir: string;
+        clientBuildVersionedSubDir: string;
+        siteStub: string;
+    };
+    protected createFunctionForRegional(): lambda.Function;
+    protected createCloudFrontDistributionForRegional(): cloudfront.Distribution;
+    protected createCloudFrontDistributionForStub(): cloudfront.Distribution;
+    protected createCloudFrontServerCachePolicy(): cloudfront.CachePolicy;
+    protected generateBuildId(): string;
+    private createImageOptimizationFunctionForRegional;
+    private createMiddlewareEdgeFunctionForRegional;
+}