devflare 1.0.0-next.5 → 1.0.0-next.50

package/dist/_chunks/local-dev-vars-CTSa-wvF.js

@@ -0,0 +1,81 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "pathe";
+//#region src/config/local-dev-vars.ts
+function parseEnvValue(value) {
+	const trimmed = value.trim();
+	const quote = trimmed[0];
+	if ((quote === "\"" || quote === "'" || quote === "`") && trimmed.endsWith(quote) && trimmed.length >= 2) {
+		const inner = trimmed.slice(1, -1);
+		return quote === "\"" ? inner.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, "\"").replace(/\\\\/g, "\\") : inner;
+	}
+	const commentIndex = trimmed.search(/\s+#/);
+	return (commentIndex >= 0 ? trimmed.slice(0, commentIndex) : trimmed).trimEnd();
+}
+function parseEnvFile(contents) {
+	const vars = {};
+	for (const line of contents.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const assignment = trimmed.startsWith("export ") ? trimmed.slice(7).trimStart() : trimmed;
+		const equalsIndex = assignment.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		const key = assignment.slice(0, equalsIndex).trim();
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+		vars[key] = parseEnvValue(assignment.slice(equalsIndex + 1));
+	}
+	return vars;
+}
+async function readOptionalEnvFile(filePath) {
+	try {
+		return parseEnvFile(await readFile(filePath, "utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function loadWranglerCompatibleLocalVars(cwd, environment) {
+	const environmentDevVars = environment ? await readOptionalEnvFile(resolve(cwd, `.dev.vars.${environment}`)) : null;
+	if (environmentDevVars) return environmentDevVars;
+	const devVars = await readOptionalEnvFile(resolve(cwd, ".dev.vars"));
+	if (devVars) return devVars;
+	const envFiles = [
+		".env",
+		".env.local",
+		...environment ? [`.env.${environment}`, `.env.${environment}.local`] : []
+	];
+	const merged = {};
+	for (const fileName of envFiles) {
+		const values = await readOptionalEnvFile(resolve(cwd, fileName));
+		if (values) Object.assign(merged, values);
+	}
+	return merged;
+}
+function toWranglerSecretsConfig(secrets) {
+	if (!secrets) return;
+	const required = Object.entries(secrets).filter(([, config]) => config.required !== false).map(([name]) => name).sort();
+	return required.length > 0 ? { required } : void 0;
+}
+async function loadLocalDevVars(options) {
+	const activeEnvironment = options.environment ?? process.env.CLOUDFLARE_ENV;
+	const localVars = await loadWranglerCompatibleLocalVars(options.cwd, activeEnvironment);
+	const secretNames = toWranglerSecretsConfig(options.secrets)?.required;
+	const filteredLocalVars = secretNames ? Object.fromEntries(Object.entries(localVars).filter(([name]) => secretNames.includes(name))) : localVars;
+	return {
+		...options.vars ?? {},
+		...filteredLocalVars
+	};
+}
+async function applyLocalDevVarsToConfig(config, options) {
+	const vars = await loadLocalDevVars({
+		...options,
+		vars: config.vars,
+		secrets: config.secrets
+	});
+	if (Object.keys(vars).length === 0) return config;
+	return {
+		...config,
+		vars
+	};
+}
+//#endregion
+export { toWranglerSecretsConfig as n, applyLocalDevVarsToConfig as t };

package/dist/_chunks/local-hyperdrive-CJ90j46O.js

@@ -0,0 +1,119 @@
+//#region src/test/binding-hints.ts
+/**
+* Derive `BindingHints` from a resolved Devflare config.
+*
+* Shared by the test-context surface (`createTestContext` / simple-context) so
+* the mapping between config sections and hint kinds lives in one place.
+*/
+function extractBindingHints(config) {
+	const hints = {};
+	if (config.bindings?.kv) for (const name of Object.keys(config.bindings.kv)) hints[name] = "kv";
+	if (config.bindings?.r2) for (const name of Object.keys(config.bindings.r2)) hints[name] = "r2";
+	if (config.bindings?.d1) for (const name of Object.keys(config.bindings.d1)) hints[name] = "d1";
+	if (config.bindings?.durableObjects) for (const name of Object.keys(config.bindings.durableObjects)) hints[name] = "do";
+	if (config.bindings?.services) for (const name of Object.keys(config.bindings.services)) hints[name] = "service";
+	if (config.bindings?.queues?.consumers) for (const consumer of config.bindings.queues.consumers) hints[consumer.queue] = "queue";
+	if (config.bindings?.queues?.producers) for (const name of Object.keys(config.bindings.queues.producers)) hints[name] = "queue";
+	if (config.bindings?.ai) hints[config.bindings.ai.binding] = "ai";
+	if (config.bindings?.sendEmail) for (const name of Object.keys(config.bindings.sendEmail)) hints[name] = "sendEmail";
+	if (config.bindings?.workflows) for (const name of Object.keys(config.bindings.workflows)) hints[name] = "workflow";
+	return hints;
+}
+//#endregion
+//#region src/shims/local-worker-loader.ts
+const activeWorkerLoaderRuntimes = /* @__PURE__ */ new Set();
+function getModuleSource(module, mainModule) {
+	if (typeof module === "string") return module;
+	if (module && typeof module === "object" && typeof module.js === "string") return module.js;
+	throw new Error(`Worker Loader local shim only supports JavaScript main modules. Could not load "${mainModule}".`);
+}
+function createRequestInit(request) {
+	return {
+		method: request.method,
+		headers: request.headers,
+		body: request.body
+	};
+}
+async function createRuntime(code) {
+	const { Miniflare } = await import("miniflare");
+	const mainModule = code.mainModule;
+	const script = getModuleSource(code.modules[mainModule], mainModule);
+	const miniflare = new Miniflare({
+		modules: true,
+		compatibilityDate: code.compatibilityDate,
+		...code.compatibilityFlags && { compatibilityFlags: code.compatibilityFlags },
+		...code.env && { bindings: code.env },
+		script
+	});
+	await miniflare.ready;
+	activeWorkerLoaderRuntimes.add(miniflare);
+	return miniflare;
+}
+function createLocalWorkerStub(codeProvider) {
+	let runtimePromise = null;
+	const getRuntime = () => {
+		runtimePromise ??= Promise.resolve(codeProvider()).then(createRuntime);
+		return runtimePromise;
+	};
+	const fetcher = { async fetch(input, init) {
+		const request = input instanceof Request ? input : new Request(input, init);
+		return (await getRuntime()).dispatchFetch(request.url, createRequestInit(request));
+	} };
+	return {
+		getEntrypoint() {
+			return fetcher;
+		},
+		getDurableObjectClass() {
+			throw new Error("Worker Loader local shim cannot materialise a dynamic Durable Object class. getDurableObjectClass() returns an opaque facet-spawning reference that workerd only exposes inside the runtime. Use createTestContext() (a real Miniflare worker) for Durable Object behavior, or createMockWorkerLoader({ stub }) to inject a stub.");
+		}
+	};
+}
+function createLocalWorkerLoaderBinding() {
+	return {
+		get(_name, getCode) {
+			return createLocalWorkerStub(getCode);
+		},
+		load(code) {
+			return createLocalWorkerStub(() => code);
+		}
+	};
+}
+async function disposeLocalWorkerLoaderBindings() {
+	const runtimes = Array.from(activeWorkerLoaderRuntimes);
+	activeWorkerLoaderRuntimes.clear();
+	await Promise.all(runtimes.map(async (runtime) => {
+		await runtime.dispose();
+	}));
+}
+//#endregion
+//#region src/shims/local-hyperdrive.ts
+const HYPERDRIVE_CONNECT_MESSAGE = "Local Hyperdrive does not implement the raw socket connect(). Use the populated connection fields (connectionString, or host/port/user/password/database) with your Node database driver, or run a createTestContext()/Miniflare-backed test (Miniflare establishes real Hyperdrive socket connections) for socket-level behavior.";
+function defaultPortForDatabaseUrl(url) {
+	if (url.port) return Number(url.port);
+	return url.protocol === "mysql:" ? 3306 : 5432;
+}
+/**
+* Creates a Hyperdrive binding around a local database connection string.
+*
+* The connection fields are real and usable with any Node database client. The
+* Cloudflare `connect()` raw socket is intentionally not implemented — it would
+* require faithfully reproducing `cloudflare:sockets` semantics (TLS, startTls(),
+* half-open, SocketInfo) over node:net, which is exactly the kind of fake that
+* fails silently. It throws a clear, actionable error instead.
+*/
+function createLocalHyperdrive(connectionString) {
+	const url = new URL(connectionString);
+	return {
+		connectionString,
+		host: url.hostname,
+		port: defaultPortForDatabaseUrl(url),
+		user: decodeURIComponent(url.username),
+		password: decodeURIComponent(url.password),
+		database: decodeURIComponent(url.pathname.replace(/^\//, "")),
+		connect() {
+			throw new Error(HYPERDRIVE_CONNECT_MESSAGE);
+		}
+	};
+}
+//#endregion
+export { extractBindingHints as i, createLocalWorkerLoaderBinding as n, disposeLocalWorkerLoaderBindings as r, createLocalHyperdrive as t };

package/dist/_chunks/local-media-bindings-DsAW4AMF.js

@@ -0,0 +1,335 @@
+//#region src/shims/local-media-bindings.ts
+function emptyNodeStream() {
+	return new ReadableStream({ start(controller) {
+		controller.close();
+	} });
+}
+function normalizeNodeContentType(value, fallback) {
+	if (!value) return fallback;
+	if (value.includes("/")) return value;
+	if (value === "jpg" || value === "jpeg") return "image/jpeg";
+	if (value === "png") return "image/png";
+	if (value === "webp") return "image/webp";
+	if (value === "avif") return "image/avif";
+	if (value === "mp4") return "video/mp4";
+	return value;
+}
+async function readNodeBytes(stream) {
+	const buffer = await new Response(stream ?? emptyNodeStream()).arrayBuffer();
+	return new Uint8Array(buffer);
+}
+function streamFromNodeBytes(bytes) {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return new Response(copy).body ?? emptyNodeStream();
+}
+function createUnsupportedHostedImagesBinding() {
+	const unsupported = () => {
+		throw new Error("Devflare local Images hosted API is not implemented. Use transform/info APIs locally, or connect to Cloudflare for hosted image storage.");
+	};
+	return {
+		image(_imageId) {
+			return {
+				details: unsupported,
+				bytes: unsupported,
+				update: unsupported,
+				delete: unsupported
+			};
+		},
+		upload: unsupported,
+		list: unsupported
+	};
+}
+function createNodeImageResult(bytes, contentType) {
+	return {
+		response() {
+			return new Response(streamFromNodeBytes(bytes), { headers: { "Content-Type": contentType } });
+		},
+		contentType() {
+			return contentType;
+		},
+		image() {
+			return streamFromNodeBytes(bytes);
+		}
+	};
+}
+function createNodeImageTransformer(bytesPromise) {
+	const transformer = {
+		transform(_transform) {
+			return transformer;
+		},
+		draw(_image, _options) {
+			return transformer;
+		},
+		async output(options) {
+			return createNodeImageResult(await bytesPromise, normalizeNodeContentType(options?.format, "image/png"));
+		}
+	};
+	return transformer;
+}
+function createLocalImagesBinding() {
+	return {
+		async info(stream) {
+			return {
+				format: "image/png",
+				fileSize: (await readNodeBytes(stream)).byteLength,
+				width: 1,
+				height: 1
+			};
+		},
+		input(stream) {
+			return createNodeImageTransformer(readNodeBytes(stream));
+		},
+		hosted: createUnsupportedHostedImagesBinding()
+	};
+}
+function createNodeMediaResult(bytesPromise, contentType) {
+	return {
+		async media() {
+			return streamFromNodeBytes(await bytesPromise);
+		},
+		async response() {
+			return new Response(streamFromNodeBytes(await bytesPromise), { headers: { "Content-Type": contentType } });
+		},
+		async contentType() {
+			return contentType;
+		}
+	};
+}
+function createNodeMediaTransformer(bytesPromise) {
+	const output = (options = {}) => createNodeMediaResult(bytesPromise, normalizeNodeContentType(options.format, "video/mp4"));
+	return {
+		transform(_transform) {
+			return { output(options) {
+				return output(options);
+			} };
+		},
+		output(options) {
+			return output(options);
+		}
+	};
+}
+function createLocalMediaBinding() {
+	return { input(stream) {
+		return createNodeMediaTransformer(readNodeBytes(stream));
+	} };
+}
+const LOCAL_MEDIA_BINDING_SCRIPT = `
+import { RpcTarget, WorkerEntrypoint } from 'cloudflare:workers'
+
+function emptyStream() {
+	return new ReadableStream({
+		start(controller) {
+			controller.close()
+		}
+	})
+}
+
+function normalizeContentType(value, fallback) {
+	if (typeof value !== 'string' || value.length === 0) return fallback
+	if (value.includes('/')) return value
+	if (value === 'jpg') return 'image/jpeg'
+	if (value === 'jpeg') return 'image/jpeg'
+	if (value === 'png') return 'image/png'
+	if (value === 'webp') return 'image/webp'
+	if (value === 'avif') return 'image/avif'
+	if (value === 'mp4') return 'video/mp4'
+	return value
+}
+
+async function readBytes(stream) {
+	return await new Response(stream || emptyStream()).arrayBuffer()
+}
+
+function streamFromBytes(bytes) {
+	return new Response(bytes.slice(0)).body || emptyStream()
+}
+
+function createBodyReader(bytes) {
+	return function takeBody() {
+		return streamFromBytes(bytes)
+	}
+}
+
+class LocalImageResult extends RpcTarget {
+	constructor(takeBody, contentType) {
+		super()
+		this.takeBody = takeBody
+		this.contentTypeValue = contentType
+	}
+
+	response() {
+		return new Response(this.takeBody(), {
+			headers: { 'Content-Type': this.contentTypeValue }
+		})
+	}
+
+	contentType() {
+		return this.contentTypeValue
+	}
+
+	image() {
+		return this.takeBody()
+	}
+}
+
+class LocalImageTransformer extends RpcTarget {
+	constructor(bytes) {
+		super()
+		this.takeBody = createBodyReader(bytes)
+	}
+
+	transform() {
+		return this
+	}
+
+	draw() {
+		return this
+	}
+
+	async output(options = {}) {
+		return new LocalImageResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'image/png')
+		)
+	}
+}
+
+function createHostedImagesBinding() {
+	const unsupported = () => {
+		throw new Error('Devflare local Images hosted API is not implemented. Use the transform/info APIs locally, or connect to Cloudflare for hosted image storage.')
+	}
+	return {
+		image() {
+			return {
+				details: unsupported,
+				bytes: unsupported,
+				update: unsupported,
+				delete: unsupported
+			}
+		},
+		upload: unsupported,
+		list: unsupported
+	}
+}
+
+export class LocalImagesBinding extends WorkerEntrypoint {
+	async info(stream) {
+		const bytes = await readBytes(stream)
+		return {
+			format: 'image/png',
+			fileSize: bytes.byteLength,
+			width: 1,
+			height: 1
+		}
+	}
+
+	async input(stream) {
+		return new LocalImageTransformer(await readBytes(stream))
+	}
+
+	get hosted() {
+		return createHostedImagesBinding()
+	}
+}
+
+class LocalMediaResult extends RpcTarget {
+	constructor(takeBody, contentType) {
+		super()
+		this.takeBody = takeBody
+		this.contentTypeValue = contentType
+	}
+
+	async media() {
+		return this.takeBody()
+	}
+
+	async response() {
+		return new Response(this.takeBody(), {
+			headers: { 'Content-Type': this.contentTypeValue }
+		})
+	}
+
+	async contentType() {
+		return this.contentTypeValue
+	}
+}
+
+class LocalMediaTransformationGenerator extends RpcTarget {
+	constructor(takeBody) {
+		super()
+		this.takeBody = takeBody
+	}
+
+	output(options = {}) {
+		return new LocalMediaResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'video/mp4')
+		)
+	}
+}
+
+class LocalMediaTransformer extends RpcTarget {
+	constructor(bytes) {
+		super()
+		this.takeBody = createBodyReader(bytes)
+	}
+
+	transform() {
+		return new LocalMediaTransformationGenerator(this.takeBody)
+	}
+
+	output(options = {}) {
+		return new LocalMediaResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'video/mp4')
+		)
+	}
+}
+
+export class LocalMediaBinding extends WorkerEntrypoint {
+	async input(stream) {
+		return new LocalMediaTransformer(await readBytes(stream))
+	}
+}
+
+export default {
+	fetch() {
+		return new Response('Devflare local Images/Media binding')
+	}
+}
+`;
+function toLocalShimWorkerName(kind, bindingName, index) {
+	return `devflare-local-${kind}-${index}-${bindingName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || kind}`;
+}
+function getEntrypoint(kind) {
+	return kind === "images" ? "LocalImagesBinding" : "LocalMediaBinding";
+}
+function buildLocalBindingShimServiceConfig(config) {
+	const entries = [...Object.keys(config.bindings?.images ?? {}).map((bindingName) => ({
+		bindingName,
+		kind: "images"
+	})), ...Object.keys(config.bindings?.media ?? {}).map((bindingName) => ({
+		bindingName,
+		kind: "media"
+	}))];
+	return {
+		localBindingNames: entries.map((entry) => entry.bindingName),
+		serviceBindings: Object.fromEntries(entries.map((entry, index) => {
+			const workerName = toLocalShimWorkerName(entry.kind, entry.bindingName, index);
+			return [entry.bindingName, {
+				name: workerName,
+				entrypoint: getEntrypoint(entry.kind)
+			}];
+		})),
+		workers: entries.map((entry, index) => ({
+			name: toLocalShimWorkerName(entry.kind, entry.bindingName, index),
+			modules: true,
+			script: LOCAL_MEDIA_BINDING_SCRIPT,
+			compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+			...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags }
+		}))
+	};
+}
+//#endregion
+export { createLocalImagesBinding as n, createLocalMediaBinding as r, buildLocalBindingShimServiceConfig as t };

package/dist/_chunks/local-secrets-DMPkmOn3.js

@@ -0,0 +1,123 @@
+import { _ as normalizeSecretsStoreBinding } from "./schema-normalization-BCwTLTGp.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/secrets/local-secrets.ts
+const LOCAL_SECRETS_PATH = join(".devflare", "secrets.local.json");
+const LOCAL_SECRET_WRAPPED_BINDING_SCRIPT = `
+class LocalSecretsStoreSecret {
+	constructor(env) {
+		this.value = env.value
+	}
+
+	async get() {
+		return this.value
+	}
+}
+
+export default function makeBinding(env) {
+	return new LocalSecretsStoreSecret(env)
+}
+`;
+function createEmptyLocalSecretsFile() {
+	return {
+		version: 1,
+		stores: {}
+	};
+}
+function getLocalSecretsFilePath(cwd) {
+	return join(cwd, LOCAL_SECRETS_PATH);
+}
+function parseLocalSecretsFile(raw) {
+	const parsed = JSON.parse(raw);
+	if (parsed.version !== 1 || !parsed.stores || typeof parsed.stores !== "object") return createEmptyLocalSecretsFile();
+	return {
+		version: 1,
+		stores: parsed.stores
+	};
+}
+function readLocalSecretsFile(cwd) {
+	const filePath = getLocalSecretsFilePath(cwd);
+	if (!existsSync(filePath)) return createEmptyLocalSecretsFile();
+	return parseLocalSecretsFile(readFileSync(filePath, "utf8"));
+}
+function writeLocalSecretsFile(cwd, file) {
+	const filePath = getLocalSecretsFilePath(cwd);
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, `${JSON.stringify(file, null, "	")}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+}
+function writeLocalSecret({ cwd, storeId, name, value }) {
+	const file = readLocalSecretsFile(cwd);
+	file.stores[storeId] ??= {};
+	file.stores[storeId][name] = {
+		value,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writeLocalSecretsFile(cwd, file);
+}
+function readLocalSecret({ cwd, storeId, name }) {
+	return readLocalSecretsFile(cwd).stores[storeId]?.[name]?.value;
+}
+function deleteLocalSecret({ cwd, storeId, name }) {
+	const file = readLocalSecretsFile(cwd);
+	const store = file.stores[storeId];
+	if (!store || !(name in store)) return false;
+	delete store[name];
+	if (Object.keys(store).length === 0) delete file.stores[storeId];
+	writeLocalSecretsFile(cwd, file);
+	return true;
+}
+function listLocalSecrets({ cwd, storeId }) {
+	const file = readLocalSecretsFile(cwd);
+	const stores = storeId ? { [storeId]: file.stores[storeId] ?? {} } : file.stores;
+	return Object.entries(stores).flatMap(([currentStoreId, secrets]) => Object.entries(secrets).map(([name, secret]) => ({
+		storeId: currentStoreId,
+		name,
+		hasValue: typeof secret.value === "string",
+		updatedAt: secret.updatedAt
+	})));
+}
+function resolveLocalSecretValuesForBindings(config, cwd) {
+	const values = {};
+	for (const [bindingName, binding] of Object.entries(config.bindings?.secretsStore ?? {})) {
+		const normalized = normalizeSecretsStoreBinding(binding, config.secretsStoreId, bindingName);
+		const value = readLocalSecret({
+			cwd,
+			storeId: normalized.storeId,
+			name: normalized.secretName
+		});
+		if (value !== void 0) values[bindingName] = value;
+	}
+	return values;
+}
+function toLocalSecretWorkerName(bindingName, index) {
+	return `devflare-local-secret-${index}-${bindingName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "secret"}`;
+}
+function buildLocalSecretWrappedBindingConfig(config, cwd) {
+	const values = resolveLocalSecretValuesForBindings(config, cwd);
+	const entries = Object.entries(values);
+	return {
+		localBindingNames: entries.map(([bindingName]) => bindingName),
+		wrappedBindings: Object.fromEntries(entries.map(([bindingName, value], index) => {
+			return [bindingName, {
+				scriptName: toLocalSecretWorkerName(bindingName, index),
+				bindings: { value }
+			}];
+		})),
+		workers: entries.map(([bindingName], index) => ({
+			name: toLocalSecretWorkerName(bindingName, index),
+			modules: true,
+			script: LOCAL_SECRET_WRAPPED_BINDING_SCRIPT
+		}))
+	};
+}
+function buildLocalSecretNodeBindings(config, cwd) {
+	const values = resolveLocalSecretValuesForBindings(config, cwd);
+	return Object.fromEntries(Object.entries(values).map(([bindingName, value]) => [bindingName, { async get() {
+		return value;
+	} }]));
+}
+//#endregion
+export { resolveLocalSecretValuesForBindings as a, listLocalSecrets as i, buildLocalSecretWrappedBindingConfig as n, writeLocalSecret as o, deleteLocalSecret as r, buildLocalSecretNodeBindings as t };