alchemy-effect 0.1.0 → 0.2.0

package/src/cloudflare/api.ts

@@ -1,72 +1,152 @@
-import * as cf from "cloudflare";
+import { APIConnectionError, Cloudflare, type APIError } from "cloudflare";
+import {
+  isRequestOptions,
+  type APIPromise,
+  type RequestOptions,
+} from "cloudflare/core";
+import type { ErrorData } from "cloudflare/resources";
+import { Layer } from "effect";
 import * as Context from "effect/Context";
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
 
-export class CloudflareApi extends Context.Tag("CloudflareApi")<
-  CloudflareApi,
-  cf.Cloudflare
->() {}
-
-export class CloudflareAccountId extends Context.Tag("CloudflareAccountId")<
+export class CloudflareAccountId extends Context.Tag("cloudflare/account-id")<
   CloudflareAccountId,
   string
->() {}
+>() {
+  static readonly fromEnv = Layer.effect(
+    CloudflareAccountId,
+    Effect.gen(function* () {
+      const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+      if (!accountId) {
+        return yield* Effect.die("CLOUDFLARE_ACCOUNT_ID is not set");
+      }
+      return accountId;
+    }),
+  );
+}
 
-export class CloudflareEmail extends Context.Tag("CloudflareEmail")<
-  CloudflareEmail,
-  string
->() {}
+export class CloudflareApi extends Effect.Service<CloudflareApi>()(
+  "cloudflare/api",
+  {
+    effect: (options?: {
+      baseUrl?: string;
+      apiToken?: string;
+      apiKey?: string;
+      apiEmail?: string;
+    }) =>
+      Effect.succeed(
+        createRecursiveProxy(
+          new Cloudflare({
+            baseURL: options?.baseUrl ?? import.meta.env.CLOUDFLARE_BASE_URL,
+            apiToken: options?.apiToken ?? import.meta.env.CLOUDFLARE_API_TOKEN,
+            apiKey: options?.apiKey ?? import.meta.env.CLOUDFLARE_API_KEY,
+            apiEmail: options?.apiEmail ?? import.meta.env.CLOUDFLARE_API_EMAIL,
+          }),
+        ),
+      ),
+  },
+) {}
 
-export class CloudflareApiKey extends Context.Tag("CloudflareApiKey")<
-  CloudflareApiKey,
-  string
->() {}
+export class CloudflareApiError extends Data.Error<{
+  _tag:
+    | "Connection"
+    | "BadRequest"
+    | "Authentication"
+    | "PermissionDenied"
+    | "NotFound"
+    | "Conflict"
+    | "UnprocessableEntity"
+    | "RateLimit"
+    | "InternalServerError"
+    | "Unknown";
+  message: string;
+  errors: ErrorData[];
+  cause: APIError;
+}> {
+  static from(cause: APIError): CloudflareApiError {
+    const error = new CloudflareApiError({
+      _tag: CloudflareApiError.getTag(cause),
+      message: cause.message,
+      errors: cause.errors,
+      cause: cause,
+    });
+    return error;
+  }
 
-export class CloudflareApiToken extends Context.Tag("CloudflareApiToken")<
-  CloudflareApiToken,
-  string
->() {}
+  private static getTag(error: APIError): CloudflareApiError["_tag"] {
+    if (error instanceof APIConnectionError) {
+      return "Connection";
+    }
+    switch (error.status) {
+      case 400:
+        return "BadRequest";
+      case 401:
+        return "Authentication";
+      case 403:
+        return "PermissionDenied";
+      case 404:
+        return "NotFound";
+      case 409:
+        return "Conflict";
+      case 422:
+        return "UnprocessableEntity";
+      case 429:
+        return "RateLimit";
+      case 500:
+        return "InternalServerError";
+      default:
+        return "Unknown";
+    }
+  }
+}
 
-export class CloudflareBaseUrl extends Context.Tag("CloudflareBaseUrl")<
-  CloudflareBaseUrl,
-  string
->() {}
+type ToEffect<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any
+    ? (
+        ...args: Parameters<T[K]>
+      ) => Effect.Effect<UnwrapAPIPromise<ReturnType<T[K]>>, CloudflareApiError>
+    : T[K] extends Record<string, any>
+      ? ToEffect<T[K]>
+      : T[K];
+};
 
-const tryGet = <Tag extends Context.Tag<any, any>>(
-  tag: Tag,
-  defaultValue: Tag["Service"] | undefined,
-) =>
-  Effect.gen(function* () {
-    const value = yield* Effect.serviceOption(tag);
-    return Option.getOrElse(value, () => defaultValue);
-  });
+type UnwrapAPIPromise<T> = T extends APIPromise<infer U> ? U : never;
 
-export const cloudflareApi = Layer.effect(
-  CloudflareApi,
-  Effect.gen(function* () {
-    const email = yield* tryGet(
-      CloudflareEmail,
-      import.meta.env.CLOUDFLARE_EMAIL,
-    );
-    const apiKey = yield* tryGet(
-      CloudflareApiKey,
-      import.meta.env.CLOUDFLARE_API_KEY,
-    );
-    const apiToken = yield* tryGet(
-      CloudflareApiToken,
-      import.meta.env.CLOUDFLARE_API_TOKEN,
-    );
-    const baseURL = yield* tryGet(
-      CloudflareBaseUrl,
-      import.meta.env.CLOUDFLARE_BASE_URL,
-    );
-    return new cf.Cloudflare({
-      apiEmail: email,
-      apiKey: apiKey,
-      apiToken: apiToken,
-      baseURL: baseURL,
-    });
-  }),
-);
+const createRecursiveProxy = <T extends object>(target: T): ToEffect<T> => {
+  return new Proxy(target as any, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return Effect.fnUntraced(function* (...args: any[]) {
+          return yield* Effect.tryPromise({
+            try: async (signal) => {
+              let modifiedArgs: any[];
+              if (isRequestOptions(args[args.length - 1])) {
+                const options = args[args.length - 1] as RequestOptions;
+                modifiedArgs = [
+                  ...args.slice(0, -1),
+                  {
+                    ...options,
+                    signal: options?.signal
+                      ? AbortSignal.any([signal, options.signal])
+                      : signal,
+                  },
+                ];
+              } else {
+                modifiedArgs = [...args, { signal }];
+              }
+              const result = await value.apply(target, modifiedArgs);
+              return result;
+            },
+            catch: (cause) => {
+              const error = CloudflareApiError.from(cause as APIError);
+              return error;
+            },
+          });
+        });
+      }
+      return createRecursiveProxy(value);
+    },
+  });
+};

package/src/cloudflare/context.ts

@@ -0,0 +1,49 @@
+import type { ExecutionContext } from "@cloudflare/workers-types";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+
+export class CloudflareContext extends Context.Tag("Cloudflare.Context")<
+  CloudflareContext,
+  {
+    env: unknown;
+    ctx: ExecutionContext;
+  }
+>() {}
+
+export const getCloudflareEnvKey = Effect.fnUntraced(function* <T>(
+  key: string,
+) {
+  return yield* Effect.serviceOptional(CloudflareContext).pipe(
+    Effect.mapError(
+      () =>
+        new CloudflareContextNotFound({
+          message: "Cloudflare context not found",
+        }),
+    ),
+    Effect.flatMap((context) => {
+      const env = context.env as Record<string, unknown>;
+      if (!(key in env)) {
+        return new CloudflareContextKeyNotFound({
+          message: `${key} is not set in cloudflare context (found ${Object.keys(env).join(", ")})`,
+          key,
+        });
+      }
+      return Effect.succeed(env[key] as T);
+    }),
+    Effect.orDie,
+  );
+});
+
+export class CloudflareContextNotFound extends Data.TaggedError(
+  "Cloudflare.Context.NotFound",
+)<{
+  message: string;
+}> {}
+
+export class CloudflareContextKeyNotFound extends Data.TaggedError(
+  "Cloudflare.Context.KeyNotFound",
+)<{
+  message: string;
+  key: string;
+}> {}

package/src/cloudflare/index.ts

@@ -1,4 +1,6 @@
-export * from "./api.ts";
-export * from "./kv.provider.ts";
-export * from "./kv.ts";
-export * from "./worker.ts";
+export * as KV from "./kv/index.ts";
+export * as R2 from "./r2/index.ts";
+export * as Assets from "./worker/assets.fetch.ts";
+export * as Worker from "./worker/index.ts";
+
+export type * as Alchemy from "../index.ts";

package/src/cloudflare/kv/index.ts

@@ -0,0 +1,3 @@
+export * from "./namespace.binding.ts";
+export * from "./namespace.client.ts";
+export * from "./namespace.ts";

package/src/cloudflare/kv/namespace.binding.ts

@@ -0,0 +1,25 @@
+import { Binding, type Capability, type To } from "alchemy-effect";
+import { Worker } from "../worker/worker.ts";
+import type { Namespace, NamespaceProps } from "./namespace.ts";
+
+export interface Bind<B = Namespace<string, NamespaceProps>>
+  extends Capability<"Cloudflare.KV.Namespace.Bind", B> {}
+
+export const Bind = Binding<
+  <B extends Namespace<string, NamespaceProps>>(
+    namespace: B,
+  ) => Binding<Worker, Bind<To<B>>>
+>(Worker, "Cloudflare.KV.Namespace.Bind");
+
+export const bindFromWorker = () =>
+  Bind.provider.succeed({
+    attach: ({ source }) => ({
+      bindings: [
+        {
+          type: "kv_namespace",
+          name: source.id,
+          namespace_id: source.attr.namespaceId,
+        },
+      ],
+    }),
+  });

package/src/cloudflare/kv/namespace.client.ts

@@ -0,0 +1,70 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { declare, type To } from "../../policy.ts";
+import { getCloudflareEnvKey } from "../context.ts";
+import { replaceEffectStream } from "../stream.ts";
+import { Bind } from "./namespace.binding.ts";
+import type * as KV from "./namespace.ts";
+
+export const get = Effect.fnUntraced(function* <KV extends KV.Namespace>(
+  namespace: KV,
+  key: string,
+) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() => client.get(key));
+});
+
+export const getWithMetadata = Effect.fnUntraced(function* <
+  KV extends KV.Namespace,
+  Metadata = unknown,
+>(
+  namespace: KV,
+  key: string,
+  options?: runtime.KVNamespaceGetOptions<undefined>,
+) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() =>
+    client.getWithMetadata<Metadata>(key, options),
+  );
+});
+
+export const put = Effect.fnUntraced(function* <KV extends KV.Namespace>(
+  namespace: KV,
+  key: string,
+  value:
+    | string
+    | ArrayBuffer
+    | ArrayBufferView
+    | runtime.ReadableStream
+    | Stream.Stream<any>,
+  options?: runtime.KVNamespacePutOptions,
+) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() =>
+    client.put(key, replaceEffectStream(value), options),
+  );
+});
+
+export const del = Effect.fnUntraced(function* <KV extends KV.Namespace>(
+  namespace: KV,
+  key: string,
+) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() => client.delete(key));
+});
+
+export const list = Effect.fnUntraced(function* <
+  KV extends KV.Namespace,
+  Metadata = unknown,
+>(namespace: KV, options?: runtime.KVNamespaceListOptions) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() => client.list<Metadata>(options));
+});
+
+const getKvNamespaceFromEnv = Effect.fnUntraced(function* <
+  KV extends KV.Namespace,
+>(namespace: KV) {
+  yield* declare<Bind<To<KV>>>();
+  return yield* getCloudflareEnvKey<runtime.KVNamespace>(namespace.id);
+});

package/src/cloudflare/kv/namespace.provider.ts

@@ -0,0 +1,99 @@
+import type { KV } from "cloudflare/resources";
+import * as Effect from "effect/Effect";
+import { App } from "../../app.ts";
+import { CloudflareAccountId, CloudflareApi } from "../api.ts";
+import {
+  Namespace,
+  type NamespaceAttr,
+  type NamespaceProps,
+} from "./namespace.ts";
+
+export const namespaceProvider = () =>
+  Namespace.provider.effect(
+    Effect.gen(function* () {
+      const app = yield* App;
+      const api = yield* CloudflareApi;
+      const accountId = yield* CloudflareAccountId;
+
+      const createTitle = (id: string, news: NamespaceProps) =>
+        news.title ?? `${app.name}-${id}-${app.stage}`;
+
+      const mapResult = <Props extends NamespaceProps>(
+        result: KV.Namespace,
+      ): NamespaceAttr<Props> => ({
+        title: result.title,
+        namespaceId: result.id,
+        supportsUrlEncoding: result.supports_url_encoding,
+        accountId,
+      });
+
+      return {
+        diff: ({ id, news, output }) =>
+          Effect.sync(() => {
+            if (output.accountId !== accountId) {
+              return { action: "replace" };
+            }
+            const title = createTitle(id, news);
+            if (title !== output.title) {
+              return { action: "update" };
+            }
+          }),
+        create: Effect.fn(function* ({ id, news }) {
+          return yield* api.kv.namespaces
+            .create({
+              account_id: accountId,
+              title: createTitle(id, news),
+            })
+            .pipe(Effect.map(mapResult<NamespaceProps>));
+        }),
+        update: Effect.fn(function* ({ id, news, output }) {
+          return yield* api.kv.namespaces
+            .update(output.namespaceId, {
+              account_id: accountId,
+              title: createTitle(id, news),
+            })
+            .pipe(Effect.map(mapResult<NamespaceProps>));
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* api.kv.namespaces
+            .delete(output.namespaceId, {
+              account_id: output.accountId,
+            })
+            .pipe(Effect.catchTag("NotFound", () => Effect.void));
+        }),
+        read: Effect.fn(function* ({ id, olds, output }) {
+          if (output?.namespaceId) {
+            return yield* api.kv.namespaces
+              .get(output.namespaceId, {
+                account_id: output.accountId,
+              })
+              .pipe(
+                Effect.map(mapResult<NamespaceProps>),
+                Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+              );
+          }
+          const title = createTitle(id, olds ?? {}); // why is olds optional?
+          let page = 1;
+          while (true) {
+            // todo: abstract pagination
+            const namespaces = yield* api.kv.namespaces.list({
+              account_id: accountId,
+              page,
+              per_page: 100,
+            });
+            const match = namespaces.result.find(
+              (namespace) => namespace.title === title,
+            );
+            if (match) {
+              return mapResult<NamespaceProps>(match);
+            }
+            if (namespaces.nextPageInfo()) {
+              page++;
+            } else {
+              return undefined;
+            }
+          }
+        }),
+      };
+    }),
+  );

package/src/cloudflare/kv/namespace.ts

@@ -0,0 +1,29 @@
+import { Resource } from "../../resource.ts";
+
+export type NamespaceProps = {
+  title?: string;
+};
+
+export type NamespaceAttr<Props extends NamespaceProps> = {
+  title: Props["title"] extends string ? Props["title"] : string;
+  namespaceId: string;
+  supportsUrlEncoding?: boolean;
+  accountId: string;
+};
+
+export interface Namespace<
+  ID extends string = string,
+  Props extends NamespaceProps = NamespaceProps,
+> extends Resource<
+    "Cloudflare.KV.Namespace",
+    ID,
+    Props,
+    NamespaceAttr<Props>
+  > {}
+
+export const Namespace = Resource<{
+  <const ID extends string, const Props extends NamespaceProps>(
+    id: ID,
+    props: Props,
+  ): Namespace<ID, Props>;
+}>("Cloudflare.KV.Namespace");

package/src/cloudflare/live.ts

@@ -0,0 +1,38 @@
+import * as Layer from "effect/Layer";
+import * as ESBuild from "../esbuild.ts";
+import { CloudflareAccountId, CloudflareApi } from "./api.ts";
+import * as KV from "./kv/index.ts";
+import { namespaceProvider } from "./kv/namespace.provider.ts";
+import { bucketProvider } from "./r2/bucket.provider.ts";
+import * as R2 from "./r2/index.ts";
+import { assetsProvider } from "./worker/assets.provider.ts";
+import { workerProvider } from "./worker/worker.provider.ts";
+
+export const providers = () =>
+  Layer.mergeAll(
+    Layer.provideMerge(
+      workerProvider(),
+      Layer.mergeAll(ESBuild.layer(), assetsProvider()),
+    ),
+    namespaceProvider(),
+    bucketProvider(),
+  );
+
+export const bindings = () =>
+  Layer.mergeAll(KV.bindFromWorker(), R2.bindFromWorker());
+
+export const defaultProviders = () =>
+  providers().pipe(Layer.provideMerge(bindings()));
+
+export const live = () =>
+  defaultProviders().pipe(
+    Layer.provideMerge(
+      Layer.mergeAll(CloudflareAccountId.fromEnv, CloudflareApi.Default()),
+    ),
+  );
+
+export default live;
+
+// Layer.mergeAll
+// Layer.provide
+// Layer.provideMerge

package/src/cloudflare/r2/bucket.binding.ts

@@ -0,0 +1,27 @@
+import { Binding, type Capability, type To } from "alchemy-effect";
+import { Worker } from "../worker/worker.ts";
+import type { Bucket } from "./bucket.ts";
+
+export interface Bind<B = Bucket>
+  extends Capability<"Cloudflare.R2.Bucket.Bind", B> {}
+
+export const Bind = Binding<
+  <B extends Bucket>(bucket: B) => Binding<Worker, Bind<To<B>>>
+>(Worker, "Cloudflare.R2.Bucket.Bind");
+
+export const bindFromWorker = () =>
+  Bind.provider.succeed({
+    attach: ({ source }) => ({
+      bindings: [
+        {
+          type: "r2_bucket",
+          name: source.id,
+          bucket_name: source.attr.name,
+          jurisdiction:
+            source.attr.jurisdiction === "default"
+              ? undefined
+              : source.attr.jurisdiction,
+        },
+      ],
+    }),
+  });

package/src/cloudflare/r2/bucket.client.ts

@@ -0,0 +1,22 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import type * as Stream from "effect/Stream";
+import { declare, type To } from "../../policy.ts";
+import { getCloudflareEnvKey } from "../context.ts";
+import { Bind } from "./bucket.binding.ts";
+import type { Bucket } from "./bucket.ts";
+
+export const getR2BucketFromEnv = Effect.fnUntraced(function* <
+  B extends Bucket,
+>(bucket: B) {
+  yield* declare<Bind<To<B>>>();
+  return yield* getCloudflareEnvKey<runtime.R2Bucket>(bucket.id);
+});
+
+export type UploadValue =
+  | string
+  | ArrayBuffer
+  | ArrayBufferView
+  | runtime.Blob
+  | runtime.ReadableStream
+  | Stream.Stream<any>;

package/src/cloudflare/r2/bucket.del.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import { getR2BucketFromEnv } from "./bucket.client.ts";
+import type { Bucket } from "./bucket.ts";
+
+export const del = Effect.fnUntraced(function* <B extends Bucket>(
+  bucket: B,
+  keys: string | string[],
+) {
+  const client = yield* getR2BucketFromEnv(bucket);
+  return yield* Effect.promise(() => client.delete(keys));
+});

package/src/cloudflare/r2/bucket.get.ts

@@ -0,0 +1,13 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import { getR2BucketFromEnv } from "./bucket.client.ts";
+import type { Bucket } from "./bucket.ts";
+
+export const get = Effect.fnUntraced(function* <B extends Bucket>(
+  bucket: B,
+  key: string,
+  options?: runtime.R2GetOptions,
+) {
+  const client = yield* getR2BucketFromEnv(bucket);
+  return yield* Effect.promise(() => client.get(key, options));
+});

package/src/cloudflare/r2/bucket.head.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import { getR2BucketFromEnv } from "./bucket.client.ts";
+import type { Bucket } from "./bucket.ts";
+
+export const head = Effect.fnUntraced(function* <B extends Bucket>(
+  bucket: B,
+  key: string,
+) {
+  const client = yield* getR2BucketFromEnv(bucket);
+  return yield* Effect.promise(() => client.head(key));
+});

package/src/cloudflare/r2/bucket.list.ts

@@ -0,0 +1,12 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import { getR2BucketFromEnv } from "./bucket.client.ts";
+import type { Bucket } from "./bucket.ts";
+
+export const list = Effect.fnUntraced(function* <B extends Bucket>(
+  bucket: B,
+  options?: runtime.R2ListOptions,
+) {
+  const client = yield* getR2BucketFromEnv(bucket);
+  return yield* Effect.promise(() => client.list(options));
+});