sst 3.0.0 → 3.0.1-2

package/runtime/handlers/pythonBundling.d.ts

@@ -1,82 +0,0 @@
-import { Runtime } from "aws-cdk-lib/aws-lambda";
-import { FunctionProps } from "../../constructs/Function.js";
-import { AssetHashType } from "aws-cdk-lib/core";
-/**
- * Dependency files to exclude from the asset hash.
- */
-export declare const DEPENDENCY_EXCLUDES: string[];
-/**
- * The location in the image that the bundler image caches dependencies.
- */
-export declare const BUNDLER_DEPENDENCIES_CACHE = "/var/dependencies";
-/**
- * Options for bundling
- */
-export interface BundlingOptions {
-    /**
-     * Entry path
-     */
-    readonly entry: string;
-    /**
-     * The runtime of the lambda function
-     */
-    readonly runtime: Runtime;
-    /**
-     * Architecture used by the lambda function
-     */
-    readonly architecture: FunctionProps["architecture"];
-    /**
-     * Output path suffix ('python' for a layer, '.' otherwise)
-     */
-    readonly outputPathSuffix: string;
-    /**
-     * Determines how asset hash is calculated. Assets will get rebuild and
-     * uploaded only if their hash has changed.
-     *
-     * If asset hash is set to `SOURCE` (default), then only changes to the source
-     * directory will cause the asset to rebuild. This means, for example, that in
-     * order to pick up a new dependency version, a change must be made to the
-     * source tree. Ideally, this can be implemented by including a dependency
-     * lockfile in your source tree or using fixed dependencies.
-     *
-     * If the asset hash is set to `OUTPUT`, the hash is calculated after
-     * bundling. This means that any change in the output will cause the asset to
-     * be invalidated and uploaded. Bear in mind that `pip` adds timestamps to
-     * dependencies it installs, which implies that in this mode Python bundles
-     * will _always_ get rebuild and uploaded. Normally this is an anti-pattern
-     * since build
-     *
-     * @default AssetHashType.SOURCE By default, hash is calculated based on the
-     * contents of the source directory. If `assetHash` is also specified, the
-     * default is `CUSTOM`. This means that only updates to the source will cause
-     * the asset to rebuild.
-     */
-    readonly assetHashType?: AssetHashType;
-    /**
-     * Specify a custom hash for this asset. If `assetHashType` is set it must
-     * be set to `AssetHashType.CUSTOM`. For consistency, this custom hash will
-     * be SHA256 hashed and encoded as hex. The resulting hash will be the asset
-     * hash.
-     *
-     * NOTE: the hash is used in order to identify a specific revision of the asset, and
-     * used for optimizing and caching deployment activities related to this asset such as
-     * packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will
-     * need to make sure it is updated every time the asset changes, or otherwise it is
-     * possible that some deployments will not be invalidated.
-     *
-     * @default - based on `assetHashType`
-     */
-    readonly assetHash?: string;
-    readonly installCommands?: string[];
-}
-/**
- * Produce bundled Lambda asset code
- */
-export declare function bundle(options: BundlingOptions & {
-    out: string;
-}): void;
-/**
- * Checks to see if the `entry` directory contains a type of dependency that
- * we know how to install.
- */
-export declare function stageDependencies(entry: string, stagedir: string): boolean;

package/runtime/handlers/pythonBundling.js

@@ -1,80 +0,0 @@
-/**
- * This file is copied from https://github.com/aws/aws-cdk/blob/master/packages/@aws-cdk/aws-lambda-python/lib/bundling.ts
- */
-import fs from "fs";
-import url from "url";
-import path from "path";
-import { DockerImage, FileSystem } from "aws-cdk-lib/core";
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-/**
- * Dependency files to exclude from the asset hash.
- */
-export const DEPENDENCY_EXCLUDES = ["*.pyc"];
-/**
- * The location in the image that the bundler image caches dependencies.
- */
-export const BUNDLER_DEPENDENCIES_CACHE = "/var/dependencies";
-/**
- * Produce bundled Lambda asset code
- */
-export function bundle(options) {
-    const { entry, runtime, architecture, outputPathSuffix, installCommands } = options;
-    const stagedir = FileSystem.mkdtemp("python-bundling-");
-    const hasDeps = stageDependencies(entry, stagedir);
-    const hasInstallCommands = stageInstallCommands(installCommands || [], stagedir);
-    // Determine which dockerfile to use. When dependencies are present, we use a
-    // Dockerfile that can create a cacheable layer. We can't use this Dockerfile
-    // if there aren't dependencies or the Dockerfile will complain about missing
-    // sources.
-    const dockerfile = hasInstallCommands
-        ? "Dockerfile.custom"
-        : hasDeps
-            ? "Dockerfile.dependencies"
-            : "Dockerfile";
-    // copy Dockerfile to workdir
-    fs.copyFileSync(path.join(__dirname, "../../support/python-runtime", dockerfile), path.join(stagedir, dockerfile));
-    const image = DockerImage.fromBuild(stagedir, {
-        buildArgs: {
-            IMAGE: runtime.bundlingImage.image +
-                // the default x86_64 doesn't need to be set explicitly
-                (architecture == "arm_64" ? ":latest-arm64" : ""),
-        },
-        file: dockerfile,
-    });
-    const outputPath = path.join(options.out, outputPathSuffix);
-    // Copy dependencies to the bundle if applicable.
-    if (hasDeps || hasInstallCommands) {
-        image.cp(`${BUNDLER_DEPENDENCIES_CACHE}/.`, outputPath);
-    }
-    // Copy source code to the bundle.
-    fs.cpSync(entry, outputPath, {
-        recursive: true,
-    });
-}
-/**
- * Checks to see if the `entry` directory contains a type of dependency that
- * we know how to install.
- */
-export function stageDependencies(entry, stagedir) {
-    const prefixes = ["Pipfile", "pyproject", "poetry", "requirements.txt"];
-    let found = false;
-    for (const file of fs.readdirSync(entry)) {
-        for (const prefix of prefixes) {
-            if (file.startsWith(prefix)) {
-                fs.copyFileSync(path.join(entry, file), path.join(stagedir, file));
-                found = true;
-            }
-        }
-    }
-    return found;
-}
-function stageInstallCommands(installCommands, stagedir) {
-    let found = false;
-    if (installCommands.length > 0) {
-        const filePath = path.join(stagedir, "sst-deps-install-command.sh");
-        fs.writeFileSync(filePath, installCommands.join(" && "));
-        fs.chmodSync(filePath, "755");
-        found = true;
-    }
-    return found;
-}

package/runtime/handlers/rust.d.ts

@@ -1,2 +0,0 @@
-import { RuntimeHandler } from "../handlers.js";
-export declare const useRustHandler: () => RuntimeHandler;

package/runtime/handlers/rust.js

@@ -1,110 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import { useRuntimeWorkers } from "../workers.js";
-import { exec, spawn } from "child_process";
-import { promisify } from "util";
-import { useRuntimeServerConfig } from "../server.js";
-import { findAbove, isChild } from "../../util/fs.js";
-const execAsync = promisify(exec);
-export const useRustHandler = () => {
-    const processes = new Map();
-    const sources = new Map();
-    const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;
-    return {
-        shouldBuild: (input) => {
-            if (!input.file.endsWith(".rs"))
-                return false;
-            const parent = sources.get(input.functionID);
-            if (!parent)
-                return false;
-            const result = isChild(parent, input.file);
-            return result;
-        },
-        canHandle: (input) => input.startsWith("rust"),
-        startWorker: async (input) => {
-            const workers = await useRuntimeWorkers();
-            const server = await useRuntimeServerConfig();
-            const proc = spawn(path.join(input.out, handlerName), {
-                env: {
-                    ...process.env,
-                    ...input.environment,
-                    IS_LOCAL: "true",
-                    RUST_BACKTRACE: "1",
-                    AWS_LAMBDA_RUNTIME_API: `http://localhost:${server.port}/${input.workerID}`,
-                    AWS_LAMBDA_FUNCTION_MEMORY_SIZE: "1024",
-                },
-                cwd: input.out,
-            });
-            proc.on("exit", () => workers.exited(input.workerID));
-            proc.stdout.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            proc.stderr.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            processes.set(input.workerID, proc);
-        },
-        stopWorker: async (workerID) => {
-            const proc = processes.get(workerID);
-            if (proc) {
-                proc.kill();
-                processes.delete(workerID);
-            }
-        },
-        build: async (input) => {
-            const parsed = path.parse(input.props.handler);
-            const project = await findAbove(parsed.dir, "Cargo.toml");
-            if (!project)
-                return {
-                    type: "error",
-                    errors: ["Could not find a Cargo.toml file"],
-                };
-            sources.set(input.functionID, project);
-            if (input.mode === "start") {
-                try {
-                    await execAsync(["cargo", "build", `--bin ${parsed.name}`].join(" "), {
-                        cwd: project,
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                    await fs.cp(path.join(project, `target/debug`, parsed.name), path.join(input.out, "handler"));
-                }
-                catch (ex) {
-                    return {
-                        type: "error",
-                        errors: [String(ex)],
-                    };
-                }
-            }
-            if (input.mode === "deploy") {
-                try {
-                    await execAsync([
-                        "cargo",
-                        "lambda",
-                        "build",
-                        "--release",
-                        ...(input.props.architecture === "arm_64" ? ["--arm64"] : []),
-                        `--bin ${parsed.name}`,
-                    ].join(" "), {
-                        cwd: project,
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                    await fs.cp(path.join(project, `target/lambda/`, parsed.name, "bootstrap"), path.join(input.out, "bootstrap"));
-                }
-                catch (ex) {
-                    return {
-                        type: "error",
-                        errors: [String(ex)],
-                    };
-                }
-            }
-            return {
-                type: "success",
-                handler: "handler",
-            };
-        },
-    };
-};

package/runtime/handlers.d.ts

@@ -1,74 +0,0 @@
-import { FunctionProps } from "../constructs/Function.js";
-declare module "../bus.js" {
-    interface Events {
-        "function.build.started": {
-            functionID: string;
-        };
-        "function.build.success": {
-            functionID: string;
-        };
-        "function.build.failed": {
-            functionID: string;
-            errors: string[];
-        };
-    }
-}
-interface BuildInput {
-    functionID: string;
-    mode: "deploy" | "start";
-    out: string;
-    props: FunctionProps;
-}
-export interface StartWorkerInput {
-    url: string;
-    workerID: string;
-    functionID: string;
-    environment: Record<string, string>;
-    out: string;
-    handler: string;
-    runtime: string;
-}
-interface ShouldBuildInput {
-    file: string;
-    functionID: string;
-}
-export interface RuntimeHandler {
-    startWorker: (worker: StartWorkerInput) => Promise<void>;
-    stopWorker: (workerID: string) => Promise<void>;
-    shouldBuild: (input: ShouldBuildInput) => boolean;
-    canHandle: (runtime: string) => boolean;
-    build: (input: BuildInput) => Promise<{
-        type: "success";
-        handler: string;
-        sourcemap?: string;
-    } | {
-        type: "error";
-        errors: string[];
-    }>;
-}
-export declare const useRuntimeHandlers: () => {
-    subscribe: <Type extends "function.build.success" | "function.build.failed">(type: Type, cb: (payload: import("../bus.js").EventPayload<Type>) => void) => {
-        type: keyof import("../bus.js").Events;
-        cb: (payload: any) => void;
-    };
-    register: (handler: RuntimeHandler) => void;
-    for: (runtime: string) => RuntimeHandler;
-    build(functionID: string, mode: BuildInput["mode"]): Promise<{
-        type: "error";
-        errors: string[];
-    } | {
-        out: string;
-        sourcemap: string | undefined;
-        type: "success";
-        handler: string;
-    }>;
-};
-interface Artifact {
-    out: string;
-    handler: string;
-}
-export declare const useFunctionBuilder: () => {
-    artifact: (functionID: string) => Artifact | Promise<Artifact | undefined>;
-    build: (functionID: string) => Promise<Artifact | undefined>;
-};
-export {};

package/runtime/handlers.js

@@ -1,151 +0,0 @@
-import { Logger } from "../logger.js";
-import path from "path";
-import fs from "fs/promises";
-import { useWatcher } from "../watcher.js";
-import { useBus } from "../bus.js";
-import { useProject } from "../project.js";
-import { useFunctions } from "../constructs/Function.js";
-import { useNodeHandler } from "./handlers/node.js";
-import { useContainerHandler } from "./handlers/container.js";
-import { useDotnetHandler } from "./handlers/dotnet.js";
-import { useGoHandler } from "./handlers/go.js";
-import { useJavaHandler } from "./handlers/java.js";
-import { usePythonHandler } from "./handlers/python.js";
-import { useRustHandler } from "./handlers/rust.js";
-import { lazy } from "../util/lazy.js";
-export const useRuntimeHandlers = lazy(() => {
-    const handlers = [
-        useNodeHandler(),
-        useGoHandler(),
-        useContainerHandler(),
-        usePythonHandler(),
-        useJavaHandler(),
-        useDotnetHandler(),
-        useRustHandler(),
-    ];
-    const project = useProject();
-    const bus = useBus();
-    const pendingBuilds = new Map();
-    const result = {
-        subscribe: bus.forward("function.build.success", "function.build.failed"),
-        register: (handler) => {
-            handlers.push(handler);
-        },
-        for: (runtime) => {
-            const result = handlers.find((x) => x.canHandle(runtime));
-            if (!result)
-                throw new Error(`${runtime} runtime is unsupported`);
-            return result;
-        },
-        async build(functionID, mode) {
-            async function task() {
-                const func = useFunctions().fromID(functionID);
-                if (!func)
-                    return {
-                        type: "error",
-                        errors: [`Function with ID "${functionID}" not found`],
-                    };
-                const handler = result.for(func.runtime);
-                const out = path.join(project.paths.artifacts, functionID);
-                await fs.rm(out, { recursive: true, force: true });
-                await fs.mkdir(out, { recursive: true });
-                bus.publish("function.build.started", { functionID });
-                if (func.hooks?.beforeBuild)
-                    await func.hooks.beforeBuild(func, out);
-                const built = await handler.build({
-                    functionID,
-                    out,
-                    mode,
-                    props: func,
-                });
-                if (built.type === "error") {
-                    bus.publish("function.build.failed", {
-                        functionID,
-                        errors: built.errors,
-                    });
-                    return built;
-                }
-                if (func.copyFiles) {
-                    await Promise.all(func.copyFiles.map(async (entry) => {
-                        const fromPath = path.join(project.paths.root, 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(out, to);
-                        if (mode === "deploy")
-                            await fs.cp(fromPath, toPath, {
-                                recursive: true,
-                            });
-                        if (mode === "start") {
-                            try {
-                                const dir = path.dirname(toPath);
-                                await fs.mkdir(dir, { recursive: true });
-                                await fs.symlink(fromPath, toPath);
-                            }
-                            catch (ex) {
-                                Logger.debug("Failed to symlink", fromPath, toPath, ex);
-                            }
-                        }
-                    }));
-                }
-                if (func.hooks?.afterBuild)
-                    await func.hooks.afterBuild(func, out);
-                bus.publish("function.build.success", { functionID });
-                return {
-                    ...built,
-                    out,
-                    sourcemap: built.sourcemap,
-                };
-            }
-            if (pendingBuilds.has(functionID)) {
-                Logger.debug("Waiting on pending build", functionID);
-                return pendingBuilds.get(functionID);
-            }
-            const promise = task();
-            pendingBuilds.set(functionID, promise);
-            Logger.debug("Building function", functionID);
-            const r = await promise;
-            pendingBuilds.delete(functionID);
-            return r;
-        },
-    };
-    return result;
-});
-export const useFunctionBuilder = lazy(() => {
-    const artifacts = new Map();
-    const handlers = useRuntimeHandlers();
-    const result = {
-        artifact: (functionID) => {
-            if (artifacts.has(functionID))
-                return artifacts.get(functionID);
-            return result.build(functionID);
-        },
-        build: async (functionID) => {
-            const result = await handlers.build(functionID, "start");
-            if (!result)
-                return;
-            if (result.type === "error")
-                return;
-            artifacts.set(functionID, result);
-            return artifacts.get(functionID);
-        },
-    };
-    const watcher = useWatcher();
-    watcher.subscribe("file.changed", async (evt) => {
-        try {
-            const functions = useFunctions();
-            for (const [functionID, info] of Object.entries(functions.all)) {
-                const handler = handlers.for(info.runtime);
-                if (!handler?.shouldBuild({
-                    functionID,
-                    file: evt.properties.file,
-                }))
-                    continue;
-                await result.build(functionID);
-                Logger.debug("Rebuilt function", functionID);
-            }
-        }
-        catch { }
-    });
-    return result;
-});

package/runtime/iot.d.ts

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

package/runtime/iot.js

@@ -1,17 +0,0 @@
-import { useBus } from "../bus.js";
-import { useIOT } from "../iot.js";
-import { lazy } from "../util/lazy.js";
-export const useIOTBridge = lazy(async () => {
-    const bus = useBus();
-    const iot = await useIOT();
-    const topic = `${iot.prefix}/events`;
-    bus.subscribe("function.success", async (evt) => {
-        iot.publish(topic + "/" + evt.properties.workerID, "function.success", evt.properties);
-    });
-    bus.subscribe("function.error", async (evt) => {
-        iot.publish(topic + "/" + evt.properties.workerID, "function.error", evt.properties);
-    });
-    bus.subscribe("function.ack", async (evt) => {
-        iot.publish(topic + "/" + evt.properties.workerID, "function.ack", evt.properties);
-    });
-});

package/runtime/runtime.d.ts

@@ -1,32 +0,0 @@
-import "../bus.js";
-declare module "../bus.js" {
-    interface Events {
-        "function.ack": {
-            workerID: string;
-            functionID: string;
-        };
-        "function.invoked": {
-            workerID: string;
-            functionID: string;
-            requestID: string;
-            env: Record<string, any>;
-            event: any;
-            context: any;
-            deadline: number;
-        };
-        "function.success": {
-            workerID: string;
-            functionID: string;
-            requestID: string;
-            body: any;
-        };
-        "function.error": {
-            workerID: string;
-            functionID: string;
-            errorType: string;
-            errorMessage: string;
-            requestID: string;
-            trace: string[];
-        };
-    }
-}

package/runtime/runtime.js

@@ -1 +0,0 @@
-import "../bus.js";

package/runtime/server.d.ts

@@ -1,6 +0,0 @@
-export declare const useRuntimeServerConfig: () => Promise<{
-    API_VERSION: string;
-    port: number;
-    url: string;
-}>;
-export declare const useRuntimeServer: () => Promise<void>;