alchemy 0.59.2 → 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/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() {