@kubb/plugin-faker 5.0.0-alpha.9 → 5.0.0-beta.100

package/src/parser.ts

@@ -1,453 +0,0 @@
-import { stringify, toRegExpString } from '@internals/utils'
-import type { Schema, SchemaKeywordMapper, SchemaMapper } from '@kubb/plugin-oas'
-import { createParser, findSchemaKeyword, isKeyword, schemaKeywords } from '@kubb/plugin-oas'
-import type { Options } from './types.ts'
-
-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()',
-  undefined: () => 'undefined',
-  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(', ')}])`,
-  /**
-   * ISO 8601
-   */
-  datetime: () => 'faker.date.anytime().toISOString()',
-  /**
-   * Type `'date'` Date
-   * Type `'string'` ISO date format (YYYY-MM-DD)
-   * @default ISO date format (YYYY-MM-DD)
-   */
-  date: (type: 'date' | 'string' = 'string', parser: Options['dateParser'] = 'faker') => {
-    if (type === '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 '${type}' and parser '${parser}' can not work together`)
-    }
-
-    return 'faker.date.anytime()'
-  },
-  /**
-   * Type `'date'` Date
-   * Type `'string'` ISO time format (HH:mm:ss[.SSSSSS])
-   * @default ISO time format (HH:mm:ss[.SSSSSS])
-   */
-  time: (type: 'date' | 'string' = 'string', parser: Options['dateParser'] = 'faker') => {
-    if (type === '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 '${type}' and parser '${parser}' can not work together`)
-    }
-
-    return 'faker.date.anytime()'
-  },
-  uuid: () => 'faker.string.uuid()',
-  url: () => 'faker.internet.url()',
-  and: (items: string[] = []) => {
-    // Handle empty array case
-    if (items.length === 0) {
-      return '{}'
-    }
-
-    // If only one item, return it as-is (no need to spread)
-    // This fixes the issue with single refs to primitives like enums
-    if (items.length === 1) {
-      return items[0] ?? '{}'
-    }
-
-    // If multiple items, spread them together
-    // This handles both object literals and multiple refs to objects
-    return `{...${items.join(', ...')}}`
-  },
-  object: () => 'object',
-  ref: () => 'ref',
-  matches: (value = '', regexGenerator: 'faker' | 'randexp' = 'faker') => {
-    if (regexGenerator === 'randexp') {
-      return `${toRegExpString(value, 'RandExp')}.gen()`
-    }
-    return `faker.helpers.fromRegExp("${value}")`
-  },
-  email: () => 'faker.internet.email()',
-  firstName: () => 'faker.person.firstName()',
-  lastName: () => 'faker.person.lastName()',
-  password: () => 'faker.internet.password()',
-  phone: () => 'faker.phone.number()',
-  blob: () => 'faker.image.url() as unknown as Blob',
-  default: undefined,
-  describe: undefined,
-  const: (value?: string | number) => (value as string) ?? '',
-  max: undefined,
-  min: undefined,
-  nullable: undefined,
-  nullish: undefined,
-  optional: undefined,
-  readOnly: undefined,
-  writeOnly: undefined,
-  deprecated: undefined,
-  example: undefined,
-  schema: undefined,
-  catchall: undefined,
-  name: undefined,
-  interface: undefined,
-  exclusiveMaximum: undefined,
-  exclusiveMinimum: undefined,
-} satisfies SchemaMapper<string | null | undefined>
-
-/**
- * @link based on https://github.com/cellular/oazapfts/blob/7ba226ebb15374e8483cc53e7532f1663179a22c/src/codegen/generate.ts#L398
- */
-
-function schemaKeywordSorter(_a: Schema, b: Schema) {
-  if (b.keyword === 'null') {
-    return -1
-  }
-
-  return 0
-}
-
-export function joinItems(items: string[]): string {
-  switch (items.length) {
-    case 0:
-      return 'undefined'
-    case 1:
-      return items[0]!
-    default:
-      return fakerKeywordMapper.union(items)
-  }
-}
-
-type ParserOptions = {
-  typeName?: string
-  rootTypeName?: string
-  regexGenerator?: 'faker' | 'randexp'
-  canOverride?: boolean
-  dateParser?: Options['dateParser']
-  mapper?: Record<string, string>
-}
-
-export const parse = createParser<string, ParserOptions>({
-  mapper: fakerKeywordMapper,
-  handlers: {
-    union(tree, options) {
-      const { current, schema, name, siblings } = tree
-
-      if (Array.isArray(current.args) && !current.args.length) {
-        return ''
-      }
-
-      return fakerKeywordMapper.union(
-        current.args
-          .map((it) => this.parse({ schema, parent: current, name, current: it, siblings }, { ...options, canOverride: false }))
-          .filter((x): x is string => Boolean(x)),
-      )
-    },
-    and(tree, options) {
-      const { current, schema, siblings } = tree
-
-      return fakerKeywordMapper.and(
-        current.args
-          .map((it) => this.parse({ schema, parent: current, current: it, siblings }, { ...options, canOverride: false }))
-          .filter((x): x is string => Boolean(x)),
-      )
-    },
-    array(tree, options) {
-      const { current, schema } = tree
-
-      return fakerKeywordMapper.array(
-        current.args.items
-          .map((it) =>
-            this.parse(
-              {
-                schema,
-                parent: current,
-                current: it,
-                siblings: current.args.items,
-              },
-              {
-                ...options,
-                typeName: `NonNullable<${options.typeName}>[number]`,
-                canOverride: false,
-              },
-            ),
-          )
-          .filter((x): x is string => Boolean(x)),
-        current.args.min,
-        current.args.max,
-      )
-    },
-    enum(tree, options) {
-      const { current, parent, name } = tree
-
-      const isParentTuple = parent ? isKeyword(parent, schemaKeywords.tuple) : false
-
-      if (isParentTuple) {
-        return fakerKeywordMapper.enum(
-          current.args.items.map((schema) => {
-            if (schema.format === 'number') {
-              return schema.value
-            }
-
-            if (schema.format === 'boolean') {
-              return schema.value
-            }
-            return stringify(schema.value)
-          }),
-        )
-      }
-
-      return fakerKeywordMapper.enum(
-        current.args.items.map((schema) => {
-          if (schema.format === 'number') {
-            return schema.value
-          }
-          if (schema.format === 'boolean') {
-            return schema.value
-          }
-          return stringify(schema.value)
-        }),
-        // TODO replace this with getEnumNameFromSchema
-        name ? options.typeName : undefined,
-      )
-    },
-    ref(tree, options) {
-      const { current, parent } = tree
-
-      if (!current.args?.name) {
-        throw new Error(`Name not defined for keyword ${current.keyword}`)
-      }
-
-      // Check if this is a self-referencing type (prevents infinite recursion)
-      // The rootTypeName is the function name being generated (e.g., "createNode")
-      // The current.args.name is the ref function name (e.g., "createNode")
-      const isSelfReferencing = options.rootTypeName && current.args.name === options.rootTypeName
-
-      if (isSelfReferencing) {
-        // For self-referencing types, return undefined to prevent infinite recursion
-        // This will result in empty arrays/objects by default
-        return 'undefined as any'
-      }
-
-      // Check if the parent is an object or and keyword - in these cases, we don't want to pass data
-      // because it would incorrectly forward the parent's data to a nested ref
-      const isNestedInObjectOrAnd = parent && (isKeyword(parent, schemaKeywords.object) || isKeyword(parent, schemaKeywords.and))
-
-      if (options.canOverride && !isNestedInObjectOrAnd) {
-        return `${current.args.name}(data)`
-      }
-
-      return `${current.args.name}()`
-    },
-    object(tree, options) {
-      const { current, schema } = tree
-
-      const argsObject = Object.entries(current.args?.properties || {})
-        .filter((item) => {
-          const schema = item[1]
-          return schema && typeof schema.map === 'function'
-        })
-        .map(([name, schemas]) => {
-          const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']
-          const mappedName = nameSchema?.args || name
-
-          // custom mapper(pluginOptions)
-          // Use Object.hasOwn to avoid matching inherited properties like 'toString', 'valueOf', etc.
-          if (options.mapper && Object.hasOwn(options.mapper, mappedName)) {
-            return `"${name}": ${options.mapper?.[mappedName]}`
-          }
-
-          return `"${name}": ${joinItems(
-            schemas
-              .sort(schemaKeywordSorter)
-              .map((it) =>
-                this.parse(
-                  {
-                    schema,
-                    name,
-                    parent: current,
-                    current: it,
-                    siblings: schemas,
-                  },
-                  {
-                    ...options,
-                    typeName: `NonNullable<${options.typeName}>[${JSON.stringify(name)}]`,
-                    canOverride: false,
-                  },
-                ),
-              )
-              .filter((x): x is string => Boolean(x)),
-          )}`
-        })
-        .join(',')
-
-      return `{${argsObject}}`
-    },
-    tuple(tree, options) {
-      const { current, schema, siblings } = tree
-
-      if (Array.isArray(current.args.items)) {
-        return fakerKeywordMapper.tuple(
-          current.args.items
-            .map((it) => this.parse({ schema, parent: current, current: it, siblings }, { ...options, canOverride: false }))
-            .filter((x): x is string => Boolean(x)),
-        )
-      }
-
-      return this.parse({ schema, parent: current, current: current.args.items, siblings }, { ...options, canOverride: false })
-    },
-    const(tree, _options) {
-      const { current } = tree
-
-      if (current.args.format === 'number' && current.args.name !== undefined) {
-        return fakerKeywordMapper.const(current.args.name?.toString())
-      }
-      return fakerKeywordMapper.const(stringify(current.args.value))
-    },
-    matches(tree, options) {
-      const { current } = tree
-
-      if (current.args) {
-        return fakerKeywordMapper.matches(current.args, options.regexGenerator)
-      }
-      return undefined
-    },
-    null() {
-      return fakerKeywordMapper.null()
-    },
-    undefined() {
-      return fakerKeywordMapper.undefined()
-    },
-    any() {
-      return fakerKeywordMapper.any()
-    },
-    string(tree, _options) {
-      const { siblings } = tree
-
-      if (siblings) {
-        const minSchema = findSchemaKeyword(siblings, 'min')
-        const maxSchema = findSchemaKeyword(siblings, 'max')
-
-        return fakerKeywordMapper.string(minSchema?.args, maxSchema?.args)
-      }
-
-      return fakerKeywordMapper.string()
-    },
-    number(tree, _options) {
-      const { siblings } = tree
-
-      if (siblings) {
-        const minSchema = findSchemaKeyword(siblings, 'min')
-        const maxSchema = findSchemaKeyword(siblings, 'max')
-
-        return fakerKeywordMapper.number(minSchema?.args, maxSchema?.args)
-      }
-
-      return fakerKeywordMapper.number()
-    },
-    integer(tree, _options) {
-      const { siblings } = tree
-
-      if (siblings) {
-        const minSchema = findSchemaKeyword(siblings, 'min')
-        const maxSchema = findSchemaKeyword(siblings, 'max')
-
-        return fakerKeywordMapper.integer(minSchema?.args, maxSchema?.args)
-      }
-
-      return fakerKeywordMapper.integer()
-    },
-    bigint(_tree, _options) {
-      return fakerKeywordMapper.bigint()
-    },
-    datetime() {
-      return fakerKeywordMapper.datetime()
-    },
-    date(tree, options) {
-      const { current } = tree
-
-      return fakerKeywordMapper.date(current.args.type, options.dateParser)
-    },
-    time(tree, options) {
-      const { current } = tree
-
-      return fakerKeywordMapper.time(current.args.type, options.dateParser)
-    },
-  },
-})

package/src/plugin.ts

@@ -1,149 +0,0 @@
-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 { pluginTsName } from '@kubb/plugin-ts'
-import { fakerGenerator } from './generators/fakerGenerator.tsx'
-import type { PluginFaker } from './types.ts'
-
-export const pluginFakerName = 'plugin-faker' satisfies PluginFaker['name']
-
-export const pluginFaker = createPlugin<PluginFaker>((options) => {
-  const {
-    output = { path: 'mocks', barrelType: 'named' },
-    seed,
-    group,
-    exclude = [],
-    include,
-    override = [],
-    transformers = {},
-    mapper = {},
-    unknownType = 'any',
-    emptySchemaType = unknownType,
-    dateType = 'string',
-    integerType = 'number',
-    dateParser = 'faker',
-    generators = [fakerGenerator].filter(Boolean),
-    regexGenerator = 'faker',
-    paramsCasing,
-    contentType,
-  } = 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
-          ? group.name
-          : (ctx) => {
-              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,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
-    },
-  }
-})