alchemy 0.15.9 → 0.15.11

package/src/cloudflare/d1-database.ts

@@ -2,10 +2,11 @@ import type { Context } from "../context.js";
 import { Resource } from "../resource.js";
 import { CloudflareApiError, handleApiError } from "./api-error.js";
 import {
-  type CloudflareApi,
   createCloudflareApi,
+  type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.js";
+import { cloneD1Database } from "./d1-clone.js";
 import { applyMigrations, listMigrationsFiles } from "./d1-migrations.js";
 
 /**
@@ -61,6 +62,17 @@ export interface D1DatabaseProps extends CloudflareApiOptions {
    */
   adopt?: boolean;
 
+  /**
+   * Clone data from an existing database to this new database.
+   * Only applicable during creation phase.
+   *
+   * Can be specified as:
+   * - A D1Database object
+   * - An object with an id property
+   * - An object with a name property (will look up the ID by name)
+   */
+  clone?: D1Database | { id: string } | { name: string };
+
   /**
    * These files will be generated internally with the D1Database wrapper function when migrationsDir is specified
    *
@@ -123,20 +135,6 @@ export type D1Database = Resource<"cloudflare::D1Database"> &
     };
   };
 
-export async function D1Database(
-  id: string,
-  props: Omit<D1DatabaseProps, "migrationsFiles">,
-) {
-  const migrationsFiles = props.migrationsDir
-    ? await listMigrationsFiles(props.migrationsDir)
-    : [];
-
-  return D1DatabaseResource(id, {
-    ...props,
-    migrationsFiles,
-  });
-}
-
 /**
  * Creates and manages Cloudflare D1 Databases.
  *
@@ -173,8 +171,43 @@ export async function D1Database(
  *   migrationsDir: "./migrations",
  * });
  *
+ * @example
+ * // Clone an existing database by ID
+ * const clonedDb = await D1Database("cloned-db", {
+ *   name: "cloned-db",
+ *   clone: otherDb
+ * });
+ *
+ * @example
+ * // Clone an existing database by ID
+ * const clonedDb = await D1Database("cloned-db", {
+ *   name: "cloned-db",
+ *   clone: { id: "existing-db-uuid" }
+ * });
+ *
+ * @example
+ * // Clone an existing database by name
+ * const clonedDb = await D1Database("cloned-db", {
+ *   name: "cloned-db",
+ *   clone: { name: "existing-db-name" }
+ * });
+ *
  * @see https://developers.cloudflare.com/d1/
  */
+export async function D1Database(
+  id: string,
+  props: Omit<D1DatabaseProps, "migrationsFiles">,
+) {
+  const migrationsFiles = props.migrationsDir
+    ? await listMigrationsFiles(props.migrationsDir)
+    : [];
+
+  return D1DatabaseResource(id, {
+    ...props,
+    migrationsFiles,
+  });
+}
+
 export const D1DatabaseResource = Resource(
   "cloudflare::D1Database",
   async function (
@@ -202,6 +235,11 @@ export const D1DatabaseResource = Resource(
       console.log("Creating D1 database:", databaseName);
       try {
         dbData = await createDatabase(api, databaseName, props);
+
+        // If clone property is provided, perform cloning after database creation
+        if (props.clone && dbData.result.uuid) {
+          await cloneDb(api, props.clone, dbData.result.uuid);
+        }
       } catch (error) {
         // Check if this is a "database already exists" error and adopt is enabled
         if (
@@ -480,3 +518,49 @@ export async function updateDatabase(
 
   return (await updateResponse.json()) as CloudflareD1Response;
 }
+
+/**
+ * Helper function to clone data from a source database to a target database
+ * Resolves the source database ID from different input formats and performs the cloning operation
+ *
+ * @param api CloudflareApi instance
+ * @param sourceDb Source database specification (can be an ID, a name, or a D1Database object)
+ * @param targetDbId Target database ID
+ */
+async function cloneDb(
+  api: CloudflareApi,
+  sourceDb: D1Database | { id: string } | { name: string },
+  targetDbId: string,
+): Promise<void> {
+  let sourceId: string;
+
+  // Determine source database ID
+  if ("id" in sourceDb && sourceDb.id) {
+    // Use provided ID directly
+    sourceId = sourceDb.id;
+  } else if ("name" in sourceDb && sourceDb.name) {
+    // Look up ID by name
+    const databases = await listDatabases(api, sourceDb.name);
+    const foundDb = databases.find((db) => db.name === sourceDb.name);
+
+    if (!foundDb) {
+      throw new Error(
+        `Source database with name '${sourceDb.name}' not found for cloning`,
+      );
+    }
+
+    sourceId = foundDb.id;
+  } else if ("type" in sourceDb && sourceDb.type === "d1" && "id" in sourceDb) {
+    // It's a D1Database object
+    sourceId = sourceDb.id;
+  } else {
+    throw new Error("Invalid clone property: must provide either id or name");
+  }
+
+  // Perform the cloning
+  console.log(`Cloning data from database ${sourceId} to ${targetDbId}`);
+  await cloneD1Database(api, {
+    sourceDatabaseId: sourceId,
+    targetDatabaseId: targetDbId,
+  });
+}

package/src/cloudflare/d1-export.ts

@@ -0,0 +1,173 @@
+import type { CloudflareApi } from "./api.js"; // Ensure CloudflareApi is exported if not already
+
+/**
+ * Options for exporting a D1 database
+ */
+export interface ExportD1DatabaseOptions {
+  /**
+   * The ID of the D1 database to export
+   */
+  databaseId: string;
+
+  /**
+   * Optional dump options to control what is exported
+   */
+  dumpOptions?: {
+    /**
+     * Optional list of tables to export
+     */
+    tables?: string[];
+
+    /**
+     * Whether to exclude schema in the export
+     */
+    no_schema?: boolean;
+
+    /**
+     * Whether to exclude data in the export
+     */
+    no_data?: boolean;
+  };
+}
+
+/**
+ * Response from the export D1 database operation
+ */
+export interface ExportD1DatabaseResult {
+  /**
+   * The filename of the exported database
+   */
+  filename: string;
+
+  /**
+   * The signed URL for downloading the exported database
+   */
+  signed_url: string;
+
+  /**
+   * The status of the export operation
+   */
+  status: "complete";
+
+  /**
+   * Whether the export operation was successful
+   */
+  success: boolean;
+}
+
+/**
+ * Error response from Cloudflare API
+ */
+interface CloudflareErrorResponse {
+  error?: string;
+  errors?: Array<{
+    message: string;
+  }>;
+}
+
+/**
+ * Response during polling for D1 database export
+ */
+interface ExportPollingResponse {
+  /**
+   * Bookmark for continuing the polling process
+   */
+  at_bookmark?: string;
+
+  /**
+   * Error message if any
+   */
+  error?: string;
+
+  /**
+   * Progress messages from the export process
+   */
+  messages: string[];
+
+  /**
+   * Result data if export is complete
+   */
+  result?: {
+    filename: string;
+    signed_url: string;
+  };
+
+  /**
+   * Status of the export process
+   */
+  status: "complete" | "error" | "processing";
+
+  /**
+   * Whether the current polling request was successful
+   */
+  success: boolean;
+
+  /**
+   * Type of operation
+   */
+  type: "export";
+}
+
+/**
+ * Initiates an export of a Cloudflare D1 database and returns a download URL.
+ * Implements recursive polling with bookmark handling, similar to wrangler.
+ * Waits indefinitely until the export process completes or fails.
+ *
+ * Based on Cloudflare API:
+ * https://developers.cloudflare.com/api/resources/d1/subresources/database/methods/export/
+ * and wrangler implementation.
+ *
+ * @param options Options including the database ID and optional dump parameters.
+ * @returns An object containing the download URL, filename, and status upon completion.
+ * @throws Will throw an error if the API call fails or the export process reports an error.
+ */
+export async function exportD1Database(
+  api: CloudflareApi,
+  options: ExportD1DatabaseOptions,
+  currentBookmark?: string,
+): Promise<ExportD1DatabaseResult> {
+  const response = await api.post(
+    `/accounts/${api.accountId}/d1/database/${options.databaseId}/export`,
+    {
+      output_format: "polling",
+      dump_options: options.dumpOptions || {},
+      current_bookmark: currentBookmark,
+    },
+  );
+
+  if (!response.ok) {
+    const errorData = (await response.json()) as CloudflareErrorResponse;
+    throw new Error(
+      `Failed to export D1 database: ${errorData.error || errorData.errors?.[0]?.message || "Unknown error"}`,
+    );
+  }
+
+  const { result: data } = (await response.json()) as {
+    result: ExportPollingResponse;
+  };
+
+  if (!data.success) {
+    throw new Error(data.error || "Unknown error during D1 export");
+  }
+
+  // Log messages for visibility
+  if (data.messages && data.messages.length > 0) {
+    for (const message of data.messages) {
+      console.log(`D1 Export: ${message}`);
+    }
+  }
+
+  if (data.status === "complete" && data.result) {
+    return {
+      filename: data.result.filename,
+      signed_url: data.result.signed_url,
+      status: data.status,
+      success: data.success,
+    };
+  } else if (data.status === "error") {
+    throw new Error(data.error || "Error during D1 export");
+  } else {
+    // Continue polling with bookmark
+    return exportD1Database(api, options, data.at_bookmark);
+  }
+}