alchemy 0.83.1 → 0.83.2

package/src/cloudflare/worker.ts

@@ -365,22 +365,16 @@ export interface BaseWorkerProps<
       };
 
   /**
-   * Smart placement configuration for the worker.
+   * Placement configuration for the worker.
    *
-   * Controls how Cloudflare places the worker across its network for optimal performance.
+   * Controls where your Worker runs to reduce latency to back-end infrastructure.
+   * Only one placement option can be specified (mutually exclusive).
    *
-   * When omitted, smart placement is disabled (default behavior).
+   * When omitted, the Worker runs in the data center closest to the incoming request.
+   *
+   * @see https://developers.cloudflare.com/workers/configuration/smart-placement/
    */
-  placement?: {
-    /**
-     * The placement mode for the worker.
-     *
-     * - "smart": Automatically optimize placement based on performance metrics
-     *
-     * @default undefined (smart placement disabled)
-     */
-    mode: "smart";
-  };
+  placement?: WorkerPlacement;
 
   limits?: {
     /**
@@ -477,6 +471,136 @@ export interface WorkerObservability {
   };
 }
 
+/**
+ * Worker placement configuration for controlling where your Worker runs.
+ *
+ * Only one placement option can be specified at a time (mutually exclusive).
+ *
+ * @see https://developers.cloudflare.com/workers/configuration/smart-placement/
+ */
+export type WorkerPlacement =
+  | WorkerPlacementSmart
+  | WorkerPlacementRegion
+  | WorkerPlacementHost
+  | WorkerPlacementHostname;
+
+/**
+ * Smart placement mode - Cloudflare automatically places your Worker
+ * closest to the upstream with the most requests.
+ *
+ * Use when your Worker connects to multiple back-end services or you
+ * don't know the exact location of your infrastructure.
+ *
+ * @example
+ * ```ts
+ * const worker = await Worker("api", {
+ *   entrypoint: "./src/worker.ts",
+ *   placement: { mode: "smart" }
+ * });
+ * ```
+ */
+export interface WorkerPlacementSmart {
+  /**
+   * Enable smart placement mode.
+   *
+   * Cloudflare automatically analyzes your Worker's traffic patterns and
+   * places it in an optimal location based on performance metrics.
+   */
+  mode: "smart";
+}
+
+/**
+ * Region-based placement - place your Worker closest to a specific
+ * cloud provider region.
+ *
+ * Use when your back-end infrastructure runs in a known AWS, GCP, or Azure region.
+ *
+ * @example
+ * ```ts
+ * const worker = await Worker("api", {
+ *   entrypoint: "./src/worker.ts",
+ *   placement: { region: "aws:us-east-1" }
+ * });
+ * ```
+ */
+export interface WorkerPlacementRegion {
+  /**
+   * Cloud provider region to place your Worker closest to.
+   *
+   * Format: `{provider}:{region}`
+   *
+   * Supported providers:
+   * - AWS: `aws:us-east-1`, `aws:us-west-2`, `aws:eu-central-1`, etc.
+   * - GCP: `gcp:us-east4`, `gcp:europe-west1`, `gcp:asia-east1`, etc.
+   * - Azure: `azure:westeurope`, `azure:eastus`, `azure:southeastasia`, etc.
+   *
+   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html
+   * @see https://cloud.google.com/compute/docs/regions-zones
+   * @see https://learn.microsoft.com/en-us/azure/reliability/regions-list
+   *
+   * @example "aws:us-east-1"
+   * @example "gcp:us-east4"
+   * @example "azure:westeurope"
+   */
+  region: string;
+}
+
+/**
+ * Host-based placement (layer 4) - place your Worker closest to a specific
+ * TCP endpoint.
+ *
+ * Use when your infrastructure is not in a major cloud provider and you need
+ * to probe a TCP service (like a database) to determine optimal placement.
+ *
+ * @example
+ * ```ts
+ * const worker = await Worker("api", {
+ *   entrypoint: "./src/worker.ts",
+ *   placement: { host: "my-database.example.com:5432" }
+ * });
+ * ```
+ */
+export interface WorkerPlacementHost {
+  /**
+   * Host endpoint to probe (TCP/layer 4) for placement.
+   *
+   * Cloudflare uses TCP CONNECT checks to measure latency and selects
+   * the best data center. Use this for database hosts or other TCP services.
+   *
+   * Format: `hostname:port`
+   *
+   * @example "my_database_host.com:5432"
+   */
+  host: string;
+}
+
+/**
+ * Hostname-based placement (layer 7) - place your Worker closest to a specific
+ * HTTP endpoint.
+ *
+ * Use when your infrastructure is not in a major cloud provider and you need
+ * to probe an HTTP service (like an API) to determine optimal placement.
+ *
+ * @example
+ * ```ts
+ * const worker = await Worker("api", {
+ *   entrypoint: "./src/worker.ts",
+ *   placement: { hostname: "my-api.example.com" }
+ * });
+ * ```
+ */
+export interface WorkerPlacementHostname {
+  /**
+   * Hostname to probe (HTTP/layer 7) for placement.
+   *
+   * Cloudflare uses HTTP HEAD checks to measure latency and selects
+   * the best data center. Use this for API endpoints or other HTTP services.
+   *
+   * @example "my_api_server.com"
+   */
+  hostname: string;
+}
+
 export interface InlineWorkerProps<
   B extends Bindings | undefined = Bindings,
   RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
@@ -630,11 +754,9 @@ export type Worker<
   version?: string;
 
   /**
-   * Smart placement configuration for the worker
+   * Placement configuration for the worker
    */
-  placement?: {
-    mode: "smart";
-  };
+  placement?: WorkerPlacement;
 
   /**
    * Whether the worker has a remote deployment

package/src/cloudflare/zone-settings.ts

@@ -89,8 +89,7 @@ export interface AutomaticHTTPSRewritesSetting extends CloudflareSettingBase {
 /**
  * Automatic Platform Optimization setting
  */
-export interface AutomaticPlatformOptimizationSetting
-  extends CloudflareSettingBase {
+export interface AutomaticPlatformOptimizationSetting extends CloudflareSettingBase {
   id: "automatic_platform_optimization";
   value: {
     enabled: boolean;

package/src/coinbase/evm-smart-account.ts

@@ -48,8 +48,7 @@ export interface EvmSmartAccountProps extends CoinbaseClientOptions {
   faucet?: FaucetConfig;
 }
 
-export interface EvmSmartAccount
-  extends Resource<"coinbase::evm-smart-account"> {
+export interface EvmSmartAccount extends Resource<"coinbase::evm-smart-account"> {
   /**
    * The smart account name in CDP
    */

package/src/coinbase/faucet.ts

@@ -141,7 +141,9 @@ for (const account of accounts) {
 
       // Skip if already processed in this run
       if (funded.has(key)) {
-        console.log(`  ⏭️  Skipping ${token} on ${network} (already requested)`);
+        console.log(
+          `  ⏭️  Skipping ${token} on ${network} (already requested)`,
+        );
         continue;
       }
 

package/src/context.ts

@@ -17,8 +17,9 @@ export type Context<
   Props extends ResourceProps = ResourceProps,
 > = CreateContext<Out> | UpdateContext<Out, Props> | DeleteContext<Out, Props>;
 
-export interface CreateContext<Out extends ResourceAttributes>
-  extends BaseContext<Out> {
+export interface CreateContext<
+  Out extends ResourceAttributes,
+> extends BaseContext<Out> {
   phase: "create";
   output?: undefined;
   props?: undefined;

package/src/esbuild/bundle.ts

@@ -73,8 +73,9 @@ export interface BundleProps extends Partial<esbuild.BuildOptions> {
 /**
  * Output returned after bundle creation/update
  */
-export interface Bundle<P extends BundleProps = BundleProps>
-  extends BundleProps {
+export interface Bundle<
+  P extends BundleProps = BundleProps,
+> extends BundleProps {
   /**
    * Path to the bundled file
    * Absolute or relative path to the generated bundle

package/src/scope.ts

@@ -101,6 +101,14 @@ export interface ScopeOptions extends ProviderCredentials {
    * @default false
    */
   adopt?: boolean;
+  /**
+   * Skip decrypting secrets and treat them as undefined.
+   * Requires --force to be enabled.
+   * Useful for recovering from lost encryption passwords.
+   *
+   * @default false
+   */
+  eraseSecrets?: boolean;
   /**
    * The path to the root directory of the project.
    *
@@ -176,8 +184,8 @@ export class Scope {
 
   public static readonly KIND = "alchemy::Scope" as const;
 
-  public static storage = globalThis.__ALCHEMY_STORAGE__ ??=
-    new AsyncLocalStorage<Scope>();
+  public static storage = (globalThis.__ALCHEMY_STORAGE__ ??=
+    new AsyncLocalStorage<Scope>());
 
   public static getScope(): Scope | undefined {
     return Scope.storage.getStore();
@@ -209,6 +217,7 @@ export class Scope {
   public readonly tunnel: boolean;
   public readonly force: boolean;
   public readonly adopt: boolean;
+  public readonly eraseSecrets: boolean;
   public readonly destroyStrategy: DestroyStrategy;
   public readonly logger: LoggerApi;
   public readonly noTrack: boolean;
@@ -252,6 +261,7 @@ export class Scope {
       destroyStrategy,
       logger,
       adopt,
+      eraseSecrets,
       dotAlchemy,
       rootDir,
       isSelected,
@@ -310,6 +320,7 @@ export class Scope {
     this.tunnel = tunnel ?? this.parent?.tunnel ?? false;
     this.force = force ?? this.parent?.force ?? false;
     this.adopt = adopt ?? this.parent?.adopt ?? false;
+    this.eraseSecrets = eraseSecrets ?? this.parent?.eraseSecrets ?? false;
     this.destroyStrategy =
       destroyStrategy ?? this.parent?.destroyStrategy ?? "sequential";
     if (this.local) {

package/src/sentry/client-key.ts

@@ -340,7 +340,11 @@ async function findClientKeyByName(
  */
 async function getClientKeyName(
   api: SentryApi,
-  { organization, project, keyId }: {
+  {
+    organization,
+    project,
+    keyId,
+  }: {
     organization: string;
     project: string;
     keyId: string;

package/src/serde.ts

@@ -177,6 +177,10 @@ export async function deserialize(
   }
   if (value && typeof value === "object") {
     if (value["@secret"]) {
+      // If eraseSecrets is enabled, return undefined instead of decrypting
+      if (scope.eraseSecrets) {
+        return undefined;
+      }
       if (!scope.password) {
         throw new Error(
           "Cannot deserialize secret without password, did you forget to set password when initializing your alchemy app?\n" +

package/src/state/d1-state-store.ts

@@ -75,9 +75,8 @@ const createDatabaseClient = memoize(async (options: D1StateStoreOptions) => {
 });
 
 const upsertDatabase = async (api: CloudflareApi, databaseName: string) => {
-  const { listDatabases, createDatabase } = await import(
-    "../cloudflare/d1-database.ts"
-  );
+  const { listDatabases, createDatabase } =
+    await import("../cloudflare/d1-database.ts");
   const { listSqlFiles } = await import("../cloudflare/d1-sql-file.ts");
   const { applyMigrations } = await import("../cloudflare/d1-migrations.ts");
   const migrate = async (databaseId: string) => {

package/src/state/instrumented-state-store.ts

@@ -5,9 +5,9 @@ import {
 } from "../util/telemetry.ts";
 
 //todo(michael): we should also handle serde here
-export class InstrumentedStateStore<T extends StateStore>
-  implements StateStore
-{
+export class InstrumentedStateStore<
+  T extends StateStore,
+> implements StateStore {
   /** @internal */
   __phantom?: T;
   private readonly stateStore: StateStore;

package/src/util/api/client/types.gen.ts

@@ -14,8 +14,7 @@ import type { Middleware } from "./utils.gen.ts";
 export type ResponseStyle = "data" | "fields";
 
 export interface Config<T extends ClientOptions = ClientOptions>
-  extends Omit<RequestInit, "body" | "headers" | "method">,
-    CoreConfig {
+  extends Omit<RequestInit, "body" | "headers" | "method">, CoreConfig {
   /**
    * Base URL for all requests made by this client.
    */
@@ -69,7 +68,9 @@ export interface RequestOptions<
   TResponseStyle extends ResponseStyle = "fields",
   ThrowOnError extends boolean = boolean,
   Url extends string = string,
-> extends Config<{
+>
+  extends
+    Config<{
       responseStyle: TResponseStyle;
       throwOnError: ThrowOnError;
     }>,

package/src/util/api/core/pathSerializer.gen.ts

@@ -1,8 +1,7 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
 interface SerializeOptions<T>
-  extends SerializePrimitiveOptions,
-    SerializerOptions<T> {}
+  extends SerializePrimitiveOptions, SerializerOptions<T> {}
 
 interface SerializePrimitiveOptions {
   allowReserved?: boolean;

package/src/util/idempotent-spawn.ts

@@ -158,7 +158,11 @@ export async function idempotentSpawn({
   // Follow a file from persisted offset and mirror to a sink (stdout/stderr)
   async function followFilePersisted(
     logPath: string,
-    { write, chunkSize = 64 * 1024, tickMs = 100 }: {
+    {
+      write,
+      chunkSize = 64 * 1024,
+      tickMs = 100,
+    }: {
       stateKey: string;
       write: (buf: Buffer) => boolean;
       chunkSize?: number;

package/templates/astro/wrangler.jsonc

@@ -2,5 +2,5 @@
   "name": "website",
   "main": "dist/_worker.js/index.js",
   "compatibility_date": "2025-04-20",
-  "assets": { "binding": "ASSETS", "directory": "dist" }
+  "assets": { "binding": "ASSETS", "directory": "dist" },
 }