fix: better types for cache and dataloader

packages/cache/src/index.ts

@@ -137,14 +137,14 @@ export interface CacheRealm {
    * Creates a new cache within the realm. All caches within
    * a realm share the same capacity and eviction queue.
    */
-  createCache<TKey, TValue>(
+  createCache: <TKey, TValue>(
     options: CacheOptions<TKey, TValue>,
-  ): Cache<TKey, TValue>;
+  ) => Cache<TKey, TValue>;
 
   /**
    * Replicates a cache delete/clear from another server.
    */
-  writeReplicationEvent(event: ReplicationEvent): void;
+  writeReplicationEvent: (event: ReplicationEvent) => void;
 }
 
 /**
@@ -166,7 +166,7 @@ export interface Cache<TKey, TValue> {
    *
    * Returns undefined if the entry is not in the cache.
    */
-  get(key: TKey): TValue | undefined;
+  get: (key: TKey) => TValue | undefined;
 
   /**
    * If the an item with this key is already in the cache,
@@ -179,32 +179,32 @@ export interface Cache<TKey, TValue> {
    * If the cache realm is full, the least recently used item will
    * be evicted.
    */
-  set(key: TKey, value: TValue): TValue;
+  set: (key: TKey, value: TValue) => TValue;
 
   /**
    * Delete items from the cache and remove them from the
    * eviction queue.
    */
-  delete(...keys: TKey[]): void;
+  delete: (...keys: TKey[]) => void;
 
   /**
    * Delete items where the serialized key has a given prefix.
    *
    * This will throw a runtime error if any keys are not
    * serialized to strings.
    */
-  deletePrefix(prefix: string): void;
+  deletePrefix: (prefix: string) => void;
 
   /**
    * Clear all items from the cache and remove them from the
    * eviction queue.
    */
-  clear(): void;
+  clear: () => void;
 
   /**
    * Dispose of the cache and remove it from the realm.
    */
-  dispose(): void;
+  dispose: () => void;
 }
 
 type SerializedKey = {__type: 'SerializedKey'};

packages/dataloader/src/MultiKeyMap.ts

@@ -11,10 +11,10 @@ type SubPath<TKeys extends readonly unknown[]> = TKeys extends readonly [
 export interface MultiKeyMap<TKeys extends Path, TValue>
   extends CacheMap<TKeys, TValue> {
   readonly size: number;
-  get(key: TKeys): TValue | undefined;
-  set(key: TKeys, value: TValue): void;
-  delete(key: TKeys | SubPath<TKeys>): void;
-  clear(): void;
+  get: (key: TKeys) => TValue | undefined;
+  set: (key: TKeys, value: TValue) => void;
+  delete: (key: TKeys | SubPath<TKeys>) => void;
+  clear: () => void;
 }
 
 export interface MultiKeyMapOptionWithMapKey<
@@ -59,10 +59,10 @@ export type MultiKeyMapOptions<
 };
 
 interface NormalizedMultiKeyMapOptions<TKeys extends Path, TValue, TMappedKey> {
-  getCache(
+  getCache: (
     depth: number,
-  ): CacheMapInput<TMappedKey, MultiKeyMapNode<TKeys, TValue>>;
-  getKeyMap(depth: number): (key: TKeys[number]) => TMappedKey;
+  ) => CacheMapInput<TMappedKey, MultiKeyMapNode<TKeys, TValue>>;
+  getKeyMap: (depth: number) => (key: TKeys[number]) => TMappedKey;
 }
 const identityFn = <T>(arg: T): T => arg;
 const DEFAULT_OPTIONS: NormalizedMultiKeyMapOptions<any, any, any> = {
@@ -159,9 +159,9 @@ const DELETE_NOOP = new DeleteResult(0, false);
 
 interface MultiKeyMapNode<TKeys extends Path, TValue> {
   get size(): number;
-  get(keys: TKeys): TValue | undefined;
-  set(keys: TKeys, value: TValue): boolean;
-  delete(keys: TKeys | SubPath<TKeys>): DeleteResult;
+  get: (keys: TKeys) => TValue | undefined;
+  set: (keys: TKeys, value: TValue) => boolean;
+  delete: (keys: TKeys | SubPath<TKeys>) => DeleteResult;
 }
 
 class BranchNode<TKeys extends Path, TValue, TMappedKey>

packages/dataloader/src/batch.ts

@@ -7,7 +7,7 @@ export type BatchResponseFunction<TKey, TResult> = (
   keys: TKey[],
 ) => Promise<TResult> | TResult;
 export type BatchResponseMap<TKey, TResult> = {
-  get(key: TKey): Promise<TResult> | TResult;
+  get: (key: TKey) => Promise<TResult> | TResult;
 };
 export type BatchResponseArray<TResult> = readonly (
   | Promise<TResult>

packages/dataloader/src/types.ts

@@ -1,23 +1,21 @@
 export interface CacheMapInput<TKey, TValue> {
   readonly size?: number;
-  get(key: TKey): TValue | undefined;
-  set(key: TKey, value: TValue): unknown;
-  delete(key: TKey): unknown;
-  clear?(): unknown;
+  get: (key: TKey) => TValue | undefined;
+  set: (key: TKey, value: TValue) => unknown;
+  delete: (key: TKey) => unknown;
+  clear?: () => unknown;
 }
-
 export interface CacheMap<TKey, TValue> {
   readonly size?: number;
-  get(key: TKey): TValue | undefined;
-  set(key: TKey, value: TValue): void;
-  delete(key: TKey): void;
-  clear(): void;
+  get: (key: TKey) => TValue | undefined;
+  set: (key: TKey, value: TValue) => void;
+  delete: (key: TKey) => void;
+  clear: () => void;
 }
-
 export interface AsyncCacheMap<TKey, TValue> {
   readonly size?: number;
-  get(key: TKey): Promise<TValue> | undefined;
-  set(key: TKey, value: Promise<TValue> | TValue): void;
-  delete(key: TKey): void;
-  clear(): void;
+  get: (key: TKey) => Promise<TValue> | undefined;
+  set: (key: TKey, value: Promise<TValue> | TValue) => void;
+  delete: (key: TKey) => void;
+  clear: () => void;
 }