sst-http 1.3.0 → 1.3.3-beta.2

package/dist/http/index.d.ts

@@ -0,0 +1,51 @@
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyResultV2 } from 'aws-lambda';
+import { R as ResponseLike, F as FirebaseAuthOptions, e as RouteOptions } from '../types-w1A7o_rd.js';
+export { c as FirebaseAuthMetadata, d as FirebaseClaims, H as Handler, a as HandlerContext, b as HttpMethod } from '../types-w1A7o_rd.js';
+import { ZodTypeAny } from 'zod/v4';
+import { L as LegacyDecorator, a as LegacyParameterDecorator } from '../handler-DaM4Racx.js';
+
+declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly headers?: Record<string, string>;
+    readonly details?: unknown;
+    constructor(statusCode: number, message: string, options?: {
+        cause?: unknown;
+        headers?: Record<string, string>;
+        details?: unknown;
+    });
+}
+declare function json(status: number, data: unknown, headers?: Record<string, string>): ResponseLike;
+declare function text(status: number, body: string, headers?: Record<string, string>): ResponseLike;
+declare function noContent(headers?: Record<string, string>): ResponseLike;
+type EventBridgeEvent = {
+    "detail-type"?: string;
+    detailType?: string;
+    detail?: unknown;
+    eventBusName?: string;
+};
+type HttpLambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
+type LambdaEvent = HttpLambdaEvent | EventBridgeEvent;
+type LambdaResult = APIGatewayProxyResult | APIGatewayProxyResultV2;
+declare function createHandler(): (event: LambdaEvent, lambdaContext: unknown) => Promise<LambdaResult>;
+declare function handleError(error: unknown, preferV2: boolean): LambdaResult;
+
+declare const Get: (path?: string) => LegacyDecorator;
+declare const Post: (path?: string) => LegacyDecorator;
+declare const Put: (path?: string) => LegacyDecorator;
+declare const Patch: (path?: string) => LegacyDecorator;
+declare const Delete: (path?: string) => LegacyDecorator;
+declare const Head: (path?: string) => LegacyDecorator;
+declare const Options: (path?: string) => LegacyDecorator;
+declare function FirebaseAuth(options?: FirebaseAuthOptions): LegacyDecorator;
+declare function Auth(): LegacyParameterDecorator;
+declare function Body(schema?: ZodTypeAny): LegacyParameterDecorator;
+declare function Query(name?: string): LegacyParameterDecorator;
+declare function Param(name?: string): LegacyParameterDecorator;
+declare function Headers(): LegacyParameterDecorator;
+declare function Header(name: string): LegacyParameterDecorator;
+declare function Req(): LegacyParameterDecorator;
+declare function Res(): LegacyParameterDecorator;
+
+declare function configureRoutes(next?: RouteOptions): void;
+
+export { Auth, Body, Delete, FirebaseAuth, FirebaseAuthOptions, Get, Head, Header, Headers, HttpError, Options, Param, Patch, Post, Put, Query, Req, Res, ResponseLike, RouteOptions, configureRoutes, createHandler, handleError, json, noContent, text };

package/dist/http/index.js

@@ -0,0 +1,53 @@
+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,
+  Delete,
+  FirebaseAuth,
+  Get,
+  Head,
+  Header,
+  Headers,
+  HttpError,
+  Options,
+  Param,
+  Patch,
+  Post,
+  Put,
+  Query,
+  Req,
+  Res,
+  configureRoutes,
+  createHandler,
+  handleError,
+  json,
+  noContent,
+  text
+};

package/dist/index.cjs

@@ -29,6 +29,7 @@ __export(index_exports, {
   Header: () => Header,
   Headers: () => Headers,
   HttpError: () => HttpError,
+  On: () => On,
   Options: () => Options,
   Param: () => Param,
   Patch: () => Patch,
@@ -42,13 +43,15 @@ __export(index_exports, {
   handleError: () => handleError,
   json: () => json,
   noContent: () => noContent,
+  publish: () => publish,
   text: () => text
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/registry.ts
+// src/core/registry.ts
 var routeMeta = /* @__PURE__ */ new Map();
 var parameterMeta = /* @__PURE__ */ new Map();
+var eventMeta = /* @__PURE__ */ new Map();
 var options = {
   inferPathFromName: false
 };
@@ -91,6 +94,12 @@ function registerParameter(target, 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()) {
@@ -108,6 +117,18 @@ function getRegisteredRoutes() {
   }
   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;
@@ -120,15 +141,15 @@ function inferPath(handler) {
   return slug ? `/${slug}` : void 0;
 }
 
-// src/router.ts
+// src/http/router.ts
 var import_path_to_regexp = require("path-to-regexp");
 
-// src/paths.ts
+// src/http/paths.ts
 function normalizeRouterPath(path) {
   return path.replace(/\{([^/{}]+)\}/g, ":$1");
 }
 
-// src/router.ts
+// src/http/router.ts
 var Router = class {
   routes;
   constructor(entries) {
@@ -170,7 +191,7 @@ function normalizeParams(params) {
   return normalized;
 }
 
-// src/runtime.ts
+// src/http/runtime.ts
 var HTTP_ERROR_MARKER = Symbol.for("sst-http.HttpError");
 var HttpError = class extends Error {
   statusCode;
@@ -218,10 +239,19 @@ function noContent(headers = {}) {
 function createHandler() {
   const routes = getRegisteredRoutes();
   const router = new Router(routes);
+  const eventHandlers = getRegisteredEvents();
   return async (event, lambdaContext) => {
-    const method = extractMethod(event);
-    const path = extractPath(event);
-    const preferV2 = isHttpApiEvent(event);
+    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);
     }
@@ -243,14 +273,14 @@ function createHandler() {
       }, preferV2);
     }
     const { entry, params } = match2;
-    const headers = normalizeHeaders(event.headers ?? {});
-    const query = extractQuery(event);
+    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(event, headers, requiresJson);
+        bodyValue = parseBody(httpEvent, headers, requiresJson);
         bodyParsed = true;
       }
       return bodyValue;
@@ -261,13 +291,13 @@ function createHandler() {
       noContent
     };
     const ctx = {
-      event,
+      event: httpEvent,
       lambdaContext,
       params,
       query,
       body: void 0,
       headers,
-      auth: extractAuthClaims(event, entry),
+      auth: extractAuthClaims(httpEvent, entry),
       response: ctxResponse
     };
     const getBody = (schema) => {
@@ -276,6 +306,7 @@ function createHandler() {
         try {
           bodyValue = schema.parse(current);
         } catch (error) {
+          console.error("[ERROR] Body validation failed", error);
           throw new HttpError(400, "Body validation failed", { cause: error });
         }
       }
@@ -295,6 +326,31 @@ function createHandler() {
     }
   };
 }
+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);
@@ -499,7 +555,7 @@ function isSupportedMethod(value) {
   return SUPPORTED_METHODS.has(value);
 }
 
-// src/decorators.ts
+// src/core/handler.ts
 function resolveHandler(target, propertyKey, descriptor) {
   if (descriptor?.value && typeof descriptor.value === "function") {
     return descriptor.value;
@@ -512,6 +568,8 @@ function resolveHandler(target, propertyKey, descriptor) {
   }
   throw new Error("Unable to determine decorated function. Ensure decorators are applied to functions.");
 }
+
+// src/http/decorators.ts
 function createRouteDecorator(method) {
   return (path) => (target, propertyKey, descriptor) => {
     const handler = resolveHandler(target, propertyKey, descriptor);
@@ -566,6 +624,137 @@ function Req() {
 function Res() {
   return createParameterDecorator("res");
 }
+
+// src/bus/decorators.ts
+function On(event) {
+  return (target, propertyKey, descriptor) => {
+    if (!event) {
+      throw new Error("@On() requires an event name.");
+    }
+    const handler = resolveHandler(target, propertyKey, descriptor);
+    registerEvent(handler, event);
+  };
+}
+
+// src/bus/event-bus.ts
+var import_node_crypto = require("crypto");
+var AWS_TARGET = "AWSEvents.PutEvents";
+var AWS_SERVICE = "events";
+var DEFAULT_SOURCE = "sst-http";
+async function publish(event, message) {
+  if (!event) {
+    throw new Error("publish() requires an event name.");
+  }
+  const payload = {
+    Entries: [
+      {
+        EventBusName: "default",
+        Source: DEFAULT_SOURCE,
+        DetailType: event,
+        Detail: JSON.stringify(message ?? null)
+      }
+    ]
+  };
+  console.log(payload);
+  await putEventsViaFetch(payload);
+}
+async function putEventsViaFetch(payload) {
+  const region = resolveRegion();
+  const creds = resolveCredentials();
+  const host = `events.${region}.amazonaws.com`;
+  const url = `https://${host}/`;
+  const body = JSON.stringify(payload);
+  const amzDate = toAmzDate(/* @__PURE__ */ new Date());
+  const dateStamp = amzDate.slice(0, 8);
+  const headers = {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-date": amzDate,
+    "x-amz-target": AWS_TARGET,
+    host
+  };
+  if (creds.sessionToken) {
+    headers["x-amz-security-token"] = creds.sessionToken;
+  }
+  const signedHeaders = getSignedHeaders(headers);
+  const canonicalRequest = [
+    "POST",
+    "/",
+    "",
+    canonicalizeHeaders(headers),
+    signedHeaders,
+    sha256(body)
+  ].join("\n");
+  const scope = `${dateStamp}/${region}/${AWS_SERVICE}/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    scope,
+    sha256(canonicalRequest)
+  ].join("\n");
+  const signingKey = getSigningKey(creds.secretAccessKey, dateStamp, region, AWS_SERVICE);
+  const signature = hmac(signingKey, stringToSign);
+  const authorization = `AWS4-HMAC-SHA256 Credential=${creds.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      ...headers,
+      Authorization: authorization
+    },
+    body
+  });
+  if (!response.ok) {
+    const text2 = await response.text();
+    throw new Error(`EventBridge PutEvents failed: ${response.status} ${text2}`);
+  }
+}
+function resolveRegion() {
+  const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
+  if (!region) {
+    throw new Error("AWS region is not set");
+  }
+  return region;
+}
+function resolveCredentials() {
+  const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+  const sessionToken = process.env.AWS_SESSION_TOKEN;
+  if (!accessKeyId || !secretAccessKey) {
+    throw new Error("AWS credentials are not set");
+  }
+  return { accessKeyId, secretAccessKey, sessionToken };
+}
+function toAmzDate(date) {
+  const pad = (value) => value.toString().padStart(2, "0");
+  return [
+    date.getUTCFullYear(),
+    pad(date.getUTCMonth() + 1),
+    pad(date.getUTCDate()),
+    "T",
+    pad(date.getUTCHours()),
+    pad(date.getUTCMinutes()),
+    pad(date.getUTCSeconds()),
+    "Z"
+  ].join("");
+}
+function sha256(value) {
+  return (0, import_node_crypto.createHash)("sha256").update(value, "utf8").digest("hex");
+}
+function hmac(key, value) {
+  return (0, import_node_crypto.createHmac)("sha256", key).update(value, "utf8").digest("hex");
+}
+function getSigningKey(secret, date, region, service) {
+  const kDate = (0, import_node_crypto.createHmac)("sha256", `AWS4${secret}`).update(date, "utf8").digest();
+  const kRegion = (0, import_node_crypto.createHmac)("sha256", kDate).update(region, "utf8").digest();
+  const kService = (0, import_node_crypto.createHmac)("sha256", kRegion).update(service, "utf8").digest();
+  return (0, import_node_crypto.createHmac)("sha256", kService).update("aws4_request", "utf8").digest();
+}
+function canonicalizeHeaders(headers) {
+  return Object.keys(headers).map((key) => key.toLowerCase()).sort().map((key) => `${key}:${headers[key].trim()}
+`).join("");
+}
+function getSignedHeaders(headers) {
+  return Object.keys(headers).map((key) => key.toLowerCase()).sort().join(";");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Auth,
@@ -577,6 +766,7 @@ function Res() {
   Header,
   Headers,
   HttpError,
+  On,
   Options,
   Param,
   Patch,
@@ -590,5 +780,6 @@ function Res() {
   handleError,
   json,
   noContent,
+  publish,
   text
 });

package/dist/index.d.cts

@@ -1,45 +1,6 @@
-import { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyResultV2 } from 'aws-lambda';
-import { c as ResponseLike, F as FirebaseAuthOptions, d as RouteOptions } from './types-BF3w-wTx.cjs';
-export { g as FirebaseAuthMetadata, h as FirebaseClaims, e as Handler, f as HandlerContext, H as HttpMethod } from './types-BF3w-wTx.cjs';
-import { ZodTypeAny } from 'zod/v4';
-
-declare class HttpError extends Error {
-    readonly statusCode: number;
-    readonly headers?: Record<string, string>;
-    readonly details?: unknown;
-    constructor(statusCode: number, message: string, options?: {
-        cause?: unknown;
-        headers?: Record<string, string>;
-        details?: unknown;
-    });
-}
-declare function json(status: number, data: unknown, headers?: Record<string, string>): ResponseLike;
-declare function text(status: number, body: string, headers?: Record<string, string>): ResponseLike;
-declare function noContent(headers?: Record<string, string>): ResponseLike;
-type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
-type LambdaResult = APIGatewayProxyResult | APIGatewayProxyResultV2;
-declare function createHandler(): (event: LambdaEvent, lambdaContext: unknown) => Promise<LambdaResult>;
-declare function handleError(error: unknown, preferV2: boolean): LambdaResult;
-
-type LegacyDecorator = (target: unknown, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;
-type LegacyParameterDecorator = (target: unknown, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-declare const Get: (path?: string) => LegacyDecorator;
-declare const Post: (path?: string) => LegacyDecorator;
-declare const Put: (path?: string) => LegacyDecorator;
-declare const Patch: (path?: string) => LegacyDecorator;
-declare const Delete: (path?: string) => LegacyDecorator;
-declare const Head: (path?: string) => LegacyDecorator;
-declare const Options: (path?: string) => LegacyDecorator;
-declare function FirebaseAuth(options?: FirebaseAuthOptions): LegacyDecorator;
-declare function Auth(): LegacyParameterDecorator;
-declare function Body(schema?: ZodTypeAny): LegacyParameterDecorator;
-declare function Query(name?: string): LegacyParameterDecorator;
-declare function Param(name?: string): LegacyParameterDecorator;
-declare function Headers(): LegacyParameterDecorator;
-declare function Header(name: string): LegacyParameterDecorator;
-declare function Req(): LegacyParameterDecorator;
-declare function Res(): LegacyParameterDecorator;
-
-declare function configureRoutes(next?: RouteOptions): void;
-
-export { Auth, Body, Delete, FirebaseAuth, FirebaseAuthOptions, Get, Head, Header, Headers, HttpError, Options, Param, Patch, Post, Put, Query, Req, Res, ResponseLike, RouteOptions, configureRoutes, createHandler, handleError, json, noContent, text };
+export { Auth, Body, Delete, FirebaseAuth, Get, Head, Header, Headers, HttpError, Options, Param, Patch, Post, Put, Query, Req, Res, configureRoutes, createHandler, handleError, json, noContent, text } from './http/index.cjs';
+export { c as FirebaseAuthMetadata, F as FirebaseAuthOptions, d as FirebaseClaims, H as Handler, a as HandlerContext, b as HttpMethod, R as ResponseLike, e as RouteOptions } from './types-w1A7o_rd.cjs';
+export { On, publish } from './bus/index.cjs';
+import 'aws-lambda';
+import 'zod/v4';
+import './handler-DaM4Racx.cjs';

package/dist/index.d.ts

@@ -1,45 +1,6 @@
-import { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyResultV2 } from 'aws-lambda';
-import { c as ResponseLike, F as FirebaseAuthOptions, d as RouteOptions } from './types-BF3w-wTx.js';
-export { g as FirebaseAuthMetadata, h as FirebaseClaims, e as Handler, f as HandlerContext, H as HttpMethod } from './types-BF3w-wTx.js';
-import { ZodTypeAny } from 'zod/v4';
-
-declare class HttpError extends Error {
-    readonly statusCode: number;
-    readonly headers?: Record<string, string>;
-    readonly details?: unknown;
-    constructor(statusCode: number, message: string, options?: {
-        cause?: unknown;
-        headers?: Record<string, string>;
-        details?: unknown;
-    });
-}
-declare function json(status: number, data: unknown, headers?: Record<string, string>): ResponseLike;
-declare function text(status: number, body: string, headers?: Record<string, string>): ResponseLike;
-declare function noContent(headers?: Record<string, string>): ResponseLike;
-type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
-type LambdaResult = APIGatewayProxyResult | APIGatewayProxyResultV2;
-declare function createHandler(): (event: LambdaEvent, lambdaContext: unknown) => Promise<LambdaResult>;
-declare function handleError(error: unknown, preferV2: boolean): LambdaResult;
-
-type LegacyDecorator = (target: unknown, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;
-type LegacyParameterDecorator = (target: unknown, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
-declare const Get: (path?: string) => LegacyDecorator;
-declare const Post: (path?: string) => LegacyDecorator;
-declare const Put: (path?: string) => LegacyDecorator;
-declare const Patch: (path?: string) => LegacyDecorator;
-declare const Delete: (path?: string) => LegacyDecorator;
-declare const Head: (path?: string) => LegacyDecorator;
-declare const Options: (path?: string) => LegacyDecorator;
-declare function FirebaseAuth(options?: FirebaseAuthOptions): LegacyDecorator;
-declare function Auth(): LegacyParameterDecorator;
-declare function Body(schema?: ZodTypeAny): LegacyParameterDecorator;
-declare function Query(name?: string): LegacyParameterDecorator;
-declare function Param(name?: string): LegacyParameterDecorator;
-declare function Headers(): LegacyParameterDecorator;
-declare function Header(name: string): LegacyParameterDecorator;
-declare function Req(): LegacyParameterDecorator;
-declare function Res(): LegacyParameterDecorator;
-
-declare function configureRoutes(next?: RouteOptions): void;
-
-export { Auth, Body, Delete, FirebaseAuth, FirebaseAuthOptions, Get, Head, Header, Headers, HttpError, Options, Param, Patch, Post, Put, Query, Req, Res, ResponseLike, RouteOptions, configureRoutes, createHandler, handleError, json, noContent, text };
+export { Auth, Body, Delete, FirebaseAuth, Get, Head, Header, Headers, HttpError, Options, Param, Patch, Post, Put, Query, Req, Res, configureRoutes, createHandler, handleError, json, noContent, text } from './http/index.js';
+export { c as FirebaseAuthMetadata, F as FirebaseAuthOptions, d as FirebaseClaims, H as Handler, a as HandlerContext, b as HttpMethod, R as ResponseLike, e as RouteOptions } from './types-w1A7o_rd.js';
+export { On, publish } from './bus/index.js';
+import 'aws-lambda';
+import 'zod/v4';
+import './handler-DaM4Racx.js';