Function loadFormatter

packages/bumpy/src/core/changelog.ts:164–223

(changelog: BumpyConfig['changelog'], rootDir: string)

 * Supports: "default", "./path/to/formatter.ts", or a module name.
 */
export async function loadFormatter(changelog: BumpyConfig['changelog'], rootDir: string): Promise<ChangelogFormatter> {
  const [name, options] = Array.isArray(changelog) ? changelog : [changelog, {}];

  // Built-in with options (e.g., ["github", { repo: "..." }])
  if (name === 'github') {
    const { createGithubFormatter } = await import('./changelog-github.ts');
    return createGithubFormatter(options as import('./changelog-github.ts').GithubChangelogOptions);
  }

  // Built-in formatter (no options)
  if (typeof name === 'string' && BUILTIN_FORMATTERS[name]) {
    const builtin = BUILTIN_FORMATTERS[name];
    if (typeof builtin === 'function' && builtin.length === 0) {
      // Lazy-loaded formatter factory (like github)
      return (builtin as () => Promise<ChangelogFormatter>)();
    }
    return builtin as ChangelogFormatter;
  }

  // Custom module
  if (typeof name === 'string') {
    try {
      let modulePath: string;
      if (name.startsWith('.')) {
        // Relative path — resolve symlinks and verify it stays within the project root
        modulePath = resolve(rootDir, name);
        try {
          modulePath = realpathSync(modulePath);
        } catch {
          // File doesn't exist yet — use the resolved path as-is
        }
        const rel = relative(realpathSync(rootDir), modulePath);
        if (rel.startsWith('..') || resolve('/', rel) === resolve('/')) {
          throw new Error(`Changelog formatter path "${name}" resolves outside the project root`);
        }
      } else {
        // Bare module specifier (e.g. npm package name)
        modulePath = name;
      }
      const mod = await import(modulePath);
      // Support: export default fn, export const changelogFormatter = fn, or module is fn
      const exported = mod.default || mod.changelogFormatter;
      if (typeof exported === 'function') {
        // If it takes options, call it as a factory; otherwise use it directly
        // Heuristic: if the function returns a function, it's a factory
        const result = exported(options);
        if (typeof result === 'function') return result;
        // If it returned a string/promise, it IS the formatter
        return exported;
      }
      throw new Error(`Changelog module "${name}" does not export a function`);
    } catch (err) {
      log.warn(`Failed to load changelog formatter "${name}": ${err instanceof Error ? err.message : err}`);
      log.warn('Falling back to default formatter');
      return defaultFormatter;
    }
  }