alchemy 0.67.0 → 0.68.0

package/src/cloudflare/api.ts

@@ -1,12 +1,10 @@
+import { Provider, type Credentials } from "../auth.ts";
 import type { Secret } from "../secret.ts";
+import { memoize } from "../util/memoize.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
 import { safeFetch } from "../util/safe-fetch.ts";
-import {
-  getCloudflareAuthHeaders,
-  normalizeAuthOptions,
-  type CloudflareAuthOptions,
-} from "./auth.ts";
-import { getCloudflareAccountId } from "./user.ts";
+import { CloudflareAuth } from "./auth.ts";
+import { getCloudflareAccountId, getUserEmailFromApiKey } from "./user.ts";
 
 /**
  * Options for Cloudflare API requests
@@ -19,6 +17,17 @@ export interface CloudflareApiOptions {
    */
   baseUrl?: string;
 
+  /**
+   * The Alchemy profile to use for Cloudflare credentials. Defaults to:
+   * - `process.env.CLOUDFLARE_PROFILE`
+   * - `process.env.ALCHEMY_PROFILE`
+   * - `"default"`
+   *
+   * If an API key or token is provided in these options or in the environment,
+   * the profile will be ignored.
+   */
+  profile?: string;
+
   /**
    * API Key to use (overrides CLOUDFLARE_API_KEY env var)
    */
@@ -42,56 +51,96 @@ export interface CloudflareApiOptions {
   email?: string;
 }
 
-/** Used to propagate normalized auth options from a parent resource to `createCloudflareApi` in a child resource */
-export type InternalCloudflareApiOptions = CloudflareAuthOptions & {
-  baseUrl?: string;
-  accountId: string;
-};
-
-function computeCacheKey(options: CloudflareApiOptions): string {
-  return `${options.baseUrl}|${options.accountId}|${options.apiKey?.unencrypted}|${options.apiToken?.unencrypted}|${options.email}`;
-}
-
-const cloudflareApiCache: Record<string, CloudflareApi> = {};
-
 /**
  * Creates a CloudflareApi instance with automatic account ID discovery if not provided
  *
  * @param options API options
  * @returns Promise resolving to a CloudflareApi instance
  */
-export async function createCloudflareApi(
-  options: Partial<CloudflareApiOptions> | InternalCloudflareApiOptions = {},
-): Promise<CloudflareApi> {
-  // TODO: Implement scope-level credential resolution similar to AWS
-  // This function should check for scope.providerCredentials.cloudflare
-  // and merge those credentials with the provided options, following
-  // the same three-tier resolution pattern: global → scope → resource
-  const cacheKey = computeCacheKey(options);
-  if (cloudflareApiCache[cacheKey]) {
-    return cloudflareApiCache[cacheKey];
-  }
+export const createCloudflareApi = memoize(
+  async (options: CloudflareApiOptions = {}) => {
+    const baseUrl = options.baseUrl ?? process.env.CLOUDFLARE_BASE_URL;
+    const apiKey =
+      options.apiKey?.unencrypted ?? process.env.CLOUDFLARE_API_KEY;
+    const apiToken =
+      options.apiToken?.unencrypted ?? process.env.CLOUDFLARE_API_TOKEN;
+    const email = options.email ?? process.env.CLOUDFLARE_EMAIL;
+    const accountId =
+      options.accountId ??
+      process.env.CLOUDFLARE_ACCOUNT_ID ??
+      process.env.CF_ACCOUNT_ID;
 
-  const authOptions = await normalizeAuthOptions(options);
-  const accountId =
-    options.accountId ??
-    process.env.CLOUDFLARE_ACCOUNT_ID ??
-    process.env.CF_ACCOUNT_ID ??
-    (await getCloudflareAccountId(authOptions));
-  return (cloudflareApiCache[cacheKey] = new CloudflareApi({
-    baseUrl: options.baseUrl,
-    accountId,
-    authOptions,
-  }));
-}
+    if (apiKey) {
+      const credentials: Credentials.ApiKey = {
+        type: "api-key",
+        apiKey,
+        email: email ?? (await getUserEmailFromApiKey(apiKey)),
+      };
+      return new CloudflareApi({
+        baseUrl: options.baseUrl,
+        credentials,
+        accountId: accountId ?? (await getCloudflareAccountId(credentials)),
+      });
+    }
+
+    if (apiToken) {
+      const credentials: Credentials.ApiToken = {
+        type: "api-token",
+        apiToken,
+      };
+      return new CloudflareApi({
+        baseUrl,
+        credentials,
+        accountId: accountId ?? (await getCloudflareAccountId(credentials)),
+      });
+    }
+
+    try {
+      const profile =
+        options.profile ??
+        process.env.CLOUDFLARE_PROFILE ??
+        process.env.ALCHEMY_PROFILE ??
+        "default";
+      const { provider, credentials } =
+        await Provider.getWithCredentials<CloudflareAuth.Metadata>({
+          provider: "cloudflare",
+          profile,
+        });
+      return new CloudflareApi({
+        baseUrl,
+        profile,
+        credentials,
+        accountId: provider.metadata.id,
+      });
+    } catch (error) {
+      throw new Error(
+        [
+          "No credentials found. Please run `alchemy login`, or set either CLOUDFLARE_API_TOKEN or CLOUDFLARE_API_KEY in your environment.",
+          "Learn more: https://alchemy.run/guides/cloudflare/",
+        ].join("\n"),
+        { cause: error },
+      );
+    }
+  },
+  (options = {}) =>
+    [
+      options.baseUrl,
+      options.profile,
+      options.apiKey?.unencrypted,
+      options.apiToken?.unencrypted,
+      options.accountId,
+      options.email,
+    ].join("|"),
+);
 
 /**
  * Cloudflare API client using raw fetch
  */
 export class CloudflareApi {
-  public readonly accountId: string;
   public readonly baseUrl: string;
-  public readonly authOptions: CloudflareAuthOptions;
+  public readonly accountId: string;
+  public readonly credentials: Credentials;
+  public readonly profile: string | undefined;
 
   /**
    * Create a new Cloudflare API client
@@ -103,11 +152,13 @@ export class CloudflareApi {
   constructor(options: {
     baseUrl?: string;
     accountId: string;
-    authOptions: CloudflareAuthOptions;
+    credentials: Credentials;
+    profile?: string;
   }) {
-    this.accountId = options.accountId;
     this.baseUrl = options.baseUrl ?? "https://api.cloudflare.com/client/v4";
-    this.authOptions = options.authOptions;
+    this.accountId = options.accountId;
+    this.credentials = options.credentials;
+    this.profile = options.profile;
   }
 
   /**
@@ -133,7 +184,10 @@ export class CloudflareApi {
       headers = init.headers;
     }
     headers = {
-      ...(await getCloudflareAuthHeaders(this.authOptions)),
+      ...(await CloudflareAuth.formatHeadersWithRefresh({
+        profile: this.profile,
+        credentials: this.credentials,
+      })),
       ...headers,
     };
 
@@ -200,13 +254,11 @@ export class CloudflareApi {
     body: any,
     init: RequestInit = {},
   ): Promise<Response> {
-    const requestBody =
-      body instanceof FormData
-        ? body
-        : typeof body === "string"
-          ? body
-          : JSON.stringify(body);
-    return this.fetch(path, { ...init, method: "POST", body: requestBody });
+    return this.fetch(path, {
+      ...init,
+      method: "POST",
+      body: this.toBody(body),
+    });
   }
 
   /**
@@ -217,8 +269,21 @@ export class CloudflareApi {
     body: any,
     init: RequestInit = {},
   ): Promise<Response> {
-    const requestBody = body instanceof FormData ? body : JSON.stringify(body);
-    return this.fetch(path, { ...init, method: "PUT", body: requestBody });
+    return this.fetch(path, {
+      ...init,
+      method: "PUT",
+      body: this.toBody(body),
+    });
+  }
+
+  toBody(body: BodyInit): BodyInit {
+    return body instanceof FormData
+      ? body
+      : typeof body === "string"
+        ? body
+        : body instanceof ReadableStream
+          ? body
+          : JSON.stringify(body);
   }
 
   /**
@@ -232,7 +297,7 @@ export class CloudflareApi {
     return this.fetch(path, {
       ...init,
       method: "PATCH",
-      body: JSON.stringify(body),
+      body: this.toBody(body),
     });
   }
 

package/src/cloudflare/assets.ts

@@ -1,9 +1,9 @@
-import * as fs from "node:fs/promises";
-import * as path from "pathe";
-import type { Context } from "../context.ts";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "pathe";
 import { Resource } from "../resource.ts";
 import { getContentType } from "../util/content-type.ts";
-import ignore from "../util/ignore-matcher.js";
+import ignore from "../util/ignore-matcher.ts";
 
 /**
  * Properties for creating or updating Assets
@@ -17,54 +17,11 @@ export interface AssetsProps {
 }
 
 /**
- * Output returned after Assets creation/update
+ * Assets binding type
  */
-export interface Assets extends Resource<"cloudflare::Asset">, AssetsProps {
-  /**
-   * The type of binding
-   */
+export type Assets = AssetsProps & {
   type: "assets";
-
-  /**
-   * The ID of the assets bundle
-   */
-  id: string;
-
-  /**
-   * Asset files that were found
-   */
-  files: AssetFile[];
-
-  /**
-   * Time at which the assets were created
-   */
-  createdAt: number;
-
-  /**
-   * Time at which the assets were last updated
-   */
-  updatedAt: number;
-}
-
-/**
- * Represents a single asset file
- */
-export interface AssetFile {
-  /**
-   * Path relative to the assets directory
-   */
-  path: string;
-
-  /**
-   * Full filesystem path to the file
-   */
-  filePath: string;
-
-  /**
-   * Content type of the file
-   */
-  contentType: string;
-}
+};
 
 /**
  * Cloudflare Assets represent a collection of static files that can be uploaded and served
@@ -72,7 +29,7 @@ export interface AssetFile {
  *
  * @example
  * // Create a basic assets bundle from a local directory
- * const staticAssets = await Assets("static", {
+ * const staticAssets = await Assets({
  *   path: "./src/assets"
  * });
  *
@@ -85,100 +42,102 @@ export interface AssetFile {
  *   }
  * });
  */
-export const Assets = Resource(
-  "cloudflare::Asset",
-  {
-    alwaysUpdate: true,
-  },
-  async function (
-    this: Context<Assets>,
-    id: string,
-    props: AssetsProps,
-  ): Promise<Assets> {
-    if (this.phase === "delete") {
-      return this.destroy();
-    }
+export async function Assets(props: AssetsProps): Promise<Assets> {
+  return {
+    type: "assets",
+    ...props,
+  };
+}
+
+export namespace Assets {
+  export interface FileMetadata {
+    path: string;
+    name: string;
+    hash: string;
+    size: number;
+    type: string;
+  }
 
+  /**
+   * Recursively read the metadata for all assets in a directory, skipping files that are ignored by the .assetsignore file
+   *
+   * @param root Path to the directory
+   * @returns Metadata for all assets in the directory
+   */
+  export const read = async (root: string): Promise<FileMetadata[]> => {
+    const matcher = ignore().add(".assetsignore");
+    const ignorePath = path.join(root, ".assetsignore");
     try {
-      // Check if the assets directory exists
-      const stats = await fs.stat(props.path);
-      if (!stats.isDirectory()) {
-        throw new Error(`Assets path ${props.path} is not a directory`);
-      }
-    } catch (_error) {
-      throw new Error(
-        `Assets directory ${props.path} does not exist or is not accessible`,
-      );
+      const content = await fs.readFile(ignorePath, "utf-8");
+      matcher.add(content.split("\n"));
+    } catch {
+      // ignore
     }
 
-    // Recursively get all files in the assets directory
-    const ignoreMatcher = await createIgnoreMatcher(props.path);
-    const filesList = await getFilesRecursively(props.path, ignoreMatcher);
+    const readDirectory = async (
+      directory: string,
+    ): Promise<FileMetadata[]> => {
+      const files = await fs.readdir(directory);
+      const result: FileMetadata[] = [];
+      await Promise.all(
+        files.map(async (file) => {
+          const absolutePath = path.join(directory, file);
+          const relativePath = path.relative(root, absolutePath);
+          if (matcher.ignores(relativePath)) {
+            return;
+          }
+          const stat = await fs.stat(absolutePath);
+          if (stat.isDirectory()) {
+            result.push(...(await readDirectory(absolutePath)));
+          } else {
+            if (stat.size > 26214400) {
+              throw new Error(
+                `File "${absolutePath}" is too large to upload as an asset to Cloudflare (the file is ${(stat.size / 1024 / 1024).toFixed(2)} MB; the maximum size is 25MB).`,
+              );
+            }
+            result.push({
+              path: absolutePath,
+              name: relativePath.startsWith("/")
+                ? relativePath
+                : `/${relativePath}`,
+              hash: await computeHash(absolutePath),
+              size: stat.size,
+              type: getContentType(absolutePath) ?? "application/null",
+            });
+          }
+        }),
+      );
+      return result;
+    };
 
-    // Create asset file objects
-    const files: AssetFile[] = filesList.map((filePath) => {
-      const relativePath = path.relative(props.path, filePath);
+    return await readDirectory(root);
+  };
 
-      return {
-        path: path.normalize(relativePath),
-        filePath: path.normalize(filePath),
-        contentType: getContentType(filePath) ?? "application/null",
-      };
-    });
+  /**
+   * Calculate the SHA-256 hash and size of a file
+   *
+   * @param filePath Path to the file
+   * @returns Hash (first 32 chars of SHA-256) and size of the file
+   */
+  const computeHash = async (filePath: string): Promise<string> => {
+    const contents = await fs.readFile(filePath);
 
-    // Get current timestamp
-    const now = Date.now();
+    const hash = crypto.createHash("sha256");
+    hash.update(contents);
 
-    // Construct the output
-    return this({
-      id,
-      type: "assets",
-      path: props.path,
-      files,
-      createdAt: this.output?.createdAt || now,
-      updatedAt: now,
-    });
-  },
-);
+    const extension = path.extname(filePath).substring(1);
+    hash.update(extension);
 
-async function createIgnoreMatcher(
-  dir: string,
-): Promise<{ ignores: (path: string) => boolean }> {
-  const ignoreMatcher = ignore().add(".assetsignore");
-  const ignorePath = path.join(dir, ".assetsignore");
-  try {
-    const content = await fs.readFile(ignorePath, "utf-8");
-    ignoreMatcher.add(content.split("\n"));
-  } catch {
-    // ignore
-  }
-  return ignoreMatcher;
+    return hash.digest("hex").slice(0, 32);
+  };
 }
 
-// Helper functions for file operations
-async function getFilesRecursively(
-  dir: string,
-  ignoreMatcher: { ignores: (path: string) => boolean },
-): Promise<string[]> {
-  const files = await fs.readdir(dir, { withFileTypes: true });
-  const result: string[] = [];
-
-  await Promise.all(
-    files.map(async (file) => {
-      const filePath = path.join(dir, file.name);
-      if (ignoreMatcher.ignores(file.name)) {
-        return;
-      }
-      if (
-        file.isDirectory() ||
-        (file.isSymbolicLink() && (await fs.stat(filePath)).isDirectory())
-      ) {
-        result.push(...(await getFilesRecursively(filePath, ignoreMatcher)));
-      } else {
-        result.push(filePath);
-      }
-    }),
-  );
+// we are deprecating the Assets resource (it is now just a function)
+// but, a user may still have a resource that depends on it, so we register a no-op dummy resource so that it can be cleanly deleted
+Resource("cloudflare::Asset", async function (this) {
+  if (this.phase === "delete") {
+    return this.destroy();
+  }
 
-  return result;
-}
+  throw new Error("Not implemented");
+});