alchemy 0.79.0 → 0.80.0

package/src/cloudflare/miniflare/build-worker-options.ts

@@ -1,6 +1,7 @@
 import * as miniflare from "miniflare";
 import path from "pathe";
 import { assertNever } from "../../util/assert-never.ts";
+import { reservePort } from "../../util/find-open-port.ts";
 import type { HTTPServer } from "../../util/http.ts";
 import { logger } from "../../util/logger.ts";
 import type { CloudflareApi } from "../api.ts";
@@ -83,6 +84,7 @@ export const buildWorkerOptions = async (
     // This exposes the worker as a route that can be accessed by setting the MF-Route-Override header.
     routes: [input.name],
   };
+  const port = input.port ?? (await reservePort(input.name));
   for (const [key, binding] of Object.entries(input.bindings ?? {})) {
     if (typeof binding === "string") {
       (options.bindings ??= {})[key] = binding;
@@ -92,6 +94,14 @@ export const buildWorkerOptions = async (
       (options.serviceBindings ??= {})[key] = miniflare.kCurrentWorker;
       continue;
     }
+    if (binding.type === "cloudflare::Worker::DevDomain") {
+      (options.bindings ??= {})[key] = `localhost:${port}`;
+      continue;
+    }
+    if (binding.type === "cloudflare::Worker::DevUrl") {
+      (options.bindings ??= {})[key] = `http://localhost:${port}`;
+      continue;
+    }
     switch (binding.type) {
       case "ai": {
         const existing = remoteBindings.find((b) => b.type === "ai");

package/src/cloudflare/miniflare/miniflare-controller.ts

@@ -2,7 +2,7 @@ import * as miniflare from "miniflare";
 import assert from "node:assert";
 import path from "pathe";
 import { Scope } from "../../scope.ts";
-import { findOpenPort } from "../../util/find-open-port.ts";
+import { reservePort } from "../../util/find-open-port.ts";
 import type { HTTPServer } from "../../util/http.ts";
 import { logger } from "../../util/logger.ts";
 import { AsyncMutex } from "../../util/mutex.ts";
@@ -37,6 +37,7 @@ export class MiniflareController {
 
   async add(input: MiniflareWorkerInput) {
     const { watch, remoteProxy } = await buildWorkerOptions(input);
+
     if (remoteProxy) {
       this.remoteProxies.set(input.name, remoteProxy);
     }
@@ -54,7 +55,7 @@ export class MiniflareController {
       });
     } else {
       const proxy = await createMiniflareWorkerProxy({
-        port: input.port ?? (await findOpenPort()),
+        port: input.port ?? (await reservePort(input.name)),
         getWorkerName: () => input.name,
         miniflare,
         mode: "local",

package/src/cloudflare/website.ts

@@ -5,6 +5,7 @@ import { Exec } from "../os/index.ts";
 import { Scope } from "../scope.ts";
 import { dedent } from "../util/dedent.ts";
 import { logger } from "../util/logger.ts";
+import { createCloudflareApi } from "./api.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
 import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.gen.ts";
@@ -13,6 +14,7 @@ import {
   extractStringAndSecretBindings,
   unencryptSecrets,
 } from "./util/filter-env-bindings.ts";
+import { computeWorkerDevDomain } from "./worker-subdomain.ts";
 import { type AssetsConfig, Worker, type WorkerProps } from "./worker.ts";
 import { WranglerJson, type WranglerJsonSpec } from "./wrangler.json.ts";
 
@@ -70,6 +72,10 @@ export interface WebsiteProps<B extends Bindings>
          * The command to run to start the dev server
          */
         command?: string;
+        /**
+         * The local domain to use for the dev server
+         */
+        domain?: string;
         /**
          * Additional environment variables to set when running the dev command
          */
@@ -225,11 +231,46 @@ export async function Website<B extends Bindings>(
     };
   })();
   const secrets = props.wrangler?.secrets ?? !props.wrangler?.path;
+
   const env = {
-    ...(process.env ?? {}),
-    ...(props.env ?? {}),
+    ...process.env,
+    ...props.env,
     ...extractStringAndSecretBindings(props.bindings ?? {}, secrets),
   };
+  if (props.bindings) {
+    for (const [key, value] of Object.entries(props.bindings)) {
+      if (typeof value !== "object") continue;
+      if (
+        value.type === "cloudflare::Worker::DevDomain" ||
+        value.type === "cloudflare::Worker::DevUrl"
+      ) {
+        if (Scope.current.local) {
+          const domain = typeof dev === "object" ? dev.domain : undefined;
+          if (!domain) {
+            // we can't know which port the local web server (e.g. vite dev) will use
+            // vite dev # default to 5173 or configured in vite.config.ts
+            // vite dev --port XYZ
+            // next dev # who fucking knows
+            // for now: we require the user tell us the local domain
+            throw new Error(
+              "You must set `dev.domain` when running in local development mode and a Worker.DevDomain binding",
+            );
+          }
+          env[key] =
+            value.type === "cloudflare::Worker::DevDomain"
+              ? domain
+              : `http://${domain}`;
+        } else {
+          const api = await createCloudflareApi(props);
+          const domain = await computeWorkerDevDomain(api, name);
+          env[key] =
+            value.type === "cloudflare::Worker::DevDomain"
+              ? domain
+              : `https://${domain}`;
+        }
+      }
+    }
+  }
   const worker = {
     ...workerProps,
     name,

package/src/cloudflare/worker-metadata.ts

@@ -19,7 +19,13 @@ import type {
   MultiStepMigration,
   SingleStepMigration,
 } from "./worker-migration.ts";
-import { isWorker, type AssetsConfig, type WorkerProps } from "./worker.ts";
+import { computeWorkerDevDomain } from "./worker-subdomain.ts";
+import {
+  isWorker,
+  Worker,
+  type AssetsConfig,
+  type WorkerProps,
+} from "./worker.ts";
 
 /**
  * Metadata returned by Cloudflare API for a worker script
@@ -427,6 +433,18 @@ export async function prepareWorkerMetadata(
         service: props.workerName,
         entrypoint: binding.__entrypoint__,
       });
+    } else if (binding.type === "cloudflare::Worker::DevDomain") {
+      meta.bindings.push({
+        type: "plain_text",
+        name: bindingName,
+        text: await computeWorkerDevDomain(api, props.workerName),
+      });
+    } else if (binding.type === "cloudflare::Worker::DevUrl") {
+      meta.bindings.push({
+        type: "plain_text",
+        name: bindingName,
+        text: `https://${await computeWorkerDevDomain(api, props.workerName)}`,
+      });
     } else if (binding.type === "d1") {
       meta.bindings.push({
         type: "d1",

package/src/cloudflare/worker-subdomain.ts

@@ -87,7 +87,9 @@ export async function disableWorkerSubdomain(
     `disable subdomain for "${scriptName}"`,
     api.post(
       `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
-      { enabled: false },
+      {
+        enabled: false,
+      },
     ),
   ).catch((error) => {
     if (error.status === 404) {
@@ -107,7 +109,10 @@ export async function enableWorkerSubdomain(
         `enable subdomain for "${scriptName}"`,
         api.post(
           `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
-          { enabled: true, previews_enabled: true },
+          {
+            enabled: true,
+            previews_enabled: true,
+          },
         ),
       ),
     (error) => error instanceof CloudflareApiError && error.status === 404,
@@ -116,6 +121,13 @@ export async function enableWorkerSubdomain(
   );
 }
 
+export async function computeWorkerDevDomain(
+  api: CloudflareApi,
+  scriptName: string,
+) {
+  return `${scriptName}.${await getAccountSubdomain(api)}.workers.dev`;
+}
+
 export async function getWorkerSubdomain(
   api: CloudflareApi,
   scriptName: string,

package/src/cloudflare/worker.ts

@@ -809,6 +809,17 @@ export function Worker<const B extends Bindings>(
   return _Worker(id, props as WorkerProps<B>);
 }
 
+export namespace Worker {
+  export type DevDomain = typeof DevDomain;
+  export const DevDomain = {
+    type: "cloudflare::Worker::DevDomain" as const,
+  };
+  export type DevUrl = typeof DevUrl;
+  export const DevUrl = {
+    type: "cloudflare::Worker::DevUrl" as const,
+  };
+}
+
 Worker.experimentalEntrypoint = <RPC extends Rpc.WorkerEntrypointBranded>(
   worker: Worker | WorkerRef | Self,
   entrypoint: string,

package/src/cloudflare/wrangler.json.ts

@@ -14,7 +14,8 @@ import type { EventSource } from "./event-source.ts";
 import { isQueueEventSource } from "./event-source.ts";
 import { isQueue } from "./queue.ts";
 import { unencryptSecrets } from "./util/filter-env-bindings.ts";
-import { isWorker, type Worker, type WorkerProps } from "./worker.ts";
+import { getAccountSubdomain } from "./worker-subdomain.ts";
+import { isWorker, Worker, type WorkerProps } from "./worker.ts";
 
 /**
  * Properties for wrangler.json configuration file
@@ -180,6 +181,7 @@ export async function WranglerJson(
       Scope.current.local && !props.worker.dev?.remote,
       async () =>
         worker.accountId ?? (await createCloudflareApi(worker)).accountId,
+      async () => await getAccountSubdomain(await createCloudflareApi(worker)),
     );
   }
 
@@ -253,6 +255,7 @@ async function processBindings(
   writeSecrets: boolean,
   local: boolean,
   getAccountId: () => Promise<string>,
+  getAccountSubdomain: () => Promise<string>,
 ): Promise<void> {
   // Arrays to collect different binding types
   const kvNamespaces: WranglerJsonConfig["kv_namespaces"] = [];
@@ -322,6 +325,16 @@ async function processBindings(
         service: workerName,
         entrypoint: binding.__entrypoint__,
       });
+    } else if (binding.type === "cloudflare::Worker::DevDomain") {
+      const subdomain = await getAccountSubdomain();
+      // Subdomain binding
+      (spec.vars ??= {})[bindingName] =
+        `${workerName}.${subdomain}.workers.dev`;
+    } else if (binding.type === "cloudflare::Worker::DevUrl") {
+      const subdomain = await getAccountSubdomain();
+      // Subdomain binding
+      (spec.vars ??= {})[bindingName] =
+        `https://${workerName}.${subdomain}.workers.dev`;
     } else if (binding.type === "service") {
       // Service binding
       services.push({

package/src/docker/api.ts

@@ -69,6 +69,12 @@ type VolumeInfo = {
   Scope: string;
 };
 
+type ContainerInfo = {
+  Id: string;
+  State: { Status: "created" | "running" | "paused" | "stopped" | "exited" };
+  Created: string;
+};
+
 /**
  * Docker API client that wraps Docker CLI commands
  */
@@ -351,6 +357,21 @@ export class DockerApi {
     return stdout;
   }
 
+  /**
+   * Get Docker container information
+   *
+   * @param containerId Container ID or name
+   * @returns Container details in JSON format
+   */
+  async inspectContainer(containerId: string): Promise<ContainerInfo[]> {
+    const { stdout } = await this.exec(["container", "inspect", containerId]);
+    try {
+      return JSON.parse(stdout.trim()) as ContainerInfo[];
+    } catch (_error) {
+      return [];
+    }
+  }
+
   /**
    * Check if a container exists
    *
@@ -359,7 +380,7 @@ export class DockerApi {
    */
   async containerExists(containerId: string): Promise<boolean> {
     try {
-      await this.exec(["inspect", containerId]);
+      await this.inspectContainer(containerId);
       return true;
     } catch (_error) {
       return false;

package/src/docker/container.ts

@@ -176,6 +176,12 @@ export interface ContainerProps {
    * Healthcheck configuration
    */
   healthcheck?: HealthcheckConfig;
+
+  /**
+   * Whether to adopt the container if it already exists
+   * @default false
+   */
+  adopt?: boolean;
 }
 
 /**
@@ -303,71 +309,96 @@ export const Container = Resource(
 
       // Return destroyed state
       return this.destroy();
-    } else {
-      let containerState: NonNullable<Container["state"]> = "created";
+    }
 
-      if (this.phase === "update") {
-        // Check if container already exists (for update)
-        const containerExists = await api.containerExists(containerName);
+    let containerState: NonNullable<Container["state"]> = "created";
 
-        if (containerExists) {
-          // Remove existing container for update
-          await api.removeContainer(containerName, true);
+    // Check if container already exists
+    const containerExists = await api.containerExists(containerName);
+
+    if (containerExists) {
+      if (this.phase === "update") {
+        // Remove existing container for update
+        await api.removeContainer(containerName, true);
+      } else {
+        // Create phase - check for adoption
+        if (!props.adopt) {
+          throw new Error(
+            `Container "${containerName}" already exists. Use adopt: true to adopt it.`,
+          );
         }
-      }
 
-      // Prepare port mappings
-      const portMappings: Record<string, string> = {};
-      if (props.ports) {
-        for (const port of props.ports) {
-          const protocol = port.protocol || "tcp";
-          portMappings[`${port.external}`] = `${port.internal}/${protocol}`;
+        // Adopt existing container
+        const containerInfos = await api.inspectContainer(containerName);
+        const containerInfo = containerInfos[0];
+        let adoptedState = containerInfo.State.Status;
+
+        // Optionally start the container if requested
+        if (props.start && containerInfo.State.Status !== "running") {
+          await api.startContainer(containerName);
+          adoptedState = "running";
         }
+
+        return {
+          ...props,
+          id: containerInfo.Id,
+          name: containerName,
+          state: adoptedState,
+          createdAt: new Date(containerInfo.Created).getTime(),
+        };
       }
+    }
 
-      // Prepare volume mappings
-      const volumeMappings: Record<string, string> = {};
-      if (props.volumes) {
-        for (const volume of props.volumes) {
-          const readOnlyFlag = volume.readOnly ? ":ro" : "";
-          volumeMappings[volume.hostPath] =
-            `${volume.containerPath}${readOnlyFlag}`;
-        }
+    // Prepare port mappings
+    const portMappings: Record<string, string> = {};
+    if (props.ports) {
+      for (const port of props.ports) {
+        const protocol = port.protocol || "tcp";
+        portMappings[`${port.external}`] = `${port.internal}/${protocol}`;
       }
+    }
 
-      // Create new container
-      const containerId = await api.createContainer(imageRef, containerName, {
-        ports: portMappings,
-        env: props.environment,
-        volumes: volumeMappings,
-        cmd: props.command,
-        healthcheck: props.healthcheck,
-      });
-
-      // Connect to networks if specified
-      if (props.networks) {
-        for (const network of props.networks) {
-          const networkId =
-            typeof network === "string" ? network : network.name;
-          await api.connectNetwork(containerId, networkId, {
-            aliases: network.aliases,
-          });
-        }
+    // Prepare volume mappings
+    const volumeMappings: Record<string, string> = {};
+    if (props.volumes) {
+      for (const volume of props.volumes) {
+        const readOnlyFlag = volume.readOnly ? ":ro" : "";
+        volumeMappings[volume.hostPath] =
+          `${volume.containerPath}${readOnlyFlag}`;
       }
+    }
 
-      // Start container if requested
-      if (props.start) {
-        await api.startContainer(containerId);
-        containerState = "running";
+    // Create new container
+    const containerId = await api.createContainer(imageRef, containerName, {
+      ports: portMappings,
+      env: props.environment,
+      volumes: volumeMappings,
+      cmd: props.command,
+      healthcheck: props.healthcheck,
+    });
+
+    // Connect to networks if specified
+    if (props.networks) {
+      for (const network of props.networks) {
+        const networkId = typeof network === "string" ? network : network.name;
+        await api.connectNetwork(containerId, networkId, {
+          aliases: network.aliases,
+        });
       }
+    }
 
-      return {
-        ...props,
-        id: containerId,
-        name: containerName,
-        state: containerState,
-        createdAt: Date.now(),
-      };
+    // Start container if requested
+    if (props.start) {
+      await api.startContainer(containerId);
+      containerState = "running";
     }
+
+    return {
+      ...props,
+      id: containerId,
+      name: containerName,
+      state: containerState,
+      createdAt: Date.now(),
+    };
   },
 );

package/src/docker/volume.ts

@@ -43,6 +43,12 @@ export interface VolumeProps {
    * Custom metadata labels for the volume
    */
   labels?: VolumeLabel[] | Record<string, string>;
+
+  /**
+   * Whether to adopt the volume if it already exists
+   * @default false
+   */
+  adopt?: boolean;
 }
 
 /**
@@ -133,33 +139,64 @@ export const Volume = Resource(
 
       // Return destroyed state
       return this.destroy();
-    } else {
-      // Set default driver if not provided
-      const driver = props.driver || "local";
-      const driverOpts = props.driverOpts || {};
-
-      // Create the volume
-      const volumeId = await api.createVolume(
-        volumeName,
-        driver,
-        driverOpts,
-        processedLabels,
-      );
-
-      // Get volume details to retrieve mountpoint
-      const volumeInfos = await api.inspectVolume(volumeId);
-      const mountpoint = volumeInfos[0].Mountpoint;
-
-      return {
-        ...props,
-        driver: driver,
-        id: volumeId,
-        name: volumeName,
-        mountpoint,
-        createdAt: Date.now(),
-        labels: Array.isArray(props.labels) ? props.labels : undefined,
-        driverOpts: props.driverOpts,
-      };
     }
+
+    // Check if volume already exists
+    const volumeExists = await api.volumeExists(volumeName);
+
+    if (volumeExists) {
+      if (this.phase === "update") {
+        this.replace();
+      } else {
+        // Create phase - check for adoption
+        if (!props.adopt) {
+          throw new Error(
+            `Volume "${volumeName}" already exists. Use adopt: true to adopt it.`,
+          );
+        }
+
+        // Adopt existing volume
+        const volumeInfos = await api.inspectVolume(volumeName);
+        const volumeInfo = volumeInfos[0];
+
+        return {
+          ...props,
+          id: volumeInfo.Name,
+          name: volumeInfo.Name,
+          driver: volumeInfo.Driver,
+          mountpoint: volumeInfo.Mountpoint,
+          createdAt: new Date(volumeInfo.CreatedAt).getTime(),
+          labels: Array.isArray(props.labels) ? props.labels : undefined,
+          driverOpts: volumeInfo.Options,
+        };
+      }
+    }
+
+    // Set default driver if not provided
+    const driver = props.driver || "local";
+    const driverOpts = props.driverOpts || {};
+
+    // Create the volume
+    const volumeId = await api.createVolume(
+      volumeName,
+      driver,
+      driverOpts,
+      processedLabels,
+    );
+
+    // Get volume details to retrieve mountpoint
+    const volumeInfos = await api.inspectVolume(volumeId);
+    const mountpoint = volumeInfos[0].Mountpoint;
+
+    return {
+      ...props,
+      driver: driver,
+      id: volumeId,
+      name: volumeName,
+      mountpoint,
+      createdAt: Date.now(),
+      labels: Array.isArray(props.labels) ? props.labels : undefined,
+      driverOpts: props.driverOpts,
+    };
   },
 );