everything-dev 1.16.2 → 1.17.0

package/src/cli/upgrade.ts

@@ -3,12 +3,13 @@ import { join } from "node:path";
 import process from "node:process";
 import * as p from "@clack/prompts";
 import { glob } from "glob";
-import type { UpgradeOptions, UpgradeResult } from "../contract";
+import type { PhaseTiming, UpgradeOptions, UpgradeResult } from "../contract";
 import { resolveExtendsRef } from "../merge";
 import { saveBosConfig } from "../utils/save-config";
 import { readInstalledFrameworkVersion } from "./framework-version";
 import { fetchParentConfig, runBunInstall, runTypesGen } from "./init";
 import { syncTemplate } from "./sync";
+import { timePhase } from "./timing";
 
 const FRAMEWORK_PACKAGES = ["everything-dev", "every-plugin"];
 
@@ -69,6 +70,197 @@ function parseBosRef(ref: string): { account: string; gateway: string } | null {
   return { account: match[1], gateway: match[2] };
 }
 
+function parseTargetedRef(ref: string): { configRef: string; targetPath?: string } {
+  const hashIndex = ref.indexOf("#");
+  if (hashIndex === -1) {
+    return { configRef: ref };
+  }
+  return {
+    configRef: ref.slice(0, hashIndex),
+    targetPath: ref.slice(hashIndex + 1) || undefined,
+  };
+}
+
+function ensureTargetedRef(ref: string, targetPath: string): string {
+  const parsed = parseTargetedRef(ref);
+  if (parsed.targetPath) return ref;
+  return `${parsed.configRef}#${targetPath}`;
+}
+
+function rewriteExtendsTarget(
+  entry: Record<string, unknown> | undefined,
+  targetPath: string,
+): boolean {
+  if (!entry?.extends) return false;
+
+  if (typeof entry.extends === "string") {
+    const next = ensureTargetedRef(entry.extends, targetPath);
+    if (next === entry.extends) return false;
+    entry.extends = next;
+    return true;
+  }
+
+  if (typeof entry.extends === "object") {
+    let changed = false;
+    for (const [key, value] of Object.entries(entry.extends as Record<string, unknown>)) {
+      if (typeof value !== "string") continue;
+      const next = ensureTargetedRef(value, targetPath);
+      if (next !== value) {
+        (entry.extends as Record<string, unknown>)[key] = next;
+        changed = true;
+      }
+    }
+    return changed;
+  }
+
+  return false;
+}
+
+function migrateRootConfigTargets(config: Record<string, unknown>): boolean {
+  let changed = false;
+  const app =
+    config.app && typeof config.app === "object"
+      ? (config.app as Record<string, unknown>)
+      : undefined;
+
+  if (app?.api && typeof app.api === "object") {
+    changed = rewriteExtendsTarget(app.api as Record<string, unknown>, "app.api") || changed;
+  }
+  if (app?.auth && typeof app.auth === "object") {
+    changed = rewriteExtendsTarget(app.auth as Record<string, unknown>, "app.auth") || changed;
+  }
+
+  if (config.plugins && typeof config.plugins === "object") {
+    for (const [pluginKey, pluginValue] of Object.entries(
+      config.plugins as Record<string, unknown>,
+    )) {
+      if (typeof pluginValue === "string") {
+        const next = ensureTargetedRef(pluginValue, `plugins.${pluginKey}`);
+        if (next !== pluginValue) {
+          (config.plugins as Record<string, unknown>)[pluginKey] = next;
+          changed = true;
+        }
+        continue;
+      }
+      if (!pluginValue || typeof pluginValue !== "object") continue;
+      changed =
+        rewriteExtendsTarget(pluginValue as Record<string, unknown>, `plugins.${pluginKey}`) ||
+        changed;
+    }
+  }
+
+  return changed;
+}
+
+function migratePluginProviderConfig(config: Record<string, unknown>, pluginKey: string): boolean {
+  let changed = false;
+  if (!config.plugins || typeof config.plugins !== "object") {
+    config.plugins = {};
+    changed = true;
+  }
+
+  const plugins = config.plugins as Record<string, unknown>;
+  if (!plugins[pluginKey] || typeof plugins[pluginKey] !== "object") {
+    plugins[pluginKey] = { name: pluginKey };
+    changed = true;
+  }
+
+  const pluginEntry = plugins[pluginKey] as Record<string, unknown>;
+  if (typeof pluginEntry.name !== "string" || pluginEntry.name.length === 0) {
+    pluginEntry.name = pluginKey;
+    changed = true;
+  }
+
+  const app =
+    config.app && typeof config.app === "object"
+      ? (config.app as Record<string, unknown>)
+      : undefined;
+  const apiEntry =
+    app?.api && typeof app.api === "object" ? (app.api as Record<string, unknown>) : undefined;
+
+  if (apiEntry) {
+    for (const key of [
+      "extends",
+      "name",
+      "development",
+      "production",
+      "integrity",
+      "proxy",
+      "variables",
+      "secrets",
+      "sidebar",
+      "routes",
+    ] as const) {
+      if (pluginEntry[key] === undefined && apiEntry[key] !== undefined) {
+        pluginEntry[key] = apiEntry[key];
+        changed = true;
+      }
+    }
+
+    delete app!.api;
+    changed = true;
+    if (Object.keys(app!).length === 0) {
+      delete config.app;
+    }
+  }
+
+  if (config.sidebar !== undefined && pluginEntry.sidebar === undefined) {
+    pluginEntry.sidebar = config.sidebar;
+    changed = true;
+  }
+  if (config.routes !== undefined && pluginEntry.routes === undefined) {
+    pluginEntry.routes = config.routes;
+    changed = true;
+  }
+  if (config.sidebar !== undefined) {
+    delete config.sidebar;
+    changed = true;
+  }
+  if (config.routes !== undefined) {
+    delete config.routes;
+    changed = true;
+  }
+
+  changed = rewriteExtendsTarget(pluginEntry, `plugins.${pluginKey}`) || changed;
+
+  return changed;
+}
+
+export async function migrateBosConfigFiles(projectDir: string): Promise<string[]> {
+  const migrated: string[] = [];
+  const rootConfigPath = join(projectDir, "bos.config.json");
+
+  if (existsSync(rootConfigPath)) {
+    const rootConfig = JSON.parse(readFileSync(rootConfigPath, "utf-8")) as Record<string, unknown>;
+    if (migrateRootConfigTargets(rootConfig)) {
+      await saveBosConfig(projectDir, rootConfig);
+      migrated.push("bos.config.json");
+    }
+  }
+
+  const pluginConfigPaths = await glob("plugins/*/bos.config.json", {
+    cwd: projectDir,
+    nodir: true,
+    dot: false,
+    absolute: false,
+  });
+
+  for (const relativePath of pluginConfigPaths) {
+    const match = relativePath.match(/^plugins\/([^/]+)\/bos\.config\.json$/);
+    const pluginKey = match?.[1];
+    if (!pluginKey) continue;
+
+    const filePath = join(projectDir, relativePath);
+    const pluginConfig = JSON.parse(readFileSync(filePath, "utf-8")) as Record<string, unknown>;
+    if (!migratePluginProviderConfig(pluginConfig, pluginKey)) continue;
+
+    writeFileSync(filePath, `${JSON.stringify(pluginConfig, null, 2)}\n`);
+    migrated.push(relativePath);
+  }
+
+  return migrated;
+}
+
 async function loadParentPluginOptions(projectDir: string): Promise<{
   localConfig: Record<string, unknown>;
   parentPlugins: Record<string, unknown>;
@@ -141,7 +333,16 @@ async function addSelectedParentPlugins(projectDir: string): Promise<string[]> {
       : {};
   const nextPlugins = { ...localPlugins };
   for (const key of selected) {
-    nextPlugins[key] = pluginOptions.parentPlugins[key];
+    const parentPlugin = pluginOptions.parentPlugins[key];
+    if (parentPlugin && typeof parentPlugin === "object") {
+      const nextPlugin = structuredClone(parentPlugin as Record<string, unknown>);
+      rewriteExtendsTarget(nextPlugin, `plugins.${key}`);
+      nextPlugins[key] = nextPlugin;
+    } else if (typeof parentPlugin === "string") {
+      nextPlugins[key] = ensureTargetedRef(parentPlugin, `plugins.${key}`);
+    } else {
+      nextPlugins[key] = parentPlugin;
+    }
   }
 
   pluginOptions.localConfig.plugins = nextPlugins;
@@ -333,38 +534,52 @@ export async function upgradeTemplate(
   projectDir: string,
   options: UpgradeOptions,
 ): Promise<UpgradeResult> {
+  const timings: PhaseTiming[] = [];
   const pkgPath = join(projectDir, "package.json");
   if (!existsSync(pkgPath)) {
     return {
       status: "error",
       packages: [],
+      timings,
       error: "No package.json found in current directory",
     };
   }
 
-  const packages: UpgradeResult["packages"] = [];
+  const { packages, catalogVersionUpdates } = await timePhase(
+    timings,
+    "check package versions",
+    async () => {
+      const nextPackages: UpgradeResult["packages"] = [];
 
-  for (const name of FRAMEWORK_PACKAGES) {
-    const installed = readInstalledVersion(projectDir, name);
-    const latest = await fetchLatestNpmVersion(name);
+      for (const name of FRAMEWORK_PACKAGES) {
+        const installed = readInstalledVersion(projectDir, name);
+        const latest = await fetchLatestNpmVersion(name);
 
-    if (!latest) {
-      packages.push({ name, from: installed, to: installed ?? "unknown" });
-      continue;
-    }
+        if (!latest) {
+          nextPackages.push({ name, from: installed, to: installed ?? "unknown" });
+          continue;
+        }
 
-    packages.push({ name, from: installed, to: latest });
-  }
+        nextPackages.push({ name, from: installed, to: latest });
+      }
 
-  const catalogVersionUpdates: Array<{ name: string; from: string | undefined; to: string }> = [];
-  for (const name of CATALOG_TOOL_PACKAGES) {
-    const installed = readInstalledVersion(projectDir, name);
-    if (!installed) continue;
-    const latest = await fetchLatestNpmVersion(name);
-    if (!latest) continue;
-    if (installed === latest) continue;
-    catalogVersionUpdates.push({ name, from: installed, to: latest });
-  }
+      const nextCatalogVersionUpdates: Array<{
+        name: string;
+        from: string | undefined;
+        to: string;
+      }> = [];
+      for (const name of CATALOG_TOOL_PACKAGES) {
+        const installed = readInstalledVersion(projectDir, name);
+        if (!installed) continue;
+        const latest = await fetchLatestNpmVersion(name);
+        if (!latest) continue;
+        if (installed === latest) continue;
+        nextCatalogVersionUpdates.push({ name, from: installed, to: latest });
+      }
+
+      return { packages: nextPackages, catalogVersionUpdates: nextCatalogVersionUpdates };
+    },
+  );
 
   const hasFrameworkUpdates = packages.some((p) => p.from !== p.to && p.from !== undefined);
   const hasCatalogUpdates = catalogVersionUpdates.length > 0;
@@ -372,7 +587,11 @@ export async function upgradeTemplate(
 
   if (options.dryRun) {
     let changelogUrl: string | undefined;
-    const pluginOptions = options.noSync ? null : await loadParentPluginOptions(projectDir);
+    const pluginOptions = options.noSync
+      ? null
+      : await timePhase(timings, "discover parent plugins", () =>
+          loadParentPluginOptions(projectDir),
+        );
     if (hasUpdates) {
       const configPath = join(projectDir, "bos.config.json");
       let parentConfig: Record<string, unknown> | null = null;
@@ -394,59 +613,75 @@ export async function upgradeTemplate(
         ...catalogVersionUpdates.map((u) => ({ name: u.name, from: u.from, to: u.to })),
       ],
       availablePlugins: pluginOptions?.newPluginKeys,
+      timings,
       changelogUrl,
     };
   }
 
-  for (const pkg of packages) {
-    if (pkg.from !== undefined && pkg.from !== pkg.to) {
-      updateRootPackageVersion(projectDir, pkg.name, pkg.to);
-    }
-  }
-
-  for (const update of catalogVersionUpdates) {
-    updateRootCatalogVersion(projectDir, update.name, update.to);
-  }
-
-  const workspacePkgPaths = await findWorkspacePackageJsons(projectDir);
-  for (const pkgPath of workspacePkgPaths) {
+  await timePhase(timings, "apply package updates", async () => {
     for (const pkg of packages) {
       if (pkg.from !== undefined && pkg.from !== pkg.to) {
-        updateWorkspacePackageRefInFile(pkgPath, pkg.name);
+        updateRootPackageVersion(projectDir, pkg.name, pkg.to);
       }
     }
+
     for (const update of catalogVersionUpdates) {
-      updateWorkspacePackageRefInFile(pkgPath, update.name);
+      updateRootCatalogVersion(projectDir, update.name, update.to);
     }
-  }
+
+    const workspacePkgPaths = await findWorkspacePackageJsons(projectDir);
+    for (const pkgPath of workspacePkgPaths) {
+      for (const pkg of packages) {
+        if (pkg.from !== undefined && pkg.from !== pkg.to) {
+          updateWorkspacePackageRefInFile(pkgPath, pkg.name);
+        }
+      }
+      for (const update of catalogVersionUpdates) {
+        updateWorkspacePackageRefInFile(pkgPath, update.name);
+      }
+    }
+  });
+
+  const migratedBosConfigs = await timePhase(timings, "migrate bos configs", () =>
+    migrateBosConfigFiles(projectDir),
+  );
 
   let syncResult: UpgradeResult["sync"];
   let addedPlugins: string[] = [];
   if (!options.noSync) {
-    if (!options.dryRun) {
-      addedPlugins = await addSelectedParentPlugins(projectDir);
-    }
-
-    syncResult = await syncTemplate(projectDir, {
-      dryRun: false,
-      force: options.force,
-      noInstall: true,
+    addedPlugins = await timePhase(timings, "discover parent plugins", async () => {
+      if (options.dryRun) return [];
+      return addSelectedParentPlugins(projectDir);
     });
-  }
 
-  if ((hasUpdates || addedPlugins.length > 0) && !options.noInstall) {
-    await runBunInstall(projectDir);
-    await runTypesGen(projectDir);
+    syncResult = await timePhase(timings, "sync template", () =>
+      syncTemplate(projectDir, {
+        dryRun: false,
+        force: options.force,
+        noInstall: true,
+      }),
+    );
   }
 
-  const migratedFiles = await rewriteLegacyUiImports(projectDir);
-  for (const file of OBSOLETE_FILES) {
-    const filePath = join(projectDir, file);
-    if (existsSync(filePath)) {
-      rmSync(filePath);
-      migratedFiles.push(file);
+  if ((hasUpdates || addedPlugins.length > 0) && !options.noInstall) {
+    await timePhase(timings, "install dependencies", () => runBunInstall(projectDir));
+    await timePhase(timings, "generate types", () => runTypesGen(projectDir));
+  }
+
+  const migratedFiles = await timePhase(timings, "clean obsolete files", async () => {
+    const nextMigratedFiles = [
+      ...migratedBosConfigs,
+      ...(await rewriteLegacyUiImports(projectDir)),
+    ];
+    for (const file of OBSOLETE_FILES) {
+      const filePath = join(projectDir, file);
+      if (existsSync(filePath)) {
+        rmSync(filePath);
+        nextMigratedFiles.push(file);
+      }
     }
-  }
+    return nextMigratedFiles;
+  });
 
   let changelogUrl: string | undefined;
   const mainPkg = packages.find((p) => p.name === "everything-dev");
@@ -470,6 +705,7 @@ export async function upgradeTemplate(
     sync: syncResult,
     migrated: migratedFiles.length > 0 ? migratedFiles : undefined,
     selectedPlugins: addedPlugins.length > 0 ? addedPlugins : undefined,
+    timings,
     changelogUrl,
   };
 }

package/src/cli.ts

@@ -2,6 +2,7 @@
 import { findCommandDescriptor } from "./cli/catalog";
 import { printHelp } from "./cli/help";
 import { parseCommandInput } from "./cli/parse";
+import { formatDuration, sumPhaseDurations } from "./cli/timing";
 import { findConfigPath } from "./config";
 import bosPlugin from "./plugin";
 import { createPluginRuntime } from "./sdk";
@@ -50,6 +51,18 @@ function normalizeVersion(v: string): string {
   return v.replace(/^[\^~>=v]+/, "").trim();
 }
 
+function printTimingSummary(timings: Array<{ name: string; durationMs: number }> | undefined) {
+  if (!timings || timings.length === 0) return;
+
+  console.log(`  ${colors.dim("Timings:")}`);
+  for (const timing of timings) {
+    console.log(`    ${colors.dim(timing.name.padEnd(22))} ${formatDuration(timing.durationMs)}`);
+  }
+  console.log(
+    `    ${colors.dim("total".padEnd(22))} ${formatDuration(sumPhaseDurations(timings))}`,
+  );
+}
+
 async function warnIfOutdated(client: any, command: string): Promise<void> {
   if (!["dev", "build", "start"].includes(command)) return;
 
@@ -152,6 +165,7 @@ async function main() {
       if (result.plugins && result.plugins.length > 0)
         console.log(`  ${colors.dim("Plugins:")} ${result.plugins.join(", ")}`);
       console.log(`  ${colors.dim("Files copied:")} ${result.filesCopied}`);
+      printTimingSummary(result.timings);
       console.log();
       console.log(colors.dim("  Next steps:"));
       console.log(colors.dim(`    cd ${result.directory}`));
@@ -246,6 +260,7 @@ async function main() {
       if (result.selectedPlugins && result.selectedPlugins.length > 0) {
         console.log(`  ${colors.dim("Added plugins:")} ${result.selectedPlugins.join(", ")}`);
       }
+      printTimingSummary(result.timings);
       if (result.sync) {
         const sync = result.sync;
         if (sync.updated.length > 0) {