@kubb/plugin-zod 3.0.0-alpha.9 → 3.0.0-beta.10

package/src/components/OperationSchema.tsx

@@ -1,60 +0,0 @@
-import { SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { Oas } from '@kubb/plugin-oas/components'
-import { useOas, useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { File, useApp } from '@kubb/react'
-
-import type { OperationSchema as OperationSchemaType } from '@kubb/plugin-oas'
-import type { ReactNode } from 'react'
-import type { FileMeta, PluginZod } from '../types.ts'
-import { Schema } from './Schema.tsx'
-
-type Props = {
-  description?: string
-  keysToOmit?: string[]
-}
-
-export function OperationSchema({ description, keysToOmit }: Props): ReactNode {
-  return <Schema keysToOmit={keysToOmit} withTypeAnnotation={false} description={description} />
-}
-
-type FileProps = {}
-
-OperationSchema.File = function ({}: FileProps): ReactNode {
-  const { pluginManager, plugin, mode } = useApp<PluginZod>()
-  const { getSchemas, getFile } = useOperationManager()
-  const oas = useOas()
-  const operation = useOperation()
-
-  const file = getFile(operation)
-  const schemas = getSchemas(operation)
-  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) => {
-    // hack so Params can be optional when needed
-    const required = Array.isArray(schema?.required) ? !!schema.required.length : !!schema?.required
-    const optional = !required && !!name.includes('Params')
-    const tree = generator.parse({ schema, name })
-
-    return (
-      <Oas.Schema key={i} name={name} value={schema} tree={[...tree, optional ? { keyword: schemaKeywords.optional } : undefined].filter(Boolean)}>
-        {mode === 'split' && <Oas.Schema.Imports isTypeOnly={false} />}
-        <OperationSchema description={description} keysToOmit={keysToOmit} />
-      </Oas.Schema>
-    )
-  }
-
-  return (
-    <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-      <File.Import name={['z']} path={plugin.options.importPath} />
-      {items.map(mapItem)}
-    </File>
-  )
-}

package/src/components/Schema.tsx

@@ -1,166 +0,0 @@
-import { Oas } from '@kubb/plugin-oas/components'
-import { Const, File, Type, useApp, useFile } from '@kubb/react'
-import { pluginTsName } from '@kubb/plugin-ts'
-
-import transformers from '@kubb/core/transformers'
-import { isKeyword, schemaKeywords } from '@kubb/plugin-oas'
-import { useSchema } from '@kubb/plugin-oas/hooks'
-import type { ReactNode } from 'react'
-import * as parserZod from '../parser/index.ts'
-import { pluginZodName } from '../plugin.ts'
-import type { PluginZod } from '../types.ts'
-
-type Props = {
-  description?: string
-  withTypeAnnotation?: boolean
-  keysToOmit?: string[]
-}
-
-export function Schema(props: Props): ReactNode {
-  const { keysToOmit, withTypeAnnotation, description } = props
-  const { tree, name } = useSchema()
-  const {
-    pluginManager,
-    plugin: {
-      options: { mapper, typedSchema, coercion },
-    },
-  } = useApp<PluginZod>()
-
-  // all checks are also inside this.schema(React)
-  const resolvedName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginZodName],
-    type: 'function',
-  })
-  const resolvedTypeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginZodName],
-    type: 'type',
-  })
-
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: 'type',
-  })
-
-  if (!tree.length) {
-    return (
-      <File.Source name={resolvedName} isExportable isIndexable>
-        <Const
-          name={resolvedName}
-          export
-          JSDoc={{
-            comments: [description ? `@description ${transformers.jsStringEscape(description)}` : undefined].filter(Boolean),
-          }}
-        >
-          undefined
-        </Const>
-      </File.Source>
-    )
-  }
-
-  const hasTuple = tree.some((item) => isKeyword(item, schemaKeywords.tuple))
-
-  const output = parserZod
-    .sort(tree)
-    .filter((item) => {
-      if (hasTuple && (isKeyword(item, schemaKeywords.min) || isKeyword(item, schemaKeywords.max))) {
-        return false
-      }
-
-      return true
-    })
-    .map((item) => parserZod.parse(undefined, item, { name, typeName, description, mapper, coercion, keysToOmit }))
-    .filter(Boolean)
-    .join('')
-
-  const suffix = output.endsWith('.nullable()') ? '.unwrap().and' : '.and'
-
-  return (
-    <>
-      <File.Source name={resolvedName} isExportable isIndexable>
-        <Const
-          export
-          name={resolvedName}
-          JSDoc={{
-            comments: [description ? `@description ${transformers.jsStringEscape(description)}` : undefined].filter(Boolean),
-          }}
-        >
-          {[
-            output,
-            keysToOmit?.length ? `${suffix}(z.object({ ${keysToOmit.map((key) => `${key}: z.never()`).join(',')} }))` : undefined,
-            withTypeAnnotation && typeName ? ` as z.ZodType<${typeName}>` : '',
-          ]
-            .filter(Boolean)
-            .join('') || ''}
-        </Const>
-      </File.Source>
-      {typedSchema && (
-        <File.Source name={resolvedTypeName} isExportable isIndexable isTypeOnly>
-          <Type export name={resolvedTypeName}>
-            {`z.infer<typeof ${resolvedName}>`}
-          </Type>
-        </File.Source>
-      )}
-    </>
-  )
-}
-
-type FileProps = {}
-
-Schema.File = function ({}: FileProps): ReactNode {
-  const {
-    pluginManager,
-    plugin: {
-      options: { typed },
-    },
-  } = useApp<PluginZod>()
-  const { schema } = useSchema()
-
-  const withTypeAnnotation = !!typed
-
-  return (
-    <Oas.Schema.File output={pluginManager.config.output.path}>
-      <Schema.Imports />
-      <Schema withTypeAnnotation={withTypeAnnotation} description={schema?.description} />
-    </Oas.Schema.File>
-  )
-}
-Schema.Imports = (): ReactNode => {
-  const {
-    pluginManager,
-    plugin: {
-      options: { typed, importPath },
-    },
-  } = useApp<PluginZod>()
-  const { path: root } = useFile()
-  const { name, tree, schema } = useSchema()
-
-  // used for this.options.typed
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: 'type',
-  })
-
-  const typeFileName = pluginManager.resolveName({
-    name: name,
-    pluginKey: [pluginTsName],
-    type: 'file',
-  })
-
-  const typePath = pluginManager.resolvePath({
-    baseName: typeFileName,
-    pluginKey: [pluginTsName],
-  })
-
-  const withTypeAnnotation = !!typed
-
-  return (
-    <>
-      <File.Import name={['z']} path={importPath} />
-      {withTypeAnnotation && typeName && typePath && <File.Import isTypeOnly root={root} path={typePath} name={[typeName]} />}
-    </>
-  )
-}

package/src/components/__snapshots__/operations.ts

@@ -1,53 +0,0 @@
-export const operations = {"get_pets-pet-id": {
-            request: undefined,
-    parameters: {
-            path: undefined,
-    query: undefined,
-    header: undefined
-          },
-    responses: {
-            200: getPetsPetIdQueryResponse,
-    default: getPetsPetIdQueryResponse
-          },
-    errors: {
-            
-          }
-          },
-    "listPets": {
-            request: undefined,
-    parameters: {
-            path: undefined,
-    query: listPetsQueryParams,
-    header: undefined
-          },
-    responses: {
-            200: listPetsQueryResponse,
-    default: listPetsQueryResponse
-          },
-    errors: {
-            
-          }
-          },
-    "createPets": {
-            request: createPetsMutationRequest,
-    parameters: {
-            path: undefined,
-    query: undefined,
-    header: undefined
-          },
-    responses: {
-            201: createPetsMutationResponse,
-    default: createPetsMutationResponse
-          },
-    errors: {
-            
-          }
-          }} as const
-
-export const paths = {"/pets/{pet_id}": {
-            get: operations["get_pets-pet-id"]
-          },
-    "/pets": {
-            get: operations["listPets"],
-    post: operations["createPets"]
-          }} as const