@awsless/cli 0.0.45 → 0.0.46-next.0

package/dist/handlers/bundle.mjs

@@ -0,0 +1,534 @@
+// src/feature/bundle/server/handle.ts
+import { patch, unpatch } from "@awsless/json";
+import { ExpectedError, invoke, isErrorResponse } from "@awsless/lambda";
+import { formatRoutePayload, getCurrentRoute, withRoute } from "awsless";
+
+// src/feature/bundle/server/preview.ts
+import { GetObjectCommand, NoSuchKey } from "@aws-sdk/client-s3";
+import { s3Client } from "@awsless/s3";
+var getPossibleRouteKeys = (path) => {
+  if (path === "" || path === "/") {
+    return ["/", "/*"];
+  }
+  const parts = path.split("/");
+  const root = path.startsWith("/") ? parts[1] : parts[0];
+  const file = parts[parts.length - 1].includes(".");
+  if (root.includes(".")) {
+    return [path, "/*.", "/*"];
+  }
+  if (file) {
+    return [path, "/" + root + "/*.", "/" + root + "/*", "/*.", "/*"];
+  }
+  return [path, "/" + root + "/*", "/*"];
+};
+var findRoute = (props, path, method) => {
+  for (const key of getPossibleRouteKeys(path)) {
+    const route = props.routes[`${props.router}:${key}`];
+    if (!route) {
+      continue;
+    }
+    if (route.type === "s3" && method !== "GET" && method !== "HEAD") {
+      continue;
+    }
+    return route;
+  }
+  return;
+};
+var rewritePath = (route, path) => {
+  if (!route.rewrite) {
+    return path;
+  }
+  if (route.rewrite.regex) {
+    return path.replace(new RegExp(route.rewrite.regex), route.rewrite.to);
+  }
+  return route.rewrite.to;
+};
+var serveObject = async (route, path, method) => {
+  const bucket = route.domainName.split(".s3")[0];
+  const key = rewritePath(route, path).replace(/^\//, "");
+  let result;
+  try {
+    result = await s3Client().send(new GetObjectCommand({
+      Bucket: bucket,
+      Key: key
+    }));
+  } catch (error) {
+    if (error instanceof NoSuchKey) {
+      return {
+        statusCode: 404
+      };
+    }
+    throw error;
+  }
+  const headers = {};
+  if (result.ContentType) {
+    headers["content-type"] = result.ContentType;
+  }
+  if (result.CacheControl) {
+    headers["cache-control"] = result.CacheControl;
+  }
+  if (result.ETag) {
+    headers["etag"] = result.ETag;
+  }
+  if (method === "HEAD") {
+    return { statusCode: 200, headers };
+  }
+  return {
+    statusCode: 200,
+    headers,
+    body: await result.Body.transformToString("base64"),
+    isBase64Encoded: true
+  };
+};
+var createPreviewHandler = (props) => {
+  return async (event) => {
+    const method = event.requestContext.http.method;
+    const headers = event.headers ?? {};
+    let path = event.rawPath;
+    try {
+      path = decodeURIComponent(path);
+    } catch {}
+    if (method === "OPTIONS") {
+      return {
+        statusCode: 204,
+        headers: {
+          "access-control-allow-origin": "*",
+          "access-control-allow-methods": "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS",
+          "access-control-allow-headers": "*",
+          "access-control-max-age": "86400"
+        }
+      };
+    }
+    const route = findRoute(props, path, method);
+    if (!route) {
+      return {
+        statusCode: 404
+      };
+    }
+    if (route.type === "s3") {
+      return serveObject(route, path, method);
+    }
+    for (const [name, value] of Object.entries(route.requestHeaders ?? {})) {
+      headers[name] = value;
+    }
+    if (headers.authorization) {
+      headers["x-awsless-authorization"] = headers.authorization;
+    } else {
+      delete headers["x-awsless-authorization"];
+    }
+    if (route.forwardHost && headers.host) {
+      headers["x-forwarded-host"] = headers.host;
+    }
+    event.headers = headers;
+    event.rawPath = rewritePath(route, path);
+    return props.dispatch(event);
+  };
+};
+
+// src/feature/bundle/server/resource/util.ts
+var asyncRoute = (key, payload) => {
+  process.env.THROW_EXPECTED_ERRORS = "1";
+  return { key, payload };
+};
+var webRoute = (key, event) => {
+  const authorization = event.headers?.["x-awsless-authorization"];
+  if (typeof authorization === "string") {
+    event.headers.authorization = authorization;
+    delete event.headers["x-awsless-authorization"];
+  }
+  return { key, payload: event };
+};
+
+// src/feature/bundle/server/resource/cron.ts
+var cronHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string" && route.split(":")[1] === "cron") {
+    return asyncRoute(route, event.event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/function.ts
+var functionHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string" && route.split(":")[1] === "function") {
+    return {
+      key: route,
+      payload: event.event
+    };
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/icon.ts
+var iconHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string") {
+    if (route.split(":")[1] === "icon") {
+      return {
+        key: route,
+        payload: event.event
+      };
+    }
+    return;
+  }
+  const requestRoute = event?.headers?.["x-awsless-route"];
+  if (typeof requestRoute === "string" && requestRoute.split(":")[1] === "icon") {
+    return webRoute(requestRoute, event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/image.ts
+var imageHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string") {
+    if (route.split(":")[1] === "image") {
+      return {
+        key: route,
+        payload: event.event
+      };
+    }
+    return;
+  }
+  const requestRoute = event?.headers?.["x-awsless-route"];
+  if (typeof requestRoute === "string" && requestRoute.split(":")[1] === "image") {
+    return webRoute(requestRoute, event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/log.ts
+var logHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string") {
+    if (route.split(":")[1] === "on-error-log") {
+      return asyncRoute(route, event.event);
+    }
+    return;
+  }
+  if (typeof event?.awslogs?.data === "string") {
+    return asyncRoute(`${process.env.APP}: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") {
+    return;
+  }
+  if (event?.source === "aws.cloudwatch" && typeof event.alarmArn === "string") {
+    const alarmName = event.alarmArn.split(":alarm:").at(-1);
+    const route = alarmName.slice(process.env.APP.length + 2).split("--").join(":");
+    if (route.split(":")[1] === "metric") {
+      return asyncRoute(route, event);
+    }
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/on-failure.ts
+var onFailureHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string") {
+    if (route.split(":")[1] === "on-failure") {
+      return asyncRoute(route, event.event);
+    }
+    return;
+  }
+  if (typeof event?.headers?.["x-awsless-route"] === "string") {
+    return;
+  }
+  const record = event?.Records?.[0];
+  const eventSourceArn = record?.eventSourceARN;
+  if (record?.eventSource === "aws:sqs" && typeof eventSourceArn === "string" && eventSourceArn.endsWith(":" + process.env.APP + "--on-failure--failure")) {
+    return asyncRoute(`${process.env.APP}:on-failure:normalizer`, event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/pubsub.ts
+var eventTypes = ["connected", "disconnected", "subscribed", "unsubscribed"];
+var pubsubHandler = (event, routes) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string") {
+    if (route.split(":")[1] === "pubsub") {
+      if (eventTypes.some((type) => route.endsWith(`-${type}`))) {
+        return asyncRoute(route, event.event);
+      }
+      return {
+        key: route,
+        payload: event.event
+      };
+    }
+    return;
+  }
+  if (typeof event?.headers?.["x-awsless-route"] === "string") {
+    return;
+  }
+  const record = event?.Records?.[0];
+  if (record?.EventSource !== "aws:sns" || typeof record?.Sns?.TopicArn !== "string") {
+    return;
+  }
+  const topicName = record.Sns.TopicArn.split(":").at(-1);
+  const [, resourceType, pubsubId] = topicName.split("--");
+  if (resourceType !== "pubsub-events") {
+    return;
+  }
+  const eventType = record.Sns.MessageAttributes?.event?.Value;
+  const listeners = routes.filter((route2) => {
+    const [, type, id] = route2.split(":");
+    return type === "pubsub" && id === `${pubsubId}-${eventType}`;
+  });
+  if (!listeners.length) {
+    throw new Error(`Unknown bundle pubsub event: ${pubsubId}-${eventType}`);
+  }
+  if (listeners.length === 1) {
+    return asyncRoute(listeners[0], event);
+  }
+  return listeners.map((key) => ({ key, payload: event }));
+};
+
+// src/feature/bundle/server/resource/queue.ts
+var queueHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string") {
+    if (route.split(":")[1] === "queue") {
+      return asyncRoute(route, event.event);
+    }
+    return;
+  }
+  if (typeof event?.headers?.["x-awsless-route"] === "string") {
+    return;
+  }
+  const record = event?.Records?.[0];
+  if (record?.eventSource === "aws:sqs" && typeof record.eventSourceARN === "string") {
+    const resourceName = record.eventSourceARN.split(":").at(-1);
+    const route2 = resourceName.replace(/\.fifo$/, "").slice(process.env.APP.length + 2).split("--").join(":");
+    if (route2.split(":")[1] === "queue") {
+      return asyncRoute(route2, event);
+    }
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/rest.ts
+var restHandler = (event) => {
+  if (typeof event?.["$awsless-route"] === "string") {
+    return;
+  }
+  const route = event?.headers?.["x-awsless-route"];
+  if (typeof route === "string" && route.split(":")[1] === "rest") {
+    return webRoute(route, event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/rpc.ts
+var rpcHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string") {
+    if (route.split(":")[1] === "rpc") {
+      return {
+        key: route,
+        payload: event.event
+      };
+    }
+    return;
+  }
+  const requestRoute = event?.headers?.["x-awsless-route"];
+  if (typeof requestRoute === "string" && requestRoute.split(":")[1] === "rpc") {
+    return webRoute(requestRoute, event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/site.ts
+var siteHandler = (event) => {
+  if (typeof event?.["$awsless-route"] === "string") {
+    return;
+  }
+  const route = event?.headers?.["x-awsless-route"];
+  if (typeof route === "string" && route.split(":")[1] === "site") {
+    return webRoute(route, event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/store.ts
+var storeHandler = (event) => {
+  const requestedRoute = event?.["$awsless-route"];
+  if (typeof requestedRoute === "string") {
+    if (requestedRoute.split(":")[1] === "store") {
+      return asyncRoute(requestedRoute, event.event);
+    }
+    return;
+  }
+  if (typeof event?.headers?.["x-awsless-route"] === "string") {
+    return;
+  }
+  const record = event?.Records?.[0];
+  const route = record?.s3?.configurationId;
+  if (record?.eventSource === "aws:s3" && typeof route === "string" && route.split(":")[1] === "store") {
+    return asyncRoute(route, event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/table.ts
+var tableHandler = (event) => {
+  if (typeof event?.["$awsless-route"] === "string" || typeof event?.headers?.["x-awsless-route"] === "string") {
+    return;
+  }
+  const record = event?.Records?.[0];
+  if (record?.eventSource === "aws:dynamodb" && typeof record.eventSourceARN === "string") {
+    const tableName = record.eventSourceARN.split("/")[1];
+    const route = tableName.slice(process.env.APP.length + 2).split("--").join(":");
+    if (route.split(":")[1] === "table") {
+      return asyncRoute(route, event);
+    }
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/task.ts
+var taskHandler = (event) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string" && route.split(":")[1] === "task") {
+    return asyncRoute(route, event.event);
+  }
+  return;
+};
+
+// src/feature/bundle/server/resource/topic.ts
+var topicHandler = (event, routes) => {
+  const route = event?.["$awsless-route"];
+  if (typeof route === "string") {
+    if (route.split(":")[1] === "topic") {
+      return asyncRoute(route, event.event);
+    }
+    return;
+  }
+  if (typeof event?.headers?.["x-awsless-route"] === "string") {
+    return;
+  }
+  const record = event?.Records?.[0];
+  if (record?.EventSource !== "aws:sns" || typeof record?.Sns?.TopicArn !== "string") {
+    return;
+  }
+  const topicId = record.Sns.TopicArn.split(":").at(-1).split("--").at(-1);
+  const subscribers = routes.filter((route2) => {
+    const [, type, id] = route2.split(":");
+    return type === "topic" && id === topicId;
+  });
+  if (!subscribers.length) {
+    throw new Error(`Unknown bundle topic: ${topicId}`);
+  }
+  if (subscribers.length === 1) {
+    return asyncRoute(subscribers[0], event);
+  }
+  return subscribers.map((key) => ({ key, payload: event }));
+};
+
+// src/feature/bundle/server/handle.ts
+var createBundle = (handlers) => {
+  const routes = Object.keys(handlers);
+  let previewConfig;
+  const matchers = [
+    functionHandler,
+    cronHandler,
+    iconHandler,
+    imageHandler,
+    metricHandler,
+    onFailureHandler,
+    logHandler,
+    queueHandler,
+    pubsubHandler,
+    topicHandler,
+    taskHandler,
+    restHandler,
+    rpcHandler,
+    siteHandler,
+    storeHandler,
+    tableHandler
+  ];
+  const matchRoute = (event) => {
+    delete process.env.THROW_EXPECTED_ERRORS;
+    for (const matcher of matchers) {
+      const match = matcher(event, routes);
+      if (match) {
+        return match;
+      }
+    }
+    const route = event?.["$awsless-route"] ?? event?.headers?.["x-awsless-route"];
+    throw new Error("Unknown bundle route: " + route);
+  };
+  return async (event, context) => {
+    const handleRoute = (match2) => {
+      const load = handlers[match2.key];
+      if (!load) {
+        throw new Error("Unknown bundle route: " + match2.key);
+      }
+      process.env.AWSLESS_ROUTE = match2.key;
+      return withRoute(match2.key, invokeRoute, async () => {
+        const handle = await load();
+        return handle(match2.payload ?? {}, context);
+      });
+    };
+    const invokeRoute = async (key, payload) => {
+      const caller = getCurrentRoute();
+      const throwExpectedErrors = process.env.THROW_EXPECTED_ERRORS;
+      let result;
+      try {
+        const match2 = matchRoute(formatRoutePayload(key, unpatch(payload ?? {})));
+        if (Array.isArray(match2)) {
+          throw new Error("Unknown bundle route: " + key);
+        }
+        result = await handleRoute(match2);
+      } finally {
+        if (caller) {
+          process.env.AWSLESS_ROUTE = caller;
+          if (throwExpectedErrors) {
+            process.env.THROW_EXPECTED_ERRORS = throwExpectedErrors;
+          } else {
+            delete process.env.THROW_EXPECTED_ERRORS;
+          }
+        }
+      }
+      const response = result === undefined ? undefined : patch(result);
+      if (isErrorResponse(response)) {
+        throw new ExpectedError(response.__error__.type, response.__error__.message);
+      }
+      return response;
+    };
+    const raw = event;
+    if (process.env.AWSLESS_PREVIEW && raw?.requestContext?.http && !event?.headers?.["x-awsless-route"]) {
+      previewConfig ??= JSON.parse(process.env.AWSLESS_PREVIEW);
+      return createPreviewHandler({
+        ...previewConfig,
+        dispatch: async (event2) => {
+          const match2 = matchRoute(event2);
+          if (Array.isArray(match2)) {
+            throw new Error("Unknown bundle route");
+          }
+          return handleRoute(match2);
+        }
+      })(event);
+    }
+    const match = matchRoute(event);
+    if (Array.isArray(match)) {
+      const name = `${process.env.AWS_LAMBDA_FUNCTION_NAME}:${process.env.AWS_LAMBDA_FUNCTION_VERSION}`;
+      await Promise.all(match.map((route) => invoke({
+        name,
+        type: "Event",
+        payload: formatRoutePayload(route.key, route.payload)
+      })));
+      return;
+    }
+    return handleRoute(match);
+  };
+};
+export {
+  createBundle
+};

package/dist/handlers/icon.mjs

@@ -0,0 +1,104 @@
+// src/feature/icon/server/handle.ts
+import { getObject, putObject } from "@awsless/s3";
+import { getRouteEnv, invokeRoute } from "awsless";
+import { optimize } from "svgo/browser";
+import svgstore from "svgstore";
+var handle_default = async (event) => {
+  try {
+    const path = event.rawPath.startsWith("/") ? event.rawPath.slice(1) : event.rawPath;
+    const bucket = getRouteEnv("ICON_BUCKET");
+    const folder = getRouteEnv("ICON_FOLDER") ?? "";
+    const cacheKey = `${folder}cache/${path}`;
+    if (bucket) {
+      const cachedIcon = await getObject({
+        bucket,
+        key: cacheKey
+      });
+      if (cachedIcon) {
+        const cachedIconData = await cachedIcon.body.transformToByteArray();
+        return {
+          statusCode: 200,
+          body: Buffer.from(cachedIconData).toString("base64"),
+          isBase64Encoded: true,
+          headers: {
+            "Content-Type": "image/svg+xml",
+            "Cache-Control": "public, max-age=31536000, immutable"
+          }
+        };
+      }
+    }
+    const configsEnv = getRouteEnv("ICON_CONFIG");
+    if (!configsEnv) {
+      throw new Error("Icon config not found in environment variables");
+    }
+    const config = JSON.parse(configsEnv);
+    let baseIcon;
+    if (getRouteEnv("ICON_ORIGIN_S3")) {
+      const result = await getObject({
+        bucket,
+        key: `${folder}origin/${path}`
+      });
+      if (result?.body) {
+        const data2 = await result.body.transformToByteArray();
+        baseIcon = Buffer.from(data2);
+      }
+    }
+    const originRoute = getRouteEnv("ICON_ORIGIN");
+    if (!baseIcon && originRoute) {
+      const result = await invokeRoute(originRoute, { path });
+      if (typeof result === "string") {
+        baseIcon = Buffer.from(result);
+      } else if (result === undefined) {
+        return { statusCode: 404 };
+      } else {
+        throw new Error("Invalid response from icon origin lambda");
+      }
+    }
+    if (!baseIcon) {
+      return { statusCode: 404 };
+    }
+    const { data } = optimize(baseIcon.toString("utf-8"), {
+      multipass: true,
+      plugins: [
+        {
+          name: "preset-default",
+          params: {
+            overrides: {
+              ...config.preserveIds ? {
+                cleanupIds: false
+              } : {}
+            }
+          }
+        }
+      ]
+    });
+    let icon = data;
+    if (config.symbols) {
+      const symbols = svgstore();
+      symbols.add("default", data);
+      icon = symbols.toString({ inline: true });
+    }
+    await putObject({
+      bucket,
+      key: cacheKey,
+      body: icon,
+      contentType: "image/svg+xml",
+      cacheControl: "public, max-age=31536000, immutable"
+    });
+    return {
+      statusCode: 200,
+      body: Buffer.from(icon).toString("base64"),
+      isBase64Encoded: true,
+      headers: {
+        "Content-Type": "image/svg+xml",
+        "Cache-Control": "public, max-age=31536000, immutable"
+      }
+    };
+  } catch (error) {
+    console.error(error);
+    return { statusCode: 500 };
+  }
+};
+export {
+  handle_default as default
+};