effect-cf 0.18.0 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -36,27 +36,26 @@
     "dev": "vp pack --watch",
     "test": "vp test",
     "check": "vp check",
-    "prepublishOnly": "vp run build"
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
     "@cloudflare/containers": "catalog:",
     "@cloudflare/vitest-pool-workers": "catalog:",
     "@cloudflare/workers-types": "catalog:",
-    "@effect/platform-node": "4.0.0-beta.77",
+    "@effect/platform-node": "4.0.0-beta.105",
     "@effect/sql-d1": "catalog:",
     "@effect/sql-pg": "catalog:",
     "@effect/sql-sqlite-do": "catalog:",
     "@effect/vitest": "catalog:",
     "effect": "catalog:",
-    "typescript": "^6.0.2",
-    "vite-plus": "0.1.20",
+    "vite-plus": "catalog:",
     "vitest": "catalog:"
   },
   "peerDependencies": {
-    "@effect/sql-d1": "^4.0.0-beta.77",
-    "@effect/sql-pg": "^4.0.0-beta.77",
-    "@effect/sql-sqlite-do": "^4.0.0-beta.77",
-    "effect": "^4.0.0-beta.77"
+    "@effect/sql-d1": "^4.0.0-beta.105",
+    "@effect/sql-pg": "^4.0.0-beta.105",
+    "@effect/sql-sqlite-do": "^4.0.0-beta.105",
+    "effect": "^4.0.0-beta.105"
   },
   "peerDependenciesMeta": {
     "@effect/sql-pg": {

package/src/AiGateway.ts

@@ -113,6 +113,7 @@ const tryAiGatewaySync = <A>(
 const providerUrl = (baseUrl: string, path = "") => {
   const url = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
   const normalizedPath = path.replace(/^\/+/, "");
+
   return normalizedPath === "" ? url : new URL(normalizedPath, url);
 };
 
@@ -141,6 +142,7 @@ export const makeClient = (definition: AiGatewayDefinition, gateway: AiGatewayBi
         const baseUrl = yield* tryAiGatewayPromise(definition.binding, "getUrl", () =>
           gateway.getUrl(options.provider),
         );
+
         return yield* tryAiGatewayPromise(definition.binding, "fetch", () =>
           fetch(providerUrl(baseUrl, options.path).href, options.init),
         );
@@ -244,6 +246,7 @@ export const makeHttpClient = (
     getLog: (logId) =>
       tryAiGatewayPromise(binding, "getLog", async () => {
         const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href);
+
         return (await response.json()) as AiGatewayLog;
       }),
     unsafeRaw: Effect.fail(

package/src/AnalyticsEngine.ts

@@ -3,13 +3,13 @@ import type {
   AnalyticsEngineDataset as CloudflareAnalyticsEngineDataset,
 } from "@cloudflare/workers-types";
 import {
+  type Redacted,
   Config,
   Context,
   Data,
   Effect,
   Layer,
   Option,
-  Redacted,
   Result,
   Schema as S,
 } from "effect";
@@ -558,7 +558,9 @@ const writeChunks = (
 const queryApiUrl = (definition: AnalyticsEngineQueryDefinition) => {
   const baseUrl = new URL(definition.apiBaseUrl ?? defaultQueryApiBaseUrl);
   const pathname = baseUrl.pathname.replace(/\/+$/, "");
+
   baseUrl.pathname = `${pathname}/accounts/${definition.accountId}/analytics_engine/sql`;
+
   return baseUrl.href;
 };
 
@@ -613,6 +615,7 @@ const executeQueryRequest = (
 
     if (response.status < 200 || response.status >= 300) {
       const body = yield* responseText(definition, response, "queryErrorBody");
+
       return yield* Effect.fail(
         analyticsEngineQueryError(
           definition,
@@ -647,6 +650,7 @@ const makeQueryClientWith = (
           ),
         ),
       );
+
       return yield* decodeQueryResponse(json);
     });
   const queryResult = <Row>(
@@ -783,6 +787,7 @@ export const queryLayerConfig = <Self>(
     tag,
     Effect.gen(function* () {
       const definition = yield* config;
+
       return yield* makeQueryClient(definition);
     }),
   );

package/src/Binding.ts

@@ -1,7 +1,6 @@
 import { Context, Data, Effect, Layer } from "effect";
 
-import { WorkerEnvironment } from "./Environment";
-import type { WorkerEnv } from "./Environment";
+import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 
 /** Internal type id marker used by binding helper services. */
 export const TypeId = "effect-cf/Binding" as const;
@@ -121,6 +120,7 @@ const getBinding = <Resource>(
   Effect.gen(function* () {
     if (!isPropertyTarget(env)) {
       const actual = describeActual(env);
+
       return yield* Effect.fail(
         new BindingValidationError({
           binding,
@@ -145,6 +145,7 @@ const getBinding = <Resource>(
     if (!isResource(resource)) {
       const expected = options?.expected ?? defaultExpected;
       const actual = describeActual(resource);
+
       return yield* Effect.fail(
         new BindingValidationError({
           binding,
@@ -187,6 +188,7 @@ export const layer = <Self, Resource, Service = Resource>(
     Effect.gen(function* () {
       const env = yield* WorkerEnvironment;
       const resource = yield* getBinding(env, binding, isResource, options);
+
       return wrap === undefined ? (resource as unknown as Service) : wrap(resource);
     }),
   );

package/src/CloudflareOtlp.ts

@@ -17,11 +17,19 @@ export type Signal = "logs" | "traces" | "metrics";
 /** OTLP payload serialization used by the Effect OTLP exporters. */
 export type Serialization = "json" | "protobuf";
 
-/** Resource metadata shared by Worker and Durable Object OTLP layers. */
+/**
+ * Resource metadata shared by Worker and Durable Object OTLP layers.
+ *
+ * Precedence follows Effect's `OtlpResource.fromConfig`: explicit
+ * `serviceName`/`serviceVersion` win over matching explicit `attributes`, and
+ * explicit attributes win over `OTEL_SERVICE_NAME`, `OTEL_SERVICE_VERSION`, and
+ * `OTEL_RESOURCE_ATTRIBUTES`. Omit an option to let operators set it from the
+ * environment.
+ */
 export interface ResourceOptions {
-  /** Explicit service name. OTEL resource environment variables take precedence. */
+  /** Explicit service name. Takes precedence over OTEL environment variables. */
   readonly serviceName?: string;
-  /** Explicit service version. OTEL resource environment variables take precedence. */
+  /** Explicit service version. Takes precedence over OTEL environment variables. */
   readonly serviceVersion?: string;
   /** Additional resource attributes attached to exported telemetry. */
   readonly attributes?: Record<string, unknown>;
@@ -89,11 +97,13 @@ const selectedSignals = (signals: ReadonlyArray<Signal> | undefined): ReadonlySe
 
 const withDefinedAttributes = (attributes: Record<string, unknown>): Record<string, unknown> => {
   const out: Record<string, unknown> = {};
+
   for (const [key, value] of Object.entries(attributes)) {
     if (value !== undefined) {
       out[key] = value;
     }
   }
+
   return out;
 };
 
@@ -114,15 +124,14 @@ const serializationLayer = (serialization: Serialization | undefined) =>
 
 type SignalLayer = ReturnType<typeof OtlpLogger.layerFromConfig>;
 
+/** Merges a non-empty signal layer list; callers handle the empty case. */
 const mergeSignalLayers = (layers: ReadonlyArray<SignalLayer>): SignalLayer => {
-  if (layers.length === 0) {
-    return Layer.empty;
-  }
-
   let merged = layers[0]!;
+
   for (let index = 1; index < layers.length; index++) {
     merged = Layer.mergeAll(merged, layers[index]!);
   }
+
   return merged;
 };
 
@@ -164,6 +173,10 @@ const makeLayer = (
     );
   }
 
+  if (layers.length === 0) {
+    return Layer.empty;
+  }
+
   return mergeSignalLayers(layers).pipe(
     Layer.provide(cloudflareConfigProviderLayer),
     Layer.provide(serializationLayer(options.serialization)),

package/src/ContainerNamespace.ts

@@ -243,6 +243,7 @@ export const makeClient =
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ): ContainerInstanceClient => {
       const instance = getByName(name, options);
+
       return {
         unsafeRaw: Effect.flatMap(instance, (client) => client.unsafeRaw),
         state: Effect.flatMap(instance, (client) => client.state),
@@ -296,6 +297,7 @@ export const Tag =
     ) =>
       Effect.gen(function* () {
         const namespace = yield* tag;
+
         return yield* namespace.getByName(name, options);
       });
 
@@ -322,6 +324,7 @@ export const Tag =
 
     const unsafeRaw = Effect.fn(function* () {
       const namespace = yield* tag;
+
       return yield* namespace.unsafeRaw;
     });
 

package/src/D1.ts

@@ -70,6 +70,7 @@ export const Service =
       Layer.unwrap(
         Effect.gen(function* () {
           const db = yield* tag;
+
           return D1Client.layer({ ...options, db });
         }),
       ).pipe(Layer.provide(tag.layer));

package/src/DurableObject.ts

@@ -1,6 +1,13 @@
 import { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
-import { ConfigProvider, Effect, Layer, ManagedRuntime, type Context, type Scope } from "effect";
-import type { Schema as S } from "effect";
+import {
+  ConfigProvider,
+  Effect,
+  Layer,
+  ManagedRuntime,
+  type Context,
+  type Scope,
+  type Schema as S,
+} from "effect";
 
 import { NativeRequest } from "./Worker";
 import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "./Environment";
@@ -173,6 +180,7 @@ export const make = <
       this.runtime = ManagedRuntime.make(runtimeLayer);
 
       const initialize = options.initialize;
+
       if (initialize !== undefined) {
         state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
       }

package/src/DurableObjectAlarm.ts

@@ -356,6 +356,7 @@ const toRepeatEveryMillis = (input: Duration.Input | undefined) => {
   return Effect.try({
     try: () => {
       const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+
       if (!Number.isFinite(millis) || millis <= 0) {
         throw new Error("Alarm repeatEvery must be a positive finite duration");
       }
@@ -404,6 +405,7 @@ const toFailureRescheduleMillis = (input: Duration.Input) =>
   Effect.try({
     try: () => {
       const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+
       if (!Number.isFinite(millis) || millis <= 0) {
         throw new Error("Alarm failure rescheduleAfter must be a positive finite duration");
       }
@@ -430,6 +432,7 @@ export const processDue = <R = never, E = never, OnFailureR = never, OnFailureE
 ) =>
   Effect.gen(function* () {
     const durableObjectAlarm = yield* DurableObjectAlarm;
+
     return yield* durableObjectAlarm.processDueAlarms(handle, options);
   });
 
@@ -506,6 +509,7 @@ export const define = <const Definitions extends AlarmDefinitions>(definitions:
       (event) =>
         Effect.gen(function* () {
           const definition = definitions[event.tag];
+
           if (definition === undefined) {
             return;
           }
@@ -536,6 +540,7 @@ export const define = <const Definitions extends AlarmDefinitions>(definitions:
             const action = getAlarmDefinitionFailureAction(definitions[failure.tag]);
             const optionAction =
               options?.onFailure === undefined ? undefined : yield* options.onFailure(failure);
+
             return action ?? optionAction;
           }),
       },
@@ -602,6 +607,7 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
 
         if (next === undefined) {
           yield* state.storage.deleteAlarm();
+
           return;
         }
 
@@ -625,7 +631,9 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
               row.run_at,
               row.payload,
             );
+
             yield* cursor.rowsWritten;
+
             return;
           }
 
@@ -642,6 +650,7 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
             row.repeat_every_ms,
             row.payload,
           );
+
           yield* cursor.rowsWritten;
         },
       );
@@ -660,7 +669,9 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
             row.run_at,
             row.payload,
           );
+
           yield* cursor.rowsWritten;
+
           return;
         }
 
@@ -678,11 +689,13 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
           row.repeat_every_ms,
           row.payload,
         );
+
         yield* cursor.rowsWritten;
       });
 
       const cancelAlarm = Effect.fn("DurableObjectAlarm.cancelAlarm")(function* (input: AlarmRef) {
         const ref = yield* decodeAlarmRef(input);
+
         yield* state.storage.transaction(() =>
           Effect.gen(function* () {
             yield* ensureTable(state);
@@ -780,15 +793,18 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
                 : yield* toFailureRescheduleMillis(actionRetryDelay);
 
             yield* rescheduleFailedAlarm(row, retryDelay);
+
             return "continue" as const;
           }
 
           if (actionMode === "skip-and-advance-repeat") {
             yield* acknowledgeAlarm(row);
+
             return "continue" as const;
           }
 
           yield* reconcileAlarm();
+
           return "stop" as const;
         };
 
@@ -797,6 +813,7 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
 
           if (Exit.isFailure(eventExit)) {
             const action = yield* handleFailure(row, undefined, eventExit.cause);
+
             if (action === "stop") {
               return yield* Effect.failCause(eventExit.cause);
             }
@@ -808,6 +825,7 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
 
           if (Exit.isFailure(handleExit)) {
             const action = yield* handleFailure(row, event, handleExit.cause);
+
             if (action === "stop") {
               return yield* Effect.failCause(handleExit.cause);
             }
@@ -819,6 +837,7 @@ export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, Alar
         }
 
         yield* reconcileAlarm();
+
         return { failed, handled };
       });
 

package/src/DurableObjectDefinition.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 * as DurableObjectEntrypoint from "./DurableObject";
 import type { DurableObjectHandler } from "./DurableObject";
 import * as DurableObjectNamespace from "./DurableObjectNamespace";
@@ -10,6 +9,13 @@ import type * as Rpc from "./Rpc";
 import * as RpcDefinition from "./RpcDefinition";
 import type { WorkerEnvironment } from "./Environment";
 
+/**
+ * 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<
@@ -232,6 +238,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<
@@ -254,16 +261,19 @@ export const Tag =
       options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
     ) {
       const namespace = yield* tag;
+
       return yield* namespace.newUniqueId(options);
     });
 
     const idFromName = Effect.fnUntraced(function* (name: string) {
       const namespace = yield* tag;
+
       return yield* namespace.idFromName(name);
     });
 
     const idFromString = Effect.fnUntraced(function* (value: string) {
       const namespace = yield* tag;
+
       return yield* namespace.idFromString(value);
     });
 
@@ -272,6 +282,7 @@ export const Tag =
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) {
       const namespace = yield* tag;
+
       return yield* namespace.get(objectId, options);
     });
 
@@ -280,11 +291,13 @@ export const Tag =
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) {
       const namespace = yield* tag;
+
       return yield* namespace.getByName(name, options);
     });
 
     const jurisdiction = Effect.fnUntraced(function* (value: globalThis.DurableObjectJurisdiction) {
       const namespace = yield* tag;
+
       return yield* namespace.jurisdiction(value);
     });
 
@@ -295,6 +308,7 @@ export const Tag =
     ) =>
       Effect.gen(function* () {
         const namespace = yield* tag;
+
         return yield* namespace.fetch(stub, input, init);
       });
 
@@ -305,7 +319,12 @@ export const Tag =
     ) =>
       Effect.gen(function* () {
         const namespace = yield* tag;
-        return yield* namespace.rpc(stub, method as never, ...(args as never));
+
+        return yield* (namespace.rpc as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>)(
+          stub,
+          method,
+          ...args,
+        );
       });
 
     const call = <Method extends keyof ClientApi>(
@@ -315,7 +334,10 @@ export const Tag =
     ) =>
       Effect.gen(function* () {
         const namespace = yield* tag;
-        return yield* namespace.call(stub, method as never, ...(args as never));
+
+        return yield* (
+          namespace.call as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>
+        )(stub, method, ...args);
       });
 
     const scopedCall = <Method extends keyof ClientApi>(
@@ -325,11 +347,15 @@ export const Tag =
     ) =>
       Effect.gen(function* () {
         const namespace = yield* tag;
-        return yield* namespace.scopedCall(stub, method as never, ...(args as never));
+
+        return yield* (
+          namespace.scopedCall as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>
+        )(stub, method, ...args);
       });
 
     const unsafeRaw = Effect.fnUntraced(function* () {
       const namespace = yield* tag;
+
       return yield* namespace.unsafeRaw;
     });
 
@@ -374,10 +400,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/DurableObjectNamespace.ts

@@ -1,4 +1,4 @@
-import { Context, Data, Effect, type Scope } from "effect";
+import { Data, Effect, type Context, type Scope } from "effect";
 
 import * as Binding from "./Binding";
 import * as CloudflareRpc from "./Rpc";
@@ -511,6 +511,7 @@ export const makeClient = <
         const methodName = String(method);
         const result = yield* rpc(stub, method, ...args);
         const value = yield* CloudflareRpc.scoped(result);
+
         return yield* decodeSuccess<Method>(methodName, value);
       });
 
@@ -598,6 +599,7 @@ export const makeDirectMethods = <
         fetch: (input: RequestInfo | URL, init?: RequestInit) =>
           Effect.gen(function* () {
             const stub = yield* getStub();
+
             return yield* helpers.fetch(stub, input, init);
           }),
       } as Record<string, unknown>;
@@ -606,6 +608,7 @@ export const makeDirectMethods = <
         client[methodName] = (...args: Array<unknown>) =>
           Effect.gen(function* () {
             const stub = yield* getStub();
+
             return yield* (
               helpers.call as (
                 stub: DurableObjectStubClient<Api>,

package/src/DurableObjectRpcWebSocket.ts

@@ -70,18 +70,23 @@ export const layer = (options: LayerOptions = {}) =>
 
       const reserveClientId = (socket: DurableWebSocket) => {
         const attachment = readAttachment(socket.raw, attachmentKey);
+
         if (attachment !== undefined) {
           nextClientId = Math.max(nextClientId, attachment + 1);
+
           return attachment;
         }
 
         const id = nextClientId++;
+
         writeAttachment(socket.raw, attachmentKey, id);
+
         return id;
       };
 
       const register = (socket: DurableWebSocket) => {
         const existing = connectionsBySocket.get(socket.raw);
+
         if (existing !== undefined) {
           return existing;
         }
@@ -95,12 +100,14 @@ export const layer = (options: LayerOptions = {}) =>
         connectionsBySocket.set(socket.raw, connection);
         connectionsById.set(connection.id, connection);
         clientIds.add(connection.id);
+
         return connection;
       };
 
       const unregister = (socket: DurableWebSocket) =>
         Effect.sync(() => {
           const connection = connectionsBySocket.get(socket.raw);
+
           if (connection === undefined) {
             return;
           }
@@ -119,11 +126,13 @@ export const layer = (options: LayerOptions = {}) =>
         Effect.sync(() => {
           try {
             const encoded = connection.parser.encode(response);
+
             if (encoded !== undefined) {
               connection.socket.raw.send(encoded);
             }
           } catch (cause) {
             const encoded = connection.parser.encode(RpcMessage.ResponseDefectEncoded(cause));
+
             if (encoded !== undefined) {
               connection.socket.raw.send(encoded);
             }
@@ -137,11 +146,13 @@ export const layer = (options: LayerOptions = {}) =>
           disconnects,
           send: (clientId, response) => {
             const connection = connectionsById.get(clientId);
+
             return connection === undefined ? Effect.void : send(connection, response);
           },
           end: (clientId) =>
             Effect.sync(() => {
               const connection = connectionsById.get(clientId);
+
               connection?.socket.raw.close();
             }),
           clientIds: Effect.sync(() => clientIds),
@@ -167,8 +178,10 @@ export const layer = (options: LayerOptions = {}) =>
             });
 
             const run = writeRequest;
+
             if (run === undefined) {
               yield* send(connection, RpcMessage.ResponseDefectEncoded("RPC server is not ready"));
+
               return;
             }
 
@@ -178,6 +191,7 @@ export const layer = (options: LayerOptions = {}) =>
           }).pipe(
             Effect.catch((error) => {
               const connection = register(socket);
+
               return send(connection, error);
             }),
           ),

package/src/DurableObjectSqlite.ts

@@ -21,6 +21,7 @@ export const layer = (options?: SqliteLayerOptions) =>
   Layer.unwrap(
     Effect.gen(function* () {
       const state = yield* DurableObjectState;
+
       return SqliteClient.layer({ ...options, db: state.raw.storage.sql });
     }),
   );

package/src/DurableObjectStorage.ts

@@ -219,11 +219,13 @@ const schemaBackedSyncKvStorage = <Key, Value, EncodedValue>(
       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) =>