@kubb/core 2.0.0-alpha.3 → 2.0.0-alpha.4

package/src/FileManager.ts

@@ -0,0 +1,482 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import crypto from 'node:crypto'
+import { extname } from 'node:path'
+
+import { print } from '@kubb/parser'
+import * as factory from '@kubb/parser/factory'
+
+import isEqual from 'lodash.isequal'
+import { orderBy } from 'natural-orderby'
+
+import { read } from './utils/read.ts'
+import { timeout } from './utils/timeout.ts'
+import { transformers } from './utils/transformers/index.ts'
+import { write } from './utils/write.ts'
+import { BarrelManager } from './BarrelManager.ts'
+
+import type { BarrelManagerOptions } from './BarrelManager.ts'
+import type { GreaterThan, KubbPlugin } from './types.ts'
+import type { Queue, QueueJob } from './utils/Queue.ts'
+
+type BasePath<T extends string = string> = `${T}/`
+
+export namespace KubbFile {
+  export type Import = {
+    name: string | Array<string>
+    path: string
+    isTypeOnly?: boolean
+  }
+
+  export type Export = {
+    name?: string | Array<string>
+    path: string
+    isTypeOnly?: boolean
+    asAlias?: boolean
+  }
+
+  export declare const dataTagSymbol: unique symbol
+  export type DataTag<Type, Value> = Type & {
+    [dataTagSymbol]: Value
+  }
+
+  export type UUID = string
+  export type Source = string
+
+  export type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`
+
+  export type Mode = 'file' | 'directory'
+
+  export type BaseName = `${string}${Extname}`
+
+  export type Path = string
+
+  export type AdvancedPath<T extends BaseName = BaseName> = `${BasePath}${T}`
+
+  export type OptionalPath = Path | undefined | null
+
+  export type FileMetaBase = {
+    pluginKey?: KubbPlugin['key']
+  }
+
+  export type File<
+    TMeta extends FileMetaBase = FileMetaBase,
+    TBaseName extends BaseName = BaseName,
+  > = {
+    /**
+     * Unique identifier to reuse later
+     * @default crypto.randomUUID()
+     */
+    id?: string
+    /**
+     * Name to be used to dynamicly create the baseName(based on input.path)
+     * Based on UNIX basename
+     * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+     */
+    baseName: TBaseName
+    /**
+     * Path will be full qualified path to a specified file
+     */
+    path: AdvancedPath<TBaseName> | Path
+    source: Source
+    imports?: Import[]
+    exports?: Export[]
+    /**
+     * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
+     * This will also ignore the combinefiles utils
+     * @default `false`
+     */
+    override?: boolean
+    meta?: TMeta
+    /**
+     * This will override `process.env[key]` inside the `source`, see `getFileSource`.
+     */
+    env?: NodeJS.ProcessEnv
+    validate?: boolean
+  }
+
+  export type ResolvedFile<
+    TMeta extends FileMetaBase = FileMetaBase,
+    TBaseName extends BaseName = BaseName,
+  > = KubbFile.File<TMeta, TBaseName> & {
+    /**
+     * @default crypto.randomUUID()
+     */
+    id: UUID
+  }
+}
+
+type CacheItem = KubbFile.ResolvedFile & {
+  cancel?: () => void
+}
+
+type AddResult<T extends Array<KubbFile.File>> = Promise<
+  Awaited<GreaterThan<T['length'], 1> extends true ? Promise<KubbFile.ResolvedFile[]> : Promise<KubbFile.ResolvedFile>>
+>
+
+type AddIndexesProps = {
+  root: KubbFile.Path
+  extName?: KubbFile.Extname
+  options?: BarrelManagerOptions
+  meta?: KubbFile.File['meta']
+}
+
+type Options = {
+  queue?: Queue
+  task?: QueueJob<KubbFile.ResolvedFile>
+  /**
+   * Timeout between writes
+   */
+  timeout?: number
+}
+
+export class FileManager {
+  #cache: Map<KubbFile.Path, CacheItem[]> = new Map()
+
+  #task?: QueueJob<KubbFile.ResolvedFile>
+  #isWriting = false
+  /**
+   * Timeout between writes
+   */
+  #timeout: number = 0
+  #queue?: Queue
+
+  constructor(options?: Options) {
+    if (options) {
+      this.#task = options.task
+      this.#queue = options.queue
+      this.#timeout = options.timeout || 0
+    }
+
+    return this
+  }
+
+  get files(): Array<KubbFile.File> {
+    const files: Array<KubbFile.File> = []
+    this.#cache.forEach((item) => {
+      files.push(...item.flat(1))
+    })
+
+    return files
+  }
+  get isExecuting(): boolean {
+    return this.#queue?.hasJobs ?? this.#isWriting ?? false
+  }
+
+  #validate(file: KubbFile.File): void {
+    if (!file.validate) {
+      return
+    }
+
+    if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
+      throw new Error(`${file.path} should end with the baseName ${file.baseName}`)
+    }
+  }
+
+  async add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(
+    ...files: T
+  ): AddResult<T> {
+    const promises = files.map((file) => {
+      this.#validate(file)
+
+      if (file.override) {
+        return this.#add(file)
+      }
+
+      return this.#addOrAppend(file)
+    })
+
+    const resolvedFiles = await Promise.all(promises)
+
+    if (files.length > 1) {
+      return resolvedFiles as unknown as AddResult<T>
+    }
+
+    return resolvedFiles[0] as unknown as AddResult<T>
+  }
+
+  async #add(file: KubbFile.File): Promise<KubbFile.ResolvedFile> {
+    const controller = new AbortController()
+    const resolvedFile: KubbFile.ResolvedFile = { id: crypto.randomUUID(), ...file }
+
+    this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }])
+
+    if (this.#queue) {
+      await this.#queue.run(
+        async () => {
+          return this.#task?.(resolvedFile)
+        },
+        { controller },
+      )
+    }
+
+    return resolvedFile
+  }
+
+  async #addOrAppend(file: KubbFile.File): Promise<KubbFile.ResolvedFile> {
+    const previousCaches = this.#cache.get(file.path)
+    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : undefined
+
+    if (previousCache) {
+      this.#cache.delete(previousCache.path)
+
+      return this.#add({
+        ...file,
+        source: previousCache.source && file.source ? `${previousCache.source}\n${file.source}` : '',
+        imports: [...(previousCache.imports || []), ...(file.imports || [])],
+        exports: [...(previousCache.exports || []), ...(file.exports || [])],
+        env: { ...(previousCache.env || {}), ...(file.env || {}) },
+      })
+    }
+    return this.#add(file)
+  }
+
+  async addIndexes({ root, extName = '.ts', meta, options = {} }: AddIndexesProps): Promise<Array<KubbFile.File> | undefined> {
+    const barrelManager = new BarrelManager(options)
+
+    const files = barrelManager.getIndexes(root, extName)
+
+    if (!files) {
+      return undefined
+    }
+
+    return await Promise.all(
+      files.map((file) => {
+        return this.#addOrAppend({
+          ...file,
+          meta: meta ? meta : file.meta,
+        })
+      }),
+    )
+  }
+
+  getCacheByUUID(UUID: KubbFile.UUID): KubbFile.File | undefined {
+    let cache: KubbFile.File | undefined
+
+    this.#cache.forEach((files) => {
+      cache = files.find((item) => item.id === UUID)
+    })
+    return cache
+  }
+
+  get(path: KubbFile.Path): Array<KubbFile.File> | undefined {
+    return this.#cache.get(path)
+  }
+
+  remove(path: KubbFile.Path): void {
+    const cacheItem = this.get(path)
+    if (!cacheItem) {
+      return
+    }
+
+    this.#cache.delete(path)
+  }
+
+  async write(...params: Parameters<typeof write>): Promise<string | undefined> {
+    if (!this.#isWriting) {
+      this.#isWriting = true
+
+      const text = await write(...params)
+
+      this.#isWriting = false
+      return text
+    }
+
+    await timeout(this.#timeout)
+
+    return this.write(...params)
+  }
+
+  async read(...params: Parameters<typeof read>): Promise<string> {
+    return read(...params)
+  }
+
+  // statics
+
+  static getSource<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(file: KubbFile.File<TMeta>): string {
+    if (!FileManager.isExtensionAllowed(file.baseName)) {
+      return file.source
+    }
+
+    const exports = file.exports ? combineExports(file.exports) : []
+    const imports = file.imports ? combineImports(file.imports, exports, file.source) : []
+
+    const importNodes = imports.map((item) => factory.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }))
+    const exportNodes = exports.map((item) =>
+      factory.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
+    )
+
+    return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join('\n')
+  }
+  static combineFiles<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(files: Array<KubbFile.File<TMeta> | null>): Array<KubbFile.File<TMeta>> {
+    return files.filter(Boolean).reduce((acc, file: KubbFile.File<TMeta>) => {
+      const prevIndex = acc.findIndex((item) => item.path === file.path)
+
+      if (prevIndex === -1) {
+        return [...acc, file]
+      }
+
+      const prev = acc[prevIndex]
+
+      if (prev && file.override) {
+        acc[prevIndex] = {
+          imports: [],
+          exports: [],
+          ...file,
+        }
+        return acc
+      }
+
+      if (prev) {
+        acc[prevIndex] = {
+          ...file,
+          source: prev.source && file.source ? `${prev.source}\n${file.source}` : '',
+          imports: [...(prev.imports || []), ...(file.imports || [])],
+          exports: [...(prev.exports || []), ...(file.exports || [])],
+          env: { ...(prev.env || {}), ...(file.env || {}) },
+        }
+      }
+
+      return acc
+    }, [] as Array<KubbFile.File<TMeta>>)
+  }
+  static getMode(path: string | undefined | null): KubbFile.Mode {
+    if (!path) {
+      return 'directory'
+    }
+    return extname(path) ? 'file' : 'directory'
+  }
+
+  static get extensions(): Array<KubbFile.Extname> {
+    return ['.js', '.ts', '.tsx']
+  }
+
+  static isExtensionAllowed(baseName: string): boolean {
+    return FileManager.extensions.some((extension) => baseName.endsWith(extension))
+  }
+}
+
+export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
+  const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ['asc']).reduce((prev, curr) => {
+    const name = curr.name
+    const prevByPath = prev.findLast((imp) => imp.path === curr.path)
+    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly)
+
+    if (prevByPathAndIsTypeOnly) {
+      // we already have an export that has the same path but uses `isTypeOnly` (export type ...)
+      return prev
+    }
+
+    const uniquePrev = prev.findLast(
+      (imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
+    )
+
+    if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
+      return prev
+    }
+
+    if (!prevByPath) {
+      return [
+        ...prev,
+        {
+          ...curr,
+          name: Array.isArray(name) ? [...new Set(name)] : name,
+        },
+      ]
+    }
+
+    if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+      prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
+
+      return prev
+    }
+
+    return [...prev, curr]
+  }, [] as Array<KubbFile.Export>)
+
+  return orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ['desc', 'desc'])
+}
+
+export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
+  const combinedImports = orderBy(imports, [(v) => !v.isTypeOnly], ['asc']).reduce((prev, curr) => {
+    let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+
+    const hasImportInSource = (importName: string) => {
+      if (!source) {
+        return true
+      }
+
+      const checker = (name?: string) => name && !!source.includes(name)
+      return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
+    }
+
+    if (Array.isArray(name)) {
+      name = name.filter((item) => hasImportInSource(item))
+    }
+
+    const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)
+    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly)
+    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly)
+
+    if (prevByPathNameAndIsTypeOnly) {
+      // we already have an export that has the same path but uses `isTypeOnly` (import type ...)
+      return prev
+    }
+
+    if (uniquePrev || (Array.isArray(name) && !name.length)) {
+      return prev
+    }
+
+    if (!prevByPath) {
+      return [
+        ...prev,
+        {
+          ...curr,
+          name,
+        },
+      ]
+    }
+
+    if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+      prevByPath.name = [...new Set([...prevByPath.name, ...name])]
+
+      return prev
+    }
+
+    if (!Array.isArray(name) && name && !hasImportInSource(name)) {
+      return prev
+    }
+
+    return [...prev, curr]
+  }, [] as Array<KubbFile.Import>)
+
+  return orderBy(combinedImports, [(v) => !v.isTypeOnly], ['desc'])
+}
+
+function getEnvSource(source: string, env: NodeJS.ProcessEnv | undefined): string {
+  if (!env) {
+    return source
+  }
+
+  const keys = Object.keys(env)
+
+  if (!keys.length) {
+    return source
+  }
+
+  return keys.reduce((prev, key: string) => {
+    const environmentValue = env[key]
+    const replaceBy = environmentValue ? `'${environmentValue.replaceAll('"', '')?.replaceAll("'", '')}'` : 'undefined'
+
+    if (key.toUpperCase() !== key) {
+      throw new TypeError(`Environment should be in upperCase for ${key}`)
+    }
+
+    if (typeof replaceBy === 'string') {
+      prev = transformers.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: 'process.env', key })
+      // removes `declare const ...`
+      prev = transformers.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*\n`, 'ig'), ''), replaceBy, key })
+    }
+
+    return prev
+  }, source)
+}

package/src/Generator.ts

@@ -0,0 +1,34 @@
+/**
+ * Abstract class that contains the building blocks for plugins to create their own Generator
+ * @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
+ */
+export abstract class Generator<TOptions = unknown, TContext = unknown> {
+  #options: TOptions = {} as TOptions
+  #context: TContext = {} as TContext
+
+  constructor(options?: TOptions, context?: TContext) {
+    if (context) {
+      this.#context = context
+    }
+
+    if (options) {
+      this.#options = options
+    }
+
+    return this
+  }
+
+  get options(): TOptions {
+    return this.#options
+  }
+
+  get context(): TContext {
+    return this.#context
+  }
+
+  set options(options: TOptions) {
+    this.#options = { ...this.#options, ...options }
+  }
+
+  abstract build(...params: unknown[]): unknown
+}

package/src/PackageManager.ts

@@ -0,0 +1,163 @@
+import mod from 'node:module'
+import os from 'node:os'
+import { pathToFileURL } from 'node:url'
+
+import { findUp, findUpSync } from 'find-up'
+import { coerce, satisfies } from 'semver'
+
+type PackageJSON = {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+type DependencyName = string
+
+type DependencyVersion = string
+
+export class PackageManager {
+  static #cache: Record<DependencyName, DependencyVersion> = {}
+
+  #cwd?: string
+  #SLASHES = new Set(['/', '\\'])
+  constructor(workspace?: string) {
+    if (workspace) {
+      this.#cwd = workspace
+    }
+
+    return this
+  }
+
+  set workspace(workspace: string) {
+    this.#cwd = workspace
+  }
+
+  get workspace(): string | undefined {
+    return this.#cwd
+  }
+
+  normalizeDirectory(directory: string): string {
+    if (!this.#SLASHES.has(directory[directory.length - 1]!)) {
+      return `${directory}/`
+    }
+
+    return directory
+  }
+
+  getLocation(path: string): string {
+    let location = path
+
+    if (this.#cwd) {
+      const require = mod.createRequire(this.normalizeDirectory(this.#cwd))
+      location = require.resolve(path)
+    }
+
+    return location
+  }
+
+  async import(path: string): Promise<any | undefined> {
+    try {
+      let location = this.getLocation(path)
+
+      if (os.platform() == 'win32') {
+        location = pathToFileURL(location).href
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const module = await import(location)
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
+      return module?.default ?? module
+    } catch (e) {
+      console.log(e)
+      return undefined
+    }
+  }
+
+  async getPackageJSON(): Promise<PackageJSON | undefined> {
+    const pkgPath = await findUp(['package.json'], {
+      cwd: this.#cwd,
+    })
+    if (!pkgPath) {
+      return undefined
+    }
+
+    return require(pkgPath) as PackageJSON
+  }
+
+  getPackageJSONSync(): PackageJSON | undefined {
+    const pkgPath = findUpSync(['package.json'], {
+      cwd: this.#cwd,
+    })
+    if (!pkgPath) {
+      return undefined
+    }
+
+    return require(pkgPath) as PackageJSON
+  }
+
+  static setVersion(dependency: DependencyName, version: DependencyVersion): void {
+    PackageManager.#cache[dependency] = version
+  }
+
+  async getVersion(dependency: DependencyName): Promise<DependencyVersion | undefined> {
+    if (PackageManager.#cache[dependency]) {
+      return PackageManager.#cache[dependency]
+    }
+
+    const packageJSON = await this.getPackageJSON()
+
+    if (!packageJSON) {
+      return undefined
+    }
+
+    return packageJSON['dependencies']?.[dependency] || packageJSON['devDependencies']?.[dependency]
+  }
+
+  getVersionSync(dependency: DependencyName): DependencyVersion | undefined {
+    if (PackageManager.#cache[dependency]) {
+      return PackageManager.#cache[dependency]
+    }
+
+    const packageJSON = this.getPackageJSONSync()
+
+    if (!packageJSON) {
+      return undefined
+    }
+
+    return packageJSON['dependencies']?.[dependency] || packageJSON['devDependencies']?.[dependency]
+  }
+
+  async isValid(dependency: DependencyName, version: DependencyVersion): Promise<boolean> {
+    const packageVersion = await this.getVersion(dependency)
+
+    if (!packageVersion) {
+      return false
+    }
+
+    if (packageVersion === version) {
+      return true
+    }
+
+    const semVer = coerce(packageVersion)
+
+    if (!semVer) {
+      throw new Error(`${packageVersion} is not valid`)
+    }
+
+    return satisfies(semVer, version)
+  }
+  isValidSync(dependency: DependencyName, version: DependencyVersion): boolean {
+    const packageVersion = this.getVersionSync(dependency)
+
+    if (!packageVersion) {
+      return false
+    }
+    const semVer = coerce(packageVersion)
+
+    if (!semVer) {
+      throw new Error(`${packageVersion} is not valid`)
+    }
+
+    return satisfies(semVer, version)
+  }
+}