effect-cf 0.6.0 → 0.8.0

package/src/QueueDefinition.ts

@@ -1,5 +1,6 @@
-import { Effect, Schema as S, type Layer, type Scope } from "effect";
+import { Context, Effect, Schema as S, type Layer, type Scope } from "effect";
 
+import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as QueueEntrypoint from "./Queue";
 import * as QueueBinding from "./QueueBinding";
@@ -19,15 +20,6 @@ export namespace Definition {
   export type Any = Definition<string, RpcDefinition.ServiceFreeSchema>;
 }
 
-declare const BindingServiceTypeId: unique symbol;
-
-export interface BindingService<Id extends string, Self extends Definition.Any> {
-  readonly [BindingServiceTypeId]: {
-    readonly id: Id;
-    readonly definition: Self;
-  };
-}
-
 export type Handler<ROut, Self extends Definition.Any> = (
   batch: QueueEntrypoint.QueueBatch<S.Schema.Type<Self["message"]>>,
 ) => Effect.Effect<
@@ -44,6 +36,44 @@ export interface Options<ROut, Self extends Definition.Any> extends Omit<
   readonly rpc?: never;
 }
 
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<
+  Self,
+  Id extends string,
+  Message extends RpcDefinition.ServiceFreeSchema,
+> extends Context.ServiceClass<Self, Id, QueueBinding.QueueBindingClient<Message>> {
+  readonly id: Id;
+  readonly message: Message;
+  readonly make: <ROut, LayerError>(
+    layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+    options: Options<ROut, Definition<Id, Message>>,
+  ) => WorkerEntrypoint.WorkerClass<Record<never, never>, ROut>;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+  readonly send: (
+    message: S.Schema.Type<Message>,
+    options?: QueueBinding.QueueSendOptions,
+  ) => Effect.Effect<void, QueueBinding.QueueOperationError | S.SchemaError, Self>;
+  readonly sendBatch: (
+    messages: Iterable<QueueBinding.MessageSendRequest<S.Schema.Type<Message>>>,
+    options?: QueueBinding.QueueSendBatchOptions,
+  ) => Effect.Effect<void, QueueBinding.QueueOperationError | S.SchemaError, Self>;
+  readonly metrics: () => Effect.Effect<
+    QueueBinding.QueueMetrics,
+    QueueBinding.QueueOperationError,
+    Self
+  >;
+  readonly unsafeRaw: () => Effect.Effect<globalThis.Queue<S.Codec.Encoded<Message>>, never, Self>;
+}
+
 const makeDefinition = <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
   id: Id,
   definition: { readonly message: Message },
@@ -63,49 +93,65 @@ const makeDefinition = <Id extends string, Message extends RpcDefinition.Service
         ...options,
         queue: wrapHandler(queueDefinition, options.queue),
       }),
-    Binding:
-      <Self>() =>
-      <BindingId extends string>(
-        bindingId: BindingId,
-        binding: Omit<QueueBinding.QueueBindingDefinition<Message>, "message">,
-      ) =>
-        QueueBinding.Service<Self>()<BindingId, Message>(bindingId, {
-          ...binding,
-          message: definition.message,
-        }),
-    binding: <BindingId extends string>(
-      bindingId: BindingId,
-      binding: Omit<QueueBinding.QueueBindingDefinition<Message>, "message">,
-    ) =>
-      QueueBinding.Service<BindingService<BindingId, SelfDefinition>>()<BindingId, Message>(
-        bindingId,
-        {
-          ...binding,
-          message: definition.message,
-        },
-      ),
   });
 };
 
-export const make = makeDefinition;
+export const make = <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
+  id: Id,
+  definition: { readonly message: Message },
+) => Tag<Definition<Id, Message>>()(id, definition);
 
 export const Tag =
-  <_Self>() =>
+  <Self>() =>
   <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
     id: Id,
     definition: { readonly message: Message },
   ) => {
     const queueDefinition = makeDefinition(id, definition);
+    const tag = Context.Service<Self, QueueBinding.QueueBindingClient<Message>>()(id);
+
+    const layer = (binding: LayerOptions) =>
+      QueueBinding.layer(tag, {
+        ...binding,
+        message: definition.message,
+      });
+
+    const send = Effect.fnUntraced(function* (
+      message: S.Schema.Type<Message>,
+      options?: QueueBinding.QueueSendOptions,
+    ) {
+      const queue = yield* tag;
+      yield* queue.send(message, options);
+    });
 
-    abstract class QueueDefinitionClass {
-      static readonly id = queueDefinition.id;
-      static readonly message = queueDefinition.message;
-      static readonly make = queueDefinition.make;
-      static readonly Binding = queueDefinition.Binding;
-      static readonly binding = queueDefinition.binding;
-    }
+    const sendBatch = Effect.fnUntraced(function* (
+      messages: Iterable<QueueBinding.MessageSendRequest<S.Schema.Type<Message>>>,
+      options?: QueueBinding.QueueSendBatchOptions,
+    ) {
+      const queue = yield* tag;
+      yield* queue.sendBatch(messages, options);
+    });
+
+    const metrics = Effect.fnUntraced(function* () {
+      const queue = yield* tag;
+      return yield* queue.metrics();
+    });
+
+    const unsafeRaw = Effect.fnUntraced(function* () {
+      const queue = yield* tag;
+      return yield* queue.unsafeRaw;
+    });
 
-    return QueueDefinitionClass as (abstract new () => object) & typeof queueDefinition;
+    return Object.assign(tag, {
+      id: queueDefinition.id,
+      message: queueDefinition.message,
+      make: queueDefinition.make,
+      layer,
+      send,
+      sendBatch,
+      metrics,
+      unsafeRaw,
+    }) as TagClass<Self, Id, Message>;
   };
 
 export const Queue = Tag;

package/src/R2.ts

@@ -0,0 +1,230 @@
+import { Context, Data, Effect, Option, type Layer } from "effect";
+
+import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
+
+/** Error raised when an R2 operation fails. */
+export class R2OperationError extends Data.TaggedError("R2OperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+/** Typed R2 bucket binding definition. */
+export interface R2Definition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+export type R2GetOptions = globalThis.R2GetOptions;
+export type R2PutOptions = globalThis.R2PutOptions;
+export type R2ListOptions = globalThis.R2ListOptions;
+export type R2MultipartOptions = globalThis.R2MultipartOptions;
+export type R2UploadPartOptions = globalThis.R2UploadPartOptions;
+export type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
+export type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
+
+export interface R2MultipartUploadClient {
+  readonly raw: globalThis.R2MultipartUpload;
+  readonly key: string;
+  readonly uploadId: string;
+  readonly uploadPart: (
+    partNumber: number,
+    value: R2UploadPartValue,
+    options?: R2UploadPartOptions,
+  ) => Effect.Effect<globalThis.R2UploadedPart, R2OperationError>;
+  readonly abort: Effect.Effect<void, R2OperationError>;
+  readonly complete: (
+    uploadedParts: ReadonlyArray<globalThis.R2UploadedPart>,
+  ) => Effect.Effect<globalThis.R2Object, R2OperationError>;
+}
+
+export interface R2Client {
+  readonly head: (
+    key: string,
+  ) => Effect.Effect<Option.Option<globalThis.R2Object>, R2OperationError>;
+  readonly get: {
+    (
+      key: string,
+      options: R2GetOptions & { readonly onlyIf: globalThis.R2Conditional | Headers },
+    ): Effect.Effect<
+      Option.Option<globalThis.R2ObjectBody | globalThis.R2Object>,
+      R2OperationError
+    >;
+    (
+      key: string,
+      options?: R2GetOptions,
+    ): Effect.Effect<Option.Option<globalThis.R2ObjectBody>, R2OperationError>;
+  };
+  readonly put: {
+    (
+      key: string,
+      value: R2PutValue,
+      options: R2PutOptions & { readonly onlyIf: globalThis.R2Conditional | Headers },
+    ): Effect.Effect<Option.Option<globalThis.R2Object>, R2OperationError>;
+    (
+      key: string,
+      value: R2PutValue,
+      options?: R2PutOptions,
+    ): Effect.Effect<globalThis.R2Object, R2OperationError>;
+  };
+  readonly createMultipartUpload: (
+    key: string,
+    options?: R2MultipartOptions,
+  ) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
+  readonly resumeMultipartUpload: (
+    key: string,
+    uploadId: string,
+  ) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
+  readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
+  readonly list: (options?: R2ListOptions) => Effect.Effect<globalThis.R2Objects, R2OperationError>;
+  readonly unsafeRaw: Effect.Effect<globalThis.R2Bucket>;
+  readonly definition: R2Definition;
+}
+
+declare const R2ServiceTypeId: unique symbol;
+
+/** Nominal service marker for R2 services created with {@link make}. */
+export interface R2Service<Id extends string> {
+  readonly [R2ServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  R2Client
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+const r2Error = (binding: string, operation: string, cause: unknown) =>
+  new R2OperationError({ binding, operation, cause });
+
+const tryR2Promise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, R2OperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => r2Error(binding, operation, cause),
+  });
+
+const tryR2Sync = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => A,
+): Effect.Effect<A, R2OperationError> =>
+  Effect.try({
+    try: evaluate,
+    catch: (cause) => r2Error(binding, operation, cause),
+  });
+
+const maybe = <A>(value: A | null): Option.Option<A> =>
+  value === null ? Option.none() : Option.some(value);
+
+export const isR2Bucket = (value: unknown): value is globalThis.R2Bucket => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const resource = value as Record<string, unknown>;
+
+  return (
+    typeof resource.head === "function" &&
+    typeof resource.get === "function" &&
+    typeof resource.put === "function" &&
+    typeof resource.createMultipartUpload === "function" &&
+    typeof resource.resumeMultipartUpload === "function" &&
+    typeof resource.delete === "function" &&
+    typeof resource.list === "function"
+  );
+};
+
+export const makeClient = (
+  definition: R2Definition,
+): ((bucket: globalThis.R2Bucket) => R2Client) => {
+  const wrapUpload = (upload: globalThis.R2MultipartUpload): R2MultipartUploadClient => ({
+    raw: upload,
+    key: upload.key,
+    uploadId: upload.uploadId,
+    uploadPart: (partNumber, value, options) =>
+      tryR2Promise(definition.binding, "uploadPart", () =>
+        upload.uploadPart(partNumber, value, options),
+      ),
+    abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()),
+    complete: (uploadedParts) =>
+      tryR2Promise(definition.binding, "completeMultipartUpload", () =>
+        upload.complete([...uploadedParts]),
+      ),
+  });
+
+  return (bucket) => ({
+    definition,
+    head: (key) =>
+      tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(maybe)),
+    get: ((key: string, options?: R2GetOptions) =>
+      tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(
+        Effect.map(maybe),
+      )) as R2Client["get"],
+    put: ((key: string, value: R2PutValue, options?: R2PutOptions) =>
+      tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(
+        Effect.map((object) => {
+          if (object === null) {
+            return Option.none<globalThis.R2Object>();
+          }
+
+          if (options !== undefined && "onlyIf" in options) {
+            return Option.some(object);
+          }
+
+          return object;
+        }),
+      )) as R2Client["put"],
+    createMultipartUpload: (key, options) =>
+      tryR2Promise(definition.binding, "createMultipartUpload", () =>
+        bucket.createMultipartUpload(key, options),
+      ).pipe(Effect.map(wrapUpload)),
+    resumeMultipartUpload: (key, uploadId) =>
+      tryR2Sync(definition.binding, "resumeMultipartUpload", () =>
+        wrapUpload(bucket.resumeMultipartUpload(key, uploadId)),
+      ),
+    delete: (keys) => {
+      const nativeKeys = typeof keys === "string" ? keys : [...keys];
+      return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
+    },
+    list: (options) => tryR2Promise(definition.binding, "list", () => bucket.list(options)),
+    unsafeRaw: Effect.succeed(bucket),
+  });
+};
+
+export const layer = <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) =>
+  Binding.layer(tag, definition.binding, isR2Bucket, makeClient(definition));
+
+export const make = <Id extends string>(id: Id) => Tag<R2Service<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, R2Client>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };