alchemy 0.62.3 → 0.63.0

package/src/upstash/redis.ts

@@ -26,8 +26,10 @@ export type UpstashRegion =
 export interface UpstashRedisProps {
   /**
    * Name of the database
+   *
+   * @default ${app}-${stage}-${id}
    */
-  name: string;
+  name?: string;
 
   /**
    * Primary region for the database
@@ -71,6 +73,11 @@ export interface UpstashRedis
    */
   id: string;
 
+  /**
+   * Name of the database.
+   */
+  name: string;
+
   /**
    * Type of the database in terms of pricing model
    */
@@ -157,7 +164,7 @@ export const UpstashRedis = Resource(
   "upstash::Redis",
   async function (
     this: Context<UpstashRedis>,
-    _id: string,
+    id: string,
     props: UpstashRedisProps,
   ): Promise<UpstashRedis> {
     const api = new UpstashApi({
@@ -165,6 +172,9 @@ export const UpstashRedis = Resource(
       email: props.email,
     });
 
+    const databaseName =
+      props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+
     if (this.phase === "delete") {
       await deleteRedisDatabase(api, this.output.id);
       return this.destroy();
@@ -177,8 +187,8 @@ export const UpstashRedis = Resource(
 
     if (this.phase === "update") {
       // Update name if changed
-      if (props.name !== this.output.name) {
-        await renameRedisDatabase(api, this.output.id, props.name);
+      if (databaseName !== this.output.name) {
+        await renameRedisDatabase(api, this.output.id, databaseName);
       }
 
       // Update read regions if changed
@@ -208,7 +218,7 @@ export const UpstashRedis = Resource(
     if (this.phase === "create") {
       database = await createRedisDatabase(api, {
         budget: props.budget,
-        name: props.name,
+        name: databaseName,
         primary_region: props.primaryRegion,
         read_regions: props.readRegions,
         region: "global",

package/src/util/ignore-matcher.ts

@@ -515,7 +515,9 @@ class RuleManager {
 
     makeArray(
       isString(pattern) ? splitPattern(pattern) : (pattern as any),
-    ).forEach((p) => this._add(p));
+    ).forEach((p) => {
+      this._add(p);
+    });
 
     return this._added;
   }

package/src/util/peer.ts

@@ -0,0 +1,53 @@
+import {
+  detectPackageManager,
+  type PackageManager,
+} from "./detect-package-manager.ts";
+
+export class PeerDependencyError extends Error {
+  constructor(input: {
+    feature?: string;
+    missing: string[];
+    packageManager?: PackageManager;
+  }) {
+    super(
+      [
+        `Missing peer ${input.missing.length} ${input.missing.length === 1 ? "dependency" : "dependencies"}${input.feature ? ` for ${input.feature}` : ""}:`,
+        ...input.missing.map((dep) => `- "${dep}"`),
+        "",
+        "Please install with:",
+        `  ${input.packageManager ?? "npm"} install ${input.missing.join(" ")}`,
+      ].join("\n"),
+    );
+  }
+}
+
+const extractPackageName = (error: unknown) => {
+  const message =
+    typeof error === "object" &&
+    error !== null &&
+    "message" in error &&
+    typeof error.message === "string"
+      ? error.message
+      : undefined;
+  const match = message?.match(/Cannot find (package|module) '([^']+)'/);
+  return match?.[2];
+};
+
+export async function importPeer<T>(promise: Promise<T>, feature?: string) {
+  try {
+    return await promise;
+  } catch (err) {
+    const name = extractPackageName(err);
+    if (!name) {
+      throw err;
+    }
+    const packageManager = await detectPackageManager();
+    const error = new PeerDependencyError({
+      feature,
+      missing: [name],
+      packageManager,
+    });
+    Error.captureStackTrace(error, importPeer);
+    throw error;
+  }
+}

package/src/vercel/project.ts

@@ -47,8 +47,10 @@ export interface ProjectProps {
    *
    * Maximum length: `100`
    * Example: `a-project-name`
+   *
+   * @default ${app}-${stage}-${id}
    */
-  name: string;
+  name?: string;
 
   /**
    * Opt-in to preview toolbar on the project level
@@ -244,6 +246,11 @@ export interface Project extends Resource<"vercel::Project">, ProjectProps {
    */
   id: string;
 
+  /**
+   * The name for the project
+   */
+  name: string;
+
   /**
    * The account ID that the project belongs to
    */
@@ -369,6 +376,31 @@ export const Project = Resource(
     id: string,
     { accessToken, ...props }: ProjectProps & { accessToken?: Secret },
   ): Promise<Project> {
+    // it's possible that `this.output.name` is undefined because a previous version
+    // of alchemy had a bug where it didn't set the name on the output
+    // so, we try to find the project by ID and use the name from the API response
+    const lookupName = async () => {
+      if (!this.output) {
+        return undefined;
+      } else if (this.output.name) {
+        return this.output.name;
+      }
+      const name = await getProjectName(
+        await createVercelApi({
+          baseUrl: "https://api.vercel.com/v9",
+          accessToken,
+        }),
+        this.output.id,
+      );
+      if (name) {
+        this.output.name = name;
+      }
+      return name;
+    };
+
+    const projectName =
+      props.name ?? (await lookupName()) ?? this.scope.createPhysicalName(id);
+
     switch (this.phase) {
       case "delete": {
         const api = await createVercelApi({
@@ -423,6 +455,7 @@ export const Project = Resource(
 
         return this({
           id: data.id,
+          name: projectName,
           accountId: data.accountId,
           createdAt: data.createdAt,
           updatedAt: data.updatedAt,
@@ -492,3 +525,15 @@ export async function updateEnvironmentVariables(
     await api.delete(`/projects/${output.id}/env/${previousEnv.id}`);
   }
 }
+
+async function getProjectName(
+  api: VercelApi,
+  id: string,
+): Promise<string | undefined> {
+  const response = await api.get(`/v9/projects/${id}`);
+  if (!response.ok) {
+    throw new Error(`API error: ${response.statusText}`);
+  }
+
+  return ((await response.json()) as { name: string }).name;
+}

package/templates/hono/README.md

@@ -0,0 +1,19 @@
+### Minimal Hono + Alchemy Template
+
+### Run
+- bun install
+- bun run dev
+
+### Deploy
+- bun run deploy
+- bun run destroy
+
+### Alchemy
+- Resource: defined in `alchemy.run.ts` (Worker + KV)
+- Binding: `KV` bound to Worker as `c.env.KV`
+- Types: inferred in `types/env.d.ts`
+
+### References
+- Alchemy Getting Started: https://alchemy.run/getting-started
+- Alchemy CLI: https://alchemy.run/concepts/cli
+- Bindings: https://alchemy.run/concepts/bindings

package/templates/hono/_env

@@ -0,0 +1 @@
+ALCHEMY_PASSWORD=change-me

package/templates/hono/_env.example

@@ -0,0 +1 @@
+ALCHEMY_PASSWORD=change-me

package/templates/hono/_gitignore

@@ -0,0 +1,34 @@
+# prod
+dist/
+
+# dev
+.yarn/
+!.yarn/releases
+.vscode/*
+!.vscode/launch.json
+!.vscode/*.code-snippets
+.idea/workspace.xml
+.idea/usage.statistics.xml
+.idea/shelf
+
+# deps
+node_modules/
+.wrangler
+.alchemy
+
+# env
+.env
+.env.production
+.dev.vars
+
+# logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+# misc
+.DS_Store

package/templates/hono/alchemy.run.ts

@@ -0,0 +1,22 @@
+/// <reference types="@types/node" />
+
+import alchemy from "alchemy";
+import { KVNamespace, Worker } from "alchemy/cloudflare";
+
+const app = await alchemy("{projectName}");
+
+const kv = await KVNamespace("kv", {
+  title: "kv",
+});
+
+export const worker = await Worker("worker", {
+  name: `${app.name}-${app.stage}`,
+  entrypoint: "src/index.ts",
+  bindings: {
+    KV: kv,
+  },
+});
+
+console.log(worker.url);
+
+await app.finalize();

package/templates/hono/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@alchemy.run/hono-template",
+  "type": "module",
+  "scripts": {
+    "check": "tsc --noEmit",
+    "dev": "alchemy dev",
+    "deploy": "alchemy deploy",
+    "destroy": "alchemy destroy"
+  },
+  "dependencies": {
+    "hono": "^4.9.2"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250820.0",
+    "@types/node": "^24.3.0",
+    "alchemy": "workspace:*"
+  }
+}

package/templates/hono/src/index.ts

@@ -0,0 +1,17 @@
+import { Hono } from 'hono'
+
+const app = new Hono<{ Bindings: Env }>()
+
+app.get('/', (c) => {
+  return c.text('Hello Hono!')
+})
+
+app.get('/kv', async (c) => {
+  const key = 'hello'
+  const value = `world@${Date.now()}`
+  await c.env.KV.put(key, value)
+  const got = await c.env.KV.get(key)
+  return c.json({ key, value: got })
+})
+
+export default app

package/templates/hono/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "lib": ["ESNext"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "hono/jsx",
+    "types": ["@cloudflare/workers-types"]
+  }
+}

package/templates/hono/types/env.d.ts

@@ -0,0 +1,16 @@
+// This file infers types for the cloudflare:workers environment from your Alchemy Worker.
+// @see https://alchemy.run/concepts/bindings/#type-safe-bindings
+
+import type { worker } from "../alchemy.run.ts";
+
+export type CloudflareEnv = typeof worker.Env;
+
+declare global {
+  type Env = CloudflareEnv;
+}
+
+declare module "cloudflare:workers" {
+  namespace Cloudflare {
+    export interface Env extends CloudflareEnv {}
+  }
+}

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

@@ -1,14 +1,16 @@
 import { reactRouter } from "@react-router/dev/vite";
 import tailwindcss from "@tailwindcss/vite";
 import alchemy from "alchemy/cloudflare/react-router";
-import { defineConfig } from "vite";
+import { defineConfig, type PluginOption } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
 
 export default defineConfig({
   plugins: [
-    alchemy(),
+    alchemy() as PluginOption,
     tailwindcss(),
     reactRouter(),
-    tsconfigPaths(),
+    tsconfigPaths({
+      root: "."
+    }),
   ],
 });