alchemy 0.15.5 → 0.15.6

package/src/cloudflare/route.ts

@@ -0,0 +1,268 @@
+import type { Context } from "../context.js";
+import { Resource } from "../resource.js";
+import { CloudflareApiError, handleApiError } from "./api-error.js";
+import {
+  createCloudflareApi,
+  type CloudflareApi,
+  type CloudflareApiOptions,
+} from "./api.js";
+import type { Worker } from "./worker.js";
+
+/**
+ * Properties for creating or updating a Route
+ */
+export interface RouteProps extends CloudflareApiOptions {
+  /**
+   * URL pattern for the route
+   * @example "example.com/*"
+   */
+  pattern: string;
+
+  /**
+   * Worker script for the route
+   * This can be a Worker resource or script name as a string
+   */
+  script: Worker | string;
+
+  /**
+   * Zone ID for the route
+   */
+  zoneId: string;
+}
+
+/**
+ * Output returned after Route creation/update
+ */
+export interface Route extends Resource<"cloudflare::Route">, RouteProps {
+  /**
+   * The unique ID of the route
+   */
+  id: string;
+
+  /**
+   * The URL pattern for the route
+   */
+  pattern: string;
+
+  /**
+   * The Worker script name for the route
+   */
+  script: string;
+
+  /**
+   * The Zone ID for the route
+   */
+  zoneId: string;
+}
+
+/**
+ * Creates and manages Cloudflare Worker Routes.
+ *
+ * Routes map URL patterns to Worker scripts, allowing you to control which
+ * requests are handled by your Workers.
+ *
+ * @example
+ * // Create a route that maps all requests on a domain to a Worker
+ * const basicRoute = await Route("main-route", {
+ *   pattern: "example.com/*",
+ *   script: "my-worker",
+ *   zoneId: "your-zone-id"
+ * });
+ *
+ * @example
+ * // Create a route using a Worker resource
+ * const worker = await Worker("api-worker", {
+ *   script: `
+ *     export default {
+ *       fetch(request, env) {
+ *         return new Response("Hello from API!");
+ *       }
+ *     }
+ *   `
+ * });
+ *
+ * const apiRoute = await Route("api-route", {
+ *   pattern: "api.example.com/*",
+ *   script: worker,
+ *   zoneId: "your-zone-id"
+ * });
+ *
+ * @see https://developers.cloudflare.com/workers/configuration/routes/
+ */
+export const Route = Resource(
+  "cloudflare::Route",
+  async function (
+    this: Context<Route>,
+    id: string,
+    props: RouteProps,
+  ): Promise<Route> {
+    const api = await createCloudflareApi(props);
+
+    // Get script name from script prop (either a string or a Worker 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);
+
+      // Only delete if we have an ID
+      if (this.output?.id) {
+        await deleteRoute(api, zoneId, this.output.id);
+      }
+
+      // Return void (a deleted route has no content)
+      return this.destroy();
+    }
+
+    let routeData: CloudflareRouteResponse;
+
+    if (this.phase === "update" && this.output?.id) {
+      console.log("Updating Route:", props.pattern);
+
+      // Update existing route
+      routeData = await updateRoute(
+        api,
+        zoneId,
+        this.output.id,
+        props.pattern,
+        scriptName,
+      );
+    } else {
+      console.log("Creating Route:", props.pattern);
+
+      // Create new route
+      routeData = await createRoute(api, zoneId, props.pattern, scriptName);
+    }
+
+    // Return the route resource
+    return this({
+      id: routeData.result.id,
+      pattern: routeData.result.pattern,
+      script: routeData.result.script,
+      zoneId,
+    });
+  },
+);
+
+interface CloudflareRouteResponse {
+  result: {
+    id: string;
+    pattern: string;
+    script: string;
+  };
+  success: boolean;
+  errors: Array<{ code: number; message: string }>;
+  messages: string[];
+}
+
+/**
+ * Create a new route
+ */
+async function createRoute(
+  api: CloudflareApi,
+  zoneId: string,
+  pattern: string,
+  script: string,
+): Promise<CloudflareRouteResponse> {
+  const createResponse = await api.post(`/zones/${zoneId}/workers/routes`, {
+    pattern,
+    script,
+  });
+
+  if (!createResponse.ok) {
+    return await handleApiError(createResponse, "creating", "Route", pattern);
+  }
+
+  return (await createResponse.json()) as CloudflareRouteResponse;
+}
+
+/**
+ * Update a route
+ */
+async function updateRoute(
+  api: CloudflareApi,
+  zoneId: string,
+  routeId: string,
+  pattern: string,
+  script: string,
+): Promise<CloudflareRouteResponse> {
+  const updateResponse = await api.put(
+    `/zones/${zoneId}/workers/routes/${routeId}`,
+    {
+      pattern,
+      script,
+    },
+  );
+
+  if (!updateResponse.ok) {
+    return await handleApiError(updateResponse, "updating", "Route", pattern);
+  }
+
+  return (await updateResponse.json()) as CloudflareRouteResponse;
+}
+
+/**
+ * Delete a route
+ */
+async function deleteRoute(
+  api: CloudflareApi,
+  zoneId: string,
+  routeId: string,
+): Promise<void> {
+  const deleteResponse = await api.delete(
+    `/zones/${zoneId}/workers/routes/${routeId}`,
+  );
+
+  if (!deleteResponse.ok && deleteResponse.status !== 404) {
+    const errorData: any = await deleteResponse.json().catch(() => ({
+      errors: [{ message: deleteResponse.statusText }],
+    }));
+
+    throw new CloudflareApiError(
+      `Error deleting Route '${routeId}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`,
+      deleteResponse,
+    );
+  }
+}
+
+/**
+ * Get a route by ID
+ */
+export async function getRoute(
+  api: CloudflareApi,
+  zoneId: string,
+  routeId: string,
+): Promise<CloudflareRouteResponse> {
+  const response = await api.get(`/zones/${zoneId}/workers/routes/${routeId}`);
+
+  if (!response.ok) {
+    throw new CloudflareApiError(
+      `Failed to get route ${routeId}: ${response.statusText}`,
+      response,
+    );
+  }
+
+  return (await response.json()) as CloudflareRouteResponse;
+}
+
+/**
+ * List all routes for a zone
+ */
+export async function listRoutes(
+  api: CloudflareApi,
+  zoneId: string,
+): Promise<CloudflareRouteResponse> {
+  const response = await api.get(`/zones/${zoneId}/workers/routes`);
+
+  if (!response.ok) {
+    throw new CloudflareApiError(
+      `Failed to list routes: ${response.statusText}`,
+      response,
+    );
+  }
+
+  return (await response.json()) as CloudflareRouteResponse;
+}

package/src/cloudflare/worker.ts

@@ -275,6 +275,12 @@ export interface Worker<B extends Bindings = Bindings>
  *   url: true
  * });
  *
+ * await Route("route", {
+ *   zoneId: zone.zoneId,
+ *   worker: api,
+ *   pattern: "api.example.com/*",
+ * });
+ *
  * @example
  * // Create a real-time chat worker using Durable Objects
  * // for state management:

package/src/cloudflare/wrangler.json.ts

@@ -268,6 +268,15 @@ export interface WranglerJsonSpec {
     binding: string;
   };
 
+  /**
+   * Migrations
+   */
+  migrations?: {
+    tag: string;
+    new_sqlite_classes?: string[];
+    new_classes?: string[];
+  }[];
+
   /**
    * Workflow bindings
    */
@@ -327,6 +336,9 @@ function processBindings(
     consumers: [],
   };
 
+  const new_sqlite_classes: string[] = [];
+  const new_classes: string[] = [];
+
   const vectorizeIndexes: { binding: string; index_name: string }[] = [];
 
   for (const eventSource of eventSources ?? []) {
@@ -383,6 +395,11 @@ function processBindings(
         script_name: doBinding.scriptName,
         environment: doBinding.environment,
       });
+      if (doBinding.sqlite) {
+        new_sqlite_classes.push(doBinding.className);
+      } else {
+        new_classes.push(doBinding.className);
+      }
     } else if (binding.type === "r2_bucket") {
       r2Buckets.push({
         binding: bindingName,
@@ -466,4 +483,14 @@ function processBindings(
   if (vectorizeIndexes.length > 0) {
     spec.vectorize_indexes = vectorizeIndexes;
   }
+
+  if (new_sqlite_classes.length > 0 || new_classes.length > 0) {
+    spec.migrations = [
+      {
+        tag: "v1",
+        new_sqlite_classes,
+        new_classes,
+      },
+    ];
+  }
 }

package/src/internal/docs/providers.ts

@@ -6,6 +6,14 @@ import { Document } from "../../ai/document.js";
 import { alchemy } from "../../alchemy.js";
 import { Folder } from "../../fs/folder.js";
 
+function getArg(arg: string) {
+  const idx = process.argv.findIndex((a) => a === arg);
+  return idx > -1 ? process.argv[idx + 1] : undefined;
+}
+
+const onlyProviderName = getArg("--provider");
+const onlyResourceName = getArg("--resource");
+
 export interface DocsProps {
   /**
    * The output directory for the docs.
@@ -117,7 +125,7 @@ async function generateProviderDocs({
         reasoningEffort: "high",
       },
     },
-    freeze: false,
+    freeze: onlyProviderName === undefined || onlyProviderName !== providerName,
     temperature: 0.1,
     schema: type({
       groups: type({
@@ -177,7 +185,8 @@ async function generateProviderDocs({
         providerDocsDir,
         `${g.filename.replace(".ts", "").replace(".md", "")}.md`,
       ),
-      freeze: false,
+      freeze:
+        onlyResourceName !== undefined && onlyResourceName !== g.identifier,
       model: {
         id: "claude-3-5-sonnet-latest",
         provider: "anthropic",

package/src/scope.ts

@@ -47,10 +47,15 @@ export class Scope {
 
   private isErrored = false;
 
-  constructor(private readonly options: ScopeOptions) {
+  constructor(options: ScopeOptions) {
     this.appName = options.appName;
     this.stage = options?.stage ?? DEFAULT_STAGE;
     this.scopeName = options.scopeName ?? null;
+    if (this.scopeName?.includes(":")) {
+      throw new Error(
+        `Scope name ${this.scopeName} cannot contain double colons`,
+      );
+    }
     this.parent = options.parent ?? Scope.get();
     this.quiet = options.quiet ?? this.parent?.quiet ?? false;
     if (this.parent && !this.scopeName) {