@awsless/cli 0.0.46-next.1 → 0.0.46-next.10

package/dist/build-json-schema.js

@@ -237,7 +237,7 @@ var CodeSchema = z10.union([
 var FnSchema = z10.object({
   code: CodeSchema,
   handler: HandlerSchema.optional()
-});
+}).strict();
 var FunctionSchema = z10.union([
   LocalFileSchema.transform((code) => ({
     code
@@ -483,6 +483,70 @@ var InstanceDefaultSchema = z15.object({
 // src/feature/router/schema.ts
 import { days as days3, minutes as minutes2, parse as parse3 } from "@awsless/duration";
 import { z as z16 } from "zod";
+
+// src/error.ts
+var ExpectedError = class extends Error {
+};
+
+// src/feature/router/pattern.ts
+var PARAM_TOKEN = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}|\*/g;
+var escapeRegex = (value) => {
+  return value.replace(/[|\\{}()[\]^$+*?.\-]/g, "\\$&");
+};
+var compileRoutePattern = (pattern) => {
+  if (!pattern.startsWith("/")) {
+    throw new ExpectedError(`Route pattern "${pattern}" must start with a slash (/)`);
+  }
+  if (pattern === "/*") {
+    return { key: pattern };
+  }
+  const params = [];
+  let regex = "";
+  let stars = 0;
+  let last = 0;
+  let token;
+  PARAM_TOKEN.lastIndex = 0;
+  while (token = PARAM_TOKEN.exec(pattern)) {
+    regex += escapeRegex(pattern.slice(last, token.index));
+    const param = token[1];
+    if (param) {
+      if (params.includes(param)) {
+        throw new ExpectedError(`Duplicate param "${param}" in route pattern "${pattern}"`);
+      }
+      params.push(param);
+      regex += "([^/]+)";
+    } else {
+      stars++;
+      regex += ".*";
+    }
+    last = PARAM_TOKEN.lastIndex;
+  }
+  if (params.length === 0 && stars === 0) {
+    return { key: pattern };
+  }
+  regex += escapeRegex(pattern.slice(last));
+  const root = pattern.split("/")[1] ?? "";
+  if (root === "" || root.includes("*") || root.includes("{")) {
+    throw new ExpectedError(
+      `The first path segment of route pattern "${pattern}" must be static when the pattern contains params or wildcards.`
+    );
+  }
+  if (root.includes(".")) {
+    throw new ExpectedError(
+      `The first path segment of route pattern "${pattern}" can't contain a dot when the pattern contains params or wildcards.`
+    );
+  }
+  if (params.length === 0 && pattern === `/${root}/*`) {
+    return { key: pattern };
+  }
+  return {
+    key: `/${root}/*`,
+    match: `^${regex}$`,
+    params: params.length > 0 ? params : void 0
+  };
+};
+
+// src/feature/router/schema.ts
 var ErrorResponsePathSchema = z16.string().describe(
   [
     "The path to the custom error page that you want to return to the viewer when your origin returns the HTTP status code specified.",
@@ -511,7 +575,29 @@ var ErrorResponseSchema = z16.union([
     minTTL: MinTTLSchema.optional()
   })
 ]).optional();
-var RouteSchema = z16.string().regex(/^\//, "Route must start with a slash (/)");
+var RouteSchema = z16.string().regex(/^\//, "Route must start with a slash (/)").regex(/^\/([^/*.]+)?$/, 'Router paths mount a single segment without dots, like "/api".');
+var RoutesSchema = z16.record(
+  ResourceIdSchema.describe("The router id to add your routes to."),
+  z16.record(z16.string().regex(/^\//, "Route must start with a slash (/)"), FunctionSchema).superRefine((routes, ctx) => {
+    for (const pattern of Object.keys(routes)) {
+      try {
+        compileRoutePattern(pattern);
+      } catch (error) {
+        ctx.addIssue({
+          code: z16.ZodIssueCode.custom,
+          path: [pattern],
+          message: error instanceof Error ? error.message : `Invalid route pattern: ${pattern}`
+        });
+      }
+    }
+  }).describe(
+    [
+      "Define the routes and the lambda function that should handle them.",
+      'Routes can be an exact path like "/sitemap.xml", a wildcard like "/sitemap/*", or contain params like "/sitemap/{locale}/{page}.xml".',
+      'Param values are passed to the function as "x-param-[NAME]" request headers.'
+    ].join("\n")
+  )
+).optional().describe("Add routes to your global Router that link a path pattern to a lambda function.");
 var VisibilitySchema = z16.boolean().default(false).describe("Whether to enable CloudWatch metrics for the WAF rule.");
 var WafSettingsSchema = z16.object({
   rateLimiter: z16.object({
@@ -1009,8 +1095,8 @@ var AppSchema = z25.object({
     layers: LayerSchema,
     router: RouterDefaultSchema
     // dataRetention: z.boolean().describe('Configure how your resources are handled on delete.').default(false),
-  }).default({}).describe("Default properties")
-});
+  }).strict().default({}).describe("Default properties")
+}).strict();
 
 // src/config/stack.ts
 import { z as z41 } from "zod";
@@ -1066,7 +1152,7 @@ var CommandsSchema = z27.record(ResourceIdSchema, CommandSchema).optional().desc
 
 // src/feature/config/schema.ts
 import { z as z28 } from "zod";
-var ConfigNameSchema = z28.string().regex(/[a-z0-9\-]/g, "Invalid config name");
+var ConfigNameSchema = z28.string().regex(/^[a-z0-9-]+$/, "Invalid config name");
 var ConfigsSchema = z28.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
 
 // src/feature/cron/schema/index.ts
@@ -1619,14 +1705,13 @@ var TestsSchema = z40.union([
 ]).describe("Define the location of your tests for your stack.").optional();
 
 // src/config/stack.ts
-var DependsSchema = ResourceIdSchema.array().optional().describe("Define the stacks that this stack is depended on.");
 var NameSchema = ResourceIdSchema.refine((name) => !["base", "hostedzones"].includes(name), {
   message: `Stack name can't be a reserved name.`
 }).describe("Stack name.");
 var StackSchema = z41.object({
   $schema: z41.string().optional(),
   name: NameSchema,
-  depends: DependsSchema,
+  routes: RoutesSchema,
   commands: CommandsSchema,
   // auth: AuthSchema,
   // http: HttpSchema,
@@ -1652,7 +1737,7 @@ var StackSchema = z41.object({
   images: ImagesSchema,
   icons: IconsSchema,
   metrics: MetricsSchema
-});
+}).strict();
 
 // src/config/stage-patch-json-schema.ts
 var clone = (value) => {

package/dist/handlers/{bundle.mjs → bundle.js}

@@ -3,128 +3,6 @@ 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";
@@ -434,7 +312,6 @@ var topicHandler = (event, routes) => {
 // src/feature/bundle/server/handle.ts
 var createBundle = (handlers) => {
   const routes = Object.keys(handlers);
-  let previewConfig;
   const matchers = [
     functionHandler,
     cronHandler,
@@ -473,7 +350,8 @@ var createBundle = (handlers) => {
       process.env.AWSLESS_ROUTE = match2.key;
       return withRoute(match2.key, invokeRoute, async () => {
         const handle = await load();
-        return handle(match2.payload ?? {}, context);
+        const routedContext = { ...context, route: match2.key };
+        return handle(match2.payload ?? {}, routedContext);
       });
     };
     const invokeRoute = async (key, payload) => {
@@ -502,20 +380,6 @@ var createBundle = (handlers) => {
       }
       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}`;

package/dist/handlers/{on-failure.mjs → on-failure.js}

@@ -1,8 +1,81 @@
 // src/feature/on-failure/server/handle.ts
-import { parse, patch } from "@awsless/json";
+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)}`);
@@ -28,13 +101,16 @@ var sqsRecord = async (record, context) => {
     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: parsePayload(record.body),
+    payload: body,
+    source: queueName ? { resource: logicalResourceName(queueName), event: body } : undefined,
     queue: {
-      name: record.messageAttributes.queueName?.stringValue,
+      name: queueName,
       url: record.messageAttributes.queueUrl?.stringValue
     }
   };
@@ -70,9 +146,6 @@ var s3Record = async (record, context) => {
     key
   });
 };
-var isDynamoDBFailureEvent = (event) => {
-  return "DDBStreamBatchInfo" in event;
-};
 var formatUnknownFailureEvent = (event) => {
   if (isDynamoDBFailureEvent(event)) {
     return formatDynamoDBStreamFailureEvent(event);
@@ -90,6 +163,7 @@ var formatAsyncLambdaFailureEvent = (event) => {
       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,
@@ -98,6 +172,9 @@ var formatAsyncLambdaFailureEvent = (event) => {
   };
 };
 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),
@@ -105,12 +182,13 @@ var formatDynamoDBStreamFailureEvent = (event) => {
     function: {
       name: event.requestContext.functionArn.split(":")[6]
     },
-    payload: parsePayload(event.payload)
+    payload,
+    source: table ? { resource: logicalResourceName(table) } : getFailureSource(payload)
   };
 };
 var parsePayload = (payload) => {
   try {
-    return parse(payload);
+    return parse2(payload);
   } catch {
     return payload;
   }