sst-http 1.3.0 → 1.3.3-beta.2

package/dist/index.js

@@ -1,520 +1,35 @@
 import {
-  normalizeRouterPath
-} from "./chunk-5MOJ3SW6.js";
-
-// src/registry.ts
-var routeMeta = /* @__PURE__ */ new Map();
-var parameterMeta = /* @__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 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 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/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/runtime.ts
-var HTTP_ERROR_MARKER = Symbol.for("sst-http.HttpError");
-var HttpError = class extends Error {
-  statusCode;
-  headers;
-  details;
-  constructor(statusCode, message, options2) {
-    super(message);
-    this.name = "HttpError";
-    Object.defineProperty(this, HTTP_ERROR_MARKER, { value: true });
-    this.statusCode = statusCode;
-    this.headers = options2?.headers;
-    this.details = options2?.details;
-    if ("cause" in (options2 ?? {})) {
-      this.cause = options2?.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);
-  return async (event, lambdaContext) => {
-    const method = extractMethod(event);
-    const path = extractPath(event);
-    const preferV2 = isHttpApiEvent(event);
-    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(event.headers ?? {});
-    const query = extractQuery(event);
-    let bodyValue = void 0;
-    let bodyParsed = false;
-    const requiresJson = entry.parameters.some((p) => p.type === "body");
-    const ensureBody = () => {
-      if (!bodyParsed) {
-        bodyValue = parseBody(event, headers, requiresJson);
-        bodyParsed = true;
-      }
-      return bodyValue;
-    };
-    const ctxResponse = {
-      json,
-      text,
-      noContent
-    };
-    const ctx = {
-      event,
-      lambdaContext,
-      params,
-      query,
-      body: void 0,
-      headers,
-      auth: extractAuthClaims(event, entry),
-      response: ctxResponse
-    };
-    const getBody = (schema) => {
-      const current = ensureBody();
-      if (schema && typeof schema.parse === "function") {
-        try {
-          bodyValue = schema.parse(current);
-        } catch (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 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/decorators.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.");
-}
-function createRouteDecorator(method) {
-  return (path) => (target, propertyKey, descriptor) => {
-    const handler = resolveHandler(target, propertyKey, descriptor);
-    registerRoute(handler, method, path);
-  };
-}
-function createParameterDecorator(type, options2) {
-  return (target, propertyKey, parameterIndex) => {
-    const handler = resolveHandler(target, propertyKey);
-    registerParameter(handler, {
-      index: parameterIndex,
-      type,
-      schema: options2?.schema,
-      name: options2?.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(options2) {
-  return (target, propertyKey, descriptor) => {
-    const handler = resolveHandler(target, propertyKey, descriptor);
-    registerFirebaseAuth(handler, options2);
-  };
-}
-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");
-}
+  On,
+  publish
+} from "./chunk-LLR3DQ65.js";
+import {
+  Auth,
+  Body,
+  Delete,
+  FirebaseAuth,
+  Get,
+  Head,
+  Header,
+  Headers,
+  HttpError,
+  Options,
+  Param,
+  Patch,
+  Post,
+  Put,
+  Query,
+  Req,
+  Res,
+  createHandler,
+  handleError,
+  json,
+  noContent,
+  text
+} from "./chunk-SENBWWVV.js";
+import "./chunk-5OUNKYO5.js";
+import {
+  configureRoutes
+} from "./chunk-YMGEGOSD.js";
 export {
   Auth,
   Body,
@@ -525,6 +40,7 @@ export {
   Header,
   Headers,
   HttpError,
+  On,
   Options,
   Param,
   Patch,
@@ -538,5 +54,6 @@ export {
   handleError,
   json,
   noContent,
+  publish,
   text
 };