@kubb/core 2.0.0-canary.20231030T124958 → 2.0.0

package/src/utils/TreeNode.ts

@@ -0,0 +1,125 @@
+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
+
+type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
+
+export class TreeNode<T = BarrelData> {
+  public data: T
+
+  public parent?: TreeNode<T>
+
+  public children: Array<TreeNode<T>> = []
+
+  constructor(data: T, parent?: TreeNode<T>) {
+    this.data = data
+    this.parent = parent
+    return this
+  }
+
+  addChild(data: T): TreeNode<T> {
+    const child = new TreeNode(data, this)
+    if (!this.children) {
+      this.children = []
+    }
+    this.children.push(child)
+    return child
+  }
+
+  find(data?: T): TreeNode<T> | null {
+    if (!data) {
+      return null
+    }
+
+    if (data === this.data) {
+      return this
+    }
+
+    if (this.children?.length) {
+      for (let i = 0, { length } = this.children, target: TreeNode<T> | null = null; i < length; i++) {
+        target = this.children[i]!.find(data)
+        if (target) {
+          return target
+        }
+      }
+    }
+
+    return null
+  }
+
+  get leaves(): TreeNode<T>[] {
+    if (!this.children || this.children.length === 0) {
+      // this is a leaf
+      return [this]
+    }
+
+    // if not a leaf, return all children's leaves recursively
+    const leaves: TreeNode<T>[] = []
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        // eslint-disable-next-line prefer-spread
+        leaves.push.apply(leaves, this.children[i]!.leaves)
+      }
+    }
+    return leaves
+  }
+
+  get root(): TreeNode<T> {
+    if (!this.parent) {
+      return this
+    }
+    return this.parent.root
+  }
+
+  forEach(callback: (treeNode: TreeNode<T>) => void): this {
+    if (typeof callback !== 'function') {
+      throw new TypeError('forEach() callback must be a function')
+    }
+
+    // run this node through function
+    callback(this)
+
+    // do the same for all children
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        this.children[i]!.forEach(callback)
+      }
+    }
+
+    return this
+  }
+
+  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] })
+
+      if (!filteredTree) {
+        return null
+      }
+
+      const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || FileManager.getMode(filteredTree.path) })
+
+      const recurse = (node: typeof treeNode, item: DirectoryTree) => {
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || FileManager.getMode(item.path) })
+
+        if (item.children?.length) {
+          item.children?.forEach((child) => {
+            recurse(subNode, child)
+          })
+        }
+      }
+
+      filteredTree.children?.forEach((child) => recurse(treeNode, child))
+
+      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

@@ -0,0 +1,133 @@
+import { camelCase } from '../transformers/casing.ts'
+
+export type URLObject = {
+  url: string
+  params?: Record<string, string>
+}
+
+type ObjectOptions = {
+  type?: 'path' | 'template'
+  replacer?: (pathParam: string) => string
+  stringify?: boolean
+}
+
+export class URLPath {
+  path: string
+
+  constructor(path: string) {
+    this.path = path
+
+    return this
+  }
+
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  get URL(): string {
+    return this.toURLPath()
+  }
+  get isURL(): boolean {
+    try {
+      const url = new URL(this.path)
+      if (url?.href) {
+        return true
+      }
+    } catch (error) {
+      return false
+    }
+    return false
+  }
+
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  get template(): string {
+    return this.toTemplateString()
+  }
+  get object(): URLObject | string {
+    return this.toObject()
+  }
+  get params(): Record<string, string> | undefined {
+    return this.getParams()
+  }
+
+  toObject({ type = 'path', replacer, stringify }: ObjectOptions = {}): URLObject | string {
+    const object = {
+      url: type === 'path' ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams(),
+    }
+
+    if (stringify) {
+      if (type === 'template') {
+        return JSON.stringify(object).replaceAll("'", '').replaceAll(`"`, '')
+      }
+
+      if (object.params) {
+        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", '').replaceAll(`"`, '')} }`
+      }
+
+      return `{ url: '${object.url}' }`
+    }
+
+    return object
+  }
+
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  toTemplateString(replacer?: (pathParam: string) => string): string {
+    const regex = /{(\w|-)*}/g
+    const found = this.path.match(regex)
+    let newPath = this.path.replaceAll('{', '${')
+
+    if (found) {
+      newPath = found.reduce((prev, curr) => {
+        const pathParam = replacer
+          ? replacer(camelCase(curr))
+          : camelCase(curr)
+        const replacement = `\${${pathParam}}`
+
+        return prev.replace(curr, replacement)
+      }, this.path)
+    }
+
+    return `\`${newPath}\``
+  }
+
+  getParams(replacer?: (pathParam: string) => string): Record<string, string> | undefined {
+    const regex = /{(\w|-)*}/g
+    const found = this.path.match(regex)
+
+    if (!found) {
+      return undefined
+    }
+
+    const params: Record<string, string> = {}
+    found.forEach((item) => {
+      item = item.replaceAll('{', '').replaceAll('}', '')
+
+      const pathParam = replacer
+        ? replacer(camelCase(item))
+        : camelCase(item)
+
+      params[pathParam] = pathParam
+    }, this.path)
+
+    return params
+  }
+
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath(): string {
+    return this.path.replaceAll('{', ':').replaceAll('}', '')
+  }
+}

package/src/utils/cache.ts

@@ -0,0 +1,35 @@
+import type { PluginCache } from '../types.ts'
+
+export interface Cache<TStore extends object = object> {
+  delete(id: keyof TStore): boolean
+  get(id: keyof TStore): TStore[keyof TStore] | null
+  has(id: keyof TStore): boolean
+  set(id: keyof TStore, value: unknown): void
+}
+
+export function createPluginCache<TStore extends PluginCache>(Store: TStore = Object.create(null) as TStore): Cache<TStore> {
+  return {
+    set(id, value): void {
+      Store[id] = [0, value] as TStore[keyof TStore]
+    },
+    get(id): TStore[keyof TStore] | null {
+      const item = Store[id]
+      if (!item) {
+        return null
+      }
+      item[0] = 0
+      return item[1] as TStore[keyof TStore]
+    },
+    has(id): boolean {
+      const item = Store[id]
+      if (!item) {
+        return false
+      }
+      item[0] = 0
+      return true
+    },
+    delete(id: keyof TStore): boolean {
+      return delete Store[id]
+    },
+  }
+}

package/src/utils/executeStrategies.ts

@@ -0,0 +1,83 @@
+/* eslint-disable unused-imports/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+type PromiseFunc<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2
+
+export type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc<infer X, infer Y>> ? X | Y : never
+
+export function noReturn(): void {}
+
+type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Array<Awaited<ValueOfPromiseFuncArray<TInput>>>
+
+/**
+ * Chains promises
+ */
+export function hookSeq<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TOutput = SeqOutput<TInput, TValue>>(
+  promises: TInput,
+): TOutput {
+  return promises.filter(Boolean).reduce(
+    (promise, func) => {
+      if (typeof func !== 'function') {
+        throw new Error('HookSeq needs a function that returns a promise `() => Promise<unknown>`')
+      }
+
+      return promise.then((state) => {
+        const calledFunc = func(state as TValue)
+
+        if (calledFunc) {
+          return calledFunc.then(Array.prototype.concat.bind(state))
+        }
+      })
+    },
+    Promise.resolve([] as unknown),
+  ) as TOutput
+}
+
+type HookFirstOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>
+
+/**
+ * Chains promises, first non-null result stops and returns
+ */
+export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookFirstOutput<TInput, TValue>>(
+  promises: TInput,
+  nullCheck = (state: any) => state !== null,
+): TOutput {
+  let promise: Promise<unknown> = Promise.resolve(null) as Promise<unknown>
+
+  for (const func of promises.filter(Boolean)) {
+    promise = promise.then((state) => {
+      if (nullCheck(state)) {
+        return state
+      }
+
+      const calledFunc = func(state as TValue)
+
+      return calledFunc
+    })
+  }
+
+  return promise as TOutput
+}
+
+type HookParallelOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>
+
+/**
+ * Run promises in parallel with allSettled
+ */
+export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookParallelOutput<TInput, TValue>>(
+  promises: TInput,
+): TOutput {
+  return Promise.allSettled(promises.filter(Boolean).map(promise => promise())) as TOutput
+}
+
+export type Strategy = 'seq' | 'first' | 'parallel'
+
+export type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc<TValue, null>>, TValue> = TStrategy extends 'first'
+  ? HookFirstOutput<TInput, TValue>
+  : TStrategy extends 'seq' ? SeqOutput<TInput, TValue>
+  : TStrategy extends 'parallel' ? HookParallelOutput<TInput, TValue>
+  : never
+
+// tests
+
+type test = ValueOfPromiseFuncArray<Array<PromiseFunc<number, null>>>
+//    ^?

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+export type { FunctionParamsAST } from './FunctionParams.ts'
+export { FunctionParams } from './FunctionParams.ts'
+export { isPromise, isPromiseFulfilledResult, isPromiseRejectedResult } from './promise.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/utils/promise.ts

@@ -0,0 +1,13 @@
+import type { PossiblePromise } from '@kubb/types'
+
+export function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {
+  return !!result && typeof (result as Promise<unknown>)?.then === 'function'
+}
+
+export function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T> {
+  return result.status === 'fulfilled'
+}
+
+export function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {
+  return result.status === 'rejected'
+}

package/src/utils/renderTemplate.ts

@@ -0,0 +1,31 @@
+export function renderTemplate<TData extends Record<string, unknown> = Record<string, unknown>>(template: string, data: TData | undefined = undefined): string {
+  if (!data || !Object.keys(data).length) {
+    return template.replace(/{{(.*?)}}/g, '')
+  }
+
+  const matches = template.match(/{{(.*?)}}/g)
+
+  return (
+    matches?.reduce((prev, curr) => {
+      const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim()
+      if (index === undefined) {
+        return prev
+      }
+      const value = data[index]
+
+      if (value === undefined) {
+        return prev
+      }
+
+      return prev
+        .replace(curr, () => {
+          if (typeof value === 'boolean') {
+            return `${value.toString()}` || 'false'
+          }
+
+          return (value as string) || ''
+        })
+        .trim()
+    }, template) || ''
+  )
+}

package/src/utils/timeout.ts

@@ -0,0 +1,7 @@
+export async function timeout(ms: number): Promise<unknown> {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true)
+    }, ms)
+  })
+}

package/src/utils/uniqueName.ts

@@ -0,0 +1,20 @@
+export function getUniqueName(originalName: string, data: Record<string, number>): string {
+  let used = data[originalName] || 0
+  if (used) {
+    data[originalName] = ++used
+    originalName += used
+  }
+  data[originalName] = 1
+  return originalName
+}
+
+export function setUniqueName(originalName: string, data: Record<string, number>): string {
+  let used = data[originalName] || 0
+  if (used) {
+    data[originalName] = ++used
+
+    return originalName
+  }
+  data[originalName] = 1
+  return originalName
+}