@bessemer/cornerstone 0.5.1 → 0.5.3

package/dist/uuid.js

@@ -0,0 +1,35 @@
+// src/uuid.ts
+import { Objects, Preconditions, Strings } from "@bessemer/cornerstone";
+var generate = () => {
+  if (Objects.isNil(crypto.randomUUID)) {
+    return `${randomHex(8)}-${randomHex(4)}-${randomHex(4)}-${randomHex(4)}-${randomHex(12)}`;
+  } else {
+    return crypto.randomUUID();
+  }
+};
+var asString = (value) => {
+  return value;
+};
+var generateString = () => {
+  return asString(generate());
+};
+var randomHex = (characters) => {
+  const randomNum = Math.floor(Math.random() * (16 ** characters - 1));
+  return Strings.padStart(randomNum.toString(16), characters, "0");
+};
+var of = (value) => {
+  Preconditions.isTrue(isValid(value), () => `Attempted to coerce invalid value to Uuid: ${value}`);
+  return value;
+};
+var 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;
+var isValid = (value) => {
+  return Strings.isString(value) && pattern.test(value);
+};
+export {
+  asString,
+  generate,
+  generateString,
+  isValid,
+  of
+};
+//# sourceMappingURL=uuid.js.map

package/dist/uuid.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/uuid.ts"],"sourcesContent":["import { Objects, Preconditions, Strings } from '@bessemer/cornerstone'\nimport { TaggedType } from '@bessemer/cornerstone/types'\n\nexport type Uuid = TaggedType<string, 'Uuid'>\n\nexport const generate = (): Uuid => {\n  if (Objects.isNil(crypto.randomUUID)) {\n    return `${randomHex(8)}-${randomHex(4)}-${randomHex(4)}-${randomHex(4)}-${randomHex(12)}` as Uuid\n  } else {\n    return crypto.randomUUID() as Uuid\n  }\n}\n\nexport const asString = (value: Uuid): string => {\n  return value\n}\n\nexport const generateString = (): string => {\n  return asString(generate())\n}\n\nconst randomHex = (characters: number) => {\n  // Generates a random number between 0x0..0 and 0xF..F for the target number of characters\n  const randomNum = Math.floor(Math.random() * (16 ** characters - 1))\n  return Strings.padStart(randomNum.toString(16), characters, '0')\n}\n\nexport const of = (value: string): Uuid => {\n  Preconditions.isTrue(isValid(value), () => `Attempted to coerce invalid value to Uuid: ${value}`)\n  return value as Uuid\n}\n\nconst 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\n\nexport const isValid = (value: unknown): value is Uuid => {\n  return Strings.isString(value) && pattern.test(value)\n}\n"],"mappings":";AAAA,SAAS,SAAS,eAAe,eAAe;AAKzC,IAAM,WAAW,MAAY;AAClC,MAAI,QAAQ,MAAM,OAAO,UAAU,GAAG;AACpC,WAAO,GAAG,UAAU,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,UAAU,EAAE,CAAC;AAAA,EACzF,OAAO;AACL,WAAO,OAAO,WAAW;AAAA,EAC3B;AACF;AAEO,IAAM,WAAW,CAAC,UAAwB;AAC/C,SAAO;AACT;AAEO,IAAM,iBAAiB,MAAc;AAC1C,SAAO,SAAS,SAAS,CAAC;AAC5B;AAEA,IAAM,YAAY,CAAC,eAAuB;AAExC,QAAM,YAAY,KAAK,MAAM,KAAK,OAAO,KAAK,MAAM,aAAa,EAAE;AACnE,SAAO,QAAQ,SAAS,UAAU,SAAS,EAAE,GAAG,YAAY,GAAG;AACjE;AAEO,IAAM,KAAK,CAAC,UAAwB;AACzC,gBAAc,OAAO,QAAQ,KAAK,GAAG,MAAM,8CAA8C,KAAK,EAAE;AAChG,SAAO;AACT;AAEA,IAAM,UAAU;AAET,IAAM,UAAU,CAAC,UAAkC;AACxD,SAAO,QAAQ,SAAS,KAAK,KAAK,QAAQ,KAAK,KAAK;AACtD;","names":[]}

package/dist/zod.d.ts

@@ -0,0 +1,17 @@
+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 declare const object: <T extends z.ZodRawShape>(shape: T, params?: z.RawCreateParams) => z.ZodObject<T, "strip", z.ZodTypeAny, z.objectOutputType<T, z.ZodTypeAny, "strip">, z.objectInputType<T, z.ZodTypeAny, "strip">>;
+export declare const string: (params?: z.RawCreateParams & {
+    coerce?: true;
+}) => z.ZodString;
+export declare const union: <T extends readonly [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>(types: T, params?: z.RawCreateParams) => z.ZodUnion<T>;
+export declare const array: <T extends z.ZodTypeAny>(schema: T, params?: z.RawCreateParams) => z.ZodArray<T>;
+export declare const unknown: (params?: z.RawCreateParams) => z.ZodUnknown;
+export declare const nullType: (params?: z.RawCreateParams) => z.ZodNull;
+export declare const undefined: (params?: z.RawCreateParams) => z.ZodUndefined;
+export declare const arrayable: <T>(type: ZodType<T>) => z.ZodUnion<[z.ZodType<T, z.ZodTypeDef, T>, z.ZodArray<z.ZodType<T, z.ZodTypeDef, T>, "many">]>;
+export declare const key: () => ZodType<ResourceKey>;
+export declare const entry: <Value, Key = string>(value: ZodType<Value>, key?: ZodType<Key>) => ZodType<Entry<Value, Key>>;
+//# sourceMappingURL=zod.d.ts.map

package/dist/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../src/zod.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAC5D,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAA;AAEnD,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AAChE,eAAO,MAAM,MAAM,qMAAW,CAAA;AAC9B,eAAO,MAAM,MAAM;UAkBk16C,CAAC;iBAlBx06C,CAAA;AAC9B,eAAO,MAAM,KAAK,6HAAU,CAAA;AAC5B,eAAO,MAAM,KAAK,kFAAU,CAAA;AAC5B,eAAO,MAAM,OAAO,8CAAY,CAAA;AAChC,eAAO,MAAM,QAAQ,2CAAS,CAAA;AAC9B,eAAO,MAAM,SAAS,gDAAc,CAAA;AAEpC,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,mGAE5C,CAAA;AAED,eAAO,MAAM,GAAG,QAAO,OAAO,CAAC,WAAW,CAEzC,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,KAAK,EAAE,GAAG,GAAG,MAAM,EAAE,OAAO,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,KAAG,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAE/G,CAAA"}

package/dist/zod.js

@@ -0,0 +1,31 @@
+// src/zod.ts
+import z from "zod";
+var object = z.object;
+var string = z.string;
+var union = z.union;
+var array = z.array;
+var unknown = z.unknown;
+var nullType = z.null;
+var undefined = z.undefined;
+var arrayable = (type) => {
+  return z.union([type, z.array(type)]);
+};
+var key = () => {
+  return z.string();
+};
+var entry = (value, key2) => {
+  return z.tuple([key2 ?? z.string(), value]);
+};
+export {
+  array,
+  arrayable,
+  entry,
+  key,
+  nullType,
+  object,
+  string,
+  undefined,
+  union,
+  unknown
+};
+//# sourceMappingURL=zod.js.map

package/dist/zod.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/zod.ts"],"sourcesContent":["import z, { ZodType } from 'zod'\nimport { ResourceKey } from '@bessemer/cornerstone/resource'\nimport { Entry } from '@bessemer/cornerstone/entry'\n\nexport type infer<T extends ZodType<any, any, any>> = z.infer<T>\nexport const object = z.object\nexport const string = z.string\nexport const union = z.union\nexport const array = z.array\nexport const unknown = z.unknown\nexport const nullType = z.null\nexport const undefined = z.undefined\n\nexport const arrayable = <T>(type: ZodType<T>) => {\n  return z.union([type, z.array(type)])\n}\n\nexport const key = (): ZodType<ResourceKey> => {\n  return z.string()\n}\n\nexport const entry = <Value, Key = string>(value: ZodType<Value>, key?: ZodType<Key>): ZodType<Entry<Value, Key>> => {\n  return z.tuple([key ?? z.string(), value]) as ZodType<Entry<Value, Key>>\n}\n"],"mappings":";AAAA,OAAO,OAAoB;AAKpB,IAAM,SAAS,EAAE;AACjB,IAAM,SAAS,EAAE;AACjB,IAAM,QAAQ,EAAE;AAChB,IAAM,QAAQ,EAAE;AAChB,IAAM,UAAU,EAAE;AAClB,IAAM,WAAW,EAAE;AACnB,IAAM,YAAY,EAAE;AAEpB,IAAM,YAAY,CAAI,SAAqB;AAChD,SAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC;AACtC;AAEO,IAAM,MAAM,MAA4B;AAC7C,SAAO,EAAE,OAAO;AAClB;AAEO,IAAM,QAAQ,CAAsB,OAAuBA,SAAmD;AACnH,SAAO,EAAE,MAAM,CAACA,QAAO,EAAE,OAAO,GAAG,KAAK,CAAC;AAC3C;","names":["key"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bessemer/cornerstone",
   "type": "module",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -35,5 +35,8 @@
   "devDependencies": {
     "@types/lodash-es": "4.17.12",
     "pino-pretty": "13.0.0"
-  }
+  },
+  "files": [
+    "dist"
+  ]
 }

package/jest.config.js

@@ -1,3 +0,0 @@
-import BaseConfig from '../jest.base.mjs'
-
-export default BaseConfig

package/src/array.ts

@@ -1,142 +0,0 @@
-import {
-  concat,
-  differenceBy as _differenceBy,
-  differenceWith as _differenceWith,
-  first as _first,
-  flatten as _flatten,
-  groupBy as _groupBy,
-  isEmpty as _isEmpty,
-  last as _last,
-  range as _range,
-  remove as _remove,
-  uniqBy,
-  uniqWith,
-} from 'lodash-es'
-import { Equalitor } from '@bessemer/cornerstone/equalitor'
-import { Signable } from '@bessemer/cornerstone/signature'
-import { Comparators, Eithers, Preconditions, Signatures } from '@bessemer/cornerstone'
-import { Either } from '@bessemer/cornerstone/either'
-import { Comparator } from '@bessemer/cornerstone/comparator'
-import { Arrayable } from 'type-fest'
-
-export const equalWith = <T>(first: Array<T>, second: Array<T>, equalitor: Equalitor<T>): boolean => {
-  if (first.length !== second.length) {
-    return false
-  }
-
-  return first.every((element, index) => equalitor(element, second[index]!))
-}
-
-export const equalBy = <T>(first: Array<T>, second: Array<T>, mapper: (element: T) => Signable): boolean => {
-  return equalWith(first, second, (first, second) => Signatures.sign(mapper(first)) === Signatures.sign(mapper(second)))
-}
-
-export const equal = <T extends Signable>(first: Array<T>, second: Array<T>): boolean => {
-  return equalBy(first, second, Signatures.sign)
-}
-
-export const differenceWith = <T>(first: Array<T>, second: Array<T>, equalitor: Equalitor<T>): Array<T> => {
-  return _differenceWith(first, second, equalitor)
-}
-
-export const differenceBy = <T>(first: Array<T>, second: Array<T>, mapper: (element: T) => Signable): Array<T> => {
-  return _differenceBy(first, second, (it) => Signatures.sign(mapper(it)))
-}
-
-export const difference = <T extends Signable>(first: Array<T>, second: Array<T>): Array<T> => {
-  return differenceBy(first, second, Signatures.sign)
-}
-
-export const removeWith = <T>(array: Array<T>, element: T, equalitor: Equalitor<T>): Array<T> => {
-  return differenceWith(array, [element], equalitor)
-}
-
-export const removeBy = <T>(array: Array<T>, element: T, mapper: (element: T) => Signable): Array<T> => {
-  return differenceBy(array, [element], mapper)
-}
-
-export const remove = <T extends Signable>(array: Array<T>, element: T): Array<T> => {
-  return difference(array, [element])
-}
-
-export const containsWith = <T>(array: Array<T>, element: T, equalitor: Equalitor<T>): boolean => {
-  return array.some((it) => equalitor(it, element))
-}
-
-export const containsBy = <T>(array: Array<T>, element: T, mapper: (element: T) => Signable): boolean => {
-  return containsWith(array, element, (first, second) => Signatures.sign(mapper(first)) === Signatures.sign(mapper(second)))
-}
-
-export const contains = <T extends Signable>(array: Array<T>, element: T): boolean => containsBy(array, element, Signatures.sign)
-
-export const containsAllWith = <T>(first: Array<T>, second: Array<T>, equalitor: Equalitor<T>): boolean =>
-  isEmpty(differenceWith(second, first, equalitor))
-
-export const containsAllBy = <T>(first: Array<T>, second: Array<T>, mapper: (element: T) => Signable): boolean =>
-  isEmpty(differenceBy(second, first, mapper))
-
-export const containsAll = <T extends Signable>(first: Array<T>, second: Array<T>): boolean => isEmpty(difference(second, first))
-
-export const dedupeWith = <T>(array: Array<T>, equalitor: Equalitor<T>): Array<T> => {
-  return uniqWith(array, equalitor)
-}
-
-export const dedupeBy = <T>(array: Array<T>, mapper: (element: T) => Signable): Array<T> => {
-  return uniqBy(array, (it) => Signatures.sign(mapper(it)))
-}
-
-export const dedupe = <T extends Signable>(array: Array<T>): Array<T> => {
-  return dedupeBy(array, Signatures.sign)
-}
-
-export const sortWith = <T>(array: Array<T>, comparator: Comparator<T>): Array<T> => {
-  return [...array].sort(comparator)
-}
-
-export const sortBy = <T>(array: Array<T>, mapper: (element: T) => Signable): Array<T> => {
-  return sortWith(
-    array,
-    Comparators.compareBy((it) => Signatures.sign(mapper(it)), Comparators.natural())
-  )
-}
-
-export const sort = <T extends Signable>(array: Array<T>): Array<T> => sortBy(array, Signatures.sign)
-
-export const concatenate = concat
-
-export const first = _first
-
-export const only = <T>(array: Array<T>): T => {
-  Preconditions.isTrue(array.length === 1)
-  return first(array)!
-}
-
-export const last = _last
-
-export const isEmpty = _isEmpty
-// TODO make a better range function
-export const range = _range
-// TODO should this live in collections?
-export const groupBy = _groupBy
-
-export const rest = <T>(array: Array<T>, elementsToSkip: number = 1): Array<T> => {
-  return array.slice(elementsToSkip)
-}
-
-export const clear = (array: Array<unknown>): void => {
-  _remove(array, () => true)
-}
-
-export const bisect = <T, L, R>(array: Array<T>, bisector: (element: T, index: number) => Either<L, R>): [Array<L>, Array<R>] => {
-  return Eithers.split(array.map(bisector))
-}
-
-export const toArray = <T>(array: Arrayable<T>): Array<T> => {
-  if (Array.isArray(array)) {
-    return array
-  }
-
-  return [array]
-}
-
-export const flatten = _flatten

package/src/async.ts

@@ -1,114 +0,0 @@
-import { Duration } from '@bessemer/cornerstone/duration'
-import { Durations, Objects } from '@bessemer/cornerstone'
-
-export type PendingValue = {
-  isSuccess: false
-  isError: false
-  isLoading: false
-  isFetching: boolean
-  data: undefined
-}
-
-export type LoadingValue = {
-  isSuccess: false
-  isError: false
-  isLoading: true
-  isFetching: boolean
-  data: undefined
-}
-
-export type ErrorValue = {
-  isSuccess: false
-  isError: true
-  isLoading: false
-  isFetching: boolean
-  data: unknown
-}
-
-export type FetchingValueSuccess<T> = {
-  isSuccess: true
-  isError: false
-  isLoading: false
-  isFetching: true
-  data: T
-}
-
-export type FetchingValueError = {
-  isSuccess: false
-  isError: true
-  isLoading: false
-  isFetching: true
-  data: unknown
-}
-
-export type SettledValue<T> = {
-  isSuccess: true
-  isError: false
-  isLoading: false
-  isFetching: false
-  data: T
-}
-
-export type AsyncValue<T> = PendingValue | LoadingValue | ErrorValue | FetchingValueSuccess<T> | FetchingValueError | SettledValue<T>
-
-export const isSettled = <T>(value: AsyncValue<T>): value is SettledValue<T> => {
-  return value.isSuccess && !value.isError && !value.isLoading && !value.isFetching
-}
-
-export const loading = (): LoadingValue => ({ isSuccess: false, isError: false, isLoading: true, isFetching: true, data: undefined })
-
-export const fetching = <T>(data: T): FetchingValueSuccess<T> => ({
-  isSuccess: true,
-  isError: false,
-  isLoading: false,
-  isFetching: true,
-  data,
-})
-
-export const settled = <T>(data: T): SettledValue<T> => ({ isSuccess: true, isError: false, isLoading: false, isFetching: false, data })
-
-export const error = (error: unknown): ErrorValue => ({ isSuccess: false, isError: true, isLoading: false, isFetching: false, data: error })
-
-export const handle = <T, N>(
-  value: AsyncValue<T | null>,
-  handlers: { loading: () => N; error: (error: unknown) => N; absent: () => N; success: (data: T) => N }
-): N => {
-  if (value.isLoading || (value.isError && value.isFetching)) {
-    return handlers.loading()
-  }
-  if (value.isError) {
-    return handlers.error(value.data)
-  }
-  if (Objects.isNil(value.data)) {
-    return handlers.absent()
-  }
-
-  return handlers.success(value.data)
-}
-
-export const map = <T, N>(value: AsyncValue<T>, mapper: (value: T) => N): AsyncValue<N> => {
-  if (!value.isSuccess) {
-    return value
-  }
-
-  return { ...value, data: mapper(value.data) }
-}
-
-export const execute = <T>(runnable: () => Promise<T>): Promise<T> => {
-  return new Promise(async (resolve, reject) => {
-    setTimeout(async () => {
-      try {
-        const value = await runnable()
-        resolve(value)
-      } catch (e) {
-        reject(e)
-      }
-    }, 0)
-  })
-}
-
-export const sleep = (duration: Duration): Promise<void> => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, Durations.inMilliseconds(duration))
-  })
-}

package/src/cache.ts

@@ -1,236 +0,0 @@
-import { AbstractLocalKeyValueStore, AbstractRemoteKeyValueStore, LocalKeyValueStore, RemoteKeyValueStore } from '@bessemer/cornerstone/store'
-import { Arrays, Dates, Durations, Objects, Strings, Zod } from '@bessemer/cornerstone'
-import { Duration } from '@bessemer/cornerstone/duration'
-import { ResourceKey, ResourceNamespace } from '@bessemer/cornerstone/resource'
-import { AbstractApplicationContext } from '@bessemer/cornerstone/context'
-import { NominalType } from '@bessemer/cornerstone/types'
-import { Entry } from '@bessemer/cornerstone/entry'
-import { GlobPattern } from '@bessemer/cornerstone/glob'
-import { Arrayable } from 'type-fest'
-import { ZodType } from 'zod'
-
-// JOHN should this even be in cornerstone? especially consider the config types down at the bottom
-
-export type CacheProps = {
-  maxSize: number | null
-  timeToLive: Duration
-  timeToStale: Duration | null
-}
-
-export type CacheOptions = Partial<CacheProps>
-
-export namespace CacheProps {
-  const DefaultCacheProps = {
-    maxSize: 50000,
-    timeToLive: Durations.OneDay,
-    timeToStale: Durations.OneHour,
-  }
-
-  export const buildCacheProps = (options?: CacheOptions): CacheProps => {
-    options = options ?? {}
-
-    const props = Objects.merge(DefaultCacheProps, options)
-
-    if (props.maxSize === null && props.timeToLive === null) {
-      throw new Error('Invalid cache configuration, both maxSize and timeToLive are null')
-    }
-
-    return props
-  }
-}
-
-export namespace CacheKey {
-  // We use a hardcoded UUID to represent a unique token value that serves as a flag to disable caching
-  const DisableCacheToken = 'f6822c1a-d527-4c65-b9dd-ddc24620b684'
-
-  export const disableCaching = (): ResourceNamespace => {
-    return DisableCacheToken
-  }
-
-  export const isDisabled = (key: ResourceNamespace): boolean => {
-    return Strings.contains(key, DisableCacheToken)
-  }
-}
-
-export type CacheSector = {
-  globs: Array<GlobPattern>
-}
-
-export namespace CacheSector {
-  export const of = (globs: Arrayable<GlobPattern>) => {
-    return { globs: Arrays.toArray(globs) }
-  }
-
-  export const namespace = (namespace: ResourceNamespace, sector: CacheSector): CacheSector => {
-    return { globs: ResourceKey.namespaceAll(namespace, sector.globs) }
-  }
-}
-
-export type CacheName = NominalType<string, 'CacheName'>
-export const CacheNameSchema: ZodType<CacheName> = Zod.string()
-
-export interface AbstractCache<T> {
-  name: CacheName
-}
-
-export interface Cache<T> extends AbstractCache<T> {
-  fetchValue(namespace: ResourceNamespace, key: ResourceKey, fetch: () => Promise<T>): Promise<T>
-
-  fetchValues(
-    namespace: ResourceNamespace,
-    keys: Array<ResourceKey>,
-    fetch: (keys: Array<ResourceKey>) => Promise<Array<Entry<T>>>
-  ): Promise<Array<Entry<T>>>
-
-  writeValue(namespace: ResourceNamespace, key: ResourceKey, value: T | undefined): Promise<void>
-
-  writeValues(namespace: ResourceNamespace, entries: Array<Entry<T | undefined>>): Promise<void>
-
-  evictAll(sector: CacheSector): Promise<void>
-}
-
-export interface CacheProvider<T> extends RemoteKeyValueStore<CacheEntry<T>> {
-  type: CacheProviderType
-
-  evictAll(sector: CacheSector): Promise<void>
-}
-
-export abstract class AbstractCacheProvider<T> extends AbstractRemoteKeyValueStore<CacheEntry<T>> implements CacheProvider<T> {
-  abstract type: CacheProviderType
-
-  abstract evictAll(sector: CacheSector): Promise<void>
-}
-
-export interface LocalCache<T> extends AbstractCache<T> {
-  getValue(namespace: ResourceNamespace, key: ResourceKey, fetch: () => T): T
-
-  getValues(namespace: ResourceNamespace, keys: Array<ResourceKey>, fetch: (keys: Array<ResourceKey>) => Array<Entry<T>>): Array<Entry<T>>
-
-  setValue(namespace: ResourceNamespace, key: ResourceKey, value: T | undefined): void
-
-  setValues(namespace: ResourceNamespace, entries: Array<Entry<T | undefined>>): void
-
-  removeAll(sector: CacheSector): void
-}
-
-export interface LocalCacheProvider<T> extends LocalKeyValueStore<CacheEntry<T>>, CacheProvider<T> {
-  removeAll(sector: CacheSector): void
-}
-
-export abstract class AbstractLocalCacheProvider<T> extends AbstractLocalKeyValueStore<CacheEntry<T>> implements LocalCacheProvider<T> {
-  abstract type: CacheProviderType
-
-  abstract removeAll(sector: CacheSector): void
-
-  async evictAll(sector: CacheSector): Promise<void> {
-    this.removeAll(sector)
-  }
-}
-
-export type CacheEntry<T> = {
-  value: T
-  liveTimestamp: Date | null
-  staleTimestamp: Date | null
-}
-
-export namespace CacheEntry {
-  export const isActive = <T>(entry: CacheEntry<T>): boolean => {
-    if (isDead(entry) || isStale(entry)) {
-      return false
-    }
-
-    return true
-  }
-
-  export const isDead = <T>(entry: CacheEntry<T> | undefined): boolean => {
-    if (Objects.isNil(entry)) {
-      return true
-    }
-
-    if (Objects.isNil(entry.liveTimestamp)) {
-      return false
-    }
-
-    return Dates.isBefore(entry.liveTimestamp, Dates.now())
-  }
-
-  export const isAlive = <T>(entry: CacheEntry<T> | undefined): boolean => !isDead(entry)
-
-  export const isStale = <T>(entry: CacheEntry<T>): boolean => {
-    if (Objects.isNil(entry.staleTimestamp)) {
-      return false
-    }
-
-    return Dates.isBefore(entry.staleTimestamp, Dates.now())
-  }
-
-  export const of = <T>(value: T) => {
-    const entry: CacheEntry<T> = {
-      value,
-      liveTimestamp: null,
-      staleTimestamp: null,
-    }
-
-    return entry
-  }
-
-  // JOHN do we want to enforce some kind of minimum liveness threshold?
-  export const applyProps = <T>(originalEntry: CacheEntry<T>, props: CacheProps): CacheEntry<T> => {
-    let liveTimestamp: Date | null = originalEntry.liveTimestamp
-    if (!Objects.isNil(props.timeToLive)) {
-      const limit = Dates.addMilliseconds(Dates.now(), Durations.inMilliseconds(props.timeToLive))
-      if (Dates.isBefore(limit, liveTimestamp ?? limit)) {
-        liveTimestamp = limit
-      }
-    }
-
-    let staleTimestamp: Date | null = originalEntry.staleTimestamp
-    if (!Objects.isNil(props.timeToStale)) {
-      const limit = Dates.addMilliseconds(Dates.now(), Durations.inMilliseconds(props.timeToStale))
-      if (Dates.isBefore(limit, staleTimestamp ?? limit)) {
-        staleTimestamp = limit
-      }
-    }
-
-    const limitedEntry: CacheEntry<T> = {
-      value: originalEntry.value,
-      liveTimestamp,
-      staleTimestamp,
-    }
-
-    return limitedEntry
-  }
-}
-
-export type CacheConfigurationOptions = CacheConfigurationSection & {
-  local: CacheConfigurationSection
-}
-
-export type CacheConfigurationSection = {
-  defaults: CacheDefinition
-
-  /**
-   * These options map from cache name key to configuration. They are a way for the tenant to override the configurations
-   * for specific caches from the cache configuration here.
-   */
-  caches?: Record<string, Partial<CacheDefinition>>
-}
-
-export type CacheDefinition = {
-  options?: CacheOptions
-  providers: Array<CacheProviderConfiguration>
-}
-
-export type CacheProviderType = NominalType<string, 'CacheProviderType'>
-export type CacheProviderConfiguration = CacheOptions & {
-  type: CacheProviderType
-}
-
-export type CacheConfiguration = CacheConfigurationSection & {
-  local: CacheConfigurationSection
-}
-
-export type CacheProviderRegistry<ContextType extends AbstractApplicationContext> = {
-  type: CacheProviderType
-  construct: <T>(props: CacheProps, context: ContextType) => CacheProvider<T>
-}

package/src/combinable.ts

@@ -1,40 +0,0 @@
-import { Arrays, Sets } from '@bessemer/cornerstone'
-
-export interface Combinable {
-  combinability: Combinability
-}
-
-export type Combinability = {
-  type: CombinabilityType
-  class: CombinabilityClass
-}
-
-export enum CombinabilityType {
-  Stackable = 'Stackable',
-  Singleton = 'Singleton',
-  Totalitarian = 'Totalitarian',
-}
-
-export type CombinabilityClass = string | null
-
-export const DefaultCombinability: Combinability = {
-  type: CombinabilityType.Stackable,
-  class: null,
-}
-
-export const combinations = <T extends Combinable>(combinables: Array<T>): Array<Array<T>> => {
-  const classMap = Arrays.groupBy(combinables, (it) => it.combinability.class)
-
-  const classCombinations: Array<Array<Array<T>>> = Object.entries(classMap).map(([_, values]) => {
-    const totalitarianCombinations = values.filter((it) => it.combinability.type === CombinabilityType.Totalitarian).map((it) => [it])
-    if (!Arrays.isEmpty(totalitarianCombinations)) {
-      return totalitarianCombinations
-    }
-
-    const singletonCombinations = values.filter((it) => it.combinability.type === CombinabilityType.Singleton).map((it) => [it])
-    const stackableCombination = values.filter((it) => it.combinability.type === CombinabilityType.Stackable)
-    return [stackableCombination, ...singletonCombinations]
-  })
-
-  return Sets.cartesianProduct(...classCombinations).flatMap((it) => it)
-}