alchemy 0.48.3 → 0.49.1

package/src/apply.ts

@@ -1,6 +1,6 @@
 import { alchemy } from "./alchemy.ts";
 import { context } from "./context.ts";
-import { destroy } from "./destroy.ts";
+import { destroy, DestroyStrategy } from "./destroy.ts";
 import {
   PROVIDERS,
   ResourceFQN,
@@ -92,6 +92,7 @@ async function _apply<Out extends Resource>(
           [ResourceKind]: resource[ResourceKind],
           [ResourceScope]: scope,
           [ResourceSeq]: resource[ResourceSeq],
+          [DestroyStrategy]: provider.options?.destroyStrategy ?? "sequential",
         },
         // deps: [...deps],
         props,
@@ -113,9 +114,14 @@ async function _apply<Out extends Resource>(
       });
       if (
         JSON.stringify(oldProps) === JSON.stringify(newProps) &&
-        alwaysUpdate !== true
+        alwaysUpdate !== true &&
+        !scope.force
       ) {
-        scope.skip();
+        const innerScope = new Scope({
+          parent: scope,
+          scopeName: resource[ResourceID],
+        });
+        innerScope.skip();
         if (!quiet) {
           logger.task(resource[ResourceFQN], {
             prefix: "skipped",
@@ -125,12 +131,7 @@ async function _apply<Out extends Resource>(
             status: "success",
           });
         }
-        options?.resolveInnerScope?.(
-          new Scope({
-            parent: scope,
-            scopeName: resource[ResourceID],
-          }),
-        );
+        options?.resolveInnerScope?.(innerScope);
         scope.telemetryClient.record({
           event: "resource.skip",
           resource: resource[ResourceKind],
@@ -174,7 +175,7 @@ async function _apply<Out extends Resource>(
       props: state.oldProps,
       state,
       isReplacement: false,
-      replace: async (force?: boolean) => {
+      replace: (force?: boolean) => {
         if (phase === "create") {
           throw new Error(
             `Resource ${resource[ResourceKind]} ${resource[ResourceFQN]} cannot be replaced in create phase.`,
@@ -186,17 +187,6 @@ async function _apply<Out extends Resource>(
           );
         }
 
-        if (force) {
-          await destroy(resource, {
-            quiet: scope.quiet,
-            strategy: "sequential",
-            replace: {
-              props: state.oldProps,
-              output: resource,
-            },
-          });
-        }
-
         isReplaced = true;
         throw new ReplacedSignal(force);
       },
@@ -209,6 +199,7 @@ async function _apply<Out extends Resource>(
         {
           isResource: true,
           parent: scope,
+          destroyStrategy: provider.options?.destroyStrategy ?? "sequential",
         },
         async (scope) => {
           options?.resolveInnerScope?.(scope);
@@ -223,6 +214,17 @@ async function _apply<Out extends Resource>(
           );
         }
 
+        if (error.force) {
+          await destroy(resource, {
+            quiet: scope.quiet,
+            strategy: resource[DestroyStrategy] ?? "sequential",
+            replace: {
+              props: state.oldProps,
+              output: resource,
+            },
+          });
+        }
+
         output = await alchemy.run(
           resource[ResourceID],
           { isResource: true, parent: scope },

package/src/aws/s3-state-store.ts

@@ -9,7 +9,7 @@ import {
 } from "@aws-sdk/client-s3";
 import { ResourceScope } from "../resource.ts";
 import type { Scope } from "../scope.ts";
-import { serialize, deserialize } from "../serde.ts";
+import { deserialize, serialize } from "../serde.ts";
 import type { State, StateStore } from "../state.ts";
 import { ignore } from "../util/ignore.ts";
 import { retry } from "./retry.ts";
@@ -55,7 +55,7 @@ export class S3StateStore implements StateStore {
    */
   constructor(
     public readonly scope: Scope,
-    private readonly options: S3StateStoreOptions = {},
+    options: S3StateStoreOptions = {},
   ) {
     // Use the scope's chain to build the prefix, similar to how FileSystemStateStore builds its directory
     const scopePath = scope.chain.join("/");

package/src/cloudflare/bindings.ts

@@ -20,6 +20,7 @@ import type { Images } from "./images.ts";
 import type { KVNamespaceResource } from "./kv-namespace.ts";
 import type { PipelineResource } from "./pipeline.ts";
 import type { QueueResource } from "./queue.ts";
+import type { RateLimit } from "./rate-limit.ts";
 import type { SecretKey } from "./secret-key.ts";
 import type { Secret as CloudflareSecret } from "./secret.ts";
 import type { VectorizeIndexResource } from "./vectorize-index.ts";
@@ -56,6 +57,7 @@ export type Binding =
   | KVNamespaceResource
   | PipelineResource
   | QueueResource
+  | RateLimit
   | R2BucketResource
   | {
       type: "kv_namespace";
@@ -108,6 +110,7 @@ export type WorkerBindingSpec =
   | WorkerBindingPipeline
   | WorkerBindingPlainText
   | WorkerBindingQueue
+  | WorkerBindingRateLimit
   | WorkerBindingR2Bucket
   | WorkerBindingSecretKey
   | WorkerBindingSecretText
@@ -284,6 +287,25 @@ export interface WorkerBindingQueue {
   queue_name: string;
 }
 
+/**
+ * Rate Limit binding type
+ */
+export interface WorkerBindingRateLimit {
+  /** The name of the binding */
+  name: string;
+  /** Type identifier for Rate Limit binding */
+  type: "ratelimit";
+  /** Namespace ID for the rate limit */
+  namespace_id: string;
+  /** Simple rate limiting configuration */
+  simple: {
+    /** Maximum number of requests */
+    limit: number;
+    /** Time period in seconds */
+    period: 60 | 10;
+  };
+}
+
 /**
  * R2 Bucket binding type
  */

package/src/cloudflare/bound.ts

@@ -15,6 +15,7 @@ import type { HyperdriveResource as _Hyperdrive } from "./hyperdrive.ts";
 import type { Images as _Images } from "./images.ts";
 import type { PipelineResource as _Pipeline } from "./pipeline.ts";
 import type { QueueResource as _Queue } from "./queue.ts";
+import type { RateLimit } from "./rate-limit.ts";
 import type { SecretKey } from "./secret-key.ts";
 import type { Secret as CloudflareSecret } from "./secret.ts";
 import type { VectorizeIndexResource as _VectorizeIndex } from "./vectorize-index.ts";
@@ -74,25 +75,31 @@ export type Bound<T extends Binding> = T extends _DurableObjectNamespace<
                                     ? AnalyticsEngineDataset
                                     : T extends _Pipeline<infer R>
                                       ? Pipeline<R>
-                                      : T extends string
-                                        ? string
-                                        : T extends BrowserRendering
-                                          ? Fetcher
-                                          : T extends _Ai<infer M>
-                                            ? Ai<M>
-                                            : T extends _Images
-                                              ? ImagesBinding
-                                              : T extends _VersionMetadata
-                                                ? WorkerVersionMetadata
-                                                : T extends Self
-                                                  ? Service
-                                                  : T extends Json<infer T>
-                                                    ? T
-                                                    : T extends _Container<
-                                                          infer Obj
-                                                        >
-                                                      ? DurableObjectNamespace<
-                                                          Obj &
-                                                            Rpc.DurableObjectBranded
-                                                        >
-                                                      : Service;
+                                      : T extends RateLimit
+                                        ? {
+                                            limit(options: {
+                                              key: string;
+                                            }): Promise<{ success: boolean }>;
+                                          }
+                                        : T extends string
+                                          ? string
+                                          : T extends BrowserRendering
+                                            ? Fetcher
+                                            : T extends _Ai<infer M>
+                                              ? Ai<M>
+                                              : T extends _Images
+                                                ? ImagesBinding
+                                                : T extends _VersionMetadata
+                                                  ? WorkerVersionMetadata
+                                                  : T extends Self
+                                                    ? Service
+                                                    : T extends Json<infer T>
+                                                      ? T
+                                                      : T extends _Container<
+                                                            infer Obj
+                                                          >
+                                                        ? DurableObjectNamespace<
+                                                            Obj &
+                                                              Rpc.DurableObjectBranded
+                                                          >
+                                                        : Service;

package/src/cloudflare/compatibility-date.gen.ts

@@ -4,4 +4,4 @@
 /**
  * The default Cloudflare Workers compatibility date, set based on the latest workerd release at the time of build.
  */
-export const DEFAULT_COMPATIBILITY_DATE = "2025-07-15";
+export const DEFAULT_COMPATIBILITY_DATE = "2025-07-19";

package/src/cloudflare/index.ts

@@ -36,6 +36,7 @@ export * from "./permission-groups.ts";
 export * from "./pipeline.ts";
 export * from "./queue-consumer.ts";
 export * from "./queue.ts";
+export * from "./rate-limit.ts";
 export * from "./react-router.ts";
 export * from "./redirect-rule.ts";
 export * from "./redwood.ts";

package/src/cloudflare/miniflare/miniflare-worker-options.ts

@@ -563,6 +563,10 @@ export async function buildMiniflareWorkerOptions({
         }
         break;
       }
+      case "ratelimit": {
+        (options.ratelimits ??= {})[name] = binding;
+        break;
+      }
       default: {
         assertNever(binding);
       }

package/src/cloudflare/rate-limit.ts

@@ -0,0 +1,70 @@
+/**
+ * Base interface for rate limiting configuration.
+ */
+export interface RateLimitProps {
+  /**
+   * A positive integer that uniquely defines this rate limiting configuration (e.g., namespace_id = 999).
+   */
+  namespace_id: number;
+  /**
+   * Simple rate limiting configuration.
+   */
+  simple: {
+    /**
+     * The limit (number of requests or API calls) to be applied. This is incremented when you call the limit() function in your Worker.
+     */
+    limit: number;
+    /**
+     * The period, in seconds, to measure increments to the limit over. Must be either 10 or 60.
+     */
+    period: 60 | 10;
+  };
+}
+
+/**
+ * RateLimit binding for Cloudflare Workers.
+ */
+export interface RateLimit extends RateLimitProps {
+  type: "ratelimit";
+}
+
+/**
+ * Rate limiting binding for Cloudflare Workers.
+ *
+ * The RateLimit binding provides access to Cloudflare's rate limiting functionality,
+ * allowing you to implement rate limiting directly in your Workers without needing
+ * to rely on external services.
+ *
+ * @example
+ * ```ts
+ * import { Worker, RateLimit } from "alchemy/cloudflare";
+ *
+ * const rateLimit = RateLimit({
+ *   namespace_id: 1001,
+ *   simple: {
+ *     limit: 1500,
+ *     period: 60
+ *   }
+ * });
+ *
+ * await Worker("my-worker", {
+ *   name: "my-worker",
+ *   entrypoint: "./src/worker.ts",
+ *   bindings: {
+ *     MY_RATE_LIMIT: rateLimit
+ *   }
+ * });
+ * ```
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/rate-limit/
+ *
+ * Creates a rate limiting binding for Cloudflare Workers.
+ * @returns A RateLimit binding object.
+ */
+export function RateLimit(options: RateLimitProps): RateLimit {
+  return {
+    type: "ratelimit",
+    namespace_id: options.namespace_id,
+    simple: options.simple,
+  };
+}

package/src/cloudflare/route.ts

@@ -282,6 +282,10 @@ async function updateRoute(
     },
   );
 
+  if (updateResponse.status === 404) {
+    return await createRoute(api, zoneId, pattern, script);
+  }
+
   if (!updateResponse.ok) {
     return await handleApiError(updateResponse, "updating", "Route", pattern);
   }

package/src/cloudflare/tanstack-start.ts

@@ -17,7 +17,16 @@ export async function TanStackStart<B extends Bindings>(
 ): Promise<TanStackStart<B>> {
   return Website(id, {
     ...props,
-    command: props?.command ?? "bun run build",
+    command: props?.command ?? "vite build",
+    commandEnv: {
+      // TODO(sam): should probably be set for all Websites, or at least all Vite Websites
+      // needs to be set or else jsxDev is included in the bundle and breaks in production
+      NODE_ENV: process.env.NODE_ENV ?? "production",
+    },
+    noBundle: true,
+    dev: props?.dev ?? {
+      command: "vite dev",
+    },
     wrangler: props?.wrangler ?? true,
     main: props?.main ?? ".output/server/index.mjs",
     compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],

package/src/cloudflare/website.ts

@@ -2,6 +2,7 @@ import path from "node:path";
 import { alchemy } from "../alchemy.ts";
 import { Exec } from "../os/exec.ts";
 import { Scope } from "../scope.ts";
+import { isSecret } from "../secret.ts";
 import { detectPackageManager } from "../util/detect-package-manager.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
@@ -18,6 +19,11 @@ export interface WebsiteProps<B extends Bindings>
    */
   command?: string;
 
+  /**
+   * Additional environment variables to set when running the command
+   */
+  commandEnv?: Record<string, string>;
+
   /**
    * Whether to memoize the command (only re-run if the command changes)
    *
@@ -224,7 +230,20 @@ export default {
         await Exec("build", {
           cwd,
           command: props.command,
-          env: props.env,
+          env: {
+            ...(props.env ?? {}),
+            ...(props.commandEnv ?? {}),
+            ...Object.fromEntries(
+              Object.entries(props.bindings ?? {}).flatMap(([key, value]) => {
+                if (isSecret(value)) {
+                  return [[key, value.unencrypted]];
+                } else if (typeof value === "string") {
+                  return [[key, value]];
+                }
+                return [];
+              }),
+            ),
+          },
           memoize: props.memoize,
         });
       }

package/src/cloudflare/worker-metadata.ts

@@ -565,6 +565,13 @@ export async function prepareWorkerMetadata(
         configureClassMigration(bindingName, binding);
       }
       (meta.containers ??= []).push({ class_name: binding.className });
+    } else if (binding.type === "ratelimit") {
+      meta.bindings.push({
+        type: "ratelimit",
+        name: bindingName,
+        namespace_id: binding.namespace_id.toString(),
+        simple: binding.simple,
+      });
     } else {
       assertNever(
         binding,

package/src/cloudflare/worker.ts

@@ -1166,7 +1166,7 @@ export const _Worker = Resource(
 
       if (oldName !== newName) {
         if (dispatchNamespace) {
-          await this.replace(true);
+          this.replace(true);
         } else {
           const renameResponse = await api.patch(
             `/accounts/${api.accountId}/workers/services/${oldName}`,

package/src/cloudflare/wrangler.json.ts

@@ -4,13 +4,21 @@ import type { Context } from "../context.ts";
 import { formatJson } from "../fs/static-json-file.ts";
 import { Resource } from "../resource.ts";
 import { assertNever } from "../util/assert-never.ts";
-import { Self, type Bindings } from "./bindings.ts";
+import {
+  Self,
+  type Bindings,
+  type WorkerBindingRateLimit,
+} from "./bindings.ts";
 import type { DurableObjectNamespace } from "./durable-object-namespace.ts";
 import type { EventSource } from "./event-source.ts";
 import { isQueueEventSource } from "./event-source.ts";
 import { isQueue } from "./queue.ts";
 import type { Worker, WorkerProps } from "./worker.ts";
 
+type WranglerJsonRateLimit = Omit<WorkerBindingRateLimit, "type"> & {
+  type: "rate_limit";
+};
+
 /**
  * Properties for wrangler.json configuration file
  */
@@ -447,6 +455,13 @@ export interface WranglerJsonSpec {
     namespace: string;
     experimental_remote?: boolean;
   }[];
+
+  /**
+   * Unsafe bindings section for experimental features
+   */
+  unsafe?: {
+    bindings: WranglerJsonRateLimit[];
+  };
 }
 
 /**
@@ -534,6 +549,7 @@ function processBindings(
     namespace: string;
     experimental_remote?: boolean;
   }[] = [];
+  const unsafeBindings: WranglerJsonRateLimit[] = [];
   const containers: {
     class_name: string;
   }[] = [];
@@ -721,6 +737,13 @@ function processBindings(
         namespace: binding.namespaceName,
         experimental_remote: true,
       });
+    } else if (binding.type === "ratelimit") {
+      unsafeBindings.push({
+        name: bindingName,
+        type: "rate_limit",
+        namespace_id: binding.namespace_id.toString(),
+        simple: binding.simple,
+      });
     } else if (binding.type === "secret_key") {
       // no-op
     } else if (binding.type === "container") {
@@ -802,4 +825,10 @@ function processBindings(
   if (dispatchNamespaces.length > 0) {
     spec.dispatch_namespaces = dispatchNamespaces;
   }
+
+  if (unsafeBindings.length > 0) {
+    spec.unsafe = {
+      bindings: unsafeBindings,
+    };
+  }
 }

package/src/context.ts

@@ -57,7 +57,7 @@ export interface BaseContext<Out extends Resource> {
    * Indicate that this resource is being replaced.
    * This will cause the resource to be deleted at the end of the stack's CREATE phase.
    */
-  replace(force?: boolean): Promise<never>;
+  replace(force?: boolean): never;
   /**
    * Terminate the resource lifecycle handler and destroy the resource.
    *
@@ -102,7 +102,7 @@ export function context<
   seq: number;
   props: Props;
   state: State<Kind, Props, Out>;
-  replace: (force?: boolean) => Promise<never>;
+  replace: (force?: boolean) => never;
   isReplacement?: boolean;
 }): Context<Out> {
   type InternalSymbols =

package/src/destroy.ts

@@ -16,9 +16,13 @@ import { logger } from "./util/logger.ts";
 
 export class DestroyedSignal extends Error {}
 
+export type DestroyStrategy = "sequential" | "parallel";
+
+export const DestroyStrategy = Symbol.for("alchemy::DestroyStrategy");
+
 export interface DestroyOptions {
   quiet?: boolean;
-  strategy?: "sequential" | "parallel";
+  strategy?: DestroyStrategy;
   replace?: {
     props?: ResourceProps | undefined;
     output?: Resource<string>;
@@ -40,7 +44,7 @@ export async function destroy<Type extends string>(
   if (isScopeArgs(args)) {
     const [scope] = args;
     const options = {
-      strategy: "sequential",
+      strategy: scope.destroyStrategy ?? "sequential",
       ...(args[1] ?? {}),
     } satisfies DestroyOptions;
 
@@ -118,7 +122,20 @@ export async function destroy<Type extends string>(
       fqn: instance[ResourceFQN],
       seq: instance[ResourceSeq],
       props: options?.replace?.props ?? state.props,
-      state,
+      state: options?.replace?.output
+        ? {
+            output: options.replace.output,
+            status: "deleting",
+            oldProps: options.replace.props,
+            data: {},
+            kind: instance[ResourceKind],
+            id: instance[ResourceID],
+            fqn: instance[ResourceFQN],
+            seq: instance[ResourceSeq],
+            props: options.replace.props,
+          }
+        : state,
+      // TODO(sam|michael): should this always be false or !!options?.replace
       isReplacement: false,
       replace: () => {
         throw new Error("Cannot replace a resource that is being deleted");
@@ -134,6 +151,7 @@ export async function destroy<Type extends string>(
           // TODO(sam): this is an awful hack to differentiate between naked scopes and resources
           isResource: instance[ResourceKind] !== "alchemy::Scope",
           parent: scope,
+          destroyStrategy: instance[DestroyStrategy] ?? "sequential",
         },
         async (scope) => {
           nestedScope = options?.replace?.props == null ? scope : undefined;
@@ -151,13 +169,17 @@ export async function destroy<Type extends string>(
       }
     }
 
+    const destroyOptions = {
+      ...options,
+      strategy: instance[DestroyStrategy] ?? "sequential",
+    };
     if (nestedScope) {
-      await destroy(nestedScope, options);
+      await destroy(nestedScope, destroyOptions);
     }
 
     if (options?.replace == null) {
       if (nestedScope) {
-        await destroy(nestedScope, options);
+        await destroy(nestedScope, destroyOptions);
       }
       await scope.deleteResource(instance[ResourceID]);
     } else {

package/src/planetscale/password.ts

@@ -306,7 +306,7 @@ export const Password = Resource(
             this.output.cidrs.length === props.cidrs.length &&
             this.output.cidrs.every((cidr, i) => cidr === props.cidrs![i])))
       ) {
-        return await this.replace();
+        return this.replace();
       }
       const updateResponse = await api.patch(
         `/organizations/${props.organizationId}/databases/${databaseName}/branches/${branchName}/passwords/${this.output.id}`,

package/src/resource.ts

@@ -1,5 +1,6 @@
 import { apply } from "./apply.ts";
 import type { Context } from "./context.ts";
+import { DestroyStrategy } from "./destroy.ts";
 import { Scope as _Scope, type Scope } from "./scope.ts";
 
 declare global {
@@ -59,6 +60,13 @@ export interface ProviderOptions {
    * If true, the resource will be updated even if the inputs have not changed.
    */
   alwaysUpdate: boolean;
+
+  /**
+   * The strategy to use when destroying the resource.
+   *
+   * @default "sequential"
+   */
+  destroyStrategy?: DestroyStrategy;
 }
 
 export type ResourceProps = {
@@ -81,6 +89,7 @@ export interface PendingResource<Out = unknown> extends Promise<Out> {
   [ResourceFQN]: ResourceFQN;
   [ResourceScope]: Scope;
   [ResourceSeq]: number;
+  [DestroyStrategy]: DestroyStrategy;
   [InnerResourceScope]: Promise<Scope>;
 }
 
@@ -90,6 +99,7 @@ export interface Resource<Kind extends ResourceKind = ResourceKind> {
   [ResourceFQN]: ResourceFQN;
   [ResourceScope]: Scope;
   [ResourceSeq]: number;
+  [DestroyStrategy]: DestroyStrategy;
 }
 
 // helper for semantic syntax highlighting (color as a type/class instead of function/value)
@@ -167,6 +177,7 @@ export function Resource<
       [ResourceFQN]: scope.fqn(resourceID),
       [ResourceSeq]: seq,
       [ResourceScope]: scope,
+      [DestroyStrategy]: options?.destroyStrategy ?? "sequential",
       [InnerResourceScope]: new Promise<Scope>((resolve) => {
         resolveInnerScope = resolve;
       }),