alchemy-effect 0.1.0 → 0.2.0

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

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

@@ -0,0 +1,249 @@
+import { FileSystem, Path } from "@effect/platform";
+import type { PlatformError } from "@effect/platform/Error";
+import { Context, Data, Layer } from "effect";
+import * as Effect from "effect/Effect";
+import type { ScopedPlanStatusSession } from "../../apply.ts";
+import { sha256 } from "../../sha256.ts";
+import { CloudflareApi, CloudflareApiError } from "../api.ts";
+import type { Worker } from "./worker.ts";
+
+const MAX_ASSET_SIZE = 1024 * 1024 * 25; // 25MB
+const MAX_ASSET_COUNT = 20_000;
+
+export declare namespace Assets {
+  export interface ReadResult {
+    directory: string;
+    config: Worker.AssetsConfig | undefined;
+    manifest: Record<string, { hash: string; size: number }>;
+    _headers: string | undefined;
+    _redirects: string | undefined;
+  }
+}
+
+export class Assets extends Context.Tag("Assets")<
+  Assets,
+  {
+    read(
+      directory: Worker.AssetsProps,
+    ): Effect.Effect<Assets.ReadResult, PlatformError | ValidationError>;
+    upload(
+      accountId: string,
+      workerName: string,
+      assets: Assets.ReadResult,
+      session: ScopedPlanStatusSession,
+    ): Effect.Effect<
+      { jwt: string | undefined },
+      PlatformError | ValidationError | CloudflareApiError
+    >;
+  }
+>() {}
+
+export class AssetTooLargeError extends Data.TaggedError("AssetTooLargeError")<{
+  message: string;
+  name: string;
+  size: number;
+}> {}
+
+export class TooManyAssetsError extends Data.TaggedError("TooManyAssetsError")<{
+  message: string;
+  directory: string;
+  count: number;
+}> {}
+
+export class AssetNotFoundError extends Data.TaggedError("AssetNotFoundError")<{
+  message: string;
+  hash: string;
+}> {}
+
+export class FailedToReadAssetError extends Data.TaggedError(
+  "FailedToReadAssetError",
+)<{
+  message: string;
+  name: string;
+  cause: PlatformError;
+}> {}
+
+export type ValidationError =
+  | AssetTooLargeError
+  | TooManyAssetsError
+  | AssetNotFoundError
+  | FailedToReadAssetError;
+
+export const assetsProvider = () =>
+  Layer.effect(
+    Assets,
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const api = yield* CloudflareApi;
+
+      const maybeReadString = Effect.fnUntraced(function* (file: string) {
+        return yield* fs.readFileString(file).pipe(
+          Effect.catchIf(
+            (error) =>
+              error._tag === "SystemError" && error.reason === "NotFound",
+            () => Effect.succeed(undefined),
+          ),
+        );
+      });
+
+      const createIgnoreMatcher = Effect.fnUntraced(function* (
+        patterns: string[],
+      ) {
+        const matcher = yield* Effect.promise(() =>
+          import("ignore").then(({ default: ignore }) =>
+            ignore().add(patterns),
+          ),
+        );
+        return (file: string) => matcher.ignores(file);
+      });
+
+      return {
+        read: Effect.fnUntraced(function* (props: Worker.AssetsProps) {
+          const resolvedDirectory = path.resolve(props.directory);
+          const [files, ignore, _headers, _redirects] = yield* Effect.all([
+            fs.readDirectory(resolvedDirectory, { recursive: true }),
+            maybeReadString(path.join(resolvedDirectory, ".assetsignore")),
+            maybeReadString(path.join(resolvedDirectory, "_headers")),
+            maybeReadString(path.join(resolvedDirectory, "_redirects")),
+          ]);
+          const ignores = yield* createIgnoreMatcher([
+            ".assetsignore",
+            "_headers",
+            "_redirects",
+            ...(ignore
+              ?.split("\n")
+              .map((line) => line.trim())
+              .filter((line) => line.length > 0 && !line.startsWith("#")) ??
+              []),
+          ]);
+          const manifest = new Map<string, { hash: string; size: number }>();
+          let count = 0;
+          yield* Effect.forEach(
+            files,
+            Effect.fnUntraced(function* (name) {
+              if (ignores(name)) {
+                return;
+              }
+              const file = path.join(resolvedDirectory, name);
+              const stat = yield* fs.stat(file);
+              if (stat.type !== "File") {
+                return;
+              }
+              const size = Number(stat.size);
+              if (size > MAX_ASSET_SIZE) {
+                return yield* new AssetTooLargeError({
+                  message: `Asset ${name} is too large (the maximum size is ${MAX_ASSET_SIZE / 1024 / 1024} MB; this asset is ${size / 1024 / 1024} MB)`,
+                  name,
+                  size,
+                });
+              }
+              const hash = yield* fs.readFile(file).pipe(
+                Effect.flatMap(sha256),
+                Effect.map((hash) => hash.slice(0, 32)),
+              );
+              count++;
+              if (count > MAX_ASSET_COUNT) {
+                return yield* new TooManyAssetsError({
+                  message: `Too many assets (the maximum count is ${MAX_ASSET_COUNT}; this directory has ${count} assets)`,
+                  directory: props.directory,
+                  count,
+                });
+              }
+              manifest.set(name.startsWith("/") ? name : `/${name}`, {
+                hash,
+                size,
+              });
+            }),
+          );
+          return {
+            directory: props.directory,
+            config: props.config,
+            manifest: Object.fromEntries(
+              Array.from(manifest.entries()).sort((a, b) =>
+                a[0].localeCompare(b[0]),
+              ),
+            ),
+            _headers,
+            _redirects,
+          };
+        }),
+        upload: Effect.fnUntraced(function* (
+          accountId: string,
+          workerName: string,
+          assets: Assets.ReadResult,
+          { note }: ScopedPlanStatusSession,
+        ) {
+          yield* note("Checking assets...");
+          const session = yield* api.workers.scripts.assets.upload.create(
+            workerName,
+            {
+              account_id: accountId,
+              manifest: assets.manifest,
+            },
+          );
+          if (!session.buckets?.length) {
+            return { jwt: session.jwt };
+          }
+          let uploaded = 0;
+          const total = session.buckets.flat().length;
+          yield* note(`Uploaded ${uploaded} of ${total} assets...`);
+          const assetsByHash = new Map<string, string>();
+          for (const [name, { hash }] of Object.entries(assets.manifest)) {
+            assetsByHash.set(hash, name);
+          }
+          let jwt: string | undefined;
+          const directory = path.resolve(assets.directory);
+          yield* Effect.forEach(
+            session.buckets,
+            Effect.fnUntraced(function* (bucket) {
+              const body: Record<string, string> = {};
+              yield* Effect.forEach(
+                bucket,
+                Effect.fnUntraced(function* (hash) {
+                  const name = assetsByHash.get(hash);
+                  if (!name) {
+                    return yield* new AssetNotFoundError({
+                      message: `Asset ${hash} not found in manifest`,
+                      hash,
+                    });
+                  }
+                  const file = yield* fs
+                    .readFile(path.join(directory, name))
+                    .pipe(
+                      Effect.mapError(
+                        (error) =>
+                          new FailedToReadAssetError({
+                            message: `Failed to read asset ${name}: ${error.message}`,
+                            name,
+                            cause: error,
+                          }),
+                      ),
+                    );
+                  body[hash] = Buffer.from(file).toString("base64");
+                }),
+              );
+              const result = yield* api.workers.assets.upload.create(
+                {
+                  account_id: accountId,
+                  base64: true,
+                  body,
+                },
+                {
+                  headers: {
+                    Authorization: `Bearer ${session.jwt}`,
+                  },
+                },
+              );
+              uploaded += bucket.length;
+              yield* note(`Uploaded ${uploaded} of ${total} assets...`);
+              if (result.jwt) {
+                jwt = result.jwt;
+              }
+            }),
+          );
+          return { jwt };
+        }),
+      };
+    }),
+  );

package/src/cloudflare/worker/index.ts

@@ -0,0 +1,6 @@
+export * from "./assets.fetch.ts";
+export * from "./worker.handler.ts";
+export * from "./worker.serve.ts";
+export * from "./worker.ts";
+
+export type * as Alchemy from "../../index.ts";

package/src/cloudflare/worker/worker.handler.ts

@@ -0,0 +1,39 @@
+import type * as runtime from "@cloudflare/workers-types";
+import type { Capability } from "alchemy-effect";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { CloudflareContext } from "../context.ts";
+
+type Handler = (
+  request: Request,
+  env: unknown,
+  ctx: runtime.ExecutionContext,
+) => Effect.Effect<Response, any, CloudflareContext>;
+type HandlerFactory<H extends Handler, Req = Capability> = Effect.Effect<
+  H,
+  any,
+  Req
+>;
+
+export const toHandler = <H extends Handler>(
+  factory: HandlerFactory<H, Capability>,
+) => {
+  return {
+    fetch: async (
+      request: Request,
+      env: unknown,
+      ctx: runtime.ExecutionContext,
+    ) => {
+      const exit = await Effect.runPromiseExit(
+        (factory as HandlerFactory<H, never>).pipe(
+          Effect.flatMap((handler) => handler(request, env, ctx)),
+          Effect.provide(Layer.succeed(CloudflareContext, { env, ctx })),
+        ),
+      );
+      if (exit._tag === "Success") {
+        return exit.value;
+      }
+      return Response.json(exit, { status: 500 });
+    },
+  };
+};