alchemy 0.2.5 → 0.3.1

package/lib/cloudflare/generate-asset-manifest.js

@@ -9,7 +9,7 @@ export async function generateAssetManifest(dir, fileOptions = [
         cacheControl: "max-age=0,no-cache,no-store,must-revalidate",
     },
     {
-        files: ["**/*.js", "**/*.css"],
+        files: ["**/*.js", "**/*.css", "**/*.png", "**/*.webp"],
         cacheControl: "max-age=31536000,public,immutable",
     },
 ]) {

package/lib/cloudflare/index.d.ts

@@ -1,8 +1,9 @@
 export * from "./bindings";
 export * from "./bucket";
+export * from "./dns";
 export * from "./durable-object-namespace";
 export * from "./kv-namespace";
-export * from "./state";
+export * from "./r2-rest-state-store";
 export * from "./static-site";
 export * from "./worker";
 export * from "./wrangler.json";

package/lib/cloudflare/index.js

@@ -1,8 +1,9 @@
 export * from "./bindings";
 export * from "./bucket";
+export * from "./dns";
 export * from "./durable-object-namespace";
 export * from "./kv-namespace";
-export * from "./state";
+export * from "./r2-rest-state-store";
 export * from "./static-site";
 export * from "./worker";
 export * from "./wrangler.json";

package/lib/cloudflare/r2-rest-state-store.d.ts

@@ -0,0 +1,125 @@
+import type { Scope } from "../scope";
+import type { State, StateStore } from "../state";
+/**
+ * Options for CloudflareR2StateStore
+ */
+export interface CloudflareR2StateStoreOptions {
+    /**
+     * The prefix to use for object keys in the R2 bucket
+     * This allows multiple state stores to use the same R2 bucket
+     */
+    prefix?: string;
+    /**
+     * The R2 bucket name to use
+     * Required - the bucket must already exist
+     */
+    bucketName: string;
+    /**
+     * API key to use (overrides CLOUDFLARE_API_KEY env var)
+     */
+    apiKey?: string;
+    /**
+     * Account ID to use (overrides CLOUDFLARE_ACCOUNT_ID env var)
+     */
+    accountId?: string;
+    /**
+     * Email to use with API Key authentication (overrides CLOUDFLARE_EMAIL env var)
+     */
+    email?: string;
+}
+/**
+ * State store implementation using Cloudflare R2 API
+ * Uses R2 for immediate consistency compared to KV's eventual consistency
+ */
+export declare class R2RestStateStore implements StateStore {
+    readonly scope: Scope;
+    private api;
+    private prefix;
+    private bucketName;
+    private apiKey;
+    private accountId;
+    private email;
+    private initialized;
+    /**
+     * Create a new CloudflareR2StateStore
+     *
+     * @param scope The scope this store belongs to
+     * @param options Options for the state store
+     */
+    constructor(scope: Scope, options: CloudflareR2StateStoreOptions);
+    /**
+     * Initialize the R2 client
+     */
+    init(): Promise<void>;
+    /**
+     * R2 buckets cannot be deleted programmatically via this method
+     */
+    deinit(): Promise<void>;
+    /**
+     * List all resources in the state store
+     */
+    list(): Promise<string[]>;
+    /**
+     * Count the number of items in the state store
+     */
+    count(): Promise<number>;
+    /**
+     * Get a state by key
+     *
+     * @param key The key to look up
+     * @returns The state or undefined if not found
+     */
+    get(key: string): Promise<State | undefined>;
+    /**
+     * Get multiple states by their keys
+     *
+     * @param ids Array of keys to fetch
+     * @returns Record mapping keys to their states
+     */
+    getBatch(ids: string[]): Promise<Record<string, State>>;
+    /**
+     * Get all states in the store
+     *
+     * @returns Record mapping all keys to their states
+     */
+    all(): Promise<Record<string, State>>;
+    /**
+     * Set a state for a key
+     *
+     * @param key The key to set
+     * @param value The state to store
+     */
+    set(key: string, value: State): Promise<void>;
+    /**
+     * Delete a state by key
+     *
+     * @param key The key to delete
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Convert key for storage by replacing slashes with colons
+     * since R2 treats slashes as directory separators
+     *
+     * @param key The original key
+     * @returns Key with slashes replaced by colons
+     */
+    private convertKeyForStorage;
+    /**
+     * Convert key from storage by replacing colons with slashes
+     *
+     * @param key The storage key
+     * @returns Key with colons replaced by slashes
+     */
+    private convertKeyFromStorage;
+    /**
+     * Get the full object key for storage
+     *
+     * @param key The original key
+     * @returns The key with prefix for use in the R2 bucket
+     */
+    private getObjectKey;
+    /**
+     * Ensure the store is initialized before operations
+     */
+    private ensureInitialized;
+}

package/lib/cloudflare/r2-rest-state-store.js

@@ -0,0 +1,254 @@
+import { withExponentialBackoff } from "../util/retry";
+import { deserialize, serialize } from "../util/serde";
+import { createCloudflareApi } from "./api";
+/**
+ * State store implementation using Cloudflare R2 API
+ * Uses R2 for immediate consistency compared to KV's eventual consistency
+ */
+export class R2RestStateStore {
+    scope;
+    api;
+    prefix;
+    bucketName;
+    apiKey;
+    accountId;
+    email;
+    initialized = false;
+    /**
+     * Create a new CloudflareR2StateStore
+     *
+     * @param scope The scope this store belongs to
+     * @param options Options for the state store
+     */
+    constructor(scope, options) {
+        this.scope = scope;
+        // Use the scope's chain to build the prefix, similar to how FileSystemStateStore builds its directory
+        const scopePath = scope.chain.join("/");
+        this.prefix = options.prefix
+            ? `${options.prefix}${scopePath}/`
+            : `alchemy/${scopePath}/`;
+        if (!options.bucketName) {
+            throw new Error("bucketName is required for CloudflareR2StateStore");
+        }
+        this.bucketName = options.bucketName;
+        this.apiKey = options.apiKey;
+        this.accountId = options.accountId;
+        this.email = options.email;
+        // We'll initialize the API in init() to allow for async creation
+        this.api = null;
+    }
+    /**
+     * Initialize the R2 client
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        // Create Cloudflare API client with automatic account discovery
+        this.api = await createCloudflareApi({
+            apiKey: this.apiKey,
+            accountId: this.accountId,
+            email: this.email,
+        });
+        this.initialized = true;
+    }
+    /**
+     * R2 buckets cannot be deleted programmatically via this method
+     */
+    async deinit() {
+        // We don't delete the bucket here, only via explicit resource deletion
+    }
+    /**
+     * List all resources in the state store
+     */
+    async list() {
+        await this.ensureInitialized();
+        // Using pagination to get all objects
+        let keys = [];
+        let cursor = null;
+        do {
+            const params = new URLSearchParams({
+                prefix: this.prefix,
+                limit: "1000",
+            });
+            if (cursor) {
+                params.append("cursor", cursor);
+            }
+            const listPath = `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects?${params.toString()}`;
+            const response = await this.api.get(listPath);
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({
+                    errors: [{ message: response.statusText }],
+                }));
+                throw new Error(`Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`);
+            }
+            const data = (await response.json());
+            // The result structure may be under "result" key in Cloudflare's API
+            const result = data.result || data;
+            const objects = result.objects || [];
+            // Add keys to our list, removing the prefix and converting from storage format
+            keys = keys.concat(objects.map((obj) => {
+                const keyName = obj.key || obj.name;
+                return this.convertKeyFromStorage(keyName.slice(this.prefix.length));
+            }));
+            // Update cursor for next page if available
+            cursor =
+                result.truncated || result.cursor_pagination
+                    ? result.cursor || null
+                    : null;
+        } while (cursor);
+        return keys;
+    }
+    /**
+     * Count the number of items in the state store
+     */
+    async count() {
+        const keys = await this.list();
+        return keys.length;
+    }
+    /**
+     * Get a state by key
+     *
+     * @param key The key to look up
+     * @returns The state or undefined if not found
+     */
+    async get(key) {
+        await this.ensureInitialized();
+        try {
+            const response = await this.api.get(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
+            if (!response.ok) {
+                if (response.status === 404) {
+                    return undefined;
+                }
+                const errorData = await response.json().catch(() => ({
+                    errors: [{ message: response.statusText }],
+                }));
+                throw new Error(`Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`);
+            }
+            // Parse and deserialize the state data
+            const rawData = await response.json();
+            const state = (await deserialize(this.scope, rawData));
+            // Create a new state object with proper output
+            return {
+                ...state,
+                output: {
+                    ...(state.output || {}),
+                    Scope: this.scope,
+                },
+            };
+        }
+        catch (error) {
+            if (error.message?.includes("404")) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get multiple states by their keys
+     *
+     * @param ids Array of keys to fetch
+     * @returns Record mapping keys to their states
+     */
+    async getBatch(ids) {
+        const result = {};
+        // R2 REST API doesn't have a batch get operation, so we need to make multiple requests
+        const promises = ids.map(async (id) => {
+            const state = await this.get(id);
+            if (state) {
+                result[id] = state;
+            }
+        });
+        await Promise.all(promises);
+        return result;
+    }
+    /**
+     * Get all states in the store
+     *
+     * @returns Record mapping all keys to their states
+     */
+    async all() {
+        const keys = await this.list();
+        return this.getBatch(keys);
+    }
+    /**
+     * Set a state for a key
+     *
+     * @param key The key to set
+     * @param value The state to store
+     */
+    async set(key, value) {
+        await this.ensureInitialized();
+        const objectKey = this.getObjectKey(key);
+        // Serialize the state to handle cyclic structures
+        const serializedData = await serialize(this.scope, value);
+        // Using withExponentialBackoff for reliability
+        await withExponentialBackoff(async () => {
+            const response = await this.api.put(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${objectKey}`, serializedData, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({
+                    errors: [{ message: response.statusText }],
+                }));
+                throw new Error(`Error writing to R2: ${errorData.errors?.[0]?.message || response.statusText}`);
+            }
+            return response;
+        }, 
+        // Retry on transient errors
+        (error) => error.message?.includes("503") || error.message?.includes("timeout"), 5, // 5 retry attempts
+        1000);
+    }
+    /**
+     * Delete a state by key
+     *
+     * @param key The key to delete
+     */
+    async delete(key) {
+        await this.ensureInitialized();
+        const response = await this.api.delete(`/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`);
+        if (!response.ok && response.status !== 404) {
+            const errorData = await response.json().catch(() => ({
+                errors: [{ message: response.statusText }],
+            }));
+            throw new Error(`Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`);
+        }
+    }
+    /**
+     * Convert key for storage by replacing slashes with colons
+     * since R2 treats slashes as directory separators
+     *
+     * @param key The original key
+     * @returns Key with slashes replaced by colons
+     */
+    convertKeyForStorage(key) {
+        return key.replaceAll("/", ":");
+    }
+    /**
+     * Convert key from storage by replacing colons with slashes
+     *
+     * @param key The storage key
+     * @returns Key with colons replaced by slashes
+     */
+    convertKeyFromStorage(key) {
+        return key.replaceAll(":", "/");
+    }
+    /**
+     * Get the full object key for storage
+     *
+     * @param key The original key
+     * @returns The key with prefix for use in the R2 bucket
+     */
+    getObjectKey(key) {
+        return `${this.prefix}${this.convertKeyForStorage(key)}`;
+    }
+    /**
+     * Ensure the store is initialized before operations
+     */
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.init();
+        }
+    }
+}

package/lib/cloudflare/response.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Cloudflare API response format
+ */
+export interface CloudflareResponse<T = unknown> {
+    result: T;
+    success: boolean;
+    errors: Array<{
+        code: number;
+        message: string;
+    }>;
+    messages: string[];
+}

package/lib/cloudflare/static-site-router.js

@@ -35,34 +35,44 @@ app.notFound(async (ctx) => {
     }
     // Fetch from KV
     {
-        const object = await env.ASSETS.getWithMetadata(filePath);
+        const object = await env.ASSETS.getWithMetadata(filePath, {
+            type: "arrayBuffer",
+        });
         if (object.value) {
             return await respond(200, filePath, object);
         }
     }
     {
         const guess = filePath + (filePath.endsWith("/") ? "" : "/") + "index.html";
-        const object = await env.ASSETS.getWithMetadata(guess);
+        const object = await env.ASSETS.getWithMetadata(guess, {
+            type: "arrayBuffer",
+        });
         if (object.value) {
             return await respond(200, guess, object);
         }
     }
     {
         const guess = filePath + ".html";
-        const object = await env.ASSETS.getWithMetadata(guess);
+        const object = await env.ASSETS.getWithMetadata(guess, {
+            type: "arrayBuffer",
+        });
         if (object.value) {
             return await respond(200, guess, object);
         }
     }
     // Handle error page
     if (env.ERROR_PAGE) {
-        const object = await env.ASSETS.getWithMetadata(env.ERROR_PAGE);
+        const object = await env.ASSETS.getWithMetadata(env.ERROR_PAGE, {
+            type: "arrayBuffer",
+        });
         if (object.value) {
             return await respond(404, env.ERROR_PAGE, object);
         }
     }
     else {
-        const object = await env.ASSETS.getWithMetadata(env.INDEX_PAGE);
+        const object = await env.ASSETS.getWithMetadata(env.INDEX_PAGE, {
+            type: "arrayBuffer",
+        });
         if (object.value) {
             return await respond(200, env.INDEX_PAGE, object);
         }
@@ -92,8 +102,7 @@ app.notFound(async (ctx) => {
             headers.set("content-type", object.metadata.contentType);
             headers.set("cache-control", object.metadata.cacheControl);
         }
-        // TODO: do we need base64 encoded here?
-        // const response = new Response(base64ToArrayBuffer(object.value), {
+        // Create response with the raw data directly
         const response = new Response(object.value, {
             status,
             headers,

package/lib/cloudflare/static-site.js

@@ -122,6 +122,9 @@ export const StaticSite = Resource("cloudflare::StaticSite", {
         }),
         generateAssetManifest(props.dir),
     ]);
+    console.log({
+        assetManifest,
+    });
     // Step 3: Upload assets to KV
     await uploadAssetManifest(api, kv.namespaceId, assetManifest);
     // Prepare the bindings for the worker

package/lib/cloudflare/upload-asset-manifest.js

@@ -34,8 +34,10 @@ export async function uploadAssetManifest(api, namespaceId, manifest) {
         // Create FormData for multipart upload
         const formData = new FormData();
         formData.append("metadata", JSON.stringify(metadata));
-        // Add file content as 'value'
-        const blob = new Blob([content]);
+        // Add file content as 'value' - Fix for binary file corruption
+        const blob = new Blob([new Uint8Array(content)], {
+            type: item.contentType,
+        });
         formData.append("value", blob);
         try {
             const response = await api.put(`/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}/values/${item.key}`, formData);

package/lib/cloudflare/zone.d.ts

@@ -249,3 +249,21 @@ export interface Zone extends Resource<"cloudflare::Zone"> {
  * @see https://developers.cloudflare.com/dns/zone-setups/
  */
 export declare const Zone: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Zone>, id: string, props: ZoneProps) => Promise<Zone>);
+/**
+ * Cloudflare Zone response format
+ */
+export interface CloudflareZone {
+    id: string;
+    name: string;
+    type: "full" | "partial" | "secondary";
+    status: string;
+    paused: boolean;
+    account: {
+        id: string;
+    };
+    name_servers: string[];
+    original_name_servers: string[] | null;
+    created_on: string;
+    modified_on: string;
+    activated_on: string | null;
+}

package/lib/cloudflare/zone.js

@@ -82,8 +82,8 @@ export const Zone = Resource("cloudflare::Zone", async function (id, props) {
         if (!response.ok) {
             throw new Error(`Error getting zone '${props.name}': ${response.statusText}`);
         }
-        const result = (await response.json());
-        const zoneData = result.result;
+        const zoneData = (await response.json())
+            .result;
         // Update zone settings if provided
         if (props.settings) {
             await updateZoneSettings(api, this.output.id, props.settings);
@@ -118,15 +118,28 @@ export const Zone = Resource("cloudflare::Zone", async function (id, props) {
             },
         });
         const body = await response.text();
+        let zoneData;
         if (!response.ok) {
             if (response.status === 400 && body.includes("already exists")) {
-                // TODO: should we error?
+                // Zone already exists, fetch it instead
+                console.warn(`Zone '${props.name}' already exists during Zone create, adopting it...`);
+                const getResponse = await api.get(`/zones?name=${props.name}`);
+                if (!getResponse.ok) {
+                    throw new Error(`Error fetching existing zone '${props.name}': ${getResponse.statusText}`);
+                }
+                const zones = (await getResponse.json()).result;
+                if (zones.length === 0) {
+                    throw new Error(`Zone '${props.name}' does not exist, but the name is reserved for another user.`);
+                }
+                zoneData = zones[0];
             }
             else {
                 throw new Error(`Error creating zone '${props.name}': ${response.statusText}\n${body}`);
             }
         }
-        const zoneData = JSON.parse(body).result;
+        else {
+            zoneData = JSON.parse(body).result;
+        }
         // Update zone settings if provided
         if (props.settings) {
             await updateZoneSettings(api, zoneData.id, props.settings);

package/lib/dns/godaddy.d.ts

@@ -0,0 +1,7 @@
+export type UpdateNameserversOptions = {
+    domain: string;
+    apiKey: string;
+    apiSecret: string;
+    nameservers: string[];
+};
+export declare function updateNameservers(options: UpdateNameserversOptions): Promise<void>;

package/lib/dns/godaddy.js

@@ -0,0 +1,21 @@
+export async function updateNameservers(options) {
+    const url = `https://api.godaddy.com/v1/domains/${options.domain}/nameservers`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+            Authorization: `sso-key ${options.apiKey}:${options.apiSecret}`,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        },
+        body: JSON.stringify({
+            nameservers: options.nameservers,
+        }),
+    });
+    if (response.ok) {
+        console.log(`✅ Nameservers updated for ${options.domain}`);
+    }
+    else {
+        const error = await response.json();
+        console.error(`❌ Failed to update nameservers:`, error);
+    }
+}