Integrate rollup (#236)

Author: kibertoad

.eslintrc.json

@@ -2,7 +2,9 @@
   "extends": [
     "eslint:recommended",
     "plugin:@typescript-eslint/recommended",
-    "plugin:prettier/recommended"
+    "plugin:prettier/recommended",
+    "plugin:import/recommended",
+    "plugin:import/typescript"
   ],
   "plugins": [
     "@typescript-eslint",
@@ -31,6 +33,7 @@
     ],
     "no-var": "off",
     "@typescript-eslint/ban-ts-comment": "off",
+    "@typescript-eslint/consistent-type-imports": "warn",
     "@typescript-eslint/no-non-null-assertion": "off",
     "@typescript-eslint/no-var-requires": "off",
     "@typescript-eslint/indent": "off",

lib/AbstractGroupedOperation.ts

@@ -1,5 +1,5 @@
 import { AbstractOperation } from './AbstractOperation'
-import { GroupedCache } from './types/DataSources'
+import type { GroupedCache } from './types/DataSources'
 
 export abstract class AbstractGroupedOperation<LoadedValue, ResolveParams = undefined> extends AbstractOperation<
   LoadedValue,

lib/AbstractOperation.ts

@@ -1,7 +1,9 @@
-import { InMemoryCache, InMemoryCacheConfiguration, NoopCache } from './memory'
-import { SynchronousGroupedCache } from './types/SyncDataSources'
-import { Cache } from './types/DataSources'
-import { defaultLogger, Logger } from './Logger'
+import type { InMemoryCacheConfiguration } from './memory'
+import { InMemoryCache, NoopCache } from './memory'
+import type { SynchronousGroupedCache } from './types/SyncDataSources'
+import type { Cache } from './types/DataSources'
+import type { Logger } from './Logger'
+import { defaultLogger } from './Logger'
 
 export type LoaderErrorHandler = (
   err: Error,

lib/GroupedCachingOperation.ts

@@ -1,5 +1,5 @@
-import { GroupedCache } from './types/DataSources'
-import { CommonOperationConfig } from './AbstractOperation'
+import type { GroupedCache } from './types/DataSources'
+import type { CommonOperationConfig } from './AbstractOperation'
 import { AbstractGroupedOperation } from './AbstractGroupedOperation'
 
 export type GroupedCachingOperationConfig<LoadedValue> = CommonOperationConfig<LoadedValue, GroupedCache<LoadedValue>>

lib/GroupedLoadingOperation.ts

@@ -1,5 +1,5 @@
-import { GroupedCache, GroupLoader } from './types/DataSources'
-import { LoadingOperationConfig } from './LoadingOperation'
+import type { GroupedCache, GroupLoader } from './types/DataSources'
+import type { LoadingOperationConfig } from './LoadingOperation'
 import { AbstractGroupedOperation } from './AbstractGroupedOperation'
 
 export type GroupedLoadingOperationConfig<LoadedValue, LoaderParams = undefined> = LoadingOperationConfig<

lib/LoadingOperation.ts

@@ -1,5 +1,5 @@
-import { CommonOperationConfig } from './AbstractOperation'
-import { Cache, Loader } from './types/DataSources'
+import type { CommonOperationConfig } from './AbstractOperation'
+import type { Cache, Loader } from './types/DataSources'
 import { AbstractFlatOperation } from './AbstractFlatOperation'
 
 export type LoadingOperationConfig<

lib/memory/InMemoryCache.ts

@@ -1,10 +1,13 @@
-import { fifo, fifoObject, lru, lruObject, ToadCache } from 'toad-cache'
-import { SynchronousCache, SynchronousGroupedCache } from '../types/SyncDataSources'
-import { CacheConfiguration } from '../types/DataSources'
+import type { CacheConstructor, ToadCache } from 'toad-cache'
+import { FifoMap, FifoObject, LruMap, LruObject } from 'toad-cache'
+import type { SynchronousCache, SynchronousGroupedCache } from '../types/SyncDataSources'
+import type { CacheConfiguration } from '../types/DataSources'
+
+type CacheTypeId = 'lru-map' | 'fifo-map' | 'lru-object' | 'fifo-object'
 
 export interface InMemoryCacheConfiguration extends CacheConfiguration {
-  cacheType?: 'lru' | 'fifo' | 'lru-object' | 'fifo-object'
-  groupCacheType?: 'lru' | 'fifo' | 'lru-object' | 'fifo-object'
+  cacheType?: CacheTypeId
+  groupCacheType?: CacheTypeId
   maxItems?: number
   maxGroups?: number
   maxItemsPerGroup?: number
@@ -25,31 +28,31 @@ export class InMemoryCache<T> implements SynchronousCache<T>, SynchronousGrouped
   name = 'In-memory cache'
   private readonly ttlInMsecs: number | undefined
   public readonly ttlLeftBeforeRefreshInMsecs?: number
-  private readonly cacheConstructor: <T = any>(max?: number, ttl?: number) => ToadCache<T>
-  private readonly groupCacheConstructor: <T = any>(max?: number, ttl?: number) => ToadCache<T>
+  private readonly cacheConstructor: CacheConstructor<ToadCache<T>>
+  private readonly groupCacheConstructor: CacheConstructor<ToadCache<ToadCache<T | null>>>
 
   constructor(config: InMemoryCacheConfiguration) {
-    this.cacheConstructor = this.resolveCacheConstructor(config.cacheType ?? DEFAULT_CONFIGURATION.cacheType)
-    this.groupCacheConstructor = this.resolveCacheConstructor(
+    this.cacheConstructor = this.resolveCacheConstructor<T>(config.cacheType ?? DEFAULT_CONFIGURATION.cacheType)
+    this.groupCacheConstructor = this.resolveCacheConstructor<ToadCache<T | null>>(
       config.groupCacheType ?? DEFAULT_CONFIGURATION.groupCacheType
     )
 
-    this.cache = this.cacheConstructor(config.maxItems ?? DEFAULT_CONFIGURATION.maxItems, config.ttlInMsecs ?? 0)
-    this.groups = this.groupCacheConstructor(config.maxGroups ?? DEFAULT_CONFIGURATION.maxGroups)
+    this.cache = new this.cacheConstructor(config.maxItems ?? DEFAULT_CONFIGURATION.maxItems, config.ttlInMsecs ?? 0)
+    this.groups = new this.groupCacheConstructor(config.maxGroups ?? DEFAULT_CONFIGURATION.maxGroups)
     this.maxItemsPerGroup = config.maxItemsPerGroup ?? DEFAULT_CONFIGURATION.maxItemsPerGroup
     this.ttlInMsecs = config.ttlInMsecs
     this.ttlLeftBeforeRefreshInMsecs = config.ttlLeftBeforeRefreshInMsecs
   }
 
-  private resolveCacheConstructor(cacheTypeId: 'lru' | 'fifo' | 'lru-object' | 'fifo-object') {
-    if (cacheTypeId === 'fifo') {
-      return fifo
-    } else if (cacheTypeId === 'lru') {
-      return lru
+  private resolveCacheConstructor<T>(cacheTypeId: CacheTypeId): CacheConstructor<ToadCache<T>> {
+    if (cacheTypeId === 'fifo-map') {
+      return FifoMap
+    } else if (cacheTypeId === 'lru-map') {
+      return LruMap
     } else if (cacheTypeId === 'fifo-object') {
-      return fifoObject
+      return FifoObject
     } else {
-      return lruObject
+      return LruObject
     }
   }
 
@@ -59,7 +62,7 @@ export class InMemoryCache<T> implements SynchronousCache<T>, SynchronousGrouped
       return groupCache
     }
 
-    const newGroupCache = this.cacheConstructor(this.maxItemsPerGroup, this.ttlInMsecs)
+    const newGroupCache = new this.cacheConstructor(this.maxItemsPerGroup, this.ttlInMsecs)
     this.groups.set(groupId, newGroupCache)
     return newGroupCache
   }

lib/memory/NoopCache.ts

@@ -1,4 +1,4 @@
-import { SynchronousCache, SynchronousGroupedCache } from '../types/SyncDataSources'
+import type { SynchronousCache, SynchronousGroupedCache } from '../types/SyncDataSources'
 
 export class NoopCache<T> implements SynchronousCache<T>, SynchronousGroupedCache<T> {
   name = 'Noop cache'

lib/redis/RedisCache.ts

@@ -1,4 +1,4 @@
-import { Cache, CacheConfiguration, GroupedCache, Loader } from '../types/DataSources'
+import type { Cache, CacheConfiguration, GroupedCache, Loader } from '../types/DataSources'
 import type { Redis } from 'ioredis'
 import { RedisTimeoutError } from './RedisTimeoutError'
 import { GET_OR_SET_ZERO_WITH_TTL, GET_OR_SET_ZERO_WITHOUT_TTL } from './lua'

lib/redis/RedisExpirationTimeGroupedLoader.ts

@@ -1,4 +1,4 @@
-import { GroupedCache, GroupLoader } from '../types/DataSources'
+import type { GroupedCache, GroupLoader } from '../types/DataSources'
 
 export class RedisExpirationTimeGroupedLoader implements GroupLoader<number> {
   public readonly name = 'RedisExpirationTimeGroupedLoader'