fauxy 0.0.1-alpha.4 → 0.0.2

package/dist/index.d.ts

@@ -15,114 +15,46 @@ type Count =
 /**
  * Mock config
  */
-type FakerType =
-  | 'uuid'
-  | 'boolean'
-  | 'words'
-  | 'number'
-  | 'url'
-  | 'fullName'
-  | 'date'
-  | 'personalNumber'
-  | 'rank'
-  | 'arrayElement'
-  | 'arrayElements'
-  | 'callback'
-  | 'array'
-  | 'object'
+type FakerWrapperType = 'callback' | 'array' | 'object' | 'instance'
 
-interface BaseFakerConfig {
-  type: FakerType
+interface BaseFakerWrapperConfig {
+  type: FakerWrapperType
 }
 
-interface UuidFakerConfig extends BaseFakerConfig {
-  type: 'uuid'
-}
-
-interface BooleanFakerConfig extends BaseFakerConfig {
-  type: 'boolean'
-}
-
-interface WordsFakerConfig extends BaseFakerConfig {
-  type: 'words'
-  count?: Count
-}
-
-interface NumberFakerConfig extends BaseFakerConfig {
-  type: 'number'
-  min?: number
-  max?: number
-}
-
-interface UrlFakerConfig extends BaseFakerConfig {
-  type: 'url'
-}
-
-interface DateFakerConfig extends BaseFakerConfig {
-  type: 'date'
-}
-
-interface FullNameFakerConfig extends BaseFakerConfig {
-  type: 'fullName'
-}
-
-interface PersonalNumberFakerConfig extends BaseFakerConfig {
-  type: 'personalNumber'
-}
-
-interface RankFakerConfig extends BaseFakerConfig {
-  type: 'rank'
-}
-
-interface ArrayElementFakerConfig extends BaseFakerConfig {
-  type: 'arrayElement'
-  items: unknown[]
-}
-
-interface ArrayElementsFakerConfig extends BaseFakerConfig {
-  type: 'arrayElements'
-  items: unknown[]
-  count?: Count
-}
-
-interface CallbackFakerConfig extends BaseFakerConfig {
+interface CallbackFakerWrapperConfig extends BaseFakerWrapperConfig {
   type: 'callback'
   callback: (...args: unknown[]) => any
 }
 
-interface ArrayFakerConfig extends BaseFakerConfig {
+interface ArrayFakerWrapperConfig extends BaseFakerWrapperConfig {
   type: 'array'
-  items: Faker<any>
+  items: FakerWrapper<any>
   count: Count
 }
 
-interface ObjectFakerConfig<O extends Record<string, any> = Record<string, any>>
-  extends BaseFakerConfig {
+interface ObjectFakerWrapperConfig<O extends Record<string, any> = Record<string, any>>
+  extends BaseFakerWrapperConfig {
   type: 'object'
   properties: {
-    [_ in keyof O]: Faker<any> | any
+    [_ in keyof O]: FakerWrapper<any> | any
   }
 }
 
+interface InstanceFakerWrapperConfig extends BaseFakerWrapperConfig {
+  type: 'instance'
+  callback: () => unknown
+  args: unknown[]
+}
+
 type FakerConfig =
-  | UuidFakerConfig
-  | BooleanFakerConfig
-  | WordsFakerConfig
-  | NumberFakerConfig
-  | UrlFakerConfig
-  | FullNameFakerConfig
-  | DateFakerConfig
-  | PersonalNumberFakerConfig
-  | RankFakerConfig
-  | ArrayElementFakerConfig
-  | ArrayElementsFakerConfig
-  | CallbackFakerConfig
-  | ArrayFakerConfig
-  | ObjectFakerConfig
+  | CallbackFakerWrapperConfig
+  | ArrayFakerWrapperConfig
+  | ObjectFakerWrapperConfig
+  | InstanceFakerWrapperConfig
 
-type ExtractFakerConfig<T extends FakerType> = Extract<FakerConfig, { type: T }>
+type ExtractFakerConfig<T extends FakerWrapperType> = Extract<FakerConfig, { type: T }>
 
-declare class Faker<T extends FakerType> {
+declare class FakerWrapper<T extends FakerWrapperType> {
   private readonly params: {
     config: ExtractFakerConfig<T>
     nullable: boolean
@@ -137,100 +69,41 @@ declare class Faker<T extends FakerType> {
     }
   }
 
-  public static uuid() {
-    return new Faker<'uuid'>({
-      type: 'uuid',
-    })
-  }
-
-  public static boolean() {
-    return new Faker<'boolean'>({
-      type: 'boolean',
-    })
-  }
-
-  public static words(params: Omit<WordsFakerConfig, 'type'> = {}) {
-    return new Faker<'words'>({
-      type: 'words',
-      count: params?.count,
-    })
-  }
-
-  public static number(params: Omit<NumberFakerConfig, 'type'> = {}) {
-    return new Faker<'number'>({
-      type: 'number',
-      min: params?.min ?? 0,
-      max: params?.max ?? 1000,
-    })
-  }
-
-  public static url() {
-    return new Faker<'url'>({
-      type: 'url',
-    })
-  }
-
-  public static date() {
-    return new Faker<'date'>({
-      type: 'date',
-    })
-  }
-
-  public static fullName() {
-    return new Faker<'fullName'>({
-      type: 'fullName',
-    })
-  }
-
-  public static personalNumber() {
-    return new Faker<'personalNumber'>({
-      type: 'personalNumber',
-    })
-  }
-
-  public static rank() {
-    return new Faker<'rank'>({
-      type: 'rank',
-    })
-  }
-
-  public static arrayElement(params: Omit<ArrayElementFakerConfig, 'type'>) {
-    return new Faker<'arrayElement'>({
-      type: 'arrayElement',
-      items: params.items,
-    })
-  }
-
-  public static arrayElements(params: Omit<ArrayElementsFakerConfig, 'type'>) {
-    return new Faker<'arrayElements'>({
-      type: 'arrayElements',
-      items: params.items,
-      count: params?.count,
-    })
-  }
-
-  public static callback(callback: CallbackFakerConfig['callback']) {
-    return new Faker<'callback'>({
+  public static callback(callback: CallbackFakerWrapperConfig['callback']) {
+    return new FakerWrapper<'callback'>({
       type: 'callback',
       callback,
     })
   }
 
-  public static array(params: Omit<ArrayFakerConfig, 'type'>) {
-    return new Faker<'array'>({
+  public static array(params: Omit<ArrayFakerWrapperConfig, 'type'>) {
+    return new FakerWrapper<'array'>({
       type: 'array',
       items: params.items,
       count: params.count,
     })
   }
 
-  public static object<O extends object = object>(params: Omit<ObjectFakerConfig<O>, 'type'>) {
-    return new Faker<'object'>({
+  public static object<O extends object = object>(
+    params: Omit<ObjectFakerWrapperConfig<O>, 'type'>,
+  ) {
+    return new FakerWrapper<'object'>({
       type: 'object',
       properties: params.properties,
     })
   }
 
+  public static instance<Function extends (...args: any[]) => any>(
+    callback: Function,
+    ...args: Parameters<Function>
+  ) {
+    return new FakerWrapper<'instance'>({
+      type: 'instance',
+      callback,
+      args,
+    })
+  }
+
   // modifiers
   public nullable(probability: number = 0.5) {
     this.params.nullable = true
@@ -265,6 +138,6 @@ declare class Faker<T extends FakerType> {
 
 declare const mockApi: (handlers: RequestHandler[]) => SetupWorkerApi
 
-declare function faker(): typeof Faker
+declare function fake(): typeof FakerWrapper
 
-export { faker, mockApi };
+export { fake, mockApi };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fauxy",
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.2",
   "description": "A package for mocking data and API requests",
   "license": "MIT",
   "homepage": "https://github.com/heavenlybilly/fauxy",

package/readme.md

@@ -20,26 +20,88 @@ npx fauxy init
 ```
 
 To ensure MSW knows where to find the service worker, add the following section to your package.json:
+
 ```json
 "msw": {
-  "workerDirectory": [
+    "workerDirectory": [
     "public"
-  ]
+]
 }
 ```
 
 An example of starting the mock service worker:
+
 ```ts
+// @mocks/index.ts
 import { mockApi } from 'fauxy'
+import someHandlers from '@/mocks/handlers/some-handlers'
+
+mockApi.start([...someHandlers])
+```
+
+```ts
+// @mocks/handlers/some-handlers.ts
+import { HttpResponse, delay, http, fake, fakerModules as fm } from 'fauxy'
+
+export default [
+  http.post('/api/persons/select', async () => {
+    await delay()
+
+    const items = fake().array({
+      count: 10,
+      items: fake().object({
+        properties: {
+          id: fake(fm.string.uuid),
+          title: fake(fm.person.fullName),
+        },
+      }),
+    })
 
-mockApi.start()
+    return HttpResponse.json(items)
+  }),
+]
 ```
 
-## How to use ![WIP](https://img.shields.io/badge/status-WIP-yellow)
+## How to use
+
+
+> How to use with [Laravel Mix](docs/laravel-mix.md)
 
-- [Laravel Mix](docs/laravel-mix.md)
+The following example demonstrates how to use `fake` and `fakerModules` to generate mock objects and arrays. It also
+shows how to set the locale for Faker.
+
+```ts
+import { fake, fakerModules as fm, setLocale } from 'fauxy'
+
+interface Person {
+  id: string
+  name: string
+  age: number
+}
+
+// set the Faker locale
+setLocale('ru')
+
+// generate an array of Person objects
+const persons = fake()
+  .array({
+    count: { min: 2, max: 4 }, // number of items in the array
+    items: fake().object<Person>({
+      properties: {
+        id: fake(fm.string.uuid), // generate a UUID for the id
+        name: fake(fm.person.fullName), // generate a full name
+        age: fake(fm.number.int, { min: 18, max: 35 }), // generate a random integer between 18 and 35
+      },
+    }),
+  })
+  .create<Person[]>()
+
+// generate a random date between two specific dates
+const date = fake(fm.date.between, { from: '2025-11-01', to: '2025-11-10' }).create()
+```
 
 ## Notes
+
 - Fauxy uses MSW directly from its package, so you can access all MSW features as usual.
 - Faker is only available via Fauxy’s wrapper, which adds convenience methods and some custom enhancements.
 - For more advanced usage and configuration, check out the official MSW repository.

package/src/declare-types/index.d.ts

@@ -1,9 +1,9 @@
 import { HttpResponse, RequestHandler, delay, http, passthrough } from 'msw'
 import { SetupWorkerApi } from 'msw/browser'
-import { Faker } from '@/faker/faker'
+import { FakerWrapper } from '@/faker/fakerWrapper'
 
 export { HttpResponse, RequestHandler, http, delay, passthrough }
 
 export declare const mockApi: (handlers: RequestHandler[]) => SetupWorkerApi
 
-export declare function faker(): typeof Faker
+export declare function fake(): typeof FakerWrapper

package/src/faker/fakerWrapper.ts

@@ -0,0 +1,90 @@
+import { generate } from './generators'
+import {
+  ArrayFakerWrapperConfig,
+  CallbackFakerWrapperConfig,
+  ExtractFakerConfig,
+  FakerWrapperType,
+  ObjectFakerWrapperConfig,
+} from './types'
+
+export class FakerWrapper<T extends FakerWrapperType> {
+  private readonly params: {
+    config: ExtractFakerConfig<T>
+    nullable: boolean
+    nullableProbability: number
+  }
+
+  private constructor(config: ExtractFakerConfig<T>) {
+    this.params = {
+      config,
+      nullable: false,
+      nullableProbability: 0,
+    }
+  }
+
+  public static callback(callback: CallbackFakerWrapperConfig['callback']) {
+    return new FakerWrapper<'callback'>({
+      type: 'callback',
+      callback,
+    })
+  }
+
+  public static array(params: Omit<ArrayFakerWrapperConfig, 'type'>) {
+    return new FakerWrapper<'array'>({
+      type: 'array',
+      items: params.items,
+      count: params.count,
+    })
+  }
+
+  public static object<O extends object = object>(
+    params: Omit<ObjectFakerWrapperConfig<O>, 'type'>,
+  ) {
+    return new FakerWrapper<'object'>({
+      type: 'object',
+      properties: params.properties,
+    })
+  }
+
+  public static instance<Function extends (...args: any[]) => any>(
+    callback: Function,
+    ...args: Parameters<Function>
+  ) {
+    return new FakerWrapper<'instance'>({
+      type: 'instance',
+      callback,
+      args,
+    })
+  }
+
+  // modifiers
+  public nullable(probability: number = 0.5) {
+    this.params.nullable = true
+    this.params.nullableProbability = probability
+
+    return this
+  }
+
+  // create methods
+  private createSingle<U>(): U {
+    return generate(this.params) as U
+  }
+
+  private createMultiple<U>(count: number): U[] {
+    return Array(count)
+      .fill(null)
+      .map(() => this.createSingle<U>())
+  }
+
+  public create<U>(): U
+
+  public create<U>(count: number): U[]
+
+  public create<U>(count?: number): U | U[] {
+    if (count === undefined) {
+      return this.createSingle<U>()
+    }
+
+    return this.createMultiple<U>(count)
+  }
+}

package/src/faker/generators/array.ts

@@ -1,7 +1,7 @@
 import { makeCount } from '@/faker/utils'
-import { ArrayFakerConfig } from '../types'
+import { ArrayFakerWrapperConfig } from '../types'
 
-export const generateArray = (config: ArrayFakerConfig) => {
+export const generateArray = (config: ArrayFakerWrapperConfig) => {
   return Array(makeCount(config.count))
     .fill(null)
     .map(() => {

package/src/faker/generators/callback.ts

@@ -1,5 +1,5 @@
-import { CallbackFakerConfig } from '../types'
+import { CallbackFakerWrapperConfig } from '../types'
 
-export const generateCallback = (config: CallbackFakerConfig) => {
+export const generateUsingCallback = (config: CallbackFakerWrapperConfig) => {
   return config.callback()
 }

package/src/faker/generators/index.ts

@@ -1,18 +1,8 @@
+import { generateUsingInstance } from '@/faker/generators/instance'
 import { FakerConfig } from '../types'
 import { generateArray } from './array'
-import { generateArrayElement } from './array-element'
-import { generateArrayElements } from './array-elements'
-import { generateBoolean } from './boolean'
-import { generateCallback } from './callback'
-import { generateDate } from './date'
-import { generateFullName } from './full-name'
-import { generateNumber } from './number'
+import { generateUsingCallback } from './callback'
 import { generateObject } from './object'
-import { generatePersonalNumber } from './personal-number'
-import { generateRank } from './rank'
-import { generateUrl } from './url'
-import { generateUuid } from './uuid'
-import { generateWords } from './words'
 
 const random = (probability: number) => {
   return Math.random() < probability
@@ -30,34 +20,14 @@ export const generate = (params: {
   }
 
   switch (type) {
-    case 'uuid':
-      return generateUuid(params.config)
-    case 'boolean':
-      return generateBoolean(params.config)
-    case 'words':
-      return generateWords(params.config)
-    case 'number':
-      return generateNumber(params.config)
-    case 'url':
-      return generateUrl(params.config)
-    case 'date':
-      return generateDate(params.config)
-    case 'personalNumber':
-      return generatePersonalNumber(params.config)
-    case 'fullName':
-      return generateFullName(params.config)
-    case 'rank':
-      return generateRank(params.config)
-    case 'arrayElement':
-      return generateArrayElement(params.config)
-    case 'arrayElements':
-      return generateArrayElements(params.config)
     case 'callback':
-      return generateCallback(params.config)
+      return generateUsingCallback(params.config)
     case 'object':
       return generateObject(params.config)
     case 'array':
       return generateArray(params.config)
+    case 'instance':
+      return generateUsingInstance(params.config)
     default: {
       const _: never = type
       throw new Error(`Unsupported type ${_}`)

package/src/faker/generators/instance.ts

@@ -0,0 +1,6 @@
+import { InstanceFakerWrapperConfig } from '../types'
+
+export const generateUsingInstance = (config: InstanceFakerWrapperConfig) => {
+  // @ts-ignore
+  return config.callback(...config.args)
+}

package/src/faker/generators/object.ts

@@ -1,11 +1,11 @@
-import { Faker } from '@/faker/faker'
-import { ObjectFakerConfig } from '../types'
+import { FakerWrapper } from '@/faker/fakerWrapper'
+import { ObjectFakerWrapperConfig } from '../types'
 
-export const generateObject = (config: ObjectFakerConfig) => {
+export const generateObject = (config: ObjectFakerWrapperConfig) => {
   return Object.keys(config.properties).reduce((carry, propertyName) => {
     const propertyValue = config.properties[propertyName]
 
-    const value = propertyValue instanceof Faker ? propertyValue.create() : propertyValue
+    const value = propertyValue instanceof FakerWrapper ? propertyValue.create() : propertyValue
 
     return {
       ...carry,

package/src/faker/index.ts

@@ -1,5 +1,64 @@
-import { Faker } from '@/faker/faker'
+import { Faker } from '@faker-js/faker'
+import { FakerWrapper } from '@/faker/fakerWrapper'
+import { Locale, locales } from '@/faker/locales'
 
-export const faker = () => {
-  return Faker
+const initialInstance = new Faker({ locale: [locales.en, locales.base] })
+
+export const fakerModules = {
+  airline: initialInstance.airline,
+  animal: initialInstance.animal,
+  book: initialInstance.book,
+  color: initialInstance.color,
+  commerce: initialInstance.commerce,
+  company: initialInstance.company,
+  database: initialInstance.database,
+  datatype: initialInstance.datatype,
+  date: initialInstance.date,
+  finance: initialInstance.finance,
+  food: initialInstance.food,
+  git: initialInstance.git,
+  hacker: initialInstance.hacker,
+  helpers: initialInstance.helpers,
+  image: initialInstance.image,
+  internet: initialInstance.internet,
+  location: initialInstance.location,
+  lorem: initialInstance.lorem,
+  music: initialInstance.music,
+  number: initialInstance.number,
+  person: initialInstance.person,
+  phone: initialInstance.phone,
+  science: initialInstance.science,
+  string: initialInstance.string,
+  system: initialInstance.system,
+  vehicle: initialInstance.vehicle,
+  word: initialInstance.word,
+}
+
+const buildModules = (locale: Locale) => {
+  const newInstance = new Faker({ locale: [locales[locale], locales.en, locales.base] })
+
+  const modules = Object.keys(fakerModules) as (keyof typeof fakerModules)[]
+
+  modules.forEach((moduleName) => {
+    // @ts-ignore
+    fakerModules[moduleName] = newInstance[moduleName]
+  })
+}
+
+export function setLocale(locale: Locale) {
+  buildModules(locale)
+}
+
+export function fake(): typeof FakerWrapper
+export function fake<T extends (...p: any[]) => any>(
+  fn: T,
+  ...args: Parameters<T>
+): FakerWrapper<'instance'>
+
+export function fake<T extends (...p: any[]) => any>(fn?: T, ...args: Parameters<T>) {
+  if (fn) {
+    return FakerWrapper.instance(fn, ...args)
+  }
+
+  return FakerWrapper
 }