wrangler 0.0.0-ecc8b172 → 0.0.0-ecded1af1

package/templates/d1-beta-facade.js

@@ -1,174 +0,0 @@
-// src/shim.ts
-import worker 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) {
-			const err = await response.json();
-			throw new Error("D1_DUMP_ERROR", {
-				cause: new Error(err.error),
-			});
-		}
-		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, []);
-		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.duration;
-				}, 0),
-			};
-		}
-	}
-	async _send(endpoint, query, params) {
-		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,
-		});
-		if (response.status !== 200) {
-			const err = await response.json();
-			throw new Error("D1_ERROR", { cause: new Error(err.error) });
-		}
-		const answer = await response.json();
-		return Array.isArray(answer) ? answer : answer;
-	}
-};
-var D1PreparedStatement = class {
-	constructor(database, statement, values) {
-		this.database = database;
-		this.statement = statement;
-		this.params = values || [];
-	}
-	bind(...values) {
-		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 (results.length < 1) {
-			throw new Error("D1_NORESULTS", { cause: new Error("No results") });
-		}
-		const result = results[0];
-		if (colName !== void 0) {
-			if (result[colName] === void 0) {
-				throw new Error("D1_COLUMN_NOTFOUND", {
-					cause: new Error(`Column not found`),
-				});
-			}
-			return result[colName];
-		} else {
-			return result;
-		}
-	}
-	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;
-}
-
-// 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 = {
-	async fetch(request, env, ctx) {
-		return worker.fetch(request, getMaskedEnv(env), ctx);
-	},
-
-	async scheduled(controller, env, ctx) {
-		return worker.scheduled(controller, getMaskedEnv(env), ctx);
-	},
-};
-export { shim_default as default };

package/templates/experimental-local-cache-stubs.js

@@ -1,27 +0,0 @@
-// `workerd` currently throws on any use of the Cache API. Workers Sites
-// requires the Cache API to function though, so stub it out to no-ops, like in
-// regular `wrangler dev`.
-
-class Cache {
-	async put(req, res) {}
-
-	async match(req, options) {}
-
-	async delete(req, options) {
-		return false;
-	}
-}
-
-class CacheStorage {
-	#cache = new Cache();
-
-	get default() {
-		return this.#cache;
-	}
-
-	async open(cacheName) {
-		return this.#cache;
-	}
-}
-
-globalThis.caches = new CacheStorage();

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

@@ -1,18 +0,0 @@
-// @ts-ignore entry point will get replaced
-import worker from "__ENTRY_POINT__";
-// @ts-ignore entry point will get replaced
-export * from "__ENTRY_POINT__";
-
-type Env = {
-	// TODO: type this
-};
-
-/**
- * Setup globals/vars as required
- */
-
-export default {
-	async fetch(request: Request, env: Env, ctx: ExecutionContext) {
-		return worker.fetch(request, env, ctx);
-	},
-};

package/templates/format-dev-errors.ts

@@ -1,32 +0,0 @@
-// @ts-expect-error We'll swap in the entry point during build
-import Worker from "__ENTRY_POINT__";
-
-// @ts-expect-error
-export * from "__ENTRY_POINT__";
-
-export default {
-	async fetch(req: Request, env: unknown, ctx: ExecutionContext) {
-		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/serve-static-assets.ts

@@ -1,63 +0,0 @@
-// @ts-expect-error
-import worker from "__ENTRY_POINT__";
-import {
-	getAssetFromKV,
-	NotFoundError,
-	MethodNotAllowedError,
-	// @ts-expect-error
-} from "__KV_ASSET_HANDLER__";
-// @ts-expect-error
-import manifest from "__STATIC_CONTENT_MANIFEST";
-import type * as kvAssetHandler from "@cloudflare/kv-asset-handler";
-
-const ASSET_MANIFEST = JSON.parse(manifest);
-
-// @ts-expect-error
-export * from "__ENTRY_POINT__";
-
-export default {
-	async fetch(
-		request: Request,
-		env: { __STATIC_CONTENT: string },
-		ctx: ExecutionContext
-	) {
-		let options = {
-			ASSET_MANIFEST,
-			ASSET_NAMESPACE: env.__STATIC_CONTENT,
-			cacheControl: __CACHE_CONTROL_OPTIONS__,
-			serveSinglePageApp: __SERVE_SINGLE_PAGE_APP__,
-		};
-
-		try {
-			const page = await (
-				getAssetFromKV as typeof kvAssetHandler.getAssetFromKV
-			)(
-				{
-					request,
-					waitUntil(promise: Promise<unknown>) {
-						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 worker.fetch(request, env, ctx);
-			}
-			// otherwise it's a real error, so throw it
-			throw e;
-		}
-	},
-};

package/templates/service-bindings-module-facade.js

@@ -1,54 +0,0 @@
-import worker from "__ENTRY_POINT__";
-const Workers = __WORKERS__;
-
-export * from "__ENTRY_POINT__";
-
-export default {
-	async fetch(req, env, ctx) {
-		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)) {
-			if (details) {
-				facadeEnv[name] = {
-					async fetch(...reqArgs) {
-						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].fetch(reqFromArgs);
-						}
-
-						const url = new URL(reqFromArgs.url);
-						url.protocol = details.protocol;
-						url.host = details.host;
-						if (details.port !== undefined) url.port = details.port;
-
-						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 worker.fetch(req, facadeEnv, ctx);
-	},
-};

package/templates/service-bindings-sw-facade.js

@@ -1,42 +0,0 @@
-import "__ENTRY_POINT__";
-const Workers = __WORKERS__;
-
-// For every Worker definition that's available,
-// create a fetcher for it on the facade env.
-for (const [name, details] of Object.entries(Workers)) {
-	if (details) {
-		globalThis[name] = {
-			async fetch(...reqArgs) {
-				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].fetch(reqFromArgs);
-				}
-
-				const url = new URL(reqFromArgs.url);
-				url.protocol = details.protocol;
-				url.host = details.host;
-				if (details.port !== undefined) url.port = details.port;
-
-				const request = new Request(url.toString(), reqFromArgs);
-				return fetch(request);
-			},
-		};
-	} else {
-		// This means it's a local mode binding
-		// but hasn't started up locally yet.
-		globalThis[name] = {
-			async fetch() {
-				return new Response(
-					`You should start up wrangler dev --local on the ${name} worker`,
-					{ status: 404 }
-				);
-			},
-		};
-	}
-}