@bessemer/cornerstone 0.5.0

package/src/types.ts

@@ -0,0 +1,21 @@
+export interface NominalTyping<NominalTypingT> {
+  _type?: NominalTypingT
+}
+
+export type NominalType<T, NominalTypingT> = T & NominalTyping<NominalTypingT>
+
+interface TaggedTyping<TaggedTypingT> {
+  _type: TaggedTypingT
+}
+
+export type TaggedType<T, TaggedTypingT> = T & TaggedTyping<TaggedTypingT>
+
+export type Throwable = unknown
+
+export type Dictionary<T> = Record<string, T>
+
+export type Nil = null | undefined
+
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends Array<infer U> ? DeepPartial<U>[] : T[P] extends object | undefined ? DeepPartial<T[P]> : T[P]
+}

package/src/ulid.ts

@@ -0,0 +1,28 @@
+import { ulid } from 'ulid'
+import { TaggedType } from '@bessemer/cornerstone/types'
+import { Preconditions, Strings } from '@bessemer/cornerstone/index'
+
+export type Ulid = TaggedType<string, 'Ulid'>
+
+export const generate = (): Ulid => {
+  return ulid() as Ulid
+}
+
+export const asString = (value: Ulid): string => {
+  return value
+}
+
+export const generateString = (): string => {
+  return asString(generate())
+}
+
+export const of = (value: string): Ulid => {
+  Preconditions.isTrue(isValid(value), () => `Attempted to coerce invalid value to Ulid: ${value}`)
+  return value as Ulid
+}
+
+const pattern = /^[0-9A-HJKMNP-TV-Z]{26}$/
+
+export const isValid = (value: unknown): value is Ulid => {
+  return Strings.isString(value) && pattern.test(value)
+}

package/src/unit.ts

@@ -0,0 +1,4 @@
+import { NominalType } from '@bessemer/cornerstone/types'
+
+export type Unit = NominalType<null, 'Unit'>
+export const Unit: Unit = null as never

package/src/uri.ts

@@ -0,0 +1,321 @@
+import { Objects, Strings } from '@bessemer/cornerstone'
+import { NominalType } from '@bessemer/cornerstone/types'
+import { StringSplitResult } from '@bessemer/cornerstone/string'
+
+export const encode = (uriComponent: UriComponent) => {
+  return encodeURIComponent(uriComponent)
+}
+
+export const decode = (uriComponent: UriComponent) => {
+  return decodeURIComponent(uriComponent)
+}
+
+export type UriString = NominalType<string, 'UriString'>
+export type UriComponent = string
+
+export type UriScheme = string
+
+export type UriAuthentication = {
+  principal: string
+  password: string | null
+}
+
+export type UriHost = {
+  value: string
+  port: number | null
+}
+
+export interface UriLocation {
+  path: string
+  query: string | null
+  fragment: string | null
+}
+
+export interface Uri {
+  scheme: UriScheme | null
+  host: UriHost | null
+  authentication: UriAuthentication | null
+  location: UriLocation
+}
+
+const parseSchemePart = (url: UriComponent): [UriScheme | null, UriComponent] => {
+  // Search for the colon or double slash
+  const schemeMatch = Strings.splitFirst(url, /(\/\/|:)/)
+
+  // If we don't find either, or we hit the double slash before finding a colon, there is no scheme
+  if (Objects.isNil(schemeMatch.selection) || schemeMatch.separator === '//') {
+    return [null, url]
+  }
+
+  // This means the string started with :, so no protocol. We'll go ahead and remove the : from consideration
+  if (Strings.isEmpty(schemeMatch.selection)) {
+    return [null, schemeMatch.rest]
+  } else {
+    return [schemeMatch.selection, schemeMatch.rest]
+  }
+}
+
+const parseAuthenticationPart = (url: UriComponent): [UriAuthentication | null, UriComponent] => {
+  let targetPart = url
+  const queryMatch = Strings.splitFirst(targetPart, '?')
+  const fragmentMatch = Strings.splitFirst(targetPart, '#')
+  if (Objects.isPresent(queryMatch.selection)) {
+    targetPart = queryMatch.selection
+  } else if (Objects.isPresent(fragmentMatch.selection)) {
+    targetPart = fragmentMatch.selection
+  }
+
+  const { selection: authentication } = Strings.splitFirst(targetPart, '@')
+
+  // If there is no @, then we don't have an authentication
+  if (Objects.isNil(authentication)) {
+    return [null, url]
+  }
+
+  const { rest } = Strings.splitFirst(url, '@')
+
+  return [parseAuthentication(Strings.removeStart(authentication, '//')), '//' + rest]
+}
+
+const parseAuthentication = (authentication: UriComponent): UriAuthentication => {
+  const { selection: principal, rest: authenticationRest } = Strings.splitFirst(authentication, ':')
+
+  // If there isn't a colon, then there is no password but there is a username
+  if (Objects.isNil(principal)) {
+    return { principal: authenticationRest, password: null }
+  }
+
+  // The authentication section started with a :, don't know what to make of this... password but no username?
+  if (Strings.isEmpty(principal)) {
+    throw new Error(`Unable to parse Authentication: ${authentication}`)
+  }
+
+  // Otherwise, we have both, so return the complete authentication object and the rest
+  return { principal, password: authenticationRest }
+}
+
+const parseHostPart = (url: UriComponent): [UriHost | null, UriComponent] => {
+  // Check if the host is starting with reserved characters, if so we should just bail on trying to parse
+  if (Strings.startsWith(url, '?') || Strings.startsWith(url, '#')) {
+    return [null, url]
+  }
+
+  let hostRequired = Strings.startsWith(url, '//')
+  if (!hostRequired) {
+    return [null, url]
+  }
+
+  url = Strings.removeStart(url, '//')
+
+  // Lets grab everything to the left of the first / ? or #, this is the remainder of our authority (if any)
+  const urlMatch = Strings.splitFirst(url, /[\/?#]/)
+  let host = urlMatch.rest
+  let rest = ''
+
+  if (Objects.isPresent(urlMatch.selection)) {
+    host = urlMatch.selection
+    rest = urlMatch.separator + urlMatch.rest
+  }
+
+  if (Strings.isEmpty(host)) {
+    return [null, rest]
+  }
+
+  return [parseHost(host), rest]
+}
+
+const parseHost = (host: UriComponent): UriHost => {
+  // Try to see if we have an ipv6 address like the form [2001:db8::7] and handle it
+  if (Strings.startsWith(host, '[')) {
+    const ipMatch = Strings.splitFirst(host, ']')
+
+    if (Objects.isPresent(ipMatch.selection)) {
+      const portMatch = Strings.splitFirst(ipMatch.rest, ':')
+      if (Objects.isPresent(portMatch.selection)) {
+        if (Strings.isEmpty(portMatch.selection)) {
+          return { value: ipMatch.selection + ']', port: Number(portMatch.rest) }
+        }
+      } else {
+        return { value: ipMatch.selection + ']', port: null }
+      }
+    }
+  }
+
+  let hostMatch: StringSplitResult = Strings.splitFirst(host, ':')
+
+  // We have no :, which means no port, so treat the rest as the hostname
+  if (Objects.isNil(hostMatch.selection)) {
+    return { value: hostMatch.rest, port: null }
+  }
+
+  // The host started with a :, this is odd
+  if (Strings.isEmpty(hostMatch.selection)) {
+    throw new Error(`Unable to parse Host: ${host}`)
+  }
+
+  const hostName = hostMatch.selection
+
+  // Otherwise, we have both, so return the complete authentication object and the rest
+  return { value: hostName, port: Number(hostMatch.rest) }
+}
+
+const parseLocation = (url: UriComponent): UriLocation => {
+  const location: UriLocation = { path: '', query: null, fragment: null }
+
+  // Lets see if we have a fragment and parse it off the end
+  const fragmentMatch = Strings.splitFirst(url, '#')
+  if (Objects.isPresent(fragmentMatch.selection) && !Strings.isEmpty(fragmentMatch.rest)) {
+    location.fragment = fragmentMatch.rest
+  }
+
+  // Lets see if we have a query string and parse it off the remainder
+  const queryMatch = Strings.splitFirst(fragmentMatch.selection ?? fragmentMatch.rest, '?')
+  if (Objects.isPresent(queryMatch.selection) && !Strings.isEmpty(queryMatch.rest)) {
+    location.query = queryMatch.rest
+  }
+
+  location.path = queryMatch.selection ?? queryMatch.rest
+  return location
+}
+
+export const parse = (urlString: UriString): Uri => {
+  const [scheme, rest1] = parseSchemePart(urlString)
+  const [authentication, rest2] = parseAuthenticationPart(rest1)
+  const [host, rest3] = parseHostPart(rest2)
+  const location = parseLocation(rest3)
+  const url: Uri = { scheme, host, authentication, location }
+  return url
+}
+
+export const emptyLocation = (): UriLocation => {
+  return {
+    path: '',
+    query: null,
+    fragment: null,
+  }
+}
+
+export type UriBuilder = {
+  scheme?: string
+  host?:
+    | {
+        value: string
+        port?: number
+      }
+    | string
+  authentication?:
+    | {
+        principal: string
+        password?: string
+      }
+    | string
+  location?:
+    | {
+        path: string
+        query?: string
+        fragment?: string
+      }
+    | string
+}
+
+export const build = (builder: UriBuilder): Uri => {
+  const scheme = builder.scheme ?? null
+
+  let host: UriHost | null = null
+  if (Objects.isPresent(builder.host)) {
+    if (Strings.isString(builder.host)) {
+      host = parseHost(builder.host)
+    } else {
+      host = {
+        value: builder.host.value,
+        port: builder.host.port ?? null,
+      }
+    }
+  }
+
+  let authentication: UriAuthentication | null = null
+  if (Objects.isPresent(builder.authentication)) {
+    if (Strings.isString(builder.authentication)) {
+      authentication = parseAuthentication(builder.authentication)
+    } else {
+      authentication = {
+        principal: builder.authentication.principal,
+        password: builder.authentication.password ?? null,
+      }
+    }
+  }
+
+  let location: UriLocation = emptyLocation()
+  if (Objects.isPresent(builder.location)) {
+    if (Strings.isString(builder.location)) {
+      location = parseLocation(builder.location)
+    } else {
+      location = {
+        path: builder.location.path,
+        query: builder.location.query ?? null,
+        fragment: builder.location.fragment ?? null,
+      }
+    }
+  }
+
+  return {
+    scheme,
+    host,
+    authentication,
+    location,
+  }
+}
+
+export const format = (uri: Uri): UriString => {
+  let urlString = ''
+  if (Objects.isPresent(uri.scheme)) {
+    urlString = urlString + uri.scheme
+  }
+
+  if (Objects.isPresent(uri.host)) {
+    if (Objects.isPresent(uri.scheme)) {
+      urlString = urlString + '://'
+    }
+
+    if (Objects.isPresent(uri.authentication)) {
+      urlString = urlString + uri.authentication.principal
+
+      if (Objects.isPresent(uri.authentication.password)) {
+        urlString = urlString + ':' + uri.authentication.password
+      }
+
+      urlString = urlString + '@'
+    }
+
+    urlString = urlString + uri.host.value
+
+    if (Objects.isPresent(uri.host.port)) {
+      urlString = urlString + ':' + uri.host.port
+    }
+  }
+
+  urlString = urlString + formatLocation(uri.location)
+  return urlString
+}
+
+const formatLocation = (location: UriLocation): string => {
+  let urlString = ''
+
+  if (!Strings.isEmpty(location.path)) {
+    urlString = urlString + location.path
+  }
+
+  if (!Strings.isEmpty(location.query)) {
+    urlString = urlString + '?' + location.query
+  }
+
+  if (!Strings.isEmpty(location.fragment)) {
+    urlString = urlString + '#' + encode(location.fragment!)
+  }
+
+  return urlString
+}
+
+export const buildString = (builder: UriBuilder): UriString => {
+  return format(build(builder))
+}

package/src/url.ts

@@ -0,0 +1,155 @@
+import { Arrays, Objects, Strings, Uris } from '@bessemer/cornerstone'
+import { Dictionary } from '@bessemer/cornerstone/types'
+import { Uri, UriBuilder, UriComponent, UriLocation, UriString } from '@bessemer/cornerstone/uri'
+
+export const encode = Uris.encode
+
+export const decode = Uris.decode
+
+export interface UrlLocation extends UriLocation {
+  pathSegments: Array<string>
+  parameters: Dictionary<string | Array<string>>
+}
+
+export interface Url extends Uri {
+  location: UrlLocation
+}
+
+export type UrlLike = Url | UriString
+
+const augmentUriLocation = (uriLocation: UriLocation, normalize: boolean): UrlLocation => {
+  const pathSegments: Array<string> = []
+  const parameters: Dictionary<string | Array<string>> = {}
+
+  if (!Strings.isBlank(uriLocation.path)) {
+    Strings.removeStart(uriLocation.path, '/')
+      .split('/')
+      .forEach((urlPathPart) => {
+        if (!Strings.isBlank(urlPathPart) || !normalize) {
+          pathSegments.push(decode(urlPathPart))
+        }
+      })
+  }
+
+  if (Objects.isPresent(uriLocation.query)) {
+    uriLocation.query.split('&').forEach((parameterPair) => {
+      let splitParameters = parameterPair.split('=')
+
+      if (!Strings.isBlank(Arrays.first(splitParameters))) {
+        let key = decode(splitParameters[0]!)
+        let value = ''
+        if (splitParameters.length === 2) {
+          value = splitParameters[1]!
+        }
+        if (Objects.isNil(parameters[key])) {
+          parameters[key] = decode(value)
+        } else if (!Array.isArray(parameters[key])) {
+          let paramList = [parameters[key]]
+          paramList.push(decode(value))
+          parameters[key] = paramList
+        } else {
+          parameters[key].push(decode(value))
+        }
+      }
+    })
+  }
+
+  return {
+    ...uriLocation,
+    pathSegments,
+    parameters,
+  }
+}
+
+export const parse = (urlString: UriString, normalize: boolean = true): Url => {
+  const uri = Uris.parse(urlString)
+  const location = augmentUriLocation(uri.location, normalize)
+
+  if (normalize) {
+    if (!Arrays.isEmpty(location.pathSegments)) {
+      location.path = (Strings.startsWith(location.path, '/') ? '/' : '') + formatPathSegments(location.pathSegments)
+    } else {
+      location.path = ''
+    }
+
+    location.query = formatQueryParameters(location.parameters)
+  }
+
+  return {
+    ...uri,
+    location,
+  }
+}
+
+export const format = Uris.format
+
+const formatPathSegments = (pathSegments: Array<string>): UriComponent => {
+  return pathSegments.map((it) => encode(it)).join('/')
+}
+
+const formatQueryParameters = (parameters: Dictionary<string | Array<string>>): UriComponent | null => {
+  const parameterEntries = Object.entries(parameters)
+  if (Arrays.isEmpty(parameterEntries)) {
+    return null
+  }
+
+  return Object.entries(parameters)
+    .flatMap(([key, value]) => {
+      if (Array.isArray(value)) {
+        return value.map((it) => `${encode(key)}=${encode(it)}`)
+      } else {
+        return [`${encode(key)}=${encode(value)}`]
+      }
+    })
+    .join('&')
+}
+
+export type UrlBuilder = UriBuilder & {
+  location?: {
+    parameters?: Dictionary<string | Array<string>>
+  }
+}
+
+export const build = (builder: UrlBuilder): Url => {
+  const uri = Uris.build(builder)
+  if (Objects.isPresent(builder.location?.parameters)) {
+    uri.location.query = formatQueryParameters(builder.location.parameters)
+  }
+
+  const urlLocation = augmentUriLocation(uri.location, false)
+
+  return {
+    ...uri,
+    location: urlLocation,
+  }
+}
+
+export const buildString = (builder: UrlBuilder): UriString => {
+  return format(build(builder))
+}
+
+export const reify = (blah: UrlLike): Url => {
+  if (!Strings.isString(blah)) {
+    return blah
+  }
+
+  return parse(blah)
+}
+
+export const getParameter = (url: UrlLike, name: string): string | undefined => {
+  const parameter = reify(url).location.parameters[name]
+  if (Objects.isNil(parameter)) {
+    return undefined
+  }
+
+  if (Array.isArray(parameter)) {
+    throw new Error(`Expected a single parameter value but found multiple for parameter: ${name}`)
+  }
+
+  return parameter
+}
+
+export const getJsonParameter = <T>(url: UrlLike, name: string): T | undefined => {
+  const value = getParameter(url, name)
+  return Objects.isPresent(value) ? JSON.parse(value) : undefined
+}

package/src/uuid.ts

@@ -0,0 +1,37 @@
+import { Objects, Preconditions, Strings } from '@bessemer/cornerstone'
+import { TaggedType } from '@bessemer/cornerstone/types'
+
+export type Uuid = TaggedType<string, 'Uuid'>
+
+export const generate = (): Uuid => {
+  if (Objects.isNil(crypto.randomUUID)) {
+    return `${randomHex(8)}-${randomHex(4)}-${randomHex(4)}-${randomHex(4)}-${randomHex(12)}` as Uuid
+  } else {
+    return crypto.randomUUID() as Uuid
+  }
+}
+
+export const asString = (value: Uuid): string => {
+  return value
+}
+
+export const generateString = (): string => {
+  return asString(generate())
+}
+
+const randomHex = (characters: number) => {
+  // Generates a random number between 0x0..0 and 0xF..F for the target number of characters
+  const randomNum = Math.floor(Math.random() * (16 ** characters - 1))
+  return Strings.padStart(randomNum.toString(16), characters, '0')
+}
+
+export const of = (value: string): Uuid => {
+  Preconditions.isTrue(isValid(value), () => `Attempted to coerce invalid value to Uuid: ${value}`)
+  return value as Uuid
+}
+
+const pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+
+export const isValid = (value: unknown): value is Uuid => {
+  return Strings.isString(value) && pattern.test(value)
+}

package/src/zod.ts

@@ -0,0 +1,24 @@
+import z, { ZodType } from 'zod'
+import { ResourceKey } from '@bessemer/cornerstone/resource'
+import { Entry } from '@bessemer/cornerstone/entry'
+
+export type infer<T extends ZodType<any, any, any>> = z.infer<T>
+export const object = z.object
+export const string = z.string
+export const union = z.union
+export const array = z.array
+export const unknown = z.unknown
+export const nullType = z.null
+export const undefined = z.undefined
+
+export const arrayable = <T>(type: ZodType<T>) => {
+  return z.union([type, z.array(type)])
+}
+
+export const key = (): ZodType<ResourceKey> => {
+  return z.string()
+}
+
+export const entry = <Value, Key = string>(value: ZodType<Value>, key?: ZodType<Key>): ZodType<Entry<Value, Key>> => {
+  return z.tuple([key ?? z.string(), value]) as ZodType<Entry<Value, Key>>
+}

package/test/comparator.test.ts

@@ -0,0 +1 @@
+test('TODO', () => {})

package/test/expression.test.ts

@@ -0,0 +1,12 @@
+import { Expressions, NumericExpressions, StringExpressions } from '@bessemer/cornerstone/expression'
+
+test('TODO', () => {
+  NumericExpressions.sum([Expressions.variable('VitalityPoints'), 10])
+
+  Expressions.equals([NumericExpressions.sum([Expressions.variable('VitalityPoints'), 10]), 5])
+
+  Expressions.and([
+    NumericExpressions.lessThan(NumericExpressions.sum([Expressions.variable('VitalityPoints'), 10]), 15),
+    StringExpressions.substring('one', 'two'),
+  ])
+})