wrangler 0.0.0-e3278fa → 0.0.0-e33294b0

package/templates/d1-beta-facade.js

@@ -0,0 +1,241 @@
+// src/shim.ts
+import worker, * as OTHER_EXPORTS from "__ENTRY_POINT__";
+export * from "__ENTRY_POINT__";
+
+// src/index.ts
+var D1Database = class {
+	constructor(binding) {
+		this.binding = binding;
+	}
+	prepare(query) {
+		return new D1PreparedStatement(this, query);
+	}
+	async dump() {
+		const response = await this.binding.fetch("/dump", {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+			},
+		});
+		if (response.status !== 200) {
+			try {
+				const err = await response.json();
+				throw new Error("D1_DUMP_ERROR", {
+					cause: new Error(err.error),
+				});
+			} catch (e) {
+				throw new Error("D1_DUMP_ERROR", {
+					cause: new Error("Status " + response.status),
+				});
+			}
+		}
+		return await response.arrayBuffer();
+	}
+	async batch(statements) {
+		const exec = await this._send(
+			"/query",
+			statements.map((s) => s.statement),
+			statements.map((s) => s.params)
+		);
+		return exec;
+	}
+	async exec(query) {
+		const lines = query.trim().split("\n");
+		const _exec = await this._send("/query", lines, [], false);
+		const exec = Array.isArray(_exec) ? _exec : [_exec];
+		const error = exec
+			.map((r) => {
+				return r.error ? 1 : 0;
+			})
+			.indexOf(1);
+		if (error !== -1) {
+			throw new Error("D1_EXEC_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;
+				}, 0),
+			};
+		}
+	}
+	async _send(endpoint, query, params, dothrow = true) {
+		const body = JSON.stringify(
+			typeof query == "object"
+				? query.map((s, index) => {
+						return { sql: s, params: params[index] };
+				  })
+				: {
+						sql: query,
+						params,
+				  }
+		);
+		const response = await this.binding.fetch(endpoint, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+			},
+			body,
+		});
+		try {
+			const answer = await response.json();
+			if (answer.error && dothrow) {
+				const err = answer;
+				throw new Error("D1_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"),
+			});
+		}
+	}
+};
+var D1PreparedStatement = class {
+	constructor(database, statement, values) {
+		this.database = database;
+		this.statement = statement;
+		this.params = values || [];
+	}
+	bind(...values) {
+		for (var r in values) {
+			switch (typeof values[r]) {
+				case "number":
+				case "string":
+					break;
+				case "object":
+					if (values[r] == null) break;
+					if (
+						Array.isArray(values[r]) &&
+						values[r]
+							.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]));
+						break;
+					}
+					if (ArrayBuffer.isView(values[r])) {
+						values[r] = Array.from(values[r]);
+						break;
+					}
+				default:
+					throw new Error("D1_TYPE_ERROR", {
+						cause: new Error(
+							"Type '" +
+								typeof values[r] +
+								"' not supported for value '" +
+								values[r] +
+								"'"
+						),
+					});
+			}
+		}
+		return new D1PreparedStatement(this.database, this.statement, values);
+	}
+	async first(colName) {
+		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", {
+					cause: new Error("Column not found"),
+				});
+			}
+			return results.length < 1 ? null : results[0][colName];
+		} else {
+			return results.length < 1 ? null : results[0];
+		}
+	}
+	async run() {
+		return firstIfArray(
+			await this.database._send("/execute", this.statement, this.params)
+		);
+	}
+	async all() {
+		return firstIfArray(
+			await this.database._send("/query", this.statement, this.params)
+		);
+	}
+	async raw() {
+		const s = firstIfArray(
+			await this.database._send("/query", this.statement, this.params)
+		);
+		const raw = [];
+		for (var r in s.results) {
+			const entry = Object.keys(s.results[r]).map((k) => {
+				return s.results[r][k];
+			});
+			raw.push(entry);
+		}
+		return raw;
+	}
+};
+function firstIfArray(results) {
+	return Array.isArray(results) ? results[0] : results;
+}
+function mapD1Result(result) {
+	let map = {
+		results: result.results || [],
+		success: result.success === void 0 ? true : result.success,
+		meta: result.meta || {},
+	};
+	result.error && (map.error = result.error);
+	return map;
+}
+
+// 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) {
+	if (envMap.has(env)) return envMap.get(env);
+	const newEnv = new Map(Object.entries(env));
+	D1_IMPORTS.filter((bindingName) =>
+		bindingName.startsWith(D1_BETA_PREFIX)
+	).forEach((bindingName) => {
+		newEnv.delete(bindingName);
+		const newName = bindingName.slice(D1_BETA_PREFIX.length);
+		const newBinding = !LOCAL_MODE
+			? new D1Database(env[bindingName])
+			: env[bindingName];
+		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);
+	},
+};
+export { shim_default as default };

package/templates/facade.d.ts

@@ -0,0 +1,14 @@
+declare module "__ENTRY_POINT__" {
+	import type { Middleware } from "./middleware/common";
+	const worker: ExportedHandler & { middleware?: Middleware[] };
+	export default worker;
+}
+
+declare module "__KV_ASSET_HANDLER__" {
+	export * from "@cloudflare/kv-asset-handler";
+}
+
+declare module "__STATIC_CONTENT_MANIFEST" {
+	const manifest: string;
+	export default manifest;
+}

package/templates/first-party-worker-module-facade.ts

@@ -0,0 +1,19 @@
+import worker from "__ENTRY_POINT__";
+export * from "__ENTRY_POINT__";
+
+type Env = {
+	// TODO: type this
+};
+
+/**
+ * Setup globals/vars as required
+ */
+
+export default <ExportedHandler>{
+	async fetch(request: Request, env: Env, ctx: ExecutionContext) {
+		if (worker.fetch === undefined) {
+			throw new TypeError("Entry point missing `fetch` handler");
+		}
+		return worker.fetch(request, env, ctx);
+	},
+};

package/templates/format-dev-errors.ts

@@ -0,0 +1,34 @@
+import worker from "__ENTRY_POINT__";
+
+export * from "__ENTRY_POINT__";
+
+export default <ExportedHandler>{
+	...worker,
+	async fetch(req, env, ctx) {
+		if (worker.fetch === undefined) {
+			throw new TypeError("Entry point missing `fetch` handler");
+		}
+		try {
+			return await worker.fetch(req, env, ctx);
+		} catch (err) {
+			return new Response(
+				`<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8" />
+		<title>Error</title>
+	</head>
+	<body>
+		<pre>${(err as Error).stack}</pre>
+	</body>
+</html>`,
+				{
+					status: 500,
+					headers: {
+						"Content-Type": "text/html",
+					},
+				}
+			);
+		}
+	},
+};

package/templates/init-tests/test-jest-new-worker.js

@@ -0,0 +1,23 @@
+const { unstable_dev } = require("wrangler");
+
+describe("Worker", () => {
+	let worker;
+
+	beforeAll(async () => {
+		worker = await unstable_dev("src/index.js", {
+			experimental: { disableExperimentalWarning: true },
+		});
+	});
+
+	afterAll(async () => {
+		await worker.stop();
+	});
+
+	it("should return Hello World", async () => {
+		const resp = await worker.fetch();
+		if (resp) {
+			const text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+	});
+});

package/templates/init-tests/test-vitest-new-worker.js

@@ -0,0 +1,24 @@
+import { unstable_dev } from "wrangler";
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+
+describe("Worker", () => {
+	let worker;
+
+	beforeAll(async () => {
+		worker = await unstable_dev("src/index.js", {
+			experimental: { disableExperimentalWarning: true },
+		});
+	});
+
+	afterAll(async () => {
+		await worker.stop();
+	});
+
+	it("should return Hello World", async () => {
+		const resp = await worker.fetch();
+		if (resp) {
+			const text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+	});
+});

package/templates/init-tests/test-vitest-new-worker.ts

@@ -0,0 +1,25 @@
+import { unstable_dev } from "wrangler";
+import type { UnstableDevWorker } from "wrangler";
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+
+describe("Worker", () => {
+	let worker: UnstableDevWorker;
+
+	beforeAll(async () => {
+		worker = await unstable_dev("src/index.ts", {
+			experimental: { disableExperimentalWarning: true },
+		});
+	});
+
+	afterAll(async () => {
+		await worker.stop();
+	});
+
+	it("should return Hello World", async () => {
+		const resp = await worker.fetch();
+		if (resp) {
+			const text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+	});
+});

package/templates/middleware/common.ts

@@ -0,0 +1,62 @@
+export type Awaitable<T> = T | Promise<T>;
+// TODO: allow dispatching more events?
+export type Dispatcher = (
+	type: "scheduled",
+	init: { cron?: string }
+) => Awaitable<void>;
+
+export interface MiddlewareContext {
+	dispatch: Dispatcher;
+	next(request: Request, env: any): Awaitable<Response>;
+}
+
+export type Middleware = (
+	request: Request,
+	env: any,
+	ctx: ExecutionContext,
+	middlewareCtx: MiddlewareContext
+) => Awaitable<Response>;
+
+const __facade_middleware__: Middleware[] = [];
+
+// The register functions allow for the insertion of one or many middleware,
+// We register internal middleware first in the stack, but have no way of controlling
+// the order that addMiddleware is run in service workers so need an internal function.
+export function __facade_register__(...args: (Middleware | Middleware[])[]) {
+	__facade_middleware__.push(...args.flat());
+}
+export function __facade_registerInternal__(
+	...args: (Middleware | Middleware[])[]
+) {
+	__facade_middleware__.unshift(...args.flat());
+}
+
+function __facade_invokeChain__(
+	request: Request,
+	env: any,
+	ctx: ExecutionContext,
+	dispatch: Dispatcher,
+	middlewareChain: Middleware[]
+): Awaitable<Response> {
+	const [head, ...tail] = middlewareChain;
+	const middlewareCtx: MiddlewareContext = {
+		dispatch,
+		next(newRequest, newEnv) {
+			return __facade_invokeChain__(newRequest, newEnv, ctx, dispatch, tail);
+		},
+	};
+	return head(request, env, ctx, middlewareCtx);
+}
+
+export function __facade_invoke__(
+	request: Request,
+	env: any,
+	ctx: ExecutionContext,
+	dispatch: Dispatcher,
+	finalMiddleware: Middleware
+): Awaitable<Response> {
+	return __facade_invokeChain__(request, env, ctx, dispatch, [
+		...__facade_middleware__,
+		finalMiddleware,
+	]);
+}

package/templates/middleware/loader-modules.ts

@@ -0,0 +1,84 @@
+// // This loads all middlewares exposed on the middleware object
+// // and then starts the invocation chain.
+// // The big idea is that we can add these to the middleware export dynamically
+// // through wrangler, or we can potentially let users directly add them as a sort
+// // of "plugin" system.
+
+import {
+	Dispatcher,
+	Middleware,
+	__facade_invoke__,
+	__facade_register__,
+} from "./common";
+
+import worker from "__ENTRY_POINT__";
+
+// We need to preserve all of the exports from the worker
+export * from "__ENTRY_POINT__";
+
+class __Facade_ScheduledController__ implements ScheduledController {
+	#noRetry: ScheduledController["noRetry"];
+
+	constructor(
+		readonly scheduledTime: number,
+		readonly cron: string,
+		noRetry: ScheduledController["noRetry"]
+	) {
+		this.#noRetry = noRetry;
+	}
+
+	noRetry() {
+		if (!(this instanceof __Facade_ScheduledController__)) {
+			throw new TypeError("Illegal invocation");
+		}
+		// Need to call native method immediately in case uncaught error thrown
+		this.#noRetry();
+	}
+}
+
+const __facade_modules_fetch__: Middleware = function (request, env, ctx) {
+	if (worker.fetch === undefined) throw new Error("No fetch handler!"); // TODO: proper error message
+	return worker.fetch(request, env, ctx);
+};
+
+const facade: ExportedHandler<unknown> = {
+	fetch(request, env, ctx) {
+		// Get the chain of middleware from the worker object
+		if (worker.middleware && worker.middleware.length > 0) {
+			for (const middleware of worker.middleware) {
+				__facade_register__(middleware);
+			}
+
+			const __facade_modules_dispatch__: Dispatcher = function (type, init) {
+				if (type === "scheduled" && worker.scheduled !== undefined) {
+					const controller = new __Facade_ScheduledController__(
+						Date.now(),
+						init.cron ?? "",
+						() => {}
+					);
+					return worker.scheduled(controller, env, ctx);
+				}
+			};
+
+			return __facade_invoke__(
+				request,
+				env,
+				ctx,
+				__facade_modules_dispatch__,
+				__facade_modules_fetch__
+			);
+		} else {
+			// We didn't have any middleware so we can skip the invocation chain,
+			// and just call the fetch handler directly
+
+			// We "don't care" if this is undefined as we want to have the same behaviour
+			// as if the worker completely bypassed middleware.
+			return worker.fetch!(request, env, ctx);
+		}
+	},
+	scheduled: worker.scheduled,
+	queue: worker.queue,
+	trace: worker.trace,
+};
+
+export default facade;