effect-cf 0.18.0 → 0.20.1

package/src/WorkerDefinition.ts

@@ -1,7 +1,6 @@
-import { Context, Effect, type Layer } from "effect";
-import type { Schema as S } from "effect";
+import { Context, Effect, type Layer, type Schema as S } from "effect";
 
-import * as Binding from "./Binding";
+import type * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as WorkerEntrypoint from "./Worker";
 import type { WorkerRpcHandler } from "./Worker";
@@ -9,6 +8,13 @@ import type * as Rpc from "./Rpc";
 import * as RpcDefinition from "./RpcDefinition";
 import * as ServiceBinding from "./ServiceBinding";
 
+/**
+ * The client tuple types are re-established by the final `TagClass` cast, so
+ * these internal invocations erase the binding client's generic argument
+ * tuples instead of instantiating them at `never`.
+ */
+type UnsafeInvoke<E> = (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, E>;
+
 export type ServiceFreeSchema = S.Codec<any, any, never, never>;
 
 export interface Method<
@@ -238,6 +244,7 @@ export const Tag =
     methods: MethodsShape & NoReservedMethods<MethodsShape>,
   ) => {
     const definition = makeDefinition<Id, MethodsShape>(id, methods);
+
     type SelfDefinition = Definition<Id, MethodsShape>;
     type ClientApi = Api<SelfDefinition>;
     const tag = Context.Service<
@@ -256,6 +263,7 @@ export const Tag =
     const fetch = (input: RequestInfo | URL, init?: RequestInit) =>
       Effect.gen(function* () {
         const service = yield* tag;
+
         return yield* service.fetch(input, init);
       });
 
@@ -265,7 +273,11 @@ export const Tag =
     ) =>
       Effect.gen(function* () {
         const service = yield* tag;
-        return yield* service.rpc(method as never, ...(args as never));
+
+        return yield* (service.rpc as UnsafeInvoke<ServiceBinding.ServiceBindingRpcError>)(
+          method,
+          ...args,
+        );
       });
 
     const call = <Method extends keyof ClientApi>(
@@ -274,7 +286,11 @@ export const Tag =
     ) =>
       Effect.gen(function* () {
         const service = yield* tag;
-        return yield* service.call(method as never, ...(args as never));
+
+        return yield* (service.call as UnsafeInvoke<ServiceBinding.ServiceBindingRpcError>)(
+          method,
+          ...args,
+        );
       });
 
     const scopedCall = <Method extends keyof ClientApi>(
@@ -283,7 +299,11 @@ export const Tag =
     ) =>
       Effect.gen(function* () {
         const service = yield* tag;
-        return yield* service.scopedCall(method as never, ...(args as never));
+
+        return yield* (service.scopedCall as UnsafeInvoke<ServiceBinding.ServiceBindingRpcError>)(
+          method,
+          ...args,
+        );
       });
 
     const directMethods = ServiceBinding.makeDirectMethods<Self, ClientApi, SelfDefinition>(
@@ -315,10 +335,12 @@ const wrapHandlers = <ROut, const Self extends Definition.Any>(
     RpcDefinition.Definition.MethodNames<Self>
   >) {
     const handler = handlers[key];
+
     wrapped[key] = (...args: Array<unknown>) =>
       Effect.gen(function* () {
         const decodedArgs = yield* RpcDefinition.decodeArgs(definition, key, args);
         const value = yield* handler(...decodedArgs);
+
         return yield* RpcDefinition.encodeSuccess(definition, key, value);
       });
   }

package/src/WorkflowBinding.ts

@@ -4,7 +4,7 @@ import type {
   WorkflowInstance as CloudflareWorkflowInstance,
   WorkflowInstanceCreateOptions as CloudflareWorkflowInstanceCreateOptions,
 } from "@cloudflare/workers-types";
-import { Context, Data, Effect, Option, Schema as S } from "effect";
+import { type Context, Data, Effect, Option, Schema as S } from "effect";
 
 import * as Binding from "./Binding";
 import type * as RpcDefinition from "./RpcDefinition";
@@ -187,7 +187,10 @@ export const makeClient = <
             return {
               status: status.status,
               output,
-              error: status.error == null ? Option.none() : Option.some(status.error),
+              error:
+                status.error === null || status.error === undefined
+                  ? Option.none()
+                  : Option.some(status.error),
             };
           }),
         ),

package/src/WorkflowDefinition.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Schema as S, type Layer } from "effect";
 
-import * as Binding from "./Binding";
+import type * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import type { ExecutionContext, WorkerContext } from "./Worker";
 import type * as RpcDefinition from "./RpcDefinition";
@@ -162,6 +162,7 @@ export const Tag =
       options?: WorkflowBinding.WorkflowInstanceCreateOptions<S.Codec.Encoded<Payload>>,
     ) {
       const workflow = yield* tag;
+
       return yield* workflow.create(payload, options);
     });
 
@@ -172,16 +173,19 @@ export const Tag =
       >,
     ) {
       const workflow = yield* tag;
+
       return yield* workflow.createBatch(batch);
     });
 
     const get = Effect.fnUntraced(function* (instanceId: string) {
       const workflow = yield* tag;
+
       return yield* workflow.get(instanceId);
     });
 
     const unsafeRaw = Effect.fnUntraced(function* () {
       const workflow = yield* tag;
+
       return yield* workflow.unsafeRaw;
     });
 
@@ -222,6 +226,7 @@ const wrapHandler = <ROut, const Self extends Definition.Any>(
       const result = yield* handler(decodedPayload as S.Schema.Type<Self["payload"]>).pipe(
         Effect.provideService(WorkflowEntrypoint.WorkflowEvent, decodedEvent),
       );
+
       return yield* encodeResult(result as S.Schema.Type<Self["result"]>);
     });
 };

package/src/internal/Clock.ts

@@ -8,8 +8,16 @@ export const clock: Clock.Clock = {
   currentTimeMillis: Effect.sync(() => clock.currentTimeMillisUnsafe()),
   currentTimeNanosUnsafe: () => BigInt(Date.now()) * nanosPerMilli,
   currentTimeNanos: Effect.sync(() => clock.currentTimeNanosUnsafe()),
+  // Workers expose `performance.now()` as time since worker start. It advances
+  // only across I/O, like `Date.now()`, but it never moves backward.
+  monotonicTimeNanosUnsafe: () =>
+    typeof performance === "undefined"
+      ? BigInt(Date.now()) * nanosPerMilli
+      : BigInt(Math.round(performance.now() * 1_000_000)),
+  monotonicTimeNanos: Effect.sync(() => clock.monotonicTimeNanosUnsafe()),
   sleep: (duration) => {
     const millis = Duration.toMillis(duration);
+
     if (millis <= 0) {
       return Effect.yieldNow;
     }
@@ -20,6 +28,7 @@ export const clock: Clock.Clock = {
       }
 
       const handle = setTimeout(() => resume(Effect.void), millis);
+
       return Effect.sync(() => clearTimeout(handle));
     });
   },

package/src/internal/RpcInvocation.ts

@@ -66,6 +66,7 @@ export const invokeRpcMethod = <Api, Method extends AsyncMethodKey<Api>, Error>(
 ): Effect.Effect<AsyncMethodCloudflareReturn<Api, Method>, Error> =>
   Effect.gen(function* () {
     const fn = yield* lookupRpcMethod<Api, Method, Error>(target, method, makeError);
+
     return yield* Effect.try({
       try: () => fn(...args),
       catch: makeError,

package/dist/Hyperdrive-89hg_Fck.mjs

@@ -1,156 +0,0 @@
-import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { Config, ConfigProvider, Context, Data, Effect, Layer } from "effect";
-//#region src/Environment.ts
-/**
-* 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) => ConfigProvider.fromUnknown(env);
-	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,
-	BindingValidationError: () => BindingValidationError,
-	Service: () => Service,
-	TypeId: () => TypeId,
-	layer: () => layer$1
-});
-/** Internal type id marker used by binding helper services. */
-const TypeId = "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. */
-var BindingValidationError = class extends Data.TaggedError("BindingValidationError") {};
-const defaultExpected = "Cloudflare binding resource";
-const isPropertyTarget = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
-const getObjectName = (value) => {
-	const tag = (() => {
-		try {
-			return Object.prototype.toString.call(value).slice(8, -1);
-		} catch {
-			return typeof value;
-		}
-	})();
-	const constructorName = (() => {
-		try {
-			return "constructor" in value && typeof value.constructor === "function" && typeof value.constructor.name === "string" ? value.constructor.name : void 0;
-		} catch {
-			return;
-		}
-	})();
-	if (tag !== "Object") return tag;
-	if (constructorName !== void 0 && constructorName !== "" && constructorName !== "Object") return constructorName;
-	return tag;
-};
-const propertyNames = (value) => {
-	const names = /* @__PURE__ */ new Set();
-	for (const target of [value, Object.getPrototypeOf(value)]) {
-		if (target === null || target === Object.prototype || target === Function.prototype) continue;
-		try {
-			for (const name of Object.getOwnPropertyNames(target)) names.add(name);
-		} catch {
-			continue;
-		}
-	}
-	return [...names].filter((name) => name !== "constructor").sort();
-};
-const isMethod = (value, name) => {
-	try {
-		return typeof Reflect.get(value, name) === "function";
-	} catch {
-		return false;
-	}
-};
-const describeActual = (value) => {
-	if (value === null) return "null";
-	if (typeof value !== "object" && typeof value !== "function") return typeof value;
-	const names = propertyNames(value);
-	const methods = names.filter((name) => isMethod(value, name));
-	const properties = names.filter((name) => !methods.includes(name));
-	const details = [methods.length > 0 ? `methods ${methods.join(", ")}` : void 0, properties.length > 0 ? `properties ${properties.join(", ")}` : void 0].filter((detail) => detail !== void 0);
-	if (details.length === 0) return getObjectName(value);
-	return `${getObjectName(value)} with ${details.join("; ")}`;
-};
-const getBinding = (env, binding, isResource, options) => Effect.gen(function* () {
-	if (!isPropertyTarget(env)) {
-		const actual = describeActual(env);
-		return yield* Effect.fail(new BindingValidationError({
-			binding,
-			expected: "WorkerEnvironment object",
-			actual,
-			message: `Cloudflare binding "${binding}" failed validation. Expected WorkerEnvironment object; got ${actual}`
-		}));
-	}
-	const resource = Reflect.get(env, binding);
-	if (resource === void 0) return yield* Effect.fail(new BindingNotFoundError({
-		binding,
-		message: `Cloudflare binding "${binding}" was not found in WorkerEnvironment`
-	}));
-	if (!isResource(resource)) {
-		const expected = options?.expected ?? defaultExpected;
-		const actual = describeActual(resource);
-		return yield* Effect.fail(new BindingValidationError({
-			binding,
-			expected,
-			actual,
-			message: `Cloudflare binding "${binding}" failed validation. Expected ${expected}; got ${actual}`
-		}));
-	}
-	return resource;
-});
-const layer$1 = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
-	const resource = yield* getBinding(yield* WorkerEnvironment, binding, isResource, options);
-	return wrap === void 0 ? resource : wrap(resource);
-}));
-const Service = () => (id, binding, isResource, wrap, options) => {
-	const tag = Context.Service()(id);
-	const serviceLayer = layer$1(tag, binding, isResource, wrap, options);
-	return Object.assign(tag, {
-		[TypeId]: TypeId,
-		binding,
-		layer: serviceLayer
-	});
-};
-//#endregion
-//#region src/Hyperdrive.ts
-var Hyperdrive_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag,
-	isHyperdrive: () => isHyperdrive,
-	layer: () => layer,
-	make: () => make,
-	makeClient: () => makeClient
-});
-const expectedHyperdrive = "Hyperdrive binding with connectionString";
-const isHyperdrive = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	return typeof value.connectionString === "string";
-};
-const makeClient = (definition) => (hyperdrive) => ({
-	definition,
-	connectionString: hyperdrive.connectionString,
-	unsafeRaw: Effect.succeed(hyperdrive)
-});
-const layer = (tag, definition) => layer$1(tag, definition.binding, isHyperdrive, makeClient(definition), { expected: expectedHyperdrive });
-const make = (id) => Tag()(id);
-const Tag = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-export { WorkerConfig as a, layer$1 as i, Binding_exports as n, WorkerEnvironment as o, Service as r, Hyperdrive_exports as t };