alchemy 0.13.0 → 0.14.0

package/src/cloudflare/auth.ts

@@ -2,201 +2,86 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import type { Secret } from "../secret.js";
-import type { CloudflareAccountId } from "./account-id.js";
-import { handleApiError } from "./api-error.js";
 /**
  * Authentication options for Cloudflare API
  */
-export interface CloudflareAuthOptions {
+export type CloudflareAuthOptions =
+  | CloudflareApiKeyAuthOptions
+  | CloudflareApiTokenAuthOptions;
+
+export type CloudflareApiKeyAuthOptions = {
   /**
    * API Key to use with API Key
    */
-  apiKey?: Secret;
-
+  apiKey: Secret;
   /**
-   * API Token to use with API Key
+   * Email to use with API Key
+   * If not provided, will attempt to discover from Cloudflare API
    */
-  apiToken?: Secret;
+  email: string;
 
   /**
-   * Email to use with API Key
-   * If not provided, will attempt to discover from Cloudflare API
+   * API Token to use with API Key
    */
-  email?: string;
-}
+  apiToken?: undefined;
+};
 
-export interface CloudflareAccount {
-  name: string;
-  id: CloudflareAccountId;
-  type: "standard" | "zero_rating" | "full_control";
-  settings: {
-    enforce_twofactor: boolean;
-    api_access_enabled: null;
-    access_approval_expiry: null;
-    abuse_contact_email: null;
-  };
-  legacy_flags: {
-    enterprise_zone_quota: {
-      maximum: number;
-      current: number;
-      available: number;
-    };
-  };
+export function isCloudflareApiKeyAuthOptions(
+  options: CloudflareAuthOptions | undefined,
+): options is CloudflareApiKeyAuthOptions {
+  return options !== undefined && options.apiKey !== undefined;
 }
 
-export interface CloudflareUserInfo {
+export type CloudflareApiTokenAuthOptions = {
+  /**
+   * API Token to use with API Key
+   */
   apiToken?: Secret;
-  apiKey?: Secret;
-  email: string;
-  username: string;
-  accounts: CloudflareAccount[];
-  organizations: CloudflareOrganization[];
-  tokenPermissions: string[] | undefined;
-  first_name: string | null;
-  last_name: string | null;
-  telephone: string | null;
-  country: string | null;
-  zipcode: string | null;
-  two_factor_authentication_enabled: boolean;
-  two_factor_authentication_locked: boolean;
-  has_pro_zones: boolean;
-  has_business_zones: boolean;
-  has_enterprise_zones: boolean;
-  suspended: boolean;
-  betas: string[];
-}
 
-export interface CloudflareOrganization {
-  id: string;
-  name: string;
-  status: string;
-  permissions: string[];
-  roles: string[];
-}
+  /**
+   * API Key to use with API Token
+   */
+  apiKey?: undefined;
 
-const userInfoCache: Record<string, CloudflareUserInfo> = {};
+  /**
+   * Email to use with API Token
+   */
+  email?: undefined;
+};
 
-export async function getCloudflareUserInfo(
-  options: CloudflareAuthOptions,
-): Promise<CloudflareUserInfo> {
-  const cacheKey = JSON.stringify({
-    apiKey: options.apiKey?.unencrypted,
-    apiToken: options.apiToken?.unencrypted,
-    email: options.email,
-  });
-  if (userInfoCache[cacheKey]) {
-    return userInfoCache[cacheKey];
-  }
-  const headers = await getCloudflareAuthHeaders(options);
-  const user = await fetch("https://api.cloudflare.com/client/v4/user", {
-    headers,
-  });
-  if (!user.ok) {
-    if (user.status === 403) {
-      throw new Error(
-        "Cloudflare authentication required. Did you forget to login with `wrangler login` or set CLOUDFLARE_API_TOKEN, CLOUDFLARE_API_KEY, or CLOUDFLARE_EMAIL, or CLOUDFLARE_API_KEY?",
-      );
-    }
-    await handleApiError(user, "getting", "user", "user");
-  }
-  const accounts = await fetch(
-    "https://api.cloudflare.com/client/v4/accounts",
-    {
-      headers,
-    },
-  );
-  const userInfo: CloudflareUserInfo = {
-    ...((await user.json()) as any).result,
-    accounts: ((await accounts.json()) as any).result,
-  };
-  userInfoCache[cacheKey] = userInfo;
-  return userInfo;
+export function isCloudflareApiTokenAuthOptions(
+  options: CloudflareAuthOptions | undefined,
+): options is CloudflareApiTokenAuthOptions {
+  return options !== undefined && options.apiToken !== undefined;
 }
 
 export async function getCloudflareAuthHeaders(
-  options: CloudflareAuthOptions = {},
+  options: CloudflareAuthOptions | undefined,
 ): Promise<Record<string, string>> {
-  // Check for API Token (preferred method)
-  const apiToken =
-    options.apiToken?.unencrypted ?? process.env.CLOUDFLARE_API_TOKEN;
-  if (apiToken) {
+  if (isCloudflareApiKeyAuthOptions(options)) {
+    // Global API Key
     return {
-      Authorization: `Bearer ${apiToken}`,
+      "X-Auth-Key": options.apiKey.unencrypted,
+      "X-Auth-Email": options.email,
     };
-  }
-
-  // Check for API Key
-  const apiKey = options.apiKey?.unencrypted ?? process.env.CLOUDFLARE_API_KEY;
-  if (apiKey) {
+  } else if (isCloudflareApiTokenAuthOptions(options)) {
+    // API Token
     return {
-      "X-Auth-Key": apiKey,
-      "X-Auth-Email":
-        options.email ??
-        process.env.CLOUDFLARE_EMAIL ??
-        (await getUserEmailFromApiKey(apiKey)),
+      Authorization: `Bearer ${options.apiToken?.unencrypted}`,
     };
   }
-
+  // Wrangler OAuth Token
   const authConfig = await getRefreshedAuthConfig();
   if (authConfig.oauth_token) {
     return {
       Authorization: `Bearer ${authConfig.oauth_token}`,
     };
   }
-
   throw new Error(
-    "Cloudflare authentication required. Did you forget to login with `wrangler login` or set CLOUDFLARE_API_TOKEN, CLOUDFLARE_API_KEY, or CLOUDFLARE_EMAIL, or CLOUDFLARE_API_KEY?",
+    "Cloudflare authentication required. Did you forget to login with `wrangler login` or set CLOUDFLARE_API_TOKEN, CLOUDFLARE_API_KEY?",
   );
 }
 
-const emailCache: Record<string, string> = {};
-
-async function getUserEmailFromApiKey(apiKey: string): Promise<string> {
-  if (emailCache[apiKey]) {
-    return emailCache[apiKey];
-  }
-
-  try {
-    const baseUrl = "https://api.cloudflare.com/client/v4";
-
-    // Call the /user endpoint to get user information
-    const response = await fetch(`${baseUrl}/user`, {
-      headers: {
-        "Content-Type": "application/json",
-        "X-Auth-Key": apiKey,
-      },
-    });
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to get user information: ${response.status} ${response.statusText}`,
-      );
-    }
-
-    const data = (await response.json()) as {
-      success: boolean;
-      result: {
-        id: string;
-        email: string;
-        name: string;
-        [key: string]: any;
-      };
-    };
-
-    if (!data.success || !data.result || !data.result.email) {
-      throw new Error("Cloudflare API did not return valid user information");
-    }
-
-    emailCache[apiKey] = data.result.email;
-    return data.result.email;
-  } catch (error) {
-    console.error("Error retrieving email from Cloudflare API:", error);
-    throw new Error(
-      "Failed to automatically discover email for API Key authentication",
-    );
-  }
-}
-
 async function refreshAuthToken(
   options: WranglerConfig,
 ): Promise<WranglerConfig> {

package/src/cloudflare/bundle/alias-plugin.ts

@@ -0,0 +1,48 @@
+import type { Plugin } from "esbuild";
+
+export const createAliasPlugin = ({
+  alias,
+  projectRoot,
+}: {
+  alias: Record<string, string>;
+  projectRoot: string;
+}): Plugin => ({
+  name: "alias",
+  setup(build) {
+    if (!alias) {
+      return;
+    }
+
+    // filter the hook calls to only those that match the alias keys
+    // this should avoid slowing down builds which don't use aliasing
+    const filter = new RegExp(
+      Object.keys(alias)
+        .map((key) => escapeRegex(key))
+        .join("|"),
+    );
+
+    // reimplement module aliasing as an esbuild plugin onResolve hook
+    build.onResolve({ filter }, (args) => {
+      const aliasPath = alias[args.path];
+      if (aliasPath) {
+        return {
+          // resolve with node resolution
+          path: require.resolve(aliasPath, {
+            // From the esbuild alias docs: "Note that when an import path is substituted using an alias, the resulting import path is resolved in the working directory instead of in the directory containing the source file with the import path."
+            // https://esbuild.github.io/api/#alias:~:text=Note%20that%20when%20an%20import%20path%20is%20substituted%20using%20an%20alias%2C%20the%20resulting%20import%20path%20is%20resolved%20in%20the%20working%20directory%20instead%20of%20in%20the%20directory%20containing%20the%20source%20file%20with%20the%20import%20path.
+            paths: [projectRoot],
+          }),
+        };
+      }
+    });
+  },
+});
+
+// Taken from https://stackoverflow.com/a/3561711
+// which is everything from the tc39 proposal, plus the following two characters: ^/
+// It's also everything included in the URLPattern escape (https://wicg.github.io/urlpattern/#escape-a-regexp-string), plus the following: -
+// As the answer says, there's no downside to escaping these extra characters, so better safe than sorry
+const ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+const escapeRegex = (str: string) => {
+  return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+};

package/src/cloudflare/bundle/build-failures.ts

@@ -0,0 +1,55 @@
+import type * as esbuild from "esbuild";
+import type { NodeJSCompatMode } from "miniflare";
+import { builtinModules } from "node:module";
+
+/**
+ * RegExp matching against esbuild's error text when it is unable to resolve
+ * a Node built-in module. If we detect this when node_compat is disabled,
+ * we'll rewrite the error to suggest enabling it.
+ */
+const nodeBuiltinResolveErrorText = new RegExp(
+  '^Could not resolve "(' +
+    builtinModules.join("|") +
+    "|" +
+    builtinModules.map((module) => `node:${module}`).join("|") +
+    ')"$',
+);
+/**
+ * Rewrites esbuild BuildFailures for failing to resolve Node built-in modules
+ * to suggest enabling Node compat as opposed to `platform: "node"`.
+ */
+export function rewriteNodeCompatBuildFailure(
+  errors: esbuild.Message[],
+  compatMode: NodeJSCompatMode = null,
+) {
+  for (const error of errors) {
+    const match = nodeBuiltinResolveErrorText.exec(error.text);
+    if (match !== null) {
+      let text = `The package "${match[1]}" wasn't found on the file system but is built into node.\n`;
+
+      if (compatMode === null || compatMode === "als") {
+        text += `- Add the "nodejs_compat" compatibility flag to your project.\n`;
+      } else if (compatMode === "v1" && !match[1].startsWith("node:")) {
+        text += `- Make sure to prefix the module name with "node:" or update your compatibility_date to 2024-09-23 or later.\n`;
+      }
+
+      error.notes = [
+        {
+          location: null,
+          text,
+        },
+      ];
+    }
+  }
+}
+/**
+ * Returns true if the passed value looks like an esbuild BuildFailure object
+ */
+export function isBuildFailure(err: unknown): err is esbuild.BuildFailure {
+  return (
+    typeof err === "object" &&
+    err !== null &&
+    "errors" in err &&
+    "warnings" in err
+  );
+}

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

@@ -0,0 +1,89 @@
+import fs from "node:fs/promises";
+import { Bundle } from "../../esbuild/bundle.js";
+import type { Bindings } from "../bindings.js";
+import type { WorkerProps } from "../worker.js";
+import { createAliasPlugin } from "./alias-plugin.js";
+import {
+  isBuildFailure,
+  rewriteNodeCompatBuildFailure,
+} from "./build-failures.js";
+import { external, external_als } from "./external.js";
+import { getNodeJSCompatMode } from "./nodejs-compat-mode.js";
+import { nodeJsCompatPlugin } from "./nodejs-compat.js";
+
+export async function bundleWorkerScript<B extends Bindings>(
+  props: WorkerProps<B> & {
+    compatibilityDate: string;
+    compatibilityFlags: string[];
+  },
+) {
+  const projectRoot = props.projectRoot ?? process.cwd();
+
+  const nodeJsCompatMode = getNodeJSCompatMode(
+    props.compatibilityDate,
+    props.compatibilityFlags,
+  );
+
+  if (nodeJsCompatMode === "v1") {
+    throw new Error(
+      "You must set your compatibilty date >= 2024-09-23 when using 'nodejs_compat' compatibility flag",
+    );
+  }
+
+  try {
+    const bundle = await Bundle("bundle", {
+      entryPoint: props.entrypoint!,
+      format: props.format === "cjs" ? "cjs" : "esm", // Use the specified format or default to ESM
+      target: "esnext",
+      platform: "node",
+      minify: false,
+      ...(props.bundle || {}),
+      conditions: ["workerd", "worker", "browser"],
+      options: {
+        absWorkingDir: projectRoot,
+        ...(props.bundle?.options || {}),
+        keepNames: true, // Important for Durable Object classes
+        loader: {
+          ".sql": "text",
+          ".json": "json",
+        },
+        plugins: [
+          ...(nodeJsCompatMode === "v2" ? [await nodeJsCompatPlugin()] : []),
+          ...(props.bundle?.alias
+            ? [
+                createAliasPlugin({
+                  alias: props.bundle?.alias,
+                  projectRoot,
+                }),
+              ]
+            : []),
+        ],
+      },
+      external: [
+        ...(nodeJsCompatMode === "als" ? external_als : external),
+        ...(props.bundle?.external ?? []),
+        ...(props.bundle?.options?.external ?? []),
+      ],
+    });
+    if (bundle.content) {
+      return bundle.content;
+    }
+    if (bundle.path) {
+      return await fs.readFile(bundle.path, "utf-8");
+    }
+    throw new Error("Failed to create bundle");
+  } catch (e: any) {
+    if (e.message?.includes("No such module 'node:")) {
+      throw new Error(
+        `${e.message}.\nMake sure to set 'nodejs_compat' compatibility flag and compatibilityDate > 2024-09-23`,
+        { cause: e },
+      );
+    }
+    if (isBuildFailure(e)) {
+      rewriteNodeCompatBuildFailure(e.errors, nodeJsCompatMode);
+      throw e;
+    }
+    console.error("Error reading bundle:", e);
+    throw new Error("Error reading bundle");
+  }
+}

package/src/cloudflare/bundle/external.ts

@@ -5,13 +5,14 @@ const nodejs_compat = [
   "node:buffer",
   "node:console",
   "node:crypto",
+  "node:debug",
   "node:diagnostics_channel",
   "node:dns",
   "node:events",
   "node:inspector",
   "node:net",
   "node:path",
-  "node:perf_hooks",
+  "node:perf_hooks", // partially supported
   "node:process",
   "node:querystring",
   "node:stream",
@@ -30,3 +31,10 @@ export const external = [
   "cloudflare:workers",
   // "cloudflare:*",
 ];
+
+export const external_als = [
+  //
+  "node:async_hooks",
+  "async_hooks",
+  "cloudflare:*",
+];

package/src/cloudflare/bundle/local-dev-cloudflare-shim.ts

@@ -1,3 +1,5 @@
+import { dedent } from "../../util/dedent.js";
+
 /**
  * TanStackStart server functions and middleware run in Node.js intead of Miniflare when using `vite dev`.
  *
@@ -13,12 +15,11 @@ export function cloudflareWorkersDevEnvironmentShim() {
     },
     load(id: string) {
       if (id === "cloudflare:workers")
-        return `
-import { getPlatformProxy } from "wrangler";
-// TODO: should we export default cloudflare; ??
-const cloudflare = await getPlatformProxy();
-export const env = cloudflare.env;
-`;
+        return dedent`
+          import { getPlatformProxy } from "wrangler";
+          // TODO: should we export default cloudflare; ??
+          const cloudflare = await getPlatformProxy();
+          export const env = cloudflare.env;`;
     },
   } as const;
 }

package/src/cloudflare/bundle/nodejs-compat-mode.ts

@@ -0,0 +1,49 @@
+import type { NodeJSCompatMode } from "miniflare";
+import { getNodeCompat } from "miniflare";
+
+/**
+ * Computes and validates the Node.js compatibility mode we are running.
+ *
+ * NOTES:
+ * - The v2 mode is configured via `nodejs_compat_v2` compat flag or via `nodejs_compat` plus a compatibility date of Sept 23rd. 2024 or later.
+ * - See `EnvironmentInheritable` for `noBundle`.
+ *
+ * @param compatibilityDateStr The compatibility date
+ * @param compatibilityFlags The compatibility flags
+ * @param noBundle Whether to skip internal build steps and directly deploy script
+ *
+ */
+export function getNodeJSCompatMode(
+  compatibilityDateStr: string,
+  compatibilityFlags: string[],
+  props?: {
+    noBundle?: boolean;
+  },
+): NodeJSCompatMode {
+  const {
+    mode,
+    hasNodejsCompatFlag,
+    hasNodejsCompatV2Flag,
+    hasExperimentalNodejsCompatV2Flag,
+  } = getNodeCompat(compatibilityDateStr, compatibilityFlags);
+
+  if (hasExperimentalNodejsCompatV2Flag) {
+    throw new Error(
+      "The `experimental:` prefix on `nodejs_compat_v2` is no longer valid. Please remove it and try again.",
+    );
+  }
+
+  if (hasNodejsCompatFlag && hasNodejsCompatV2Flag) {
+    throw new Error(
+      "The `nodejs_compat` and `nodejs_compat_v2` compatibility flags cannot be used in together. Please select just one.",
+    );
+  }
+
+  if (props?.noBundle && hasNodejsCompatV2Flag) {
+    console.warn(
+      "`nodejs_compat_v2` compatibility flag and `--no-bundle` can't be used together. If you want to polyfill Node.js built-ins and disable Wrangler's bundling, please polyfill as part of your own bundling process.",
+    );
+  }
+
+  return mode;
+}

package/src/cloudflare/bundle/{hybrid-nodejs-compat.ts → nodejs-compat.ts}

@@ -1,13 +1,13 @@
+/**
+ * Copied from https://github.com/cloudflare/workers-sdk/blob/main/packages/wrangler/src/deployment-bundle/esbuild-plugins/hybrid-nodejs-compat.ts#L17
+ */
+
 import type { Plugin, PluginBuild } from "esbuild";
 import assert from "node:assert";
 import { builtinModules } from "node:module";
 import nodePath from "node:path";
 import { dedent } from "../../util/dedent.js";
 
-/**
- * Copied from https://github.com/cloudflare/workers-sdk/blob/main/packages/wrangler/src/deployment-bundle/esbuild-plugins/hybrid-nodejs-compat.ts#L17
- */
-
 const REQUIRED_NODE_BUILT_IN_NAMESPACE = "node-built-in-modules";
 const REQUIRED_UNENV_ALIAS_NAMESPACE = "required-unenv-alias";
 
@@ -16,7 +16,7 @@ const REQUIRED_UNENV_ALIAS_NAMESPACE = "required-unenv-alias";
  *
  * @returns ESBuild plugin
  */
-export async function nodejsHybridPlugin(): Promise<Plugin> {
+export async function nodeJsCompatPlugin(): Promise<Plugin> {
   // `unenv` and `@cloudflare/unenv-preset` only publish esm
   const { defineEnv } = await import("unenv");
   const { cloudflare } = await import("@cloudflare/unenv-preset");
@@ -212,6 +212,7 @@ function handleNodeJSGlobals(
         module,
       );
     }
+    // eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
     injectsByModule.get(module)!.push({ injectedName, exportName, importName });
   }
 

package/src/cloudflare/queue-consumer.ts

@@ -2,8 +2,8 @@ import type { Context } from "../context.js";
 import { Resource } from "../resource.js";
 import { CloudflareApiError, handleApiError } from "./api-error.js";
 import {
-  type CloudflareApi,
   createCloudflareApi,
+  type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.js";
 import type { Queue } from "./queue.js";
@@ -163,10 +163,8 @@ export const QueueConsumer = Resource(
     let consumerData: CloudflareQueueConsumerResponse;
 
     if (this.phase === "create") {
-      console.log(`Creating Queue Consumer for queue ${queueId}`);
       consumerData = await createQueueConsumer(api, queueId, props);
     } else if (this.output?.id) {
-      console.log(`Updating Queue Consumer ${this.output.id}`);
       consumerData = await updateQueueConsumer(
         api,
         queueId,
@@ -174,10 +172,6 @@ export const QueueConsumer = Resource(
         props,
       );
     } else {
-      // If no ID exists, fall back to creating a new consumer
-      console.log(
-        `No existing Consumer ID found, creating new Queue Consumer for queue ${queueId}`,
-      );
       consumerData = await createQueueConsumer(api, queueId, props);
     }