@awsless/cli 0.0.46-next.7 → 0.0.46-next.9

package/dist/bin.js

@@ -2234,6 +2234,66 @@ var InstanceDefaultSchema = z19.object({
 // src/feature/router/schema.ts
 import { days as days3, minutes as minutes2, parse as parse3 } from "@awsless/duration";
 import { z as z20 } 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 = z20.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.",
@@ -2263,6 +2323,28 @@ var ErrorResponseSchema = z20.union([
   })
 ]).optional();
 var RouteSchema = z20.string().regex(/^\//, "Route must start with a slash (/)").regex(/^\/([^/*.]+)?$/, 'Router paths mount a single segment without dots, like "/api".');
+var RoutesSchema = z20.record(
+  ResourceIdSchema.describe("The router id to add your routes to."),
+  z20.record(z20.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: z20.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 = z20.boolean().default(false).describe("Whether to enable CloudWatch metrics for the WAF rule.");
 var WafSettingsSchema = z20.object({
   rateLimiter: z20.object({
@@ -3371,14 +3453,13 @@ var TestsSchema = z44.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 = z45.object({
   $schema: z45.string().optional(),
   name: NameSchema,
-  depends: DependsSchema,
+  routes: RoutesSchema,
   commands: CommandsSchema,
   // auth: AuthSchema,
   // http: HttpSchema,
@@ -4480,11 +4561,6 @@ var bundleFeature = defineFeature({
       addLayer,
       addPermission
     });
-  },
-  onStack(ctx) {
-    const bundle = ctx.shared.get("bundle", "main");
-    ctx.onEnv(bundle.addEnv);
-    ctx.onPermission(bundle.addPermission);
   }
 });
 
@@ -4795,7 +4871,7 @@ var configFeature = defineFeature({
       ctx.addEnv(`CONFIG_${constantCase4(name)}`, name);
     }
     if (configs.length) {
-      ctx.addStackPermission({
+      ctx.addGlobalPermission({
         actions: [
           "ssm:GetParameter",
           "ssm:GetParameters",
@@ -6397,7 +6473,7 @@ var queueFeature = defineFeature({
         });
       }
       ctx.addEnv(`QUEUE_${constantCase6(ctx.stack.name)}_${constantCase6(id)}_URL`, queue2.url);
-      ctx.addStackPermission({
+      ctx.addGlobalPermission({
         actions: [
           "sqs:SendMessage",
           "sqs:ReceiveMessage",
@@ -6757,7 +6833,7 @@ var searchFeature = defineFeature({
         }
       );
       ctx.addEnv(`SEARCH_${constantCase8(ctx.stack.name)}_${constantCase8(id)}_DOMAIN`, openSearch.endpointV2);
-      ctx.addStackPermission({
+      ctx.addGlobalPermission({
         actions: ["es:ESHttp*"],
         resources: [
           //
@@ -8677,13 +8753,13 @@ var jobFeature = defineFeature({
       const group = new Group25(ctx.stack, "job", id);
       createFargateJob(group, ctx, "job", id, props);
     }
-    ctx.addStackPermission({
+    ctx.addGlobalPermission({
       actions: ["ecs:RunTask"],
       resources: [
         `arn:aws:ecs:${ctx.appConfig.region}:*:task-definition/${ctx.app.name}--${ctx.stackConfig.name}--*`
       ]
     });
-    ctx.addStackPermission({
+    ctx.addGlobalPermission({
       actions: ["iam:PassRole"],
       resources: ["*"],
       conditions: {
@@ -9220,7 +9296,7 @@ var metricFeature = defineFeature({
   onStack(ctx) {
     const bundle = ctx.shared.get("bundle", "main");
     const namespace = `awsless/${kebabCase11(ctx.app.name)}/${kebabCase11(ctx.stack.name)}`;
-    ctx.addStackPermission({
+    ctx.addGlobalPermission({
       actions: ["cloudwatch:PutMetricData"],
       resources: ["*"],
       conditions: {
@@ -9299,7 +9375,7 @@ var metricFeature = defineFeature({
 import { days as days10, seconds as seconds7, toSeconds as toSeconds13, years } from "@awsless/duration";
 import { Group as Group29 } from "@terraforge/core";
 import { aws as aws30 } from "@terraforge/aws";
-import { camelCase as camelCase9, constantCase as constantCase15 } from "change-case";
+import { camelCase as camelCase9, constantCase as constantCase15, kebabCase as kebabCase12 } from "change-case";
 
 // src/feature/router/router-code.ts
 import { minutes as minutes8, seconds as seconds6, toSeconds as toSeconds12 } from "@awsless/duration";
@@ -9498,6 +9574,38 @@ 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: route, params: params };
+		}
+
+		return { route: route };
+	}
+}
+
 async function findRoute(path, method, prefix) {
 	// only route selection is normalized, the forwarded uri stays untouched
 	if (path.length > 1 && path.slice(-1) === '/') {
@@ -9509,14 +9617,34 @@ async function findRoute(path, method, prefix) {
 
 	for(const i in keys) {
 		const key = keys[i];
+		let value;
 
 		try {
-			const route = await store.get(prefix + key, { format: 'json' });
+			value = await store.get(prefix + key, { format: 'json' });
+		} catch (e) {
+			continue;
+		}
+
+		// 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(prefix + key + '#' + n, { format: 'json' });
+					const result = matchRoute(route, path, method);
+
+					if(result) {
+						return result;
+					}
+				} catch (e) {}
+			}
+		} else {
+			const result = matchRoute(value, path, method);
 
-			if(isValidRoute(route, method)) {
-				return route;
+			if(result) {
+				return result;
 			}
-		} catch (e) {}
+		}
 	}
 }
 
@@ -9639,15 +9767,36 @@ async function handler(event) {
 
 	${prefixCode}
 
-	const route = await findRoute(path, request.method, prefix);
+	const result = await findRoute(path, request.method, prefix);
 
-	if(!route) {
+	if(!result) {
 		return {
 			statusCode: 404,
 			statusDescription: 'Not Found'
 		};
 	}
 
+	const route = result.route;
+
+	// A client provided param header can never reach the origin.
+	const spoofed = [];
+
+	for(const name in headers) {
+		if(name.indexOf('x-param-') === 0) {
+			spoofed.push(name);
+		}
+	}
+
+	for(const i in spoofed) {
+		delete headers[spoofed[i]];
+	}
+
+	if(result.params) {
+		for(const name in result.params) {
+			headers['x-param-' + name.toLowerCase()] = { value: encodeURIComponent(result.params[name]) };
+		}
+	}
+
 	if(route.requestHeaders) {
 		for(const name in route.requestHeaders) {
 			headers[name] = { value: route.requestHeaders[name] };
@@ -9700,6 +9849,31 @@ async function handler(event) {
 `;
 
 // src/feature/router/index.ts
+var MAX_VALUE_SIZE = 1e3;
+var ORIGIN_PLACEHOLDER = "x".repeat(64);
+var assertRouteValueSize = (key, route) => {
+  const withOrigin = (entry) => {
+    return entry.type === "lambda" ? { ...entry, domainName: ORIGIN_PLACEHOLDER } : entry;
+  };
+  for (const entry of Array.isArray(route) ? route : [route]) {
+    if (Buffer.byteLength(JSON.stringify(withOrigin(entry)), "utf8") > MAX_VALUE_SIZE) {
+      throw new ExpectedError(`The route value of the "${key}" route key is too large.`);
+    }
+  }
+};
+var createRouteStoreEntries = (key, route) => {
+  const value = JSON.stringify(route);
+  if (!Array.isArray(route) || Buffer.byteLength(value, "utf8") <= MAX_VALUE_SIZE) {
+    return [{ key, value }];
+  }
+  return [
+    { key, value: JSON.stringify({ list: route.length }) },
+    ...route.map((entry, index) => ({
+      key: `${key}#${index}`,
+      value: JSON.stringify(entry)
+    }))
+  ];
+};
 var routerFeature = defineFeature({
   name: "router",
   onApp(ctx) {
@@ -9745,12 +9919,13 @@ var routerFeature = defineFeature({
           if (Object.hasOwn(routes, `${id}:${key}`)) {
             throw new ExpectedError(`Duplicate route key: ${key} in the "${id}" router`);
           }
+          assertRouteValueSize(`${id}:${key}`, route);
           routes[`${id}:${key}`] = route;
         }
         for (const dependency of options?.dependsOn ?? []) {
           routeDependencies.add(dependency);
         }
-        if (Object.values(newRoutes).some((route) => route.type === "lambda")) {
+        if (Object.values(newRoutes).flat().some((route) => route.type === "lambda")) {
           hasLambdaRoutes = true;
         }
       });
@@ -10152,12 +10327,15 @@ var routerFeature = defineFeature({
               storeArn: routeStore.arn,
               functionVersion: bundle.lambda.version,
               routes: $resolve([routes, lambdaUrlHost], (routes2, lambdaUrlHost2) => {
-                return Object.entries(routes2).map(([key, route]) => ({
-                  key,
-                  value: JSON.stringify(
-                    route.type === "lambda" ? { ...route, domainName: lambdaUrlHost2 } : route
+                const withOrigin = (route) => {
+                  return route.type === "lambda" ? { ...route, domainName: lambdaUrlHost2 } : route;
+                };
+                return Object.entries(routes2).flatMap(
+                  ([key, route]) => createRouteStoreEntries(
+                    key,
+                    Array.isArray(route) ? route.map(withOrigin) : withOrigin(route)
                   )
-                }));
+                );
               })
             },
             {
@@ -10217,6 +10395,41 @@ var routerFeature = defineFeature({
         ctx.bind(`ROUTER_${constantCase15(id)}_ENDPOINT`, domainName);
       }
     }
+  },
+  onStack(ctx) {
+    for (const [id, patterns] 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 addRoutes = ctx.shared.entry("router", "addRoutes", id);
+      const grouped = {};
+      for (const [pattern, props] of Object.entries(patterns)) {
+        const compiled = compileRoutePattern(pattern);
+        const slug = kebabCase12(pattern).slice(0, 20);
+        const routeKey = formatRouteKey(ctx.stack.name, "route", `${slug || "root"}-${shortId(pattern)}`);
+        registerBundleFunction(ctx, routeKey, props);
+        grouped[compiled.key] ??= [];
+        grouped[compiled.key].push({
+          type: "lambda",
+          forwardHost: true,
+          urlEncodedQueryString: true,
+          match: compiled.match,
+          params: compiled.params,
+          requestHeaders: {
+            [ROUTE_HEADER]: routeKey
+          }
+        });
+      }
+      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(merged);
+    }
   }
 });
 
@@ -10602,14 +10815,6 @@ var SharedData = class {
 };
 
 // src/app.ts
-var assertDepsExists = (stack, stacks) => {
-  for (const dep of stack.depends ?? []) {
-    const found = stacks.find((i) => i.name === dep);
-    if (!found) {
-      throw new FileError(stack.file, `Stack "${stack.name}" depends on a stack "${dep}" that doesn't exist.`);
-    }
-  }
-};
 var createApp = (props) => {
   const app = new App2(props.appConfig.name);
   const zones = new Stack(app, "zones");
@@ -10633,17 +10838,10 @@ var createApp = (props) => {
   const bindListeners = [];
   const globalEnv = [];
   const globalEnvListeners = [];
-  const allLocalEnv = {};
-  const allLocalEnvListeners = {};
   const globalPermissions = [];
   const globalPermissionCallbacks = [];
   const appPermissions = [];
   const appPermissionCallbacks = [];
-  const allStackPermissions = {};
-  const allStackPermissionCallbacks = {};
-  for (const stackConfig of props.stackConfigs) {
-    assertDepsExists(stackConfig, props.stackConfigs);
-  }
   for (const feature of features) {
     feature.onBefore?.({
       ...props,
@@ -10716,14 +10914,6 @@ var createApp = (props) => {
   }
   for (const stackConfig of props.stackConfigs) {
     const stack = new Stack(app, stackConfig.name);
-    const localEnvListeners = [];
-    const localEnv = [];
-    const stackPermissions = [];
-    const stackPermissionCallbacks = [];
-    allStackPermissions[stack.name] = stackPermissions;
-    allStackPermissionCallbacks[stack.name] = stackPermissionCallbacks;
-    allLocalEnvListeners[stack.name] = localEnvListeners;
-    allLocalEnv[stack.name] = localEnv;
     for (const feature of features) {
       feature.onStack?.({
         ...props,
@@ -10737,7 +10927,6 @@ var createApp = (props) => {
         shared,
         onPermission(callback) {
           globalPermissionCallbacks.push(callback);
-          stackPermissionCallbacks.push(callback);
         },
         addGlobalPermission(permission) {
           globalPermissions.push(permission);
@@ -10745,9 +10934,6 @@ var createApp = (props) => {
         addAppPermission(permission) {
           appPermissions.push(permission);
         },
-        addStackPermission(permission) {
-          stackPermissions.push(permission);
-        },
         addWarning(props2) {
           warnings.push(props2);
         },
@@ -10811,10 +10997,10 @@ var createApp = (props) => {
           bindListeners.push(cb);
         },
         addEnv(name, value) {
-          localEnv.push({ name, value });
+          globalEnv.push({ name, value });
         },
         onEnv(cb) {
-          localEnvListeners.push(cb);
+          globalEnvListeners.push(cb);
         },
         onReady(cb) {
           readyListeners.push(cb);
@@ -10824,16 +11010,6 @@ var createApp = (props) => {
         }
       });
     }
-    for (const callback of stackPermissionCallbacks) {
-      for (const permission of stackPermissions) {
-        callback(permission);
-      }
-    }
-    for (const listener of localEnvListeners) {
-      for (const env of localEnv) {
-        listener(env.name, env.value);
-      }
-    }
   }
   for (const callback of appPermissionCallbacks) {
     for (const permission of appPermissions) {
@@ -10855,24 +11031,6 @@ var createApp = (props) => {
       listener(name, value);
     }
   }
-  for (const stackConfig of props.stackConfigs) {
-    const envListeners = allLocalEnvListeners[stackConfig.name];
-    const permissionCallbacks = allStackPermissionCallbacks[stackConfig.name];
-    for (const dependency of stackConfig.depends ?? []) {
-      const permissions = allStackPermissions[dependency];
-      const env = allLocalEnv[dependency];
-      for (const permission of permissions) {
-        for (const callback of permissionCallbacks) {
-          callback(permission);
-        }
-      }
-      for (const entry of env) {
-        for (const listener of envListeners) {
-          listener(entry.name, entry.value);
-        }
-      }
-    }
-  }
   const ready = () => {
     for (const listener of readyListeners) {
       listener();
@@ -13507,10 +13665,13 @@ program.on("option:no-cache", () => {
 commands10.forEach((fn) => fn(program));
 
 // src/bin.ts
-var interrupt = (code) => () => {
+var interrupt = (signal, code) => () => {
   process.stdout.write("\x1B[?25h");
+  if (signal === "SIGINT" && process.listenerCount(signal) > 1) {
+    return;
+  }
   process.exit(code);
 };
-process.on("SIGINT", interrupt(130));
-process.on("SIGTERM", interrupt(143));
+process.on("SIGINT", interrupt("SIGINT", 130));
+process.on("SIGTERM", interrupt("SIGTERM", 143));
 program.parse(process.argv);

package/dist/build-json-schema.js

@@ -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.",
@@ -512,6 +576,28 @@ var ErrorResponseSchema = z16.union([
   })
 ]).optional();
 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({
@@ -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,