alchemy 0.24.0 → 0.24.1

package/src/cloudflare/queue-consumer.ts

@@ -6,7 +6,7 @@ import {
   type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.ts";
-import type { QueueResource, Queue } from "./queue.ts";
+import type { Queue, QueueResource } from "./queue.ts";
 
 /**
  * Settings for configuring a Queue Consumer
@@ -450,3 +450,61 @@ export async function listQueueConsumers(
       : undefined,
   }));
 }
+
+export async function listQueueConsumersForWorker(
+  api: CloudflareApi,
+  workerName: string,
+) {
+  const response = await api.get(
+    `/accounts/${api.accountId}/workers/scripts/${workerName}/queue-consumers?perPage=100`,
+  );
+
+  if (response.status === 404) {
+    return [];
+  }
+
+  if (!response.ok) {
+    return await handleApiError(
+      response,
+      "list",
+      "QueueConsumer",
+      `for worker ${workerName}`,
+    );
+  }
+
+  const data = (await response.json()) as {
+    result: Array<{
+      script: string;
+      settings?: {
+        batch_size?: number;
+        max_retries?: number;
+        max_wait_time_ms?: number;
+        retry_delay?: number;
+        dead_letter_queue?: string;
+      };
+      type: string;
+      queue_name: string;
+      queue_id: string;
+      consumer_id: string;
+      created_on: string;
+    }>;
+    success: boolean;
+    errors: any[] | null;
+    messages: any[] | null;
+    result_info: {
+      page: number;
+      per_page: number;
+      count: number;
+      total_count: number;
+      total_pages: number;
+    };
+  };
+
+  return data.result.map((consumer) => ({
+    queueName: consumer.queue_name,
+    queueId: consumer.queue_id,
+    consumerId: consumer.consumer_id,
+    createdOn: consumer.created_on,
+    settings: consumer.settings,
+  }));
+}

package/src/cloudflare/website.ts

@@ -15,8 +15,37 @@ export interface WebsiteProps<B extends Bindings>
   extends Omit<WorkerProps<B>, "name" | "assets" | "entrypoint"> {
   /**
    * The command to run to build the site
+   *
+   * If one is not provided, the build is assumed to have already happened.
+   */
+  command?: string;
+
+  /**
+   * Whether to memoize the command (only re-run if the command changes)
+   *
+   * When set to `true`, the command will only be re-executed if the command string changes.
+   *
+   * When set to an object with `patterns`, the command will be re-executed if either:
+   * 1. The command string changes, or
+   * 2. The contents of any files matching the glob patterns change
+   *
+   * ⚠️ **Important Note**: When using memoization with build commands, the build outputs
+   * will not be produced if the command is memoized. This is because the command is not
+   * actually executed when memoized. Consider disabling memoization in CI environments:
+   *
+   * @example
+   * // Disable memoization in CI to ensure build outputs are always produced
+   * await Website("my-website", {
+   *   command: "vite build",
+   *   memoize: process.env.CI ? false : {
+   *     patterns: ["./src/**"]
+   *   }
+   * });
+   *
+   * @default false
    */
-  command: string;
+  memoize?: boolean | { patterns: string[] };
+
   /**
    * The name of the worker
    *
@@ -128,11 +157,14 @@ export default {
       });
     }
 
-    await Exec("build", {
-      cwd,
-      command: props.command,
-      env: props.env,
-    });
+    if (props.command) {
+      await Exec("build", {
+        cwd,
+        command: props.command,
+        env: props.env,
+        memoize: props.memoize,
+      });
+    }
 
     return (await Worker("worker", {
       ...workerProps,

package/src/cloudflare/worker-metadata.ts

@@ -361,7 +361,7 @@ export async function prepareWorkerMetadata<B extends Bindings>(
       meta.bindings.push({
         type: "service",
         name: bindingName,
-        service: binding.name,
+        service: "service" in binding ? binding.service : binding.name,
       });
     } else if (binding.type === "durable_object_namespace") {
       meta.bindings.push({

package/src/cloudflare/worker.ts

@@ -23,6 +23,7 @@ import {
   type Binding,
   type Bindings,
   Json,
+  type WorkerBindingService,
   type WorkerBindingSpec,
 } from "./bindings.ts";
 import type { Bound } from "./bound.ts";
@@ -46,7 +47,7 @@ import { isPipeline } from "./pipeline.ts";
 import {
   QueueConsumer,
   deleteQueueConsumer,
-  listQueueConsumers,
+  listQueueConsumersForWorker,
 } from "./queue-consumer.ts";
 import { type QueueResource, isQueue } from "./queue.ts";
 import { isVectorizeIndex } from "./vectorize-index.ts";
@@ -384,6 +385,56 @@ export type Worker<
     compatibilityFlags: string[];
   };
 
+/**
+ * Represents a reference to a Cloudflare Worker service.
+ *
+ * @template RPC - The type of the worker's RPC entrypoint, defaults to Rpc.WorkerEntrypointBranded.
+ *
+ * This interface extends all properties of WorkerBindingService except for "name".
+ * It also includes an optional __rpc__ property for type branding.
+ */
+export type WorkerRef<
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = Omit<WorkerBindingService, "name"> & {
+  /**
+   * Optional type branding for the worker's RPC entrypoint.
+   */
+  __rpc__?: RPC;
+};
+
+/**
+ * Creates a reference to a Cloudflare Worker service.
+ *
+ * @example
+ * // Create a reference to a Cloudflare Worker service:
+ * const ref = WorkerRef({
+ *   service: "my-worker",
+ *   environment: "production",
+ *   namespace: "main"
+ * });
+ *
+ * // Optionally, you can specify only the service:
+ * const ref2 = WorkerRef({ service: "my-worker" });
+ *
+ * // You can also specify the RPC type for stronger typing:
+ * interface MyWorkerRPC extends Rpc.WorkerEntrypointBranded {
+ *   myMethod(arg: string): Promise<number>;
+ * }
+ * const typedRef = WorkerRef<MyWorkerRPC>({ service: "my-worker" });
+ */
+export function WorkerRef<
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(options?: {
+  service: string;
+  environment?: string;
+  namespace?: string;
+}): WorkerRef<RPC> {
+  return {
+    ...options,
+    type: "service",
+  } as WorkerRef<RPC>;
+}
+
 /**
  * A Cloudflare Worker is a serverless function that can be deployed to the Cloudflare network.
  *
@@ -869,7 +920,7 @@ export const _Worker = Resource(
 
     if (this.phase === "delete") {
       // Delete any queue consumers attached to this worker first
-      await deleteQueueConsumers(this, api, workerName);
+      await deleteQueueConsumers(api, workerName);
 
       // @ts-ignore
       await uploadWorkerScript({
@@ -879,7 +930,7 @@ export const _Worker = Resource(
         script:
           props.format === "cjs"
             ? "addEventListener('fetch', event => { event.respondWith(new Response('hello world')); });"
-            : "export default { fetch(request) { return new Response('hello world'); } }",
+            : "export default { fetch(request) { return new Response('hello world'); }, queue: () => {} }",
         bindings: {} as B,
         // we are writing a stub worker (to remove binding/event source dependencies)
         // queue consumers will no longer exist by this point
@@ -1074,7 +1125,14 @@ export async function putWorker(
 
       return formData;
     },
-    (err) => err.status === 404 || err.status === 500 || err.status === 503,
+    (err) =>
+      err.status === 404 ||
+      err.status === 500 ||
+      err.status === 503 ||
+      // this is a tranient error that cloudflare throws randomly
+      (err instanceof CloudflareApiError &&
+        err.status === 400 &&
+        err.message.match(/binding.*failed to generate/)),
     10,
     100,
   );
@@ -1248,53 +1306,15 @@ async function getWorkerBindings(api: CloudflareApi, workerName: string) {
  * @param api CloudflareApi instance
  * @param workerName Name of the worker script
  */
-async function deleteQueueConsumers<B extends Bindings>(
-  ctx: Context<Worker<B>>,
+async function deleteQueueConsumers(
   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];
-    }
-    if (isQueueEventSource(eventSource)) {
-      return [eventSource.queue.id];
-    }
-    return [];
-  });
+  const consumers = await listQueueConsumersForWorker(api, workerName);
 
-  // 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;
-        }
-      }
+    consumers.map(async (consumer) => {
+      await deleteQueueConsumer(api, consumer.queueId, consumer.consumerId);
     }),
   );
 }

package/src/cloudflare/wrangler.json.ts

@@ -447,7 +447,7 @@ function processBindings(
       // Service binding
       services.push({
         binding: bindingName,
-        service: binding.name,
+        service: "name" in binding ? binding.name : binding.service,
       });
     } else if (binding.type === "kv_namespace") {
       // KV Namespace binding

package/src/fs/file-system-state-store.ts

@@ -11,8 +11,13 @@ const stateRootDir = path.join(process.cwd(), ".alchemy");
 export class FileSystemStateStore implements StateStore {
   public readonly dir: string;
   private initialized = false;
-  constructor(public readonly scope: Scope) {
-    this.dir = path.join(stateRootDir, ...scope.chain);
+  constructor(
+    public readonly scope: Scope,
+    options?: {
+      rootDir?: string;
+    },
+  ) {
+    this.dir = path.join(options?.rootDir ?? stateRootDir, ...scope.chain);
   }
 
   async init(): Promise<void> {

package/src/stripe/card.ts

@@ -0,0 +1,320 @@
+import type Stripe from "stripe";
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import type { Secret } from "../secret.ts";
+import {
+  createStripeClient,
+  handleStripeDeleteError,
+  isStripeConflictError,
+} from "./client.ts";
+
+/**
+ * Properties for creating a Stripe card
+ */
+export interface CardProps {
+  /**
+   * The ID of the customer to attach the card to
+   */
+  customer: string;
+
+  /**
+   * A token or source to attach to the customer
+   */
+  source?: string;
+
+  /**
+   * The card number, as a string without any separators
+   */
+  number?: string;
+
+  /**
+   * Two-digit number representing the card's expiration month
+   */
+  expMonth?: number;
+
+  /**
+   * Four-digit number representing the card's expiration year
+   */
+  expYear?: number;
+
+  /**
+   * Card security code
+   */
+  cvc?: string;
+
+  /**
+   * Cardholder's full name
+   */
+  name?: string;
+
+  /**
+   * City/District/Suburb/Town/Village
+   */
+  addressCity?: string;
+
+  /**
+   * Billing address country, if provided when creating card
+   */
+  addressCountry?: string;
+
+  /**
+   * Address line 1 (Street address/PO Box/Company name)
+   */
+  addressLine1?: string;
+
+  /**
+   * Address line 2 (Apartment/Suite/Unit/Building)
+   */
+  addressLine2?: string;
+
+  /**
+   * State/County/Province/Region
+   */
+  addressState?: string;
+
+  /**
+   * ZIP or postal code
+   */
+  addressZip?: string;
+
+  /**
+   * Required when adding a card to an account (not applicable to customers or recipients)
+   */
+  currency?: string;
+
+  /**
+   * Only applicable on accounts (not customers or recipients)
+   */
+  defaultForCurrency?: boolean;
+
+  /**
+   * Set of key-value pairs that you can attach to an object
+   */
+  metadata?: Record<string, string>;
+
+  /**
+   * API key to use (overrides environment variable)
+   */
+  apiKey?: Secret;
+
+  /**
+   * If true, adopt existing resource if creation fails due to conflict
+   */
+  adopt?: boolean;
+}
+
+/**
+ * Output from the Stripe card
+ */
+export interface Card extends Resource<"stripe::Card">, CardProps {
+  /**
+   * The ID of the card
+   */
+  id: string;
+
+  /**
+   * String representing the object's type
+   */
+  object: "card";
+
+  /**
+   * Card brand (Visa, American Express, MasterCard, Discover, JCB, Diners Club, or Unknown)
+   */
+  brand: string;
+
+  /**
+   * Two-letter ISO code representing the country of the card
+   */
+  country?: string;
+
+  /**
+   * The last four digits of the device account number
+   */
+  dynamicLast4?: string;
+
+  /**
+   * Uniquely identifies this particular card number
+   */
+  fingerprint?: string;
+
+  /**
+   * Card funding type (credit, debit, prepaid, or unknown)
+   */
+  funding: string;
+
+  /**
+   * The last four digits of the card
+   */
+  last4: string;
+
+  /**
+   * If the card number is tokenized, this is the method that was used
+   */
+  tokenizationMethod?: string;
+}
+
+/**
+ * Create and manage Stripe cards attached to customers
+ *
+ * @example
+ * // Create a card using raw card details
+ * const customerCard = await Card("customer-card", {
+ *   customer: "cus_xyz123",
+ *   number: "4242424242424242",
+ *   expMonth: 12,
+ *   expYear: 2025,
+ *   cvc: "123",
+ *   name: "John Doe",
+ *   addressLine1: "123 Main St",
+ *   addressCity: "San Francisco",
+ *   addressState: "CA",
+ *   addressZip: "94105",
+ *   addressCountry: "US"
+ * });
+ *
+ * @example
+ * // Create a card using a token
+ * const tokenCard = await Card("token-card", {
+ *   customer: "cus_xyz123",
+ *   source: "tok_visa",
+ *   metadata: {
+ *     type: "primary",
+ *     source: "mobile_app"
+ *   }
+ * });
+ *
+ * @example
+ * // Create a card for international customer
+ * const internationalCard = await Card("international-card", {
+ *   customer: "cus_international456",
+ *   number: "4000000000000002",
+ *   expMonth: 6,
+ *   expYear: 2026,
+ *   name: "Maria Garcia",
+ *   addressLine1: "Calle Principal 123",
+ *   addressCity: "Madrid",
+ *   addressCountry: "ES",
+ *   addressZip: "28001",
+ *   metadata: {
+ *     region: "europe",
+ *     currency_preference: "eur"
+ *   }
+ * });
+ */
+export const Card = Resource(
+  "stripe::Card",
+  async function (
+    this: Context<Card>,
+    _id: string,
+    props: CardProps,
+  ): Promise<Card> {
+    const stripe = createStripeClient({ apiKey: props.apiKey });
+
+    if (this.phase === "delete") {
+      try {
+        if (this.output?.id && this.output?.customer) {
+          await stripe.customers.deleteSource(
+            this.output.customer,
+            this.output.id,
+          );
+        }
+      } catch (error) {
+        handleStripeDeleteError(error, "Card", this.output?.id);
+      }
+      return this.destroy();
+    }
+
+    try {
+      let card: Stripe.Card;
+
+      if (this.phase === "update" && this.output?.id) {
+        const updateParams = {
+          name: props.name,
+          address_city: props.addressCity,
+          address_country: props.addressCountry,
+          address_line1: props.addressLine1,
+          address_line2: props.addressLine2,
+          address_state: props.addressState,
+          address_zip: props.addressZip,
+          exp_month: props.expMonth?.toString(),
+          exp_year: props.expYear?.toString(),
+          metadata: props.metadata,
+        };
+
+        card = (await stripe.customers.updateSource(
+          props.customer,
+          this.output.id,
+          updateParams,
+        )) as Stripe.Card;
+      } else {
+        const createParams: any = {
+          metadata: props.metadata,
+        };
+
+        if (props.source) {
+          createParams.source = props.source;
+        } else if (props.number) {
+          createParams.source = {
+            object: "card",
+            number: props.number,
+            exp_month: props.expMonth,
+            exp_year: props.expYear,
+            cvc: props.cvc,
+            name: props.name,
+            address_city: props.addressCity,
+            address_country: props.addressCountry,
+            address_line1: props.addressLine1,
+            address_line2: props.addressLine2,
+            address_state: props.addressState,
+            address_zip: props.addressZip,
+            currency: props.currency,
+            default_for_currency: props.defaultForCurrency,
+          };
+        }
+
+        try {
+          card = (await stripe.customers.createSource(
+            props.customer,
+            createParams,
+          )) as Stripe.Card;
+        } catch (error) {
+          if (isStripeConflictError(error) && props.adopt) {
+            throw new Error(
+              "Card adoption is not supported - cards cannot be uniquely identified for adoption",
+            );
+          } else {
+            throw error;
+          }
+        }
+      }
+
+      return this({
+        id: card.id,
+        object: card.object,
+        customer: props.customer,
+        brand: card.brand,
+        country: card.country || undefined,
+        dynamicLast4: card.dynamic_last4 || undefined,
+        expMonth: card.exp_month,
+        expYear: card.exp_year,
+        fingerprint: card.fingerprint || undefined,
+        funding: card.funding,
+        last4: card.last4,
+        name: card.name || undefined,
+        addressCity: card.address_city || undefined,
+        addressCountry: card.address_country || undefined,
+        addressLine1: card.address_line1 || undefined,
+        addressLine2: card.address_line2 || undefined,
+        addressState: card.address_state || undefined,
+        addressZip: card.address_zip || undefined,
+        currency: card.currency || undefined,
+        defaultForCurrency: card.default_for_currency || undefined,
+        metadata: card.metadata || undefined,
+        tokenizationMethod: card.tokenization_method || undefined,
+      });
+    } catch (error) {
+      console.error("Error creating/updating card:", error);
+      throw error;
+    }
+  },
+);