alchemy 0.16.9 → 0.17.0

package/src/cloudflare/wrangler.json.ts

@@ -1,6 +1,7 @@
 import type { Context } from "../context.js";
 import { StaticJsonFile } from "../fs/static-json-file.js";
 import { Resource } from "../resource.js";
+import { assertNever } from "../util/assert-never.js";
 import { Self, type Bindings } from "./bindings.js";
 import type { DurableObjectNamespace } from "./durable-object-namespace.js";
 import type { EventSource } from "./event-source.js";
@@ -66,7 +67,7 @@ export const WranglerJson = Resource(
   "cloudflare::WranglerJson",
   async function (
     this: Context<WranglerJson>,
-    id: string,
+    _id: string,
     props: WranglerJsonProps,
   ): Promise<WranglerJson> {
     // Default path is wrangler.json in current directory
@@ -103,6 +104,10 @@ export const WranglerJson = Resource(
       spec.vars = { ...worker.env };
     }
 
+    if (worker.crons && worker.crons.length > 0) {
+      spec.triggers = { crons: worker.crons };
+    }
+
     await StaticJsonFile(filePath, spec);
 
     // Return the resource
@@ -150,6 +155,13 @@ export interface WranglerJsonSpec {
    */
   routes?: string[];
 
+  /**
+   * Scheduled triggers for the worker
+   */
+  triggers?: {
+    crons: string[];
+  };
+
   /**
    * AI bindings
    */
@@ -291,6 +303,21 @@ export interface WranglerJsonSpec {
    * Whether to minify the worker script
    */
   minify?: boolean;
+
+  /**
+   * Analytics Engine datasets
+   */
+  analytics_engine_datasets?: { binding: string; dataset: string }[];
+
+  /**
+   * Hyperdrive bindings
+   */
+  hyperdrive?: { binding: string; id: string; localConnectionString: string }[];
+
+  /**
+   * Pipelines
+   */
+  pipelines?: { binding: string; pipeline: string }[];
 }
 
 /**
@@ -340,6 +367,13 @@ function processBindings(
   const new_classes: string[] = [];
 
   const vectorizeIndexes: { binding: string; index_name: string }[] = [];
+  const analyticsEngineDatasets: { binding: string; dataset: string }[] = [];
+  const hyperdrive: {
+    binding: string;
+    id: string;
+    localConnectionString: string;
+  }[] = [];
+  const pipelines: { binding: string; pipeline: string }[] = [];
 
   for (const eventSource of eventSources ?? []) {
     if (isQueueEventSource(eventSource)) {
@@ -375,7 +409,7 @@ function processBindings(
       // Service binding
       services.push({
         binding: bindingName,
-        service: binding.id,
+        service: binding.name,
       });
     } else if (binding.type === "kv_namespace") {
       // KV Namespace binding
@@ -450,6 +484,33 @@ function processBindings(
       spec.ai = {
         binding: bindingName,
       };
+    } else if (binding.type === "analytics_engine") {
+      analyticsEngineDatasets.push({
+        binding: bindingName,
+        dataset: binding.dataset,
+      });
+    } else if (binding.type === "ai_gateway") {
+      // no-op
+    } else if (binding.type === "hyperdrive") {
+      const password =
+        "password" in binding.origin
+          ? binding.origin.password.unencrypted
+          : binding.origin.access_client_secret.unencrypted;
+      hyperdrive.push({
+        binding: bindingName,
+        id: binding.hyperdriveId,
+        localConnectionString: `${binding.origin.scheme || "postgres"}://${binding.origin.user}:${password}@${binding.origin.host}:${binding.origin.port || 5432}/${binding.origin.database}`,
+      });
+    } else if (binding.type === "pipeline") {
+      pipelines.push({
+        binding: bindingName,
+        pipeline: binding.name,
+      });
+    } else if (binding.type === "json") {
+      // TODO(sam): anything to do here? not sure wrangler.json supports this
+    } else {
+      // biome-ignore lint/correctness/noVoidTypeReturn: it returns never
+      return assertNever(binding);
     }
   }
 
@@ -497,4 +558,16 @@ function processBindings(
   if (workflows.length > 0) {
     spec.workflows = workflows;
   }
+
+  if (analyticsEngineDatasets.length > 0) {
+    spec.analytics_engine_datasets = analyticsEngineDatasets;
+  }
+
+  if (hyperdrive.length > 0) {
+    spec.hyperdrive = hyperdrive;
+  }
+
+  if (pipelines.length > 0) {
+    spec.pipelines = pipelines;
+  }
 }

package/src/cloudflare/zone.ts

@@ -305,7 +305,7 @@ export const Zone = Resource(
   "cloudflare::Zone",
   async function (
     this: Context<Zone>,
-    id: string,
+    _id: string,
     props: ZoneProps,
   ): Promise<Zone> {
     // Create Cloudflare API client with automatic account discovery

package/src/destroy.ts

@@ -39,11 +39,11 @@ export async function destroy<Type extends string>(
     } satisfies DestroyOptions;
 
     // destroy all active resources
-    await destroy.all(Array.from(scope.resources.values()), options);
+    await destroyAll(Array.from(scope.resources.values()), options);
 
     // then detect orphans and destroy them
     const orphans = await scope.state.all();
-    await destroy.all(
+    await destroyAll(
       Object.values(orphans).map((orphan) => ({
         ...orphan.output,
         Scope: scope,
@@ -151,27 +151,16 @@ export async function destroy<Type extends string>(
   }
 }
 
-export namespace destroy {
-  export async function all(resources: Resource[], options?: DestroyOptions) {
-    if (options?.strategy !== "parallel") {
-      const sorted = resources.sort((a, b) => b[ResourceSeq] - a[ResourceSeq]);
-      for (const resource of sorted) {
-        await destroy(resource, options);
-      }
-    } else {
-      await Promise.all(
-        resources.map((resource) => destroy(resource, options)),
-      );
-    }
-  }
-
-  export async function sequentially(
-    ...resources: (Resource<string> | undefined | null)[]
-  ) {
-    for (const resource of resources) {
-      if (resource) {
-        await destroy(resource);
-      }
+export async function destroyAll(
+  resources: Resource[],
+  options?: DestroyOptions,
+) {
+  if (options?.strategy !== "parallel") {
+    const sorted = resources.sort((a, b) => b[ResourceSeq] - a[ResourceSeq]);
+    for (const resource of sorted) {
+      await destroy(resource, options);
     }
+  } else {
+    await Promise.all(resources.map((resource) => destroy(resource, options)));
   }
 }

package/src/dns/import-dns.ts

@@ -133,7 +133,7 @@ export const ImportDnsRecords = Resource(
   "dns::ImportDnsRecords",
   async function (
     this: Context<ImportDnsRecords>,
-    id: string,
+    _id: string,
     props: ImportDnsRecordsProps,
   ): Promise<ImportDnsRecords> {
     // For delete phase, just return destroyed state since this is a read-only resource

package/src/encrypt.ts

@@ -1,5 +1,3 @@
-import sodium from "libsodium-wrappers";
-
 /**
  * Encrypt a value with a symmetric key using libsodium
  *
@@ -8,6 +6,7 @@ import sodium from "libsodium-wrappers";
  * @returns The base64-encoded encrypted value with nonce
  */
 export async function encrypt(value: string, key: string): Promise<string> {
+  const sodium = (await import("libsodium-wrappers")).default;
   // Initialize libsodium
   await sodium.ready;
 
@@ -46,6 +45,7 @@ export async function decryptWithKey(
   encryptedValue: string,
   key: string,
 ): Promise<string> {
+  const sodium = (await import("libsodium-wrappers")).default;
   // Initialize libsodium
   await sodium.ready;
 

package/src/env.ts

@@ -16,16 +16,23 @@ async function _env<T = string>(
   if (value !== undefined) {
     return value;
   }
+  const env = await resolveEnv();
+  if (name in env) {
+    return env[name] as T;
+  }
+  throw new Error(error ?? `Environment variable ${name} is not set`);
+}
+
+async function resolveEnv(): Promise<Record<string, any>> {
   if (typeof process !== "undefined") {
-    // we are in a node environment
-    return process.env[name]! as T;
+    return process.env;
   }
-  // we are in a browser environment
   try {
     const { env } = await import("cloudflare:workers");
-    if (name in env) {
-      return env[name as keyof typeof env] as T;
-    }
-  } catch (error) {}
-  throw new Error(error ?? `Environment variable ${name} is not set`);
+    return env;
+  } catch (_error) {}
+  if (typeof import.meta !== "undefined") {
+    return import.meta.env;
+  }
+  throw new Error("No environment found");
 }

package/src/esbuild/bundle.ts

@@ -1,4 +1,4 @@
-import esbuild from "esbuild";
+import type esbuild from "esbuild";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -122,7 +122,7 @@ export const Bundle = Resource(
   },
   async function <Props extends BundleProps>(
     this: Context<Bundle<any>>,
-    id: string,
+    _id: string,
     props: Props,
   ): Promise<Bundle<Props>> {
     if (this.phase === "delete") {
@@ -193,7 +193,7 @@ export async function bundle(props: BundleProps) {
     // write:
     //   props.outdir === undefined && props.outfile === undefined ? false : true,
     // write: false,
-    entryPoints: [props.entryPoint],
+    entryPoints: [entryPoint],
     outdir: props.outdir ? props.outdir : props.outfile ? undefined : ".out",
     outfile: props.outfile,
     bundle: true,
@@ -208,5 +208,6 @@ export async function bundle(props: BundleProps) {
   if (process.env.DEBUG) {
     console.log(options);
   }
+  const esbuild = await import("esbuild");
   return await esbuild.build(options);
 }

package/src/fs/copy-file.ts

@@ -63,7 +63,7 @@ export const CopyFile = Resource(
   "fs::CopyFile",
   async function (
     this: Context<CopyFile>,
-    id: string,
+    _id: string,
     props: CopyFileProps,
   ): Promise<CopyFile> {
     const { src, dest, overwrite = true } = props;

package/src/github/client.ts

@@ -17,7 +17,7 @@ export async function getGitHubTokenFromCLI(): Promise<string | null> {
     // Get the auth token
     const { stdout: token } = await execAsync("gh auth token");
     return token?.trim() || null;
-  } catch (error) {
+  } catch (_error) {
     return null;
   }
 }

package/src/github/repository-environment.ts

@@ -173,7 +173,7 @@ export const RepositoryEnvironment = Resource(
   "github::RepositoryEnvironment",
   async function (
     this: Context<RepositoryEnvironment>,
-    id: string,
+    _id: string,
     props: RepositoryEnvironmentProps,
   ): Promise<RepositoryEnvironment> {
     // Create authenticated Octokit client
@@ -210,7 +210,7 @@ export const RepositoryEnvironment = Resource(
     }
     try {
       // Check if the environment already exists
-      let environmentId: number | undefined = undefined; // Use undefined instead of 0
+      let environmentId: number | undefined; // Use undefined instead of 0
       try {
         const { data: environments } =
           await octokit.rest.repos.getAllEnvironments({

package/src/github/secret.ts

@@ -134,7 +134,7 @@ export const GitHubSecret = Resource(
   "github::Secret",
   async function (
     this: Context<GitHubSecretOutput>,
-    id: string,
+    _id: string,
     props: GitHubSecretProps,
   ): Promise<GitHubSecretOutput> {
     // Create authenticated Octokit client - will automatically handle token resolution

package/src/internal/docs/providers.ts

@@ -52,7 +52,7 @@ export type Providers = {
 export async function Providers({
   srcDir,
   outDir,
-  filter,
+  // filter,
   parallel = true,
 }: DocsProps): Promise<Providers> {
   outDir = typeof outDir === "string" ? outDir : outDir.path;

package/src/neon/api-error.ts

@@ -53,11 +53,11 @@ export async function handleApiError(
 
   try {
     errorData = await response.json();
-  } catch (e) {
+  } catch (_e) {
     // If we can't parse JSON, just use the response text
     try {
       errorData = { message: await response.text() };
-    } catch (textError) {
+    } catch (_textError) {
       errorData = { message: response.statusText };
     }
   }

package/src/os/exec.ts

@@ -218,7 +218,7 @@ export const Exec = Resource(
       }
 
       // Wait for the process to complete
-      exitCode = await new Promise<number>((resolve, reject) => {
+      exitCode = await new Promise<number>((resolve, _reject) => {
         childProcess.on("close", (code) => {
           resolve(code || 0);
         });

package/src/resource.ts

@@ -1,6 +1,6 @@
 import { apply } from "./apply.js";
 import type { Context } from "./context.js";
-import { Scope as _Scope } from "./scope.js";
+import { Scope as _Scope, type Scope } from "./scope.js";
 
 export const PROVIDERS = new Map<ResourceKind, Provider<string, any>>();
 
@@ -11,6 +11,7 @@ export const ResourceFQN = Symbol.for("alchemy::ResourceFQN");
 export type ResourceKind = string;
 export const ResourceKind = Symbol.for("alchemy::ResourceKind");
 export const ResourceScope = Symbol.for("alchemy::ResourceScope");
+export const InnerResourceScope = Symbol.for("alchemy::InnerResourceScope");
 export const ResourceSeq = Symbol.for("alchemy::ResourceSeq");
 
 export interface ProviderOptions {
@@ -34,35 +35,21 @@ export type Provider<
     handler: F;
   };
 
-export type PendingResource<
-  Out = unknown,
-  Kind extends ResourceKind = ResourceKind,
-  ID extends ResourceID = ResourceID,
-  FQN extends ResourceFQN = ResourceFQN,
-  Scope extends _Scope = _Scope,
-  Seq extends number = number,
-> = Promise<Out> & {
-  [ResourceKind]: Kind;
-  [ResourceID]: ID;
-  [ResourceFQN]: FQN;
+export interface PendingResource<Out = unknown> extends Promise<Out> {
+  [ResourceKind]: ResourceKind;
+  [ResourceID]: ResourceID;
+  [ResourceFQN]: ResourceFQN;
   [ResourceScope]: Scope;
-  [ResourceSeq]: Seq;
-};
+  [ResourceSeq]: number;
+  [InnerResourceScope]: Promise<Scope>;
+}
 
-export interface Resource<
-  // give each name types for syntax highlighting (differentiation)
-  Kind extends ResourceKind = ResourceKind,
-  ID extends ResourceID = ResourceID,
-  FQN extends ResourceFQN = ResourceFQN,
-  Scope extends _Scope = _Scope,
-  Seq extends number = number,
-> {
-  // use capital letters to avoid collision with conventional camelCase typescript properties
+export interface Resource<Kind extends ResourceKind = ResourceKind> {
   [ResourceKind]: Kind;
-  [ResourceID]: ID;
-  [ResourceFQN]: FQN;
+  [ResourceID]: ResourceID;
+  [ResourceFQN]: ResourceFQN;
   [ResourceScope]: Scope;
-  [ResourceSeq]: Seq;
+  [ResourceSeq]: number;
 }
 
 // helper for semantic syntax highlighting (color as a type/class instead of function/value)
@@ -102,7 +89,7 @@ export function Resource<
 
   type Out = Awaited<ReturnType<F>>;
 
-  const provider = ((
+  const provider = (async (
     resourceID: string,
     props: ResourceProps,
   ): Promise<Resource<string>> => {
@@ -123,21 +110,25 @@ export function Resource<
           `Resource ${resourceID} already exists in the stack and is of a different type: '${otherResource?.[ResourceKind]}' !== '${type}'`,
         );
       }
-      // console.warn(
-      //   `Resource ${resourceID} already exists in the stack: ${scope.chain.join("/")}`,
-      // );
     }
 
     // get a sequence number (unique within the scope) for the resource
     const seq = scope.seq();
+    let resolveInnerScope: ((scope: Scope) => void) | undefined;
     const meta = {
       [ResourceKind]: type,
       [ResourceID]: resourceID,
       [ResourceFQN]: scope.fqn(resourceID),
       [ResourceSeq]: seq,
       [ResourceScope]: scope,
+      [InnerResourceScope]: new Promise<Scope>((resolve) => {
+        resolveInnerScope = resolve;
+      }),
     } as any as PendingResource<Out>;
-    const promise = apply(meta, props, options);
+    const promise = apply(meta, props, {
+      ...options,
+      resolveInnerScope,
+    });
     const resource = Object.assign(promise, meta);
     scope.resources.set(resourceID, resource);
     return resource;

package/src/runtime/bind.ts

@@ -0,0 +1,95 @@
+import { isPromise } from "node:util/types";
+import type { Binding as CloudflareBinding } from "../cloudflare/bindings.js";
+import type { Bound as CloudflareBound } from "../cloudflare/bound.js";
+import { isWorkerStub } from "../cloudflare/worker-stub.js";
+import { isWorker } from "../cloudflare/worker.js";
+import { env } from "../env.js";
+import { ResourceFQN, ResourceScope, type Resource } from "../resource.js";
+import { isRuntime } from "./global.js";
+
+/**
+ * Get a Resource's Binding from the Environment.
+ */
+export function getBinding<T extends Resource>(resource: T): Promise<Bound<T>> {
+  return env[getBindKey(resource)] as Promise<Bound<T>>;
+}
+
+export function tryGetBinding<T extends Resource>(
+  resource: T,
+): Promise<Bound<T>> | undefined {
+  if (isRuntime) {
+    return getBinding(resource);
+  }
+  return undefined;
+}
+
+/**
+ * Compute a unique key for where to store a Resource's Binding.
+ */
+export function getBindKey(resource: Resource): string {
+  if (isWorker(resource) || isWorkerStub(resource)) {
+    return `worker:${resource.name}`;
+  }
+  const fqn = resource[ResourceFQN];
+  const scope = resource[ResourceScope];
+  const prefix = `${scope.appName}/${scope.stage}`;
+  const key = fqn.slice(prefix.length + 1).replace(/[^a-zA-Z0-9-_]/g, "_");
+  return key;
+}
+
+export type Bound<T> = T extends CloudflareBinding ? CloudflareBound<T> : T;
+
+/**
+ * Create a lazy binding of a Resource to an environment that exposes the Resource's methods
+ * throw a Proxy that delays initialization of the binding until the Resource's methods are accessed.
+ *
+ * This allows us to run the same code during build time and runtime.
+ */
+export async function bind<T extends Resource>(
+  resource: T | Promise<T>,
+  options?: {
+    reify?: (value: T, key: string) => Promise<Bound<T>>;
+    /** @default true */
+    bindThis?: boolean;
+  },
+): Promise<Bound<T>> {
+  if (isPromise(resource)) {
+    return resource.then((r) => bind(r, options)) as Promise<Bound<T>>;
+  }
+  let _runtime: [Bound<T>] | undefined;
+  const runtime = async (): Promise<Bound<T>> =>
+    (_runtime ??= [
+      await (options?.reify
+        ? options.reify(resource, getBindKey(resource))
+        : getBinding(resource)),
+    ])[0];
+
+  return new Proxy(() => {}, {
+    get: (target: any, prop: string) => {
+      if (prop in target) {
+        return (resource as T)[prop as keyof T];
+      } else if (prop === "then" || prop === "catch" || prop === "finally") {
+        return target[prop];
+      }
+      return async (...args: any[]) => {
+        const rt: Bound<T> = await runtime();
+        if (rt === undefined) {
+          throw new Error(`Resource ${resource[ResourceFQN]} is not bound`);
+        }
+        const method = rt[prop as keyof Bound<T>];
+        if (typeof method !== "function") {
+          throw new Error(
+            `Method ${prop} on '${resource[ResourceFQN]}' is not a function`,
+          );
+        }
+        if (options?.bindThis !== false) {
+          return method.bind(rt)(...args);
+        }
+        return method(...args);
+      };
+    },
+    // apply: (target, thisArg, argArray) => {
+    //   return target(thisArg, ...argArray);
+    // },
+  }) as T & Bound<T>;
+}

package/src/runtime/global.ts

@@ -0,0 +1,10 @@
+import type { SerializedScope } from "../serde.js";
+
+declare global {
+  const __ALCHEMY_WORKER_NAME__: string;
+  const __ALCHEMY_RUNTIME__: true;
+  const __ALCHEMY_SERIALIZED_SCOPE__: SerializedScope;
+}
+
+// __ALCHEMY_SERIALIZED_SCOPE__ is injected by esbuild when bundling a Worker
+export const isRuntime = typeof __ALCHEMY_RUNTIME__ !== "undefined";