@kubb/plugin-faker 5.0.0-beta.3 → 5.0.0-beta.30

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "@kubb/plugin-faker",
-  "version": "5.0.0-beta.3",
-  "description": "Faker.js data generator plugin for Kubb, creating realistic mock data from OpenAPI specifications for development and testing.",
+  "version": "5.0.0-beta.30",
+  "description": "Generate Faker.js mock data factories from your OpenAPI schemas. Produces realistic seed data, test fixtures, and datasets for development and testing.",
   "keywords": [
-    "code-generator",
+    "code-generation",
     "codegen",
-    "data-generation",
-    "development",
     "faker",
     "faker.js",
     "fakerjs",
@@ -14,11 +12,8 @@
     "kubb",
     "mock-data",
     "mocks",
-    "oas",
     "openapi",
-    "plugins",
     "swagger",
-    "testing",
     "typescript"
   ],
   "license": "MIT",
@@ -31,7 +26,7 @@
   "files": [
     "src",
     "dist",
-    "plugin.json",
+    "extension.yaml",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -71,15 +66,15 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.3",
-    "@kubb/renderer-jsx": "5.0.0-beta.3",
-    "@kubb/plugin-ts": "5.0.0-beta.3"
+    "@kubb/core": "5.0.0-beta.29",
+    "@kubb/renderer-jsx": "5.0.0-beta.29",
+    "@kubb/plugin-ts": "5.0.0-beta.30"
   },
   "devDependencies": {
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.3"
+    "@kubb/renderer-jsx": "5.0.0-beta.29"
   },
   "size-limit": [
     {

package/src/components/Faker.tsx

@@ -44,71 +44,17 @@ export function Faker({ node, description, name, typeName, printer, seed, canOve
   const isTuple = node.type === 'tuple'
   const isScalar = SCALAR_TYPES.has(node.type)
 
-  let fakerTextWithOverride = fakerText
-  let useGenericOverride = false
-
-  if (canOverride && isObject) {
-    useGenericOverride = true
-  }
-
-  if (canOverride && isTuple) {
-    fakerTextWithOverride = `data || ${fakerText}`
-  }
-
-  if (canOverride && isArray) {
-    fakerTextWithOverride = `[
-  ...${fakerText},
-  ...(data || [])
-]`
-  }
-
-  if (canOverride && isScalar) {
-    fakerTextWithOverride = `data ?? ${fakerText}`
-  }
+  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)
 
-  let functionSignature = ''
-  let functionBody = ''
-
-  if (useGenericOverride) {
-    // Generate function with defaultFakeData structure
-    const jsdoc = description ? `/**\n   * @description ${jsStringEscape(description)}\n   */\n  ` : ''
-    functionSignature = `${jsdoc}export function ${name}(data?: Partial<${typeName}>): Required<${typeName}>`
-
-    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 }))
-
-    if (hasGetters) {
-      functionBody = `{
-  ${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 Required<${typeName}>
-}`
-    } else {
-      functionBody = `{
-  ${seedCode}const defaultFakeData = ${fakerText}
-  return {
-    ...defaultFakeData,
-    ...(data || {}),
-  } as Required<${typeName}>
-}`
-    }
-  } else {
+  if (!useGenericOverride) {
     const usesData = /\bdata\b/.test(fakerTextWithOverride)
     const dataParamName = usesData ? 'data' : '_data'
     const params = ast.createFunctionParameters({
@@ -130,7 +76,7 @@ export function Faker({ node, description, name, typeName, printer, seed, canOve
           name={name}
           JSDoc={{ comments: description ? [`@description ${jsStringEscape(description)}`] : [] }}
           params={canOverride ? paramsSignature : undefined}
-          returnType={returnType}
+          returnType={returnType ?? undefined}
         >
           {seed ? (
             <>
@@ -144,6 +90,41 @@ export function Faker({ node, description, name, typeName, printer, seed, canOve
     )
   }
 
+  // Generate function with defaultFakeData structure
+  const jsdoc = description ? `/**\n   * @description ${jsStringEscape(description)}\n   */\n  ` : ''
+  const functionSignature = `${jsdoc}export function ${name}(data?: Partial<${typeName}>): Required<${typeName}>`
+
+  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 Required<${typeName}>
+}`
+    : `{
+  ${seedCode}const defaultFakeData = ${fakerText}
+  return {
+    ...defaultFakeData,
+    ...(data || {}),
+  } as Required<${typeName}>
+}`
+
   return (
     <File.Source name={name} isExportable isIndexable>
       {functionSignature}

package/src/generators/fakerGenerator.tsx

@@ -1,49 +1,45 @@
+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 { 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 {
-  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,
+  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 || !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 schemaName = node.name
     const mode = ctx.getMode(output)
     const meta = {
       name: resolver.resolveName(schemaName),
-      file: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }),
+      file: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group: group ?? undefined }),
       typeName: tsResolver.resolveTypeName(schemaName),
       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 +50,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,
@@ -65,9 +61,9 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
     })
 
     const imports = adapter
-      .getImports(schemaNode, (schemaName) => ({
+      .getImports(node, (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)
     const usedImports = filterUsedImports(imports, fakerText)
@@ -77,8 +73,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'} />}
@@ -89,8 +85,8 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
         <Faker
           name={meta.name}
           typeName={typeReference.typeName}
-          description={schemaNode.description}
-          node={schemaNode}
+          description={node.description}
+          node={node}
           printer={printerInstance}
           seed={seed}
           canOverride={canOverride}
@@ -138,8 +134,13 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
       ...(dataEntry ? [dataEntry.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 +151,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 +160,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 +183,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 +230,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'} />}
@@ -245,7 +245,7 @@ export const fakerGenerator = defineGenerator<PluginFaker>({
         )}
         {responseEntries.map(({ response, name, typeName }) =>
           renderEntry({
-            schema: response.schema,
+            schema: response.content?.[0]?.schema ?? null,
             name,
             typeName,
             description: response.description,

package/src/plugin.ts

@@ -6,17 +6,34 @@ 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 {
@@ -50,7 +67,7 @@ export const pluginFaker = definePlugin<PluginFaker>((options) => {
               return `${camelCase(ctx.group)}Controller`
             },
       } satisfies Group)
-    : undefined
+    : null
 
   return {
     name: pluginFakerName,

package/src/printers/printerFaker.ts

@@ -3,12 +3,30 @@ 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.
@@ -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,
@@ -313,7 +377,7 @@ export const printerFaker: (options: PrinterFakerOptions) => ast.Printer<Printer
 
             const value: string =
               printNested(property.schema, {
-                typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[${JSON.stringify(property.name)}]` : undefined,
+                typeName: this.options.typeName ? indexedTypeName(this.options.typeName, property.name, this.options.nestedInUnion) : undefined,
                 nestedInObject: true,
               }) ?? 'undefined'