alchemy 0.45.6 → 0.46.0

package/package.json

@@ -1,31 +1,31 @@
 {
   "name": "alchemy",
-  "version": "0.45.6",
-  "type": "module",
-  "module": "./lib/index.js",
+  "version": "0.46.0",
   "license": "Apache-2.0",
+  "author": "Sam Goodwin <sam@alchemy.run>",
+  "homepage": "https://alchemy.run",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sam-goodwin/alchemy.git",
     "directory": "alchemy"
   },
+  "type": "module",
+  "module": "./lib/index.js",
+  "bin": {
+    "alchemy": "bin/alchemy.mjs"
+  },
   "scripts": {
     "build:cli": "bun ./scripts/bundle-cli.ts",
     "build:workers": "bun ./scripts/build-workers.ts",
     "build": "rm -rf ./*.tsbuildinfo && rm -rf ./lib && tsc -b && bun run build:cli && bun run build:workers",
-    "db:generate": "drizzle-kit generate",
+    "drizzle:generate": "bun run scripts/drizzle-generate.ts",
     "docs:gen": "rm -rf ./docs && typedoc",
     "postbuild": "cpx 'src/**/*/types.d.ts' lib && cpx 'src/**/*.txt' lib",
     "publish:npm": "cp ../README.md . && bun run build && bun run build:cli && npm publish && rm README.md"
   },
-  "bin": {
-    "alchemy": "bin/alchemy.mjs"
-  },
-  "author": "Sam Goodwin <sam@alchemy.run>",
-  "homepage": "https://alchemy.run",
   "files": [
     "bin",
-    "drizzle",
+    "drizzle/default",
     "lib",
     "src",
     "templates",
@@ -112,9 +112,9 @@
       "bun": "./src/web/shadcn.ts",
       "import": "./lib/web/shadcn.js"
     },
-    "./sqlite": {
-      "bun": "./src/sqlite/index.ts",
-      "import": "./lib/sqlite/index.js"
+    "./state": {
+      "bun": "./src/state/index.ts",
+      "import": "./lib/state/index.js"
     },
     "./web/astro": {
       "bun": "./src/web/astro.ts",
@@ -149,6 +149,8 @@
     "kleur": "^4.1.5",
     "libsodium-wrappers": "^0.7.15",
     "miniflare": "^4.20250617.4",
+    "neverthrow": "^8.2.0",
+    "open": "^10.1.2",
     "pathe": "^2.0.3",
     "turndown": "^7.0.0",
     "unenv": "2.0.0-rc.15",
@@ -174,10 +176,11 @@
     "arktype": "^2.0.0",
     "cloudflare": "^4.0.0",
     "drizzle-orm": "^0.44.2",
+    "execa": "^9.6.0",
     "hono": "^4.0.0",
     "prettier": "^3.0.0",
     "stripe": "^17.0.0",
-    "zod": "^3.0.0"
+    "zod": "^4.0.5"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.6",
@@ -206,7 +209,6 @@
     "cpx": "^1.5.0",
     "dofs": "^0.1.0",
     "drizzle-kit": "^0.31.4",
-    "execa": "^9.6.0",
     "fs-extra": "^11.3.0",
     "globby": "^14.1.0",
     "libsodium-wrappers": "^0.7.15",
@@ -214,7 +216,7 @@
     "openpgp": "^6.1.0",
     "picocolors": "^1.1.1",
     "prettier": "^3.5.3",
-    "trpc-cli": "^0.9.2",
+    "trpc-cli": "^0.10.0",
     "turndown": "^7.2.0",
     "typedoc": "^0.28.1",
     "typedoc-plugin-markdown": "^4.6.0",

package/src/apply.ts

@@ -1,5 +1,6 @@
 import { alchemy } from "./alchemy.ts";
 import { context } from "./context.ts";
+import { destroy } from "./destroy.ts";
 import {
   PROVIDERS,
   ResourceFQN,
@@ -33,7 +34,14 @@ export function apply<Out extends Resource>(
   return _apply(resource, props, options);
 }
 
-export class ReplacedSignal extends Error {}
+export class ReplacedSignal extends Error {
+  public force: boolean;
+
+  constructor(force?: boolean) {
+    super();
+    this.force = force ?? false;
+  }
+}
 
 async function _apply<Out extends Resource>(
   resource: PendingResource<Out>,
@@ -165,7 +173,7 @@ async function _apply<Out extends Resource>(
       props: state.oldProps,
       state,
       isReplacement: false,
-      replace: () => {
+      replace: async (force?: boolean) => {
         if (phase === "create") {
           throw new Error(
             `Resource ${resource[ResourceKind]} ${resource[ResourceFQN]} cannot be replaced in create phase.`,
@@ -177,8 +185,19 @@ async function _apply<Out extends Resource>(
           );
         }
 
+        if (force) {
+          await destroy(resource, {
+            quiet: scope.quiet,
+            strategy: "sequential",
+            replace: {
+              props: state.oldProps,
+              output: resource,
+            },
+          });
+        }
+
         isReplaced = true;
-        throw new ReplacedSignal();
+        throw new ReplacedSignal(force);
       },
     });
 
@@ -227,13 +246,15 @@ async function _apply<Out extends Resource>(
             )(resource[ResourceID], props),
         );
 
-        const pendingDeletions =
-          (await scope.get<PendingDeletions>("pendingDeletions")) ?? [];
-        pendingDeletions.push({
-          resource: oldOutput,
-          oldProps: state.oldProps,
-        });
-        await scope.set("pendingDeletions", pendingDeletions);
+        if (!error.force) {
+          const pendingDeletions =
+            (await scope.get<PendingDeletions>("pendingDeletions")) ?? [];
+          pendingDeletions.push({
+            resource: oldOutput,
+            oldProps: state.oldProps,
+          });
+          await scope.set("pendingDeletions", pendingDeletions);
+        }
       } else {
         throw error;
       }

package/src/build-date.ts

@@ -5,4 +5,4 @@
  * The build date used as the default worker compatibility date.
  * This is set to the date when the package was built.
  */
-export const BUILD_DATE = "2025-07-12";
+export const BUILD_DATE = "2025-07-15";

package/src/cloudflare/ai.ts

@@ -9,7 +9,7 @@
  * ```ts
  * import { Worker, Ai } from "alchemy/cloudflare";
  *
- * const ai = new Ai();
+ * const ai = Ai();
  *
  * await Worker("my-worker", {
  *   name: "my-worker",
@@ -22,12 +22,17 @@
  *
  * @see https://developers.cloudflare.com/workers-ai/
  */
-export class Ai<Models extends AiModelListType = AiModelListType> {
-  public readonly type = "ai";
+export function Ai<Models extends AiModelListType = AiModelListType>() {
+  return {
+    type: "ai",
+    _phantom: undefined! as Models,
+  } as const;
+}
 
+export type Ai<Models extends AiModelListType = AiModelListType> = {
+  type: "ai";
   /**
    * @internal
    */
-  ///@ts-ignore
   _phantom: Models;
-}
+};

package/src/cloudflare/analytics-engine.ts

@@ -6,21 +6,30 @@ export interface AnalyticsEngineDatasetProps {
   dataset: string;
 }
 
+export type AnalyticsEngineDataset = {
+  type: "analytics_engine";
+  id: string;
+  dataset: string;
+};
+
 /**
+ * Creates a binding for an Analytics Engine dataset.
+ *
  * @example
+ * ```ts
  * // Create a binding for an Analytics Engine dataset
- * const dataset = new AnalyticsEngineDataset("ae-dataset", {
+ * const dataset = AnalyticsEngineDataset("ae-dataset", {
  *   dataset: "WEATHER",
  * });
+ * ```
  */
-export class AnalyticsEngineDataset {
-  public readonly type = "analytics_engine" as const;
-  public readonly dataset: string;
-
-  constructor(
-    public readonly id: string,
-    input: AnalyticsEngineDatasetProps,
-  ) {
-    this.dataset = input.dataset;
-  }
+export function AnalyticsEngineDataset(
+  id: string,
+  props: AnalyticsEngineDatasetProps,
+): AnalyticsEngineDataset {
+  return {
+    type: "analytics_engine",
+    id,
+    dataset: props.dataset,
+  };
 }

package/src/cloudflare/{types.ts → api-response.ts}

@@ -47,6 +47,11 @@ export interface CloudflareApiError {
    * Error message
    */
   message: string;
+
+  /**
+   * Error documentation URL
+   */
+  documentation_url?: string;
 }
 
 /**
@@ -68,3 +73,29 @@ export async function extractCloudflareError(
     return `HTTP ${response.status}: ${response.statusText}`;
   }
 }
+
+export async function extractCloudflareResult<T>(
+  label: string,
+  promise: Promise<Response>,
+): Promise<T> {
+  const response = await promise.catch(() => {
+    throw new Error(`Failed to ${label}: Failed to fetch`);
+  });
+  const json = (await response.json().catch(() => {
+    throw new Error(
+      `Failed to ${label} (${response.status}): The API returned an invalid response`,
+    );
+  })) as CloudflareApiResponse<T>;
+  if (json.success) {
+    return json.result;
+  } else {
+    const error = new Error(
+      `Failed to ${label} (${response.status} ${response.statusText}):\n${json.errors.map((e) => `- [${e.code}] ${e.message}${e.documentation_url ? ` (${e.documentation_url})` : ""}`).join("\n")}`,
+    );
+    Error.captureStackTrace(error, extractCloudflareResult);
+    Object.assign(error, {
+      status: response.status,
+    });
+    throw error;
+  }
+}

package/src/cloudflare/auth-wrangler.ts

@@ -0,0 +1,314 @@
+import kleur from "kleur";
+import { err, ok, ResultAsync } from "neverthrow";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import open from "open";
+import { HTTPServer } from "../util/http-server.ts";
+import { memoize, memoizeSync } from "../util/memoize.ts";
+import { detached, ensure, singleFlight } from "../util/neverthrow.ts";
+import { createXdgAppPaths } from "../util/xdg-paths.ts";
+
+const CLIENT_ID = "54d11594-84e4-41aa-b438-e81b8fa78ee7";
+const REDIRECT_URI = "http://localhost:8976/oauth/callback";
+const ALCHEMY_BASE_URL = "https://alchemy.run";
+export const DEFAULT_SCOPES = [
+  "account:read",
+  "user:read",
+  "workers:write",
+  "workers_kv:write",
+  "workers_routes:write",
+  "workers_scripts:write",
+  "workers_tail:read",
+  "d1:write",
+  "pages:write",
+  "zone:read",
+  "ssl_certs:write",
+  "ai:write",
+  "queues:write",
+  "pipelines:write",
+  "secrets_store:write",
+  "containers:write",
+  "cloudchamber:write",
+];
+
+interface WranglerConfig {
+  oauth_token: string;
+  refresh_token: string;
+  expiration_time: Date;
+  scopes: string[];
+}
+
+const getWranglerConfigPath = memoize(async () => {
+  const xdgConfigDir = createXdgAppPaths(".wrangler").config();
+  const legacyConfigDir = path.join(os.homedir(), ".wrangler");
+  const configDir = (await fs
+    .stat(legacyConfigDir)
+    .then((stat) => stat.isDirectory())
+    .catch(() => false))
+    ? legacyConfigDir
+    : xdgConfigDir;
+  return path.join(configDir, "config", "default.toml");
+});
+
+const readWranglerConfig = () => {
+  return ResultAsync.fromSafePromise(getWranglerConfigPath())
+    .andThen((path) =>
+      ResultAsync.fromPromise(
+        fs.readFile(path, "utf-8").then(async (text) => {
+          const toml = await import("@iarna/toml");
+          return toml.parse(text.replace(/\r\n/g, "\n"));
+        }),
+        () => new Error("Failed to read Wrangler config."),
+      ),
+    )
+    .andThen((config) => {
+      if (
+        typeof config.oauth_token !== "string" ||
+        typeof config.refresh_token !== "string" ||
+        !config.expiration_time ||
+        !Array.isArray(config.scopes)
+      ) {
+        return err(new Error("Invalid Wrangler config."));
+      }
+      return ok({
+        oauth_token: config.oauth_token,
+        refresh_token: config.refresh_token,
+        expiration_time: new Date(config.expiration_time as any),
+        scopes: Array.from(config.scopes as string[]),
+      } as WranglerConfig);
+    });
+};
+
+const writeWranglerConfig = (config: WranglerConfig) => {
+  return ResultAsync.fromSafePromise(getWranglerConfigPath()).map(
+    async (configPath) => {
+      const toml = await import("@iarna/toml");
+      await fs.writeFile(
+        configPath,
+        toml.stringify({
+          oauth_token: config.oauth_token,
+          refresh_token: config.refresh_token,
+          expiration_time: config.expiration_time,
+          scopes: config.scopes,
+        }),
+      );
+    },
+  );
+};
+
+const fetchToken = (
+  body:
+    | {
+        grant_type: "refresh_token";
+        refresh_token: string;
+        client_id: string;
+      }
+    | {
+        grant_type: "authorization_code";
+        code: string;
+        code_verifier: string;
+        client_id: string;
+        redirect_uri: string;
+      },
+) => {
+  return ResultAsync.fromPromise(
+    fetch("https://dash.cloudflare.com/oauth2/token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: new URLSearchParams(body),
+    }),
+    () =>
+      new OAuthError({
+        error: "fetch_error",
+        error_description: "Failed to fetch OAuth token.",
+        status_code: 0,
+      }),
+  )
+    .andThen((res) =>
+      ResultAsync.fromPromise(
+        res.json(),
+        () =>
+          new OAuthError({
+            error: "invalid_response",
+            error_description: "The server returned an invalid response.",
+            status_code: res.status,
+          }),
+      ).andThen((json) =>
+        res.ok ? ok(json as OAuthTokens) : err(new OAuthError(json as any)),
+      ),
+    )
+    .map(
+      (tokens): WranglerConfig => ({
+        oauth_token: tokens.access_token,
+        refresh_token: tokens.refresh_token,
+        expiration_time: new Date(Date.now() + tokens.expires_in * 1000),
+        scopes: tokens.scope.split(" "),
+      }),
+    )
+    .andTee((config) => writeWranglerConfig(config));
+};
+
+interface OAuthTokens {
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+  scope: string;
+}
+
+export const getRefreshedWranglerConfig = singleFlight(
+  memoizeSync(
+    () => {
+      return readWranglerConfig()
+        .andThen((config) => {
+          if (config.expiration_time.getTime() > Date.now() + 10 * 1000) {
+            return ok(config);
+          }
+          return fetchToken({
+            grant_type: "refresh_token",
+            refresh_token: config.refresh_token,
+            client_id: CLIENT_ID,
+          });
+        })
+        .orElse((error) => {
+          if (isInteractive()) {
+            return wranglerLogin();
+          }
+          if (error instanceof OAuthError) {
+            return err(error);
+          }
+          return ok(null);
+        });
+    },
+    () => Math.floor(Date.now() / 5000).toString(),
+  ),
+);
+
+const isInteractive = () => {
+  return process.stdin.isTTY && process.stdout.isTTY && !process.env.CI;
+};
+
+const generateAuthorizationURL = (scopes: string[]) => {
+  const state = crypto.randomBytes(32).toString("base64url");
+  const verifier = crypto.randomBytes(96).toString("base64url");
+  const challenge = crypto
+    .createHash("sha256")
+    .update(verifier)
+    .digest("base64url");
+  const url = new URL("https://dash.cloudflare.com/oauth2/auth");
+  url.search = new URLSearchParams({
+    response_type: "code",
+    client_id: CLIENT_ID,
+    redirect_uri: REDIRECT_URI,
+    scope: [...scopes, "offline_access"].join(" "),
+    state,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+  }).toString();
+  return { url: url.toString(), state, verifier };
+};
+
+class OAuthError extends Error {
+  readonly error: string;
+  readonly error_verbose?: string;
+  readonly error_hint?: string;
+  readonly status_code: number;
+  constructor(params: {
+    error: string;
+    error_verbose?: string;
+    error_description: string;
+    error_hint?: string;
+    status_code: number;
+  }) {
+    console.dir(params, { depth: null });
+    super(params.error_description);
+    this.error = params.error;
+    this.error_verbose = params.error_verbose;
+    this.error_hint = params.error_hint;
+    this.status_code = params.status_code;
+  }
+}
+
+export const wranglerLogin = (
+  scopes: string[] = DEFAULT_SCOPES,
+  log: (message: string) => void = console.log, // using console.log instead of logger.log to avoid bundling hell with CLI
+) => {
+  const challenge = generateAuthorizationURL(scopes);
+  log(
+    [
+      "Opening browser to authorize with Cloudflare...",
+      "",
+      kleur.gray(
+        "If you are not automatically redirected, please open the following URL in your browser:",
+      ),
+      challenge.url,
+    ].join("\n"),
+  );
+  open(challenge.url);
+  const { result, ok, err } = detached<WranglerConfig, OAuthError>();
+  const server = new HTTPServer({
+    port: 8976,
+    fetch: async (request) => {
+      const url = new URL(request.url);
+      if (url.pathname !== "/oauth/callback") {
+        return new Response("Not found", { status: 404 });
+      }
+      const error = url.searchParams.get("error");
+      const error_description = url.searchParams.get("error_description");
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      if (error) {
+        err(
+          new OAuthError({
+            error,
+            error_description: error_description ?? "Unknown error",
+            status_code: 400,
+          }),
+        );
+        return Response.redirect(`${ALCHEMY_BASE_URL}/auth/error`);
+      }
+      if (!code || !state || state !== challenge.state) {
+        err(
+          new OAuthError({
+            error: "invalid_request",
+            error_description: "Invalid request",
+            status_code: 400,
+          }),
+        );
+        return Response.redirect(`${ALCHEMY_BASE_URL}/auth/error`);
+      }
+      const tokens = await fetchToken({
+        grant_type: "authorization_code",
+        code,
+        code_verifier: challenge.verifier,
+        client_id: CLIENT_ID,
+        redirect_uri: REDIRECT_URI,
+      });
+      if (tokens.isErr()) {
+        err(tokens.error);
+        return Response.redirect(`${ALCHEMY_BASE_URL}/auth/error`);
+      }
+      ok(tokens.value);
+      return Response.redirect(`${ALCHEMY_BASE_URL}/auth/success`);
+    },
+  });
+  const timeout = setTimeout(
+    () => {
+      err(
+        new OAuthError({
+          error: "timeout",
+          error_description: "Authorization timed out after 5 minutes",
+          status_code: 408,
+        }),
+      );
+    },
+    1000 * 60 * 5,
+  );
+  return ensure(result, async () => {
+    clearTimeout(timeout);
+    await server.stop();
+  });
+};