alchemy 0.55.3 → 0.57.0

package/src/random/random-string.ts

@@ -0,0 +1,126 @@
+import { alchemy } from "../alchemy.ts";
+import { Resource } from "../resource.ts";
+import type { Secret } from "../secret.ts";
+
+/**
+ * Properties for configuring a random string generation
+ */
+export interface RandomStringProps {
+  /**
+   * The number of random bytes to generate.
+   * The actual string length will depend on the encoding:
+   * - hex: length * 2 characters
+   * - base64: approximately length * 1.33 characters
+   * @default 32
+   */
+  length?: number;
+
+  /**
+   * The encoding format for the random string.
+   * - "hex": Hexadecimal encoding (0-9, a-f)
+   * - "base64": Base64 encoding (A-Z, a-z, 0-9, +, /)
+   * @default "hex"
+   */
+  encoding?: "hex" | "base64";
+}
+
+/**
+ * A cryptographically secure random string resource
+ */
+export interface RandomString extends Resource<"random::String"> {
+  /**
+   * The generated random string value, stored as a secret
+   */
+  value: Secret;
+
+  /**
+   * The length of the random string
+   */
+  length: number;
+
+  /**
+   * The encoding format of the random string
+   */
+  encoding: "hex" | "base64";
+}
+
+/**
+ * Generates a cryptographically secure random string that can be used
+ * for API keys, tokens, passwords, or other security-sensitive values.
+ * The generated value is automatically wrapped as a secret to prevent
+ * accidental exposure in logs or console output.
+ *
+ * @example
+ * // Generate a default random string (32 bytes, hex encoded)
+ * const apiKey = await RandomString("api-key");
+ * // Result: 64 character hex string (e.g., "a1b2c3d4...")
+ *
+ * @example
+ * // Generate a shorter random string for a verification code
+ * const verificationCode = await RandomString("email-verification", {
+ *   length: 8,
+ *   encoding: "hex"
+ * });
+ * // Result: 16 character hex string
+ *
+ * @example
+ * // Generate a base64-encoded random string for a session token
+ * const sessionToken = await RandomString("session-token", {
+ *   length: 48,
+ *   encoding: "base64"
+ * });
+ * // Result: ~64 character base64 string
+ *
+ * @example
+ * // Use with other resources that require secrets
+ * const database = await PostgresDatabase("mydb", {
+ *   name: "production",
+ *   password: (await RandomString("db-password")).value
+ * });
+ *
+ * @example
+ * // Generate multiple unique secrets
+ * const jwtSecret = await RandomString("jwt-secret", { length: 64 });
+ * const encryptionKey = await RandomString("encryption-key", {
+ *   length: 32,
+ *   encoding: "base64"
+ * });
+ *
+ * @param id - Unique identifier for this random string resource
+ * @param props - Configuration options for the random string generation
+ * @returns A RandomString resource containing the generated secret value
+ */
+export const RandomString = Resource(
+  "random::String",
+  async function (
+    _id: string,
+    props: RandomStringProps = {},
+  ): Promise<RandomString> {
+    if (this.phase === "delete") {
+      return this.destroy();
+    }
+    const length = props.length ?? 32;
+    const encoding = props.encoding ?? "hex";
+
+    if (
+      this.phase === "update" &&
+      this.props.length === length &&
+      this.props.encoding === encoding
+    ) {
+      // this is an update (input props changed)
+      // but the length and encoding did not change
+      // so, we can just return the existing output (no-op)
+      return this(this.output);
+    }
+    const crypto = await import("node:crypto");
+    return this({
+      length,
+      encoding,
+      value: alchemy.secret(
+        crypto
+          .randomBytes(props.length ?? 32)
+          .toString(props.encoding ?? "hex"),
+      ),
+    });
+  },
+);

package/src/runtime/bind.ts

@@ -10,8 +10,8 @@ import { isRuntime } from "./global.ts";
 /**
  * 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 getBinding<T extends Resource>(resource: T): Bound<T> {
+  return env[getBindKey(resource)] as Bound<T>;
 }
 
 export function tryGetBinding<T extends Resource>(

package/src/scope.ts

@@ -1,3 +1,4 @@
+import kleur from "kleur";
 import { AsyncLocalStorage } from "node:async_hooks";
 import util from "node:util";
 import type { Phase } from "./alchemy.ts";
@@ -144,6 +145,7 @@ export class Scope {
   private finalized = false;
   private startedAt = performance.now();
   private deferred: (() => Promise<any>)[] = [];
+  private cleanups: (() => Promise<void>)[] = [];
 
   public get appName(): string {
     if (this.parent) {
@@ -466,6 +468,7 @@ export class Scope {
     });
 
     if (!this.parent && process.env.ALCHEMY_TEST_KILL_ON_FINALIZE) {
+      await this.cleanup();
       process.exit(0);
     }
   }
@@ -537,6 +540,28 @@ export class Scope {
     return promise;
   }
 
+  /**
+   * Run all cleanup functions registered with `onCleanup`.
+   * This should only be called on the root scope.
+   */
+  public async cleanup() {
+    if (this.parent || this.cleanups.length === 0) return;
+    this.logger.log(kleur.gray("Exiting..."));
+    await Promise.allSettled(this.cleanups.map((cleanup) => cleanup()));
+  }
+
+  /**
+   * Register a cleanup function that will be called when the process exits.
+   * This should only be called on the root scope.
+   */
+  public onCleanup(fn: () => Promise<void>) {
+    if (this.parent) {
+      this.root.onCleanup(fn);
+      return;
+    }
+    this.cleanups.push(fn);
+  }
+
   /**
    * Returns a string representation of the scope.
    */

package/src/secret.ts

@@ -123,8 +123,8 @@ export function secret<S = string>(
 
 export namespace secret {
   export interface Env {
-    [key: string]: Promise<Secret>;
-    (name: string, value?: string, error?: string): Promise<Secret>;
+    [key: string]: Secret;
+    (name: string, value?: string, error?: string): Secret;
   }
 
   export const env = new Proxy(_env, {
@@ -132,12 +132,8 @@ export namespace secret {
     apply: (_, __, args: [string, any?, string?]) => _env(...args),
   }) as Env;
 
-  async function _env(
-    name: string,
-    value?: string,
-    error?: string,
-  ): Promise<Secret> {
-    const result = await alchemy.env(name, value, error);
+  function _env(name: string, value?: string, error?: string): Secret {
+    const result = alchemy.env(name, value, error);
     if (typeof result === "string") {
       return secret(result, name);
     }

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

@@ -105,11 +105,11 @@ const provision = memoize(
     const scriptName = options.scriptName ?? "alchemy-state-service";
     const token =
       options.stateToken ??
-      (await alchemy.secret.env(
+      alchemy.secret.env(
         "ALCHEMY_STATE_TOKEN",
         undefined,
         "Missing token for DOStateStore. Please set ALCHEMY_STATE_TOKEN in the environment or set the `stateToken` option in the DOStateStore constructor.",
-      ));
+      );
 
     const api = await createCloudflareApi(options);
     const [bundle, settings, subdomain] = await Promise.all([

package/src/state/dofs-state-store/index.ts

@@ -66,7 +66,7 @@ export class DOFSStateStore implements StateStore {
   private async createClient() {
     const token =
       this.options.worker?.token ??
-      (await alchemy.secret.env.ALCHEMY_STATE_TOKEN).unencrypted;
+      alchemy.secret.env.ALCHEMY_STATE_TOKEN.unencrypted;
     if (this.options.worker && "url" in this.options.worker) {
       const client = new DOFSStateStoreClient({
         app: this.scope.appName ?? "alchemy",

package/src/util/detect-package-manager.ts

@@ -34,3 +34,14 @@ export async function detectPackageManager(
 
   return "npm";
 }
+
+export async function getPackageManagerRunner(): Promise<string> {
+  const packageManager = await detectPackageManager();
+  return {
+    bun: "bun run",
+    pnpm: "pnpm",
+    yarn: "yarn",
+    npm: "npx",
+    deno: "deno run",
+  }[packageManager];
+}

package/src/util/telemetry/client.ts

@@ -10,7 +10,7 @@ import type { Telemetry } from "./types.ts";
 
 export interface TelemetryClientOptions {
   sessionId: string;
-  phase: Phase;
+  phase?: Phase;
   enabled: boolean;
   quiet: boolean;
 }
@@ -85,7 +85,28 @@ export class TelemetryClient implements ITelemetryClient {
     if (events.length === 0) {
       return;
     }
-    const { userId, ...context } = await this.context;
+    const { userId, projectId, ...context } = await this.context;
+    const safeProjectId = projectId ?? `temp_${userId}`;
+    const groupResponse = await fetch(`${POSTHOG_CLIENT_API_HOST}/i/v0/e/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        api_key: POSTHOG_PROJECT_ID,
+        event: "$groupidentify",
+        distinct_id: "project-identify",
+        properties: {
+          $group_type: "project",
+          $group_key: safeProjectId,
+        },
+      }),
+    });
+    if (!groupResponse.ok) {
+      throw new Error(
+        `Failed to send group identify: ${groupResponse.status} ${groupResponse.statusText} - ${await groupResponse.text()}`,
+      );
+    }
     const response = await fetch(`${POSTHOG_CLIENT_API_HOST}/batch`, {
       method: "POST",
       headers: {
@@ -100,6 +121,8 @@ export class TelemetryClient implements ITelemetryClient {
             distinct_id: userId,
             ...context,
             ...properties,
+            projectId: safeProjectId,
+            $groups: { project: safeProjectId },
           },
           timestamp: new Date(timestamp).toISOString(),
         })),

package/src/util/telemetry/constants.ts

@@ -1,8 +1,6 @@
-import xdgAppPaths from "xdg-app-paths";
+import envPaths from "env-paths";
 
-const xdg = xdgAppPaths("alchemy");
-
-export const CONFIG_DIR = xdg.config();
+export const CONFIG_DIR = envPaths("alchemy", { suffix: "" }).config;
 
 export const TELEMETRY_DISABLED =
   !!process.env.ALCHEMY_TELEMETRY_DISABLED || !!process.env.DO_NOT_TRACK;

package/src/util/telemetry/context.ts

@@ -132,7 +132,7 @@ function environment(): Telemetry.Context["environment"] {
 
 export async function context(input: {
   sessionId: string;
-  phase: Phase;
+  phase?: Phase;
 }): Promise<Telemetry.Context> {
   const env = environment();
   const [uid, pid] = await Promise.all([

package/src/util/telemetry/types.ts

@@ -29,7 +29,7 @@ export namespace Telemetry {
 
     alchemy: {
       version: string;
-      phase: Phase;
+      phase?: Phase;
     };
   }
 
@@ -72,6 +72,11 @@ export namespace Telemetry {
     replaced?: boolean;
   }
 
+  export interface CliEvent extends BaseEvent {
+    event: "cli.start" | "cli.success" | "cli.error";
+    command: string;
+  }
+
   export interface StateStoreEvent extends BaseEvent {
     event:
       | "stateStore.init"
@@ -88,11 +93,12 @@ export namespace Telemetry {
     error?: SerializedError;
   }
 
-  export type Event = AppEvent | ResourceEvent | StateStoreEvent;
+  export type Event = AppEvent | ResourceEvent | StateStoreEvent | CliEvent;
   export type EventInput = (
     | Omit<AppEvent, "timestamp" | "error">
     | Omit<ResourceEvent, "timestamp" | "error">
     | Omit<StateStoreEvent, "timestamp" | "error">
+    | Omit<CliEvent, "timestamp" | "error">
   ) & {
     error?: ErrorInput;
   };

package/src/vercel/api.ts

@@ -26,10 +26,8 @@ export interface VercelApiOptions {
 export async function createVercelApi(
   options: VercelApiOptions,
 ): Promise<VercelApi> {
-  const {
-    accessToken = await alchemy.secret.env.VERCEL_ACCESS_TOKEN,
-    baseUrl,
-  } = options;
+  const { accessToken = alchemy.secret.env.VERCEL_ACCESS_TOKEN, baseUrl } =
+    options;
 
   return new VercelApi({
     baseUrl,

package/templates/astro/alchemy.run.ts

@@ -5,9 +5,7 @@ import { Astro } from "alchemy/cloudflare";
 
 const app = await alchemy("my-alchemy-app");
 
-export const worker = await Astro("website", {
-  command: "bun run build",
-});
+export const worker = await Astro("website");
 
 console.log({
   url: worker.url,

package/templates/astro/astro.config.mjs

@@ -1,8 +1,8 @@
+import alchemy from 'alchemy/cloudflare/astro';
 import { defineConfig } from 'astro/config';
-import cloudflare from '@astrojs/cloudflare';
 
 // https://astro.build/config
 export default defineConfig({
   output: 'server',
-  adapter: cloudflare(),
+  adapter: alchemy(),
 });

package/templates/nuxt/alchemy.run.ts

@@ -5,9 +5,7 @@ import { Nuxt } from "alchemy/cloudflare";
 
 const app = await alchemy("my-alchemy-app");
 
-export const worker = await Nuxt("website", {
-  command: "bun run build",
-});
+export const worker = await Nuxt("website");
 
 console.log({
   url: worker.url,

package/templates/nuxt/nuxt.config.ts

@@ -1,13 +1,12 @@
+import alchemy from "alchemy/cloudflare/nuxt";
+import { defineNuxtConfig } from "nuxt/config";
+
 // https://nuxt.com/docs/api/configuration/nuxt-config
 export default defineNuxtConfig({
-  compatibilityDate: '2025-05-15',
   devtools: { enabled: true },
   nitro: {
     preset: "cloudflare_module",
-    cloudflare: {
-      deployConfig: true,
-      nodeCompat: true
-    }
+    cloudflare: alchemy(),
   },
   modules: ["nitro-cloudflare-dev"],
 });

package/templates/nuxt/package.json

@@ -8,7 +8,6 @@
     "destroy": "alchemy destroy",
     "dev": "alchemy dev",
     "generate": "nuxt generate",
-    "postinstall": "nuxt prepare",
     "preview": "nuxt preview"
   },
   "dependencies": {

package/templates/react-router/alchemy.run.ts

@@ -5,10 +5,7 @@ import { ReactRouter } from "alchemy/cloudflare";
 
 const app = await alchemy("my-alchemy-app");
 
-export const worker = await ReactRouter("website", {
-  main: "workers/app.ts",
-  command: "bun run build",
-});
+export const worker = await ReactRouter("website");
 
 console.log({
   url: worker.url,

package/templates/react-router/vite.config.ts

@@ -1,12 +1,12 @@
 import { reactRouter } from "@react-router/dev/vite";
-import { cloudflare } from "@cloudflare/vite-plugin";
 import tailwindcss from "@tailwindcss/vite";
+import alchemy from "alchemy/cloudflare/react-router";
 import { defineConfig } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
 
 export default defineConfig({
   plugins: [
-    cloudflare({ viteEnvironment: { name: "ssr" } }),
+    alchemy(),
     tailwindcss(),
     reactRouter(),
     tsconfigPaths(),

package/templates/rwsdk/alchemy.run.ts

@@ -11,7 +11,6 @@ const database = await D1Database("database", {
 
 export const worker = await Redwood("website", {
   name: "my-alchemy-app-website",
-  command: "bun run build",
   bindings: {
     AUTH_SECRET_KEY: alchemy.secret(process.env.AUTH_SECRET_KEY),
     DB: database,

package/templates/rwsdk/package.json

@@ -16,7 +16,6 @@
     "deploy": "alchemy deploy",
     "destroy": "alchemy destroy",
     "dev": "alchemy dev",
-    "dev:init": "rw-scripts dev-init",
     "generate": "rw-scripts ensure-env && prisma generate && wrangler types",
     "migrate:dev": "prisma generate && wrangler d1 migrations apply DB --local",
     "migrate:new": "rw-scripts migrate-new",
@@ -24,7 +23,6 @@
     "prepare": "vibe-rules install cursor",
     "preview": "vite preview",
     "release": "rw-scripts ensure-deploy-env && npm run clean && prisma generate && RWSDK_DEPLOY=1 npm run build && wrangler deploy",
-    "seed": "npm run worker:run ./src/scripts/seed.ts",
     "types": "tsc",
     "worker:run": "rw-scripts worker-run"
   },

package/templates/rwsdk/vite.config.mts

@@ -1,6 +1,6 @@
+import alchemyRedwood from "alchemy/cloudflare/redwood";
 import { defineConfig } from "vite";
-import { redwood } from "rwsdk/vite";
 
 export default defineConfig({
-  plugins: [redwood()],
+  plugins: [alchemyRedwood()],
 });

package/templates/sveltekit/alchemy.run.ts

@@ -5,9 +5,7 @@ import { SvelteKit } from "alchemy/cloudflare";
 
 const app = await alchemy("my-alchemy-app");
 
-export const worker = await SvelteKit("website", {
-  command: "bun run build",
-});
+export const worker = await SvelteKit("website");
 
 console.log({
   url: worker.url,

package/templates/sveltekit/svelte.config.js

@@ -1,11 +1,11 @@
-import adapter from '@sveltejs/adapter-cloudflare';
 import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+import alchemy from 'alchemy/cloudflare/sveltekit';
 
 /** @type {import('@sveltejs/kit').Config} */
 const config = {
   preprocess: vitePreprocess(),
   kit: {
-    adapter: adapter()
+    adapter: alchemy()
   }
 };
 

package/templates/tanstack-start/vite.config.ts

@@ -1,7 +1,7 @@
 import tailwindcss from "@tailwindcss/vite";
 import { tanstackStart } from "@tanstack/react-start/plugin/vite";
 import viteReact from "@vitejs/plugin-react";
-import { cloudflareWorkersDevEnvironmentShim } from "alchemy/cloudflare";
+import alchemy from "alchemy/cloudflare/tanstack-start";
 import { defineConfig, PluginOption } from "vite";
 import tsConfigPaths from "vite-tsconfig-paths";
 
@@ -17,7 +17,7 @@ export default defineConfig({
   },
   plugins: [
     tailwindcss() as PluginOption,
-    cloudflareWorkersDevEnvironmentShim(),
+    alchemy(),
     tsConfigPaths({
       projects: ["./tsconfig.json"],
     }),

package/templates/vite/alchemy.run.ts

@@ -6,7 +6,7 @@ import { Vite } from "alchemy/cloudflare";
 const app = await alchemy("my-alchemy-app");
 
 export const worker = await Vite("website", {
-  main: "worker/index.ts",
+  entrypoint: "worker/index.ts",
 });
 
 console.log({

package/templates/vite/vite.config.ts

@@ -1,9 +1,8 @@
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
-
-import { cloudflare } from "@cloudflare/vite-plugin";
+import react from '@vitejs/plugin-react';
+import alchemy from "alchemy/cloudflare/vite";
+import { defineConfig } from 'vite';
 
 // https://vite.dev/config/
 export default defineConfig({
-  plugins: [react(), cloudflare()],
+  plugins: [react(), alchemy()],
 });

package/workers/cloudflare-state-store.js

@@ -736,7 +736,7 @@ var WithSubquery = class extends Subquery {
 };
 
 // ../node_modules/drizzle-orm/version.js
-var version = "0.44.3";
+var version = "0.44.4";
 
 // ../node_modules/drizzle-orm/tracing.js
 var otel;
@@ -2739,6 +2739,17 @@ var DrizzleError = class extends Error {
     this.cause = cause;
   }
 };
+var DrizzleQueryError = class _DrizzleQueryError extends Error {
+  constructor(query, params, cause) {
+    super(`Failed query: ${query}
+params: ${params}`);
+    this.query = query;
+    this.params = params;
+    this.cause = cause;
+    Error.captureStackTrace(this, _DrizzleQueryError);
+    if (cause) this.cause = cause;
+  }
+};
 var TransactionRollbackError = class extends DrizzleError {
   static [entityKind] = "TransactionRollbackError";
   constructor() {
@@ -4985,19 +4996,6 @@ async function hashQuery(sql2, params) {
   return hashHex;
 }
 
-// ../node_modules/drizzle-orm/errors/index.js
-var DrizzleQueryError = class _DrizzleQueryError extends Error {
-  constructor(query, params, cause) {
-    super(`Failed query: ${query}
-params: ${params}`);
-    this.query = query;
-    this.params = params;
-    this.cause = cause;
-    Error.captureStackTrace(this, _DrizzleQueryError);
-    if (cause) this.cause = cause;
-  }
-};
-
 // ../node_modules/drizzle-orm/sqlite-core/session.js
 var ExecuteResultSync = class extends QueryPromise {
   constructor(resultCb) {

package/lib/cloudflare/astro.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"astro.d.ts","sourceRoot":"","sources":["../../src/cloudflare/astro.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;GAGG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,QAAQ,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;CAAG;AAE1E;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,QAAQ,IAAI,CAAC,SAAS;IAAE,MAAM,EAAE,GAAG,CAAA;CAAE,GAC7D,KAAK,GACL,MAAM,CAAC,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAsB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAC5C,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,UAAU,CAAC,CAAC,CAAM,GACxB,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CA0BnB"}