effortless-aws 0.28.0 → 0.29.0

package/dist/runtime/wrap-api.js

@@ -1,7 +1,7 @@
 import {
   AUTH_COOKIE_NAME,
   createHandlerRuntime
-} from "../chunk-EZG3NX42.js";
+} from "../chunk-ISJC6CHC.js";
 
 // src/runtime/wrap-api.ts
 var CONTENT_TYPE_MAP = {
@@ -23,32 +23,6 @@ var parseBody = (body, isBase64) => {
     return decoded;
   }
 };
-var buildGetMatchers = (routes, basePath) => Object.entries(routes).map(([pattern, handler]) => {
-  const fullPattern = (basePath + pattern).replace(/\/\/+/g, "/");
-  const paramNames = [];
-  const regexStr = fullPattern.replace(/\{(\w+)\}/g, (_, name) => {
-    paramNames.push(name);
-    return "([^/]+)";
-  });
-  return {
-    regex: new RegExp(`^${regexStr}$`),
-    paramNames,
-    handler
-  };
-});
-var matchRoute = (matchers, path) => {
-  for (const matcher of matchers) {
-    const match = path.match(matcher.regex);
-    if (match) {
-      const params = {};
-      matcher.paramNames.forEach((name, i) => {
-        params[name] = match[i + 1];
-      });
-      return { handler: matcher.handler, params };
-    }
-  }
-  return null;
-};
 var toResult = (r) => {
   const resolved = r.contentType ? CONTENT_TYPE_MAP[r.contentType] : void 0;
   const customContentType = resolved ?? r.headers?.["content-type"] ?? r.headers?.["Content-Type"];
@@ -74,14 +48,14 @@ var unauthorized = () => ({
   headers: { "Content-Type": "application/json" },
   body: JSON.stringify({ error: "Unauthorized" })
 });
-var isPublicPath = (path, patterns) => patterns.some(
-  (p) => p.endsWith("*") ? path.startsWith(p.slice(0, -1)) : path === p
+var findRoute = (routes, method, relativePath) => routes.find(
+  (r) => r.path === relativePath && (r.method === method || r.method === "GET" && method === "HEAD")
 );
 var wrapApi = (handler) => {
   const rt = createHandlerRuntime(handler, "api", handler.__spec.lambda?.logLevel ?? "info");
   const basePath = handler.__spec.basePath;
   const isStream = handler.__spec.stream === true;
-  const getMatchers = handler.get ? buildGetMatchers(handler.get, basePath) : [];
+  const routes = handler.routes ?? [];
   const defaultError = (error, status) => {
     console.error(`[effortless:${rt.handlerName}]`, error);
     return toResult({
@@ -92,91 +66,89 @@ var wrapApi = (handler) => {
       }
     });
   };
+  const extractRelativePath = (fullPath) => {
+    const prefix = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+    if (!fullPath.startsWith(prefix)) return null;
+    const rest = fullPath.slice(prefix.length);
+    if (rest === "" || rest === "/") return "/";
+    if (!rest.startsWith("/")) return null;
+    return rest;
+  };
   const handleRequest = async (event, streamCtx) => {
     const startTime = Date.now();
     rt.patchConsole();
     let sharedArgs;
+    let ctxProps = {};
     try {
+      const method = event.requestContext?.http?.method ?? event.httpMethod ?? "GET";
+      const path = event.requestContext?.http?.path ?? event.path ?? "/";
+      const headers = event.headers ?? {};
+      const query = event.queryStringParameters ?? {};
+      const params = event.pathParameters ?? {};
+      const body = parseBody(event.body, event.isBase64Encoded ?? false);
+      const merged = {
+        ...query,
+        ...typeof body === "object" && body !== null ? body : {},
+        ...params
+      };
       const req = {
-        method: event.requestContext?.http?.method ?? event.httpMethod ?? "GET",
-        path: event.requestContext?.http?.path ?? event.path ?? "/",
-        headers: event.headers ?? {},
-        query: event.queryStringParameters ?? {},
-        params: event.pathParameters ?? {},
-        body: parseBody(event.body, event.isBase64Encoded ?? false),
+        method,
+        path,
+        headers,
+        query,
+        params,
+        body,
         rawBody: event.body
       };
-      const input = { method: req.method, path: req.path, query: req.query, body: req.body };
+      const logInput = { method, path, query, body };
+      const relativePath = extractRelativePath(req.path);
+      if (!relativePath) {
+        rt.logExecution(startTime, logInput, { status: 404 });
+        return notFound();
+      }
+      const entry = findRoute(routes, req.method, relativePath);
+      if (!entry) {
+        rt.logExecution(startTime, logInput, { status: 404 });
+        return notFound();
+      }
       const cookieHeader = req.headers["cookie"] ?? req.headers["Cookie"] ?? "";
       let authCookie;
       if (cookieHeader) {
         const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${AUTH_COOKIE_NAME}=([^;]+)`));
         if (match) authCookie = match[1];
       }
-      const authHeaderName = handler.apiToken?.header ?? "authorization";
+      const authHeaderName = "authorization";
       const authHeader = req.headers[authHeaderName] ?? req.headers[authHeaderName.toLowerCase()] ?? void 0;
-      sharedArgs = await rt.commonArgs(authCookie, authHeader);
-      if (handler.auth && sharedArgs.auth) {
-        const auth = sharedArgs.auth;
-        const publicPaths = handler.auth.public ?? [];
-        const routePath = req.path.replace(new RegExp(`^${basePath}`), "") || "/";
-        if (!auth.session && !isPublicPath(routePath, publicPaths) && !isPublicPath(req.path, publicPaths)) {
-          rt.logExecution(startTime, input, { status: 401 });
+      sharedArgs = await rt.commonArgs(authCookie, authHeader, req.headers);
+      if (sharedArgs.auth) {
+        const auth2 = sharedArgs.auth;
+        if (!auth2.session && !entry.public) {
+          rt.logExecution(startTime, logInput, { status: 401 });
           return unauthorized();
         }
       }
-      if (req.method === "GET" || req.method === "HEAD") {
-        const matched = matchRoute(getMatchers, req.path);
-        if (!matched) {
-          rt.logExecution(startTime, input, { status: 404 });
-          return notFound();
-        }
-        req.params = { ...req.params, ...matched.params };
-        const args = { req, ...sharedArgs };
-        if (streamCtx) args.stream = streamCtx.stream;
-        try {
-          const response = await matched.handler(args);
-          if (response) {
-            rt.logExecution(startTime, input, response.body);
-            return toResult(response);
-          }
-          rt.logExecution(startTime, input, "[stream]");
-          return void 0;
-        } catch (error) {
-          rt.logError(startTime, input, error);
-          return handler.onError ? toResult(handler.onError({ error, req, ...sharedArgs })) : defaultError(error, 500);
-        }
-      }
-      if (req.method === "POST" && handler.post) {
-        const args = { req, ...sharedArgs };
-        if (streamCtx) args.stream = streamCtx.stream;
-        if (handler.schema) {
-          try {
-            args.data = handler.schema(req.body);
-          } catch (error) {
-            rt.logError(startTime, input, error);
-            return handler.onError ? toResult(handler.onError({ error, req, ...sharedArgs })) : defaultError(error, 400);
-          }
-        }
-        try {
-          const response = await handler.post(args);
-          if (response) {
-            rt.logExecution(startTime, input, response.body);
-            return toResult(response);
-          }
-          rt.logExecution(startTime, input, "[stream]");
-          return void 0;
-        } catch (error) {
-          rt.logError(startTime, input, error);
-          return handler.onError ? toResult(handler.onError({ error, req, ...sharedArgs })) : defaultError(error, 500);
+      const { ctx, auth, ...rest } = sharedArgs;
+      ctxProps = ctx && typeof ctx === "object" ? { ...ctx } : {};
+      delete ctxProps.auth;
+      const args = { ...ctxProps, req, input: merged, ...rest };
+      if (auth) args.auth = auth;
+      if (streamCtx) args.stream = streamCtx.stream;
+      try {
+        const response = await entry.onRequest(args);
+        if (response) {
+          rt.logExecution(startTime, logInput, response.body);
+          return toResult(response);
         }
+        rt.logExecution(startTime, logInput, "[stream]");
+        return void 0;
+      } catch (error) {
+        rt.logError(startTime, logInput, error);
+        return handler.onError ? toResult(handler.onError({ error, req, ...ctxProps })) : defaultError(error, 500);
       }
-      rt.logExecution(startTime, input, { status: 404 });
-      return notFound();
     } finally {
       if (handler.onAfterInvoke && sharedArgs) {
         try {
-          await handler.onAfterInvoke(sharedArgs);
+          await handler.onAfterInvoke(ctxProps);
         } catch (e) {
           console.error(`[effortless:${rt.handlerName}] onAfterInvoke error`, e);
         }

package/dist/runtime/wrap-bucket.js

@@ -1,7 +1,7 @@
 import {
   createBucketClient,
   createHandlerRuntime
-} from "../chunk-EZG3NX42.js";
+} from "../chunk-ISJC6CHC.js";
 
 // src/runtime/wrap-bucket.ts
 var ENV_DEP_SELF = "EFF_DEP_SELF";
@@ -26,11 +26,15 @@ var wrapBucket = (handler) => {
   return async (event) => {
     const startTime = Date.now();
     rt.patchConsole();
-    let shared;
+    let ctxProps = {};
     try {
       const rawRecords = event.Records ?? [];
       const input = { recordCount: rawRecords.length };
-      shared = { ...await rt.commonArgs(), bucket: getSelfClient() };
+      const common = await rt.commonArgs();
+      const ctx = common.ctx;
+      ctxProps = ctx && typeof ctx === "object" ? { ...ctx } : {};
+      const bucket = getSelfClient();
+      const shared = { bucket, ...ctxProps };
       let errorCount = 0;
       for (const record of rawRecords) {
         const bucketEvent = {
@@ -58,9 +62,9 @@ var wrapBucket = (handler) => {
         rt.logExecution(startTime, input, { processedCount: rawRecords.length });
       }
     } finally {
-      if (handler.onAfterInvoke && shared) {
+      if (handler.onAfterInvoke) {
         try {
-          await handler.onAfterInvoke(shared);
+          await handler.onAfterInvoke(ctxProps);
         } catch (e) {
           console.error(`[effortless:${rt.handlerName}] onAfterInvoke error`, e);
         }

package/dist/runtime/wrap-fifo-queue.js

@@ -1,6 +1,6 @@
 import {
   createHandlerRuntime
-} from "../chunk-EZG3NX42.js";
+} from "../chunk-ISJC6CHC.js";
 
 // src/runtime/wrap-fifo-queue.ts
 var parseMessages = (rawRecords, schema) => {
@@ -29,19 +29,22 @@ var parseMessages = (rawRecords, schema) => {
   return messages;
 };
 var wrapFifoQueue = (handler) => {
-  if (!handler.onMessage && !handler.onBatch) {
-    throw new Error("wrapFifoQueue requires a handler with onMessage or onBatch defined");
+  if (!handler.onMessage && !handler.onMessageBatch) {
+    throw new Error("wrapFifoQueue requires a handler with onMessage or onMessageBatch defined");
   }
   const rt = createHandlerRuntime(handler, "fifo-queue", handler.__spec.lambda?.logLevel ?? "info");
   const handleError = handler.onError ?? (({ error }) => console.error(`[effortless:${rt.handlerName}]`, error));
   return async (event) => {
     const startTime = Date.now();
     rt.patchConsole();
-    let shared;
+    let ctxProps = {};
     try {
       const rawRecords = event.Records ?? [];
       const input = { messageCount: rawRecords.length };
-      shared = await rt.commonArgs();
+      const common = await rt.commonArgs();
+      const ctx = common.ctx;
+      ctxProps = ctx && typeof ctx === "object" ? { ...ctx } : {};
+      const shared = { ...ctxProps };
       let messages;
       try {
         messages = parseMessages(rawRecords, handler.schema);
@@ -53,9 +56,14 @@ var wrapFifoQueue = (handler) => {
         };
       }
       const batchItemFailures = [];
-      if (handler.onBatch) {
+      if (handler.onMessageBatch) {
         try {
-          await handler.onBatch({ messages, ...shared });
+          const result = await handler.onMessageBatch({ messages, ...shared });
+          if (result?.failures) {
+            for (const id of result.failures) {
+              batchItemFailures.push({ itemIdentifier: id });
+            }
+          }
         } catch (error) {
           handleError({ error, ...shared });
           for (const message of messages) {
@@ -80,9 +88,9 @@ var wrapFifoQueue = (handler) => {
       }
       return { batchItemFailures };
     } finally {
-      if (handler.onAfterInvoke && shared) {
+      if (handler.onAfterInvoke) {
         try {
-          await handler.onAfterInvoke(shared);
+          await handler.onAfterInvoke(ctxProps);
         } catch (e) {
           console.error(`[effortless:${rt.handlerName}] onAfterInvoke error`, e);
         }

package/dist/runtime/wrap-table-stream.js

@@ -1,7 +1,7 @@
 import {
   createHandlerRuntime,
   createTableClient
-} from "../chunk-EZG3NX42.js";
+} from "../chunk-ISJC6CHC.js";
 
 // src/runtime/wrap-table-stream.ts
 import { unmarshall } from "@aws-sdk/util-dynamodb";
@@ -36,20 +36,13 @@ var parseRecords = (rawRecords, schema) => {
   }
   return { records, sequenceNumbers };
 };
-var collectFailures = (records, sequenceNumbers) => {
-  const failures = [];
-  for (const record of records) {
-    const seq = sequenceNumbers.get(record);
-    if (seq) failures.push({ itemIdentifier: seq });
-  }
-  return failures;
-};
 var ENV_DEP_SELF = "EFF_DEP_SELF";
 var wrapTableStream = (handler) => {
-  if (!handler.onRecord && !handler.onBatch) {
-    throw new Error("wrapTableStream requires a handler with onRecord or onBatch defined");
+  if (!handler.onRecord && !handler.onRecordBatch) {
+    throw new Error("wrapTableStream requires a handler with onRecord or onRecordBatch defined");
   }
   const tagField = handler.__spec.tagField ?? "tag";
+  const concurrency = handler.__spec.concurrency ?? 1;
   let selfClient = null;
   const getSelfClient = () => {
     if (selfClient) return selfClient;
@@ -67,11 +60,14 @@ var wrapTableStream = (handler) => {
   return async (event) => {
     const startTime = Date.now();
     rt.patchConsole();
-    let shared;
+    let ctxProps = {};
     try {
       const rawRecords = event.Records ?? [];
       const input = { recordCount: rawRecords.length };
-      shared = { ...await rt.commonArgs(), table: getSelfClient() };
+      const common = await rt.commonArgs();
+      const ctx = common.ctx;
+      ctxProps = ctx && typeof ctx === "object" ? { ...ctx } : {};
+      const shared = { ...ctxProps };
       let records;
       let sequenceNumbers;
       try {
@@ -82,37 +78,47 @@ var wrapTableStream = (handler) => {
         return { batchItemFailures: rawRecords.map((r) => r.dynamodb?.SequenceNumber).filter((s) => !!s).map((seq) => ({ itemIdentifier: seq })) };
       }
       const batchItemFailures = [];
-      if (handler.onBatch) {
+      const frozenBatch = Object.freeze(records);
+      if (handler.onRecordBatch) {
         try {
-          await handler.onBatch({ records, ...shared });
+          const result = await handler.onRecordBatch({ records: frozenBatch, ...shared });
+          if (result?.failures) {
+            for (const seq of result.failures) {
+              batchItemFailures.push({ itemIdentifier: seq });
+            }
+          }
         } catch (error) {
           handleError({ error, ...shared });
-          batchItemFailures.push(...collectFailures(records, sequenceNumbers));
-        }
-      } else {
-        const results = [];
-        const failures = [];
-        const onRecord = handler.onRecord;
-        for (const record of records) {
-          try {
-            const result = await onRecord({ record, ...shared });
-            if (result !== void 0) results.push(result);
-          } catch (error) {
-            handleError({ error, ...shared });
-            failures.push({ record, error });
+          for (const record of records) {
             const seq = sequenceNumbers.get(record);
             if (seq) batchItemFailures.push({ itemIdentifier: seq });
           }
         }
-        if (handler.onBatchComplete) {
-          try {
-            await handler.onBatchComplete({ results, failures, ...shared });
-          } catch (error) {
-            handleError({ error, ...shared });
-            for (const record of records) {
+      } else {
+        const onRecord = handler.onRecord;
+        if (concurrency <= 1) {
+          for (const record of records) {
+            try {
+              await onRecord({ record, batch: frozenBatch, ...shared });
+            } catch (error) {
+              handleError({ error, ...shared });
               const seq = sequenceNumbers.get(record);
-              if (seq && !batchItemFailures.some((f) => f.itemIdentifier === seq)) {
-                batchItemFailures.push({ itemIdentifier: seq });
+              if (seq) batchItemFailures.push({ itemIdentifier: seq });
+            }
+          }
+        } else {
+          for (let i = 0; i < records.length; i += concurrency) {
+            const chunk = records.slice(i, i + concurrency);
+            const results = await Promise.allSettled(
+              chunk.map((record) => onRecord({ record, batch: frozenBatch, ...shared }))
+            );
+            for (let j = 0; j < results.length; j++) {
+              const result = results[j];
+              const record = chunk[j];
+              if (result.status === "rejected") {
+                handleError({ error: result.reason, ...shared });
+                const seq = sequenceNumbers.get(record);
+                if (seq) batchItemFailures.push({ itemIdentifier: seq });
               }
             }
           }
@@ -125,9 +131,9 @@ var wrapTableStream = (handler) => {
       }
       return { batchItemFailures };
     } finally {
-      if (handler.onAfterInvoke && shared) {
+      if (handler.onAfterInvoke) {
         try {
-          await handler.onAfterInvoke(shared);
+          await handler.onAfterInvoke(ctxProps);
         } catch (e) {
           console.error(`[effortless:${rt.handlerName}] onAfterInvoke error`, e);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effortless-aws",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "license": "MIT",
   "type": "module",
   "description": "Code-first AWS Lambda framework. Export handlers, deploy with one command.",
@@ -45,10 +45,13 @@
     "@types/node": "^22.19.9",
     "tsup": "^8.5.1",
     "type-fest": "^4.22.1",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "tsup",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
 }