effect-cf 0.23.1 → 0.24.0

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
+import { a as DurableObjectWebSocket_exports, c as causeMessage, d as WorkerConfig, f as WorkerEnvironment, i as fromExecutionContext, l as violationsMessage, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState, u as Environment_exports } from "./DurableObjectState-8sgBJB0s.mjs";
+import { Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
@@ -8,29 +9,6 @@ import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
 import * as RpcServer from "effect/unstable/rpc/RpcServer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
-//#region src/Environment.ts
-var Environment_exports = /* @__PURE__ */ __exportAll({
-	WorkerConfig: () => WorkerConfig,
-	WorkerEnvironment: () => WorkerEnvironment
-});
-/**
-* Context service for reading worker bindings from the current `env` object.
-*/
-var WorkerEnvironment = class extends Context.Service()("effect-cf/WorkerEnvironment") {};
-let WorkerConfig;
-(function(_WorkerConfig) {
-	_WorkerConfig.string = (name) => Config.string(name);
-	_WorkerConfig.redacted = (name) => Config.redacted(name);
-	_WorkerConfig.number = (name) => Config.number(name);
-	_WorkerConfig.integer = (name) => Config.int(name);
-	_WorkerConfig.boolean = (name) => Config.boolean(name);
-	const providerFromEnv = _WorkerConfig.providerFromEnv = (env, options) => ConfigProvider.fromUnknown(env, options);
-	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment, makeProvider);
-	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
-	_WorkerConfig.layer = _WorkerConfig.providerLayer = ConfigProvider.layer(provider);
-	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
-})(WorkerConfig || (WorkerConfig = {}));
-//#endregion
 //#region src/Binding.ts
 var Binding_exports = /* @__PURE__ */ __exportAll({
 	BindingNotFoundError: () => BindingNotFoundError,
@@ -149,25 +127,6 @@ const Service$2 = () => {
 	return makeService;
 };
 //#endregion
-//#region src/internal/ErrorMessage.ts
-/**
-* Renders the most useful human-readable description of an unknown `cause`
-* for use in tagged error `message` getters.
-*/
-const causeMessage = (cause) => {
-	if (typeof cause === "object" && cause !== null) {
-		const message = Reflect.get(cause, "message");
-		if (typeof message === "string" && message.length > 0) return message;
-	}
-	try {
-		return String(cause);
-	} catch {
-		return "unknown cause";
-	}
-};
-/** Renders a violation list as a single `path: message; ...` line. */
-const violationsMessage = (violations) => violations.map((violation) => `${violation.path}: ${violation.message}`).join("; ");
-//#endregion
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag$16,
@@ -734,345 +693,6 @@ const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$11(storage
 /** Provides Cache API services from Cloudflare's global `caches` object. */
 const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 //#endregion
-//#region src/DurableObjectStorage.ts
-var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
-	StorageOperationError: () => StorageOperationError,
-	fromDurableObjectStorage: () => fromDurableObjectStorage
-});
-/** Error type used when a storage operation throws or rejects. */
-var StorageOperationError = class extends Data.TaggedError("StorageOperationError") {
-	get message() {
-		return `Durable Object storage ${this.operation} failed: ${causeMessage(this.cause)}`;
-	}
-};
-const storageError = (operation, cause) => new StorageOperationError({
-	operation,
-	cause
-});
-const tryStorageSync = (operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => storageError(operation, cause)
-});
-const tryStoragePromise = (operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => storageError(operation, cause)
-});
-const fromSqlCursor = (cursor) => ({
-	next: () => tryStorageSync("sql.next", () => cursor.next()),
-	toArray: () => tryStorageSync("sql.toArray", () => cursor.toArray()),
-	one: () => tryStorageSync("sql.one", () => cursor.one()),
-	raw: () => tryStorageSync("sql.raw", () => cursor.raw()),
-	get columnNames() {
-		return cursor.columnNames;
-	},
-	rowsRead: tryStorageSync("sql.rowsRead", () => cursor.rowsRead),
-	rowsWritten: tryStorageSync("sql.rowsWritten", () => cursor.rowsWritten)
-});
-const fromSqlStorage = (sql) => ({
-	exec: (query, ...bindings) => tryStorageSync("sql.exec", () => fromSqlCursor(sql.exec(query, ...bindings))),
-	get databaseSize() {
-		return sql.databaseSize;
-	}
-});
-const schemaBackedSyncKvStorage = (kv, definition) => {
-	const encodeKey = Schema.encodeEffect(definition.key);
-	const decodeKey = Schema.decodeUnknownEffect(definition.key);
-	const encodeValue = Schema.encodeEffect(definition.value);
-	const decodeValue = Schema.decodeUnknownEffect(definition.value);
-	return {
-		get: (key) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			const encodedValue = yield* tryStorageSync("kv.get", () => kv.get(encodedKey));
-			if (encodedValue === void 0) return Option.none();
-			return yield* decodeValue(encodedValue).pipe(Effect.map(Option.some));
-		}),
-		put: (key, value) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			const encodedValue = yield* encodeValue(value);
-			yield* tryStorageSync("kv.put", () => kv.put(encodedKey, encodedValue));
-		}),
-		delete: (key) => Effect.gen(function* () {
-			const encodedKey = yield* encodeKey(key);
-			return yield* tryStorageSync("kv.delete", () => kv.delete(encodedKey));
-		}),
-		list: (options) => Effect.gen(function* () {
-			const entries = Array.from(yield* tryStorageSync("kv.list", () => kv.list(options)));
-			const decoded = [];
-			for (const [key, value] of entries) decoded.push([yield* decodeKey(key), yield* decodeValue(value)]);
-			return decoded;
-		})
-	};
-};
-const fromSyncKvStorage = (kv) => ({
-	get: (key) => tryStorageSync("kv.get", () => kv.get(key)),
-	put: (key, value) => tryStorageSync("kv.put", () => kv.put(key, value)),
-	delete: (key) => tryStorageSync("kv.delete", () => kv.delete(key)),
-	list: (options) => tryStorageSync("kv.list", () => Array.from(kv.list(options))),
-	schema: (definition) => schemaBackedSyncKvStorage(kv, definition)
-});
-const fromDurableObjectTransaction = (txn) => ({
-	get: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)) : tryStoragePromise("transaction.get", () => txn.get(keyOrKeys, options)),
-	list: (options) => tryStoragePromise("transaction.list", () => txn.list(options)),
-	put: (keyOrEntries, valueOrOptions, maybeOptions) => tryStoragePromise("transaction.put", () => typeof keyOrEntries === "string" ? txn.put(keyOrEntries, valueOrOptions, maybeOptions) : txn.put(keyOrEntries, valueOrOptions)),
-	delete: (keyOrKeys, options) => Array.isArray(keyOrKeys) ? tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)) : tryStoragePromise("transaction.delete", () => txn.delete(keyOrKeys, options)),
-	rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
-	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),
-	setAlarm: (scheduledTime, options) => tryStoragePromise("transaction.setAlarm", () => txn.setAlarm(scheduledTime, options)),
-	deleteAlarm: (options) => tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options))
-});
-/**
-* Wraps native Cloudflare storage APIs as Effect-returning helpers.
-*/
-const fromDurableObjectStorage = (storage) => ({
-	get: (key, options) => tryStoragePromise("get", () => storage.get(key, options)),
-	put: (key, value, options) => tryStoragePromise("put", () => storage.put(key, value, options)),
-	delete: (key, options) => tryStoragePromise("delete", () => storage.delete(key, options)),
-	deleteAll: (options) => tryStoragePromise("deleteAll", () => storage.deleteAll(options)),
-	getAlarm: (options) => tryStoragePromise("getAlarm", () => storage.getAlarm(options)),
-	setAlarm: (scheduledTime, options) => tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
-	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
-	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
-		try {
-			return Effect.succeed(storage.transactionSync(() => {
-				const exit = Effect.runSyncExitWith(context)(closure());
-				if (Exit.isSuccess(exit)) return exit.value;
-				throw exit;
-			}));
-		} catch (cause) {
-			if (Exit.isExit(cause) && Exit.isFailure(cause)) return Effect.failCause(cause.cause);
-			return Effect.fail(storageError("transactionSync", cause));
-		}
-	}))),
-	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
-		storage.transaction(async (txn) => {
-			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
-			if (Exit.isSuccess(exit)) return exit.value;
-			throw exit;
-		}).then((value) => resume(Effect.succeed(value)), (cause) => {
-			if (Exit.isExit(cause) && Exit.isFailure(cause)) resume(Effect.failCause(cause.cause));
-			else resume(Effect.fail(storageError("transaction", cause)));
-		});
-	}))),
-	sync: () => tryStoragePromise("sync", () => storage.sync()),
-	getCurrentBookmark: () => tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),
-	onNextSessionRestoreBookmark: (bookmark) => tryStoragePromise("onNextSessionRestoreBookmark", () => storage.onNextSessionRestoreBookmark(bookmark)),
-	sql: fromSqlStorage(storage.sql),
-	kv: fromSyncKvStorage(storage.kv)
-});
-//#endregion
-//#region src/DurableObjectWebSocket.ts
-var DurableObjectWebSocket_exports = /* @__PURE__ */ __exportAll({
-	DurableWebSocketAttachmentError: () => DurableWebSocketAttachmentError,
-	DurableWebSocketCloseError: () => DurableWebSocketCloseError,
-	DurableWebSocketSendError: () => DurableWebSocketSendError,
-	acceptUpgrade: () => acceptUpgrade,
-	attachment: () => attachment,
-	fromWebSocket: () => fromWebSocket,
-	handlers: () => handlers
-});
-/** Error raised when sending on a Durable Object websocket fails. */
-var DurableWebSocketSendError = class extends Data.TaggedError("DurableWebSocketSendError") {
-	get message() {
-		return `Durable Object websocket send failed: ${causeMessage(this.cause)}`;
-	}
-};
-/** Error raised when closing a Durable Object websocket fails. */
-var DurableWebSocketCloseError = class extends Data.TaggedError("DurableWebSocketCloseError") {
-	get message() {
-		return `Durable Object websocket close failed: ${causeMessage(this.cause)}`;
-	}
-};
-/** Error raised when serializing or deserializing a websocket attachment fails. */
-var DurableWebSocketAttachmentError = class extends Data.TaggedError("DurableWebSocketAttachmentError") {
-	get message() {
-		return `Durable Object websocket attachment ${this.operation} failed: ${causeMessage(this.cause)}`;
-	}
-};
-const wrappers = /* @__PURE__ */ new WeakMap();
-/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
-const fromWebSocket = (raw) => {
-	const existing = wrappers.get(raw);
-	if (existing !== void 0) return existing;
-	const socket = {
-		raw,
-		send: (data) => Effect.try({
-			try: () => raw.send(data),
-			catch: (cause) => new DurableWebSocketSendError({ cause })
-		}),
-		close: (code, reason) => Effect.try({
-			try: () => raw.close(code, reason),
-			catch: (cause) => new DurableWebSocketCloseError({ cause })
-		}),
-		serializeAttachment: (value) => Effect.try({
-			try: () => raw.serializeAttachment(value),
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "serialize",
-				cause
-			})
-		}),
-		deserializeAttachment: Effect.try({
-			try: () => raw.deserializeAttachment(),
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "deserialize",
-				cause
-			})
-		})
-	};
-	wrappers.set(raw, socket);
-	return socket;
-};
-/**
-* Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
-*
-* @example
-* ```ts
-* const response = yield* DurableObjectWebSocket.acceptUpgrade({
-*   tags: ["room:general"],
-* });
-*
-* return response.response;
-* ```
-*/
-const acceptUpgrade = Effect.fn("DurableObjectWebSocket.acceptUpgrade")(function* (options = {}) {
-	const state = yield* DurableObjectState;
-	const pair = new WebSocketPair();
-	const client = pair[0];
-	const server = fromWebSocket(pair[1]);
-	if (options.attachment !== void 0) yield* server.serializeAttachment(options.attachment);
-	yield* state.acceptWebSocket(server, options.tags === void 0 ? void 0 : [...options.tags]);
-	return {
-		client,
-		server,
-		response: new Response(null, {
-			status: 101,
-			webSocket: client
-		})
-	};
-});
-/** Creates typed attachment helpers for accepted and rehydrated sockets. */
-const attachment = (schema) => {
-	const serialize = (socket, value) => Schema.encodeEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
-		operation: "serialize",
-		cause
-	})), Effect.flatMap((encoded) => socket.serializeAttachment(encoded)));
-	const deserialize = (socket) => Effect.gen(function* () {
-		const value = yield* socket.deserializeAttachment;
-		if (value === null || value === void 0) return Option.none();
-		return Option.some(yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new DurableWebSocketAttachmentError({
-			operation: "deserialize",
-			cause
-		}))));
-	});
-	const rehydrate = (options = {}) => Effect.gen(function* () {
-		const sockets = yield* (yield* DurableObjectState).getWebSockets(options.tag);
-		const restored = [];
-		const onInvalid = options.onInvalid ?? "ignore";
-		for (const socket of sockets) {
-			const decoded = yield* Effect.result(deserialize(socket));
-			if (Result.isSuccess(decoded) && Option.isSome(decoded.success)) {
-				restored.push({
-					socket,
-					attachment: decoded.success.value
-				});
-				continue;
-			}
-			if (Result.isFailure(decoded) && onInvalid === "fail") return yield* Effect.fail(decoded.failure);
-			if (Result.isFailure(decoded) && onInvalid === "ignore-and-close") yield* socket.close(1008, "invalid websocket attachment").pipe(Effect.ignore);
-		}
-		return restored;
-	});
-	return {
-		serialize,
-		deserialize,
-		rehydrate,
-		schema
-	};
-};
-/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
-const handlers = (options) => ({
-	webSocketMessage: options.message,
-	webSocketClose: options.close,
-	webSocketError: options.error
-});
-//#endregion
-//#region src/internal/WorkerContext.ts
-const causeError = (cause) => {
-	const squashed = Cause.squash(cause);
-	return squashed instanceof Error ? squashed : new Error(Cause.pretty(cause), { cause: squashed });
-};
-const failureHandler = (label, cause, options) => (options?.onFailure?.(cause) ?? Effect.logError(`${label} failed`, Cause.pretty(cause))).pipe(Effect.catchCause((handlerCause) => Effect.logError(`${label} failure handler failed`, Cause.pretty(cause), Cause.pretty(handlerCause))));
-/**
-* Builds a `waitUntil` scheduler for any Cloudflare lifecycle that accepts
-* background promises (`ExecutionContext`, `DurableObjectState`).
-*
-* Background effects capture the calling fiber's context via `Effect.context`
-* before being registered, so the default module-level `Effect.runPromiseExit`
-* runner is sufficient; entrypoints may still pass a runtime-bound runner.
-*/
-const makeWaitUntilScheduler = (label, register, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
-	return (effect, options, mode) => Effect.context().pipe(Effect.flatMap((context) => Effect.sync(() => {
-		const runHandler = (cause) => runPromiseExit(Effect.scoped(Effect.provideContext(failureHandler(label, cause, options), context))).then((exit) => {
-			if (Exit.isFailure(exit)) console.error(`${label} failure handler failed`, Cause.pretty(exit.cause));
-		});
-		register(runPromiseExit(Effect.scoped(Effect.provideContext(effect, context))).then(async (exit) => {
-			if (Exit.isSuccess(exit)) return;
-			await runHandler(exit.cause);
-			if (mode === "propagate") throw causeError(exit.cause);
-		}));
-	})));
-};
-/**
-* Builds the `WorkerContext` service from a native `ExecutionContext`.
-*/
-const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromiseExit(effect)) => {
-	const schedule = makeWaitUntilScheduler("WorkerContext.waitUntil", (promise) => ctx.waitUntil(promise), runPromiseExit);
-	return {
-		raw: ctx,
-		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
-		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
-		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
-	};
-};
-//#endregion
-//#region src/DurableObjectState.ts
-var DurableObjectState_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectState: () => DurableObjectState,
-	fromDurableObjectState: () => fromDurableObjectState
-});
-/**
-* Context tag for accessing the current Durable Object state service.
-*/
-var DurableObjectState = class extends Context.Service()("effect-cf/DurableObjectState") {};
-/**
-* Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
-*/
-const fromDurableObjectState = (state) => {
-	const scheduleWaitUntil = makeWaitUntilScheduler("DurableObjectState.waitUntil", (promise) => state.waitUntil(promise));
-	const waitUntil = ((input, options) => Effect.isEffect(input) ? scheduleWaitUntil(input, options, options?.mode ?? "observe") : Effect.sync(() => state.waitUntil(input)));
-	return {
-		raw: state,
-		id: state.id,
-		storage: fromDurableObjectStorage(state.storage),
-		waitUntil,
-		blockConcurrencyWhile: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(context, effect)))), Effect.flatten),
-		blockConcurrencyWhileOrReset: (effect) => Effect.context().pipe(Effect.flatMap((context) => Effect.promise(() => state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect))))),
-		acceptWebSocket: (ws, tags) => Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
-		getWebSockets: (tag) => Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
-		setWebSocketAutoResponse: (pair) => Effect.sync(() => state.setWebSocketAutoResponse(pair)),
-		getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
-		getWebSocketAutoResponseTimestamp: (ws) => Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
-		setHibernatableWebSocketEventTimeout: (timeoutMs) => Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
-		getHibernatableWebSocketEventTimeout: Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
-		getTags: (ws) => Effect.sync(() => state.getTags(ws.raw)),
-		abort: (reason) => Effect.sync(() => state.abort(reason))
-	};
-};
-const runPromiseExitPreservingTypedFailures = async (context, effect) => {
-	const exit = await Effect.runPromiseExitWith(context)(effect);
-	if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) throw Cause.squash(exit.cause);
-	return exit;
-};
-//#endregion
 //#region src/CloudflareOtlp.ts
 /**
 * OTLP telemetry layers for Cloudflare Workers and Durable Objects.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,11 @@
       "import": "./dist/HyperdrivePg.mjs",
       "default": "./dist/HyperdrivePg.mjs"
     },
+    "./vitest": {
+      "types": "./dist/Vitest.d.mts",
+      "import": "./dist/Vitest.mjs",
+      "default": "./dist/Vitest.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -53,6 +58,7 @@
     "vitest": "catalog:"
   },
   "peerDependencies": {
+    "@cloudflare/vitest-pool-workers": "^0.21.3",
     "@cloudflare/workers-types": "^4.20260611.1",
     "@effect/sql-d1": "4.0.0-beta.105",
     "@effect/sql-pg": "4.0.0-beta.105",
@@ -60,6 +66,9 @@
     "effect": "4.0.0-beta.105"
   },
   "peerDependenciesMeta": {
+    "@cloudflare/vitest-pool-workers": {
+      "optional": true
+    },
     "@cloudflare/workers-types": {
       "optional": true
     },