@kubb/plugin-faker 5.0.0-alpha.8 → 5.0.0-beta.3

package/src/generators/fakerGenerator.tsx

@@ -1,87 +1,223 @@
-import { useMode, usePluginDriver } from '@kubb/core/hooks'
-import { type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
-import { applyParamsCasing, getBanner, getFooter, getImports, isParameterSchema } from '@kubb/plugin-oas/utils'
+import { ast, defineGenerator } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
-import { Faker } from '../components'
-import type { PluginFaker } from '../types'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { Faker } from '../components/Faker.tsx'
+import { printerFaker } from '../printers/printerFaker.ts'
+import type { PluginFaker } from '../types.ts'
+import {
+  aliasConflictingImports,
+  buildResponseUnionSchema,
+  canOverrideSchema,
+  filterUsedImports,
+  localeToFakerImport,
+  resolveParamNameByLocation,
+  resolveSchemaRef,
+  resolveTypeReference,
+  rewriteAliasedImports,
+} from '../utils.ts'
 
-export const fakerGenerator = createReactGenerator<PluginFaker>({
+export const fakerGenerator = defineGenerator<PluginFaker>({
   name: 'faker',
-  Operation({ operation, generator, plugin }) {
-    const {
-      options,
-      options: { dateParser, regexGenerator, seed, mapper },
-    } = plugin
-    const mode = useMode()
-    const driver = usePluginDriver()
+  renderer: jsxRenderer,
+  schema(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, group, dateParser, regexGenerator, mapper, seed, locale, printer } = ctx.options
+    const pluginTs = ctx.driver.getPlugin(pluginTsName)
 
-    const oas = useOas()
-    const { getSchemas, getFile, getGroup } = useOperationManager(generator)
-    const schemaManager = useSchemaManager()
+    if (!node.name || !pluginTs || !adapter.inputNode) {
+      return
+    }
+
+    const tsResolver = ctx.driver.getResolver(pluginTsName)
 
-    const file = getFile(operation)
-    const schemas = getSchemas(operation)
-    const schemaGenerator = new SchemaGenerator(options, {
-      fabric: generator.context.fabric,
-      oas,
-      plugin,
-      events: generator.context.events,
-      driver,
-      mode,
-      override: options.override,
+    const schemaNode = resolveSchemaRef(node, adapter.inputNode.schemas)
+    const schemaName = schemaNode.name ?? node.name
+    const mode = ctx.getMode(output)
+    const meta = {
+      name: resolver.resolveName(schemaName),
+      file: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }),
+      typeName: tsResolver.resolveTypeName(schemaName),
+      typeFile: tsResolver.resolveFile(
+        { name: schemaName, extname: '.ts' },
+        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group },
+      ),
+    } as const
+    const canOverride = canOverrideSchema(schemaNode)
+    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
+    const printerInstance = printerFaker({
+      resolver,
+      schemaName,
+      typeName: meta.typeName,
+      dateParser,
+      regexGenerator,
+      mapper,
+      nodes: printer?.nodes,
+      cyclicSchemas,
+    })
+    const fakerText = printerInstance.print(schemaNode) ?? 'undefined'
+    const typeReference = resolveTypeReference({
+      node: schemaNode,
+      canOverride,
+      name: meta.name,
+      typeName: meta.typeName,
+      filePath: meta.file.path,
+      typeFilePath: meta.typeFile.path,
     })
 
-    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
-      .flat()
-      .filter((x): x is OperationSchemaType => Boolean(x))
+    const imports = adapter
+      .getImports(schemaNode, (schemaName) => ({
+        name: resolver.resolveName(schemaName),
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      }))
+      .filter((entry) => entry.path !== meta.file.path)
+    const usedImports = filterUsedImports(imports, fakerText)
 
-    const mapOperationSchema = ({ name, schema, description, ...options }: OperationSchemaType) => {
-      // Apply paramsCasing transformation if enabled and this is a parameter schema
-      const shouldTransform = isParameterSchema(name) && plugin.options.paramsCasing
-      const transformedSchema = shouldTransform ? applyParamsCasing(schema, plugin.options.paramsCasing) : schema
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+      >
+        <File.Import name={locale ? [{ propertyName: localeToFakerImport(locale), name: 'faker' }] : ['faker']} path="@faker-js/faker" />
+        {regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
+        {dateParser !== 'faker' && <File.Import path={dateParser} name={dateParser} />}
+        {typeReference.importPath && <File.Import isTypeOnly root={meta.file.path} path={typeReference.importPath} name={[meta.typeName]} />}
+        {mode === 'split' &&
+          usedImports.map((imp) => <File.Import key={[schemaName, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+        <Faker
+          name={meta.name}
+          typeName={typeReference.typeName}
+          description={schemaNode.description}
+          node={schemaNode}
+          printer={printerInstance}
+          seed={seed}
+          canOverride={canOverride}
+        />
+      </File>
+    )
+  },
+  operation(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, group, paramsCasing, dateParser, regexGenerator, mapper, seed, locale, printer } = ctx.options
+    const pluginTs = ctx.driver.getPlugin(pluginTsName)
+
+    if (!pluginTs) {
+      return
+    }
 
-      const tree = schemaGenerator.parse({ schema: transformedSchema, name, parentName: null })
-      const imports = getImports(tree)
-      const group = options.operation ? getGroup(options.operation) : undefined
+    const tsResolver = ctx.driver.getResolver(pluginTsName)
 
-      const faker = {
-        name: schemaManager.getName(name, { type: 'function' }),
-        file: schemaManager.getFile(name),
-      }
+    const params = ast.caseParams(node.parameters, paramsCasing)
+    const paramEntries = params.map((param) => ({
+      param,
+      name: resolveParamNameByLocation(resolver, node, param),
+      typeName: resolveParamNameByLocation(tsResolver, node, param),
+    }))
+    const responseEntries = node.responses.map((response) => ({
+      response,
+      name: resolver.resolveResponseStatusName(node, response.statusCode),
+      typeName: tsResolver.resolveResponseStatusName(node, response.statusCode),
+    }))
+    const dataEntry = node.requestBody?.content?.[0]?.schema
+      ? {
+          schema: {
+            ...node.requestBody.content![0]!.schema!,
+            description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
+          },
+          name: resolver.resolveDataName(node),
+          typeName: tsResolver.resolveDataName(node),
+          description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
+        }
+      : null
+    const responseName = resolver.resolveResponseName(node)
+    const localHelperNames = new Set([
+      ...paramEntries.map((entry) => entry.name),
+      ...responseEntries.map((entry) => entry.name),
+      ...(dataEntry ? [dataEntry.name] : []),
+      responseName,
+    ])
+    const meta = {
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+      typeFile: tsResolver.resolveFile(
+        {
+          name: node.operationId,
+          extname: '.ts',
+          tag: node.tags[0] ?? 'default',
+          path: node.path,
+        },
+        {
+          root,
+          output: pluginTs.options?.output ?? output,
+          group: pluginTs.options?.group,
+        },
+      ),
+    } as const
 
-      const type = {
-        name: schemaManager.getName(name, { type: 'type', pluginName: pluginTsName }),
-        file: schemaManager.getFile(options.operationName || name, { pluginName: pluginTsName, group }),
+    function resolveMockImports(schema: ast.SchemaNode) {
+      return adapter
+        .getImports(schema, (schemaName) => ({
+          name: resolver.resolveName(schemaName),
+          path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+        }))
+        .filter((entry) => entry.path !== meta.file.path)
+    }
+
+    function renderEntry({
+      schema,
+      name,
+      typeName,
+      description,
+      skipImportNames = [],
+    }: {
+      schema: ast.SchemaNode | null
+      name: string
+      typeName: string
+      description?: string
+      skipImportNames?: Array<string>
+    }) {
+      if (!schema) {
+        return null
       }
 
-      const canOverride = tree.some(
-        ({ keyword }) =>
-          keyword === schemaKeywords.array ||
-          keyword === schemaKeywords.and ||
-          keyword === schemaKeywords.object ||
-          keyword === schemaKeywords.union ||
-          keyword === schemaKeywords.tuple ||
-          keyword === schemaKeywords.enum ||
-          keyword === schemaKeywords.ref,
-      )
+      const canOverride = canOverrideSchema(schema)
+      const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
+      const printerInstance = printerFaker({
+        resolver,
+        schemaName: name,
+        typeName,
+        dateParser,
+        regexGenerator,
+        mapper,
+        nodes: printer?.nodes,
+        cyclicSchemas,
+      })
+      const fakerText = printerInstance.print(schema) ?? 'undefined'
+      const usedImports = filterUsedImports(resolveMockImports(schema), fakerText, skipImportNames)
+      const { imports, aliases } = aliasConflictingImports(usedImports, localHelperNames)
+      const rewrittenFakerText = rewriteAliasedImports(fakerText, aliases)
+      const typeReference = resolveTypeReference({
+        node: schema,
+        canOverride,
+        name,
+        typeName,
+        filePath: meta.file.path,
+        typeFilePath: meta.typeFile.path,
+      })
 
       return (
         <>
-          {canOverride && <File.Import isTypeOnly root={file.path} path={type.file.path} name={[type.name]} />}
+          {typeReference.importPath && <File.Import isTypeOnly root={meta.file.path} path={typeReference.importPath} name={[typeName]} />}
           {imports.map((imp) => (
-            <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} />
+            <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />
           ))}
           <Faker
-            name={faker.name}
-            typeName={type.name}
+            name={name}
+            typeName={typeReference.typeName}
             description={description}
-            tree={tree}
-            regexGenerator={regexGenerator}
-            dateParser={dateParser}
-            mapper={mapper}
+            node={schema}
+            printer={{ ...printerInstance, print: () => rewrittenFakerText }}
             seed={seed}
             canOverride={canOverride}
           />
@@ -91,79 +227,44 @@ export const fakerGenerator = createReactGenerator<PluginFaker>({
 
     return (
       <File
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-        banner={getBanner({ oas, output: plugin.options.output, config: driver.config })}
-        footer={getFooter({ oas, output: plugin.options.output })}
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
-        <File.Import name={['faker']} path="@faker-js/faker" />
+        <File.Import name={locale ? [{ propertyName: localeToFakerImport(locale), name: 'faker' }] : ['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, plugin }) {
-    const { getName, getFile } = useSchemaManager()
-    const {
-      options: { output, dateParser, regexGenerator, seed, mapper },
-    } = plugin
-    const driver = usePluginDriver()
-    const oas = useOas()
-    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', pluginName: pluginTsName }),
-      file: getFile(schema.name, { pluginName: pluginTsName }),
-    }
-
-    const canOverride = schema.tree.some(
-      ({ keyword }) =>
-        keyword === schemaKeywords.array ||
-        keyword === schemaKeywords.and ||
-        keyword === schemaKeywords.object ||
-        keyword === schemaKeywords.union ||
-        keyword === schemaKeywords.tuple ||
-        keyword === schemaKeywords.ref ||
-        keyword === schemaKeywords.enum ||
-        keyword === schemaKeywords.string ||
-        keyword === schemaKeywords.integer ||
-        keyword === schemaKeywords.number,
-    )
-
-    return (
-      <File
-        baseName={faker.file.baseName}
-        path={faker.file.path}
-        meta={faker.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
-      >
-        <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) => (
-          <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} 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}
-        />
+        {paramEntries.map(({ param, name, typeName }) =>
+          renderEntry({
+            schema: param.schema,
+            name,
+            typeName,
+          }),
+        )}
+        {responseEntries.map(({ response, name, typeName }) =>
+          renderEntry({
+            schema: response.schema,
+            name,
+            typeName,
+            description: response.description,
+          }),
+        )}
+        {dataEntry
+          ? renderEntry({
+              schema: dataEntry.schema,
+              name: dataEntry.name,
+              typeName: dataEntry.typeName,
+              description: dataEntry.description,
+            })
+          : null}
+        {renderEntry({
+          schema: buildResponseUnionSchema(node, resolver),
+          name: responseName,
+          typeName: tsResolver.resolveResponseName(node),
+          skipImportNames: responseEntries.map(({ name }) => name),
+        })}
       </File>
     )
   },

package/src/index.ts

@@ -1,2 +1,7 @@
-export { pluginFaker, pluginFakerName } from './plugin.ts'
-export type { PluginFaker } from './types.ts'
+export { Faker } from './components/Faker.tsx'
+export { fakerGenerator } from './generators/fakerGenerator.tsx'
+export { default, pluginFaker, pluginFakerName } from './plugin.ts'
+export type { PrinterFakerFactory, PrinterFakerNodes, PrinterFakerOptions } from './printers/printerFaker.ts'
+export { printerFaker } from './printers/printerFaker.ts'
+export { resolverFaker } from './resolvers/resolverFaker.ts'
+export type { PluginFaker, ResolverFaker } from './types.ts'

package/src/plugin.ts

@@ -1,149 +1,88 @@
-import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode } from '@kubb/core'
-import { OperationGenerator, pluginOasName, SchemaGenerator } from '@kubb/plugin-oas'
+import { definePlugin, type Group } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { fakerGenerator } from './generators/fakerGenerator.tsx'
+import { resolverFaker } from './resolvers/resolverFaker.ts'
 import type { PluginFaker } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-faker`, used in driver lookups and warnings.
+ */
 export const pluginFakerName = 'plugin-faker' satisfies PluginFaker['name']
 
-export const pluginFaker = createPlugin<PluginFaker>((options) => {
+/**
+ * Generates Faker mock data factories from OpenAPI/AST specification.
+ *
+ * Creates randomized test data and mock helpers from schema definitions.
+ *
+ * @example
+ * `import pluginFaker from '@kubb/plugin-faker'; export default defineConfig({ plugins: [pluginFaker({ output: { path: 'mocks' } })], })`
+ */
+export const pluginFaker = definePlugin<PluginFaker>((options) => {
   const {
     output = { path: 'mocks', barrelType: 'named' },
     seed,
+    locale,
     group,
     exclude = [],
     include,
     override = [],
-    transformers = {},
     mapper = {},
-    unknownType = 'any',
-    emptySchemaType = unknownType,
-    dateType = 'string',
-    integerType = 'number',
     dateParser = 'faker',
-    generators = [fakerGenerator].filter(Boolean),
+    generators: userGenerators = [],
     regexGenerator = 'faker',
     paramsCasing,
-    contentType,
+    printer,
+    resolver: userResolver,
+    transformer: userTransformer,
   } = options
 
-  // @deprecated Will be removed in v5 when collisionDetection defaults to true
-  const usedEnumNames = {}
-
-  return {
-    name: pluginFakerName,
-    options: {
-      output,
-      transformers,
-      seed,
-      dateType,
-      integerType,
-      unknownType,
-      emptySchemaType,
-      dateParser,
-      mapper,
-      override,
-      regexGenerator,
-      paramsCasing,
-      group,
-      usedEnumNames,
-    },
-    pre: [pluginOasName, pluginTsName],
-    resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? getMode(path.resolve(root, output.path))
-
-      if (mode === 'single') {
-        /**
-         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
-         */
-        return path.resolve(root, output.path)
-      }
-
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: Group['name'] = group?.name
+  const groupConfig = group
+    ? ({
+        ...group,
+        name: group.name
           ? group.name
-          : (ctx) => {
-              if (group?.type === 'path') {
+          : (ctx: { group: string }) => {
+              if (group.type === 'path') {
                 return `${ctx.group.split('/')[1]}`
               }
-              return `${camelCase(ctx.group)}Controller`
-            }
-
-        return path.resolve(
-          root,
-          output.path,
-          groupName({
-            group: group.type === 'path' ? options.group.path! : options.group.tag!,
-          }),
-          baseName,
-        )
-      }
-
-      return path.resolve(root, output.path, baseName)
-    },
-    resolveName(name, type) {
-      const resolvedName = camelCase(name, {
-        prefix: type ? 'create' : undefined,
-        isFile: type === 'file',
-      })
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
-      }
 
-      return resolvedName
-    },
-    async install() {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = getMode(path.resolve(root, output.path))
-      const oas = await this.getOas()
-
-      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        include: undefined,
-        override,
-        mode,
-        output: output.path,
-      })
-
-      const schemaFiles = await schemaGenerator.build(...generators)
-      await this.upsertFile(...schemaFiles)
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
-      })
-
-      const operationFiles = await operationGenerator.build(...generators)
-      await this.upsertFile(...operationFiles)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
+              return `${camelCase(ctx.group)}Controller`
+            },
+      } satisfies Group)
+    : undefined
 
-      await this.upsertFile(...barrelFiles)
+  return {
+    name: pluginFakerName,
+    options,
+    dependencies: [pluginTsName],
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        ctx.setOptions({
+          output,
+          seed,
+          locale,
+          exclude,
+          include,
+          override,
+          group: groupConfig,
+          mapper,
+          dateParser,
+          regexGenerator,
+          paramsCasing,
+          printer,
+        })
+        ctx.setResolver(userResolver ? { ...resolverFaker, ...userResolver } : resolverFaker)
+        if (userTransformer) {
+          ctx.setTransformer(userTransformer)
+        }
+        ctx.addGenerator(fakerGenerator)
+        for (const generator of userGenerators) {
+          ctx.addGenerator(generator)
+        }
+      },
     },
   }
 })
+
+export default pluginFaker