@bessemer/cornerstone 0.5.0

package/src/logger.ts

@@ -0,0 +1,144 @@
+import pino from 'pino'
+import { Lazy, Objects } from '@bessemer/cornerstone'
+import { createGlobalVariable } from '@bessemer/cornerstone/global-variable'
+import { LazyValue } from '@bessemer/cornerstone/lazy'
+import { UnknownRecord } from 'type-fest'
+
+type PinoLogger = pino.Logger
+type PinoBindings = pino.Bindings
+export type LoggerOptions = pino.LoggerOptions
+
+type LogOptions = { error?: unknown; context?: UnknownRecord }
+type LogFunction = (message: LazyValue<string>, options?: LogOptions) => void
+
+export class Logger {
+  constructor(private readonly logger: PinoLogger) {}
+
+  trace: LogFunction = (message: LazyValue<string>, options?: LogOptions): void => {
+    if (this.logger.isLevelEnabled?.('trace') ?? true) {
+      this.logger.trace({ err: options?.error, context: options?.context }, Lazy.evaluate(message))
+    }
+  }
+
+  debug: LogFunction = (message: LazyValue<string>, options?: LogOptions): void => {
+    if (this.logger.isLevelEnabled?.('debug') ?? true) {
+      this.logger.debug({ err: options?.error, context: options?.context }, Lazy.evaluate(message))
+    }
+  }
+
+  info: LogFunction = (message: LazyValue<string>, options?: LogOptions): void => {
+    if (this.logger.isLevelEnabled?.('info') ?? true) {
+      this.logger.info({ err: options?.error, context: options?.context }, Lazy.evaluate(message))
+    }
+  }
+
+  warn: LogFunction = (message: LazyValue<string>, options?: LogOptions): void => {
+    if (this.logger.isLevelEnabled?.('warn') ?? true) {
+      this.logger.warn({ err: options?.error, context: options?.context }, Lazy.evaluate(message))
+    }
+  }
+
+  error: LogFunction = (message: LazyValue<string>, options?: LogOptions): void => {
+    if (this.logger.isLevelEnabled?.('error') ?? true) {
+      this.logger.error({ err: options?.error, context: options?.context }, Lazy.evaluate(message))
+    }
+  }
+
+  fatal: LogFunction = (message: LazyValue<string>, options?: LogOptions): void => {
+    if (this.logger.isLevelEnabled?.('fatal') ?? true) {
+      this.logger.fatal({ err: options?.error, context: options?.context }, Lazy.evaluate(message))
+    }
+  }
+}
+
+const getPrettyTransport = (): LoggerOptions => {
+  if (process.env.NODE_ENV === 'production' || typeof window !== 'undefined') {
+    return {}
+  }
+
+  return {
+    transport: {
+      target: 'pino-pretty',
+      options: {
+        colorize: true,
+        ignore: 'pid,hostname,module',
+        messageFormat: '{if module}{module} - {end}{msg}',
+      },
+    },
+  }
+}
+
+const applyDefaultOptions = (options?: LoggerOptions): LoggerOptions => {
+  const defaultOptions: LoggerOptions = {
+    browser: {
+      asObject: true,
+    },
+    ...getPrettyTransport(),
+  }
+
+  return Objects.merge(defaultOptions, options)
+}
+
+const createProxyHandler = (getLogger: () => PinoLogger): ProxyHandler<PinoLogger> => {
+  let cachedLogger: PinoLogger | null = null
+  let cachedVersion = GlobalLoggerState.getValue().version
+
+  const getOrCreateLogger = () => {
+    if (cachedVersion !== GlobalLoggerState.getValue().version) {
+      cachedLogger = null
+      cachedVersion = GlobalLoggerState.getValue().version
+    }
+
+    if (Objects.isNil(cachedLogger)) {
+      cachedLogger = getLogger()
+    }
+
+    return cachedLogger
+  }
+
+  return {
+    get(_: any, prop: string): any {
+      if (prop === 'child') {
+        return (bindings: PinoBindings) => {
+          return new Proxy(
+            {} as PinoLogger,
+            createProxyHandler(() => getOrCreateLogger().child(bindings))
+          )
+        }
+      }
+
+      return (getOrCreateLogger() as any)[prop]
+    },
+  }
+}
+
+const GlobalLoggerState = createGlobalVariable<{
+  version: number
+  logger: pino.Logger
+}>('GlobalLoggerState', () => ({
+  version: 0,
+  logger: pino(applyDefaultOptions({ level: 'info' })),
+}))
+
+const LoggerProxy: PinoLogger = new Proxy(
+  {} as PinoLogger,
+  createProxyHandler(() => GlobalLoggerState.getValue().logger)
+)
+
+const Primary: Logger = new Logger(LoggerProxy)
+
+export const initialize = (initialOptions?: LoggerOptions): void => {
+  const options = applyDefaultOptions(initialOptions)
+  GlobalLoggerState.setValue({ version: GlobalLoggerState.getValue().version + 1, logger: pino(options) })
+}
+
+export const child = (module: string): Logger => {
+  return new Logger(LoggerProxy.child({ module }))
+}
+
+export const trace = Primary.trace
+export const debug = Primary.debug
+export const info = Primary.info
+export const warn = Primary.warn
+export const error = Primary.error
+export const fatal = Primary.fatal

package/src/math.ts

@@ -0,0 +1,132 @@
+import { isNumber as _isNumber } from 'lodash-es'
+
+export const isNumber = (value?: unknown): value is number => {
+  return _isNumber(value)
+}
+
+export const isPositive = (value?: unknown): value is number => {
+  return isNumber(value) && value > 0
+}
+
+export const isEven = (d: number) => d % 2 === 0
+
+export enum RoundingMode {
+  Nearest = 'Nearest',
+  Down = 'Down',
+  Up = 'Up',
+  HalfEven = 'HalfEven',
+}
+
+export const round = (value: number, scale: number, roundingMode: RoundingMode): number => {
+  switch (roundingMode) {
+    case RoundingMode.Nearest:
+      return roundNearest(value, scale)
+    case RoundingMode.Down:
+      return roundDown(value, scale)
+    case RoundingMode.Up:
+      return roundUp(value, scale)
+    case RoundingMode.HalfEven:
+      return roundHalfEven(value, scale)
+  }
+}
+
+export const roundNearest = (value: number, scale: number): number => {
+  const factor = Math.pow(10, scale)
+  return Math.round((value + Number.EPSILON) * factor) / factor
+}
+
+export const roundDown = (value: number, scale: number) => {
+  const factor = Math.pow(10, scale)
+  return Math.floor((value + +Number.EPSILON) * factor) / factor
+}
+
+export const roundUp = (value: number, scale: number) => {
+  const factor = Math.pow(10, scale)
+  return Math.ceil((value + +Number.EPSILON) * factor) / factor
+}
+
+/**
+ * Round Half-Even (Banker's Rounding) Utility
+ * https://en.wikipedia.org/wiki/Rounding#Round_half_to_even
+ *
+ * Mostly copied from this Github: https://github.com/schowdhuri/round-half-even
+ */
+export const roundHalfEven = (value: number, scale: number): number => {
+  if (value < 0) {
+    return -roundHalfEven(-value, scale)
+  }
+  if (scale === 0) {
+    return roundHalfEven(value / 10, 1) * 10
+  }
+
+  const MAX_DECIMALS_ALLOWED = 20
+  if (scale > MAX_DECIMALS_ALLOWED) {
+    throw new Error(`Cannot handle more than ${MAX_DECIMALS_ALLOWED} decimals`)
+  }
+
+  // convert to string; remove trailing 0s
+  const isExponentialForm = value.toString().includes('e') || value.toString().includes('E')
+  const strNum = (isExponentialForm ? value.toFixed(MAX_DECIMALS_ALLOWED).toString() : value.toString()).replace(/0+$/, '')
+  const decimalIndex = strNum.indexOf('.')
+  if (decimalIndex < 0) {
+    // no fractional part
+    return value
+  }
+  let intPart: string = strNum.slice(0, decimalIndex)
+  if (intPart.length == 0) {
+    intPart = '0'
+  }
+  let fractPart = strNum.slice(decimalIndex + 1) // extract fractional part
+  if (fractPart.length < scale) {
+    return value
+  }
+  const followingDig = parseInt(fractPart[scale]!, 10)
+  if (followingDig < 5) {
+    // rounding not required
+    const newFractPart = fractPart.slice(0, scale)
+    return parseFloat(`${intPart}.${newFractPart}`)
+  }
+  if (followingDig === 5) {
+    const newFractPart = fractPart.slice(0, scale + 1)
+    if (parseInt(fractPart.slice(scale + 1), 10) > 0) {
+      fractPart = `${newFractPart}9`
+    } else {
+      fractPart = newFractPart
+    }
+  }
+
+  let nextDig = parseInt(fractPart[fractPart.length - 1]!, 10)
+  let carriedOver = 0
+  for (let ptr = fractPart.length - 1; ptr >= scale; ptr--) {
+    let dig = parseInt(fractPart[ptr - 1]!, 10) + carriedOver
+    if (nextDig > 5 || (nextDig == 5 && !isEven(dig))) {
+      ++dig
+    }
+    if (dig > 9) {
+      dig -= 10
+      carriedOver = 1
+    } else {
+      carriedOver = 0
+    }
+    nextDig = dig
+  }
+
+  let newFractPart = ''
+  for (let ptr = scale - 2; ptr >= 0; ptr--) {
+    let d = parseInt(fractPart[ptr]!, 10) + carriedOver
+    if (d > 9) {
+      d -= 10
+      carriedOver = 1
+    } else {
+      carriedOver = 0
+    }
+    newFractPart = `${d}${newFractPart}`
+  }
+
+  const resolvedIntPart = parseInt(intPart, 10) + carriedOver
+  return parseFloat(`${resolvedIntPart}.${newFractPart}${nextDig}`)
+}
+
+export const random = (min: number, max: number): number => {
+  return Math.random() * (max - min) + min
+}

package/src/misc.ts

@@ -0,0 +1,22 @@
+import { Objects, Preconditions } from '@bessemer/cornerstone'
+import { Equalitor } from '@bessemer/cornerstone/equalitor'
+
+export const doUntilConsistent = <T>(supplier: (previous: T | null) => T, equals: Equalitor<T>): T => {
+  let done = false
+  let previousValue: T | null = null
+  let attempts = 0
+  do {
+    Preconditions.isTrue(attempts < 10)
+
+    const currentValue = supplier(previousValue)
+
+    if (Objects.isPresent(previousValue) && equals(previousValue, currentValue)) {
+      done = true
+    }
+
+    previousValue = currentValue
+    attempts++
+  } while (!done)
+
+  return previousValue
+}

package/src/object.ts

@@ -0,0 +1,236 @@
+import {
+  clone as _clone,
+  cloneDeep as _cloneDeep,
+  invert as _invert,
+  isEqual as _isEqual,
+  isNil as _isNil,
+  isNumber,
+  isObject as _isObject,
+  isPlainObject as _isPlainObject,
+  isString,
+  isUndefined as _isUndefined,
+  mapValues as _mapValues,
+  merge as unsafeMerge,
+  mergeWith as unsafeMergeWith,
+} from 'lodash-es'
+import { produce } from 'immer'
+import { NominalType } from '@bessemer/cornerstone/types'
+import { Primitive, UnknownRecord } from 'type-fest'
+
+export const update: typeof produce = produce
+
+export const isUndefined = _isUndefined
+export const isNil = _isNil
+export const isPresent = <T>(value: T): value is NonNullable<T> => {
+  return !isNil(value)
+}
+export const isObject = _isObject
+export const isPlainObject = _isPlainObject
+export const deepEqual = _isEqual
+export const invert = _invert
+export const mapValues = _mapValues
+
+export const clone = _clone
+export const cloneDeep = _cloneDeep
+
+export const mergeAll = <T>(objects: Array<T>): T => {
+  return objects.reduce((x, y) => merge(x, y))
+}
+
+export function merge<TObject, TSource>(object: TObject, source: TSource): TObject & TSource
+export function merge<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2
+export function merge<TObject, TSource1, TSource2, TSource3>(
+  object: TObject,
+  source1: TSource1,
+  source2: TSource2,
+  source3: TSource3
+): TObject & TSource1 & TSource2 & TSource3
+export function merge<TObject, TSource1, TSource2, TSource3, TSource4>(
+  object: TObject,
+  source1: TSource1,
+  source2: TSource2,
+  source3: TSource3,
+  source4: TSource4
+): TObject & TSource1 & TSource2 & TSource3 & TSource4
+export function merge(object: any, ...otherArgs: any[]): any {
+  return unsafeMerge({}, object, ...otherArgs)
+}
+
+export function mergeInto<Source1, Source2>(source: Source1, values: Source2): asserts source is Source1 & Source2 {
+  unsafeMerge(source, values)
+}
+
+export const mergeWith: typeof unsafeMergeWith = (...args: Array<any>) => {
+  const clone = cloneDeep(args[0])
+  return unsafeMergeWith.apply(null, [clone, ...args.slice(1)])
+}
+
+export type ObjectDiffResult = {
+  elementsUpdated: Record<string, { originalValue: unknown; updatedValue: unknown }>
+  elementsAdded: UnknownRecord
+  elementsRemoved: UnknownRecord
+}
+
+export function diffShallow(original: UnknownRecord, updated: UnknownRecord): ObjectDiffResult {
+  const result: ObjectDiffResult = {
+    elementsUpdated: {},
+    elementsAdded: {},
+    elementsRemoved: {},
+  }
+
+  for (const [key, originalValue] of Object.entries(original)) {
+    const updatedValue = updated[key]
+    if (updatedValue === undefined) {
+      result.elementsRemoved[key] = originalValue
+    } else if (!deepEqual(originalValue, updatedValue)) {
+      result.elementsUpdated[key] = { originalValue: originalValue, updatedValue: updatedValue }
+    }
+  }
+
+  for (const [key, updatedValue] of Object.entries(updated)) {
+    const originalValue = original[key]
+    if (originalValue === undefined) {
+      result.elementsAdded[key] = updatedValue
+    }
+  }
+  return result
+}
+
+export const isValidKey = (field: PropertyKey, obj: object): field is keyof typeof obj => {
+  return field in obj
+}
+
+/** Determines if the list of fields are present on the object (not null or undefined), with type inference */
+export function fieldsPresent<T extends object, K extends keyof T>(
+  object: T,
+  fields: Array<K>
+): object is Exclude<T, K> & Required<{ [P in K]: NonNullable<T[P]> }> {
+  return fields.every((field) => isPresent(object[field]))
+}
+
+export type ObjectPath = {
+  path: Array<string | number>
+}
+
+export const path = (path: Array<string | number>): ObjectPath => {
+  return { path }
+}
+
+export const parsePath = (path: string): ObjectPath => {
+  const result: Array<string | number> = []
+  const regex = /([^.\[\]]+)|\[(\d+)]/g
+
+  let match: RegExpExecArray | null
+  while ((match = regex.exec(path)) !== null) {
+    if (match[1] !== undefined) {
+      result.push(match[1])
+    } else if (match[2] !== undefined) {
+      result.push(Number(match[2]))
+    }
+  }
+
+  return { path: result }
+}
+
+const pathify = (path: ObjectPath | string): ObjectPath => {
+  if (isString(path)) {
+    return parsePath(path)
+  }
+
+  return path as ObjectPath
+}
+
+export const getPathValue = (object: UnknownRecord, initialPath: ObjectPath | string): unknown | undefined => {
+  const path = pathify(initialPath)
+  let current: any = object
+
+  for (const key of path.path) {
+    if (isPrimitive(current)) {
+      return undefined
+    }
+
+    current = current[key]
+  }
+
+  return current
+}
+
+export const applyPathValue = (object: UnknownRecord, initialPath: ObjectPath | string, value: unknown): UnknownRecord | undefined => {
+  const path = pathify(initialPath)
+
+  const newObject = update(object, (draft) => {
+    let current: any = draft
+
+    for (let i = 0; i < path.path.length; i++) {
+      const key = path.path[i]!
+      const isLastKey = i === path.path.length - 1
+
+      if (isPrimitive(current)) {
+        return
+      }
+
+      if (Array.isArray(current)) {
+        if (!isNumber(key)) {
+          return
+        }
+
+        if (key >= current.length) {
+          return
+        }
+      }
+
+      if (isLastKey) {
+        current[key] = value
+      } else {
+        current = current[key]
+      }
+    }
+  })
+
+  if (newObject === object) {
+    return undefined
+  }
+
+  return newObject
+}
+
+const isPrimitive = (value: any): value is Primitive => {
+  return value === null || (typeof value !== 'object' && typeof value !== 'function')
+}
+
+type TransformFunction = (value: any, path: (string | number)[], key: string | number, parent: any) => any
+
+const walk = (value: any, transform: TransformFunction, path: (string | number)[] = []): any => {
+  if (isNil(value) || isPrimitive(value)) {
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((value, index) => {
+      const currentPath = [...path, index]
+      return walk(transform(value, currentPath, index, value), transform, currentPath)
+    })
+  }
+
+  const result: any = {}
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      const currentPath = [...path, key]
+      const transformedValue = transform(value[key], currentPath, key, value)
+      result[key] = walk(transformedValue, transform, currentPath)
+    }
+  }
+
+  return result
+}
+
+export type RecordAttribute<Type = unknown, Class extends string = 'RecordAttribute'> = NominalType<string, [Type, Class]>
+type RecordAttributeType<Attribute> = Attribute extends RecordAttribute<infer Type, string> ? Type : never
+
+export const getAttribute = <T extends RecordAttribute<unknown, string>>(record: UnknownRecord, attribute: T): RecordAttributeType<T> | undefined => {
+  return record[attribute] as RecordAttributeType<T> | undefined
+}
+
+export const coerceNil = <T>(value: T | null | undefined): T | undefined => {
+  return isNil(value) ? undefined : value
+}

package/src/patch.ts

@@ -0,0 +1,128 @@
+import {
+  ArrayExpressions,
+  EvaluateExpression,
+  Expression,
+  Expressions,
+  NumericExpressions,
+  ReducingExpression,
+} from '@bessemer/cornerstone/expression'
+import { Objects, Preconditions } from '@bessemer/cornerstone'
+import { UnknownRecord } from 'type-fest'
+
+export enum PatchType {
+  Set = 'Set',
+  Apply = 'Apply',
+  Patch = 'Patch',
+}
+
+export type SetPatch<T> = {
+  _PatchType: PatchType.Set
+  value: Expression<T>
+}
+
+export type ApplyPatch<T> = {
+  _PatchType: PatchType.Apply
+  value: Expression<T>
+  reducer: ReducingExpression<T, T>
+}
+
+export type PatchPatch<T> = {
+  _PatchType: PatchType.Patch
+  patch: Patchable<T>
+}
+
+export type Patch<T> = SetPatch<T> | ApplyPatch<T> | PatchPatch<T>
+
+export type PatchValue<T> = {
+  value: T
+  patch: Patch<T>
+}
+
+export type Patchable<T> = {
+  [P in keyof T]?: T[P] extends Array<infer U>
+    ? Patch<U[]> | Patchable<U[]>
+    : T[P] extends object | undefined
+    ? Patch<T[P]> | Patchable<T[P]>
+    : Patch<T[P]> | T[P]
+}
+
+export const set = <T>(value: Expression<T>): Patch<T> => {
+  return {
+    _PatchType: PatchType.Set,
+    value: value as any,
+  }
+}
+
+export const apply = <T>(value: Expression<T>, reducer: ReducingExpression<T, T>): Patch<T> => {
+  return {
+    _PatchType: PatchType.Apply,
+    value,
+    reducer,
+  }
+}
+
+export const patch = <T extends UnknownRecord, N extends Patchable<T> = Patchable<T>>(patch: N): Patch<T> => {
+  return {
+    _PatchType: PatchType.Patch,
+    patch,
+  }
+}
+
+export const sum = (value: Expression<number>): Patch<number> => {
+  return apply(value, Expressions.reference(NumericExpressions.SumExpression))
+}
+
+export const multiply = (value: Expression<number>): Patch<number> => {
+  return apply(value, Expressions.reference(NumericExpressions.MultiplyExpression))
+}
+
+export const concatenate = <T extends Array<Expression<unknown>>>(value: Expression<T>): Patch<T> => {
+  return apply(value, Expressions.reference(ArrayExpressions.ConcatenateExpression)) as Patch<T>
+}
+
+export type ResolvePatchesResult<T> = {
+  value: T
+  patchValues: Array<PatchValue<T>>
+}
+
+export const resolveWithDetails = <T>(value: T, patches: Array<Patch<T>>, evaluate: EvaluateExpression): ResolvePatchesResult<T> => {
+  let currentValue: T = value
+
+  const patchValues = patches.map((patch) => {
+    switch (patch._PatchType) {
+      case PatchType.Set:
+        currentValue = evaluate(patch.value)
+        break
+      case PatchType.Apply:
+        currentValue = evaluate(Expressions.dereference(patch.reducer, [currentValue, patch.value]))
+        break
+      case PatchType.Patch:
+        currentValue = applyPatch(currentValue, patch.patch, evaluate)
+        break
+      default:
+        Preconditions.isUnreachable(() => `Unrecognized PatchType for value: ${JSON.stringify(it)}`)
+    }
+
+    return { value: currentValue, patch }
+  })
+
+  return { value: currentValue, patchValues }
+}
+
+export const resolve = <T>(value: T, patches: Array<Patch<T>>, evaluate: EvaluateExpression): T => {
+  return resolveWithDetails(value, patches, evaluate).value
+}
+
+const applyPatch = <T>(value: T, patch: Patchable<T>, evaluate: EvaluateExpression): T => {
+  return Objects.mergeWith(value, patch, (value, patch) => {
+    if (Objects.isNil(patch)) {
+      return value
+    }
+
+    if (!Objects.isObject(patch) || !('_PatchType' in patch)) {
+      return undefined
+    }
+
+    return evaluate(resolve(value, [patch as Patch<T>], evaluate))
+  })
+}

package/src/precondition.ts

@@ -0,0 +1,25 @@
+import { Lazy, Objects } from '@bessemer/cornerstone'
+import { LazyValue } from '@bessemer/cornerstone/lazy'
+import { Nil } from '@bessemer/cornerstone/types'
+
+export function isUnreachable(message: LazyValue<string> = 'Preconditions.isUnreachable was reached'): never {
+  throw new Error(Lazy.evaluate(message))
+}
+
+export function isTrue(value: boolean, message: LazyValue<string> = 'Preconditions.isTrue failed validation'): asserts value is true {
+  if (!value) {
+    throw new Error(Lazy.evaluate(message))
+  }
+}
+
+export function isFalse(value: boolean, message: LazyValue<string> = 'Preconditions.isFalse failed validation'): asserts value is false {
+  return isTrue(!value, message)
+}
+
+export function isNil(value: any, message: LazyValue<string> = 'Preconditions.isNil failed validation'): asserts value is Nil {
+  return isTrue(Objects.isNil(value), message)
+}
+
+export function isPresent<T>(value: T, message: LazyValue<string> = 'Preconditions.isPresent failed validation'): asserts value is NonNullable<T> {
+  return isTrue(Objects.isPresent(value), message)
+}

package/src/promise.ts

@@ -0,0 +1,16 @@
+export type PromiseContext<T> = { promise: Promise<T>; resolve: (value: T) => void; reject: (reason?: any) => void }
+
+export const isPromise = <T>(element: T | Promise<T>): element is Promise<T> => {
+  return typeof (element as Promise<T>).then === 'function'
+}
+
+export const create = <T>(): PromiseContext<T> => {
+  let resolveVar
+  let rejectVar
+  const promise = new Promise<T>((resolve, reject) => {
+    resolveVar = resolve
+    rejectVar = reject
+  })
+
+  return { promise, resolve: resolveVar!, reject: rejectVar! }
+}