@kubb/plugin-oas 0.0.0-canary-20240509211223

package/src/SchemaMapper.ts

@@ -0,0 +1,145 @@
+import type { KubbFile } from '@kubb/core'
+
+export type SchemaKeywordMapper = {
+  object: {
+    keyword: 'object'
+    args: {
+      properties: { [x: string]: Schema[] }
+      additionalProperties: Schema[]
+      strict?: boolean
+    }
+  }
+  strict: { keyword: 'strict' }
+  url: { keyword: 'url' }
+  readOnly: { keyword: 'readOnly' }
+  uuid: { keyword: 'uuid' }
+  email: { keyword: 'email' }
+  firstName: { keyword: 'firstName' }
+  lastName: { keyword: 'lastName' }
+  phone: { keyword: 'phone' }
+  password: { keyword: 'password' }
+  date: { keyword: 'date'; args: { type?: 'date' | 'string' } }
+  time: { keyword: 'time'; args: { type?: 'date' | 'string' } }
+  datetime: { keyword: 'datetime'; args: { offset?: boolean; local?: boolean } }
+  tuple: { keyword: 'tuple'; args: Schema[] }
+  array: {
+    keyword: 'array'
+    args: { items: Schema[]; min?: number; max?: number }
+  }
+  enum: {
+    keyword: 'enum'
+    args: {
+      name: string
+      typeName: string
+      asConst: boolean
+      items: Array<{
+        name: string | number
+        format: 'string' | 'number'
+        value?: string | number
+      }>
+    }
+  }
+  and: { keyword: 'and'; args: Schema[] }
+  const: {
+    keyword: 'const'
+    args: {
+      name: string | number
+      format: 'string' | 'number'
+      value?: string | number
+    }
+  }
+  union: { keyword: 'union'; args: Schema[] }
+  ref: {
+    keyword: 'ref'
+    args: { name: string; path: KubbFile.OptionalPath; isTypeOnly?: boolean }
+  }
+  matches: { keyword: 'matches'; args?: string }
+  boolean: { keyword: 'boolean' }
+  default: { keyword: 'default'; args: string | number | boolean }
+  string: { keyword: 'string' }
+  integer: { keyword: 'integer' }
+  number: { keyword: 'number' }
+  max: { keyword: 'max'; args: number }
+  min: { keyword: 'min'; args: number }
+  describe: { keyword: 'describe'; args: string }
+  example: { keyword: 'example'; args: string }
+  deprecated: { keyword: 'deprecated' }
+  optional: { keyword: 'optional' }
+  undefined: { keyword: 'undefined' }
+  nullish: { keyword: 'nullish' }
+  nullable: { keyword: 'nullable' }
+  null: { keyword: 'null' }
+  any: { keyword: 'any' }
+  unknown: { keyword: 'unknown' }
+  blob: { keyword: 'blob' }
+  schema: { keyword: 'schema'; args: { type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object'; format?: string } }
+  name: { keyword: 'name'; args: string }
+  catchall: { keyword: 'catchall' }
+}
+
+export const schemaKeywords = {
+  any: 'any',
+  strict: 'strict',
+  unknown: 'unknown',
+  number: 'number',
+  integer: 'integer',
+  string: 'string',
+  boolean: 'boolean',
+  undefined: 'undefined',
+  nullable: 'nullable',
+  null: 'null',
+  nullish: 'nullish',
+  array: 'array',
+  tuple: 'tuple',
+  enum: 'enum',
+  union: 'union',
+  datetime: 'datetime',
+  date: 'date',
+  email: 'email',
+  uuid: 'uuid',
+  url: 'url',
+  /* intersection */
+  default: 'default',
+  const: 'const',
+  and: 'and',
+  describe: 'describe',
+  min: 'min',
+  max: 'max',
+  optional: 'optional',
+  readOnly: 'readOnly',
+
+  // custom ones
+  object: 'object',
+  ref: 'ref',
+  matches: 'matches',
+  firstName: 'firstName',
+  lastName: 'lastName',
+  password: 'password',
+  phone: 'phone',
+  blob: 'blob',
+  deprecated: 'deprecated',
+  example: 'example',
+  schema: 'schema',
+  catchall: 'catchall',
+  time: 'time',
+  name: 'name',
+} satisfies {
+  [K in keyof SchemaKeywordMapper]: SchemaKeywordMapper[K]['keyword']
+}
+
+export type SchemaKeyword = keyof SchemaKeywordMapper
+
+export type SchemaMapper<T = string | null | undefined> = {
+  [K in keyof SchemaKeywordMapper]: (() => T | undefined) | undefined
+}
+
+export type SchemaKeywordBase<T> = {
+  keyword: SchemaKeyword
+  args: T
+}
+
+export type Schema = { keyword: string } | SchemaKeywordMapper[keyof SchemaKeywordMapper]
+
+export function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]> {
+  return meta.keyword === keyword
+}

package/src/components/Oas.tsx

@@ -0,0 +1,31 @@
+import { createContext } from '@kubb/react'
+
+import { Operation } from './Operation.tsx'
+import { Schema } from './Schema.tsx'
+
+import type { Oas as OasType, Operation as OperationType } from '@kubb/oas'
+import type { KubbNode } from '@kubb/react'
+import type { OperationGenerator } from '../OperationGenerator.ts'
+
+type Props = {
+  oas: OasType
+  operations?: OperationType[]
+  generator?: OperationGenerator
+  children?: KubbNode
+}
+
+type OasContextProps = {
+  oas?: OasType
+  operations?: OperationType[]
+  generator?: OperationGenerator
+}
+
+const OasContext = createContext<OasContextProps>({})
+
+export function Oas({ oas, children, operations, generator }: Props): KubbNode {
+  return <OasContext.Provider value={{ oas, generator, operations }}>{children}</OasContext.Provider>
+}
+
+Oas.Context = OasContext
+Oas.Operation = Operation
+Oas.Schema = Schema

package/src/components/Operation.tsx

@@ -0,0 +1,21 @@
+import { createContext } from '@kubb/react'
+
+import type { Operation as OperationType } from '@kubb/oas'
+import type { KubbNode } from '@kubb/react'
+
+type Props = {
+  operation: OperationType
+  children?: KubbNode
+}
+
+type OperationContextProps = {
+  operation?: OperationType
+}
+
+const OperationContext = createContext<OperationContextProps>({})
+
+export function Operation({ operation, children }: Props): KubbNode {
+  return <OperationContext.Provider value={{ operation }}>{children}</OperationContext.Provider>
+}
+
+Operation.Context = OperationContext

package/src/components/Schema.tsx

@@ -0,0 +1,156 @@
+import { Parser, File, createContext, useApp, useFile } from '@kubb/react'
+
+import { schemaKeywords } from '../SchemaMapper.ts'
+import { useSchema } from '../hooks/useSchema.ts'
+
+import type { KubbFile } from '@kubb/core'
+import type { SchemaObject } from '@kubb/oas'
+import type { KubbNode } from '@kubb/react'
+import type { ReactNode } from 'react'
+import type { SchemaGenerator, SchemaGeneratorBuildOptions } from '../SchemaGenerator.ts'
+import type { Schema as SchemaType } from '../SchemaMapper.ts'
+import type { PluginOas } from '../types.ts'
+
+export type SchemaContextProps = {
+  name: string
+  object?: SchemaObject
+  generator?: SchemaGenerator
+  schemas: SchemaType[]
+}
+
+type Props = {
+  name: string
+  object?: SchemaObject
+  generator: SchemaGenerator<any, any, any>
+  children?: KubbNode
+}
+
+const SchemaContext = createContext<SchemaContextProps>({
+  name: 'unknown',
+  schemas: [],
+})
+
+export function Schema({ name, object, generator, children }: Props): KubbNode {
+  const schemas = generator.buildSchemas({ schema: object, name })
+
+  return <SchemaContext.Provider value={{ name, schemas, object, generator }}>{children}</SchemaContext.Provider>
+}
+
+type FileProps = {
+  isTypeOnly?: boolean
+  output: string | undefined
+  children?: KubbNode
+}
+
+Schema.File = function ({ output, isTypeOnly, children }: FileProps): ReactNode {
+  const { plugin, pluginManager, mode } = useApp<PluginOas>()
+  const { name } = useSchema()
+
+  if (mode === 'single') {
+    const baseName = output as KubbFile.BaseName
+    const resolvedPath = pluginManager.resolvePath({
+      baseName: '',
+      pluginKey: plugin.key,
+    })
+
+    if (!resolvedPath) {
+      return null
+    }
+
+    return (
+      <Parser language="typescript">
+        <File
+          baseName={baseName}
+          path={resolvedPath}
+          meta={{
+            pluginKey: plugin.key,
+          }}
+        >
+          <File.Source>
+            <Schema.Source />
+          </File.Source>
+          {children}
+        </File>
+      </Parser>
+    )
+  }
+
+  const baseName = `${pluginManager.resolveName({
+    name,
+    pluginKey: plugin.key,
+    type: 'file',
+  })}.ts` as const
+  const resolvedPath = pluginManager.resolvePath({
+    baseName,
+    pluginKey: plugin.key,
+  })
+
+  if (!resolvedPath) {
+    return null
+  }
+
+  return (
+    <Parser language="typescript">
+      <File
+        baseName={baseName}
+        path={resolvedPath}
+        meta={{
+          pluginKey: plugin.key,
+        }}
+      >
+        <Schema.Imports isTypeOnly={isTypeOnly} />
+        <File.Source>
+          <Schema.Source />
+        </File.Source>
+        {children}
+      </File>
+    </Parser>
+  )
+}
+
+type SchemaImportsProps = {
+  isTypeOnly?: boolean
+}
+
+Schema.Imports = ({ isTypeOnly }: SchemaImportsProps): ReactNode => {
+  const { generator, schemas } = useSchema()
+  const { path: root } = useFile()
+
+  const refs = generator.deepSearch(schemas, schemaKeywords.ref)
+
+  return (
+    <>
+      {refs
+        ?.map((item, i) => {
+          if (!item.args.path) {
+            return undefined
+          }
+
+          return <File.Import key={i} root={root} name={[item.args.name]} path={item.args.path} isTypeOnly={item.args.isTypeOnly ?? isTypeOnly} />
+        })
+        .filter(Boolean)}
+    </>
+  )
+}
+
+type SchemaSourceProps<TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions> = {
+  extraSchemas?: SchemaType[]
+  options?: TOptions
+}
+
+Schema.Source = <TOptions extends SchemaGeneratorBuildOptions = SchemaGeneratorBuildOptions>({
+  options,
+  extraSchemas = [],
+}: SchemaSourceProps<TOptions>): ReactNode => {
+  const { name, generator, schemas } = useSchema()
+
+  const source = generator.getSource(name, [...schemas, ...extraSchemas], options as SchemaGeneratorBuildOptions)
+
+  return (
+    <>
+      {source}
+      <br />
+    </>
+  )
+}
+Schema.Context = SchemaContext

package/src/components/index.ts

@@ -0,0 +1,3 @@
+export { Oas } from './Oas.tsx'
+export { Operation } from './Operation.tsx'
+export { Schema } from './Schema.tsx'

package/src/hooks/index.ts

@@ -0,0 +1,5 @@
+export { useOas } from './useOas.ts'
+export { useOperation } from './useOperation.ts'
+export { useOperationManager } from './useOperationManager.ts'
+export { useOperations } from './useOperations.ts'
+export { useSchema } from './useSchema.ts'

package/src/hooks/useOas.ts

@@ -0,0 +1,15 @@
+import { useContext } from '@kubb/react'
+
+import { Oas } from '../components/Oas.tsx'
+
+import type { Oas as OasType } from '@kubb/oas'
+
+export function useOas(): OasType {
+  const { oas } = useContext(Oas.Context)
+
+  if (!oas) {
+    throw new Error('Oas is not defined')
+  }
+
+  return oas
+}

package/src/hooks/useOperation.ts

@@ -0,0 +1,18 @@
+import { useContext } from '@kubb/react'
+
+import { Operation } from '../components/Operation.tsx'
+
+import type { Operation as OperationType } from '@kubb/oas'
+
+/**
+ * `useOperation` will return the current `Operation`
+ */
+export function useOperation(): OperationType {
+  const { operation } = useContext(Operation.Context)
+
+  if (!operation) {
+    throw new Error('Operation is not defined')
+  }
+
+  return operation
+}

package/src/hooks/useOperationManager.ts

@@ -0,0 +1,142 @@
+import { useApp, useContext } from '@kubb/react'
+
+import { Oas } from '../components/Oas.tsx'
+
+import type { KubbFile, Plugin, ResolveNameParams } from '@kubb/core'
+import type { Operation, Operation as OperationType } from '@kubb/oas'
+import type { OperationSchemas } from '../types.ts'
+
+type FileMeta = KubbFile.FileMetaBase & {
+  pluginKey: Plugin['key']
+  name: string
+  tag?: string
+}
+
+type SchemaNames = {
+  request: string | undefined
+  parameters: {
+    path: string | undefined
+    query: string | undefined
+    header: string | undefined
+  }
+  responses: Record<number, string>
+}
+
+type UseOperationManagerResult = {
+  getName: (operation: OperationType, params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => string
+  getFile: (operation: OperationType, params?: { pluginKey?: Plugin['key']; extName?: KubbFile.Extname }) => KubbFile.File<FileMeta>
+  groupSchemasByByName: (operation: OperationType, params: { pluginKey?: Plugin['key']; type: ResolveNameParams['type'] }) => SchemaNames
+  getSchemas: (operation: Operation, forStatusCode?: string | number) => OperationSchemas
+}
+
+/**
+ * `useOperationManager` will return some helper functions that can be used to get the operation file, get the operation name.
+ */
+export function useOperationManager(): UseOperationManagerResult {
+  const { plugin, pluginManager } = useApp()
+  const { generator } = useContext(Oas.Context)
+
+  if (!generator) {
+    throw new Error(`'generator' is not defined`)
+  }
+
+  const getName: UseOperationManagerResult['getName'] = (operation, { pluginKey = plugin.key, type }) => {
+    return pluginManager.resolveName({
+      name: operation.getOperationId(),
+      pluginKey,
+      type,
+    })
+  }
+
+  const getFile: UseOperationManagerResult['getFile'] = (operation, { pluginKey = plugin.key, extName = '.ts' } = {}) => {
+    // needed for the `output.group`
+    const tag = operation.getTags().at(0)?.name
+    const name = getName(operation, { type: 'file', pluginKey })
+
+    const file = pluginManager.getFile({
+      name,
+      extName,
+      pluginKey,
+      options: { type: 'file', pluginKey, tag },
+    })
+
+    return {
+      ...file,
+      meta: {
+        ...file.meta,
+        name,
+        pluginKey,
+        tag,
+      },
+    }
+  }
+
+  const groupSchemasByByName: UseOperationManagerResult['groupSchemasByByName'] = (operation, { pluginKey = plugin.key, type }) => {
+    const schemas = generator.getSchemas(operation)
+
+    const errors = (schemas.errors || []).reduce(
+      (prev, acc) => {
+        if (!acc.statusCode) {
+          return prev
+        }
+
+        prev[acc.statusCode] = pluginManager.resolveName({
+          name: acc.name,
+          pluginKey: plugin.key,
+          type,
+        })
+
+        return prev
+      },
+      {} as Record<number, string>,
+    )
+
+    return {
+      request: schemas.request?.name
+        ? pluginManager.resolveName({
+            name: schemas.request.name,
+            pluginKey,
+            type,
+          })
+        : undefined,
+      parameters: {
+        path: schemas.pathParams?.name
+          ? pluginManager.resolveName({
+              name: schemas.pathParams.name,
+              pluginKey,
+              type,
+            })
+          : undefined,
+        query: schemas.queryParams?.name
+          ? pluginManager.resolveName({
+              name: schemas.queryParams.name,
+              pluginKey,
+              type,
+            })
+          : undefined,
+        header: schemas.headerParams?.name
+          ? pluginManager.resolveName({
+              name: schemas.headerParams.name,
+              pluginKey,
+              type,
+            })
+          : undefined,
+      },
+      responses: {
+        [schemas.response.statusCode || 'default']: pluginManager.resolveName({
+          name: schemas.response.name,
+          pluginKey,
+          type,
+        }),
+        ...errors,
+      },
+    }
+  }
+
+  return {
+    getName,
+    getFile,
+    getSchemas: (operation, forStatusCode) => generator.getSchemas(operation, forStatusCode),
+    groupSchemasByByName,
+  }
+}

package/src/hooks/useOperations.ts

@@ -0,0 +1,40 @@
+import { useContext } from '@kubb/react'
+
+import { Oas } from '../components/Oas.tsx'
+
+import type { HttpMethod, Operation } from '@kubb/oas'
+
+type UseOperationsProps = {
+  /**
+   * Filter based on path
+   * Weight: 2
+   */
+  path?: string
+  /**
+   * Filter based on method
+   * Weight: 1
+   */
+  method?: HttpMethod
+}
+
+/**
+ * `useOperations` will return all the Operations
+ */
+export function useOperations({ method, path }: UseOperationsProps = {}): Operation[] {
+  const { operations } = useContext(Oas.Context)
+
+  if (!operations) {
+    throw new Error('Operations is not defined')
+  }
+  let items = operations
+
+  if (path) {
+    items = items.filter((item) => item.path === path)
+  }
+
+  if (method) {
+    items = items.filter((item) => item.method === method)
+  }
+
+  return items
+}

package/src/hooks/useSchema.ts

@@ -0,0 +1,23 @@
+import { useContext } from '@kubb/react'
+
+import { Schema } from '../components/Schema.tsx'
+
+import type { SchemaContextProps } from '../components/Schema.tsx'
+import type { SchemaGenerator } from '../SchemaGenerator.ts'
+
+type UseSchemaResult = Omit<SchemaContextProps, 'generator'> & {
+  generator: SchemaGenerator
+}
+
+/**
+ * `useSchema` will return the current `schema properties`
+ */
+export function useSchema(): UseSchemaResult {
+  const props = useContext(Schema.Context)
+
+  if (!props.generator) {
+    throw new Error('Generator is not defined')
+  }
+
+  return props as UseSchemaResult
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+import { pluginOas } from './plugin.ts'
+
+export type {
+  GetOperationGeneratorOptions,
+  OperationMethodResult,
+} from './OperationGenerator.ts'
+export { OperationGenerator } from './OperationGenerator.ts'
+export { pluginOas, pluginOasName } from './plugin.ts'
+export type {
+  SchemaGeneratorBuildOptions,
+  SchemaGeneratorOptions,
+} from './SchemaGenerator.ts'
+export type { SchemaMethodResult } from './SchemaGenerator.ts'
+export { SchemaGenerator } from './SchemaGenerator.ts'
+export type {
+  Schema,
+  SchemaKeyword,
+  SchemaKeywordBase,
+  SchemaKeywordMapper,
+  SchemaMapper,
+} from './SchemaMapper.ts'
+export { isKeyword, schemaKeywords } from './SchemaMapper.ts'
+export type * from './types.ts'
+
+/**
+ * @deprecated Use `import { pluginOas } from '@kubb/plugin-oas'` instead
+ */
+const definePluginDefault = pluginOas
+
+export default definePluginDefault