@awsless/cli 0.0.46-next.2 → 0.0.46-next.21

package/dist/handlers/icon.mjs

@@ -1,104 +0,0 @@
-// 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
-};

package/dist/handlers/on-failure.mjs

@@ -1,216 +0,0 @@
-// src/feature/on-failure/server/handle.ts
-import { parse as parse2, patch } from "@awsless/json";
-import { invoke } from "@awsless/lambda";
-import { deleteObject, getObject } from "@awsless/s3";
-import { formatRoutePayload, getRouteEnv } from "awsless";
-
-// 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 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 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 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 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;
-  }
-};
-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

@@ -1,43 +0,0 @@
-// 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
-};