Renamed service (#79)

src/controllers/ExtensionController.ts

@@ -53,7 +53,7 @@ import {
 import type {
   ConnectionState,
   Disposable,
-  ICacheService,
+  IAsyncCacheService,
   IConfigService,
   IDheService,
   IDheServiceFactory,
@@ -110,14 +110,15 @@ export class ExtensionController implements Disposable {
   private _connectionController: ConnectionController | null = null;
   private _coreCredentialsCache: URLMap<Lazy<DhcType.LoginCredentials>> | null =
     null;
-  private _dheClientCache: ICacheService<URL, EnterpriseClient> | null = null;
+  private _dheClientCache: IAsyncCacheService<URL, EnterpriseClient> | null =
+    null;
   private _dheCredentialsCache: URLMap<DheLoginCredentials> | null = null;
-  private _dheServiceCache: ICacheService<URL, IDheService> | null = null;
+  private _dheServiceCache: IAsyncCacheService<URL, IDheService> | null = null;
   private _panelController: PanelController | null = null;
   private _panelService: IPanelService | null = null;
   private _pipServerController: PipServerController | null = null;
   private _dhcServiceFactory: IDhServiceFactory | null = null;
-  private _dheJsApiCache: ICacheService<URL, DheType> | null = null;
+  private _dheJsApiCache: IAsyncCacheService<URL, DheType> | null = null;
   private _dheServiceFactory: IDheServiceFactory | null = null;
   private _serverManager: IServerManager | null = null;
   private _userLoginController: UserLoginController | null = null;

src/services/DheService.ts

@@ -8,7 +8,7 @@ import type {
 import {
   WorkerURL,
   type ConsoleType,
-  type ICacheService,
+  type IAsyncCacheService,
   type IDheService,
   type IDheServiceFactory,
   type Lazy,
@@ -43,9 +43,9 @@ export class DheService implements IDheService {
    */
   static factory = (
     coreCredentialsCache: URLMap<Lazy<DhcType.LoginCredentials>>,
-    dheClientCache: ICacheService<URL, EnterpriseClient>,
+    dheClientCache: IAsyncCacheService<URL, EnterpriseClient>,
     dheCredentialsCache: URLMap<DheLoginCredentials>,
-    dheJsApiCache: ICacheService<URL, DheType>
+    dheJsApiCache: IAsyncCacheService<URL, DheType>
   ): IDheServiceFactory => {
     return {
       create: (serverUrl: URL): IDheService =>
@@ -66,9 +66,9 @@ export class DheService implements IDheService {
   private constructor(
     serverUrl: URL,
     coreCredentialsCache: URLMap<Lazy<DhcType.LoginCredentials>>,
-    dheClientCache: ICacheService<URL, EnterpriseClient>,
+    dheClientCache: IAsyncCacheService<URL, EnterpriseClient>,
     dheCredentialsCache: URLMap<DheLoginCredentials>,
-    dheJsApiCache: ICacheService<URL, DheType>
+    dheJsApiCache: IAsyncCacheService<URL, DheType>
   ) {
     this.serverUrl = serverUrl;
     this._coreCredentialsCache = coreCredentialsCache;
@@ -84,9 +84,9 @@ export class DheService implements IDheService {
   private readonly _coreCredentialsCache: URLMap<
     Lazy<DhcType.LoginCredentials>
   >;
-  private readonly _dheClientCache: ICacheService<URL, EnterpriseClient>;
+  private readonly _dheClientCache: IAsyncCacheService<URL, EnterpriseClient>;
   private readonly _dheCredentialsCache: URLMap<DheLoginCredentials>;
-  private readonly _dheJsApiCache: ICacheService<URL, DheType>;
+  private readonly _dheJsApiCache: IAsyncCacheService<URL, DheType>;
   private readonly _querySerialSet: Set<QuerySerial>;
   private readonly _workerInfoMap: URLMap<WorkerInfo, WorkerURL>;
 

src/services/ServerManager.ts

@@ -15,7 +15,7 @@ import type {
   ServerState,
   WorkerInfo,
   IDheService,
-  ICacheService,
+  IAsyncCacheService,
   WorkerURL,
   Lazy,
   UniqueID,
@@ -39,7 +39,7 @@ export class ServerManager implements IServerManager {
     configService: IConfigService,
     coreCredentialsCache: URLMap<Lazy<DhcType.LoginCredentials>>,
     dhcServiceFactory: IDhServiceFactory,
-    dheServiceCache: ICacheService<URL, IDheService>
+    dheServiceCache: IAsyncCacheService<URL, IDheService>
   ) {
     this._configService = configService;
     this._connectionMap = new URLMap<ConnectionState>();
@@ -61,7 +61,7 @@ export class ServerManager implements IServerManager {
     Lazy<DhcType.LoginCredentials>
   >;
   private readonly _dhcServiceFactory: IDhServiceFactory;
-  private readonly _dheServiceCache: ICacheService<URL, IDheService>;
+  private readonly _dheServiceCache: IAsyncCacheService<URL, IDheService>;
   private readonly _uriConnectionsMap: URIMap<ConnectionState>;
   private readonly _workerURLToServerURLMap: URLMap<URL>;
   private _serverMap: URLMap<ServerState>;

src/services/cache/URLPromiseMapCache.ts → src/services/cache/ByURLAsyncCache.ts

@@ -1,11 +1,13 @@
-import type { ICacheService } from '../../types';
+import type { IAsyncCacheService } from '../../types';
 import { isDisposable } from '../../util';
 import { URLMap } from '../URLMap';
 
 /**
  * Cache service that stores values by URL.
  */
-export class URLPromiseMapCache<TValue> implements ICacheService<URL, TValue> {
+export class ByURLAsyncCache<TValue>
+  implements IAsyncCacheService<URL, TValue>
+{
   constructor(loader: (url: URL) => Promise<TValue>) {
     this._loader = loader;
     this._promiseMap = new URLMap<Promise<TValue>>();

src/services/cache/DheClientCache.ts

@@ -2,15 +2,15 @@ import type {
   EnterpriseDhType as DheType,
   EnterpriseClient,
 } from '@deephaven-enterprise/jsapi-types';
-import { URLPromiseMapCache } from './URLPromiseMapCache';
+import { ByURLAsyncCache } from './ByURLAsyncCache';
 import { createDheClient, getWsUrl } from '../../dh/dhe';
-import type { ICacheService } from '../../types';
+import type { IAsyncCacheService } from '../../types';
 
 /**
  * Cache DHE client instances by URL.
  */
-export class DheClientCache extends URLPromiseMapCache<EnterpriseClient> {
-  constructor(dheJsApiCache: ICacheService<URL, DheType>) {
+export class DheClientCache extends ByURLAsyncCache<EnterpriseClient> {
+  constructor(dheJsApiCache: IAsyncCacheService<URL, DheType>) {
     super(async (url: URL) => {
       const dhe = await dheJsApiCache.get(url);
       return createDheClient(dhe, getWsUrl(url));

src/services/cache/DheJsApiCache.ts

@@ -1,12 +1,12 @@
 import { initDheApi } from '@deephaven/require-jsapi';
 import type { EnterpriseDhType as DheType } from '@deephaven-enterprise/jsapi-types';
 import { getTempDir, urlToDirectoryName } from '../../util';
-import { URLPromiseMapCache } from './URLPromiseMapCache';
+import { ByURLAsyncCache } from './ByURLAsyncCache';
 
 /**
  * Cache DHE jsapi instances by URL.
  */
-export class DheJsApiCache extends URLPromiseMapCache<DheType> {
+export class DheJsApiCache extends ByURLAsyncCache<DheType> {
   constructor() {
     super(async url =>
       initDheApi(url, getTempDir({ subDirectory: urlToDirectoryName(url) }))

src/services/cache/DheServiceCache.ts

@@ -1,10 +1,10 @@
-import { URLPromiseMapCache } from './URLPromiseMapCache';
+import { ByURLAsyncCache } from './ByURLAsyncCache';
 import type { IDheService, IDheServiceFactory } from '../../types';
 
 /**
  * Cache `IdheService` instances by URL.
  */
-export class DheServiceCache extends URLPromiseMapCache<IDheService> {
+export class DheServiceCache extends ByURLAsyncCache<IDheService> {
   constructor(dheServiceFactory: IDheServiceFactory) {
     super(async url => {
       return dheServiceFactory.create(url);

src/services/cache/index.ts

@@ -1,4 +1,4 @@
-export * from './URLPromiseMapCache';
+export * from './ByURLAsyncCache';
 export * from './DheClientCache';
 export * from './DheJsApiCache';
 export * from './DheServiceCache';

src/types/serviceTypes.d.ts

@@ -17,7 +17,7 @@ import type {
   UniqueID,
 } from '../types/commonTypes';
 
-export interface ICacheService<TKey, TValue> extends Disposable {
+export interface IAsyncCacheService<TKey, TValue> extends Disposable {
   get: (key: TKey) => Promise<TValue>;
   has: (key: TKey) => boolean;
   invalidate: (key: TKey) => void;