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

package/src/printers/printerFaker.ts

@@ -1,341 +0,0 @@
-import { stringify, toRegExpString } from '@internals/utils'
-import { ast } from '@kubb/core'
-import type { PluginFaker, ResolverFaker } from '../types.ts'
-
-/**
- * Partial printer nodes for Faker generation, mapping schema types to output strings.
- */
-export type PrinterFakerNodes = ast.PrinterPartial<string, PrinterFakerOptions>
-
-/**
- * Configuration options for the Faker printer, including resolvers, mappers, and cyclic schema tracking.
- */
-export type PrinterFakerOptions = {
-  dateParser?: PluginFaker['resolvedOptions']['dateParser']
-  regexGenerator?: PluginFaker['resolvedOptions']['regexGenerator']
-  mapper?: PluginFaker['resolvedOptions']['mapper']
-  resolver: ResolverFaker
-  typeName?: string
-  schemaName?: string
-  nestedInObject?: boolean
-  nodes?: PrinterFakerNodes
-  /**
-   * Names of schemas that participate in a circular dependency chain.
-   * Properties whose schema transitively references one of these are emitted
-   * as lazy getters so that user overrides via the `data` parameter prevent
-   * the recursive faker call from ever executing (avoiding stack overflow).
-   */
-  cyclicSchemas?: ReadonlySet<string>
-}
-
-/**
- * Factory options for the Faker printer, defining input/output types and configuration.
- */
-export type PrinterFakerFactory = ast.PrinterFactoryOptions<'faker', PrinterFakerOptions, string, string>
-
-const fakerKeywordMapper = {
-  any: () => 'undefined',
-  unknown: () => 'undefined',
-  void: () => 'undefined',
-  number: (min?: number, max?: number) => {
-    if (max !== undefined && min !== undefined) {
-      return `faker.number.float({ min: ${min}, max: ${max} })`
-    }
-
-    if (max !== undefined) {
-      return `faker.number.float({ max: ${max} })`
-    }
-
-    if (min !== undefined) {
-      return `faker.number.float({ min: ${min} })`
-    }
-
-    return 'faker.number.float()'
-  },
-  integer: (min?: number, max?: number) => {
-    if (max !== undefined && min !== undefined) {
-      return `faker.number.int({ min: ${min}, max: ${max} })`
-    }
-
-    if (max !== undefined) {
-      return `faker.number.int({ max: ${max} })`
-    }
-
-    if (min !== undefined) {
-      return `faker.number.int({ min: ${min} })`
-    }
-
-    return 'faker.number.int()'
-  },
-  bigint: () => 'faker.number.bigInt()',
-  string: (min?: number, max?: number) => {
-    if (max !== undefined && min !== undefined) {
-      return `faker.string.alpha({ length: { min: ${min}, max: ${max} } })`
-    }
-
-    if (max !== undefined) {
-      return `faker.string.alpha({ length: ${max} })`
-    }
-
-    if (min !== undefined) {
-      return `faker.string.alpha({ length: ${min} })`
-    }
-
-    return 'faker.string.alpha()'
-  },
-  boolean: () => 'faker.datatype.boolean()',
-  null: () => 'null',
-  array: (items: string[] = [], min?: number, max?: number) => {
-    if (items.length > 1) {
-      return `faker.helpers.arrayElements([${items.join(', ')}])`
-    }
-
-    const item = items.at(0)
-
-    if (min !== undefined && max !== undefined) {
-      return `faker.helpers.multiple(() => (${item}), { count: { min: ${min}, max: ${max} }})`
-    }
-
-    if (min !== undefined) {
-      return `faker.helpers.multiple(() => (${item}), { count: ${min} })`
-    }
-
-    if (max !== undefined) {
-      return `faker.helpers.multiple(() => (${item}), { count: { min: 0, max: ${max} }})`
-    }
-
-    return `faker.helpers.multiple(() => (${item}))`
-  },
-  tuple: (items: string[] = []) => `[${items.join(', ')}]`,
-  enum: (items: Array<string | number | boolean | undefined> = [], type = 'any') => `faker.helpers.arrayElement<${type}>([${items.join(', ')}])`,
-  union: (items: string[] = []) => `faker.helpers.arrayElement<any>([${items.join(', ')}])`,
-  datetime: () => 'faker.date.anytime().toISOString()',
-  date: (representation: 'date' | 'string' = 'string', parser: PluginFaker['resolvedOptions']['dateParser'] = 'faker') => {
-    if (representation === 'string') {
-      if (parser !== 'faker') {
-        return `${parser}(faker.date.anytime()).format("YYYY-MM-DD")`
-      }
-
-      return 'faker.date.anytime().toISOString().substring(0, 10)'
-    }
-
-    if (parser !== 'faker') {
-      throw new Error(`type '${representation}' and parser '${parser}' can not work together`)
-    }
-
-    return 'faker.date.anytime()'
-  },
-  time: (representation: 'date' | 'string' = 'string', parser: PluginFaker['resolvedOptions']['dateParser'] = 'faker') => {
-    if (representation === 'string') {
-      if (parser !== 'faker') {
-        return `${parser}(faker.date.anytime()).format("HH:mm:ss")`
-      }
-
-      return 'faker.date.anytime().toISOString().substring(11, 19)'
-    }
-
-    if (parser !== 'faker') {
-      throw new Error(`type '${representation}' and parser '${parser}' can not work together`)
-    }
-
-    return 'faker.date.anytime()'
-  },
-  uuid: () => 'faker.string.uuid()',
-  url: () => 'faker.internet.url()',
-  and: (items: string[] = []) => {
-    if (items.length === 0) {
-      return '{}'
-    }
-
-    if (items.length === 1) {
-      return items[0] ?? '{}'
-    }
-
-    return `{...${items.join(', ...')}}`
-  },
-  matches: (value = '', regexGenerator: 'faker' | 'randexp' = 'faker') => {
-    if (regexGenerator === 'randexp') {
-      return `${toRegExpString(value, 'RandExp')}.gen()`
-    }
-
-    return `faker.helpers.fromRegExp("${value}")`
-  },
-  email: () => 'faker.internet.email()',
-  blob: () => 'faker.image.url() as unknown as Blob',
-} as const
-
-function getEnumValues(node: ast.EnumSchemaNode): Array<string | number | boolean | undefined> {
-  if (node.namedEnumValues?.length) {
-    return node.namedEnumValues.map((item) => item.value as string | number | boolean | undefined)
-  }
-
-  return (node.enumValues ?? []) as Array<string | number | boolean | undefined>
-}
-
-function parseEnumValue(value: string | number | boolean | undefined) {
-  if (typeof value === 'string') {
-    return stringify(value)
-  }
-
-  return value
-}
-
-/**
- * Creates a Faker printer that generates mock data generation code from schema nodes.
- * Handles circular references gracefully by emitting memoizing getters for cyclic properties.
- */
-export const printerFaker: (options: PrinterFakerOptions) => ast.Printer<PrinterFakerFactory> = ast.definePrinter<PrinterFakerFactory>((options) => {
-  const printNested = (node: ast.SchemaNode, overrideOptions: Partial<PrinterFakerOptions> = {}): string => {
-    return (
-      printerFaker({
-        ...options,
-        ...overrideOptions,
-        nodes: options.nodes,
-      }).print(node) ?? 'undefined'
-    )
-  }
-
-  return {
-    name: 'faker',
-    options,
-    nodes: {
-      any: () => fakerKeywordMapper.any(),
-      unknown: () => fakerKeywordMapper.unknown(),
-      void: () => fakerKeywordMapper.void(),
-      boolean: () => fakerKeywordMapper.boolean(),
-      null: () => fakerKeywordMapper.null(),
-      string(node) {
-        if (node.pattern) {
-          return fakerKeywordMapper.matches(node.pattern, this.options.regexGenerator)
-        }
-
-        return fakerKeywordMapper.string(node.min, node.max)
-      },
-      email: () => fakerKeywordMapper.email(),
-      url: () => fakerKeywordMapper.url(),
-      uuid: () => fakerKeywordMapper.uuid(),
-      number(node) {
-        return fakerKeywordMapper.number(node.min, node.max)
-      },
-      integer(node) {
-        return fakerKeywordMapper.integer(node.min, node.max)
-      },
-      bigint: () => fakerKeywordMapper.bigint(),
-      blob: () => fakerKeywordMapper.blob(),
-      datetime: () => fakerKeywordMapper.datetime(),
-      date(node) {
-        return fakerKeywordMapper.date(node.representation ?? 'string', this.options.dateParser)
-      },
-      time(node) {
-        return fakerKeywordMapper.time(node.representation ?? 'string', this.options.dateParser)
-      },
-      ref(node) {
-        // Parser-generated refs (with $ref) carry raw schema names that need resolving.
-        // Use the canonical name from the $ref path — node.name may have been overridden
-        // (e.g. by single-member allOf flatten using the property-derived child name).
-        // Inline refs (without $ref) from faker utils already carry resolved helper names.
-        const refName = node.ref ? (ast.extractRefName(node.ref) ?? node.name ?? node.schema?.name) : (node.name ?? node.schema?.name)
-
-        if (!refName) {
-          throw new Error('Name not defined for ref node')
-        }
-
-        if (this.options.schemaName && refName === this.options.schemaName) {
-          return 'undefined as any'
-        }
-
-        // Internal helper refs (for generated response/data helpers) are already
-        // emitted with resolver output and should not be transformed twice.
-        const resolvedName = node.ref ? this.options.resolver.resolveName(refName) : refName
-
-        if (!this.options.nestedInObject) {
-          return `${resolvedName}(data)`
-        }
-
-        return `${resolvedName}()`
-      },
-      enum(node) {
-        return fakerKeywordMapper.enum(getEnumValues(node).map(parseEnumValue), this.options.typeName)
-      },
-      union(node): string {
-        const items: string[] = (node.members ?? [])
-          .map((member) =>
-            printNested(member, {
-              nestedInObject: true,
-            }),
-          )
-          .filter((item): item is string => Boolean(item))
-
-        return fakerKeywordMapper.union(items)
-      },
-      intersection(node): string {
-        const items: string[] = (node.members ?? [])
-          .map((member) =>
-            printNested(member, {
-              nestedInObject: true,
-            }),
-          )
-          .filter((item): item is string => Boolean(item))
-
-        return fakerKeywordMapper.and(items)
-      },
-      array(node): string {
-        const items: string[] = (node.items ?? [])
-          .map((member) =>
-            printNested(member, {
-              typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[number]` : undefined,
-              nestedInObject: true,
-            }),
-          )
-          .filter((item): item is string => Boolean(item))
-
-        return fakerKeywordMapper.array(items, node.min, node.max)
-      },
-      tuple(node): string {
-        const items: string[] = (node.items ?? [])
-          .map((member, index) =>
-            printNested(member, {
-              typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[${index}]` : undefined,
-              nestedInObject: true,
-            }),
-          )
-          .filter((item): item is string => Boolean(item))
-
-        return fakerKeywordMapper.tuple(items)
-      },
-      object(node): string {
-        const cyclicSchemas = this.options.cyclicSchemas
-        const properties = (node.properties ?? [])
-          .map((property): string => {
-            if (this.options.mapper && Object.hasOwn(this.options.mapper, property.name)) {
-              return `"${property.name}": ${this.options.mapper[property.name]}`
-            }
-
-            const value: string =
-              printNested(property.schema, {
-                typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[${JSON.stringify(property.name)}]` : undefined,
-                nestedInObject: true,
-              }) ?? 'undefined'
-
-            // When the property's schema transitively references a schema that is
-            // part of a circular dependency (other than the current schema itself),
-            // emit a memoizing lazy getter. On first access it computes the value,
-            // replaces itself with a plain data property via Object.defineProperty,
-            // and returns the cached value – so every subsequent read is stable.
-            if (cyclicSchemas && ast.containsCircularRef(property.schema, { circularSchemas: cyclicSchemas, excludeName: this.options.schemaName })) {
-              return `get ${property.name}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`
-            }
-
-            return `"${property.name}": ${value}`
-          })
-          .join(',')
-
-        return `{${properties}}`
-      },
-      ...options.nodes,
-    },
-    print(node) {
-      return this.transform(node) ?? null
-    },
-  }
-})

package/src/resolvers/resolverFaker.ts

@@ -1,85 +0,0 @@
-import { createHash } from 'node:crypto'
-import path from 'node:path'
-import { camelCase, isValidVarName } from '@internals/utils'
-import { defineResolver, PluginDriver } from '@kubb/core'
-import type { PluginFaker } from '../types.ts'
-
-/**
- * Naming convention resolver for Faker plugin.
- *
- * Provides default naming helpers using camelCase with a `create` prefix for factory functions and files.
- *
- * @example
- * `resolverFaker.default('list pets', 'function')  // → 'createListPets'`
- */
-export const resolverFaker = defineResolver<PluginFaker>(() => {
-  return {
-    name: 'default',
-    pluginName: 'plugin-faker',
-    default(name, type) {
-      const resolvedName = camelCase(name, { isFile: type === 'file', prefix: 'create' })
-
-      if (type === 'file' || isValidVarName(resolvedName)) {
-        return resolvedName
-      }
-
-      return `_${resolvedName}`
-    },
-    resolveName(name, type) {
-      return this.default(name, type)
-    },
-    resolvePathName(name, type) {
-      return this.default(name, type)
-    },
-    resolveFile({ name, extname, tag, path: groupPath }, context) {
-      const pathMode = PluginDriver.getMode(path.resolve(context.root, context.output.path))
-      const baseName = `${pathMode === 'single' ? '' : this.resolveName(name, 'file')}${extname}` as `${string}.${string}`
-      const filePath = this.resolvePath(
-        {
-          baseName,
-          pathMode,
-          tag,
-          path: groupPath,
-        },
-        context,
-      )
-
-      return {
-        kind: 'File',
-        id: createHash('sha256').update(filePath).digest('hex'),
-        name: path.basename(filePath, extname),
-        path: filePath,
-        baseName,
-        extname,
-        meta: { pluginName: this.pluginName },
-        sources: [],
-        imports: [],
-        exports: [],
-      }
-    },
-    resolveParamName(node, param) {
-      return this.resolveName(`${node.operationId} ${param.in} ${param.name}`)
-    },
-    resolveDataName(node) {
-      return this.resolveName(`${node.operationId} Data`)
-    },
-    resolveResponseStatusName(node, statusCode) {
-      return this.resolveName(`${node.operationId} Status ${statusCode}`)
-    },
-    resolveResponseName(node) {
-      return this.resolveName(`${node.operationId} Response`)
-    },
-    resolveResponsesName(node) {
-      return this.resolveName(`${node.operationId} Responses`)
-    },
-    resolvePathParamsName(node, param) {
-      return this.resolveParamName(node, param)
-    },
-    resolveQueryParamsName(node, param) {
-      return this.resolveParamName(node, param)
-    },
-    resolveHeaderParamsName(node, param) {
-      return this.resolveParamName(node, param)
-    },
-  }
-})

package/src/types.ts

@@ -1,179 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
-import type { PrinterFakerNodes } from './printers/printerFaker.ts'
-
-/**
- * Resolver for Faker that provides naming methods for mock functions.
- */
-export type ResolverFaker = Resolver &
-  ast.OperationParamsResolver & {
-    /**
-     * Resolves the faker function name for a schema.
-     *
-     * @example Resolving faker function names
-     * `resolver.resolveName('show pet by id') // -> 'showPetById'`
-     */
-    resolveName(this: ResolverFaker, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-    /**
-     * Resolves the output file name for a faker module.
-     *
-     * @example Resolving faker file names
-     * `resolver.resolvePathName('show pet by id', 'file') // -> 'showPetById'`
-     */
-    resolvePathName(this: ResolverFaker, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-    /**
-     * Resolves the faker function name for a request body.
-     *
-     * @example Resolving data function names
-     * `resolver.resolveDataName(node) // -> 'createPetsData'`
-     */
-    resolveDataName(this: ResolverFaker, node: ast.OperationNode): string
-    /**
-     * Resolves the faker function name for a response by status code.
-     *
-     * @example Response status names
-     * `resolver.resolveResponseStatusName(node, 200) // -> 'listPetsStatus200'`
-     */
-    resolveResponseStatusName(this: ResolverFaker, node: ast.OperationNode, statusCode: ast.StatusCode): string
-    /**
-     * Resolves the faker function name for the response union.
-     *
-     * @example Response union names
-     * `resolver.resolveResponseName(node) // -> 'listPetsResponse'`
-     */
-    resolveResponseName(this: ResolverFaker, node: ast.OperationNode): string
-    /**
-     * Resolves the faker function name for the response collection.
-     *
-     * @example Responses collection names
-     * `resolver.resolveResponsesName(node) // -> 'listPetsResponses'`
-     */
-    resolveResponsesName(this: ResolverFaker, node: ast.OperationNode): string
-    /**
-     * Resolves the faker function name for path parameters.
-     *
-     * @example Path parameters names
-     * `resolver.resolvePathParamsName(node, param) // -> 'showPetByIdPathPetId'`
-     */
-    resolvePathParamsName(this: ResolverFaker, node: ast.OperationNode, param: ast.ParameterNode): string
-    /**
-     * Resolves the faker function name for query parameters.
-     *
-     * @example Query parameters names
-     * `resolver.resolveQueryParamsName(node, param) // -> 'listPetsQueryLimit'`
-     */
-    resolveQueryParamsName(this: ResolverFaker, node: ast.OperationNode, param: ast.ParameterNode): string
-    /**
-     * Resolves the faker function name for header parameters.
-     *
-     * @example Header parameters names
-     * `resolver.resolveHeaderParamsName(node, param) // -> 'deletePetHeaderApiKey'`
-     */
-    resolveHeaderParamsName(this: ResolverFaker, node: ast.OperationNode, param: ast.ParameterNode): string
-  }
-
-export type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output.
-   * @default { path: 'mocks', barrelType: 'named' }
-   */
-  output?: Output
-  /**
-   * Group the Faker mocks based on the provided name.
-   */
-  group?: Group
-  /**
-   * Tags, operations, or paths to exclude from generation.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Tags, operations, or paths to include in generation.
-   */
-  include?: Array<Include>
-  /**
-   * Override options for specific tags, operations, or paths.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Parser to use when formatting date/time values as strings.
-   *
-   * @default 'faker'
-   */
-  dateParser?: 'faker' | 'dayjs' | 'moment' | (string & {})
-  /**
-   * Generator to use for RegExp patterns.
-   *
-   * @default 'faker'
-   */
-  regexGenerator?: 'faker' | 'randexp'
-  /**
-   * Provide per-property faker expressions keyed by property name.
-   */
-  mapper?: Record<string, string>
-  /**
-   * Locale for generating mock data.
-   * Imports the matching localized `@faker-js/faker` instance so names, addresses,
-   * and phone numbers reflect the target region.
-   *
-   * @default 'en'
-   *
-   * @example German
-   * `locale: 'de'`
-   *
-   * @example Austrian German
-   * `locale: 'de_AT'`
-   *
-   * @see https://fakerjs.dev/api/localization.html
-   */
-  locale?: string
-  /**
-   * Seed faker for deterministic output.
-   */
-  seed?: number | number[]
-  /**
-   * Apply casing to parameter names to match your configuration.
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * Additional generators alongside the default generators.
-   */
-  generators?: Array<Generator<PluginFaker>>
-  /**
-   * Override naming conventions for function names and types.
-   */
-  resolver?: Partial<ResolverFaker> & ThisType<ResolverFaker>
-  /**
-   * AST visitor to transform generated nodes.
-   */
-  transformer?: ast.Visitor
-  /**
-   * Override individual faker printer node handlers.
-   */
-  printer?: {
-    nodes?: PrinterFakerNodes
-  }
-}
-
-type ResolvedOptions = {
-  output: Output
-  group: Group | undefined
-  exclude: NonNullable<Options['exclude']>
-  include: Options['include']
-  override: NonNullable<Options['override']>
-  dateParser: NonNullable<Options['dateParser']>
-  regexGenerator: NonNullable<Options['regexGenerator']>
-  mapper: NonNullable<Options['mapper']>
-  seed: NonNullable<Options['seed']> | undefined
-  locale: Options['locale']
-  paramsCasing: Options['paramsCasing']
-  printer: Options['printer']
-}
-
-export type PluginFaker = PluginFactoryOptions<'plugin-faker', Options, ResolvedOptions, ResolverFaker>
-
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-faker': PluginFaker
-    }
-  }
-}