@awsless/cli 0.0.45 → 0.0.46-next.0

package/dist/handlers/image.mjs

@@ -0,0 +1,136 @@
+// src/feature/image/server/handle.ts
+import { getObject, putObject } from "@awsless/s3";
+import sharp from "sharp";
+import { getRouteEnv, invokeRoute } from "awsless";
+
+// src/feature/image/server/validate.ts
+import { object, picklist, pipe, safeParse, string, transform } from "@awsless/validate";
+var supportedExtensions = ["jpg", "png", "webp"];
+var schema = pipe(string(), transform((path) => {
+  const cleanPath = path.startsWith("/") ? path.slice(1) : path;
+  const parts = cleanPath.split("/");
+  const options = parts.pop();
+  const originalPath = parts.join("/");
+  if (!originalPath || !options) {
+    return {};
+  }
+  const [preset, extension] = options.split(".");
+  if (!preset || !extension) {
+    return {};
+  }
+  return {
+    originalPath,
+    preset,
+    extension
+  };
+}), object({
+  originalPath: string(),
+  preset: string(),
+  extension: picklist(supportedExtensions)
+}));
+var parsePath = (path) => {
+  return safeParse(schema, path);
+};
+
+// src/feature/image/server/handle.ts
+var normalizeExtension = (extension) => {
+  if (extension === "jpg") {
+    return "jpeg";
+  }
+  return extension;
+};
+var handle_default = async (event) => {
+  try {
+    const request = parsePath(event.rawPath);
+    const bucket = getRouteEnv("IMAGE_BUCKET");
+    const folder = getRouteEnv("IMAGE_FOLDER") ?? "";
+    if (!request.success) {
+      return { statusCode: 404 };
+    }
+    const originalPath = request.output.originalPath;
+    const preset = request.output.preset;
+    const extension = request.output.extension;
+    const cacheKey = `${folder}cache/${event.rawPath.startsWith("/") ? event.rawPath.slice(1) : event.rawPath}`;
+    if (bucket) {
+      const cachedImage = await getObject({
+        bucket,
+        key: cacheKey
+      });
+      if (cachedImage) {
+        const cachedImageData = await cachedImage.body.transformToByteArray();
+        return {
+          statusCode: 200,
+          body: Buffer.from(cachedImageData).toString("base64"),
+          isBase64Encoded: true,
+          headers: {
+            "Content-Type": `image/${normalizeExtension(extension)}`,
+            "Cache-Control": "public, max-age=31536000, immutable"
+          }
+        };
+      }
+    }
+    const configsEnv = getRouteEnv("IMAGE_CONFIG");
+    if (!configsEnv) {
+      throw new Error("Image configurations not found in environment variables");
+    }
+    const configs = JSON.parse(configsEnv);
+    const presetConfig = configs.presets?.[preset];
+    const extensionConfig = configs.extensions?.[extension];
+    if (!presetConfig || !extensionConfig) {
+      return { statusCode: 404 };
+    }
+    let baseImage = undefined;
+    if (getRouteEnv("IMAGE_ORIGIN_S3")) {
+      const result = await getObject({
+        bucket,
+        key: `${folder}origin/${originalPath}`
+      });
+      if (result?.body) {
+        const data = await result.body.transformToByteArray();
+        baseImage = Buffer.from(data);
+      }
+    }
+    const originRoute = getRouteEnv("IMAGE_ORIGIN");
+    if (!baseImage && originRoute) {
+      const result = await invokeRoute(originRoute, { path: originalPath });
+      if (typeof result === "string") {
+        baseImage = Buffer.from(result, "base64");
+      } else if (result === undefined) {
+        return { statusCode: 404 };
+      } else {
+        throw new Error(`Invalid response from image origin lambda. Path: ${originalPath}`);
+      }
+    }
+    if (!baseImage) {
+      return { statusCode: 404 };
+    }
+    const image = await sharp(baseImage).resize({
+      width: presetConfig.width,
+      height: presetConfig.height,
+      fit: presetConfig.fit,
+      position: presetConfig.position
+    })[normalizeExtension(extension)]({ ...extensionConfig, quality: presetConfig.quality }).toBuffer();
+    await putObject({
+      bucket,
+      key: cacheKey,
+      body: image,
+      contentType: `image/${extension}`,
+      cacheControl: "public, max-age=31536000, immutable"
+    });
+    return {
+      statusCode: 200,
+      body: image.toString("base64"),
+      isBase64Encoded: true,
+      headers: {
+        "Content-Type": `image/${extension}`,
+        "Cache-Control": "public, max-age=31536000, immutable"
+      }
+    };
+  } catch (error) {
+    console.error(error);
+    return { statusCode: 500 };
+  }
+};
+export {
+  handle_default as default
+};

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

@@ -0,0 +1,177 @@
+// src/feature/on-error-log/server/handle.ts
+import {
+  array,
+  literal,
+  looseObject,
+  number,
+  object,
+  optional,
+  picklist,
+  pipe,
+  safeParse,
+  string,
+  toLowerCase,
+  transform,
+  uuid
+} from "@awsless/validate";
+import {
+  define,
+  getItem,
+  number as dbNumber,
+  object as dbObject,
+  putItem,
+  string as dbString
+} from "@awsless/dynamodb";
+import { getRouteEnv, invokeRoute } from "awsless";
+import { createHash } from "crypto";
+import * as zlib from "zlib";
+var RuntimeErrorSchema = object({
+  timestamp: string(),
+  level: pipe(string(), toLowerCase(), picklist(["error", "warn", "fatal"])),
+  requestId: uuid(),
+  message: looseObject({
+    errorType: string(),
+    errorMessage: string(),
+    stackTrace: optional(array(string()))
+  })
+});
+var SimpleErrorSchema = object({
+  timestamp: string(),
+  level: pipe(string(), toLowerCase(), picklist(["error", "warn", "fatal"])),
+  requestId: uuid(),
+  message: string()
+});
+var SystemErrorSchema = object({
+  type: literal("platform.report"),
+  time: string(),
+  record: looseObject({
+    requestId: uuid(),
+    status: picklist(["timeout", "error", "failure"]),
+    errorType: optional(string())
+  })
+});
+var EventSchema = object({
+  logGroup: string(),
+  logEvents: array(object({
+    id: string(),
+    message: string(),
+    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;
+      }
+      const invoke = invokeRoute(consumerRoute, {
+        ...error,
+        origin,
+        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);
+  } finally {
+    console.error = original.error;
+    console.warn = original.warn;
+  }
+};
+var parseError = (message, origin) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return;
+  }
+  const runtimeError = safeParse(RuntimeErrorSchema, parsed);
+  if (runtimeError.success) {
+    const { requestId, level } = runtimeError.output;
+    const { errorType, errorMessage, stackTrace, ...extra } = runtimeError.output.message;
+    const hash = createHash("sha256").update([origin, errorType, errorMessage, stackTrace].join("-")).digest("hex");
+    return {
+      hash,
+      requestId,
+      level,
+      type: errorType,
+      message: errorMessage,
+      stackTrace,
+      data: Object.keys(extra).length ? extra : undefined
+    };
+  }
+  const systemError = safeParse(SystemErrorSchema, parsed);
+  if (systemError.success) {
+    const { requestId, status, errorType, ...extra } = systemError.output.record;
+    const hash = createHash("sha256").update([origin, errorType, status].join("-")).digest("hex");
+    return {
+      hash,
+      requestId,
+      level: "fatal",
+      type: errorType ?? status,
+      message: `Fatal system error: ${errorType ?? status}`,
+      data: Object.keys(extra).length ? extra : undefined
+    };
+  }
+  const simpleError = safeParse(SimpleErrorSchema, parsed);
+  if (simpleError.success) {
+    const { requestId, level, message: message2 } = simpleError.output;
+    const hash = createHash("sha256").update([origin, message2].join("-")).digest("hex");
+    return {
+      hash,
+      requestId,
+      level,
+      type: "Error",
+      message: message2
+    };
+  }
+  return;
+};
+export {
+  handle_default as default
+};

package/dist/handlers/on-failure.mjs

@@ -0,0 +1,138 @@
+// src/feature/on-failure/server/handle.ts
+import { parse, patch } from "@awsless/json";
+import { invoke } from "@awsless/lambda";
+import { deleteObject, getObject } from "@awsless/s3";
+import { formatRoutePayload, getRouteEnv } from "awsless";
+var handle_default = async (event, context) => {
+  if (!Array.isArray(event.Records)) {
+    throw new TypeError(`Unknown Event Type: ${JSON.stringify(event)}`);
+  }
+  await Promise.all(event.Records.map((record) => {
+    return unknownRecord(record, context);
+  }));
+};
+var unknownRecord = (record, context) => {
+  if (typeof record.eventSource === "string") {
+    if (record.eventSource.startsWith("aws:sqs")) {
+      return sqsRecord(record, context);
+    }
+    if (record.eventSource.startsWith("aws:s3")) {
+      return s3Record(record, context);
+    }
+  }
+  throw new TypeError(`Unknown Record Type: ${JSON.stringify(record)}`);
+};
+var sqsRecord = async (record, context) => {
+  const s3Records = parseS3Records(record.body);
+  if (s3Records) {
+    await Promise.all(s3Records.map((record2) => s3Record(record2, context)));
+    return;
+  }
+  const payload = {
+    type: "queue",
+    id: record.messageId,
+    date: new Date(Number(record.attributes.SentTimestamp)),
+    payload: parsePayload(record.body),
+    queue: {
+      name: record.messageAttributes.queueName?.stringValue,
+      url: record.messageAttributes.queueUrl?.stringValue
+    }
+  };
+  await invokeConsumer(payload, context);
+};
+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, context) => {
+  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 invokeConsumer(payload, context);
+  await deleteObject({
+    bucket: record.s3.bucket.name,
+    key
+  });
+};
+var isDynamoDBFailureEvent = (event) => {
+  return "DDBStreamBatchInfo" in event;
+};
+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,
+    error: {
+      type: event.responsePayload.errorType,
+      message: event.responsePayload.errorMessage,
+      stackTrace: event.responsePayload.stackTrace
+    }
+  };
+};
+var formatDynamoDBStreamFailureEvent = (event) => {
+  return {
+    type: "dynamodb-stream",
+    date: new Date(event.timestamp),
+    id: event.requestContext.requestId,
+    function: {
+      name: event.requestContext.functionArn.split(":")[6]
+    },
+    payload: parsePayload(event.payload)
+  };
+};
+var parsePayload = (payload) => {
+  try {
+    return parse(payload);
+  } catch {
+    return payload;
+  }
+};
+var patchPayload = (payload) => {
+  try {
+    return patch(payload);
+  } catch {
+    return payload;
+  }
+};
+var invokeConsumer = async (payload, context) => {
+  const consumerRoute = getRouteEnv("CONSUMER");
+  if (!consumerRoute) {
+    throw new Error("The CONSUMER route env is not set");
+  }
+  await invoke({
+    name: context.invokedFunctionArn,
+    type: "RequestResponse",
+    payload: formatRoutePayload(consumerRoute, payload)
+  });
+};
+export {
+  handle_default as default
+};

package/dist/handlers/pubsub-publisher.mjs

@@ -0,0 +1,43 @@
+// src/feature/pubsub/publisher/handle.ts
+import { stringify } from "@awsless/json";
+import { lambda } from "@awsless/lambda";
+import { maxLength, minLength, object, optional, pipe, string, unknown } from "@awsless/validate";
+import { getRouteEnv } from "awsless";
+import { Redis } from "ioredis";
+var createClient = () => {
+  return new Redis({
+    host: getRouteEnv("REDIS_HOST"),
+    port: Number(getRouteEnv("REDIS_PORT") ?? 6379),
+    tls: {},
+    lazyConnect: true,
+    keepAlive: 0,
+    noDelay: true,
+    enableReadyCheck: false,
+    maxRetriesPerRequest: 3,
+    connectTimeout: 5000,
+    commandTimeout: 5000
+  });
+};
+var handle_default = lambda({
+  schema: object({
+    topic: pipe(string(), minLength(1), maxLength(128)),
+    event: pipe(string(), minLength(1), maxLength(64)),
+    payload: optional(unknown())
+  }),
+  async handle({ topic, event, payload }, ctx) {
+    const redis = createClient();
+    ctx.onFinally(() => {
+      return redis.quit().catch(() => {
+        redis.disconnect();
+      });
+    });
+    await redis.publish(getRouteEnv("CHANNEL"), stringify({
+      topic,
+      event,
+      payload: typeof payload === "undefined" ? undefined : stringify(payload)
+    }));
+  }
+});
+export {
+  handle_default as default
+};