alchemy 0.45.6 → 0.46.0

package/bin/commands/dev.ts

@@ -0,0 +1,21 @@
+import z from "zod";
+import {
+  entrypoint,
+  execAlchemy,
+  execArgs,
+} from "../services/execute-alchemy.ts";
+import { t } from "../trpc.ts";
+
+export const dev = t.procedure
+  .meta({
+    description:
+      "Run an Alchemy program in dev-mode (local simulation & hot reloading)",
+  })
+  .input(z.tuple([entrypoint, z.object(execArgs)]))
+  .mutation(async ({ input: [main, options] }) =>
+    execAlchemy(main, {
+      ...options,
+      dev: true,
+      watch: true,
+    }),
+  );

package/bin/commands/login.ts

@@ -0,0 +1,66 @@
+import { cancel, intro, log, outro } from "@clack/prompts";
+import pc from "picocolors";
+import z from "zod";
+import {
+  DEFAULT_SCOPES,
+  wranglerLogin,
+} from "../../src/cloudflare/auth-wrangler.ts";
+import { throwWithContext } from "../errors.ts";
+import { t } from "../trpc.ts";
+
+export const login = t.procedure
+  .meta({
+    description: "Login to Cloudflare",
+  })
+  .input(
+    z.tuple([
+      z.object({
+        scopes: z
+          .array(z.string())
+          .optional()
+          .default([])
+          .describe("Cloudflare OAuth scopes to authorize"),
+        defaultScopes: z
+          .boolean()
+          .optional()
+          .default(true)
+          .describe(
+            "Whether to include the default Wrangler scopes when authenticating",
+          ),
+      }),
+    ]),
+  )
+  .mutation(async ({ input: [options] }) => {
+    try {
+      intro(pc.cyan("🔐 Cloudflare Login"));
+
+      const scopes = options.defaultScopes
+        ? Array.from(new Set([...DEFAULT_SCOPES, ...options.scopes]))
+        : options.scopes;
+      if (scopes.length === 0) {
+        cancel(
+          "No scopes provided. Please provide at least one scope or remove the --exclude-default-scopes flag.",
+        );
+        return;
+      }
+      const result = await wranglerLogin(scopes, (message) => {
+        log.step(message);
+      });
+
+      if (result.isErr()) {
+        throwWithContext(result.error, "Login failed");
+      }
+
+      outro(pc.green("✅ Login successful!"));
+    } catch (error) {
+      if (error instanceof Error) {
+        log.error(`${pc.red("Error:")} ${error.message}`);
+        if (error.stack && process.env.DEBUG) {
+          log.error(`${pc.gray("Stack trace:")}\n${error.stack}`);
+        }
+      } else {
+        log.error(pc.red(String(error)));
+      }
+      process.exit(1);
+    }
+  });

package/bin/commands/run.ts

@@ -0,0 +1,29 @@
+import z from "zod";
+import {
+  entrypoint,
+  execAlchemy,
+  execArgs,
+  watch,
+} from "../services/execute-alchemy.ts";
+import { t } from "../trpc.ts";
+
+export const run = t.procedure
+  .meta({
+    description:
+      "Run an Alchemy program with read-only access to your infrastructure (no changes will be applied)",
+  })
+  .input(
+    z.tuple([
+      entrypoint,
+      z.object({
+        ...execArgs,
+        watch,
+      }),
+    ]),
+  )
+  .mutation(async ({ input: [main, options] }) =>
+    execAlchemy(main, {
+      ...options,
+      read: true,
+    }),
+  );

package/bin/services/dependencies.ts

@@ -1,4 +1,3 @@
-import { log } from "@clack/prompts";
 import fs from "fs-extra";
 import path from "node:path";
 
@@ -25,8 +24,6 @@ export const addPackageDependencies = async (opts: {
     const version = dependencyVersionMap[pkgName];
     if (version) {
       pkgJson.dependencies[pkgName] = version;
-    } else {
-      log.warn(`Warning: Dependency ${pkgName} not found in version map.`);
     }
   }
 
@@ -34,8 +31,6 @@ export const addPackageDependencies = async (opts: {
     const version = dependencyVersionMap[pkgName];
     if (version) {
       pkgJson.devDependencies[pkgName] = version;
-    } else {
-      log.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
     }
   }
 

package/bin/services/execute-alchemy.ts

@@ -0,0 +1,160 @@
+import { log } from "@clack/prompts";
+import { execa } from "execa";
+import { resolve } from "node:path";
+import pc from "picocolors";
+import z from "zod";
+import { detectRuntime } from "../../src/util/detect-node-runtime.ts";
+import { detectPackageManager } from "../../src/util/detect-package-manager.ts";
+import { exists } from "../../src/util/exists.ts";
+
+export const entrypoint = z
+  .string()
+  .optional()
+  .describe(
+    "Path to the entrypoint file. Defaults to ./alchemy.run.ts > ./alchemy.run.js",
+  );
+
+export const watch = z
+  .boolean()
+  .optional()
+  .default(false)
+  .describe("Watch for changes to infrastructure and redeploy automatically");
+
+export const execArgs = {
+  cwd: z
+    .string()
+    .optional()
+    .describe("Path to the project directory (defaults to current directory)"),
+  quiet: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Suppress Create/Update/Delete messages"),
+  stage: z
+    .string()
+    .optional()
+    .describe(
+      "Specify which stage/environment to target. Defaults to your username ($USER, or $USERNAME on windows)",
+    ),
+  envFile: z.string().optional().describe("Path to environment file to load"),
+} as const;
+
+export async function execAlchemy(
+  main: string | undefined,
+  {
+    cwd = process.cwd(),
+    quiet,
+    stage,
+    destroy,
+    watch,
+    envFile,
+    read,
+    dev,
+  }: {
+    cwd?: string;
+    quiet?: boolean;
+    stage?: string;
+    destroy?: boolean;
+    watch?: boolean;
+    envFile?: string;
+    read?: boolean;
+    dev?: boolean;
+  },
+) {
+  const args: string[] = [];
+  const execArgs: string[] = [];
+  if (quiet) args.push("--quiet");
+  if (read) args.push("--read");
+  if (stage) args.push(`--stage ${stage}`);
+  if (destroy) args.push("--destroy");
+  if (watch) execArgs.push("--watch");
+  if (envFile) execArgs.push(`--env-file ${envFile}`);
+  if (dev) args.push("--dev");
+
+  // Check for alchemy.run.ts or alchemy.run.js (if not provided)
+  if (!main) {
+    const candidates = ["alchemy.run.ts", "alchemy.run.js"];
+    for (const file of candidates) {
+      const resolved = resolve(cwd, file);
+      if (await exists(resolved)) {
+        main = resolved;
+        break;
+      }
+    }
+  }
+
+  if (!main) {
+    log.error(
+      pc.red(
+        "No alchemy.run.ts or alchemy.run.js file found in the current directory.",
+      ),
+    );
+    log.info("Create an alchemy.run.ts file to define your infrastructure.");
+    process.exit(1);
+  }
+
+  // Detect package manager
+  const packageManager = await detectPackageManager(cwd);
+  const runtime = detectRuntime();
+
+  const argsString = args.join(" ");
+  const execArgsString = execArgs.join(" ");
+  // Determine the command to run based on package manager and file extension
+  let command: string;
+  const isTypeScript = main.endsWith(".ts");
+
+  switch (packageManager) {
+    case "bun":
+      command = `bun ${execArgsString} ${main} ${argsString}`;
+      break;
+    case "deno":
+      command = `deno run -A ${execArgsString} ${main} ${argsString}`;
+      break;
+    case "pnpm":
+      command = isTypeScript
+        ? `pnpm tsx ${execArgsString} ${main} ${argsString}`
+        : `pnpm node ${execArgsString} ${main} ${argsString}`;
+      break;
+    case "yarn":
+      command = isTypeScript
+        ? `yarn tsx ${execArgsString} ${main} ${argsString}`
+        : `yarn node ${execArgsString} ${main} ${argsString}`;
+      break;
+    default:
+      switch (runtime) {
+        case "bun":
+          command = `bun ${execArgsString} ${main} ${argsString}`;
+          break;
+        case "deno":
+          command = `deno run -A ${execArgsString} ${main} ${argsString}`;
+          break;
+        case "node":
+          command = isTypeScript
+            ? `npx tsx ${execArgsString} ${main} ${argsString}`
+            : `node ${execArgsString} ${main} ${argsString}`;
+          break;
+      }
+  }
+
+  try {
+    console.log(command);
+    await execa(command, {
+      cwd,
+      shell: true,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1",
+      },
+    });
+  } catch (error: any) {
+    log.error(pc.red(`Deploy failed: ${error.message}`));
+    if (error.stdout) {
+      console.log(error.stdout);
+    }
+    if (error.stderr) {
+      console.error(error.stderr);
+    }
+    process.exit(1);
+  }
+}

package/bin/services/git.ts

@@ -0,0 +1,27 @@
+import { $ } from "execa";
+
+import { throwWithContext } from "../errors.ts";
+import type { ProjectContext } from "../types.ts";
+
+export async function isGitInstalled(): Promise<boolean> {
+  try {
+    await $`git --version`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function initializeGitRepo(
+  context: ProjectContext,
+): Promise<void> {
+  const cwd = context.path;
+
+  try {
+    await $({ cwd })`git init`;
+    await $({ cwd })`git add -A`;
+    await $({ cwd })`git commit -m ${"initial commit"}`;
+  } catch (error) {
+    throwWithContext(error, "Git initialisation failed");
+  }
+}

package/bin/services/github-workflow.ts

@@ -0,0 +1,229 @@
+import { spinner } from "@clack/prompts";
+import * as fs from "fs-extra";
+import path from "node:path";
+import { throwWithContext } from "../errors.ts";
+import type { ProjectContext } from "../types.ts";
+
+export async function addGitHubWorkflowToAlchemy(
+  context: ProjectContext,
+): Promise<void> {
+  const alchemyFilePath = path.join(context.path, "alchemy.run.ts");
+
+  const s = spinner();
+  s.start("Setting up GitHub Actions...");
+
+  try {
+    const workflowDir = path.join(context.path, ".github", "workflows");
+    await fs.ensureDir(workflowDir);
+
+    const prPreviewWorkflow = `name: Preview
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize, closed]
+
+# Ensure only one workflow runs at a time per PR
+concurrency:
+  group: "pr-preview-\${{ github.event.pull_request.number }}"
+  cancel-in-progress: false
+
+jobs:
+  deploy-preview:
+    if: \${{ github.event.action != 'closed' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        shell: bash
+        run: bun install
+
+      - name: Deploy Preview
+        run: bun run deploy
+        env:
+          BRANCH_PREFIX: pr-\${{ github.event.pull_request.number }}
+          GITHUB_SHA: \${{ github.event.pull_request.head.sha }}
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY_OWNER: \${{ github.repository_owner }}
+          GITHUB_REPOSITORY_NAME: \${{ github.event.repository.name }}
+          PULL_REQUEST: \${{ github.event.pull_request.number }}
+          CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+
+  cleanup-preview:
+    if: \${{ github.event.action == 'closed' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        shell: bash
+        run: bun install
+
+      - name: Cleanup Preview
+        run: bun run destroy
+        env:
+          BRANCH_PREFIX: pr-\${{ github.event.pull_request.number }}
+          GITHUB_SHA: \${{ github.event.pull_request.head.sha }}
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY_OWNER: \${{ github.repository_owner }}
+          GITHUB_REPOSITORY_NAME: \${{ github.event.repository.name }}
+          PULL_REQUEST: \${{ github.event.pull_request.number }}
+          CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+`;
+
+    const publishWorkflow = `name: Publish
+
+on:
+  push:
+    branches: [main]
+
+# Ensure only one workflow runs at a time
+concurrency:
+  group: "publish"
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        shell: bash
+        run: bun install
+
+      - name: Deploy to Production
+        run: bun run deploy
+        env:
+          STAGE: prod
+          GITHUB_SHA: \${{ github.sha }}
+          CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+`;
+
+    await fs.writeFile(
+      path.join(workflowDir, "pr-preview.yml"),
+      prPreviewWorkflow,
+    );
+    await fs.writeFile(path.join(workflowDir, "publish.yml"), publishWorkflow);
+
+    let code = await fs.readFile(alchemyFilePath, "utf-8");
+
+    const alchemyImportRegex = /(import alchemy from "alchemy";)/;
+    const alchemyImportMatch = code.match(alchemyImportRegex);
+    if (alchemyImportMatch) {
+      const githubImport = '\nimport { GitHubComment } from "alchemy/github";';
+      code = code.replace(alchemyImportRegex, `$1${githubImport}`);
+    }
+
+    const lastImportRegex = /import[^;]+from[^;]+;(\s*\n)*/g;
+    let lastImportMatch;
+    let lastImportEnd = 0;
+
+    while ((lastImportMatch = lastImportRegex.exec(code)) !== null) {
+      lastImportEnd = lastImportMatch.index + lastImportMatch[0].length;
+    }
+
+    if (lastImportEnd > 0) {
+      const stageVariable = `
+const stage = process.env.STAGE || process.env.BRANCH_PREFIX || "dev";
+`;
+      code =
+        code.slice(0, lastImportEnd) +
+        stageVariable +
+        code.slice(lastImportEnd);
+    }
+
+    const appCallRegex = /const app = await alchemy\("([^"]+)"\);/;
+    const appMatch = code.match(appCallRegex);
+    if (appMatch) {
+      const appName = appMatch[1];
+      code = code.replace(
+        appCallRegex,
+        `const app = await alchemy("${appName}", {
+  stage,
+});`,
+      );
+    }
+
+    const cloudflareResourceRegex =
+      /(await (?:Worker|TanStackStart|Nuxt|Astro|Website|SvelteKit|Redwood|ReactRouter|Vite)\([^,]+,\s*{[^}]*)(}\);)/g;
+    code = code.replace(
+      cloudflareResourceRegex,
+      (match, beforeClosing, closing) => {
+        if (beforeClosing.includes("version:")) {
+          return match;
+        }
+
+        const hasTrailingComma = beforeClosing.trim().endsWith(",");
+        const versionProp = hasTrailingComma
+          ? `  version: stage === "prod" ? undefined : stage,\n`
+          : `,\n  version: stage === "prod" ? undefined : stage,\n`;
+
+        return beforeClosing + versionProp + closing;
+      },
+    );
+
+    const finalizeRegex = /(await app\.finalize\(\);)/;
+    const finalizeMatch = code.match(finalizeRegex);
+    if (finalizeMatch) {
+      const githubWorkflowCode = `
+if (process.env.PULL_REQUEST) {
+  const previewUrl = worker.url;
+  
+  await GitHubComment("pr-preview-comment", {
+    owner: process.env.GITHUB_REPOSITORY_OWNER || "your-username",
+    repository: process.env.GITHUB_REPOSITORY_NAME || "${context.name}",
+    issueNumber: Number(process.env.PULL_REQUEST),
+    body: \`
+## 🚀 Preview Deployed
+
+Your preview is ready! 
+
+**Preview URL:** \${previewUrl}
+
+This preview was built from commit \${process.env.GITHUB_SHA}
+
+---
+<sub>🤖 This comment will be updated automatically when you push new commits to this PR.</sub>\`,
+  });
+}
+
+`;
+
+      code = code.replace(finalizeRegex, `${githubWorkflowCode}$1`);
+    }
+
+    await fs.writeFile(alchemyFilePath, code, "utf-8");
+
+    s.stop("GitHub Actions configured");
+  } catch (error) {
+    s.stop("GitHub Actions setup failed");
+    throwWithContext(error, "Failed to add GitHub workflow setup");
+  }
+}

package/bin/services/package-manager.ts

@@ -1,70 +1,54 @@
-import { log } from "@clack/prompts";
 import { execa } from "execa";
-import * as fs from "fs-extra";
-import type { PackageManager, ProjectContext } from "../types.ts";
+import { throwWithContext } from "../errors.ts";
+import type { ProjectContext } from "../types.ts";
 
-export function detectPackageManager(): PackageManager {
-  if (fs.pathExistsSync("bun.lockb")) return "bun";
-  if (fs.pathExistsSync("pnpm-lock.yaml")) return "pnpm";
-  if (fs.pathExistsSync("yarn.lock")) return "yarn";
-
-  if (process.env.npm_execpath?.includes("bun")) {
-    return "bun";
-  }
-
-  const userAgent = process.env.npm_config_user_agent;
-  if (userAgent) {
-    if (userAgent.startsWith("bun")) return "bun";
-    if (userAgent.startsWith("pnpm")) return "pnpm";
-    if (userAgent.startsWith("yarn")) return "yarn";
-    if (userAgent.startsWith("npm")) return "npm";
-  }
-
-  return "npm";
-}
-
-export function getPackageManagerCommands(pm: PackageManager) {
-  const commands = {
-    bun: {
-      init: "bun init -y",
-      install: "bun install",
-      add: "bun add",
-      addDev: "bun add -D",
-      run: "bun run",
-      create: "bun create",
-      x: "bunx",
-    },
-    npm: {
-      init: "npm init -y",
-      install: "npm install",
-      add: "npm install",
-      addDev: "npm install --save-dev",
-      run: "npm run",
-      create: "npm create",
-      x: "npx",
-    },
-    pnpm: {
-      init: "pnpm init",
-      install: "pnpm install",
-      add: "pnpm add",
-      addDev: "pnpm add -D",
-      run: "pnpm run",
-      create: "pnpm create",
-      x: "pnpm dlx",
-    },
-    yarn: {
-      init: "yarn init -y",
-      install: "yarn install",
-      add: "yarn add",
-      addDev: "yarn add -D",
-      run: "yarn",
-      create: "yarn create",
-      x: "yarn dlx",
-    },
-  } as const;
-
-  return commands[pm];
-}
+export const PackageManager = {
+  bun: {
+    init: "bun init -y",
+    install: "bun install",
+    add: "bun add",
+    addDev: "bun add -D",
+    run: "bun run",
+    create: "bun create",
+    x: "bunx",
+  },
+  npm: {
+    init: "npm init -y",
+    install: "npm install",
+    add: "npm install",
+    addDev: "npm install --save-dev",
+    run: "npm run",
+    create: "npm create",
+    x: "npx",
+  },
+  pnpm: {
+    init: "pnpm init",
+    install: "pnpm install",
+    add: "pnpm add",
+    addDev: "pnpm add -D",
+    run: "pnpm run",
+    create: "pnpm create",
+    x: "pnpm dlx",
+  },
+  yarn: {
+    init: "yarn init -y",
+    install: "yarn install",
+    add: "yarn add",
+    addDev: "yarn add -D",
+    run: "yarn",
+    create: "yarn create",
+    x: "yarn dlx",
+  },
+  deno: {
+    init: "deno init",
+    install: "deno install",
+    add: "deno add",
+    addDev: "deno add",
+    run: "deno task",
+    create: "deno run -A",
+    x: "deno run -A",
+  },
+} as const;
 
 export async function installDependencies(
   context: ProjectContext,
@@ -80,7 +64,7 @@ export async function installDependencies(
 ): Promise<void> {
   const targetCwd = cwd || context.path;
   const pm = context.packageManager;
-  const commands = getPackageManagerCommands(pm);
+  const commands = PackageManager[pm];
 
   try {
     if (!dependencies && !devDependencies) {
@@ -107,7 +91,6 @@ export async function installDependencies(
       });
     }
   } catch (error) {
-    log.error("Failed to install dependencies");
-    throw error;
+    throwWithContext(error, "Failed to install dependencies");
   }
 }