alchemy 0.70.1 → 0.70.2

package/src/cloudflare/worker-metadata.ts

@@ -1,4 +1,5 @@
 import { assertNever } from "../util/assert-never.ts";
+import { camelToSnakeObjectDeep } from "../util/camel-to-snake.ts";
 import { logger } from "../util/logger.ts";
 import { memoize } from "../util/memoize.ts";
 import { extractCloudflareResult } from "./api-response.ts";
@@ -180,8 +181,20 @@ export interface WorkerMetadata {
   compatibility_date: string;
   compatibility_flags?: string[];
   bindings: WorkerBindingSpec[];
-  observability: {
-    enabled: boolean;
+  observability?: {
+    enabled?: boolean;
+    head_sampling_rate?: number;
+    logs?: {
+      enabled?: boolean;
+      head_sampling_rate?: number;
+      invocation_logs?: boolean;
+    };
+    traces?: {
+      enabled?: boolean;
+      head_sampling_rate?: number;
+      persist?: boolean;
+      destinations?: string[];
+    };
   };
   logpush?: boolean;
   migrations?: SingleStepMigration;
@@ -235,6 +248,7 @@ export async function prepareWorkerMetadata(
       ...(oldSettings?.tags ?? []),
     ]),
   );
+
   const oldBindings = oldSettings?.bindings;
   // we use Cloudflare Worker tags to store a mapping between Alchemy's stable identifier and the binding name
   // e.g.
@@ -315,6 +329,8 @@ export async function prepareWorkerMetadata(
     return [];
   });
 
+  const observability = camelToSnakeObjectDeep(props.observability);
+
   // Prepare metadata with bindings
   const meta: WorkerMetadata = {
     compatibility_date: props.compatibilityDate,
@@ -324,7 +340,8 @@ export async function prepareWorkerMetadata(
     ),
     bindings: [],
     observability: {
-      enabled: props.observability?.enabled !== false,
+      ...observability,
+      enabled: observability?.enabled !== false,
     },
     logpush: props.logpush ?? false,
     // TODO(sam): base64 encode instead? 0 collision risk vs readability.

package/src/cloudflare/worker-stub.ts

@@ -128,7 +128,7 @@ export const WorkerStub = Resource("cloudflare::WorkerStub", async function <
   } as WorkerStub<RPC>;
 });
 
-async function exists(
+export async function exists(
   api: CloudflareApi,
   workerName: string,
 ): Promise<boolean> {
@@ -145,9 +145,10 @@ async function exists(
   }
 }
 
-async function createEmptyWorker(
+export async function createEmptyWorker(
   api: CloudflareApi,
   workerName: string,
+  version?: string,
 ): Promise<void> {
   // Minimal empty worker script
   const emptyScript = `export default { 
@@ -178,6 +179,12 @@ async function createEmptyWorker(
           main_module: "worker.js",
           compatibility_date: "2025-04-20",
           bindings: [],
+          ...(version != null && {
+            annotations: {
+              "workers/tag": version,
+              "workers/message": `Version ${version}`,
+            },
+          }),
         }),
       ],
       {
@@ -189,14 +196,24 @@ async function createEmptyWorker(
   // Upload worker script
   await extractCloudflareResult(
     `create empty worker "${workerName}"`,
-    api.put(
-      `/accounts/${api.accountId}/workers/scripts/${workerName}`,
-      formData,
-      {
-        headers: {
-          "Content-Type": "multipart/form-data",
-        },
-      },
-    ),
+    version != null
+      ? api.post(
+          `/accounts/${api.accountId}/workers/scripts/${workerName}/versions`,
+          formData,
+          {
+            headers: {
+              "Content-Type": "multipart/form-data",
+            },
+          },
+        )
+      : api.put(
+          `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+          formData,
+          {
+            headers: {
+              "Content-Type": "multipart/form-data",
+            },
+          },
+        ),
   );
 }

package/src/cloudflare/worker.ts

@@ -61,6 +61,7 @@ import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
 import "../esbuild/bundle.ts";
 import { Scope } from "../scope.ts";
 import type { WorkerRef } from "./worker-ref.ts";
+import { createEmptyWorker, exists } from "./worker-stub.ts";
 
 /**
  * Configuration options for static assets
@@ -166,18 +167,12 @@ export interface BaseWorkerProps<
   url?: boolean;
 
   /**
-   * Observability configuration for the worker
+   * Specify the observability behavior of the Worker.
    *
-   * Controls whether worker logs are enabled
-   * @default { enabled: true }
+   * @see https://developers.cloudflare.com/workers/wrangler/configuration/#observability
+   * @default - `enabled: true`
    */
-  observability?: {
-    /**
-     * Whether to enable worker logs
-     * @default true
-     */
-    enabled?: boolean;
-  };
+  observability?: WorkerObservability;
 
   /**
    * Enable Workers Logpush to export trace events (request/response metadata,
@@ -393,6 +388,85 @@ export interface BaseWorkerProps<
   tailConsumers?: Array<Worker | { service: string }>;
 }
 
+export interface WorkerObservability {
+  /**
+   * If observability is enabled for this Worker
+   *
+   * @default true
+   */
+  enabled?: boolean;
+
+  /**
+   * A number between 0 and 1, where 0 indicates zero out of one hundred requests are logged, and 1 indicates every request is logged.
+   * If head_sampling_rate is unspecified, it is configured to a default value of 1 (100%).
+   * @see https://developers.cloudflare.com/workers/observability/logs/workers-logs/#head-based-sampling
+   * @default 1
+   */
+  headSamplingRate?: number;
+
+  /**
+   * Configuration for worker logs
+   */
+  logs?: {
+    /**
+     * Whether logs are enabled
+     * @default true
+     */
+    enabled?: boolean;
+
+    /**
+     * The sampling rate for logs
+     */
+    headSamplingRate?: number;
+
+    /**
+     * Set to false to disable invocation logs
+     * @default true
+     */
+    invocationLogs?: boolean;
+
+    /**
+     * If logs should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.
+     * @default true
+     */
+    persist?: boolean;
+
+    /**
+     * What destinations logs emitted from the Worker should be sent to.
+     * @default []
+     */
+    destinations?: string[];
+  };
+
+  /**
+   * Configuration for worker traces
+   */
+  traces?: {
+    /**
+     * Whether traces are enabled
+     * @default true
+     */
+    enabled?: boolean;
+
+    /**
+     * The sampling rate for traces
+     */
+    headSamplingRate?: number;
+
+    /**
+     * If traces should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.
+     * @default true
+     */
+    persist?: boolean;
+
+    /**
+     * What destinations traces emitted from the Worker should be sent to.
+     * @default []
+     */
+    destinations?: string[];
+  };
+}
+
 export interface InlineWorkerProps<
   B extends Bindings | undefined = Bindings,
   RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
@@ -863,13 +937,20 @@ const _Worker = Resource(
         durableObjects: options.durableObjects,
         workflows: options.workflows,
       });
-      if (!props.version && this.output?.dev?.hasRemote !== false) {
+      if (this.output?.dev?.hasRemote !== false) {
         const api = await createCloudflareApi(props);
-        await deleteQueueConsumers(api, options.name);
-        await deleteWorker(api, {
-          scriptName: options.name,
-          dispatchNamespace: options.dispatchNamespace,
-        });
+        if (props.version) {
+          //* if the worker exists we deploy an empty version so we can destroy
+          if (await exists(api, options.name)) {
+            await createEmptyWorker(api, options.name, props.version);
+          }
+        } else {
+          await deleteQueueConsumers(api, options.name);
+          await deleteWorker(api, {
+            scriptName: options.name,
+            dispatchNamespace: options.dispatchNamespace,
+          });
+        }
       }
       return this.destroy();
     }
@@ -1607,7 +1688,7 @@ async function assertWorkerDoesNotExist(
   );
 }
 
-async function getScriptMetadata(
+export async function getScriptMetadata(
   api: CloudflareApi,
   scriptName: string,
 ): Promise<WorkerScriptMetadata | undefined> {

package/src/util/camel-to-snake.ts

@@ -0,0 +1,88 @@
+export interface LogPushProps {
+  maxFooBar: string;
+}
+
+export function camelToSnakeObjectDeep<T extends object | undefined>(
+  obj: T,
+): T extends undefined ? undefined : CamelToSnake<T> {
+  return (
+    obj
+      ? Object.fromEntries(
+          Object.entries(obj).map(([key, value]) => [
+            key
+              .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2") // Handle consecutive capitals: "FOOBar" -> "FOO_Bar"
+              .replace(/([a-z])([A-Z])/g, "$1_$2") // Handle normal camelCase: "fooBar" -> "foo_Bar"
+              .toLowerCase(),
+            Array.isArray(value)
+              ? value.map(camelToSnakeObjectDeep)
+              : typeof value === "object" && value !== null
+                ? camelToSnakeObjectDeep(value)
+                : value,
+          ]),
+        )
+      : undefined
+  ) as T extends undefined ? undefined : CamelToSnake<T>;
+}
+
+// Helper to check if a character is uppercase
+type IsUpper<C extends string> = C extends Uppercase<C>
+  ? C extends Lowercase<C>
+    ? false // Not a letter
+    : true // Uppercase letter
+  : false;
+
+// Helper to check if a character is lowercase
+type IsLower<C extends string> = C extends Lowercase<C>
+  ? C extends Uppercase<C>
+    ? false // Not a letter
+    : true // Lowercase letter
+  : false;
+
+// Convert a camelCase string to snake_case at the type level
+type CamelToSnakeString<
+  S extends string,
+  Acc extends string = "",
+> = S extends `${infer First}${infer Second}${infer Rest}`
+  ? IsUpper<First> extends true
+    ? IsUpper<Second> extends true
+      ? // FOO... pattern - check if next char is lowercase
+        Rest extends `${infer Third}${infer _}`
+        ? IsLower<Third> extends true
+          ? // FOOBar -> add First, add _, add Second lowercase, continue with Rest
+            CamelToSnakeString<
+              Rest,
+              `${Acc}${Lowercase<First>}_${Lowercase<Second>}`
+            >
+          : // FOO -> continue
+            CamelToSnakeString<`${Second}${Rest}`, `${Acc}${Lowercase<First>}`>
+        : // Only two chars left, both upper
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${Lowercase<First>}`>
+      : // FooBar or Foo - add underscore before uppercase if not at start
+        CamelToSnakeString<
+          `${Second}${Rest}`,
+          Acc extends "" ? `${Lowercase<First>}` : `${Acc}_${Lowercase<First>}`
+        >
+    : IsLower<First> extends true
+      ? IsUpper<Second> extends true
+        ? // fooBar -> just add the lowercase char, underscore will be added when processing uppercase
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+        : // foobar -> continue
+          CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+      : // Number or special char
+        CamelToSnakeString<`${Second}${Rest}`, `${Acc}${First}`>
+  : S extends `${infer Last}`
+    ? `${Acc}${Lowercase<Last>}`
+    : Acc;
+
+// Deep transformation for objects
+type CamelToSnake<T> = T extends object
+  ? T extends Array<infer U>
+    ? Array<CamelToSnake<U>>
+    : T extends Date | RegExp | Function
+      ? T // Don't transform special object types
+      : {
+          [K in keyof T as K extends string
+            ? CamelToSnakeString<K>
+            : K]: CamelToSnake<T[K]>;
+        }
+  : T;

package/workers/tunnel-proxy.js

@@ -34,7 +34,7 @@ var h={async fetch(e,r){let n=new URL(e.url);n.host=r.TUNNEL_HOST;let l=new Head
             Alchemy</a>.</p>
       </div>
       <div class="bg-slate-200 px-5 py-3 flex flex-col w-full max-w-lg">
-        <p class="text-sm text-slate-500">Alchemy 0.70.1</p>
+        <p class="text-sm text-slate-500">Alchemy 0.70.2</p>
       </div>
     </div>
   </body>