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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-oas",
-  "version": "0.0.0-canary-20240806053140",
+  "version": "0.0.0-canary-20241106205013",
   "description": "Generator swagger",
   "keywords": [
     "typescript",
@@ -25,6 +25,11 @@
       "require": "./dist/index.cjs",
       "default": "./dist/index.cjs"
     },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs",
+      "default": "./dist/generators.cjs"
+    },
     "./utils": {
       "import": "./dist/utils.js",
       "require": "./dist/utils.cjs",
@@ -56,6 +61,9 @@
       ],
       "components": [
         "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
       ]
     }
   },
@@ -67,27 +75,25 @@
   ],
   "dependencies": {
     "@stoplight/yaml": "^4.3.0",
-    "remeda": "^2.7.1",
-    "@kubb/core": "0.0.0-canary-20240806053140",
-    "@kubb/fs": "0.0.0-canary-20240806053140",
-    "@kubb/oas": "0.0.0-canary-20240806053140",
-    "@kubb/react": "0.0.0-canary-20240806053140"
+    "remeda": "^2.16.0",
+    "@kubb/core": "0.0.0-canary-20241106205013",
+    "@kubb/fs": "0.0.0-canary-20241106205013",
+    "@kubb/oas": "0.0.0-canary-20241106205013",
+    "@kubb/react": "0.0.0-canary-20241106205013"
   },
   "devDependencies": {
-    "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0",
+    "@types/react": "^18.3.12",
     "react": "^18.3.1",
-    "tsup": "^8.2.4",
-    "typescript": "^5.5.4",
-    "@kubb/config-biome": "0.0.0-canary-20240806053140",
-    "@kubb/config-ts": "0.0.0-canary-20240806053140",
-    "@kubb/config-tsup": "0.0.0-canary-20240806053140"
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "@kubb/config-ts": "0.0.0-canary-20241106205013",
+    "@kubb/config-tsup": "0.0.0-canary-20241106205013"
   },
   "peerDependencies": {
-    "@kubb/react": "0.0.0-canary-20240806053140"
+    "@kubb/react": "0.0.0-canary-20241106205013"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "publishConfig": {
     "access": "public",

package/src/OperationGenerator.ts

@@ -1,15 +1,14 @@
-import { type FileMetaBase, Generator } from '@kubb/core'
+import { BaseGenerator, type FileMetaBase } from '@kubb/core'
 import transformers from '@kubb/core/transformers'
 
 import type { PluginFactoryOptions, PluginManager } from '@kubb/core'
 import type * as KubbFile from '@kubb/fs/types'
 
 import type { Plugin } from '@kubb/core'
-import type { HttpMethod, Oas, OasTypes, Operation, contentType } from '@kubb/oas'
+import type { HttpMethod, Oas, OasTypes, Operation, SchemaObject, contentType } from '@kubb/oas'
+import type { Generator } from './generator.tsx'
 import type { Exclude, Include, OperationSchemas, OperationsByMethod, Override } from './types.ts'
 
-export type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never
-
 export type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>
 
 type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
@@ -26,11 +25,10 @@ type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
   mode: KubbFile.Mode
 }
 
-export abstract class OperationGenerator<
-  TOptions = unknown,
+export class OperationGenerator<
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
-> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context<TPluginOptions['resolvedOptions'], TPluginOptions>> {
   #operationsByMethod: OperationsByMethod = {}
   get operationsByMethod(): OperationsByMethod {
     return this.#operationsByMethod
@@ -40,7 +38,7 @@ export abstract class OperationGenerator<
     this.#operationsByMethod = paths
   }
 
-  #getOptions(operation: Operation, method: HttpMethod): Partial<TOptions> {
+  #getOptions(operation: Operation, method: HttpMethod): Partial<TPluginOptions['resolvedOptions']> {
     const { override = [] } = this.context
 
     return (
@@ -65,10 +63,7 @@ export abstract class OperationGenerator<
       })?.options || {}
     )
   }
-  /**
-   *
-   * @deprecated
-   */
+
   #isExcluded(operation: Operation, method: HttpMethod): boolean {
     const { exclude = [] } = this.context
     let matched = false
@@ -93,10 +88,7 @@ export abstract class OperationGenerator<
 
     return matched
   }
-  /**
-   *
-   * @deprecated
-   */
+
   #isIncluded(operation: Operation, method: HttpMethod): boolean {
     const { include = [] } = this.context
     let matched = false
@@ -124,15 +116,16 @@ export abstract class OperationGenerator<
 
   getSchemas(
     operation: Operation,
-    { forStatusCode, resolveName = (name) => name }: { forStatusCode?: string | number; resolveName?: (name: string) => string } = {},
+    {
+      resolveName = (name) => name,
+    }: {
+      resolveName?: (name: string) => string
+    } = {},
   ): OperationSchemas {
     const pathParamsSchema = this.context.oas.getParametersSchema(operation, 'path')
     const queryParamsSchema = this.context.oas.getParametersSchema(operation, 'query')
     const headerParamsSchema = this.context.oas.getParametersSchema(operation, 'header')
     const requestSchema = this.context.oas.getRequestSchema(operation)
-    const responseStatusCode =
-      forStatusCode || (operation.schema.responses && Object.keys(operation.schema.responses).find((key) => key.startsWith('2'))) || 200
-    const responseSchema = this.context.oas.getResponseSchema(operation, responseStatusCode)
     const statusCodes = operation.getResponseStatusCodes().map((statusCode) => {
       let name = statusCode
       if (name === 'default') {
@@ -149,8 +142,15 @@ export abstract class OperationGenerator<
         operationName: transformers.pascalCase(`${operation.getOperationId()}`),
         statusCode: name === 'error' ? undefined : Number(statusCode),
         keys: schema?.properties ? Object.keys(schema.properties) : undefined,
+        keysToOmit: schema?.properties
+          ? Object.keys(schema.properties).filter((key) => {
+              const item = schema.properties?.[key] as OasTypes.SchemaObject
+              return item?.writeOnly
+            })
+          : undefined,
       }
     })
+    const hasResponses = statusCodes.some((item) => item.statusCode?.toString().startsWith('2'))
 
     return {
       pathParams: pathParamsSchema
@@ -199,38 +199,30 @@ export abstract class OperationGenerator<
         : undefined,
       response: {
         name: resolveName(transformers.pascalCase(`${operation.getOperationId()} ${operation.method === 'get' ? 'queryResponse' : 'mutationResponse'}`)),
-        description: operation.getResponseAsJSONSchema(responseStatusCode)?.at(0)?.description,
         operation,
         operationName: transformers.pascalCase(`${operation.getOperationId()}`),
-        schema: responseSchema,
-        statusCode: Number(responseStatusCode),
-        keys: responseSchema?.properties ? Object.keys(responseSchema.properties) : undefined,
-        keysToOmit: responseSchema?.properties
-          ? Object.keys(responseSchema.properties).filter((key) => {
-              const item = responseSchema.properties?.[key] as OasTypes.SchemaObject
-              return item?.writeOnly
-            })
-          : undefined,
+        schema: {
+          oneOf: hasResponses
+            ? statusCodes
+                .filter((item) => item.statusCode?.toString().startsWith('2'))
+                .map((item) => {
+                  return {
+                    ...item.schema,
+                    $ref: resolveName(transformers.pascalCase(`${operation.getOperationId()} ${item.statusCode}`)),
+                  }
+                })
+            : undefined,
+        } as SchemaObject,
       },
+      responses: statusCodes.filter((item) => item.statusCode?.toString().startsWith('2')),
       errors: statusCodes.filter((item) => item.statusCode?.toString().startsWith('4') || item.statusCode?.toString().startsWith('5')),
       statusCodes,
     }
   }
 
-  get #methods() {
-    return {
-      get: this.get,
-      post: this.post,
-      patch: this.patch,
-      put: this.put,
-      delete: this.delete,
-      head: undefined,
-      options: undefined,
-      trace: undefined,
-    } as const
-  }
+  #methods = ['get', 'post', 'patch', 'put', 'delete']
 
-  async build(): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas } = this.context
 
     const paths = oas.getPaths()
@@ -239,7 +231,7 @@ export abstract class OperationGenerator<
 
       methods.forEach((method) => {
         const operation = oas.operation(path, method)
-        if (operation && this.#methods[method]) {
+        if (operation && [this.#methods].some((methods) => method === operation.method)) {
           const isExcluded = this.#isExcluded(operation, method)
           const isIncluded = this.context.include ? this.#isIncluded(operation, method) : true
 
@@ -267,21 +259,43 @@ export abstract class OperationGenerator<
       methods.forEach((method) => {
         const { operation } = this.operationsByMethod[path]?.[method]!
         const options = this.#getOptions(operation, method)
-        const promiseMethod = this.#methods[method]?.call(this, operation, {
-          ...this.options,
-          ...options,
-        })
+
+        const methodToCall = this[method as keyof typeof this] as any
+
+        if (typeof methodToCall === 'function') {
+          const promiseMethod = methodToCall?.call(this, operation, {
+            ...this.options,
+            ...options,
+          })
+
+          if (promiseMethod) {
+            acc.push(promiseMethod)
+          }
+        }
+
         const promiseOperation = this.operation.call(this, operation, {
           ...this.options,
           ...options,
         })
 
-        if (promiseMethod) {
-          acc.push(promiseMethod)
-        }
         if (promiseOperation) {
           acc.push(promiseOperation)
         }
+
+        generators?.forEach((generator) => {
+          const promise = generator.operation?.({
+            instance: this,
+            operation,
+            options: {
+              ...this.options,
+              ...options,
+            },
+          } as any) as Promise<Array<KubbFile.File<TFileMeta>>>
+
+          if (promise) {
+            acc.push(promise)
+          }
+        })
       })
 
       return acc
@@ -291,6 +305,19 @@ export abstract class OperationGenerator<
 
     promises.push(this.all(operations.flat().filter(Boolean), this.operationsByMethod))
 
+    generators?.forEach((generator) => {
+      const promise = generator.operations?.({
+        instance: this,
+        operations: operations.flat().filter(Boolean),
+        operationsByMethod: this.operationsByMethod,
+        options: this.options,
+      } as any) as Promise<Array<KubbFile.File<TFileMeta>>>
+
+      if (promise) {
+        promises.push(promise)
+      }
+    })
+
     const files = await Promise.all(promises)
 
     // using .flat because operationGenerator[method] can return a array of files or just one file
@@ -300,48 +327,48 @@ export abstract class OperationGenerator<
   /**
    * Operation
    */
-  async operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+  async operation(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
+    return []
   }
 
   /**
    * GET
    */
-  async get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+  async get(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
+    return []
   }
 
   /**
    * POST
    */
-  async post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+  async post(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
+    return []
   }
   /**
    * PATCH
    */
-  async patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+  async patch(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
+    return []
   }
 
   /**
    * PUT
    */
-  async put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+  async put(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
+    return []
   }
 
   /**
    * DELETE
    */
-  async delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+  async delete(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
+    return []
   }
 
   /**
    * Combination of GET, POST, PATCH, PUT, DELETE
    */
   async all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta> {
-    return null
+    return []
   }
 }

package/src/SchemaGenerator.ts

@@ -1,4 +1,4 @@
-import { type FileMetaBase, Generator } from '@kubb/core'
+import { BaseGenerator, type FileMetaBase } from '@kubb/core'
 import transformers, { pascalCase } from '@kubb/core/transformers'
 import { getUniqueName } from '@kubb/core/utils'
 
@@ -13,6 +13,7 @@ import type * as KubbFile from '@kubb/fs/types'
 
 import type { Oas, OpenAPIV3, SchemaObject, contentType } from '@kubb/oas'
 import type { Schema, SchemaKeywordMapper } from './SchemaMapper.ts'
+import type { Generator } from './generator.tsx'
 import type { OperationSchema, Override, Refs } from './types.ts'
 
 export type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never
@@ -63,11 +64,11 @@ type SchemaProps = {
   parentName?: string
 }
 
-export abstract class SchemaGenerator<
+export class SchemaGenerator<
   TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
-> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
   // Collect the types of all referenced schemas, so we can export them later
   refs: Refs = {}
 
@@ -85,7 +86,7 @@ export abstract class SchemaGenerator<
     const defaultSchemas = this.#parseSchemaObject(props)
     const schemas = options.transformers?.schema?.(props, defaultSchemas) || defaultSchemas || []
 
-    return uniqueWith<Schema>(schemas, isDeepEqual)
+    return uniqueWith(schemas, isDeepEqual)
   }
 
   deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T][] {
@@ -301,7 +302,7 @@ export abstract class SchemaGenerator<
 
     if (additionalProperties) {
       additionalPropertiesSchemas =
-        additionalProperties === true
+        additionalProperties === true || !Object.keys(additionalProperties).length
           ? [{ keyword: this.#getUnknownReturn({ schema, name }) }]
           : this.parse({ schema: additionalProperties as SchemaObject, parentName: name })
     }
@@ -335,7 +336,7 @@ export abstract class SchemaGenerator<
       return [
         {
           keyword: schemaKeywords.ref,
-          args: { name: ref.propertyName, path: ref.path },
+          args: { name: ref.propertyName, path: ref.path, isImportable: !!this.context.oas.get($ref) },
         },
       ]
     }
@@ -348,7 +349,7 @@ export abstract class SchemaGenerator<
     const file = this.context.pluginManager.getFile({
       name: fileName,
       pluginKey: this.context.plugin.key,
-      extName: '.ts',
+      extname: '.ts',
     })
 
     ref = this.refs[$ref] = {
@@ -360,7 +361,7 @@ export abstract class SchemaGenerator<
     return [
       {
         keyword: schemaKeywords.ref,
-        args: { name: ref.propertyName, path: ref?.path, isTypeOnly: false },
+        args: { name: ref.propertyName, path: ref?.path, isImportable: !!this.context.oas.get($ref) },
       },
     ]
   }
@@ -378,12 +379,6 @@ export abstract class SchemaGenerator<
     const options = this.#getOptions({ schema: _schema, name })
     const unknownReturn = this.#getUnknownReturn({ schema: _schema, name })
     const { schema, version } = this.#getParsedSchemaObject(_schema)
-    const resolvedName = this.context.pluginManager.resolveName({
-      name: `${parentName || ''} ${name}`,
-      pluginKey: this.context.plugin.key,
-      type: 'type',
-    })
-
     if (!schema) {
       return [{ keyword: unknownReturn }]
     }
@@ -407,12 +402,16 @@ export abstract class SchemaGenerator<
           keyword: schemaKeywords.default,
           args: transformers.stringify(schema.default),
         })
-      }
-      if (typeof schema.default === 'boolean') {
+      } else if (typeof schema.default === 'boolean') {
         baseItems.push({
           keyword: schemaKeywords.default,
           args: schema.default ?? false,
         })
+      } else {
+        baseItems.push({
+          keyword: schemaKeywords.default,
+          args: schema.default,
+        })
       }
     }
 
@@ -454,10 +453,16 @@ export abstract class SchemaGenerator<
       baseItems.push({ keyword: schemaKeywords.readOnly })
     }
 
+    if (schema.writeOnly) {
+      baseItems.push({ keyword: schemaKeywords.writeOnly })
+    }
+
     if (isReference(schema)) {
       return [
         ...this.#getRefAlias(schema),
         nullable && { keyword: schemaKeywords.nullable },
+        schema.readOnly && { keyword: schemaKeywords.readOnly },
+        schema.writeOnly && { keyword: schemaKeywords.writeOnly },
         {
           keyword: schemaKeywords.schema,
           args: {
@@ -484,7 +489,20 @@ export abstract class SchemaGenerator<
           }),
       }
       if (schemaWithoutOneOf.properties) {
-        return [...this.parse({ schema: schemaWithoutOneOf, name, parentName }), union, ...baseItems]
+        const propertySchemas = this.parse({ schema: schemaWithoutOneOf, name, parentName })
+
+        return [
+          {
+            ...union,
+            args: union.args.map((arg) => {
+              return {
+                keyword: schemaKeywords.and,
+                args: [arg, ...propertySchemas],
+              }
+            }),
+          },
+          ...baseItems,
+        ]
       }
 
       return [union, ...baseItems]
@@ -619,6 +637,35 @@ export abstract class SchemaGenerator<
         ]
       }
 
+      if (schema.type === 'boolean') {
+        // we cannot use z.enum when enum type is boolean
+        const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum)) as unknown as SchemaKeywordMapper['enum']
+        return [
+          {
+            keyword: schemaKeywords.enum,
+            args: {
+              name: enumName,
+              typeName,
+              asConst: true,
+              items: enumNames?.args?.items
+                ? [...new Set(enumNames.args.items)].map(({ name, value }) => ({
+                    name,
+                    value,
+                    format: 'boolean',
+                  }))
+                : [...new Set(filteredValues)].map((value: string) => {
+                    return {
+                      name: value,
+                      value,
+                      format: 'boolean',
+                    }
+                  }),
+            },
+          },
+          ...baseItems.filter((item) => item.keyword !== schemaKeywords.matches),
+        ]
+      }
+
       if (extensionEnums.length > 0 && extensionEnums[0]) {
         return extensionEnums[0]
       }
@@ -809,6 +856,10 @@ export abstract class SchemaGenerator<
         ].filter(Boolean)
       }
 
+      if (!['boolean', 'object', 'number', 'string', 'integer', 'null'].includes(schema.type)) {
+        this.context.pluginManager.logger.emit('warning', `Schema type '${schema.type}' is not valid for schema ${parentName}.${name}`)
+      }
+
       // 'string' | 'number' | 'integer' | 'boolean'
       return [{ keyword: schema.type }, ...baseItems]
     }
@@ -816,14 +867,20 @@ export abstract class SchemaGenerator<
     return [{ keyword: unknownReturn }]
   }
 
-  async build(): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas, contentType, include } = this.context
 
+    oas.resolveDiscriminators()
+
     const schemas = getSchemas({ oas, contentType, includes: include })
 
-    const promises = Object.entries(schemas).reduce((acc, [name, schema]) => {
+    const promises = Object.entries(schemas).reduce((acc, [name, value]) => {
+      if (!value) {
+        return acc
+      }
+
       const options = this.#getOptions({ name })
-      const promiseOperation = this.schema.call(this, name, schema, {
+      const promiseOperation = this.schema.call(this, name, value, {
         ...this.options,
         ...options,
       })
@@ -832,17 +889,40 @@ export abstract class SchemaGenerator<
         acc.push(promiseOperation)
       }
 
+      generators?.forEach((generator) => {
+        const tree = this.parse({ schema: value, name: name })
+
+        const promise = generator.schema?.({
+          instance: this,
+          schema: {
+            name,
+            value,
+            tree,
+          },
+          options: {
+            ...this.options,
+            ...options,
+          },
+        } as any) as Promise<Array<KubbFile.File<TFileMeta>>>
+
+        if (promise) {
+          acc.push(promise)
+        }
+      })
+
       return acc
     }, [] as SchemaMethodResult<TFileMeta>[])
 
     const files = await Promise.all(promises)
 
-    // using .flat because schemaGenerator[method] can return a array of files or just one file
+    // using .flat because schemaGenerator[method] can return an array of files or just one file
     return files.flat().filter(Boolean)
   }
 
   /**
    * Schema
    */
-  abstract schema(name: string, object: SchemaObject, options: TOptions): SchemaMethodResult<TFileMeta>
+  async schema(name: string, object: SchemaObject, options: TOptions): SchemaMethodResult<TFileMeta> {
+    return []
+  }
 }

package/src/SchemaMapper.ts

@@ -12,6 +12,7 @@ export type SchemaKeywordMapper = {
   strict: { keyword: 'strict' }
   url: { keyword: 'url' }
   readOnly: { keyword: 'readOnly' }
+  writeOnly: { keyword: 'writeOnly' }
   uuid: { keyword: 'uuid' }
   email: { keyword: 'email' }
   firstName: { keyword: 'firstName' }
@@ -34,8 +35,8 @@ export type SchemaKeywordMapper = {
       asConst: boolean
       items: Array<{
         name: string | number
-        format: 'string' | 'number'
-        value?: string | number
+        format: 'string' | 'number' | 'boolean'
+        value?: string | number | boolean
       }>
     }
   }
@@ -44,14 +45,25 @@ export type SchemaKeywordMapper = {
     keyword: 'const'
     args: {
       name: string | number
-      format: 'string' | 'number'
-      value?: string | number
+      format: 'string' | 'number' | 'boolean'
+      value?: string | number | boolean
     }
   }
   union: { keyword: 'union'; args: Schema[] }
   ref: {
     keyword: 'ref'
-    args: { name: string; path: KubbFile.OptionalPath; isTypeOnly?: boolean }
+    args: {
+      name: string
+      /**
+       * Full qualified path.
+       */
+      path: KubbFile.OptionalPath
+      /**
+       * When true `File.Import` will be used.
+       * When false a reference will be used inside the current file.
+       */
+      isImportable: boolean
+    }
   }
   matches: { keyword: 'matches'; args?: string }
   boolean: { keyword: 'boolean' }
@@ -107,6 +119,7 @@ export const schemaKeywords = {
   max: 'max',
   optional: 'optional',
   readOnly: 'readOnly',
+  writeOnly: 'writeOnly',
 
   // custom ones
   object: 'object',
@@ -140,6 +153,12 @@ export type SchemaKeywordBase<T> = {
 
 export type Schema = { keyword: string } | SchemaKeywordMapper[keyof SchemaKeywordMapper]
 
+export type SchemaTree = {
+  parent: Schema | undefined
+  current: Schema
+  siblings: Schema[]
+}
+
 export function isKeyword<T extends Schema, K extends keyof SchemaKeywordMapper>(meta: T, keyword: K): meta is Extract<T, SchemaKeywordMapper[K]> {
   return meta.keyword === keyword
 }