wrangler 2.8.0 → 2.8.1

package/src/__tests__/user.test.ts

@@ -45,7 +45,6 @@ describe("User", () => {
 					counter += 1;
 
 					return response.once(
-						context.status(200),
 						context.json({
 							access_token: "test-access-token",
 							expires_in: 100000,

package/src/__tests__/whoami.test.tsx

@@ -4,6 +4,7 @@ import { getUserInfo } from "../whoami";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { useMockIsTTY } from "./helpers/mock-istty";
 import {
+	createFetchResult,
 	msw,
 	mswSuccessOauthHandlers,
 	mswSuccessUserHandlers,
@@ -44,18 +45,14 @@ describe("getUserInfo()", () => {
 		msw.use(
 			rest.get("*/user", (_, res, ctx) => {
 				return res.once(
-					ctx.status(200),
-					ctx.json({
-						success: false,
-						errors: [
+					ctx.json(
+						createFetchResult({}, false, [
 							{
 								code: 9109,
 								message: "Uauthorized to access requested resource",
 							},
-						],
-						messages: [],
-						result: {},
-					})
+						])
+					)
 				);
 			}),
 			rest.get("*/accounts", (request, res, ctx) => {
@@ -71,15 +68,7 @@ describe("getUserInfo()", () => {
 			  "host": "api.cloudflare.com",
 			}
 		`);
-				return res.once(
-					ctx.status(200),
-					ctx.json({
-						success: true,
-						errors: [],
-						messages: [],
-						result: [],
-					})
-				);
+				return res.once(ctx.json(createFetchResult([])));
 			})
 		);
 		const userInfo = await getUserInfo();

package/src/__tests__/worker-namespace.test.ts

@@ -1,7 +1,11 @@
 import { rest } from "msw";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { mockConsoleMethods } from "./helpers/mock-console";
-import { msw, mswSuccessNamespacesHandlers } from "./helpers/msw";
+import {
+	createFetchResult,
+	msw,
+	mswSuccessNamespacesHandlers,
+} from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
@@ -49,22 +53,23 @@ describe("dispatch-namespace", () => {
 		let counter = 0;
 		msw.use(
 			rest.post(
-				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
-				(req, res, cxt) => {
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
 					counter++;
 					const { namespaceNameParam } = req.params;
 					expect(counter).toBe(1);
 					expect(namespaceNameParam).toBe(namespaceName);
 					return res.once(
-						cxt.status(200),
-						cxt.json({
-							namespace_id: "some-namespace-id",
-							namespace_name: "namespace-name",
-							created_on: "2022-06-29T14:30:08.16152Z",
-							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
-							modified_on: "2022-06-29T14:30:08.16152Z",
-							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
-						})
+						ctx.json(
+							createFetchResult({
+								namespace_id: "some-namespace-id",
+								namespace_name: "namespace-name",
+								created_on: "2022-06-29T14:30:08.16152Z",
+								created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+								modified_on: "2022-06-29T14:30:08.16152Z",
+								modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							})
+						)
 					);
 				}
 			)
@@ -108,13 +113,13 @@ describe("dispatch-namespace", () => {
 		let counter = 0;
 		msw.use(
 			rest.delete(
-				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
-				(req, res, cxt) => {
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
 					counter++;
 					const { namespaceNameParam } = req.params;
 					expect(counter).toBe(1);
 					expect(namespaceNameParam).toBe(namespaceName);
-					return res.once(cxt.status(200), cxt.json(null));
+					return res.once(ctx.json(null));
 				}
 			)
 		);
@@ -157,22 +162,23 @@ describe("dispatch-namespace", () => {
 		let counter = 0;
 		msw.use(
 			rest.get(
-				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
-				(req, res, cxt) => {
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
 					counter++;
 					const { namespaceNameParam } = req.params;
 					expect(counter).toBe(1);
 					expect(namespaceNameParam).toBe(namespaceName);
 					return res.once(
-						cxt.status(200),
-						cxt.json({
-							namespace_id: "some-namespace-id",
-							namespace_name: "namespace-name",
-							created_on: "2022-06-29T14:30:08.16152Z",
-							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
-							modified_on: "2022-06-29T14:30:08.16152Z",
-							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
-						})
+						ctx.json(
+							createFetchResult({
+								namespace_id: "some-namespace-id",
+								namespace_name: "namespace-name",
+								created_on: "2022-06-29T14:30:08.16152Z",
+								created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+								modified_on: "2022-06-29T14:30:08.16152Z",
+								modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							})
+						)
 					);
 				}
 			)
@@ -223,22 +229,23 @@ describe("dispatch-namespace", () => {
 		let counter = 0;
 		msw.use(
 			rest.get(
-				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
-				(req, res, cxt) => {
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
 					counter++;
 					const { namespaceNameParam } = req.params;
 					expect(counter).toBe(1);
 					expect(namespaceNameParam).toBe(namespaceName);
 					return res.once(
-						cxt.status(200),
-						cxt.json({
-							namespace_id: "some-namespace-id",
-							namespace_name: "namespace-name",
-							created_on: "2022-06-29T14:30:08.16152Z",
-							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
-							modified_on: "2022-06-29T14:30:08.16152Z",
-							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
-						})
+						ctx.json(
+							createFetchResult({
+								namespace_id: "some-namespace-id",
+								namespace_name: "namespace-name",
+								created_on: "2022-06-29T14:30:08.16152Z",
+								created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+								modified_on: "2022-06-29T14:30:08.16152Z",
+								modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							})
+						)
 					);
 				}
 			)
@@ -266,22 +273,23 @@ describe("dispatch-namespace", () => {
 		let counter = 0;
 		msw.use(
 			rest.put(
-				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
-				(req, res, cxt) => {
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
 					counter++;
 					const { namespaceNameParam } = req.params;
 					expect(counter).toBe(1);
 					expect(namespaceNameParam).toBe(namespaceName);
 					return res.once(
-						cxt.status(200),
-						cxt.json({
-							namespace_id: "some-namespace-id",
-							namespace_name: "namespace-name",
-							created_on: "2022-06-29T14:30:08.16152Z",
-							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
-							modified_on: "2022-06-29T14:30:08.16152Z",
-							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
-						})
+						ctx.json(
+							createFetchResult({
+								namespace_id: "some-namespace-id",
+								namespace_name: "namespace-name",
+								created_on: "2022-06-29T14:30:08.16152Z",
+								created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+								modified_on: "2022-06-29T14:30:08.16152Z",
+								modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							})
+						)
 					);
 				}
 			)

package/src/api/index.ts

@@ -1,2 +1,3 @@
 export { unstable_dev } from "./dev";
 export type { UnstableDevWorker, UnstableDevOptions } from "./dev";
+export { unstable_pages } from "./pages";

package/src/api/pages/index.ts

@@ -0,0 +1,5 @@
+import { publish } from "./publish";
+
+export const unstable_pages = {
+	publish,
+};

package/src/api/pages/publish.tsx

@@ -0,0 +1,321 @@
+import { existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve as resolvePath } from "node:path";
+import { cwd } from "node:process";
+import { File, FormData } from "undici";
+import { fetchResult } from "../../cfetch";
+import { FatalError } from "../../errors";
+import { logger } from "../../logger";
+import { buildFunctions } from "../../pages/buildFunctions";
+import {
+	FunctionsNoRoutesError,
+	getFunctionsNoRoutesWarning,
+} from "../../pages/errors";
+import {
+	buildRawWorker,
+	checkRawWorker,
+} from "../../pages/functions/buildWorker";
+import { validateRoutes } from "../../pages/functions/routes-validation";
+import { upload } from "../../pages/upload";
+import type { Project, Deployment } from "@cloudflare/types";
+
+interface PagesPublishOptions {
+	/**
+	 * Path to static assets to publish to Pages
+	 */
+	directory: string;
+	/**
+	 * The Cloudflare Account ID that owns the project that's
+	 * being published
+	 */
+	accountId: string;
+	/**
+	 * The name of the project to be published
+	 */
+	projectName: string;
+	/**
+	 * Branch name to use. Defaults to production branch
+	 */
+	branch?: string;
+	/**
+	 * Whether or not to skip local file upload result caching
+	 */
+	skipCaching?: boolean;
+	/**
+	 * Commit message associated to deployment
+	 */
+	commitMessage?: string;
+	/**
+	 * Commit hash associated to deployment
+	 */
+	commitHash?: string;
+	/**
+	 * Whether or not the deployment should be considered to be
+	 * in a dirty commit state
+	 */
+	commitDirty?: boolean;
+	/**
+	 * Path to the project's functions directory. Default uses
+	 * the current working directory + /functions since this is
+	 * typically called in a CLI
+	 */
+	functionsDirectory?: string;
+
+	/**
+	 * Whether to run bundling on `_worker.js` before deploying.
+	 * Default: false
+	 */
+	bundle?: boolean;
+
+	// TODO: Allow passing in the API key and plumb it through
+	// to the API calls so that the publish function does not
+	// rely on the `CLOUDFLARE_API_KEY` environment variable
+}
+
+/**
+ * Publish a directory to an account/project.
+ * NOTE: You will need the `CLOUDFLARE_API_KEY` environment
+ * variable set
+ */
+export async function publish({
+	directory,
+	accountId,
+	projectName,
+	branch,
+	skipCaching,
+	commitMessage,
+	commitHash,
+	commitDirty,
+	functionsDirectory: customFunctionsDirectory,
+	bundle,
+}: PagesPublishOptions) {
+	let _headers: string | undefined,
+		_redirects: string | undefined,
+		_routesGenerated: string | undefined,
+		_routesCustom: string | undefined,
+		_workerJS: string | undefined;
+
+	const workerScriptPath = resolvePath(directory, "_worker.js");
+
+	try {
+		_headers = readFileSync(join(directory, "_headers"), "utf-8");
+	} catch {}
+
+	try {
+		_redirects = readFileSync(join(directory, "_redirects"), "utf-8");
+	} catch {}
+
+	try {
+		/**
+		 * Developers can specify a custom _routes.json file, for projects with Pages
+		 * Functions or projects in Advanced Mode
+		 */
+		_routesCustom = readFileSync(join(directory, "_routes.json"), "utf-8");
+	} catch {}
+
+	try {
+		_workerJS = readFileSync(workerScriptPath, "utf-8");
+	} catch {}
+
+	// Grab the bindings from the API, we need these for shims and other such hacky inserts
+	const project = await fetchResult<Project>(
+		`/accounts/${accountId}/pages/projects/${projectName}`
+	);
+	let isProduction = true;
+	if (branch) {
+		isProduction = project.production_branch === branch;
+	}
+
+	/**
+	 * Evaluate if this is an Advanced Mode or Pages Functions project. If Advanced Mode, we'll
+	 * go ahead and upload `_worker.js` as is, but if Pages Functions, we need to attempt to build
+	 * Functions first and exit if it failed
+	 */
+	let builtFunctions: string | undefined = undefined;
+	const functionsDirectory =
+		customFunctionsDirectory || join(cwd(), "functions");
+	const routesOutputPath = !existsSync(join(directory, "_routes.json"))
+		? join(tmpdir(), `_routes-${Math.random()}.json`)
+		: undefined;
+
+	// Routing configuration displayed in the Functions tab of a deployment in Dash
+	let filepathRoutingConfig: string | undefined;
+
+	if (!_workerJS && existsSync(functionsDirectory)) {
+		const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`);
+		const outputConfigPath = join(
+			tmpdir(),
+			`functions-filepath-routing-config-${Math.random()}.json`
+		);
+
+		try {
+			await buildFunctions({
+				outfile,
+				outputConfigPath,
+				functionsDirectory,
+				onEnd: () => {},
+				buildOutputDirectory: dirname(outfile),
+				routesOutputPath,
+				local: false,
+				d1Databases: Object.keys(
+					project.deployment_configs[isProduction ? "production" : "preview"]
+						.d1_databases ?? {}
+				),
+			});
+
+			builtFunctions = readFileSync(outfile, "utf-8");
+			filepathRoutingConfig = readFileSync(outputConfigPath, "utf-8");
+		} catch (e) {
+			if (e instanceof FunctionsNoRoutesError) {
+				logger.warn(
+					getFunctionsNoRoutesWarning(functionsDirectory, "skipping")
+				);
+			} else {
+				throw e;
+			}
+		}
+	}
+
+	const manifest = await upload({
+		directory,
+		accountId,
+		projectName,
+		skipCaching: skipCaching ?? false,
+	});
+
+	const formData = new FormData();
+
+	formData.append("manifest", JSON.stringify(manifest));
+
+	if (branch) {
+		formData.append("branch", branch);
+	}
+
+	if (commitMessage) {
+		formData.append("commit_message", commitMessage);
+	}
+
+	if (commitHash) {
+		formData.append("commit_hash", commitHash);
+	}
+
+	if (commitDirty !== undefined) {
+		formData.append("commit_dirty", commitDirty);
+	}
+
+	if (_headers) {
+		formData.append("_headers", new File([_headers], "_headers"));
+		logger.log(`✨ Uploading _headers`);
+	}
+
+	if (_redirects) {
+		formData.append("_redirects", new File([_redirects], "_redirects"));
+		logger.log(`✨ Uploading _redirects`);
+	}
+
+	if (filepathRoutingConfig) {
+		formData.append(
+			"functions-filepath-routing-config.json",
+			new File(
+				[filepathRoutingConfig],
+				"functions-filepath-routing-config.json"
+			)
+		);
+	}
+
+	/**
+	 * Advanced Mode
+	 * https://developers.cloudflare.com/pages/platform/functions/#advanced-mode
+	 *
+	 * When using a _worker.js file, the entire /functions directory is ignored
+	 * – this includes its routing and middleware characteristics.
+	 */
+	if (_workerJS) {
+		let workerFileContents = _workerJS;
+		if (bundle) {
+			const outfile = join(tmpdir(), `./bundledWorker-${Math.random()}.mjs`);
+			await buildRawWorker({
+				workerScriptPath,
+				outfile,
+				directory: directory ?? ".",
+				local: false,
+				sourcemap: true,
+				watch: false,
+				onEnd: () => {},
+			});
+			workerFileContents = readFileSync(outfile, "utf8");
+		} else {
+			await checkRawWorker(workerScriptPath, () => {});
+		}
+
+		formData.append("_worker.js", new File([workerFileContents], "_worker.js"));
+		logger.log(`✨ Uploading _worker.js`);
+
+		if (_routesCustom) {
+			// user provided a custom _routes.json file
+			try {
+				const routesCustomJSON = JSON.parse(_routesCustom);
+				validateRoutes(routesCustomJSON, join(directory, "_routes.json"));
+
+				formData.append(
+					"_routes.json",
+					new File([_routesCustom], "_routes.json")
+				);
+				logger.log(`✨ Uploading _routes.json`);
+			} catch (err) {
+				if (err instanceof FatalError) {
+					throw err;
+				}
+			}
+		}
+	}
+
+	/**
+	 * Pages Functions
+	 * https://developers.cloudflare.com/pages/platform/functions/
+	 */
+	if (builtFunctions && !_workerJS) {
+		// if Functions were build successfully, proceed to uploading the build file
+		formData.append("_worker.js", new File([builtFunctions], "_worker.js"));
+		logger.log(`✨ Uploading Functions`);
+
+		if (_routesCustom) {
+			// user provided a custom _routes.json file
+			try {
+				const routesCustomJSON = JSON.parse(_routesCustom);
+				validateRoutes(routesCustomJSON, join(directory, "_routes.json"));
+
+				formData.append(
+					"_routes.json",
+					new File([_routesCustom], "_routes.json")
+				);
+				logger.log(`✨ Uploading _routes.json`);
+			} catch (err) {
+				if (err instanceof FatalError) {
+					throw err;
+				}
+			}
+		} else if (routesOutputPath) {
+			// no custom _routes.json file found, so fallback to the generated one
+			try {
+				_routesGenerated = readFileSync(routesOutputPath, "utf-8");
+
+				if (_routesGenerated) {
+					formData.append(
+						"_routes.json",
+						new File([_routesGenerated], "_routes.json")
+					);
+				}
+			} catch {}
+		}
+	}
+
+	const deploymentResponse = await fetchResult<Deployment>(
+		`/accounts/${accountId}/pages/projects/${projectName}/deployments`,
+		{
+			method: "POST",
+			body: formData,
+		}
+	);
+	return deploymentResponse;
+}

package/src/bundle.ts

@@ -9,10 +9,10 @@ import tmp from "tmp-promise";
 import createModuleCollector from "./module-collection";
 import { getBasePath, toUrlPath } from "./paths";
 import type { Config } from "./config";
+import type { DurableObjectBindings } from "./config/environment";
 import type { WorkerRegistry } from "./dev-registry";
 import type { Entry } from "./entry";
 import type { CfModule } from "./worker";
-
 export type BundleResult = {
 	modules: CfModule[];
 	dependencies: esbuild.Metafile["outputs"][string]["inputs"];
@@ -95,6 +95,7 @@ export async function bundleWorker(
 		serveAssetsFromWorker: boolean;
 		assets?: StaticAssetsConfig;
 		betaD1Shims?: string[];
+		doBindings: DurableObjectBindings;
 		jsxFactory?: string;
 		jsxFragment?: string;
 		rules: Config["rules"];
@@ -123,6 +124,7 @@ export async function bundleWorker(
 	const {
 		serveAssetsFromWorker,
 		betaD1Shims,
+		doBindings,
 		jsxFactory,
 		jsxFragment,
 		rules,
@@ -271,7 +273,13 @@ export async function bundleWorker(
 		Array.isArray(betaD1Shims) &&
 			betaD1Shims.length > 0 &&
 			((currentEntry: Entry) => {
-				return applyD1BetaFacade(currentEntry, tmpDir.path, betaD1Shims, local);
+				return applyD1BetaFacade(
+					currentEntry,
+					tmpDir.path,
+					betaD1Shims,
+					local,
+					doBindings
+				);
 			}),
 
 		// Middleware loader: to add middleware, we add the path to the middleware
@@ -395,13 +403,23 @@ export async function bundleWorker(
 		_path.includes(".map")
 	)[0];
 
+	const resolvedEntryPointPath = path.resolve(
+		entry.directory,
+		entryPointOutputs[0][0]
+	);
+
+	// copy all referenced modules into the output bundle directory
+	for (const module of moduleCollector.modules) {
+		fs.writeFileSync(
+			path.join(path.dirname(resolvedEntryPointPath), module.name),
+			module.content
+		);
+	}
+
 	return {
 		modules: moduleCollector.modules,
 		dependencies,
-		resolvedEntryPointPath: path.resolve(
-			entry.directory,
-			entryPointOutputs[0][0]
-		),
+		resolvedEntryPointPath,
 		bundleType,
 		stop: result.stop,
 		sourceMapPath,
@@ -779,17 +797,51 @@ async function applyFirstPartyWorkerDevFacade(
  * This code be removed from here when the API is in Workers core,
  * but moved inside Miniflare for simulating D1.
  */
-
 async function applyD1BetaFacade(
 	entry: Entry,
 	tmpDirPath: string,
 	betaD1Shims: string[],
-	local: boolean
+	local: boolean,
+	doBindings: DurableObjectBindings
 ): Promise<Entry> {
+	let entrypointPath = path.resolve(
+		getBasePath(),
+		"templates/d1-beta-facade.js"
+	);
+	if (Array.isArray(doBindings) && doBindings.length > 0) {
+		//we have DO bindings, so we need to shim them
+		const maskedDoBindings = doBindings
+			// Don't shim anything not local to this worker
+			.filter((b) => !b.script_name)
+			// Reexport the DO classnames
+			.map(
+				(b) =>
+					`export const ${b.class_name} = maskDurableObjectDefinition(OTHER_EXPORTS.${b.class_name});`
+			)
+			.join("\n");
+		const baseFile = fs.readFileSync(
+			path.resolve(getBasePath(), "templates/d1-beta-facade.js"),
+			"utf8"
+		);
+		//getMaskedEnv is already used to shim regular Workers
+		const contents = `
+		${baseFile}
+
+		var maskDurableObjectDefinition = (cls) =>
+		class extends cls {
+			constructor(state, env) {
+				super(state, getMaskedEnv(env));
+			}
+		};
+		${maskedDoBindings}`;
+		const doD1FacadePath = path.join(tmpDirPath, "d1-do-facade.js");
+		//write our shim so we can build it
+		fs.writeFileSync(doD1FacadePath, contents);
+		entrypointPath = doD1FacadePath;
+	}
 	const targetPath = path.join(tmpDirPath, "d1-beta-facade.entry.js");
-
 	await esbuild.build({
-		entryPoints: [path.resolve(getBasePath(), "templates/d1-beta-facade.js")],
+		entryPoints: [entrypointPath],
 		bundle: true,
 		format: "esm",
 		sourcemap: true,

package/src/cli.ts

@@ -1,6 +1,6 @@
 import process from "process";
 import { hideBin } from "yargs/helpers";
-import { unstable_dev } from "./api";
+import { unstable_dev, unstable_pages } from "./api";
 import { FatalError } from "./errors";
 import { main } from ".";
 
@@ -24,5 +24,5 @@ if (typeof jest === "undefined" && require.main === module) {
  * It makes it possible to import wrangler from 'wrangler',
  * and call wrangler.unstable_dev().
  */
-export { unstable_dev };
+export { unstable_dev, unstable_pages };
 export type { UnstableDevWorker, UnstableDevOptions };