alchemy-effect 0.7.1 → 0.9.0

package/src/Cloudflare/Container.ts

@@ -268,80 +268,82 @@ export const Container: Platform<
   ContainerShape,
   Server.ProcessContext,
   Container
-> = Platform("Cloudflare.Container", (id: string): Server.ProcessContext => {
-  const runners: Effect.Effect<void, never, any>[] = [];
-  const env: Record<string, any> = {};
+> = Platform("Cloudflare.Container", {
+  createExecutionContext: (id: string): Server.ProcessContext => {
+    const runners: Effect.Effect<void, never, any>[] = [];
+    const env: Record<string, any> = {};
 
-  const serve = <Req = never>(handler: HttpEffect<Req>) =>
-    Effect.sync(() => {
-      runners.push(
-        Effect.gen(function* () {
-          const httpServer = yield* Effect.serviceOption(HttpServer).pipe(
-            Effect.map(Option.getOrUndefined),
-          );
-          if (httpServer) {
-            yield* httpServer.serve(handler);
-            yield* Effect.never;
-          } else {
-            // this should only happen at plantime, validate?
-          }
-        }).pipe(Effect.orDie),
-      );
-    });
-
-  return {
-    Type: ContainerTypeId,
-    LogicalId: id,
-    id,
-    env,
-    set: (bindingId: string, output: Output.Output) =>
+    const serve = <Req = never>(handler: HttpEffect<Req>) =>
       Effect.sync(() => {
-        const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
-        env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
-        return key;
-      }),
-    get: <T>(key: string) =>
-      Config.string(key)
-        .asEffect()
-        .pipe(
-          Effect.flatMap((value) =>
-            Effect.try({
-              try: () => JSON.parse(value) as T,
-              catch: (error) => error as Error,
-            }),
-          ),
-          Effect.catch((cause) =>
-            Effect.die(
-              new Error(`Failed to get environment variable: ${key}`, {
-                cause,
+        runners.push(
+          Effect.gen(function* () {
+            const httpServer = yield* Effect.serviceOption(HttpServer).pipe(
+              Effect.map(Option.getOrUndefined),
+            );
+            if (httpServer) {
+              yield* httpServer.serve(handler);
+              yield* Effect.never;
+            } else {
+              // this should only happen at plantime, validate?
+            }
+          }).pipe(Effect.orDie),
+        );
+      });
+
+    return {
+      Type: ContainerTypeId,
+      LogicalId: id,
+      id,
+      env,
+      set: (bindingId: string, output: Output.Output) =>
+        Effect.sync(() => {
+          const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
+          env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
+          return key;
+        }),
+      get: <T>(key: string) =>
+        Config.string(key)
+          .asEffect()
+          .pipe(
+            Effect.flatMap((value) =>
+              Effect.try({
+                try: () => JSON.parse(value) as T,
+                catch: (error) => error as Error,
               }),
             ),
+            Effect.catch((cause) =>
+              Effect.die(
+                new Error(`Failed to get environment variable: ${key}`, {
+                  cause,
+                }),
+              ),
+            ),
           ),
-        ),
-    run: ((effect: Effect.Effect<void, never, any>) =>
-      Effect.sync(() => {
-        runners.push(effect);
-      })) as unknown as Server.ProcessContext["run"],
-    serve,
-    exports: Effect.sync(() => ({
-      default: Effect.all(
-        runners.map((eff) =>
-          Effect.forever(
-            eff.pipe(
-              // Log and ignore errors (daemon mode, it should just re-run)
-              Effect.tapError((err) => Effect.logError(err)),
-              Effect.ignore,
-              // TODO(sam): ignore cause? for now, let that actually kill the server
-              // Effect.ignoreCause
+      run: ((effect: Effect.Effect<void, never, any>) =>
+        Effect.sync(() => {
+          runners.push(effect);
+        })) as unknown as Server.ProcessContext["run"],
+      serve,
+      exports: Effect.sync(() => ({
+        default: Effect.all(
+          runners.map((eff) =>
+            Effect.forever(
+              eff.pipe(
+                // Log and ignore errors (daemon mode, it should just re-run)
+                Effect.tapError((err) => Effect.logError(err)),
+                Effect.ignore,
+                // TODO(sam): ignore cause? for now, let that actually kill the server
+                // Effect.ignoreCause
+              ),
             ),
           ),
+          {
+            concurrency: "unbounded",
+          },
         ),
-        {
-          concurrency: "unbounded",
-        },
-      ),
-    })),
-  } as Server.ProcessContext;
+      })),
+    } as Server.ProcessContext;
+  },
 });
 
 export const bindContainer = Effect.fnUntraced(function* <Shape, Req = never>(
@@ -410,6 +412,32 @@ export const bindContainer = Effect.fnUntraced(function* <Shape, Req = never>(
   });
 });
 
+export const resolveDurableObjectApplicationRecovery = ({
+  namespaceId,
+  expectedName,
+  existingName,
+}: {
+  namespaceId: string;
+  expectedName: string;
+  existingName: string | undefined;
+}) => {
+  if (!existingName) {
+    return {
+      canAdopt: false as const,
+      message: `Container application for Durable Object namespace "${namespaceId}" already exists but could not be found for adoption.`,
+    };
+  }
+  if (existingName !== expectedName) {
+    return {
+      canAdopt: false as const,
+      message: `Existing container application "${existingName}" is already attached to Durable Object namespace "${namespaceId}". Use that application name to adopt it.`,
+    };
+  }
+  return {
+    canAdopt: true as const,
+  };
+};
+
 /**
  * Runs the Container in a Durable Object and monitors it, providing a durable fetch and RPC interface to it.
  */
@@ -527,6 +555,37 @@ export interface Rollout {
   stepPercentage?: number;
 }
 
+const containerApplicationReadinessSchedule = Schedule.exponential(100).pipe(
+  Schedule.both(Schedule.recurs(20)),
+);
+
+const isContainerApplicationNotFound = (
+  error: unknown,
+): error is Containers.ContainerApplicationNotFound =>
+  typeof error === "object" &&
+  error !== null &&
+  "_tag" in error &&
+  error._tag === "ContainerApplicationNotFound";
+
+export const retryForContainerApplicationReadiness = <A, E, R>(
+  operation: string,
+  applicationId: string,
+  effect: Effect.Effect<A, E, R>,
+) =>
+  effect.pipe(
+    Effect.tapError((error) =>
+      isContainerApplicationNotFound(error)
+        ? Effect.logDebug(
+            `Cloudflare Container ${operation}: application ${applicationId} not found yet, retrying`,
+          )
+        : Effect.void,
+    ),
+    Effect.retry({
+      while: isContainerApplicationNotFound,
+      schedule: containerApplicationReadinessSchedule,
+    }),
+  );
+
 export const ContainerProvider = () =>
   Container.provider.effect(
     Effect.gen(function* () {
@@ -637,7 +696,6 @@ export const ContainerProvider = () =>
       });
 
       const bundleProgram = Effect.fnUntraced(function* ({
-        id,
         main,
         runtime,
         handler = "default",
@@ -856,18 +914,22 @@ await Effect.runPromise(serverEffect).catch((err) => {
         const stepPercentage =
           strategy === "immediate" ? 100 : (rollout?.stepPercentage ?? 25);
 
-        yield* createContainerApplicationRollout({
-          accountId,
+        yield* retryForContainerApplicationReadiness(
+          "rollout",
           applicationId,
-          description:
-            strategy === "immediate"
-              ? "Immediate update"
-              : "Progressive update",
-          strategy: "rolling",
-          kind: rollout?.kind ?? "full_auto",
-          stepPercentage,
-          targetConfiguration: configuration,
-        });
+          createContainerApplicationRollout({
+            accountId,
+            applicationId,
+            description:
+              strategy === "immediate"
+                ? "Immediate update"
+                : "Progressive update",
+            strategy: "rolling",
+            kind: rollout?.kind ?? "full_auto",
+            stepPercentage,
+            targetConfiguration: configuration,
+          }),
+        );
       });
 
       const createApplication = Effect.fnUntraced(function* ({
@@ -957,22 +1019,25 @@ await Effect.runPromise(serverEffect).catch((err) => {
           durableObjects,
         }).pipe(
           Effect.catchTag("DurableObjectAlreadyHasApplication", () =>
-            adoptPolicy && durableObjects
+            durableObjects
               ? Effect.gen(function* () {
                   const existing = yield* findApplicationByNamespace(
                     durableObjects.namespaceId,
                   );
-                  if (!existing) {
+                  const recovery = resolveDurableObjectApplicationRecovery({
+                    namespaceId: durableObjects.namespaceId,
+                    expectedName: name,
+                    existingName: existing?.name,
+                  });
+                  if (!recovery.canAdopt) {
                     return yield* Effect.fail(
-                      new Error(
-                        `Container application for Durable Object namespace "${durableObjects.namespaceId}" already exists but could not be found for adoption.`,
-                      ),
+                      new Error(recovery.message),
                     );
                   }
-                  if (existing.name !== name) {
+                  if (!existing) {
                     return yield* Effect.fail(
                       new Error(
-                        `Existing container application "${existing.name}" is already attached to Durable Object namespace "${durableObjects.namespaceId}". Use that application name to adopt it.`,
+                        `Container application for Durable Object namespace "${durableObjects.namespaceId}" already exists but could not be found for adoption.`,
                       ),
                     );
                   }
@@ -985,7 +1050,7 @@ await Effect.runPromise(serverEffect).catch((err) => {
                 })
               : Effect.fail(
                   new Error(
-                    `Durable Object namespace "${durableObjects?.namespaceId ?? "unknown"}" already has a container application. Set AdoptPolicy to adopt it.`,
+                    "Durable Object namespace already has a container application. Set AdoptPolicy to adopt it.",
                   ),
                 ),
           ),
@@ -1031,16 +1096,20 @@ await Effect.runPromise(serverEffect).catch((err) => {
         yield* session.note(
           `Updating container application ${existing.applicationName}...`,
         );
-        const application = yield* updateContainerApplication({
-          accountId,
-          applicationId: existing.applicationId,
-          instances: news.instances ?? 1,
-          maxInstances: news.maxInstances ?? 1,
-          schedulingPolicy: news.schedulingPolicy ?? "default",
-          constraints: news.constraints ?? {},
-          affinities: news.affinities,
-          configuration,
-        });
+        const application = yield* retryForContainerApplicationReadiness(
+          "update",
+          existing.applicationId,
+          updateContainerApplication({
+            accountId,
+            applicationId: existing.applicationId,
+            instances: news.instances ?? 1,
+            maxInstances: news.maxInstances ?? 1,
+            schedulingPolicy: news.schedulingPolicy ?? "default",
+            constraints: news.constraints ?? {},
+            affinities: news.affinities,
+            configuration,
+          }),
+        );
         const updated = toAttributes(application);
         if (!deepEqual(existing.configuration, configuration)) {
           yield* Effect.logInfo(
@@ -1174,6 +1243,31 @@ await Effect.runPromise(serverEffect).catch((err) => {
             !adoptPolicy &&
             !deepEqual(output.durableObjects, durableObjects)
           ) {
+            if (durableObjects) {
+              const existing = yield* findApplicationByNamespace(
+                durableObjects.namespaceId,
+              );
+              const recovery = resolveDurableObjectApplicationRecovery({
+                namespaceId: durableObjects.namespaceId,
+                expectedName: name,
+                existingName: existing?.name,
+              });
+              if (recovery.canAdopt) {
+                if (!existing) {
+                  return yield* Effect.fail(
+                    new Error(
+                      `Container application for Durable Object namespace "${durableObjects.namespaceId}" already exists but could not be found for adoption.`,
+                    ),
+                  );
+                }
+                return yield* upsertApplication({
+                  id,
+                  news,
+                  existing: toAttributes(existing),
+                  session,
+                });
+              }
+            }
             yield* Effect.logInfo(
               `Cloudflare Container create: recreating pre-created application ${name} with durable object binding`,
             );
@@ -1258,6 +1352,24 @@ await Effect.runPromise(serverEffect).catch((err) => {
           );
         }),
         read: Effect.fnUntraced(function* ({ id, olds, output }) {
+          const readByName = (name: string) =>
+            Effect.gen(function* () {
+              yield* Effect.logInfo(
+                `Cloudflare Container read: looking up ${name}`,
+              );
+              const existing = yield* findApplicationByName(name);
+              if (!existing) {
+                yield* Effect.logInfo(
+                  `Cloudflare Container read: ${name} not found`,
+                );
+                return undefined;
+              }
+              return {
+                ...toAttributes(existing),
+                hash: output?.hash,
+              };
+            });
+
           if (output?.applicationId) {
             yield* Effect.logInfo(
               `Cloudflare Container read: checking ${output.applicationName}`,
@@ -1271,24 +1383,13 @@ await Effect.runPromise(serverEffect).catch((err) => {
                 hash: output.hash,
               })),
               Effect.catchTag("ContainerApplicationNotFound", () =>
-                Effect.succeed(undefined),
+                readByName(output.applicationName),
               ),
             );
           }
 
           const name = yield* createApplicationName(id, olds?.name);
-          yield* Effect.logInfo(
-            `Cloudflare Container read: looking up ${name}`,
-          );
-          const existing = yield* findApplicationByName(name);
-          if (!existing) {
-            yield* Effect.logInfo(
-              `Cloudflare Container read: ${name} not found`,
-            );
-          }
-          return existing
-            ? { ...toAttributes(existing), hash: output?.hash }
-            : undefined;
+          return yield* readByName(name);
         }),
         tail: ({ output }) =>
           telemetry.tailStream({

package/src/Cloudflare/D1/D1Database.ts

@@ -123,6 +123,38 @@ export const DatabaseProvider = (): Layer<
             return { action: "update" } as const;
           }
         }),
+        read: Effect.fn(function* ({ id, output, olds }) {
+          if (output?.databaseId) {
+            return yield* getDb({
+              accountId: output.accountId,
+              databaseId: output.databaseId,
+            }).pipe(
+              Effect.map((db) => ({
+                databaseId: db.uuid ?? output.databaseId,
+                databaseName: db.name ?? output.databaseName,
+                jurisdiction: output.jurisdiction,
+                readReplication: db.readReplication ?? undefined,
+                accountId: output.accountId,
+              })),
+              Effect.catchTag("DatabaseNotFound", () =>
+                Effect.succeed(undefined),
+              ),
+            );
+          }
+          const name = yield* createDatabaseName(id, olds?.name);
+          const dbs = yield* listDbs({ accountId, name });
+          const match = dbs.result.find((db) => db.name === name);
+          if (match) {
+            return {
+              databaseId: match.uuid!,
+              databaseName: match.name ?? name,
+              jurisdiction: (olds?.jurisdiction ?? "default") as Jurisdiction,
+              readReplication: olds?.readReplication,
+              accountId,
+            };
+          }
+          return undefined;
+        }),
         create: Effect.fn(function* ({ id, news = {} }) {
           const name = yield* createDatabaseName(id, news.name);
           const jurisdiction = news.jurisdiction ?? "default";
@@ -185,38 +217,6 @@ export const DatabaseProvider = (): Layer<
             databaseId: output.databaseId,
           }).pipe(Effect.catchTag("DatabaseNotFound", () => Effect.void));
         }),
-        read: Effect.fn(function* ({ id, output, olds }) {
-          if (output?.databaseId) {
-            return yield* getDb({
-              accountId: output.accountId,
-              databaseId: output.databaseId,
-            }).pipe(
-              Effect.map((db) => ({
-                databaseId: db.uuid ?? output.databaseId,
-                databaseName: db.name ?? output.databaseName,
-                jurisdiction: output.jurisdiction,
-                readReplication: db.readReplication ?? undefined,
-                accountId: output.accountId,
-              })),
-              Effect.catchTag("DatabaseNotFound", () =>
-                Effect.succeed(undefined),
-              ),
-            );
-          }
-          const name = yield* createDatabaseName(id, olds?.name);
-          const dbs = yield* listDbs({ accountId, name });
-          const match = dbs.result.find((db) => db.name === name);
-          if (match) {
-            return {
-              databaseId: match.uuid!,
-              databaseName: match.name ?? name,
-              jurisdiction: (olds?.jurisdiction ?? "default") as Jurisdiction,
-              readReplication: olds?.readReplication,
-              accountId,
-            };
-          }
-          return undefined;
-        }),
       };
     }),
   );

package/src/Cloudflare/KV/Delete.ts

@@ -3,12 +3,14 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
-import { NamespaceBinding } from "./NamespaceBinding.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
+import { NamespaceBinding } from "./KVNamespaceBinding.ts";
 
 export class Delete extends Binding.Service<
   Delete,
-  (namespace: Namespace) => Effect.Effect<(key: string) => Effect.Effect<void>>
+  (
+    namespace: KVNamespace,
+  ) => Effect.Effect<(key: string) => Effect.Effect<void>>
 >()("Cloudflare.KV.Delete") {}
 
 export const DeleteLive = Layer.effect(
@@ -17,7 +19,7 @@ export const DeleteLive = Layer.effect(
     const Policy = yield* DeletePolicy;
     const env = yield* WorkerEnvironment;
 
-    return Effect.fn(function* (namespace: Namespace) {
+    return Effect.fn(function* (namespace: KVNamespace) {
       yield* Policy(namespace);
       const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
         namespace.LogicalId
@@ -32,7 +34,7 @@ export const DeleteLive = Layer.effect(
 
 export class DeletePolicy extends Binding.Policy<
   DeletePolicy,
-  (namespace: Namespace) => Effect.Effect<void>
+  (namespace: KVNamespace) => Effect.Effect<void>
 >()("Cloudflare.KV.Delete") {}
 
 export const DeletePolicyLive = DeletePolicy.layer.succeed(NamespaceBinding);

package/src/Cloudflare/KV/Get.ts

@@ -3,13 +3,13 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
-import { NamespaceBinding } from "./NamespaceBinding.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
+import { NamespaceBinding } from "./KVNamespaceBinding.ts";
 
 export class Get extends Binding.Service<
   Get,
   (
-    namespace: Namespace,
+    namespace: KVNamespace,
   ) => Effect.Effect<(key: string) => Effect.Effect<string | null>>
 >()("Cloudflare.KV.Get") {}
 
@@ -19,7 +19,7 @@ export const GetLive = Layer.effect(
     const Policy = yield* GetPolicy;
     const env = yield* WorkerEnvironment;
 
-    return Effect.fn(function* (namespace: Namespace) {
+    return Effect.fn(function* (namespace: KVNamespace) {
       yield* Policy(namespace);
       const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
         namespace.LogicalId
@@ -34,7 +34,7 @@ export const GetLive = Layer.effect(
 
 export class GetPolicy extends Binding.Policy<
   GetPolicy,
-  (namespace: Namespace) => Effect.Effect<void>
+  (namespace: KVNamespace) => Effect.Effect<void>
 >()("Cloudflare.KV.Get") {}
 
 export const GetPolicyLive = GetPolicy.layer.succeed(NamespaceBinding);

package/src/Cloudflare/KV/GetWithMetadata.ts

@@ -3,15 +3,15 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
-import { NamespaceBinding } from "./NamespaceBinding.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
+import { NamespaceBinding } from "./KVNamespaceBinding.ts";
 
 export interface GetWithMetadataOptions extends runtime.KVNamespaceGetOptions<undefined> {}
 
 export class GetWithMetadata extends Binding.Service<
   GetWithMetadata,
   (
-    namespace: Namespace,
+    namespace: KVNamespace,
   ) => Effect.Effect<
     <Metadata = unknown>(
       key: string,
@@ -28,7 +28,7 @@ export const GetWithMetadataLive = Layer.effect(
     const Policy = yield* GetWithMetadataPolicy;
     const env = yield* WorkerEnvironment;
 
-    return Effect.fn(function* (namespace: Namespace) {
+    return Effect.fn(function* (namespace: KVNamespace) {
       yield* Policy(namespace);
       const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
         namespace.LogicalId
@@ -47,7 +47,7 @@ export const GetWithMetadataLive = Layer.effect(
 
 export class GetWithMetadataPolicy extends Binding.Policy<
   GetWithMetadataPolicy,
-  (namespace: Namespace) => Effect.Effect<void>
+  (namespace: KVNamespace) => Effect.Effect<void>
 >()("Cloudflare.KV.GetWithMetadata") {}
 
 export const GetWithMetadataPolicyLive =

package/src/Cloudflare/KV/{Namespace.ts → KVNamespace.ts}

@@ -21,8 +21,8 @@ export type NamespaceProps = {
   title?: string;
 };
 
-export interface Namespace extends Resource<
-  "Cloudflare.KV.Namespace",
+export type KVNamespace = Resource<
+  "Cloudflare.KVNamespace",
   NamespaceProps,
   {
     title: string;
@@ -30,16 +30,16 @@ export interface Namespace extends Resource<
     supportsUrlEncoding: boolean | undefined;
     accountId: string;
   }
-> {}
+>;
 
-export const Namespace = Resource<Namespace>("Cloudflare.KV.Namespace");
+export const KVNamespace = Resource<KVNamespace>("Cloudflare.KVNamespace");
 
 export const NamespaceProvider = (): Layer<
-  Provider<Namespace>,
+  Provider<KVNamespace>,
   never,
   Account | Credentials | HttpClient | Stack | Stage
 > =>
-  Namespace.provider.effect(
+  KVNamespace.provider.effect(
     Effect.gen(function* () {
       const accountId = yield* Account;
       const createNamespace = yield* kv.createNamespace;

package/src/Cloudflare/KV/{NamespaceBinding.ts → KVNamespaceBinding.ts}

@@ -1,11 +1,11 @@
 import * as Effect from "effect/Effect";
 import type { ResourceLike } from "../../Resource.ts";
 import { isWorker } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
 
 export const NamespaceBinding = Effect.fn(function* (
   host: ResourceLike,
-  namespace: Namespace,
+  namespace: KVNamespace,
 ) {
   if (isWorker(host)) {
     yield* host.bind`Bind(${namespace})`({