alchemy 0.86.0 → 0.89.0

package/src/cloudflare/workflow.ts

@@ -25,6 +25,20 @@ export interface WorkflowProps {
    * @default - bound worker script
    */
   scriptName?: string;
+  /**
+   * Limits for the workflow instance
+   */
+  limits?: {
+    /**
+     * Maximum number of steps per workflow instance.
+     *
+     * Workers Free: 1,024 (not configurable)
+     * Workers Paid: 10,000 default, configurable up to 25,000
+     *
+     * @see https://developers.cloudflare.com/workflows/reference/limits/
+     */
+    steps?: number;
+  };
   dev?: {
     /**
      * Whether to run the workflow remotely instead of locally
@@ -45,6 +59,9 @@ export type Workflow<PARAMS = unknown> = {
   workflowName: string;
   className: string;
   scriptName?: string;
+  limits?: {
+    steps?: number;
+  };
 };
 
 export function isWorkflow(binding: Binding): binding is Workflow {
@@ -77,6 +94,7 @@ export function Workflow<PARAMS = unknown>(
     workflowName,
     className,
     scriptName: props.scriptName,
+    limits: props.limits,
   };
 }
 

package/src/cloudflare/wrangler.json.ts

@@ -403,6 +403,7 @@ async function processBindings(
         binding: bindingName,
         class_name: binding.className,
         script_name: binding.scriptName,
+        ...(binding.limits ? { limits: binding.limits } : {}),
       });
     } else if (binding.type === "d1") {
       const id =

package/src/docker/api.ts

@@ -106,9 +106,48 @@ export type ContainerInfo = {
         Aliases: string[] | null;
       }
     > | null;
+    Ports?: Record<
+      string,
+      Array<{ HostIp: string; HostPort: string }> | null
+    > | null;
   };
 };
 
+export type ContainerRuntimeInfo = {
+  /**
+   * Map of internal container ports to their bound host ports.
+   * Format: "internalPort/protocol" -> hostPort (number)
+   */
+  ports: Record<string, number>;
+};
+
+export type NetworkInfo = {
+  Name: string;
+  Id: string;
+  Created: string;
+  Scope: string;
+  Driver: string;
+  EnableIPv6: boolean;
+  IPAM: {
+    Driver: string;
+    Options: Record<string, string> | null;
+    Config: Array<{
+      Subnet: string;
+      Gateway: string;
+    }> | null;
+  };
+  Internal: boolean;
+  Attachable: boolean;
+  Ingress: boolean;
+  ConfigFrom: {
+    Network: string;
+  };
+  ConfigOnly: boolean;
+  Containers: Record<string, any>;
+  Options: Record<string, string>;
+  Labels: Record<string, string>;
+};
+
 /**
  * Docker API client that wraps Docker CLI commands
  */
@@ -457,6 +496,40 @@ export class DockerApi {
     await this.exec(["network", "rm", networkId]);
   }
 
+  /**
+   * Get Docker network information
+   *
+   * @param networkId Network ID or name
+   * @returns Network details in JSON format
+   */
+  async inspectNetwork(networkId: string): Promise<NetworkInfo[]> {
+    const { stdout } = await this.exec(
+      ["network", "inspect", networkId],
+      undefined,
+      true,
+    );
+    try {
+      return JSON.parse(stdout.trim()) as NetworkInfo[];
+    } catch (_error) {
+      return [];
+    }
+  }
+
+  /**
+   * Check if a network exists
+   *
+   * @param networkId Network ID or name
+   * @returns True if network exists
+   */
+  async networkExists(networkId: string): Promise<boolean> {
+    try {
+      const networks = await this.inspectNetwork(networkId);
+      return networks.length > 0;
+    } catch (_error) {
+      return false;
+    }
+  }
+
   /**
    * Connect container to network
    *

package/src/docker/container.ts

@@ -1,6 +1,12 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
-import { DockerApi, normalizeDuration, type ContainerInfo } from "./api.ts";
+import { Secret } from "../secret.ts";
+import {
+  DockerApi,
+  normalizeDuration,
+  type ContainerInfo,
+  type ContainerRuntimeInfo,
+} from "./api.ts";
 import type { Image } from "./image.ts";
 import type { RemoteImage } from "./remote-image.ts";
 
@@ -140,7 +146,7 @@ export interface ContainerProps {
   /**
    * Environment variables
    */
-  environment?: Record<string, string>;
+  environment?: Record<string, string | Secret>;
 
   /**
    * Port mappings
@@ -207,6 +213,11 @@ export interface Container extends ContainerProps {
    * Time when the container was created
    */
   createdAt: number;
+
+  /**
+   * Inspect the container to get detailed information
+   */
+  inspect(): Promise<ContainerRuntimeInfo>;
 }
 
 /**
@@ -370,6 +381,13 @@ export const Container = Resource(
           name: containerName,
           state: containerState,
           createdAt: new Date(containerInfo.Created).getTime(),
+          inspect: async () => {
+            const [info] = await api.inspectContainer(containerName);
+            if (!info) {
+              throw new Error(`Container ${containerName} not found`);
+            }
+            return toRuntimeInfo(info);
+          },
         };
       }
     }
@@ -396,7 +414,7 @@ export const Container = Resource(
     // Create new container
     const containerId = await api.createContainer(imageRef, containerName, {
       ports: portMappings,
-      env: props.environment,
+      env: normalizeEnvironment(props.environment),
       volumes: volumeMappings,
       cmd: props.command,
       healthcheck: props.healthcheck,
@@ -424,10 +442,46 @@ export const Container = Resource(
       name: containerName,
       state: containerState,
       createdAt: Date.now(),
+      inspect: async () => {
+        const [info] = await api.inspectContainer(containerName);
+        if (!info) {
+          throw new Error(`Container ${containerName} not found`);
+        }
+        return toRuntimeInfo(info);
+      },
     };
   },
 );
 
+function toRuntimeInfo(info: ContainerInfo): ContainerRuntimeInfo {
+  const ports: Record<string, number> = {};
+  const networkSettings = info.NetworkSettings;
+
+  if (networkSettings?.Ports) {
+    for (const [internal, bindings] of Object.entries(networkSettings.Ports)) {
+      if (bindings && bindings.length > 0) {
+        ports[internal] = parseInt(bindings[0].HostPort, 10);
+      }
+    }
+  }
+
+  // Also check HostConfig.PortBindings as a fallback or additional source
+  // though NetworkSettings.Ports is usually the source of truth for running containers
+  if (info.HostConfig.PortBindings) {
+    for (const [internal, bindings] of Object.entries(
+      info.HostConfig.PortBindings,
+    )) {
+      if (bindings && bindings.length > 0 && !(internal in ports)) {
+        ports[internal] = parseInt(bindings[0].HostPort, 10);
+      }
+    }
+  }
+
+  return {
+    ports,
+  };
+}
+
 function getNetworkChanges(
   props: ContainerProps,
   containerInfo: ContainerInfo,
@@ -477,7 +531,12 @@ function shouldReplace(
   }
 
   // Environment variables
-  if (!compareEnv(props.environment, containerInfo.Config.Env)) {
+  if (
+    !compareEnv(
+      normalizeEnvironment(props.environment),
+      containerInfo.Config.Env,
+    )
+  ) {
     return true;
   }
 
@@ -513,6 +572,21 @@ function shouldReplace(
   return false;
 }
 
+/**
+ * Unwrap secrets in given environment variables
+ * @internal
+ */
+function normalizeEnvironment(
+  environment: Record<string, string | Secret> | undefined,
+): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(environment ?? {}).map(([key, value]) => [
+      key,
+      Secret.unwrap(value),
+    ]),
+  );
+}
+
 /**
  * Normalize port mappings to a comparable format
  * @internal

package/src/docker/network.ts

@@ -102,14 +102,34 @@ export const Network = Resource(
     } else {
       // Create the network
       props.driver = props.driver || "bridge";
-      const networkId = await api.createNetwork(networkName, props.driver);
+      try {
+        const networkId = await api.createNetwork(networkName, props.driver);
 
-      return {
-        ...props,
-        id: networkId,
-        name: networkName,
-        createdAt: Date.now(),
-      };
+        return {
+          ...props,
+          id: networkId,
+          name: networkName,
+          createdAt: Date.now(),
+        };
+      } catch (error: any) {
+        const errorMessage = error.message || String(error);
+        if (
+          errorMessage.includes(
+            `network with name ${networkName} already exists`,
+          )
+        ) {
+          const [details] = await api.inspectNetwork(networkName);
+          if (details) {
+            return {
+              ...props,
+              id: details.Id,
+              name: networkName,
+              createdAt: Date.parse(details.Created) || Date.now(),
+            };
+          }
+        }
+        throw error;
+      }
     }
   },
 );

package/src/planetscale/api.ts

@@ -78,7 +78,7 @@ export function createPlanetScaleClient(
   });
 }
 
-const extractToken = (props: PlanetScaleProps) => {
+export const extractToken = (props: PlanetScaleProps) => {
   if (props.apiKey) {
     return props.apiKey.unencrypted;
   } else if (props.serviceTokenId && props.serviceToken) {

package/src/planetscale/branch.ts

@@ -83,6 +83,22 @@ export interface BranchProps extends PlanetScaleProps {
    * Enable or disable safe migrations on this branch
    */
   safeMigrations?: boolean;
+
+  /**
+   * The region to create the branch in.
+   * If not provided, the branch will be created in the default region for its database.
+   * On adopt/update, if specified, the actual branch region is validated against this value.
+   *
+   * @see https://planetscale.com/docs/concepts/regions
+   */
+  region?: {
+    /**
+     * The slug identifier of the region (e.g. "us-east", "eu-west", "gcp-us-central1")
+     *
+     * @see https://planetscale.com/docs/concepts/regions#available-regions
+     */
+    slug: string;
+  };
 }
 
 /**
@@ -113,6 +129,20 @@ export interface Branch extends BranchProps {
    * HTML URL to access the branch
    */
   htmlUrl: string;
+
+  /**
+   * The region of the branch as reported by PlanetScale.
+   *
+   * @see https://planetscale.com/docs/concepts/regions
+   */
+  region: {
+    /**
+     * The slug identifier of the region (e.g. "us-east", "eu-west", "gcp-us-central1")
+     *
+     * @see https://planetscale.com/docs/concepts/regions#available-regions
+     */
+    slug: string;
+  };
 }
 
 /**
@@ -259,6 +289,18 @@ export const Branch = Resource(
       const data = getResponse.data;
       const currentParentBranch = data.parent_branch || "main";
 
+      // Validate region matches if specified
+      if (props.region) {
+        const actualSlug = data.region.slug;
+        if (actualSlug !== props.region.slug) {
+          throw new Error(
+            `Branch "${branchName}" is in region "${actualSlug}" but expected "${props.region.slug}". ` +
+              `PlanetScale branch regions cannot be changed after creation. ` +
+              `Either update the region in your configuration to match, or create a new branch in the correct region.`,
+          );
+        }
+      }
+
       // Check immutable properties
       if (props.parentBranch && parentBranchName !== currentParentBranch) {
         throw new Error(
@@ -323,6 +365,7 @@ export const Branch = Resource(
         createdAt: data.created_at,
         updatedAt: data.updated_at,
         htmlUrl: data.html_url,
+        region: { slug: data.region.slug },
       };
     }
     let clusterSize: string | undefined;
@@ -352,6 +395,7 @@ export const Branch = Resource(
         parent_branch: parentBranchName,
         backup_id: props.backupId,
         seed_data: props.seedData,
+        region: props.region?.slug,
         // This is ignored unless props.backupId is provided
         cluster_size: clusterSize,
       },
@@ -391,6 +435,7 @@ export const Branch = Resource(
       createdAt: data.created_at,
       updatedAt: data.updated_at,
       htmlUrl: data.html_url,
+      region: { slug: data.region.slug },
     };
   },
 );