alchemy 0.12.6 → 0.12.8

package/src/cloudflare/worker.ts

@@ -6,7 +6,7 @@ import { Resource } from "../resource.js";
 import { getContentType } from "../util/content-type.js";
 import { withExponentialBackoff } from "../util/retry.js";
 import { slugify } from "../util/slugify.js";
-import { handleApiError } from "./api-error.js";
+import { CloudflareApiError, handleApiError } from "./api-error.js";
 import {
   type CloudflareApi,
   type CloudflareApiOptions,
@@ -16,6 +16,13 @@ import type { Assets } from "./assets.js";
 import type { Bindings, WorkerBindingSpec } from "./bindings.js";
 import type { Bound } from "./bound.js";
 import type { DurableObjectNamespace } from "./durable-object-namespace.js";
+import { type EventSource, isQueueEventSource } from "./event-source.js";
+import {
+  QueueConsumer,
+  deleteQueueConsumer,
+  listQueueConsumers,
+} from "./queue-consumer.js";
+import { isQueue } from "./queue.js";
 import type { WorkerScriptMetadata } from "./worker-metadata.js";
 import type { SingleStepMigration } from "./worker-migration.js";
 import { type Workflow, upsertWorkflow } from "./workflow.js";
@@ -98,9 +105,10 @@ export interface WorkerProps<B extends Bindings = Bindings>
 
   /**
    * Name for the worker
-   * This is mandatory - must be explicitly specified
+   *
+   * @default id
    */
-  name: string;
+  name?: string;
 
   /**
    * Bindings to attach to the worker
@@ -169,6 +177,12 @@ export interface WorkerProps<B extends Bindings = Bindings>
    * @see https://developers.cloudflare.com/workers/configuration/cron-triggers/#examples
    */
   crons?: string[];
+
+  /**
+   * Event sources that this worker will consume.
+   * Can include queues, streams, or other event sources.
+   */
+  eventSources?: EventSource[];
 }
 
 /**
@@ -184,6 +198,11 @@ export interface Worker<B extends Bindings = Bindings>
    */
   id: string;
 
+  /**
+   * The name of the worker
+   */
+  name: string;
+
   /**
    * Time at which the worker was created
    */
@@ -326,7 +345,7 @@ export const Worker = Resource(
     const api = await createCloudflareApi(props);
 
     // Use the provided name
-    const workerName = props.name;
+    const workerName = props.name ?? id;
 
     // Validate input - we need either script, entryPoint, or bundle
     if (!props.script && !props.entrypoint) {
@@ -379,7 +398,7 @@ export const Worker = Resource(
       );
     }
 
-    const compatibilityDate = props.compatibilityDate ?? "2024-09-09";
+    const compatibilityDate = props.compatibilityDate ?? "2025-03-01";
     const compatibilityFlags = props.compatibilityFlags ?? [];
 
     // Prepare metadata with bindings
@@ -404,6 +423,24 @@ export const Worker = Resource(
       });
     }
 
+    await Promise.all(
+      props.eventSources?.map((eventSource) => {
+        if (isQueue(eventSource) || isQueueEventSource(eventSource)) {
+          const queue = isQueue(eventSource) ? eventSource : eventSource.queue;
+          return QueueConsumer(`${queue.id}-consumer`, {
+            queue,
+            scriptName: workerName,
+            accountId: api.accountId,
+            settings: isQueueEventSource(eventSource)
+              ? eventSource.settings
+              : undefined,
+          });
+        } else {
+          throw new Error(`Unsupported event source type: ${eventSource}`);
+        }
+      }) ?? []
+    );
+
     // TODO: it is less than ideal that this can fail, resulting in state problem
     await this.set("bindings", props.bindings);
 
@@ -451,6 +488,7 @@ export const Worker = Resource(
       observability: scriptMetadata.observability,
       createdAt: now,
       updatedAt: now,
+      eventSources: props.eventSources,
       url: workerUrl,
       // Include assets configuration in the output
       assets: props.assets,
@@ -467,6 +505,9 @@ async function deleteWorker<B extends Bindings>(
   api: CloudflareApi,
   workerName: string
 ) {
+  // Delete any queue consumers attached to this worker first
+  await deleteQueueConsumers(ctx, api, workerName);
+
   // Delete worker
   const deleteResponse = await api.delete(
     `/accounts/${api.accountId}/workers/scripts/${workerName}`
@@ -784,6 +825,13 @@ async function prepareWorkerMetadata<B extends Bindings>(
         type: "ai",
         name: bindingName,
       });
+    } else if (binding.type === "hyperdrive") {
+      // Hyperdrive binding
+      meta.bindings.push({
+        type: "hyperdrive",
+        name: bindingName,
+        id: binding.hyperdriveId,
+      });
     } else {
       // @ts-expect-error - we should never reach here
       throw new Error(`Unsupported binding type: ${binding.type}`);
@@ -1215,3 +1263,59 @@ async function calculateFileMetadata(
     size: fileContent.length,
   };
 }
+
+/**
+ * Lists and deletes all queue consumers for a specific worker
+ * @param ctx Worker context containing eventSources
+ * @param api CloudflareApi instance
+ * @param workerName Name of the worker script
+ */
+async function deleteQueueConsumers<B extends Bindings>(
+  ctx: Context<Worker<B>>,
+  api: CloudflareApi,
+  workerName: string
+): Promise<void> {
+  const eventSources = ctx.output?.eventSources || [];
+
+  // Extract queue IDs from event sources
+  const queueIds = eventSources.flatMap((eventSource) => {
+    if (isQueue(eventSource)) {
+      return [eventSource.id];
+    } else if (isQueueEventSource(eventSource)) {
+      return [eventSource.queue.id];
+    }
+    return [];
+  });
+
+  // Process each queue associated with this worker
+  await Promise.all(
+    queueIds.map(async (queueId) => {
+      try {
+        // List all consumers for this queue
+        const consumers = await listQueueConsumers(api, queueId);
+
+        // Filter consumers by worker name
+        const workerConsumers = consumers.filter(
+          (consumer) => consumer.scriptName === workerName
+        );
+
+        // Delete all consumers for this worker in parallel
+        await Promise.all(
+          workerConsumers.map(async (consumer) => {
+            console.log(
+              `Deleting queue consumer ${consumer.id} for worker ${workerName}`
+            );
+            // Use the deleteQueueConsumer function from queue-consumer.ts
+            await deleteQueueConsumer(api, consumer.queueId, consumer.id);
+          })
+        );
+      } catch (err) {
+        if (err instanceof CloudflareApiError && err.status === 404) {
+          // this is OK
+        } else {
+          throw err;
+        }
+      }
+    })
+  );
+}

package/src/cloudflare/wrangler.json.ts

@@ -3,6 +3,9 @@ import { StaticJsonFile } from "../fs/static-json-file.js";
 import { Resource } from "../resource.js";
 import type { Bindings } from "./bindings.js";
 import type { DurableObjectNamespace } from "./durable-object-namespace.js";
+import type { EventSource } from "./event-source.js";
+import { isQueueEventSource } from "./event-source.js";
+import { isQueue } from "./queue.js";
 import type { Worker } from "./worker.js";
 
 /**
@@ -80,7 +83,7 @@ export const WranglerJson = Resource(
 
     // Process bindings if they exist
     if (worker.bindings) {
-      processBindings(spec, worker.bindings);
+      processBindings(spec, worker.bindings, worker.eventSources);
     }
 
     // Add environment variables as vars
@@ -166,9 +169,16 @@ export interface WranglerJsonSpec {
    * Queue bindings
    */
   queues?: {
-    binding: string;
-    queue: string;
-  }[];
+    producers: { queue: string; binding: string }[];
+    consumers: {
+      queue: string;
+      max_batch_size?: number;
+      max_concurrency?: number;
+      max_retries?: number;
+      max_wait_time_ms?: number;
+      retry_delay?: number;
+    }[];
+  };
 
   /**
    * Service bindings
@@ -238,7 +248,11 @@ export interface WranglerJsonSpec {
 /**
  * Process worker bindings into wrangler.json format
  */
-function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
+function processBindings(
+  spec: WranglerJsonSpec,
+  bindings: Bindings,
+  eventSources: EventSource[] | undefined
+): void {
   // Arrays to collect different binding types
   const kvNamespaces: { binding: string; id: string }[] = [];
   const durableObjects: {
@@ -258,9 +272,39 @@ function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
     database_name: string;
     migrations_dir?: string;
   }[] = [];
-  const queues: { binding: string; queue: string }[] = [];
+  const queues: {
+    producers: { queue: string; binding: string }[];
+    consumers: {
+      queue: string;
+      max_batch_size?: number;
+      max_concurrency?: number;
+      max_retries?: number;
+      max_wait_time_ms?: number;
+      retry_delay?: number;
+    }[];
+  } = {
+    producers: [],
+    consumers: [],
+  };
+
   const vectorizeIndexes: { binding: string; index_name: string }[] = [];
 
+  for (const eventSource of eventSources ?? []) {
+    if (isQueueEventSource(eventSource)) {
+      queues.consumers.push({
+        queue: eventSource.queue.id,
+        max_batch_size: eventSource.settings?.batchSize,
+        max_concurrency: eventSource.settings?.maxConcurrency,
+        max_retries: eventSource.settings?.maxRetries,
+        max_wait_time_ms: eventSource.settings?.maxWaitTimeMs,
+        retry_delay: eventSource.settings?.retryDelay,
+      });
+    } else if (isQueue(eventSource)) {
+      queues.consumers.push({
+        queue: eventSource.id,
+      });
+    }
+  }
   // Process each binding
   for (const [bindingName, binding] of Object.entries(bindings)) {
     if (typeof binding === "string") {
@@ -320,7 +364,7 @@ function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
         migrations_dir: binding.migrationsDir,
       });
     } else if (binding.type === "queue") {
-      queues.push({
+      queues.producers.push({
         binding: bindingName,
         queue: binding.name,
       });
@@ -355,7 +399,7 @@ function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
     spec.d1_databases = d1Databases;
   }
 
-  if (queues.length > 0) {
+  if (queues.consumers.length > 0) {
     spec.queues = queues;
   }
 

package/src/neon/api-error.ts

@@ -0,0 +1,81 @@
+/**
+ * Error class for Neon API errors
+ */
+export class NeonApiError extends Error {
+  /**
+   * HTTP status code
+   */
+  public readonly status: number;
+
+  /**
+   * HTTP status text
+   */
+  public readonly statusText: string;
+
+  /**
+   * Error data from the API response
+   */
+  public readonly errorData?: any;
+
+  /**
+   * Create a new NeonApiError
+   */
+  constructor(message: string, response: Response, errorData?: any) {
+    super(message);
+    this.name = "NeonApiError";
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.errorData = errorData;
+
+    // Capture stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, NeonApiError);
+    }
+  }
+}
+
+/**
+ * Handle API errors and throw NeonApiError with context
+ *
+ * @param response Response object from fetch
+ * @param action Action that was being performed
+ * @param resourceType Type of resource
+ * @param resourceId ID of the resource
+ */
+export async function handleApiError(
+  response: Response,
+  action: "get" | "create" | "update" | "delete" | "list",
+  resourceType: string,
+  resourceId?: string
+): Promise<never> {
+  const resourceDisplay = resourceId ? `'${resourceId}'` : "";
+  let errorData: any;
+
+  try {
+    errorData = await response.json();
+  } catch (e) {
+    // If we can't parse JSON, just use the response text
+    try {
+      errorData = { message: await response.text() };
+    } catch (textError) {
+      errorData = { message: response.statusText };
+    }
+  }
+
+  let message = `Error ${action} ${resourceType} ${resourceDisplay}: `;
+
+  if (errorData?.error?.message) {
+    message += errorData.error.message;
+  } else if (errorData?.message) {
+    message += errorData.message;
+  } else if (errorData?.error) {
+    message +=
+      typeof errorData.error === "string"
+        ? errorData.error
+        : JSON.stringify(errorData.error);
+  } else {
+    message += response.statusText;
+  }
+
+  throw new NeonApiError(message, response, errorData);
+}

package/src/neon/api.ts

@@ -0,0 +1,178 @@
+import type { Secret } from "../secret.js";
+import { withExponentialBackoff } from "../util/retry.js";
+
+/**
+ * Options for Neon API requests
+ */
+export interface NeonApiOptions {
+  /**
+   * Base URL for Neon API
+   * @default https://console.neon.tech/api/v2
+   */
+  baseUrl?: string;
+
+  /**
+   * API Key to use (overrides NEON_API_KEY env var)
+   */
+  apiKey?: Secret;
+}
+
+/**
+ * Create a NeonApi instance with environment variable fallback
+ * @param options API options
+ * @returns NeonApi instance
+ */
+export function createNeonApi(options: Partial<NeonApiOptions> = {}): NeonApi {
+  return new NeonApi({
+    baseUrl: options.baseUrl,
+    apiKey: options.apiKey,
+  });
+}
+
+/**
+ * Get authentication headers for Neon API
+ * @param options NeonApiOptions
+ * @returns Headers for authentication
+ */
+export async function getNeonAuthHeaders(
+  options: Partial<NeonApiOptions>
+): Promise<Record<string, string>> {
+  const apiKey = options.apiKey?.unencrypted ?? process.env.NEON_API_KEY;
+
+  if (!apiKey) {
+    throw new Error(
+      "Neon API key is required. Set NEON_API_KEY environment variable or provide apiKey option."
+    );
+  }
+
+  return {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    Authorization: `Bearer ${apiKey}`,
+  };
+}
+
+/**
+ * Neon API client using raw fetch
+ */
+export class NeonApi {
+  public readonly baseUrl: string;
+
+  /**
+   * Create a new Neon API client
+   * Use createNeonApi factory function instead of direct constructor
+   *
+   * @param options API options
+   */
+  constructor(private readonly options: NeonApiOptions) {
+    this.baseUrl = options.baseUrl ?? "https://console.neon.tech/api/v2";
+  }
+
+  /**
+   * Make a fetch request to the Neon API
+   *
+   * @param path API path (without base URL)
+   * @param init Fetch init options
+   * @returns Raw Response object from fetch
+   */
+  async fetch(path: string, init: RequestInit = {}): Promise<Response> {
+    let headers: Record<string, string> = {};
+
+    if (Array.isArray(init.headers)) {
+      init.headers.forEach(([key, value]) => {
+        headers[key] = value;
+      });
+    } else if (init.headers instanceof Headers) {
+      init.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+    } else if (init.headers) {
+      headers = init.headers as Record<string, string>;
+    }
+
+    headers = {
+      ...(await getNeonAuthHeaders(this.options)),
+      ...headers,
+    };
+
+    // Use withExponentialBackoff for automatic retry on network errors
+    return withExponentialBackoff(
+      () =>
+        fetch(`${this.baseUrl}${path}`, {
+          ...init,
+          headers,
+        }),
+      (error) => {
+        // Only retry on network-related errors
+        const errorMsg = (error as Error).message || "";
+        const isNetworkError =
+          errorMsg.includes("socket connection was closed") ||
+          errorMsg.includes("ECONNRESET") ||
+          errorMsg.includes("ETIMEDOUT") ||
+          errorMsg.includes("ECONNREFUSED");
+
+        return isNetworkError || error?.status?.toString().startsWith("5");
+      },
+      5, // Maximum 5 attempts (1 initial + 4 retries)
+      1000 // Start with 1s delay, will exponentially increase
+    );
+  }
+
+  /**
+   * Helper for GET requests
+   */
+  async get(path: string, init: RequestInit = {}): Promise<Response> {
+    return this.fetch(path, { ...init, method: "GET" });
+  }
+
+  /**
+   * Helper for POST requests
+   */
+  async post(
+    path: string,
+    body: any,
+    init: RequestInit = {}
+  ): Promise<Response> {
+    const requestBody =
+      body instanceof FormData
+        ? body
+        : typeof body === "string"
+          ? body
+          : JSON.stringify(body);
+    return this.fetch(path, { ...init, method: "POST", body: requestBody });
+  }
+
+  /**
+   * Helper for PUT requests
+   */
+  async put(
+    path: string,
+    body: any,
+    init: RequestInit = {}
+  ): Promise<Response> {
+    const requestBody = body instanceof FormData ? body : JSON.stringify(body);
+    return this.fetch(path, { ...init, method: "PUT", body: requestBody });
+  }
+
+  /**
+   * Helper for PATCH requests
+   */
+  async patch(
+    path: string,
+    body: any,
+    init: RequestInit = {}
+  ): Promise<Response> {
+    return this.fetch(path, {
+      ...init,
+      method: "PATCH",
+      body: JSON.stringify(body),
+    });
+  }
+
+  /**
+   * Helper for DELETE requests
+   */
+  async delete(path: string, init: RequestInit = {}): Promise<Response> {
+    return this.fetch(path, { ...init, method: "DELETE" });
+  }
+}

package/src/neon/index.ts

@@ -0,0 +1,3 @@
+export * from "./api-error.js";
+export * from "./api.js";
+export * from "./project.js";