@awsless/cli 0.0.41 → 0.0.43

package/dist/bin.js

@@ -1205,7 +1205,9 @@ var LayersSchema = z15.string().array().describe(
 var FileCodeSchema = z15.object({
   file: LocalFileSchema.describe("The file path of the function code."),
   minify: MinifySchema.optional().default(true),
-  moduleSideEffects: z15.boolean().default(false).describe(`Will flag all modules as having potential side effects.`),
+  moduleSideEffects: RelativePathSchema.array().default([]).describe(
+    `A list of glob patterns for modules that should be flagged as having potential side effects. For example "./.svelte-kit/**" will flag every file inside the .svelte-kit folder.`
+  ),
   external: z15.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`),
   importAsString: z15.string().array().optional().describe(`A list of glob patterns, which specifies the files that should be imported as string.`)
 });
@@ -1505,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.",
@@ -1534,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({
@@ -2647,6 +2731,7 @@ var StackSchema = z45.object({
   // auth: AuthSchema,
   // http: HttpSchema,
   rest: RestSchema,
+  routes: RoutesSchema,
   rpc: RpcSchema,
   configs: ConfigsSchema,
   crons: CronsSchema,
@@ -3727,8 +3812,18 @@ var zipBundle = async ({ directory }) => {
 
 // src/feature/function/build/typescript/rolldown.ts
 import { createHash as createHash2 } from "crypto";
+import { Minimatch } from "minimatch";
 import { rolldown } from "rolldown";
 import { importAsString } from "rollup-plugin-string-import";
+var createModuleMatcher = (patterns = []) => {
+  const globs = patterns.map((pattern) => {
+    return new Minimatch(pattern.replaceAll("\\", "/"), { dot: true });
+  });
+  return (id) => {
+    const path = id.replaceAll("\\", "/");
+    return globs.some((glob6) => glob6.match(path));
+  };
+};
 var bundleTypeScriptWithRolldown = async ({
   format: format3 = "esm",
   minify = true,
@@ -3740,6 +3835,7 @@ var bundleTypeScriptWithRolldown = async ({
   codeSplitting = true,
   importAsString: importAsStringList
 }) => {
+  const hasModuleSideEffects = createModuleMatcher(moduleSideEffects);
   const bundle = await rolldown({
     input: file,
     platform: "node",
@@ -3750,7 +3846,7 @@ var bundleTypeScriptWithRolldown = async ({
       debugError(error.message);
     },
     treeshake: {
-      moduleSideEffects: moduleSideEffects ? true : (id) => file === id
+      moduleSideEffects: (id) => file === id || hasModuleSideEffects(id)
     },
     plugins: [
       // nodeResolve({ preferBuiltins: true }),
@@ -9063,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) => {
@@ -9153,18 +9249,49 @@ 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];
-
 		try {
-			const route = await store.get(key, { format: 'json' });
+			const value = await store.get(keys[i], { format: 'json' });
+			const result = matchRoute(value, path, method);
 
-			if(isValidRoute(route, method)) {
-				return route;
+			if(result) {
+				return result;
 			}
 		} catch (e) {}
 	}
@@ -9271,11 +9398,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 };
 		}
@@ -9704,6 +9839,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

@@ -259,7 +259,9 @@ var LayersSchema = z11.string().array().describe(
 var FileCodeSchema = z11.object({
   file: LocalFileSchema.describe("The file path of the function code."),
   minify: MinifySchema.optional().default(true),
-  moduleSideEffects: z11.boolean().default(false).describe(`Will flag all modules as having potential side effects.`),
+  moduleSideEffects: RelativePathSchema.array().default([]).describe(
+    `A list of glob patterns for modules that should be flagged as having potential side effects. For example "./.svelte-kit/**" will flag every file inside the .svelte-kit folder.`
+  ),
   external: z11.string().array().optional().describe(`A list of external packages that won't be included in the bundle.`),
   importAsString: z11.string().array().optional().describe(`A list of glob patterns, which specifies the files that should be imported as string.`)
 });
@@ -559,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.",
@@ -588,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({
@@ -1700,6 +1788,7 @@ var StackSchema = z41.object({
   // auth: AuthSchema,
   // http: HttpSchema,
   rest: RestSchema,
+  routes: RoutesSchema,
   rpc: RpcSchema,
   configs: ConfigsSchema,
   crons: CronsSchema,
@@ -1994,6 +2083,7 @@ var generateJsonSchema = (props) => {
 var appendDefaults = (object) => {
   if (Array.isArray(object)) {
     object.forEach(appendDefaults);
+    return;
   }
   if (typeof object === "object" && object !== null) {
     if ("default" in object && "type" in object) {

package/dist/prebuild.js

@@ -12,6 +12,7 @@ import { join } from "path";
 
 // src/feature/function/build/typescript/rolldown.ts
 import { createHash } from "crypto";
+import { Minimatch } from "minimatch";
 import { rolldown } from "rolldown";
 import { importAsString } from "rollup-plugin-string-import";
 
@@ -45,6 +46,15 @@ var debugError = (error) => {
 };
 
 // src/feature/function/build/typescript/rolldown.ts
+var createModuleMatcher = (patterns = []) => {
+  const globs = patterns.map((pattern) => {
+    return new Minimatch(pattern.replaceAll("\\", "/"), { dot: true });
+  });
+  return (id) => {
+    const path = id.replaceAll("\\", "/");
+    return globs.some((glob) => glob.match(path));
+  };
+};
 var bundleTypeScriptWithRolldown = async ({
   format = "esm",
   minify = true,
@@ -56,6 +66,7 @@ var bundleTypeScriptWithRolldown = async ({
   codeSplitting = true,
   importAsString: importAsStringList
 }) => {
+  const hasModuleSideEffects = createModuleMatcher(moduleSideEffects);
   const bundle = await rolldown({
     input: file,
     platform: "node",
@@ -66,7 +77,7 @@ var bundleTypeScriptWithRolldown = async ({
       debugError(error.message);
     },
     treeshake: {
-      moduleSideEffects: moduleSideEffects ? true : (id) => file === id
+      moduleSideEffects: (id) => file === id || hasModuleSideEffects(id)
     },
     plugins: [
       // nodeResolve({ preferBuiltins: true }),