Verdict

“Use Turborepo's built‑in `turbo prune --docker` to generate a minimal repository copy containing only the API workspace and its dependencies before building the Docker image.”

The problem of building a Docker image for a single app in a Turborepo/Bun monorepo is well‑known and already addressed by existing tooling. Turborepo provides the `turbo prune --docker` command (or `turbo prune -- --docker`) that creates a temporary copy of the repository containing only the workspace and its transitive dependencies, which can then be used as the Docker build context. This eliminates the need to manually copy individual `package.json` files and avoids the Bun error that occurs when workspaces are missing. Alternative approaches include using a `.dockerignore` file to exclude unrelated apps, employing multi‑stage Dockerfiles that run `bun install` in a stage with the full repo and then copy only the needed output, or using package managers that support workspace filtering (e.g., Yarn 2+ `yarn workspaces focus`). Because the solution is already built into Turborepo and similar monorepo tools, there is little room for a new entrant to offer a defensible differentiation unless they provide a significantly smoother developer experience, deeper integration with Bun's lockfile handling, or automated CI/CD pipelines that go beyond what `turbo prune` already delivers. In practice, the recommended production approach is to rely on `turbo prune --docker` (or an equivalent workspace‑filtering step) rather than copying the whole repository or attempting custom selective copies.

“Turborepo and Bun's monorepo-centric design makes building an isolated Docker image for a single app highly non-standard and inefficient.”

The proposed Docker image build approach for a single Turborepo app (API) is fraught with structural and dependency challenges inherent to Turborepo and Bun's design. By design, Turborepo and Bun are optimized for monorepo workflows, assuming a unified build context. Attempting to isolate a single app (e.g., `apps/api`) while excluding others (`apps/admin`, `apps/public`) breaks this assumption, leading to resolution errors for declared but missing workspaces. Copying the entire repository works but bloats the image. `turbo prune --docker` is designed for Turbo's build system, not directly applicable to Bun's dependency resolution in this context. Bun's `install` command, tied to the root `package.json`'s workspace declaration, insists on all declared workspaces being present, making selective installation of only `api` and its direct dependencies (like `@repo/db`) without the full workspace context highly non-standard and unsupported out-of-the-box. This setup forces a choice between image bloat or significant custom scripting to mimic a partial monorepo setup, neither of which aligns with 'recommended production approaches' for Turborepo/Bun ecosystems.

“Use `turbo prune --docker` to generate a minimal, dependency-resolved Docker context for a single Turborepo app.”

The core problem here is a mismatch between Turborepo's workspace-aware tooling (which expects all declared workspaces to exist) and Docker's layer-based build system (which struggles with partial workspace resolution). The user's frustration is valid: copying the entire repo works but bloats the image, while selective copying breaks Bun's workspace resolution. The recommended production approach is indeed `turbo prune --docker`, which is purpose-built for this scenario. This command generates a minimal, self-contained snapshot of the monorepo containing only the app and its transitive dependencies, then outputs a Dockerfile template. It handles workspace resolution correctly by rewriting package references to point to the pruned context. Alternatives like manual COPY directives are fragile and violate the principle of least surprise. The audience for this solution is primarily JavaScript/TypeScript monorepo maintainers who need production-grade Docker builds without unnecessary bloat. The market size is substantial: monorepos are increasingly popular (e.g., ~30% of large JS codebases use Turborepo or similar), and Docker optimization is a recurring pain point. Willingness to pay exists indirectly - developers will adopt this pattern to reduce CI/CD costs and deployment sizes, even if they don't pay directly for the tooling. The unmet need is a frictionless path from monorepo to minimal Docker image, which `turbo prune` directly addresses.

“Using `turbo prune --docker` is the recommended approach to build a Docker image for a specific app in a Turborepo, as it efficiently includes only the necessary dependencies.”

The idea addresses a common challenge in monorepo setups: efficiently building Docker images for specific apps without including unnecessary dependencies. The proposed solution using `turbo prune --docker` is a strong approach, as it automatically prunes the repository to include only the necessary dependencies for the specified app. This reduces the Docker image size and build time, which is crucial for production efficiency. However, the implementation requires careful handling of workspace dependencies and ensuring that the pruned repository still meets all runtime requirements. The key insight is that leveraging Turborepo's built-in tools like `turbo prune` can significantly optimize the Docker build process for monorepos.

“Use `turbo prune --docker` to minimize the build context, then copy and install only necessary parts, accepting some repository copying as a practical compromise.”

Building a Docker image for a single app in a Turborepo with Bun workspaces is feasible but requires careful handling of dependencies and workspace configurations. The challenge lies in Bun's expectation of all declared workspaces, complicating selective dependency installation. Copying the whole repository (score reducer: -2 for inefficiency) works but is not ideal due to image size. Turbo prune --docker (score booster: +1 for efficiency) can help optimize the build context by only including necessary files, reducing the image size significantly. However, its primary function is to optimize build times by pruning unnecessary files for Turbo builds, not necessarily solving the Bun install issue for isolated workspaces. The recommended approach involves a hybrid strategy: use `turbo prune --docker` to minimize the build context while still copying the necessary parts of the repository to satisfy Bun's workspace expectations, then apply a post-install cleanup (score booster: +1 for creativity). Directly installing only the API workspace without copying all workspaces isn't natively supported by Bun due to its workspace resolution mechanism (score reducer: -2 for complexity).