@bessemer/cornerstone 0.5.0

package/src/content.ts

@@ -0,0 +1,138 @@
+import { Referencable, Reference, ReferenceType } from '@bessemer/cornerstone/reference'
+import { NominalType } from '@bessemer/cornerstone/types'
+import { AbstractApplicationContext } from '@bessemer/cornerstone/context'
+import { Arrays, Objects, References, Tags, Ulids, Zod } from '@bessemer/cornerstone'
+import { RichTextJson } from '@bessemer/cornerstone/rich-text'
+import { Tag } from '@bessemer/cornerstone/tag'
+import { ZodType } from 'zod'
+
+export type ContentSector = NominalType<string, 'ContentSector'>
+export const ContentSectorSchema: ZodType<ContentSector> = Zod.string()
+
+export type ContentKey = NominalType<string, 'ContentKey'>
+export const ContentKeySchema: ZodType<ContentKey> = Zod.string()
+
+export type ContentType<Data = unknown> = NominalType<string, ['ContentType', Data]>
+export const ContentTypeSchema: ZodType<ContentType> = Zod.string()
+
+export type ContentReference = Reference<'Content'>
+
+type ContentDataType<Type> = Type extends ContentType<infer Data> ? Data : never
+
+export const ContentDataSchema = Zod.object({
+  key: ContentKeySchema,
+  type: ContentTypeSchema,
+  data: Zod.unknown(),
+  sector: ContentSectorSchema.nullable(),
+})
+
+export type ContentData<Type extends ContentType = ContentType, Data = ContentDataType<Type>> = Referencable<ContentReference> & {
+  key: ContentKey
+  type: Type
+  data: Data
+  sector: ContentSector | null
+}
+
+export type ContentTypeConstructor<Content extends ContentData> = Content['type']
+
+export type ContentDisplayType = NominalType<string, 'ContentDisplayType'>
+
+export namespace ContentDisplayTypes {
+  export const Default: ContentDisplayType = 'Default'
+  export const Label: ContentDisplayType = 'Label'
+  export const Desktop: ContentDisplayType = 'Desktop'
+  export const Mobile: ContentDisplayType = 'Mobile'
+  export const Modal: ContentDisplayType = 'Modal'
+  export const Tooltip: ContentDisplayType = 'Tooltip'
+}
+
+export const TextContentType: ContentType<RichTextJson> = 'Text'
+export type TextContent = ContentData<typeof TextContentType>
+
+export interface ContentProvider<ContextType extends AbstractApplicationContext = AbstractApplicationContext> {
+  fetchContentByIds: (references: Array<ReferenceType<ContentReference>>, context: ContextType) => Promise<Array<ContentData>>
+
+  fetchContentByKeys: (keys: Array<ContentKey>, tags: Array<Tag>, context: ContextType) => Promise<Array<ContentData>>
+
+  fetchContentBySectors: (sectors: Array<ContentSector>, tags: Array<Tag>, context: ContextType) => Promise<Array<ContentData>>
+}
+
+export type ContentNormalizer<
+  ApplicationContext extends AbstractApplicationContext = AbstractApplicationContext,
+  Type extends ContentData = ContentData
+> = {
+  type: Type['type']
+  normalize: (data: Array<ContentData>, context: ApplicationContext) => Promise<Array<Type>>
+}
+
+// TODO might be more efficient to put the normalizers in a map at some point
+export const normalizeContent = async <ApplicationContext extends AbstractApplicationContext>(
+  content: Array<ContentData>,
+  normalizers: Array<ContentNormalizer<ApplicationContext>>,
+  context: ApplicationContext
+): Promise<Array<ContentData>> => {
+  const groupedContent = Arrays.groupBy(content, (it) => it.type)
+  const normalizedGroupedContent = Object.entries(groupedContent).map(async ([type, values]) => {
+    const normalizer = normalizers.find((it) => it.type === type)
+    if (Objects.isNil(normalizer)) {
+      return values
+    }
+
+    return await normalizer.normalize(values, context)
+  })
+
+  const normalizedContent = (await Promise.all(normalizedGroupedContent)).flatMap((it) => it)
+  return normalizedContent
+}
+
+export type StaticContentData<Type extends ContentType = ContentType, Data = ContentDataType<Type>> = ContentData<Type, Data> & {
+  tags: Array<Tag>
+}
+
+export const staticData = <Type extends ContentType = ContentType, Data = ContentDataType<Type>>(
+  key: ContentKey,
+  type: Type,
+  data: Data,
+  options?: { tags?: Array<Tag>; sector?: ContentSector }
+): StaticContentData<Type, Data> => {
+  return {
+    reference: References.reference(Ulids.generateString(), 'Content'),
+    key,
+    type,
+    data,
+    tags: options?.tags ?? [],
+    sector: options?.sector ?? null,
+  }
+}
+
+export const staticProvider = <ApplicationContext extends AbstractApplicationContext>(
+  content: Array<StaticContentData>,
+  normalizers?: Array<ContentNormalizer<ApplicationContext>>
+): ContentProvider<ApplicationContext> => {
+  return {
+    async fetchContentByIds(references: Array<ReferenceType<ContentReference>>, context: ApplicationContext): Promise<Array<ContentData>> {
+      const matchingContent = content.filter((it) => Arrays.contains(references, it.reference))
+      return normalizeContent(matchingContent, normalizers ?? [], context)
+    },
+    async fetchContentByKeys(keys: Array<ContentKey>, tags: Array<Tag>, context: ApplicationContext): Promise<Array<ContentData>> {
+      const matchingContent = content.filter((it) => Arrays.contains(keys, it.key))
+
+      const resolvedContent = Object.values(Arrays.groupBy(matchingContent, (it) => it.key)).map((it) => {
+        const resolvedContent = Tags.resolveBy(it, (it) => it.tags ?? [], tags)
+        return Arrays.first(resolvedContent)!
+      })
+
+      return normalizeContent(resolvedContent, normalizers ?? [], context)
+    },
+    async fetchContentBySectors(sectors: Array<ContentSector>, tags: Array<Tag>, context: ApplicationContext): Promise<Array<ContentData>> {
+      const matchingContent = content.filter((it) => Objects.isPresent(it.sector)).filter((it) => Arrays.contains(sectors, it.sector!))
+
+      const resolvedContent = Object.values(Arrays.groupBy(matchingContent, (it) => it.key)).map((it) => {
+        const resolvedContent = Tags.resolveBy(it, (it) => it.tags ?? [], tags)
+        return Arrays.first(resolvedContent)!
+      })
+
+      return normalizeContent(resolvedContent, normalizers ?? [], context)
+    },
+  }
+}

package/src/context.ts

@@ -0,0 +1,6 @@
+export type AbstractApplicationContext = {
+  global: {}
+  client: {
+    runtime: {}
+  }
+}

package/src/crypto.ts

@@ -0,0 +1,11 @@
+export const getRandomBytes = (length: number): Uint8Array => {
+  return crypto.getRandomValues(new Uint8Array(length))
+}
+
+export const getRandomHex = (length: number): string => {
+  const bytes = getRandomBytes(length)
+  // JOHN should Uint8Array to Hex String be a utility?
+  const hashArray = Array.from(bytes)
+  const hexString = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+  return hexString
+}

package/src/date.ts

@@ -0,0 +1,18 @@
+import { addHours as _addHours, addMilliseconds as _addMilliseconds, isAfter as _isAfter, isBefore as _isBefore, parseISO } from 'date-fns'
+import { Duration } from '@bessemer/cornerstone/duration'
+import { Durations } from '@bessemer/cornerstone/index'
+
+export const now = (): Date => {
+  return new Date()
+}
+
+export const of = (dateString: string): Date => {
+  return parseISO(dateString)
+}
+
+export const addMilliseconds = _addMilliseconds
+export const addHours = _addHours
+export const isBefore = _isBefore
+export const isAfter = _isAfter
+
+export const addDuration = (date: Date, duration: Duration): Date => addMilliseconds(date, Durations.inMilliseconds(duration))

package/src/duration.ts

@@ -0,0 +1,57 @@
+import { NominalType } from '@bessemer/cornerstone/types'
+
+export type Millisecond = NominalType<number, 'Millisecond'>
+export type Second = NominalType<number, 'Second'>
+export type Minute = NominalType<number, 'Minute'>
+export type Hour = NominalType<number, 'Hour'>
+export type Day = NominalType<number, 'Day'>
+
+export type Duration = {
+  value: Millisecond
+}
+
+export const ofMilliseconds = (value: Millisecond) => {
+  return {
+    value,
+  }
+}
+
+export const inMilliseconds = (duration: Duration) => {
+  return duration.value
+}
+
+export const ofSeconds = (value: Second) => {
+  return ofMilliseconds(value * 1000)
+}
+
+export const inSeconds = (duration: Duration) => {
+  return inMilliseconds(duration) / 1000
+}
+
+export const ofMinutes = (value: Minute) => {
+  return ofSeconds(value * 60)
+}
+
+export const inMinutes = (duration: Duration) => {
+  return inSeconds(duration) / 60
+}
+
+export const ofHours = (value: Hour) => {
+  return ofMinutes(value * 60)
+}
+
+export const inHours = (duration: Duration) => {
+  return inMinutes(duration) / 60
+}
+
+export const ofDays = (value: Day) => {
+  return ofHours(value * 24)
+}
+
+export const inDays = (duration: Duration) => {
+  return inHours(duration) / 24
+}
+
+export const Zero = ofMilliseconds(0)
+export const OneDay = ofDays(1)
+export const OneHour = ofHours(1)

package/src/either.ts

@@ -0,0 +1,29 @@
+import { Eithers } from '@bessemer/cornerstone/index'
+
+export enum EitherType {
+  Left = 'Left',
+  Right = 'Right',
+}
+
+export type Left<T> = {
+  type: EitherType.Left
+  value: T
+}
+export type Right<N> = {
+  type: EitherType.Right
+  value: N
+}
+
+export type Either<T, N> = Left<T> | Right<N>
+
+export const left = <T>(value: T): Left<T> => ({ type: EitherType.Left, value })
+export const right = <N>(value: N): Right<N> => ({ type: EitherType.Right, value })
+
+export const isLeft = <T, N>(either: Either<T, N>): either is Left<T> => either.type === EitherType.Left
+export const isRight = <T, N>(either: Either<T, N>): either is Right<N> => either.type === EitherType.Right
+
+export const split = <L, R>(array: Array<Either<L, R>>): [Array<L>, Array<R>] => {
+  const lefts = array.filter(Eithers.isLeft).map((it) => it.value)
+  const rights = array.filter(Eithers.isRight).map((it) => it.value)
+  return [lefts, rights]
+}

package/src/entry.ts

@@ -0,0 +1,21 @@
+export type Entry<Value, Key = string> = [Key, Value]
+
+export const of = <Value, Key = string>(key: Key, value: Value): Entry<Value, Key> => {
+  return [key, value]
+}
+
+export const keys = <Key>(entries: Array<Entry<unknown, Key>>): Array<Key> => {
+  return entries.map((it) => it[0])
+}
+
+export const values = <T>(entries: Array<Entry<T>>): Array<T> => {
+  return entries.map((it) => it[1])
+}
+
+export const mapKeys = <Value, Key, NewKey>(entries: Array<Entry<Value, Key>>, mapper: (key: Key) => NewKey): Array<Entry<Value, NewKey>> => {
+  return entries.map(([key, value]) => of(mapper(key), value))
+}
+
+export const mapValues = <Value, Key, NewValue>(entries: Array<Entry<Value, Key>>, mapper: (key: Value) => NewValue): Array<Entry<NewValue, Key>> => {
+  return entries.map(([key, value]) => of(key, mapper(value)))
+}

package/src/equalitor.ts

@@ -0,0 +1,12 @@
+import { Comparator } from '@bessemer/cornerstone/comparator'
+
+export type Equalitor<T> = (first: T, second: T) => boolean
+
+export const fromComparator = <T>(comparator: Comparator<T>): Equalitor<T> => {
+  return (first, second) => comparator(first, second) === 0
+}
+
+export const reference =
+  <T>(): Equalitor<T> =>
+  (first, second) =>
+    first === second

package/src/error-event.ts

@@ -0,0 +1,126 @@
+import { Arrays, Errors, Objects } from '@bessemer/cornerstone'
+import { NominalType, Throwable } from '@bessemer/cornerstone/types'
+import { RecordAttribute } from '@bessemer/cornerstone/object'
+
+/*
+  Represents a structured error event. The code can be mapped to a unique type of error while the
+  message and attributes can provide contextual information about the error. Finally,
+  an ErrorEvent could have multiple causes which get aggregated into a single parent error.
+ */
+export type ErrorCode = NominalType<string, 'ErrorCode'>
+export type ErrorAttribute<Type = unknown> = RecordAttribute<Type, 'ErrorAttribute'>
+
+export type ErrorEvent = {
+  code: ErrorCode
+  message: string
+  attributes: Record<ErrorAttribute, unknown>
+  causes: Array<ErrorEvent>
+}
+
+// Builder object that allows for 'partial' representation of ErrorEvents
+export type ErrorEventBuilder = {
+  code: ErrorCode
+  message?: string | null
+  attributes?: Record<ErrorAttribute, unknown>
+  causes?: Array<ErrorEvent>
+}
+
+// An exception type that contains an ErrorEvent
+export class ErrorEventException extends Error {
+  readonly errorEvent: ErrorEvent
+
+  constructor(errorEvent: ErrorEvent, cause?: unknown) {
+    super(errorEvent.message ?? '', { cause })
+    this.name = this.constructor.name
+    this.errorEvent = errorEvent
+  }
+}
+
+export const isErrorEvent = (throwable: Throwable): throwable is ErrorEvent => {
+  if (!Objects.isObject(throwable)) {
+    return false
+  }
+
+  return 'code' in throwable && 'message' in throwable && 'attributes' in throwable && 'causes' in throwable
+}
+
+export const isErrorEventException = (throwable: Throwable): throwable is ErrorEventException => {
+  return throwable instanceof ErrorEventException
+}
+
+export const of = (builder: ErrorEventBuilder): ErrorEvent => {
+  const code = builder.code
+
+  return {
+    code,
+    message: builder.message ?? code,
+    attributes: builder.attributes ?? {},
+    causes: builder.causes ?? [],
+  }
+}
+
+export const from = (throwable: Throwable): ErrorEvent => {
+  if (isErrorEvent(throwable)) {
+    return throwable
+  }
+
+  if (!Errors.isError(throwable)) {
+    return unhandled()
+  }
+
+  const errorEventException = Errors.findInCausalChain(throwable, isErrorEventException) as ErrorEventException | undefined
+  if (Objects.isNil(errorEventException)) {
+    return unhandled()
+  }
+
+  return errorEventException.errorEvent
+}
+
+export const findByCodeInCausalChain = (error: ErrorEvent, code: string): ErrorEvent | undefined => {
+  return findInCausalChain(error, (it) => it.code === code)
+}
+
+/*
+   Traverses the causal chain of the ErrorEvent, searching for a predicate that matches (including matching on the parent error event)
+   This is useful if you want to find whether or not a given error was caused by a specific failure. The search executes depth-first and
+   will return te first matching instance that satisfies the predicate, or undefined otherwise
+ */
+export const findInCausalChain = (error: ErrorEvent, predicate: (error: ErrorEvent) => boolean): ErrorEvent | undefined => {
+  if (predicate(error)) {
+    return error
+  }
+
+  return Arrays.first(error.causes.map((it) => findInCausalChain(it, predicate)).filter(Objects.isPresent))
+}
+
+export const aggregate = (builder: ErrorEventBuilder, causes: Array<ErrorEvent>): ErrorEvent | undefined => {
+  if (causes.length === 0) {
+    return undefined
+  }
+
+  return of({ ...builder, causes })
+}
+
+export const UnhandledErrorCode: ErrorCode = 'error-event.unhandled'
+export const NotFoundErrorCode: ErrorCode = 'error-event.not-found'
+
+export const RequestCorrelationIdAttribute: ErrorAttribute<string> = 'requestCorrelationId'
+export const HttpStatusCodeAttribute: ErrorAttribute<number> = 'httpStatusCode'
+
+export const unhandled = (builder?: ErrorEventBuilder) =>
+  of(
+    Objects.merge(builder, {
+      code: UnhandledErrorCode,
+      message: 'An Unhandled Error has occurred.',
+      attributes: { [HttpStatusCodeAttribute]: 500 },
+    })
+  )
+
+export const notFound = (builder?: ErrorEventBuilder) =>
+  of(
+    Objects.merge(builder, {
+      code: NotFoundErrorCode,
+      message: 'The requested Resource could not be found.',
+      attributes: { [HttpStatusCodeAttribute]: 404 },
+    })
+  )

package/src/error.ts

@@ -0,0 +1,16 @@
+import { Objects } from '@bessemer/cornerstone'
+import { isError as _isError } from 'lodash-es'
+
+export const isError = _isError
+
+export const findInCausalChain = (error: Error, predicate: (error: Error) => boolean): Error | undefined => {
+  if (predicate(error)) {
+    return error
+  }
+
+  if (Objects.isPresent(error.cause) && error.cause instanceof Error) {
+    return findInCausalChain(error.cause, predicate)
+  }
+
+  return undefined
+}

package/src/expression/array-expression.ts

@@ -0,0 +1,29 @@
+import { defineExpression } from '@bessemer/cornerstone/expression/internal'
+import { Expression } from '@bessemer/cornerstone/expression'
+import { Arrays } from '@bessemer/cornerstone'
+
+export const ConcatenateExpression = defineExpression({
+  expressionKey: 'Array.Concatenate',
+  builder: (operands: Array<Expression<Array<Expression<unknown>>>>) => {
+    return { operands }
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = evaluate(operands).map((it) => evaluate(it))
+    return Arrays.concatenate(values[0], ...Arrays.rest(values))
+  },
+})
+
+export const concatenate = ConcatenateExpression.builder
+
+export const FirstExpression = defineExpression({
+  expressionKey: 'Array.First',
+  builder: (operands: Array<Expression<Array<Expression<unknown>>>>) => {
+    return { operands }
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = evaluate(operands).map((it) => evaluate(it))
+    return Arrays.first(values)
+  },
+})
+
+export const first = FirstExpression.builder

package/src/expression/expression-evaluator.ts

@@ -0,0 +1,34 @@
+import { Expression, ExpressionContext, ExpressionDefinition, ExpressionReference, IExpression } from '@bessemer/cornerstone/expression'
+import { Objects, Preconditions } from '@bessemer/cornerstone'
+
+export class ExpressionEvaluator {
+  constructor(private readonly expressionDefinitions: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>>) {}
+
+  evaluate<T>(expression: Expression<T>, context: ExpressionContext): T {
+    if (isValue(expression)) {
+      return expression
+    }
+
+    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === expression.expressionKey)
+    Preconditions.isPresent(matchingExpressionDefinition)
+    return matchingExpressionDefinition.resolver(expression, (expression) => this.evaluate(expression, context), context) as T
+  }
+
+  dereference<ReturnType, ArgumentType extends Array<unknown>>(
+    reference: ExpressionReference<ReturnType, ArgumentType>,
+    ...args: ArgumentType
+  ): Expression<ReturnType> {
+    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === reference.expressionKey)
+    Preconditions.isPresent(matchingExpressionDefinition, () => `Unable to find Expression Definition for type: ${reference.expressionKey}`)
+    return matchingExpressionDefinition.builder(...args)
+  }
+}
+
+const isValue = <T>(expression: Expression<T>): expression is T => {
+  if (!Objects.isObject(expression)) {
+    return true
+  }
+
+  const result = (expression as IExpression<T>).expressionKey === undefined
+  return result
+}