alchemy 0.7.0 → 0.7.1

package/lib/cloudflare/bindings.d.ts

@@ -6,8 +6,10 @@
 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 { Queue } from "./queue";
 import type { Worker } from "./worker";
 import type { Workflow } from "./workflow";
 export type Bindings = {
@@ -16,7 +18,7 @@ export type Bindings = {
 /**
  * L2 Binding Resources.
  */
-export type Binding = DurableObjectNamespace | KVNamespace | Worker | Workflow | R2Bucket | Secret | string | Assets;
+export type Binding = Assets | D1Database | DurableObjectNamespace | KVNamespace | Queue | R2Bucket | Secret | string | Worker | Workflow;
 /**
  * Union type for all Worker binding types (API spec)
  */

package/lib/cloudflare/bound.d.ts

@@ -2,8 +2,10 @@ 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 { 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 : Service;

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

@@ -0,0 +1,134 @@
+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;
+}
+/**
+ * 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"
+ * });
+ *
+ * @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): 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,161 @@
+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"
+ * });
+ *
+ * @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);
+            dbData = await createDatabase(api, databaseName, props);
+        }
+        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) {
+    const response = await api.get(`/accounts/${api.accountId}/d1/database`);
+    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,16 @@
 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 "./queue";
 export * from "./r2-rest-state-store";
 export * from "./worker";
 export { Workflow } from "./workflow";

package/lib/cloudflare/index.js

@@ -1,13 +1,16 @@
 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 "./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.
  *

package/lib/cloudflare/queue.d.ts

@@ -0,0 +1,147 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { CloudflareApi, type CloudflareApiOptions } from "./api";
+/**
+ * Settings for a Cloudflare Queue
+ */
+export interface QueueSettings {
+    /**
+     * Delay in seconds before message delivery
+     * Queue will not deliver messages until this time has elapsed
+     */
+    deliveryDelay?: number;
+    /**
+     * Whether delivery is paused
+     * If true, the queue will not deliver messages to consumers
+     */
+    deliveryPaused?: boolean;
+    /**
+     * Period in seconds to retain messages
+     * Messages will be automatically deleted after this time
+     */
+    messageRetentionPeriod?: number;
+}
+/**
+ * Properties for creating or updating a Cloudflare Queue
+ */
+export interface QueueProps extends CloudflareApiOptions {
+    /**
+     * Name of the queue
+     * Required during creation
+     * Cannot be changed after creation
+     */
+    name: string;
+    /**
+     * Settings for the queue
+     * These can be updated after queue creation
+     */
+    settings?: QueueSettings;
+    /**
+     * Whether to delete the queue.
+     * If set to false, the queue will remain but the resource will be removed from state
+     *
+     * @default true
+     */
+    delete?: boolean;
+}
+/**
+ * Output returned after Cloudflare Queue creation/update
+ */
+export interface Queue extends Resource<"cloudflare::Queue">, QueueProps {
+    /**
+     * Type identifier for Cloudflare Queue
+     */
+    type: "queue";
+    /**
+     * The unique ID of the queue
+     */
+    id: string;
+    /**
+     * Time when the queue was created
+     */
+    createdOn: string;
+    /**
+     * Modified timestamp
+     */
+    modifiedOn: string;
+}
+interface CloudflareQueueResponse {
+    result: {
+        queue_id?: string;
+        queue_name: string;
+        created_on?: string;
+        modified_on?: string;
+        settings?: {
+            delivery_delay?: number;
+            delivery_paused?: boolean;
+            message_retention_period?: number;
+        };
+    };
+    success: boolean;
+    errors: Array<{
+        code: number;
+        message: string;
+    }>;
+    messages: string[];
+}
+/**
+ * Creates and manages Cloudflare Queues.
+ *
+ * Queues provide a managed queue system for reliable message delivery
+ * between workers and other systems.
+ *
+ * @example
+ * // Create a basic queue with default settings
+ * const basicQueue = await Queue("my-app-queue", {
+ *   name: "my-app-queue"
+ * });
+ *
+ * @example
+ * // Create a queue with custom settings
+ * const customQueue = await Queue("delayed-queue", {
+ *   name: "delayed-queue",
+ *   settings: {
+ *     deliveryDelay: 30, // 30 second delay before message delivery
+ *     messageRetentionPeriod: 86400 // Store messages for 1 day
+ *   }
+ * });
+ *
+ * @example
+ * // Create a paused queue for later activation
+ * const pausedQueue = await Queue("paused-queue", {
+ *   name: "paused-queue",
+ *   settings: {
+ *     deliveryPaused: true
+ *   }
+ * });
+ *
+ * @see https://developers.cloudflare.com/queues/
+ */
+export declare const Queue: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Queue>, id: string, props: QueueProps) => Promise<Queue>);
+/**
+ * Create a new Cloudflare Queue
+ */
+export declare function createQueue(api: CloudflareApi, queueName: string, props: QueueProps): Promise<CloudflareQueueResponse>;
+/**
+ * Get a Cloudflare Queue
+ */
+export declare function getQueue(api: CloudflareApi, queueId: string): Promise<CloudflareQueueResponse>;
+/**
+ * Delete a Cloudflare Queue
+ */
+export declare function deleteQueue(api: CloudflareApi, queueId?: string): Promise<void>;
+/**
+ * Update a Cloudflare Queue
+ *
+ * Note: According to Cloudflare API, the queue name cannot be changed after creation.
+ * Only the settings can be updated.
+ */
+export declare function updateQueue(api: CloudflareApi, queueId: string, props: QueueProps): Promise<CloudflareQueueResponse>;
+/**
+ * List all Cloudflare Queues in an account
+ */
+export declare function listQueues(api: CloudflareApi): Promise<{
+    name: string;
+    id: string;
+}[]>;
+export {};