alchemy 0.63.1 → 0.64.0

package/src/cloudflare/wrangler.json.ts

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { Scope } from "../scope.ts";
 import { isSecret } from "../secret.ts";
 import { assertNever } from "../util/assert-never.ts";
 import {
@@ -9,6 +10,7 @@ import {
   type Bindings,
   type WorkerBindingRateLimit,
 } from "./bindings.ts";
+import type { R2BucketJurisdiction } from "./bucket.ts";
 import type { DurableObjectNamespace } from "./durable-object-namespace.ts";
 import type { EventSource } from "./event-source.ts";
 import { isQueueEventSource } from "./event-source.ts";
@@ -86,9 +88,7 @@ export interface WranglerJsonProps {
 /**
  * Output returned after WranglerJson creation/update
  */
-export interface WranglerJson
-  extends Resource<"cloudflare::WranglerJson">,
-    WranglerJsonProps {
+export interface WranglerJson extends WranglerJsonProps {
   /**
    * Time at which the file was created
    */
@@ -110,128 +110,123 @@ export interface WranglerJson
   spec: WranglerJsonSpec;
 }
 
+// we are deprecating the WranglerJson resource (it is now just a funciton)
+// but, a user may still have a resource that depends on it, so we register a no-op dummy resource so that it can be cleanly delted
+Resource("cloudflare::WranglerJson", async function (this: Context<any>) {
+  if (this.phase === "delete") {
+    return this.destroy();
+  }
+
+  throw new Error("Not implemented");
+});
+
 /**
  * Resource for managing wrangler.json configuration files
  */
-export const WranglerJson = Resource(
-  "cloudflare::WranglerJson",
-  {
-    alwaysUpdate: true,
-  },
-  async function (
-    this: Context<WranglerJson>,
-    _id: string,
-    props: WranglerJsonProps,
-  ): Promise<WranglerJson> {
-    if (this.phase === "delete") {
-      return this.destroy();
-    }
+export async function WranglerJson(
+  props: WranglerJsonProps,
+): Promise<WranglerJson> {
+  const cwd = props.worker.cwd ? path.resolve(props.worker.cwd) : process.cwd();
 
-    const cwd = props.worker.cwd
-      ? path.resolve(props.worker.cwd)
-      : process.cwd();
-
-    const toAbsolute = <T extends string | undefined>(input: T): T => {
-      return (input ? path.resolve(cwd, input) : undefined) as T;
-    };
+  const toAbsolute = <T extends string | undefined>(input: T): T => {
+    return (input ? path.resolve(cwd, input) : undefined) as T;
+  };
 
-    const main = toAbsolute(props.main ?? props.worker.entrypoint);
-    let filePath = toAbsolute(props.path ?? cwd);
-    if (!path.basename(filePath).match(".json")) {
-      filePath = path.join(filePath, props.name ?? "wrangler.jsonc");
-    }
+  const main = toAbsolute(props.main ?? props.worker.entrypoint);
+  let filePath = toAbsolute(props.path ?? cwd);
+  if (!path.basename(filePath).match(".json")) {
+    filePath = path.join(filePath, props.name ?? "wrangler.jsonc");
+  }
 
-    const dirname = path.dirname(filePath);
+  const dirname = path.dirname(filePath);
 
-    if (!main) {
-      throw new Error(
-        "Worker must have an entrypoint to generate a wrangler.json",
-      );
-    }
+  if (!main) {
+    throw new Error(
+      "Worker must have an entrypoint to generate a wrangler.json",
+    );
+  }
 
-    const worker = props.worker;
-
-    const spec: WranglerJsonSpec = {
-      name: worker.name,
-      // Use entrypoint as main if it exists
-      main: path.relative(dirname, main),
-      // see: https://developers.cloudflare.com/workers/configuration/compatibility-dates/
-      compatibility_date: worker.compatibilityDate,
-      compatibility_flags: props.worker.compatibilityFlags,
-      assets: props.assets
-        ? {
-            directory: toAbsolute(props.assets.directory),
-            binding: props.assets.binding,
-            not_found_handling: props.worker.assets?.not_found_handling,
-            html_handling: props.worker.assets?.html_handling,
-            run_worker_first: props.worker.assets?.run_worker_first,
-          }
-        : undefined,
-      placement: worker.placement,
-      limits: worker.limits,
-    };
+  const worker = props.worker;
+
+  const spec: WranglerJsonSpec = {
+    name: worker.name,
+    // Use entrypoint as main if it exists
+    main: path.relative(dirname, main),
+    // see: https://developers.cloudflare.com/workers/configuration/compatibility-dates/
+    compatibility_date: worker.compatibilityDate,
+    compatibility_flags: props.worker.compatibilityFlags,
+    assets: props.assets
+      ? {
+          directory: toAbsolute(props.assets.directory),
+          binding: props.assets.binding,
+          not_found_handling: props.worker.assets?.not_found_handling,
+          html_handling: props.worker.assets?.html_handling,
+          run_worker_first: props.worker.assets?.run_worker_first,
+        }
+      : undefined,
+    placement: worker.placement,
+    limits: worker.limits,
+  };
 
-    // Process bindings if they exist
-    if (worker.bindings) {
-      processBindings(
-        spec,
-        worker.bindings,
-        worker.eventSources,
-        worker.name,
-        cwd,
-        props.secrets ?? false,
-        this.scope.local && !props.worker.dev?.remote,
-      );
-    }
+  // Process bindings if they exist
+  if (worker.bindings) {
+    processBindings(
+      spec,
+      worker.bindings,
+      worker.eventSources,
+      worker.name,
+      cwd,
+      props.secrets ?? false,
+      Scope.current.local && !props.worker.dev?.remote,
+    );
+  }
 
-    // Add environment variables as vars
-    if (worker.env) {
-      spec.vars = { ...worker.env };
-    }
+  // Add environment variables as vars
+  if (worker.env) {
+    spec.vars = { ...worker.env };
+  }
 
-    if (worker.crons && worker.crons.length > 0) {
-      spec.triggers = { crons: worker.crons };
-    }
+  if (worker.crons && worker.crons.length > 0) {
+    spec.triggers = { crons: worker.crons };
+  }
 
-    if (spec.assets) {
-      spec.assets.directory = path.relative(dirname, spec.assets.directory);
-    }
+  if (spec.assets) {
+    spec.assets.directory = path.relative(dirname, spec.assets.directory);
+  }
 
-    // Apply the wrangler configuration hook as the final transformation
-    const finalSpec = props.transform?.wrangler
-      ? await props.transform.wrangler(spec)
-      : spec;
-
-    await fs.mkdir(dirname, { recursive: true });
-    if (props.secrets) {
-      // If secrets are enabled, decrypt them in the wrangler.json file,
-      // but do not modify `finalSpec` so that way secrets aren't written to state unencrypted.
-      const withSecretsUnwrapped = {
-        ...finalSpec,
-        vars: {
-          ...finalSpec.vars,
-          ...Object.fromEntries(
-            Object.entries(finalSpec.vars ?? {}).map(([key, value]) =>
-              isSecret(value) ? [key, value.unencrypted] : [key, value],
-            ),
+  // Apply the wrangler configuration hook as the final transformation
+  const finalSpec = props.transform?.wrangler
+    ? await props.transform.wrangler(spec)
+    : spec;
+
+  await fs.mkdir(dirname, { recursive: true });
+  if (props.secrets) {
+    // If secrets are enabled, decrypt them in the wrangler.json file,
+    // but do not modify `finalSpec` so that way secrets aren't written to state unencrypted.
+    const withSecretsUnwrapped = {
+      ...finalSpec,
+      vars: {
+        ...finalSpec.vars,
+        ...Object.fromEntries(
+          Object.entries(finalSpec.vars ?? {}).map(([key, value]) =>
+            isSecret(value) ? [key, value.unencrypted] : [key, value],
           ),
-        },
-      };
-      await writeJSON(filePath, withSecretsUnwrapped);
-    } else {
-      await writeJSON(filePath, finalSpec);
-    }
+        ),
+      },
+    };
+    await writeJSON(filePath, withSecretsUnwrapped);
+  } else {
+    await writeJSON(filePath, finalSpec);
+  }
 
-    // Return the resource
-    return this({
-      ...props,
-      path: path.relative(cwd, filePath),
-      spec: finalSpec,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    });
-  },
-);
+  return {
+    ...props,
+    path: path.relative(cwd, filePath),
+    spec: finalSpec,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  };
+}
 
 const writeJSON = async (filePath: string, content: any) => {
   await fs.writeFile(filePath, `${JSON.stringify(content, null, 2)}\n`);
@@ -537,6 +532,7 @@ function processBindings(
     binding: string;
     bucket_name: string;
     preview_bucket_name: string;
+    jurisdiction?: R2BucketJurisdiction;
   }[] = [];
   const services: { binding: string; service: string; environment?: string }[] =
     [];
@@ -683,6 +679,8 @@ function processBindings(
         binding: bindingName,
         bucket_name: name,
         preview_bucket_name: name,
+        jurisdiction:
+          binding.jurisdiction === "default" ? undefined : binding.jurisdiction,
         ...(binding.dev?.remote ? { experimental_remote: true } : {}),
       });
     } else if (binding.type === "secret") {

package/src/context.ts

@@ -65,8 +65,10 @@ export interface BaseContext<Out extends Resource> {
    *
    * It is so that the resource lifecycle handler can "return never" instead of
    * "return undefined" so that `await MyResource()` always returns a value.
+   *
+   * @param retainChildren - Whether to retain the children of the resource.
    */
-  destroy(): never;
+  destroy(retainChildren?: boolean): never;
   /**
    * Register a cleanup function that will be called when the process exits.
    *
@@ -161,8 +163,8 @@ export function context<
       return value;
     },
     quiet: scope.quiet,
-    destroy: () => {
-      throw new DestroyedSignal();
+    destroy: (retainChildren = false) => {
+      throw new DestroyedSignal(retainChildren);
     },
     onCleanup: (fn: () => void | Promise<void>) => {
       // make the function idempotent so repeated calls don't cause the process to hang

package/src/destroy.ts

@@ -15,7 +15,16 @@ import type { State } from "./state.ts";
 import { formatFQN } from "./util/cli.ts";
 import { logger } from "./util/logger.ts";
 
-export class DestroyedSignal extends Error {}
+export function isDestroyedSignal(error: any): error is DestroyedSignal {
+  return error instanceof Error && (error as any).kind === "DestroyedSignal";
+}
+
+export class DestroyedSignal extends Error {
+  readonly kind = "DestroyedSignal";
+  constructor(public readonly noop: boolean) {
+    super();
+  }
+}
 
 export type DestroyStrategy = "sequential" | "parallel";
 
@@ -28,6 +37,10 @@ export interface DestroyOptions {
     props?: ResourceProps | undefined;
     output?: Resource<string>;
   };
+  /**
+   * If true, children of the resource will not be destroyed (but their state will be deleted).
+   */
+  noop?: boolean;
 }
 
 function isScopeArgs(a: any): a is [scope: Scope, options?: DestroyOptions] {
@@ -98,7 +111,7 @@ export async function destroy<Type extends string>(
   const quiet = options?.quiet ?? scope.quiet;
 
   try {
-    if (!quiet) {
+    if (!quiet && !options?.noop) {
       logger.task(instance[ResourceFQN], {
         prefix: options?.replace ? "cleanup" : "deleting",
         prefixColor: options?.replace ? "magenta" : "redBright",
@@ -149,6 +162,8 @@ export async function destroy<Type extends string>(
     });
 
     let nestedScope: Scope | undefined;
+    let noop = options?.noop ?? false;
+
     try {
       // BUG: this does not restore persisted scope
       await alchemy.run(
@@ -158,17 +173,19 @@ export async function destroy<Type extends string>(
           isResource: instance[ResourceKind] !== "alchemy::Scope",
           parent: scope,
           destroyStrategy: instance[DestroyStrategy] ?? "sequential",
+          noop,
         },
         async (scope) => {
           nestedScope = options?.replace?.props == null ? scope : undefined;
-          return await Provider.handler.bind(ctx)(
-            instance[ResourceID],
-            ctx.props,
-          );
+          if (noop) {
+            return ctx.destroy(noop);
+          }
+          return Provider.handler.bind(ctx)(instance[ResourceID], ctx.props);
         },
       );
     } catch (err) {
-      if (err instanceof DestroyedSignal) {
+      if (isDestroyedSignal(err)) {
+        noop = noop || err.noop;
         // TODO: should we fail if the DestroyedSignal is not thrown?
       } else {
         throw err;
@@ -178,6 +195,7 @@ export async function destroy<Type extends string>(
     if (nestedScope) {
       await destroy(nestedScope, {
         ...options,
+        noop,
         strategy: instance[DestroyStrategy] ?? "sequential",
       });
     }
@@ -195,7 +213,7 @@ export async function destroy<Type extends string>(
       await scope.set("pendingDeletions", pendingDeletions);
     }
 
-    if (!quiet) {
+    if (!quiet && !options?.noop) {
       logger.task(instance[ResourceFQN], {
         prefix: options?.replace ? "cleaned" : "deleted",
         prefixColor: "greenBright",