alchemy 0.7.0 → 0.7.2

package/src/cloudflare/d1-database.ts

@@ -0,0 +1,412 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import {
+  CloudflareApi,
+  createCloudflareApi,
+  type CloudflareApiOptions,
+} from "./api";
+import { CloudflareApiError, handleApiError } from "./api-error";
+
+/**
+ * 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 const D1Database = Resource(
+  "cloudflare::D1Database",
+  async function (
+    this: Context<D1Database>,
+    id: string,
+    props: D1DatabaseProps
+  ): Promise<D1Database> {
+    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: CloudflareD1Response;
+
+      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,
+      });
+    }
+  }
+);
+
+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 async function createDatabase(
+  api: CloudflareApi,
+  databaseName: string,
+  props: D1DatabaseProps
+): Promise<CloudflareD1Response> {
+  // Create new D1 database
+  const createPayload: any = {
+    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()) as CloudflareD1Response;
+}
+
+/**
+ * Get a D1 database
+ */
+export async function getDatabase(
+  api: CloudflareApi,
+  databaseId?: string
+): Promise<CloudflareD1Response> {
+  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()) as CloudflareD1Response;
+}
+
+/**
+ * Delete a D1 database
+ */
+export async function deleteDatabase(
+  api: CloudflareApi,
+  databaseId?: string
+): Promise<void> {
+  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: any = 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: CloudflareApi,
+  name?: string
+): Promise<{ name: string; id: string }[]> {
+  // 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()) as {
+    success: boolean;
+    errors?: Array<{ code: number; message: string }>;
+    result?: Array<{
+      name: string;
+      uuid: string;
+    }>;
+  };
+
+  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: CloudflareApi,
+  databaseId: string,
+  props: D1DatabaseProps
+): Promise<CloudflareD1Response> {
+  // 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: any = {};
+
+  // 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()) as CloudflareD1Response;
+}

package/src/cloudflare/index.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/src/cloudflare/kv-namespace.ts

@@ -8,12 +8,6 @@ import {
 } from "./api";
 import { handleApiError } from "./api-error";
 
-export function isKVNamespace(resource: any): resource is KVNamespace {
-  return (
-    resource && typeof resource === "object" && resource.type === "kv_namespace"
-  );
-}
-
 /**
  * Properties for creating or updating a KV Namespace
  */