alchemy 0.45.6 → 0.46.1

package/src/cloudflare/auth.ts

@@ -1,233 +1,101 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+import { alchemy } from "../alchemy.ts";
 import type { Secret } from "../secret.ts";
-import { createXdgAppPaths } from "../util/xdg-paths.ts";
-/**
- * Authentication options for Cloudflare API
- */
-export type CloudflareAuthOptions =
-  | CloudflareApiKeyAuthOptions
-  | CloudflareApiTokenAuthOptions;
-
-export type CloudflareApiKeyAuthOptions = {
-  /**
-   * API Key to use with API Key
-   */
-  apiKey: Secret;
-  /**
-   * Email to use with API Key
-   * If not provided, will attempt to discover from Cloudflare API
-   */
-  email: string;
+import type { CloudflareApiOptions } from "./api.ts";
+import { getRefreshedWranglerConfig } from "./oauth.ts";
+import { getUserEmailFromApiKey } from "./user.ts";
 
-  /**
-   * API Token to use with API Key
-   */
-  apiToken?: undefined;
-};
-
-export function isCloudflareApiKeyAuthOptions(
-  options: CloudflareAuthOptions | undefined,
-): options is CloudflareApiKeyAuthOptions {
-  return options !== undefined && options.apiKey !== undefined;
+export interface CloudflareApiTokenAuthOptions {
+  type: "api-token";
+  apiToken: Secret<string>;
 }
 
-export type CloudflareApiTokenAuthOptions = {
-  /**
-   * API Token to use with API Key
-   */
-  apiToken?: Secret;
+export interface CloudflareApiKeyAuthOptions {
+  type: "api-key";
+  apiKey: Secret;
+  apiEmail: string;
+}
 
-  /**
-   * API Key to use with API Token
-   */
-  apiKey?: undefined;
+export interface CloudflareWranglerAuthOptions {
+  type: "wrangler";
+}
 
-  /**
-   * Email to use with API Token
-   */
-  email?: undefined;
+export type CloudflareAuthOptions =
+  | CloudflareApiTokenAuthOptions
+  | CloudflareApiKeyAuthOptions
+  | CloudflareWranglerAuthOptions;
+
+export const isCloudflareAuthOptions = (
+  input?: CloudflareApiOptions | CloudflareAuthOptions,
+): input is CloudflareAuthOptions => {
+  return (
+    input !== undefined &&
+    "type" in input &&
+    (input.type === "api-token" ||
+      input.type === "api-key" ||
+      input.type === "wrangler")
+  );
 };
 
-export function isCloudflareApiTokenAuthOptions(
-  options: CloudflareAuthOptions | undefined,
-): options is CloudflareApiTokenAuthOptions {
-  return options !== undefined && options.apiToken !== undefined;
-}
-
-export async function getCloudflareAuthHeaders(
-  options: CloudflareAuthOptions | undefined,
-): Promise<Record<string, string>> {
-  if (isCloudflareApiKeyAuthOptions(options)) {
-    // Global API Key
-    return {
-      "X-Auth-Key": options.apiKey.unencrypted,
-      "X-Auth-Email": options.email,
-    };
-  } else if (isCloudflareApiTokenAuthOptions(options)) {
-    // API Token
-    return {
-      Authorization: `Bearer ${options.apiToken?.unencrypted}`,
-    };
+export async function normalizeAuthOptions(
+  input?: CloudflareApiOptions | CloudflareAuthOptions,
+): Promise<CloudflareAuthOptions> {
+  if (isCloudflareAuthOptions(input)) {
+    return input;
   }
-  // Wrangler OAuth Token
-  const authConfig = await getRefreshedAuthConfig();
-  if (authConfig.oauth_token) {
+
+  const email = async (apiKey: Secret<string>) =>
+    input?.email ??
+    process.env.CLOUDFLARE_EMAIL ??
+    (await getUserEmailFromApiKey(apiKey.unencrypted));
+
+  if (input?.apiKey) {
     return {
-      Authorization: `Bearer ${authConfig.oauth_token}`,
+      type: "api-key",
+      apiKey: input.apiKey,
+      apiEmail: await email(input.apiKey),
     };
   }
-  throw new Error(
-    "Cloudflare authentication required. Did you forget to login with `wrangler login` or set CLOUDFLARE_API_TOKEN, CLOUDFLARE_API_KEY?",
-  );
-}
-
-async function refreshAuthToken(
-  options: WranglerConfig,
-): Promise<WranglerConfig> {
-  const response = await fetch("https://dash.cloudflare.com/oauth2/token", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-    },
-    body: new URLSearchParams({
-      grant_type: "refresh_token",
-      refresh_token: options.refresh_token!,
-      client_id: "54d11594-84e4-41aa-b438-e81b8fa78ee7",
-    }).toString(),
-  });
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to refresh auth token: ${response.status} ${response.statusText} ${await response.text()}`,
-    );
+  if (input?.apiToken) {
+    return { type: "api-token", apiToken: input.apiToken };
   }
-
-  const data: any = await response.json();
-  if (!data.access_token) {
-    throw new Error("Failed to refresh auth token - no access token returned");
+  if (process.env.CLOUDFLARE_API_KEY) {
+    const key = alchemy.secret(process.env.CLOUDFLARE_API_KEY);
+    return { type: "api-key", apiKey: key, apiEmail: await email(key) };
   }
-
-  options.oauth_token = data.access_token;
-  options.refresh_token = data.refresh_token;
-  options.expiration_time = new Date(
-    Date.now() + data.expires_in * 1000,
-  ).toISOString();
-  options.scopes = data.scope?.split(" ") || [];
-
-  return options;
-}
-
-interface WranglerConfig {
-  path: string;
-  oauth_token?: string;
-  refresh_token?: string;
-  expiration_time?: string;
-  scopes?: string[];
-  /** exists is `false` if the config file doesn't exist, like in CI */
-  exists?: boolean;
-  /** @deprecated - this field was only provided by the deprecated v1 `wrangler config` command. */
-  api_token?: string;
-}
-
-async function getRefreshedAuthConfig(): Promise<WranglerConfig> {
-  let authConfig = await readWranglerConfig();
-  if (authConfig.expiration_time) {
-    const expiry = new Date(authConfig.expiration_time);
-    // if expiring in 10s
-    if (expiry.getTime() < Date.now() + 10 * 1000) {
-      authConfig = await refreshAuthToken(authConfig);
-      authConfigCache[authConfig.path] = authConfig;
-      await writeWranglerConfig(authConfig);
-    }
+  if (process.env.CLOUDFLARE_API_TOKEN) {
+    return {
+      type: "api-token",
+      apiToken: alchemy.secret(process.env.CLOUDFLARE_API_TOKEN),
+    };
   }
-  return authConfig;
-}
-
-async function writeWranglerConfig(config: WranglerConfig) {
-  if (config.exists === false) return;
-
-  const TOML = await import("@iarna/toml");
-  const configPath = await findWranglerConfig();
-  config = {
-    ...config,
-  };
-  // @ts-ignore - i put this here
-  delete config.path;
-  const toml = TOML.stringify(config as any);
-  await fs.writeFile(configPath, toml);
+  return { type: "wrangler" };
 }
 
-// cache the file once per process
-const authConfigCache: Record<string, WranglerConfig> = {};
-
-async function readWranglerConfig(): Promise<WranglerConfig> {
-  const configPath = await findWranglerConfig();
-  try {
-    const config = (authConfigCache[configPath] ??= await parseTOML(
-      await fs.readFile(configPath, "utf-8"),
-    ));
-    config.path = configPath;
-
-    return config;
-  } catch (e: any) {
-    if (e.code === "ENOENT") {
-      // The config doesn't exist
+export async function getCloudflareAuthHeaders(
+  authOptions: CloudflareAuthOptions,
+): Promise<Record<string, string>> {
+  switch (authOptions.type) {
+    case "api-token":
+      return { Authorization: `Bearer ${authOptions.apiToken.unencrypted}` };
+    case "api-key":
       return {
-        path: configPath,
-        exists: false,
+        "X-Auth-Key": authOptions.apiKey.unencrypted,
+        "X-Auth-Email": authOptions.apiEmail,
+      };
+    case "wrangler": {
+      const wranglerConfig = await getRefreshedWranglerConfig();
+      if (wranglerConfig.isErr()) {
+        throw new Error(
+          [
+            wranglerConfig.error.message,
+            "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"),
+        );
+      }
+      return {
+        Authorization: `Bearer ${wranglerConfig.value.oauth_token}`,
       };
     }
-
-    throw e;
-  }
-}
-
-let wranglerConfigPath: string | undefined;
-
-async function findWranglerConfig(): Promise<string> {
-  if (wranglerConfigPath) {
-    return wranglerConfigPath;
-  }
-  const environment = process.env.WRANGLER_API_ENVIRONMENT ?? "production";
-  const filePath = path.join(
-    "config",
-    `${environment === "production" ? "default.toml" : `${environment}.toml`}`,
-  );
-
-  const xdgAppPaths = createXdgAppPaths(".wrangler");
-  //TODO: We should implement a custom path --global-config and/or the WRANGLER_HOME type environment variable
-  const configDir = xdgAppPaths.config(); // New XDG compliant config path
-  const legacyConfigDir = path.join(os.homedir(), ".wrangler"); // Legacy config in user's home directory
-
-  // Check for the .wrangler directory in root if it is not there then use the XDG compliant path.
-  wranglerConfigPath = path.join(
-    (await isDirectory(legacyConfigDir)) ? legacyConfigDir : configDir,
-    filePath,
-  );
-  return wranglerConfigPath;
-}
-
-async function parseTOML(input: string): Promise<any> {
-  const TOML = await import("@iarna/toml");
-  try {
-    // Normalize CRLF to LF to avoid hitting https://github.com/iarna/iarna-toml/issues/33.
-    const normalizedInput = input.replace(/\r\n/g, "\n");
-    return TOML.parse(normalizedInput);
-  } catch (err: any) {
-    const { name } = err;
-    if (name !== "TomlError") {
-      throw err;
-    }
-    throw new Error("TOML parse error");
-  }
-}
-
-async function isDirectory(dir: string) {
-  try {
-    return (await fs.stat(dir)).isDirectory();
-  } catch (_err) {
-    return false;
   }
 }

package/src/cloudflare/browser-rendering.ts

@@ -1,3 +1,17 @@
-export class BrowserRendering {
-  public readonly type = "browser";
+export type BrowserRendering = {
+  type: "browser";
+};
+
+/**
+ * Creates a browser rendering binding for running browser tasks in Workers.
+ *
+ * @example
+ * ```ts
+ * const browser = BrowserRendering();
+ * ```
+ */
+export function BrowserRendering(): BrowserRendering {
+  return {
+    type: "browser",
+  };
 }

package/src/cloudflare/bundle/fs.ts

@@ -45,6 +45,11 @@ export class FSBundleProvider implements WorkerBundleProvider {
         }
       }),
     );
+    if (fileNames.size === 0) {
+      throw new Error(
+        `No files found matching ${this.globs.join(", ")} in ${this.root}`,
+      );
+    }
     const { files, hash } = await parseFiles(
       this.root,
       Array.from(fileNames),

package/src/cloudflare/bundle/internal-worker-bundle.ts

@@ -0,0 +1,21 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { memoize } from "../../util/memoize.ts";
+
+export type InternalWorker =
+  | "cloudflare-state-store"
+  | "dofs-state-store"
+  | "remote-binding-proxy";
+
+export const getInternalWorkerBundle = memoize(async (name: InternalWorker) => {
+  const content = await fs.readFile(
+    path.join(import.meta.dirname, "..", "..", "..", "workers", `${name}.js`),
+  );
+  return {
+    file: new File([content], `${name}.js`, {
+      type: "application/javascript+module",
+    }),
+    tag: `${name}:${crypto.createHash("sha256").update(content).digest("hex")}`,
+  };
+});

package/src/cloudflare/compatibility-presets.ts

@@ -0,0 +1,34 @@
+/**
+ * Compatibility presets for Cloudflare Workers
+ *
+ * These presets provide common sets of compatibility flags to avoid
+ * users having to remember which flags they need for common use cases.
+ */
+
+/**
+ * Mapping of compatibility presets to their respective compatibility flags
+ */
+export const COMPATIBILITY_PRESETS = {
+  /**
+   * Node.js compatibility preset
+   * Enables Node.js APIs and runtime compatibility
+   */
+  node: ["nodejs_compat"],
+} as const;
+
+export type CompatibilityPreset = keyof typeof COMPATIBILITY_PRESETS;
+
+/**
+ * Union preset compatibility flags with user-provided flags
+ */
+export function unionCompatibilityFlags(
+  preset: CompatibilityPreset | undefined,
+  userFlags: string[] = [],
+): string[] {
+  if (!preset) {
+    return userFlags;
+  }
+
+  const presetFlags = COMPATIBILITY_PRESETS[preset];
+  return Array.from(new Set([...presetFlags, ...userFlags]));
+}

package/src/cloudflare/container.ts

@@ -545,7 +545,7 @@ export const ContainerApplication = Resource(
       let application: ContainerApplicationData;
 
       try {
-        application = await createContainerApplication(api, {
+        application = await createContainerApplication(api, props.adopt, {
           name: props.name,
           scheduling_policy: props.schedulingPolicy ?? "default",
           instances: props.instances ?? 1,
@@ -734,6 +734,23 @@ export interface ContainerApplicationData {
   [key: string]: any;
 }
 
+export async function getContainerApplication(
+  api: CloudflareApi,
+  applicationId: string,
+) {
+  const response = await api.get(
+    `/accounts/${api.accountId}/containers/applications/${applicationId}`,
+  );
+
+  const result = (await response.json()) as {
+    result: ContainerApplicationData;
+    errors: { message: string }[];
+  };
+  if (response.ok) {
+    return result.result;
+  }
+}
+
 export async function listContainerApplications(
   api: CloudflareApi,
 ): Promise<ContainerApplicationData[]> {
@@ -770,11 +787,15 @@ export interface CreateContainerApplicationBody {
   instances?: number;
   scheduling_policy?: string;
   constraints?: { tier: number };
+  affinities?: {
+    colocation?: "datacenter";
+  };
   [key: string]: any;
 }
 
 export async function createContainerApplication(
   api: CloudflareApi,
+  adopt: boolean | undefined,
   body: CreateContainerApplicationBody,
 ) {
   const response = await api.post(
@@ -783,17 +804,63 @@ export async function createContainerApplication(
   );
   const result = (await response.json()) as {
     result: ContainerApplicationData;
-    errors: { message: string }[];
+    errors: { message: string; code: number }[];
   };
   if (response.ok) {
     return result.result;
   }
 
+  const error = result.errors.find((e) => e.code === 1000);
+  if (error) {
+    // WEIRD: json-encoded error message - might change when they release an official API
+    const errorMessage = JSON.parse(error.message) as {
+      error: "DURABLE_OBJECT_ALREADY_HAS_APPLICATION" | (string & {});
+      details: {
+        name: string;
+        id: string;
+      };
+    };
+
+    if (errorMessage.error === "DURABLE_OBJECT_ALREADY_HAS_APPLICATION") {
+      if (!adopt) {
+        throw new Error(
+          `Durable Object namespace ${body.durable_objects?.namespace_id} already has an application with id ${errorMessage.details.id}. Use adopt: true to adopt it.`,
+        );
+      }
+      const application = await getContainerApplication(
+        api,
+        errorMessage.details.id,
+      );
+      if (application) {
+        const currentId = application.durable_objects.namespace_id;
+        const desiredId = body.durable_objects?.namespace_id;
+        if (currentId === desiredId) {
+          await updateContainerApplication(api, application.id, {
+            configuration: body.configuration,
+            instances: body.instances,
+            constraints: body.constraints,
+            scheduling_policy: body.scheduling_policy,
+            max_instances: body.max_instances,
+            affinities: body.affinities,
+            // TODO(sam): API does not accepet this as input, we may need to repace
+            // durable_objects: body.durable_objects,
+          });
+          // it's the same application, so we can just adpt it
+          return application;
+        } else {
+          // TODO(sam): not sure what to do in this case
+          throw new Error(
+            "Cannot adopt an existing Container Application that is bound to a different Durable Object",
+          );
+        }
+      }
+    }
+  }
+
   throw Error(
     `Failed to create container application: ${result.errors?.map((e: { message: string }) => e.message).join(", ") ?? "Unknown error"}`,
   );
 }
-
 type Region =
   | "AFR"
   | "APAC"

package/src/cloudflare/dispatch-namespace.ts

@@ -279,3 +279,31 @@ export async function deleteDispatchNamespace(
     );
   }
 }
+
+export async function listWorkersInNamespace(
+  api: CloudflareApi,
+  namespace: string,
+): Promise<Array<{ id: string; created_on: string; modified_on: string }>> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/workers/dispatch/namespaces/${namespace}/scripts`,
+  );
+
+  if (!response.ok) {
+    await handleApiError(
+      response,
+      "list workers in",
+      "dispatch_namespace",
+      namespace,
+    );
+  }
+
+  const data = (await response.json()) as {
+    result: Array<{
+      id: string;
+      created_on: string;
+      modified_on: string;
+    }>;
+  };
+
+  return data.result || [];
+}

package/src/cloudflare/durable-object-namespace.ts

@@ -3,7 +3,7 @@ import type { Binding } from "./bindings.ts";
 /**
  * Properties for creating a Durable Object Namespace
  */
-export interface DurableObjectNamespaceInput {
+export interface DurableObjectNamespaceProps {
   className: string;
   scriptName?: string | undefined;
   environment?: string | undefined;
@@ -11,6 +11,18 @@ export interface DurableObjectNamespaceInput {
   namespaceId?: string | undefined;
 }
 
+export type DurableObjectNamespace<T = any> = {
+  type: "durable_object_namespace";
+  id: string;
+  className: string;
+  scriptName?: string;
+  environment?: string;
+  sqlite?: boolean;
+  namespaceId?: string;
+  // @ts-ignore - phantom type
+  __service__: T;
+};
+
 export function isDurableObjectNamespace(
   binding: Binding,
 ): binding is DurableObjectNamespace {
@@ -20,48 +32,47 @@ export function isDurableObjectNamespace(
 }
 
 /**
+ * Creates a Durable Object namespace binding.
+ *
  * @example
+ * ```ts
  * // Create a basic Durable Object namespace for stateful chat rooms
- * const rooms = new DurableObjectNamespace("chat-rooms", {
+ * const rooms = DurableObjectNamespace("chat-rooms", {
  *   className: "ChatRoom"
  * });
+ * ```
  *
  * @example
+ * ```ts
  * // Create a Durable Object with SQLite storage for user data
- * const users = new DurableObjectNamespace("user-store", {
+ * const users = DurableObjectNamespace("user-store", {
  *   className: "User",
  *   sqlite: true
  * });
+ * ```
  *
  * @example
+ * ```ts
  * // Create a Durable Object in production for game state management
- * const game = new DurableObjectNamespace("game-state", {
+ * const game = DurableObjectNamespace("game-state", {
  *   className: "GameState",
  *   scriptName: "game-worker",
  *   environment: "production"
  * });
+ * ```
  */
-export class DurableObjectNamespace<T = any>
-  implements DurableObjectNamespaceInput
-{
-  public readonly type = "durable_object_namespace" as const;
-  // alias for bindingName to be consistent with other bindings
-  public readonly className: string;
-  public readonly scriptName?: string | undefined;
-  public readonly environment?: string | undefined;
-  public readonly sqlite?: boolean | undefined;
-  public readonly namespaceId?: string | undefined;
-
-  // @ts-ignore - phantom type
-  protected readonly __service__: T;
-
-  constructor(
-    public readonly id: string,
-    input: DurableObjectNamespaceInput,
-  ) {
-    this.className = input.className;
-    this.scriptName = input.scriptName;
-    this.environment = input.environment;
-    this.sqlite = input.sqlite;
-  }
+export function DurableObjectNamespace<T = any>(
+  id: string,
+  props: DurableObjectNamespaceProps,
+): DurableObjectNamespace<T> {
+  return {
+    type: "durable_object_namespace",
+    id,
+    className: props.className,
+    scriptName: props.scriptName,
+    environment: props.environment,
+    sqlite: props.sqlite,
+    namespaceId: props.namespaceId,
+    __service__: undefined!,
+  };
 }