@awsless/cli 0.0.46-next.34 → 0.0.46-next.35

package/dist/handlers/bundle.js

@@ -151,21 +151,6 @@ var imageHandler = (event) => {
   return;
 };
 
-// src/feature/bundle/server/resource/log.ts
-var logHandler = (event) => {
-  const route = event?.["$awsless-route"];
-  if (typeof route === "string") {
-    if (routeType(route) === "on-error-log") {
-      return asyncRoute(route, event.event);
-    }
-    return;
-  }
-  if (typeof event?.awslogs?.data === "string") {
-    return asyncRoute("base:on-error-log:handler", event);
-  }
-  return;
-};
-
 // src/feature/bundle/server/resource/metric.ts
 var metricHandler = (event) => {
   if (typeof event?.["$awsless-route"] === "string" || typeof event?.headers?.["x-awsless-route"] === "string") {
@@ -181,15 +166,6 @@ var metricHandler = (event) => {
   return;
 };
 
-// src/feature/bundle/server/resource/on-failure.ts
-var onFailureHandler = (event) => {
-  const route = event?.["$awsless-route"];
-  if (typeof route === "string" && routeType(route) === "on-failure") {
-    return asyncRoute(route, event.event);
-  }
-  return;
-};
-
 // src/feature/bundle/server/resource/pubsub.ts
 var eventTypes = ["connected", "disconnected", "subscribed", "unsubscribed"];
 var pubsubHandler = (event, routes) => {
@@ -398,8 +374,6 @@ var createBundle = (handlers) => {
     iconHandler,
     imageHandler,
     metricHandler,
-    onFailureHandler,
-    logHandler,
     queueHandler,
     pubsubHandler,
     topicHandler,

package/dist/handlers/on-error-log.js

@@ -14,15 +14,6 @@ import {
   transform,
   uuid
 } from "@awsless/validate";
-import {
-  define,
-  getItem,
-  number as dbNumber,
-  object as dbObject,
-  putItem,
-  string as dbString
-} from "@awsless/dynamodb";
-import { getRouteEnv, internalInvoke } from "awsless";
 import { createHash } from "crypto";
 import * as zlib from "zlib";
 var RuntimeErrorSchema = object({
@@ -58,69 +49,35 @@ var EventSchema = object({
     timestamp: pipe(number(), transform((v) => new Date(v)))
   }))
 });
-var requestTable = define(getRouteEnv("TABLE"), {
-  hash: "id",
-  schema: dbObject({
-    id: dbString(),
-    ttl: dbNumber()
-  })
-});
-var registerOwnRequest = async (requestId) => {
-  try {
-    await putItem(requestTable, {
-      id: requestId,
-      ttl: Math.floor(Date.now() / 1000) + 3600
-    });
-  } catch (error) {
-    console.info("Failed to register the request marker", error);
-  }
-};
-var isOwnRequest = async (requestId) => {
-  try {
-    const item = await getItem(requestTable, { id: requestId }, { consistentRead: true });
-    return !!item;
-  } catch (error) {
-    console.info("Failed to check the request marker", error);
-    return false;
-  }
-};
-var handle_default = async (event, context) => {
-  const consumerRoute = getRouteEnv("CONSUMER");
-  if (!consumerRoute) {
-    throw new Error("The CONSUMER route env is not set");
-  }
-  await registerOwnRequest(context.awsRequestId);
-  const original = { error: console.error, warn: console.warn };
-  console.error = console.info;
-  console.warn = console.info;
-  try {
-    const payload = Buffer.from(event.awslogs.data, "base64");
-    const unzipped = zlib.gunzipSync(new Uint8Array(payload));
-    const result = safeParse(EventSchema, JSON.parse(unzipped.toString("utf-8")));
-    if (!result.success) {
-      console.info("Failed to parse log data", result.issues);
-      return;
-    }
-    const origin = result.output.logGroup.split("/").pop();
-    for (const logEvent of result.output.logEvents) {
-      const error = parseError(logEvent.message, origin);
-      if (!error || await isOwnRequest(error.requestId)) {
-        continue;
+var createHandler = (consumer) => {
+  return async (event, context) => {
+    try {
+      const payload = Buffer.from(event.awslogs.data, "base64");
+      const unzipped = zlib.gunzipSync(new Uint8Array(payload));
+      const result = safeParse(EventSchema, JSON.parse(unzipped.toString("utf-8")));
+      if (!result.success) {
+        console.info("Failed to parse log data", result.issues);
+        return;
+      }
+      const origin = result.output.logGroup.split("/").pop();
+      for (const logEvent of result.output.logEvents) {
+        const error = parseError(logEvent.message, origin);
+        if (!error) {
+          continue;
+        }
+        const invoke = Promise.resolve().then(() => {
+          return consumer({
+            ...error,
+            date: logEvent.timestamp
+          });
+        }).catch(() => {});
+        const deadline = Math.max(0, context.getRemainingTimeInMillis() - 3000);
+        await Promise.race([invoke, new Promise((resolve) => setTimeout(resolve, deadline))]);
       }
-      const invoke = internalInvoke(consumerRoute, {
-        ...error,
-        date: logEvent.timestamp
-      });
-      invoke.catch(() => {});
-      const deadline = Math.max(0, context.getRemainingTimeInMillis() - 3000);
-      await Promise.race([invoke, new Promise((resolve) => setTimeout(resolve, deadline))]);
+    } catch (error) {
+      console.info("Failed to consume the error logs", error);
     }
-  } catch (error) {
-    console.info("Failed to consume the error logs", error);
-  } finally {
-    console.error = original.error;
-    console.warn = original.warn;
-  }
+  };
 };
 var parseError = (message, origin) => {
   let parsed;
@@ -179,5 +136,5 @@ var parseError = (message, origin) => {
   return;
 };
 export {
-  handle_default as default
+  createHandler
 };

package/dist/handlers/on-failure.js

@@ -0,0 +1,205 @@
+// src/feature/on-failure/server/handle.ts
+import { parse as parse2, patch } from "@awsless/json";
+import { deleteObject, getObject } from "@awsless/s3";
+
+// src/feature/on-failure/server/util.ts
+import { parse } from "@awsless/json";
+var isDynamoDBFailureEvent = (event) => {
+  return "DDBStreamBatchInfo" in event;
+};
+var logicalResourceName = (physical) => {
+  const segments = physical.replace(/\.fifo$/, "").split("--");
+  if (segments.length === 4) {
+    return `${segments[1]}:${segments[2]}:${segments[3]}`;
+  }
+  if (segments.length === 3) {
+    return `${segments[1]}:${segments[2]}`;
+  }
+  return physical;
+};
+var getFailureSource = (payload) => {
+  const record = getDeliveryRecord(payload);
+  if (!record) {
+    return;
+  }
+  if (isTopicRecord(record)) {
+    return {
+      resource: record.Sns.TopicArn ? logicalResourceName(lastArnSegment(record.Sns.TopicArn)) : "topic",
+      event: parseEvent(record.Sns.Message)
+    };
+  }
+  if (isStreamRecord(record)) {
+    const table = record.eventSourceARN.split("/")[1];
+    return {
+      resource: table ? logicalResourceName(table) : "table-stream"
+    };
+  }
+  if (isQueueRecord(record)) {
+    return {
+      resource: logicalResourceName(lastArnSegment(record.eventSourceARN)),
+      event: parseEvent(record.body)
+    };
+  }
+  return;
+};
+var getDeliveryRecord = (payload) => {
+  if (!payload || typeof payload !== "object") {
+    return;
+  }
+  const records = payload.Records;
+  const record = Array.isArray(records) ? records[0] : undefined;
+  return record && typeof record === "object" ? record : undefined;
+};
+var isTopicRecord = (record) => {
+  return "Sns" in record && typeof record.Sns === "object" && record.Sns !== null;
+};
+var isStreamRecord = (record) => {
+  return "eventSource" in record && record.eventSource === "aws:dynamodb" && "eventSourceARN" in record;
+};
+var isQueueRecord = (record) => {
+  return "eventSource" in record && record.eventSource === "aws:sqs" && "eventSourceARN" in record;
+};
+var lastArnSegment = (arn) => {
+  return arn.split(":").at(-1);
+};
+var parseEvent = (value) => {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return parse(value);
+  } catch {
+    return value;
+  }
+};
+
+// src/feature/on-failure/server/handle.ts
+var createHandler = (consumer) => {
+  return async (event) => {
+    if (!Array.isArray(event.Records)) {
+      throw new TypeError(`Unknown Event Type: ${JSON.stringify(event)}`);
+    }
+    await Promise.all(event.Records.map((record) => {
+      return unknownRecord(record, consumer);
+    }));
+  };
+};
+var unknownRecord = (record, consumer) => {
+  if (typeof record.eventSource === "string") {
+    if (record.eventSource.startsWith("aws:sqs")) {
+      return sqsRecord(record, consumer);
+    }
+    if (record.eventSource.startsWith("aws:s3")) {
+      return s3Record(record, consumer);
+    }
+  }
+  throw new TypeError(`Unknown Record Type: ${JSON.stringify(record)}`);
+};
+var sqsRecord = async (record, consumer) => {
+  const s3Records = parseS3Records(record.body);
+  if (s3Records) {
+    await Promise.all(s3Records.map((record2) => s3Record(record2, consumer)));
+    return;
+  }
+  const queueName = record.messageAttributes.queueName?.stringValue;
+  const body = parsePayload(record.body);
+  const payload = {
+    type: "queue",
+    id: record.messageId,
+    date: new Date(Number(record.attributes.SentTimestamp)),
+    payload: body,
+    source: queueName ? { resource: logicalResourceName(queueName), event: body } : undefined,
+    queue: {
+      name: queueName,
+      url: record.messageAttributes.queueUrl?.stringValue
+    }
+  };
+  await consumer(payload);
+};
+var parseS3Records = (body) => {
+  try {
+    const event = JSON.parse(body);
+    if (event?.Event === "s3:TestEvent") {
+      return [];
+    }
+    if (Array.isArray(event?.Records) && event.Records[0]?.eventSource === "aws:s3") {
+      return event.Records;
+    }
+  } catch {}
+  return;
+};
+var s3Record = async (record, consumer) => {
+  const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, " "));
+  const object = await getObject({
+    bucket: record.s3.bucket.name,
+    key
+  });
+  if (!object) {
+    return;
+  }
+  const json = await object.body.transformToString();
+  const unknownEvent = JSON.parse(json);
+  const payload = formatUnknownFailureEvent(unknownEvent);
+  await consumer(payload);
+  await deleteObject({
+    bucket: record.s3.bucket.name,
+    key
+  });
+};
+var formatUnknownFailureEvent = (event) => {
+  if (isDynamoDBFailureEvent(event)) {
+    return formatDynamoDBStreamFailureEvent(event);
+  }
+  return formatAsyncLambdaFailureEvent(event);
+};
+var formatAsyncLambdaFailureEvent = (event) => {
+  const payload = patchPayload(event.requestPayload);
+  const route = payload && typeof payload === "object" ? payload["$awsless-route"] : undefined;
+  return {
+    type: "async-lambda",
+    date: new Date(event.timestamp),
+    id: event.requestContext.requestId,
+    function: {
+      name: typeof route === "string" ? route : event.requestContext.functionArn.split(":")[6]
+    },
+    payload: typeof route === "string" ? payload.event ?? {} : payload,
+    source: typeof route === "string" ? { resource: route, event: payload.event ?? {} } : getFailureSource(payload),
+    error: {
+      type: event.responsePayload.errorType,
+      message: event.responsePayload.errorMessage,
+      stackTrace: event.responsePayload.stackTrace
+    }
+  };
+};
+var formatDynamoDBStreamFailureEvent = (event) => {
+  const payload = parsePayload(event.payload);
+  const streamArn = event.DDBStreamBatchInfo?.streamArn;
+  const table = streamArn?.split("/")[1];
+  return {
+    type: "dynamodb-stream",
+    date: new Date(event.timestamp),
+    id: event.requestContext.requestId,
+    function: {
+      name: event.requestContext.functionArn.split(":")[6]
+    },
+    payload,
+    source: table ? { resource: logicalResourceName(table) } : getFailureSource(payload)
+  };
+};
+var parsePayload = (payload) => {
+  try {
+    return parse2(payload);
+  } catch {
+    return payload;
+  }
+};
+var patchPayload = (payload) => {
+  try {
+    return patch(payload);
+  } catch {
+    return payload;
+  }
+};
+export {
+  createHandler
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awsless/cli",
-  "version": "0.0.46-next.34",
+  "version": "0.0.46-next.35",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -25,14 +25,14 @@
     "@awsless/ts-file-cache": "^0.0.16"
   },
   "peerDependencies": {
+    "@awsless/big-float": "^0.1.7",
     "@awsless/duration": "^0.0.4",
-    "@awsless/json": "^0.0.11",
     "@awsless/dynamodb": "^0.3.22",
-    "@awsless/lambda": "^0.0.47",
+    "@awsless/json": "^0.0.11",
     "@awsless/validate": "^0.1.7",
     "@awsless/s3": "^0.0.22",
-    "@awsless/big-float": "^0.1.7",
     "@awsless/weak-cache": "^0.0.1",
+    "@awsless/lambda": "^0.0.47",
     "awsless": "^0.0.15-next.8"
   },
   "devDependencies": {
@@ -103,24 +103,24 @@
     "zod": "^3.24.2",
     "zod-to-json-schema": "^3.24.3",
     "@awsless/big-float": "^0.1.7",
+    "@awsless/clui": "^0.0.9",
     "@awsless/cloudwatch": "^0.0.1",
     "@awsless/duration": "^0.0.4",
-    "@awsless/iot": "^0.0.5",
     "@awsless/dynamodb": "^0.3.22",
+    "@awsless/json": "^0.0.11",
+    "@awsless/iot": "^0.0.5",
     "@awsless/lambda": "^0.0.47",
+    "@awsless/open-search": "^0.0.24",
     "@awsless/s3": "^0.0.22",
-    "@awsless/redis": "^0.1.13",
-    "@awsless/clui": "^0.0.9",
-    "@awsless/size": "^0.0.2",
+    "@awsless/scheduler": "^0.0.5",
     "@awsless/sns": "^0.0.11",
     "@awsless/sqs": "^0.0.24",
-    "@awsless/json": "^0.0.11",
-    "@awsless/validate": "^0.1.7",
+    "@awsless/size": "^0.0.2",
     "@awsless/ssm": "^0.0.8",
-    "@awsless/scheduler": "^0.0.5",
-    "@awsless/weak-cache": "^0.0.1",
+    "@awsless/validate": "^0.1.7",
     "awsless": "^0.0.15-next.8",
-    "@awsless/open-search": "^0.0.24"
+    "@awsless/weak-cache": "^0.0.1",
+    "@awsless/redis": "^0.1.13"
   },
   "scripts": {
     "test": "bun cli/build-handlers.ts && pnpm vitest",

package/dist/prebuild/on-failure/HASH

@@ -1 +0,0 @@
-360568614ec11c8dd2efe5e05ccc2dde09fb5b28