alchemy 0.4.0 → 0.5.0

package/src/alchemy.ts

@@ -22,7 +22,7 @@ export const alchemy: Alchemy = _alchemy as any;
  *
  * @example
  * // Create an application scope with stage and secret handling
- * const app = alchemy("github:alchemy", {
+ * const app = await alchemy("github:alchemy", {
  *   stage: "prod",
  *   phase: "up",
  *   // Required for encrypting/decrypting secrets
@@ -57,13 +57,13 @@ export interface Alchemy {
    * Used to create and manage resources with proper secret handling.
    *
    * @example
-   * const app = alchemy("my-app", {
+   * const app = await alchemy("my-app", {
    *   stage: "prod",
    *   // Required for encrypting/decrypting secrets
    *   password: process.env.SECRET_PASSPHRASE
    * });
    */
-  (...parameters: Parameters<typeof scope>): ReturnType<typeof scope>;
+  (...parameters: Parameters<typeof scope>): Promise<Scope>;
   /**
    * Template literal tag that supports file interpolation for documentation.
    * Automatically formats the content and appends file contents as code blocks.
@@ -88,11 +88,11 @@ export interface Alchemy {
  * Implementation of the alchemy function that handles both application scoping
  * and template string interpolation.
  */
-function _alchemy(
+async function _alchemy(
   ...args:
     | [template: TemplateStringsArray, ...values: any[]]
     | [appName: string, options?: Omit<AlchemyOptions, "appName">]
-): any {
+): Promise<Scope | string | never> {
   if (typeof args[0] === "string") {
     const [appName, options] = args as [string, AlchemyOptions?];
     const root = scope(undefined, {
@@ -101,9 +101,8 @@ function _alchemy(
       stage: options?.stage,
     });
     if (options?.phase === "destroy") {
-      return destroy(root).finally(() => {
-        process.exit(0);
-      });
+      await destroy(root);
+      return process.exit(0);
     }
     return root;
   } else {
@@ -114,106 +113,104 @@ function _alchemy(
       : 0;
     const indent = " ".repeat(leadingSpaces);
 
-    return (async () => {
-      const { isFileCollection, isFileRef } = await import("./fs");
+    const { isFileCollection, isFileRef } = await import("./fs");
 
-      const appendices: Record<string, string> = {};
+    const appendices: Record<string, string> = {};
 
-      const stringValues = await Promise.all(
-        values.map(async function resolve(value): Promise<string> {
-          if (typeof value === "string") {
-            return indent + value;
-          } else if (value === null) {
-            return "null";
-          } else if (value === undefined) {
-            return "undefined";
-          } else if (
-            typeof value === "number" ||
-            typeof value === "boolean" ||
-            typeof value === "bigint"
-          ) {
-            return value.toString();
-          } else if (value instanceof Promise) {
-            return resolve(await value);
-          } else if (isFileRef(value)) {
-            if (!(value.path in appendices)) {
-              appendices[value.path] = await fs.readFile(value.path, "utf-8");
-            }
+    const stringValues = await Promise.all(
+      values.map(async function resolve(value): Promise<string> {
+        if (typeof value === "string") {
+          return indent + value;
+        } else if (value === null) {
+          return "null";
+        } else if (value === undefined) {
+          return "undefined";
+        } else if (
+          typeof value === "number" ||
+          typeof value === "boolean" ||
+          typeof value === "bigint"
+        ) {
+          return value.toString();
+        } else if (value instanceof Promise) {
+          return resolve(await value);
+        } else if (isFileRef(value)) {
+          if (!(value.path in appendices)) {
+            appendices[value.path] = await fs.readFile(value.path, "utf-8");
+          }
+          return `[${path.basename(value.path)}](${value.path})`;
+        } else if (isFileCollection(value)) {
+          return Object.entries(value.files)
+            .map(([filePath, content]) => {
+              appendices[filePath] = content;
+              return `[${path.basename(filePath)}](${filePath})`;
+            })
+            .join("\n\n");
+        } else if (Array.isArray(value)) {
+          return (
+            await Promise.all(
+              value.map(async (value, i) => `${i}. ${await resolve(value)}`)
+            )
+          ).join("\n");
+        } else if (
+          typeof value === "object" &&
+          typeof value.path === "string"
+        ) {
+          if (typeof value.content === "string") {
+            appendices[value.path] = value.content;
             return `[${path.basename(value.path)}](${value.path})`;
-          } else if (isFileCollection(value)) {
-            return Object.entries(value.files)
-              .map(([filePath, content]) => {
-                appendices[filePath] = content;
-                return `[${path.basename(filePath)}](${filePath})`;
-              })
-              .join("\n\n");
-          } else if (Array.isArray(value)) {
-            return (
-              await Promise.all(
-                value.map(async (value, i) => `${i}. ${await resolve(value)}`)
-              )
-            ).join("\n");
-          } else if (
-            typeof value === "object" &&
-            typeof value.path === "string"
-          ) {
-            if (typeof value.content === "string") {
-              appendices[value.path] = value.content;
-              return `[${path.basename(value.path)}](${value.path})`;
-            } else {
-              appendices[value.path] = await fs.readFile(value.path, "utf-8");
-              return `[${path.basename(value.path)}](${value.path})`;
-            }
-          } else if (typeof value === "object") {
-            return (
-              await Promise.all(
-                Object.entries(value).map(async ([key, value]) => {
-                  return `* ${key}: ${await resolve(value)}`;
-                })
-              )
-            ).join("\n");
           } else {
-            // TODO: support other types
-            console.log(value);
-            throw new Error(`Unsupported value type: ${value}`);
+            appendices[value.path] = await fs.readFile(value.path, "utf-8");
+            return `[${path.basename(value.path)}](${value.path})`;
           }
-        })
-      );
-
-      // Construct the string template by joining template parts with interpolated values
-      const lines = template
-        .map((part) =>
-          part
-            .split("\n")
-            .map((line) =>
-              line.startsWith(indent) ? line.slice(indent.length) : line
+        } else if (typeof value === "object") {
+          return (
+            await Promise.all(
+              Object.entries(value).map(async ([key, value]) => {
+                return `* ${key}: ${await resolve(value)}`;
+              })
             )
-            .join("\n")
-        )
-        .flatMap((part, i) =>
-          i < stringValues.length ? [part, stringValues[i] ?? ""] : [part]
-        )
-        .join("")
-        .split("\n");
+          ).join("\n");
+        } else {
+          // TODO: support other types
+          console.log(value);
+          throw new Error(`Unsupported value type: ${value}`);
+        }
+      })
+    );
 
-      // Collect and sort appendices by file path
-      return [
-        // format the user prompt and trim the first line if it's empty
-        lines.length > 1 && lines[0].replaceAll(" ", "").length === 0
-          ? lines.slice(1).join("\n")
-          : lines.join("\n"),
+    // Construct the string template by joining template parts with interpolated values
+    const lines = template
+      .map((part) =>
+        part
+          .split("\n")
+          .map((line) =>
+            line.startsWith(indent) ? line.slice(indent.length) : line
+          )
+          .join("\n")
+      )
+      .flatMap((part, i) =>
+        i < stringValues.length ? [part, stringValues[i] ?? ""] : [part]
+      )
+      .join("")
+      .split("\n");
 
-        // sort appendices by path and include at the end of the prompt
-        Object.entries(appendices)
-          .sort(([a], [b]) => a.localeCompare(b))
-          .map(([filePath, content]) => {
-            const extension = path.extname(filePath).slice(1);
-            const codeTag = extension ? extension : "";
-            return `// ${filePath}\n\`\`\`${codeTag}\n${content}\n\`\`\``;
-          })
-          .join("\n\n"),
-      ].join("\n");
-    })();
+    // Collect and sort appendices by file path
+    return [
+      // format the user prompt and trim the first line if it's empty
+      lines.length > 1 && lines[0].replaceAll(" ", "").length === 0
+        ? lines.slice(1).join("\n")
+        : lines.join("\n"),
+
+      // sort appendices by path and include at the end of the prompt
+      Object.entries(appendices)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([filePath, content]) => {
+          const extension = path.extname(filePath).slice(1);
+          const codeTag = extension ? extension : "";
+          return `// ${filePath}\n\`\`\`${codeTag}\n${content}\n\`\`\``;
+        })
+        .join("\n\n"),
+    ].join("\n");
   }
 }
 _alchemy.destroy = destroy;

package/src/cloudflare/assets.ts

@@ -0,0 +1,158 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { getContentType } from "../util/content-type";
+
+/**
+ * Properties for creating or updating Assets
+ */
+export interface AssetsProps {
+  /**
+   * Path to a directory containing static assets to be uploaded
+   * These files will be served by Cloudflare's Workers runtime
+   */
+  path: string;
+}
+
+/**
+ * Output returned after Assets creation/update
+ */
+export interface Assets extends Resource<"cloudflare::Asset">, AssetsProps {
+  /**
+   * The type of binding
+   */
+  type: "assets";
+
+  /**
+   * The ID of the assets bundle
+   */
+  id: string;
+
+  /**
+   * Asset files that were found
+   */
+  files: AssetFile[];
+
+  /**
+   * Time at which the assets were created
+   */
+  createdAt: number;
+
+  /**
+   * Time at which the assets were last updated
+   */
+  updatedAt: number;
+}
+
+/**
+ * Represents a single asset file
+ */
+export interface AssetFile {
+  /**
+   * Path relative to the assets directory
+   */
+  path: string;
+
+  /**
+   * Full filesystem path to the file
+   */
+  filePath: string;
+
+  /**
+   * Content type of the file
+   */
+  contentType: string;
+}
+
+/**
+ * Cloudflare Assets represent a collection of static files that can be uploaded and served
+ * by Cloudflare Workers.
+ *
+ * @example
+ * // Create a basic assets bundle from a local directory
+ * const staticAssets = await Assets("static", {
+ *   path: "./src/assets"
+ * });
+ *
+ * // Use these assets with a worker
+ * const worker = await Worker("frontend", {
+ *   name: "frontend-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     ASSETS: staticAssets
+ *   }
+ * });
+ */
+export const Assets = Resource(
+  "cloudflare::Asset",
+  {
+    alwaysUpdate: true,
+  },
+  async function (
+    this: Context<Assets>,
+    id: string,
+    props: AssetsProps
+  ): Promise<Assets> {
+    if (this.phase === "delete") {
+      return this.destroy();
+    }
+
+    try {
+      // Check if the assets directory exists
+      const stats = await fs.stat(props.path);
+      if (!stats.isDirectory()) {
+        throw new Error(`Assets path ${props.path} is not a directory`);
+      }
+    } catch (error) {
+      throw new Error(
+        `Assets directory ${props.path} does not exist or is not accessible`
+      );
+    }
+
+    // Recursively get all files in the assets directory
+    const filesList = await getFilesRecursively(props.path);
+
+    // Create asset file objects
+    const files: AssetFile[] = filesList.map((filePath) => {
+      const relativePath = path.relative(props.path, filePath);
+      const normalizedPath = relativePath.split(path.sep).join("/"); // Ensure forward slashes for URLs
+
+      return {
+        path: normalizedPath,
+        filePath,
+        contentType: getContentType(filePath),
+      };
+    });
+
+    // Get current timestamp
+    const now = Date.now();
+
+    // Construct the output
+    return this({
+      id,
+      type: "assets",
+      path: props.path,
+      files,
+      createdAt: this.output?.createdAt || now,
+      updatedAt: now,
+    });
+  }
+);
+
+// Helper functions for file operations
+async function getFilesRecursively(dir: string): Promise<string[]> {
+  const files = await fs.readdir(dir, { withFileTypes: true });
+
+  const allFiles = await Promise.all(
+    files.map(async (file) => {
+      const path = `${dir}/${file.name}`;
+      if (file.isDirectory()) {
+        return getFilesRecursively(path);
+      }
+      return path;
+    })
+  );
+
+  return allFiles.flat();
+}

package/src/cloudflare/bindings.ts

@@ -4,6 +4,7 @@
  * https://developers.cloudflare.com/api/resources/workers/subresources/scripts/methods/update/
  */
 import type { Secret } from "../secret";
+import type { Assets } from "./assets";
 import type { R2Bucket } from "./bucket";
 import type { DurableObjectNamespace } from "./durable-object-namespace";
 import type { KVNamespace } from "./kv-namespace";
@@ -22,16 +23,24 @@ export type Binding =
   | Worker
   | R2Bucket
   | Secret
-  | string;
+  | string
+  | Assets;
 
 export function isDurableObjectNamespace(
-  binding: Binding,
+  binding: Binding
 ): binding is DurableObjectNamespace {
   return (
     typeof binding === "object" && binding.type === "durable_object_namespace"
   );
 }
 
+/**
+ * Check if a binding is an Assets resource
+ */
+export function isAssets(binding: Binding): binding is Assets {
+  return typeof binding === "object" && binding.type === "assets";
+}
+
 /**
  * Union type for all Worker binding types (API spec)
  */

package/src/cloudflare/bound.ts

@@ -1,4 +1,5 @@
 import type { Secret } from "../secret";
+import type { Assets } from "./assets";
 import type { Binding } from "./bindings";
 import type { R2Bucket as _R2Bucket } from "./bucket";
 import type { DurableObjectNamespace as _DurableObjectNamespace } from "./durable-object-namespace";
@@ -15,4 +16,6 @@ export type Bound<T extends Binding> = T extends _DurableObjectNamespace
         ? R2Bucket
         : T extends Secret
           ? string
-          : never;
+          : T extends Assets
+            ? Service
+            : Service;

package/src/cloudflare/custom-domain.ts

@@ -64,8 +64,7 @@ export interface CustomDomain
 
 /**
  * Configure custom domain for a Cloudflare Worker using the Cloudflare Custom Domains API
- * This attaches a worker (either a standard Worker or the one backing a StaticSite)
- * to a specific hostname within a zone.
+ * This attaches a worker to a specific hostname within a zone.
  *
  * @example
  * // Bind a domain to a standard Cloudflare Worker
@@ -80,19 +79,6 @@ export interface CustomDomain
  *   workerName: apiWorker.name // Use the name from the Worker resource
  * });
  *
- * @example
- * // Bind a domain to a Cloudflare Static Site
- * const mySite = await StaticSite("landing-page", {
- *   name: "my-landing-page-site", // This becomes the underlying worker name
- *   dir: "./dist/landing-page"
- * });
- *
- * const siteDomain = await CustomDomain("site-domain-binding", {
- *   name: "www.example.com",
- *   zoneId: "YOUR_ZONE_ID", // Replace with actual Zone ID
- *   workerName: mySite.name // Use the name from the StaticSite resource
- * });
- *
  * @see https://developers.cloudflare.com/api/resources/workers/subresources/domains/
  */
 export const CustomDomain = Resource(

package/src/cloudflare/index.ts

@@ -1,5 +1,6 @@
 export * from "./account-api-token";
 export * from "./api";
+export * from "./assets";
 export * from "./bindings";
 export * from "./bucket";
 export * from "./custom-domain";
@@ -8,7 +9,6 @@ export * from "./durable-object-namespace";
 export * from "./kv-namespace";
 export * from "./permission-groups";
 export * from "./r2-rest-state-store";
-export * from "./static-site";
 export * from "./worker";
 export * from "./wrangler.json";
 export * from "./zone";

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

@@ -123,16 +123,30 @@ export class R2RestStateStore implements StateStore {
       }
 
       const listPath = `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects?${params.toString()}`;
-      const response = await this.api.get(listPath);
-
-      if (!response.ok) {
-        const errorData: any = await response.json().catch(() => ({
-          errors: [{ message: response.statusText }],
-        }));
-        throw new Error(
-          `Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`
-        );
-      }
+
+      const response = await withExponentialBackoff(
+        async () => {
+          const response = await this.api.get(listPath);
+
+          if (!response.ok) {
+            const errorData: any = await response.json().catch(() => ({
+              errors: [{ message: response.statusText }],
+            }));
+            throw new Error(
+              `Error listing R2 objects: ${errorData.errors?.[0]?.message || response.statusText}`
+            );
+          }
+
+          return response;
+        },
+        // Retry on transient errors
+        (error) =>
+          error.message?.includes("502") ||
+          error.message?.includes("503") ||
+          error.message?.includes("timeout"),
+        5, // 5 retry attempts
+        1000 // Start with 1 second delay
+      );
 
       const data = (await response.json()) as any;
 
@@ -176,21 +190,38 @@ export class R2RestStateStore implements StateStore {
     await this.ensureInitialized();
 
     try {
-      const response = await this.api.get(
-        `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
-      );
+      const response = await withExponentialBackoff(
+        async () => {
+          const response = await this.api.get(
+            `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
+          );
 
-      if (!response.ok) {
-        if (response.status === 404) {
-          return undefined;
-        }
+          if (!response.ok) {
+            if (response.status === 404) {
+              return response;
+            }
+
+            const errorData: any = await response.json().catch(() => ({
+              errors: [{ message: response.statusText }],
+            }));
+            throw new Error(
+              `Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`
+            );
+          }
 
-        const errorData: any = await response.json().catch(() => ({
-          errors: [{ message: response.statusText }],
-        }));
-        throw new Error(
-          `Error getting R2 object: ${errorData.errors?.[0]?.message || response.statusText}`
-        );
+          return response;
+        },
+        // Retry on transient errors
+        (error) =>
+          error.message?.includes("502") ||
+          error.message?.includes("503") ||
+          error.message?.includes("timeout"),
+        5, // 5 retry attempts
+        1000 // Start with 1 second delay
+      );
+
+      if (response.status === 404) {
+        return undefined;
       }
 
       // Parse and deserialize the state data
@@ -298,18 +329,31 @@ export class R2RestStateStore implements StateStore {
   async delete(key: string): Promise<void> {
     await this.ensureInitialized();
 
-    const response = await this.api.delete(
-      `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
-    );
+    await withExponentialBackoff(
+      async () => {
+        const response = await this.api.delete(
+          `/accounts/${this.api.accountId}/r2/buckets/${this.bucketName}/objects/${this.getObjectKey(key)}`
+        );
 
-    if (!response.ok && response.status !== 404) {
-      const errorData: any = await response.json().catch(() => ({
-        errors: [{ message: response.statusText }],
-      }));
-      throw new Error(
-        `Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`
-      );
-    }
+        if (!response.ok && response.status !== 404) {
+          const errorData: any = await response.json().catch(() => ({
+            errors: [{ message: response.statusText }],
+          }));
+          throw new Error(
+            `Error deleting from R2: ${errorData.errors?.[0]?.message || response.statusText}`
+          );
+        }
+
+        return response;
+      },
+      // Retry on transient errors
+      (error) =>
+        error.message?.includes("502") ||
+        error.message?.includes("503") ||
+        error.message?.includes("timeout"),
+      5, // 5 retry attempts
+      1000 // Start with 1 second delay
+    );
   }
 
   /**