@kubb/plugin-faker 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/generators/__snapshots__/petWithRandExp.ts

@@ -0,0 +1,9 @@
+import RandExp from "randexp";
+import { faker } from "@faker-js/faker";
+
+ export function pet(data: NonNullable<Partial<Pet>> = {}) {
+    return {
+        ...{ "id": faker.number.int(), "name": faker.string.alpha(), "tag": faker.string.alpha(), "code": faker.helpers.arrayElement<any>([faker.string.alpha(), new RandExp("\\b[1-9]\\b").gen()]), "shipDate": faker.date.anytime(), "shipTime": faker.date.anytime() },
+        ...data
+    };
+}

package/src/generators/__snapshots__/pets.ts

@@ -0,0 +1,8 @@
+import { faker } from "@faker-js/faker";
+
+ export function pets(data: NonNullable<Partial<Pets>> = []) {
+    return [
+        ...faker.helpers.arrayElements([pet()]) as any,
+        ...data
+    ];
+}

package/src/generators/__snapshots__/showPetById.ts

@@ -0,0 +1,29 @@
+import { faker } from "@faker-js/faker";
+
+ export function showPetByIdPathParams(data: NonNullable<Partial<ShowPetByIdPathParams>> = {}) {
+    return {
+        ...{ "petId": faker.string.alpha(), "testId": faker.string.alpha() },
+        ...data
+    };
+}
+
+ /**
+ * @description Expected response to a valid request
+ */
+export function showPetById200() {
+    return pet();
+}
+
+ /**
+ * @description unexpected error
+ */
+export function showPetByIdError() {
+    return error();
+}
+
+ /**
+ * @description Expected response to a valid request
+ */
+export function showPetByIdQueryResponse() {
+    return pet();
+}

package/src/generators/fakerGenerator.tsx

@@ -0,0 +1,140 @@
+import { type OperationSchema as OperationSchemaType, SchemaGenerator, createReactGenerator, schemaKeywords } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { File, useApp } from '@kubb/react'
+import { Faker } from '../components'
+import type { PluginFaker } from '../types'
+
+export const fakerGenerator = createReactGenerator<PluginFaker>({
+  name: 'faker',
+  Operation({ operation, options }) {
+    const { dateParser, regexGenerator, seed, mapper } = options
+
+    const { plugin, pluginManager, mode } = useApp<PluginFaker>()
+    const oas = useOas()
+    const { getSchemas, getFile } = useOperationManager()
+    const schemaManager = useSchemaManager()
+
+    const file = getFile(operation)
+    const schemas = getSchemas(operation)
+    const schemaGenerator = new SchemaGenerator(options, {
+      oas,
+      plugin,
+      pluginManager,
+      mode,
+      override: options.override,
+    })
+
+    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
+      .flat()
+      .filter(Boolean)
+
+    const mapOperationSchema = ({ name, schema, description, ...options }: OperationSchemaType, i: number) => {
+      const tree = schemaGenerator.parse({ schema, name })
+      const imports = schemaManager.getImports(tree)
+
+      const faker = {
+        name: schemaManager.getName(name, { type: 'function' }),
+        file: schemaManager.getFile(name),
+      }
+
+      const type = {
+        name: schemaManager.getName(name, { type: 'type', pluginKey: [pluginTsName] }),
+        file: schemaManager.getFile(options.operationName || name, { pluginKey: [pluginTsName], tag: options.operation?.getTags()[0]?.name }),
+      }
+
+      const canOverride = tree.some(
+        ({ keyword }) =>
+          keyword === schemaKeywords.array ||
+          keyword === schemaKeywords.and ||
+          keyword === schemaKeywords.object ||
+          keyword === schemaKeywords.union ||
+          keyword === schemaKeywords.tuple,
+      )
+
+      return (
+        <Oas.Schema key={i} name={name} value={schema} tree={tree}>
+          {canOverride && <File.Import isTypeOnly root={file.path} path={type.file.path} name={[type.name]} />}
+          {imports.map((imp, index) => (
+            <File.Import key={index} root={file.path} path={imp.path} name={imp.name} />
+          ))}
+          <Faker
+            name={faker.name}
+            typeName={type.name}
+            description={description}
+            tree={tree}
+            regexGenerator={regexGenerator}
+            dateParser={dateParser}
+            mapper={mapper}
+            seed={seed}
+            canOverride={canOverride}
+          />
+        </Oas.Schema>
+      )
+    }
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={plugin.options.output?.banner} footer={plugin.options.output?.footer}>
+        <File.Import name={['faker']} path="@faker-js/faker" />
+        {regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
+        {dateParser !== 'faker' && <File.Import path={dateParser} name={dateParser} />}
+        {operationSchemas.map(mapOperationSchema)}
+      </File>
+    )
+  },
+  Schema({ schema, options }) {
+    const { dateParser, regexGenerator, seed, mapper } = options
+
+    const { getName, getFile, getImports } = useSchemaManager()
+    const {
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginFaker>()
+    const imports = getImports(schema.tree)
+
+    const faker = {
+      name: getName(schema.name, { type: 'function' }),
+      file: getFile(schema.name),
+    }
+
+    const type = {
+      name: getName(schema.name, { type: 'type', pluginKey: [pluginTsName] }),
+      file: getFile(schema.name, { pluginKey: [pluginTsName] }),
+    }
+
+    const canOverride = schema.tree.some(
+      ({ keyword }) =>
+        keyword === schemaKeywords.array ||
+        keyword === schemaKeywords.and ||
+        keyword === schemaKeywords.object ||
+        keyword === schemaKeywords.union ||
+        keyword === schemaKeywords.tuple,
+    )
+
+    return (
+      <File baseName={faker.file.baseName} path={faker.file.path} meta={faker.file.meta} banner={output?.banner} footer={output?.footer}>
+        <File.Import name={['faker']} path="@faker-js/faker" />
+        {regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
+        {dateParser !== 'faker' && <File.Import path={dateParser} name={dateParser} />}
+        <File.Import isTypeOnly root={faker.file.path} path={type.file.path} name={[type.name]} />
+        {imports.map((imp, index) => (
+          <File.Import key={index} root={faker.file.path} path={imp.path} name={imp.name} />
+        ))}
+
+        <Faker
+          name={faker.name}
+          typeName={type.name}
+          description={schema.value.description}
+          tree={schema.tree}
+          regexGenerator={regexGenerator}
+          dateParser={dateParser}
+          mapper={mapper}
+          seed={seed}
+          canOverride={canOverride}
+        />
+      </File>
+    )
+  },
+})

package/src/generators/index.ts

@@ -0,0 +1 @@
+export { fakerGenerator } from './fakerGenerator.tsx'

package/src/parser/index.ts

@@ -4,7 +4,7 @@ import { SchemaGenerator, isKeyword, schemaKeywords } from '@kubb/plugin-oas'
 import type { Schema, SchemaKeywordBase, SchemaKeywordMapper, SchemaMapper } from '@kubb/plugin-oas'
 import type { Options } from '../types.ts'
 
-export const fakerKeywordMapper = {
+const fakerKeywordMapper = {
   any: () => 'undefined',
   unknown: () => 'unknown',
   number: (min?: number, max?: number) => {
@@ -68,13 +68,18 @@ export const fakerKeywordMapper = {
    * Type `'string'` ISO date format (YYYY-MM-DD)
    * @default ISO date format (YYYY-MM-DD)
    */
-  date: (type: 'date' | 'string' = 'string', parser?: string) => {
+  date: (type: 'date' | 'string' = 'string', parser: Options['dateParser'] = 'faker') => {
     if (type === 'string') {
-      if (parser) {
+      if (parser !== 'faker') {
         return `${parser}(faker.date.anytime()).format("YYYY-MM-DD")`
       }
       return 'faker.date.anytime().toString()'
     }
+
+    if (parser !== 'faker') {
+      throw new Error(`type '${type}' and parser '${parser}' can not work together`)
+    }
+
     return 'faker.date.anytime()'
   },
   /**
@@ -82,13 +87,18 @@ export const fakerKeywordMapper = {
    * Type `'string'` ISO time format (HH:mm:ss[.SSSSSS])
    * @default ISO time format (HH:mm:ss[.SSSSSS])
    */
-  time: (type: 'date' | 'string' = 'string', parser?: string) => {
+  time: (type: 'date' | 'string' = 'string', parser: Options['dateParser'] = 'faker') => {
     if (type === 'string') {
-      if (parser) {
+      if (parser !== 'faker') {
         return `${parser}(faker.date.anytime()).format("HH:mm:ss")`
       }
       return 'faker.date.anytime().toString()'
     }
+
+    if (parser !== 'faker') {
+      throw new Error(`type '${type}' and parser '${parser}' can not work together`)
+    }
+
     return 'faker.date.anytime()'
   },
   uuid: () => 'faker.string.uuid()',
@@ -155,7 +165,7 @@ type ParserOptions = {
 
   seed?: number | number[]
   regexGenerator?: 'faker' | 'randexp'
-  withData?: boolean
+  canOverride?: boolean
   dateParser?: Options['dateParser']
   mapper?: Record<string, string>
 }
@@ -168,15 +178,15 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
   }
 
   if (isKeyword(current, schemaKeywords.union)) {
-    return fakerKeywordMapper.union(current.args.map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean))
+    return fakerKeywordMapper.union(current.args.map((schema) => parse(current, schema, { ...options, canOverride: false })).filter(Boolean))
   }
 
   if (isKeyword(current, schemaKeywords.and)) {
-    return fakerKeywordMapper.and(current.args.map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean))
+    return fakerKeywordMapper.and(current.args.map((schema) => parse(current, schema, { ...options, canOverride: false })).filter(Boolean))
   }
 
   if (isKeyword(current, schemaKeywords.array)) {
-    return fakerKeywordMapper.array(current.args.items.map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean))
+    return fakerKeywordMapper.array(current.args.items.map((schema) => parse(current, schema, { ...options, canOverride: false })).filter(Boolean))
   }
 
   if (isKeyword(current, schemaKeywords.enum)) {
@@ -195,7 +205,7 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
       throw new Error(`Name not defined for keyword ${current.keyword}`)
     }
 
-    if (options.withData) {
+    if (options.canOverride) {
       return `${current.args.name}(data)`
     }
 
@@ -220,7 +230,7 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
         return `"${name}": ${joinItems(
           schemas
             .sort(schemaKeywordsorter)
-            .map((schema) => parse(current, schema, { ...options, withData: false }))
+            .map((schema) => parse(current, schema, { ...options, canOverride: false }))
             .filter(Boolean),
         )}`
       })
@@ -231,10 +241,10 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
 
   if (isKeyword(current, schemaKeywords.tuple)) {
     if (Array.isArray(current.args.items)) {
-      return fakerKeywordMapper.tuple(current.args.items.map((schema) => parse(current, schema, { ...options, withData: false })).filter(Boolean))
+      return fakerKeywordMapper.tuple(current.args.items.map((schema) => parse(current, schema, { ...options, canOverride: false })).filter(Boolean))
     }
 
-    return parse(current, current.args.items, { ...options, withData: false })
+    return parse(current, current.args.items, { ...options, canOverride: false })
   }
 
   if (isKeyword(current, schemaKeywords.const)) {

package/src/plugin.ts

@@ -3,15 +3,13 @@ import path from 'node:path'
 import { FileManager, PluginManager, createPlugin } from '@kubb/core'
 import { camelCase } from '@kubb/core/transformers'
 import { renderTemplate } from '@kubb/core/utils'
-import { pluginOasName } from '@kubb/plugin-oas'
-import { getGroupedByTagFiles } from '@kubb/plugin-oas/utils'
-import { pluginTsName } from '@kubb/plugin-ts'
+import { OperationGenerator, SchemaGenerator, pluginOasName } from '@kubb/plugin-oas'
 
-import { OperationGenerator } from './OperationGenerator.tsx'
-import { SchemaGenerator } from './SchemaGenerator.tsx'
+import { pluginTsName } from '@kubb/plugin-ts'
 
 import type { Plugin } from '@kubb/core'
 import type { PluginOas } from '@kubb/plugin-oas'
+import { fakerGenerator } from './generators/fakerGenerator.tsx'
 import type { PluginFaker } from './types.ts'
 
 export const pluginFakerName = 'plugin-faker' satisfies PluginFaker['name']
@@ -26,9 +24,9 @@ export const pluginFaker = createPlugin<PluginFaker>((options) => {
     override = [],
     transformers = {},
     mapper = {},
-    dateType = 'string',
     unknownType = 'any',
-    dateParser,
+    dateType = 'string',
+    dateParser = 'faker',
     regexGenerator = 'faker',
   } = options
   const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
@@ -36,10 +34,13 @@ export const pluginFaker = createPlugin<PluginFaker>((options) => {
   return {
     name: pluginFakerName,
     options: {
-      extName: output.extName,
+      output: {
+        exportType: 'barrelNamed',
+        ...output,
+      },
       transformers,
-      dateType,
       seed,
+      dateType,
       unknownType,
       dateParser,
       mapper,
@@ -97,7 +98,7 @@ export const pluginFaker = createPlugin<PluginFaker>((options) => {
         output: output.path,
       })
 
-      const schemaFiles = await schemaGenerator.build()
+      const schemaFiles = await schemaGenerator.build(fakerGenerator)
       await this.addFile(...schemaFiles)
 
       const operationGenerator = new OperationGenerator(this.plugin.options, {
@@ -111,36 +112,22 @@ export const pluginFaker = createPlugin<PluginFaker>((options) => {
         mode,
       })
 
-      const operationFiles = await operationGenerator.build()
+      const operationFiles = await operationGenerator.build(fakerGenerator)
       await this.addFile(...operationFiles)
-    },
-    async buildEnd() {
-      if (this.config.output.write === false) {
-        return
-      }
 
-      const root = path.resolve(this.config.root, this.config.output.path)
-
-      if (group?.type === 'tag') {
-        const rootFiles = await getGroupedByTagFiles({
-          logger: this.logger,
-          files: this.fileManager.files,
-          plugin: this.plugin,
-          template,
-          exportAs: group.exportAs || '{{tag}}Mocks',
+      if (this.config.output.exportType) {
+        const barrelFiles = await this.fileManager.getBarrelFiles({
           root,
           output,
+          files: this.fileManager.files,
+          meta: {
+            pluginKey: this.plugin.key,
+          },
+          logger: this.logger,
         })
 
-        await this.addFile(...rootFiles)
+        await this.addFile(...barrelFiles)
       }
-
-      await this.fileManager.addIndexes({
-        root,
-        output,
-        meta: { pluginKey: this.plugin.key },
-        logger: this.logger,
-      })
     },
   }
 })

package/src/types.ts

@@ -1,32 +1,13 @@
-import type { Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type * as KubbFile from '@kubb/fs/types'
+import type { Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 
 import type { SchemaObject } from '@kubb/oas'
 import type { Exclude, Include, Override, ResolvePathOptions, Schema } from '@kubb/plugin-oas'
 
 export type Options = {
-  output?: {
-    /**
-     * Relative path to save the Faker mocks.
-     * When output is a file it will save all models inside that file else it will create a file per schema item.
-     * @default 'mocks'
-     */
-    path: string
-    /**
-     * Name to be used for the `export * as {{exportAs}} from './'`
-     */
-    exportAs?: string
-    /**
-     * Add an extension to the generated imports and exports, default it will not use an extension
-     */
-    extName?: KubbFile.Extname
-    /**
-     * Define what needs to exported, here you can also disable the export of barrel files
-     * @default `'barrel'`
-     */
-    exportType?: 'barrel' | 'barrelNamed' | false
-  }
-
+  /**
+   * @default 'handlers'
+   */
+  output?: Output
   /**
    * Group the Faker mocks based on the provided name.
    */
@@ -74,26 +55,14 @@ export type Options = {
    * - Schema with format 'time' will use ISO time format (HH:mm:ss[.SSSSSS])
    *   - `'dayjs'` will use `dayjs(faker.date.anytime()).format("HH:mm:ss")`.
    *   - `undefined` will use `faker.date.anytime().toString()`
-   * * @default undefined
+   * * @default 'faker'
    */
-  dateParser?: 'dayjs' | 'moment' | (string & {})
+  dateParser?: 'faker' | 'dayjs' | 'moment' | (string & {})
   /**
    * Which type to use when the Swagger/OpenAPI file is not providing more information
    * @default 'any'
    */
   unknownType?: 'any' | 'unknown'
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
-    /**
-     * Receive schema and baseName(propertName) and return FakerMeta array
-     * TODO TODO add docs
-     * @beta
-     */
-    schema?: (props: { schema?: SchemaObject; name?: string; parentName?: string }, defaultSchemas: Schema[]) => Schema[] | undefined
-  }
   /**
    * Choose which generator to use when using Regexp.
    *
@@ -108,23 +77,29 @@ export type Options = {
    * The use of Seed is intended to allow for consistent values in a test.
    */
   seed?: number | number[]
+  transformers?: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
+    /**
+     * Receive schema and baseName(propertName) and return FakerMeta array
+     * TODO TODO add docs
+     * @beta
+     */
+    schema?: (props: { schema?: SchemaObject; name?: string; parentName?: string }, defaultSchemas: Schema[]) => Schema[] | undefined
+  }
 }
 
 type ResolvedOptions = {
-  extName: KubbFile.Extname | undefined
+  output: Output
+  override: NonNullable<Options['override']>
   dateType: NonNullable<Options['dateType']>
-  dateParser: Options['dateParser']
+  dateParser: NonNullable<Options['dateParser']>
   unknownType: NonNullable<Options['unknownType']>
   transformers: NonNullable<Options['transformers']>
-  override: NonNullable<Options['override']>
   seed: NonNullable<Options['seed']> | undefined
   mapper: NonNullable<Options['mapper']>
   regexGenerator: NonNullable<Options['regexGenerator']>
 }
-
-export type FileMeta = {
-  pluginKey?: Plugin['key']
-  tag?: string
-}
-
 export type PluginFaker = PluginFactoryOptions<'plugin-faker', Options, ResolvedOptions, never, ResolvePathOptions>

package/src/OperationGenerator.tsx

@@ -1,30 +0,0 @@
-import { OperationGenerator as Generator } from '@kubb/plugin-oas'
-import { Oas } from '@kubb/plugin-oas/components'
-import { App, createRoot } from '@kubb/react'
-
-import { OperationSchema } from './components/OperationSchema.tsx'
-
-import type { Operation } from '@kubb/oas'
-import type { OperationMethodResult } from '@kubb/plugin-oas'
-import type { FileMeta, PluginFaker } from './types.ts'
-
-export class OperationGenerator extends Generator<PluginFaker['resolvedOptions'], PluginFaker> {
-  async operation(operation: Operation, options: PluginFaker['resolvedOptions']): OperationMethodResult<FileMeta> {
-    const { oas, pluginManager, plugin, mode } = this.context
-
-    const root = createRoot({
-      logger: pluginManager.logger,
-    })
-    root.render(
-      <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
-        <Oas oas={oas} operations={[operation]} generator={this}>
-          <Oas.Operation operation={operation}>
-            <OperationSchema.File />
-          </Oas.Operation>
-        </Oas>
-      </App>,
-    )
-
-    return root.files
-  }
-}

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, PluginFaker } from './types.ts'
-
-export class SchemaGenerator extends Generator<PluginFaker['resolvedOptions'], PluginFaker> {
-  async schema(name: string, schema: SchemaObject, options: PluginFaker['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,84 +0,0 @@
-import { Oas } from '@kubb/plugin-oas/components'
-import { useOas, useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { File, Parser, useApp } from '@kubb/react'
-import { pluginTsName } from '@kubb/plugin-ts'
-
-import { SchemaGenerator } from '../SchemaGenerator.tsx'
-
-import type { OperationSchema as OperationSchemaType } from '@kubb/plugin-oas'
-import type { ReactNode } from 'react'
-import type { FileMeta, PluginFaker } from '../types.ts'
-import { Schema } from './Schema.tsx'
-
-type Props = {
-  description?: string
-}
-
-export function OperationSchema({ description }: Props): ReactNode {
-  return <Schema withData={false} description={description} />
-}
-
-type FileProps = {}
-
-OperationSchema.File = function ({}: FileProps): ReactNode {
-  const { plugin, pluginManager, mode } = useApp<PluginFaker>()
-
-  const oas = useOas()
-  const { getSchemas, getFile } = useOperationManager()
-  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, ...options }: OperationSchemaType, i: number) => {
-    // used for this.options.typed
-    const typeName = pluginManager.resolveName({
-      name,
-      pluginKey: [pluginTsName],
-      type: 'type',
-    })
-    const typeFileName = pluginManager.resolveName({
-      name: options.operationName || name,
-      pluginKey: [pluginTsName],
-      type: 'file',
-    })
-    const typePath = pluginManager.resolvePath({
-      baseName: typeFileName,
-      pluginKey: [pluginTsName],
-      options: { tag: options.operation?.getTags()[0]?.name },
-    })
-
-    const tree = generator.parse({ schema, name })
-
-    return (
-      <Oas.Schema key={i} name={name} value={schema} tree={tree}>
-        {typeName && typePath && <File.Import extName={plugin.options.extName} isTypeOnly root={file.path} path={typePath} name={[typeName]} />}
-        {plugin.options.dateParser && <File.Import path={plugin.options.dateParser} name={plugin.options.dateParser} />}
-
-        {mode === 'split' && <Oas.Schema.Imports extName={plugin.options.extName} />}
-        <File.Source>
-          <OperationSchema description={description} />
-        </File.Source>
-      </Oas.Schema>
-    )
-  }
-
-  return (
-    <Parser language="typescript">
-      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-        <File.Import name={['faker']} path="@faker-js/faker" />
-        {plugin.options.regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
-        {items.map(mapItem)}
-      </File>
-    </Parser>
-  )
-}