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

package/package.json

@@ -1,35 +1,56 @@
 {
   "name": "@kubb/plugin-faker",
-  "version": "5.0.0-alpha.9",
+  "version": "5.0.0-beta.4",
   "description": "Faker.js data generator plugin for Kubb, creating realistic mock data from OpenAPI specifications for development and testing.",
   "keywords": [
+    "code-generator",
+    "codegen",
+    "data-generation",
+    "development",
     "faker",
     "faker.js",
     "fakerjs",
+    "fixtures",
+    "kubb",
     "mock-data",
     "mocks",
-    "data-generation",
-    "fixtures",
-    "testing",
-    "development",
-    "typescript",
-    "openapi",
-    "swagger",
     "oas",
-    "code-generator",
-    "codegen",
+    "openapi",
     "plugins",
-    "kubb"
+    "swagger",
+    "testing",
+    "typescript"
   ],
+  "license": "MIT",
+  "author": "stijnvanhulle",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kubb-labs/kubb.git",
+    "url": "git+https://github.com/kubb-labs/plugins.git",
     "directory": "packages/plugin-faker"
   },
-  "license": "MIT",
-  "author": "stijnvanhulle",
-  "sideEffects": false,
+  "files": [
+    "src",
+    "dist",
+    "extension.yaml",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
   "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
+      ]
+    }
+  },
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -45,24 +66,21 @@
     },
     "./package.json": "./package.json"
   },
-  "types": "./dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "components": [
-        "./dist/components.d.ts"
-      ],
-      "generators": [
-        "./dist/generators.d.ts"
-      ]
-    }
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@kubb/core": "5.0.0-beta.4",
+    "@kubb/renderer-jsx": "5.0.0-beta.4",
+    "@kubb/plugin-ts": "5.0.0-beta.4"
+  },
+  "devDependencies": {
+    "@internals/utils": "0.0.0"
+  },
+  "peerDependencies": {
+    "@kubb/renderer-jsx": "5.0.0-beta.4"
   },
-  "files": [
-    "src",
-    "dist",
-    "!/**/**.test.**",
-    "!/**/__tests__/**",
-    "!/**/__snapshots__/**"
-  ],
   "size-limit": [
     {
       "path": "./dist/*.js",
@@ -70,30 +88,14 @@
       "gzip": true
     }
   ],
-  "dependencies": {
-    "@kubb/react-fabric": "0.14.0",
-    "@kubb/oas": "5.0.0-alpha.9",
-    "@kubb/core": "5.0.0-alpha.9",
-    "@kubb/plugin-oas": "5.0.0-alpha.9",
-    "@kubb/plugin-ts": "5.0.0-alpha.9"
-  },
   "engines": {
     "node": ">=22"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "devDependencies": {
-    "@internals/utils": "0.0.0"
-  },
   "scripts": {
     "build": "tsdown && size-limit",
     "clean": "npx rimraf ./dist",
-    "lint": "bun biome lint .",
-    "lint:fix": "bun biome lint --fix --unsafe .",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
     "release": "pnpm publish --no-git-check",
     "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
     "start": "tsdown --watch",

package/src/components/Faker.tsx

@@ -1,107 +1,153 @@
 import { jsStringEscape } from '@internals/utils'
-import type { Schema } from '@kubb/plugin-oas'
-import { isKeyword, schemaKeywords } from '@kubb/plugin-oas'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import * as parserFaker from '../parser.ts'
+import { ast } from '@kubb/core'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import type { PrinterFakerFactory } from '../printers/printerFaker.ts'
 import type { PluginFaker } from '../types.ts'
+import { resolveFakerTypeUsage } from '../utils.ts'
 
 type Props = {
   name: string
   typeName: string
-  tree: Array<Schema>
+  node: ast.SchemaNode
+  printer: ast.Printer<PrinterFakerFactory>
   seed?: PluginFaker['options']['seed']
   description?: string
-  regexGenerator?: PluginFaker['options']['regexGenerator']
-  mapper?: PluginFaker['options']['mapper']
-  dateParser?: PluginFaker['options']['dateParser']
   canOverride: boolean
 }
 
-export function Faker({ tree, description, name, typeName, seed, regexGenerator, canOverride, mapper, dateParser }: Props): FabricReactNode {
-  const fakerText = parserFaker.joinItems(
-    tree
-      .map((schema, _index, siblings) =>
-        parserFaker.parse(
-          { name, schema, parent: undefined, current: schema, siblings },
-          {
-            typeName,
-            rootTypeName: name,
-            regexGenerator,
-            mapper,
-            canOverride,
-            dateParser,
-          },
-        ),
-      )
-      .filter((x): x is string => Boolean(x)),
-  )
-
-  const isArray = fakerText.startsWith('faker.helpers.arrayElements') || fakerText.startsWith('faker.helpers.multiple')
-  const isRefToArray = tree.some((s) => isKeyword(s, schemaKeywords.schema) && s.args.type === 'array')
-  const isObject = fakerText.startsWith('{')
-  const isTuple = fakerText.startsWith('faker.helpers.arrayElement')
-
-  const isSimpleString = name === 'string'
-  const isSimpleInt = name === 'integer'
-  const isSimpleFloat = name === 'float'
+const OBJECT_TYPES = new Set<ast.SchemaNode['type']>(['object', 'intersection'])
+const ARRAY_TYPES = new Set<ast.SchemaNode['type']>(['array'])
+const SCALAR_TYPES = new Set<ast.SchemaNode['type']>([
+  'string',
+  'email',
+  'url',
+  'uuid',
+  'number',
+  'integer',
+  'bigint',
+  'boolean',
+  'date',
+  'time',
+  'datetime',
+  'blob',
+  'enum',
+])
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+
+export function Faker({ node, description, name, typeName, printer, seed, canOverride }: Props): KubbReactNode {
+  const fakerText = printer.print(node) ?? 'undefined'
+
+  const isArray = ARRAY_TYPES.has(node.type)
+  const isObject = OBJECT_TYPES.has(node.type)
+  const isTuple = node.type === 'tuple'
+  const isScalar = SCALAR_TYPES.has(node.type)
 
   let fakerTextWithOverride = fakerText
+  let useGenericOverride = false
 
   if (canOverride && isObject) {
-    fakerTextWithOverride = `{
-  ...${fakerText},
-  ...data || {}
-}`
+    useGenericOverride = true
   }
 
-  if (canOverride && isTuple) fakerTextWithOverride = `data || ${fakerText}`
+  if (canOverride && isTuple) {
+    fakerTextWithOverride = `data || ${fakerText}`
+  }
 
   if (canOverride && isArray) {
     fakerTextWithOverride = `[
-      ...${fakerText},
-      ...data || []
-    ]`
+  ...${fakerText},
+  ...(data || [])
+]`
   }
 
-  if (canOverride && isSimpleString) fakerTextWithOverride = 'data ?? faker.string.alpha()'
-
-  if (canOverride && isSimpleInt) fakerTextWithOverride = 'data ?? faker.number.int()'
-
-  if (canOverride && isSimpleFloat) fakerTextWithOverride = 'data ?? faker.number.float()'
-
-  let type = `Partial<${typeName}>`
-
-  if (isArray) type = typeName
-  if (isRefToArray) type = typeName
-  if (isSimpleString) type = name
-  if (isSimpleInt || isSimpleFloat) type = 'number'
-
-  const params = FunctionParams.factory({
-    data: {
-      // making a partial out of an array does not make sense
-      type,
-      optional: true,
-    },
-  })
-
-  let returnType = canOverride ? typeName : undefined
+  if (canOverride && isScalar) {
+    fakerTextWithOverride = `data ?? ${fakerText}`
+  }
 
-  if (isSimpleString || isSimpleInt || isSimpleFloat) returnType = type
+  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 {
+    const usesData = /\bdata\b/.test(fakerTextWithOverride)
+    const dataParamName = usesData ? 'data' : '_data'
+    const params = ast.createFunctionParameters({
+      params: [
+        ast.createFunctionParameter({
+          name: dataParamName,
+          type: ast.createParamsType({ variant: 'reference', name: dataType }),
+          optional: true,
+        }),
+      ],
+    })
+    const paramsSignature = declarationPrinter.print(params) ?? ''
+    const returnType = resolvedReturnType
+
+    return (
+      <File.Source name={name} isExportable isIndexable>
+        <Function
+          export
+          name={name}
+          JSDoc={{ comments: description ? [`@description ${jsStringEscape(description)}`] : [] }}
+          params={canOverride ? paramsSignature : undefined}
+          returnType={returnType}
+        >
+          {seed ? (
+            <>
+              {`faker.seed(${JSON.stringify(seed)})`}
+              <br />
+            </>
+          ) : undefined}
+          {`return ${fakerTextWithOverride}`}
+        </Function>
+      </File.Source>
+    )
+  }
 
   return (
     <File.Source name={name} isExportable isIndexable>
-      <Function
-        export
-        name={name}
-        JSDoc={{ comments: [description ? `@description ${jsStringEscape(description)}` : undefined].filter(Boolean) }}
-        params={canOverride ? params.toConstructor() : undefined}
-        returnType={returnType}
-      >
-        {seed ? `faker.seed(${JSON.stringify(seed)})` : undefined}
-        <br />
-        {`return ${fakerTextWithOverride}`}
-      </Function>
+      {functionSignature}
+      {functionBody}
     </File.Source>
   )
 }