@kubb/plugin-ts 0.0.0-canary-20241104172400

package/src/parser/index.ts

@@ -0,0 +1,279 @@
+import transformers from '@kubb/core/transformers'
+import * as factory from '@kubb/parser-ts/factory'
+import { type SchemaTree, isKeyword, schemaKeywords } from '@kubb/plugin-oas'
+
+import type { Schema, SchemaKeywordMapper, SchemaMapper } from '@kubb/plugin-oas'
+import type ts from 'typescript'
+
+export const typeKeywordMapper = {
+  any: () => factory.keywordTypeNodes.any,
+  unknown: () => factory.keywordTypeNodes.unknown,
+  number: () => factory.keywordTypeNodes.number,
+  integer: () => factory.keywordTypeNodes.number,
+  object: (nodes?: ts.TypeElement[]) => {
+    if (!nodes || !nodes.length) {
+      return factory.keywordTypeNodes.object
+    }
+
+    return factory.createTypeLiteralNode(nodes)
+  },
+  string: () => factory.keywordTypeNodes.string,
+  boolean: () => factory.keywordTypeNodes.boolean,
+  undefined: () => factory.keywordTypeNodes.undefined,
+  nullable: undefined,
+  null: () => factory.keywordTypeNodes.null,
+  nullish: undefined,
+  array: (nodes?: ts.TypeNode[]) => {
+    if (!nodes) {
+      return undefined
+    }
+
+    return factory.createArrayDeclaration({ nodes })
+  },
+  tuple: (nodes?: ts.TypeNode[]) => {
+    if (!nodes) {
+      return undefined
+    }
+
+    return factory.createTupleTypeNode(nodes)
+  },
+  enum: (name?: string) => {
+    if (!name) {
+      return undefined
+    }
+
+    return factory.createTypeReferenceNode(name, undefined)
+  },
+  union: (nodes?: ts.TypeNode[]) => {
+    if (!nodes) {
+      return undefined
+    }
+
+    return factory.createUnionDeclaration({
+      withParentheses: true,
+      nodes,
+    })
+  },
+  const: (name?: string | number | boolean, format?: 'string' | 'number' | 'boolean') => {
+    if (!name) {
+      return undefined
+    }
+
+    if (format === 'boolean') {
+      if (name === true) {
+        return factory.createLiteralTypeNode(factory.createTrue())
+      }
+
+      return factory.createLiteralTypeNode(factory.createFalse())
+    }
+
+    if (format === 'number' && typeof name === 'number') {
+      return factory.createLiteralTypeNode(factory.createNumericLiteral(name))
+    }
+
+    return factory.createLiteralTypeNode(factory.createStringLiteral(name.toString()))
+  },
+  datetime: () => factory.keywordTypeNodes.string,
+  date: (type: 'date' | 'string' = 'string') =>
+    type === 'string' ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier('Date')),
+  time: (type: 'date' | 'string' = 'string') =>
+    type === 'string' ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier('Date')),
+  uuid: undefined,
+  url: undefined,
+  strict: undefined,
+  default: undefined,
+  and: (nodes?: ts.TypeNode[]) => {
+    if (!nodes) {
+      return undefined
+    }
+
+    return factory.createIntersectionDeclaration({
+      withParentheses: true,
+      nodes,
+    })
+  },
+  describe: undefined,
+  min: undefined,
+  max: undefined,
+  optional: undefined,
+  matches: undefined,
+  email: undefined,
+  firstName: undefined,
+  lastName: undefined,
+  password: undefined,
+  phone: undefined,
+  readOnly: undefined,
+  writeOnly: undefined,
+  ref: (propertyName?: string) => {
+    if (!propertyName) {
+      return undefined
+    }
+
+    return factory.createTypeReferenceNode(propertyName, undefined)
+  },
+  blob: () => factory.createTypeReferenceNode('Blob', []),
+  deprecated: undefined,
+  example: undefined,
+  schema: undefined,
+  catchall: undefined,
+  name: undefined,
+} satisfies SchemaMapper<ts.Node | null | undefined>
+
+type ParserOptions = {
+  name: string
+  typeName?: string
+  description?: string
+  /**
+   * @default `'questionToken'`
+   */
+  optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined'
+  /**
+   * @default `'asConst'`
+   * asPascalConst is deprecated
+   */
+  enumType: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal'
+  keysToOmit?: string[]
+  mapper?: Record<string, ts.PropertySignature>
+}
+
+export function parse({ parent, current, siblings }: SchemaTree, options: ParserOptions): ts.Node | null | undefined {
+  const value = typeKeywordMapper[current.keyword as keyof typeof typeKeywordMapper]
+
+  if (!value) {
+    return undefined
+  }
+
+  if (isKeyword(current, schemaKeywords.union)) {
+    return typeKeywordMapper.union(
+      current.args.map((schema) => parse({ parent: current, current: schema, siblings }, options)).filter(Boolean) as ts.TypeNode[],
+    )
+  }
+
+  if (isKeyword(current, schemaKeywords.and)) {
+    return typeKeywordMapper.and(current.args.map((schema) => parse({ parent: current, current: schema, siblings }, options)).filter(Boolean) as ts.TypeNode[])
+  }
+
+  if (isKeyword(current, schemaKeywords.array)) {
+    return typeKeywordMapper.array(
+      current.args.items.map((schema) => parse({ parent: current, current: schema, siblings }, options)).filter(Boolean) as ts.TypeNode[],
+    )
+  }
+
+  if (isKeyword(current, schemaKeywords.enum)) {
+    return typeKeywordMapper.enum(current.args.typeName)
+  }
+
+  if (isKeyword(current, schemaKeywords.ref)) {
+    return typeKeywordMapper.ref(current.args.name)
+  }
+
+  if (isKeyword(current, schemaKeywords.blob)) {
+    return value()
+  }
+
+  if (isKeyword(current, schemaKeywords.tuple)) {
+    return typeKeywordMapper.tuple(
+      current.args.items.map((schema) => parse({ parent: current, current: schema, siblings }, options)).filter(Boolean) as ts.TypeNode[],
+    )
+  }
+
+  if (isKeyword(current, schemaKeywords.const)) {
+    return typeKeywordMapper.const(current.args.name, current.args.format)
+  }
+
+  if (isKeyword(current, schemaKeywords.object)) {
+    const properties = Object.entries(current.args?.properties || {})
+      .filter((item) => {
+        const schemas = item[1]
+        return schemas && typeof schemas.map === 'function'
+      })
+      .map(([name, schemas]) => {
+        const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']
+        const mappedName = nameSchema?.args || name
+
+        // custom mapper(pluginOptions)
+        if (options.mapper?.[mappedName]) {
+          return options.mapper?.[mappedName]
+        }
+
+        const isNullish = schemas.some((schema) => schema.keyword === schemaKeywords.nullish)
+        const isNullable = schemas.some((schema) => schema.keyword === schemaKeywords.nullable)
+        const isOptional = schemas.some((schema) => schema.keyword === schemaKeywords.optional)
+        const isReadonly = schemas.some((schema) => schema.keyword === schemaKeywords.readOnly)
+        const describeSchema = schemas.find((schema) => schema.keyword === schemaKeywords.describe) as SchemaKeywordMapper['describe'] | undefined
+        const deprecatedSchema = schemas.find((schema) => schema.keyword === schemaKeywords.deprecated) as SchemaKeywordMapper['deprecated'] | undefined
+        const defaultSchema = schemas.find((schema) => schema.keyword === schemaKeywords.default) as SchemaKeywordMapper['default'] | undefined
+        const exampleSchema = schemas.find((schema) => schema.keyword === schemaKeywords.example) as SchemaKeywordMapper['example'] | undefined
+        const schemaSchema = schemas.find((schema) => schema.keyword === schemaKeywords.schema) as SchemaKeywordMapper['schema'] | undefined
+
+        let type = schemas.map((schema) => parse({ parent: current, current: schema, siblings }, options)).filter(Boolean)[0] as ts.TypeNode
+
+        if (isNullable) {
+          type = factory.createUnionDeclaration({
+            nodes: [type, factory.keywordTypeNodes.null],
+          }) as ts.TypeNode
+        }
+
+        if (isNullish && ['undefined', 'questionTokenAndUndefined'].includes(options.optionalType as string)) {
+          type = factory.createUnionDeclaration({
+            nodes: [type, factory.keywordTypeNodes.undefined],
+          }) as ts.TypeNode
+        }
+
+        if (isOptional && ['undefined', 'questionTokenAndUndefined'].includes(options.optionalType as string)) {
+          type = factory.createUnionDeclaration({
+            nodes: [type, factory.keywordTypeNodes.undefined],
+          }) as ts.TypeNode
+        }
+
+        const propertySignature = factory.createPropertySignature({
+          questionToken: isOptional || isNullish ? ['questionToken', 'questionTokenAndUndefined'].includes(options.optionalType as string) : false,
+          name: mappedName,
+          type,
+          readOnly: isReadonly,
+        })
+
+        return factory.appendJSDocToNode({
+          node: propertySignature,
+          comments: [
+            describeSchema ? `@description ${transformers.jsStringEscape(describeSchema.args)}` : undefined,
+            deprecatedSchema ? '@deprecated' : undefined,
+            defaultSchema ? `@default ${defaultSchema.args}` : undefined,
+            exampleSchema ? `@example ${exampleSchema.args}` : undefined,
+            schemaSchema?.args?.type || schemaSchema?.args?.format
+              ? [`@type ${schemaSchema?.args?.type || 'unknown'}${!isOptional ? '' : ' | undefined'}`, schemaSchema?.args?.format].filter(Boolean).join(', ')
+              : undefined,
+          ].filter(Boolean),
+        })
+      })
+
+    const additionalProperties = current.args?.additionalProperties?.length
+      ? factory.createIndexSignature(
+          current.args.additionalProperties
+            .map((schema) => parse({ parent: current, current: schema, siblings }, options))
+            .filter(Boolean)
+            .at(0) as ts.TypeNode,
+        )
+      : undefined
+
+    return typeKeywordMapper.object([...properties, additionalProperties].filter(Boolean))
+  }
+
+  if (isKeyword(current, schemaKeywords.datetime)) {
+    return typeKeywordMapper.datetime()
+  }
+
+  if (isKeyword(current, schemaKeywords.date)) {
+    return typeKeywordMapper.date(current.args.type)
+  }
+
+  if (isKeyword(current, schemaKeywords.time)) {
+    return typeKeywordMapper.time(current.args.type)
+  }
+
+  if (current.keyword in typeKeywordMapper) {
+    return value()
+  }
+
+  return undefined
+}

package/src/plugin.ts

@@ -0,0 +1,127 @@
+import path from 'node:path'
+
+import { FileManager, type Group, PluginManager, createPlugin } from '@kubb/core'
+import { camelCase, pascalCase } from '@kubb/core/transformers'
+import { OperationGenerator, SchemaGenerator, pluginOasName } from '@kubb/plugin-oas'
+
+import type { Plugin } from '@kubb/core'
+import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
+import { oasGenerator, typeGenerator } from './generators'
+import type { PluginTs } from './types.ts'
+
+export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
+
+export const pluginTs = createPlugin<PluginTs>((options) => {
+  const {
+    output = { path: 'types', barrelType: 'named' },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    enumType = 'asConst',
+    enumSuffix = 'enum',
+    dateType = 'string',
+    unknownType = 'any',
+    optionalType = 'questionToken',
+    transformers = {},
+    oasType = false,
+    mapper = {},
+    generators = [typeGenerator, oasType === 'infer' ? oasGenerator : undefined].filter(Boolean),
+  } = options
+
+  return {
+    name: pluginTsName,
+    options: {
+      output,
+      transformers,
+      dateType,
+      optionalType,
+      oasType,
+      enumType,
+      enumSuffix,
+      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
+      usedEnumNames: {},
+      unknownType,
+      override,
+      mapper,
+    },
+    pre: [pluginOasName],
+    resolvePath(baseName, pathMode, options) {
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
+
+      if (options?.tag && group?.type === 'tag') {
+        const groupName: Group['name'] = group?.name ? group.name : (ctx) => `${ctx.group}Controller`
+
+        return path.resolve(root, output.path, groupName({ group: camelCase(options.tag) }), baseName)
+      }
+
+      if (mode === 'single') {
+        /**
+         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
+         */
+        return path.resolve(root, output.path)
+      }
+
+      return path.resolve(root, output.path, baseName)
+    },
+    resolveName(name, type) {
+      const resolvedName = pascalCase(name, { isFile: type === 'file' })
+
+      if (type) {
+        return transformers?.name?.(resolvedName, type) || resolvedName
+      }
+
+      return resolvedName
+    },
+    async buildStart() {
+      const [swaggerPlugin]: [Plugin<SwaggerPluginOptions>] = PluginManager.getDependedPlugins<SwaggerPluginOptions>(this.plugins, [pluginOasName])
+
+      const oas = await swaggerPlugin.context.getOas()
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = FileManager.getMode(path.resolve(root, output.path))
+
+      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType: swaggerPlugin.context.contentType,
+        include: undefined,
+        override,
+        mode,
+        output: output.path,
+      })
+
+      const schemaFiles = await schemaGenerator.build(...generators)
+      await this.addFile(...schemaFiles)
+
+      const operationGenerator = new OperationGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType: swaggerPlugin.context.contentType,
+        exclude,
+        include,
+        override,
+        mode,
+      })
+
+      const operationFiles = await operationGenerator.build(...generators)
+      await this.addFile(...operationFiles)
+
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
+        root,
+        output,
+        files: this.fileManager.files,
+        meta: {
+          pluginKey: this.plugin.key,
+        },
+        logger: this.logger,
+      })
+
+      await this.addFile(...barrelFiles)
+    },
+  }
+})

package/src/types.ts

@@ -0,0 +1,97 @@
+import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { Exclude, Generator, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
+import type ts from 'typescript'
+
+export type Options = {
+  /**
+   * Specify the export location for the files and define the behavior of the output
+   * @default { path: 'types', barrelType: 'named' }
+   */
+  output?: Output
+  /**
+   * Group the clients based on the provided name.
+   */
+  group?: Group
+  /**
+   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   */
+  exclude?: Array<Exclude>
+  /**
+   * Array containing include parameters to include tags/operations/methods/paths.
+   */
+  include?: Array<Include>
+  /**
+   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   */
+  override?: Array<Override<ResolvedOptions>>
+  /**
+   * Choose to use `enum` or `as const` for enums
+   * @default 'asConst'
+   * asPascalConst is deprecated
+   */
+  enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal'
+  /**
+   * Set a suffix for the generated enums.
+   * @default 'enum'
+   */
+  enumSuffix?: string
+  /**
+   * Choose to use `date` or `datetime` as JavaScript `Date` instead of `string`.
+   * @default 'string'
+   */
+  dateType?: 'string' | 'date'
+  /**
+   * Which type to use when the Swagger/OpenAPI file is not providing more information.
+   * @default 'any'
+   */
+  unknownType?: 'any' | 'unknown'
+  /**
+   * Choose what to use as mode for an optional value.
+   * @examples 'questionToken': type?: string
+   * @examples 'undefined': type: string | undefined
+   * @examples 'questionTokenAndUndefined': type?: string | undefined
+   * @default 'questionToken'
+   */
+  optionalType?: 'questionToken' | 'undefined' | 'questionTokenAndUndefined'
+  transformers?: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
+  }
+  /**
+   * Export an Oas object as Oas type with `import type { Infer } from '@kubb/oas'`
+   */
+  oasType?: 'infer' | false
+  /**
+   * @example
+   * Use https://ts-ast-viewer.com to generate factory code(see createPropertySignature)
+   * category: factory.createPropertySignature(
+   *   undefined,
+   *   factory.createIdentifier("category"),
+   *   factory.createToken(ts.SyntaxKind.QuestionToken),
+   *   factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+   * )
+   */
+  mapper?: Record<string, ts.PropertySignature>
+  /**
+   * Define some generators next to the ts generators
+   */
+  generators?: Array<Generator<PluginTs>>
+}
+
+type ResolvedOptions = {
+  output: Output
+  override: NonNullable<Options['override']>
+  enumType: NonNullable<Options['enumType']>
+  enumSuffix: NonNullable<Options['enumSuffix']>
+  dateType: NonNullable<Options['dateType']>
+  unknownType: NonNullable<Options['unknownType']>
+  optionalType: NonNullable<Options['optionalType']>
+  transformers: NonNullable<Options['transformers']>
+  oasType: NonNullable<Options['oasType']>
+  usedEnumNames: Record<string, number>
+  mapper: Record<string, any>
+}
+
+export type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions>