alchemy 0.7.0 → 0.7.1

package/lib/cloudflare/wrangler.json.js

@@ -1,4 +1,4 @@
-import * as fs from "fs/promises";
+import { StaticJsonFile } from "../fs";
 import { Resource } from "../resource";
 /**
  * Resource for managing wrangler.json configuration files
@@ -7,29 +7,136 @@ export const WranglerJson = Resource("cloudflare::WranglerJson", async function
     // Default path is wrangler.json in current directory
     const filePath = props.path || "wrangler.json";
     if (this.phase === "delete") {
-        try {
-            await fs.unlink(filePath);
-        }
-        catch (error) {
-            // Ignore errors if file doesn't exist
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-        }
         return this.destroy();
     }
-    // Create or update the file
-    const config = {
-        ...props,
-        // Remove internal path property
-        path: undefined,
+    if (props.worker.entrypoint === undefined) {
+        throw new Error("Worker must have an entrypoint to generate a wrangler.json");
+    }
+    const worker = props.worker;
+    const spec = {
+        name: worker.name,
+        // Use entrypoint as main if it exists
+        main: worker.entrypoint,
+        // see: https://developers.cloudflare.com/workers/configuration/compatibility-dates/
+        compatibility_date: "2022-04-05",
     };
-    // Write the file
-    await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+    // Process bindings if they exist
+    if (worker.bindings) {
+        processBindings(spec, worker.bindings);
+    }
+    // Add environment variables as vars
+    if (worker.env) {
+        spec.vars = { ...worker.env };
+    }
+    await StaticJsonFile("wrangler.json", spec);
     // Return the resource
     return this({
         ...props,
+        path: filePath,
         createdAt: Date.now(),
         updatedAt: Date.now(),
     });
 });
+/**
+ * Process worker bindings into wrangler.json format
+ */
+function processBindings(spec, bindings) {
+    // Arrays to collect different binding types
+    const kvNamespaces = [];
+    const durableObjects = [];
+    const r2Buckets = [];
+    const services = [];
+    const secrets = [];
+    const workflows = [];
+    const d1Databases = [];
+    const queues = [];
+    // Process each binding
+    for (const [bindingName, binding] of Object.entries(bindings)) {
+        if (typeof binding === "string") {
+            // Plain text binding - add to vars
+            if (!spec.vars) {
+                spec.vars = {};
+            }
+            spec.vars[bindingName] = binding;
+        }
+        else if (binding.type === "kv_namespace") {
+            // KV Namespace binding
+            kvNamespaces.push({
+                binding: bindingName,
+                id: binding.namespaceId,
+            });
+        }
+        else if (typeof binding === "object" &&
+            binding.type === "durable_object_namespace") {
+            // Durable Object binding
+            const doBinding = binding;
+            durableObjects.push({
+                name: bindingName,
+                class_name: doBinding.className,
+                script_name: doBinding.scriptName,
+                environment: doBinding.environment,
+            });
+        }
+        else if (binding.type === "r2_bucket") {
+            r2Buckets.push({
+                binding: bindingName,
+                bucket_name: binding.name,
+            });
+        }
+        else if (binding.type === "service") {
+            // Service binding
+            services.push({
+                binding: bindingName,
+                service: binding.id,
+            });
+        }
+        else if (binding.type === "secret") {
+            // Secret binding
+            secrets.push(bindingName);
+        }
+        else if (binding.type === "assets") {
+            spec.assets = {
+                directory: binding.path,
+                binding: bindingName,
+            };
+        }
+        else if (binding.type === "workflow") {
+            workflows.push({
+                name: bindingName,
+                binding: binding.id,
+                class_name: binding.className,
+            });
+        }
+        else if (binding.type === "d1") {
+            d1Databases.push({
+                binding: bindingName,
+                database_id: binding.id,
+                database_name: binding.name,
+            });
+        }
+        else if (binding.type === "queue") {
+            queues.push({
+                binding: bindingName,
+                queue: binding.name,
+            });
+        }
+    }
+    // Add collected bindings to the spec
+    if (kvNamespaces.length > 0) {
+        spec.kv_namespaces = kvNamespaces;
+    }
+    if (durableObjects.length > 0) {
+        spec.durable_objects = {
+            bindings: durableObjects,
+        };
+    }
+    if (r2Buckets.length > 0) {
+        spec.r2_buckets = r2Buckets;
+    }
+    if (services.length > 0) {
+        spec.services = services;
+    }
+    if (queues.length > 0) {
+        spec.queues = queues;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {

package/src/cloudflare/bindings.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";
 
@@ -19,14 +21,16 @@ export type Bindings = {
  * L2 Binding Resources.
  */
 export type Binding =
+  | Assets
+  | D1Database
   | DurableObjectNamespace
   | KVNamespace
-  | Worker
-  | Workflow
+  | Queue
   | R2Bucket
   | Secret
   | string
-  | Assets;
+  | Worker
+  | Workflow;
 
 /**
  * Union type for all Worker binding types (API spec)

package/src/cloudflare/bound.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";
 
@@ -21,4 +23,8 @@ export type Bound<T extends Binding> = T extends _DurableObjectNamespace
             ? Service
             : T extends _Workflow<infer P>
               ? Workflow<P>
-              : Service;
+              : T extends _D1Database
+                ? D1Database
+                : T extends _Queue
+                  ? Queue
+                  : Service;

package/src/cloudflare/d1-database.ts

@@ -0,0 +1,354 @@
+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;
+}
+
+/**
+ * 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 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);
+        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,
+      });
+    }
+  }
+);
+
+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
+): Promise<{ name: string; id: string }[]> {
+  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()) 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,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/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
  */