alchemy 0.87.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

@@ -121,6 +121,33 @@ export type ContainerRuntimeInfo = {
   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
  */
@@ -469,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/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 },
     };
   },
 );