sst-http 1.3.2 → 1.3.3-beta.2

package/dist/infra.js

@@ -1,15 +1,37 @@
 import {
   normalizeApiGatewayPath
-} from "./chunk-5MOJ3SW6.js";
+} from "./chunk-5OUNKYO5.js";
 
 // src/infra.ts
 import { readFileSync } from "fs";
 import { resolve } from "path";
-function ensureSstAws(source) {
-  if (source?.sst?.aws) {
-    return source.sst.aws;
+
+// src/core/infra.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function getFunction(value, key) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const candidate = value[key];
+  return typeof candidate === "function" ? candidate : void 0;
+}
+function getStringProp(value, key) {
+  if (!isRecord(value)) {
+    return void 0;
   }
-  const aws = globalThis.sst?.aws;
+  const candidate = value[key];
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
+function ensureRecord(value, message) {
+  if (!isRecord(value)) {
+    throw new Error(message);
+  }
+  return value;
+}
+function ensureSstAws(source) {
+  const aws = typeof sst !== "undefined" ? sst.aws : source?.sst?.aws ?? globalThis.sst?.aws;
   if (!aws) {
     throw new Error(
       "SST aws namespace is not available. Ensure this code runs within an SST config."
@@ -17,32 +39,127 @@ function ensureSstAws(source) {
   }
   return aws;
 }
-function wireApiFromManifest(manifest, opts) {
-  if (!manifest || !Array.isArray(manifest.routes)) {
-    throw new Error("Invalid routes manifest");
+function resolveHandlerInput(handler) {
+  if (handler === void 0) {
+    return void 0;
   }
-  const firebaseRoutes = manifest.routes.filter((route) => route.auth.type === "firebase");
-  let firebaseAuthorizerRef;
-  if (firebaseRoutes.length > 0) {
-    if (!opts.firebaseProjectId) {
-      throw new Error("firebaseProjectId is required when using @FirebaseAuth()");
+  if (typeof handler === "string") {
+    return handler;
+  }
+  if (!isRecord(handler)) {
+    throw new Error("Unsupported handler type: provide a handler string, FunctionArgs, or a Function ARN/output");
+  }
+  if ("arn" in handler) {
+    return handler.arn;
+  }
+  if (typeof handler.handler === "string") {
+    return handler;
+  }
+  throw new Error("Unsupported handler type: provide a handler string, FunctionArgs, or a Function ARN/output");
+}
+
+// src/bus/infra.ts
+var MAX_SUBSCRIBER_NAME_LENGTH = 60;
+function createBus() {
+  const aws = ensureSstAws();
+  return new aws.Bus("default");
+}
+function getBus() {
+  const aws = ensureSstAws();
+  return aws.Bus.get("default", "default");
+}
+function wireEventsFromManifest(events, opts) {
+  if (!events || events.length === 0) {
+    return;
+  }
+  const aws = ensureSstAws(opts.source);
+  const busMap = normalizeBusInput(opts.buses);
+  const subscriber = resolveHandlerInput(opts.handler);
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    const key = `default:${event.event}`;
+    if (seen.has(key)) {
+      continue;
     }
-    const issuer = `https://securetoken.google.com/${opts.firebaseProjectId}`;
-    firebaseAuthorizerRef = opts.ensureJwtAuthorizer("firebase", {
-      issuer,
-      audiences: [opts.firebaseProjectId]
-    });
+    seen.add(key);
+    const bus = resolveBusForEvent(busMap, aws);
+    const subscriberName = buildSubscriberName(event.event);
+    subscribeToBus(bus, subscriberName, subscriber, event.event);
+  }
+}
+function normalizeBusInput(input) {
+  if (!input) {
+    return void 0;
   }
+  const map = /* @__PURE__ */ new Map();
+  if (Array.isArray(input)) {
+    for (const bus of input) {
+      const key2 = getBusKey(bus);
+      if (key2) {
+        map.set(key2, bus);
+      }
+    }
+    if (map.size === 1 && !map.has("default")) {
+      const [bus] = map.values();
+      map.set("default", bus);
+    }
+    return map;
+  }
+  if (isBusRecord(input)) {
+    for (const [key2, bus] of Object.entries(input)) {
+      map.set(key2, bus);
+    }
+    return map;
+  }
+  const key = getBusKey(input) ?? "default";
+  map.set(key, input);
+  return map;
+}
+function isBusRecord(input) {
+  return !Array.isArray(input) && isRecord(input) && !("subscribe" in input);
+}
+function getBusKey(bus) {
+  return getStringProp(bus, "name") ?? getStringProp(bus, "constructorName");
+}
+function resolveBusForEvent(busMap, aws) {
+  if (busMap && busMap.size > 0) {
+    const direct = busMap.get("default");
+    if (direct) {
+      return direct;
+    }
+    if (busMap.size === 1) {
+      return busMap.values().next().value;
+    }
+  }
+  return aws.Bus.get("default", "default");
+}
+function subscribeToBus(bus, subscriberName, subscriber, eventName) {
+  if (typeof bus.subscribe !== "function") {
+    throw new Error("Bus instance does not support subscribe().");
+  }
+  bus.subscribe(subscriberName, subscriber, {
+    pattern: {
+      detailType: [eventName]
+    }
+  });
+}
+function buildSubscriberName(eventName) {
+  const base = `default-${eventName}`.replace(/[^a-zA-Z0-9]/g, "");
+  if (base.length === 0) {
+    return "Event";
+  }
+  return base.length > MAX_SUBSCRIBER_NAME_LENGTH ? base.slice(0, MAX_SUBSCRIBER_NAME_LENGTH) : base;
+}
+
+// src/http/infra.ts
+function wireRoutesFromManifest(manifest, opts) {
+  const firebaseRoutes = manifest.routes.filter((route) => route.auth.type === "firebase");
+  const firebaseAuthorizerRef = ensureFirebaseAuthorizer(firebaseRoutes.length, opts);
   for (const route of manifest.routes) {
     const isProtected = route.auth.type === "firebase";
     const rawPath = route.path.startsWith("/") ? route.path : `/${route.path}`;
     const path = normalizeApiGatewayPath(rawPath);
-    const authConfig = isProtected && route.auth.type === "firebase" ? {
-      name: "firebase",
-      optional: route.auth.optional,
-      roles: route.auth.roles,
-      ref: firebaseAuthorizerRef
-    } : void 0;
+    const authConfig = buildAuthorizerConfig(route, firebaseAuthorizerRef);
     opts.registerRoute(route.method, path, {
       handler: opts.handler,
       protected: isProtected,
@@ -50,33 +167,74 @@ function wireApiFromManifest(manifest, opts) {
     });
   }
 }
-function loadRoutesManifest(filePath) {
-  const resolved = resolve(filePath);
-  const contents = readFileSync(resolved, "utf8");
-  const manifest = JSON.parse(contents);
-  if (!manifest || !Array.isArray(manifest.routes)) {
-    throw new Error(`Invalid routes manifest at ${resolved}`);
-  }
-  return manifest;
-}
 function httpApiAdapter(args) {
   const aws = args?.api ? void 0 : ensureSstAws(args);
   const api = args?.api ?? new aws.ApiGatewayV2(args?.apiName ?? "HttpApi", args?.apiArgs);
+  const ensureJwtAuthorizer = createHttpAuthorizerManager(api);
+  const registerRoute = createRouteRegistrar(api, "ApiGatewayV2");
+  return {
+    api,
+    registerRoute,
+    ensureJwtAuthorizer
+  };
+}
+function restApiAdapter(args) {
+  const aws = args?.api ? void 0 : ensureSstAws(args);
+  const api = args?.api ?? new aws.ApiGateway(args?.apiName ?? "RestApi", args?.apiArgs);
+  const ensureJwtAuthorizer = createRestAuthorizerManager(api);
+  const registerRoute = createRouteRegistrar(api, "ApiGateway");
+  return {
+    api,
+    registerRoute,
+    ensureJwtAuthorizer
+  };
+}
+function ensureFirebaseAuthorizer(firebaseRouteCount, opts) {
+  if (firebaseRouteCount === 0) {
+    return void 0;
+  }
+  if (!opts.firebaseProjectId) {
+    throw new Error("firebaseProjectId is required when using @FirebaseAuth()");
+  }
+  const issuer = `https://securetoken.google.com/${opts.firebaseProjectId}`;
+  return opts.ensureJwtAuthorizer("firebase", {
+    issuer,
+    audiences: [opts.firebaseProjectId]
+  });
+}
+function buildAuthorizerConfig(route, firebaseAuthorizerRef) {
+  if (route.auth.type !== "firebase") {
+    return void 0;
+  }
+  return {
+    name: "firebase",
+    optional: route.auth.optional,
+    roles: route.auth.roles,
+    ref: firebaseAuthorizerRef
+  };
+}
+function createHttpAuthorizerManager(api) {
   const authorizers = /* @__PURE__ */ new Map();
-  const ensureJwtAuthorizer = (name, cfg) => {
+  return (name, cfg) => {
     if (authorizers.has(name)) {
       return authorizers.get(name);
     }
-    const apiAny = api;
+    const addAuthorizer = getFunction(api, "addAuthorizer");
+    const addAuthorizers = getFunction(api, "addAuthorizers");
+    const authorizer = getFunction(api, "authorizer");
     let ref = void 0;
-    if (typeof apiAny["addAuthorizer"] === "function") {
-      const created = apiAny.addAuthorizer({
+    if (addAuthorizer) {
+      const created = addAuthorizer.call(api, {
         name,
         jwt: { issuer: cfg.issuer, audiences: cfg.audiences }
       });
-      ref = created.id;
-    } else if (typeof apiAny.addAuthorizers === "function") {
-      apiAny.addAuthorizers({
+      if (isRecord(created) && "id" in created) {
+        ref = created.id ?? created;
+      } else {
+        ref = created;
+      }
+    } else if (addAuthorizers) {
+      addAuthorizers.call(api, {
         [name]: {
           type: "jwt",
           jwt: {
@@ -86,8 +244,8 @@ function httpApiAdapter(args) {
         }
       });
       ref = name;
-    } else if (typeof apiAny.authorizer === "function") {
-      ref = apiAny.authorizer(name, {
+    } else if (authorizer) {
+      ref = authorizer.call(api, name, {
         type: "jwt",
         jwt: {
           issuer: cfg.issuer,
@@ -100,58 +258,13 @@ function httpApiAdapter(args) {
     authorizers.set(name, ref);
     return ref;
   };
-  const registerRoute = (method, path, config) => {
-    const apiAny = api;
-    const normalizedPath = normalizeApiGatewayPath(path);
-    const routeKey = `${method} ${normalizedPath}`;
-    const asAny = config.handler;
-    const handlerInput = typeof asAny === "string" ? asAny : asAny && typeof asAny.arn !== "undefined" ? asAny.arn : asAny && typeof asAny.handler === "string" ? asAny.handler : asAny === void 0 ? void 0 : (() => {
-      throw new Error("Unsupported handler type: provide a handler string, FunctionArgs, or a Function ARN/output");
-    })();
-    const args2 = {};
-    if (config.protected && config.authorizer) {
-      args2.auth = {
-        jwt: {
-          authorizer: config.authorizer.ref ?? config.authorizer.name,
-          scopes: config.authorizer.roles
-        }
-      };
-    }
-    if (typeof apiAny.route === "function") {
-      apiAny.route(routeKey, handlerInput, args2);
-      return;
-    }
-    if (typeof apiAny.addRoutes === "function") {
-      apiAny.addRoutes({
-        [routeKey]: {
-          handler: handlerInput,
-          ...args2
-        }
-      });
-      return;
-    }
-    if (typeof apiAny.addRoute === "function") {
-      apiAny.addRoute(routeKey, { handler: handlerInput, ...args2 });
-      return;
-    }
-    throw new Error("Unsupported ApiGatewayV2 instance: expected route() or addRoutes() method.");
-  };
-  return {
-    api,
-    registerRoute,
-    ensureJwtAuthorizer
-  };
 }
-function restApiAdapter(args) {
-  const aws = args?.api ? void 0 : ensureSstAws(args);
-  const api = args?.api ?? new aws.ApiGateway(args?.apiName ?? "RestApi", args?.apiArgs);
+function createRestAuthorizerManager(api) {
   const authorizers = /* @__PURE__ */ new Map();
-  const ensureJwtAuthorizer = (name, cfg) => {
+  return (name, cfg) => {
     if (authorizers.has(name)) {
       return authorizers.get(name);
     }
-    const apiAny = api;
-    let ref = name;
     const payload = {
       type: "jwt",
       jwt: {
@@ -159,64 +272,98 @@ function restApiAdapter(args) {
         audience: cfg.audiences
       }
     };
-    if (typeof apiAny.addAuthorizers === "function") {
-      apiAny.addAuthorizers({
+    const addAuthorizers = getFunction(api, "addAuthorizers");
+    const authorizer = getFunction(api, "authorizer");
+    let ref = name;
+    if (addAuthorizers) {
+      addAuthorizers.call(api, {
         [name]: payload
       });
-    } else if (typeof apiAny.authorizer === "function") {
-      ref = apiAny.authorizer(name, payload);
+    } else if (authorizer) {
+      ref = authorizer.call(api, name, payload);
     } else {
-      apiAny.authorizers = {
-        ...apiAny.authorizers ?? {},
+      const apiRecord = ensureRecord(api, "ApiGateway instance does not support authorizers.");
+      const current = isRecord(apiRecord.authorizers) ? apiRecord.authorizers : {};
+      apiRecord.authorizers = {
+        ...current,
         [name]: payload
       };
     }
     authorizers.set(name, ref);
     return ref;
   };
-  const registerRoute = (method, path, config) => {
-    const apiAny = api;
+}
+function createRouteRegistrar(api, apiLabel) {
+  return (method, path, config) => {
     const normalizedPath = normalizeApiGatewayPath(path);
     const routeKey = `${method} ${normalizedPath}`;
-    const asAny = config.handler;
-    const handlerInput = typeof asAny === "string" ? asAny : asAny && typeof asAny.arn !== "undefined" ? asAny.arn : asAny && typeof asAny.handler === "string" ? asAny.handler : asAny === void 0 ? void 0 : (() => {
-      throw new Error("Unsupported handler type: provide a handler string, FunctionArgs, or a Function ARN/output");
-    })();
-    const args2 = {};
-    if (config.protected && config.authorizer) {
-      args2.auth = {
-        jwt: {
-          authorizer: config.authorizer.ref ?? config.authorizer.name,
-          scopes: config.authorizer.roles
-        }
-      };
-    }
-    if (typeof apiAny.route === "function") {
-      apiAny.route(routeKey, handlerInput, args2);
+    const handlerInput = resolveHandlerInput(config.handler);
+    const args = buildRouteArgs(config);
+    const route = getFunction(api, "route");
+    if (route) {
+      route.call(api, routeKey, handlerInput, args);
       return;
     }
-    if (typeof apiAny.addRoutes === "function") {
-      apiAny.addRoutes({
+    const addRoutes = getFunction(api, "addRoutes");
+    if (addRoutes) {
+      addRoutes.call(api, {
         [routeKey]: {
           handler: handlerInput,
-          ...args2
+          ...args
         }
       });
       return;
     }
-    if (typeof apiAny.addRoute === "function") {
-      apiAny.addRoute(routeKey, { handler: handlerInput, ...args2 });
+    const addRoute = getFunction(api, "addRoute");
+    if (addRoute) {
+      addRoute.call(api, routeKey, { handler: handlerInput, ...args });
       return;
     }
-    throw new Error("Unsupported ApiGateway instance: expected route() or addRoutes() method.");
+    throw new Error(`Unsupported ${apiLabel} instance: expected route() or addRoutes() method.`);
   };
+}
+function buildRouteArgs(config) {
+  if (!config.protected || !config.authorizer) {
+    return {};
+  }
   return {
-    api,
-    registerRoute,
-    ensureJwtAuthorizer
+    auth: {
+      jwt: {
+        authorizer: config.authorizer.ref ?? config.authorizer.name,
+        scopes: config.authorizer.roles
+      }
+    }
   };
 }
+
+// src/infra.ts
+function wireApiFromManifest(manifest, opts) {
+  if (!manifest || !Array.isArray(manifest.routes)) {
+    throw new Error("Invalid routes manifest");
+  }
+  wireRoutesFromManifest(manifest, {
+    handler: opts.handler,
+    firebaseProjectId: opts.firebaseProjectId,
+    registerRoute: opts.registerRoute,
+    ensureJwtAuthorizer: opts.ensureJwtAuthorizer
+  });
+  wireEventsFromManifest(manifest.events, {
+    handler: opts.handler,
+    buses: opts.buses
+  });
+}
+function loadRoutesManifest(filePath) {
+  const resolved = resolve(filePath);
+  const contents = readFileSync(resolved, "utf8");
+  const manifest = JSON.parse(contents);
+  if (!manifest || !Array.isArray(manifest.routes)) {
+    throw new Error(`Invalid routes manifest at ${resolved}`);
+  }
+  return manifest;
+}
 export {
+  createBus,
+  getBus,
   httpApiAdapter,
   loadRoutesManifest,
   restApiAdapter,

package/dist/{types-BF3w-wTx.d.cts → types-w1A7o_rd.d.cts}

@@ -47,8 +47,12 @@ type RoutesManifestRoute = {
     path: string;
     auth: RoutesManifestAuth;
 };
+type RoutesManifestEvent = {
+    event: string;
+};
 type RoutesManifest = {
     routes: RoutesManifestRoute[];
+    events?: RoutesManifestEvent[];
 };
 
-export type { FirebaseAuthOptions as F, HttpMethod as H, RoutesManifest as R, RoutesManifestRoute as a, RoutesManifestAuth as b, ResponseLike as c, RouteOptions as d, Handler as e, HandlerContext as f, FirebaseAuthMetadata as g, FirebaseClaims as h };
+export type { FirebaseAuthOptions as F, Handler as H, ResponseLike as R, HandlerContext as a, HttpMethod as b, FirebaseAuthMetadata as c, FirebaseClaims as d, RouteOptions as e, RoutesManifestEvent as f, RoutesManifest as g, RoutesManifestRoute as h, RoutesManifestAuth as i };

package/dist/{types-BF3w-wTx.d.ts → types-w1A7o_rd.d.ts}

@@ -47,8 +47,12 @@ type RoutesManifestRoute = {
     path: string;
     auth: RoutesManifestAuth;
 };
+type RoutesManifestEvent = {
+    event: string;
+};
 type RoutesManifest = {
     routes: RoutesManifestRoute[];
+    events?: RoutesManifestEvent[];
 };
 
-export type { FirebaseAuthOptions as F, HttpMethod as H, RoutesManifest as R, RoutesManifestRoute as a, RoutesManifestAuth as b, ResponseLike as c, RouteOptions as d, Handler as e, HandlerContext as f, FirebaseAuthMetadata as g, FirebaseClaims as h };
+export type { FirebaseAuthOptions as F, Handler as H, ResponseLike as R, HandlerContext as a, HttpMethod as b, FirebaseAuthMetadata as c, FirebaseClaims as d, RouteOptions as e, RoutesManifestEvent as f, RoutesManifest as g, RoutesManifestRoute as h, RoutesManifestAuth as i };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst-http",
-  "version": "1.3.2",
+  "version": "1.3.3-beta.2",
   "description": "Decorator-based routing for SST v3 with a single Lambda and Firebase JWT authorizer.",
   "license": "MIT",
   "author": "",
@@ -26,6 +26,16 @@
       "types": "./dist/infra.d.ts",
       "import": "./dist/infra.js",
       "require": "./dist/infra.cjs"
+    },
+    "./bus": {
+      "types": "./dist/bus/index.d.ts",
+      "import": "./dist/bus/index.js",
+      "require": "./dist/bus/index.cjs"
+    },
+    "./http": {
+      "types": "./dist/http/index.d.ts",
+      "import": "./dist/http/index.js",
+      "require": "./dist/http/index.cjs"
     }
   },
   "bin": {
@@ -64,17 +74,18 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/infra.ts src/cli.ts --dts --format esm,cjs --clean",
-    "dev": "tsup --watch",
+    "build": "tsup src/index.ts src/http/index.ts src/bus/index.ts src/infra.ts src/cli.ts --dts --format esm,cjs --clean",
+    "dev": "tsup src/index.ts src/http/index.ts src/bus/index.ts src/infra.ts src/cli.ts --dts --format esm,cjs --watch",
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
     "prebuild": "pnpm clean",
     "prerelease": "pnpm lint && pnpm typecheck && pnpm build",
-    "release": "pnpm publish --access public",
+    "release": "pnpm publish --access public --tag latest",
     "release:patch": "pnpm version patch && pnpm run release",
     "release:minor": "pnpm version minor && pnpm run release",
     "release:major": "pnpm version major && pnpm run release",
-    "release:dry": "pnpm publish --access public --dry-run"
+    "release:dry": "pnpm publish --access public --dry-run",
+    "release:beta": "pnpm version prerelease --preid beta && pnpm publish --access public --tag beta"
   }
 }