alchemy 2.0.0-beta.test-export-fix-4 → 2.0.0-cli-bundle-fix.1

package/src/Cloudflare/EdgeSession.ts

@@ -0,0 +1,144 @@
+import { Credentials } from "@distilled.cloud/cloudflare/Credentials";
+import * as workers from "@distilled.cloud/cloudflare/workers";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { CloudflareEnvironment } from "./CloudflareEnvironment.ts";
+
+/**
+ * A "remote binding" as understood by the Cloudflare Workers
+ * edge-preview API. We reuse the distilled request schema so the
+ * shape tracks Cloudflare's surface.
+ */
+type EdgeMetadata = NonNullable<
+  NonNullable<workers.CreateScriptEdgePreviewRequest["metadata"]>
+>;
+export type EdgeBinding = NonNullable<
+  NonNullable<EdgeMetadata["bindings"]>
+>[number];
+
+export class EdgeSessionError extends Data.TaggedError("EdgeSessionError")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+export interface EdgeSessionOptions {
+  /**
+   * Name used as the preview script identifier on Cloudflare's side.
+   * Shows up as the hostname: `{scriptName}.{subdomain}.workers.dev`.
+   */
+  readonly scriptName: string;
+  /** ES-module worker script(s). The first file is the entrypoint. */
+  readonly files: ReadonlyArray<File>;
+  /** Remote bindings attached to the preview worker. */
+  readonly bindings: ReadonlyArray<EdgeBinding>;
+  /** @default "2025-04-28" */
+  readonly compatibilityDate?: string;
+}
+
+/**
+ * Information needed to call a running edge-preview worker. Attach
+ * `headers` (including the `cf-workers-preview-token`) and fetch
+ * `url` or a path under it.
+ */
+export interface EdgeSessionHandle {
+  readonly url: string;
+  readonly headers: Record<string, string>;
+}
+
+const DEFAULT_COMPATIBILITY_DATE = "2025-04-28";
+
+const wrap = <A, E, R>(effect: Effect.Effect<A, E, R>, message: string) =>
+  effect.pipe(
+    Effect.mapError((cause) => new EdgeSessionError({ message, cause })),
+  );
+
+/**
+ * Ask Cloudflare for a preview upload token. Some accounts return an
+ * `exchangeUrl` that must be GET'd to swap the session token for a
+ * short-lived upload token; when present we do the swap, falling back
+ * to the original if the exchange fails.
+ */
+const createUploadToken = Effect.gen(function* () {
+  const env = yield* CloudflareEnvironment;
+  const http = yield* HttpClient.HttpClient;
+  const createSubdomainEdgePreviewSession =
+    yield* workers.createSubdomainEdgePreviewSession;
+  const { token, exchangeUrl } = yield* createSubdomainEdgePreviewSession({
+    accountId: env.accountId,
+  });
+  if (!exchangeUrl) return token;
+  const json = yield* http.get(exchangeUrl).pipe(
+    Effect.flatMap((r) => r.json),
+    Effect.timeout(30_000),
+    Effect.catch(() => Effect.succeed(null as unknown)),
+  );
+  if (
+    typeof json === "object" &&
+    json !== null &&
+    "token" in json &&
+    typeof (json as Record<string, unknown>).token === "string"
+  ) {
+    return (json as { token: string }).token;
+  }
+  return token;
+});
+
+const uploadScript = (options: EdgeSessionOptions, uploadToken: string) =>
+  Effect.gen(function* () {
+    const env = yield* CloudflareEnvironment;
+    const createScriptEdgePreview = yield* workers.createScriptEdgePreview;
+    return yield* createScriptEdgePreview({
+      accountId: env.accountId,
+      scriptName: options.scriptName,
+      cfPreviewUploadConfigToken: uploadToken,
+      wranglerSessionConfig: { workersDev: true, minimalMode: true },
+      metadata: {
+        compatibilityDate:
+          options.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
+        bindings: options.bindings as EdgeMetadata["bindings"],
+        mainModule: options.files[0]!.name,
+      },
+      // Distilled's generated schema expects a mutable array; our
+      // public surface keeps `readonly` so callers can pass a frozen
+      // tuple without a cast on their side.
+      files: options.files.slice(),
+    }).pipe(Effect.timeout(30_000));
+  });
+
+const workerHost = (scriptName: string) =>
+  Effect.gen(function* () {
+    const env = yield* CloudflareEnvironment;
+    const getSubdomain = yield* workers.getSubdomain;
+    const { subdomain } = yield* getSubdomain({ accountId: env.accountId });
+    return `${scriptName}.${subdomain}.workers.dev`;
+  });
+
+/**
+ * Upload a short-lived preview worker to Cloudflare's edge and
+ * return its URL plus the headers needed to reach it.
+ *
+ * Preview workers are ephemeral: they live only while a client keeps
+ * sending requests with the returned preview token and expire soon
+ * after. Nothing is deployed or billed.
+ */
+export const createEdgeSession = (
+  options: EdgeSessionOptions,
+): Effect.Effect<
+  EdgeSessionHandle,
+  EdgeSessionError,
+  CloudflareEnvironment | HttpClient.HttpClient | Credentials
+> =>
+  Effect.gen(function* () {
+    const [{ previewToken }, host] = yield* Effect.all(
+      [
+        createUploadToken.pipe(Effect.flatMap((t) => uploadScript(options, t))),
+        workerHost(options.scriptName),
+      ],
+      { concurrency: "unbounded" },
+    );
+    return {
+      url: `https://${host}`,
+      headers: { "cf-workers-preview-token": previewToken },
+    } satisfies EdgeSessionHandle;
+  }).pipe((e) => wrap(e, "Failed to create edge preview session"));

package/src/Cloudflare/KV/KVNamespace.ts

@@ -4,7 +4,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 { Providers } from "../Providers.ts";
 import { KVNamespaceBinding } from "./KVNamespaceBinding.ts";
 
@@ -63,7 +63,7 @@ export const KVNamespaceProvider = () =>
   Provider.effect(
     KVNamespace,
     Effect.gen(function* () {
-      const accountId = yield* Account;
+      const { accountId } = yield* CloudflareEnvironment;
       const createNamespace = yield* kv.createNamespace;
       const updateNamespace = yield* kv.updateNamespace;
       const deleteNamespace = yield* kv.deleteNamespace;

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}'`),
+      );
+    }
+  }),
+);