sst 1.16.0 → 2.0.0-rc.0

package/src/context/handler.ts

@@ -1,53 +0,0 @@
-import {
-  APIGatewayProxyEventV2,
-  APIGatewayProxyStructuredResultV2,
-  Context as LambdaContext,
-  SQSBatchResponse,
-  SQSEvent
-} from "aws-lambda";
-import { Context } from "./context.js";
-
-export interface Handlers {
-  api: {
-    event: APIGatewayProxyEventV2;
-    response: APIGatewayProxyStructuredResultV2;
-  };
-  sqs: {
-    event: SQSEvent;
-    response: SQSBatchResponse;
-  };
-}
-
-type HandlerTypes = keyof Handlers;
-
-type Requests = {
-  [key in HandlerTypes]: {
-    type: key;
-    event: Handlers[key]["event"];
-    context: LambdaContext;
-  };
-}[HandlerTypes];
-
-const RequestContext = Context.create<Requests>();
-
-export function useEvent<Type extends HandlerTypes>(type: Type) {
-  const ctx = RequestContext.use();
-  if (ctx.type !== type) throw new Error(`Expected ${type} event`);
-  return ctx.event as Handlers[Type]["event"];
-}
-
-export function useLambdaContext() {
-  const ctx = RequestContext.use();
-  return ctx.context;
-}
-
-export function Handler<
-  Type extends HandlerTypes,
-  Event = Handlers[Type]["event"],
-  Response = Handlers[Type]["response"]
->(type: Type, cb: (evt: Event, ctx: LambdaContext) => Promise<Response>) {
-  return function handler(event: Event, context: LambdaContext) {
-    RequestContext.provide({ type, event: event as any, context });
-    return cb(event, context);
-  };
-}

package/src/context/index.ts

@@ -1,2 +0,0 @@
-export * from "./context.js";
-export * from "./handler.js";

package/src/credentials.ts

@@ -1,103 +0,0 @@
-import { Context } from "@serverless-stack/node/context/index.js";
-import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
-import { Client } from "@aws-sdk/smithy-client";
-import { RegionInputConfig } from "@aws-sdk/config-resolver";
-import { RetryInputConfig } from "@aws-sdk/middleware-retry";
-import { AwsAuthInputConfig } from "@aws-sdk/middleware-signing";
-import { GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
-import { Logger } from "./logger.js";
-import { SdkProvider } from "aws-cdk/lib/api/aws-auth/sdk-provider.js";
-import { StandardRetryStrategy } from "@aws-sdk/middleware-retry";
-
-type Config = RegionInputConfig & RetryInputConfig & AwsAuthInputConfig;
-
-export const useAWSCredentialsProvider = Context.memo(() => {
-  const project = useProject();
-  Logger.debug("Using AWS profile", project.profile);
-  const provider = fromNodeProviderChain({
-    profile: project.profile,
-  });
-  return provider;
-});
-
-export const useAWSCredentials = () => {
-  const provider = useAWSCredentialsProvider();
-  return provider();
-};
-
-export const useSTSIdentity = Context.memo(async () => {
-  const sts = useAWSClient(STSClient);
-  const identity = await sts.send(new GetCallerIdentityCommand({}));
-  Logger.debug(
-    "Using identity",
-    "Account:",
-    identity.Account,
-    "User:",
-    identity.UserId
-  );
-  return identity;
-});
-
-const useClientCache = Context.memo(() => new Map<string, any>());
-
-export function useAWSClient<C extends Client<any, any, any, any>>(
-  client: new (config: Config) => C,
-  force = false
-) {
-  const cache = useClientCache();
-  const existing = cache.get(client.name);
-  if (existing && !force) return existing as C;
-  const [project, credentials] = [useProject(), useAWSCredentialsProvider()];
-  const result = new client({
-    region: project.region,
-    credentials: credentials,
-    retryStrategy: new StandardRetryStrategy(async () => 10000, {
-      delayDecider: (_, attempts) => {
-        return Math.min(1.5 ** attempts * 100, 5000);
-      },
-    }),
-  });
-  cache.set(client.name, result);
-  Logger.debug("Created AWS client", client.name);
-  return result;
-}
-
-import aws from "aws-sdk";
-import { useProject } from "./app.js";
-const CredentialProviderChain = aws.CredentialProviderChain;
-
-/**
- * Do not use this. It is only used for AWS CDK compatibility.
- */
-export const useAWSProvider = async () => {
-  Logger.debug("Loading v2 AWS SDK");
-  const project = useProject();
-  const creds = await useAWSCredentials();
-  const chain = new CredentialProviderChain([
-    () => ({
-      ...creds,
-      get(cb) {
-        cb();
-      },
-      async getPromise() {},
-      needsRefresh() {
-        return false;
-      },
-      refresh(cb) {
-        cb();
-      },
-      async refreshPromise() {},
-      expired: false,
-      expireTime: creds.expiration!,
-      accessKeyId: creds.accessKeyId!,
-      sessionToken: creds.sessionToken!,
-      secretAccessKey: creds.secretAccessKey!,
-    }),
-  ]);
-  const provider = new SdkProvider(chain, project.region!, {
-    maxRetries: 10000,
-    region: project.region,
-  });
-
-  return provider;
-};

package/src/error.ts

@@ -1,5 +0,0 @@
-export class VisibleError extends Error {
-  constructor(...message: string[]) {
-    super(message.join("\n"));
-  }
-}

package/src/iot.ts

@@ -1,105 +0,0 @@
-import { IoTClient, DescribeEndpointCommand } from "@aws-sdk/client-iot";
-import { Context } from "./context/context.js";
-import { useAWSClient, useAWSCredentials } from "./credentials.js";
-import { VisibleError } from "./error.js";
-
-export const useIOTEndpoint = Context.memo(async () => {
-  const iot = useAWSClient(IoTClient);
-  Logger.debug("Getting IoT endpoint");
-  const response = await iot.send(
-    new DescribeEndpointCommand({
-      endpointType: "iot:Data-ATS",
-    })
-  );
-  Logger.debug("Using IoT endpoint:", response.endpointAddress);
-
-  if (!response.endpointAddress)
-    throw new VisibleError("IoT Endpoint address not found");
-
-  return response.endpointAddress;
-});
-
-import iot from "aws-iot-device-sdk";
-import { EventPayload, Events, EventTypes, useBus } from "./bus.js";
-import { useProject } from "./app.js";
-import { Logger } from "./logger.js";
-
-interface Fragment {
-  id: string;
-  index: number;
-  count: number;
-  data: string;
-}
-
-export const useIOT = Context.memo(async () => {
-  const bus = useBus();
-
-  const endpoint = await useIOTEndpoint();
-  const creds = await useAWSCredentials();
-  const project = useProject();
-  const device = new iot.device({
-    protocol: "wss",
-    host: endpoint,
-    accessKeyId: creds.accessKeyId,
-    secretKey: creds.secretAccessKey,
-    sessionToken: creds.sessionToken,
-  });
-  const PREFIX = `/sst/${project.name}/${project.stage}`;
-  device.subscribe(`${PREFIX}/events`);
-
-  const fragments = new Map<string, Map<number, Fragment>>();
-
-  device.on("message", (_topic, buffer: Buffer) => {
-    const fragment = JSON.parse(buffer.toString()) as Fragment;
-    let pending = fragments.get(fragment.id);
-    if (!pending) {
-      pending = new Map();
-      fragments.set(fragment.id, pending);
-    }
-    pending.set(fragment.index, fragment);
-
-    if (pending.size === fragment.count) {
-      const data = [...pending.values()]
-        .sort((a, b) => a.index - b.index)
-        .map((item) => item.data)
-        .join("");
-      fragments.delete(fragment.id);
-      const evt = JSON.parse(data) as EventPayload;
-      if (evt.sourceID === bus.sourceID) return;
-      bus.publish(evt.type, evt.properties);
-    }
-  });
-
-  return {
-    prefix: PREFIX,
-    publish<Type extends EventTypes>(
-      topic: string,
-      type: Type,
-      properties: Events[Type]
-    ) {
-      const payload: EventPayload = {
-        type,
-        properties,
-        sourceID: bus.sourceID,
-      };
-      for (const fragment of encode(payload)) {
-        device.publish(topic, JSON.stringify(fragment), {
-          qos: 1,
-        });
-      }
-    },
-  };
-});
-
-function encode(input: any) {
-  const json = JSON.stringify(input);
-  const parts = json.match(/.{1,100000}/g);
-  if (!parts) return [];
-  const id = Math.random().toString();
-  return parts.map((part, index) => ({
-    id,
-    index,
-    count: parts?.length,
-    data: part,
-  }));
-}

package/src/logger.ts

@@ -1,35 +0,0 @@
-import chalk, { ChalkInstance } from "chalk";
-import fs from "fs/promises";
-import path from "path";
-
-type Colors = {
-  [key in keyof typeof chalk]: typeof chalk[key] extends ChalkInstance
-    ? key
-    : never;
-}[keyof typeof chalk];
-
-let previous = new Date();
-
-const filePath = path.join("debug.log");
-const file = await fs.open(filePath, "w");
-
-export const Logger = {
-  ui<T extends Colors>(color: T, ...lines: string[]) {
-    console.log(chalk[color](lines.join("\n")));
-  },
-  async debug(...parts: any[]) {
-    const now = new Date();
-    const diff = now.getTime() - previous.getTime();
-    previous = now;
-    const line = [
-      new Date().toISOString(),
-      `+${diff}ms`.padStart(8),
-      "[debug]",
-      ...parts.map((x) => {
-        if (typeof x === "string") return x;
-        return JSON.stringify(x);
-      }),
-    ];
-    file.write(line.join(" ") + "\n");
-  },
-};

package/src/runtime/handlers.ts

@@ -1,121 +0,0 @@
-import { Context } from "@serverless-stack/node/context/context.js";
-import { Logger } from "../logger.js";
-import { useFunctions, useMetadata } 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";
-
-declare module "../bus.js" {
-  export interface Events {
-    "function.built": {
-      functionID: string;
-    };
-  }
-}
-
-interface BuildInput {
-  functionID: string;
-  mode: "deploy" | "start";
-  srcPath: string;
-  handler: string;
-  out: string;
-}
-
-interface StartWorkerInput {
-  url: string;
-  workerID: string;
-  environment: Record<string, string>;
-  out: string;
-  handler: string;
-}
-
-interface ShouldBuildInput {
-  file: string;
-  functionID: string;
-}
-
-interface RuntimeHandler {
-  startWorker: (worker: StartWorkerInput) => Promise<void>;
-  stopWorker: (workerID: string) => Promise<void>;
-  shouldBuild: (input: ShouldBuildInput) => boolean;
-  canHandle: (runtime: string) => boolean;
-  build: (input: BuildInput) => Promise<string>;
-}
-
-export const useRuntimeHandlers = Context.memo(() => {
-  const handlers: RuntimeHandler[] = [];
-
-  return {
-    register: (handler: RuntimeHandler) => {
-      handlers.push(handler);
-    },
-    for: (runtime: string) => {
-      return handlers.find((x) => x.canHandle(runtime));
-    },
-  };
-});
-
-interface Artifact {
-  out: string;
-  handler: string;
-}
-
-export const useFunctionBuilder = Context.memo(() => {
-  const artifacts = new Map<string, Artifact>();
-  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: string) => {
-      if (artifacts.has(functionID)) return artifacts.get(functionID)!;
-      return result.build(functionID);
-    },
-    build: async (functionID: string) => {
-      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/src/runtime/iot.ts

@@ -1,16 +0,0 @@
-import { Context } from "@serverless-stack/node/context/context.js";
-import { useBus } from "../bus.js";
-import { useIOT } from "../iot.js";
-
-export const useIOTBridge = Context.memo(async () => {
-  const bus = useBus();
-  const iot = await useIOT();
-  const topic = `${iot.prefix}/events`;
-
-  bus.subscribe("function.success", async (evt) => {
-    iot.publish(topic, "function.success", evt.properties);
-  });
-  bus.subscribe("function.error", async (evt) => {
-    iot.publish(topic, "function.error", evt.properties);
-  });
-});

package/src/runtime/node.ts

@@ -1,111 +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: Record<string, esbuild.BuildResult> = {};
-  const project = useProject();
-  const threads = new Map<string, Worker>();
-
-  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: Buffer) => {
-          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;
-    },
-  });
-});

package/src/runtime/runtime.ts

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