refactor(cli): delegate build-strategy resolution to the SDK, drop module fallback

resolvePreviewBuildStrategy now forwards directly to the SDK's
resolveBuildStrategy: framework detection, per-framework construction, and
Bun entrypoint resolution all live in one place. Deletes the CLI's
per-framework switch and its createPreviewBuildStrategy.

Bun entrypoint resolution is now main-only (or an explicit --entry),
everywhere — the deploy path (via the SDK) and the local `app run` path
(readBunPackageEntrypoint). Dropping the package.json `module` fallback
keeps `run` and `deploy` resolving the same entrypoint, so an app can't
run locally but fail to deploy.

Tests: framework-detection cases that mocked the SDK strategy classes are
removed (detection is the SDK's responsibility and is covered by its own
tests); the remaining bun cases use `main` / explicit `--entry`.

Author: AmanVarshney01

packages/cli/src/lib/app/bun-project.ts

@@ -3,7 +3,6 @@ import path from "node:path";
 
 export interface BunPackageJsonLike {
   main?: unknown;
-  module?: unknown;
   packageManager?: unknown;
   scripts?: unknown;
   dependencies?: unknown;
@@ -42,15 +41,7 @@ export async function readBunPackageJson(
 export function readBunPackageEntrypoint(
   packageJson: BunPackageJsonLike | null,
 ): string | undefined {
-  if (typeof packageJson?.main === "string") {
-    return packageJson.main;
-  }
-
-  if (typeof packageJson?.module === "string") {
-    return packageJson.module;
-  }
-
-  return undefined;
+  return typeof packageJson?.main === "string" ? packageJson.main : undefined;
 }
 
 export async function resolveBunEntrypoint(
@@ -63,7 +54,7 @@ export async function resolveBunEntrypoint(
 
   if (!candidate) {
     throw new Error(
-      "Entrypoint is required. Pass --entry or define package.json main or module.",
+      "Entrypoint is required. Pass --entry or define package.json main.",
     );
   }
 

packages/cli/src/lib/app/preview-build.ts

@@ -2,19 +2,13 @@ import { cp, rm, stat } from "node:fs/promises";
 import path from "node:path";
 
 import {
-  AstroBuild,
   type BuildArtifact,
   type BuildStrategy,
-  BunBuild,
-  NestjsBuild,
-  NextjsBuild,
-  NuxtBuild,
   normalizeArtifactSymlinks,
+  resolveBuildStrategy,
   stageStandaloneArtifact,
-  TanstackStartBuild,
 } from "@prisma/compute-sdk";
 
-import { resolveBunEntrypoint } from "./bun-project";
 import type { PreviewBuildSettings } from "./preview-build-settings";
 
 export {
@@ -139,99 +133,16 @@ export async function resolvePreviewBuildStrategy(options: {
   strategy: BuildStrategy;
   buildType: ResolvedPreviewBuildType;
 }> {
-  if (options.buildType !== "auto") {
-    const strategy = await createPreviewBuildStrategy({
-      appPath: options.appPath,
-      entrypoint: options.entrypoint,
-      buildType: options.buildType,
-      signal: options.signal,
-      buildSettings: options.buildSettings,
-    });
-
-    return {
-      buildType: options.buildType,
-      strategy,
-    };
-  }
-
-  for (const buildType of RESOLVED_PREVIEW_BUILD_TYPES) {
-    // Bun is the fallback because it can build any valid Bun entrypoint.
-    if (buildType === "bun") continue;
-
-    const strategy = await createPreviewBuildStrategy({
-      appPath: options.appPath,
-      entrypoint: options.entrypoint,
-      buildType,
-      signal: options.signal,
-      buildSettings: options.buildSettings,
-    });
-
-    if (await strategy.canBuild(options.signal)) {
-      return {
-        buildType,
-        strategy,
-      };
-    }
-  }
-
-  return {
-    buildType: "bun",
-    strategy: await createPreviewBuildStrategy({
-      appPath: options.appPath,
-      entrypoint: options.entrypoint,
-      buildType: "bun",
-      signal: options.signal,
-      buildSettings: options.buildSettings,
-    }),
-  };
-}
-
-/**
- * Constructs the SDK build strategy for a resolved framework. The strategies
- * run the framework build (and any `package.json` build script) and stage a
- * deployable artifact themselves; the CLI only resolves the Bun entrypoint,
- * which supports the `module` field on top of `main`.
- */
-async function createPreviewBuildStrategy(options: {
-  appPath: string;
-  entrypoint?: string;
-  buildType: ResolvedPreviewBuildType;
-  signal?: AbortSignal;
-  buildSettings?: PreviewBuildSettings;
-}): Promise<BuildStrategy> {
-  switch (options.buildType) {
-    case "nextjs":
-      return new NextjsBuild({
-        appPath: options.appPath,
-        buildSettings: options.buildSettings,
-      });
-    case "nuxt":
-      return new NuxtBuild({ appPath: options.appPath });
-    case "astro":
-      return new AstroBuild({ appPath: options.appPath });
-    case "nestjs":
-      return new NestjsBuild({
-        appPath: options.appPath,
-        buildSettings: options.buildSettings,
-      });
-    case "tanstack-start":
-      return new TanstackStartBuild({
-        appPath: options.appPath,
-        buildSettings: options.buildSettings,
-      });
-    case "bun": {
-      const entrypoint = await resolveBunEntrypoint(
-        options.appPath,
-        options.entrypoint,
-        options.signal,
-      );
-      return new BunBuild({
-        appPath: options.appPath,
-        entrypoint,
-        buildSettings: options.buildSettings,
-      });
-    }
-  }
+  // Detection, per-framework construction, and Bun entrypoint resolution
+  // (package.json `main`) all live in the SDK now; the CLI forwards. The CLI's
+  // build types map 1:1 to the SDK's, and `auto` is the SDK default.
+  return resolveBuildStrategy({
+    appPath: options.appPath,
+    buildType: options.buildType,
+    entrypoint: options.entrypoint,
+    buildSettings: options.buildSettings,
+    signal: options.signal,
+  });
 }
 
 /**

packages/cli/tests/app-bun-compat.test.ts

@@ -11,21 +11,8 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
-function mockBuildStrategy(
-  createInstance: (options: object) => object = () => ({
-    canBuild: vi.fn(),
-    execute: vi.fn(),
-  }),
-) {
-  return vi.fn().mockImplementation(function BuildStrategyMock(
-    options: object,
-  ) {
-    return createInstance(options);
-  });
-}
-
 describe("bun compatibility", () => {
-  it("resolves the Bun entrypoint from package.json module", async () => {
+  it("does not fall back to package.json module for the Bun entrypoint", async () => {
     const cwd = await createTempCwd();
 
     await writeFile(
@@ -50,8 +37,8 @@ describe("bun compatibility", () => {
 
     const { resolveBunEntrypoint } = await import("../src/lib/app/bun-project");
 
-    await expect(resolveBunEntrypoint(cwd, undefined)).resolves.toBe(
-      "index.ts",
+    await expect(resolveBunEntrypoint(cwd, undefined)).rejects.toThrow(
+      "Entrypoint is required. Pass --entry or define package.json main.",
     );
   });
 
@@ -68,14 +55,14 @@ describe("bun compatibility", () => {
     );
   });
 
-  it("detects a Bun project when package.json uses module instead of main", async () => {
+  it("detects a Bun project from package.json main and a bun dev script", async () => {
     const cwd = await createTempCwd();
 
     await writeFile(
       path.join(cwd, "package.json"),
       JSON.stringify(
         {
-          module: "index.ts",
+          main: "index.ts",
           devDependencies: {
             "@types/bun": "latest",
           },
@@ -99,139 +86,9 @@ describe("bun compatibility", () => {
     await expect(detectLocalBuildType(cwd)).resolves.toBe("bun");
   });
 
-  it("passes the module-based Bun entrypoint into the shared deploy/build strategy", async () => {
+  it("forwards explicit build types to the SDK strategy resolver", async () => {
     const cwd = await createTempCwd();
 
-    await writeFile(
-      path.join(cwd, "package.json"),
-      JSON.stringify(
-        {
-          module: "index.ts",
-          devDependencies: {
-            "@types/bun": "latest",
-          },
-        },
-        null,
-        2,
-      ),
-      "utf8",
-    );
-    await writeFile(
-      path.join(cwd, "index.ts"),
-      "console.log('hello');\n",
-      "utf8",
-    );
-
-    const bunBuild = mockBuildStrategy((options: object) => ({
-      options,
-      canBuild: vi.fn().mockResolvedValue(true),
-      execute: vi.fn(),
-    }));
-    const nextjsBuild = mockBuildStrategy(() => ({
-      canBuild: vi.fn().mockResolvedValue(false),
-      execute: vi.fn(),
-    }));
-    const otherFrameworkBuild = mockBuildStrategy(() => ({
-      canBuild: vi.fn().mockResolvedValue(false),
-      execute: vi.fn(),
-    }));
-
-    vi.doMock("@prisma/compute-sdk", async (importOriginal) => ({
-      ...(await importOriginal<typeof import("@prisma/compute-sdk")>()),
-      AstroBuild: otherFrameworkBuild,
-      BunBuild: bunBuild,
-      NextjsBuild: nextjsBuild,
-      NuxtBuild: otherFrameworkBuild,
-      NestjsBuild: otherFrameworkBuild,
-      TanstackStartBuild: otherFrameworkBuild,
-    }));
-
-    const { resolvePreviewBuildStrategy } = await import(
-      "../src/lib/app/preview-build"
-    );
-
-    const result = await resolvePreviewBuildStrategy({
-      appPath: cwd,
-      buildType: "auto",
-      entrypoint: undefined,
-    });
-
-    expect(result.buildType).toBe("bun");
-    expect(bunBuild).toHaveBeenCalledWith({
-      appPath: cwd,
-      entrypoint: "index.ts",
-    });
-  });
-
-  it("auto-detects SDK framework strategies before falling back to Bun", async () => {
-    const cwd = await createTempCwd();
-
-    const bunBuild = mockBuildStrategy(() => ({
-      canBuild: vi.fn().mockResolvedValue(true),
-      execute: vi.fn(),
-    }));
-    const nextjsBuild = mockBuildStrategy(() => ({
-      canBuild: vi.fn().mockResolvedValue(false),
-      execute: vi.fn(),
-    }));
-    const nuxtBuild = mockBuildStrategy(() => ({
-      canBuild: vi.fn().mockResolvedValue(true),
-      execute: vi.fn(),
-    }));
-    const astroBuild = mockBuildStrategy(() => ({
-      canBuild: vi.fn().mockResolvedValue(true),
-      execute: vi.fn(),
-    }));
-    const tanstackStartBuild = mockBuildStrategy(() => ({
-      canBuild: vi.fn().mockResolvedValue(true),
-      execute: vi.fn(),
-    }));
-
-    vi.doMock("@prisma/compute-sdk", async (importOriginal) => ({
-      ...(await importOriginal<typeof import("@prisma/compute-sdk")>()),
-      AstroBuild: astroBuild,
-      BunBuild: bunBuild,
-      NextjsBuild: nextjsBuild,
-      NuxtBuild: nuxtBuild,
-      NestjsBuild: nextjsBuild,
-      TanstackStartBuild: tanstackStartBuild,
-    }));
-
-    const { resolvePreviewBuildStrategy } = await import(
-      "../src/lib/app/preview-build"
-    );
-
-    const result = await resolvePreviewBuildStrategy({
-      appPath: cwd,
-      buildType: "auto",
-      entrypoint: undefined,
-    });
-
-    expect(result.buildType).toBe("nuxt");
-    expect(nuxtBuild).toHaveBeenCalledWith({ appPath: cwd });
-    expect(bunBuild).not.toHaveBeenCalled();
-    expect(astroBuild).not.toHaveBeenCalled();
-    expect(tanstackStartBuild).not.toHaveBeenCalled();
-  });
-
-  it("resolves explicit SDK framework build strategies", async () => {
-    const cwd = await createTempCwd();
-
-    const buildStrategy = mockBuildStrategy(() => ({
-      canBuild: vi.fn(),
-      execute: vi.fn(),
-    }));
-
-    vi.doMock("@prisma/compute-sdk", async (importOriginal) => ({
-      ...(await importOriginal<typeof import("@prisma/compute-sdk")>()),
-      AstroBuild: buildStrategy,
-      BunBuild: buildStrategy,
-      NextjsBuild: buildStrategy,
-      NuxtBuild: buildStrategy,
-      NestjsBuild: buildStrategy,
-      TanstackStartBuild: buildStrategy,
-    }));
-
     const { resolvePreviewBuildStrategy } = await import(
       "../src/lib/app/preview-build"
     );

packages/cli/tests/app-controller.test.ts

@@ -2290,8 +2290,8 @@ describe("app controller", () => {
       expectedBuildType: "bun",
     },
     {
-      name: "Bun from --framework bun with package.json module",
-      packageJson: { module: "index.ts" },
+      name: "Bun from --framework bun with package.json main",
+      packageJson: { main: "index.ts" },
       framework: "bun",
       expectedEntrypoint: "index.ts",
       expectedBuildType: "bun",