alchemy 0.1.18 → 0.2.1

package/src/cloudflare/kv-namespace.ts

@@ -1,8 +1,14 @@
-import type { Resolved } from "../output";
-import { type Context, Resource } from "../resource";
-import { withExponentialBackoff } from "../utils/retry";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { withExponentialBackoff } from "../util/retry";
 import { createCloudflareApi } from "./api";
 
+export function isKVNamespace(resource: any): resource is KVNamespace {
+  return (
+    resource && typeof resource === "object" && resource.type === "kv_namespace"
+  );
+}
+
 /**
  * Properties for creating or updating a KV Namespace
  */
@@ -52,12 +58,14 @@ export interface KVPair {
 /**
  * Output returned after KV Namespace creation/update
  */
-export interface KVNamespaceOutput extends KVNamespaceProps {
+export interface KVNamespace
+  extends Resource<"cloudflare::KVNamespace">,
+    KVNamespaceProps {
   type: "kv_namespace";
   /**
    * The ID of the namespace
    */
-  id: string;
+  namespaceId: string;
 
   /**
    * Time at which the namespace was created
@@ -70,23 +78,19 @@ export interface KVNamespaceOutput extends KVNamespaceProps {
   modifiedAt: number;
 }
 
-export function isKVNamespace(
-  resource: any,
-): resource is Resolved<KVNamespace> {
-  return (
-    resource && typeof resource === "object" && resource.type === "kv_namespace"
-  );
-}
-
-export class KVNamespace extends Resource(
+export const KVNamespace = Resource(
   "cloudflare::KVNamespace",
-  async (ctx: Context<KVNamespaceOutput>, props: KVNamespaceProps) => {
+  async function (
+    this: Context<KVNamespace>,
+    id: string,
+    props: KVNamespaceProps,
+  ) {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi();
 
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
       // For delete operations, we need to check if the namespace ID exists in the output
-      const namespaceId = ctx.output?.id;
+      const namespaceId = this.output?.namespaceId;
       if (namespaceId) {
         // Delete KV namespace
         const deleteResponse = await api.delete(
@@ -104,19 +108,22 @@ export class KVNamespace extends Resource(
       }
 
       // Return minimal output for deleted state
-      return;
+      return this.destroy();
     } else {
       // For create or update operations
-      // If ctx.event is "update", we expect ctx.output to exist
-      let namespaceId = ctx.event === "update" ? ctx.output?.id || "" : "";
+      // If this.phase is "update", we expect this.output to exist
+      let namespaceId =
+        this.phase === "update" ? this.output?.namespaceId || "" : "";
       let createdAt =
-        ctx.event === "update"
-          ? ctx.output?.createdAt || Date.now()
+        this.phase === "update"
+          ? this.output?.createdAt || Date.now()
           : Date.now();
 
-      if (ctx.event === "update" && namespaceId) {
+      if (this.phase === "update" && namespaceId) {
         // Can't update a KV namespace title directly, just work with existing ID
       } else {
+        // TODO: if it already exists, then check the tags to see if we own it and continue
+
         // Create new KV namespace
         const createResponse = await api.post(
           `/accounts/${api.accountId}/storage/kv/namespaces`,
@@ -207,19 +214,14 @@ export class KVNamespace extends Resource(
         }
       }
 
-      const now = Date.now();
-
-      // Construct the output
-      const output: KVNamespaceOutput = {
+      return this({
         type: "kv_namespace",
-        id: namespaceId,
+        namespaceId: namespaceId,
         title: props.title,
         values: props.values,
         createdAt: createdAt,
-        modifiedAt: now,
-      };
-
-      return output;
+        modifiedAt: Date.now(),
+      });
     }
   },
-) {}
+);

package/src/cloudflare/static-site-router.ts

@@ -34,14 +34,12 @@ export default {
       isInit = true;
       for (const [key, value] of Object.entries(env)) {
         if (key.startsWith("ROUTE_")) {
-          console.log(key, value);
           const service = value as Service;
           const patternKey = `__${key}`;
           if (!(patternKey in env)) {
             throw new Error(`Missing pattern key: ${patternKey}`);
           }
           const pattern = (env as any)[`__${key}`];
-          console.log("pattern", pattern);
           // TODO(sam): we should support narrowing down METHOD
           app.all(pattern, (ctx) => service.fetch(ctx.req.raw));
         }
@@ -53,7 +51,6 @@ export default {
 
 // fall back to assuming the request is a static file
 app.notFound(async (ctx) => {
-  console.log("not found");
   const request = ctx.req;
   const env = ctx.env;
   const url = new URL(request.url);

package/src/cloudflare/static-site.ts

@@ -2,10 +2,9 @@ import { exec } from "child_process";
 import { promises as fs } from "fs";
 import path from "path";
 import { promisify } from "util";
-import { apply } from "../apply";
-import type { BundleProps } from "../esbuild";
-import type { Input } from "../input";
-import { type Context, Resource } from "../resource";
+import type { Context } from "../context";
+import type { BundleProps } from "../esbuild/bundle";
+import { Resource } from "../resource";
 import { createCloudflareApi } from "./api";
 import type { Bindings } from "./bindings";
 import { generateAssetManifest } from "./generate-asset-manifest";
@@ -131,12 +130,7 @@ export interface StaticSiteProps {
 /**
  * Output returned after StaticSite creation/update
  */
-export interface StaticSiteOutput {
-  /**
-   * The ID of the site
-   */
-  id: string;
-
+export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
   /**
    * The ID of the worker
    */
@@ -208,16 +202,20 @@ export interface StaticSiteOutput {
   routes?: Record<string, string>;
 }
 
-export class StaticSite extends Resource(
+export const StaticSite = Resource(
   "cloudflare::StaticSite",
   {
     alwaysUpdate: true,
   },
-  async (ctx: Context<StaticSiteOutput>, props: StaticSiteProps) => {
-    if (ctx.event === "delete") {
+  async function (
+    this: Context<StaticSite>,
+    id: string,
+    props: StaticSiteProps,
+  ) {
+    if (this.phase === "delete") {
       // For delete operations, we'll rely on the Worker delete to clean up
       // Return empty output for deleted state
-      return;
+      return this.destroy();
     }
 
     // Validate that a name is provided
@@ -232,21 +230,10 @@ export class StaticSite extends Resource(
       throw new Error("Directory is required for StaticSite");
     }
 
-    try {
-      const dirStat = await fs.stat(props.dir);
-      if (!dirStat.isDirectory()) {
-        throw new Error(`"${props.dir}" is not a directory`);
-      }
-    } catch (error: any) {
-      throw new Error(
-        `Directory "${props.dir}" does not exist: ${error.message}`,
-      );
-    }
-
     // Run build command if provided
     if (props.build?.command) {
       try {
-        if (!ctx.quiet) {
+        if (!this.quiet) {
           console.log(props.build.command);
         }
         const execAsync = promisify(exec);
@@ -254,7 +241,7 @@ export class StaticSite extends Resource(
           cwd: process.cwd(),
         });
 
-        if (stdout && !ctx.quiet) console.log(stdout);
+        if (stdout && !this.quiet) console.log(stdout);
       } catch (error: any) {
         // Log detailed error information
         console.error(`Build command failed with exit code ${error.code}`);
@@ -268,6 +255,17 @@ export class StaticSite extends Resource(
       }
     }
 
+    try {
+      const dirStat = await fs.stat(props.dir);
+      if (!dirStat.isDirectory()) {
+        throw new Error(`"${props.dir}" is not a directory`);
+      }
+    } catch (error: any) {
+      throw new Error(
+        `Directory "${props.dir}" does not exist: ${error.message}`,
+      );
+    }
+
     // Use the provided name
     const siteName = props.name;
     const indexPage = props.indexPage || "index.html";
@@ -276,22 +274,18 @@ export class StaticSite extends Resource(
     const api = await createCloudflareApi();
 
     // Step 1: Create or get the KV namespace for assets
-    const kv = new KVNamespace("assets", {
-      title: `${siteName}-assets`,
-    });
-
-    const [{ id: kvNamespaceId }, assetManifest] = await Promise.all([
-      apply(kv, {
-        quiet: ctx.quiet,
+    const [kv, assetManifest] = await Promise.all([
+      KVNamespace("assets", {
+        title: `${siteName}-assets`,
       }),
       generateAssetManifest(props.dir),
     ]);
 
     // Step 3: Upload assets to KV
-    await uploadAssetManifest(api, kvNamespaceId, assetManifest);
+    await uploadAssetManifest(api, kv.namespaceId, assetManifest);
 
     // Prepare the bindings for the worker
-    const bindings: Input<Bindings> = {
+    const bindings: Bindings = {
       ASSETS: kv,
       INDEX_PAGE: indexPage,
       // Add error page binding if specified
@@ -335,39 +329,31 @@ export class StaticSite extends Resource(
       // TypeScript file doesn't exist, use JavaScript (default)
     }
 
-    const worker = new Worker(
-      "worker",
-      {
-        name: siteName,
-        url: true,
-        format: props.format || "esm",
-        // If a custom worker script is provided, use it, otherwise use the entrypoint from router
-        ...(props.workerScript
-          ? { script: props.workerScript }
-          : {
-              entrypoint: path.resolve(__dirname, entrypointFile),
-              bundle: bundleOptions,
-            }),
-        bindings,
-        env: {
-          ...Object.fromEntries(
-            Object.entries(routes).map(([key, value]) => [
-              `__ROUTE_${value}`,
-              key,
-            ]),
-          ),
-        },
+    const worker = await Worker("worker", {
+      name: siteName,
+      url: true,
+      format: props.format || "esm",
+      // If a custom worker script is provided, use it, otherwise use the entrypoint from router
+      ...(props.workerScript
+        ? { script: props.workerScript }
+        : {
+            entrypoint: path.resolve(__dirname, entrypointFile),
+            bundle: bundleOptions as any,
+          }),
+      bindings,
+      env: {
+        ...Object.fromEntries(
+          Object.entries(routes).map(([key, value]) => [
+            `__ROUTE_${value}`,
+            key,
+          ]),
+        ),
       },
-      // place a dependency on the namespace
-      kv.id,
-    );
+    });
 
-    // Get current timestamp
     const now = Date.now();
 
-    // Construct the output
-    const output: Input<StaticSiteOutput> = {
-      id: siteName,
+    return this({
       workerId: worker.id,
       name: siteName,
       directory: props.dir,
@@ -375,14 +361,12 @@ export class StaticSite extends Resource(
       errorPage: props.errorPage,
       indexPage,
       assets: assetManifest.map((item) => item.key),
-      createdAt: ctx.output?.createdAt || now,
+      createdAt: this.output?.createdAt || now,
       updatedAt: now,
       domain: props.domain,
       production: props.production !== false,
-      url: worker.url as Input<string | undefined>,
+      url: worker.url,
       routes,
-    };
-
-    return output;
+    });
   },
-) {}
+);