sst 3.0.0 → 3.0.1-10

package/runtime/server.js

@@ -1,150 +0,0 @@
-import express from "express";
-import { useBus } from "../bus.js";
-import { Logger } from "../logger.js";
-import { useRuntimeWorkers } from "./workers.js";
-import https from "https";
-import getPort from "get-port";
-import { lazy } from "../util/lazy.js";
-export const useRuntimeServerConfig = lazy(async () => {
-    const port = await getPort({
-        port: 12557,
-    });
-    return {
-        API_VERSION: "2018-06-01",
-        port,
-        url: `http://localhost:${port}`,
-    };
-});
-export const useRuntimeServer = lazy(async () => {
-    const bus = useBus();
-    const app = express();
-    const workers = await useRuntimeWorkers();
-    const cfg = await useRuntimeServerConfig();
-    const workersWaiting = new Map();
-    const invocationsQueued = new Map();
-    function next(workerID) {
-        const queue = invocationsQueued.get(workerID);
-        const value = queue?.shift();
-        if (value)
-            return value;
-        return new Promise((resolve, reject) => {
-            workersWaiting.set(workerID, resolve);
-        });
-    }
-    workers.subscribe("worker.exited", async (evt) => {
-        const waiting = workersWaiting.get(evt.properties.workerID);
-        if (!waiting)
-            return;
-        workersWaiting.delete(evt.properties.workerID);
-    });
-    bus.subscribe("function.invoked", async (evt) => {
-        const worker = workersWaiting.get(evt.properties.workerID);
-        if (worker) {
-            workersWaiting.delete(evt.properties.workerID);
-            worker(evt.properties);
-            return;
-        }
-        let arr = invocationsQueued.get(evt.properties.workerID);
-        if (!arr) {
-            arr = [];
-            invocationsQueued.set(evt.properties.workerID, arr);
-        }
-        arr.push(evt.properties);
-    });
-    app.post(`/:workerID/${cfg.API_VERSION}/runtime/init/error`, express.json({
-        strict: false,
-        type: ["application/json", "application/*+json"],
-        limit: "10mb",
-    }), async (req, res) => {
-        const worker = workers.fromID(req.params.workerID);
-        bus.publish("function.error", {
-            requestID: workers.getCurrentRequestID(worker.workerID),
-            workerID: worker.workerID,
-            functionID: worker.functionID,
-            ...req.body,
-        });
-        res.json("ok");
-    });
-    app.get(`/:workerID/${cfg.API_VERSION}/runtime/invocation/next`, async (req, res) => {
-        Logger.debug("Worker", req.params.workerID, "is waiting for next invocation");
-        const payload = await next(req.params.workerID);
-        Logger.debug("Worker", req.params.workerID, "sending next payload");
-        res.set({
-            "Lambda-Runtime-Aws-Request-Id": payload.context.awsRequestId,
-            "Lambda-Runtime-Deadline-Ms": Date.now() + payload.deadline,
-            "Lambda-Runtime-Invoked-Function-Arn": payload.context.invokedFunctionArn,
-            "Lambda-Runtime-Client-Context": JSON.stringify(payload.context.clientContext || null),
-            "Lambda-Runtime-Cognito-Identity": JSON.stringify(payload.context.identity || null),
-            "Lambda-Runtime-Log-Group-Name": payload.context.logGroupName,
-            "Lambda-Runtime-Log-Stream-Name": payload.context.logStreamName,
-        });
-        res.json(payload.event);
-    });
-    app.post(`/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/response`, express.json({
-        strict: false,
-        type() {
-            return true;
-        },
-        limit: "10mb",
-    }), (req, res) => {
-        Logger.debug("Worker", req.params.workerID, "got response", req.body);
-        const worker = workers.fromID(req.params.workerID);
-        bus.publish("function.success", {
-            workerID: worker.workerID,
-            functionID: worker.functionID,
-            requestID: req.params.awsRequestId,
-            body: req.body,
-        });
-        res.status(202).send();
-    });
-    app.all(`/proxy*`, express.raw({
-        type: "*/*",
-        limit: "1024mb",
-    }), (req, res) => {
-        res.header("Access-Control-Allow-Origin", "*");
-        res.header("Access-Control-Allow-Methods", "GET, PUT, PATCH, POST, DELETE");
-        res.header("Access-Control-Allow-Headers", req.header("access-control-request-headers"));
-        if (req.method === "OPTIONS")
-            return res.send();
-        const u = new URL(req.url.substring(7));
-        const forward = https.request(u, {
-            headers: {
-                ...req.headers,
-                host: u.hostname,
-            },
-            method: req.method,
-        }, (proxied) => {
-            res.status(proxied.statusCode);
-            for (const [key, value] of Object.entries(proxied.headers)) {
-                res.header(key, value);
-            }
-            proxied.pipe(res);
-        });
-        if (req.method !== "GET" &&
-            req.method !== "DELETE" &&
-            req.method !== "HEAD" &&
-            req.body)
-            forward.write(req.body);
-        forward.end();
-        forward.on("error", (e) => {
-            console.log(e.message);
-        });
-    });
-    app.post(`/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/error`, express.json({
-        strict: false,
-        type: ["application/json", "application/*+json"],
-        limit: "10mb",
-    }), (req, res) => {
-        const worker = workers.fromID(req.params.workerID);
-        bus.publish("function.error", {
-            workerID: worker.workerID,
-            functionID: worker.functionID,
-            errorType: req.body.errorType,
-            errorMessage: req.body.errorMessage,
-            requestID: req.params.awsRequestId,
-            trace: req.body.trace,
-        });
-        res.status(202).send();
-    });
-    app.listen(cfg.port);
-});

package/runtime/workers.d.ts

@@ -1,37 +0,0 @@
-declare module "../bus.js" {
-    interface Events {
-        "worker.started": {
-            workerID: string;
-            functionID: string;
-        };
-        "worker.stopped": {
-            workerID: string;
-            functionID: string;
-        };
-        "worker.exited": {
-            workerID: string;
-            functionID: string;
-        };
-        "worker.stdout": {
-            workerID: string;
-            functionID: string;
-            requestID: string;
-            message: string;
-        };
-    }
-}
-interface Worker {
-    workerID: string;
-    functionID: string;
-}
-export declare const useRuntimeWorkers: () => Promise<{
-    fromID(workerID: string): Worker;
-    getCurrentRequestID(workerID: string): string | undefined;
-    stdout(workerID: string, message: string): void;
-    exited(workerID: string): void;
-    subscribe: <Type extends "worker.started" | "worker.stopped" | "worker.exited" | "worker.stdout">(type: Type, cb: (payload: import("../bus.js").EventPayload<Type>) => void) => {
-        type: keyof import("../bus.js").Events;
-        cb: (payload: any) => void;
-    };
-}>;
-export {};

package/runtime/workers.js

@@ -1,85 +0,0 @@
-import { useBus } from "../bus.js";
-import { useFunctionBuilder, useRuntimeHandlers } from "./handlers.js";
-import { useRuntimeServerConfig } from "./server.js";
-import { useFunctions } from "../constructs/Function.js";
-import { lazy } from "../util/lazy.js";
-export const useRuntimeWorkers = lazy(async () => {
-    const workers = new Map();
-    const bus = useBus();
-    const handlers = useRuntimeHandlers();
-    const builder = useFunctionBuilder();
-    const server = await useRuntimeServerConfig();
-    handlers.subscribe("function.build.success", async (evt) => {
-        for (const [_, worker] of workers) {
-            if (worker.functionID === evt.properties.functionID) {
-                const props = useFunctions().fromID(worker.functionID);
-                if (!props)
-                    return;
-                const handler = handlers.for(props.runtime);
-                await handler?.stopWorker(worker.workerID);
-                bus.publish("worker.stopped", worker);
-            }
-        }
-    });
-    const lastRequestId = new Map();
-    bus.subscribe("function.invoked", async (evt) => {
-        bus.publish("function.ack", {
-            functionID: evt.properties.functionID,
-            workerID: evt.properties.workerID,
-        });
-        lastRequestId.set(evt.properties.workerID, evt.properties.requestID);
-        let worker = workers.get(evt.properties.workerID);
-        if (worker)
-            return;
-        const props = useFunctions().fromID(evt.properties.functionID);
-        if (!props)
-            return;
-        const handler = handlers.for(props.runtime);
-        if (!handler)
-            return;
-        const build = await builder.artifact(evt.properties.functionID);
-        if (!build)
-            return;
-        await handler.startWorker({
-            ...build,
-            workerID: evt.properties.workerID,
-            functionID: evt.properties.functionID,
-            environment: evt.properties.env,
-            url: `${server.url}/${evt.properties.workerID}/${server.API_VERSION}`,
-            runtime: props.runtime,
-        });
-        workers.set(evt.properties.workerID, {
-            workerID: evt.properties.workerID,
-            functionID: evt.properties.functionID,
-        });
-        bus.publish("worker.started", {
-            workerID: evt.properties.workerID,
-            functionID: evt.properties.functionID,
-        });
-    });
-    return {
-        fromID(workerID) {
-            return workers.get(workerID);
-        },
-        getCurrentRequestID(workerID) {
-            return lastRequestId.get(workerID);
-        },
-        stdout(workerID, message) {
-            const worker = workers.get(workerID);
-            bus.publish("worker.stdout", {
-                ...worker,
-                message: message.trim(),
-                requestID: lastRequestId.get(workerID),
-            });
-        },
-        exited(workerID) {
-            const existing = workers.get(workerID);
-            if (!existing)
-                return;
-            workers.delete(workerID);
-            lastRequestId.delete(workerID);
-            bus.publish("worker.exited", existing);
-        },
-        subscribe: bus.forward("worker.started", "worker.stopped", "worker.exited", "worker.stdout"),
-    };
-});

package/stacks/app-metadata.d.ts

@@ -1,7 +0,0 @@
-interface Metadata {
-    mode: "deploy" | "dev";
-}
-export declare function saveAppMetadata(data: Metadata): Promise<void>;
-export declare function clearAppMetadata(): Promise<void>;
-export declare const useAppMetadata: () => Promise<Metadata | undefined>;
-export {};

package/stacks/app-metadata.js

@@ -1,75 +0,0 @@
-import { useBootstrap } from "../bootstrap.js";
-import { useAWSCredentials } from "../credentials.js";
-import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, } from "@aws-sdk/client-s3";
-import { Logger } from "../logger.js";
-import { useProject } from "../project.js";
-import { lazy } from "../util/lazy.js";
-async function metadata() {
-    Logger.debug("Fetching app metadata");
-    const [project, credentials, bootstrap] = await Promise.all([
-        useProject(),
-        useAWSCredentials(),
-        useBootstrap(),
-    ]);
-    const s3 = new S3Client({
-        region: project.config.region,
-        credentials,
-    });
-    try {
-        const result = await s3.send(new GetObjectCommand({
-            Key: useS3Key(),
-            Bucket: bootstrap.bucket,
-        }));
-        const body = await result.Body.transformToString();
-        return JSON.parse(body);
-    }
-    catch (ex) {
-        Logger.debug("Fetching app metadata: not found");
-    }
-}
-export async function saveAppMetadata(data) {
-    Logger.debug("Saving app metadata");
-    const [project, credentials, bootstrap] = await Promise.all([
-        useProject(),
-        useAWSCredentials(),
-        useBootstrap(),
-    ]);
-    const s3 = new S3Client({
-        region: project.config.region,
-        credentials,
-    });
-    try {
-        await s3.send(new PutObjectCommand({
-            Key: useS3Key(),
-            Bucket: bootstrap.bucket,
-            Body: JSON.stringify(data),
-        }));
-    }
-    catch (ex) {
-        Logger.debug("Saving app metadata: not found");
-    }
-}
-export async function clearAppMetadata() {
-    Logger.debug("Clearing app metadata");
-    const [project, credentials, bootstrap] = await Promise.all([
-        useProject(),
-        useAWSCredentials(),
-        useBootstrap(),
-    ]);
-    const s3 = new S3Client({
-        region: project.config.region,
-        credentials,
-    });
-    await s3.send(new DeleteObjectCommand({
-        Key: useS3Key(),
-        Bucket: bootstrap.bucket,
-    }));
-}
-function useS3Key() {
-    const project = useProject();
-    return `appMetadata/app.${project.config.name}/stage.${project.config.stage}.json`;
-}
-export const useAppMetadata = lazy(async () => {
-    const data = await metadata();
-    return data;
-});

package/stacks/assembly.d.ts

@@ -1 +0,0 @@
-export declare function loadAssembly(from: string): Promise<import("aws-cdk-lib/cx-api").CloudAssembly>;

package/stacks/assembly.js

@@ -1,4 +0,0 @@
-export async function loadAssembly(from) {
-    const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
-    return new CloudAssembly(from);
-}

package/stacks/build.d.ts

@@ -1,9 +0,0 @@
-import esbuild from "esbuild";
-declare module "../bus.js" {
-    interface Events {
-        "stack.built": {
-            metafile: esbuild.Metafile;
-        };
-    }
-}
-export declare function load(input: string, shallow?: boolean): Promise<readonly [esbuild.Metafile, any]>;

package/stacks/build.js

@@ -1,110 +0,0 @@
-import esbuild from "esbuild";
-import fs from "fs/promises";
-import path from "path";
-import { dynamicImport } from "../util/module.js";
-import { findAbove } from "../util/fs.js";
-import { VisibleError } from "../error.js";
-import babel from "@babel/core";
-const _ = await import("@babel/generator");
-const generate = _.default?.default ?? _.default;
-// @ts-expect-error
-import ts from "@babel/plugin-syntax-typescript";
-export async function load(input, shallow) {
-    const parsed = path.parse(input);
-    const root = await findAbove(input, "package.json");
-    if (!root)
-        throw new VisibleError("Could not find a package.json file");
-    const outfile = path.join(parsed.dir, `.${parsed.name}.${Date.now()}.mjs`);
-    const pkg = JSON.parse(await fs.readFile(path.join(root, "package.json")).then((x) => x.toString()));
-    try {
-        // Logger.debug("running esbuild on", input);
-        const result = await esbuild.build({
-            keepNames: true,
-            bundle: true,
-            platform: "node",
-            target: "esnext",
-            metafile: true,
-            format: "esm",
-            logLevel: "silent",
-            define: {
-                "process.env.IS_SHALLOW": shallow ? "true" : "false",
-            },
-            external: [
-                "aws-cdk-lib",
-                "sst",
-                ...Object.keys({
-                    ...pkg.devDependencies,
-                    ...pkg.dependencies,
-                    ...pkg.peerDependencies,
-                }),
-            ],
-            plugins: [
-                {
-                    name: "shallow",
-                    setup(build) {
-                        if (!shallow)
-                            return;
-                        build.onLoad({ filter: /.*/ }, async (args) => {
-                            if (args.path !== input)
-                                return;
-                            let contents = await fs
-                                .readFile(args.path)
-                                .then((x) => x.toString());
-                            const ast = babel.parse(contents, {
-                                sourceType: "module",
-                                babelrc: false,
-                                configFile: false,
-                                filename: "sst.config.ts",
-                                plugins: [ts],
-                            });
-                            babel.traverse(ast, {
-                                ObjectMethod(path) {
-                                    const { key } = path.node;
-                                    if ("name" in key && key.name === "stacks") {
-                                        path.remove();
-                                    }
-                                },
-                            });
-                            return {
-                                contents: generate(ast).code,
-                                loader: "ts",
-                            };
-                        });
-                    },
-                },
-            ],
-            absWorkingDir: root,
-            outfile,
-            banner: {
-                js: [
-                    `import { createRequire as topLevelCreateRequire } from 'module';`,
-                    `const require = topLevelCreateRequire(import.meta.url);`,
-                ].join(""),
-            },
-            // The entry can have any file name (ie. "stacks/anything.ts"). We want the
-            // build output to be always named "lib/index.js". This allow us to always
-            // import from "buildDir" without needing to pass "anything" around.
-            //  stdin: {
-            //    contents,
-            //    loader: "ts",
-            //    resolveDir: path.dirname(input),
-            //  },
-            entryPoints: [input],
-        });
-        // Logger.debug("built", input);
-        const mod = await dynamicImport(outfile);
-        // Logger.debug("imported", input);
-        await fs.rm(outfile, {
-            force: true,
-        });
-        if (!mod.default?.config)
-            throw new VisibleError(`The config file is improperly formatted.`, `Example:`, `export default {`, `  config() {`, `    return {`, `      name: "my-app",`, `      region: "us-east-1"`, `    }`, `  },`, `  stacks(app) {`, `  }`, `}`);
-        return [result.metafile, mod.default];
-    }
-    catch (e) {
-        await fs.rm(outfile, {
-            force: true,
-        });
-        throw e;
-    }
-}

package/stacks/deploy.d.ts

@@ -1,9 +0,0 @@
-import type { CloudFormationStackArtifact } from "aws-cdk-lib/cx-api";
-import { StackDeploymentResult } from "./monitor.js";
-export declare function publishAssets(stacks: CloudFormationStackArtifact[]): Promise<Record<string, any>>;
-export declare function deployMany(stacks: CloudFormationStackArtifact[]): Promise<Record<string, {
-    status: string;
-    outputs: Record<string, string>;
-    errors: Record<string, string>;
-}>>;
-export declare function deploy(stack: CloudFormationStackArtifact): Promise<StackDeploymentResult>;