wrangler 0.0.0-e2f9bb2 → 0.0.0-e30d1013

package/src/pages/errors.ts

@@ -0,0 +1,66 @@
+import {
+	MAX_FUNCTIONS_ROUTES_RULES,
+	MAX_FUNCTIONS_ROUTES_RULE_LENGTH,
+	ROUTES_SPEC_VERSION,
+} from "./constants";
+import { RoutesValidationError } from "./functions/routes-validation";
+
+/**
+ * Exit code for `pages functions build` when no routes are found.
+ */
+export const EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR = 156;
+
+/**
+ * Pages error when no routes are found in the functions directory
+ */
+export class FunctionsNoRoutesError extends Error {
+	constructor(message: string) {
+		super(message);
+	}
+}
+
+/**
+ * Warning message for when buildFunctions throws FunctionsNoRoutesError
+ */
+export function getFunctionsNoRoutesWarning(
+	functionsDirectory: string,
+	suffix?: string
+) {
+	return `No routes found when building Functions directory: ${functionsDirectory}${
+		suffix ? " - " + suffix : ""
+	}`;
+}
+
+export function getRoutesValidationErrorMessage(
+	errorCode: RoutesValidationError,
+	routesPath: string
+): string {
+	switch (errorCode) {
+		case RoutesValidationError.NO_INCLUDE_RULES:
+			return `Invalid _routes.json file found at: ${routesPath}
+Routes must have at least 1 include rule, but no include rules were detected.`;
+		case RoutesValidationError.TOO_MANY_RULES:
+			return `Invalid _routes.json file found at: ${routesPath}
+Detected rules that are over the ${MAX_FUNCTIONS_ROUTES_RULES} rule limit. Please make sure you have a total of ${MAX_FUNCTIONS_ROUTES_RULES} include and exclude rules combined.`;
+		case RoutesValidationError.RULE_TOO_LONG:
+			return `Invalid _routes.json file found at: ${routesPath}
+Detected rules the are over the ${MAX_FUNCTIONS_ROUTES_RULE_LENGTH} character limit. Please make sure that each include and exclude routing rule is at most ${MAX_FUNCTIONS_ROUTES_RULE_LENGTH} characters long.`;
+		case RoutesValidationError.INVALID_RULES:
+			return `Invalid _routes.json file found at: ${routesPath}
+All rules must start with '/'.`;
+		case RoutesValidationError.OVERLAPPING_RULES:
+			return `Invalid _routes.json file found at: ${routesPath}
+Overlapping rules found. Please make sure that rules ending with a splat (eg. "/api/*") don't overlap any other rules (eg. "/api/foo"). This applies to both include and exclude rules individually.`;
+		case RoutesValidationError.INVALID_JSON_SPEC:
+		default:
+			return `Invalid _routes.json file found at: ${routesPath}
+Please make sure the JSON object has the following format:
+{
+	version: ${ROUTES_SPEC_VERSION};
+	include: string[];
+	exclude: string[];
+}
+and that at least one include rule is provided.
+			`;
+	}
+}

package/src/pages/functions/buildPlugin.ts

@@ -0,0 +1,106 @@
+import { access, lstat } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import { bundleWorker } from "../../bundle";
+import { getBasePath } from "../../paths";
+import { D1_BETA_PREFIX } from "../../worker";
+import type { Options as WorkerOptions } from "./buildWorker";
+
+type Options = Omit<WorkerOptions, "fallbackService" | "buildOutputDirectory">;
+
+export function buildPlugin({
+	routesModule,
+	outfile = "bundle.js",
+	minify = false,
+	sourcemap = false,
+	watch = false,
+	onEnd = () => {},
+	nodeCompat,
+	functionsDirectory,
+	local,
+	betaD1Shims,
+}: Options) {
+	return bundleWorker(
+		{
+			file: resolve(getBasePath(), "templates/pages-template-plugin.ts"),
+			directory: functionsDirectory,
+			format: "modules",
+		},
+		resolve(outfile),
+		{
+			inject: [routesModule],
+			minify,
+			sourcemap,
+			watch,
+			nodeCompat,
+			define: {},
+			betaD1Shims: (betaD1Shims || []).map(
+				(binding) => `${D1_BETA_PREFIX}${binding}`
+			),
+			plugins: [
+				{
+					name: "wrangler notifier and monitor",
+					setup(pluginBuild) {
+						pluginBuild.onEnd((result) => {
+							if (result.errors.length > 0) {
+								console.error(
+									`${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
+								);
+							} else if (result.warnings.length > 0) {
+								console.warn(
+									`${result.warnings.length} warning(s) when compiling Worker.`
+								);
+								onEnd();
+							} else {
+								console.log("Compiled Worker successfully.");
+								onEnd();
+							}
+						});
+					},
+				},
+				{
+					name: "Assets",
+					setup(pluginBuild) {
+						if (pluginBuild.initialOptions.outfile) {
+							const outdir = dirname(pluginBuild.initialOptions.outfile);
+
+							pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
+								const directory = resolve(
+									args.resolveDir,
+									args.path.slice("assets:".length)
+								);
+
+								const exists = await access(directory)
+									.then(() => true)
+									.catch(() => false);
+
+								const isDirectory =
+									exists && (await lstat(directory)).isDirectory();
+
+								if (!isDirectory) {
+									return {
+										errors: [
+											{
+												text: `'${directory}' does not exist or is not a directory.`,
+											},
+										],
+									};
+								}
+
+								const path = `assets:./${relative(outdir, directory)}`;
+
+								return { path, external: true, namespace: "assets" };
+							});
+						}
+					},
+				},
+			],
+			isOutfile: true,
+			serveAssetsFromWorker: false,
+			disableModuleCollection: true,
+			rules: [],
+			checkFetch: local,
+			targetConsumer: local ? "dev" : "publish",
+			local,
+		}
+	);
+}

package/src/pages/functions/buildWorker.ts

@@ -0,0 +1,165 @@
+import { access, cp, lstat, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { nanoid } from "nanoid";
+import { bundleWorker } from "../../bundle";
+import { getBasePath } from "../../paths";
+import { D1_BETA_PREFIX } from "../../worker";
+
+export type Options = {
+	routesModule: string;
+	outfile: string;
+	minify?: boolean;
+	sourcemap?: boolean;
+	fallbackService?: string;
+	watch?: boolean;
+	onEnd?: () => void;
+	buildOutputDirectory?: string;
+	nodeCompat?: boolean;
+	functionsDirectory: string;
+	local: boolean;
+	betaD1Shims?: string[];
+};
+
+export function buildWorker({
+	routesModule,
+	outfile = "bundle.js",
+	minify = false,
+	sourcemap = false,
+	fallbackService = "ASSETS",
+	watch = false,
+	onEnd = () => {},
+	buildOutputDirectory,
+	nodeCompat,
+	functionsDirectory,
+	local,
+	betaD1Shims,
+}: Options) {
+	return bundleWorker(
+		{
+			file: resolve(getBasePath(), "templates/pages-template-worker.ts"),
+			directory: functionsDirectory,
+			format: "modules",
+		},
+		resolve(outfile),
+		{
+			inject: [routesModule],
+			minify,
+			sourcemap,
+			watch,
+			nodeCompat,
+			loader: {
+				".txt": "text",
+				".html": "text",
+			},
+			define: {
+				__FALLBACK_SERVICE__: JSON.stringify(fallbackService),
+			},
+			betaD1Shims: (betaD1Shims || []).map(
+				(binding) => `${D1_BETA_PREFIX}${binding}`
+			),
+			plugins: [
+				{
+					name: "wrangler notifier and monitor",
+					setup(pluginBuild) {
+						pluginBuild.onEnd((result) => {
+							if (result.errors.length > 0) {
+								console.error(
+									`${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
+								);
+							} else if (result.warnings.length > 0) {
+								console.warn(
+									`${result.warnings.length} warning(s) when compiling Worker.`
+								);
+								onEnd();
+							} else {
+								console.log("Compiled Worker successfully.");
+								onEnd();
+							}
+						});
+					},
+				},
+				{
+					name: "Assets",
+					setup(pluginBuild) {
+						const identifiers = new Map<string, string>();
+
+						pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
+							const directory = resolve(
+								args.resolveDir,
+								args.path.slice("assets:".length)
+							);
+
+							const exists = await access(directory)
+								.then(() => true)
+								.catch(() => false);
+
+							const isDirectory =
+								exists && (await lstat(directory)).isDirectory();
+
+							if (!isDirectory) {
+								return {
+									errors: [
+										{
+											text: `'${directory}' does not exist or is not a directory.`,
+										},
+									],
+								};
+							}
+
+							// TODO: Consider hashing the contents rather than using a unique identifier every time?
+							identifiers.set(directory, nanoid());
+							if (!buildOutputDirectory) {
+								console.warn(
+									"You're attempting to import static assets as part of your Pages Functions, but have not specified a directory in which to put them. You must use 'wrangler pages dev <directory>' rather than 'wrangler pages dev -- <command>' to import static assets in Functions."
+								);
+							}
+							return { path: directory, namespace: "assets" };
+						});
+
+						pluginBuild.onLoad(
+							{ filter: /.*/, namespace: "assets" },
+							async (args) => {
+								const identifier = identifiers.get(args.path);
+
+								if (buildOutputDirectory) {
+									const staticAssetsOutputDirectory = join(
+										buildOutputDirectory,
+										"cdn-cgi",
+										"pages-plugins",
+										identifier as string
+									);
+									await rm(staticAssetsOutputDirectory, {
+										force: true,
+										recursive: true,
+									});
+									await cp(args.path, staticAssetsOutputDirectory, {
+										force: true,
+										recursive: true,
+									});
+
+									return {
+										// TODO: Watch args.path for changes and re-copy when updated
+										contents: `export const onRequest = ({ request, env, functionPath }) => {
+                    const url = new URL(request.url)
+                    const relativePathname = \`/\${url.pathname.split(functionPath)[1] || ''}\`.replace(/^\\/\\//, '/');
+                    url.pathname = '/cdn-cgi/pages-plugins/${identifier}' + relativePathname
+                    request = new Request(url.toString(), request)
+                    return env.ASSETS.fetch(request)
+                  }`,
+									};
+								}
+							}
+						);
+					},
+				},
+			],
+			isOutfile: true,
+			serveAssetsFromWorker: false,
+			disableModuleCollection: true,
+			rules: [],
+			checkFetch: local,
+			targetConsumer: local ? "dev" : "publish",
+			local,
+		}
+	);
+}

package/{pages → src/pages}/functions/filepath-routing.test.ts

@@ -1,141 +1,141 @@
 import { writeFileSync, mkdirSync } from "fs";
-import { runInTempDir } from "../../src/__tests__/helpers/run-in-tmp";
-import { toUrlPath } from "../../src/paths";
+import { runInTempDir } from "../../__tests__/helpers/run-in-tmp";
+import { toUrlPath } from "../../paths";
 import { compareRoutes, generateConfigFromFileTree } from "./filepath-routing";
-import type { UrlPath } from "../../src/paths";
+import type { UrlPath } from "../../paths";
 import type { HTTPMethod, RouteConfig } from "./routes";
 
 describe("filepath-routing", () => {
-  describe("compareRoutes()", () => {
-    test("routes / last", () => {
-      expect(
-        compareRoutes(routeConfig("/"), routeConfig("/foo"))
-      ).toBeGreaterThanOrEqual(1);
-      expect(
-        compareRoutes(routeConfig("/"), routeConfig("/:foo"))
-      ).toBeGreaterThanOrEqual(1);
-      expect(
-        compareRoutes(routeConfig("/"), routeConfig("/:foo*"))
-      ).toBeGreaterThanOrEqual(1);
-    });
-
-    test("routes with fewer segments come after those with more segments", () => {
-      expect(
-        compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar"))
-      ).toBeGreaterThanOrEqual(1);
-      expect(
-        compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar/cat"))
-      ).toBeGreaterThanOrEqual(1);
-    });
-
-    test("routes with wildcard segments come after those without", () => {
-      expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/foo"))).toBe(1);
-      expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/:foo"))).toBe(
-        1
-      );
-    });
-
-    test("routes with dynamic segments come after those without", () => {
-      expect(compareRoutes(routeConfig("/:foo"), routeConfig("/foo"))).toBe(1);
-    });
-
-    test("routes with dynamic segments occurring earlier come after those with dynamic segments in later positions", () => {
-      expect(
-        compareRoutes(routeConfig("/foo/:id/bar"), routeConfig("/foo/bar/:id"))
-      ).toBe(1);
-    });
-
-    test("routes with no HTTP method come after those specifying a method", () => {
-      expect(
-        compareRoutes(routeConfig("/foo"), routeConfig("/foo", "GET"))
-      ).toBe(1);
-    });
-
-    test("two equal routes are sorted according to their original position in the list", () => {
-      expect(
-        compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo", "GET"))
-      ).toBe(0);
-    });
-
-    test("it returns -1 if the first argument should appear first in the list", () => {
-      expect(
-        compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo"))
-      ).toBe(-1);
-    });
-  });
-
-  describe("generateConfigFromFileTree", () => {
-    runInTempDir();
-
-    it("should generate a route entry for each file in the tree", async () => {
-      writeFileSync(
-        "foo.ts",
-        `
+	describe("compareRoutes()", () => {
+		test("routes / last", () => {
+			expect(
+				compareRoutes(routeConfig("/"), routeConfig("/foo"))
+			).toBeGreaterThanOrEqual(1);
+			expect(
+				compareRoutes(routeConfig("/"), routeConfig("/:foo"))
+			).toBeGreaterThanOrEqual(1);
+			expect(
+				compareRoutes(routeConfig("/"), routeConfig("/:foo*"))
+			).toBeGreaterThanOrEqual(1);
+		});
+
+		test("routes with fewer segments come after those with more segments", () => {
+			expect(
+				compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar"))
+			).toBeGreaterThanOrEqual(1);
+			expect(
+				compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar/cat"))
+			).toBeGreaterThanOrEqual(1);
+		});
+
+		test("routes with wildcard segments come after those without", () => {
+			expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/foo"))).toBe(1);
+			expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/:foo"))).toBe(
+				1
+			);
+		});
+
+		test("routes with dynamic segments come after those without", () => {
+			expect(compareRoutes(routeConfig("/:foo"), routeConfig("/foo"))).toBe(1);
+		});
+
+		test("routes with dynamic segments occurring earlier come after those with dynamic segments in later positions", () => {
+			expect(
+				compareRoutes(routeConfig("/foo/:id/bar"), routeConfig("/foo/bar/:id"))
+			).toBe(1);
+		});
+
+		test("routes with no HTTP method come after those specifying a method", () => {
+			expect(
+				compareRoutes(routeConfig("/foo"), routeConfig("/foo", "GET"))
+			).toBe(1);
+		});
+
+		test("two equal routes are sorted according to their original position in the list", () => {
+			expect(
+				compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo", "GET"))
+			).toBe(0);
+		});
+
+		test("it returns -1 if the first argument should appear first in the list", () => {
+			expect(
+				compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo"))
+			).toBe(-1);
+		});
+	});
+
+	describe("generateConfigFromFileTree", () => {
+		runInTempDir();
+
+		it("should generate a route entry for each file in the tree", async () => {
+			writeFileSync(
+				"foo.ts",
+				`
       export function onRequestGet() {}
       export function onRequestPost() {}
       `
-      );
-      writeFileSync(
-        "bar.ts",
-        `
+			);
+			writeFileSync(
+				"bar.ts",
+				`
       export function onRequestPut() {}
       export function onRequestDelete() {}
       `
-      );
+			);
 
-      mkdirSync("todos");
+			mkdirSync("todos");
 
-      writeFileSync(
-        "todos/[id].ts",
-        `
+			writeFileSync(
+				"todos/[id].ts",
+				`
       export function onRequestPost() {}
       export function onRequestDelete() {}
       `
-      );
+			);
 
-      mkdirSync("authors");
-      mkdirSync("authors/[authorId]");
-      mkdirSync("authors/[authorId]/todos");
+			mkdirSync("authors");
+			mkdirSync("authors/[authorId]");
+			mkdirSync("authors/[authorId]/todos");
 
-      writeFileSync(
-        "authors/[authorId]/todos/[todoId].ts",
-        `
+			writeFileSync(
+				"authors/[authorId]/todos/[todoId].ts",
+				`
       export function onRequestPost() {}
       `
-      );
+			);
 
-      mkdirSync("books");
+			mkdirSync("books");
 
-      writeFileSync(
-        "books/[[title]].ts",
-        `
+			writeFileSync(
+				"books/[[title]].ts",
+				`
       export function onRequestPost() {}
       `
-      );
+			);
 
-      mkdirSync("cats");
-      mkdirSync("cats/[[breed]]");
+			mkdirSync("cats");
+			mkdirSync("cats/[[breed]]");
 
-      writeFileSync(
-        "cats/[[breed]]/blah.ts",
-        `
+			writeFileSync(
+				"cats/[[breed]]/blah.ts",
+				`
       export function onRequestPost() {}
       `
-      );
+			);
 
-      // This won't actually work at runtime.
-      writeFileSync(
-        "cats/[[breed]]/[[name]].ts",
-        `
+			// This won't actually work at runtime.
+			writeFileSync(
+				"cats/[[breed]]/[[name]].ts",
+				`
       export function onRequestPost() {}
       `
-      );
+			);
 
-      const entries = await generateConfigFromFileTree({
-        baseDir: ".",
-        baseURL: "/base" as UrlPath,
-      });
-      expect(entries).toMatchInlineSnapshot(`
+			const entries = await generateConfigFromFileTree({
+				baseDir: ".",
+				baseURL: "/base" as UrlPath,
+			});
+			expect(entries).toMatchInlineSnapshot(`
         Object {
           "routes": Array [
             Object {
@@ -221,14 +221,14 @@ describe("filepath-routing", () => {
           ],
         }
       `);
-    });
-  });
+		});
+	});
 });
 
 function routeConfig(routePath: string, method?: string): RouteConfig {
-  return {
-    routePath: toUrlPath(routePath),
-    mountPath: toUrlPath("/"),
-    method: method as HTTPMethod,
-  };
+	return {
+		routePath: toUrlPath(routePath),
+		mountPath: toUrlPath("/"),
+		method: method as HTTPMethod,
+	};
 }