everything-dev 1.16.3 → 1.19.0

package/src/cli/upgrade.ts

@@ -70,6 +70,314 @@ 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") {
+    return false;
+  }
+
+  const plugins = config.plugins as Record<string, unknown>;
+  const entry = plugins[pluginKey];
+  if (!entry || typeof entry !== "object") return false;
+
+  const pluginEntry = entry as Record<string, unknown>;
+
+  if ("name" in pluginEntry) {
+    delete pluginEntry.name;
+    changed = true;
+  }
+
+  if (typeof pluginEntry.development === "string" && pluginEntry.development.startsWith("local:")) {
+    if ("extends" in pluginEntry) {
+      delete pluginEntry.extends;
+      changed = true;
+    }
+  }
+
+  changed = rewriteExtendsTarget(pluginEntry, `plugins.${pluginKey}`) || changed;
+
+  return changed;
+}
+
+function mergePluginConfigIntoRoot(
+  rootConfig: Record<string, unknown>,
+  pluginKey: string,
+  pluginConfig: Record<string, unknown>,
+): boolean {
+  let changed = false;
+
+  if (!rootConfig.plugins || typeof rootConfig.plugins !== "object") {
+    rootConfig.plugins = {};
+    changed = true;
+  }
+  const plugins = rootConfig.plugins as Record<string, unknown>;
+  if (!plugins[pluginKey] || typeof plugins[pluginKey] !== "object") {
+    plugins[pluginKey] = {};
+    changed = true;
+  }
+
+  const entry = plugins[pluginKey] as Record<string, unknown>;
+
+  const pluginData = extractPluginEntry(pluginConfig, pluginKey);
+
+  const apiData = getApiEntry(pluginConfig);
+
+  if (pluginData) {
+    for (const key of [
+      "secrets",
+      "variables",
+      "routes",
+      "sidebar",
+      "production",
+      "integrity",
+      "proxy",
+    ] as const) {
+      if (pluginData[key] !== undefined && entry[key] === undefined) {
+        entry[key] = pluginData[key];
+        changed = true;
+      }
+    }
+
+    if (typeof pluginData.development === "string" && pluginData.development.startsWith("local:")) {
+      pluginData.development = `local:plugins/${pluginKey}`;
+    }
+    if (entry.development === undefined && pluginData.development !== undefined) {
+      entry.development = pluginData.development;
+      changed = true;
+    }
+  }
+
+  if (apiData) {
+    for (const key of [
+      "production",
+      "integrity",
+      "proxy",
+      "variables",
+      "secrets",
+      "sidebar",
+      "routes",
+    ] as const) {
+      if (apiData[key] !== undefined && entry[key] === undefined) {
+        entry[key] = apiData[key];
+        changed = true;
+      }
+    }
+  }
+
+  if ("extends" in entry) {
+    const extendsStr = typeof entry.extends === "string" ? entry.extends : undefined;
+    if (!extendsStr || extendsStr.includes(`#plugins.${pluginKey}`)) {
+      delete entry.extends;
+      changed = true;
+    }
+  }
+
+  if ("name" in entry) {
+    delete entry.name;
+    changed = true;
+  }
+
+  if (configHasTopLevelFields(pluginConfig, pluginKey)) {
+    if (entry.routes === undefined && Array.isArray(pluginConfig.routes)) {
+      entry.routes = pluginConfig.routes;
+      changed = true;
+    }
+    if (entry.sidebar === undefined && Array.isArray(pluginConfig.sidebar)) {
+      entry.sidebar = pluginConfig.sidebar;
+      changed = true;
+    }
+    const api = getApiEntry(pluginConfig);
+    if (api) {
+      if (entry.routes === undefined && Array.isArray(api.routes)) {
+        entry.routes = api.routes;
+        changed = true;
+      }
+      if (entry.sidebar === undefined && Array.isArray(api.sidebar)) {
+        entry.sidebar = api.sidebar;
+        changed = true;
+      }
+    }
+  }
+
+  return changed;
+}
+
+function extractPluginEntry(
+  pluginConfig: Record<string, unknown>,
+  pluginKey: string,
+): Record<string, unknown> | null {
+  if (
+    pluginConfig.plugins &&
+    typeof pluginConfig.plugins === "object" &&
+    (pluginConfig.plugins as Record<string, unknown>)[pluginKey] &&
+    typeof (pluginConfig.plugins as Record<string, unknown>)[pluginKey] === "object"
+  ) {
+    return (pluginConfig.plugins as Record<string, unknown>)[pluginKey] as Record<string, unknown>;
+  }
+
+  const fallback: Record<string, unknown> = {};
+  if (pluginConfig.sidebar !== undefined) {
+    fallback.sidebar = pluginConfig.sidebar;
+  }
+  if (pluginConfig.routes !== undefined) {
+    fallback.routes = pluginConfig.routes;
+  }
+  if (Object.keys(fallback).length > 0) {
+    return fallback;
+  }
+
+  return null;
+}
+
+function configHasTopLevelFields(
+  pluginConfig: Record<string, unknown>,
+  _pluginKey: string,
+): boolean {
+  return (
+    (pluginConfig.routes !== undefined && Array.isArray(pluginConfig.routes)) ||
+    (pluginConfig.sidebar !== undefined && Array.isArray(pluginConfig.sidebar)) ||
+    getApiEntry(pluginConfig) !== null
+  );
+}
+
+function getApiEntry(pluginConfig: Record<string, unknown>): Record<string, unknown> | null {
+  if (!pluginConfig.app || typeof pluginConfig.app !== "object") return null;
+  const app = pluginConfig.app as Record<string, unknown>;
+  if (!app.api || typeof app.api !== "object") return null;
+  return app.api as Record<string, unknown>;
+}
+
+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>;
+    let rootChanged = migrateRootConfigTargets(rootConfig);
+
+    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);
+      try {
+        const pluginConfig = JSON.parse(readFileSync(filePath, "utf-8")) as Record<string, unknown>;
+        rootChanged = mergePluginConfigIntoRoot(rootConfig, pluginKey, pluginConfig) || rootChanged;
+      } catch {}
+
+      try {
+        rmSync(filePath);
+        migrated.push(relativePath);
+      } catch {}
+    }
+
+    if (rootConfig.plugins && typeof rootConfig.plugins === "object") {
+      for (const pluginKey of Object.keys(rootConfig.plugins as Record<string, unknown>)) {
+        rootChanged = migratePluginProviderConfig(rootConfig, pluginKey) || rootChanged;
+      }
+    }
+
+    if (rootChanged || migrated.length > 0) {
+      await saveBosConfig(projectDir, rootConfig);
+      if (!migrated.includes("bos.config.json")) {
+        migrated.push("bos.config.json");
+      }
+    }
+  }
+
+  return migrated;
+}
+
 async function loadParentPluginOptions(projectDir: string): Promise<{
   localConfig: Record<string, unknown>;
   parentPlugins: Record<string, unknown>;
@@ -142,7 +450,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;
@@ -442,6 +759,10 @@ export async function upgradeTemplate(
     }
   });
 
+  const migratedBosConfigs = await timePhase(timings, "migrate bos configs", () =>
+    migrateBosConfigFiles(projectDir),
+  );
+
   let syncResult: UpgradeResult["sync"];
   let addedPlugins: string[] = [];
   if (!options.noSync) {
@@ -465,7 +786,10 @@ export async function upgradeTemplate(
   }
 
   const migratedFiles = await timePhase(timings, "clean obsolete files", async () => {
-    const nextMigratedFiles = await rewriteLegacyUiImports(projectDir);
+    const nextMigratedFiles = [
+      ...migratedBosConfigs,
+      ...(await rewriteLegacyUiImports(projectDir)),
+    ];
     for (const file of OBSOLETE_FILES) {
       const filePath = join(projectDir, file);
       if (existsSync(filePath)) {