chore: correct use of mapper

examples/advanced/configs/kubb.config.ts

@@ -162,6 +162,9 @@ export default defineConfig(async () => {
         ],
         group: { type: 'tag' },
         dateType: 'date',
+        mapper: {
+          status: `faker.helpers.arrayElement(['working', 'idle']) as any`,
+        },
       }),
       createSwaggerMsw({
         output: {

examples/advanced/src/gen/mocks/createAddPetRequest.ts

@@ -11,7 +11,7 @@ export function createAddPetRequest(override: NonNullable<Partial<AddPetRequest>
       category: createCategory(),
       photoUrls: faker.helpers.arrayElements([faker.string.alpha()]) as any,
       tags: faker.helpers.arrayElements([createTagTag()]) as any,
-      status: faker.helpers.arrayElement<any>(['available', 'pending', 'sold']),
+      status: faker.helpers.arrayElement(['working', 'idle']) as any,
     },
     ...override,
   }

examples/advanced/src/gen/mocks/createOrder.ts

@@ -10,7 +10,7 @@ export function createOrder(override: NonNullable<Partial<Order>> = {}): NonNull
       orderType: faker.helpers.arrayElement<any>(['foo', 'bar']),
       type: faker.string.alpha(),
       shipDate: faker.date.anytime(),
-      status: faker.helpers.arrayElement<any>(['placed', 'approved', 'delivered']),
+      status: faker.helpers.arrayElement(['working', 'idle']) as any,
       http_status: faker.helpers.arrayElement<any>(['ok', 'not_found']),
       complete: faker.datatype.boolean(),
     },

examples/advanced/src/gen/mocks/createPet.ts

@@ -11,7 +11,7 @@ export function createPet(override: NonNullable<Partial<Pet>> = {}): NonNullable
       category: createCategory(),
       photoUrls: faker.helpers.arrayElements([faker.string.alpha()]) as any,
       tags: faker.helpers.arrayElements([createTagTag()]) as any,
-      status: faker.helpers.arrayElement<any>(['available', 'pending', 'sold']),
+      status: faker.helpers.arrayElement(['working', 'idle']) as any,
     },
     ...override,
   }

examples/advanced/src/gen/mocks/petController/createFindPetsByStatus.ts

@@ -9,7 +9,7 @@ import { createPet } from '../createPet'
 
 export function createFindPetsByStatusQueryParams(override: NonNullable<Partial<FindPetsByStatusQueryParams>> = {}): NonNullable<FindPetsByStatusQueryParams> {
   return {
-    ...{ status: faker.helpers.arrayElement<any>(['available', 'pending', 'sold']) },
+    ...{ status: faker.helpers.arrayElement(['working', 'idle']) as any },
     ...override,
   }
 }

examples/advanced/src/gen/mocks/petController/createUpdatePetWithForm.ts

@@ -17,7 +17,7 @@ export function createUpdatePetWithFormQueryParams(
   override: NonNullable<Partial<UpdatePetWithFormQueryParams>> = {},
 ): NonNullable<UpdatePetWithFormQueryParams> {
   return {
-    ...{ name: faker.string.alpha(), status: faker.string.alpha() },
+    ...{ name: faker.string.alpha(), status: faker.helpers.arrayElement(['working', 'idle']) as any },
     ...override,
   }
 }

examples/faker/kubb.config.cjs

@@ -50,7 +50,7 @@ module.exports = defineConfig(async () => {
           },
         },
         mapper: {
-          message: () => 'faker.commerce.productName()',
+          message: 'faker.commerce.productName()',
         },
         include: [
           {

examples/faker/src/gen/customMocks/createApiResponse.ts

@@ -3,7 +3,7 @@ import type { ApiResponse } from '../models/ApiResponse'
 
 export function createApiResponse(override: NonNullable<Partial<ApiResponse>> = {}): NonNullable<ApiResponse> {
   return {
-    ...{ code: faker.number.int(), type: faker.string.alpha(), message: faker.string.alpha() },
+    ...{ code: faker.number.int(), type: faker.string.alpha(), message: faker.commerce.productName() },
     ...override,
   }
 }

package.json

@@ -38,7 +38,7 @@
     "lint": "bun biome lint ./packages",
     "lint:case": "npx case-police --fix",
     "lint:ci": "bun biome lint ./packages",
-    "lint:fix": "bun biome lint --apply ./packages && bun run lint:case",
+    "lint:fix": "bun biome lint --apply-unsafe ./packages && bun run lint:case",
     "lint:turbo": "turbo run lint",
     "release": "changeset publish",
     "release:canary": "changeset publish --no-git-tag",

packages/core/mocks/hellowWorld.js

@@ -1 +1 @@
-export const hallo = 'world'
+export const hallo = 'world'

packages/swagger-faker/src/SchemaGenerator.tsx

@@ -82,7 +82,7 @@ export class SchemaGenerator extends Generator<PluginOptions['resolvedOptions'],
       name: resolvedName,
       typeName,
       description,
-      mapper: this.options.mapper as typeof fakerKeywordMapper,
+      mapper: this.options.mapper,
       seed: this.options.seed,
     })
 

packages/swagger-faker/src/fakerParser.tsx

@@ -101,14 +101,14 @@ function schemaKeywordsorter(a: Schema, b: Schema) {
   return 0
 }
 
-function joinItems(items: string[], mapper: typeof fakerKeywordMapper): string {
+function joinItems(items: string[]): string {
   switch (items.length) {
     case 0:
       return 'undefined'
     case 1:
       return items[0]!
     default:
-      return mapper.union(items)
+      return fakerKeywordMapper.union(items)
   }
 }
 
@@ -119,31 +119,30 @@ type ParserOptions = {
 
   seed?: number | number[]
   withOverride?: boolean
-  mapper?: typeof fakerKeywordMapper
+  mapper?: Record<string, string>
 }
 
 export function parseFakerMeta(parent: Schema | undefined, current: Schema, options: ParserOptions): string | null | undefined {
-  const mapper = { ...fakerKeywordMapper, ...options.mapper }
-  const value = mapper[current.keyword as keyof typeof mapper]
+  const value = fakerKeywordMapper[current.keyword as keyof typeof fakerKeywordMapper]
 
   if (!value) {
     return undefined
   }
 
   if (isKeyword(current, schemaKeywords.union)) {
-    return mapper.union(current.args.map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false })).filter(Boolean))
+    return fakerKeywordMapper.union(current.args.map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false })).filter(Boolean))
   }
 
   if (isKeyword(current, schemaKeywords.and)) {
-    return mapper.and(current.args.map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false })).filter(Boolean))
+    return fakerKeywordMapper.and(current.args.map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false })).filter(Boolean))
   }
 
   if (isKeyword(current, schemaKeywords.array)) {
-    return mapper.array(current.args.items.map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false })).filter(Boolean))
+    return fakerKeywordMapper.array(current.args.items.map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false })).filter(Boolean))
   }
 
   if (isKeyword(current, schemaKeywords.enum)) {
-    return mapper.enum(
+    return fakerKeywordMapper.enum(
       current.args.items.map((schema) => {
         if (schema.format === 'number') {
           return schema.name
@@ -175,12 +174,16 @@ export function parseFakerMeta(parent: Schema | undefined, current: Schema, opti
         const name = item[0]
         const schemas = item[1]
 
+        // custom mapper(pluginOptions)
+        if (options.mapper?.[name]) {
+          return `"${name}": ${options.mapper?.[name]}`
+        }
+
         return `"${name}": ${joinItems(
           schemas
             .sort(schemaKeywordsorter)
             .map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false }))
             .filter(Boolean),
-          mapper,
         )}`
       })
       .join(',')
@@ -190,22 +193,22 @@ export function parseFakerMeta(parent: Schema | undefined, current: Schema, opti
 
   if (isKeyword(current, schemaKeywords.tuple)) {
     if (Array.isArray(current.args)) {
-      return mapper.tuple(current.args.map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false })).filter(Boolean))
+      return fakerKeywordMapper.tuple(current.args.map((schema) => parseFakerMeta(current, schema, { ...options, withOverride: false })).filter(Boolean))
     }
 
     return parseFakerMeta(current, current.args, { ...options, withOverride: false })
   }
 
   if (isKeyword(current, schemaKeywords.const)) {
     if (current.args.format === 'number' && current.args.name !== undefined) {
-      return mapper.const(current.args.name?.toString())
+      return fakerKeywordMapper.const(current.args.name?.toString())
     }
-    return mapper.const(transformers.stringify(current.args.value))
+    return fakerKeywordMapper.const(transformers.stringify(current.args.value))
   }
 
   if (isKeyword(current, schemaKeywords.matches)) {
     if (current.args) {
-      return mapper.matches(transformers.toRegExpString(current.args))
+      return fakerKeywordMapper.matches(transformers.toRegExpString(current.args))
     }
   }
 
@@ -218,52 +221,51 @@ export function parseFakerMeta(parent: Schema | undefined, current: Schema, opti
       const minSchema = SchemaGenerator.find([parent], schemaKeywords.min)
       const maxSchema = SchemaGenerator.find([parent], schemaKeywords.max)
 
-      return mapper.string(minSchema?.args, maxSchema?.args)
+      return fakerKeywordMapper.string(minSchema?.args, maxSchema?.args)
     }
 
-    return mapper.string()
+    return fakerKeywordMapper.string()
   }
 
   if (isKeyword(current, schemaKeywords.number)) {
     if (parent) {
       const minSchema = SchemaGenerator.find([parent], schemaKeywords.min)
       const maxSchema = SchemaGenerator.find([parent], schemaKeywords.max)
 
-      return mapper.number(minSchema?.args, maxSchema?.args)
+      return fakerKeywordMapper.number(minSchema?.args, maxSchema?.args)
     }
 
-    return mapper.number()
+    return fakerKeywordMapper.number()
   }
 
   if (isKeyword(current, schemaKeywords.integer)) {
     if (parent) {
       const minSchema = SchemaGenerator.find([parent], schemaKeywords.min)
       const maxSchema = SchemaGenerator.find([parent], schemaKeywords.max)
 
-      return mapper.integer(minSchema?.args, maxSchema?.args)
+      return fakerKeywordMapper.integer(minSchema?.args, maxSchema?.args)
     }
 
-    return mapper.integer()
+    return fakerKeywordMapper.integer()
   }
 
-  if (current.keyword in mapper && 'args' in current) {
-    const value = mapper[current.keyword as keyof typeof mapper] as (typeof fakerKeywordMapper)['const']
+  if (current.keyword in fakerKeywordMapper && 'args' in current) {
+    const value = fakerKeywordMapper[current.keyword as keyof typeof fakerKeywordMapper] as (typeof fakerKeywordMapper)['const']
 
     const options = JSON.stringify((current as SchemaKeywordBase<unknown>).args)
 
     return value(options)
   }
 
-  if (current.keyword in mapper) {
+  if (current.keyword in fakerKeywordMapper) {
     return value()
   }
 
   return undefined
 }
 
 export function fakerParser(schemas: Schema[], options: ParserOptions): string {
-  const mapper = { ...fakerKeywordMapper, ...options.mapper }
-  const fakerText = joinItems(schemas.map((schema) => parseFakerMeta(undefined, schema, { ...options, withOverride: true })).filter(Boolean), mapper)
+  const fakerText = joinItems(schemas.map((schema) => parseFakerMeta(undefined, schema, { ...options, withOverride: true })).filter(Boolean))
 
   let fakerDefaultOverride: '' | '[]' | '{}' = ''
   let fakerTextWithOverride = fakerText

packages/swagger-faker/src/plugin.ts

@@ -40,10 +40,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       dateType,
       seed,
       unknownType,
-      mapper: {
-        ...fakerKeywordMapper,
-        ...mapper,
-      },
+      mapper,
     },
     pre: [swaggerPluginName, swaggerTypeScriptPluginName],
     resolvePath(baseName, pathMode, options) {

packages/swagger-faker/src/types.ts

@@ -82,7 +82,7 @@ export type Options = {
      */
     schema?: (schema: OasTypes.SchemaObject | undefined, baseName?: string) => Schema[] | undefined
   }
-  mapper?: Partial<SchemaMapper>
+  mapper?: Record<string, string>
   /**
    * The use of Seed is intended to allow for consistent values in a test.
    */
@@ -94,7 +94,7 @@ type ResolvedOptions = {
   unknownType: NonNullable<Options['unknownType']>
   transformers: NonNullable<Options['transformers']>
   seed: NonNullable<Options['seed']> | undefined
-  mapper: NonNullable<SchemaMapper<string | null | undefined>>
+  mapper: Record<string, string>
 }
 
 export type FileMeta = {

packages/swagger-ts/src/typeParser.ts

@@ -121,47 +121,46 @@ type ParserOptions = {
    */
   enumType: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal'
   keysToOmit?: string[]
-  mapper?: typeof typeKeywordMapper
+  mapper?: SchemaMapper
 }
 
 export function parseTypeMeta(parent: Schema | undefined, current: Schema, options: ParserOptions): ts.Node | null | undefined {
-  const mapper = { ...typeKeywordMapper, ...options.mapper }
-  const value = mapper[current.keyword as keyof typeof mapper]
+  const value = typeKeywordMapper[current.keyword as keyof typeof typeKeywordMapper]
 
   if (!value) {
     return undefined
   }
 
   if (isKeyword(current, schemaKeywords.union)) {
-    return mapper.union(current.args.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean) as ts.TypeNode[])
+    return typeKeywordMapper.union(current.args.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean) as ts.TypeNode[])
   }
 
   if (isKeyword(current, schemaKeywords.and)) {
-    return mapper.and(current.args.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean) as ts.TypeNode[])
+    return typeKeywordMapper.and(current.args.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean) as ts.TypeNode[])
   }
 
   if (isKeyword(current, schemaKeywords.array)) {
-    return mapper.array(current.args.items.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean) as ts.TypeNode[])
+    return typeKeywordMapper.array(current.args.items.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean) as ts.TypeNode[])
   }
 
   if (isKeyword(current, schemaKeywords.enum)) {
-    return mapper.enum(current.args.typeName)
+    return typeKeywordMapper.enum(current.args.typeName)
   }
 
   if (isKeyword(current, schemaKeywords.ref)) {
-    return mapper.ref(current.args.name)
+    return typeKeywordMapper.ref(current.args.name)
   }
 
   if (isKeyword(current, schemaKeywords.blob)) {
     return value()
   }
 
   if (isKeyword(current, schemaKeywords.tuple)) {
-    return mapper.tuple(current.args.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean) as ts.TypeNode[])
+    return typeKeywordMapper.tuple(current.args.map((schema) => parseTypeMeta(current, schema, options)).filter(Boolean) as ts.TypeNode[])
   }
 
   if (isKeyword(current, schemaKeywords.const)) {
-    return mapper.const(current.args.name, current.args.format)
+    return typeKeywordMapper.const(current.args.name, current.args.format)
   }
 
   if (isKeyword(current, schemaKeywords.object)) {
@@ -233,10 +232,10 @@ export function parseTypeMeta(parent: Schema | undefined, current: Schema, optio
         )
       : undefined
 
-    return mapper.object([...properties, additionalProperties].filter(Boolean))
+    return typeKeywordMapper.object([...properties, additionalProperties].filter(Boolean))
   }
 
-  if (current.keyword in mapper) {
+  if (current.keyword in typeKeywordMapper) {
     return value()
   }
 

packages/swagger-zod/src/SchemaGenerator.tsx

@@ -87,7 +87,7 @@ export class SchemaGenerator extends Generator<PluginOptions['resolvedOptions'],
         type: 'function',
       }),
       description,
-      mapper: this.options.mapper as typeof zodKeywordMapper,
+      mapper: this.options.mapper,
       typeName: withTypeAnnotation ? typeName : undefined,
     })
 

packages/swagger-zod/src/plugin.ts

@@ -45,10 +45,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       typed,
       dateType,
       unknownType,
-      mapper: {
-        ...zodKeywordMapper,
-        ...mapper,
-      },
+      mapper,
       templates: {
         operations: Operations.templates,
         ...templates,

packages/swagger-zod/src/types.ts

@@ -69,7 +69,7 @@ export type Options = {
      */
     name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
   }
-  mapper?: Partial<SchemaMapper>
+  mapper?: Record<string, string>
   /**
    * Make it possible to override one of the templates
    */
@@ -99,7 +99,7 @@ type ResolvedOptions = {
   unknownType: NonNullable<Options['unknownType']>
   typed: NonNullable<Options['typed']>
   templates: NonNullable<Templates>
-  mapper: NonNullable<SchemaMapper>
+  mapper: Record<string, string>
 }
 
 export type FileMeta = {