alchemy 0.7.0 → 0.7.2

package/lib/cloudflare/bindings.d.ts

@@ -6,8 +6,11 @@
 import type { Secret } from "../secret";
 import type { Assets } from "./assets";
 import type { R2Bucket } from "./bucket";
+import type { D1Database } from "./d1-database";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace } from "./kv-namespace";
+import type { Pipeline } from "./pipeline";
+import type { Queue } from "./queue";
 import type { Worker } from "./worker";
 import type { Workflow } from "./workflow";
 export type Bindings = {
@@ -16,11 +19,11 @@ export type Bindings = {
 /**
  * L2 Binding Resources.
  */
-export type Binding = DurableObjectNamespace | KVNamespace | Worker | Workflow | R2Bucket | Secret | string | Assets;
+export type Binding = Assets | D1Database | DurableObjectNamespace | KVNamespace | Pipeline | Queue | R2Bucket | Secret | string | Worker | Workflow;
 /**
  * Union type for all Worker binding types (API spec)
  */
-export type WorkerBindingSpec = WorkerBindingAI | WorkerBindingAnalyticsEngine | WorkerBindingAssets | WorkerBindingBrowserRendering | WorkerBindingD1 | WorkerBindingDispatchNamespace | WorkerBindingDurableObjectNamespace | WorkerBindingHyperdrive | WorkerBindingJson | WorkerBindingKVNamespace | WorkerBindingMTLSCertificate | WorkerBindingPlainText | WorkerBindingQueue | WorkerBindingR2Bucket | WorkerBindingSecretText | WorkerBindingService | WorkerBindingStaticContent | WorkerBindingTailConsumer | WorkerBindingVectorize | WorkerBindingVersionMetadata | WorkerBindingWasmModule | WorkerBindingWorkflow;
+export type WorkerBindingSpec = WorkerBindingAI | WorkerBindingAnalyticsEngine | WorkerBindingAssets | WorkerBindingBrowserRendering | WorkerBindingD1 | WorkerBindingDispatchNamespace | WorkerBindingDurableObjectNamespace | WorkerBindingHyperdrive | WorkerBindingJson | WorkerBindingKVNamespace | WorkerBindingMTLSCertificate | WorkerBindingPipeline | WorkerBindingPlainText | WorkerBindingQueue | WorkerBindingR2Bucket | WorkerBindingSecretText | WorkerBindingService | WorkerBindingStaticContent | WorkerBindingTailConsumer | WorkerBindingVectorize | WorkerBindingVersionMetadata | WorkerBindingWasmModule | WorkerBindingWorkflow;
 /**
  * AI binding type
  */
@@ -276,3 +279,14 @@ export interface WorkerBindingWorkflow {
      */
     script_name?: string;
 }
+/**
+ * Pipeline binding type
+ */
+export interface WorkerBindingPipeline {
+    /** The name of the binding */
+    name: string;
+    /** Type identifier for Pipeline binding */
+    type: "pipelines";
+    /** Pipeline name */
+    pipeline: string;
+}

package/lib/cloudflare/bound.d.ts

@@ -1,9 +1,13 @@
+import type { Pipeline } from "cloudflare:pipelines";
 import type { Secret } from "../secret";
 import type { Assets } from "./assets";
 import type { Binding } from "./bindings";
 import type { R2Bucket as _R2Bucket } from "./bucket";
+import type { D1Database as _D1Database } from "./d1-database";
 import type { DurableObjectNamespace as _DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace as _KVNamespace } from "./kv-namespace";
+import type { Pipeline as _Pipeline } from "./pipeline";
+import type { Queue as _Queue } from "./queue";
 import type { Worker as _Worker } from "./worker";
 import type { Workflow as _Workflow } from "./workflow";
-export type Bound<T extends Binding> = T extends _DurableObjectNamespace ? DurableObjectNamespace : T extends _KVNamespace ? KVNamespace : T extends _Worker ? Worker : T extends _R2Bucket ? R2Bucket : T extends Secret ? string : T extends Assets ? Service : T extends _Workflow<infer P> ? Workflow<P> : Service;
+export type Bound<T extends Binding> = T extends _DurableObjectNamespace ? DurableObjectNamespace : T extends _KVNamespace ? KVNamespace : T extends _Worker ? Worker : T extends _R2Bucket ? R2Bucket : T extends Secret ? string : T extends Assets ? Service : T extends _Workflow<infer P> ? Workflow<P> : T extends _D1Database ? D1Database : T extends _Queue ? Queue : T extends _Pipeline<infer R> ? Pipeline<R> : Service;

package/lib/cloudflare/bucket.js

@@ -205,6 +205,7 @@ export async function emptyBucket(r2, bucketName, jurisdiction) {
     let totalDeleted = 0;
     try {
         do {
+            console.log(`Listing objects in bucket ${bucketName}`);
             // List objects in the bucket
             const { objects, continuationToken: nextToken } = await listObjects(r2, bucketName, continuationToken, jurisdiction);
             continuationToken = nextToken;

package/lib/cloudflare/d1-database.d.ts

@@ -0,0 +1,151 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { CloudflareApi, type CloudflareApiOptions } from "./api";
+/**
+ * Properties for creating or updating a D1 Database
+ */
+export interface D1DatabaseProps extends CloudflareApiOptions {
+    /**
+     * Name of the database
+     */
+    name: string;
+    /**
+     * Optional primary location hint for the database
+     * Indicates the primary geographical location data will be stored
+     */
+    primaryLocationHint?: "wnam" | "enam" | "weur" | "eeur" | "apac" | "auto" | string;
+    /**
+     * Read replication configuration
+     * Only mutable property during updates
+     */
+    readReplication?: {
+        /**
+         * Read replication mode
+         * - auto: Automatic read replication
+         * - disabled: No read replication
+         */
+        mode: "auto" | "disabled";
+    };
+    /**
+     * Whether to delete the database.
+     * If set to false, the database will remain but the resource will be removed from state
+     *
+     * @default true
+     */
+    delete?: boolean;
+    /**
+     * Whether to adopt an existing database with the same name if it exists
+     * If true and a database with the same name exists, it will be adopted rather than creating a new one
+     *
+     * @default false
+     */
+    adopt?: boolean;
+}
+/**
+ * Output returned after D1 Database creation/update
+ */
+export interface D1Database extends Resource<"cloudflare::D1Database">, D1DatabaseProps {
+    type: "d1";
+    /**
+     * The unique ID of the database (UUID)
+     */
+    id: string;
+    /**
+     * File size of the database
+     */
+    fileSize: number;
+    /**
+     * Number of tables in the database
+     */
+    numTables: number;
+    /**
+     * Version of the database
+     */
+    version: string;
+    /**
+     * Read replication configuration
+     */
+    readReplication?: {
+        /**
+         * Read replication mode
+         */
+        mode: "auto" | "disabled";
+    };
+}
+/**
+ * Creates and manages Cloudflare D1 Databases.
+ *
+ * D1 Databases provide serverless SQL databases built on SQLite with
+ * automatic data replication for high availability.
+ *
+ * @example
+ * // Create a basic D1 database with default settings
+ * const basicDatabase = await D1Database("my-app-db", {
+ *   name: "my-app-db"
+ * });
+ *
+ * @example
+ * // Create a database with location hint for optimal performance
+ * const westUsDatabase = await D1Database("west-us-db", {
+ *   name: "west-us-db",
+ *   primaryLocationHint: "wnam"
+ * });
+ *
+ * @example
+ * // Adopt an existing database if it already exists instead of failing
+ * const existingDb = await D1Database("existing-db", {
+ *   name: "existing-db",
+ *   adopt: true,
+ *   readReplication: {
+ *     mode: "auto"
+ *   }
+ * });
+ *
+ * @see https://developers.cloudflare.com/d1/
+ */
+export declare const D1Database: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<D1Database>, id: string, props: D1DatabaseProps) => Promise<D1Database>);
+interface CloudflareD1Response {
+    result: {
+        uuid?: string;
+        name: string;
+        file_size: number;
+        num_tables: number;
+        version: string;
+        primary_location_hint?: string;
+        read_replication?: {
+            mode: "auto" | "disabled";
+        };
+    };
+    success: boolean;
+    errors: Array<{
+        code: number;
+        message: string;
+    }>;
+    messages: string[];
+}
+/**
+ * Create a new D1 database
+ */
+export declare function createDatabase(api: CloudflareApi, databaseName: string, props: D1DatabaseProps): Promise<CloudflareD1Response>;
+/**
+ * Get a D1 database
+ */
+export declare function getDatabase(api: CloudflareApi, databaseId?: string): Promise<CloudflareD1Response>;
+/**
+ * Delete a D1 database
+ */
+export declare function deleteDatabase(api: CloudflareApi, databaseId?: string): Promise<void>;
+/**
+ * List all D1 databases in an account
+ */
+export declare function listDatabases(api: CloudflareApi, name?: string): Promise<{
+    name: string;
+    id: string;
+}[]>;
+/**
+ * Update a D1 database
+ *
+ * Note: According to Cloudflare API, only read_replication.mode can be modified during updates.
+ */
+export declare function updateDatabase(api: CloudflareApi, databaseId: string, props: D1DatabaseProps): Promise<CloudflareD1Response>;
+export {};

package/lib/cloudflare/d1-database.js

@@ -0,0 +1,200 @@
+import { Resource } from "../resource";
+import { CloudflareApi, createCloudflareApi, } from "./api";
+import { CloudflareApiError, handleApiError } from "./api-error";
+/**
+ * Creates and manages Cloudflare D1 Databases.
+ *
+ * D1 Databases provide serverless SQL databases built on SQLite with
+ * automatic data replication for high availability.
+ *
+ * @example
+ * // Create a basic D1 database with default settings
+ * const basicDatabase = await D1Database("my-app-db", {
+ *   name: "my-app-db"
+ * });
+ *
+ * @example
+ * // Create a database with location hint for optimal performance
+ * const westUsDatabase = await D1Database("west-us-db", {
+ *   name: "west-us-db",
+ *   primaryLocationHint: "wnam"
+ * });
+ *
+ * @example
+ * // Adopt an existing database if it already exists instead of failing
+ * const existingDb = await D1Database("existing-db", {
+ *   name: "existing-db",
+ *   adopt: true,
+ *   readReplication: {
+ *     mode: "auto"
+ *   }
+ * });
+ *
+ * @see https://developers.cloudflare.com/d1/
+ */
+export const D1Database = Resource("cloudflare::D1Database", async function (id, props) {
+    const api = await createCloudflareApi(props);
+    const databaseName = props.name || id;
+    if (this.phase === "delete") {
+        console.log("Deleting D1 database:", databaseName);
+        if (props.delete !== false) {
+            // Delete D1 database
+            console.log("Deleting D1 database:", databaseName);
+            await deleteDatabase(api, this.output?.id);
+        }
+        // Return void (a deleted database has no content)
+        return this.destroy();
+    }
+    else {
+        let dbData;
+        if (this.phase === "create") {
+            console.log("Creating D1 database:", databaseName);
+            try {
+                dbData = await createDatabase(api, databaseName, props);
+            }
+            catch (error) {
+                // Check if this is a "database already exists" error and adopt is enabled
+                if (props.adopt &&
+                    error instanceof CloudflareApiError &&
+                    error.message.includes("already exists")) {
+                    console.log(`Database ${databaseName} already exists, adopting it`);
+                    // Find the existing database by name
+                    const databases = await listDatabases(api, databaseName);
+                    const existingDb = databases.find((db) => db.name === databaseName);
+                    if (!existingDb) {
+                        throw new Error(`Failed to find existing database '${databaseName}' for adoption`);
+                    }
+                    // Get the database details using its ID
+                    dbData = await getDatabase(api, existingDb.id);
+                    // Update the database with the provided properties
+                    if (props.readReplication) {
+                        console.log(`Updating adopted database ${databaseName} with new properties`);
+                        dbData = await updateDatabase(api, existingDb.id, props);
+                    }
+                }
+                else {
+                    // Re-throw the error if adopt is false or it's not a "database already exists" error
+                    throw error;
+                }
+            }
+        }
+        else {
+            // Update operation
+            if (this.output?.id) {
+                console.log("Updating D1 database:", databaseName);
+                // Update the database with new properties
+                dbData = await updateDatabase(api, this.output.id, props);
+            }
+            else {
+                // If no ID exists, fall back to creating a new database
+                console.log("No existing database ID found, creating new D1 database:", databaseName);
+                dbData = await createDatabase(api, databaseName, props);
+            }
+        }
+        return this({
+            type: "d1",
+            id: dbData.result.uuid || "",
+            name: databaseName,
+            fileSize: dbData.result.file_size,
+            numTables: dbData.result.num_tables,
+            version: dbData.result.version,
+            readReplication: dbData.result.read_replication,
+            primaryLocationHint: props.primaryLocationHint,
+            accountId: api.accountId,
+        });
+    }
+});
+/**
+ * Create a new D1 database
+ */
+export async function createDatabase(api, databaseName, props) {
+    // Create new D1 database
+    const createPayload = {
+        name: databaseName,
+    };
+    if (props.primaryLocationHint) {
+        createPayload.primary_location_hint = props.primaryLocationHint;
+    }
+    const createResponse = await api.post(`/accounts/${api.accountId}/d1/database`, createPayload);
+    if (!createResponse.ok) {
+        return await handleApiError(createResponse, "creating", "D1 database", databaseName);
+    }
+    return (await createResponse.json());
+}
+/**
+ * Get a D1 database
+ */
+export async function getDatabase(api, databaseId) {
+    if (!databaseId) {
+        throw new Error("Database ID is required");
+    }
+    const response = await api.get(`/accounts/${api.accountId}/d1/database/${databaseId}`);
+    if (!response.ok) {
+        return await handleApiError(response, "getting", "D1 database", databaseId);
+    }
+    return (await response.json());
+}
+/**
+ * Delete a D1 database
+ */
+export async function deleteDatabase(api, databaseId) {
+    if (!databaseId) {
+        console.log("No database ID provided, skipping delete");
+        return;
+    }
+    // Delete D1 database
+    const deleteResponse = await api.delete(`/accounts/${api.accountId}/d1/database/${databaseId}`);
+    if (!deleteResponse.ok && deleteResponse.status !== 404) {
+        const errorData = await deleteResponse.json().catch(() => ({
+            errors: [{ message: deleteResponse.statusText }],
+        }));
+        throw new CloudflareApiError(`Error deleting D1 database '${databaseId}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`, deleteResponse);
+    }
+}
+/**
+ * List all D1 databases in an account
+ */
+export async function listDatabases(api, name) {
+    // Construct query string if name is provided
+    const queryParams = name ? `?name=${encodeURIComponent(name)}` : "";
+    const response = await api.get(`/accounts/${api.accountId}/d1/database${queryParams}`);
+    if (!response.ok) {
+        throw new CloudflareApiError(`Failed to list databases: ${response.statusText}`, response);
+    }
+    const data = (await response.json());
+    if (!data.success) {
+        const errorMessage = data.errors?.[0]?.message || "Unknown error";
+        throw new Error(`Failed to list databases: ${errorMessage}`);
+    }
+    // Transform API response
+    return (data.result || []).map((db) => ({
+        name: db.name,
+        id: db.uuid,
+    }));
+}
+/**
+ * Update a D1 database
+ *
+ * Note: According to Cloudflare API, only read_replication.mode can be modified during updates.
+ */
+export async function updateDatabase(api, databaseId, props) {
+    // Get current database state to check for non-mutable changes
+    const currentDB = await getDatabase(api, databaseId);
+    // Only read_replication can be modified in update
+    if (props.primaryLocationHint &&
+        props.primaryLocationHint !== currentDB.result.primary_location_hint) {
+        throw new Error("Cannot update primaryLocationHint after database creation. Only readReplication.mode can be modified.");
+    }
+    const updatePayload = {};
+    // Only include read_replication in update payload
+    if (props.readReplication) {
+        updatePayload.read_replication = {
+            mode: props.readReplication.mode,
+        };
+    }
+    const updateResponse = await api.patch(`/accounts/${api.accountId}/d1/database/${databaseId}`, updatePayload);
+    if (!updateResponse.ok) {
+        return await handleApiError(updateResponse, "updating", "D1 database", databaseId);
+    }
+    return (await updateResponse.json());
+}

package/lib/cloudflare/index.d.ts

@@ -1,13 +1,17 @@
 export * from "./account-api-token";
 export * from "./api";
+export * from "./api-error";
 export * from "./assets";
 export * from "./bindings";
 export * from "./bucket";
 export * from "./custom-domain";
+export * from "./d1-database";
 export * from "./dns-records";
 export * from "./durable-object-namespace";
 export * from "./kv-namespace";
 export * from "./permission-groups";
+export * from "./pipeline";
+export * from "./queue";
 export * from "./r2-rest-state-store";
 export * from "./worker";
 export { Workflow } from "./workflow";

package/lib/cloudflare/index.js

@@ -1,13 +1,17 @@
 export * from "./account-api-token";
 export * from "./api";
+export * from "./api-error";
 export * from "./assets";
 export * from "./bindings";
 export * from "./bucket";
 export * from "./custom-domain";
+export * from "./d1-database";
 export * from "./dns-records";
 export * from "./durable-object-namespace";
 export * from "./kv-namespace";
 export * from "./permission-groups";
+export * from "./pipeline";
+export * from "./queue";
 export * from "./r2-rest-state-store";
 export * from "./worker";
 export { Workflow } from "./workflow";

package/lib/cloudflare/kv-namespace.d.ts

@@ -1,7 +1,6 @@
 import type { Context } from "../context";
 import { Resource } from "../resource";
 import { CloudflareApi, type CloudflareApiOptions } from "./api";
-export declare function isKVNamespace(resource: any): resource is KVNamespace;
 /**
  * Properties for creating or updating a KV Namespace
  */

package/lib/cloudflare/kv-namespace.js

@@ -2,9 +2,6 @@ import { Resource } from "../resource";
 import { withExponentialBackoff } from "../util/retry";
 import { CloudflareApi, createCloudflareApi, } from "./api";
 import { handleApiError } from "./api-error";
-export function isKVNamespace(resource) {
-    return (resource && typeof resource === "object" && resource.type === "kv_namespace");
-}
 /**
  * A Cloudflare KV Namespace is a key-value store that can be used to store data for your application.
  *