alchemy-effect 0.0.0 → 0.2.0

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));
+});

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

@@ -0,0 +1,55 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import { replaceEffectStream } from "../stream.ts";
+import { getR2BucketFromEnv, type UploadValue } from "./bucket.client.ts";
+import type { Bucket } from "./bucket.ts";
+
+export const createMultipartUpload = Effect.fnUntraced(function* <
+  R2Bucket extends Bucket,
+>(bucket: R2Bucket, key: string, options?: runtime.R2MultipartOptions) {
+  const client = yield* getR2BucketFromEnv(bucket);
+  return yield* Effect.promise(async () =>
+    makeMultipartUploadEffectClient(
+      await client.createMultipartUpload(key, options),
+    ),
+  );
+});
+
+export const resumeMultipartUpload = Effect.fnUntraced(function* <
+  R2Bucket extends Bucket,
+>(bucket: R2Bucket, key: string, uploadId: string) {
+  const client = yield* getR2BucketFromEnv(bucket);
+  return yield* Effect.sync(() =>
+    makeMultipartUploadEffectClient(
+      client.resumeMultipartUpload(key, uploadId),
+    ),
+  );
+});
+
+const makeMultipartUploadEffectClient = (
+  multipartUpload: runtime.R2MultipartUpload,
+) => ({
+  key: multipartUpload.key,
+  uploadId: multipartUpload.uploadId,
+  uploadPart: Effect.fnUntraced(function* (
+    partNumber: number,
+    value: UploadValue,
+    options?: runtime.R2UploadPartOptions,
+  ) {
+    return yield* Effect.promise(() =>
+      multipartUpload.uploadPart(
+        partNumber,
+        replaceEffectStream(value),
+        options,
+      ),
+    );
+  }),
+  abort: Effect.fnUntraced(function* () {
+    return yield* Effect.promise(() => multipartUpload.abort());
+  }),
+  complete: Effect.fnUntraced(function* (
+    uploadedParts: runtime.R2UploadedPart[],
+  ) {
+    return yield* Effect.promise(() => multipartUpload.complete(uploadedParts));
+  }),
+});

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

@@ -0,0 +1,83 @@
+import type { R2 } from "cloudflare/resources";
+import * as Effect from "effect/Effect";
+import { App } from "../../app";
+import { CloudflareAccountId, CloudflareApi } from "../api";
+import { Bucket, type BucketAttr, type BucketProps } from "./bucket";
+
+export const bucketProvider = () =>
+  Bucket.provider.effect(
+    Effect.gen(function* () {
+      const api = yield* CloudflareApi;
+      const accountId = yield* CloudflareAccountId;
+      const app = yield* App;
+
+      const createName = (id: string, props: BucketProps) =>
+        props.name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
+
+      const mapResult = <Props extends BucketProps>(
+        bucket: R2.Bucket,
+      ): BucketAttr<Props> =>
+        ({
+          name: bucket.name,
+          storageClass: bucket.storage_class ?? "Standard",
+          jurisdiction: bucket.jurisdiction ?? "default",
+          location: bucket.location,
+          accountId,
+        }) as BucketAttr<Props>;
+
+      return {
+        diff: ({ id, olds, news, output }) =>
+          Effect.sync(() => {
+            if (
+              output.accountId !== accountId ||
+              output.name !== createName(id, news) ||
+              output.jurisdiction !== (news.jurisdiction ?? "default") ||
+              olds.locationHint !== news.locationHint
+            ) {
+              return { action: "replace" };
+            }
+            if (output.storageClass !== (news.storageClass ?? "Standard")) {
+              return { action: "update" };
+            }
+            return { action: "noop" };
+          }),
+        create: Effect.fnUntraced(function* ({ id, news }) {
+          const bucket = yield* api.r2.buckets.create({
+            account_id: accountId,
+            name: createName(id, news),
+            storageClass: news.storageClass,
+            jurisdiction: news.jurisdiction,
+            locationHint: news.locationHint,
+          });
+          return mapResult<BucketProps>(bucket);
+        }),
+        update: Effect.fnUntraced(function* ({ id, news, output }) {
+          const bucket = yield* api.r2.buckets.edit(output.name, {
+            account_id: output.accountId,
+            storage_class: news.storageClass ?? output.storageClass,
+            jurisdiction: output.jurisdiction,
+          });
+          return mapResult<BucketProps>(bucket);
+        }),
+        delete: Effect.fnUntraced(function* ({ output }) {
+          yield* api.r2.buckets
+            .delete(output.name, {
+              account_id: output.accountId,
+            })
+            .pipe(Effect.catchTag("NotFound", () => Effect.void));
+        }),
+        read: Effect.fnUntraced(function* ({ id, output, olds }) {
+          const params = {
+            account_id: output?.accountId ?? accountId,
+            name: output?.name ?? createName(id, olds ?? {}),
+          };
+          return yield* api.r2.buckets
+            .get(params.name, { account_id: params.account_id })
+            .pipe(
+              Effect.map(mapResult<BucketProps>),
+              Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+            );
+        }),
+      };
+    }),
+  );

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

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

package/src/cloudflare/r2/bucket.ts

@@ -0,0 +1,38 @@
+import { Resource } from "../../resource.ts";
+
+export type BucketProps = {
+  name?: string;
+  storageClass?: Bucket.StorageClass;
+  jurisdiction?: Bucket.Jurisdiction;
+  locationHint?: Bucket.Location;
+};
+
+export type BucketAttr<Props extends BucketProps> = {
+  name: Props["name"] extends string ? Props["name"] : string;
+  storageClass: Props["storageClass"] extends Bucket.StorageClass
+    ? Props["storageClass"]
+    : "Standard";
+  jurisdiction: Props["jurisdiction"] extends Bucket.Jurisdiction
+    ? Props["jurisdiction"]
+    : "default";
+  location: Bucket.Location | undefined;
+  accountId: string;
+};
+
+export interface Bucket<
+  ID extends string = string,
+  Props extends BucketProps = BucketProps,
+> extends Resource<"Cloudflare.R2.Bucket", ID, Props, BucketAttr<Props>> {}
+
+export const Bucket = Resource<{
+  <const ID extends string, const Props extends BucketProps>(
+    id: ID,
+    props: Props,
+  ): Bucket<ID, Props>;
+}>("Cloudflare.R2.Bucket");
+
+export declare namespace Bucket {
+  export type StorageClass = "Standard" | "InfrequentAccess";
+  export type Jurisdiction = "default" | "eu" | "fedramp";
+  export type Location = "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc";
+}

package/src/cloudflare/r2/index.ts

@@ -0,0 +1,9 @@
+export * from "./bucket.binding.ts";
+export * from "./bucket.client.ts";
+export * from "./bucket.del.ts";
+export * from "./bucket.get.ts";
+export * from "./bucket.head.ts";
+export * from "./bucket.list.ts";
+export * from "./bucket.multipart.ts";
+export * from "./bucket.put.ts";
+export * from "./bucket.ts";

package/src/cloudflare/stream.ts

@@ -0,0 +1,21 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Predicate from "effect/Predicate";
+import * as Stream from "effect/Stream";
+
+type ReplaceEffectStream<T> =
+  T extends Stream.Stream<any> ? runtime.ReadableStream<any> : T;
+
+/**
+ * If the value is an Effect stream, converts it to a ReadableStream.
+ * Otherwise, returns the value unchanged.
+ */
+export function replaceEffectStream<T>(value: T): ReplaceEffectStream<T> {
+  if (isEffectStream(value)) {
+    return Stream.toReadableStream(value) as ReplaceEffectStream<T>;
+  }
+  return value as ReplaceEffectStream<T>;
+}
+
+function isEffectStream(value: unknown): value is Stream.Stream<any> {
+  return Predicate.hasProperty(value, Stream.StreamTypeId);
+}

package/src/cloudflare/worker/assets.fetch.ts

@@ -0,0 +1,27 @@
+import type * as runtime from "@cloudflare/workers-types";
+import { Binding, declare, type Capability } from "alchemy-effect";
+import * as Effect from "effect/Effect";
+import { getCloudflareEnvKey } from "../context.ts";
+import { Worker } from "./worker.ts";
+
+export interface Fetch extends Capability<"Cloudflare.Assets.Fetch"> {}
+
+export const Fetch = Binding<() => Binding<Worker, Fetch>>(
+  Worker,
+  "Cloudflare.Assets.Fetch",
+);
+
+export const fetch = Effect.fnUntraced(function* (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) {
+  yield* declare<Fetch>();
+  const fetcher = yield* getCloudflareEnvKey<runtime.Fetcher>("ASSETS");
+  return yield* Effect.promise(
+    (): Promise<Response> =>
+      fetcher.fetch(
+        input as URL | runtime.RequestInfo,
+        init as runtime.RequestInit<runtime.CfProperties<unknown>>,
+      ) as any,
+  );
+});