@certik/serverless-api 1.0.12 → 2.0.0

package/entrypoint.js

@@ -1,68 +0,0 @@
-/*
- * All handlers will share this same entrypoint
- * the entrypoint will be responsible for routing the request to the correct handler
- * and also for applying middlewares
- * */
-import pathModule from "node:path";
-import { getRoutes } from "./lib/routes.js";
-
-export const handler = async (event, context) => {
-  const routes = await getRoutes(pathModule.resolve("routes"));
-
-  const currentRoute = routes.find((route) => {
-    return (
-      route.path === event.path &&
-      route.method.toLowerCase() === event.httpMethod.toLowerCase()
-    );
-  });
-
-  if (!currentRoute) {
-    return {
-      statusCode: 404,
-      body: "Not Found",
-    };
-  }
-
-  const extraHeaders = {};
-
-  if (currentRoute.corsOrigin) {
-    extraHeaders["Access-Control-Allow-Origin"] = currentRoute.corsOrigin;
-  }
-
-  const response = await Promise.race([
-    (async () => {
-      let body = event.body ? event.body : null;
-
-      if (event.isBase64Encoded && body) {
-        body = Buffer.from(body, "base64").toString("utf-8");
-      }
-
-      const rp = await currentRoute.handler(
-        {
-          ...event,
-          body,
-          isBase64Encoded: false,
-        },
-        context,
-      );
-
-      return rp;
-    })(),
-    new Promise(function timeoutResponse(resolve) {
-      setTimeout(() => {
-        resolve({
-          statusCode: 408,
-          body: `Request Timeout after ${currentRoute.timeout} seconds`,
-        });
-      }, currentRoute.timeout * 1000);
-    }),
-  ]);
-
-  return {
-    ...response,
-    headers: {
-      ...response.headers,
-      ...extraHeaders,
-    },
-  };
-};

package/lib/app.js

@@ -1,162 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as aws from "@pulumi/aws";
-import * as apigateway from "@pulumi/aws-apigateway";
-import { readFile } from "node:fs/promises";
-import { isReservedEnvName } from "./env.js";
-import { packAndZip } from "./pack.js";
-
-export function getWildcardCertificateName(domainName) {
-  const parts = domainName.split(".");
-  return ["*", ...parts.slice(1)].join(".");
-}
-
-export async function createPulumiAPIApp({
-  routes,
-  bundleDevDependencies = false,
-}) {
-  const { zipFileName, zipFileHash } = await packAndZip({
-    bundleDevDependencies,
-  });
-
-  const projectName = pulumi.getProject();
-  const stackName = pulumi.getStack();
-
-  const namespace = `wf-${stackName}-${projectName}-${stackName}`;
-
-  const config = new pulumi.Config();
-  const sourceBucketName = config.require("sourceBucket");
-  const hostedZone = config.require("hostedZone");
-  const runtime = config.require("runtime");
-  // we can use subdomain config option to specify a custom name
-  let subdomain = config.get("subdomain");
-  if (!subdomain) {
-    // default subdomain will be generated from pulumi project name
-    subdomain = projectName.startsWith("api-")
-      ? projectName.slice(4)
-      : projectName;
-  }
-  const domainName = `${subdomain}.${hostedZone}`;
-  // this bases on a naming convention
-  const wildcardCertificateName = getWildcardCertificateName(domainName);
-  const lambdaRoleName = config.get("lambdaRole");
-
-  const role = aws.iam.getRole({ name: lambdaRoleName });
-
-  const sourceBucket = aws.s3.getBucket({ bucket: sourceBucketName });
-  const sourceKey = `${namespace}/sourcecode.zip`;
-
-  // write to s3 bucket
-  // eslint-disable-next-line no-new
-  const sourceS3File = new aws.s3.BucketObject(`${namespace}-s3-sourcecode`, {
-    bucket: sourceBucket.then((b) => b.id),
-    key: sourceKey,
-    source: new pulumi.asset.FileArchive(zipFileName),
-    sourceHash: zipFileHash,
-  });
-
-  // Create an API endpoint
-  const site = new apigateway.RestAPI(namespace, {
-    routes: routes.map(
-      ({ name, path, method, timeout, memorySize, environmentVariables }) => {
-        const variables = environmentVariables
-          ? environmentVariables.reduce((acc, envName) => {
-              if (isReservedEnvName(envName)) {
-                // for reserved env names, we don't need to set them
-                return acc;
-              }
-
-              if (process.env[envName]) {
-                acc[envName] = process.env[envName];
-              } else {
-                console.warn(
-                  `Environment variable not set: process.env.${envName}`,
-                );
-              }
-
-              return acc;
-            }, {})
-          : {};
-
-        return {
-          path,
-          method,
-          eventHandler: new aws.lambda.Function(
-            // maximum length of lambda function name is 64, pulumi will append 8 random characters to the name
-            `${namespace}-${name}`.slice(0, 56),
-            {
-              name: `${namespace}-${name}`.slice(0, 56),
-              role: role.then((r) => r.arn),
-              runtime,
-              s3Bucket: sourceBucketName,
-              s3Key: sourceS3File.key, // wait until the source code is uploaded
-              handler: "entrypoint.handler",
-              sourceCodeHash: zipFileHash,
-              timeout: timeout + 10, // add a few more second for buffer so entrypoint can handle 408 case
-              memorySize,
-              environment: { variables },
-            },
-          ),
-        };
-      },
-    ),
-  });
-
-  // Get certificate for desired endpoint
-  const certificate = await aws.acm.getCertificate({
-    domain: wildcardCertificateName,
-    statuses: ["ISSUED"],
-  });
-
-  // Get the zone we're going to use
-  const zone = await aws.route53.getZone({ name: hostedZone }, { async: true });
-
-  // API Gateway requires register the domain with it first
-  const domain = new aws.apigateway.DomainName(namespace, {
-    certificateArn: certificate.arn,
-    domainName,
-  });
-
-  // eslint-disable-next-line no-new
-  new aws.apigateway.BasePathMapping(namespace, {
-    restApi: site.api,
-    stageName: site.stage.stageName,
-    domainName: domain.domainName,
-  });
-
-  // a DNS record to point at the API Gateway
-  // eslint-disable-next-line no-new
-  new aws.route53.Record(namespace, {
-    type: "A",
-    zoneId: zone.zoneId,
-    name: domainName,
-    aliases: [
-      {
-        // APIGateway provides it's own CloudFront distribution we can point at...
-        name: domain.cloudfrontDomainName,
-        zoneId: domain.cloudfrontZoneId,
-        evaluateTargetHealth: false,
-      },
-    ],
-  });
-
-  const routesInfo = routes.reduce((acc, { name, method, timeout, path }) => {
-    acc[name] = {
-      method,
-      timeout,
-      url: `https://${domainName}${path}`,
-    };
-    return acc;
-  }, {});
-
-  const readme = (await readFile("./README.md")).toString();
-
-  return {
-    zipFileName,
-    zipFileHash,
-    routes: routesInfo,
-    runtime,
-    hostedZone,
-    domainName,
-    readme,
-  };
-}

package/lib/const.js

@@ -1,4 +0,0 @@
-export const DEFAULT_TIMEOUT = 30; // seconds
-export const MAX_TIMEOUT = 90; // seconds
-
-export const DEFAULT_MEMORY_SIZE = 128; // MB

package/lib/cors.js

@@ -1,21 +0,0 @@
-export function corsPreflight(name, path) {
-  return {
-    name,
-    path,
-    method: "OPTIONS",
-    timeout: 30,
-    memorySize: 128,
-    handler: async () => {
-      return {
-        body: "",
-        statusCode: 200,
-        headers: {
-          "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods":
-            "GET, POST, OPTIONS, PUT, PATCH, DELETE",
-          "Access-Control-Allow-Headers": "*",
-        },
-      };
-    },
-  };
-}

package/lib/dev.js

@@ -1,54 +0,0 @@
-import express from "express";
-
-export function mapRequestToEvent(req) {
-  // a custom simulator
-  return {
-    resource: req.path,
-    path: req.path,
-    httpMethod: req.method,
-    requestContext: {
-      resourcePath: req.path,
-      httpMethod: req.method,
-      path: req.path,
-    },
-    headers: req.headers,
-    multiValueHeaders: {},
-    queryStringParameters: req.query,
-    body: Buffer.isBuffer(req.body) ? req.body.toString("base64") : "",
-    isBase64Encoded: true,
-  };
-}
-
-export async function startLocalApp({ routes, handler }) {
-  const app = express();
-
-  app.use(
-    express.raw({
-      inflate: true,
-      limit: "10mb",
-      type: () => true, // this matches all content types
-    }),
-  );
-
-  routes.forEach(({ path, method }) => {
-    const m = method || "GET";
-    console.log(`registering ${m} ${path}`);
-    const callback = async (req, res) => {
-      const context = {};
-      const result = await handler(mapRequestToEvent(req), context);
-
-      for (const [key, value] of Object.entries(result.headers || {})) {
-        res.set(key, value);
-      }
-      res.status(result.statusCode);
-      res.send(result.body);
-    };
-    app[m.toLowerCase()](path, callback);
-    // keep compatibility with serverless-offline
-    app[m.toLowerCase()](`/dev${path}`, callback);
-  });
-
-  console.log("listening on http://localhost:4000");
-
-  app.listen(4000);
-}

package/lib/env.js

@@ -1,24 +0,0 @@
-const RESERVED_ENV_NAMES = [
-  "_HANDLER",
-  "_X_AMZN_TRACE_ID",
-  "AWS_DEFAULT_REGION",
-  "AWS_REGION",
-  "AWS_EXECUTION_ENV",
-  "AWS_LAMBDA_FUNCTION_NAME",
-  "AWS_LAMBDA_FUNCTION_MEMORY_SIZE",
-  "AWS_LAMBDA_FUNCTION_VERSION",
-  "AWS_LAMBDA_INITIALIZATION_TYPE",
-  "AWS_LAMBDA_LOG_GROUP_NAME",
-  "AWS_LAMBDA_LOG_STREAM_NAME",
-  "AWS_ACCESS_KEY",
-  "AWS_ACCESS_KEY_ID",
-  "AWS_SECRET_ACCESS_KEY",
-  "AWS_SESSION_TOKEN",
-  "AWS_LAMBDA_RUNTIME_API",
-  "LAMBDA_TASK_ROOT",
-  "LAMBDA_RUNTIME_DIR",
-];
-
-export function isReservedEnvName(name) {
-  return RESERVED_ENV_NAMES.includes(name);
-}

package/lib/pack.js

@@ -1,83 +0,0 @@
-import fsModule from "node:fs";
-import pathModule from "node:path";
-import cryptoModule from "node:crypto";
-import { promisify } from "node:util";
-import { exec } from "node:child_process";
-import archiver from "archiver";
-
-const execPromise = promisify(exec);
-const rmPromise = promisify(fsModule.rm);
-const mkdirPromise = promisify(fsModule.mkdir);
-const readdirPromise = promisify(fsModule.readdir);
-const cpPromise = promisify(fsModule.cp);
-
-const PACK_DIR = ".serverless-pack";
-const ZIP_FILE = "all-code.zip";
-const EXCLUDED_FILES = [
-  "node_modules",
-  "test",
-  "bun.lockb",
-  ZIP_FILE,
-  PACK_DIR,
-];
-
-function zipDirectory(sourceDir, outPath) {
-  const archive = archiver("zip", { zlib: { level: 9 } });
-  const stream = fsModule.createWriteStream(outPath);
-
-  return new Promise((resolve, reject) => {
-    archive
-      .directory(sourceDir, false)
-      .on("error", (err) => reject(err))
-      .pipe(stream);
-
-    stream.on("close", () => resolve());
-    archive.finalize();
-  });
-}
-
-async function getHash(path) {
-  return new Promise((resolve, reject) => {
-    const hash = cryptoModule.createHash("sha256");
-    const rs = fsModule.createReadStream(path);
-    rs.on("error", reject);
-    rs.on("data", (chunk) => hash.update(chunk));
-    rs.on("end", () => resolve(hash.digest("hex")));
-  });
-}
-
-export async function packAndZip({ bundleDevDependencies } = {}) {
-  const packDirAbsolute = pathModule.resolve(PACK_DIR);
-
-  // remove directory for packing
-  await rmPromise(packDirAbsolute, { recursive: true, force: true });
-  // make new directory for packing
-  await mkdirPromise(packDirAbsolute);
-  // copy files to new directory, ignore node_modules, test and all-code.zip
-  const rootLevelFiles = await readdirPromise(".");
-
-  for (const file of rootLevelFiles) {
-    if (!EXCLUDED_FILES.includes(file)) {
-      await cpPromise(file, pathModule.join(packDirAbsolute, file), {
-        recursive: true,
-      });
-    }
-  }
-
-  // assume bun exist
-  // run bun install --production
-  if (bundleDevDependencies) {
-    await execPromise("bun install", { cwd: packDirAbsolute });
-  } else {
-    // install only production dependencies
-    await execPromise("bun install --production", { cwd: packDirAbsolute });
-  }
-
-  // zip all files in directory
-  // create a file to stream archive data to.
-  await zipDirectory(packDirAbsolute, pathModule.resolve(ZIP_FILE));
-
-  const zipFileHash = await getHash(pathModule.resolve(ZIP_FILE));
-
-  return { zipFileName: ZIP_FILE, zipFileHash };
-}

package/lib/path.js

@@ -1,6 +0,0 @@
-import pathModule from "node:path";
-import { fileURLToPath } from "node:url";
-
-export function dirname(importMetaUrl) {
-  return fileURLToPath(new URL(pathModule.join("."), importMetaUrl));
-}

package/lib/routes.js

@@ -1,39 +0,0 @@
-import pathModule from "node:path";
-import { readdir } from "node:fs/promises";
-import { corsPreflight } from "./cors.js";
-import { DEFAULT_TIMEOUT, MAX_TIMEOUT, DEFAULT_MEMORY_SIZE } from "./const.js";
-
-export async function getRoutes(routeDirectory) {
-  const routeFiles = await readdir(routeDirectory);
-
-  const routesFromFiles = await Promise.all(
-    routeFiles.map(async (routeFile) => {
-      const routeFilePath = pathModule.join(routeDirectory, routeFile);
-      const route = await import(`file://${routeFilePath}`);
-      const routeName = pathModule.basename(routeFile, ".js");
-      const methods = route.methods || ["GET"];
-      const environmentVariables = route.environmentVariables || [];
-
-      const methodRoutes = methods.map((method) => ({
-        name: `${routeName}-${method}`,
-        path: `/${routeName}`,
-        method,
-        corsOrigin: route.corsOrigin,
-        timeout: Math.min(route.timeout || DEFAULT_TIMEOUT, MAX_TIMEOUT),
-        handler: route.default,
-        memorySize: route.memorySize || DEFAULT_MEMORY_SIZE,
-        environmentVariables,
-      }));
-
-      if (route.corsOrigin) {
-        methodRoutes.push(
-          corsPreflight(`${routeName}-OPTIONS`, `/${routeName}`),
-        );
-      }
-
-      return methodRoutes;
-    }),
-  );
-
-  return routesFromFiles.reduce((acc, rs) => acc.concat(rs), []);
-}