effect-cf 0.4.0 → 0.6.0

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
 import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Schema } from "effect";
+import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
@@ -28,11 +29,11 @@ let WorkerConfig;
 var Binding_exports = /* @__PURE__ */ __exportAll({
 	BindingNotFoundError: () => BindingNotFoundError,
 	BindingValidationError: () => BindingValidationError,
-	Service: () => Service$5,
-	TypeId: () => TypeId$5
+	Service: () => Service$6,
+	TypeId: () => TypeId$6
 });
 /** Internal type id marker used by binding helper services. */
-const TypeId$5 = "effect-cf/Binding";
+const TypeId$6 = "effect-cf/Binding";
 /** Error raised when a configured binding does not exist on `env`. */
 var BindingNotFoundError = class extends Data.TaggedError("BindingNotFoundError") {};
 /** Error raised when a binding exists but does not match the expected shape. */
@@ -45,21 +46,101 @@ const getBinding = (env, binding, isResource) => Effect.gen(function* () {
 	if (!isResource(resource)) return yield* Effect.fail(new BindingValidationError({ binding }));
 	return resource;
 });
-/**
-* Creates a Context tag + layer for reading and validating a Cloudflare binding.
-*/
-const Service$5 = () => (id, binding, isResource) => {
+const Service$6 = () => (id, binding, isResource, wrap) => {
 	const tag = Context.Service()(id);
 	const layer = Layer.effect(tag, Effect.gen(function* () {
-		return yield* getBinding(yield* WorkerEnvironment, binding, isResource);
+		const resource = yield* getBinding(yield* WorkerEnvironment, binding, isResource);
+		return wrap === void 0 ? resource : wrap(resource);
 	}));
 	return Object.assign(tag, {
-		[TypeId$5]: TypeId$5,
+		[TypeId$6]: TypeId$6,
 		binding,
 		layer
 	});
 };
 //#endregion
+//#region src/D1.ts
+var D1_exports = /* @__PURE__ */ __exportAll({
+	D1OperationError: () => D1OperationError,
+	Service: () => Service$5,
+	make: () => make$11
+});
+const TypeId$5 = "effect-cf/D1";
+/** Error raised when a D1 operation fails. */
+var D1OperationError = class extends Data.TaggedError("D1OperationError") {};
+const isD1Database = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const resource = value;
+	return typeof resource.prepare === "function" && typeof resource.batch === "function" && typeof resource.exec === "function";
+};
+const d1Error = (binding, operation, cause) => new D1OperationError({
+	binding,
+	operation,
+	cause
+});
+const tryD1Promise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => d1Error(binding, operation, cause)
+});
+const tryD1Sync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => d1Error(binding, operation, cause)
+});
+/**
+* Creates a typed D1 service tag plus Effect helpers.
+*/
+const make$11 = (id, definition) => Service$5()(id, definition);
+/**
+* Builds a D1 service around a Cloudflare D1 database binding.
+*
+* The returned service exposes the raw `D1Database` binding, small native D1
+* helpers, and `sqlLayer(...)` for providing `effect/unstable/sql` via
+* `@effect/sql-d1`.
+*
+* @example
+* ```ts
+* class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
+*   binding: "TODO_DB",
+* }) {}
+*
+* const SqlLive = TodoDatabase.sqlLayer();
+* ```
+*/
+const Service$5 = () => (id, definition) => {
+	const tag = Service$6()(id, definition.binding, isD1Database);
+	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
+		const db = yield* tag;
+		return D1Client.layer({
+			...options,
+			db
+		});
+	})).pipe(Layer.provide(tag.layer));
+	const prepare = Effect.fnUntraced(function* (query) {
+		const db = yield* tag;
+		return yield* tryD1Sync(definition.binding, "prepare", () => db.prepare(query));
+	});
+	const batch = Effect.fnUntraced(function* (statements) {
+		const db = yield* tag;
+		return yield* tryD1Promise(definition.binding, "batch", () => db.batch([...statements]));
+	});
+	const exec = Effect.fnUntraced(function* (query) {
+		const db = yield* tag;
+		return yield* tryD1Promise(definition.binding, "exec", () => db.exec(query));
+	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* tag;
+	});
+	return Object.assign(tag, {
+		[TypeId$5]: TypeId$5,
+		definition,
+		sqlLayer,
+		prepare,
+		batch,
+		exec,
+		unsafeRaw
+	});
+};
+//#endregion
 //#region src/QueueBinding.ts
 var QueueBinding_exports = /* @__PURE__ */ __exportAll({
 	QueueOperationError: () => QueueOperationError,
@@ -88,32 +169,43 @@ const make$10 = (id, definition) => Service$4()(id, definition);
 * Builds an Effect service around a Cloudflare Queue producer binding.
 */
 const Service$4 = () => (id, definition) => {
-	const tag = Service$5()(id, definition.binding, (value) => isQueue(value));
 	const encodeMessage = Schema.encodeEffect(definition.message);
+	const makeClient = (queue) => ({
+		send: Effect.fnUntraced(function* (message, options) {
+			const encoded = yield* encodeMessage(message);
+			yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
+		}),
+		sendBatch: Effect.fnUntraced(function* (messages, options) {
+			const encodedMessages = [];
+			for (const message of messages) encodedMessages.push({
+				...message,
+				body: yield* encodeMessage(message.body)
+			});
+			yield* tryQueuePromise(definition.binding, "sendBatch", () => queue.sendBatch(encodedMessages, options));
+		}),
+		metrics: () => tryQueuePromise(definition.binding, "metrics", () => queue.metrics()),
+		unsafeRaw: Effect.succeed(queue)
+	});
+	const tag = Service$6()(id, definition.binding, (value) => isQueue(value), makeClient);
 	const send = Effect.fnUntraced(function* (message, options) {
-		const queue = yield* tag;
-		const encoded = yield* encodeMessage(message);
-		return yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
+		yield* (yield* tag).send(message, options);
 	});
 	const sendBatch = Effect.fnUntraced(function* (messages, options) {
-		const queue = yield* tag;
-		const encodedMessages = [];
-		for (const message of messages) encodedMessages.push({
-			...message,
-			body: yield* encodeMessage(message.body)
-		});
-		return yield* tryQueuePromise(definition.binding, "sendBatch", () => queue.sendBatch(encodedMessages, options));
+		yield* (yield* tag).sendBatch(messages, options);
 	});
 	const metrics = Effect.fnUntraced(function* () {
-		const queue = yield* tag;
-		return yield* tryQueuePromise(definition.binding, "metrics", () => queue.metrics());
+		return yield* (yield* tag).metrics();
+	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).unsafeRaw;
 	});
 	return Object.assign(tag, {
 		[TypeId$4]: TypeId$4,
 		binding: definition.binding,
 		send,
 		sendBatch,
-		metrics
+		metrics,
+		unsafeRaw
 	});
 };
 //#endregion
@@ -421,46 +513,63 @@ var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcEr
 * ```
 */
 const Service$3 = () => (id, definition) => {
-	const tag = Service$5()(id, definition.binding, (value) => typeof value === "object" && value !== null && "fetch" in value);
-	const fetch = (input, init) => Effect.gen(function* () {
-		const service = yield* tag;
-		return yield* Effect.tryPromise({
+	const makeClient = (service) => {
+		const fetch = (input, init) => Effect.tryPromise({
 			try: () => service.fetch(input, init),
 			catch: (cause) => new ServiceBindingFetchError({
 				binding: definition.binding,
 				cause
 			})
 		});
+		const rpc = (method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			return yield* invokeRpcMethod(service, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}))), (cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}));
+		});
+		const call = (method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			const value = yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+			if (definition.definition === void 0) return value;
+			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+		});
+		const scopedCall = (method, ...args) => Effect.gen(function* () {
+			return yield* scoped(yield* rpc(method, ...args));
+		});
+		const directMethods = makeDirectMethods$1(definition.definition, call);
+		return Object.assign(directMethods, {
+			fetch,
+			rpc,
+			call,
+			scopedCall
+		});
+	};
+	const tag = Service$6()(id, definition.binding, (value) => typeof value === "object" && value !== null && "fetch" in value, makeClient);
+	const fetch = (input, init) => Effect.gen(function* () {
+		return yield* (yield* tag).fetch(input, init);
 	});
 	const rpc = (method, ...args) => Effect.gen(function* () {
-		const service = yield* tag;
-		const methodName = String(method);
-		return yield* invokeRpcMethod(service, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		}))), (cause) => new ServiceBindingRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		}));
+		return yield* (yield* tag).rpc(method, ...args);
 	});
 	const call = (method, ...args) => Effect.gen(function* () {
-		const methodName = String(method);
-		const value = yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		})));
-		if (definition.definition === void 0) return value;
-		return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-			binding: definition.binding,
-			method: methodName,
-			cause
-		})));
+		return yield* (yield* tag).call(method, ...args);
 	});
 	const scopedCall = (method, ...args) => Effect.gen(function* () {
-		return yield* scoped(yield* rpc(method, ...args));
+		return yield* (yield* tag).scopedCall(method, ...args);
 	});
 	const directMethods = makeDirectMethods$1(definition.definition, call);
 	return Object.assign(tag, directMethods, {
@@ -1006,24 +1115,87 @@ var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetch
 const Service$2 = () => (id, definition) => {
 	const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
 	const isDurableObjectNamespaceClient = (value) => typeof value === "object" && value !== null && hasFunction(value, "getByName") && hasFunction(value, "get") && hasFunction(value, "idFromName") && hasFunction(value, "idFromString") && hasFunction(value, "newUniqueId") && hasFunction(value, "jurisdiction");
-	const tag = Service$5()(id, definition.binding, (value) => isDurableObjectNamespaceClient(value));
+	const makeClient = (namespace) => {
+		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
+		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
+		const idFromString = (id) => Effect.sync(() => namespace.idFromString(id));
+		const get = (id, options) => Effect.sync(() => namespace.get(id, options));
+		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
+		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
+		const fetch = (stub, input, init) => Effect.tryPromise({
+			try: () => stub.fetch(input, init),
+			catch: (cause) => new DurableObjectFetchError({
+				binding: definition.binding,
+				cause
+			})
+		});
+		const rpc = (stub, method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			return yield* invokeRpcMethod(stub, method, definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}))), (cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			}));
+		});
+		const call = (stub, method, ...args) => Effect.gen(function* () {
+			const methodName = String(method);
+			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+			if (definition.definition === void 0) return value;
+			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
+		});
+		const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
+			return yield* scoped(yield* rpc(stub, method, ...args));
+		});
+		const directMethods = makeDirectMethods(definition.definition, {
+			call,
+			fetch,
+			get,
+			getByName
+		});
+		return Object.assign(directMethods, {
+			newUniqueId,
+			idFromName,
+			idFromString,
+			get,
+			getByName,
+			jurisdiction,
+			fetch,
+			rpc,
+			call,
+			scopedCall,
+			unsafeRaw: Effect.succeed(namespace)
+		});
+	};
+	const tag = Service$6()(id, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient);
 	const newUniqueId = Effect.fnUntraced(function* (options) {
-		return (yield* tag).newUniqueId(options);
+		return yield* (yield* tag).newUniqueId(options);
 	});
 	const idFromName = Effect.fnUntraced(function* (name) {
-		return (yield* tag).idFromName(name);
+		return yield* (yield* tag).idFromName(name);
 	});
 	const idFromString = Effect.fnUntraced(function* (id) {
-		return (yield* tag).idFromString(id);
+		return yield* (yield* tag).idFromString(id);
 	});
 	const get = Effect.fnUntraced(function* (id, options) {
-		return (yield* tag).get(id, options);
+		return yield* (yield* tag).get(id, options);
 	});
 	const getByName = Effect.fnUntraced(function* (name, options) {
-		return (yield* tag).getByName(name, options);
+		return yield* (yield* tag).getByName(name, options);
 	});
 	const jurisdiction = Effect.fnUntraced(function* (value) {
-		return (yield* tag).jurisdiction(value);
+		return yield* (yield* tag).jurisdiction(value);
 	});
 	const fetch = (stub, input, init) => Effect.tryPromise({
 		try: () => stub.fetch(input, init),
@@ -1061,6 +1233,9 @@ const Service$2 = () => (id, definition) => {
 	const scopedCall = (stub, method, ...args) => Effect.gen(function* () {
 		return yield* scoped(yield* rpc(stub, method, ...args));
 	});
+	const unsafeRaw = Effect.fnUntraced(function* () {
+		return yield* (yield* tag).unsafeRaw;
+	});
 	const directMethods = makeDirectMethods(definition.definition, {
 		call,
 		fetch,
@@ -1079,7 +1254,8 @@ const Service$2 = () => (id, definition) => {
 		fetch,
 		rpc,
 		call,
-		scopedCall
+		scopedCall,
+		unsafeRaw
 	});
 };
 const makeDirectMethods = (rpcDefinition, helpers) => {
@@ -1770,69 +1946,83 @@ const Tag$2 = () => (id, definition) => {
 * ```
 */
 const Service$1 = () => (id, definition) => {
-	const tag = Service$5()(id, definition.binding, (value) => {
-		if (typeof value !== "object" || value === null) return false;
-		const resource = value;
-		return typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.delete === "function" && typeof resource.getWithMetadata === "function" && typeof resource.list === "function";
-	});
 	const encodeKey = Schema.encodeEffect(definition.key);
 	const decodeKey = Schema.decodeUnknownEffect(definition.key);
 	const encodeValue = Schema.encodeEffect(Schema.fromJsonString(Schema.toCodecJson(definition.value)));
 	const decodeValue = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.toCodecJson(definition.value)));
+	const makeClient = (kv) => ({
+		definition,
+		put: Effect.fnUntraced(function* (key, value, options) {
+			const keyEncoded = yield* encodeKey(key);
+			const valueEncoded = yield* encodeValue(value);
+			yield* tryKvPromise(definition.binding, "put", () => kv.put(keyEncoded, valueEncoded, options));
+		}),
+		get: Effect.fnUntraced(function* (key) {
+			const keyEncoded = yield* encodeKey(key);
+			const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
+			if (valueEncoded === null) return Option.none();
+			return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+		}),
+		getWithMetadata: Effect.fnUntraced(function* (key, metadataSchema) {
+			const keyEncoded = yield* encodeKey(key);
+			const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () => kv.getWithMetadata(keyEncoded));
+			if (result.value === null) return Option.none();
+			const value = yield* decodeValue(result.value);
+			const metadata = result.metadata === null ? Option.none() : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(result.metadata));
+			return Option.some({
+				value,
+				metadata,
+				cacheStatus: maybeString(result.cacheStatus)
+			});
+		}),
+		list: Effect.fnUntraced(function* (options) {
+			const { metadataSchema, ...kvOptions } = options ?? {};
+			const result = yield* tryKvPromise(definition.binding, "list", () => kv.list(kvOptions));
+			const keys = [];
+			for (const key of result.keys) {
+				const decodedName = yield* decodeKey(key.name);
+				const decodedMetadata = key.metadata === void 0 ? Option.none() : metadataSchema === void 0 ? Option.some(key.metadata) : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(key.metadata));
+				keys.push({
+					name: decodedName,
+					expiration: maybeNumber(key.expiration),
+					metadata: decodedMetadata
+				});
+			}
+			return {
+				keys,
+				listComplete: result.list_complete,
+				cursor: maybeString("cursor" in result ? result.cursor : void 0),
+				cacheStatus: maybeString(result.cacheStatus)
+			};
+		}),
+		remove: Effect.fnUntraced(function* (key) {
+			const keyEncoded = yield* encodeKey(key);
+			yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+		}),
+		unsafeRaw: Effect.succeed(kv)
+	});
+	const tag = Service$6()(id, definition.binding, (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		const resource = value;
+		return typeof resource.get === "function" && typeof resource.put === "function" && typeof resource.delete === "function" && typeof resource.getWithMetadata === "function" && typeof resource.list === "function";
+	}, makeClient);
 	const put = Effect.fnUntraced(function* (key, value, options) {
-		const kv = yield* tag;
-		const keyEncoded = yield* encodeKey(key);
-		const valueEncoded = yield* encodeValue(value);
-		yield* tryKvPromise(definition.binding, "put", () => kv.put(keyEncoded, valueEncoded, options));
+		yield* (yield* tag).put(key, value, options);
 	});
 	const get = Effect.fnUntraced(function* (key) {
-		const kv = yield* tag;
-		const keyEncoded = yield* encodeKey(key);
-		const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
-		if (valueEncoded === null) return Option.none();
-		return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+		return yield* (yield* tag).get(key);
 	});
 	const getWithMetadata = Effect.fnUntraced(function* (key, metadataSchema) {
-		const kv = yield* tag;
-		const keyEncoded = yield* encodeKey(key);
-		const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () => kv.getWithMetadata(keyEncoded));
-		if (result.value === null) return Option.none();
-		const value = yield* decodeValue(result.value);
-		const metadata = result.metadata === null ? Option.none() : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(result.metadata));
-		return Option.some({
-			value,
-			metadata,
-			cacheStatus: maybeString(result.cacheStatus)
-		});
+		return yield* (yield* tag).getWithMetadata(key, metadataSchema);
 	});
 	const list = Effect.fnUntraced(function* (options) {
-		const kv = yield* tag;
-		const { metadataSchema, ...kvOptions } = options ?? {};
-		const result = yield* tryKvPromise(definition.binding, "list", () => kv.list(kvOptions));
-		const keys = [];
-		for (const key of result.keys) {
-			const decodedName = yield* decodeKey(key.name);
-			const decodedMetadata = key.metadata === void 0 ? Option.none() : metadataSchema === void 0 ? Option.some(key.metadata) : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(key.metadata));
-			keys.push({
-				name: decodedName,
-				expiration: maybeNumber(key.expiration),
-				metadata: decodedMetadata
-			});
-		}
-		return {
-			keys,
-			listComplete: result.list_complete,
-			cursor: maybeString("cursor" in result ? result.cursor : void 0),
-			cacheStatus: maybeString(result.cacheStatus)
-		};
+		return yield* (yield* tag).list(options);
 	});
 	const remove = Effect.fnUntraced(function* (key) {
-		const kv = yield* tag;
-		const keyEncoded = yield* encodeKey(key);
-		yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+		yield* (yield* tag).remove(key);
 	});
 	const unsafeRaw = Effect.fnUntraced(function* () {
-		return yield* tag;
+		return yield* (yield* tag).unsafeRaw;
 	});
 	return Object.assign(tag, {
 		[TypeId$1]: TypeId$1,
@@ -1872,7 +2062,7 @@ const isWorkflow = (value) => {
 };
 const make$2 = (id, definition) => Service()(id, definition);
 const Service = () => (id, definition) => {
-	const tag = Service$5()(id, definition.binding, (value) => isWorkflow(value));
+	const tag = Service$6()(id, definition.binding, (value) => isWorkflow(value));
 	const encodePayload = Schema.encodeEffect(definition.payload);
 	const decodeResult = Schema.decodeUnknownEffect(definition.result);
 	const wrapInstance = (raw) => {
@@ -2056,4 +2246,4 @@ const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1.asEffect()
 const Tag = Tag$1;
 const implement = implement$1;
 //#endregion
-export { Binding_exports as Binding, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+export { Binding_exports as Binding, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -36,6 +36,7 @@
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "^0.15.0",
     "@cloudflare/workers-types": "^4.20260421.1",
+    "@effect/sql-d1": "catalog:",
     "@effect/vitest": "catalog:",
     "effect": "catalog:",
     "typescript": "^6.0.2",
@@ -43,6 +44,7 @@
     "vitest": "catalog:"
   },
   "peerDependencies": {
+    "@effect/sql-d1": "^4.0.0-beta.65",
     "effect": "^4.0.0-beta.65"
   }
 }

package/src/Binding.ts

@@ -45,20 +45,36 @@ const getBinding = <Resource>(
 /**
  * Creates a Context tag + layer for reading and validating a Cloudflare binding.
  */
+export interface BindingService<Self, Id extends string, Service> extends Context.ServiceClass<
+  Self,
+  Id,
+  Service
+> {
+  readonly [TypeId]: typeof TypeId;
+  readonly binding: string;
+  readonly layer: Layer.Layer<
+    Self,
+    BindingNotFoundError | BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
 export const Service =
   <Self>() =>
-  <Id extends string, Resource>(
+  <Id extends string, Resource, Service = Resource>(
     id: Id,
     binding: string,
     isResource: (value: unknown) => value is Resource,
-  ) => {
-    const tag = Context.Service<Self, Resource>()(id);
+    wrap?: (resource: Resource) => Service,
+  ): BindingService<Self, Id, Service> => {
+    const tag = Context.Service<Self, Service>()(id);
 
     const layer = Layer.effect(
       tag,
       Effect.gen(function* () {
         const env = yield* WorkerEnvironment;
-        return yield* getBinding(env, binding, isResource);
+        const resource = yield* getBinding(env, binding, isResource);
+        return wrap === undefined ? (resource as unknown as Service) : wrap(resource);
       }),
     );
 
@@ -66,5 +82,5 @@ export const Service =
       [TypeId]: TypeId,
       binding,
       layer,
-    });
+    }) as BindingService<Self, Id, Service>;
   };