sst-http 1.3.2 → 1.3.3-beta.2

package/dist/chunk-SENBWWVV.js

@@ -0,0 +1,499 @@
+import {
+  normalizeRouterPath
+} from "./chunk-5OUNKYO5.js";
+import {
+  getRegisteredEvents,
+  getRegisteredRoutes,
+  registerFirebaseAuth,
+  registerParameter,
+  registerRoute,
+  resolveHandler
+} from "./chunk-YMGEGOSD.js";
+
+// src/http/router.ts
+import { match } from "path-to-regexp";
+var Router = class {
+  routes;
+  constructor(entries) {
+    this.routes = entries.map((entry) => ({
+      entry,
+      matcher: match(normalizeRouterPath(entry.path), { decode: decodeURIComponent })
+    }));
+  }
+  find(method, pathname) {
+    const allowed = /* @__PURE__ */ new Set();
+    for (const route of this.routes) {
+      const result = route.matcher(pathname);
+      if (!result) {
+        continue;
+      }
+      allowed.add(route.entry.method);
+      if (route.entry.method === method) {
+        return {
+          type: "found",
+          entry: route.entry,
+          params: normalizeParams(result.params)
+        };
+      }
+    }
+    if (allowed.size > 0) {
+      return {
+        type: "method-not-allowed",
+        allowedMethods: [...allowed]
+      };
+    }
+    return void 0;
+  }
+};
+function normalizeParams(params) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(params)) {
+    normalized[key] = Array.isArray(value) ? value[value.length - 1] ?? "" : value;
+  }
+  return normalized;
+}
+
+// src/http/runtime.ts
+var HTTP_ERROR_MARKER = Symbol.for("sst-http.HttpError");
+var HttpError = class extends Error {
+  statusCode;
+  headers;
+  details;
+  constructor(statusCode, message, options) {
+    super(message);
+    this.name = "HttpError";
+    Object.defineProperty(this, HTTP_ERROR_MARKER, { value: true });
+    this.statusCode = statusCode;
+    this.headers = options?.headers;
+    this.details = options?.details;
+    if ("cause" in (options ?? {})) {
+      this.cause = options?.cause;
+    }
+  }
+};
+function json(status, data, headers = {}) {
+  return {
+    statusCode: status,
+    body: JSON.stringify(data ?? null),
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      ...headers
+    }
+  };
+}
+function text(status, body, headers = {}) {
+  return {
+    statusCode: status,
+    body,
+    headers: {
+      "content-type": "text/plain; charset=utf-8",
+      ...headers
+    }
+  };
+}
+function noContent(headers = {}) {
+  return {
+    statusCode: 204,
+    headers,
+    body: ""
+  };
+}
+function createHandler() {
+  const routes = getRegisteredRoutes();
+  const router = new Router(routes);
+  const eventHandlers = getRegisteredEvents();
+  return async (event, lambdaContext) => {
+    if (isEventBridgeEvent(event)) {
+      await handleEventBridgeEvent(event, eventHandlers, lambdaContext);
+      return {
+        statusCode: 200,
+        body: ""
+      };
+    }
+    const httpEvent = event;
+    const method = extractMethod(httpEvent);
+    const path = extractPath(httpEvent);
+    const preferV2 = isHttpApiEvent(httpEvent);
+    if (!method || !path) {
+      return formatResponse(text(400, "Invalid request"), preferV2);
+    }
+    const normalizedMethod = method.toUpperCase();
+    if (!isSupportedMethod(normalizedMethod)) {
+      return formatResponse(text(405, "Method Not Allowed"), preferV2);
+    }
+    const match2 = router.find(normalizedMethod, path);
+    if (!match2) {
+      return formatResponse(text(404, "Not Found"), preferV2);
+    }
+    if (match2.type === "method-not-allowed") {
+      return formatResponse({
+        statusCode: 405,
+        headers: {
+          Allow: match2.allowedMethods.join(", ")
+        },
+        body: ""
+      }, preferV2);
+    }
+    const { entry, params } = match2;
+    const headers = normalizeHeaders(httpEvent.headers ?? {});
+    const query = extractQuery(httpEvent);
+    let bodyValue = void 0;
+    let bodyParsed = false;
+    const requiresJson = entry.parameters.some((p) => p.type === "body");
+    const ensureBody = () => {
+      if (!bodyParsed) {
+        bodyValue = parseBody(httpEvent, headers, requiresJson);
+        bodyParsed = true;
+      }
+      return bodyValue;
+    };
+    const ctxResponse = {
+      json,
+      text,
+      noContent
+    };
+    const ctx = {
+      event: httpEvent,
+      lambdaContext,
+      params,
+      query,
+      body: void 0,
+      headers,
+      auth: extractAuthClaims(httpEvent, entry),
+      response: ctxResponse
+    };
+    const getBody = (schema) => {
+      const current = ensureBody();
+      if (schema && typeof schema.parse === "function") {
+        try {
+          bodyValue = schema.parse(current);
+        } catch (error) {
+          console.error("[ERROR] Body validation failed", error);
+          throw new HttpError(400, "Body validation failed", { cause: error });
+        }
+      }
+      ctx.body = bodyValue;
+      return bodyValue;
+    };
+    try {
+      ctx.body = ensureBody();
+      const args = buildHandlerArguments(entry, ctx, getBody);
+      const result = await entry.handler(...args);
+      if (result === void 0) {
+        return formatResponse(noContent(), preferV2);
+      }
+      return formatResponse(result, preferV2);
+    } catch (error) {
+      return handleError(error, preferV2);
+    }
+  };
+}
+function isEventBridgeEvent(event) {
+  if (!event || typeof event !== "object") {
+    return false;
+  }
+  const e = event;
+  return typeof e["detail-type"] === "string" || typeof e.detailType === "string";
+}
+async function handleEventBridgeEvent(event, handlers, lambdaContext) {
+  const eventType = event["detail-type"] ?? event.detailType;
+  if (!eventType) {
+    return;
+  }
+  const matches = handlers.filter((entry) => {
+    if (entry.event !== eventType) {
+      return false;
+    }
+    return true;
+  });
+  if (matches.length === 0) {
+    return;
+  }
+  await Promise.all(
+    matches.map((entry) => Promise.resolve(entry.handler(event.detail, event, lambdaContext)))
+  );
+}
+function buildHandlerArguments(entry, ctx, getBody) {
+  const maxIndex = entry.parameters.reduce((max, meta) => Math.max(max, meta.index), -1);
+  const length = Math.max(entry.handler.length, maxIndex + 1, 1);
+  const args = new Array(length).fill(void 0);
+  for (const meta of entry.parameters) {
+    switch (meta.type) {
+      case "body": {
+        args[meta.index] = getBody(meta.schema);
+        break;
+      }
+      case "query": {
+        args[meta.index] = meta.name ? ctx.query[meta.name] : ctx.query;
+        break;
+      }
+      case "param": {
+        args[meta.index] = meta.name ? ctx.params[meta.name] : ctx.params;
+        break;
+      }
+      case "headers": {
+        args[meta.index] = ctx.headers;
+        break;
+      }
+      case "header": {
+        args[meta.index] = meta.name ? ctx.headers[meta.name.toLowerCase()] : ctx.headers;
+        break;
+      }
+      case "req": {
+        args[meta.index] = ctx.event;
+        break;
+      }
+      case "res": {
+        args[meta.index] = ctx.response;
+        break;
+      }
+      case "auth": {
+        args[meta.index] = ctx.auth;
+        break;
+      }
+      default: {
+        args[meta.index] = ctx;
+      }
+    }
+  }
+  for (let i = 0; i < length; i += 1) {
+    if (args[i] === void 0) {
+      args[i] = ctx;
+    }
+  }
+  return args;
+}
+function parseBody(event, headers, forceJson) {
+  const raw = extractRawBody(event);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const contentType = headers["content-type"];
+  const shouldParse = forceJson || isJsonContentType(contentType);
+  if (!shouldParse) {
+    return raw;
+  }
+  if (raw.trim() === "") {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new HttpError(400, "Invalid JSON body", { cause: error });
+  }
+}
+function extractRawBody(event) {
+  if (!event.body) {
+    return void 0;
+  }
+  if (event.isBase64Encoded) {
+    return Buffer.from(event.body, "base64").toString("utf8");
+  }
+  return event.body;
+}
+function isJsonContentType(contentType) {
+  if (!contentType) {
+    return false;
+  }
+  return contentType.includes("application/json") || contentType.includes("+json");
+}
+function normalizeHeaders(headers) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "undefined") {
+      continue;
+    }
+    normalized[key.toLowerCase()] = value;
+  }
+  return normalized;
+}
+function extractQuery(event) {
+  const single = event.queryStringParameters ?? event.queryStringParameters ?? {};
+  const multi = event.multiValueQueryStringParameters ?? {};
+  const query = {};
+  for (const [key, value] of Object.entries(single ?? {})) {
+    query[key] = value ?? void 0;
+  }
+  for (const [key, value] of Object.entries(multi ?? {})) {
+    if (!value || value.length === 0) {
+      continue;
+    }
+    query[key] = value[value.length - 1];
+  }
+  return query;
+}
+function extractMethod(event) {
+  return event.requestContext?.http?.method || event.httpMethod || void 0;
+}
+function extractPath(event) {
+  return event.rawPath || event.path || void 0;
+}
+function extractAuthClaims(event, entry) {
+  if (!entry.auth || entry.auth.type !== "firebase") {
+    return void 0;
+  }
+  const ctxV2 = event.requestContext;
+  const ctxV1 = event.requestContext;
+  const claims = ctxV2?.authorizer?.jwt?.claims || ctxV1?.authorizer?.claims;
+  return claims ?? void 0;
+}
+function isHttpError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const marker = error[HTTP_ERROR_MARKER] === true;
+  const named = error.name === "HttpError";
+  const status = typeof error.statusCode === "number";
+  return status && (marker || named);
+}
+function handleError(error, preferV2) {
+  if (isHttpError(error)) {
+    return formatResponse({
+      statusCode: error.statusCode,
+      headers: {
+        "content-type": "application/json; charset=utf-8",
+        ...error.headers
+      },
+      body: error.details ? JSON.stringify({ message: error.message, details: error.details }) : JSON.stringify({ message: error.message })
+    }, preferV2);
+  }
+  console.error("Unhandled error in sst-http handler", error);
+  return formatResponse({
+    statusCode: 500,
+    headers: {
+      "content-type": "application/json; charset=utf-8"
+    },
+    body: JSON.stringify({ message: "Internal Server Error" })
+  }, preferV2);
+}
+function formatResponse(result, preferV2) {
+  if (typeof result === "string") {
+    result = { statusCode: 200, body: result };
+  }
+  const normalized = {
+    statusCode: result.statusCode ?? 200,
+    headers: result.headers,
+    body: result.body ?? "",
+    cookies: "cookies" in result ? result.cookies : void 0,
+    isBase64Encoded: result.isBase64Encoded
+  };
+  if (preferV2) {
+    const response2 = {
+      statusCode: normalized.statusCode,
+      headers: normalized.headers,
+      body: normalized.body
+    };
+    if (normalized.cookies) {
+      response2.cookies = normalized.cookies;
+    }
+    if (typeof normalized.isBase64Encoded === "boolean") {
+      response2.isBase64Encoded = normalized.isBase64Encoded;
+    }
+    return response2;
+  }
+  const response = {
+    statusCode: normalized.statusCode,
+    headers: normalized.headers,
+    body: normalized.body
+  };
+  if (typeof normalized.isBase64Encoded === "boolean") {
+    response.isBase64Encoded = normalized.isBase64Encoded;
+  }
+  return response;
+}
+function isHttpApiEvent(event) {
+  return event.version === "2.0";
+}
+var SUPPORTED_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+]);
+function isSupportedMethod(value) {
+  return SUPPORTED_METHODS.has(value);
+}
+
+// src/http/decorators.ts
+function createRouteDecorator(method) {
+  return (path) => (target, propertyKey, descriptor) => {
+    const handler = resolveHandler(target, propertyKey, descriptor);
+    registerRoute(handler, method, path);
+  };
+}
+function createParameterDecorator(type, options) {
+  return (target, propertyKey, parameterIndex) => {
+    const handler = resolveHandler(target, propertyKey);
+    registerParameter(handler, {
+      index: parameterIndex,
+      type,
+      schema: options?.schema,
+      name: options?.name
+    });
+  };
+}
+var Get = createRouteDecorator("GET");
+var Post = createRouteDecorator("POST");
+var Put = createRouteDecorator("PUT");
+var Patch = createRouteDecorator("PATCH");
+var Delete = createRouteDecorator("DELETE");
+var Head = createRouteDecorator("HEAD");
+var Options = createRouteDecorator("OPTIONS");
+function FirebaseAuth(options) {
+  return (target, propertyKey, descriptor) => {
+    const handler = resolveHandler(target, propertyKey, descriptor);
+    registerFirebaseAuth(handler, options);
+  };
+}
+function Auth() {
+  return createParameterDecorator("auth");
+}
+function Body(schema) {
+  return createParameterDecorator("body", { schema });
+}
+function Query(name) {
+  return createParameterDecorator("query", { name });
+}
+function Param(name) {
+  return createParameterDecorator("param", { name });
+}
+function Headers() {
+  return createParameterDecorator("headers");
+}
+function Header(name) {
+  return createParameterDecorator("header", { name });
+}
+function Req() {
+  return createParameterDecorator("req");
+}
+function Res() {
+  return createParameterDecorator("res");
+}
+
+export {
+  HttpError,
+  json,
+  text,
+  noContent,
+  createHandler,
+  handleError,
+  Get,
+  Post,
+  Put,
+  Patch,
+  Delete,
+  Head,
+  Options,
+  FirebaseAuth,
+  Auth,
+  Body,
+  Query,
+  Param,
+  Headers,
+  Header,
+  Req,
+  Res
+};

package/dist/chunk-YMGEGOSD.js

@@ -0,0 +1,117 @@
+// src/core/registry.ts
+var routeMeta = /* @__PURE__ */ new Map();
+var parameterMeta = /* @__PURE__ */ new Map();
+var eventMeta = /* @__PURE__ */ new Map();
+var options = {
+  inferPathFromName: false
+};
+function configureRoutes(next) {
+  options = {
+    ...options,
+    ...next
+  };
+}
+function registerRoute(target, method, explicitPath) {
+  const handler = target;
+  const pathInput = explicitPath ?? inferPath(handler);
+  const path = pathInput?.startsWith("/") ? pathInput : pathInput ? `/${pathInput}` : void 0;
+  if (!path) {
+    const name = handler.name || "<anonymous>";
+    throw new Error(`Route for "${name}" is missing a path. Provide one or enable name inference.`);
+  }
+  const current = routeMeta.get(handler) ?? {};
+  routeMeta.set(handler, {
+    ...current,
+    method,
+    path
+  });
+}
+function registerFirebaseAuth(target, cfg) {
+  const handler = target;
+  const current = routeMeta.get(handler) ?? {};
+  routeMeta.set(handler, {
+    ...current,
+    auth: {
+      type: "firebase",
+      ...cfg
+    }
+  });
+}
+function registerParameter(target, meta) {
+  const handler = target;
+  const list = parameterMeta.get(handler) ?? [];
+  list.push(meta);
+  list.sort((a, b) => a.index - b.index);
+  parameterMeta.set(handler, list);
+}
+function registerEvent(target, event) {
+  const handler = target;
+  const list = eventMeta.get(handler) ?? [];
+  list.push({ event });
+  eventMeta.set(handler, list);
+}
+function getRegisteredRoutes() {
+  const routes = [];
+  for (const [handler, meta] of routeMeta.entries()) {
+    if (!meta.method || !meta.path) {
+      const name = handler.name || "<anonymous>";
+      throw new Error(`Route for "${name}" is incomplete. Ensure it has an HTTP method decorator.`);
+    }
+    routes.push({
+      handler,
+      method: meta.method,
+      path: meta.path,
+      auth: meta.auth,
+      parameters: [...parameterMeta.get(handler) ?? []]
+    });
+  }
+  return routes;
+}
+function getRegisteredEvents() {
+  const events = [];
+  for (const [handler, list] of eventMeta.entries()) {
+    for (const entry of list) {
+      events.push({
+        handler,
+        event: entry.event
+      });
+    }
+  }
+  return events;
+}
+function inferPath(handler) {
+  if (!options.inferPathFromName) {
+    return void 0;
+  }
+  const name = handler.name;
+  if (!name) {
+    return void 0;
+  }
+  const slug = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+  return slug ? `/${slug}` : void 0;
+}
+
+// src/core/handler.ts
+function resolveHandler(target, propertyKey, descriptor) {
+  if (descriptor?.value && typeof descriptor.value === "function") {
+    return descriptor.value;
+  }
+  if (typeof target === "function" && propertyKey === void 0) {
+    return target;
+  }
+  if (target && propertyKey && typeof target[propertyKey] === "function") {
+    return target[propertyKey];
+  }
+  throw new Error("Unable to determine decorated function. Ensure decorators are applied to functions.");
+}
+
+export {
+  configureRoutes,
+  registerRoute,
+  registerFirebaseAuth,
+  registerParameter,
+  registerEvent,
+  getRegisteredRoutes,
+  getRegisteredEvents,
+  resolveHandler
+};