alchemy-effect 0.2.0 → 0.4.0

package/src/cloudflare/api.ts

@@ -5,46 +5,50 @@ import {
   type RequestOptions,
 } from "cloudflare/core";
 import type { ErrorData } from "cloudflare/resources";
-import { Layer } from "effect";
-import * as Context from "effect/Context";
 import * as Data from "effect/Data";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
+import { Config } from "effect";
 
-export class CloudflareAccountId extends Context.Tag("cloudflare/account-id")<
-  CloudflareAccountId,
-  string
->() {
-  static readonly fromEnv = Layer.effect(
-    CloudflareAccountId,
-    Effect.gen(function* () {
-      const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
-      if (!accountId) {
-        return yield* Effect.die("CLOUDFLARE_ACCOUNT_ID is not set");
-      }
-      return accountId;
-    }),
-  );
-}
+export const CLOUDFLARE_BASE_URL = Config.string("CLOUDFLARE_BASE_URL").pipe(
+  Config.option,
+);
+export const CLOUDFLARE_API_TOKEN = Config.string("CLOUDFLARE_API_TOKEN").pipe(
+  Config.option,
+);
+export const CLOUDFLARE_API_KEY = Config.string("CLOUDFLARE_API_KEY").pipe(
+  Config.option,
+);
+export const CLOUDFLARE_API_EMAIL = Config.string("CLOUDFLARE_API_EMAIL").pipe(
+  Config.option,
+);
 
 export class CloudflareApi extends Effect.Service<CloudflareApi>()(
   "cloudflare/api",
   {
-    effect: (options?: {
+    effect: Effect.fn(function* (options?: {
       baseUrl?: string;
       apiToken?: string;
       apiKey?: string;
       apiEmail?: string;
-    }) =>
-      Effect.succeed(
-        createRecursiveProxy(
-          new Cloudflare({
-            baseURL: options?.baseUrl ?? import.meta.env.CLOUDFLARE_BASE_URL,
-            apiToken: options?.apiToken ?? import.meta.env.CLOUDFLARE_API_TOKEN,
-            apiKey: options?.apiKey ?? import.meta.env.CLOUDFLARE_API_KEY,
-            apiEmail: options?.apiEmail ?? import.meta.env.CLOUDFLARE_API_EMAIL,
-          }),
-        ),
-      ),
+    }) {
+      return createRecursiveProxy(
+        new Cloudflare({
+          baseURL:
+            options?.baseUrl ??
+            (yield* CLOUDFLARE_BASE_URL).pipe(Option.getOrUndefined),
+          apiToken:
+            options?.apiToken ??
+            (yield* CLOUDFLARE_API_TOKEN).pipe(Option.getOrUndefined),
+          apiKey:
+            options?.apiKey ??
+            (yield* CLOUDFLARE_API_KEY).pipe(Option.getOrUndefined),
+          apiEmail:
+            options?.apiEmail ??
+            (yield* CLOUDFLARE_API_EMAIL).pipe(Option.getOrUndefined),
+        }),
+      );
+    }),
   },
 ) {}
 

package/src/cloudflare/config.ts

@@ -0,0 +1,7 @@
+declare module "../stage.ts" {
+  interface StageConfig {
+    cloudflare?: {
+      account: string;
+    };
+  }
+}

package/src/cloudflare/index.ts

@@ -2,5 +2,7 @@ export * as KV from "./kv/index.ts";
 export * as R2 from "./r2/index.ts";
 export * as Assets from "./worker/assets.fetch.ts";
 export * as Worker from "./worker/index.ts";
+export * from "./account.ts";
+export * from "./live.ts";
 
-export type * as Alchemy from "../index.ts";
+import "./config.ts";

package/src/cloudflare/kv/namespace.binding.ts

@@ -1,4 +1,6 @@
-import { Binding, type Capability, type To } from "alchemy-effect";
+import { Binding } from "../../binding.ts";
+import type { Capability } from "../../capability.ts";
+import type { To } from "../../policy.ts";
 import { Worker } from "../worker/worker.ts";
 import type { Namespace, NamespaceProps } from "./namespace.ts";
 

package/src/cloudflare/kv/namespace.provider.ts

@@ -1,7 +1,8 @@
 import type { KV } from "cloudflare/resources";
 import * as Effect from "effect/Effect";
 import { App } from "../../app.ts";
-import { CloudflareAccountId, CloudflareApi } from "../api.ts";
+import { Account } from "../account.ts";
+import { CloudflareApi } from "../api.ts";
 import {
   Namespace,
   type NamespaceAttr,
@@ -13,10 +14,10 @@ export const namespaceProvider = () =>
     Effect.gen(function* () {
       const app = yield* App;
       const api = yield* CloudflareApi;
-      const accountId = yield* CloudflareAccountId;
+      const accountId = yield* Account;
 
-      const createTitle = (id: string, news: NamespaceProps) =>
-        news.title ?? `${app.name}-${id}-${app.stage}`;
+      const createTitle = (id: string, title: string | undefined) =>
+        title ?? `${app.name}-${id}-${app.stage}`;
 
       const mapResult = <Props extends NamespaceProps>(
         result: KV.Namespace,
@@ -28,12 +29,13 @@ export const namespaceProvider = () =>
       });
 
       return {
+        stables: ["namespaceId", "accountId"],
         diff: ({ id, news, output }) =>
           Effect.sync(() => {
             if (output.accountId !== accountId) {
               return { action: "replace" };
             }
-            const title = createTitle(id, news);
+            const title = createTitle(id, news.title);
             if (title !== output.title) {
               return { action: "update" };
             }
@@ -42,7 +44,7 @@ export const namespaceProvider = () =>
           return yield* api.kv.namespaces
             .create({
               account_id: accountId,
-              title: createTitle(id, news),
+              title: createTitle(id, news.title),
             })
             .pipe(Effect.map(mapResult<NamespaceProps>));
         }),
@@ -50,7 +52,7 @@ export const namespaceProvider = () =>
           return yield* api.kv.namespaces
             .update(output.namespaceId, {
               account_id: accountId,
-              title: createTitle(id, news),
+              title: createTitle(id, news.title),
             })
             .pipe(Effect.map(mapResult<NamespaceProps>));
         }),
@@ -72,7 +74,7 @@ export const namespaceProvider = () =>
                 Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
               );
           }
-          const title = createTitle(id, olds ?? {}); // why is olds optional?
+          const title = createTitle(id, olds?.title); // why is olds optional? because read can be called before the resource exists (sync)
           let page = 1;
           while (true) {
             // todo: abstract pagination

package/src/cloudflare/kv/namespace.ts

@@ -18,12 +18,13 @@ export interface Namespace<
     "Cloudflare.KV.Namespace",
     ID,
     Props,
-    NamespaceAttr<Props>
+    NamespaceAttr<Props>,
+    Namespace
   > {}
 
 export const Namespace = Resource<{
   <const ID extends string, const Props extends NamespaceProps>(
     id: ID,
-    props: Props,
+    props?: Props,
   ): Namespace<ID, Props>;
 }>("Cloudflare.KV.Namespace");

package/src/cloudflare/live.ts

@@ -1,6 +1,7 @@
 import * as Layer from "effect/Layer";
 import * as ESBuild from "../esbuild.ts";
-import { CloudflareAccountId, CloudflareApi } from "./api.ts";
+import { CloudflareApi } from "./api.ts";
+import * as Account from "./account.ts";
 import * as KV from "./kv/index.ts";
 import { namespaceProvider } from "./kv/namespace.provider.ts";
 import { bucketProvider } from "./r2/bucket.provider.ts";
@@ -8,7 +9,12 @@ import * as R2 from "./r2/index.ts";
 import { assetsProvider } from "./worker/assets.provider.ts";
 import { workerProvider } from "./worker/worker.provider.ts";
 
-export const providers = () =>
+import "./config.ts";
+
+export const bindings = () =>
+  Layer.mergeAll(KV.bindFromWorker(), R2.bindFromWorker());
+
+export const defaultProviders = () =>
   Layer.mergeAll(
     Layer.provideMerge(
       workerProvider(),
@@ -16,23 +22,11 @@ export const providers = () =>
     ),
     namespaceProvider(),
     bucketProvider(),
-  );
+  ).pipe(Layer.provideMerge(bindings()));
 
-export const bindings = () =>
-  Layer.mergeAll(KV.bindFromWorker(), R2.bindFromWorker());
-
-export const defaultProviders = () =>
-  providers().pipe(Layer.provideMerge(bindings()));
-
-export const live = () =>
+export const providers = () =>
   defaultProviders().pipe(
     Layer.provideMerge(
-      Layer.mergeAll(CloudflareAccountId.fromEnv, CloudflareApi.Default()),
+      Layer.mergeAll(Account.fromStageConfig(), CloudflareApi.Default()),
     ),
   );
-
-export default live;
-
-// Layer.mergeAll
-// Layer.provide
-// Layer.provideMerge

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

@@ -1,4 +1,6 @@
-import { Binding, type Capability, type To } from "alchemy-effect";
+import { Binding } from "../../binding.ts";
+import type { Capability } from "../../capability.ts";
+import type { To } from "../../policy.ts";
 import { Worker } from "../worker/worker.ts";
 import type { Bucket } from "./bucket.ts";
 

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

@@ -1,18 +1,19 @@
 import type { R2 } from "cloudflare/resources";
 import * as Effect from "effect/Effect";
 import { App } from "../../app";
-import { CloudflareAccountId, CloudflareApi } from "../api";
+import { Account } from "../account.ts";
+import { 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 accountId = yield* Account;
       const app = yield* App;
 
-      const createName = (id: string, props: BucketProps) =>
-        props.name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
+      const createName = (id: string, name: string | undefined) =>
+        name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
 
       const mapResult = <Props extends BucketProps>(
         bucket: R2.Bucket,
@@ -30,28 +31,34 @@ export const bucketProvider = () =>
           Effect.sync(() => {
             if (
               output.accountId !== accountId ||
-              output.name !== createName(id, news) ||
+              output.name !== createName(id, news.name) ||
               output.jurisdiction !== (news.jurisdiction ?? "default") ||
               olds.locationHint !== news.locationHint
             ) {
               return { action: "replace" };
             }
             if (output.storageClass !== (news.storageClass ?? "Standard")) {
-              return { action: "update" };
+              return {
+                action: "update",
+                stables:
+                  output.name === createName(id, news.name)
+                    ? ["name"]
+                    : undefined,
+              };
             }
             return { action: "noop" };
           }),
         create: Effect.fnUntraced(function* ({ id, news }) {
           const bucket = yield* api.r2.buckets.create({
             account_id: accountId,
-            name: createName(id, news),
+            name: createName(id, news.name),
             storageClass: news.storageClass,
             jurisdiction: news.jurisdiction,
             locationHint: news.locationHint,
           });
           return mapResult<BucketProps>(bucket);
         }),
-        update: Effect.fnUntraced(function* ({ id, news, output }) {
+        update: Effect.fnUntraced(function* ({ news, output }) {
           const bucket = yield* api.r2.buckets.edit(output.name, {
             account_id: output.accountId,
             storage_class: news.storageClass ?? output.storageClass,
@@ -69,7 +76,7 @@ export const bucketProvider = () =>
         read: Effect.fnUntraced(function* ({ id, output, olds }) {
           const params = {
             account_id: output?.accountId ?? accountId,
-            name: output?.name ?? createName(id, olds ?? {}),
+            name: output?.name ?? createName(id, olds?.name),
           };
           return yield* api.r2.buckets
             .get(params.name, { account_id: params.account_id })

package/src/cloudflare/r2/bucket.ts

@@ -22,12 +22,18 @@ export type BucketAttr<Props extends BucketProps> = {
 export interface Bucket<
   ID extends string = string,
   Props extends BucketProps = BucketProps,
-> extends Resource<"Cloudflare.R2.Bucket", ID, Props, BucketAttr<Props>> {}
+> extends Resource<
+    "Cloudflare.R2.Bucket",
+    ID,
+    Props,
+    BucketAttr<Props>,
+    Bucket
+  > {}
 
 export const Bucket = Resource<{
   <const ID extends string, const Props extends BucketProps>(
     id: ID,
-    props: Props,
+    props?: Props,
   ): Bucket<ID, Props>;
 }>("Cloudflare.R2.Bucket");
 

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

@@ -1,6 +1,8 @@
 import type * as runtime from "@cloudflare/workers-types";
-import { Binding, declare, type Capability } from "alchemy-effect";
 import * as Effect from "effect/Effect";
+import { Binding } from "../../binding.ts";
+import type { Capability } from "../../capability.ts";
+import { declare } from "../../policy.ts";
 import { getCloudflareEnvKey } from "../context.ts";
 import { Worker } from "./worker.ts";
 

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

@@ -2,7 +2,7 @@ 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 type { ScopedPlanStatusSession } from "../../cli/service.ts";
 import { sha256 } from "../../sha256.ts";
 import { CloudflareApi, CloudflareApiError } from "../api.ts";
 import type { Worker } from "./worker.ts";

package/src/cloudflare/worker/index.ts

@@ -2,5 +2,3 @@ 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

@@ -1,7 +1,7 @@
 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 type { Capability } from "../../capability.ts";
 import { CloudflareContext } from "../context.ts";
 
 type Handler = (

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

@@ -3,11 +3,12 @@ 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 type { ScopedPlanStatusSession } from "../../cli/service.ts";
 import { DotAlchemy } from "../../dot-alchemy.ts";
 import { ESBuild } from "../../esbuild.ts";
 import { sha256 } from "../../sha256.ts";
-import { CloudflareAccountId, CloudflareApi } from "../api.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";
 
@@ -16,7 +17,7 @@ export const workerProvider = () =>
     Effect.gen(function* () {
       const app = yield* App;
       const api = yield* CloudflareApi;
-      const accountId = yield* CloudflareAccountId;
+      const accountId = yield* Account;
       const { read, upload } = yield* Assets;
       const { build } = yield* ESBuild;
       const fs = yield* FileSystem.FileSystem;
@@ -46,8 +47,8 @@ export const workerProvider = () =>
         yield* Effect.logDebug("setWorkerSubdomain", subdomain);
       });
 
-      const createWorkerName = (id: string, props: WorkerProps | undefined) =>
-        props?.name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
+      const createWorkerName = (id: string, name: string | undefined) =>
+        name ?? `${app.name}-${id}-${app.stage}`.toLowerCase();
 
       const prepareAssets = Effect.fnUntraced(function* (
         assets: WorkerProps["assets"],
@@ -83,7 +84,9 @@ export const workerProvider = () =>
         };
       });
 
-      const prepareMetadata = Effect.fnUntraced(function* (props: WorkerProps) {
+      const prepareMetadata = Effect.fnUntraced(function* (
+        props: WorkerProps<any>,
+      ) {
         const metadata: Workers.ScriptUpdateParams.Metadata = {
           assets: undefined,
           bindings: [],
@@ -113,13 +116,13 @@ export const workerProvider = () =>
 
       const putWorker = Effect.fnUntraced(function* (
         id: string,
-        news: WorkerProps,
+        news: WorkerProps<any>,
         bindings: Worker["binding"][],
-        olds: WorkerProps | undefined,
-        output: WorkerAttr<WorkerProps> | undefined,
+        olds: WorkerProps<any> | undefined,
+        output: WorkerAttr<WorkerProps<any>> | undefined,
         session: ScopedPlanStatusSession,
       ) {
-        const name = createWorkerName(id, news);
+        const name = createWorkerName(id, news.name);
         const [assets, bundle, metadata] = yield* Effect.all([
           prepareAssets(news.assets),
           prepareBundle(id, news.main),
@@ -180,15 +183,16 @@ export const workerProvider = () =>
             assets: assets?.hash,
             bundle: bundle.hash,
           },
-        } as WorkerAttr<WorkerProps>;
+        } as WorkerAttr<WorkerProps<any>>;
       });
 
       return {
+        stables: ["id"],
         diff: Effect.fnUntraced(function* ({ id, olds, news, output }) {
           if (output.accountId !== accountId) {
             return { action: "replace" };
           }
-          const workerName = createWorkerName(id, news);
+          const workerName = createWorkerName(id, news.name);
           if (workerName !== output.name) {
             return { action: "replace" };
           }
@@ -200,11 +204,14 @@ export const workerProvider = () =>
             assets?.hash !== output.hash.assets ||
             bundle.hash !== output.hash.bundle
           ) {
-            return { action: "update" };
+            return {
+              action: "update",
+              stables: output.name === workerName ? ["name"] : undefined,
+            };
           }
         }),
         create: Effect.fnUntraced(function* ({ id, news, bindings, session }) {
-          const name = createWorkerName(id, news);
+          const name = createWorkerName(id, news.name);
           const existing = yield* api.workers.beta.workers
             .get(name, {
               account_id: accountId,

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

@@ -1,7 +1,10 @@
-import type * as types from "@cloudflare/workers-types";
+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,
@@ -11,7 +14,7 @@ export const serve =
       fetch: (
         request: Request,
         env: unknown,
-        ctx: types.ExecutionContext,
+        ctx: ExecutionContext,
       ) => Effect.Effect<Response, never, Req>;
     },
   ) =>

package/src/cloudflare/worker/worker.ts

@@ -29,7 +29,7 @@ export type WorkerProps<Req = any> = RuntimeProps<
         assets: string | Worker.AssetsProps;
       });
 
-export type WorkerAttr<Props extends WorkerProps> = {
+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;
@@ -48,8 +48,9 @@ export type WorkerAttr<Props extends WorkerProps> = {
 };
 
 export interface Worker extends Runtime<WorkerType> {
-  props: WorkerProps;
-  attr: WorkerAttr<Extract<this["props"], WorkerProps>>;
+  base: Worker;
+  props: WorkerProps<any>;
+  attr: WorkerAttr<Extract<this["props"], WorkerProps<any>>>;
   binding: {
     bindings: Worker.Binding[];
   };

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,7 +1,3 @@
 import { apply } from "./apply.ts";
 
-export const destroy = () =>
-  apply({
-    phase: "destroy",
-    resources: [],
-  });
+export const destroy = () => apply();

package/src/diff.ts

@@ -0,0 +1,48 @@
+export type Diff = NoopDiff | UpdateDiff | ReplaceDiff;
+
+export interface NoopDiff {
+  action: "noop";
+  stables?: undefined;
+}
+
+export interface UpdateDiff {
+  action: "update";
+  /** properties that won't change as part of this update */
+  stables?: string[];
+}
+
+export interface ReplaceDiff {
+  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;
+};
+
+export const anyPropsAreDifferent = <Props extends Record<string, any>>(
+  olds: Props,
+  news: Props,
+) => {
+  for (const prop in olds) {
+    if (olds[prop] !== news[prop]) {
+      return true;
+    }
+  }
+  for (const prop in news) {
+    if (!(prop in olds)) {
+      return true;
+    }
+  }
+  return false;
+};

package/src/env.ts

@@ -1,9 +1,28 @@
+let _env;
+try {
+  // @ts-expect-error
+  const { env } = await import("cloudflare:workers");
+  _env = env;
+} catch {
+  if (typeof process !== "undefined") {
+    _env = process.env;
+  } else {
+    _env = import.meta.env;
+  }
+}
+
+export interface Env {
+  [key: string]: string | undefined;
+}
+
+export const env: Env = _env;
+
 export const toEnvKey = <const ID extends string, const Suffix extends string>(
   id: ID,
   suffix: Suffix,
 ) => `${replace(toUpper(id))}_${replace(toUpper(suffix))}` as const;
 
-const toUpper = <const S extends string>(str: S) =>
+export const toUpper = <const S extends string>(str: S) =>
   str.toUpperCase() as string extends S ? S : Uppercase<S>;
 
 const replace = <const S extends string>(str: S) =>
@@ -18,34 +37,3 @@ type Replace<S extends string, Accum extends string = ""> = string extends S
         ? Replace<Rest, `${Accum}_`>
         : Replace<Rest, `${Accum}${S}`>
       : Accum;
-
-function _test_both_literals() {
-  const key = toEnvKey("my-id", "my-suffix");
-  const _: typeof key = "MY_ID_MY_SUFFIX";
-  // @ts-expect-error
-  const _err: typeof key = "MY_ID_MY_SUFFIX2";
-}
-function _test_replace_wide_string() {
-  const ___ = toUpper(undefined! as string);
-  const id: string = "my-id";
-  const key = toEnvKey(id, "my-suffix");
-  const _: typeof key = "MY_ID_MY_SUFFIX";
-  const _2: typeof key = `${id}_MY_SUFFIX` as const;
-  // @ts-expect-error
-  const _err: typeof key = "MY_ID_MY_SUFFIX2";
-  // @ts-expect-error
-  const _err2: typeof key = `${id}_MY_SUFFIX2` as const;
-}
-
-function _test_replace_wide_suffix() {
-  const ___ = toUpper(undefined! as string);
-  const id = "my-id";
-  const suffix = "my-suffix" as string;
-  const key = toEnvKey(id, suffix);
-  const _: typeof key = "MY_ID_MY_SUFFIX";
-  const _2: typeof key = `MY_ID_${suffix}` as const;
-  // @ts-expect-error
-  const _err: typeof key = "WRONG_PREFIX_MY_SUFFIX";
-  // @ts-expect-error
-  const _err2: typeof key = `WRONG_PREFIX_${suffix}`;
-}