alchemy 0.29.2 → 0.30.0

package/src/cloudflare/secret.ts

@@ -74,6 +74,11 @@ export function isSecret(resource: Resource): resource is Secret {
 export interface Secret
   extends Resource<"cloudflare::Secret">,
     Omit<_SecretProps, "delete"> {
+  /**
+   * The binding type for Cloudflare Workers
+   */
+  type: "secrets_store_secret";
+
   /**
    * The name of the secret
    */
@@ -190,6 +195,7 @@ const _Secret = Resource(
     await insertSecret(api, props.store.id, name, props.value);
 
     return this({
+      type: "secrets_store_secret",
       name,
       storeId: props.store.id,
       store: props.store,
@@ -209,24 +215,98 @@ export async function insertSecret(
   secretName: string,
   secretValue: AlchemySecret,
 ): Promise<void> {
-  const response = await api.post(
+  // First try to create the secret
+  const createResponse = await api.post(
     `/accounts/${api.accountId}/secrets_store/stores/${storeId}/secrets`,
     [
       {
         name: secretName,
         value: secretValue.unencrypted,
-        scopes: [],
+        scopes: ["workers"],
       },
     ],
   );
 
+  if (createResponse.ok) {
+    return; // Secret created successfully
+  }
+
+  // If creation failed, check if it's because the secret already exists
+  const createErrorData: any = await createResponse.json().catch(() => ({
+    errors: [{ message: createResponse.statusText }],
+  }));
+
+  const isAlreadyExists = createErrorData.errors?.some(
+    (error: any) =>
+      error.code === 10021 ||
+      error.message?.includes("secret_name_already_exists"),
+  );
+
+  if (isAlreadyExists) {
+    // Secret already exists, find its ID and update it
+    const secretId = await getSecretId(api, storeId, secretName);
+    if (!secretId) {
+      throw new Error(`Secret '${secretName}' not found in store`);
+    }
+
+    const updateResponse = await api.patch(
+      `/accounts/${api.accountId}/secrets_store/stores/${storeId}/secrets/${secretId}`,
+      {
+        value: secretValue.unencrypted,
+        scopes: ["workers"],
+      },
+    );
+
+    if (!updateResponse.ok) {
+      const updateErrorData: any = await updateResponse.json().catch(() => ({
+        errors: [{ message: updateResponse.statusText }],
+      }));
+      const updateErrorMessage =
+        updateErrorData.errors?.[0]?.message || updateResponse.statusText;
+      throw new Error(
+        `Error updating secret '${secretName}': ${updateErrorMessage}`,
+      );
+    }
+  } else {
+    // Some other error occurred during creation
+    const createErrorMessage =
+      createErrorData.errors?.[0]?.message || createResponse.statusText;
+    throw new Error(
+      `Error creating secret '${secretName}': ${createErrorMessage}`,
+    );
+  }
+}
+
+/**
+ * Get the ID of a secret by its name
+ */
+async function getSecretId(
+  api: CloudflareApi,
+  storeId: string,
+  secretName: string,
+): Promise<string | null> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/secrets_store/stores/${storeId}/secrets`,
+  );
+
   if (!response.ok) {
-    const errorData: any = await response.json().catch(() => ({
-      errors: [{ message: response.statusText }],
-    }));
-    const errorMessage = errorData.errors?.[0]?.message || response.statusText;
-    throw new Error(`Error creating secret '${secretName}': ${errorMessage}`);
+    return null;
   }
+
+  const data = (await response.json()) as {
+    result: Array<{
+      id: string;
+      name: string;
+      created: string;
+      modified: string;
+      status: string;
+    }>;
+    success: boolean;
+    errors: any[];
+  };
+
+  const secret = data.result.find((s) => s.name === secretName);
+  return secret?.id || null;
 }
 
 /**

package/src/cloudflare/secrets-store.ts

@@ -1,6 +1,5 @@
 import type { Context } from "../context.ts";
 import { Resource, ResourceKind } from "../resource.ts";
-import { bind } from "../runtime/bind.ts";
 import { secret, type Secret } from "../secret.ts";
 import { handleApiError } from "./api-error.ts";
 import {
@@ -8,7 +7,6 @@ import {
   type CloudflareApi,
   type CloudflareApiOptions,
 } from "./api.ts";
-import type { Bound } from "./bound.ts";
 
 /**
  * Properties for creating or updating a Secrets Store
@@ -66,11 +64,6 @@ export interface SecretsStore<
   S extends Record<string, Secret> | undefined = undefined,
 > extends Resource<"cloudflare::SecretsStore">,
     Omit<SecretsStoreProps<S>, "delete"> {
-  /**
-   * The binding type for Cloudflare Workers
-   */
-  type: "secrets_store";
-
   /**
    * The unique identifier of the secrets store
    */
@@ -98,10 +91,6 @@ export interface SecretsStore<
   modifiedAt: number;
 }
 
-export type SecretsStoreWithBinding<
-  S extends Record<string, Secret> | undefined = undefined,
-> = SecretsStore<S> & Bound<SecretsStore<S>>;
-
 /**
  * A Cloudflare Secrets Store is a secure, centralized location for storing account-level secrets.
  *
@@ -162,7 +151,7 @@ export async function SecretsStore<
 >(
   name: string,
   props: SecretsStoreProps<S> = {} as SecretsStoreProps<S>,
-): Promise<SecretsStoreWithBinding<S>> {
+): Promise<SecretsStore<S>> {
   // Convert string values to Secret instances
   const normalizedProps: SecretsStoreProps<S> = {
     ...props,
@@ -176,12 +165,7 @@ export async function SecretsStore<
       : undefined,
   };
 
-  const store = await _SecretsStore(name, normalizedProps);
-  const binding = await bind(store);
-  return {
-    ...store,
-    get: binding.get,
-  } as SecretsStoreWithBinding<S>;
+  return _SecretsStore(name, normalizedProps);
 }
 
 const _SecretsStore = Resource("cloudflare::SecretsStore", async function <
@@ -254,7 +238,6 @@ const _SecretsStore = Resource("cloudflare::SecretsStore", async function <
   }
 
   return this({
-    type: "secrets_store",
     id: storeId,
     name: name,
     secrets: props.secrets as S,
@@ -345,7 +328,7 @@ export async function insertSecrets<
       const bulkPayload = batch.map(([name, secretValue]) => ({
         name,
         value: (secretValue as Secret).unencrypted,
-        scopes: [],
+        scopes: ["workers"],
       }));
 
       const bulkResponse = await api.post(

package/src/cloudflare/worker-metadata.ts

@@ -387,12 +387,12 @@ export async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         bucket_name: binding.name,
       });
-    } else if (binding.type === "secrets_store") {
+    } else if (binding.type === "secrets_store_secret") {
       meta.bindings.push({
-        type: "secrets_store",
+        type: "secrets_store_secret",
         name: bindingName,
-        store_id: binding.id,
-        secret_name: bindingName,
+        store_id: binding.storeId,
+        secret_name: binding.name,
       });
     } else if (binding.type === "assets") {
       meta.bindings.push({

package/src/cloudflare/worker.ts

@@ -288,6 +288,13 @@ export interface EntrypointWorkerProps<
    */
   noBundle?: boolean;
 
+  /**
+   * Whether to upload source maps for the worker script.
+   *
+   * @default false
+   */
+  uploadSourceMaps?: boolean;
+
   /**
    * Rules for adding additional files to the bundle.
    *
@@ -847,6 +854,7 @@ export const _Worker = Resource(
         props.script ??
         (await bundleWorkerScript({
           ...props,
+          name: workerName,
           compatibilityDate,
           compatibilityFlags,
         }));

package/src/cloudflare/wrangler.json.ts

@@ -596,16 +596,12 @@ function processBindings(
       });
     } else if (binding.type === "json") {
       // TODO(sam): anything to do here? not sure wrangler.json supports this
-    } else if (binding.type === "secrets_store") {
-      if (binding.secrets) {
-        for (const [secretName, _secret] of Object.entries(binding.secrets)) {
-          secretsStoreSecrets.push({
-            binding: bindingName,
-            store_id: binding.id,
-            secret_name: secretName,
-          });
-        }
-      }
+    } else if (binding.type === "secrets_store_secret") {
+      secretsStoreSecrets.push({
+        binding: bindingName,
+        store_id: binding.storeId,
+        secret_name: binding.name,
+      });
     } else if (binding.type === "dispatch_namespace") {
       dispatchNamespaces.push({
         binding: bindingName,

package/src/secret.ts

@@ -1,9 +1,15 @@
 import { alchemy } from "./alchemy.ts";
 
+declare global {
+  var __ALCHEMY_SECRETS__: {
+    [name: string]: Secret;
+  };
+}
+
 // a global registry of all secrets that we will use when serializing an application
 const globalSecrets: {
   [name: string]: Secret;
-} = {};
+} = (globalThis.__ALCHEMY_SECRETS__ ??= {});
 
 let i = 0;
 function nextName() {

package/src/util/content-type.ts

@@ -2,34 +2,35 @@ import path from "node:path";
 
 // Common MIME types
 const mimeTypes: Record<string, string> = {
-  ".html": "text/html",
-  ".htm": "text/html",
   ".css": "text/css",
+  ".eot": "application/vnd.ms-fontobject",
+  ".gif": "image/gif",
+  ".htm": "text/html",
+  ".html": "text/html",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js.map": "application/source-map",
   ".js": "application/javascript",
-  ".mjs": "application/javascript+module",
   ".json": "application/json",
-  ".xml": "application/xml",
-  ".txt": "text/plain",
   ".md": "text/markdown",
+  ".mjs": "application/javascript+module",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".otf": "font/otf",
+  ".pdf": "application/pdf",
   ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
   ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".pdf": "application/pdf",
-  ".zip": "application/zip",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
   ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".eot": "application/vnd.ms-fontobject",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
+  ".txt": "text/plain",
   ".wasm": "application/wasm",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".xml": "application/xml",
+  ".zip": "application/zip",
 };
 
 /**
@@ -39,5 +40,8 @@ const mimeTypes: Record<string, string> = {
  * @returns The content type for the file
  */
 export function getContentType(filePath: string): string | undefined {
+  if (filePath.endsWith(".js.map")) {
+    return mimeTypes[".js.map"];
+  }
   return mimeTypes[path.extname(filePath).toLowerCase()];
 }