alchemy-effect 0.1.0 → 0.2.0

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

@@ -0,0 +1,246 @@
+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 "../../apply.ts";
+import { DotAlchemy } from "../../dot-alchemy.ts";
+import { ESBuild } from "../../esbuild.ts";
+import { sha256 } from "../../sha256.ts";
+import { CloudflareAccountId, 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 app = yield* App;
+      const api = yield* CloudflareApi;
+      const accountId = yield* CloudflareAccountId;
+      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, props: WorkerProps | undefined) =>
+        props?.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) {
+        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,
+        bindings: Worker["binding"][],
+        olds: WorkerProps | undefined,
+        output: WorkerAttr<WorkerProps> | undefined,
+        session: ScopedPlanStatusSession,
+      ) {
+        const name = createWorkerName(id, news);
+        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>;
+      });
+
+      return {
+        diff: Effect.fnUntraced(function* ({ id, olds, news, output }) {
+          if (output.accountId !== accountId) {
+            return { action: "replace" };
+          }
+          const workerName = createWorkerName(id, news);
+          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);
+          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,19 @@
+import type * as types from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Worker from "./worker.ts";
+
+export const serve =
+  <const ID extends string, Req>(
+    id: ID,
+    {
+      fetch,
+    }: {
+      fetch: (
+        request: Request,
+        env: unknown,
+        ctx: types.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,76 @@
+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> = {
+  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> {
+  props: WorkerProps;
+  attr: WorkerAttr<Extract<this["props"], WorkerProps>>;
+  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,4 +1,7 @@
-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({
+    phase: "destroy",
+    resources: [],
+  });

package/src/dot-alchemy.ts

@@ -1,8 +1,8 @@
-import { FileSystem } from "@effect/platform";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import path from "node:path";
 
 export class DotAlchemy extends Context.Tag(".alchemy")<DotAlchemy, string>() {}
 
@@ -10,6 +10,7 @@ export const dotAlchemy = Layer.effect(
   DotAlchemy,
   Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
     const dir = path.join(process.cwd(), ".alchemy");
     yield* fs.makeDirectory(dir, { recursive: true });
     return dir;

package/src/esbuild.ts

@@ -0,0 +1,98 @@
+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 Queue from "effect/Queue";
+import type * as Scope from "effect/Scope";
+import type esbuild from "esbuild";
+
+export class ESBuild extends Context.Tag("ESBuild")<
+  ESBuild,
+  {
+    readonly build: <T extends esbuild.BuildOptions>(
+      options: esbuild.SameShape<esbuild.BuildOptions, T>,
+    ) => Effect.Effect<esbuild.BuildResult<T>, ESBuildError>;
+    readonly context: <T extends esbuild.BuildOptions>(
+      options: esbuild.SameShape<esbuild.BuildOptions, T>,
+    ) => Effect.Effect<
+      {
+        queue: Queue.Queue<esbuild.BuildResult<T>>;
+        rebuild: () => Effect.Effect<
+          esbuild.BuildResult<T>,
+          ESBuildError,
+          never
+        >;
+      },
+      ESBuildError,
+      Scope.Scope
+    >;
+  }
+>() {}
+
+export const layer = () =>
+  Layer.effect(
+    ESBuild,
+    Effect.gen(function* () {
+      const esbuild = yield* Effect.promise(() => import("esbuild"));
+      return ESBuild.of({
+        build: Effect.fnUntraced(function* (options) {
+          return yield* Effect.tryPromise({
+            try: () => esbuild.build(options),
+            catch: ESBuildError.map,
+          });
+        }),
+        context: Effect.fnUntraced(function* (options) {
+          const queue = yield* Queue.unbounded<esbuild.BuildResult>();
+          const context = yield* Effect.tryPromise({
+            try: async () =>
+              esbuild.context({
+                ...options,
+                plugins: [
+                  ...(options.plugins ?? []),
+                  {
+                    name: "queue",
+                    setup: (build) => {
+                      build.onEnd((result) => {
+                        Queue.unsafeOffer(queue, result as esbuild.BuildResult);
+                      });
+                    },
+                  },
+                ],
+              }),
+            catch: ESBuildError.map,
+          });
+          yield* Effect.addFinalizer(() =>
+            Effect.promise(() => context.dispose()),
+          );
+          yield* Effect.tryPromise({
+            try: () => context.watch(),
+            catch: ESBuildError.map,
+          });
+          return {
+            queue,
+            rebuild: Effect.fnUntraced(function* () {
+              return yield* Effect.tryPromise({
+                try: (): Promise<esbuild.BuildResult> => context.rebuild(),
+                catch: ESBuildError.map,
+              });
+            }),
+          };
+        }),
+      });
+    }),
+  );
+
+export class ESBuildError extends Data.TaggedError("ESBuildError")<{
+  message: string;
+  errors: esbuild.Message[];
+  messages: esbuild.Message[];
+}> {
+  static map(error: unknown): ESBuildError {
+    const cause = error as esbuild.BuildFailure;
+    return new ESBuildError({
+      message: cause.message,
+      errors: cause.errors,
+      messages: cause.warnings,
+    });
+  }
+}

package/src/index.ts

@@ -14,8 +14,9 @@ export * from "./provider.ts";
 export * from "./resource.ts";
 export * from "./runtime.ts";
 export * from "./service.ts";
-export * as State from "./state.ts";
+export * from "./type.ts";
 
-export * as AWS from "./aws/index.ts";
-export * as CLI from "./cli/index.ts";
-export * as Cloudflare from "./cloudflare/index.ts";
+// export * as AWS from "./aws/index.ts";
+// export * as CLI from "./cli/index.ts";
+// export * as Cloudflare from "./cloudflare/index.ts";
+export * as State from "./state.ts";