alchemy 2.0.0-beta.10 → 2.0.0-beta.13

package/src/Cloudflare/Providers.ts

@@ -1,15 +1,17 @@
-import * as Auth from "@distilled.cloud/cloudflare/Auth";
 import * as Layer from "effect/Layer";
-import * as Socket from "effect/unstable/socket/Socket";
 import { Command } from "../Build/Command.ts";
 import * as Build from "../Build/index.ts";
 import * as Provider from "../Provider.ts";
 import { Random, RandomProvider } from "../Random.ts";
-import * as Account from "./Account.ts";
+import { CloudflareAuth } from "./Auth/AuthProvider.ts";
+import * as CloudflareEnvironment from "./CloudflareEnvironment.ts";
 import * as Containers from "./Container/index.ts";
+import * as Credentials from "./Credentials.ts";
 import * as D1 from "./D1/index.ts";
 import * as KV from "./KV/index.ts";
+import * as Queue from "./Queue/index.ts";
 import * as R2 from "./R2/index.ts";
+import * as SecretsStore from "./SecretsStore/index.ts";
 import * as Workers from "./Workers/index.ts";
 import * as Workflows from "./Workers/Workflow.ts";
 
@@ -34,8 +36,14 @@ export const providers = () =>
       D1.D1Database,
       KV.KVNamespace,
       KV.KVNamespaceBindingPolicy,
+      Queue.Queue,
+      Queue.QueueBindingPolicy,
+      Queue.QueueConsumer,
       R2.R2Bucket,
       R2.R2BucketBindingPolicy,
+      SecretsStore.SecretBindingPolicy,
+      SecretsStore.SecretsStore,
+      SecretsStore.Secret,
       Random,
       Workers.BindWorkerPolicy,
       Workers.FetchPolicy,
@@ -50,8 +58,14 @@ export const providers = () =>
         D1.DatabaseProvider(),
         KV.KVNamespaceBindingPolicyLive,
         KV.KVNamespaceProvider(),
+        Queue.QueueBindingPolicyLive,
+        Queue.QueueProvider(),
+        Queue.QueueConsumerProvider(),
         R2.R2BucketBindingPolicyLive,
         R2.R2BucketProvider(),
+        SecretsStore.SecretBindingPolicyLive,
+        SecretsStore.SecretsStoreProvider(),
+        SecretsStore.StoreSecretProvider(),
         Workers.BindWorkerPolicyLive,
         Workers.FetchPolicyLive,
         Workers.WorkerProvider(),
@@ -61,12 +75,8 @@ export const providers = () =>
     Layer.provideMerge(
       Layer.mergeAll(Build.CommandProvider(), RandomProvider()),
     ),
-    Layer.provideMerge(
-      Layer.mergeAll(
-        Account.fromStageConfig(),
-        Auth.fromEnv(),
-        Socket.layerWebSocketConstructorGlobal,
-      ),
-    ),
+    Layer.provideMerge(Credentials.fromAuthProvider()),
+    Layer.provideMerge(CloudflareEnvironment.fromProfile()),
+    Layer.provideMerge(CloudflareAuth),
     Layer.orDie,
   );

package/src/Cloudflare/Queue/Queue.ts

@@ -0,0 +1,174 @@
+import * as queues from "@distilled.cloud/cloudflare/queues";
+import * as Effect from "effect/Effect";
+import { isResolved } from "../../Diff.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Providers } from "../Providers.ts";
+import { QueueBinding } from "./QueueBinding.ts";
+
+export type QueueProps = {
+  /**
+   * Name of the queue. If omitted, a unique name will be generated.
+   * @default ${app}-${stage}-${id}
+   */
+  name?: string;
+};
+
+export type Queue = Resource<
+  "Cloudflare.Queue",
+  QueueProps,
+  {
+    queueId: string;
+    queueName: string;
+    accountId: string;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * A Cloudflare Queue for reliable message passing between Workers.
+ *
+ * Queues enable you to send and receive messages with guaranteed delivery.
+ * Create a queue as a resource, then bind it to a Worker to send messages
+ * at runtime. Register a consumer to process messages.
+ *
+ * @section Creating a Queue
+ * @example Basic queue
+ * ```typescript
+ * const queue = yield* Cloudflare.Queue("MyQueue");
+ * ```
+ *
+ * @example Queue with explicit name
+ * ```typescript
+ * const queue = yield* Cloudflare.Queue("MyQueue", {
+ *   name: "my-app-queue",
+ * });
+ * ```
+ *
+ * @section Binding to a Worker
+ * @example Sending messages from a Worker
+ * ```typescript
+ * // In your Worker definition, add the queue to bindings:
+ * const Worker = Cloudflare.Worker("Worker", {
+ *   bindings: { MY_QUEUE: queue },
+ * });
+ * ```
+ */
+export const Queue = Resource<Queue>("Cloudflare.Queue")({
+  bind: QueueBinding.bind,
+});
+
+export const QueueProvider = () =>
+  Provider.effect(
+    Queue,
+    Effect.gen(function* () {
+      const { accountId } = yield* CloudflareEnvironment;
+      const createQueue = yield* queues.createQueue;
+      const getQueue = yield* queues.getQueue;
+      const updateQueue = yield* queues.updateQueue;
+      const deleteQueue = yield* queues.deleteQueue;
+      const listQueues = yield* queues.listQueues;
+
+      const createQueueName = (id: string, name: string | undefined) =>
+        Effect.gen(function* () {
+          if (name) return name;
+          return (yield* createPhysicalName({
+            id,
+            maxLength: 63,
+          })).toLowerCase();
+        });
+
+      return {
+        stables: ["queueId", "accountId"],
+        diff: Effect.fn(function* ({ id, olds = {}, news = {}, output }) {
+          if (!isResolved(news)) return undefined;
+          if ((output?.accountId ?? accountId) !== accountId) {
+            return { action: "replace" } as const;
+          }
+          const name = yield* createQueueName(id, news.name);
+          const oldName = output?.queueName
+            ? output.queueName
+            : yield* createQueueName(id, olds.name);
+          if (name !== oldName) {
+            return { action: "replace" } as const;
+          }
+        }),
+        create: Effect.fn(function* ({ id, news = {} }) {
+          const queueName = yield* createQueueName(id, news.name);
+          const queue = yield* createQueue({
+            accountId,
+            queueName,
+          }).pipe(
+            Effect.catch(() =>
+              Effect.gen(function* () {
+                // Queue may already exist -- look it up by name
+                const allQueues = yield* listQueues({ accountId });
+                const match = allQueues.result.find(
+                  (q) => q.queueName === queueName,
+                );
+                if (match && match.queueId && match.queueName) {
+                  return match as { queueId: string; queueName: string };
+                }
+                return yield* Effect.die(
+                  `Queue "${queueName}" already exists but could not be found`,
+                );
+              }),
+            ),
+          );
+          return {
+            queueId: queue.queueId!,
+            queueName: queue.queueName!,
+            accountId,
+          };
+        }),
+        update: Effect.fn(function* ({ id, news = {}, output }) {
+          const queueName = yield* createQueueName(id, news.name);
+          const queue = yield* updateQueue({
+            accountId: output.accountId,
+            queueId: output.queueId,
+            queueName,
+          });
+          return {
+            queueId: queue.queueId!,
+            queueName: queue.queueName!,
+            accountId: output.accountId,
+          };
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* deleteQueue({
+            accountId: output.accountId,
+            queueId: output.queueId,
+          }).pipe(Effect.catch(() => Effect.void));
+        }),
+        read: Effect.fn(function* ({ id, output, olds }) {
+          if (output?.queueId) {
+            return yield* getQueue({
+              accountId: output.accountId,
+              queueId: output.queueId,
+            }).pipe(
+              Effect.map((queue) => ({
+                queueId: queue.queueId!,
+                queueName: queue.queueName!,
+                accountId: output.accountId,
+              })),
+              Effect.catch(() => Effect.succeed(undefined)),
+            );
+          }
+          const queueName = yield* createQueueName(id, olds?.name);
+          const allQueues = yield* listQueues({ accountId });
+          const match = allQueues.result.find((q) => q.queueName === queueName);
+          if (match && match.queueId && match.queueName) {
+            return {
+              queueId: match.queueId,
+              queueName: match.queueName,
+              accountId,
+            };
+          }
+          return undefined;
+        }),
+      };
+    }),
+  );

package/src/Cloudflare/Queue/QueueBinding.ts

@@ -0,0 +1,110 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
+import type { Queue } from "./Queue.ts";
+
+export interface QueueSender {
+  raw: Effect.Effect<any, never, WorkerEnvironment>;
+  send(
+    body: unknown,
+    options?: { contentType?: "json" | "text" },
+  ): Effect.Effect<void, QueueSendError, WorkerEnvironment>;
+  sendBatch(
+    messages: ReadonlyArray<{
+      body: unknown;
+      contentType?: "json" | "text";
+    }>,
+  ): Effect.Effect<void, QueueSendError, WorkerEnvironment>;
+}
+
+import * as Data from "effect/Data";
+
+export class QueueSendError extends Data.TaggedError("QueueSendError")<{
+  message: string;
+  cause?: unknown;
+}> {}
+
+export class QueueBinding extends Binding.Service<
+  QueueBinding,
+  (queue: Queue) => Effect.Effect<QueueSender>
+>()("Cloudflare.Queue") {}
+
+export const QueueBindingLive = Layer.effect(
+  QueueBinding,
+  Effect.gen(function* () {
+    const bind = yield* QueueBindingPolicy;
+
+    return Effect.fn(function* (queue: Queue) {
+      yield* bind(queue);
+      const env = WorkerEnvironment.asEffect();
+      const raw = env.pipe(
+        Effect.map((env) => (env as Record<string, any>)[queue.LogicalId]),
+      );
+
+      const tryPromise = <T>(
+        fn: () => Promise<T>,
+      ): Effect.Effect<T, QueueSendError> =>
+        Effect.tryPromise({
+          try: fn,
+          catch: (error: any) =>
+            new QueueSendError({
+              message: error?.message ?? "Unknown queue error",
+              cause: error,
+            }),
+        });
+
+      return {
+        raw,
+        send: (body: unknown, options?: { contentType?: "json" | "text" }) =>
+          raw.pipe(
+            Effect.flatMap((q) => tryPromise(() => q.send(body, options))),
+          ),
+        sendBatch: (
+          messages: ReadonlyArray<{
+            body: unknown;
+            contentType?: "json" | "text";
+          }>,
+        ) =>
+          raw.pipe(
+            Effect.flatMap((q) =>
+              tryPromise(() =>
+                q.sendBatch(
+                  messages.map((m) => ({
+                    body: m.body,
+                    ...(m.contentType ? { contentType: m.contentType } : {}),
+                  })),
+                ),
+              ),
+            ),
+          ),
+      } satisfies QueueSender;
+    });
+  }),
+);
+
+export class QueueBindingPolicy extends Binding.Policy<
+  QueueBindingPolicy,
+  (queue: Queue) => Effect.Effect<void>
+>()("Cloudflare.Queue") {}
+
+export const QueueBindingPolicyLive = QueueBindingPolicy.layer.succeed(
+  Effect.fnUntraced(function* (host: ResourceLike, queue: Queue) {
+    if (isWorker(host)) {
+      yield* host.bind`${queue}`({
+        bindings: [
+          {
+            type: "queue",
+            name: queue.LogicalId,
+            queueName: queue.queueName,
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        new Error(`QueueBinding does not support runtime '${host.Type}'`),
+      );
+    }
+  }),
+);

package/src/Cloudflare/Queue/QueueConsumer.ts

@@ -0,0 +1,219 @@
+import * as queues from "@distilled.cloud/cloudflare/queues";
+import * as Effect from "effect/Effect";
+import { isResolved } from "../../Diff.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Providers } from "../Providers.ts";
+
+export type QueueConsumerProps = {
+  /**
+   * The queue ID to attach the consumer to.
+   */
+  queueId: string;
+  /**
+   * Name of the Worker script that will consume messages.
+   */
+  scriptName: string;
+  /**
+   * Optional dead letter queue name for failed messages.
+   */
+  deadLetterQueue?: string;
+  /**
+   * Consumer settings.
+   */
+  settings?: {
+    /**
+     * The maximum number of messages per batch.
+     * @default 10
+     */
+    batchSize?: number;
+    /**
+     * The maximum number of concurrent consumer invocations.
+     */
+    maxConcurrency?: number;
+    /**
+     * The maximum number of retries for a message.
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * The maximum time to wait for a batch to fill, in milliseconds.
+     * @default 5000
+     */
+    maxWaitTimeMs?: number;
+    /**
+     * The number of seconds to wait before retrying a message.
+     */
+    retryDelay?: number;
+  };
+};
+
+export type QueueConsumer = Resource<
+  "Cloudflare.QueueConsumer",
+  QueueConsumerProps,
+  {
+    consumerId: string;
+    queueId: string;
+    scriptName: string;
+    accountId: string;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * A Cloudflare Queue Consumer that processes messages from a Queue.
+ *
+ * Register a Worker as a consumer of a Queue. The Worker's `queue()`
+ * handler will be invoked with batches of messages.
+ *
+ * @section Registering a Consumer
+ * @example Basic consumer
+ * ```typescript
+ * const queue = yield* Cloudflare.Queue("MyQueue");
+ * const worker = yield* Cloudflare.Worker("Worker", { ... });
+ *
+ * yield* Cloudflare.QueueConsumer("MyConsumer", {
+ *   queueId: queue.queueId,
+ *   scriptName: "my-worker",
+ * });
+ * ```
+ *
+ * @example Consumer with settings
+ * ```typescript
+ * yield* Cloudflare.QueueConsumer("MyConsumer", {
+ *   queueId: queue.queueId,
+ *   scriptName: "my-worker",
+ *   settings: {
+ *     batchSize: 50,
+ *     maxRetries: 5,
+ *     maxWaitTimeMs: 10000,
+ *   },
+ * });
+ * ```
+ */
+export const QueueConsumer = Resource<QueueConsumer>(
+  "Cloudflare.QueueConsumer",
+);
+
+export const QueueConsumerProvider = () =>
+  Provider.effect(
+    QueueConsumer,
+    Effect.gen(function* () {
+      const { accountId } = yield* CloudflareEnvironment;
+      const createConsumer = yield* queues.createConsumer;
+      const getConsumer = yield* queues.getConsumer;
+      const updateConsumer = yield* queues.updateConsumer;
+      const deleteConsumer = yield* queues.deleteConsumer;
+      const listConsumers = yield* queues.listConsumers;
+
+      return {
+        stables: ["consumerId", "accountId"],
+        diff: Effect.fn(function* ({ olds, news, output }) {
+          if (!isResolved(news)) return undefined;
+          if ((output?.accountId ?? accountId) !== accountId) {
+            return { action: "replace" } as const;
+          }
+          // Queue change requires replacement
+          if (output?.queueId && news.queueId !== output.queueId) {
+            return { action: "replace" } as const;
+          }
+          // Script change requires replacement
+          if (output?.scriptName && news.scriptName !== output.scriptName) {
+            return { action: "replace" } as const;
+          }
+          // Settings change is an update
+          if (
+            JSON.stringify(olds.settings ?? {}) !==
+            JSON.stringify(news.settings ?? {})
+          ) {
+            return { action: "update" } as const;
+          }
+        }),
+        create: Effect.fn(function* ({ news }) {
+          const consumer = yield* createConsumer({
+            accountId,
+            queueId: news.queueId!,
+            scriptName: news.scriptName,
+            type: "worker",
+            deadLetterQueue: news.deadLetterQueue,
+            settings: news.settings,
+          }).pipe(
+            Effect.catch(() =>
+              Effect.gen(function* () {
+                // Consumer may already exist -- look it up
+                const existing = yield* listConsumers({
+                  accountId,
+                  queueId: news.queueId!,
+                });
+                const match = existing.result.find(
+                  (c) => "script" in c && c.script === news.scriptName,
+                );
+                if (match && match.consumerId) {
+                  return match as {
+                    consumerId: string;
+                    queueId?: string | null;
+                  };
+                }
+                return yield* Effect.die(
+                  `Consumer for script "${news.scriptName}" on queue "${news.queueId}" already exists but could not be found`,
+                );
+              }),
+            ),
+          );
+          return {
+            consumerId: consumer.consumerId!,
+            queueId: news.queueId!,
+            scriptName: news.scriptName!,
+            accountId,
+          };
+        }),
+        update: Effect.fn(function* ({ news, output }) {
+          yield* updateConsumer({
+            accountId: output.accountId,
+            queueId: output.queueId,
+            consumerId: output.consumerId,
+            scriptName: news.scriptName,
+            type: "worker",
+            settings: news.settings,
+            deadLetterQueue: news.deadLetterQueue,
+          });
+          return {
+            consumerId: output.consumerId,
+            queueId: output.queueId,
+            scriptName: news.scriptName ?? output.scriptName,
+            accountId: output.accountId,
+          };
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* deleteConsumer({
+            accountId: output.accountId,
+            queueId: output.queueId,
+            consumerId: output.consumerId,
+          }).pipe(Effect.catch(() => Effect.void));
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (output?.consumerId) {
+            return yield* getConsumer({
+              accountId: output.accountId,
+              queueId: output.queueId,
+              consumerId: output.consumerId,
+            }).pipe(
+              Effect.map((consumer) => ({
+                consumerId: consumer.consumerId!,
+                queueId: output.queueId,
+                scriptName:
+                  ("script" in consumer
+                    ? (consumer.script as string)
+                    : output.scriptName) ?? output.scriptName,
+                accountId: output.accountId,
+              })),
+              Effect.catch(() => Effect.succeed(undefined)),
+            );
+          }
+          return undefined;
+        }),
+      };
+    }),
+  );

package/src/Cloudflare/Queue/index.ts

@@ -0,0 +1,3 @@
+export * from "./Queue.ts";
+export * from "./QueueBinding.ts";
+export * from "./QueueConsumer.ts";

package/src/Cloudflare/R2/R2Bucket.ts

@@ -5,7 +5,7 @@ import { isResolved } from "../../Diff.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
-import { Account } from "../Account.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import type * as Cloudflare from "../Providers.ts";
 import { R2BucketBinding } from "./R2BucketBinding.ts";
 
@@ -104,7 +104,7 @@ export const R2BucketProvider = () =>
   Provider.effect(
     R2Bucket,
     Effect.gen(function* () {
-      const accountId = yield* Account;
+      const { accountId } = yield* CloudflareEnvironment;
       const createBucket = yield* r2.createBucket;
       const patchBucket = yield* r2.patchBucket;
       const deleteBucket = yield* r2.deleteBucket;