alchemy-effect 0.5.0 → 0.6.2

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

@@ -1,249 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,279 +0,0 @@
-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 type { ScopedPlanStatusSession } from "../../cli/service.ts";
-import { DotAlchemy } from "../../dot-alchemy.ts";
-import { ESBuild } from "../../esbuild.ts";
-import { createPhysicalName } from "../../physical-name.ts";
-import { sha256 } from "../../sha256.ts";
-import { Account } from "../account.ts";
-import { CloudflareApi } from "../api.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 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) =>
-        Effect.gen(function* () {
-          if (name) return name;
-          return (yield* createPhysicalName({
-            id,
-            maxLength: 54,
-          })).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 = yield* 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 {
-          workerId: worker.id,
-          workerName: 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 {
-        stables: ["workerId"],
-        diff: Effect.fnUntraced(function* ({ id, news, output }) {
-          if (output.accountId !== accountId) {
-            return { action: "replace" };
-          }
-          const workerName = yield* createWorkerName(id, news.name);
-          if (workerName !== output.workerName) {
-            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",
-              stables: output.workerName === workerName ? ["name"] : undefined,
-            };
-          }
-        }),
-        read: Effect.fnUntraced(function* ({ id, output }) {
-          const workerName = yield* createWorkerName(id, output?.workerName);
-          const worker = yield* api.workers.beta.workers.get(workerName, {
-            account_id: accountId,
-          });
-          return {
-            accountId,
-            workerId: worker.id,
-            workerName: worker.name,
-            logpush: worker.logpush,
-            observability: worker.observability,
-            subdomain: {
-              enabled: worker.subdomain.enabled,
-              previews_enabled: worker.subdomain.previews_enabled,
-            },
-            url: worker.subdomain.enabled
-              ? `https://${workerName}.${yield* getAccountSubdomain(accountId)}.workers.dev`
-              : undefined,
-            tags: worker.tags,
-          } as WorkerAttr<WorkerProps<any>>;
-        }),
-        create: Effect.fnUntraced(function* ({ id, news, bindings, session }) {
-          const name = yield* 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.workerId, {
-              account_id: output.accountId,
-            })
-            .pipe(Effect.catchTag("NotFound", () => Effect.void));
-        }),
-      };
-    }),
-  );

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

@@ -1,22 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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>> = {
-  workerId: string;
-  workerName: 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/destroy.ts

@@ -1,3 +0,0 @@
-import { apply } from "./apply.ts";
-
-export const destroy = () => apply();