fix(shadcn): apply for monorepo

Author: shadcn

.changeset/thirty-aliens-live.md

@@ -0,0 +1,5 @@
+---
+"shadcn": patch
+---
+
+fix apply in monorepo

packages/shadcn/src/commands/apply.ts

@@ -16,8 +16,12 @@ import { isUrl } from "@/src/registry/utils"
 import { getTemplateForFramework } from "@/src/templates/index"
 import { loadEnvFiles } from "@/src/utils/env-loader"
 import * as ERRORS from "@/src/utils/errors"
-import { withFileBackup } from "@/src/utils/file-helper"
-import { getBase } from "@/src/utils/get-config"
+import { FileBackupError, withFileBackup } from "@/src/utils/file-helper"
+import {
+  getBase,
+  getWorkspaceConfig,
+  type Config,
+} from "@/src/utils/get-config"
 import {
   getProjectComponents,
   getProjectInfo,
@@ -26,6 +30,7 @@ import { handleError } from "@/src/utils/handle-error"
 import { highlighter } from "@/src/utils/highlighter"
 import { logger } from "@/src/utils/logger"
 import { Command } from "commander"
+import fs from "fs-extra"
 import prompts from "prompts"
 import { z } from "zod"
 
@@ -209,7 +214,7 @@ export const apply = new Command()
             only,
           })
 
-          await runInit({
+          const config = await runInit({
             cwd: options.cwd,
             yes: true,
             force: false,
@@ -223,15 +228,8 @@ export const apply = new Command()
             existingConfig,
             components: [cleanUrl, ...reinstallComponents],
           })
-        },
-        {
-          onBackupFailure: () => {
-            logger.error(
-              `Could not back up ${highlighter.info(
-                "components.json"
-              )}. Aborting.`
-            )
-          },
+
+          await syncApplyWorkspaceConfigs(config, { only })
         }
       )
 
@@ -247,6 +245,14 @@ export const apply = new Command()
         process.exit(1)
       }
 
+      if (error instanceof FileBackupError) {
+        logger.error(
+          `Could not back up ${highlighter.info("components.json")}. Aborting.`
+        )
+        logger.break()
+        process.exit(1)
+      }
+
       logger.break()
       handleError(error)
     } finally {
@@ -406,6 +412,79 @@ async function resolveApplyTemplate(cwd: string) {
   return getTemplateForFramework(projectInfo?.framework.name)
 }
 
+async function syncApplyWorkspaceConfigs(
+  config: Config,
+  options?: {
+    only?: string[]
+  }
+) {
+  if (options?.only && !options.only.includes("theme")) {
+    return
+  }
+
+  const linkedConfigs = await getApplyWorkspaceConfigs(config)
+  if (!linkedConfigs.length) {
+    return
+  }
+
+  const patch = {
+    style: config.style,
+    tailwind: {
+      baseColor: config.tailwind.baseColor,
+      cssVariables: config.tailwind.cssVariables,
+    },
+    ...(config.iconLibrary ? { iconLibrary: config.iconLibrary } : {}),
+    ...(config.rtl !== undefined ? { rtl: config.rtl } : {}),
+    ...(config.menuColor ? { menuColor: config.menuColor } : {}),
+    ...(config.menuAccent ? { menuAccent: config.menuAccent } : {}),
+  }
+
+  for (const linkedConfig of linkedConfigs) {
+    const configPath = path.resolve(
+      linkedConfig.resolvedPaths.cwd,
+      "components.json"
+    )
+    if (!(await fs.pathExists(configPath))) {
+      continue
+    }
+
+    const existingConfig = await fs.readJson(configPath)
+    await fs.writeJson(
+      configPath,
+      {
+        ...existingConfig,
+        ...patch,
+        tailwind: {
+          ...existingConfig.tailwind,
+          ...patch.tailwind,
+        },
+      },
+      { spaces: 2 }
+    )
+  }
+}
+
+async function getApplyWorkspaceConfigs(config: Config) {
+  const workspaceConfig = await getWorkspaceConfig(config)
+  if (!workspaceConfig) {
+    return []
+  }
+
+  const linkedConfigs = new Map<string, Config>()
+
+  for (const linkedConfig of Object.values(workspaceConfig)) {
+    if (linkedConfig.resolvedPaths.cwd === config.resolvedPaths.cwd) {
+      continue
+    }
+
+    linkedConfigs.set(linkedConfig.resolvedPaths.cwd, linkedConfig)
+  }
+
+  return Array.from(linkedConfigs.values()).sort((a, b) =>
+    a.resolvedPaths.cwd.localeCompare(b.resolvedPaths.cwd)
+  )
+}
+
 export function resolveApplyInitUrl(
   preset: string,
   currentBase: "radix" | "base",

packages/shadcn/src/preflights/preflight-apply.ts

@@ -7,6 +7,7 @@ import {
   getMonorepoTargets,
   isMonorepoRoot,
 } from "@/src/utils/get-monorepo-info"
+import { getProjectInfo } from "@/src/utils/get-project-info"
 import { highlighter } from "@/src/utils/highlighter"
 import { logger } from "@/src/utils/logger"
 import fs from "fs-extra"
@@ -28,8 +29,19 @@ export async function preFlightApply(options: { cwd: string }) {
   if (!fs.existsSync(path.resolve(options.cwd, "components.json"))) {
     if (await isMonorepoRoot(options.cwd)) {
       const targets = await getMonorepoTargets(options.cwd)
-      if (targets.length > 0) {
-        formatMonorepoMessage("apply --preset <preset>", targets, {
+      const applyTargets = []
+
+      for (const target of targets) {
+        const projectInfo = await getProjectInfo(
+          path.resolve(options.cwd, target.name)
+        )
+        if (projectInfo?.framework && projectInfo.framework.name !== "manual") {
+          applyTargets.push(target)
+        }
+      }
+
+      if (applyTargets.length > 0) {
+        formatMonorepoMessage("apply --preset <preset>", applyTargets, {
           cwdFlag: "-c",
         })
         process.exit(1)

packages/shadcn/src/utils/file-helper.test.ts

@@ -3,7 +3,11 @@ import path from "path"
 import fs from "fs-extra"
 import { afterEach, describe, expect, it, vi } from "vitest"
 
-import { FILE_BACKUP_SUFFIX, withFileBackup } from "./file-helper"
+import {
+  FILE_BACKUP_SUFFIX,
+  FileBackupError,
+  withFileBackup,
+} from "./file-helper"
 
 const tempDirs: string[] = []
 
@@ -18,6 +22,7 @@ async function createTempFile() {
 }
 
 afterEach(async () => {
+  vi.restoreAllMocks()
   await Promise.all(tempDirs.splice(0).map((dir) => fs.remove(dir)))
 })
 
@@ -49,22 +54,21 @@ describe("withFileBackup", () => {
 
   it("should abort when backup creation fails", async () => {
     const filePath = await createTempFile()
-    const consoleErrorSpy = vi
-      .spyOn(console, "error")
-      .mockImplementation(() => {})
+    const task = vi.fn(async () => {
+      await fs.writeFile(filePath, '{"style":"after"}\n', "utf8")
+    })
     const renameSyncSpy = vi.spyOn(fs, "renameSync").mockImplementation(() => {
       throw new Error("boom")
     })
 
-    await expect(
-      withFileBackup(filePath, async () => {
-        await fs.writeFile(filePath, '{"style":"after"}\n', "utf8")
-      })
-    ).rejects.toThrow(`Could not back up ${filePath}.`)
+    await expect(withFileBackup(filePath, task)).rejects.toThrow(
+      FileBackupError
+    )
 
+    expect(task).not.toHaveBeenCalled()
     expect(await fs.readFile(filePath, "utf8")).toBe('{"style":"before"}\n')
+    expect(await fs.pathExists(`${filePath}${FILE_BACKUP_SUFFIX}`)).toBe(false)
 
     renameSyncSpy.mockRestore()
-    consoleErrorSpy.mockRestore()
   })
 })

packages/shadcn/src/utils/file-helper.ts

@@ -2,8 +2,14 @@ import fsExtra from "fs-extra"
 
 export const FILE_BACKUP_SUFFIX = ".bak"
 
-type WithFileBackupOptions = {
-  onBackupFailure?: (filePath: string) => void
+export class FileBackupError extends Error {
+  filePath: string
+
+  constructor(filePath: string) {
+    super(`Could not back up ${filePath}.`)
+    this.name = "FileBackupError"
+    this.filePath = filePath
+  }
 }
 
 export function createFileBackup(filePath: string): string | null {
@@ -15,8 +21,7 @@ export function createFileBackup(filePath: string): string | null {
   try {
     fsExtra.renameSync(filePath, backupPath)
     return backupPath
-  } catch (error) {
-    console.error(`Failed to create backup of ${filePath}: ${error}`)
+  } catch {
     return null
   }
 }
@@ -57,8 +62,7 @@ export function deleteFileBackup(filePath: string): boolean {
 
 export async function withFileBackup<T>(
   filePath: string,
-  task: () => Promise<T>,
-  options: WithFileBackupOptions = {}
+  task: () => Promise<T>
 ) {
   if (!fsExtra.existsSync(filePath)) {
     return task()
@@ -67,8 +71,7 @@ export async function withFileBackup<T>(
   const backupPath = createFileBackup(filePath)
 
   if (!backupPath) {
-    options.onBackupFailure?.(filePath)
-    throw new Error(`Could not back up ${filePath}.`)
+    throw new FileBackupError(filePath)
   }
 
   const restoreBackupOnExit = () => restoreFileBackup(filePath)