@kubb/plugin-faker 3.0.0-alpha.0

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@kubb/plugin-faker",
+  "version": "3.0.0-alpha.0",
+  "description": "Generator plugin-faker",
+  "keywords": [
+    "faker",
+    "faker.js",
+    "mock",
+    "mocking",
+    "plugins",
+    "kubb",
+    "codegen",
+    "swagger",
+    "openapi"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/kubb-labs/kubb.git",
+    "directory": "packages/plugin-faker"
+  },
+  "license": "MIT",
+  "author": "Stijn Van Hulle <stijn@stijnvanhulle.be",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs",
+      "default": "./dist/components.cjs"
+    },
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "./dist/components.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**"
+  ],
+  "dependencies": {
+    "@kubb/core": "3.0.0-alpha.0",
+    "@kubb/fs": "3.0.0-alpha.0",
+    "@kubb/oas": "3.0.0-alpha.0",
+    "@kubb/parser-ts": "3.0.0-alpha.0",
+    "@kubb/plugin-oas": "3.0.0-alpha.0",
+    "@kubb/plugin-ts": "3.0.0-alpha.0",
+    "@kubb/react": "3.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "react": "^18.3.1",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4",
+    "@kubb/config-biome": "3.0.0-alpha.0",
+    "@kubb/config-ts": "3.0.0-alpha.0",
+    "@kubb/config-tsup": "3.0.0-alpha.0"
+  },
+  "peerDependencies": {
+    "@kubb/react": "3.0.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "npx rimraf ./dist",
+    "lint": "bun biome lint .",
+    "lint:fix": "bun biome lint --apply-unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsup --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/src/OperationGenerator.tsx

@@ -0,0 +1,30 @@
+import { OperationGenerator as Generator } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { App, createRoot } from '@kubb/react'
+
+import { OperationSchema } from './components/OperationSchema.tsx'
+
+import type { Operation } from '@kubb/oas'
+import type { OperationMethodResult } from '@kubb/plugin-oas'
+import type { FileMeta, PluginFaker } from './types.ts'
+
+export class OperationGenerator extends Generator<PluginFaker['resolvedOptions'], PluginFaker> {
+  async operation(operation: Operation, options: PluginFaker['resolvedOptions']): OperationMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin, mode } = this.context
+
+    const root = createRoot({
+      logger: pluginManager.logger,
+    })
+    root.render(
+      <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
+        <Oas oas={oas} operations={[operation]} generator={this}>
+          <Oas.Operation operation={operation}>
+            <OperationSchema.File />
+          </Oas.Operation>
+        </Oas>
+      </App>,
+    )
+
+    return root.files
+  }
+}

package/src/SchemaGenerator.tsx

@@ -0,0 +1,31 @@
+import type { SchemaObject } from '@kubb/oas'
+import { SchemaGenerator as Generator } from '@kubb/plugin-oas'
+import type { SchemaMethodResult } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { App, createRoot } from '@kubb/react'
+import { Schema } from './components/Schema.tsx'
+import type { FileMeta, PluginFaker } from './types.ts'
+
+export class SchemaGenerator extends Generator<PluginFaker['resolvedOptions'], PluginFaker> {
+  async schema(name: string, schema: SchemaObject, options: PluginFaker['resolvedOptions']): SchemaMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin, mode, output } = this.context
+
+    const root = createRoot({
+      logger: pluginManager.logger,
+    })
+
+    const tree = this.parse({ schema, name })
+
+    root.render(
+      <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
+        <Oas oas={oas}>
+          <Oas.Schema name={name} value={schema} tree={tree}>
+            <Schema.File />
+          </Oas.Schema>
+        </Oas>
+      </App>,
+    )
+
+    return root.files
+  }
+}

package/src/components/OperationSchema.tsx

@@ -0,0 +1,84 @@
+import { Oas } from '@kubb/plugin-oas/components'
+import { useOas, useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
+import { File, Parser, useApp } from '@kubb/react'
+import { pluginTsName } from '@kubb/plugin-ts'
+
+import { SchemaGenerator } from '../SchemaGenerator.tsx'
+
+import type { OperationSchema as OperationSchemaType } from '@kubb/plugin-oas'
+import type { ReactNode } from 'react'
+import type { FileMeta, PluginFaker } from '../types.ts'
+import { Schema } from './Schema.tsx'
+
+type Props = {
+  description?: string
+}
+
+export function OperationSchema({ description }: Props): ReactNode {
+  return <Schema withData={false} description={description} />
+}
+
+type FileProps = {}
+
+OperationSchema.File = function ({}: FileProps): ReactNode {
+  const { plugin, pluginManager, mode } = useApp<PluginFaker>()
+
+  const oas = useOas()
+  const { getSchemas, getFile } = useOperationManager()
+  const operation = useOperation()
+
+  const file = getFile(operation)
+  const schemas = getSchemas(operation)
+  const generator = new SchemaGenerator(plugin.options, {
+    oas,
+    plugin,
+    pluginManager,
+    mode,
+    override: plugin.options.override,
+  })
+
+  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean)
+
+  const mapItem = ({ name, schema, description, ...options }: OperationSchemaType, i: number) => {
+    // used for this.options.typed
+    const typeName = pluginManager.resolveName({
+      name,
+      pluginKey: [pluginTsName],
+      type: 'type',
+    })
+    const typeFileName = pluginManager.resolveName({
+      name: options.operationName || name,
+      pluginKey: [pluginTsName],
+      type: 'file',
+    })
+    const typePath = pluginManager.resolvePath({
+      baseName: typeFileName,
+      pluginKey: [pluginTsName],
+      options: { tag: options.operation?.getTags()[0]?.name },
+    })
+
+    const tree = generator.parse({ schema, name })
+
+    return (
+      <Oas.Schema key={i} name={name} value={schema} tree={tree}>
+        {typeName && typePath && <File.Import extName={plugin.options.extName} isTypeOnly root={file.path} path={typePath} name={[typeName]} />}
+        {plugin.options.dateParser && <File.Import path={plugin.options.dateParser} name={plugin.options.dateParser} />}
+
+        {mode === 'split' && <Oas.Schema.Imports extName={plugin.options.extName} />}
+        <File.Source>
+          <OperationSchema description={description} />
+        </File.Source>
+      </Oas.Schema>
+    )
+  }
+
+  return (
+    <Parser language="typescript">
+      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
+        <File.Import name={['faker']} path="@faker-js/faker" />
+        {plugin.options.regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
+        {items.map(mapItem)}
+      </File>
+    </Parser>
+  )
+}

package/src/components/Schema.tsx

@@ -0,0 +1,146 @@
+import { Oas } from '@kubb/plugin-oas/components'
+import { File, Function, useApp, useFile } from '@kubb/react'
+import { pluginTsName } from '@kubb/plugin-ts'
+
+import transformers from '@kubb/core/transformers'
+import { schemaKeywords } from '@kubb/plugin-oas'
+import { useSchema } from '@kubb/plugin-oas/hooks'
+import type { ReactNode } from 'react'
+import * as parserFaker from '../parser/index.ts'
+import { pluginFakerName } from '../plugin.ts'
+import type { PluginFaker } from '../types.ts'
+
+type Props = {
+  description?: string
+  withData?: boolean
+}
+
+export function Schema(props: Props): ReactNode {
+  const { withData, description } = props
+  const { tree, name } = useSchema()
+  const {
+    pluginManager,
+    plugin: {
+      options: { dateParser, regexGenerator, mapper, seed },
+    },
+  } = useApp<PluginFaker>()
+
+  // all checks are also inside this.schema(React)
+  const resolvedName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginFakerName],
+    type: 'function',
+  })
+
+  const typeName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginTsName],
+    type: 'type',
+  })
+
+  const fakerText = parserFaker.joinItems(
+    tree
+      .map((schema) => parserFaker.parse(undefined, schema, { name: resolvedName, typeName, seed, regexGenerator, mapper, withData, dateParser }))
+      .filter(Boolean),
+  )
+
+  let fakerDefaultOverride: '' | '[]' | '{}' | undefined = undefined
+  let fakerTextWithOverride = fakerText
+
+  if (withData && fakerText.startsWith('{')) {
+    fakerDefaultOverride = '{}'
+    fakerTextWithOverride = `{
+  ...${fakerText},
+  ...data
+}`
+  }
+
+  if (withData && fakerText.startsWith('faker.helpers.arrayElements')) {
+    fakerDefaultOverride = '[]'
+    fakerTextWithOverride = `[
+      ...${fakerText},
+      ...data
+    ]`
+  }
+
+  const params = fakerDefaultOverride ? `data: NonNullable<Partial<${typeName}>> = ${fakerDefaultOverride}` : `data?: NonNullable<Partial<${typeName}>>`
+
+  return (
+    <>
+      <Function
+        export
+        name={resolvedName}
+        JSDoc={{ comments: [description ? `@description ${transformers.jsStringEscape(description)}` : undefined].filter(Boolean) }}
+        params={withData ? params : ''}
+        returnType={typeName ? `NonNullable<${typeName}>` : ''}
+      >
+        {seed ? `faker.seed(${JSON.stringify(seed)})` : ''}
+        <br />
+        <Function.Return>{fakerTextWithOverride}</Function.Return>
+      </Function>
+      <br />
+    </>
+  )
+}
+
+type FileProps = {}
+
+Schema.File = function ({}: FileProps): ReactNode {
+  const { pluginManager } = useApp<PluginFaker>()
+  const { tree, schema } = useSchema()
+
+  const withData = tree.some(
+    (schema) =>
+      schema.keyword === schemaKeywords.array ||
+      schema.keyword === schemaKeywords.and ||
+      schema.keyword === schemaKeywords.object ||
+      schema.keyword === schemaKeywords.union ||
+      schema.keyword === schemaKeywords.tuple,
+  )
+
+  return (
+    <Oas.Schema.File output={pluginManager.config.output.path}>
+      <Schema.Imports />
+      <File.Source>
+        <Schema description={schema?.description} withData={withData} />
+      </File.Source>
+    </Oas.Schema.File>
+  )
+}
+Schema.Imports = (): ReactNode => {
+  const {
+    pluginManager,
+    plugin: {
+      options: { extName, dateParser, regexGenerator },
+    },
+  } = useApp<PluginFaker>()
+  const { path: root } = useFile()
+  const { name, tree, schema } = useSchema()
+
+  // used for this.options.typed
+  const typeName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginTsName],
+    type: 'type',
+  })
+
+  const typeFileName = pluginManager.resolveName({
+    name: name,
+    pluginKey: [pluginTsName],
+    type: 'file',
+  })
+
+  const typePath = pluginManager.resolvePath({
+    baseName: typeFileName,
+    pluginKey: [pluginTsName],
+  })
+
+  return (
+    <>
+      <File.Import name={['faker']} path="@faker-js/faker" />
+      {regexGenerator === 'randexp' && <File.Import name={'RandExp'} path={'randexp'} />}
+      {dateParser && <File.Import path={dateParser} name={dateParser} />}
+      {typeName && typePath && <File.Import extName={extName} isTypeOnly root={root} path={typePath} name={[typeName]} />}
+    </>
+  )
+}

package/src/components/index.ts

@@ -0,0 +1,2 @@
+export { OperationSchema } from './OperationSchema.tsx'
+export { Schema } from './Schema.tsx'

package/src/index.ts

@@ -0,0 +1,2 @@
+export { pluginFaker, pluginFakerName } from './plugin.ts'
+export type { PluginFaker } from './types.ts'