@koalarx/nest 1.19.0 → 3.0.2

package/src/core/mapping/auto-mapping-list.ts

@@ -0,0 +1,154 @@
+import { Type } from '@nestjs/common'
+import { findOnList } from '../utils/find-on-list'
+import { getTypeByProp } from '../utils/get-type-by-prop'
+import { List } from '../utils/list'
+import { AutoMappingClassContext } from './auto-mapping-class-context'
+import { AutoMappingContext } from './auto-mapping-context'
+import { ForMemberDefinition } from './for-member'
+
+interface AutoMappingGetContext {
+  mapContext: AutoMappingContext | null
+  propSourceContext: AutoMappingClassContext | null
+  propTargetContext: AutoMappingClassContext | null
+}
+
+export class AutoMappingList {
+  private static _mappedPropList: List<AutoMappingClassContext> | undefined
+  private static _mappingProfileList: List<AutoMappingContext> | undefined
+
+  private static initializeLists() {
+    if (!this._mappedPropList) {
+      this._mappedPropList = new List(AutoMappingClassContext)
+    }
+    if (!this._mappingProfileList) {
+      this._mappingProfileList = new List(AutoMappingContext)
+    }
+  }
+
+  static add(
+    source: Type<any>,
+    target: Type<any>,
+    ...forMember: ForMemberDefinition<any, any>
+  ) {
+    this.initializeLists()
+    this._mappingProfileList!.add(
+      new AutoMappingContext(source, target, forMember),
+    )
+    this._mappedPropList!.add(new AutoMappingClassContext(source))
+    this._mappedPropList!.add(new AutoMappingClassContext(target))
+
+    this.addExtendedPropsIntoSubClass(source)
+    this.addExtendedPropsIntoSubClass(target)
+  }
+
+  static get(source: Type<any>, target: Type<any>): AutoMappingGetContext {
+    this.initializeLists()
+    return {
+      mapContext: findOnList(
+        this._mappingProfileList!,
+        (mp) =>
+          mp.source.name === source.name && mp.target.name === target.name,
+        (mp) =>
+          Object.getPrototypeOf(mp.source.prototype.constructor) === source &&
+          mp.target.name === target.name,
+      ),
+      propSourceContext: this._mappedPropList!.find(
+        (mp) => mp.source.name === source.name,
+      ),
+      propTargetContext: this._mappedPropList!.find(
+        (mp) => mp.source.name === target.name,
+      ),
+    }
+  }
+
+  static getSourceByName(sourceName: string) {
+    this.initializeLists()
+    return this._mappedPropList!.find((mp) => mp.source.name === sourceName)
+      ?.source
+  }
+
+  static getPropDefinitions(source: Type<any>, propName: string) {
+    this.initializeLists()
+    const prop = this._mappedPropList!.find(
+      (mp) => mp.source.name === source.name,
+    )?.props.find((prop) => prop.name === propName)
+
+    if (!prop) {
+      return undefined
+    }
+
+    return {
+      ...prop,
+      type: getTypeByProp(prop),
+    }
+  }
+
+  static getTargets(source: Type<any>) {
+    this.initializeLists()
+    return this._mappingProfileList!.filter(
+      (mp) =>
+        mp.source.name === source.name ||
+        Object.getPrototypeOf(mp.source.prototype.constructor) === source,
+    )
+      .map((mp) => mp.target)
+      .toArray()
+  }
+
+  static addMappedProp(source: Type<any>, propName: string) {
+    this.initializeLists()
+    let mappedClass = this._mappedPropList!.find(
+      (mp) => mp.source.name === source.name,
+    )
+
+    if (!mappedClass) {
+      mappedClass = new AutoMappingClassContext(source)
+
+      const mappedExtendedClass = this._mappedPropList!.find(
+        (mp) =>
+          mp.source === Object.getPrototypeOf(source.prototype.constructor),
+      )
+
+      if (mappedExtendedClass) {
+        mappedClass.props.setList(mappedExtendedClass.props.toArray())
+      }
+
+      this._mappedPropList!.add(mappedClass)
+    }
+
+    const type = Reflect.getMetadata('design:type', source.prototype, propName)
+    const compositionType = Reflect.getMetadata(
+      'composition:type',
+      source.prototype,
+      propName,
+    )
+    const compositionAction = Reflect.getMetadata(
+      'composition:action',
+      source.prototype,
+      propName,
+    )
+
+    mappedClass.props.add({
+      name: propName,
+      type,
+      compositionType,
+      compositionAction,
+    })
+  }
+
+  static addExtendedPropsIntoSubClass(source: Type<any>) {
+    this.initializeLists()
+    const mappedExtendedClass = this._mappedPropList!.find(
+      (mp) => mp.source === Object.getPrototypeOf(source.prototype.constructor),
+    )
+    if (mappedExtendedClass) {
+      const mappedClass = this._mappedPropList!.find(
+        (mp) => mp.source.name === source.name,
+      )
+      if (mappedClass) {
+        mappedExtendedClass.props
+          .toArray()
+          .forEach((prop) => mappedClass.props.add(prop))
+      }
+    }
+  }
+}

package/src/core/mapping/auto-mapping-profile.ts

@@ -0,0 +1,3 @@
+export abstract class AutoMappingProfile {
+  abstract profile(): void
+}

package/src/core/mapping/auto-mapping.decorator.ts

@@ -0,0 +1,54 @@
+import { Type } from '@nestjs/common'
+import { AutoMappingList } from './auto-mapping-list'
+
+interface AutoMapConfig<T> {
+  type?: () => Type<T>
+  isArray?: boolean | { addTo: boolean }
+}
+
+export function AutoMap<T>(config?: AutoMapConfig<T>) {
+  return function (target: any, propertyKey: string) {
+    const isArray = config?.isArray
+
+    let customMetadata: (() => any) | undefined = config?.type
+
+    if (!customMetadata) {
+      customMetadata = isArray ? Array : undefined
+    }
+
+    if (customMetadata) {
+      if (isArray) {
+        Reflect.defineMetadata(
+          'composition:type',
+          customMetadata,
+          target,
+          propertyKey,
+        )
+        Reflect.defineMetadata(
+          'composition:action',
+          `${isArray === true || !isArray.addTo ? 'onlySet' : 'addTo'}`,
+          target,
+          propertyKey,
+        )
+
+        if (customMetadata !== Array) {
+          customMetadata = Array
+        }
+      }
+
+      if (
+        !Reflect.getMetadata('design:type', target, propertyKey) ||
+        !isArray
+      ) {
+        Reflect.defineMetadata(
+          'design:type',
+          customMetadata,
+          target,
+          propertyKey,
+        )
+      }
+    }
+
+    AutoMappingList.addMappedProp(target.constructor, propertyKey)
+  }
+}

package/src/core/mapping/auto-mapping.module.ts

@@ -0,0 +1,17 @@
+import { DynamicModule, Module, Type } from '@nestjs/common'
+import { AutoMappingProfile } from './auto-mapping-profile'
+import { AutoMappingService } from './auto-mapping.service'
+
+@Module({})
+export class AutoMappingModule {
+  static register(profile: Type<AutoMappingProfile>): DynamicModule {
+    return {
+      module: AutoMappingModule,
+      providers: [
+        { provide: AutoMappingProfile, useClass: profile },
+        AutoMappingService,
+      ],
+      exports: [AutoMappingService],
+    }
+  }
+}

package/src/core/mapping/auto-mapping.service.ts

@@ -0,0 +1,187 @@
+import { Injectable, Type } from '@nestjs/common'
+import { getTypeByProp } from '../utils/get-type-by-prop'
+import { List } from '../utils/list'
+import { AutoMappingList } from './auto-mapping-list'
+import { AutoMappingProfile } from './auto-mapping-profile'
+
+@Injectable()
+export class AutoMappingService {
+  private readonly _contextList = AutoMappingList
+
+  constructor(automappingProfile: AutoMappingProfile) {
+    automappingProfile.profile()
+  }
+
+  private getInstanceType(
+    prop: () => Type<any> | ArrayConstructor,
+  ): Type<any> | ArrayConstructor {
+    try {
+      return prop() ?? prop
+    } catch {
+      return prop as any
+    }
+  }
+
+  map<S, T>(data: any, source: Type<S>, target: Type<T>): T {
+    const { mapContext, propSourceContext, propTargetContext } =
+      this._contextList.get(source, target)
+
+    if (!mapContext) {
+      throw new Error(
+        `No mapping context found for ${source.name} to ${target.name}`,
+      )
+    }
+
+    const mappedTarget = new target.prototype.constructor()
+
+    propSourceContext?.props.forEach((propSource) => {
+      const value = data[propSource.name]
+      const compositionType = propSource.compositionType
+      const compositionAction = propSource.compositionAction
+
+      if (value !== undefined) {
+        const targetProp = propTargetContext?.props.find(
+          (tp) => tp.name === propSource.name,
+        )
+
+        if (targetProp) {
+          const typeSource = getTypeByProp(propSource)
+          const typeTarget = getTypeByProp(targetProp)
+
+          const listToArray =
+            typeSource === List.name &&
+            typeTarget === Array.name &&
+            value instanceof List
+
+          const arrayToList =
+            typeSource === Array.name &&
+            typeTarget === List.name &&
+            value instanceof Array &&
+            !!compositionType
+
+          const arrayToArray =
+            typeSource === Array.name &&
+            typeTarget === Array.name &&
+            value instanceof Array &&
+            !!compositionType
+
+          let mappedValue = value
+
+          if (listToArray) {
+            mappedValue = this.mapListToArray(value)
+          } else if (arrayToList) {
+            mappedValue = this.mapArrayToList(
+              value,
+              this.getInstanceType(compositionType),
+              compositionAction === 'onlySet',
+            )
+          } else if (arrayToArray) {
+            mappedValue = this.mapArrayToArray(
+              value,
+              this.getInstanceType(compositionType),
+            )
+          } else {
+            const propSourceInstance =
+              this._contextList.getSourceByName(typeSource)
+            if (propSourceInstance) {
+              mappedValue = this.mapNestedProp(value, propSourceInstance)
+            }
+          }
+
+          mappedTarget[targetProp.name] = mappedValue
+        }
+      }
+    })
+
+    propTargetContext?.props.forEach((prop) => {
+      const formMemberDefinition = mapContext.forMemberDifinitions?.find(
+        (def) => def[prop.name],
+      )?.[prop.name]
+
+      if (formMemberDefinition) {
+        mappedTarget[prop.name] = formMemberDefinition(data)
+      }
+    })
+
+    return mappedTarget
+  }
+
+  private getTarget(data: any, source: Type<any>) {
+    if (this.isPrimitiveType(data)) {
+      return data
+    }
+
+    const targets = this._contextList.getTargets(source.prototype.constructor)
+
+    if (targets.length === 0) {
+      throw new Error(`No mapping context found for ${source.name}`)
+    }
+
+    return targets[0]
+  }
+
+  private mapNestedProp(data: any, source: Type<any>) {
+    return this.map(
+      data,
+      source.prototype.constructor,
+      this.getTarget(data, source),
+    )
+  }
+
+  private mapListToArray(value: List<any>) {
+    return value.toArray().map((item) => {
+      const entityOnList = value.entityType?.prototype.constructor
+
+      if (entityOnList) {
+        return this.mapNestedProp(item, entityOnList) ?? {}
+      }
+
+      return {}
+    })
+  }
+
+  private mapArrayToList(
+    value: Array<any>,
+    compositionType: Type<any>,
+    onlySet = true,
+  ) {
+    const list = new List(
+      this.getTarget(value, compositionType.prototype.constructor),
+    )
+
+    const mappedValue = value.map(
+      (item) =>
+        this.mapNestedProp(item, compositionType.prototype.constructor) ?? {},
+    )
+
+    if (onlySet) {
+      list.setList(mappedValue)
+    } else {
+      list.update(mappedValue)
+    }
+
+    return list
+  }
+
+  private mapArrayToArray(value: Array<any>, compositionType: Type<any>) {
+    return value.map(
+      (item) =>
+        this.mapNestedProp(item, compositionType.prototype.constructor) ?? {},
+    )
+  }
+
+  private isPrimitiveType(value: any) {
+    switch (typeof value) {
+      case 'string':
+      case 'number':
+      case 'bigint':
+      case 'boolean':
+        return true
+      case 'symbol':
+      case 'undefined':
+      case 'object':
+      case 'function':
+        return false
+    }
+  }
+}

package/src/core/mapping/create-map.ts

@@ -0,0 +1,11 @@
+import { Type } from '@nestjs/common'
+import { AutoMappingList } from './auto-mapping-list'
+import { ForMemberDefinition } from './for-member'
+
+export function createMap<TSource, TTarget>(
+  source: Type<TSource>,
+  target: Type<TTarget>,
+  ...formMember: ForMemberDefinition<TTarget, TSource>
+) {
+  AutoMappingList.add(source, target, ...formMember)
+}

package/src/core/mapping/for-member.ts

@@ -0,0 +1,16 @@
+export type ForMemberResult<TTarget, TSource> = {
+  [Key in keyof TTarget]: (source: TSource) => TTarget[Key]
+}
+
+export type ForMemberDefinition<TTarget, TSource> = Array<
+  Partial<ForMemberResult<TTarget, TSource>>
+>
+
+export function forMember<TTarget, TSource>(
+  targetProp: keyof TTarget,
+  map: (source: TSource) => TTarget[keyof TTarget],
+): Partial<ForMemberResult<TTarget, TSource>> {
+  return {
+    [targetProp]: map,
+  } as Partial<ForMemberResult<TTarget, TSource>>
+}

package/src/core/request-overflow/request-handler.base.ts

@@ -0,0 +1,8 @@
+import { RequestResult } from './request-result'
+
+export abstract class RequestHandlerBase<
+  TRequest,
+  TResponse extends RequestResult<Error, any>,
+> {
+  abstract handle(req: TRequest): Promise<TResponse>
+}

package/src/core/request-overflow/request-result.spec.ts

@@ -0,0 +1,23 @@
+import { RequestResult, failure, ok } from './request-result'
+
+function doSometing(shouldSuccess: boolean): RequestResult<string, number> {
+  if (shouldSuccess) {
+    return ok(10)
+  } else {
+    return failure('error')
+  }
+}
+
+test('success result', () => {
+  const result = doSometing(true)
+
+  expect(result.isOk()).toBe(true)
+  expect(result.isFailure()).toBe(false)
+})
+
+test('error result', () => {
+  const result = doSometing(false)
+
+  expect(result.isFailure()).toBe(true)
+  expect(result.isOk()).toBe(false)
+})

package/src/core/request-overflow/request-result.ts

@@ -0,0 +1,41 @@
+export class Failure<L, R> {
+  readonly value: L
+
+  constructor(value: L) {
+    this.value = value
+  }
+
+  isFailure(): this is Failure<L, R> {
+    return true
+  }
+
+  isOk(): this is Ok<L, R> {
+    return false
+  }
+}
+
+export class Ok<L, R> {
+  readonly value: R
+
+  constructor(value: R) {
+    this.value = value
+  }
+
+  isFailure(): this is Failure<L, R> {
+    return false
+  }
+
+  isOk(): this is Ok<L, R> {
+    return true
+  }
+}
+
+export type RequestResult<L, R> = Failure<L, R> | Ok<L, R>
+
+export const failure = <L, R>(value: L): RequestResult<L, R> => {
+  return new Failure(value)
+}
+
+export const ok = <L, R>(value: R): RequestResult<L, R> => {
+  return new Ok(value)
+}

package/src/core/request-overflow/request-validator.base.ts

@@ -0,0 +1,33 @@
+import { ZodType } from 'zod'
+
+export abstract class RequestValidatorBase<
+  TRequest extends Record<string, any>,
+> {
+  protected _request: Record<string, any>
+
+  constructor(request: TRequest) {
+    this._request = { ...request }
+  }
+
+  validate(): TRequest {
+    Object.keys(this._request).forEach((key) => {
+      if (key.includes('[]')) {
+        const newKey = key.replace('[]', '')
+        const value = this._request[key]
+        this._request[newKey] =
+          typeof value === 'string' ? value.split(',') : value
+        delete this._request[key]
+      }
+    })
+
+    const requestParsed = this.schema.safeParse(this._request)
+
+    if (requestParsed.success) {
+      return Object.assign(this._request as any, requestParsed.data)
+    }
+
+    throw requestParsed.error
+  }
+
+  protected abstract get schema(): ZodType
+}

package/src/core/security/strategies/api-key.strategy.ts

@@ -0,0 +1,45 @@
+import { UnauthorizedException } from '@nestjs/common'
+import { Request } from 'express'
+import { Strategy } from 'passport-custom'
+
+export type DoneFn = (err: Error | null, user?: any) => void
+
+interface ApiKeyStrategyOptions {
+  header: string
+  prefix?: string
+}
+
+abstract class ApiKeyStrategyBase extends Strategy {
+  constructor({ header, prefix }: ApiKeyStrategyOptions) {
+    super(async (request: Request, done: DoneFn) => {
+      try {
+        const apikey = request.headers[header.toLowerCase()] as string
+        const apiKeyEncoded = apikey?.replace(`${prefix || ''} `, '')
+
+        if (apiKeyEncoded) {
+          return await this.validate(apiKeyEncoded, done, request)
+        }
+
+        return done(new UnauthorizedException())
+      } catch (err) {
+        return done(err, null)
+      }
+    })
+  }
+
+  abstract validate(
+    apikey: string,
+    done: DoneFn,
+    request: Request,
+  ): Promise<void> | void
+}
+
+export class ApiKeyStrategy extends ApiKeyStrategyBase {
+  constructor(options: ApiKeyStrategyOptions) {
+    super(options)
+  }
+
+  validate(apikey: string, done: DoneFn, request: Request) {
+    throw new Error('Method not implemented.')
+  }
+}

package/src/core/utils/assing-object.ts

@@ -0,0 +1,9 @@
+import { Type } from '@nestjs/common'
+
+export type ObjectProps<T> = {
+  [K in keyof T as T[K] extends Function ? never : K]: T[K]
+}
+
+export function assignObject<T>(Target: Type<T>, source: ObjectProps<T>): T {
+  return Object.assign(new Target() as any, source)
+}

package/src/core/utils/env.config.ts

@@ -0,0 +1,17 @@
+export class EnvConfig {
+  static get isEnvTest() {
+    return process.env.NODE_ENV === 'test'
+  }
+
+  static get isEnvDevelop() {
+    return process.env.NODE_ENV === 'develop'
+  }
+
+  static get isEnvStaging() {
+    return process.env.NODE_ENV === 'staging'
+  }
+
+  static get isEnvProduction() {
+    return process.env.NODE_ENV === 'production'
+  }
+}

package/src/core/utils/filter-request-params.ts

@@ -0,0 +1,23 @@
+import { ArgumentsHost } from '@nestjs/common/interfaces'
+import { Request, Response } from 'express'
+
+export class FilterRequestParams {
+  static get(host: ArgumentsHost) {
+    const ctx = host.switchToHttp()
+    const response = ctx.getResponse<Response>()
+    const request = ctx.getRequest<Request & { user?: { login: string } }>()
+    const method = request.method
+    const isGetMethod = method === 'GET'
+
+    return {
+      response,
+      loggedUserName:
+        request?.user?.login ?? request.headers.origin ?? request.ip ?? '',
+      filterParams: {
+        method,
+        payload: !isGetMethod ? request.body : undefined,
+        endpoint: request.url,
+      },
+    }
+  }
+}

package/src/core/utils/find-on-list.ts

@@ -0,0 +1,18 @@
+import { List } from './list'
+
+export function findOnList<T>(
+  list: List<T>,
+  ...predicates: ((item: T) => boolean)[]
+) {
+  let result: T | null = null
+
+  for (const predicate of predicates) {
+    result = list.find(predicate)
+
+    if (result) {
+      break
+    }
+  }
+
+  return result
+}

package/src/core/utils/get-type-by-prop.ts

@@ -0,0 +1,9 @@
+import { AutoMappingClassProp } from '../mapping/auto-mapping-class-context'
+
+export function getTypeByProp(prop: AutoMappingClassProp) {
+  try {
+    return prop.type().name ?? prop.type.name ?? ''
+  } catch {
+    return prop.type.name ?? ''
+  }
+}