sst 3.0.0 → 3.0.1-10

package/support/nixpacks/Dockerfile

@@ -1,6 +0,0 @@
-FROM debian:bookworm-slim
-RUN apt-get update && apt-get install -y curl
-RUN curl -LO https://github.com/railwayapp/nixpacks/releases/download/v1.11.0/nixpacks-v1.11.0-amd64.deb
-RUN dpkg -i nixpacks-v1.11.0-amd64.deb
-
-ENTRYPOINT ["nixpacks"]

package/support/nodejs-runtime/index.mjs

@@ -1,169 +0,0 @@
-import { createRequire as topLevelCreateRequire } from 'module';const require = topLevelCreateRequire(import.meta.url);
-
-// support/nodejs-runtime/index.ts
-import { workerData } from "node:worker_threads";
-import path from "path";
-import fs from "fs";
-import http from "http";
-import url from "url";
-var input = workerData;
-var parsed = path.parse(input.handler);
-var file = [".js", ".jsx", ".mjs", ".cjs"].map((ext) => path.join(input.out, parsed.dir, parsed.name + ext)).find((file2) => {
-  return fs.existsSync(file2);
-});
-var fn;
-function fetch(req) {
-  return new Promise((resolve, reject) => {
-    const request2 = http.request(
-      input.url + req.path,
-      {
-        headers: req.headers,
-        method: req.method
-      },
-      (res) => {
-        let body = "";
-        res.setEncoding("utf8");
-        res.on("data", (chunk) => {
-          body += chunk.toString();
-        });
-        res.on("end", () => {
-          resolve({
-            statusCode: res.statusCode,
-            headers: res.headers,
-            body
-          });
-        });
-      }
-    );
-    request2.on("error", reject);
-    if (req.body)
-      request2.write(req.body);
-    request2.end();
-  });
-}
-try {
-  const { href } = url.pathToFileURL(file);
-  const mod = await import(href);
-  const handler = parsed.ext.substring(1);
-  fn = mod[handler];
-  if (!fn) {
-    throw new Error(
-      `Function "${handler}" not found in "${input.handler}". Found ${Object.keys(mod).join(", ")}`
-    );
-  }
-} catch (ex) {
-  await fetch({
-    path: `/runtime/init/error`,
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      errorType: "Error",
-      errorMessage: ex.message,
-      trace: ex.stack?.split("\n")
-    })
-  });
-  process.exit(1);
-}
-var timeout;
-var request;
-var response;
-var context;
-async function error(ex) {
-  await fetch({
-    path: `/runtime/invocation/${context.awsRequestId}/error`,
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      errorType: "Error",
-      errorMessage: ex.message,
-      trace: ex.stack?.split("\n")
-    })
-  });
-}
-process.on("unhandledRejection", error);
-while (true) {
-  if (timeout)
-    clearTimeout(timeout);
-  timeout = setTimeout(() => {
-    process.exit(0);
-  }, 1e3 * 60 * 15);
-  try {
-    const result = await fetch({
-      path: `/runtime/invocation/next`,
-      method: "GET",
-      headers: {}
-    });
-    context = {
-      awsRequestId: result.headers["lambda-runtime-aws-request-id"],
-      invokedFunctionArn: result.headers["lambda-runtime-invoked-function-arn"],
-      getRemainingTimeInMillis: () => Math.max(
-        Number(result.headers["lambda-runtime-deadline-ms"]) - Date.now(),
-        0
-      ),
-      // If identity is null, we want to mimick AWS behavior and return undefined
-      identity: JSON.parse(result.headers["lambda-runtime-cognito-identity"]) ?? void 0,
-      // If clientContext is null, we want to mimick AWS behavior and return undefined
-      clientContext: JSON.parse(result.headers["lambda-runtime-client-context"]) ?? void 0,
-      functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
-      functionVersion: process.env.AWS_LAMBDA_FUNCTION_VERSION,
-      memoryLimitInMB: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE,
-      logGroupName: result.headers["lambda-runtime-log-group-name"],
-      logStreamName: result.headers["lambda-runtime-log-stream-name"],
-      callbackWaitsForEmptyEventLoop: {
-        set value(_value) {
-          throw new Error(
-            "`callbackWaitsForEmptyEventLoop` on lambda Context is not implemented by SST Live Lambda Development."
-          );
-        },
-        get value() {
-          return true;
-        }
-      }.value,
-      done() {
-        throw new Error(
-          "`done` on lambda Context is not implemented by SST Live Lambda Development."
-        );
-      },
-      fail() {
-        throw new Error(
-          "`fail` on lambda Context is not implemented by SST Live Lambda Development."
-        );
-      },
-      succeed() {
-        throw new Error(
-          "`succeed` on lambda Context is not implemented by SST Live Lambda Development."
-        );
-      }
-    };
-    request = JSON.parse(result.body);
-  } catch {
-    continue;
-  }
-  global[Symbol.for("aws.lambda.runtime.requestId")] = context.awsRequestId;
-  try {
-    response = await fn(request, context);
-  } catch (ex) {
-    error(ex);
-    continue;
-  }
-  while (true) {
-    try {
-      await fetch({
-        path: `/runtime/invocation/${context.awsRequestId}/response`,
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(response)
-      });
-      break;
-    } catch (ex) {
-      console.error(ex);
-      await new Promise((resolve) => setTimeout(resolve, 500));
-    }
-  }
-}

package/support/python-runtime/Dockerfile

@@ -1,9 +0,0 @@
-# The correct AWS SAM build image based on the runtime of the function will be
-# passed as build arg. The default allows to do `docker build .` when testing.
-ARG IMAGE=amazon/aws-sam-cli-build-image-python3.7
-FROM $IMAGE
-
-# Ensure rsync is installed
-RUN yum -q list installed rsync &>/dev/null || yum install -y rsync
-
-CMD [ "python" ]

package/support/python-runtime/Dockerfile.custom

@@ -1,21 +0,0 @@
-# The correct AWS SAM build image based on the runtime of the function will be
-# passed as build arg. The default allows to do `docker build .` when testing.
-ARG IMAGE=amazon/aws-sam-cli-build-image-python3.7
-FROM $IMAGE
-
-# Ensure rsync is installed
-RUN yum -q list installed rsync &>/dev/null || yum install -y rsync
-
-# Upgrade pip (required by cryptography v3.4 and above, which is a dependency of poetry)
-RUN pip install --upgrade pip
-
-# Install pipenv and poetry so we can create a requirements.txt if we detect pipfile or poetry.lock respectively
-RUN pip install pipenv poetry
-
-# Install the dependencies in a cacheable layer
-WORKDIR /var/dependencies
-COPY Pipfile* pyproject* poetry* requirements.tx[t] sst-deps-install-command.sh ./
-
-RUN ./sst-deps-install-command.sh
-
-CMD [ "python" ]

package/support/python-runtime/Dockerfile.dependencies

@@ -1,26 +0,0 @@
-# The correct AWS SAM build image based on the runtime of the function will be
-# passed as build arg. The default allows to do `docker build .` when testing.
-ARG IMAGE=amazon/aws-sam-cli-build-image-python3.7
-FROM $IMAGE
-
-# Ensure rsync is installed
-RUN yum -q list installed rsync &>/dev/null || yum install -y rsync
-
-# Upgrade pip (required by cryptography v3.4 and above, which is a dependency of poetry)
-RUN pip install --upgrade pip
-
-# Install pipenv and poetry so we can create a requirements.txt if we detect pipfile or poetry.lock respectively
-RUN pip install pipenv poetry==1.5.1
-
-# Install the dependencies in a cacheable layer
-WORKDIR /var/dependencies
-COPY Pipfile* pyproject* poetry* requirements.tx[t] ./
-
-# Run these command separately
-# Note: "pipenv requirements > requirements.txt" command can fail if the pipenv is using a Python version (ie. Python3.9)
-#       that's not the same as the Lambda Python version (ie. Python3.8)
-RUN if [ -f 'Pipfile' ]; then pipenv requirements > requirements.txt; else echo "Pipfile not found"; fi
-RUN if [ -f 'poetry.lock' ]; then poetry export --with-credentials --format requirements.txt --output requirements.txt; else echo "poetry.lock not found"; fi
-RUN if [ -f 'requirements.txt' ]; then pip install -r requirements.txt -t .; else echo "requirements.txt not found"; fi
-
-CMD [ "python" ]

package/support/python-runtime/runtime.py

@@ -1,127 +0,0 @@
-import os
-import sys
-import json
-import logging
-import argparse
-import traceback
-from urllib import request, parse
-from time import strftime, time
-from importlib import import_module
-
-class Identity(object):
-    def __init__(self, **kwargs):
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-    #__slots__ = ["cognito_identity_id", "cognito_identity_pool_id"]
-
-class ClientContext(object):
-    def __init__(self, **kwargs):
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-    #__slots__ = ['custom', 'env', 'client']
-
-class Context(object):
-    def __init__(self, invoked_function_arn, aws_request_id, deadline_ms, identity, client_context, log_group_name, log_stream_name):
-        self.function_name = os.environ['AWS_LAMBDA_FUNCTION_NAME']
-        self.invoked_function_arn = invoked_function_arn
-        self.aws_request_id = aws_request_id
-        self.memory_limit_in_mb = os.environ['AWS_LAMBDA_FUNCTION_MEMORY_SIZE']
-        self.deadline_ms = deadline_ms
-        # If identity is null, we want to mimick AWS behavior and return an object with None values
-        self.identity = Identity(**json.loads(identity)) if identity != 'null' else Identity(cognito_identity_id = None, cognito_identity_pool_id = None)
-        # If client_context is null, we want to mimick AWS behavior and return None
-        self.client_context = ClientContext(**json.loads(client_context)) if client_context != 'null' else None
-        self.log_group_name = log_group_name
-        self.log_stream_name = log_stream_name
-
-    def get_remaining_time_in_millis(self):
-        return int(max(self.deadline_ms - int(round(time() * 1000)), 0))
-
-    def log(self):
-        return sys.stdout.write
-
-
-def handleUnserializable(obj):
-    print(
-        "Unserializable {}: {} when returning result {!r}".format(
-            type(obj), repr(obj), result
-        )
-    )
-
-    raise TypeError("Unserializable {}: {!r}".format(type(obj), obj))
-
-
-logging.basicConfig()
-
-parser = argparse.ArgumentParser(
-    prog='invoke',
-    description='Runs a Lambda entry point (handler) with an optional event',
-)
-
-parser.add_argument('handler_module',
-                    help=('Module containing the handler function,'
-                          ' omitting ".py". IE: "path.to.module"'))
-parser.add_argument('src_path', help='SrcPath of the handler function')
-parser.add_argument('handler_name', help='Name of the handler function')
-
-if __name__ == '__main__':
-    args = parser.parse_args()
-
-    # this is needed because you need to import from where you've executed sst
-    sys.path.append('.')
-
-    # fetch request
-    url = "http://{}/2018-06-01/runtime/invocation/next".format(os.environ['AWS_LAMBDA_RUNTIME_API'])
-    r = request.urlopen(url)
-    event = json.loads(r.read())
-    context = Context(
-        r.getheader('Lambda-Runtime-Invoked-Function-Arn'),
-        r.getheader('Lambda-Runtime-Aws-Request-Id'),
-        r.getheader('Lambda-Runtime-Deadline-Ms'),
-        r.getheader('Lambda-Runtime-Cognito-Identity'),
-        r.getheader('Lambda-Runtime-Client-Context'),
-        r.getheader('Lambda-Runtime-Log-Group-Name'),
-        r.getheader('Lambda-Runtime-Log-Stream-Name')
-    )
-
-    # invoke handler
-    has_error = False
-    try:
-        # set the sys.path to the src_path. Other wise importing a local file
-        # would fail with error ModuleNotFoundError
-        sys.path.append(args.src_path)
-
-        # remove leading zeros for relative imports
-        if args.handler_module.startswith('.'):
-          module = import_module(args.handler_module[1:])
-        else: 
-          module = import_module(args.handler_module)
-
-        handler = getattr(module, args.handler_name)
-        result = handler(event, context)
-        data = json.dumps(result, default=handleUnserializable).encode("utf-8")
-
-    except Exception as e:
-        has_error = True
-        # print error in bootstrap because we won't be able to print the Python
-        # stack trace in the correct format in NodeJS
-        traceback.print_exc()
-        # build error response
-        ex_type, ex_value, ex_traceback = sys.exc_info()
-        result = {
-            "errorType": ex_type.__name__,
-            "errorMessage": str(ex_value),
-            "trace": traceback.format_tb(ex_traceback),
-        }
-        data = json.dumps(result).encode("utf-8")
-
-    # send response
-    if has_error == False:
-        url_destination = '/response'
-    else:
-        url_destination = '/error'
-    url = "http://{}/2018-06-01/runtime/invocation/{}{}".format(os.environ['AWS_LAMBDA_RUNTIME_API'], context.aws_request_id, url_destination)
-    req =  request.Request(url, method="POST", data=data)
-    req.add_header('Content-Type', 'application/json')
-    r = request.urlopen(req, data=data)
-