@kubb/core 2.0.0-beta.1 → 2.0.0-beta.11

package/src/plugin.ts

@@ -26,10 +26,10 @@ type Options = {
 }
 
 // not publicly exported
-export type CorePluginOptions = PluginFactoryOptions<'core', 'controller', Options, Options, PluginContext, never>
+export type CorePluginOptions = PluginFactoryOptions<'core', Options, Options, PluginContext, never>
 
 export const pluginName = 'core' satisfies CorePluginOptions['name']
-export const pluginKey: CorePluginOptions['key'] = ['controller', pluginName] satisfies CorePluginOptions['key']
+export const pluginKey: CorePluginOptions['key'] = [pluginName] satisfies CorePluginOptions['key']
 
 export const definePlugin = createPlugin<CorePluginOptions>((options) => {
   const { fileManager, pluginManager, resolvePath, resolveName, logger } = options
@@ -37,8 +37,8 @@ export const definePlugin = createPlugin<CorePluginOptions>((options) => {
   return {
     name: pluginName,
     options,
-    key: ['controller', 'core'],
-    kind: 'controller',
+    key: ['core'],
+
     api() {
       return {
         get config() {

package/src/transformers/casing.ts

@@ -0,0 +1,9 @@
+import { camelCase as changeCaseCamel, camelCaseTransformMerge, pascalCase as changePascalCase, pascalCaseTransformMerge } from 'change-case'
+
+export function camelCase(text: string): string {
+  return changeCaseCamel(text, { delimiter: '', stripRegexp: /[^A-Z0-9$]/gi, transform: camelCaseTransformMerge })
+}
+
+export function pascalCase(text: string): string {
+  return changePascalCase(text, { delimiter: '', stripRegexp: /[^A-Z0-9$]/gi, transform: pascalCaseTransformMerge })
+}

package/src/transformers/createJSDocBlockText.ts

@@ -0,0 +1,9 @@
+export function createJSDocBlockText({ comments }: { comments: Array<string> }): string {
+  const filteredComments = comments.filter(Boolean)
+
+  if (!filteredComments.length) {
+    return ''
+  }
+
+  return `/**\n * ${filteredComments.join('\n * ')}\n */`
+}

package/src/transformers/index.ts

@@ -0,0 +1,36 @@
+import { camelCase, pascalCase } from './casing.ts'
+import { combineCodes } from './combineCodes.ts'
+import { createJSDocBlockText } from './createJSDocBlockText.ts'
+import { escape, jsStringEscape } from './escape.ts'
+import { createIndent } from './indent.ts'
+import { nameSorter } from './nameSorter.ts'
+import { searchAndReplace } from './searchAndReplace.ts'
+import { transformReservedWord } from './transformReservedWord.ts'
+import { trim, trimExtName } from './trim.ts'
+
+export { camelCase, pascalCase } from './casing.ts'
+export { combineCodes } from './combineCodes.ts'
+export { createJSDocBlockText } from './createJSDocBlockText.ts'
+export { escape, jsStringEscape } from './escape.ts'
+export { createIndent } from './indent.ts'
+export { nameSorter } from './nameSorter.ts'
+export { searchAndReplace } from './searchAndReplace.ts'
+export { transformReservedWord } from './transformReservedWord.ts'
+export { trim, trimExtName } from './trim.ts'
+
+export default {
+  combineCodes,
+  escape,
+  jsStringEscape,
+  createIndent,
+  transformReservedWord,
+  nameSorter,
+  searchAndReplace,
+  trim,
+  trimExtName,
+  JSDoc: {
+    createJSDocBlockText,
+  },
+  camelCase,
+  pascalCase,
+} as const

package/src/transformers/trim.ts

@@ -0,0 +1,7 @@
+export function trim(text: string): string {
+  return text.replaceAll(/\n/g, '').trim()
+}
+
+export function trimExtName(text: string): string {
+  return text.replace(/\.[^/.]+$/, '')
+}

package/src/types.ts

@@ -1,9 +1,9 @@
 import type { PossiblePromise } from '@kubb/types'
 import type { FileManager, KubbFile } from './FileManager.ts'
 import type { OptionsPlugins, PluginUnion } from './index.ts'
+import type { Logger, LogLevel } from './logger.ts'
 import type { PluginManager } from './PluginManager.ts'
 import type { Cache } from './utils/cache.ts'
-import type { Logger, LogLevel } from './utils/logger.ts'
 
 // config
 
@@ -123,8 +123,6 @@ export type CLIOptions = {
 
 // plugin
 
-export type KubbPluginKind = 'schema' | 'controller'
-
 export type KubbUnionPlugins = PluginUnion
 
 export type KubbObjectPlugin = keyof OptionsPlugins
@@ -134,10 +132,6 @@ export type PluginFactoryOptions<
    * Name to be used for the plugin, this will also be used for they key.
    */
   TName extends string = string,
-  /**
-   * @type "schema" | "controller"
-   */
-  TKind extends KubbPluginKind = KubbPluginKind,
   /**
    * Options of the plugin.
    */
@@ -161,18 +155,17 @@ export type PluginFactoryOptions<
   TAppMeta = unknown,
 > = {
   name: TName
-  kind: TKind
   /**
    * Same behaviour like what has been done with `QueryKey` in `@tanstack/react-query`
    */
-  key: [kind: TKind | undefined, name: TName | string, identifier?: string | number]
+  key: [name: TName | string, identifier?: string | number]
   options: TOptions
   resolvedOptions: TResolvedOptions
   api: TAPI
   resolvePathOptions: TResolvePathOptions
   appMeta: {
     pluginManager: PluginManager
-    plugin: KubbPlugin<PluginFactoryOptions<TName, TKind, TOptions, TResolvedOptions, TAPI, TResolvePathOptions, TAppMeta>>
+    plugin: KubbPlugin<PluginFactoryOptions<TName, TOptions, TResolvedOptions, TAPI, TResolvePathOptions, TAppMeta>>
   } & TAppMeta
 }
 
@@ -182,18 +175,23 @@ export type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactory
   & {
     /**
      * Unique name used for the plugin
+     * The name of the plugin follows the format scope:foo-bar or foo-bar, adding scope: can avoid naming conflicts with other plugins.
      * @example @kubb/typescript
      */
     name: TOptions['name']
-    /**
-     * Internal key used when a developer uses more than one of the same plugin
-     * @private
-     */
-    key?: TOptions['key']
     /**
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
     options: TOptions['resolvedOptions']
+    /**
+     * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
+     * Can be used to validate depended plugins.
+     */
+    pre?: Array<string>
+    /**
+     * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
+     */
+    post?: Array<string>
   }
   & (TOptions['api'] extends never ? {
       api?: never
@@ -201,24 +199,10 @@ export type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactory
     : {
       api: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['api']
     })
-  & (TOptions['kind'] extends never ? {
-      kind?: never
-    }
-    : {
-      /**
-       * Kind/type for the plugin
-       *
-       * Type 'schema' can be used for JSON schema's, TypeScript types, ...
-       *
-       * Type 'controller' can be used to create generate API calls, React-Query hooks, Axios controllers, ...
-       * @default undefined
-       */
-      kind: TOptions['kind']
-    })
 
 export type KubbUserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = KubbUserPlugin<TOptions> & PluginLifecycle<TOptions>
 
-type UnknownKubbUserPlugin = KubbUserPlugin<PluginFactoryOptions<any, any, any, any, any, any, any>>
+type UnknownKubbUserPlugin = KubbUserPlugin<PluginFactoryOptions<any, any, any, any, any, any>>
 
 export type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
   & {
@@ -233,16 +217,18 @@ export type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
      */
     key: TOptions['key']
     /**
-     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
+     * Can be used to validate depended plugins.
      */
-    options: TOptions['resolvedOptions']
+    pre?: Array<string>
     /**
-     * Kind/type for the plugin
-     * Type 'schema' can be used for JSON schema's, TypeScript types, ...
-     * Type 'controller' can be used to create generate API calls, React-Query hooks, Axios controllers, ...
-     * @default undefined
+     * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
      */
-    kind?: TOptions['kind']
+    post?: Array<string>
+    /**
+     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     */
+    options: TOptions['resolvedOptions']
     /**
      * Define an api that can be used by other plugins, see `PluginManager' where we convert from `KubbUserPlugin` to `KubbPlugin`(used when calling `createPlugin`).
      */
@@ -257,11 +243,6 @@ export type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
 export type KubbPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = KubbPlugin<TOptions> & PluginLifecycle<TOptions>
 
 export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
-  /**
-   * Valdiate all plugins to see if their depended plugins are installed and configured.
-   * @type hookParallel
-   */
-  validate?: (this: Omit<PluginContext<TOptions>, 'addFile'>, plugins: NonNullable<KubbConfig['plugins']>) => PossiblePromise<true>
   /**
    * Start of the lifecycle of a plugin.
    * @type hookParallel

package/src/utils/FunctionParams.ts

@@ -1,6 +1,7 @@
-import { camelCase, camelCaseTransformMerge } from 'change-case'
 import { orderBy } from 'natural-orderby'
 
+import transformers from '../transformers/index.ts'
+
 type FunctionParamsASTWithoutType = {
   name?: string
   type?: string
@@ -66,7 +67,7 @@ export class FunctionParams {
           return acc
         }
         // TODO check whey we still need the camelcase here
-        const parameterName = name.startsWith('{') ? name : camelCase(name, { delimiter: '', transform: camelCaseTransformMerge })
+        const parameterName = name.startsWith('{') ? name : transformers.camelCase(name)
 
         if (type) {
           if (required) {

package/src/utils/TreeNode.ts

@@ -3,10 +3,13 @@ import dirTree from 'directory-tree'
 import { FileManager } from '../FileManager.ts'
 
 import type { DirectoryTree, DirectoryTreeOptions } from 'directory-tree'
+import type { KubbFile } from '../FileManager.ts'
 
 export type TreeNodeOptions = DirectoryTreeOptions
 
-export class TreeNode<T = unknown> {
+type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
+
+export class TreeNode<T = BarrelData> {
   public data: T
 
   public parent?: TreeNode<T>
@@ -91,7 +94,7 @@ export class TreeNode<T = unknown> {
     return this
   }
 
-  public static build<T = unknown>(path: string, options: TreeNodeOptions = {}): TreeNode<T> | null {
+  public static build(path: string, options: TreeNodeOptions = {}): TreeNode | null {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean)
       const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] })
@@ -114,7 +117,7 @@ export class TreeNode<T = unknown> {
 
       filteredTree.children?.forEach((child) => recurse(treeNode, child))
 
-      return treeNode as TreeNode<T>
+      return treeNode
     } catch (e) {
       throw new Error('Something went wrong with creating index files with the TreehNode class', { cause: e })
     }

package/src/utils/URLPath.ts

@@ -1,4 +1,4 @@
-import { camelCase, camelCaseTransformMerge } from 'change-case'
+import transformers from '../transformers/index.ts'
 
 export type URLObject = {
   url: string
@@ -90,8 +90,8 @@ export class URLPath {
     if (found) {
       newPath = found.reduce((prev, curr) => {
         const pathParam = replacer
-          ? replacer(camelCase(curr, { delimiter: '', transform: camelCaseTransformMerge }))
-          : camelCase(curr, { delimiter: '', transform: camelCaseTransformMerge })
+          ? replacer(transformers.camelCase(curr))
+          : transformers.camelCase(curr)
         const replacement = `\${${pathParam}}`
 
         return prev.replace(curr, replacement)
@@ -114,8 +114,8 @@ export class URLPath {
       item = item.replaceAll('{', '').replaceAll('}', '')
 
       const pathParam = replacer
-        ? replacer(camelCase(item, { delimiter: '', transform: camelCaseTransformMerge }))
-        : camelCase(item, { delimiter: '', transform: camelCaseTransformMerge })
+        ? replacer(transformers.camelCase(item))
+        : transformers.camelCase(item)
 
       params[pathParam] = pathParam
     }, this.path)

package/src/utils/index.ts

@@ -1,19 +1,10 @@
-export * from './cache.ts'
-export * from './cache.ts'
-export * from './clean.ts'
-export * from './FunctionParams.ts'
-export * from './FunctionParams.ts'
-export * from './logger.ts'
-export * from './promise.ts'
-export * from './Queue.ts'
-export * from './Queue.ts'
-export * from './randomColour.ts'
-export * from './read.ts'
-export * from './renderTemplate.ts'
-export * from './throttle.ts'
-export * from './timeout.ts'
-export * from './transformers/index.ts'
-export * from './TreeNode.ts'
-export * from './uniqueName.ts'
-export * from './URLPath.ts'
-export * from './write.ts'
+export type { FunctionParamsAST } from './FunctionParams.ts'
+export { FunctionParams } from './FunctionParams.ts'
+export { isPromise, isPromiseFulfilledResult, isPromiseRejectedResult } from './promise.ts'
+export type { QueueJob } from './Queue.ts'
+export { Queue } from './Queue.ts'
+export { renderTemplate } from './renderTemplate.ts'
+export { timeout } from './timeout.ts'
+export { getUniqueName, setUniqueName } from './uniqueName.ts'
+export type { URLObject } from './URLPath.ts'
+export { URLPath } from './URLPath.ts'

package/src/SchemaGenerator.ts

@@ -1,8 +0,0 @@
-import { Generator } from './Generator.ts'
-
-/**
- * Abstract class that contains the building blocks for plugins to create their own SchemaGenerator
- */
-export abstract class SchemaGenerator<TOptions extends object, TInput, TOutput> extends Generator<TOptions> {
-  abstract build(schema: TInput, name: string, description?: string): TOutput
-}

package/src/utils/randomColour.ts

@@ -1,39 +0,0 @@
-import pc from 'picocolors'
-import seedrandom from 'seedrandom'
-
-import type { Formatter } from 'picocolors/types.ts'
-
-const defaultColours = ['black', 'blue', 'darkBlue', 'cyan', 'gray', 'green', 'darkGreen', 'magenta', 'red', 'darkRed', 'yellow', 'darkYellow'] as const
-
-export function randomColour(text?: string, colours = defaultColours): string {
-  if (!text) {
-    return 'white'
-  }
-
-  const random = seedrandom(text)
-  const colour = colours.at(Math.floor(random() * colours.length)) || 'white'
-
-  return colour
-}
-
-export function randomPicoColour(text?: string, colors = defaultColours): string {
-  const colours = pc.createColors(true)
-
-  if (!text) {
-    return colours.white(text)
-  }
-
-  const colour = randomColour(text, colors)
-  const isDark = colour.includes('dark')
-  const key = colour.replace('dark', '').toLowerCase() as keyof typeof colours
-  const formatter: Formatter = colours[key] as Formatter
-
-  if (isDark) {
-    return pc.bold(formatter(text))
-  }
-
-  if (typeof formatter !== 'function') {
-    throw new Error('Formatter for picoColor is not of type function/Formatter')
-  }
-  return formatter(text)
-}

package/src/utils/throttle.ts

@@ -1,30 +0,0 @@
-export const throttle = <R, A extends any[]>(fn: (...args: A) => R, delay: number): [(...args: A) => R | undefined, () => void] => {
-  let wait = false
-  let timeout: NodeJS.Timeout
-  let cancelled = false
-
-  return [
-    (...args: A) => {
-      if (cancelled) {
-        return undefined
-      }
-      if (wait) {
-        return undefined
-      }
-
-      const val = fn(...args)
-
-      wait = true
-
-      timeout = setTimeout(() => {
-        wait = false
-      }, delay)
-
-      return val
-    },
-    () => {
-      cancelled = true
-      clearTimeout(timeout)
-    },
-  ]
-}

package/src/utils/transformers/createJSDocBlockText.ts

@@ -1,15 +0,0 @@
-export function createJSDocBlockText({ comments, newLine }: { comments: Array<string>; newLine?: boolean }): string {
-  const filteredComments = comments.filter(Boolean)
-
-  if (!filteredComments.length) {
-    return ''
-  }
-
-  const source = `/**\n * ${filteredComments.join('\n * ')}\n */`
-
-  if (newLine) {
-    return `${source}\n`
-  }
-
-  return source
-}

package/src/utils/transformers/index.ts

@@ -1,22 +0,0 @@
-import { combineCodes } from './combineCodes.ts'
-import { createJSDocBlockText } from './createJSDocBlockText.ts'
-import { escape, jsStringEscape } from './escape.ts'
-import { createIndent } from './indent.ts'
-import { nameSorter } from './nameSorter.ts'
-import { searchAndReplace } from './searchAndReplace.ts'
-import { transformReservedWord } from './transformReservedWord.ts'
-import { trim } from './trim.ts'
-
-export const transformers = {
-  combineCodes,
-  escape,
-  jsStringEscape,
-  createIndent,
-  transformReservedWord,
-  nameSorter,
-  searchAndReplace,
-  trim,
-  JSDoc: {
-    createJSDocBlockText,
-  },
-} as const

package/src/utils/transformers/trim.ts

@@ -1,3 +0,0 @@
-export function trim(text: string): string {
-  return text.replaceAll(/\n/g, '').trim()
-}