@kubb/plugin-faker 5.0.0-beta.10 → 5.0.0-beta.103

package/src/components/Faker.tsx

@@ -1,153 +0,0 @@
-import { jsStringEscape } from '@internals/utils'
-import { ast } from '@kubb/core'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PrinterFakerFactory } from '../printers/printerFaker.ts'
-import type { PluginFaker } from '../types.ts'
-import { resolveFakerTypeUsage } from '../utils.ts'
-
-type Props = {
-  name: string
-  typeName: string
-  node: ast.SchemaNode
-  printer: ast.Printer<PrinterFakerFactory>
-  seed?: PluginFaker['options']['seed']
-  description?: string
-  canOverride: boolean
-}
-
-const OBJECT_TYPES = new Set<ast.SchemaNode['type']>(['object', 'intersection'])
-const ARRAY_TYPES = new Set<ast.SchemaNode['type']>(['array'])
-const SCALAR_TYPES = new Set<ast.SchemaNode['type']>([
-  'string',
-  'email',
-  'url',
-  'uuid',
-  'number',
-  'integer',
-  'bigint',
-  'boolean',
-  'date',
-  'time',
-  'datetime',
-  'blob',
-  'enum',
-])
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-export function Faker({ node, description, name, typeName, printer, seed, canOverride }: Props): KubbReactNode {
-  const fakerText = printer.print(node) ?? 'undefined'
-
-  const isArray = ARRAY_TYPES.has(node.type)
-  const isObject = OBJECT_TYPES.has(node.type)
-  const isTuple = node.type === 'tuple'
-  const isScalar = SCALAR_TYPES.has(node.type)
-
-  let fakerTextWithOverride = fakerText
-  let useGenericOverride = false
-
-  if (canOverride && isObject) {
-    useGenericOverride = true
-  }
-
-  if (canOverride && isTuple) {
-    fakerTextWithOverride = `data || ${fakerText}`
-  }
-
-  if (canOverride && isArray) {
-    fakerTextWithOverride = `[
-  ...${fakerText},
-  ...(data || [])
-]`
-  }
-
-  if (canOverride && isScalar) {
-    fakerTextWithOverride = `data ?? ${fakerText}`
-  }
-
-  const { dataType, returnType: resolvedReturnType } = resolveFakerTypeUsage(node, typeName, canOverride)
-
-  let functionSignature = ''
-  let functionBody = ''
-
-  if (useGenericOverride) {
-    // Generate function with defaultFakeData structure
-    const jsdoc = description ? `/**\n   * @description ${jsStringEscape(description)}\n   */\n  ` : ''
-    functionSignature = `${jsdoc}export function ${name}(data?: Partial<${typeName}>): Required<${typeName}>`
-
-    const seedCode = seed ? `faker.seed(${JSON.stringify(seed)})\n  ` : ''
-
-    // When the object node has properties that transitively reference a cyclic schema,
-    // the printer emits memoizing getters for those properties. Spreading the object
-    // literal would immediately invoke those getters, triggering recursive faker calls
-    // and causing a stack overflow. Detect this upfront via ast helpers so we can
-    // use Object.defineProperty-based merging instead of spread.
-    const { cyclicSchemas, schemaName } = printer.options
-    const hasGetters =
-      node.type === 'object' &&
-      !!cyclicSchemas &&
-      (node.properties ?? []).some((p) => ast.containsCircularRef(p.schema, { circularSchemas: cyclicSchemas, excludeName: schemaName }))
-
-    if (hasGetters) {
-      functionBody = `{
-  ${seedCode}const defaultFakeData = ${fakerText}
-  if (data) {
-    for (const [key, value] of Object.entries(data)) {
-      Object.defineProperty(defaultFakeData, key, { value, configurable: true, writable: true, enumerable: true })
-    }
-  }
-  return defaultFakeData as Required<${typeName}>
-}`
-    } else {
-      functionBody = `{
-  ${seedCode}const defaultFakeData = ${fakerText}
-  return {
-    ...defaultFakeData,
-    ...(data || {}),
-  } as Required<${typeName}>
-}`
-    }
-  } else {
-    const usesData = /\bdata\b/.test(fakerTextWithOverride)
-    const dataParamName = usesData ? 'data' : '_data'
-    const params = ast.createFunctionParameters({
-      params: [
-        ast.createFunctionParameter({
-          name: dataParamName,
-          type: ast.createParamsType({ variant: 'reference', name: dataType }),
-          optional: true,
-        }),
-      ],
-    })
-    const paramsSignature = declarationPrinter.print(params) ?? ''
-    const returnType = resolvedReturnType
-
-    return (
-      <File.Source name={name} isExportable isIndexable>
-        <Function
-          export
-          name={name}
-          JSDoc={{ comments: description ? [`@description ${jsStringEscape(description)}`] : [] }}
-          params={canOverride ? paramsSignature : undefined}
-          returnType={returnType}
-        >
-          {seed ? (
-            <>
-              {`faker.seed(${JSON.stringify(seed)})`}
-              <br />
-            </>
-          ) : undefined}
-          {`return ${fakerTextWithOverride}`}
-        </Function>
-      </File.Source>
-    )
-  }
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      {functionSignature}
-      {functionBody}
-    </File.Source>
-  )
-}

package/src/components/index.ts

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

package/src/generators/fakerGenerator.tsx

@@ -1,269 +0,0 @@
-import { aliasConflictingImports, filterUsedImports, rewriteAliasedImports } from '@internals/utils'
-import { ast, defineGenerator } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-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 {
-  buildResponseUnionSchema,
-  canOverrideSchema,
-  localeToFakerImport,
-  resolveParamNameByLocation,
-  resolveSchemaRef,
-  resolveTypeReference,
-} from '../utils.ts'
-
-export const fakerGenerator = defineGenerator<PluginFaker>({
-  name: 'faker',
-  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)
-
-    if (!node.name || !pluginTs || !adapter.inputNode) {
-      return
-    }
-
-    const tsResolver = ctx.driver.getResolver(pluginTsName)
-
-    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 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)
-
-    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 tsResolver = ctx.driver.getResolver(pluginTsName)
-
-    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
-
-    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 = 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 (
-        <>
-          {typeReference.importPath && <File.Import isTypeOnly root={meta.file.path} path={typeReference.importPath} name={[typeName]} />}
-          {imports.map((imp) => (
-            <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />
-          ))}
-          <Faker
-            name={name}
-            typeName={typeReference.typeName}
-            description={description}
-            node={schema}
-            printer={{ ...printerInstance, print: () => rewrittenFakerText }}
-            seed={seed}
-            canOverride={canOverride}
-          />
-        </>
-      )
-    }
-
-    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} />}
-        {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/generators/index.ts

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

package/src/index.ts

@@ -1,7 +0,0 @@
-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,88 +0,0 @@
-import { camelCase } from '@internals/utils'
-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']
-
-/**
- * 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 = [],
-    mapper = {},
-    dateParser = 'faker',
-    generators: userGenerators = [],
-    regexGenerator = 'faker',
-    paramsCasing,
-    printer,
-    resolver: userResolver,
-    transformer: userTransformer,
-  } = options
-
-  const groupConfig = group
-    ? ({
-        ...group,
-        name: group.name
-          ? group.name
-          : (ctx: { group: string }) => {
-              if (group.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-
-              return `${camelCase(ctx.group)}Controller`
-            },
-      } satisfies Group)
-    : undefined
-
-  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