feat(asset): load dependencies only once, change ttlcache to map (#81)

Co-authored-by: Robert Aradei <[email protected]>

src/core/query-builder.utils.test.ts

@@ -1,5 +1,4 @@
 import { expressionBuilderCallback, expressionReaderCallback, ExpressionTransformFunction, transformComputedFieldsQuery } from "./query-builder.utils"
-import TTLCache from "@isaacs/ttlcache";
 
 describe('QueryBuilderUtils', () => {
   describe('transformComputedFieldsQuery', () => {
@@ -50,9 +49,9 @@ describe('QueryBuilderUtils', () => {
     });
 
     it('should handle options correctly', () => {
-      const options = new Map<string, TTLCache<string, unknown>>();
-      const cache = new TTLCache<string, unknown>();
-      cache.set('key', 'value', { ttl: 1 });
+      const options = new Map<string, Map<string, unknown>>();
+      const cache = new Map<string, unknown>();
+      cache.set('key', 'value');
       options.set('Object1', cache);
 
       const query = 'Object1 = "value1"';

src/core/query-builder.utils.ts

@@ -1,6 +1,5 @@
 import { QueryBuilderCustomOperation } from "smart-webcomponents-react";
 import { QueryBuilderOption } from "./types";
-import TTLCache from "@isaacs/ttlcache";
 
 /**
  * Should be used when looking to build a custom expression for a field
@@ -9,7 +8,7 @@ import TTLCache from "@isaacs/ttlcache";
  * @param options The options to be used in the transformation
  * @returns The transformed value
  */
-export type ExpressionTransformFunction = (value: string, operation: string, options?: TTLCache<string, unknown>) => string;
+export type ExpressionTransformFunction = (value: string, operation: string, options?: Map<string, unknown>) => string;
 
 /**
  * Supported operations for computed fields
@@ -27,7 +26,7 @@ export const computedFieldsupportedOperations = ['=', '!='];
 export function transformComputedFieldsQuery(
   query: string,
   computedDataFields: Map<string, ExpressionTransformFunction>,
-  options?: Map<string, TTLCache<string, unknown>>
+  options?: Map<string, Map<string, unknown>>
 ) {
   for (const [field, transformation] of computedDataFields.entries()) {
     const regex = new RegExp(`\\b${field}\\s*(${computedFieldsupportedOperations.join('|')})\\s*"([^"]*)"`, 'g');

src/datasources/asset-calibration/AssetCalibrationDataSource.ts

@@ -23,8 +23,6 @@ import {
 import { ExpressionTransformFunction, transformComputedFieldsQuery } from 'core/query-builder.utils';
 import { AssetCalibrationFieldNames } from './constants';
 import { AssetModel, AssetsResponse } from 'datasources/asset-common/types';
-import TTLCache from '@isaacs/ttlcache';
-import { metadataCacheTTL } from 'datasources/data-frame/constants';
 import { SystemMetadata } from 'datasources/system/types';
 import { defaultOrderBy, defaultProjection } from 'datasources/system/constants';
 import { QueryBuilderOperations } from 'core/query-builder.constants';
@@ -37,13 +35,16 @@ export class AssetCalibrationDataSource extends DataSourceBase<AssetCalibrationQ
     filter: ''
   };
 
-  public areSystemsLoaded = false;
-  public areWorkspacesLoaded = false;
+  private systemsLoaded!: () => void;
+  private workspacesLeaded!: () => void;
+
+  public areSystemsLoaded$ = new Promise<void>(resolve => this.systemsLoaded = resolve);
+  public areWorkspacesLoaded$ = new Promise<void>(resolve => this.workspacesLeaded = resolve);
 
   public error = '';
 
-  public readonly systemAliasCache: TTLCache<string, SystemMetadata> = new TTLCache<string, SystemMetadata>({ ttl: metadataCacheTTL });
-  public readonly workspacesCache: TTLCache<string, Workspace> = new TTLCache<string, Workspace>({ ttl: metadataCacheTTL });
+  public readonly systemAliasCache = new Map<string, SystemMetadata>([]);
+  public readonly workspacesCache = new Map<string, Workspace>([]);
   public readonly busTypeCache = new Map<BusType, string>([
     ...BusTypeOptions.map(busType => [busType.value, busType.label]) as Array<[BusType, string]>
   ]);
@@ -52,17 +53,22 @@ export class AssetCalibrationDataSource extends DataSourceBase<AssetCalibrationQ
   ]);
 
   private readonly baseUrl = this.instanceSettings.url + '/niapm/v1';
+  private dependenciesLoadedPromise: Promise<void>;
 
   constructor(
     readonly instanceSettings: DataSourceInstanceSettings,
     readonly backendSrv: BackendSrv = getBackendSrv(),
     readonly templateSrv: TemplateSrv = getTemplateSrv(),
   ) {
     super(instanceSettings, backendSrv, templateSrv);
+    this.dependenciesLoadedPromise = this.loadDependencies();
   }
 
   async runQuery(query: AssetCalibrationQuery, options: DataQueryRequest): Promise<DataFrameDTO> {
-    await this.loadDependencies();
+    await this.dependenciesLoadedPromise;
+
+    this.error = '';
+
     this.validateQueryRange(query, options);
 
     if (query.filter) {
@@ -80,7 +86,7 @@ export class AssetCalibrationDataSource extends DataSourceBase<AssetCalibrationQ
     ...Object.values(AssetCalibrationFieldNames).map(field => [field, this.multipleValuesQuery(field)] as [AssetCalibrationFieldNames, ExpressionTransformFunction]),
     [
       AssetCalibrationFieldNames.LOCATION,
-      (value: string, operation: string, options?: TTLCache<string, unknown>) => {
+      (value: string, operation: string, options?: Map<string, unknown>) => {
         let values = [value];
 
         if (this.isMultiSelectValue(value)) {
@@ -126,7 +132,7 @@ export class AssetCalibrationDataSource extends DataSourceBase<AssetCalibrationQ
     return operation === QueryBuilderOperations.EQUALS.name ? '||' : '&&';
   }
 
-  private readonly queryTransformationOptions = new Map<AssetCalibrationFieldNames, TTLCache<string, unknown>>([
+  private readonly queryTransformationOptions = new Map<AssetCalibrationFieldNames, Map<string, unknown>>([
     [AssetCalibrationFieldNames.LOCATION, this.systemAliasCache]
   ]);
 
@@ -289,8 +295,9 @@ export class AssetCalibrationDataSource extends DataSourceBase<AssetCalibrationQ
         this.error = parseErrorMessage(error)!;
       });
 
-    this.areSystemsLoaded = true;
     systems?.forEach(system => this.systemAliasCache.set(system.id, system));
+
+    this.systemsLoaded();
   }
 
   private async loadWorkspaces(): Promise<void> {
@@ -303,13 +310,12 @@ export class AssetCalibrationDataSource extends DataSourceBase<AssetCalibrationQ
         this.error = parseErrorMessage(error)!;
       });
 
-    this.areWorkspacesLoaded = true;
     workspaces?.forEach(workspace => this.workspacesCache.set(workspace.id, workspace));
+
+    this.workspacesLeaded();
   }
 
   async loadDependencies(): Promise<void> {
-    this.error = '';
-
     await this.loadSystems();
     await this.loadWorkspaces();
   }

src/datasources/asset-calibration/__snapshots__/AssetCalibrationDataSource.test.ts.snap

@@ -195,7 +195,7 @@ exports[`queries calibration forecast with minion ID location groupBy 1`] = `
       {
         "name": "Group",
         "values": [
-          "Minion1-alias",
+          "Minion1",
           "Minion2",
           "Minion3",
         ],

src/datasources/asset-calibration/components/AssetCalibrationQueryEditor.tsx

@@ -20,16 +20,12 @@ export const AssetCalibrationQueryEditor = ({ query, onChange, onRunQuery, datas
   const [areDependenciesLoaded, setAreDependenciesLoaded] = useState<boolean>(false);
 
   useEffect(() => {
-    if (datasource.areWorkspacesLoaded) {
+    Promise.all([datasource.areSystemsLoaded$, datasource.areWorkspacesLoaded$]).then(() => {
       setWorkspaces(Array.from(datasource.workspacesCache.values()));
-    }
-
-    if (datasource.areSystemsLoaded) {
       setSystems(Array.from(datasource.systemAliasCache.values()));
-    }
-
-    setAreDependenciesLoaded(datasource.areSystemsLoaded && datasource.areWorkspacesLoaded);
-  }, [datasource, datasource.areSystemsLoaded, datasource.areWorkspacesLoaded]);
+      setAreDependenciesLoaded(true);
+    });
+  }, [datasource]);
 
   const handleQueryChange = (value: AssetCalibrationQuery, runQuery: boolean): void => {
     onChange(value);