effect-cf 0.5.0 → 0.6.0

package/dist/index.mjs

@@ -46,13 +46,11 @@ 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$6 = () => (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$6]: TypeId$6,
@@ -171,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$6()(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
@@ -504,46 +513,63 @@ var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcEr
 * ```
 */
 const Service$3 = () => (id, definition) => {
-	const tag = Service$6()(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, {
@@ -1089,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$6()(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),
@@ -1144,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,
@@ -1162,7 +1254,8 @@ const Service$2 = () => (id, definition) => {
 		fetch,
 		rpc,
 		call,
-		scopedCall
+		scopedCall,
+		unsafeRaw
 	});
 };
 const makeDirectMethods = (rpcDefinition, helpers) => {
@@ -1853,69 +1946,83 @@ const Tag$2 = () => (id, definition) => {
 * ```
 */
 const Service$1 = () => (id, definition) => {
-	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";
-	});
 	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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

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>;
   };