@kubb/plugin-faker 5.0.0-beta.4 → 5.0.0-beta.56

package/src/generators/fakerGenerator.tsx

@@ -1,21 +1,19 @@
+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, jsxRenderer } from '@kubb/renderer-jsx'
 import { Faker } from '../components/Faker.tsx'
 import { printerFaker } from '../printers/printerFaker.ts'
 import type { PluginFaker } from '../types.ts'
-import {
-  aliasConflictingImports,
-  buildResponseUnionSchema,
-  canOverrideSchema,
-  filterUsedImports,
-  localeToFakerImport,
-  resolveParamNameByLocation,
-  resolveSchemaRef,
-  resolveTypeReference,
-  rewriteAliasedImports,
-} from '../utils.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: jsxRenderer,
@@ -24,26 +22,29 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
     const { output, group, dateParser, regexGenerator, mapper, seed, locale, printer } = ctx.options
     const pluginTs = ctx.driver.getPlugin(pluginTsName)
 
-    if (!node.name || !pluginTs || !adapter.inputNode) {
+    if (!node.name || !pluginTs) {
       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 schemaName = node.name
+    const isEnumSchema = !!ast.narrowSchema(node, ast.schemaTypes.enum)
+    const tsEnumType = pluginTs.options?.enum?.type
+    const tsEnumTypeSuffix = pluginTs.options?.enum?.typeSuffix ?? 'Key'
+    const schemaTypeName =
+      isEnumSchema && tsEnumType === 'asConst' ? tsResolver.resolveEnumKeyName({ name: schemaName }, tsEnumTypeSuffix) : tsResolver.resolveTypeName(schemaName)
     const meta = {
       name: resolver.resolveName(schemaName),
-      file: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }),
-      typeName: tsResolver.resolveTypeName(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 },
+        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group ?? undefined },
       ),
     } as const
-    const canOverride = canOverrideSchema(schemaNode)
-    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
+    const canOverride = canOverrideSchema(node)
+    const cyclicSchemas = new Set<string>(ctx.meta.circularNames)
     const printerInstance = printerFaker({
       resolver,
       schemaName,
@@ -54,9 +55,9 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
       nodes: printer?.nodes,
       cyclicSchemas,
     })
-    const fakerText = printerInstance.print(schemaNode) ?? 'undefined'
+    const fakerText = printerInstance.print(node) ?? 'undefined'
     const typeReference = resolveTypeReference({
-      node: schemaNode,
+      node,
       canOverride,
       name: meta.name,
       typeName: meta.typeName,
@@ -64,12 +65,10 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
       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 imports = adapter.getImports(node, (schemaName) => ({
+      name: resolver.resolveName(schemaName),
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
+    }))
     const usedImports = filterUsedImports(imports, fakerText)
 
     return (
@@ -77,20 +76,21 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
         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 })}
+        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} />)}
+        {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}
+          description={node.description}
+          node={node}
           printer={printerInstance}
           seed={seed}
           canOverride={canOverride}
@@ -115,31 +115,66 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
       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
+    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),
-      ...responseEntries.map((entry) => entry.name),
-      ...(dataEntry ? [dataEntry.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 }),
+      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,
@@ -150,7 +185,7 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
         {
           root,
           output: pluginTs.options?.output ?? output,
-          group: pluginTs.options?.group,
+          group: pluginTs.options?.group ?? undefined,
         },
       ),
     } as const
@@ -159,7 +194,7 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
       return adapter
         .getImports(schema, (schemaName) => ({
           name: resolver.resolveName(schemaName),
-          path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+          path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }).path,
         }))
         .filter((entry) => entry.path !== meta.file.path)
     }
@@ -182,7 +217,6 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
       }
 
       const canOverride = canOverrideSchema(schema)
-      const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
       const printerInstance = printerFaker({
         resolver,
         schemaName: name,
@@ -230,8 +264,8 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
         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 })}
+        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'} />}
@@ -243,27 +277,29 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
             typeName,
           }),
         )}
-        {responseEntries.map(({ response, name, typeName }) =>
+        {responseUnits.map((unit) =>
           renderEntry({
-            schema: response.schema,
-            name,
-            typeName,
-            description: response.description,
+            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,
           }),
         )}
-        {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),
+          skipImportNames: responseUnits.map((unit) => unit.name),
         })}
       </File>
     )

package/src/plugin.ts

@@ -1,28 +1,45 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
+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 in driver lookups and warnings.
+ * 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 Faker mock data factories from OpenAPI/AST specification.
- *
- * Creates randomized test data and mock helpers from schema definitions.
+ * 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
- * `import pluginFaker from '@kubb/plugin-faker'; export default defineConfig({ plugins: [pluginFaker({ output: { path: 'mocks' } })], })`
+ * ```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' },
+    output = { path: 'mocks', barrel: { type: 'named' } },
     seed,
-    locale,
+    locale = 'en',
     group,
     exclude = [],
     include,
@@ -37,20 +54,7 @@ export const pluginFaker = definePlugin<PluginFaker>((options) => {
     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
+  const groupConfig = createGroupConfig(group)
 
   return {
     name: pluginFakerName,

package/src/printers/printerFaker.ts

@@ -1,14 +1,32 @@
-import { stringify, toRegExpString } from '@internals/utils'
+import { buildObject, extractRefName, objectKey, stringify, toRegExpString } from '@kubb/ast/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.
+ * Partial map of node-type overrides for the Faker printer. Each key is a
+ * `SchemaType` (`'string'`, `'date'`, ...) and each handler returns the
+ * Faker expression for that schema as a string. Use `this.transform` to
+ * recurse into nested schema nodes and `this.options` to read printer options.
+ *
+ * @example Override the integer handler
+ * ```ts
+ * pluginFaker({
+ *   printer: {
+ *     nodes: {
+ *       integer() {
+ *         return 'faker.number.float()'
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
  */
 export type PrinterFakerNodes = ast.PrinterPartial<string, PrinterFakerOptions>
 
 /**
- * Configuration options for the Faker printer, including resolvers, mappers, and cyclic schema tracking.
+ * Options passed to the Faker printer at instantiation: the parser library
+ * for date strings, the regex generator, the user-supplied schema-name
+ * mapper, and the resolver used to compute identifiers.
  */
 export type PrinterFakerOptions = {
   dateParser?: PluginFaker['resolvedOptions']['dateParser']
@@ -18,6 +36,12 @@ export type PrinterFakerOptions = {
   typeName?: string
   schemaName?: string
   nestedInObject?: boolean
+  /**
+   * Set while printing the members of a union (`oneOf`). Object properties then index their
+   * type as `(NonNullable<T> & Record<K, unknown>)[K]` instead of `NonNullable<T>[K]`, so a key
+   * carried by only some branches stays valid (a plain index would be a TS2339).
+   */
+  nestedInUnion?: boolean
   nodes?: PrinterFakerNodes
   /**
    * Names of schemas that participate in a circular dependency chain.
@@ -85,7 +109,7 @@ const fakerKeywordMapper = {
   },
   boolean: () => 'faker.datatype.boolean()',
   null: () => 'null',
-  array: (items: string[] = [], min?: number, max?: number) => {
+  array: (items: Array<string> = [], min?: number, max?: number) => {
     if (items.length > 1) {
       return `faker.helpers.arrayElements([${items.join(', ')}])`
     }
@@ -106,9 +130,9 @@ const fakerKeywordMapper = {
 
     return `faker.helpers.multiple(() => (${item}))`
   },
-  tuple: (items: string[] = []) => `[${items.join(', ')}]`,
+  tuple: (items: Array<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(', ')}])`,
+  union: (items: Array<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') {
@@ -142,7 +166,7 @@ const fakerKeywordMapper = {
   },
   uuid: () => 'faker.string.uuid()',
   url: () => 'faker.internet.url()',
-  and: (items: string[] = []) => {
+  and: (items: Array<string> = []) => {
     if (items.length === 0) {
       return '{}'
     }
@@ -180,6 +204,32 @@ function parseEnumValue(value: string | number | boolean | undefined) {
   return value
 }
 
+/** Reads the discriminator literal off a variant, or `undefined` when it can't be determined. */
+function getDiscriminatorValue(member: ast.SchemaNode, discriminatorPropertyName: string) {
+  const prop = ast.narrowSchema(member, 'object')?.properties?.find((p) => p.name === discriminatorPropertyName)
+  const enumNode = prop ? ast.narrowSchema(prop.schema, 'enum') : null
+
+  return enumNode ? getEnumValues(enumNode)[0] : undefined
+}
+
+/**
+ * Type expression for an object property's value, indexed off the parent `typeName`.
+ *
+ * In a union (`oneOf`), a key that only some branches declare turns a plain `NonNullable<T>[K]`
+ * into a TS2339 error, so union members guard the access. The breakdown is below.
+ */
+function indexedTypeName(typeName: string, propertyName: string, nestedInUnion?: boolean): string {
+  const key = JSON.stringify(propertyName)
+
+  // `(NonNullable<T> & Record<K, unknown>)[K]`, read inside-out:
+  //   NonNullable<T>          strips null and undefined from the parent type T.
+  //   & Record<K, unknown>    forces every branch to have key K. A branch that already declares K
+  //                           keeps it (`T[K] & unknown` is `T[K]`); a branch missing K gains it as `unknown`.
+  //   [K]                     reads the key, which is now always present, so it never hits TS2339.
+  // For a single object T the intersection does nothing, leaving `T[K]`.
+  return nestedInUnion ? `(NonNullable<${typeName}> & Record<${key}, unknown>)[${key}]` : `NonNullable<${typeName}>[${key}]`
+}
+
 /**
  * Creates a Faker printer that generates mock data generation code from schema nodes.
  * Handles circular references gracefully by emitting memoizing getters for cyclic properties.
@@ -234,7 +284,7 @@ export const printerFaker: (options: PrinterFakerOptions) => ast.Printer<Printer
         // 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)
+        const refName = node.ref ? (extractRefName(node.ref) ?? node.name ?? node.schema?.name) : (node.name ?? node.schema?.name)
 
         if (!refName) {
           throw new Error('Name not defined for ref node')
@@ -258,18 +308,32 @@ export const printerFaker: (options: PrinterFakerOptions) => ast.Printer<Printer
         return fakerKeywordMapper.enum(getEnumValues(node).map(parseEnumValue), this.options.typeName)
       },
       union(node): string {
-        const items: string[] = (node.members ?? [])
-          .map((member) =>
-            printNested(member, {
-              nestedInObject: true,
-            }),
-          )
+        const { discriminatorPropertyName } = node
+        const baseTypeName = this.options.typeName
+
+        const items: Array<string> = (node.members ?? [])
+          .map((member) => {
+            // For a discriminated union, narrow each variant to its own branch so nested
+            // `NonNullable<T>[K]` indexes resolve against that branch instead of the whole union.
+            const value = discriminatorPropertyName ? getDiscriminatorValue(member, discriminatorPropertyName) : undefined
+
+            if (baseTypeName && value !== undefined) {
+              const typeName = `Extract<NonNullable<${baseTypeName}>, { ${JSON.stringify(discriminatorPropertyName)}: ${parseEnumValue(value)} }>`
+
+              return printNested(member, { typeName, nestedInObject: true })
+            }
+
+            // Without a discriminator, keep the union type but guard each indexed access (see
+            // `indexedTypeName`) so a key carried by only some branches resolves to `unknown`
+            // rather than erroring with TS2339.
+            return printNested(member, { typeName: baseTypeName, nestedInObject: true, nestedInUnion: true })
+          })
           .filter((item): item is string => Boolean(item))
 
         return fakerKeywordMapper.union(items)
       },
       intersection(node): string {
-        const items: string[] = (node.members ?? [])
+        const items: Array<string> = (node.members ?? [])
           .map((member) =>
             printNested(member, {
               nestedInObject: true,
@@ -280,7 +344,7 @@ export const printerFaker: (options: PrinterFakerOptions) => ast.Printer<Printer
         return fakerKeywordMapper.and(items)
       },
       array(node): string {
-        const items: string[] = (node.items ?? [])
+        const items: Array<string> = (node.items ?? [])
           .map((member) =>
             printNested(member, {
               typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[number]` : undefined,
@@ -292,7 +356,7 @@ export const printerFaker: (options: PrinterFakerOptions) => ast.Printer<Printer
         return fakerKeywordMapper.array(items, node.min, node.max)
       },
       tuple(node): string {
-        const items: string[] = (node.items ?? [])
+        const items: Array<string> = (node.items ?? [])
           .map((member, index) =>
             printNested(member, {
               typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[${index}]` : undefined,
@@ -305,32 +369,30 @@ export const printerFaker: (options: PrinterFakerOptions) => ast.Printer<Printer
       },
       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 entries = (node.properties ?? []).map((property): string => {
+          if (this.options.mapper && Object.hasOwn(this.options.mapper, property.name)) {
+            return `${objectKey(property.name)}: ${this.options.mapper[property.name]}`
+          }
+
+          const value: string =
+            printNested(property.schema, {
+              typeName: this.options.typeName ? indexedTypeName(this.options.typeName, property.name, this.options.nestedInUnion) : undefined,
+              nestedInObject: true,
+            }) ?? 'undefined'
 
-            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 }`
-            }
+          // 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 ${objectKey(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 `${objectKey(property.name)}: ${value}`
+        })
 
-        return `{${properties}}`
+        return buildObject(entries)
       },
       ...options.nodes,
     },