fauxy 0.0.1-alpha.0

package/readme.md

@@ -0,0 +1,47 @@
+# Vue Api Mock 182
+description
+
+## Содержание
+- [Начало работы](#начало-работы)
+
+## Начало работы
+
+#### Установка пакета
+```bash
+npm i fauxy
+```
+
+#### Настройка окружения
+1. Для добавления Mock API в Laravel Mix, необходимо добавить новый файл, например, `resources/ts/mock.ts` с содержимым:
+```ts
+import { mockApi } from 'fauxy'
+
+mockApi.start()
+```
+
+2. Изменить файл `package.json`:
+```json
+"scripts": {
+    "watch:msw": "MIX_MOCK_API=true mix watch",
+},
+```
+
+Добавить в конец файла:
+```json
+"msw": {
+  "workerDirectory": [
+    "public"
+  ]
+}
+```
+
+3. В файле `webpack.mix.js` добавить в сборку файл `mock.ts` (из п.1):
+```js
+const mockSrc = process.env.MIX_MOCK_API === 'true' ? ['resources/ts/mock.ts'] : [];
+
+mix
+  .ts([
+    ...mockSrc,
+    'resources/ts/vue.ts'
+  ], 'public/js/vue.js')
+```

package/scripts/init.cjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const colors = {
+  error: '\x1b[31m',
+  success: '\x1b[32m',
+  reset: '\x1b[0m'
+};
+
+const sourceSwPath = path.join(__dirname, '../node_modules/msw/lib/mockServiceWorker.js');
+const targetSwPath = path.join(process.cwd(), 'public/mockServiceWorker.js');
+
+try {
+  if (!fs.existsSync(sourceSwPath)) {
+    console.error(colors.error + '❌  Mock Service Worker not found' + colors.reset);
+    process.exit(0);
+  }
+
+  const publicDir = path.dirname(targetSwPath);
+  if (!fs.existsSync(publicDir)) {
+    fs.mkdirSync(publicDir, { recursive: true });
+  }
+
+  fs.copyFileSync(sourceSwPath, targetSwPath);
+  console.log(colors.success + '✅  Mock Service Worker copied to public/' + colors.reset);
+
+} catch (error) {
+  console.error(colors.error + '❌  Failed to copy Mock Service Worker:' + colors.reset);
+  console.error(colors.error + error.message + colors.reset);
+}

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

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

package/src/faker/faker.ts

@@ -0,0 +1,153 @@
+import { generate } from './generators'
+import {
+  ArrayElementFakerConfig,
+  ArrayElementsFakerConfig,
+  ArrayFakerConfig,
+  CallbackFakerConfig,
+  ExtractFakerConfig,
+  FakerType,
+  NumberFakerConfig,
+  ObjectFakerConfig,
+  WordsFakerConfig,
+} from './types'
+
+export class Faker<T extends FakerType> {
+  private readonly params: {
+    config: ExtractFakerConfig<T>
+    nullable: boolean
+    nullableProbability: number
+  }
+
+  private constructor(config: ExtractFakerConfig<T>) {
+    this.params = {
+      config,
+      nullable: false,
+      nullableProbability: 0,
+    }
+  }
+
+  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'>({
+      type: 'callback',
+      callback,
+    })
+  }
+
+  public static array(params: Omit<ArrayFakerConfig, 'type'>) {
+    return new Faker<'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'>({
+      type: 'object',
+      properties: params.properties,
+    })
+  }
+
+  // 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-element.ts

@@ -0,0 +1,7 @@
+import { faker } from '@faker-js/faker'
+import { ArrayElementFakerConfig } from '../types'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateArrayElement = (config: ArrayElementFakerConfig) => {
+  return faker.helpers.arrayElement(config.items)
+}

package/src/faker/generators/array-elements.ts

@@ -0,0 +1,8 @@
+import { faker } from '@faker-js/faker'
+import { makeCount } from '@/faker/utils'
+import { ArrayElementsFakerConfig } from '../types'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateArrayElements = (config: ArrayElementsFakerConfig) => {
+  return faker.helpers.arrayElements(config.items, makeCount(config.count))
+}

package/src/faker/generators/array.ts

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

package/src/faker/generators/boolean.ts

@@ -0,0 +1,7 @@
+import { faker } from '@faker-js/faker'
+import { BooleanFakerConfig } from '../types'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateBoolean = (config: BooleanFakerConfig) => {
+  return faker.datatype.boolean()
+}

package/src/faker/generators/callback.ts

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

package/src/faker/generators/date.ts

@@ -0,0 +1,13 @@
+import { faker } from '@faker-js/faker'
+import { DateFakerConfig } from '../types'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateDate = (config: DateFakerConfig) => {
+  const date = new Date(faker.date.anytime())
+
+  const day = date.getDate()
+  const month = date.getMonth() + 1
+  const year = date.getFullYear()
+
+  return `${day}.${month.toString().padStart(2, '0')}.${year}`
+}

package/src/faker/generators/full-name.ts

@@ -0,0 +1,11 @@
+import { fakerRU } from '@faker-js/faker'
+import { FullNameFakerConfig } from '../types'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateFullName = (config: FullNameFakerConfig) => {
+  const firstName = fakerRU.person.firstName('male')
+  const lastName = fakerRU.person.lastName('male')
+  const middleName = fakerRU.person.middleName('male')
+
+  return `${lastName} ${firstName} ${middleName}`
+}

package/src/faker/generators/index.ts

@@ -0,0 +1,66 @@
+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 { 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
+}
+
+export const generate = (params: {
+  config: FakerConfig
+  nullable: boolean
+  nullableProbability: number
+}) => {
+  const { type } = params.config
+
+  if (params.nullable && random(params.nullableProbability)) {
+    return null
+  }
+
+  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)
+    case 'object':
+      return generateObject(params.config)
+    case 'array':
+      return generateArray(params.config)
+    default: {
+      const _: never = type
+      throw new Error(`Unsupported type ${_}`)
+    }
+  }
+}

package/src/faker/generators/number.ts

@@ -0,0 +1,9 @@
+import { faker } from '@faker-js/faker'
+import { NumberFakerConfig } from '../types'
+
+export const generateNumber = (config: NumberFakerConfig) => {
+  return faker.number.int({
+    min: config.min,
+    max: config.max,
+  })
+}

package/src/faker/generators/object.ts

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

package/src/faker/generators/personal-number.ts

@@ -0,0 +1,12 @@
+import { PersonalNumberFakerConfig } from '../types'
+
+const letters = ['Х', 'Э', 'ВЕ', 'Е']
+const digits = '0123456789'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generatePersonalNumber = (config: PersonalNumberFakerConfig) => {
+  return `${letters[Math.floor(Math.random() * letters.length)]}-${Array.from(
+    { length: 6 },
+    () => digits[Math.floor(Math.random() * digits.length)],
+  ).join('')}`
+}

package/src/faker/generators/rank.ts

@@ -0,0 +1,36 @@
+import { RankFakerConfig } from '../types'
+
+const ranks = [
+  'рядовой',
+  'матрос',
+  'ефрейтор',
+  'старший матрос',
+  'младший сержант',
+  'старшина 2 статьи',
+  'сержант',
+  'старшина 3 статьи',
+  'старший сержант',
+  'главный старшина',
+  'старшина',
+  'главный корабельный старшина',
+  'прапорщик',
+  'мичман',
+  'старший прапорщик',
+  'старший мичман',
+  'младший лейтенант',
+  'лейтенант',
+  'старший лейтенант',
+  'капитан',
+  'капитан-лейтенант',
+  'майор',
+  'капитан 3 ранга',
+  'подполковник',
+  'капитан 2 ранга',
+  'полковник',
+  'капитан 1 ранга',
+]
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateRank = (config: RankFakerConfig) => {
+  return ranks[Math.floor(Math.random() * ranks.length)]
+}

package/src/faker/generators/url.ts

@@ -0,0 +1,7 @@
+import { faker } from '@faker-js/faker'
+import { UrlFakerConfig } from '../types'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateUrl = (config: UrlFakerConfig) => {
+  return faker.internet.url()
+}

package/src/faker/generators/uuid.ts

@@ -0,0 +1,7 @@
+import { faker } from '@faker-js/faker'
+import { UuidFakerConfig } from '../types'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateUuid = (config: UuidFakerConfig) => {
+  return faker.string.uuid()
+}

package/src/faker/generators/words.ts

@@ -0,0 +1,10 @@
+import { fakerRU } from '@faker-js/faker'
+import { makeCount } from '@/faker/utils'
+import { WordsFakerConfig } from '../types'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const generateWords = (config: WordsFakerConfig) => {
+  return fakerRU.word.words({
+    count: makeCount(config?.count),
+  })
+}

package/src/faker/index.ts

@@ -0,0 +1,5 @@
+import { Faker } from '@/faker/faker'
+
+export const faker = () => {
+  return Faker
+}

package/src/faker/types.ts

@@ -0,0 +1,121 @@
+import { Faker } from './faker'
+
+/**
+ * Utils
+ */
+export type Count =
+  | number
+  | {
+      min: number
+      max: number
+    }
+
+/**
+ * Mock config
+ */
+export type FakerType =
+  | 'uuid'
+  | 'boolean'
+  | 'words'
+  | 'number'
+  | 'url'
+  | 'fullName'
+  | 'date'
+  | 'personalNumber'
+  | 'rank'
+  | 'arrayElement'
+  | 'arrayElements'
+  | 'callback'
+  | 'array'
+  | 'object'
+
+interface BaseFakerConfig {
+  type: FakerType
+}
+
+export interface UuidFakerConfig extends BaseFakerConfig {
+  type: 'uuid'
+}
+
+export interface BooleanFakerConfig extends BaseFakerConfig {
+  type: 'boolean'
+}
+
+export interface WordsFakerConfig extends BaseFakerConfig {
+  type: 'words'
+  count?: Count
+}
+
+export interface NumberFakerConfig extends BaseFakerConfig {
+  type: 'number'
+  min?: number
+  max?: number
+}
+
+export interface UrlFakerConfig extends BaseFakerConfig {
+  type: 'url'
+}
+
+export interface DateFakerConfig extends BaseFakerConfig {
+  type: 'date'
+}
+
+export interface FullNameFakerConfig extends BaseFakerConfig {
+  type: 'fullName'
+}
+
+export interface PersonalNumberFakerConfig extends BaseFakerConfig {
+  type: 'personalNumber'
+}
+
+export interface RankFakerConfig extends BaseFakerConfig {
+  type: 'rank'
+}
+
+export interface ArrayElementFakerConfig extends BaseFakerConfig {
+  type: 'arrayElement'
+  items: unknown[]
+}
+
+export interface ArrayElementsFakerConfig extends BaseFakerConfig {
+  type: 'arrayElements'
+  items: unknown[]
+  count?: Count
+}
+
+export interface CallbackFakerConfig extends BaseFakerConfig {
+  type: 'callback'
+  callback: (...args: unknown[]) => any
+}
+
+export interface ArrayFakerConfig extends BaseFakerConfig {
+  type: 'array'
+  items: Faker<any>
+  count: Count
+}
+
+export interface ObjectFakerConfig<O extends Record<string, any> = Record<string, any>>
+  extends BaseFakerConfig {
+  type: 'object'
+  properties: {
+    [_ in keyof O]: Faker<any> | any
+  }
+}
+
+export type FakerConfig =
+  | UuidFakerConfig
+  | BooleanFakerConfig
+  | WordsFakerConfig
+  | NumberFakerConfig
+  | UrlFakerConfig
+  | FullNameFakerConfig
+  | DateFakerConfig
+  | PersonalNumberFakerConfig
+  | RankFakerConfig
+  | ArrayElementFakerConfig
+  | ArrayElementsFakerConfig
+  | CallbackFakerConfig
+  | ArrayFakerConfig
+  | ObjectFakerConfig
+
+export type ExtractFakerConfig<T extends FakerType> = Extract<FakerConfig, { type: T }>

package/src/faker/utils.ts

@@ -0,0 +1,23 @@
+import { Count } from '@/faker/types'
+
+export const makeCount = (count?: Count): number => {
+  if (count === undefined) {
+    return 1
+  }
+
+  if (typeof count === 'number') {
+    return count
+  }
+
+  const { min, max } = count
+
+  if (min > max) {
+    throw new Error('Min cannot be greater than max')
+  }
+
+  if (min < 0 || max < 0) {
+    throw new Error('Count values cannot be negative')
+  }
+
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './msw'
+export * from './faker'

package/src/msw/index.ts

@@ -0,0 +1,14 @@
+import { HttpResponse, RequestHandler, delay, http, passthrough } from 'msw'
+import { setupWorker } from 'msw/browser'
+
+const mockApi = async (handlers: RequestHandler[]) => {
+  const worker = setupWorker(...handlers)
+
+  await worker.start({
+    onUnhandledRequest: 'bypass',
+  })
+
+  return worker
+}
+
+export { mockApi, HttpResponse, RequestHandler, http, delay, passthrough }