alchemy 0.59.1 → 0.60.0

package/src/cloudflare/ruleset.ts

@@ -0,0 +1,257 @@
+import type { Context } from "../context.ts";
+import { Resource } from "../resource.ts";
+import { handleApiError } from "./api-error.ts";
+import {
+  createCloudflareApi,
+  type CloudflareApi,
+  type CloudflareApiOptions,
+} from "./api.ts";
+import type { Kind, Rule, RulePhase } from "./rule.ts";
+import { findZoneForHostname, type Zone } from "./zone.ts";
+
+/**
+ * Properties for creating or updating a Ruleset
+ */
+export interface RulesetProps<Phase extends RulePhase>
+  extends Partial<CloudflareApiOptions> {
+  /**
+   * The zone to apply the ruleset to
+   */
+  zone: string | Zone;
+
+  /**
+   * The phase of the ruleset
+   * @default "http_ratelimit"
+   */
+  phase: Phase;
+
+  /**
+   * Rules to apply to the ruleset
+   */
+  rules: Array<Rule>;
+
+  /**
+   * Human-readable name for the ruleset
+   */
+  name?: string;
+
+  /**
+   * Description of the ruleset
+   */
+  description?: string;
+}
+
+/**
+ * Output returned after Ruleset creation/update
+ */
+export interface Ruleset<Phase extends RulePhase>
+  extends Resource<"cloudflare::Ruleset"> {
+  /**
+   * The ID of the ruleset
+   */
+  id: string;
+
+  /**
+   * The zone ID
+   */
+  zoneId: string;
+
+  /**
+   * The phase of the ruleset
+   */
+  phase: Phase;
+
+  /**
+   * Human-readable name of the ruleset
+   */
+  name: string;
+
+  /**
+   * Description of the ruleset
+   */
+  description?: string;
+
+  /**
+   * The rules in the ruleset
+   */
+  rules: Array<Rule>;
+
+  /**
+   * ISO datetime the ruleset was last updated
+   */
+  lastUpdated: string;
+
+  /**
+   * Version string of the ruleset
+   */
+  version: string;
+}
+
+/**
+ * Cloudflare Ruleset manages rules within a specific phase's entrypoint ruleset.
+ * This resource allows you to configure rules for various phases like rate limiting,
+ * firewall, transforms, and more.
+ *
+ * @example
+ * // Create a rate limiting ruleset
+ * const rateLimits = await Ruleset("api-rate-limits", {
+ *   zone: "example.com",
+ *   phase: "http_ratelimit",
+ *   rules: [
+ *     {
+ *       description: "API rate limit",
+ *       expression: "(http.request.uri.path wildcard r\"/api/*\")",
+ *       action: "block",
+ *       ratelimit: {
+ *         characteristics: ["ip.src"],
+ *         period: 60,
+ *         requests_per_period: 100,
+ *         mitigation_timeout: 600
+ *       }
+ *     }
+ *   ]
+ * });
+ *
+ * @example
+ * // Create a custom firewall ruleset
+ * const firewall = await Ruleset("custom-firewall", {
+ *   zone: myZone,
+ *   phase: "http_request_firewall_custom",
+ *   rules: [
+ *     {
+ *       description: "Block bad IPs",
+ *       expression: "ip.src in {1.2.3.4 1.2.3.5}",
+ *       action: "block"
+ *     },
+ *     {
+ *       description: "Challenge suspicious requests",
+ *       expression: "cf.threat_score > 50",
+ *       action: "challenge"
+ *     }
+ *   ]
+ * });
+ *
+ * @example
+ * // Create a transform ruleset for request headers
+ * const transforms = await Ruleset("header-transforms", {
+ *   zone: "example.com",
+ *   phase: "http_request_transform",
+ *   rules: [
+ *     {
+ *       description: "Add custom header",
+ *       expression: "true",
+ *       action: "rewrite",
+ *       action_parameters: {
+ *         headers: {
+ *           "X-Custom-Header": { value: "my-value" }
+ *         }
+ *       }
+ *     }
+ *   ]
+ * });
+ */
+export const Ruleset = Resource("cloudflare::Ruleset", async function <
+  Phase extends RulePhase,
+>(this: Context<Ruleset<Phase>>, _id: string, props: RulesetProps<Phase>): Promise<
+  Ruleset<Phase>
+> {
+  const api = await createCloudflareApi(props);
+
+  // Default phase to http_ratelimit if not specified
+  const phase = props.phase || "http_ratelimit";
+
+  // Get zone ID from zone name
+  const zoneId =
+    typeof props.zone === "string"
+      ? (await findZoneForHostname(api, props.zone)).zoneId
+      : props.zone.id;
+
+  if (this.phase === "delete") {
+    // Overwrite entire entrypoint with empty rules
+    await updateRuleset(api, zoneId, phase, { rules: [] });
+    return this.destroy();
+  }
+
+  // Overwrite entire entrypoint with only the provided rules
+  const result = await updateRuleset(api, zoneId, phase, {
+    rules: props.rules,
+    ...(props.name && { name: props.name }),
+    ...(props.description && { description: props.description }),
+  });
+
+  // Transform response back to our format
+  return this({
+    id: result.id,
+    zoneId,
+    phase: props.phase,
+    name: result.name || props.name || `${phase} ruleset`,
+    description: result.description || props.description,
+    rules: (result.rules as Array<Rule> | undefined) ?? [],
+    lastUpdated: result.last_updated,
+    version: result.version,
+  });
+});
+
+interface CloudflareApiRuleset {
+  /** Unique ID of the ruleset (versioned under the hood). */
+  id: string;
+  /** ISO datetime last updated. */
+  last_updated: string; // date-time
+  /** Version string of the ruleset. */
+  version: string;
+  /** Kind of ruleset. */
+  kind: Kind;
+  /** Human-readable name. */
+  name: string; // minLength: 1
+  /** Phase this ruleset runs in. */
+  phase: RulePhase;
+  /** Optional description. */
+  description?: string;
+  /** The list of rules in the ruleset. */
+  rules?: Rule[]; // or (RulesetRule[]) if you prefer loose typing
+}
+
+/**
+ * Update a ruleset for a specific zone and phase
+ * Ensures consistent error handling on non-2xx responses
+ */
+export async function updateRuleset(
+  api: CloudflareApi,
+  zoneId: string,
+  /** Phase of the ruleset */
+  phase: RulePhase,
+  body: {
+    /** Human-readable name of the ruleset */
+    name?: string; // minLength: 1
+    /** Informative description of the ruleset */
+    description?: string;
+    /** Kind of the ruleset (managed, custom, root, etc.) */
+    kind?: Kind;
+    /** The list of rules in the ruleset */
+    rules: Array<Rule>;
+  },
+): Promise<CloudflareApiRuleset> {
+  const response = await api.put(
+    `/zones/${zoneId}/rulesets/phases/${phase}/entrypoint`,
+    body,
+  );
+
+  if (!response.ok) {
+    await handleApiError(response, "updating", "ruleset", `${zoneId}/${phase}`);
+  }
+
+  const data = (await response.json()) as { result: CloudflareApiRuleset };
+  return data.result;
+}
+
+export async function getRuleset(
+  api: CloudflareApi,
+  zoneId: string,
+  phase: RulePhase,
+): Promise<CloudflareApiRuleset> {
+  const response = await api.get(
+    `/zones/${zoneId}/rulesets/phases/${phase}/entrypoint`,
+  );
+  const data = (await response.json()) as { result: CloudflareApiRuleset };
+  return data.result;
+}

package/src/cloudflare/wrangler.json.ts

@@ -163,6 +163,9 @@ export const WranglerJson = Resource(
         ? {
             directory: toAbsolute(props.assets.directory),
             binding: props.assets.binding,
+            not_found_handling: props.worker.assets?.not_found_handling,
+            html_handling: props.worker.assets?.html_handling,
+            run_worker_first: props.worker.assets?.run_worker_first,
           }
         : undefined,
       placement: worker.placement,
@@ -417,6 +420,13 @@ export interface WranglerJsonSpec {
   assets?: {
     directory: string;
     binding: string;
+    not_found_handling?: "none" | "404-page" | "single-page-application";
+    html_handling?:
+      | "auto-trailing-slash"
+      | "drop-trailing-slash"
+      | "force-trailing-slash"
+      | "none";
+    run_worker_first?: boolean | string[];
   };
 
   /**

package/src/cloudflare/zone-bot-management.ts

@@ -0,0 +1,147 @@
+import type { CloudflareApi } from "./api.ts";
+
+export type BotManagement =
+  | BotFightModeConfiguration
+  | SuperBotFightModeDefinitelyConfiguration
+  | SuperBotFightModeLikelyConfiguration
+  | SubscriptionConfiguration;
+
+/**
+ * Bot Management configuration types
+ * See Cloudflare API: https://developers.cloudflare.com/api/resources/bot_management/methods/update/
+ */
+/**
+ * Action to apply to traffic classified by Super Bot Fight Mode.
+ * Maps to Cloudflare API values for SBFM: sbfm_* fields.
+ */
+export type SbfmAction = "allow" | "block" | "challenge";
+
+/**
+ * Bot Fight Mode plan configuration.
+ * Maps to Cloudflare API: fight_mode, ai_bots_protection, crawler_protection,
+ * enable_js, is_robots_txt_managed, optimize_wordpress, suppress_session_score
+ */
+export interface BotFightModeConfiguration {
+  /** Enable or disable Bot Fight Mode (fight_mode) */
+  fightMode?: boolean;
+  /** Configure AI bot protection behavior (ai_bots_protection): "block" or "none" */
+  aiBotsProtection?: "block" | "none";
+  /** Enable or disable crawler protection (crawler_protection): "enabled" or "disabled" */
+  crawlerProtection?: "enabled" | "disabled";
+  /** Require JavaScript challenges for suspicious traffic (enable_js) */
+  enableJs?: boolean;
+  /** Manage robots.txt via Cloudflare (is_robots_txt_managed) */
+  isRobotsTxtManaged?: boolean;
+  /** Optimize protections for WordPress (optimize_wordpress) */
+  optimizeWordpress?: boolean;
+  /** Suppress session score collection (suppress_session_score) */
+  suppressSessionScore?: boolean;
+}
+
+/**
+ * Super Bot Fight Mode Likely plan configuration.
+ * Maps to Cloudflare API: sbfm_likely_automated, sbfm_verified_bots,
+ * sbfm_static_resource_protection, optimize_wordpress, suppress_session_score, fight_mode
+ */
+export interface SuperBotFightModeLikelyConfiguration {
+  /** Action for likely automated traffic (sbfm_likely_automated) */
+  sbfmLikelyAutomated?: SbfmAction;
+  /** Handling for verified bots (sbfm_verified_bots): "allow" or "challenge" */
+  sbfmVerifiedBots?: "allow" | "challenge";
+  /** Protect static resources from automated requests (sbfm_static_resource_protection) */
+  sbfmStaticResourceProtection?: boolean;
+  /** Optimize protections for WordPress (optimize_wordpress) */
+  optimizeWordpress?: boolean;
+  /** Suppress session score collection (suppress_session_score) */
+  suppressSessionScore?: boolean;
+  /** Enable or disable legacy Bot Fight Mode setting if applicable (fight_mode) */
+  fightMode?: boolean;
+}
+
+/**
+ * Super Bot Fight Mode Definitely plan configuration.
+ * Maps to Cloudflare API: sbfm_definitely_automated, sbfm_verified_bots,
+ * sbfm_static_resource_protection, optimize_wordpress, suppress_session_score, fight_mode
+ */
+export interface SuperBotFightModeDefinitelyConfiguration {
+  /** Action for definitely automated traffic (sbfm_definitely_automated) */
+  sbfmDefinitelyAutomated?: SbfmAction;
+  /** Handling for verified bots (sbfm_verified_bots): "allow" or "challenge" */
+  sbfmVerifiedBots?: "allow" | "challenge";
+  /** Protect static resources from automated requests (sbfm_static_resource_protection) */
+  sbfmStaticResourceProtection?: boolean;
+  /** Optimize protections for WordPress (optimize_wordpress) */
+  optimizeWordpress?: boolean;
+  /** Suppress session score collection (suppress_session_score) */
+  suppressSessionScore?: boolean;
+  /** Enable or disable legacy Bot Fight Mode setting if applicable (fight_mode) */
+  fightMode?: boolean;
+}
+
+/**
+ * Bot Management for Enterprise subscription configuration.
+ * Extends base Bot Fight Mode options, adds model auto-update control.
+ * Maps to Cloudflare API: auto_update_model
+ */
+export interface SubscriptionConfiguration extends BotFightModeConfiguration {
+  /** Automatically update Bot Management model (auto_update_model) */
+  autoUpdateModel?: boolean;
+}
+
+/**
+ * Helper function to update Bot Management configuration for a zone
+ * Maps high-level options to Cloudflare API fields
+ */
+export async function updateBotManagement(
+  api: CloudflareApi,
+  zoneId: string,
+  botManagement: BotManagement | undefined,
+  oldBotManagement: BotManagement | undefined,
+): Promise<void> {
+  const payload = createUpdateBotManagementPayload(botManagement);
+  const oldPayload = createUpdateBotManagementPayload(oldBotManagement);
+  if (JSON.stringify(payload) === JSON.stringify(oldPayload)) {
+    return;
+  }
+  const response = await api.put(`/zones/${zoneId}/bot_management`, payload);
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(
+      `Failed to update bot management settings: ${response.status} ${response.statusText}\n${body}`,
+    );
+  }
+}
+
+const createUpdateBotManagementPayload = (props: BotManagement | undefined) =>
+  props === undefined
+    ? {}
+    : {
+        fight_mode: (props as BotFightModeConfiguration).fightMode,
+        ai_bots_protection: (props as BotFightModeConfiguration)
+          .aiBotsProtection,
+        crawler_protection: (props as BotFightModeConfiguration)
+          .crawlerProtection,
+        enable_js: (props as BotFightModeConfiguration).enableJs,
+        is_robots_txt_managed: (props as BotFightModeConfiguration)
+          .isRobotsTxtManaged,
+        auto_update_model: (props as SubscriptionConfiguration).autoUpdateModel,
+        optimize_wordpress: (props as BotFightModeConfiguration)
+          .optimizeWordpress,
+        suppress_session_score: (props as BotFightModeConfiguration)
+          .suppressSessionScore,
+        sbfm_likely_automated: (props as SuperBotFightModeLikelyConfiguration)
+          .sbfmLikelyAutomated,
+        sbfm_definitely_automated: (
+          props as SuperBotFightModeDefinitelyConfiguration
+        ).sbfmDefinitelyAutomated,
+        sbfm_verified_bots: (
+          props as
+            | SuperBotFightModeLikelyConfiguration
+            | SuperBotFightModeDefinitelyConfiguration
+        ).sbfmVerifiedBots,
+        sbfm_static_resource_protection: (
+          props as
+            | SuperBotFightModeLikelyConfiguration
+            | SuperBotFightModeDefinitelyConfiguration
+        ).sbfmStaticResourceProtection,
+      };

package/src/cloudflare/zone.ts

@@ -7,6 +7,10 @@ import {
   type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.ts";
+import {
+  updateBotManagement,
+  type BotManagement,
+} from "./zone-bot-management.ts";
 import type {
   AlwaysUseHTTPSValue,
   AutomaticHTTPSRewritesValue,
@@ -167,6 +171,11 @@ export interface ZoneProps extends CloudflareApiOptions {
      */
     minTlsVersion?: MinTLSVersionValue;
   };
+
+  /**
+   * Cloudflare Bot Management settings
+   */
+  botManagement?: BotManagement;
 }
 
 /**
@@ -314,7 +323,7 @@ export interface Zone extends Resource<"cloudflare::Zone">, ZoneData {}
 export const Zone = Resource(
   "cloudflare::Zone",
   async function (
-    this: Context<Zone>,
+    this: Context<Zone, ZoneProps>,
     _id: string,
     props: ZoneProps,
   ): Promise<Zone> {
@@ -408,6 +417,14 @@ export const Zone = Resource(
     // https://github.com/sam-goodwin/alchemy/issues/681
     await new Promise((resolve) => setTimeout(resolve, 2000));
 
+    // Update Bot Management configuration if provided
+    await updateBotManagement(
+      api,
+      zoneData.id,
+      props.botManagement,
+      this.props?.botManagement,
+    );
+
     return this({
       id: zoneData.id,
       name: zoneData.name,

package/src/state/instrumented-state-store.ts

@@ -24,16 +24,24 @@ export class InstrumentedStateStore<T extends StateStore>
   ): Promise<T> {
     const start = performance.now();
     let error: unknown;
-    return await fn()
-      .catch((err) => (error = err))
-      .finally(() => {
-        this.telemetryClient.record({
-          event,
-          stateStoreClass: this.stateStoreClass,
-          elapsed: performance.now() - start,
-          error: error instanceof Error ? error : new Error(String(error)),
-        });
+    try {
+      return await fn();
+    } catch (err) {
+      error = err;
+      throw err;
+    } finally {
+      this.telemetryClient.record({
+        event,
+        stateStoreClass: this.stateStoreClass,
+        elapsed: performance.now() - start,
+        error:
+          error instanceof Error
+            ? error
+            : error
+              ? new Error(String(error))
+              : undefined,
       });
+    }
   }
 
   async init() {