alchemy 0.81.0 → 0.81.2

package/src/cloudflare/redirect-rule.ts

@@ -6,12 +6,19 @@ import {
   type CloudflareApiOptions,
 } from "./api.ts";
 import type { CloudflareResponse } from "./response.ts";
-import type { Zone } from "./zone.ts";
+import { getZoneByDomain, type Zone } from "./zone.ts";
 
 /**
  * Properties for creating or updating a RedirectRule
  */
 export interface RedirectRuleProps extends CloudflareApiOptions {
+  /**
+   * Description of the redirect rule
+   *
+   * @default ${app.name}-${app.stage}-${id}
+   */
+  description?: string;
+
   /**
    * The zone where the redirect rule will be applied
    * Can be a zone ID string or a Zone resource
@@ -110,6 +117,11 @@ export interface RedirectRule {
    */
   zoneId: string;
 
+  /**
+   * Description of the redirect rule
+   */
+  description: string;
+
   /**
    * The request URL pattern (for wildcard redirects)
    */
@@ -146,6 +158,23 @@ export interface RedirectRule {
   lastUpdated: string;
 }
 
+/**
+ * Internal rule data structure for API operations
+ */
+interface RuleData {
+  api: CloudflareApi;
+  zoneId: string;
+  rulesetId: string;
+  /** The rule ID (for updates/deletes) */
+  ruleId?: string;
+  /** Description of the rule */
+  description: string;
+  expression: string;
+  targetUrl: string;
+  statusCode: number;
+  preserveQueryString: boolean;
+}
+
 /**
  * A Cloudflare Redirect Rule enables URL redirects and rewrites using Cloudflare's Rules engine.
  * Supports wildcard redirects, static redirects, and dynamic redirects with expressions.
@@ -200,24 +229,33 @@ export const RedirectRule = Resource(
   "cloudflare::RedirectRule",
   async function (
     this: Context<RedirectRule>,
-    _id: string,
+    id: string,
     props: RedirectRuleProps,
   ): Promise<RedirectRule> {
     // Create Cloudflare API client
     const api = await createCloudflareApi(props);
 
+    const description = props.description ?? this.scope.createPhysicalName(id);
+
     // Get zone ID
-    const zoneId = typeof props.zone === "string" ? props.zone : props.zone.id;
+    const zoneId =
+      typeof props.zone === "string"
+        ? props.zone.includes(".")
+          ? (await getZoneByDomain(api, props.zone))?.id
+          : props.zone
+        : props.zone.id;
+    if (!zoneId) {
+      throw new Error(`Zone ${props.zone} not found`);
+    }
 
     if (this.phase === "delete") {
       if (this.output?.ruleId && this.output?.rulesetId) {
-        // Let delete errors propagate instead of swallowing them
-        await deleteRedirectRule(
+        await deleteRule({
           api,
           zoneId,
-          this.output.rulesetId,
-          this.output.ruleId,
-        );
+          rulesetId: this.output.rulesetId,
+          ruleId: this.output.ruleId,
+        });
       }
       return this.destroy();
     }
@@ -249,24 +287,24 @@ export const RedirectRule = Resource(
       this.output?.ruleId &&
       this.output?.rulesetId
     ) {
-      // Update existing rule
-      const updatedRule = await updateRedirectRule(
+      // Update existing rule using PATCH API
+      const updatedRule = await updateRule({
         api,
         zoneId,
-        this.output.rulesetId,
-        this.output.ruleId,
-        {
-          expression: ruleExpression,
-          targetUrl: props.targetUrl,
-          statusCode,
-          preserveQueryString,
-        },
-      );
+        rulesetId: this.output.rulesetId,
+        ruleId: this.output.ruleId,
+        description,
+        expression: ruleExpression,
+        targetUrl: props.targetUrl,
+        statusCode,
+        preserveQueryString,
+      });
 
       return {
         ruleId: updatedRule.id,
         rulesetId: this.output.rulesetId,
         zoneId,
+        description,
         requestUrl: props.requestUrl,
         expression: props.expression,
         targetUrl: props.targetUrl,
@@ -280,8 +318,12 @@ export const RedirectRule = Resource(
     // Get or create the redirect ruleset for this zone
     const rulesetId = await getOrCreateRedirectRuleset(api, zoneId);
 
-    // Create the rule
-    const createdRule = await createRedirectRule(api, zoneId, rulesetId, {
+    // Create the rule using POST API
+    const createdRule = await createRule({
+      api,
+      zoneId,
+      rulesetId,
+      description,
       expression: ruleExpression,
       targetUrl: props.targetUrl,
       statusCode,
@@ -292,6 +334,7 @@ export const RedirectRule = Resource(
       ruleId: createdRule.id,
       rulesetId,
       zoneId,
+      description,
       requestUrl: props.requestUrl,
       expression: props.expression,
       targetUrl: props.targetUrl,
@@ -367,118 +410,80 @@ async function getOrCreateRedirectRuleset(
 }
 
 /**
- * Create a new redirect rule by updating the ruleset
+ * Build the redirect rule body for API requests
  */
-async function createRedirectRule(
-  api: CloudflareApi,
-  zoneId: string,
-  rulesetId: string,
-  ruleData: {
-    expression: string;
-    targetUrl: string;
-    statusCode: number;
-    preserveQueryString: boolean;
-  },
-): Promise<CloudflareRule> {
-  // Get current ruleset
-  const ruleset = await getRuleset(api, zoneId, rulesetId);
-  if (!ruleset) {
-    throw new Error(`Ruleset ${rulesetId} not found`);
-  }
-
-  // Create new rule object
-  const newRule = {
+function buildRuleBody(
+  data: Omit<RuleData, "api" | "zoneId" | "rulesetId" | "ruleId">,
+) {
+  return {
     action: "redirect" as const,
-    expression: ruleData.expression,
+    description: data.description,
+    expression: data.expression,
+    enabled: true,
     action_parameters: {
       from_value: {
-        status_code: ruleData.statusCode,
+        status_code: data.statusCode,
         target_url: {
-          value: ruleData.targetUrl,
+          value: data.targetUrl,
         },
-        preserve_query_string: ruleData.preserveQueryString,
+        preserve_query_string: data.preserveQueryString,
       },
     },
-    enabled: true,
   };
+}
 
-  // Update ruleset with new rule
-  const response = await api.put(`/zones/${zoneId}/rulesets/${rulesetId}`, {
-    name: ruleset.name,
-    description: ruleset.description,
-    kind: ruleset.kind,
-    phase: ruleset.phase,
-    rules: [...(ruleset.rules ?? []), newRule],
-  });
+/**
+ * Create a new redirect rule using the individual rule API
+ * @see https://developers.cloudflare.com/api/resources/rulesets/subresources/rules/methods/create/
+ */
+async function createRule(
+  data: Omit<RuleData, "ruleId">,
+): Promise<CloudflareRule> {
+  const { api, zoneId, rulesetId, ...ruleFields } = data;
+
+  const response = await api.post(
+    `/zones/${zoneId}/rulesets/${rulesetId}/rules`,
+    buildRuleBody(ruleFields),
+  );
 
   if (!response.ok) {
     const errorBody = await response.text();
     throw new Error(
-      `Failed to create redirect rule: ${response.statusText}\nResponse: ${errorBody}`,
+      `Failed to create redirect rule: ${response.status} ${response.statusText}\nResponse: ${errorBody}`,
     );
   }
 
   const result =
     (await response.json()) as CloudflareResponse<CloudflareRuleset>;
-  // Return the last rule (the one we just added)
+  // The API returns the updated ruleset, find the newly created rule (last one)
   const createdRule = result.result.rules[result.result.rules.length - 1];
+  if (!createdRule) {
+    throw new Error("Created rule not found in response");
+  }
   return createdRule;
 }
 
 /**
- * Update an existing redirect rule by updating the ruleset
+ * Update an existing redirect rule using the individual rule API
+ * @see https://developers.cloudflare.com/api/resources/rulesets/subresources/rules/methods/edit/
  */
-async function updateRedirectRule(
-  api: CloudflareApi,
-  zoneId: string,
-  rulesetId: string,
-  ruleId: string,
-  ruleData: {
-    expression: string;
-    targetUrl: string;
-    statusCode: number;
-    preserveQueryString: boolean;
-  },
-): Promise<CloudflareRule> {
-  // Get current ruleset
-  const ruleset = await getRuleset(api, zoneId, rulesetId);
-  if (!ruleset) {
-    throw new Error(`Ruleset ${rulesetId} not found`);
-  }
+async function updateRule(data: RuleData): Promise<CloudflareRule> {
+  const { api, zoneId, rulesetId, ruleId, ...ruleFields } = data;
 
-  // Find and update the rule
-  const updatedRules = ruleset.rules.map((rule) => {
-    if (rule.id === ruleId) {
-      return {
-        ...rule,
-        action: "redirect" as const,
-        expression: ruleData.expression,
-        action_parameters: {
-          from_value: {
-            status_code: ruleData.statusCode,
-            target_url: {
-              value: ruleData.targetUrl,
-            },
-            preserve_query_string: ruleData.preserveQueryString,
-          },
-        },
-        enabled: true,
-      };
-    }
-    return rule;
-  });
+  if (!ruleId) {
+    throw new Error("ruleId is required for update");
+  }
 
-  // Update ruleset with modified rules
-  const response = await api.put(`/zones/${zoneId}/rulesets/${rulesetId}`, {
-    name: ruleset.name,
-    description: ruleset.description,
-    kind: ruleset.kind,
-    phase: ruleset.phase,
-    rules: updatedRules,
-  });
+  const response = await api.patch(
+    `/zones/${zoneId}/rulesets/${rulesetId}/rules/${ruleId}`,
+    buildRuleBody(ruleFields),
+  );
 
   if (!response.ok) {
-    throw new Error(`Failed to update redirect rule: ${response.statusText}`);
+    const errorBody = await response.text();
+    throw new Error(
+      `Failed to update redirect rule: ${response.status} ${response.statusText}\nResponse: ${errorBody}`,
+    );
   }
 
   const result =
@@ -492,22 +497,28 @@ async function updateRedirectRule(
 }
 
 /**
- * Get a ruleset with its rules
+ * Delete a redirect rule using the individual rule API
+ * @see https://developers.cloudflare.com/api/resources/rulesets/subresources/rules/methods/delete/
  */
-async function getRuleset(
-  api: CloudflareApi,
-  zoneId: string,
-  rulesetId: string,
-): Promise<CloudflareRuleset | null> {
-  const response = await api.get(`/zones/${zoneId}/rulesets/${rulesetId}`);
+async function deleteRule(data: {
+  api: CloudflareApi;
+  zoneId: string;
+  rulesetId: string;
+  ruleId: string;
+}): Promise<void> {
+  const { api, zoneId, rulesetId, ruleId } = data;
 
-  if (!response.ok) {
-    return null;
-  }
+  const response = await api.delete(
+    `/zones/${zoneId}/rulesets/${rulesetId}/rules/${ruleId}`,
+  );
 
-  const result =
-    (await response.json()) as CloudflareResponse<CloudflareRuleset>;
-  return result.result;
+  // 404 is acceptable - rule may already be deleted
+  if (!response.ok && response.status !== 404) {
+    const errorBody = await response.text();
+    throw new Error(
+      `Failed to delete redirect rule: ${response.status} ${response.statusText}\nResponse: ${errorBody}`,
+    );
+  }
 }
 
 /**
@@ -529,43 +540,11 @@ export async function findRuleInRuleset(
 
   const rulesetData =
     (await response.json()) as CloudflareResponse<CloudflareRuleset>;
-  const rule = rulesetData.result.rules.find((r) => r.id === ruleId);
+  const rule = rulesetData.result.rules?.find((r) => r.id === ruleId);
 
   return rule || null;
 }
 
-/**
- * Delete a redirect rule by updating the ruleset to exclude it
- */
-async function deleteRedirectRule(
-  api: CloudflareApi,
-  zoneId: string,
-  rulesetId: string,
-  ruleId: string,
-): Promise<void> {
-  const ruleset = await getRuleset(api, zoneId, rulesetId);
-
-  if (!ruleset) {
-    throw new Error(`Ruleset ${rulesetId} not found for deletion`);
-  }
-
-  // Filter out the rule to delete
-  const updatedRules = ruleset.rules.filter((rule) => rule.id !== ruleId);
-
-  // Update the ruleset with the filtered rules
-  const response = await api.put(`/zones/${zoneId}/rulesets/${rulesetId}`, {
-    name: ruleset.name,
-    description: ruleset.description,
-    kind: ruleset.kind,
-    phase: ruleset.phase,
-    rules: updatedRules,
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to delete redirect rule: ${response.statusText}`);
-  }
-}
-
 /**
  * Convert a wildcard URL pattern to a Cloudflare Rules expression
  * Uses operators available on Free plans (no regex matching)

package/src/cloudflare/website.ts

@@ -8,7 +8,7 @@ import { logger } from "../util/logger.ts";
 import { createCloudflareApi } from "./api.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
-import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.gen.ts";
+import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.ts";
 import { unionCompatibilityFlags } from "./compatibility-presets.ts";
 import {
   extractStringAndSecretBindings,

package/src/cloudflare/worker.ts

@@ -20,7 +20,7 @@ import type {
   WorkerBindingSpec,
 } from "./bindings.ts";
 import type { Bound } from "./bound.ts";
-import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.gen.ts";
+import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.ts";
 import {
   type CompatibilityPreset,
   unionCompatibilityFlags,

package/src/fs/folder.ts

@@ -68,7 +68,7 @@ export const Folder = Resource(
       if (props?.delete !== false) {
         // we just do a best effort attempt
         await ignore(["ENOENT", "ENOTEMPTY"], async () =>
-          fs.promises.rmdir(dirPath, { recursive: props?.clean ?? false }),
+          fs.promises.rm(dirPath, { recursive: props?.clean ?? false }),
         );
       }
       return this.destroy();

package/src/prisma-postgres/connection.ts

@@ -143,7 +143,7 @@ export const Connection = Resource(
       createdAt: connection.createdAt,
       prismaConnectionString: secret(connection.connectionString),
       connectionString: secret(
-        `postgres://${connection.user}:${connection.pass}@${connection.host}/${connection.database}`,
+        `postgres://${connection.user}:${connection.pass}@${connection.host}/${connection.database.name}`,
       ),
       database: database,
       host: connection.host,

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

@@ -2,7 +2,7 @@ import { alchemy } from "../alchemy.ts";
 import type { CloudflareApiOptions } from "../cloudflare/api.ts";
 import { createCloudflareApi } from "../cloudflare/api.ts";
 import { getInternalWorkerBundle } from "../cloudflare/bundle/internal-worker-bundle.ts";
-import { DEFAULT_COMPATIBILITY_DATE } from "../cloudflare/compatibility-date.gen.ts";
+import { DEFAULT_COMPATIBILITY_DATE } from "../cloudflare/compatibility-date.ts";
 import { DurableObjectNamespace } from "../cloudflare/durable-object-namespace.ts";
 import { getWorkerSettings } from "../cloudflare/worker-metadata.ts";
 import {

package/workers/tunnel-proxy.js

@@ -83,7 +83,7 @@ const renderErrorHtml = (props) => `
             Alchemy</a>.</p>
       </div>
       <div class="bg-slate-200 px-5 py-3 flex flex-col w-full max-w-lg">
-        <p class="text-sm text-slate-500">Alchemy 0.81.0</p>
+        <p class="text-sm text-slate-500">Alchemy 0.81.2</p>
       </div>
     </div>
   </body>

package/lib/cloudflare/compatibility-date.gen.d.ts

@@ -1,5 +0,0 @@
-/**
- * The default Cloudflare Workers compatibility date, set based on the latest workerd release at the time of build.
- */
-export declare const DEFAULT_COMPATIBILITY_DATE = "2025-12-09";
-//# sourceMappingURL=compatibility-date.gen.d.ts.map

package/lib/cloudflare/compatibility-date.gen.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compatibility-date.gen.d.ts","sourceRoot":"","sources":["../../src/cloudflare/compatibility-date.gen.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,0BAA0B,eAAe,CAAC"}

package/lib/cloudflare/compatibility-date.gen.js

@@ -1,7 +0,0 @@
-// This file is auto-generated during build
-// Do not edit manually
-/**
- * The default Cloudflare Workers compatibility date, set based on the latest workerd release at the time of build.
- */
-export const DEFAULT_COMPATIBILITY_DATE = "2025-12-09";
-//# sourceMappingURL=compatibility-date.gen.js.map

package/lib/cloudflare/compatibility-date.gen.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compatibility-date.gen.js","sourceRoot":"","sources":["../../src/cloudflare/compatibility-date.gen.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,uBAAuB;AAEvB;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,YAAY,CAAC"}

package/src/cloudflare/compatibility-date.gen.ts

@@ -1,7 +0,0 @@
-// This file is auto-generated during build
-// Do not edit manually
-
-/**
- * The default Cloudflare Workers compatibility date, set based on the latest workerd release at the time of build.
- */
-export const DEFAULT_COMPATIBILITY_DATE = "2025-12-09";