alchemy 0.24.1 → 0.26.0

package/src/cloudflare/route.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { logger } from "../util/logger.ts";
 import { CloudflareApiError, handleApiError } from "./api-error.ts";
 import {
   createCloudflareApi,
@@ -7,6 +8,7 @@ import {
   type CloudflareApiOptions,
 } from "./api.ts";
 import type { Worker } from "./worker.ts";
+import { getZoneByDomain } from "./zone.ts";
 
 /**
  * Properties for creating or updating a Route
@@ -26,8 +28,18 @@ export interface RouteProps extends CloudflareApiOptions {
 
   /**
    * Zone ID for the route
+   * If not provided, will be automatically inferred from the route pattern using Cloudflare's zones API.
+   * The system will attempt to find a zone that matches the domain in the route pattern.
+   *
+   * @example
+   * // Explicit zone ID:
+   * { pattern: "api.example.com/*", zoneId: "abc123def456" }
+   *
+   * // Automatic inference (recommended):
+   * { pattern: "api.example.com/*" } // Zone ID automatically inferred from "example.com"
+   * { pattern: "*.example.com/api/*" } // Zone ID inferred from "example.com"
    */
-  zoneId: string;
+  zoneId?: string;
 
   /**
    * Whether to adopt an existing route with the same pattern if it exists
@@ -95,6 +107,21 @@ export interface Route extends Resource<"cloudflare::Route">, RouteProps {
  *   zoneId: "your-zone-id"
  * });
  *
+ * @example
+ * // Create a route with automatic zone ID inference
+ * // The zone ID will be automatically determined from the domain in the pattern
+ * const autoRoute = await Route("auto-route", {
+ *   pattern: "api.example.com/*", // Zone ID inferred from example.com
+ *   script: "my-worker"
+ * });
+ *
+ * @example
+ * // Works with wildcard patterns too
+ * const wildcardRoute = await Route("wildcard-route", {
+ *   pattern: "*.example.com/api/*", // Zone ID inferred from example.com
+ *   script: "api-worker"
+ * });
+ *
  * @see https://developers.cloudflare.com/workers/configuration/routes/
  */
 export const Route = Resource(
@@ -110,25 +137,44 @@ export const Route = Resource(
     const scriptName =
       typeof props.script === "string" ? props.script : props.script.name;
 
-    // Get zone ID from props
-    const { zoneId } = props;
-
     if (this.phase === "delete") {
-      console.log("Deleting Route:", props.pattern);
+      logger.log("Deleting Route:", props.pattern);
 
-      // Only delete if we have an ID
-      if (this.output?.id) {
-        await deleteRoute(api, zoneId, this.output.id);
+      // Only delete if we have complete output data (both ID and zoneId)
+      // If creation failed, we won't have proper output, so just skip deletion
+      if (this.output?.id && this.output?.zoneId) {
+        await deleteRoute(api, this.output.zoneId, this.output.id);
       }
 
       // Return void (a deleted route has no content)
       return this.destroy();
     }
 
+    // Get or infer zone ID (only needed for create/update phases)
+    let zoneId = props.zoneId;
+    if (!zoneId) {
+      const inferredZoneId = await inferZoneIdFromPattern(props.pattern, {
+        accountId: props.accountId,
+        apiKey: props.apiKey,
+        apiToken: props.apiToken,
+        baseUrl: props.baseUrl,
+        email: props.email,
+      });
+
+      if (!inferredZoneId) {
+        throw new Error(
+          `Could not infer zone ID for route pattern "${props.pattern}". ` +
+            "Please ensure the domain is managed by Cloudflare or specify an explicit zoneId.",
+        );
+      }
+
+      zoneId = inferredZoneId;
+    }
+
     let routeData: CloudflareRouteResponse;
 
     if (this.phase === "update" && this.output?.id) {
-      console.log("Updating Route:", props.pattern);
+      logger.log("Updating Route:", props.pattern);
 
       // Update existing route
       routeData = await updateRoute(
@@ -139,7 +185,7 @@ export const Route = Resource(
         scriptName,
       );
     } else {
-      console.log("Creating Route:", props.pattern);
+      logger.log("Creating Route:", props.pattern);
 
       try {
         // Create new route
@@ -151,7 +197,7 @@ export const Route = Resource(
           error instanceof CloudflareApiError &&
           error.status === 409
         ) {
-          console.log(
+          logger.log(
             `Route with pattern '${props.pattern}' already exists, adopting it`,
           );
           // Find the existing route by pattern
@@ -167,13 +213,14 @@ export const Route = Resource(
             );
           }
 
-          // Use the existing route data
-          routeData = {
-            result: existingRoute,
-            success: true,
-            errors: [],
-            messages: [],
-          };
+          // Update the existing route to point to our script
+          routeData = await updateRoute(
+            api,
+            zoneId,
+            existingRoute.id,
+            props.pattern,
+            scriptName,
+          );
         } else {
           // Re-throw the error if adopt is false or it's not a 409 error
           throw error;
@@ -350,3 +397,56 @@ async function findRouteByPattern(
   const match = data.result.find((route) => route.pattern === pattern);
   return match || null;
 }
+
+/**
+ * Extract domain from a route pattern, similar to wrangler's logic
+ * @param pattern The route pattern (e.g., "api.example.com/*", "*.example.com/api/*")
+ * @returns The domain part of the pattern
+ */
+function extractDomainFromPattern(pattern: string): string {
+  // Remove protocol if present
+  let domain = pattern.replace(/^https?:\/\//, "");
+
+  // Remove path part (everything after the first '/')
+  domain = domain.split("/")[0];
+
+  // Remove port if present
+  domain = domain.split(":")[0];
+
+  return domain;
+}
+
+/**
+ * Infer zone ID from a route pattern using Cloudflare API
+ * This implements similar logic to wrangler's zone inference
+ * @param pattern The route pattern
+ * @param apiOptions API options for Cloudflare API calls
+ * @returns Promise resolving to zone ID or null if not found
+ */
+async function inferZoneIdFromPattern(
+  pattern: string,
+  apiOptions: Partial<CloudflareApiOptions>,
+): Promise<string | null> {
+  const domain = extractDomainFromPattern(pattern);
+
+  // Handle wildcard domains by removing the wildcard part
+  const cleanDomain = domain.replace(/^\*\./, "");
+
+  // Try to find zone for the exact domain first
+  let zone = await getZoneByDomain(cleanDomain, apiOptions);
+  if (zone) {
+    return zone.id;
+  }
+
+  // If not found, try parent domains (similar to wrangler's logic)
+  const domainParts = cleanDomain.split(".");
+  for (let i = 1; i < domainParts.length - 1; i++) {
+    const parentDomain = domainParts.slice(i).join(".");
+    zone = await getZoneByDomain(parentDomain, apiOptions);
+    if (zone) {
+      return zone.id;
+    }
+  }
+
+  return null;
+}

package/src/cloudflare/secret.ts

@@ -0,0 +1,253 @@
+import type { Context } from "../context.ts";
+import { Resource, ResourceKind } from "../resource.ts";
+import {
+  secret as alchemySecret,
+  type Secret as AlchemySecret,
+} from "../secret.ts";
+import { handleApiError } from "./api-error.ts";
+import {
+  createCloudflareApi,
+  type CloudflareApi,
+  type CloudflareApiOptions,
+} from "./api.ts";
+import type { SecretsStore } from "./secrets-store.ts";
+
+/**
+ * Properties for creating or updating a Secret in a Secrets Store (internal interface)
+ */
+interface _SecretProps extends CloudflareApiOptions {
+  /**
+   * The secrets store to add this secret to
+   */
+  store: SecretsStore<any>;
+
+  /**
+   * The secret value to store (must be an AlchemySecret for security)
+   */
+  value: AlchemySecret;
+
+  /**
+   * Whether to delete the secret.
+   * If set to false, the secret will remain but the resource will be removed from state
+   *
+   * @default true
+   */
+  delete?: boolean;
+}
+
+/**
+ * Properties for creating or updating a Secret in a Secrets Store (public interface)
+ */
+export interface SecretProps extends CloudflareApiOptions {
+  /**
+   * The secrets store to add this secret to
+   */
+  store: SecretsStore<any>;
+
+  /**
+   * The secret value to store
+   * Can be a string or an existing Secret instance
+   *
+   * @example
+   * ```ts
+   * const secret = await Secret("api-key", {
+   *   store: mySecretsStore,
+   *   value: alchemy.secret(process.env.API_KEY)
+   * });
+   * ```
+   */
+  value: string | AlchemySecret;
+
+  /**
+   * Whether to delete the secret.
+   * If set to false, the secret will remain but the resource will be removed from state
+   *
+   * @default true
+   */
+  delete?: boolean;
+}
+
+export function isSecret(resource: Resource): resource is Secret {
+  return resource[ResourceKind] === "cloudflare::Secret";
+}
+
+export interface Secret
+  extends Resource<"cloudflare::Secret">,
+    Omit<_SecretProps, "delete"> {
+  /**
+   * The name of the secret
+   */
+  name: string;
+
+  /**
+   * The unique identifier of the secrets store this secret belongs to
+   */
+  storeId: string;
+
+  /**
+   * The secret value (as an alchemy Secret instance)
+   */
+  value: AlchemySecret;
+
+  /**
+   * Timestamp when the secret was created
+   */
+  createdAt: number;
+
+  /**
+   * Timestamp when the secret was last modified
+   */
+  modifiedAt: number;
+}
+
+/**
+ * A Cloudflare Secret represents an individual secret stored in a Secrets Store.
+ *
+ * Use this resource to add individual secrets to an existing Secrets Store,
+ * providing fine-grained control over secret management.
+ *
+ * @see https://developers.cloudflare.com/api/resources/secrets_store/subresources/stores/subresources/secrets/
+ *
+ * @example
+ * // Create a secrets store first
+ * const store = await SecretsStore("my-store", {
+ *   name: "production-secrets"
+ * });
+ *
+ * // Add individual secrets to the store
+ * const apiKey = await Secret("api-key", {
+ *   store: store,
+ *   value: alchemy.secret(process.env.API_KEY)
+ * });
+ *
+ * const dbUrl = await Secret("database-url", {
+ *   store: store,
+ *   value: process.env.DATABASE_URL
+ * });
+ *
+ * @example
+ * // Use in a Worker binding
+ * const worker = await Worker("my-worker", {
+ *   bindings: {
+ *     SECRETS: store
+ *   },
+ *   code: `
+ *     export default {
+ *       async fetch(request, env) {
+ *         const apiKey = await env.SECRETS.get("api-key");
+ *         const dbUrl = await env.SECRETS.get("database-url");
+ *         return new Response(\`API: \${apiKey ? "set" : "unset"}\`);
+ *       }
+ *     }
+ *   `
+ * });
+ *
+ * @example
+ * // When removing from Alchemy state, keep the secret in Cloudflare
+ * const preservedSecret = await Secret("preserve-secret", {
+ *   store: myStore,
+ *   value: "preserved-value",
+ *   delete: false
+ * });
+ */
+export async function Secret(
+  name: string,
+  props: SecretProps,
+): Promise<Secret> {
+  // Convert string value to AlchemySecret if needed to prevent plain text serialization
+  const secretValue =
+    typeof props.value === "string" ? alchemySecret(props.value) : props.value;
+
+  // Call the internal resource with secure props
+  return _Secret(name, {
+    ...props,
+    value: secretValue,
+  });
+}
+
+const _Secret = Resource(
+  "cloudflare::Secret",
+  async function (
+    this: Context<Secret>,
+    name: string,
+    props: _SecretProps,
+  ): Promise<Secret> {
+    const api = await createCloudflareApi(props);
+
+    if (this.phase === "delete") {
+      if (props.delete !== false) {
+        await deleteSecret(api, props.store.id, name);
+      }
+      return this.destroy();
+    }
+
+    const createdAt =
+      this.phase === "update"
+        ? this.output?.createdAt || Date.now()
+        : Date.now();
+
+    // Insert or update the secret
+    await insertSecret(api, props.store.id, name, props.value);
+
+    return this({
+      name,
+      storeId: props.store.id,
+      store: props.store,
+      value: props.value,
+      createdAt,
+      modifiedAt: Date.now(),
+    });
+  },
+);
+
+/**
+ * Insert or update a secret in a secrets store
+ */
+export async function insertSecret(
+  api: CloudflareApi,
+  storeId: string,
+  secretName: string,
+  secretValue: AlchemySecret,
+): Promise<void> {
+  const response = await api.post(
+    `/accounts/${api.accountId}/secrets_store/stores/${storeId}/secrets`,
+    [
+      {
+        name: secretName,
+        value: secretValue.unencrypted,
+        scopes: [],
+      },
+    ],
+  );
+
+  if (!response.ok) {
+    const errorData: any = await response.json().catch(() => ({
+      errors: [{ message: response.statusText }],
+    }));
+    const errorMessage = errorData.errors?.[0]?.message || response.statusText;
+    throw new Error(`Error creating secret '${secretName}': ${errorMessage}`);
+  }
+}
+
+/**
+ * Delete a secret from a secrets store
+ */
+export async function deleteSecret(
+  api: CloudflareApi,
+  storeId: string,
+  secretName: string,
+): Promise<void> {
+  const response = await api.delete(
+    `/accounts/${api.accountId}/secrets_store/stores/${storeId}/secrets`,
+    {
+      body: JSON.stringify([secretName]),
+      headers: {
+        "Content-Type": "application/json",
+      },
+    },
+  );
+
+  if (!response.ok && response.status !== 404) {
+    await handleApiError(response, "delete", "secret", secretName);
+  }
+}