wrangler 0.0.0-e8df68ee → 0.0.0-e9106dfa5

package/Cloudflare_CA.pem

@@ -1,18 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIC6zCCAkygAwIBAgIUI7b68p0pPrCBoW4ptlyvVcPItscwCgYIKoZIzj0EAwQw
-gY0xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1T
-YW4gRnJhbmNpc2NvMRgwFgYDVQQKEw9DbG91ZGZsYXJlLCBJbmMxNzA1BgNVBAMT
-LkNsb3VkZmxhcmUgZm9yIFRlYW1zIEVDQyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkw
-HhcNMjAwMjA0MTYwNTAwWhcNMjUwMjAyMTYwNTAwWjCBjTELMAkGA1UEBhMCVVMx
-EzARBgNVBAgTCkNhbGlmb3JuaWExFjAUBgNVBAcTDVNhbiBGcmFuY2lzY28xGDAW
-BgNVBAoTD0Nsb3VkZmxhcmUsIEluYzE3MDUGA1UEAxMuQ2xvdWRmbGFyZSBmb3Ig
-VGVhbXMgRUNDIENlcnRpZmljYXRlIEF1dGhvcml0eTCBmzAQBgcqhkjOPQIBBgUr
-gQQAIwOBhgAEAVdXsX8tpA9NAQeEQalvUIcVaFNDvGsR69ysZxOraRWNGHLfq1mi
-P6o3wtmtx/C2OXG01Cw7UFJbKl5MEDxnT2KoAdFSynSJOF2NDoe5LoZHbUW+yR3X
-FDl+MF6JzZ590VLGo6dPBf06UsXbH7PvHH2XKtFt8bBXVNMa5a21RdmpD0Pho0Uw
-QzAOBgNVHQ8BAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBAjAdBgNVHQ4EFgQU
-YBcQng1AEMMNteuRDAMG0/vgFe0wCgYIKoZIzj0EAwQDgYwAMIGIAkIBQU5OTA2h
-YqmFk8paan5ezHVLcmcucsfYw4L/wmeEjCkczRmCVNm6L86LjhWU0v0wER0e+lHO
-3efvjbsu8gIGSagCQgEBnyYMP9gwg8l96QnQ1khFA1ljFlnqc2XgJHDSaAJC0gdz
-+NV3JMeWaD2Rb32jc9r6/a7xY0u0ByqxBQ1OQ0dt7A==
------END CERTIFICATE-----

package/templates/middleware/middleware-d1-beta.d.ts

@@ -1,3 +0,0 @@
-declare module "config:middleware/d1-beta" {
-	export const D1_IMPORTS: string[];
-}

package/templates/middleware/middleware-d1-beta.ts

@@ -1,244 +0,0 @@
-/// <reference path="middleware-d1-beta.d.ts"/>
-
-import { D1_IMPORTS } from "config:middleware/d1-beta";
-
-// src/index.ts
-class D1Database {
-	constructor(readonly binding: Fetcher) {}
-	prepare(query: string) {
-		return new D1PreparedStatement(this, query);
-	}
-	async dump() {
-		const response = await this.binding.fetch("http://d1/dump", {
-			method: "POST",
-			headers: {
-				"content-type": "application/json",
-			},
-		});
-		if (response.status !== 200) {
-			try {
-				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: Status + ${response.status}`, {
-					cause: new Error("Status " + response.status),
-				});
-			}
-		}
-		return await response.arrayBuffer();
-	}
-	async batch(statements: D1PreparedStatement[]) {
-		const exec = await this._send(
-			"/query",
-			statements.map((s) => s.statement),
-			statements.map((s) => s.params)
-		);
-		return exec;
-	}
-	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];
-		const error = exec
-			.map((r) => {
-				return r.error ? 1 : 0;
-			})
-			.indexOf(1);
-		if (error !== -1) {
-			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 as number);
-				}, 0),
-			};
-		}
-	}
-	async _send(
-		endpoint: string,
-		query: string | string[],
-		params: unknown[],
-		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(new URL(endpoint, "http://d1"), {
-			method: "POST",
-			headers: {
-				"content-type": "application/json",
-			},
-			body,
-		});
-		try {
-			const answer = (await response.json()) as { error?: string };
-			if (answer.error && dothrow) {
-				const err = answer;
-				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) {
-			const error = e as Error;
-			throw new Error(`D1_ERROR: ${error.cause || "Something went wrong"}`, {
-				cause: new Error(`${error.cause}` || "Something went wrong"),
-			});
-		}
-	}
-}
-
-class D1PreparedStatement {
-	constructor(
-		readonly database: D1Database,
-		readonly statement: string,
-		readonly params: unknown[] = []
-	) {}
-	bind(...values: unknown[]) {
-		for (var r in values) {
-			const value = values[r];
-			switch (typeof value) {
-				case "number":
-				case "string":
-					break;
-				case "object":
-					if (value == null) break;
-					if (
-						Array.isArray(value) &&
-						value
-							.map((b) => {
-								return typeof b == "number" && b >= 0 && b < 256 ? 1 : 0;
-							})
-							.indexOf(0) == -1
-					)
-						break;
-					if (value instanceof ArrayBuffer) {
-						values[r] = Array.from(new Uint8Array(value));
-						break;
-					}
-					if (ArrayBuffer.isView(value)) {
-						values[r] = Array.from(new Uint8Array(value.buffer));
-						break;
-					}
-				default:
-					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: 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: Column not found (${colName})`, {
-					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: unknown) {
-	return Array.isArray(results) ? results[0] : results;
-}
-function mapD1Result(result: Partial<D1Result>): D1Result {
-	let map: D1Result = {
-		results: result.results || [],
-		success: result.success === void 0 ? true : result.success,
-		meta: result.meta || {},
-	};
-	result.error && (map.error = result.error);
-	return map;
-}
-
-type D1Result = {
-	results: unknown[];
-	success: boolean;
-	meta: Record<string, unknown>;
-	error?: string;
-};
-
-// src/shim.ts
-var D1_BETA_PREFIX = `__D1_BETA__`;
-var envMap = /* @__PURE__ */ new Map();
-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) =>
-		bindingName.startsWith(D1_BETA_PREFIX)
-	).forEach((bindingName) => {
-		newEnv.delete(bindingName);
-		const newName = bindingName.slice(D1_BETA_PREFIX.length);
-		const newBinding = new D1Database(env[bindingName] as Fetcher);
-		newEnv.set(newName, newBinding);
-	});
-	const newEnvObj = Object.fromEntries(newEnv.entries());
-	envMap.set(env, newEnvObj);
-	return newEnvObj;
-}
-
-export function wrap(env: Record<string, D1Database | Fetcher>) {
-	return getMaskedEnv(env);
-}

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

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

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

@@ -1,59 +0,0 @@
-// @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

@@ -1,6 +0,0 @@
-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

@@ -1,56 +0,0 @@
-/// <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;