alchemy 0.30.0 → 0.31.0

package/src/cloudflare/worker-metadata.ts

@@ -484,6 +484,16 @@ export async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         namespace: binding.namespaceName,
       });
+    } else if (binding.type === "secret_key") {
+      meta.bindings.push({
+        type: "secret_key",
+        name: bindingName,
+        algorithm: binding.algorithm,
+        format: binding.format,
+        usages: binding.usages,
+        key_base64: binding.key_base64?.unencrypted,
+        key_jwk: binding.key_jwk?.unencrypted,
+      });
     } else {
       // @ts-expect-error - we should never reach here
       throw new Error(`Unsupported binding type: ${binding.type}`);

package/src/cloudflare/worker.ts

@@ -599,8 +599,36 @@ export function WorkerRef<
  *   }
  * });
  *
- * @see
- * https://developers.cloudflare.com/workers/
+ * @example
+ * // Create a worker with queue event sources and custom consumer settings:
+ * const taskQueue = await Queue("task-queue", {
+ *   name: "task-queue"
+ * });
+ *
+ * const dlq = await Queue("failed-tasks", {
+ *   name: "failed-tasks"
+ * });
+ *
+ * const queueWorker = await Worker("queue-processor", {
+ *   name: "queue-processor",
+ *   entrypoint: "./src/processor.ts",
+ *   bindings: {
+ *     TASK_QUEUE: taskQueue  // Producer: bind queue for sending messages
+ *   },
+ *   eventSources: [{  // Consumer: configure processing settings
+ *     queue: taskQueue,
+ *     settings: {
+ *       batchSize: 15,           // Process 15 messages at once
+ *       maxConcurrency: 3,       // Allow 3 concurrent invocations
+ *       maxRetries: 5,           // Retry failed messages up to 5 times
+ *       maxWaitTimeMs: 2500,     // Wait up to 2.5 seconds to fill a batch
+ *       retryDelay: 60,          // Wait 60 seconds before retrying failed messages
+ *       deadLetterQueue: dlq     // Send failed messages to dead letter queue
+ *     }
+ *   }]
+ * });
+ *
+ * @see https://developers.cloudflare.com/workers/
  */
 export function Worker<
   const B extends Bindings,

package/src/cloudflare/wrangler.json.ts

@@ -607,6 +607,8 @@ function processBindings(
         binding: bindingName,
         namespace: binding.namespaceName,
       });
+    } else if (binding.type === "secret_key") {
+      // no-op
     } else {
       // biome-ignore lint/correctness/noVoidTypeReturn: it returns never
       return assertNever(binding);

package/src/secret.ts

@@ -8,7 +8,7 @@ declare global {
 
 // a global registry of all secrets that we will use when serializing an application
 const globalSecrets: {
-  [name: string]: Secret;
+  [name: string]: Secret<any>;
 } = (globalThis.__ALCHEMY_SECRETS__ ??= {});
 
 let i = 0;
@@ -53,19 +53,19 @@ const SecretSymbol = Symbol.for("alchemy::Secret");
  *   }
  * }
  */
-export class Secret {
+export class Secret<T = string> {
   [SecretSymbol] = true;
 
   /**
    * @internal
    */
-  public static all(): Secret[] {
+  public static all(): Secret<any>[] {
     return Object.values(globalSecrets);
   }
 
   public readonly type = "secret";
   constructor(
-    readonly unencrypted: string,
+    readonly unencrypted: T,
     readonly name: string = nextName(),
   ) {
     globalSecrets[name] = this;
@@ -111,10 +111,10 @@ export function isSecret(binding: any): binding is Secret {
  * @throws {Error} If the value is undefined
  * @throws {Error} If no password is set in the alchemy application options or current scope
  */
-export function secret<S extends string | undefined>(
-  unencrypted: S,
+export function secret<S = string>(
+  unencrypted: S | undefined,
   name?: string,
-): Secret {
+): Secret<S> {
   if (unencrypted === undefined) {
     throw new Error("Secret cannot be undefined");
   }

package/src/serde.ts

@@ -31,33 +31,39 @@ export type Serialized<T> = T extends
     ? {
         "@schema": string;
       }
-    : T extends Secret
+    : T extends Secret<string>
       ? {
           "@secret": string;
         }
-      : T extends Date
+      : T extends Secret<any>
         ? {
-            "@date": string;
+            "@secret": {
+              object: string;
+            };
           }
-        : T extends Symbol
+        : T extends Date
           ? {
-              "@symbol": string;
+              "@date": string;
             }
-          : T extends Scope
+          : T extends Symbol
             ? {
-                "@scope": null;
+                "@symbol": string;
               }
-            : T extends Function
-              ? undefined
-              : T extends Array<infer U>
-                ? Array<Serialized<U>>
-                : T extends object
-                  ? {
-                      [K in keyof T as K extends symbol
-                        ? string
-                        : K]: Serialized<T[K]>;
-                    }
-                  : T;
+            : T extends Scope
+              ? {
+                  "@scope": null;
+                }
+              : T extends Function
+                ? undefined
+                : T extends Array<infer U>
+                  ? Array<Serialized<U>>
+                  : T extends object
+                    ? {
+                        [K in keyof T as K extends symbol
+                          ? string
+                          : K]: Serialized<T[K]>;
+                      }
+                    : T;
 
 export type SerializedScope = {
   [fqn: ResourceFQN]: Serialized<Resource>;
@@ -121,7 +127,14 @@ export async function serialize(
     return {
       "@secret":
         options?.encrypt !== false
-          ? await encrypt(value.unencrypted, scope.password)
+          ? typeof value.unencrypted === "string"
+            ? await encrypt(value.unencrypted, scope.password)
+            : {
+                data: await encrypt(
+                  JSON.stringify(value.unencrypted),
+                  scope.password,
+                ),
+              }
           : value.unencrypted,
     };
   } else if (isType(value)) {
@@ -203,13 +216,20 @@ export async function deserialize(
     );
   }
   if (value && typeof value === "object") {
-    if (typeof value["@secret"] === "string") {
+    if (value["@secret"]) {
       if (!scope.password) {
         throw new Error(
           "Cannot deserialize secret without password, did you forget to set password when initializing your alchemy app?\n" +
             "See: https://alchemy.run/docs/concepts/secret.html#encryption-password",
         );
       }
+      if (typeof value["@secret"] === "object") {
+        return new Secret(
+          JSON.parse(
+            await decryptWithKey(value["@secret"].data, scope.password),
+          ),
+        );
+      }
       return new Secret(await decryptWithKey(value["@secret"], scope.password));
     } else if ("@schema" in value) {
       return value["@schema"];