wrangler 0.0.0-e87ad068 → 0.0.0-e8df68ee

package/templates/{d1-beta-facade.js → middleware/middleware-d1-beta.ts}

@@ -1,13 +1,11 @@
-// src/shim.ts
-import worker, * as OTHER_EXPORTS from "__ENTRY_POINT__";
-export * from "__ENTRY_POINT__";
+/// <reference path="middleware-d1-beta.d.ts"/>
+
+import { D1_IMPORTS } from "config:middleware/d1-beta";
 
 // src/index.ts
-var D1Database = class {
-	constructor(binding) {
-		this.binding = binding;
-	}
-	prepare(query) {
+class D1Database {
+	constructor(readonly binding: Fetcher) {}
+	prepare(query: string) {
 		return new D1PreparedStatement(this, query);
 	}
 	async dump() {
@@ -19,19 +17,19 @@ var D1Database = class {
 		});
 		if (response.status !== 200) {
 			try {
-				const err = await response.json();
-				throw new Error("D1_DUMP_ERROR", {
+				const err = (await response.json()) as { error: string };
+				throw new Error(`D1_DUMP_ERROR: ${err.error}`, {
 					cause: new Error(err.error),
 				});
 			} catch (e) {
-				throw new Error("D1_DUMP_ERROR", {
+				throw new Error(`D1_DUMP_ERROR: Status + ${response.status}`, {
 					cause: new Error("Status " + response.status),
 				});
 			}
 		}
 		return await response.arrayBuffer();
 	}
-	async batch(statements) {
+	async batch(statements: D1PreparedStatement[]) {
 		const exec = await this._send(
 			"/query",
 			statements.map((s) => s.statement),
@@ -39,7 +37,7 @@ var D1Database = class {
 		);
 		return exec;
 	}
-	async exec(query) {
+	async exec(query: string) {
 		const lines = query.trim().split("\n");
 		const _exec = await this._send("/query", lines, [], false);
 		const exec = Array.isArray(_exec) ? _exec : [_exec];
@@ -49,26 +47,36 @@ var D1Database = class {
 			})
 			.indexOf(1);
 		if (error !== -1) {
-			throw new Error("D1_EXEC_ERROR", {
-				cause: new Error(
-					"Error in line " +
-						(error + 1) +
-						": " +
-						lines[error] +
-						": " +
-						exec[error].error
-				),
-			});
+			throw new Error(
+				`D1_EXEC_ERROR: Error in line ${error + 1}: ${lines[error]}: ${
+					exec[error].error
+				}`,
+				{
+					cause: new Error(
+						"Error in line " +
+							(error + 1) +
+							": " +
+							lines[error] +
+							": " +
+							exec[error].error
+					),
+				}
+			);
 		} else {
 			return {
 				count: exec.length,
 				duration: exec.reduce((p, c) => {
-					return p + c.meta.duration;
+					return p + (c.meta.duration as number);
 				}, 0),
 			};
 		}
 	}
-	async _send(endpoint, query, params, dothrow = true) {
+	async _send(
+		endpoint: string,
+		query: string | string[],
+		params: unknown[],
+		dothrow = true
+	) {
 		const body = JSON.stringify(
 			typeof query == "object"
 				? query.map((s, index) => {
@@ -87,75 +95,79 @@ var D1Database = class {
 			body,
 		});
 		try {
-			const answer = await response.json();
+			const answer = (await response.json()) as { error?: string };
 			if (answer.error && dothrow) {
 				const err = answer;
-				throw new Error("D1_ERROR", { cause: new Error(err.error) });
+				throw new Error(`D1_ERROR: ${err.error}`, {
+					cause: new Error(err.error),
+				});
 			} else {
 				return Array.isArray(answer)
 					? answer.map((r) => mapD1Result(r))
 					: mapD1Result(answer);
 			}
 		} catch (e) {
-			throw new Error("D1_ERROR", {
-				cause: new Error(e.cause || "Something went wrong"),
+			const error = e as Error;
+			throw new Error(`D1_ERROR: ${error.cause || "Something went wrong"}`, {
+				cause: new Error(`${error.cause}` || "Something went wrong"),
 			});
 		}
 	}
-};
-var D1PreparedStatement = class {
-	constructor(database, statement, values) {
-		this.database = database;
-		this.statement = statement;
-		this.params = values || [];
-	}
-	bind(...values) {
+}
+
+class D1PreparedStatement {
+	constructor(
+		readonly database: D1Database,
+		readonly statement: string,
+		readonly params: unknown[] = []
+	) {}
+	bind(...values: unknown[]) {
 		for (var r in values) {
-			switch (typeof values[r]) {
+			const value = values[r];
+			switch (typeof value) {
 				case "number":
 				case "string":
 					break;
 				case "object":
-					if (values[r] == null) break;
+					if (value == null) break;
 					if (
-						Array.isArray(values[r]) &&
-						values[r]
+						Array.isArray(value) &&
+						value
 							.map((b) => {
 								return typeof b == "number" && b >= 0 && b < 256 ? 1 : 0;
 							})
 							.indexOf(0) == -1
 					)
 						break;
-					if (values[r] instanceof ArrayBuffer) {
-						values[r] = Array.from(new Uint8Array(values[r]));
+					if (value instanceof ArrayBuffer) {
+						values[r] = Array.from(new Uint8Array(value));
 						break;
 					}
-					if (ArrayBuffer.isView(values[r])) {
-						values[r] = Array.from(values[r]);
+					if (ArrayBuffer.isView(value)) {
+						values[r] = Array.from(new Uint8Array(value.buffer));
 						break;
 					}
 				default:
-					throw new Error("D1_TYPE_ERROR", {
-						cause: new Error(
-							"Type '" +
-								typeof values[r] +
-								"' not supported for value '" +
-								values[r] +
-								"'"
-						),
-					});
+					throw new Error(
+						`D1_TYPE_ERROR: Type '${typeof value}' not supported for value '${value}'`,
+						{
+							cause: new Error(
+								`Type '${typeof value}' not supported for value '${value}'`
+							),
+						}
+					);
 			}
 		}
 		return new D1PreparedStatement(this.database, this.statement, values);
 	}
-	async first(colName) {
+	async first(colName: string) {
 		const info = firstIfArray(
 			await this.database._send("/query", this.statement, this.params)
 		);
 		const results = info.results;
 		if (colName !== void 0) {
 			if (results.length > 0 && results[0][colName] === void 0) {
-				throw new Error("D1_COLUMN_NOTFOUND", {
+				throw new Error(`D1_COLUMN_NOTFOUND: Column not found (${colName})`, {
 					cause: new Error("Column not found"),
 				});
 			}
@@ -187,12 +199,12 @@ var D1PreparedStatement = class {
 		}
 		return raw;
 	}
-};
-function firstIfArray(results) {
+}
+function firstIfArray(results: unknown) {
 	return Array.isArray(results) ? results[0] : results;
 }
-function mapD1Result(result) {
-	let map = {
+function mapD1Result(result: Partial<D1Result>): D1Result {
+	let map: D1Result = {
 		results: result.results || [],
 		success: result.success === void 0 ? true : result.success,
 		meta: result.meta || {},
@@ -201,12 +213,17 @@ function mapD1Result(result) {
 	return map;
 }
 
+type D1Result = {
+	results: unknown[];
+	success: boolean;
+	meta: Record<string, unknown>;
+	error?: string;
+};
+
 // src/shim.ts
-var D1_IMPORTS = __D1_IMPORTS__;
-var LOCAL_MODE = __LOCAL_MODE__;
 var D1_BETA_PREFIX = `__D1_BETA__`;
 var envMap = /* @__PURE__ */ new Map();
-function getMaskedEnv(env) {
+function getMaskedEnv(env: Record<string, Fetcher | D1Database>) {
 	if (envMap.has(env)) return envMap.get(env);
 	const newEnv = new Map(Object.entries(env));
 	D1_IMPORTS.filter((bindingName) =>
@@ -214,31 +231,14 @@ function getMaskedEnv(env) {
 	).forEach((bindingName) => {
 		newEnv.delete(bindingName);
 		const newName = bindingName.slice(D1_BETA_PREFIX.length);
-		const newBinding = !LOCAL_MODE
-			? new D1Database(env[bindingName])
-			: env[bindingName];
+		const newBinding = new D1Database(env[bindingName] as Fetcher);
 		newEnv.set(newName, newBinding);
 	});
 	const newEnvObj = Object.fromEntries(newEnv.entries());
 	envMap.set(env, newEnvObj);
 	return newEnvObj;
 }
-var shim_default = {
-	...worker,
-	async fetch(request, env, ctx) {
-		return worker.fetch(request, getMaskedEnv(env), ctx);
-	},
-	async queue(batch, env, ctx) {
-		return worker.queue(batch, getMaskedEnv(env), ctx);
-	},
-	async scheduled(controller, env, ctx) {
-		return worker.scheduled(controller, getMaskedEnv(env), ctx);
-	},
-	async trace(traces, env, ctx) {
-		return worker.trace(traces, getMaskedEnv(env), ctx);
-	},
-	async email(message, env, ctx) {
-		return worker.email(message, getMaskedEnv(env), ctx);
-	},
-};
-export { shim_default as default };
+
+export function wrap(env: Record<string, D1Database | Fetcher>) {
+	return getMaskedEnv(env);
+}

package/templates/middleware/middleware-multiworker-dev.d.ts

@@ -0,0 +1,4 @@
+declare module "config:middleware/multiworker-dev" {
+	import type { WorkerRegistry } from "../../src/dev-registry";
+	export const workers: WorkerRegistry;
+}

package/templates/middleware/middleware-multiworker-dev.ts

@@ -0,0 +1,59 @@
+// @ts-nocheck
+/// <reference path="middleware-multiworker-dev.d.ts"/>
+
+import { workers } from "config:middleware/multiworker-dev";
+import type { WorkerRegistry } from "../../src/dev-registry";
+
+export function wrap(env: Record<string, unknown>) {
+	const facadeEnv = { ...env };
+	// For every Worker definition that's available,
+	// create a fetcher for it on the facade env.
+	// for const [name,  binding] of env
+	// if Workers[name]
+	// const details = Workers[name];
+
+	for (const [name, details] of Object.entries(workers as WorkerRegistry)) {
+		if (details) {
+			facadeEnv[name] = {
+				async fetch(...reqArgs: Parameters<Fetcher["fetch"]>) {
+					const reqFromArgs = new Request(...reqArgs);
+					if (details.headers) {
+						for (const [key, value] of Object.entries(details.headers)) {
+							// In remote mode, you need to add a couple of headers
+							// to make sure it's talking to the 'dev' preview session
+							// (much like wrangler dev already does via proxy.ts)
+							reqFromArgs.headers.set(key, value);
+						}
+						return (env[name] as Fetcher).fetch(reqFromArgs);
+					}
+
+					const url = new URL(reqFromArgs.url);
+					if (details.protocol !== undefined) {
+						url.protocol = details.protocol;
+					}
+					if (details.host !== undefined) {
+						url.host = details.host;
+					}
+					if (details.port !== undefined) {
+						url.port = details.port.toString();
+					}
+
+					const request = new Request(url.toString(), reqFromArgs);
+					return fetch(request);
+				},
+			};
+		} else {
+			// This means there's no dev binding available.
+			// Let's use whatever's available, or put a shim with a message.
+			facadeEnv[name] = facadeEnv[name] || {
+				async fetch() {
+					return new Response(
+						`You should start up wrangler dev --local on the ${name} worker`,
+						{ status: 404 }
+					);
+				},
+			};
+		}
+	}
+	return facadeEnv;
+}

package/templates/middleware/middleware-serve-static-assets.d.ts

@@ -0,0 +1,6 @@
+declare module "config:middleware/serve-static-assets" {
+	import type { CacheControl } from "@cloudflare/kv-asset-handler";
+
+	export const spaMode: boolean;
+	export const cacheControl: Partial<CacheControl>;
+}

package/templates/middleware/middleware-serve-static-assets.ts

@@ -0,0 +1,56 @@
+/// <reference path="middleware-serve-static-assets.d.ts"/>
+
+import {
+	getAssetFromKV,
+	NotFoundError,
+	MethodNotAllowedError,
+	serveSinglePageApp,
+} from "@cloudflare/kv-asset-handler";
+import type { Options } from "@cloudflare/kv-asset-handler";
+import { spaMode, cacheControl } from "config:middleware/serve-static-assets";
+import type * as kvAssetHandler from "@cloudflare/kv-asset-handler";
+import manifest from "__STATIC_CONTENT_MANIFEST";
+const ASSET_MANIFEST = JSON.parse(manifest);
+
+import type { Middleware } from "./common";
+
+const staticAssets: Middleware = async (request, env, _ctx, middlewareCtx) => {
+	let options: Partial<Options> = {
+		ASSET_MANIFEST,
+		ASSET_NAMESPACE: env.__STATIC_CONTENT,
+		cacheControl: cacheControl,
+		mapRequestToAsset: spaMode ? serveSinglePageApp : undefined,
+	};
+
+	try {
+		const page = await (getAssetFromKV as typeof kvAssetHandler.getAssetFromKV)(
+			{
+				request,
+				waitUntil(promise) {
+					return _ctx.waitUntil(promise);
+				},
+			},
+			options
+		);
+
+		// allow headers to be altered
+		const response = new Response(page.body, page);
+
+		response.headers.set("X-XSS-Protection", "1; mode=block");
+		response.headers.set("X-Content-Type-Options", "nosniff");
+		response.headers.set("X-Frame-Options", "DENY");
+		response.headers.set("Referrer-Policy", "unsafe-url");
+		response.headers.set("Feature-Policy", "none");
+
+		return response;
+	} catch (e) {
+		if (e instanceof NotFoundError || e instanceof MethodNotAllowedError) {
+			// if a known error is thrown then serve from actual worker
+			return await middlewareCtx.next(request, env);
+		}
+		// otherwise it's a real error, so throw it
+		throw e;
+	}
+};
+
+export default staticAssets;

package/templates/new-worker-scheduled.ts

@@ -5,7 +5,7 @@
  * - Run `curl "http://localhost:8787/cdn-cgi/mf/scheduled"` to trigger the scheduled event
  * - Go back to the console to see what your worker has logged
  * - Update the Cron trigger in wrangler.toml (see https://developers.cloudflare.com/workers/wrangler/configuration/#triggers)
- * - Run `wrangler publish --name my-worker` to publish your worker
+ * - Run `wrangler deploy --name my-worker` to deploy your worker
  *
  * Learn more at https://developers.cloudflare.com/workers/runtime-apis/scheduled-event/
  */

package/templates/new-worker.ts

@@ -3,7 +3,7 @@
  *
  * - Run `wrangler dev src/index.ts` in your terminal to start a development server
  * - Open a browser tab at http://localhost:8787/ to see your worker in action
- * - Run `wrangler publish src/index.ts --name my-worker` to publish your worker
+ * - Run `wrangler deploy src/index.ts --name my-worker` to deploy your worker
  *
  * Learn more at https://developers.cloudflare.com/workers/
  */

package/templates/pages-shim.ts

@@ -3,9 +3,6 @@
 
 export default <ExportedHandler<{ ASSETS: Fetcher }>>{
 	async fetch(request, env, context) {
-		// @ts-expect-error due to a bug in `@cloudflare/workers-types`, the `cf`
-		//  types from the `request` parameter and `RequestInit` are incompatible.
-		//  We'll get this fixed very soon.
 		const response = await env.ASSETS.fetch(request.url, request);
 		return new Response(response.body, response);
 	},

package/templates/pages-template-plugin.ts

@@ -122,7 +122,8 @@ function* executeRequest(request: Request, relativePathname: string) {
 export default function (pluginArgs: unknown) {
 	const onRequest: PagesPluginFunction = async (workerContext) => {
 		let { request } = workerContext;
-		const { env, next, data } = workerContext;
+		const { env, next } = workerContext;
+		let { data } = workerContext;
 
 		const url = new URL(request.url);
 		// TODO: Replace this with something actually legible.
@@ -149,7 +150,16 @@ export default function (pluginArgs: unknown) {
 					functionPath: workerContext.functionPath + path,
 					next: pluginNext,
 					params,
-					data,
+					get data() {
+						return data;
+					},
+					set data(value) {
+						if (typeof value !== "object" || value === null) {
+							throw new Error("context.data must be an object");
+						}
+						// user has overriden context.data, so we need to merge it with the existing data
+						data = value;
+					},
 					pluginArgs,
 					env,
 					waitUntil: workerContext.waitUntil.bind(workerContext),

package/templates/pages-template-worker.ts

@@ -120,7 +120,7 @@ export default {
 	) {
 		let request = originalRequest;
 		const handlerIterator = executeRequest(request);
-		const data = {}; // arbitrary data the user can set between functions
+		let data = {}; // arbitrary data the user can set between functions
 		let isFailOpen = false;
 
 		const next = async (input?: RequestInfo, init?: RequestInit) => {
@@ -141,7 +141,16 @@ export default {
 					functionPath: path,
 					next,
 					params,
-					data,
+					get data() {
+						return data;
+					},
+					set data(value) {
+						if (typeof value !== "object" || value === null) {
+							throw new Error("context.data must be an object");
+						}
+						// user has overriden context.data, so we need to merge it with the existing data
+						data = value;
+					},
 					env,
 					waitUntil: workerContext.waitUntil.bind(workerContext),
 					passThroughOnException: () => {

package/templates/tsconfig.json

@@ -1,5 +1,5 @@
 {
-	"extends": "../tsconfig.json",
+	"extends": "@cloudflare/workers-tsconfig/tsconfig.json",
 	"compilerOptions": {
 		"types": ["@cloudflare/workers-types"]
 	},