@kubb/plugin-ts 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/SchemaGenerator.tsx

@@ -1,31 +0,0 @@
-import type { SchemaObject } from '@kubb/oas'
-import { SchemaGenerator as Generator } from '@kubb/plugin-oas'
-import type { SchemaMethodResult } from '@kubb/plugin-oas'
-import { Oas } from '@kubb/plugin-oas/components'
-import { App, createRoot } from '@kubb/react'
-import { Schema } from './components/Schema.tsx'
-import type { FileMeta, PluginTs } from './types.ts'
-
-export class SchemaGenerator extends Generator<PluginTs['resolvedOptions'], PluginTs> {
-  async schema(name: string, schema: SchemaObject, options: PluginTs['resolvedOptions']): SchemaMethodResult<FileMeta> {
-    const { oas, pluginManager, plugin, mode, output } = this.context
-
-    const root = createRoot({
-      logger: pluginManager.logger,
-    })
-
-    const tree = this.parse({ schema, name })
-
-    root.render(
-      <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
-        <Oas oas={oas}>
-          <Oas.Schema name={name} value={schema} tree={tree}>
-            <Schema.File />
-          </Oas.Schema>
-        </Oas>
-      </App>,
-    )
-
-    return root.files
-  }
-}

package/src/components/OperationSchema.tsx

@@ -1,161 +0,0 @@
-import transformers from '@kubb/core/transformers'
-import { print } from '@kubb/parser-ts'
-import * as factory from '@kubb/parser-ts/factory'
-import { Oas } from '@kubb/plugin-oas/components'
-import { useOas, useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { File, useApp } from '@kubb/react'
-
-import { SchemaGenerator } from '../SchemaGenerator.tsx'
-
-import type { PluginManager } from '@kubb/core'
-import type { Operation } from '@kubb/oas'
-import type { ts } from '@kubb/parser-ts'
-import type { OperationSchema as OperationSchemaType } from '@kubb/plugin-oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { pluginTsName } from '@kubb/plugin-ts'
-import type { ReactNode } from 'react'
-import type { FileMeta, PluginTs } from '../types.ts'
-import { Schema } from './Schema.tsx'
-
-function printCombinedSchema({
-  name,
-  operation,
-  schemas,
-  pluginManager,
-}: { name: string; operation: Operation; schemas: OperationSchemas; pluginManager: PluginManager }): string {
-  const properties: Record<string, ts.TypeNode> = {}
-
-  if (schemas.response) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.response.name,
-      pluginKey: [pluginTsName],
-      type: 'function',
-    })
-    properties['response'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.request) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.request.name,
-      pluginKey: [pluginTsName],
-      type: 'function',
-    })
-    properties['request'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.pathParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.pathParams.name,
-      pluginKey: [pluginTsName],
-      type: 'function',
-    })
-    properties['pathParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.queryParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.queryParams.name,
-      pluginKey: [pluginTsName],
-      type: 'function',
-    })
-    properties['queryParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.headerParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.headerParams.name,
-      pluginKey: [pluginTsName],
-      type: 'function',
-    })
-    properties['headerParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-  }
-
-  if (schemas.errors) {
-    properties['errors'] = factory.createUnionDeclaration({
-      nodes: schemas.errors.map((error) => {
-        const identifier = pluginManager.resolveName({
-          name: error.name,
-          pluginKey: [pluginTsName],
-          type: 'function',
-        })
-
-        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
-      }),
-    })!
-  }
-
-  const namespaceNode = factory.createTypeAliasDeclaration({
-    name,
-    type: factory.createTypeLiteralNode(
-      Object.keys(properties)
-        .map((key) => {
-          const type = properties[key]
-          if (!type) {
-            return undefined
-          }
-
-          return factory.createPropertySignature({
-            name: transformers.pascalCase(key),
-            type,
-          })
-        })
-        .filter(Boolean),
-    ),
-    modifiers: [factory.modifiers.export],
-  })
-
-  return print(namespaceNode)
-}
-
-type Props = {
-  description?: string
-  keysToOmit?: string[]
-}
-
-export function OperationSchema({ keysToOmit, description }: Props): ReactNode {
-  return <Schema keysToOmit={keysToOmit} description={description} />
-}
-
-type FileProps = {}
-
-OperationSchema.File = function ({}: FileProps): ReactNode {
-  const { pluginManager, plugin, mode } = useApp<PluginTs>()
-  const oas = useOas()
-  const { getSchemas, getFile, getName } = useOperationManager()
-  const operation = useOperation()
-
-  const file = getFile(operation)
-  const schemas = getSchemas(operation)
-  const factoryName = getName(operation, { type: 'type' })
-  const generator = new SchemaGenerator(plugin.options, {
-    oas,
-    plugin,
-    pluginManager,
-    mode,
-    override: plugin.options.override,
-  })
-  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean)
-
-  const mapItem = ({ name, schema, description, keysToOmit, ...options }: OperationSchemaType, i: number) => {
-    const tree = generator.parse({ schema, name })
-
-    return (
-      <Oas.Schema key={i} name={name} value={schema} tree={tree}>
-        {mode === 'split' && <Oas.Schema.Imports isTypeOnly />}
-        <OperationSchema description={description} keysToOmit={keysToOmit} />
-      </Oas.Schema>
-    )
-  }
-
-  const combinedSchemaName = operation.method === 'get' ? `${factoryName}Query` : `${factoryName}Mutation`
-
-  return (
-    <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-      {items.map(mapItem)}
-
-      <File.Source name={combinedSchemaName} isExportable isIndexable isTypeOnly>
-        {printCombinedSchema({ name: combinedSchemaName, operation, schemas, pluginManager })}
-      </File.Source>
-    </File>
-  )
-}

package/src/components/__snapshots__/Schema/pets.ts

@@ -1,27 +0,0 @@
-/**
- * @description Null response
-*/
-export type createPets201 = any;
-
-/**
- * @description unexpected error
-*/
-export type createPetsError = error;
-
-export type createPetsMutationRequest = {
-    /**
-     * @type string
-    */
-    name: string;
-    /**
-     * @type string
-    */
-    tag: string;
-};
-
-export type createPetsMutationResponse = any;
-
-export type CreatePetsMutation = {
-    Response: createPetsMutationResponse;
-    Request: createPetsMutationRequest;
-};

package/src/oas/index.ts

@@ -1 +0,0 @@
-export type { Infer, Response, RequestParams, Model } from '@kubb/oas'