alchemy 0.54.0 → 0.55.0

package/src/aws/index.ts

@@ -9,3 +9,12 @@ export * from "./s3-state-store.ts";
 export * from "./ses.ts";
 export * from "./ssm-parameter.ts";
 export * from "./table.ts";
+
+// EC2 Resources
+export * from "./ec2/internet-gateway.ts";
+export * from "./ec2/nat-gateway.ts";
+export * from "./ec2/route-table.ts";
+export * from "./ec2/route.ts";
+export * from "./ec2/security-group.ts";
+export * from "./ec2/subnet.ts";
+export * from "./ec2/vpc.ts";

package/src/aws/utils.ts

@@ -0,0 +1,137 @@
+import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
+import { loadConfig } from "@smithy/node-config-provider";
+import { AwsClient } from "aws4fetch";
+import { flattenParams } from "../util/params.ts";
+
+/**
+ * Get AWS region from configuration
+ */
+export const getRegion = loadConfig({
+  environmentVariableSelector: (env: any) =>
+    env.AWS_REGION || env.AWS_DEFAULT_REGION,
+  configFileSelector: (profile: any) => profile.region,
+  default: "us-east-1",
+});
+
+/**
+ * AWS Service Configuration
+ */
+export interface AwsServiceConfig {
+  service: string;
+  version: string;
+  endpoint: (region: string) => string;
+}
+
+/**
+ * AWS API Caller interface
+ */
+export interface AwsApiCaller<T = any> {
+  createClient(): Promise<AwsClient>;
+  callApi<R = T>(
+    client: AwsClient,
+    action: string,
+    params?: Record<string, any>,
+  ): Promise<R>;
+}
+
+/**
+ * Create an AWS API caller for a specific service
+ */
+export function getAwsApiCaller<T = any>(
+  config: AwsServiceConfig,
+  responseParser: (xmlText: string) => T,
+): AwsApiCaller<T> {
+  return {
+    async createClient(): Promise<AwsClient> {
+      const credentials = await fromNodeProviderChain()();
+      const region = await getRegion();
+
+      return new AwsClient({
+        ...credentials,
+        service: config.service,
+        region,
+      });
+    },
+
+    async callApi<R = T>(
+      client: AwsClient,
+      action: string,
+      params: Record<string, any> = {},
+    ): Promise<R> {
+      // Try the API call, and retry once with fresh credentials on auth failure
+      for (let attempt = 1; attempt <= 2; attempt++) {
+        try {
+          const region = await getRegion();
+          const url = config.endpoint(region);
+
+          const body = new URLSearchParams({
+            Action: action,
+            Version: config.version,
+            ...flattenParams(params),
+          });
+
+          const signedRequest = await client.sign(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: body.toString(),
+          });
+
+          const response = await fetch(signedRequest);
+
+          if (!response.ok) {
+            const errorText = await response.text();
+
+            // Parse AWS error code from XML response
+            const errorCodeMatch = errorText.match(/<Code>([^<]+)<\/Code>/);
+            const errorCode = errorCodeMatch ? errorCodeMatch[1] : null;
+
+            // If this is an auth failure and we haven't retried yet, create a fresh client and retry
+            if (errorCode === "AuthFailure" && attempt === 1) {
+              console.log(
+                `🔄 Auth failure detected, refreshing credentials and retrying ${action}...`,
+              );
+              // Create a fresh client with new credentials
+              const freshCredentials = await fromNodeProviderChain()();
+              const region = await getRegion();
+              client = new AwsClient({
+                ...freshCredentials,
+                service: config.service,
+                region,
+              });
+              continue; // Retry with fresh client
+            }
+
+            const error = new Error(
+              `${config.service.toUpperCase()} API error: ${response.status} ${response.statusText}\n${errorText}`,
+            );
+
+            // Set the error code for the ignore function
+            if (errorCode) {
+              (error as any).code = errorCode;
+            }
+
+            throw error;
+          }
+
+          const xmlText = await response.text();
+          const parsed = responseParser(xmlText);
+          return parsed as unknown as R;
+        } catch (error) {
+          // If it's not an auth failure or we've already retried, throw the error
+          if (
+            attempt === 2 ||
+            !(error as any)?.message?.includes("AuthFailure")
+          ) {
+            throw error;
+          }
+          // Otherwise, continue to retry
+        }
+      }
+
+      // This should never be reached, but TypeScript needs it
+      throw new Error("Unexpected error in API call retry logic");
+    },
+  };
+}

package/src/build-date.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated during build
+// Do not edit manually
+
+/**
+ * The build date used as the default worker compatibility date.
+ * This is set to the date when the package was built.
+ */
+export const BUILD_DATE = "2025-07-13";

package/src/util/params.ts

@@ -0,0 +1,33 @@
+/**
+ * Flatten nested parameters for API calls
+ */
+export function flattenParams(
+  params: Record<string, any>,
+  prefix = "",
+): Record<string, string> {
+  const result: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(params)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+
+    if (value === null || value === undefined) {
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        if (typeof item === "object") {
+          Object.assign(result, flattenParams(item, `${fullKey}.${index + 1}`));
+        } else {
+          result[`${fullKey}.${index + 1}`] = String(item);
+        }
+      });
+    } else if (typeof value === "object") {
+      Object.assign(result, flattenParams(value, fullKey));
+    } else {
+      result[fullKey] = String(value);
+    }
+  }
+
+  return result;
+}

package/src/util/timeout.ts

@@ -0,0 +1,178 @@
+/**
+ * Timeout configuration interface
+ */
+export interface TimeoutConfig {
+  maxAttempts: number;
+  delayMs: number;
+}
+
+/**
+ * Resource timeout error class
+ */
+export class ResourceTimeoutError extends Error {
+  constructor(
+    resourceType: string,
+    resourceId: string,
+    timeoutMs: number,
+    operation: string,
+  ) {
+    super(
+      `${resourceType} ${resourceId} did not complete ${operation} within ${timeoutMs}ms`,
+    );
+    this.name = "ResourceTimeoutError";
+  }
+}
+
+/**
+ * Validate timeout configuration
+ */
+export function validateTimeoutConfig(config: TimeoutConfig): void {
+  if (config.maxAttempts <= 0) {
+    throw new Error("maxAttempts must be greater than 0");
+  }
+  if (config.delayMs <= 0) {
+    throw new Error("delayMs must be greater than 0");
+  }
+}
+
+/**
+ * Merge default timeout configuration with optional overrides
+ */
+export function mergeTimeoutConfig(
+  defaultConfig: TimeoutConfig,
+  override?: Partial<TimeoutConfig>,
+): TimeoutConfig {
+  if (!override) {
+    return defaultConfig;
+  }
+
+  const merged = {
+    maxAttempts: override.maxAttempts ?? defaultConfig.maxAttempts,
+    delayMs: override.delayMs ?? defaultConfig.delayMs,
+  };
+
+  validateTimeoutConfig(merged);
+  return merged;
+}
+
+/**
+ * Wait for a resource to reach a desired state with configurable timeout
+ */
+export async function waitForResourceState<T>(
+  checkFunction: () => Promise<T>,
+  isReady: (result: T) => boolean,
+  config: TimeoutConfig,
+  resourceId: string,
+  resourceType: string,
+  operation = "become ready",
+): Promise<void> {
+  validateTimeoutConfig(config);
+  const { maxAttempts, delayMs } = config;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const result = await checkFunction();
+      if (isReady(result)) {
+        return;
+      }
+
+      console.log(
+        `${resourceType} ${resourceId} not ready, waiting... (attempt ${attempt}/${maxAttempts})`,
+      );
+
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    } catch (error) {
+      console.log(
+        `Error checking ${resourceType} status (attempt ${attempt}/${maxAttempts}):`,
+        error,
+      );
+
+      // Check if this is a non-retryable error (contains "NonRetryableError" in the name)
+      if (error instanceof Error && error.name.includes("NonRetryableError")) {
+        throw error;
+      }
+
+      if (attempt === maxAttempts) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+
+  const totalTimeMs = maxAttempts * delayMs;
+  throw new ResourceTimeoutError(
+    resourceType,
+    resourceId,
+    totalTimeMs,
+    operation,
+  );
+}
+/**
+ * Generic function to wait for an operation to complete
+ * This is the most flexible version that can handle any type of operation
+ */
+export async function waitForOperation<T>(
+  checkFunction: () => Promise<T>,
+  isComplete: (result: T) => boolean,
+  config: TimeoutConfig,
+  resourceId: string,
+  resourceType: string,
+  operation = "complete",
+  onError?: (error: any, attempt: number, maxAttempts: number) => boolean, // Return true to continue retrying
+): Promise<void> {
+  validateTimeoutConfig(config);
+  const { maxAttempts, delayMs } = config;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const result = await checkFunction();
+
+      if (isComplete(result)) {
+        console.log(`${resourceType} ${resourceId} ${operation} completed`);
+        return;
+      }
+
+      console.log(
+        `${resourceType} ${resourceId} ${operation} in progress... (attempt ${attempt}/${maxAttempts})`,
+      );
+
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    } catch (error) {
+      // Allow custom error handling
+      if (onError) {
+        const shouldContinue = onError(error, attempt, maxAttempts);
+        if (!shouldContinue) {
+          // If onError returns false, it means the operation completed successfully
+          // (e.g., resource was deleted and not found)
+          console.log(
+            `${resourceType} ${resourceId} ${operation} completed (via error handling)`,
+          );
+          return;
+        }
+      } else {
+        console.log(
+          `Error checking ${resourceType} ${operation} status (attempt ${attempt}/${maxAttempts}):`,
+          error,
+        );
+      }
+
+      if (attempt === maxAttempts) {
+        throw error;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+
+  const totalTimeMs = maxAttempts * delayMs;
+  throw new ResourceTimeoutError(
+    resourceType,
+    resourceId,
+    totalTimeMs,
+    operation,
+  );
+}

package/src/util/xml.ts

@@ -0,0 +1,7 @@
+/**
+ * Extract value from XML string
+ */
+export function extractXmlValue(xml: string, tagName: string): string {
+  const match = xml.match(new RegExp(`<${tagName}>(.*?)<\/${tagName}>`));
+  return match ? match[1] : "";
+}