@prefecthq/prefect-ui-library 2.9.18 → 2.10.0

package/src/schemas/utilities/errors.ts

@@ -0,0 +1,49 @@
+import { State } from '@prefecthq/prefect-design'
+import { SchemaValueError, isNotStringError, isSchemaValueIndexError, isSchemaValuePropertyError } from '@/schemas/types/schemaValuesValidationResponse'
+import { isString } from '@/utilities/strings'
+
+export function getSchemaPropertyErrors(propertyKeyOrIndex: string | number, errors: SchemaValueError[]): SchemaValueError[] {
+  if (isString(propertyKeyOrIndex)) {
+    return errors.filter(isSchemaValuePropertyError).filter(error => error.property === propertyKeyOrIndex).flatMap(error => error.errors)
+  }
+
+  return errors.filter(isSchemaValueIndexError).filter(error => error.index == propertyKeyOrIndex).flatMap(error => error.errors)
+}
+
+export type SchemaPropertyError = {
+  state: State,
+  message: string | undefined,
+}
+
+export function getSchemaPropertyError(errors: SchemaValueError[]): SchemaPropertyError {
+  const propertyErrors = errors.filter(isString)
+  const state: State = { pending: false, valid: true, validated: true }
+
+  if (propertyErrors.length) {
+    state.valid = false
+    return {
+      state,
+      message: propertyErrors.join(' and '),
+    }
+  }
+
+  return {
+    state,
+    message: undefined,
+  }
+}
+
+export function getAllSchemaPropertyErrors(errors: SchemaValueError[]): SchemaValueError[] {
+  const propertyErrors = getAllRootSchemaPropertyErrors(errors)
+  const childErrors = getAllChildSchemaPropertyErrors(errors)
+
+  return [...propertyErrors, ...childErrors]
+}
+
+export function getAllRootSchemaPropertyErrors(errors: SchemaValueError[]): SchemaValueError[] {
+  return errors.filter(isString)
+}
+
+export function getAllChildSchemaPropertyErrors(errors: SchemaValueError[]): SchemaValueError[] {
+  return errors.filter(isNotStringError)
+}

package/src/schemas/utilities/properties.ts

@@ -0,0 +1,154 @@
+import { isDefined } from '@prefecthq/prefect-design'
+import { Schema, SchemaProperty, SchemaPropertyType, isPropertyWith, isSchemaPropertyType } from '@/schemas/types/schema'
+import { BlockDocumentReferenceValue, SchemaValue, isBlockDocumentReferenceValue } from '@/schemas/types/schemaValues'
+import { getSchemaDefinition } from '@/schemas/utilities/definitions'
+import { Require } from '@/types/utilities'
+import { isArray, isEmptyObject, isRecord } from '@/utilities'
+import { CreateApi } from '@/utilities/api'
+
+const schemaPropertyTypeLabelMap: Record<SchemaPropertyType, string> = {
+  'null': 'None',
+  'string': 'str',
+  'boolean': 'bool',
+  'integer': 'int',
+  'number': 'float',
+  'array': 'list',
+  'object': 'dict',
+}
+
+export function getSchemaPropertyTypeLabel(type: SchemaPropertyType | undefined): string {
+  if (type) {
+    return schemaPropertyTypeLabelMap[type]
+  }
+
+  return ''
+}
+
+export function getSchemaPropertyLabel(property: SchemaProperty): string {
+  const type = getSchemaPropertyTypeLabel(property.type)
+
+  return property.title ?? property.format ?? type
+}
+
+/*
+ * This is purposefully not recursive and does not resolve definition
+ * Schemas can be circular so we just want to get the default value for one level
+ */
+export function getSchemaPropertyDefaultValue(property: SchemaProperty): SchemaValue {
+  if (isDefined(property.default)) {
+    return property.default
+  }
+
+  if (isSchemaPropertyType(property.type, 'object') && isPropertyWith(property, 'properties')) {
+    return Object.entries(property.properties).reduce<Record<string, unknown>>((value, [key, property]) => {
+      if (isDefined(property.default)) {
+        value[key] = property.default
+      }
+
+      return value
+    }, {})
+  }
+
+  return undefined
+}
+
+export function getSchemaPropertyAllOfDefinitions(property: Require<SchemaProperty, 'anyOf'>, schema: Schema): SchemaProperty[] {
+  return property.anyOf.map(definition => {
+    if (isPropertyWith(definition, '$ref')) {
+      return getSchemaDefinition(schema, definition.$ref)
+    }
+
+    return definition
+  })
+}
+
+type InitialIndexContext = {
+  property: Require<SchemaProperty, 'anyOf'>,
+  value: SchemaValue,
+  schema: Schema,
+  api: CreateApi,
+}
+
+export async function getInitialIndexForSchemaPropertyAnyOfValue({ value, property, schema, api }: InitialIndexContext): Promise<number> {
+  const valueOrDefaultValue = isDefined(value) ? value : property.default
+
+  // if there's no value default to showing the first definition
+  if (!isDefined(valueOrDefaultValue)) {
+    return 0
+  }
+
+  const definitions = getSchemaPropertyAllOfDefinitions(property, schema)
+
+  // block documents are the only reason this utility is async.
+  // if the value is a block document reference we need to fetch the block document from the api
+  // to determine the block type
+  if (isBlockDocumentReferenceValue(valueOrDefaultValue)) {
+    return await getBlockDocumentReferenceDefinitionIndex(valueOrDefaultValue, definitions, api)
+  }
+
+  switch (typeof valueOrDefaultValue) {
+    case 'string':
+      return definitions.findIndex(definition => definition.type == 'string')
+    case 'number':
+      return definitions.findIndex(definition => definition.type == 'number' || definition.type === 'integer')
+    case 'boolean':
+      return definitions.findIndex(definition => definition.type == 'boolean')
+    case 'object':
+      return getObjectDefinitionIndex(valueOrDefaultValue, definitions)
+    default:
+      return -1
+  }
+}
+
+async function getBlockDocumentReferenceDefinitionIndex(value: BlockDocumentReferenceValue, definitions: SchemaProperty[], api: CreateApi): Promise<number> {
+  const blockDocument = await api.blockDocuments.getBlockDocument(value.$ref)
+
+  const definition = definitions.find(definition => definition.blockTypeSlug === blockDocument.blockType.slug)
+
+  if (definition) {
+    return definitions.indexOf(definition)
+  }
+
+  return -1
+}
+
+function getObjectDefinitionIndex(value: object | null, definitions: SchemaProperty[]): number {
+  if (isRecord(value)) {
+    return getRecordDefinitionIndex(value, definitions)
+  }
+
+  if (isArray(value)) {
+    return definitions.findIndex(definition => definition.type === 'array')
+  }
+
+  if (value === null) {
+    return definitions.findIndex(definition => definition.type === 'null')
+  }
+
+  return -1
+}
+
+function getRecordDefinitionIndex(value: Record<string, unknown>, definitions: SchemaProperty[]): number {
+  if (isEmptyObject(value)) {
+    return definitions.findIndex(definition => definition.type === 'object')
+  }
+
+  const valueKeys = Object.keys(value)
+
+  const [index, keysInCommon] = definitions.reduce<[number, number]>(([resultIndex, resultKeysInCommon], definition, definitionIndex) => {
+    const definitionKeys = Object.keys(definition.properties ?? {})
+    const definitionKeysInCommon = valueKeys.filter(value => definitionKeys.includes(value)).length
+
+    if (definitionKeysInCommon > resultKeysInCommon) {
+      return [definitionIndex, definitionKeysInCommon]
+    }
+
+    return [resultIndex, resultKeysInCommon]
+  }, [0, 0])
+
+  if (keysInCommon === 0) {
+    return -1
+  }
+
+  return index
+}

package/src/services/Api.ts

@@ -0,0 +1,134 @@
+import { asArray } from '@prefecthq/prefect-design'
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse, RawAxiosRequestHeaders } from 'axios'
+import { MaybeArray } from '@/types/utilities'
+import { isDefined } from '@/utilities/variables'
+
+export type AxiosInstanceSetupHook = (instance: AxiosInstance) => void
+
+export type PrefectConfig = {
+  baseUrl: string,
+  token?: string,
+}
+
+type ConfigFunction<R, T extends PrefectConfig = PrefectConfig> = (config: T) => R
+export type ApiBaseUrl<T extends PrefectConfig = PrefectConfig> = string | ConfigFunction<string, T>
+export type ApiHeaders<T extends PrefectConfig = PrefectConfig> = RawAxiosRequestHeaders | ConfigFunction<RawAxiosRequestHeaders, T>
+
+export const getPrefectBaseUrl: ApiBaseUrl = (config) => config.baseUrl
+
+export const getPrefectUIHeaders: RawAxiosRequestHeaders = { 'X-PREFECT-UI': true }
+
+export const getAuthorizationHeaders: ApiHeaders = (config) => {
+  const value: RawAxiosRequestHeaders = {}
+
+  if (config.token) {
+    value.Authorization = `bearer ${config.token}`
+  }
+
+  return value
+}
+
+export class Api<T extends PrefectConfig = PrefectConfig> {
+  protected readonly apiConfig: T
+  protected apiHeaders: MaybeArray<ApiHeaders> = [getPrefectUIHeaders, getAuthorizationHeaders]
+  protected apiBaseUrl: ApiBaseUrl = getPrefectBaseUrl
+  protected routePrefix: string | undefined
+  protected instanceSetupHook: AxiosInstanceSetupHook | null
+
+  public constructor(apiConfig: T, instanceSetupHook: AxiosInstanceSetupHook | null = null) {
+    this.apiConfig = apiConfig
+    this.instanceSetupHook = instanceSetupHook
+  }
+
+  protected composeBaseUrl(): string {
+    if (typeof this.apiBaseUrl === 'string') {
+      return this.apiBaseUrl
+    }
+
+    return this.apiBaseUrl(this.apiConfig)
+  }
+
+  protected composeHeaders(): RawAxiosRequestHeaders {
+    const array = asArray(this.apiHeaders)
+
+    return array.reduce<RawAxiosRequestHeaders>((headers, header) => {
+      const value = typeof header === 'function' ? header(this.apiConfig) : header
+
+      return {
+        ...headers,
+        ...value,
+      }
+    }, {})
+  }
+
+  protected combinePath(route: string | undefined): string {
+    const repeatingSlashes = /(\/+)/g
+
+    return [this.routePrefix, route]
+      .filter(isDefined)
+      .join('/')
+      .replace(repeatingSlashes, '/')
+  }
+
+  protected instance(): AxiosInstance {
+    const config: AxiosRequestConfig = {
+      baseURL: this.composeBaseUrl(),
+      headers: this.composeHeaders(),
+    }
+
+    const instance = axios.create(config)
+    if (this.instanceSetupHook) {
+      this.instanceSetupHook(instance)
+    }
+
+    return instance
+  }
+
+  protected get<T, R = AxiosResponse<T>>(route?: string, config?: AxiosRequestConfig): Promise<R> {
+    const path = this.combinePath(route)
+
+    return this.instance().get(path, config)
+  }
+
+  protected delete<T, R = AxiosResponse<T>>(route?: string, config?: AxiosRequestConfig): Promise<R> {
+    const path = this.combinePath(route)
+
+    return this.instance().delete(path, config)
+  }
+
+  protected head<T, R = AxiosResponse<T>>(route?: string, config?: AxiosRequestConfig): Promise<R> {
+    const path = this.combinePath(route)
+
+    return this.instance().head(path, config)
+  }
+
+  protected options<T, R = AxiosResponse<T>>(route?: string, config?: AxiosRequestConfig): Promise<R> {
+    const path = this.combinePath(route)
+
+    return this.instance().options(path, config)
+  }
+
+  // axios uses any for the data argument
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected post<T, R = AxiosResponse<T>>(route?: string, data?: any, config?: AxiosRequestConfig): Promise<R> {
+    const path = this.combinePath(route)
+
+    return this.instance().post(path, data, config)
+  }
+
+  // axios uses any for the data argument
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected put<T, R = AxiosResponse<T>>(route?: string, data?: any, config?: AxiosRequestConfig): Promise<R> {
+    const path = this.combinePath(route)
+
+    return this.instance().put(path, data, config)
+  }
+
+  // axios uses any for the data argument
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected patch<T, R = AxiosResponse<T>>(route?: string, data?: any, config?: AxiosRequestConfig): Promise<R> {
+    const path = this.combinePath(route)
+
+    return this.instance().patch(path, data, config)
+  }
+}

package/src/services/BatchProcessor/BatchProcessor.ts

@@ -0,0 +1,156 @@
+import { BatchLookupError } from '@/models/BatchLookupError'
+import { MaybePromise } from '@/types'
+
+export type BatchCallbackLookup<V, R> = (value: V) => MaybePromise<R>
+export type BatchCallback<V, R> = (values: V[]) => MaybePromise<Map<V, R> | BatchCallbackLookup<V, R>>
+export type BatchOptions = {
+  maxBatchSize?: number,
+  maxWaitMilliseconds?: number,
+}
+
+type Timer = ReturnType<typeof setTimeout>
+type Resolve<V> = (value: V) => void
+type Reject = (reason?: unknown) => void
+type BatchQueueValue<R> = {
+  response: Promise<R>,
+  resolve: Resolve<R>,
+  reject: Reject,
+}
+
+type BatchQueue<V, R> = Map<V, BatchQueueValue<R>>
+
+export class BatchProcessor<V, R> {
+  private readonly callback: BatchCallback<V, R>
+  private readonly options: BatchOptions
+  private readonly queue: BatchQueue<V, R> = new Map()
+  private timeout: Timer | undefined = undefined
+  private waitingSince: number | null = null
+
+  public constructor(callback: BatchCallback<V, R>, options: BatchOptions = {}) {
+    this.callback = callback
+    this.options = options
+  }
+
+  public batch(value: V): Promise<R> {
+    if (this.queue.has(value)) {
+      const { response } = this.queue.get(value)!
+
+      return response
+    }
+
+    let resolve!: Resolve<R>
+    let reject!: Reject
+
+    const response = new Promise<R>((...args) => {
+      [resolve, reject] = args
+    })
+
+    this.queue.set(value, {
+      response,
+      resolve,
+      reject,
+    })
+
+    this.requestProcessQueue()
+
+    return response
+  }
+
+  public process(): void {
+    this.processQueue()
+  }
+
+  private requestProcessQueue(): void {
+    if (this.shouldProcessNow()) {
+      this.processQueue()
+      return
+    }
+
+    this.waitToProcessQueue()
+  }
+
+  private waitToProcessQueue(): void {
+    if (this.waitingSince === null) {
+      this.waitingSince = Date.now()
+    }
+
+    clearTimeout(this.timeout)
+
+    this.timeout = setTimeout(() => this.processQueue())
+  }
+
+  private shouldProcessNow(): boolean {
+    return this.maxBatchSizeReached() || this.maxWaitReached()
+  }
+
+  private maxBatchSizeReached(): boolean {
+    const { maxBatchSize = Infinity } = this.options
+
+    return this.queue.size >= maxBatchSize
+  }
+
+  private maxWaitReached(): boolean {
+    const { maxWaitMilliseconds = Infinity } = this.options
+    const now = Date.now()
+    const since = this.waitingSince ?? 0
+
+    return now - since >= maxWaitMilliseconds
+  }
+
+  private getBatchToProcess(): BatchQueue<V, R> {
+    const batch = new Map(this.queue)
+
+    this.queue.clear()
+    this.waitingSince = null
+
+    clearTimeout(this.timeout)
+
+    return batch
+  }
+
+  private async processQueue(): Promise<void> {
+    const batch = this.getBatchToProcess()
+    const values = Array.from(batch.keys())
+
+    try {
+      const response = await this.callback(values)
+
+      if (this.isBatchCallbackLookup(response)) {
+        return this.resolveBatchUsingLookup(batch, response)
+      }
+
+      return this.resolveBatchUsingMap(batch, response)
+
+    } catch (error) {
+      this.rejectBatch(batch, error)
+    }
+  }
+
+  private resolveBatchUsingMap(batch: BatchQueue<V, R>, map: Map<V, R>): void {
+    batch.forEach(({ resolve, reject }, id) => {
+      const value = map.get(id)
+
+      if (value === undefined) {
+        reject(new BatchLookupError(id))
+        return
+      }
+
+      resolve(value)
+    })
+  }
+
+  private resolveBatchUsingLookup(batch: BatchQueue<V, R>, lookup: BatchCallbackLookup<V, R>): void {
+    batch.forEach(async ({ resolve }, id) => {
+      resolve(await lookup(id))
+    })
+  }
+
+  private rejectBatch(batch: BatchQueue<V, R>, error: unknown): void {
+    batch.forEach(({ reject }) => reject(error))
+  }
+
+  private isBatchCallbackLookup(value: ReturnType<BatchCallback<V, R>>): value is BatchCallbackLookup<V, R> {
+    return typeof value === 'function'
+  }
+
+}

package/src/services/BatchProcessor/README.md

@@ -0,0 +1,36 @@
+# BatchProcessor
+The `BatchProcessor` can be used to queue and batch the processing of values using a single callback. This is useful for repetitive tasks but also useful for combining tasks for efficiency. A common use case for this is batching individual calls to an api endpoint into a single api request. 
+
+A `BatchProcessor` can be created by passing a callback to be used for processing multiple values. The `BatchProcessor` will execute the callback automatically, passing one or more values in to be processed. 
+
+A callback can return either `Map<Value, Response>` or `(value: Value) => Response`. If a map is returned from a callback, it assumes that every value will exist as a key in the map and the response can be found using that key. If a lookup function is returned it will call the lookup function for each value being processed to get the response for each value
+
+## Example 
+```typescript
+const batcher = new BatchProcessor<string, User>(async userIds => {
+  const users: User[] = await getUsersArray(userIds)
+
+  // this is using a lookup function
+  return userId => users.find(user => user.id === userId)
+})
+
+const user1: Promise<User> = batcher.batch('userId1')
+const user2: Promise<User> = batcher.batch('userId2')
+const user3: Promise<User> = batcher.batch('userId3')
+```
+
+## Public Methods
+
+### Batch
+
+```typescript
+public batch(value: V): Promise<R>
+```
+This method adds a value to the queue to be processed later. 
+
+
+### Process
+```typescript
+public process(): void
+```
+This method immediately processes the queue. 

package/src/services/BatchProcessor/index.ts

@@ -0,0 +1 @@
+export * from './BatchProcessor'

package/src/services/CollectionsApi.ts

@@ -0,0 +1,17 @@
+import { CollectionItem, CollectionsResponse, PrefectWorkerCollectionResponse, WorkerCollectionItem } from '@/models'
+import { Api } from '@/services/Api'
+import { mapper } from '@/services/Mapper'
+
+export class CollectionsApi extends Api {
+  protected override routePrefix = '/collections'
+
+  public getFlowCollection(): Promise<CollectionItem[]> {
+    return this.get<CollectionsResponse>('/views/aggregate-flow-metadata')
+      .then(({ data }) => mapper.map('CollectionResponse', data, 'CollectionItems'))
+  }
+
+  public getWorkerCollection(): Promise<WorkerCollectionItem[]> {
+    return this.get<PrefectWorkerCollectionResponse>('/views/aggregate-worker-metadata')
+      .then(({ data }) => mapper.map('PrefectWorkerCollectionResponse', data, 'WorkerCollectionItem'))
+  }
+}

package/src/services/HealthApi.ts

@@ -0,0 +1,17 @@
+import { Api } from '@/services/Api'
+
+export class HealthApi extends Api {
+  protected override routePrefix = '/health'
+
+  public getHealth(): Promise<boolean> {
+    return this.get<boolean>().then(({ data }) => data)
+  }
+
+  public async isHealthy(): Promise<boolean> {
+    try {
+      return await this.getHealth()
+    } catch {
+      return false
+    }
+  }
+}

package/src/services/Mapper.ts

@@ -0,0 +1,67 @@
+/* eslint-disable no-dupe-class-members */
+import { maps } from '@/maps'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Map = (...args: any) => any
+type Maps = Record<string, Record<string, Map>>
+type MapsMember<T extends Maps, S extends keyof T> = T[S][keyof T[S]]
+type Mappers<T extends Maps, S extends keyof T> = Extract<MapsMember<T, S>, Map>
+type MapperSourceType<T extends Maps, S extends keyof T> = Parameters<Mappers<T, S>>[0]
+type MapperDestinationType<T extends Maps, S extends keyof T, D extends keyof T[S]> = ReturnType<T[S][D]>
+
+export class Mapper<T extends Maps> {
+  private readonly mapperFunctions: T
+
+  public constructor(mapperFunctions: T) {
+    this.mapperFunctions = mapperFunctions
+  }
+
+  public map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S>, destination: D): MapperDestinationType<T, S, D>
+  public map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | null, destination: D): MapperDestinationType<T, S, D> | null
+  public map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | undefined, destination: D): MapperDestinationType<T, S, D> | undefined
+  public map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | null | undefined, destination: D): MapperDestinationType<T, S, D> | null | undefined
+  public map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S>[], destination: D): MapperDestinationType<T, S, D>[]
+  public map<S extends keyof T, D extends keyof T[S]>(source: S, value: MapperSourceType<T, S> | MapperSourceType<T, S>[] | null | undefined, destination: D): MapperDestinationType<T, S, D> | MapperDestinationType<T, S, D>[] | null | undefined {
+    if (value === null || value === undefined) {
+      return value
+    }
+
+    const mapper = this.bindMapper(this.mapperFunctions[source][destination])
+
+    if (Array.isArray(value)) {
+      return value.map(mapper)
+    }
+
+    return mapper(value)
+  }
+
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>>, destination: D): Record<string, MapperDestinationType<T, S, D>>
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | null, destination: D): Record<string, MapperDestinationType<T, S, D>> | null
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>> | undefined
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>> | null | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>> | null | undefined
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]>, destination: D): Record<string, MapperDestinationType<T, S, D>[]>
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | null, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | null
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | undefined
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S>[]> | null | undefined, destination: D): Record<string, MapperDestinationType<T, S, D>[]> | null | undefined
+  public mapEntries<S extends keyof T, D extends keyof T[S]>(source: S, value: Record<string, MapperSourceType<T, S> | MapperSourceType<T, S>[]> | null | undefined, destination: D): Record<string, MapperDestinationType<T, S, D> | MapperDestinationType<T, S, D>[]> | null | undefined {
+    if (value === null || value === undefined) {
+      return value
+    }
+
+    const response = {} as Record<string, MapperDestinationType<T, S, D>>
+
+    return Object.entries(value).reduce<Record<string, MapperDestinationType<T, S, D>>>((mapped, [key, value]) => {
+      mapped[key] = this.map(source, value, destination)
+
+      return mapped
+    }, response)
+  }
+
+  private bindMapper<S extends keyof T, D extends keyof T[S]>(mapper: MapsMember<T, S>): (source: MapperSourceType<T, S>) => MapperDestinationType<T, S, D> {
+    return mapper.bind(this)
+  }
+}
+
+export const mapper = new Mapper(maps)
+
+export type MapFunction<S, D> = (this: typeof mapper, source: S) => D

package/src/services/Mocker.ts

@@ -0,0 +1,42 @@
+import { mocks } from '@/mocks'
+import { repeat } from '@/utilities'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Mock = (...args: any[]) => any
+type MockParams<T extends Mock> = Parameters<T>
+type MockReturns<T extends Mock> = ReturnType<T>
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type OnlyRequired<T extends any[], U extends any[] = []> = Partial<T> extends T ? U : T extends [infer F, ...infer R] ? OnlyRequired<R, [...U, F]> : U
+type MockParamsRequired<T extends Mock> = OnlyRequired<MockParams<T>>
+
+type CreateArguments<T extends Record<string, Mock>, K extends keyof T> = MockParamsRequired<T[K]> extends never[]
+  ? [key: K, args?: MockParams<T[K]>]
+  : [key: K, args: MockParams<T[K]>]
+
+type CreateManyArguments<T extends Record<string, Mock>, K extends keyof T> = MockParamsRequired<T[K]> extends never[]
+  ? [key: K, count: number, args?: MockParams<T[K]>]
+  : [key: K, count: number, args: MockParams<T[K]>]
+
+export class Mocker<T extends Record<string, Mock>> {
+  private readonly mockerFunctions: T
+
+  public constructor(mockerFunctions: T) {
+    this.mockerFunctions = mockerFunctions
+  }
+
+  public create<K extends keyof T>(...[key, args]: CreateArguments<T, K>): MockReturns<T[K]> {
+    const mock = this.mockerFunctions[key].bind(this, ...args ?? [])
+
+    return mock()
+  }
+
+  public createMany<K extends keyof T>(...[key, count, args]: CreateManyArguments<T, K>): MockReturns<T[K]>[] {
+    const mock = this.mockerFunctions[key].bind(this, ...args ?? [])
+
+    return repeat(count, mock)
+  }
+}
+
+export const mocker = new Mocker(mocks)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type MockFunction<T, Args extends any[]> = (this: typeof mocker, ...args: Args) => T