@kubb/plugin-faker 5.0.0-beta.42 → 5.0.0-beta.64

package/src/components/Faker.tsx

@@ -1,139 +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)
-
-  const useGenericOverride = canOverride && isObject
-  const fakerTextWithOverride = (() => {
-    if (canOverride && isTuple) return `data || ${fakerText}`
-    if (canOverride && isArray) return `[\n  ...${fakerText},\n  ...(data || [])\n]`
-    if (canOverride && isScalar) return `data ?? ${fakerText}`
-    return fakerText
-  })()
-
-  const { dataType, returnType: resolvedReturnType } = resolveFakerTypeUsage(node, typeName, canOverride)
-
-  if (!useGenericOverride) {
-    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
-
-    // A `ref` wrapper delegates to another faker. Object fakers are now generic and
-    // widen to `Partial<T>` when called with a `Partial<T>`-typed argument, so cast
-    // back to the wrapper's declared return type to keep it assignable.
-    const returnExpression = node.type === 'ref' && canOverride && returnType ? `${fakerTextWithOverride} as ${returnType}` : fakerTextWithOverride
-
-    return (
-      <File.Source name={name} isExportable isIndexable>
-        <Function
-          export
-          name={name}
-          JSDoc={{ comments: description ? [`@description ${jsStringEscape(description)}`] : [] }}
-          params={canOverride ? paramsSignature : undefined}
-          returnType={returnType ?? undefined}
-        >
-          {seed ? (
-            <>
-              {`faker.seed(${JSON.stringify(seed)})`}
-              <br />
-            </>
-          ) : undefined}
-          {`return ${returnExpression}`}
-        </Function>
-      </File.Source>
-    )
-  }
-
-  // Generate function with defaultFakeData structure
-  const jsdoc = description ? `/**\n   * @description ${jsStringEscape(description)}\n   */\n  ` : ''
-  const functionSignature = `${jsdoc}export function ${name}<TData extends Partial<${typeName}> = object>(data?: TData)`
-
-  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 }))
-
-  const functionBody = hasGetters
-    ? `{
-  ${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 Omit<typeof defaultFakeData, keyof TData> & TData
-}`
-    : `{
-  ${seedCode}const defaultFakeData = ${fakerText}
-  return {
-    ...defaultFakeData,
-    ...(data || {}),
-  } as Omit<typeof defaultFakeData, keyof TData> & TData
-}`
-
-  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,311 +0,0 @@
-import { getPerContentTypeName, resolveContentTypeVariants } from '@internals/shared'
-import { aliasConflictingImports, filterUsedImports, rewriteAliasedImports } from '@internals/utils'
-import { ast, defineGenerator } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { File, jsxRendererSync } 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, resolveTypeReference } from '../utils.ts'
-
-/**
- * Built-in generator for `@kubb/plugin-faker`. Emits one `createX` factory
- * per schema in the spec plus per-operation request/response factories. Each
- * factory returns a value matching the corresponding TypeScript type from
- * `@kubb/plugin-ts`.
- */
-export const fakerGenerator = defineGenerator<PluginFaker>({
-  name: 'faker',
-  renderer: jsxRendererSync,
-  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) {
-      return
-    }
-
-    const tsResolver = ctx.driver.getResolver(pluginTsName)
-
-    const schemaName = node.name
-    const mode = ctx.getMode(output)
-    const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum)
-    const tsEnumType = pluginTs.options?.enumType
-    const tsEnumTypeSuffix = pluginTs.options?.enumTypeSuffix ?? 'Key'
-    const schemaTypeName =
-      isEnumSchema && (tsEnumType === 'asConst' || tsEnumType === 'asPascalConst')
-        ? tsResolver.resolveEnumKeyName({ name: schemaName }, tsEnumTypeSuffix)
-        : tsResolver.resolveTypeName(schemaName)
-    const meta = {
-      name: resolver.resolveName(schemaName),
-      file: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }),
-      typeName: schemaTypeName,
-      typeFile: tsResolver.resolveFile(
-        { name: schemaName, extname: '.ts' },
-        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group ?? undefined },
-      ),
-    } as const
-    const canOverride = canOverrideSchema(node)
-    const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
-    const printerInstance = printerFaker({
-      resolver,
-      schemaName,
-      typeName: meta.typeName,
-      dateParser,
-      regexGenerator,
-      mapper,
-      nodes: printer?.nodes,
-      cyclicSchemas,
-    })
-    const fakerText = printerInstance.print(node) ?? 'undefined'
-    const typeReference = resolveTypeReference({
-      node,
-      canOverride,
-      name: meta.name,
-      typeName: meta.typeName,
-      filePath: meta.file.path,
-      typeFilePath: meta.typeFile.path,
-    })
-
-    const imports = adapter
-      .getImports(node, (schemaName) => ({
-        name: resolver.resolveName(schemaName),
-        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).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(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-      >
-        <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={node.description}
-          node={node}
-          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),
-    }))
-    type RenderUnit = { schema: ast.SchemaNode | null; name: string; typeName: string; description?: string; skipImportNames: Array<string> }
-
-    // Expands a content array into render units: one faker per content type plus a union faker
-    // (named `baseName`) when more than one content type carries a schema, else a single faker.
-    function expandContentUnits(
-      entries: Array<{ contentType: string; schema?: ast.SchemaNode | null }>,
-      baseName: string,
-      tsBaseName: string,
-      description: string | undefined,
-      decorate?: (schema: ast.SchemaNode) => ast.SchemaNode,
-    ): Array<RenderUnit> {
-      const withSchema = entries.filter((entry) => entry.schema)
-      if (withSchema.length <= 1) {
-        const primary = withSchema[0] ?? entries[0]
-        if (!primary?.schema) return []
-        return [{ schema: decorate ? decorate(primary.schema) : primary.schema, name: baseName, typeName: tsBaseName, description, skipImportNames: [] }]
-      }
-      const variants = resolveContentTypeVariants(entries, baseName)
-      const unionSchema = ast.createSchema({ type: 'union', members: variants.map((variant) => ast.createSchema({ type: 'ref', name: variant.name })) })
-      return [
-        ...variants.map((variant) => ({
-          schema: decorate ? decorate(variant.schema) : variant.schema,
-          name: variant.name,
-          typeName: getPerContentTypeName(tsBaseName, variant.suffix),
-          description,
-          skipImportNames: [],
-        })),
-        { schema: unionSchema, name: baseName, typeName: tsBaseName, description, skipImportNames: variants.map((variant) => variant.name) },
-      ]
-    }
-
-    const responseUnits = node.responses.flatMap((response) =>
-      expandContentUnits(
-        response.content ?? [],
-        resolver.resolveResponseStatusName(node, response.statusCode),
-        tsResolver.resolveResponseStatusName(node, response.statusCode),
-        response.description,
-      ),
-    )
-    const dataUnits = expandContentUnits(
-      node.requestBody?.content ?? [],
-      resolver.resolveDataName(node),
-      tsResolver.resolveDataName(node),
-      node.requestBody?.description,
-      (schema) => ({ ...schema, description: node.requestBody?.description ?? schema.description }),
-    )
-    const responseName = resolver.resolveResponseName(node)
-    const localHelperNames = new Set([
-      ...paramEntries.map((entry) => entry.name),
-      ...responseUnits.map((unit) => unit.name),
-      ...dataUnits.map((unit) => unit.name),
-      responseName,
-    ])
-    const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
-
-    const meta = {
-      file: resolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        { root, output, group: group ?? undefined },
-      ),
-      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 ?? undefined,
-        },
-      ),
-    } 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: group ?? undefined }).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 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(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-      >
-        <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,
-          }),
-        )}
-        {responseUnits.map((unit) =>
-          renderEntry({
-            schema: unit.schema,
-            name: unit.name,
-            typeName: unit.typeName,
-            description: unit.description,
-            skipImportNames: unit.skipImportNames,
-          }),
-        )}
-        {dataUnits.map((unit) =>
-          renderEntry({
-            schema: unit.schema,
-            name: unit.name,
-            typeName: unit.typeName,
-            description: unit.description,
-            skipImportNames: unit.skipImportNames,
-          }),
-        )}
-        {renderEntry({
-          schema: buildResponseUnionSchema(node, resolver),
-          name: responseName,
-          typeName: tsResolver.resolveResponseName(node),
-          skipImportNames: responseUnits.map((unit) => unit.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,92 +0,0 @@
-import { createGroupConfig } from '@internals/shared'
-import { definePlugin } 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 for driver lookups and
- * cross-plugin dependency references.
- */
-export const pluginFakerName = 'plugin-faker' satisfies PluginFaker['name']
-
-/**
- * Generates one mock-data factory per OpenAPI schema using Faker.js. Call
- * `createPet()` to get a realistic `Pet` object. Useful for tests, Storybook,
- * and local development without a running backend.
- *
- * @example
- * ```ts
- * import { defineConfig } from 'kubb'
- * import { pluginTs } from '@kubb/plugin-ts'
- * import { pluginFaker } from '@kubb/plugin-faker'
- *
- * export default defineConfig({
- *   input: { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   plugins: [
- *     pluginTs(),
- *     pluginFaker({
- *       output: { path: './mocks' },
- *       seed: [100],
- *     }),
- *   ],
- * })
- * ```
- */
-export const pluginFaker = definePlugin<PluginFaker>((options) => {
-  const {
-    output = { path: 'mocks', barrelType: 'named' },
-    seed,
-    locale = 'en',
-    group,
-    exclude = [],
-    include,
-    override = [],
-    mapper = {},
-    dateParser = 'faker',
-    generators: userGenerators = [],
-    regexGenerator = 'faker',
-    paramsCasing,
-    printer,
-    resolver: userResolver,
-    transformer: userTransformer,
-  } = options
-
-  const groupConfig = createGroupConfig(group, { suffix: 'Controller' })
-
-  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