@awsless/cli 0.0.42 → 0.0.44

package/dist/bin.js

@@ -1507,6 +1507,66 @@ var InstanceDefaultSchema = z20.object({
 // src/feature/router/schema.ts
 import { days as days3, minutes as minutes2, parse as parse3 } from "@awsless/duration";
 import { z as z21 } from "zod";
+
+// 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 root2 = pattern.split("/")[1] ?? "";
+  if (root2 === "" || root2.includes("*") || root2.includes("{")) {
+    throw new ExpectedError(
+      `The first path segment of route pattern "${pattern}" must be static when the pattern contains params or wildcards.`
+    );
+  }
+  if (root2.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 === `/${root2}/*`) {
+    return { key: pattern };
+  }
+  return {
+    key: `/${root2}/*`,
+    match: `^${regex}$`,
+    params: params.length > 0 ? params : void 0
+  };
+};
+
+// src/feature/router/schema.ts
 var ErrorResponsePathSchema = z21.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.",
@@ -1536,6 +1596,28 @@ var ErrorResponseSchema = z21.union([
   })
 ]).optional();
 var RouteSchema = z21.string().regex(/^\//, "Route must start with a slash (/)");
+var RoutesSchema = z21.record(
+  ResourceIdSchema.describe("The router id to add your routes to."),
+  z21.record(RouteSchema, FunctionSchema).superRefine((routes, ctx) => {
+    for (const pattern of Object.keys(routes)) {
+      try {
+        compileRoutePattern(pattern);
+      } catch (error) {
+        ctx.addIssue({
+          code: z21.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 = z21.boolean().default(false).describe("Whether to enable CloudWatch metrics for the WAF rule.");
 var WafSettingsSchema = z21.object({
   rateLimiter: z21.object({
@@ -2649,6 +2731,7 @@ var StackSchema = z45.object({
   // auth: AuthSchema,
   // http: HttpSchema,
   rest: RestSchema,
+  routes: RoutesSchema,
   rpc: RpcSchema,
   configs: ConfigsSchema,
   crons: CronsSchema,
@@ -9076,7 +9159,7 @@ var metricFeature = defineFeature({
 import { days as days12, seconds as seconds12, toSeconds as toSeconds12, years } from "@awsless/duration";
 import { Future, Group as Group31 } from "@terraforge/core";
 import { aws as aws32 } from "@terraforge/aws";
-import { camelCase as camelCase9, constantCase as constantCase16 } from "change-case";
+import { camelCase as camelCase9, constantCase as constantCase16, kebabCase as kebabCase9 } from "change-case";
 
 // src/feature/router/router-code.ts
 var getViewerRequestFunctionCode = (props) => {
@@ -9166,20 +9249,74 @@ function isValidRoute(route, method) {
 	return true;
 }
 
+function matchRoute(value, path, method) {
+	const list = Array.isArray(value) ? value : [value];
+
+	for(const i in list) {
+		const route = list[i];
+
+		if(!isValidRoute(route, method)) {
+			continue;
+		}
+
+		if(route.match) {
+			const found = path.match(new RegExp(route.match));
+
+			if(!found) {
+				continue;
+			}
+
+			const params = {};
+
+			if(route.params) {
+				for(const p in route.params) {
+					params[route.params[p]] = found[Number(p) + 1];
+				}
+			}
+
+			return { route, params };
+		}
+
+		return { route };
+	}
+}
+
 async function findRoute(path, method) {
 	const store = cf.kvs();
 	const keys = getPossibleRouteKeys(path);
 
 	for(const i in keys) {
 		const key = keys[i];
+		let value;
 
 		try {
-			const route = await store.get(key, { format: 'json' });
+			value = await store.get(key, { format: 'json' });
+		} catch (e) {
+			continue;
+		}
 
-			if(isValidRoute(route, method)) {
-				return route;
+		// Route lists that are too big for a single key value pair
+		// are sharded over multiple entries behind a route index.
+		if(value && value.list) {
+			for(let n = 0; n < value.list; n++) {
+				try {
+					const route = await store.get(key + '#' + n, { format: 'json' });
+					const result = matchRoute(route, path, method);
+
+					if(result) {
+						return result;
+					}
+				} catch (e) {}
 			}
-		} catch (e) {}
+
+			continue;
+		}
+
+		const result = matchRoute(value, path, method);
+
+		if(result) {
+			return result;
+		}
 	}
 }
 
@@ -9284,11 +9421,19 @@ async function handler(event) {
 
 	${injection.join("\n")}
 
-	const route = await findRoute(path, request.method);
+	const result = await findRoute(path, request.method);
+
+	if(result) {
+		const route = result.route;
 
-	if(route) {
 		setRouteOrigin(route);
 
+		if(result.params) {
+			for(const name in result.params) {
+				headers['x-param-' + name.toLowerCase()] = { value: encodeURIComponent(result.params[name]) };
+			}
+		}
+
 		if(route.forwardHost && headers.host && headers.host.value) {
 			headers['x-forwarded-host'] = { value: headers.host.value };
 		}
@@ -9325,6 +9470,32 @@ async function handler(event) {
 
 // src/feature/router/index.ts
 import { createHash as createHash8 } from "crypto";
+
+// src/feature/router/route.ts
+var MAX_VALUE_SIZE = 1e3;
+var createRouteStoreEntries = (routes) => {
+  const entries = [];
+  for (const [key, value] of Object.entries(routes)) {
+    const json = JSON.stringify(value);
+    if (Array.isArray(value) && Buffer.byteLength(json, "utf8") > MAX_VALUE_SIZE) {
+      entries.push({
+        key,
+        value: JSON.stringify({ list: value.length })
+      });
+      value.forEach((route, index) => {
+        entries.push({
+          key: `${key}#${index}`,
+          value: JSON.stringify(route)
+        });
+      });
+    } else {
+      entries.push({ key, value: json });
+    }
+  }
+  return entries;
+};
+
+// src/feature/router/index.ts
 var routerFeature = defineFeature({
   name: "router",
   onApp(ctx) {
@@ -9354,9 +9525,7 @@ var routerFeature = defineFeature({
           {
             kvsArn: routeStore.arn,
             keys: $resolve([routes], (routes2) => {
-              return Object.entries(routes2).map(([key, value]) => {
-                return { key, value: JSON.stringify(value) };
-              });
+              return createRouteStoreEntries(routes2);
             })
           },
           {
@@ -9717,6 +9886,67 @@ var routerFeature = defineFeature({
         ctx.bind(`ROUTER_${constantCase16(id)}_ENDPOINT`, domainName);
       }
     }
+  },
+  onStack(ctx) {
+    for (const [id, routes] of Object.entries(ctx.stackConfig.routes ?? {})) {
+      if (!ctx.appConfig.defaults.router?.[id]) {
+        throw new FileError(ctx.stackConfig.file, `Router "${id}" is not defined on the app level.`);
+      }
+      const group = new Group31(ctx.stack, "routes", id);
+      const addRoutes = ctx.shared.entry("router", "addRoutes", id);
+      const addInvalidation = ctx.shared.entry("router", "addInvalidation", id);
+      const grouped = {};
+      const invalidationPaths = /* @__PURE__ */ new Set();
+      const versions = [];
+      for (const [pattern, props] of Object.entries(routes)) {
+        const compiled = compileRoutePattern(pattern);
+        const slug = pattern.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 20);
+        const entryId = kebabCase9(`${slug || "root"}-${shortId(pattern)}`);
+        const routeGroup = new Group31(group, "route", entryId);
+        const result = createLambdaFunction(routeGroup, ctx, "route", entryId, props);
+        versions.push(result.code.sourceHash);
+        ctx.onBind((name, value) => {
+          result.setEnvironment(name, value);
+        });
+        new aws32.lambda.Permission(routeGroup, "permission", {
+          principal: "cloudfront.amazonaws.com",
+          action: "lambda:InvokeFunctionUrl",
+          functionName: result.lambda.functionName,
+          functionUrlAuthType: "AWS_IAM",
+          sourceArn: `arn:aws:cloudfront::${ctx.accountId}:*`
+        });
+        new aws32.lambda.Permission(routeGroup, "invoke-permission", {
+          principal: "cloudfront.amazonaws.com",
+          action: "lambda:InvokeFunction",
+          functionName: result.lambda.functionName,
+          sourceArn: `arn:aws:cloudfront::${ctx.accountId}:*`
+        });
+        const url = new aws32.lambda.FunctionUrl(routeGroup, "url", {
+          functionName: result.lambda.functionName,
+          authorizationType: "AWS_IAM"
+        });
+        grouped[compiled.key] ??= [];
+        grouped[compiled.key].push({
+          type: "lambda",
+          domainName: url.functionUrl.pipe((url2) => url2.split("/")[2]),
+          forwardHost: true,
+          urlEncodedQueryString: true,
+          match: compiled.match,
+          params: compiled.params
+        });
+        invalidationPaths.add(compiled.key);
+      }
+      const merged = {};
+      for (const [key, list3] of Object.entries(grouped)) {
+        if (list3.length === 1) {
+          merged[key] = list3[0];
+        } else {
+          merged[key] = [...list3.filter((route) => route.match), ...list3.filter((route) => !route.match)];
+        }
+      }
+      addRoutes(group, "routes", merged);
+      addInvalidation(group, "invalidate", [...invalidationPaths], versions);
+    }
   }
 });
 

package/dist/build-json-schema.js

@@ -561,6 +561,70 @@ var InstanceDefaultSchema = z16.object({
 // src/feature/router/schema.ts
 import { days as days3, minutes as minutes2, parse as parse3 } from "@awsless/duration";
 import { z as z17 } 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 = z17.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.",
@@ -590,6 +654,28 @@ var ErrorResponseSchema = z17.union([
   })
 ]).optional();
 var RouteSchema = z17.string().regex(/^\//, "Route must start with a slash (/)");
+var RoutesSchema = z17.record(
+  ResourceIdSchema.describe("The router id to add your routes to."),
+  z17.record(RouteSchema, FunctionSchema).superRefine((routes, ctx) => {
+    for (const pattern of Object.keys(routes)) {
+      try {
+        compileRoutePattern(pattern);
+      } catch (error) {
+        ctx.addIssue({
+          code: z17.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 = z17.boolean().default(false).describe("Whether to enable CloudWatch metrics for the WAF rule.");
 var WafSettingsSchema = z17.object({
   rateLimiter: z17.object({
@@ -1702,6 +1788,7 @@ var StackSchema = z41.object({
   // auth: AuthSchema,
   // http: HttpSchema,
   rest: RestSchema,
+  routes: RoutesSchema,
   rpc: RpcSchema,
   configs: ConfigsSchema,
   crons: CronsSchema,