sst 1.16.0 → 2.0.0-rc.0

package/dist/constructs/nextjs-site/custom-resource/edge-lambda-version.js

@@ -1,138 +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) => {
-    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;
-            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) {
-    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, version) {
-    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) {
-        // 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) {
-    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);
-    }
-}

package/dist/constructs/nextjs-site/custom-resource/edge-lambda.d.ts

@@ -1 +0,0 @@
-export declare const handler: (event: any) => Promise<void>;

package/dist/constructs/nextjs-site/custom-resource/edge-lambda.js

@@ -1,136 +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 s3 = new AWS.S3({ region: "us-east-1" });
-const lambda = new AWS.Lambda({ region: "us-east-1" });
-export const handler = cfnResponse.safeHandler(async (cfnRequest) => {
-    log("onEventHandler", cfnRequest);
-    // Get bucket name
-    const functionName = cfnRequest.RequestType === "Create"
-        ? generateFunctionName(cfnRequest.ResourceProperties.FunctionNamePrefix)
-        : cfnRequest.PhysicalResourceId.split(":").pop();
-    // Process request
-    let PhysicalResourceId;
-    let Data;
-    const bucket = cfnRequest.ResourceProperties.FunctionBucket;
-    const params = cfnRequest.ResourceProperties.FunctionParams;
-    switch (cfnRequest.RequestType) {
-        case "Create": {
-            await copyAsset(bucket, params);
-            const ret = await createFunction(functionName, params);
-            PhysicalResourceId = ret.FunctionArn;
-            Data = {
-                FunctionArn: ret.FunctionArn,
-            };
-            break;
-        }
-        case "Update": {
-            const oldParams = cfnRequest.OldResourceProperties.FunctionParams;
-            if (isConfigurationChanged(params, oldParams)) {
-                await updateFunctionConfiguration(functionName, params);
-            }
-            if (isCodeChanged(params, oldParams)) {
-                await copyAsset(bucket, params);
-                await updateFunctionCode(functionName, params);
-            }
-            PhysicalResourceId = cfnRequest.PhysicalResourceId;
-            Data = {
-                FunctionArn: cfnRequest.PhysicalResourceId,
-            };
-            break;
-        }
-        case "Delete": {
-            await deleteFunction(functionName);
-            break;
-        }
-        default:
-            throw new Error("Unsupported request type");
-    }
-    // Build response
-    return cfnResponse.submitResponse("SUCCESS", {
-        ...cfnRequest,
-        PhysicalResourceId,
-        Data,
-    });
-});
-function generateFunctionName(prefix) {
-    const MAX_NAME_LENGTH = 64;
-    const length = 20;
-    const characters = "abcdefghijklmnopqrstuvwxyz";
-    const charactersLength = characters.length;
-    let result = `${prefix
-        .toLowerCase()
-        .slice(0, MAX_NAME_LENGTH - length - 1)}-`;
-    for (let i = 0; i < length; i++) {
-        result += characters.charAt(Math.floor(Math.random() * charactersLength));
-    }
-    return result;
-}
-async function copyAsset(bucket, params) {
-    log(`copyAsset() called with params`, bucket, params);
-    // Copy
-    log(`copy`);
-    const resp = await s3
-        .copyObject({
-        Bucket: bucket,
-        CopySource: `/${params.Code.S3Bucket}/${params.Code.S3Key}`,
-        Key: params.Code.S3Key,
-    })
-        .promise();
-    log(`response`, resp);
-    // Update params
-    params.Code.S3Bucket = bucket;
-}
-async function createFunction(functionName, params) {
-    log(`createFunction() called with params`, params);
-    const resp = await lambda
-        .createFunction({
-        ...params,
-        FunctionName: functionName,
-    })
-        .promise();
-    log(`response`, resp);
-    return { FunctionArn: resp.FunctionArn };
-}
-async function updateFunctionConfiguration(functionName, params) {
-    log(`updateFunctionConfiguration() called with params`, params);
-    const resp = await lambda
-        .updateFunctionConfiguration({
-        FunctionName: functionName,
-        ...params,
-        Code: undefined,
-    })
-        .promise();
-    log(`response`, resp);
-}
-async function updateFunctionCode(functionName, params) {
-    log(`updateFunctionCode() called with params`, params);
-    const resp = await lambda
-        .updateFunctionCode({
-        FunctionName: functionName,
-        Publish: false,
-        ...params.Code,
-    })
-        .promise();
-    log(`response`, resp);
-}
-async function deleteFunction(functionName) {
-    log(`deleteFunction() called with functionName`, functionName);
-    const resp = await lambda
-        .deleteFunction({
-        FunctionName: functionName,
-    })
-        .promise();
-    log(`response`, resp);
-}
-function isConfigurationChanged(params, oldParams) {
-    return (Object.keys(params).length !== Object.keys(params).length ||
-        ["Description", "Handler", "Runtime", "MemorySize", "Timeout", "Role"].some((p) => params[p] !== oldParams[p]));
-}
-function isCodeChanged(params, oldParams) {
-    return (params.Code.S3Bucket !== oldParams.Code.S3Bucket ||
-        params.Code.S3Key !== oldParams.Code.S3Key);
-}

package/dist/constructs/nextjs-site/custom-resource/s3-bucket.d.ts

@@ -1 +0,0 @@
-export declare const handler: (event: any) => Promise<void>;

package/dist/constructs/nextjs-site/custom-resource/s3-bucket.js

@@ -1,94 +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 s3 = new AWS.S3({ region: "us-east-1" });
-export const handler = cfnResponse.safeHandler(async (cfnRequest) => {
-    log("onEventHandler", cfnRequest);
-    // Get bucket name
-    const bucketName = cfnRequest.RequestType === "Create"
-        ? generateBucketName(cfnRequest.ResourceProperties.BucketNamePrefix)
-        : cfnRequest.PhysicalResourceId;
-    // Process request
-    let responseData;
-    switch (cfnRequest.RequestType) {
-        case "Create":
-            await createBucket(bucketName);
-            responseData = {
-                BucketName: bucketName,
-            };
-            break;
-        case "Update":
-            break;
-        case "Delete":
-            await emptyBucket(bucketName);
-            await deleteBucket(bucketName);
-            break;
-        default:
-            throw new Error("Unsupported request type");
-    }
-    // Build response
-    return cfnResponse.submitResponse("SUCCESS", {
-        ...cfnRequest,
-        PhysicalResourceId: bucketName,
-        Data: responseData,
-    });
-});
-async function createBucket(bucketName) {
-    log(`createBucket() called with bucketName`, bucketName);
-    const resp = await s3
-        .createBucket({
-        Bucket: bucketName,
-    })
-        .promise();
-    log(`response`, resp);
-}
-async function deleteBucket(bucketName) {
-    log(`deleteBucket() called with bucketName`, bucketName);
-    const resp = await s3
-        .deleteBucket({
-        Bucket: bucketName,
-    })
-        .promise();
-    log(`response`, resp);
-}
-function generateBucketName(prefix) {
-    const MAX_NAME_LENGTH = 63;
-    const length = 20;
-    const characters = "abcdefghijklmnopqrstuvwxyz";
-    const charactersLength = characters.length;
-    let result = `${prefix
-        .toLowerCase()
-        .slice(0, MAX_NAME_LENGTH - length - 1)}-`;
-    for (let i = 0; i < length; i++) {
-        result += characters.charAt(Math.floor(Math.random() * charactersLength));
-    }
-    return result;
-}
-////////////////
-// @aws-cdk/aws-s3/lib/auto-delete-objectshandler
-////////////////
-async function emptyBucket(bucketName) {
-    const listedObjects = await s3
-        .listObjectVersions({ Bucket: bucketName })
-        .promise();
-    const contents = [
-        ...(listedObjects.Versions ?? []),
-        ...(listedObjects.DeleteMarkers ?? []),
-    ];
-    if (contents.length === 0) {
-        return;
-    }
-    const records = contents.map((record) => ({
-        Key: record.Key,
-        VersionId: record.VersionId,
-    }));
-    await s3
-        .deleteObjects({ Bucket: bucketName, Delete: { Objects: records } })
-        .promise();
-    if (listedObjects?.IsTruncated) {
-        await emptyBucket(bucketName);
-    }
-}

package/dist/constructs/nextjs-site/custom-resource/util.d.ts

@@ -1 +0,0 @@
-export declare function log(title: any, ...args: any[]): void;

package/dist/constructs/nextjs-site/custom-resource/util.js

@@ -1,4 +0,0 @@
-/* eslint-disable no-console */
-export function log(title, ...args) {
-    console.log("[provider-framework]", title, ...args.map((x) => typeof x === "object" ? JSON.stringify(x, undefined, 2) : x));
-}

package/dist/logger.d.ts

@@ -1,9 +0,0 @@
-import chalk, { ChalkInstance } from "chalk";
-declare type Colors = {
-    [key in keyof typeof chalk]: typeof chalk[key] extends ChalkInstance ? key : never;
-}[keyof typeof chalk];
-export declare const Logger: {
-    ui<T extends Colors>(color: T, ...lines: string[]): void;
-    debug(...parts: any[]): Promise<void>;
-};
-export {};

package/dist/runtime/handlers.js

@@ -1,72 +0,0 @@
-import { Context } from "@serverless-stack/node/context/context.js";
-import { Logger } from "../logger.js";
-import { useFunctions } from "../stacks/metadata.js";
-import path from "path";
-import fs from "fs/promises";
-import { useWatcher } from "../watcher.js";
-import { useBus } from "../bus.js";
-import { useProject } from "../app.js";
-export const useRuntimeHandlers = Context.memo(() => {
-    const handlers = [];
-    return {
-        register: (handler) => {
-            handlers.push(handler);
-        },
-        for: (runtime) => {
-            return handlers.find((x) => x.canHandle(runtime));
-        },
-    };
-});
-export const useFunctionBuilder = Context.memo(() => {
-    const artifacts = new Map();
-    const handlers = useRuntimeHandlers();
-    const bus = useBus();
-    const project = useProject();
-    const artifactPath = path.join(project.paths.out, "artifacts");
-    const result = {
-        subscribe: bus.forward("function.built"),
-        artifact: (functionID) => {
-            if (artifacts.has(functionID))
-                return artifacts.get(functionID);
-            return result.build(functionID);
-        },
-        build: async (functionID) => {
-            Logger.debug("Building function", functionID);
-            const handler = handlers.for("node");
-            const functions = await useFunctions();
-            const func = functions[functionID];
-            const out = path.join(artifactPath, functionID);
-            await fs.rm(out, { recursive: true });
-            await fs.mkdir(out, { recursive: true });
-            const result = await handler.build({
-                functionID,
-                out,
-                mode: "start",
-                handler: func.data.handler,
-                srcPath: func.data.srcPath,
-            });
-            artifacts.set(functionID, {
-                out,
-                handler: result,
-            });
-            bus.publish("function.built", { functionID });
-            return artifacts.get(functionID);
-        },
-    };
-    const watcher = useWatcher();
-    watcher.subscribe("file.changed", async (evt) => {
-        const functions = await useFunctions();
-        for (const [_, func] of Object.entries(functions)) {
-            const functionID = func.data.localId;
-            const handler = handlers.for("node");
-            if (!handler?.shouldBuild({
-                functionID,
-                file: evt.properties.file,
-            }))
-                continue;
-            await result.build(functionID);
-            Logger.debug("Rebuilt function", functionID);
-        }
-    });
-    return result;
-});

package/dist/runtime/node.js

@@ -1,99 +0,0 @@
-import { Context } from "@serverless-stack/node/context/context.js";
-import path from "path";
-import fs from "fs";
-import { useProject } from "../app.js";
-import esbuild from "esbuild";
-import url from "url";
-import { Worker } from "worker_threads";
-import { useRuntimeHandlers } from "./handlers.js";
-import { useRuntimeWorkers } from "./workers.js";
-export const useNodeHandler = Context.memo(() => {
-    const handlers = useRuntimeHandlers();
-    const workers = useRuntimeWorkers();
-    const cache = {};
-    const project = useProject();
-    const threads = new Map();
-    handlers.register({
-        shouldBuild: (input) => {
-            const result = cache[input.functionID];
-            if (!result)
-                return false;
-            const relative = path.relative(project.paths.root, input.file);
-            return Boolean(result.metafile?.inputs[relative]);
-        },
-        startWorker: async (input) => {
-            new Promise(async () => {
-                const worker = new Worker(url.fileURLToPath(new URL("./support/nodejs-runtime/index.mjs", import.meta.url)), {
-                    env: input.environment,
-                    workerData: input,
-                    stdout: true,
-                    stderr: true,
-                });
-                worker.stdout.on("data", (data) => {
-                    workers.stdout(input.workerID, data.toString());
-                });
-                worker.on("exit", () => workers.exited(input.workerID));
-                threads.set(input.workerID, worker);
-            });
-        },
-        canHandle: () => true,
-        stopWorker: async (workerID) => {
-            const worker = threads.get(workerID);
-            await worker?.terminate();
-        },
-        build: async (input) => {
-            const exists = cache[input.functionID];
-            const dir = path.dirname(input.handler);
-            const ext = path.extname(input.handler);
-            const base = path.basename(input.handler).split(".")[0];
-            const root = project.paths.root;
-            const file = [
-                ".ts",
-                ".tsx",
-                ".mts",
-                ".cts",
-                ".js",
-                ".jsx",
-                ".mjs",
-                ".cjs",
-            ]
-                .map((ext) => path.join(dir, base + ext))
-                .find((file) => {
-                const p = path.join(input.srcPath, file);
-                return fs.existsSync(p);
-            });
-            const target = path.join(input.out, path
-                .relative(root, path.resolve(input.srcPath))
-                .split(path.sep)
-                .filter((x) => x !== "node_modules")
-                .join(path.sep), path.dirname(file), base + ".mjs");
-            const handler = path.relative(input.out, target.replace(".mjs", ext));
-            if (exists?.rebuild) {
-                const result = await exists.rebuild();
-                cache[input.functionID] = result;
-                return handler;
-            }
-            if (!file)
-                throw new Error(`Cannot find a handler file for "${input.handler}"`);
-            const result = await esbuild.build({
-                entryPoints: [path.join(input.srcPath, file)],
-                platform: "node",
-                format: "esm",
-                target: "esnext",
-                mainFields: ["module", "main"],
-                external: ["mjml"],
-                bundle: true,
-                metafile: true,
-                banner: {
-                    js: [
-                        `import { createRequire as topLevelCreateRequire } from 'module';`,
-                        `const require = topLevelCreateRequire(import.meta.url);`,
-                    ].join("\n"),
-                },
-                outfile: target,
-            });
-            cache[input.functionID] = result;
-            return handler;
-        },
-    });
-});