alchemy-effect 0.7.0 → 0.8.0

package/src/Cloudflare/KV/GetWithMetadata.ts

@@ -3,15 +3,15 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
-import { NamespaceBinding } from "./NamespaceBinding.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
+import { NamespaceBinding } from "./KVNamespaceBinding.ts";
 
 export interface GetWithMetadataOptions extends runtime.KVNamespaceGetOptions<undefined> {}
 
 export class GetWithMetadata extends Binding.Service<
   GetWithMetadata,
   (
-    namespace: Namespace,
+    namespace: KVNamespace,
   ) => Effect.Effect<
     <Metadata = unknown>(
       key: string,
@@ -28,7 +28,7 @@ export const GetWithMetadataLive = Layer.effect(
     const Policy = yield* GetWithMetadataPolicy;
     const env = yield* WorkerEnvironment;
 
-    return Effect.fn(function* (namespace: Namespace) {
+    return Effect.fn(function* (namespace: KVNamespace) {
       yield* Policy(namespace);
       const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
         namespace.LogicalId
@@ -47,7 +47,7 @@ export const GetWithMetadataLive = Layer.effect(
 
 export class GetWithMetadataPolicy extends Binding.Policy<
   GetWithMetadataPolicy,
-  (namespace: Namespace) => Effect.Effect<void>
+  (namespace: KVNamespace) => Effect.Effect<void>
 >()("Cloudflare.KV.GetWithMetadata") {}
 
 export const GetWithMetadataPolicyLive =

package/src/Cloudflare/KV/{Namespace.ts → KVNamespace.ts}

@@ -21,8 +21,8 @@ export type NamespaceProps = {
   title?: string;
 };
 
-export interface Namespace extends Resource<
-  "Cloudflare.KV.Namespace",
+export type KVNamespace = Resource<
+  "Cloudflare.KVNamespace",
   NamespaceProps,
   {
     title: string;
@@ -30,16 +30,16 @@ export interface Namespace extends Resource<
     supportsUrlEncoding: boolean | undefined;
     accountId: string;
   }
-> {}
+>;
 
-export const Namespace = Resource<Namespace>("Cloudflare.KV.Namespace");
+export const KVNamespace = Resource<KVNamespace>("Cloudflare.KVNamespace");
 
 export const NamespaceProvider = (): Layer<
-  Provider<Namespace>,
+  Provider<KVNamespace>,
   never,
   Account | Credentials | HttpClient | Stack | Stage
 > =>
-  Namespace.provider.effect(
+  KVNamespace.provider.effect(
     Effect.gen(function* () {
       const accountId = yield* Account;
       const createNamespace = yield* kv.createNamespace;

package/src/Cloudflare/KV/{NamespaceBinding.ts → KVNamespaceBinding.ts}

@@ -1,11 +1,11 @@
 import * as Effect from "effect/Effect";
 import type { ResourceLike } from "../../Resource.ts";
 import { isWorker } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
 
 export const NamespaceBinding = Effect.fn(function* (
   host: ResourceLike,
-  namespace: Namespace,
+  namespace: KVNamespace,
 ) {
   if (isWorker(host)) {
     yield* host.bind`Bind(${namespace})`({

package/src/Cloudflare/KV/List.ts

@@ -3,15 +3,15 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
-import { NamespaceBinding } from "./NamespaceBinding.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
+import { NamespaceBinding } from "./KVNamespaceBinding.ts";
 
 export interface ListOptions extends runtime.KVNamespaceListOptions {}
 
 export class List extends Binding.Service<
   List,
   (
-    namespace: Namespace,
+    namespace: KVNamespace,
   ) => Effect.Effect<
     <Metadata = unknown>(
       options?: ListOptions,
@@ -25,7 +25,7 @@ export const ListLive = Layer.effect(
     const Policy = yield* ListPolicy;
     const env = yield* WorkerEnvironment;
 
-    return Effect.fn(function* (namespace: Namespace) {
+    return Effect.fn(function* (namespace: KVNamespace) {
       yield* Policy(namespace);
       const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
         namespace.LogicalId
@@ -39,7 +39,7 @@ export const ListLive = Layer.effect(
 
 export class ListPolicy extends Binding.Policy<
   ListPolicy,
-  (namespace: Namespace) => Effect.Effect<void>
+  (namespace: KVNamespace) => Effect.Effect<void>
 >()("Cloudflare.KV.List") {}
 
 export const ListPolicyLive = ListPolicy.layer.succeed(NamespaceBinding);

package/src/Cloudflare/KV/Put.ts

@@ -5,8 +5,8 @@ import type * as Stream from "effect/Stream";
 import * as Binding from "../../Binding.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
 import { replaceEffectStream } from "../stream.ts";
-import type { Namespace } from "./Namespace.ts";
-import { NamespaceBinding } from "./NamespaceBinding.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
+import { NamespaceBinding } from "./KVNamespaceBinding.ts";
 
 export type PutValue =
   | string
@@ -20,7 +20,7 @@ export interface PutOptions extends runtime.KVNamespacePutOptions {}
 export class Put extends Binding.Service<
   Put,
   (
-    namespace: Namespace,
+    namespace: KVNamespace,
   ) => Effect.Effect<
     (key: string, value: PutValue, options?: PutOptions) => Effect.Effect<void>
   >
@@ -32,7 +32,7 @@ export const PutLive = Layer.effect(
     const Policy = yield* PutPolicy;
     const env = yield* WorkerEnvironment;
 
-    return Effect.fn(function* (namespace: Namespace) {
+    return Effect.fn(function* (namespace: KVNamespace) {
       yield* Policy(namespace);
       const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
         namespace.LogicalId
@@ -53,7 +53,7 @@ export const PutLive = Layer.effect(
 
 export class PutPolicy extends Binding.Policy<
   PutPolicy,
-  (namespace: Namespace) => Effect.Effect<void>
+  (namespace: KVNamespace) => Effect.Effect<void>
 >()("Cloudflare.KV.Put") {}
 
 export const PutPolicyLive = PutPolicy.layer.succeed(NamespaceBinding);

package/src/Cloudflare/KV/index.ts

@@ -1,6 +1,6 @@
 export * from "./Delete.ts";
 export * from "./Get.ts";
 export * from "./GetWithMetadata.ts";
+export * from "./KVNamespace.ts";
 export * from "./List.ts";
-export * from "./Namespace.ts";
 export * from "./Put.ts";

package/src/Cloudflare/Providers.ts

@@ -53,7 +53,7 @@ export const resources = () =>
     WorkflowProvider(),
     D1.DatabaseProvider(),
     KV.NamespaceProvider(),
-    R2.BucketProvider(),
+    R2.R2BucketProvider(),
   );
 
 /**
@@ -62,13 +62,7 @@ export const resources = () =>
 export const bindings = () =>
   Layer.mergeAll(
     D1.D1ConnectionPolicyLive,
-    R2.GetObjectPolicyLive,
-    R2.PutObjectPolicyLive,
-    R2.DeleteObjectPolicyLive,
-    R2.HeadObjectPolicyLive,
-    R2.ListObjectsPolicyLive,
-    R2.CreateMultipartUploadPolicyLive,
-    R2.ResumeMultipartUploadPolicyLive,
+    R2.R2BucketBindingPolicyLive,
     KV.GetPolicyLive,
     KV.PutPolicyLive,
     KV.DeletePolicyLive,

package/src/Cloudflare/R2/{Bucket.ts → R2Bucket.ts}

@@ -6,9 +6,9 @@ import { createPhysicalName } from "../../PhysicalName.ts";
 import { Resource } from "../../Resource.ts";
 import { Account } from "../Account.ts";
 
-export type BucketName = string;
+export type R2BucketName = string;
 
-export type BucketProps = {
+export type R2BucketProps = {
   /**
    * Name of the bucket. If omitted, a unique name will be generated.
    * @default ${app}-${stage}-${id}
@@ -18,40 +18,40 @@ export type BucketProps = {
    * Storage class for newly uploaded objects.
    * @default "Standard"
    */
-  storageClass?: Bucket.StorageClass;
+  storageClass?: R2Bucket.StorageClass;
   /**
    * Jurisdiction where objects in this bucket are guaranteed to be stored.
    * @default "default"
    */
-  jurisdiction?: Bucket.Jurisdiction;
+  jurisdiction?: R2Bucket.Jurisdiction;
   /**
    * Location hint for the bucket.
    */
-  locationHint?: Bucket.Location;
+  locationHint?: R2Bucket.Location;
 };
 
-export interface Bucket extends Resource<
-  "Cloudflare.R2.Bucket",
-  BucketProps,
+export type R2Bucket = Resource<
+  "Cloudflare.R2Bucket",
+  R2BucketProps,
   {
-    bucketName: BucketName;
-    storageClass: Bucket.StorageClass;
-    jurisdiction: Bucket.Jurisdiction;
-    location: Bucket.Location | undefined;
+    bucketName: R2BucketName;
+    storageClass: R2Bucket.StorageClass;
+    jurisdiction: R2Bucket.Jurisdiction;
+    location: R2Bucket.Location | undefined;
     accountId: string;
   }
-> {}
+>;
 
-export const Bucket = Resource<Bucket>("Cloudflare.R2.Bucket");
+export const R2Bucket = Resource<R2Bucket>("Cloudflare.R2Bucket");
 
-export declare namespace Bucket {
+export declare namespace R2Bucket {
   export type StorageClass = "Standard" | "InfrequentAccess";
   export type Jurisdiction = "default" | "eu" | "fedramp";
   export type Location = "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc";
 }
 
-export const BucketProvider = () =>
-  Bucket.provider.effect(
+export const R2BucketProvider = () =>
+  R2Bucket.provider.effect(
     Effect.gen(function* () {
       const accountId = yield* Account;
       const createBucket = yield* r2.createBucket;
@@ -70,9 +70,9 @@ export const BucketProvider = () =>
 
       const normalizeLocation = (
         location: string | undefined | null,
-      ): Bucket.Location | undefined => {
+      ): R2Bucket.Location | undefined => {
         if (!location) return undefined;
-        return location.toLowerCase() as Bucket.Location;
+        return location.toLowerCase() as R2Bucket.Location;
       };
 
       return {

package/src/Cloudflare/R2/R2BucketBinding.ts

@@ -0,0 +1,299 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import * as Binding from "../../Binding.ts";
+import * as Output from "../../Output.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
+import type { R2Bucket } from "./R2Bucket.ts";
+
+export interface R2Object extends Omit<runtime.R2Object, "writeHttpMetadata"> {
+  writeHttpMetadata(headers: Headers): Effect.Effect<void>;
+}
+
+export interface R2ObjectBody extends R2Object {
+  get body(): Stream.Stream<Uint8Array, R2Error>;
+  get bodyUsed(): boolean;
+  arrayBuffer(): Effect.Effect<ArrayBuffer, R2Error>;
+  bytes(): Effect.Effect<Uint8Array, R2Error>;
+  text(): Effect.Effect<string, R2Error>;
+  json<T>(): Effect.Effect<T, R2Error>;
+  blob(): Effect.Effect<runtime.Blob, R2Error>;
+}
+
+export type R2GetOptions = runtime.R2GetOptions;
+export type R2PutOptions = runtime.R2PutOptions;
+
+export type R2ListOptions = runtime.R2ListOptions;
+export type R2Objects = {
+  objects: R2Object[];
+  delimitedPrefixes: string[];
+} & (
+  | {
+      truncated: true;
+      cursor: string;
+    }
+  | {
+      truncated: false;
+    }
+);
+export type R2Conditional = runtime.R2Conditional;
+
+export class R2Error extends Data.TaggedError("R2Error")<{
+  message: string;
+  cause: Error;
+}> {}
+
+export interface R2MultipartUpload {
+  raw: runtime.R2MultipartUpload;
+  readonly key: string;
+  readonly uploadId: string;
+  uploadPart(
+    partNumber: number,
+    value: ReadableStream | (ArrayBuffer | ArrayBufferView) | string | Blob,
+    options?: R2UploadPartOptions,
+  ): Effect.Effect<R2UploadedPart, R2Error>;
+  abort(): Effect.Effect<void, R2Error>;
+  complete(uploadedParts: R2UploadedPart[]): Effect.Effect<R2Object, R2Error>;
+}
+export type R2MultipartOptions = runtime.R2MultipartOptions;
+export type R2UploadedPart = runtime.R2UploadedPart;
+export interface R2UploadPartOptions extends runtime.R2UploadPartOptions {}
+
+export interface R2BucketClient {
+  raw: runtime.R2Bucket;
+  head(key: string): Effect.Effect<R2Object | null, R2Error>;
+  get(
+    key: string,
+    options: R2GetOptions & {
+      onlyIf: runtime.R2Conditional | Headers;
+    },
+  ): Effect.Effect<R2ObjectBody | R2Object | null, R2Error>;
+  get(
+    key: string,
+    options?: R2GetOptions,
+  ): Effect.Effect<R2ObjectBody | null, R2Error>;
+  put(
+    key: string,
+    value:
+      | ReadableStream
+      | ArrayBuffer
+      | ArrayBufferView
+      | string
+      | null
+      | Blob
+      | Stream.Stream<Uint8Array>,
+    options?: R2PutOptions & {
+      onlyIf: R2Conditional | Headers;
+    },
+  ): Effect.Effect<R2Object | null, R2Error>;
+  put(
+    key: string,
+    value:
+      | ReadableStream
+      | ArrayBuffer
+      | ArrayBufferView
+      | string
+      | null
+      | Blob
+      | Stream.Stream<Uint8Array>,
+    options?: R2PutOptions,
+  ): Effect.Effect<R2Object, R2Error>;
+  delete(keys: string | string[]): Effect.Effect<void, R2Error>;
+  list(options?: R2ListOptions): Effect.Effect<R2Objects, R2Error>;
+  createMultipartUpload(
+    key: string,
+    options?: R2MultipartOptions,
+  ): Effect.Effect<R2MultipartUpload, R2Error>;
+  resumeMultipartUpload(
+    key: string,
+    uploadId: string,
+  ): Effect.Effect<R2MultipartUpload, R2Error>;
+}
+
+export class R2BucketBinding extends Binding.Service<
+  R2BucketBinding,
+  (bucket: R2Bucket) => Effect.Effect<R2BucketClient>
+>()("Cloudflare.R2Bucket") {}
+
+export const R2BucketBindingLive = Layer.effect(
+  R2BucketBinding,
+  Effect.gen(function* () {
+    const bind = yield* BucketBindingPolicy;
+    const env = yield* WorkerEnvironment;
+
+    return Effect.fn(function* (bucket: R2Bucket) {
+      yield* bind(bucket);
+      const raw = (env as Record<string, runtime.R2Bucket>)[bucket.LogicalId];
+      const tryPromise = <T>(fn: () => Promise<T>): Effect.Effect<T, R2Error> =>
+        Effect.tryPromise({
+          try: fn,
+          catch: (error: any) =>
+            new R2Error({
+              message: error.message ?? "Unknown error",
+              cause: error,
+            }),
+        });
+
+      const wrapR2Object = (object: runtime.R2Object): R2Object => ({
+        ...object,
+        writeHttpMetadata: (headers: Headers) =>
+          Effect.sync(() => object.writeHttpMetadata(headers)),
+      });
+      const wrapR2ObjectBody = (
+        object: runtime.R2ObjectBody,
+      ): R2ObjectBody => ({
+        ...wrapR2Object(object),
+        body: Stream.fromReadableStream({
+          evaluate: () =>
+            object.body as any as ReadableStream<Uint8Array<ArrayBufferLike>>,
+          onError: (error: any) =>
+            new R2Error({
+              message: error.message ?? "Unknown error",
+              cause: error,
+            }),
+        }),
+        bodyUsed: object.bodyUsed,
+        arrayBuffer: () => tryPromise(() => object.arrayBuffer()),
+        bytes: () => tryPromise(() => object.bytes()),
+        text: () => tryPromise(() => object.text()),
+        json: <T>() => tryPromise(() => object.json<T>()),
+        blob: () => tryPromise(() => object.blob()),
+      });
+
+      const wrapR2Objects = (objects: runtime.R2Objects): R2Objects =>
+        ({
+          objects: objects.objects.map(wrapR2Object),
+          delimitedPrefixes: objects.delimitedPrefixes,
+          ...("cursor" in objects ? { cursor: objects.cursor } : {}),
+          ...("truncated" in objects ? { truncated: objects.truncated } : {}),
+        }) as R2Objects;
+
+      const wrapR2ObjectOrBody = (
+        object: runtime.R2Object | runtime.R2ObjectBody | null,
+      ): R2Object | R2ObjectBody | null =>
+        object === null
+          ? object
+          : isR2ObjectBody(object)
+            ? wrapR2ObjectBody(object)
+            : wrapR2Object(object);
+
+      const wrapR2MultipartUpload = (
+        upload: runtime.R2MultipartUpload,
+      ): R2MultipartUpload => ({
+        ...upload,
+        raw: upload,
+        uploadId: upload.uploadId,
+        abort: () => tryPromise(() => upload.abort()),
+        complete: (uploadedParts: R2UploadedPart[]) =>
+          tryPromise(() => upload.complete(uploadedParts)).pipe(
+            Effect.map(wrapR2Object),
+          ),
+        uploadPart: (
+          partNumber: number,
+          value:
+            | ReadableStream
+            | ArrayBuffer
+            | ArrayBufferView
+            | string
+            | Blob
+            | Stream.Stream<Uint8Array>,
+          options?: R2UploadPartOptions,
+        ) =>
+          tryPromise(() =>
+            upload.uploadPart(
+              partNumber,
+              Stream.isStream(value)
+                ? value.pipe(Stream.toReadableStream())
+                : (value as any),
+              options,
+            ),
+          ),
+      });
+
+      const isR2ObjectBody = (object: any): object is runtime.R2ObjectBody =>
+        object !== null && typeof object === "object" && "body" in object;
+
+      return {
+        raw: raw,
+        head: (key: string) =>
+          tryPromise(() => raw.head(key)).pipe(
+            Effect.map((object) => (object ? wrapR2Object(object) : object)),
+          ),
+        get: (key: string, options?: R2GetOptions) =>
+          tryPromise(() => raw.get(key, options)).pipe(
+            Effect.map(wrapR2ObjectOrBody),
+          ) as any,
+        put: (
+          key: string,
+          value:
+            | ReadableStream
+            | ArrayBuffer
+            | ArrayBufferView
+            | string
+            | null
+            | Blob
+            | Stream.Stream<Uint8Array>,
+          options?: R2PutOptions & { onlyIf: R2Conditional | Headers },
+        ) =>
+          tryPromise(() =>
+            raw.put(
+              key,
+              Stream.isStream(value)
+                ? value.pipe(Stream.toReadableStream())
+                : (value as any),
+              options,
+            ),
+          ).pipe(Effect.map(wrapR2ObjectOrBody)) as any,
+        delete: (keys: string | string[]) => tryPromise(() => raw.delete(keys)),
+        list: (options?: R2ListOptions) =>
+          tryPromise(() => raw.list(options)).pipe(Effect.map(wrapR2Objects)),
+        createMultipartUpload: (key: string, options?: R2MultipartOptions) =>
+          tryPromise(() => raw.createMultipartUpload(key, options)).pipe(
+            Effect.map(wrapR2MultipartUpload),
+          ),
+        resumeMultipartUpload: (key: string, uploadId: string) =>
+          Effect.sync(() => raw.resumeMultipartUpload(key, uploadId)).pipe(
+            Effect.map(wrapR2MultipartUpload),
+          ),
+      } satisfies R2BucketClient as R2BucketClient;
+    });
+  }),
+);
+
+export class BucketBindingPolicy extends Binding.Policy<
+  BucketBindingPolicy,
+  (bucket: R2Bucket) => Effect.Effect<void>
+>()("Cloudflare.R2Bucket") {}
+
+export const R2BucketBindingPolicyLive = BucketBindingPolicy.layer.succeed(
+  (host, bucket) => R2BucketClient(host, bucket),
+);
+
+export const R2BucketClient = Effect.fn(function* (
+  host: ResourceLike,
+  bucket: R2Bucket,
+) {
+  if (isWorker(host)) {
+    yield* host.bind`Bind(${bucket})`({
+      bindings: [
+        {
+          type: "r2_bucket",
+          name: bucket.LogicalId,
+          bucketName: bucket.bucketName,
+          jurisdiction: bucket.jurisdiction.pipe(
+            Output.map((jurisdiction) =>
+              jurisdiction === "default" ? undefined : jurisdiction,
+            ),
+          ),
+        },
+      ],
+    });
+  } else {
+    return yield* Effect.die(
+      new Error(`BucketBinding does not support runtime '${host.Type}'`),
+    );
+  }
+});

package/src/Cloudflare/R2/index.ts

@@ -1,9 +1,2 @@
-export * from "./Bucket.ts";
-export * from "./CreateMultipartUpload.ts";
-export * from "./DeleteObject.ts";
-export * from "./GetObject.ts";
-export * from "./HeadObject.ts";
-export * from "./ListObjects.ts";
-export * from "./MultipartUploadClient.ts";
-export * from "./PutObject.ts";
-export * from "./ResumeMultipartUpload.ts";
+export * from "./R2Bucket.ts";
+export * from "./R2BucketBinding.ts";

package/src/Cloudflare/Workers/InferEnv.ts

@@ -0,0 +1,23 @@
+/// <reference types="@cloudflare/workers-types" />
+// import type * as cf from "@cloudflare/workers-types";
+
+import type * as Effect from "effect/Effect";
+import type { UnwrapEffect } from "../../Util/effect.ts";
+import type * as Cloudflare from "../index.ts";
+import type { Worker } from "./Worker.ts";
+
+export type InferEnv<W> = W extends
+  | Worker<infer Bindings>
+  | Effect.Effect<Worker<infer Bindings>, any, any>
+  ? {
+      [K in keyof Bindings]: GetBindingType<UnwrapEffect<Bindings[K]>>;
+    }
+  : never;
+
+type GetBindingType<T> = T extends Cloudflare.D1Database
+  ? D1Database
+  : T extends Cloudflare.R2Bucket
+    ? R2Bucket
+    : T extends Cloudflare.KVNamespace
+      ? KVNamespace
+      : never;