@kubb/plugin-oas 0.0.0-canary-20240806053140 → 0.0.0-canary-20241106205013

package/src/plugin.ts

@@ -1,34 +1,35 @@
-import path from 'node:path'
-
-import { createPlugin } from '@kubb/core'
-import { camelCase } from '@kubb/core/transformers'
+import { FileManager, createPlugin } from '@kubb/core'
 
 import { getSchemas } from './utils/getSchemas.ts'
+import { parseFromConfig } from './utils/parseFromConfig.ts'
 
+import path from 'node:path'
 import type { Config } from '@kubb/core'
 import type { Logger } from '@kubb/core/logger'
-import type { Oas, OasTypes } from '@kubb/oas'
-import type { FormatOptions } from '@kubb/oas/parser'
+import type { Oas } from '@kubb/oas'
+import { OperationGenerator } from './OperationGenerator.ts'
+import { SchemaGenerator } from './SchemaGenerator.ts'
+import { jsonGenerator } from './generators'
 import type { PluginOas } from './types.ts'
-import { parseFromConfig } from './utils/parseFromConfig.ts'
 
 export const pluginOasName = 'plugin-oas' satisfies PluginOas['name']
 
 export const pluginOas = createPlugin<PluginOas>((options) => {
   const {
-    output = { path: 'schemas', export: false },
-    experimentalFilter: filter,
-    experimentalSort: sort,
+    output = {
+      path: 'schemas',
+    },
     validate = true,
-    serverIndex = 0,
+    generators = [jsonGenerator],
+    serverIndex,
     contentType,
     oasClass,
   } = options
 
-  const getOas = async ({ config, logger, formatOptions }: { config: Config; logger: Logger; formatOptions?: FormatOptions }): Promise<Oas> => {
+  const getOas = async ({ config, logger }: { config: Config; logger: Logger }): Promise<Oas> => {
     try {
       // needs to be in a different variable or the catch here will not work(return of a promise instead)
-      const oas = await parseFromConfig(config, formatOptions, oasClass)
+      const oas = await parseFromConfig(config, oasClass)
 
       if (validate) {
         await oas.valdiate()
@@ -39,20 +40,22 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
       const error = e as Error
 
       logger.emit('warning', error?.message)
-      return parseFromConfig(config, {}, oasClass)
+      return parseFromConfig(config, oasClass)
     }
   }
 
   return {
     name: pluginOasName,
-    options,
-
-    api() {
+    options: {
+      output,
+      ...options,
+    },
+    context() {
       const { config, logger } = this
 
       return {
-        getOas(formatOptions) {
-          return getOas({ config, logger, formatOptions })
+        getOas() {
+          return getOas({ config, logger })
         },
         async getSchemas({ includes } = {}) {
           const oas = await this.getOas()
@@ -60,30 +63,28 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
         },
         async getBaseURL() {
           const oasInstance = await this.getOas()
-          const baseURL = oasInstance.api.servers?.at(serverIndex)?.url
-          return baseURL
+          if (serverIndex) {
+            return oasInstance.api.servers?.at(serverIndex)?.url
+          }
+
+          return undefined
         },
         contentType,
       }
     },
-    resolvePath(baseName) {
-      if (output === false) {
-        return undefined
-      }
-
+    resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
-
-      return path.resolve(root, output.path, baseName)
-    },
-    resolveName(name, type) {
-      return camelCase(name, { isFile: type === 'file' })
-    },
-    async writeFile(path, source) {
-      if (!path.endsWith('.json') || !source) {
-        return
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
+
+      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 this.fileManager.write(path, source, { sanity: false })
+      return path.resolve(root, output.path, baseName)
     },
     async buildStart() {
       if (!output) {
@@ -93,42 +94,45 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
       const oas = await getOas({
         config: this.config,
         logger: this.logger,
-        formatOptions: {
-          filterSet: filter,
-          sortSet: sort,
-        },
       })
       await oas.dereference()
-      const schemas = getSchemas({ oas, contentType })
-
-      const mapSchema = async ([name, schema]: [string, OasTypes.SchemaObject]) => {
-        const resolvedPath = this.resolvePath({
-          baseName: `${name}.json`,
-          pluginKey: this.plugin.key,
-        })
-
-        const resvoledFileName = this.resolveName({
-          name: `${name}.json`,
-          pluginKey: [pluginOasName],
-          type: 'file',
-        }) as `${string}.json`
-
-        if (!resolvedPath) {
-          return
-        }
-
-        await this.addFile({
-          path: resolvedPath,
-          baseName: resvoledFileName,
-          source: JSON.stringify(schema),
-          meta: {
-            pluginKey: this.plugin.key,
-          },
-        })
-      }
 
-      const promises = Object.entries(schemas).map(mapSchema)
-      await Promise.all(promises)
+      const schemaGenerator = new SchemaGenerator(
+        {
+          unknownType: 'unknown',
+          dateType: 'date',
+          transformers: {},
+          ...this.plugin.options,
+        },
+        {
+          oas,
+          pluginManager: this.pluginManager,
+          plugin: this.plugin,
+          contentType,
+          include: undefined,
+          override: undefined,
+          mode: 'split',
+          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,
+        exclude: undefined,
+        include: undefined,
+        override: undefined,
+        mode: 'split',
+      })
+
+      const operationFiles = await operationGenerator.build(...generators)
+
+      await this.addFile(...operationFiles)
     },
   }
 })

package/src/types.ts

@@ -1,9 +1,9 @@
-import type { Plugin } from '@kubb/core'
+import type { Output, Plugin } from '@kubb/core'
 import type { PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 import type * as KubbFile from '@kubb/fs/types'
 
 import type { HttpMethod, Oas, Operation, SchemaObject, contentType } from '@kubb/oas'
-import type { FormatOptions } from '@kubb/oas/parser'
+import type { Generator } from './generator.tsx'
 import type { GetSchemasProps } from './utils/getSchemas.ts'
 
 export type ResolvePathOptions = {
@@ -13,7 +13,7 @@ export type ResolvePathOptions = {
 }
 
 export type API = {
-  getOas: (formatOptions?: FormatOptions) => Promise<Oas>
+  getOas: () => Promise<Oas>
   getSchemas: (options?: Pick<GetSchemasProps, 'includes'>) => Promise<Record<string, SchemaObject>>
   getBaseURL: () => Promise<string | undefined>
   contentType?: contentType
@@ -25,44 +25,42 @@ export type Options = {
    * @default true
    */
   validate?: boolean
-  output?:
-    | {
-        /**
-         * Relative path to save the JSON models.
-         * False will not generate the schema JSON's.
-         * @default 'schemas'
-         */
-        path: string
-      }
-    | false
+  /**
+   * Specify the export location for the files and define the behavior of the output
+   * @default { path: 'schemas', barrelType: 'named' }
+   */
+  output?: Output
   /**
    * Which server to use from the array of `servers.url[serverIndex]`
    * @example
    * - `0` will return `http://petstore.swagger.io/api`
    * - `1` will return `http://localhost:3000`
-   * @default 0
    */
   serverIndex?: number
   /**
    * Define which contentType should be used.
-   * By default, this is set based on the first used contentType..
+   * By default, this is set based on the contentType being found.
    */
   contentType?: contentType
-  experimentalFilter?: FormatOptions['filterSet']
-  experimentalSort?: FormatOptions['sortSet']
+  /**
+   * Override some behaviour of the Oas class instance, see '@kubb/oas'
+   */
   oasClass?: typeof Oas
+  /**
+   * Define some generators next to the JSON generation
+   */
+  generators?: Array<Generator<PluginOas>>
 }
 
 /**
  * `propertyName` is the ref name + resolved with the nameResolver
- *  @example `import { Pet } from './Pet'`
+ *  @example import { Pet } from './Pet'
  *
  * `originalName` is the original name used(in PascalCase), only used to remove duplicates
  *
  * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
- * @example import a type(swagger-ts) for a mock file(swagger-faker)
+ * @example import a type(plugin-ts) for a mock file(swagger-faker)
  */
-
 export type Ref = {
   propertyName: string
   originalName: string
@@ -90,7 +88,7 @@ export type OperationSchema = {
   /**
    * OperationName in PascalCase, only being used in OperationGenerator
    */
-  operationName?: string
+  operationName: string
   description?: string
   statusCode?: number
   keys?: string[]
@@ -104,6 +102,7 @@ export type OperationSchemas = {
   headerParams?: OperationSchema & { keysToOmit?: never }
   request?: OperationSchema
   response: OperationSchema
+  responses: Array<OperationSchema>
   statusCodes?: Array<OperationSchema>
   errors?: Array<OperationSchema>
 }
@@ -128,6 +127,11 @@ type ByMethod = {
   type: 'method'
   pattern: HttpMethod | RegExp
 }
+// TODO implement as alternative for ByMethod
+type ByMethods = {
+  type: 'methods'
+  pattern: Array<HttpMethod>
+}
 
 type BySchemaName = {
   type: 'schemaName'
@@ -141,10 +145,8 @@ export type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | By
   options: Partial<TOptions>
 }
 
-export type PluginOas = PluginFactoryOptions<'plugin-oas', Options, Options, API, never>
-
-declare module '@kubb/core' {
-  export interface _Register {
-    ['@kubb/plugin-oas']: PluginOas
-  }
+type ResolvedOptions = Options & {
+  output: Output
 }
+
+export type PluginOas = PluginFactoryOptions<'plugin-oas', Options, ResolvedOptions, API, never>

package/src/utils/getParams.ts

@@ -1,10 +1,10 @@
 import { isParameterObject } from '@kubb/oas'
 
+import { camelCase } from '@kubb/core/transformers'
 import type { FunctionParamsAST } from '@kubb/core/utils'
 import type { OasTypes } from '@kubb/oas'
-import type { Params } from '@kubb/react'
+import type { Params } from '@kubb/react/types'
 import type { OperationSchema } from '../types.ts'
-import { camelCase } from '@kubb/core/transformers'
 /**
  *
  * @deprecated

package/src/utils/getSchemaFactory.ts

@@ -26,7 +26,7 @@ export function getSchemaFactory<TWithRef extends boolean = false>(oas: Oas): (s
     const version = isOpenApiV3_1Document(oas.api) ? '3.1' : '3.0'
 
     return {
-      schema,
+      schema: oas.dereferenceWithRef(schema),
       version,
     } as SchemaResult<TWithRef>
   }

package/src/utils/index.ts

@@ -1,8 +1,8 @@
 export { getComments } from './getComments.ts'
-export { getGroupedByTagFiles } from './getGroupedByTagFiles.ts'
 export { getASTParams, getPathParams } from './getParams.ts'
 export { getSchemaFactory } from './getSchemaFactory.ts'
 export type { GetSchemasProps } from './getSchemas.ts'
 export { getSchemas } from './getSchemas.ts'
-export { refsSorter } from './refSorter.ts'
 export { parseFromConfig } from './parseFromConfig.ts'
+
+export { isOptional } from '@kubb/oas'

package/src/utils/parseFromConfig.ts

@@ -2,35 +2,35 @@ import { resolve } from 'node:path'
 
 import { URLPath } from '@kubb/core/utils'
 
-import { type FormatOptions, parse } from '@kubb/oas/parser'
+import { parse } from '@kubb/oas/parser'
 
 import type { Config } from '@kubb/core'
 import { Oas, type OasTypes } from '@kubb/oas'
 import yaml from '@stoplight/yaml'
 
-export function parseFromConfig(config: Config, options: FormatOptions = {}, oasClass: typeof Oas = Oas): Promise<Oas> {
+export function parseFromConfig(config: Config, oasClass: typeof Oas = Oas): Promise<Oas> {
   if ('data' in config.input) {
     if (typeof config.input.data === 'object') {
       const api: OasTypes.OASDocument = JSON.parse(JSON.stringify(config.input.data)) as OasTypes.OASDocument
-      return parse(api, options, oasClass)
+      return parse(api, oasClass)
     }
 
     try {
       const api: string = yaml.parse(config.input.data as string) as string
 
-      return parse(api, options, oasClass)
+      return parse(api, oasClass)
     } catch (e) {
       /* empty */
     }
 
     const api: OasTypes.OASDocument = JSON.parse(JSON.stringify(config.input.data)) as OasTypes.OASDocument
 
-    return parse(api, options, oasClass)
+    return parse(api, oasClass)
   }
 
   if (new URLPath(config.input.path).isURL) {
-    return parse(config.input.path, options, oasClass)
+    return parse(config.input.path, oasClass)
   }
 
-  return parse(resolve(config.root, config.input.path), options, oasClass)
+  return parse(resolve(config.root, config.input.path), oasClass)
 }

package/dist/OperationGenerator-BV6QRtkW.d.cts

@@ -1,60 +0,0 @@
-import { FileMetaBase, PluginFactoryOptions, Generator, PluginManager, Plugin } from '@kubb/core';
-import * as KubbFile from '@kubb/fs/types';
-import { Operation, Oas, contentType } from '@kubb/oas';
-import { g as OperationsByMethod, f as OperationSchemas, E as Exclude, I as Include, b as Override } from './types-Db0qp8u-.cjs';
-
-type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never;
-type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
-type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
-    oas: Oas;
-    exclude: Array<Exclude> | undefined;
-    include: Array<Include> | undefined;
-    override: Array<Override<TOptions>> | undefined;
-    contentType: contentType | undefined;
-    pluginManager: PluginManager;
-    /**
-     * Current plugin
-     */
-    plugin: Plugin<TPluginOptions>;
-    mode: KubbFile.Mode;
-};
-declare abstract class OperationGenerator<TOptions = unknown, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
-    #private;
-    get operationsByMethod(): OperationsByMethod;
-    set operationsByMethod(paths: OperationsByMethod);
-    getSchemas(operation: Operation, { forStatusCode, resolveName }?: {
-        forStatusCode?: string | number;
-        resolveName?: (name: string) => string;
-    }): OperationSchemas;
-    build(): Promise<Array<KubbFile.File<TFileMeta>>>;
-    /**
-     * Operation
-     */
-    operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * GET
-     */
-    get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * POST
-     */
-    post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * PATCH
-     */
-    patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * PUT
-     */
-    put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * DELETE
-     */
-    delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * Combination of GET, POST, PATCH, PUT, DELETE
-     */
-    all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>;
-}
-
-export { type GetOperationGeneratorOptions as G, type OperationMethodResult as O, OperationGenerator as a };

package/dist/OperationGenerator-DO5tNGuT.d.ts

@@ -1,60 +0,0 @@
-import { FileMetaBase, PluginFactoryOptions, Generator, PluginManager, Plugin } from '@kubb/core';
-import * as KubbFile from '@kubb/fs/types';
-import { Operation, Oas, contentType } from '@kubb/oas';
-import { g as OperationsByMethod, f as OperationSchemas, E as Exclude, I as Include, b as Override } from './types-Db0qp8u-.js';
-
-type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never;
-type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
-type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
-    oas: Oas;
-    exclude: Array<Exclude> | undefined;
-    include: Array<Include> | undefined;
-    override: Array<Override<TOptions>> | undefined;
-    contentType: contentType | undefined;
-    pluginManager: PluginManager;
-    /**
-     * Current plugin
-     */
-    plugin: Plugin<TPluginOptions>;
-    mode: KubbFile.Mode;
-};
-declare abstract class OperationGenerator<TOptions = unknown, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
-    #private;
-    get operationsByMethod(): OperationsByMethod;
-    set operationsByMethod(paths: OperationsByMethod);
-    getSchemas(operation: Operation, { forStatusCode, resolveName }?: {
-        forStatusCode?: string | number;
-        resolveName?: (name: string) => string;
-    }): OperationSchemas;
-    build(): Promise<Array<KubbFile.File<TFileMeta>>>;
-    /**
-     * Operation
-     */
-    operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * GET
-     */
-    get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * POST
-     */
-    post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * PATCH
-     */
-    patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * PUT
-     */
-    put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * DELETE
-     */
-    delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * Combination of GET, POST, PATCH, PUT, DELETE
-     */
-    all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>;
-}
-
-export { type GetOperationGeneratorOptions as G, type OperationMethodResult as O, OperationGenerator as a };

package/dist/Schema-DefwBJMc.d.ts

@@ -1,35 +0,0 @@
-import * as react from 'react';
-import { ReactNode } from 'react';
-import * as KubbFile from '@kubb/fs/types';
-import { SchemaObject } from '@kubb/oas';
-import { KubbNode } from '@kubb/react';
-import { S as Schema$1 } from './SchemaMapper-CsBQ6eEx.js';
-
-type SchemaContextProps = {
-    name: string;
-    schema?: SchemaObject;
-    tree: Array<Schema$1>;
-};
-type Props = {
-    name: string;
-    value?: SchemaObject;
-    tree?: Array<Schema$1>;
-    children?: KubbNode;
-};
-declare function Schema({ name, value, tree, children }: Props): KubbNode;
-declare namespace Schema {
-    var File: ({ output, isTypeOnly, children }: FileProps) => ReactNode;
-    var Imports: ({ isTypeOnly, extName }: SchemaImportsProps) => ReactNode;
-    var Context: react.Context<SchemaContextProps>;
-}
-type FileProps = {
-    isTypeOnly?: boolean;
-    output: string | undefined;
-    children?: KubbNode;
-};
-type SchemaImportsProps = {
-    isTypeOnly?: boolean;
-    extName?: KubbFile.Extname;
-};
-
-export { Schema as S, type SchemaContextProps as a };

package/dist/Schema-an5hOrjZ.d.cts

@@ -1,35 +0,0 @@
-import * as react from 'react';
-import { ReactNode } from 'react';
-import * as KubbFile from '@kubb/fs/types';
-import { SchemaObject } from '@kubb/oas';
-import { KubbNode } from '@kubb/react';
-import { S as Schema$1 } from './SchemaMapper-CsBQ6eEx.cjs';
-
-type SchemaContextProps = {
-    name: string;
-    schema?: SchemaObject;
-    tree: Array<Schema$1>;
-};
-type Props = {
-    name: string;
-    value?: SchemaObject;
-    tree?: Array<Schema$1>;
-    children?: KubbNode;
-};
-declare function Schema({ name, value, tree, children }: Props): KubbNode;
-declare namespace Schema {
-    var File: ({ output, isTypeOnly, children }: FileProps) => ReactNode;
-    var Imports: ({ isTypeOnly, extName }: SchemaImportsProps) => ReactNode;
-    var Context: react.Context<SchemaContextProps>;
-}
-type FileProps = {
-    isTypeOnly?: boolean;
-    output: string | undefined;
-    children?: KubbNode;
-};
-type SchemaImportsProps = {
-    isTypeOnly?: boolean;
-    extName?: KubbFile.Extname;
-};
-
-export { Schema as S, type SchemaContextProps as a };