alchemy 0.2.0 → 0.2.1

package/src/apply.ts

@@ -21,110 +21,116 @@ export async function apply<Out extends Resource>(
   options?: ApplyOptions,
 ): Promise<Awaited<Out>> {
   const scope = resource.Scope;
-  const quiet = props.quiet ?? scope.quiet;
-  await scope.init();
-  let state: State | undefined = (await scope.state.get(resource.ID))!;
-  const provider: Provider = PROVIDERS.get(resource.Kind);
-  if (provider === undefined) {
-    throw new Error(`Provider "${resource.Kind}" not found`);
-  }
-  if (state === undefined) {
-    state = {
-      kind: resource.Kind,
-      id: resource.ID,
-      fqn: resource.FQN,
-      seq: resource.Seq,
-      status: "creating",
-      data: {},
-      output: {
-        ID: resource.ID,
-        FQN: resource.FQN,
-        Kind: resource.Kind,
-        Scope: scope,
-        Seq: resource.Seq,
-      },
-      // deps: [...deps],
-      props,
-    };
-    await scope.state.set(resource.ID, state);
-  }
+  try {
+    const quiet = props.quiet ?? scope.quiet;
+    await scope.init();
+    let state: State | undefined = (await scope.state.get(resource.ID))!;
+    const provider: Provider = PROVIDERS.get(resource.Kind);
+    if (provider === undefined) {
+      throw new Error(`Provider "${resource.Kind}" not found`);
+    }
+    if (state === undefined) {
+      state = {
+        kind: resource.Kind,
+        id: resource.ID,
+        fqn: resource.FQN,
+        seq: resource.Seq,
+        status: "creating",
+        data: {},
+        output: {
+          ID: resource.ID,
+          FQN: resource.FQN,
+          Kind: resource.Kind,
+          Scope: scope,
+          Seq: resource.Seq,
+        },
+        // deps: [...deps],
+        props,
+      };
+      await scope.state.set(resource.ID, state);
+    }
 
-  const alwaysUpdate =
-    options?.alwaysUpdate ?? provider.options?.alwaysUpdate ?? false;
+    const alwaysUpdate =
+      options?.alwaysUpdate ?? provider.options?.alwaysUpdate ?? false;
 
-  // Skip update if inputs haven't changed and resource is in a stable state
-  if (state.status === "created" || state.status === "updated") {
-    if (
-      JSON.stringify(state.props) === JSON.stringify(serialize(scope, props)) &&
-      alwaysUpdate !== true
-    ) {
-      if (!quiet) {
-        console.log(`Skip:    "${resource.FQN}" (no changes)`);
+    // Skip update if inputs haven't changed and resource is in a stable state
+    if (state.status === "created" || state.status === "updated") {
+      if (
+        JSON.stringify(state.props) ===
+          JSON.stringify(await serialize(scope, props)) &&
+        alwaysUpdate !== true
+      ) {
+        if (!quiet) {
+          console.log(`Skip:    "${resource.FQN}" (no changes)`);
+        }
+        // if (resourceState.output !== undefined) {
+        //   resource[Provide](resourceState.output);
+        // }
+        return state.output as Awaited<Out>;
       }
-      // if (resourceState.output !== undefined) {
-      //   resource[Provide](resourceState.output);
-      // }
-      return state.output as Awaited<Out>;
     }
-  }
 
-  const phase = state.status === "creating" ? "create" : "update";
-  state.status = phase === "create" ? "creating" : "updating";
-  state.oldProps = state.props;
-  state.props = props;
+    const phase = state.status === "creating" ? "create" : "update";
+    state.status = phase === "create" ? "creating" : "updating";
+    state.oldProps = state.props;
+    state.props = props;
 
-  if (!quiet) {
-    console.log(
-      `${phase === "create" ? "Create" : "Update"}:  "${resource.FQN}"`,
-    );
-  }
+    if (!quiet) {
+      console.log(
+        `${phase === "create" ? "Create" : "Update"}:  "${resource.FQN}"`,
+      );
+    }
 
-  await scope.state.set(resource.ID, state);
+    await scope.state.set(resource.ID, state);
 
-  let isReplaced = false;
+    let isReplaced = false;
 
-  const ctx = context({
-    scope,
-    phase,
-    kind: resource.Kind,
-    id: resource.ID,
-    fqn: resource.FQN,
-    seq: resource.Seq,
-    state,
-    replace: () => {
-      if (isReplaced) {
-        console.warn(
-          `Resource ${resource.Kind} ${resource.FQN} is already marked as REPLACE`,
-        );
-        return;
-      }
-      isReplaced = true;
-    },
-  });
+    const ctx = context({
+      scope,
+      phase,
+      kind: resource.Kind,
+      id: resource.ID,
+      fqn: resource.FQN,
+      seq: resource.Seq,
+      state,
+      replace: () => {
+        if (isReplaced) {
+          console.warn(
+            `Resource ${resource.Kind} ${resource.FQN} is already marked as REPLACE`,
+          );
+          return;
+        }
+        isReplaced = true;
+      },
+    });
 
-  const output = await alchemy.run(resource.ID, async () =>
-    provider.handler.bind(ctx)(resource.ID, props),
-  );
+    const output = await alchemy.run(resource.ID, async () => {
+      return provider.handler.bind(ctx)(resource.ID, props);
+    });
 
-  if (!quiet) {
-    console.log(
-      `${phase === "create" ? "Created" : "Updated"}: "${resource.FQN}"`,
-    );
-  }
+    if (!quiet) {
+      console.log(
+        `${phase === "create" ? "Created" : "Updated"}: "${resource.FQN}"`,
+      );
+    }
 
-  await scope.state.set(resource.ID, {
-    kind: resource.Kind,
-    id: resource.ID,
-    fqn: resource.FQN,
-    seq: resource.Seq,
-    data: state.data,
-    status: phase === "create" ? "created" : "updated",
-    output,
-    props,
-    // deps: [...deps],
-  });
-  // if (output !== undefined) {
-  //   resource[Provide](output as Out);
-  // }
-  return output as any;
+    await scope.state.set(resource.ID, {
+      kind: resource.Kind,
+      id: resource.ID,
+      fqn: resource.FQN,
+      seq: resource.Seq,
+      data: state.data,
+      status: phase === "create" ? "created" : "updated",
+      output,
+      props,
+      // deps: [...deps],
+    });
+    // if (output !== undefined) {
+    //   resource[Provide](output as Out);
+    // }
+    return output as any;
+  } catch (error) {
+    scope.fail();
+    throw error;
+  }
 }

package/src/cloudflare/index.ts

@@ -5,3 +5,5 @@ export * from "./kv-namespace";
 export * from "./state";
 export * from "./static-site";
 export * from "./worker";
+export * from "./wrangler.json";
+export * from "./zone";

package/src/cloudflare/static-site.ts

@@ -230,17 +230,6 @@ export const StaticSite = 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 {
@@ -266,6 +255,17 @@ export const StaticSite = 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";

package/src/cloudflare/worker.ts

@@ -528,7 +528,7 @@ async function assertWorkerDoesNotExist<B extends Bindings>(
     );
   } else {
     throw new Error(
-      `Error checking if worker exists: ${response.status} ${response.statusText}`,
+      `Error checking if worker exists: ${response.status} ${response.statusText} ${await response.text()}`,
     );
   }
 }

package/src/cloudflare/wrangler.json.ts

@@ -0,0 +1,309 @@
+import * as fs from "fs/promises";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+
+/**
+ * Properties for wrangler.json configuration file
+ */
+export interface WranglerJsonProps {
+  /**
+   * The name of your worker
+   */
+  name: string;
+
+  /**
+   * The directory containing your worker entry point
+   * @default "src"
+   */
+  main?: string;
+
+  /**
+   * The entry point for your worker
+   * @default "index.ts" or "index.js"
+   */
+  entrypoint?: string;
+
+  /**
+   * The directory to store build artifacts
+   * @default "dist"
+   */
+  outdir?: string;
+
+  /**
+   * The directory to serve static assets from
+   */
+  assets?: string;
+
+  /**
+   * Minify the worker script
+   * @default true
+   */
+  minify?: boolean;
+
+  /**
+   * Node.js compatibility mode
+   * @default false
+   */
+  node_compat?: boolean;
+
+  /**
+   * First-party worker service bindings
+   */
+  services?: Array<{
+    /**
+     * Binding name
+     */
+    name: string;
+    /**
+     * Service environment
+     */
+    environment?: string;
+  }>;
+
+  /**
+   * Worker environment variables
+   */
+  vars?: Record<string, string>;
+
+  /**
+   * KV Namespace bindings
+   */
+  kv_namespaces?: Array<{
+    /**
+     * Binding name
+     */
+    binding: string;
+    /**
+     * KV namespace ID
+     */
+    id: string;
+    /**
+     * Preview KV namespace ID
+     */
+    preview_id?: string;
+  }>;
+
+  /**
+   * R2 bucket bindings
+   */
+  r2_buckets?: Array<{
+    /**
+     * Binding name
+     */
+    binding: string;
+    /**
+     * Bucket name
+     */
+    bucket_name: string;
+    /**
+     * Preview bucket name
+     */
+    preview_bucket_name?: string;
+  }>;
+
+  /**
+   * D1 database bindings
+   */
+  d1_databases?: Array<{
+    /**
+     * Binding name
+     */
+    binding: string;
+    /**
+     * Database name
+     */
+    database_name: string;
+    /**
+     * Database ID
+     */
+    database_id: string;
+    /**
+     * Preview database ID
+     */
+    preview_database_id?: string;
+  }>;
+
+  /**
+   * Durable Object bindings
+   */
+  durable_objects?: {
+    /**
+     * Durable Object bindings
+     */
+    bindings: Array<{
+      /**
+       * Binding name
+       */
+      name: string;
+      /**
+       * Class name
+       */
+      class_name: string;
+      /**
+       * Script name
+       */
+      script_name?: string;
+      /**
+       * Environment name
+       */
+      environment?: string;
+    }>;
+  };
+
+  /**
+   * Queue bindings
+   */
+  queues?: {
+    /**
+     * Producer bindings
+     */
+    producers?: Array<{
+      /**
+       * Binding name
+       */
+      binding: string;
+      /**
+       * Queue name
+       */
+      queue: string;
+    }>;
+    /**
+     * Consumer configuration
+     */
+    consumers?: Array<{
+      /**
+       * Queue name
+       */
+      queue: string;
+      /**
+       * Maximum batch size
+       */
+      max_batch_size?: number;
+      /**
+       * Maximum batch timeout
+       */
+      max_batch_timeout?: number;
+      /**
+       * Maximum retries
+       */
+      max_retries?: number;
+      /**
+       * Dead letter queue
+       */
+      dead_letter_queue?: string;
+    }>;
+  };
+
+  /**
+   * Analytics Engine bindings
+   */
+  analytics_engine_datasets?: Array<{
+    /**
+     * Binding name
+     */
+    binding: string;
+    /**
+     * Dataset name
+     */
+    dataset?: string;
+  }>;
+
+  /**
+   * Route configuration
+   */
+  routes?: Array<string>;
+
+  /**
+   * Triggers configuration
+   */
+  triggers?: {
+    /**
+     * Cron triggers
+     */
+    crons: Array<string>;
+  };
+
+  /**
+   * Worker compatibility date
+   */
+  compatibility_date?: string;
+
+  /**
+   * Worker compatibility flags
+   */
+  compatibility_flags?: Array<string>;
+
+  /**
+   * Worker usage model
+   * "bundled" - Includes resources like CPU and memory. Better for consistent workloads.
+   * "unbound" - Pay only for what you use. Better for sporadic workloads.
+   */
+  usage_model?: "bundled" | "unbound";
+
+  /**
+   * Path to the wrangler.json file
+   * @internal
+   */
+  path?: string;
+}
+
+/**
+ * Output returned after WranglerJson creation/update
+ */
+export interface WranglerJson
+  extends Resource<"cloudflare::WranglerJson">,
+    WranglerJsonProps {
+  /**
+   * Time at which the file was created
+   */
+  createdAt: number;
+
+  /**
+   * Time at which the file was last updated
+   */
+  updatedAt: number;
+}
+
+/**
+ * Resource for managing wrangler.json configuration files
+ */
+export const WranglerJson = Resource(
+  "cloudflare::WranglerJson",
+  async function (
+    this: Context<WranglerJson>,
+    id: string,
+    props: WranglerJsonProps,
+  ): Promise<WranglerJson> {
+    // Default path is wrangler.json in current directory
+    const filePath = props.path || "wrangler.json";
+
+    if (this.phase === "delete") {
+      try {
+        await fs.unlink(filePath);
+      } catch (error) {
+        // Ignore errors if file doesn't exist
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+          throw error;
+        }
+      }
+      return this.destroy();
+    }
+
+    // Create or update the file
+    const config = {
+      ...props,
+      // Remove internal path property
+      path: undefined,
+    };
+
+    // Write the file
+    await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+
+    // Return the resource
+    return this({
+      ...props,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+  },
+);