alchemy-effect 0.1.0 → 0.3.0

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 "../../cli/service.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,4 @@
+export * from "./assets.fetch.ts";
+export * from "./worker.handler.ts";
+export * from "./worker.serve.ts";
+export * from "./worker.ts";

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

@@ -0,0 +1,39 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { Capability } from "../../capability.ts";
+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 });
+    },
+  };
+};

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

@@ -0,0 +1,249 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import type { Workers } from "cloudflare/resources.mjs";
+import * as Effect from "effect/Effect";
+import { App } from "../../app.ts";
+import type { ScopedPlanStatusSession } from "../../cli/service.ts";
+import { DotAlchemy } from "../../dot-alchemy.ts";
+import { ESBuild } from "../../esbuild.ts";
+import { sha256 } from "../../sha256.ts";
+import { CloudflareApi } from "../api.ts";
+import { Account } from "../account.ts";
+import { Assets } from "./assets.provider.ts";
+import { Worker, type WorkerAttr, type WorkerProps } from "./worker.ts";
+
+export const workerProvider = () =>
+  Worker.provider.effect(
+    Effect.gen(function* () {
+      const app = yield* App;
+      const api = yield* CloudflareApi;
+      const accountId = yield* Account;
+      const { read, upload } = yield* Assets;
+      const { build } = yield* ESBuild;
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const dotAlchemy = yield* DotAlchemy;
+
+      const getAccountSubdomain = yield* Effect.cachedFunction(
+        Effect.fnUntraced(function* (accountId: string) {
+          const { subdomain } = yield* api.workers.subdomains.get({
+            account_id: accountId,
+          });
+          return subdomain;
+        }),
+      );
+
+      // pre-fetch subdomain in background
+      yield* Effect.forkDaemon(getAccountSubdomain(accountId));
+
+      const setWorkerSubdomain = Effect.fnUntraced(function* (
+        name: string,
+        enabled: boolean,
+      ) {
+        const subdomain = yield* api.workers.scripts.subdomain.create(name, {
+          account_id: accountId,
+          enabled,
+        });
+        yield* Effect.logDebug("setWorkerSubdomain", subdomain);
+      });
+
+      const createWorkerName = (id: string, name: string | undefined) =>
+        name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
+
+      const prepareAssets = Effect.fnUntraced(function* (
+        assets: WorkerProps["assets"],
+      ) {
+        if (!assets) return undefined;
+        const result = yield* read(
+          typeof assets === "string" ? { directory: assets } : assets,
+        );
+        return {
+          ...result,
+          hash: yield* sha256(JSON.stringify(result)),
+        };
+      });
+
+      const prepareBundle = Effect.fnUntraced(function* (
+        id: string,
+        main: string,
+      ) {
+        const outfile = path.join(dotAlchemy, "out", `${id}.js`);
+        yield* build({
+          entryPoints: [path.relative(process.cwd(), main)],
+          outfile,
+          write: true,
+          bundle: true,
+          format: "esm",
+          sourcemap: false,
+          treeShaking: true,
+        });
+        const code = yield* fs.readFileString(outfile);
+        return {
+          code,
+          hash: yield* sha256(code),
+        };
+      });
+
+      const prepareMetadata = Effect.fnUntraced(function* (
+        props: WorkerProps<any>,
+      ) {
+        const metadata: Workers.ScriptUpdateParams.Metadata = {
+          assets: undefined,
+          bindings: [],
+          body_part: undefined,
+          compatibility_date: props.compatibility?.date,
+          compatibility_flags: props.compatibility?.flags,
+          keep_assets: undefined,
+          keep_bindings: undefined,
+          limits: props.limits,
+          logpush: props.logpush,
+          main_module: "worker.js",
+          migrations: undefined,
+          observability: props.observability ?? {
+            enabled: true,
+            logs: {
+              enabled: true,
+              invocation_logs: true,
+            },
+          },
+          placement: props.placement,
+          tags: props.tags,
+          tail_consumers: undefined,
+          usage_model: undefined,
+        };
+        return metadata;
+      });
+
+      const putWorker = Effect.fnUntraced(function* (
+        id: string,
+        news: WorkerProps<any>,
+        bindings: Worker["binding"][],
+        olds: WorkerProps<any> | undefined,
+        output: WorkerAttr<WorkerProps<any>> | undefined,
+        session: ScopedPlanStatusSession,
+      ) {
+        const name = createWorkerName(id, news.name);
+        const [assets, bundle, metadata] = yield* Effect.all([
+          prepareAssets(news.assets),
+          prepareBundle(id, news.main),
+          prepareMetadata(news),
+        ]).pipe(Effect.orDie);
+        metadata.bindings = bindings.flatMap((binding) => binding.bindings);
+        if (assets) {
+          if (output?.hash.assets !== assets.hash) {
+            const { jwt } = yield* upload(accountId, name, assets, session);
+            metadata.assets = {
+              jwt,
+              config: assets.config,
+            };
+          } else {
+            metadata.assets = {
+              config: assets.config,
+            };
+            metadata.keep_assets = true;
+          }
+          metadata.bindings.push({
+            type: "assets",
+            name: "ASSETS",
+          });
+        }
+        yield* session.note("Uploading worker...");
+        const worker = yield* api.workers.scripts.update(name, {
+          account_id: accountId,
+          metadata: metadata,
+          files: [
+            new File([bundle.code], "worker.js", {
+              type: "application/javascript+module",
+            }),
+          ],
+        });
+        if (!olds || news.subdomain?.enabled !== olds.subdomain?.enabled) {
+          const enable = news.subdomain?.enabled !== false;
+          yield* session.note(
+            `${enable ? "Enabling" : "Disabling"} workers.dev subdomain...`,
+          );
+          yield* setWorkerSubdomain(name, enable);
+        }
+        return {
+          id: worker.id,
+          name,
+          logpush: worker.logpush,
+          observability: metadata.observability,
+          subdomain: news.subdomain ?? {
+            enabled: true,
+            previews_enabled: true,
+          },
+          url:
+            news.subdomain?.enabled !== false
+              ? `https://${name}.${yield* getAccountSubdomain(accountId)}.workers.dev`
+              : undefined,
+          tags: metadata.tags,
+          accountId,
+          hash: {
+            assets: assets?.hash,
+            bundle: bundle.hash,
+          },
+        } as WorkerAttr<WorkerProps<any>>;
+      });
+
+      return {
+        diff: Effect.fnUntraced(function* ({ id, olds, news, output }) {
+          if (output.accountId !== accountId) {
+            return { action: "replace" };
+          }
+          const workerName = createWorkerName(id, news.name);
+          if (workerName !== output.name) {
+            return { action: "replace" };
+          }
+          const [assets, bundle] = yield* Effect.all([
+            prepareAssets(news.assets),
+            prepareBundle(id, news.main),
+          ]).pipe(Effect.orDie);
+          if (
+            assets?.hash !== output.hash.assets ||
+            bundle.hash !== output.hash.bundle
+          ) {
+            return { action: "update" };
+          }
+        }),
+        create: Effect.fnUntraced(function* ({ id, news, bindings, session }) {
+          const name = createWorkerName(id, news.name);
+          const existing = yield* api.workers.beta.workers
+            .get(name, {
+              account_id: accountId,
+            })
+            .pipe(Effect.catchTag("NotFound", () => Effect.void));
+          if (existing) {
+            return yield* Effect.fail(
+              new Error(`Worker "${name}" already exists`),
+            );
+          }
+          return yield* putWorker(
+            id,
+            news,
+            bindings,
+            undefined,
+            undefined,
+            session,
+          );
+        }),
+        update: Effect.fnUntraced(function* ({
+          id,
+          olds,
+          news,
+          output,
+          bindings,
+          session,
+        }) {
+          return yield* putWorker(id, news, bindings, olds, output, session);
+        }),
+        delete: Effect.fnUntraced(function* ({ output }) {
+          yield* api.workers.scripts
+            .delete(output.id, {
+              account_id: output.accountId,
+            })
+            .pipe(Effect.catchTag("NotFound", () => Effect.void));
+        }),
+      };
+    }),
+  );

package/src/cloudflare/worker/worker.serve.ts

@@ -0,0 +1,22 @@
+import type { ExecutionContext } from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Worker from "./worker.ts";
+
+export type { ExecutionContext };
+export type * from "../../exports.ts";
+
+export const serve =
+  <const ID extends string, Req>(
+    id: ID,
+    {
+      fetch,
+    }: {
+      fetch: (
+        request: Request,
+        env: unknown,
+        ctx: ExecutionContext,
+      ) => Effect.Effect<Response, never, Req>;
+    },
+  ) =>
+  <const Props extends Worker.WorkerProps<Req>>(props: Props) =>
+    Worker.Worker(id, { handle: fetch })(props);

package/src/cloudflare/worker/worker.ts

@@ -0,0 +1,77 @@
+import type { Workers } from "cloudflare/resources";
+import { Runtime, type RuntimeProps } from "../../runtime.ts";
+import type * as Assets from "./assets.fetch.ts";
+
+export const WorkerType = "Cloudflare.Worker" as const;
+export type WorkerType = typeof WorkerType;
+
+export type WorkerProps<Req = any> = RuntimeProps<
+  Worker,
+  Exclude<Req, Assets.Fetch>
+> & {
+  name?: string;
+  logpush?: boolean;
+  observability?: Worker.Observability;
+  subdomain?: Worker.Subdomain;
+  tags?: string[];
+  main: string;
+  compatibility?: {
+    date?: string;
+    flags?: string[];
+  };
+  limits?: Worker.Limits;
+  placement?: Worker.Placement;
+} & (Extract<Req, Assets.Fetch> extends never
+    ? {
+        assets?: string | Worker.AssetsProps;
+      }
+    : {
+        assets: string | Worker.AssetsProps;
+      });
+
+export type WorkerAttr<Props extends WorkerProps<any>> = {
+  id: string;
+  name: Props["name"] extends string ? Props["name"] : string;
+  logpush: Props["logpush"] extends boolean ? Props["logpush"] : boolean;
+  observability: Props["observability"] extends Worker.Observability
+    ? Props["observability"]
+    : {
+        // whatever cloudflare's (or our, probably ours) default is
+      };
+  url: Props["subdomain"] extends { enabled: false } ? undefined : string;
+  subdomain: Props["subdomain"] extends Worker.Subdomain
+    ? Props["subdomain"]
+    : { enabled: true; previews_enabled: true };
+  tags: Props["tags"] extends string[] ? Props["tags"] : string[];
+  accountId: string;
+  hash: { assets: string | undefined; bundle: string };
+};
+
+export interface Worker extends Runtime<WorkerType> {
+  base: Worker;
+  props: WorkerProps<any>;
+  attr: WorkerAttr<Extract<this["props"], WorkerProps<any>>>;
+  binding: {
+    bindings: Worker.Binding[];
+  };
+}
+
+export const Worker = Runtime(WorkerType)<Worker>();
+
+export declare namespace Worker {
+  export type Observability = Workers.ScriptUpdateParams.Metadata.Observability;
+  export type Subdomain = Workers.Beta.Worker.Subdomain;
+  export type Binding = NonNullable<
+    Workers.Beta.Workers.VersionCreateParams["bindings"]
+  >[number];
+  export type Limits = Workers.Beta.Workers.Version.Limits;
+  export type Placement = Workers.Beta.Workers.Version.Placement;
+  export type Assets = Workers.Beta.Workers.Version.Assets;
+  export type AssetsConfig = Workers.Beta.Workers.Version.Assets.Config;
+  export type Module = Workers.Beta.Workers.Version.Module;
+
+  export interface AssetsProps {
+    directory: string;
+    config?: AssetsConfig;
+  }
+}

package/src/data.ts

@@ -0,0 +1,18 @@
+export type Primitive =
+  | never
+  | undefined
+  | null
+  | boolean
+  | number
+  | string
+  | bigint
+  | symbol;
+
+export const isPrimitive = (value: any): value is Primitive =>
+  value === undefined ||
+  value === null ||
+  typeof value === "boolean" ||
+  typeof value === "number" ||
+  typeof value === "string" ||
+  typeof value === "symbol" ||
+  typeof value === "bigint";

package/src/destroy.ts

@@ -1,4 +1,3 @@
-import type * as Effect from "effect/Effect";
-import type { App } from "./app.ts";
+import { apply } from "./apply.ts";
 
-export declare const destroy: () => Effect.Effect<void, never, App>;
+export const destroy = () => apply();

package/src/diff.ts

@@ -0,0 +1,30 @@
+export type Diff =
+  | {
+      action: "noop";
+      deleteFirst?: undefined;
+      stables?: undefined;
+    }
+  | {
+      action: "update";
+      deleteFirst?: undefined;
+      /** properties that won't change as part of this update */
+      stables?: string[];
+    }
+  | {
+      action: "replace";
+      deleteFirst?: boolean;
+      stables?: undefined;
+    };
+
+export const somePropsAreDifferent = <Props extends Record<string, any>>(
+  olds: Props,
+  news: Props,
+  props: (keyof Props)[],
+) => {
+  for (const prop of props) {
+    if (olds[prop] !== news[prop]) {
+      return true;
+    }
+  }
+  return false;
+};