@kubb/core 5.0.0-alpha.5 → 5.0.0-alpha.50

package/src/PluginManager.ts

@@ -1,667 +0,0 @@
-import { basename, extname, resolve } from 'node:path'
-import { performance } from 'node:perf_hooks'
-import type { AsyncEventEmitter } from '@internals/utils'
-import { setUniqueName, transformReservedWord } from '@internals/utils'
-import type { RootNode } from '@kubb/ast/types'
-import type { Fabric as FabricType, KubbFile } from '@kubb/fabric-core/types'
-import { CORE_PLUGIN_NAME, DEFAULT_STUDIO_URL } from './constants.ts'
-import { openInStudio as openInStudioFn } from './devtools.ts'
-import { ValidationPluginError } from './errors.ts'
-import { isPromiseRejectedResult, PromiseManager } from './PromiseManager.ts'
-import type {
-  Adapter,
-  Config,
-  DevtoolsOptions,
-  KubbEvents,
-  Plugin,
-  PluginContext,
-  PluginFactoryOptions,
-  PluginLifecycle,
-  PluginLifecycleHooks,
-  PluginParameter,
-  PluginWithLifeCycle,
-  ResolveNameParams,
-  ResolvePathParams,
-  UserPlugin,
-} from './types.ts'
-
-type RequiredPluginLifecycle = Required<PluginLifecycle>
-
-export type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq'
-
-type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H]
-
-type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
-  result: Result
-  plugin: Plugin
-}
-
-// inspired by: https://github.com/rollup/rollup/blob/master/src/utils/PluginDriver.ts#
-
-type Options = {
-  fabric: FabricType
-  events: AsyncEventEmitter<KubbEvents>
-  /**
-   * @default Number.POSITIVE_INFINITY
-   */
-  concurrency?: number
-}
-
-export type GetFileOptions<TOptions = object> = {
-  name: string
-  mode?: KubbFile.Mode
-  extname: KubbFile.Extname
-  pluginName: string
-  options?: TOptions
-}
-
-export function getMode(fileOrFolder: string | undefined | null): KubbFile.Mode {
-  if (!fileOrFolder) {
-    return 'split'
-  }
-  return extname(fileOrFolder) ? 'single' : 'split'
-}
-
-export class PluginManager {
-  readonly config: Config
-  readonly options: Options
-
-  /**
-   * The universal `@kubb/ast` `RootNode` produced by the adapter, set by
-   * the build pipeline after the adapter's `parse()` resolves.
-   */
-  rootNode: RootNode | undefined = undefined
-  adapter: Adapter | undefined = undefined
-  #studioIsOpen = false
-
-  readonly #plugins = new Set<Plugin>()
-  readonly #usedPluginNames: Record<string, number> = {}
-  readonly #promiseManager
-
-  constructor(config: Config, options: Options) {
-    this.config = config
-    this.options = options
-    this.#promiseManager = new PromiseManager({
-      nullCheck: (state: SafeParseResult<'resolveName'> | null) => !!state?.result,
-    })
-    ;[...(config.plugins || [])].forEach((plugin) => {
-      const parsedPlugin = this.#parse(plugin as UserPlugin)
-
-      this.#plugins.add(parsedPlugin)
-    })
-  }
-
-  get events() {
-    return this.options.events
-  }
-
-  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown> {
-    const plugins = [...this.#plugins]
-    const pluginManager = this
-
-    const baseContext = {
-      fabric: this.options.fabric,
-      config: this.config,
-      plugin,
-      events: this.options.events,
-      pluginManager: this,
-      mode: getMode(resolve(this.config.root, this.config.output.path)),
-      addFile: async (...files: Array<KubbFile.File>) => {
-        await this.options.fabric.addFile(...files)
-      },
-      upsertFile: async (...files: Array<KubbFile.File>) => {
-        await this.options.fabric.upsertFile(...files)
-      },
-      get rootNode(): RootNode | undefined {
-        return pluginManager.rootNode
-      },
-      get adapter(): Adapter | undefined {
-        return pluginManager.adapter
-      },
-      openInStudio(options?: DevtoolsOptions) {
-        if (!pluginManager.config.devtools || pluginManager.#studioIsOpen) {
-          return
-        }
-
-        if (typeof pluginManager.config.devtools !== 'object') {
-          throw new Error('Devtools must be an object')
-        }
-
-        if (!pluginManager.rootNode || !pluginManager.adapter) {
-          throw new Error('adapter is not defined, make sure you have set the parser in kubb.config.ts')
-        }
-
-        pluginManager.#studioIsOpen = true
-
-        const studioUrl = pluginManager.config.devtools?.studioUrl ?? DEFAULT_STUDIO_URL
-
-        return openInStudioFn(pluginManager.rootNode, studioUrl, options)
-      },
-    } as unknown as PluginContext<TOptions>
-
-    const mergedExtras: Record<string, unknown> = {}
-    for (const p of plugins) {
-      if (typeof p.inject === 'function') {
-        const result = (p.inject as (this: PluginContext, context: PluginContext) => unknown).call(
-          baseContext as unknown as PluginContext,
-          baseContext as unknown as PluginContext,
-        )
-        if (result !== null && typeof result === 'object') {
-          Object.assign(mergedExtras, result)
-        }
-      }
-    }
-
-    return {
-      ...baseContext,
-      ...mergedExtras,
-    }
-  }
-
-  get plugins(): Array<Plugin> {
-    return this.#getSortedPlugins()
-  }
-
-  getFile<TOptions = object>({ name, mode, extname, pluginName, options }: GetFileOptions<TOptions>): KubbFile.File<{ pluginName: string }> {
-    const resolvedName = mode ? (mode === 'single' ? '' : this.resolveName({ name, pluginName, type: 'file' })) : name
-
-    const path = this.resolvePath({
-      baseName: `${resolvedName}${extname}` as const,
-      mode,
-      pluginName,
-      options,
-    })
-
-    if (!path) {
-      throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`)
-    }
-
-    return {
-      path,
-      baseName: basename(path) as KubbFile.File['baseName'],
-      meta: {
-        pluginName,
-      },
-      sources: [],
-      imports: [],
-      exports: [],
-    }
-  }
-
-  resolvePath = <TOptions = object>(params: ResolvePathParams<TOptions>): KubbFile.Path => {
-    const root = resolve(this.config.root, this.config.output.path)
-    const defaultPath = resolve(root, params.baseName)
-
-    if (params.pluginName) {
-      const paths = this.hookForPluginSync({
-        pluginName: params.pluginName,
-        hookName: 'resolvePath',
-        parameters: [params.baseName, params.mode, params.options as object],
-      })
-
-      return paths?.at(0) || defaultPath
-    }
-
-    const firstResult = this.hookFirstSync({
-      hookName: 'resolvePath',
-      parameters: [params.baseName, params.mode, params.options as object],
-    })
-
-    return firstResult?.result || defaultPath
-  }
-  //TODO refactor by using the order of plugins and the cache of the fileManager instead of guessing and recreating the name/path
-  resolveName = (params: ResolveNameParams): string => {
-    if (params.pluginName) {
-      const names = this.hookForPluginSync({
-        pluginName: params.pluginName,
-        hookName: 'resolveName',
-        parameters: [params.name.trim(), params.type],
-      })
-
-      const uniqueNames = new Set(names)
-
-      return transformReservedWord([...uniqueNames].at(0) || params.name)
-    }
-
-    const name = this.hookFirstSync({
-      hookName: 'resolveName',
-      parameters: [params.name.trim(), params.type],
-    })?.result
-
-    return transformReservedWord(name ?? params.name)
-  }
-
-  /**
-   * Run a specific hookName for plugin x.
-   */
-  async hookForPlugin<H extends PluginLifecycleHooks>({
-    pluginName,
-    hookName,
-    parameters,
-  }: {
-    pluginName: string
-    hookName: H
-    parameters: PluginParameter<H>
-  }): Promise<Array<ReturnType<ParseResult<H>> | null>> {
-    const plugins = this.getPluginsByName(hookName, pluginName)
-
-    this.events.emit('plugins:hook:progress:start', {
-      hookName,
-      plugins,
-    })
-
-    const items: Array<ReturnType<ParseResult<H>>> = []
-
-    for (const plugin of plugins) {
-      const result = await this.#execute<H>({
-        strategy: 'hookFirst',
-        hookName,
-        parameters,
-        plugin,
-      })
-
-      if (result !== undefined && result !== null) {
-        items.push(result)
-      }
-    }
-
-    this.events.emit('plugins:hook:progress:end', { hookName })
-
-    return items
-  }
-  /**
-   * Run a specific hookName for plugin x.
-   */
-
-  hookForPluginSync<H extends PluginLifecycleHooks>({
-    pluginName,
-    hookName,
-    parameters,
-  }: {
-    pluginName: string
-    hookName: H
-    parameters: PluginParameter<H>
-  }): Array<ReturnType<ParseResult<H>>> | null {
-    const plugins = this.getPluginsByName(hookName, pluginName)
-
-    const result = plugins
-      .map((plugin) => {
-        return this.#executeSync<H>({
-          strategy: 'hookFirst',
-          hookName,
-          parameters,
-          plugin,
-        })
-      })
-      .filter((x): x is NonNullable<typeof x> => x !== null)
-
-    return result
-  }
-
-  /**
-   * Returns the first non-null result.
-   */
-  async hookFirst<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    skipped,
-  }: {
-    hookName: H
-    parameters: PluginParameter<H>
-    skipped?: ReadonlySet<Plugin> | null
-  }): Promise<SafeParseResult<H>> {
-    const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-      return skipped ? !skipped.has(plugin) : true
-    })
-
-    this.events.emit('plugins:hook:progress:start', { hookName, plugins })
-
-    const promises = plugins.map((plugin) => {
-      return async () => {
-        const value = await this.#execute<H>({
-          strategy: 'hookFirst',
-          hookName,
-          parameters,
-          plugin,
-        })
-
-        return Promise.resolve({
-          plugin,
-          result: value,
-        } as SafeParseResult<H>)
-      }
-    })
-
-    const result = await this.#promiseManager.run('first', promises)
-
-    this.events.emit('plugins:hook:progress:end', { hookName })
-
-    return result
-  }
-
-  /**
-   * Returns the first non-null result.
-   */
-  hookFirstSync<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    skipped,
-  }: {
-    hookName: H
-    parameters: PluginParameter<H>
-    skipped?: ReadonlySet<Plugin> | null
-  }): SafeParseResult<H> | null {
-    let parseResult: SafeParseResult<H> | null = null
-    const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-      return skipped ? !skipped.has(plugin) : true
-    })
-
-    for (const plugin of plugins) {
-      parseResult = {
-        result: this.#executeSync<H>({
-          strategy: 'hookFirst',
-          hookName,
-          parameters,
-          plugin,
-        }),
-        plugin,
-      } as SafeParseResult<H>
-
-      if (parseResult?.result != null) {
-        break
-      }
-    }
-
-    return parseResult
-  }
-
-  /**
-   * Runs all plugins in parallel based on `this.plugin` order and `pre`/`post` settings.
-   */
-  async hookParallel<H extends PluginLifecycleHooks, TOutput = void>({
-    hookName,
-    parameters,
-  }: {
-    hookName: H
-    parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined
-  }): Promise<Awaited<TOutput>[]> {
-    const plugins = this.#getSortedPlugins(hookName)
-    this.events.emit('plugins:hook:progress:start', { hookName, plugins })
-
-    const pluginStartTimes = new Map<Plugin, number>()
-
-    const promises = plugins.map((plugin) => {
-      return () => {
-        pluginStartTimes.set(plugin, performance.now())
-        return this.#execute({
-          strategy: 'hookParallel',
-          hookName,
-          parameters,
-          plugin,
-        }) as Promise<TOutput>
-      }
-    })
-
-    const results = await this.#promiseManager.run('parallel', promises, {
-      concurrency: this.options.concurrency,
-    })
-
-    results.forEach((result, index) => {
-      if (isPromiseRejectedResult<Error>(result)) {
-        const plugin = this.#getSortedPlugins(hookName)[index]
-
-        if (plugin) {
-          const startTime = pluginStartTimes.get(plugin) ?? performance.now()
-          this.events.emit('error', result.reason, {
-            plugin,
-            hookName,
-            strategy: 'hookParallel',
-            duration: Math.round(performance.now() - startTime),
-            parameters,
-          })
-        }
-      }
-    })
-
-    this.events.emit('plugins:hook:progress:end', { hookName })
-
-    return results.reduce((acc, result) => {
-      if (result.status === 'fulfilled') {
-        acc.push(result.value)
-      }
-      return acc
-    }, [] as Awaited<TOutput>[])
-  }
-
-  /**
-   * Chains plugins
-   */
-  async hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: { hookName: H; parameters?: PluginParameter<H> }): Promise<void> {
-    const plugins = this.#getSortedPlugins(hookName)
-    this.events.emit('plugins:hook:progress:start', { hookName, plugins })
-
-    const promises = plugins.map((plugin) => {
-      return () =>
-        this.#execute({
-          strategy: 'hookSeq',
-          hookName,
-          parameters,
-          plugin,
-        })
-    })
-
-    await this.#promiseManager.run('seq', promises)
-
-    this.events.emit('plugins:hook:progress:end', { hookName })
-  }
-
-  #getSortedPlugins(hookName?: keyof PluginLifecycle): Array<Plugin> {
-    const plugins = [...this.#plugins]
-
-    if (hookName) {
-      return plugins.filter((plugin) => hookName in plugin)
-    }
-    // TODO add test case for sorting with pre/post
-
-    return plugins
-      .map((plugin) => {
-        if (plugin.pre) {
-          let missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName))
-
-          // when adapter is set, we can ignore the depends on plugin-oas, in v5 this will not be needed anymore
-          if (missingPlugins.includes('plugin-oas') && this.adapter) {
-            missingPlugins = missingPlugins.filter((pluginName) => pluginName !== 'plugin-oas')
-          }
-
-          if (missingPlugins.length > 0) {
-            throw new ValidationPluginError(`The plugin '${plugin.name}' has a pre set that references missing plugins for '${missingPlugins.join(', ')}'`)
-          }
-        }
-
-        return plugin
-      })
-      .sort((a, b) => {
-        if (b.pre?.includes(a.name)) {
-          return 1
-        }
-        if (b.post?.includes(a.name)) {
-          return -1
-        }
-        return 0
-      })
-  }
-
-  getPluginByName(pluginName: string): Plugin | undefined {
-    const plugins = [...this.#plugins]
-
-    return plugins.find((item) => item.name === pluginName)
-  }
-
-  getPluginsByName(hookName: keyof PluginWithLifeCycle, pluginName: string): Plugin[] {
-    const plugins = [...this.plugins]
-
-    const pluginByPluginName = plugins.filter((plugin) => hookName in plugin).filter((item) => item.name === pluginName)
-
-    if (!pluginByPluginName?.length) {
-      // fallback on the core plugin when there is no match
-
-      const corePlugin = plugins.find((plugin) => plugin.name === CORE_PLUGIN_NAME && hookName in plugin)
-
-      return corePlugin ? [corePlugin] : []
-    }
-
-    return pluginByPluginName
-  }
-
-  /**
-   * Run an async plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The actual pluginObject to run.
-   */
-  #emitProcessingEnd<H extends PluginLifecycleHooks>({
-    startTime,
-    output,
-    strategy,
-    hookName,
-    plugin,
-    parameters,
-  }: {
-    startTime: number
-    output: unknown
-    strategy: Strategy
-    hookName: H
-    plugin: PluginWithLifeCycle
-    parameters: unknown[] | undefined
-  }): void {
-    this.events.emit('plugins:hook:processing:end', {
-      duration: Math.round(performance.now() - startTime),
-      parameters,
-      output,
-      strategy,
-      hookName,
-      plugin,
-    })
-  }
-
-  // Implementation signature
-  #execute<H extends PluginLifecycleHooks>({
-    strategy,
-    hookName,
-    parameters,
-    plugin,
-  }: {
-    strategy: Strategy
-    hookName: H
-    parameters: unknown[] | undefined
-    plugin: PluginWithLifeCycle
-  }): Promise<ReturnType<ParseResult<H>> | null> | null {
-    const hook = plugin[hookName]
-
-    if (!hook) {
-      return null
-    }
-
-    this.events.emit('plugins:hook:processing:start', {
-      strategy,
-      hookName,
-      parameters,
-      plugin,
-    })
-
-    const startTime = performance.now()
-
-    const task = (async () => {
-      try {
-        const output =
-          typeof hook === 'function' ? await Promise.resolve((hook as (...args: unknown[]) => unknown).apply(this.getContext(plugin), parameters ?? [])) : hook
-
-        this.#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters })
-
-        return output as ReturnType<ParseResult<H>>
-      } catch (error) {
-        this.events.emit('error', error as Error, {
-          plugin,
-          hookName,
-          strategy,
-          duration: Math.round(performance.now() - startTime),
-        })
-
-        return null
-      }
-    })()
-
-    return task
-  }
-
-  /**
-   * Run a sync plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The actual plugin
-   */
-  #executeSync<H extends PluginLifecycleHooks>({
-    strategy,
-    hookName,
-    parameters,
-    plugin,
-  }: {
-    strategy: Strategy
-    hookName: H
-    parameters: PluginParameter<H>
-    plugin: PluginWithLifeCycle
-  }): ReturnType<ParseResult<H>> | null {
-    const hook = plugin[hookName]
-
-    if (!hook) {
-      return null
-    }
-
-    this.events.emit('plugins:hook:processing:start', {
-      strategy,
-      hookName,
-      parameters,
-      plugin,
-    })
-
-    const startTime = performance.now()
-
-    try {
-      const output =
-        typeof hook === 'function'
-          ? ((hook as (...args: unknown[]) => unknown).apply(this.getContext(plugin), parameters) as ReturnType<ParseResult<H>>)
-          : (hook as ReturnType<ParseResult<H>>)
-
-      this.#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters })
-
-      return output
-    } catch (error) {
-      this.events.emit('error', error as Error, {
-        plugin,
-        hookName,
-        strategy,
-        duration: Math.round(performance.now() - startTime),
-      })
-
-      return null
-    }
-  }
-
-  #parse(plugin: UserPlugin): Plugin {
-    const usedPluginNames = this.#usedPluginNames
-
-    setUniqueName(plugin.name, usedPluginNames)
-
-    const usageCount = usedPluginNames[plugin.name]
-    if (usageCount && usageCount > 1) {
-      throw new ValidationPluginError(
-        `Duplicate plugin "${plugin.name}" detected. Each plugin can only be used once. Use a different configuration instead of adding multiple instances of the same plugin.`,
-      )
-    }
-
-    return {
-      install() {},
-      ...plugin,
-    } as unknown as Plugin
-  }
-}

package/src/PromiseManager.ts

@@ -1,40 +0,0 @@
-import type { Strategy, StrategySwitch } from './utils/executeStrategies.ts'
-import { hookFirst, hookParallel, hookSeq } from './utils/executeStrategies.ts'
-
-type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2
-
-type Options<TState = unknown> = {
-  nullCheck?: (state: TState) => boolean
-}
-
-export class PromiseManager<TState = unknown> {
-  #options: Options<TState> = {}
-
-  constructor(options: Options<TState> = {}) {
-    this.#options = options
-  }
-
-  run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(
-    strategy: TStrategy,
-    promises: TInput,
-    { concurrency = Number.POSITIVE_INFINITY }: { concurrency?: number } = {},
-  ): TOutput {
-    if (strategy === 'seq') {
-      return hookSeq<TInput, TValue, TOutput>(promises)
-    }
-
-    if (strategy === 'first') {
-      return hookFirst<TInput, TValue, TOutput>(promises, this.#options.nullCheck as ((state: unknown) => boolean) | undefined)
-    }
-
-    if (strategy === 'parallel') {
-      return hookParallel<TInput, TValue, TOutput>(promises, concurrency)
-    }
-
-    throw new Error(`${strategy} not implemented`)
-  }
-}
-
-export function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {
-  return result.status === 'rejected'
-}