@static-suite/static-suite-data-server 0.0.1 → 0.0.2

package/src/lib/store/store.types.ts

@@ -40,44 +40,18 @@ export interface StoreData<K, V> extends Map<K, V> {
  */
 export type Store = {
   /**
-   * Date to tell when was the store last synced.
-   *
-   * Every time the store is updated, syncDate is set with the last modification
-   * date of the data directory, not the date when the store has finished updating.
-   *
-   * Given this scenario:
-   * - Data directory modified at 12:30:00
-   * - Syncing the store takes 3 seconds and finishes at 12:30:03
-   *
-   * ... syncDate will be 12:30:00, not 12:30:03.
-   *
-   * Doing it the other way round can cause data inconsistencies, because syncing files
-   * to the store takes time, it is done sequentially, and in the meanwhile, other
-   * modifications can happen:
-   * - Store last syncDate is 12:29:00
-   * - Data directory is modified at 12:30:00
-   * - We ask for modified files after 12:29:00 and got 3 files (1.json, 2.json and 3.json)
-   * - File "1.json" is processed and added to the store at 12:30:01
-   * - While "2.json" is being processed and added to the store, data directory is modified
-   * again at 12:30:02 and "1.json" is changed.
-   * - File "3.json" is processed and added to the store at 12:30:03
-   *
-   * At this moment, there are two options:
+   * Initial unique id when the store was initially loaded.
+   */
+  initialUniqueId: string;
+
+  /**
+   * Current unique id to tell when was the store last synced.
    *
-   * 1) Setting syncDate to the current date:
-   * - Store syncDate is set to 12:30:03
-   * - Data directory is modified again at 12:30:10 and only "3.json" is changed
-   * - We ask for modified files after 12:30:03 and get only "3.json"
-   * - Modification done at 12:30:02 to "1.json" is lost and cannot be recovered unless "1.json" is
-   * modified again, or Data Server is restarted
+   * Every time the store is updated, this id is set with the last modification
+   * unique id of the data directory, not the date when the store has finished updating.
    *
-   * 2) Setting syncDate to the last modification date of the data directory:
-   * - Store syncDate is set to 12:30:00
-   * - Data directory is modified again at 12:30:10 and only "3.json" is changed
-   * - We ask for modified files after 12:30:00 and get "1.json" and "3.json"
-   * - Modification done at 12:30:02 to "1.json" is properly processed
    */
-  syncDate: Date | null;
+  currentUniqueId: string;
 
   /**
    * Map that holds all data for all files.
@@ -105,7 +79,7 @@ export type Store = {
   data: StoreData<string, any>;
 
   /**
-   * A list of deleted files from store, to be able to track them.
+   * A list of deleted files since last reboot, to be able to track them.
    */
   deleted: Set<string>;
 
@@ -119,7 +93,7 @@ export type Store = {
     url: Map<string, any>;
 
     /**
-     * An index that holds all data for all files, keyed by their lang and uuid.
+     * An index that holds all data for all files, keyed by their langcode and UUID.
      */
     uuid: Map<string, any>;
 
@@ -168,6 +142,11 @@ export type StoreSubsetOptions = {
  * Object holding a subset of items from the store.
  */
 export type StoreSubset = {
+  /**
+   * Map of elements, with the filename as key
+   */
+  map: Map<string, any>;
+
   /**
    * Array of filenames in this subset.
    */

package/src/lib/store/storeManager.ts

@@ -1,6 +1,6 @@
 import { config } from '@lib/config';
 import { getFileContent } from '@lib/utils/fs';
-import { FileType } from '@lib/utils/fs/fs.types';
+import { Json } from '@lib/utils/object/object.types';
 import { StoreManager } from './store.types';
 import { hookManager } from './hook';
 import { store, resetStore } from '.';
@@ -16,7 +16,12 @@ import { dependencyTagger } from './dependency/dependencyTagger';
  *
  * @returns Object with two properties, "raw" and "json".
  */
-const setFileIntoStore = (relativeFilepath: string): FileType => {
+const setFileIntoStore = (
+  relativeFilepath: string,
+): {
+  fileContent: Json | string | null;
+  previousStoredData: Json | null;
+} => {
   const absoluteFilePath = `${config.dataDir}/${relativeFilepath}`;
   let fileContent = getFileContent(absoluteFilePath);
 
@@ -26,10 +31,12 @@ const setFileIntoStore = (relativeFilepath: string): FileType => {
     fileContent,
   });
 
+  let previousStoredData: any = null;
+
   const dataToStore = fileContent.json || fileContent.raw;
+  const previousData = store.data.get(relativeFilepath);
   if (fileContent.json) {
     // Check if the object already exists to make sure we don't break the reference
-    const previousData = store.data.get(relativeFilepath);
     if (dataToStore && typeof dataToStore === 'object') {
       if (previousData) {
         // Delete include dependencies.
@@ -51,8 +58,10 @@ const setFileIntoStore = (relativeFilepath: string): FileType => {
           store.index.uuid.get(langcode)?.delete(uuid);
         }
 
-        // Delete all referenced object properties
+        // Delete all referenced object properties and copy them to another object.
+        previousStoredData = {};
         Object.keys(previousData).forEach(key => {
+          previousStoredData[key] = previousData[key];
           delete previousData[key];
         });
         // hydrate new object properties into referenced object
@@ -78,26 +87,31 @@ const setFileIntoStore = (relativeFilepath: string): FileType => {
       }
 
       // Add include dependencies.
-      dependencyIncludeHelper.setIncludeDependencies(
+      dependencyIncludeHelper.addIncludeDependencies(
         relativeFilepath,
         dataToStore,
       );
     }
+  } else {
+    previousStoredData = previousData;
   }
   store.data.set(relativeFilepath, dataToStore);
 
   // Remove this path from store.deleted
   store.deleted.delete(relativeFilepath);
 
-  return fileContent;
+  return { fileContent: dataToStore, previousStoredData };
 };
 
 export const storeManager: StoreManager = {
   add: (relativeFilepath: string): StoreManager => {
-    const fileContent = setFileIntoStore(relativeFilepath);
+    const { fileContent } = setFileIntoStore(relativeFilepath);
 
     // Invoke "store add" hook.
-    hookManager.invokeOnStoreItemAdd({ relativeFilepath, fileContent });
+    hookManager.invokeOnStoreItemAdd({
+      relativeFilepath,
+      storeItem: fileContent,
+    });
 
     return storeManager;
   },
@@ -107,11 +121,12 @@ export const storeManager: StoreManager = {
     if (storedData) {
       hookManager.invokeOnStoreItemBeforeUpdate({
         relativeFilepath,
-        fileContent: storedData,
+        storeItem: storedData,
       });
     }
 
-    const fileContent = setFileIntoStore(relativeFilepath);
+    const { fileContent, previousStoredData } =
+      setFileIntoStore(relativeFilepath);
 
     // Invalidate this item.
     dependencyTagger.invalidateTags([relativeFilepath]);
@@ -119,7 +134,8 @@ export const storeManager: StoreManager = {
     // Invoke "store update" hook.
     hookManager.invokeOnStoreItemAfterUpdate({
       relativeFilepath,
-      fileContent,
+      storeItem: fileContent,
+      previousStoreItem: previousStoredData,
     });
 
     return storeManager;
@@ -154,7 +170,7 @@ export const storeManager: StoreManager = {
     // Invoke "store remove" hook.
     hookManager.invokeOnStoreItemDelete({
       relativeFilepath,
-      fileContent: storedData,
+      storeItem: storedData,
     });
 
     return storeManager;

package/src/lib/store/workDir/__tests__/workDirHelper.test.ts

@@ -11,8 +11,13 @@ describe('workDirHelper test', () => {
 
     it(`Gets modified and deleted files from static-suite log`, () => {
       expect(
-        workDirHelper.getChangedFilesSince(new Date('2021-08-01')),
+        workDirHelper.getChangedFilesBetween(
+          '2021-08-16_07-11-55.666963__3503',
+          '2021-08-17_08-50-00.235800__1900',
+        ),
       ).toEqual({
+        fromUniqueId: '2021-08-16_07-11-55.666963__3503',
+        toUniqueId: '2021-08-17_08-50-00.235800__1900',
         deleted: ['es/entity/node/article/10.json'],
         updated: [
           'en/entity/node/article/10.json',

package/src/lib/store/workDir/storage/__tests__/{getChangedLinesSince.test.ts → getChangedLinesBetween.test.ts}

@@ -1,16 +1,21 @@
 import fs from 'fs';
 import path from 'path';
 import { config } from '@lib/config';
-import { getChangedLinesSince } from '../getChangedLinesSince';
+import { getChangedLinesBetween } from '../getChangedLinesBetween';
 
-describe('workDir storage getChangedLinesSince test', () => {
-  describe('getChangedLinesSince', () => {
+describe('workDir storage getChangedLinesBetween test', () => {
+  describe('getChangedLinesBetween', () => {
     config.workDir = fs.realpathSync(
       path.resolve('src/__tests__/fixtures/work'),
     );
 
     it(`Gets lines of log since given date`, () => {
-      expect(getChangedLinesSince(new Date('2021-08-01'))).toEqual([
+      expect(
+        getChangedLinesBetween(
+          '2021-08-16_07-11-55.666963__3503',
+          '2021-08-17_08-50-00.235800__1900',
+        ),
+      ).toEqual([
         '2021-08-16_07-11-55.666963__3504 delete [ID: 10] Prueba y cultiva tus propias hierbas | static-local://es/entity/node/article/10.json',
         '2021-08-16_07-12-45.771095__5959 write [ID: 10] Give it a go and grow your own herbs | static-local://en/entity/node/article/10.json',
         '2021-08-16_07-12-46.771095__5959 delete [ID: 10] Give it a go and grow your own herbs | static-local://en/entity/node/article/10.json',

package/src/lib/store/workDir/storage/getChangedLinesBetween.ts

@@ -0,0 +1,52 @@
+import fs from 'fs';
+import { logger } from '@lib/utils/logger';
+import { isUniqueId } from '@lib/utils/string';
+import { getLogFile } from './getLogFile';
+
+/**
+ * Get changed files between a set of dates.
+ *
+ * @param fromUniqueId - Unique id to search from.
+ * @param toUniqueId - Unique id to search to.
+ *
+ * @remarks
+ * It searches for lines grater than fromUniqueId and lower
+ * or equal to toUniqueId, to avoid getting repeated entries
+ * when dates are advanced in blocks (from 1 to 2, from 2 to 3,
+ * from 3 to 4, etc).
+ *
+ * @returns Array of changed lines
+ */
+export const getChangedLinesBetween = (
+  fromUniqueId: string,
+  toUniqueId: string,
+): string[] => {
+  let allLines: string[] = [];
+  const logFile = getLogFile();
+  if (logFile) {
+    try {
+      allLines = fs.readFileSync(logFile).toString().trim().split('\n');
+    } catch (e) {
+      logger.error(
+        `Error reading metadata log file located at ${`logFile`}: ${e}`,
+      );
+    }
+  }
+
+  const changedLines = allLines.filter(line => {
+    const uniqueId = line.substring(0, 32);
+    return (
+      uniqueId &&
+      isUniqueId(uniqueId) &&
+      uniqueId > fromUniqueId &&
+      uniqueId <= toUniqueId
+    );
+  });
+
+  logger.debug(`Found ${changedLines.length} changed lines`);
+  changedLines.forEach(line => {
+    logger.debug(`Found changed line: ${line}`);
+  });
+
+  return changedLines;
+};

package/src/lib/store/workDir/storage/getDataFromLogLine.ts

@@ -1,3 +1,4 @@
+import { logger } from '@lib/utils/logger';
 import { LogLineData } from '../workDir.types';
 
 /**
@@ -8,13 +9,31 @@ import { LogLineData } from '../workDir.types';
  * @returns An object with parsed data, or null if line format is not valid.
  */
 export const getDataFromLogLine = (line: string): LogLineData | null => {
-  const matches = line.match(/^(\S+) (\S+) \[ID: ([^\]]+)] (.+)/);
+  const matches = line.match(/^(\S+) (\S+) \[ID: ([^\]]+)] (.+)$/);
   if (matches) {
     const uniqueId = matches[1];
     const operation = matches[2];
     const fileId = matches[3];
-    const [fileLabel, uri] = matches[4].split(' | ');
-    const [, uriTarget] = uri.split('://');
+    // Some lines contain more than one "|"
+    const labelUriParts = matches[4].split(' | ');
+    const uri = labelUriParts.pop();
+    const fileLabel = labelUriParts.join(' | ');
+    const uriTarget = uri?.split('://').pop();
+
+    if (
+      !uniqueId ||
+      (operation !== 'write' && operation !== 'delete') ||
+      !fileId ||
+      !fileLabel ||
+      !uriTarget
+    ) {
+      const errorMessage = `Line ${line} meets parsing criteria but it contains invalid data. Regex match: ${JSON.stringify(
+        matches,
+      )}`;
+      logger.error(errorMessage);
+      throw Error(errorMessage);
+    }
+
     if (operation === 'write' || operation === 'delete') {
       return {
         uniqueId,

package/src/lib/store/workDir/storage/index.ts

@@ -3,6 +3,6 @@ These functions are separated from workDirHelper, since they are specific
 to the current storage backend (log files saved on disk) and they can change
 in the future.
 */
-export * from './getChangedLinesSince';
+export * from './getChangedLinesBetween';
 export * from './getDataFromLogLine';
 export * from './getLogFile';

package/src/lib/store/workDir/workDir.types.ts

@@ -2,6 +2,16 @@
  * A group of changed files in Static Suite's data dir.
  */
 export type ChangedFiles = {
+  /**
+   * A unique id representing the date from which those changes are obtained.
+   */
+  fromUniqueId: string;
+
+  /**
+   * A unique id representing the date until which those changes are obtained.
+   */
+  toUniqueId: string;
+
   /**
    * A list of updated files (both newly added and changed files).
    */
@@ -17,7 +27,7 @@ export type ChangedFiles = {
  */
 export type LogLineData = {
   /**
-   * The unique ID of the write/delete operation from Static Suite.
+   * The unique id of the write/delete operation from Static Suite.
    */
   uniqueId: string;
 

package/src/lib/store/workDir/workDirHelper.ts

@@ -1,34 +1,63 @@
-import { getModificationDate } from '@lib/utils/fs';
+import fs from 'fs';
 import { logger } from '@lib/utils/logger';
+import { isUniqueId } from '@lib/utils/string';
 import { ChangedFiles, LogLineData } from './workDir.types';
 import {
   getLogFile,
-  getChangedLinesSince,
+  getChangedLinesBetween,
   getDataFromLogLine,
 } from './storage';
 
+/**
+ * The unique id of the Unix Epoch (00:00:00 UTC on 1 January 1970)
+ */
+export const unixEpochUniqueId = '1970-01-01_00-00-00.000000__0000';
+
 export const workDirHelper = {
   /**
-   * Gets date of last modification of work directory.
+   * Gets unique id of last modification of work directory.
    *
-   * @returns The date of last modification of work directory, or null if directory not found.
+   * @returns The unique id of last modification of work directory, or null if directory not found.
    */
-  getModificationDate: (): Date | null => {
+  getModificationUniqueId: (): string | null => {
+    let modificationUniqueId: string | null = null;
     const logFile = getLogFile();
-    return logFile ? getModificationDate(logFile) : null;
+    let allLines: string[] = [];
+    if (logFile) {
+      try {
+        allLines = fs.readFileSync(logFile).toString().trim().split('\n');
+      } catch (e) {
+        logger.error(
+          `Error reading metadata log file located at ${`logFile`}: ${e}`,
+        );
+      }
+      const lastLine = allLines.slice(-1)[0];
+      const lastLineUniqueId = lastLine.substring(0, 32);
+      if (isUniqueId(lastLineUniqueId)) {
+        modificationUniqueId = lastLineUniqueId;
+      }
+    }
+
+    return modificationUniqueId;
   },
 
   /**
    * Get changed files since a date.
    *
-   * @param sinceDate - Date to search
+   * @param fromUniqueId - Date to search from.
+   * @param toUniqueId - Date to search to.
    *
-   * @returns Object with two properties:
+   * @returns Object with four properties:
    * - updated: array of changed files.
    * - deleted: array of deleted files.
+   * - fromTimestamp
+   * - toTimestamp
    */
-  getChangedFilesSince: (sinceDate: Date): ChangedFiles => {
-    const changedLines = getChangedLinesSince(sinceDate);
+  getChangedFilesBetween: (
+    fromUniqueId: string,
+    toUniqueId: string,
+  ): ChangedFiles => {
+    const changedLines = getChangedLinesBetween(fromUniqueId, toUniqueId);
     const lineData: Record<string, LogLineData> = {};
     changedLines.forEach(line => {
       const dataFromLogLine = getDataFromLogLine(line);
@@ -54,6 +83,11 @@ export const workDirHelper = {
       logger.debug(`Found deleted file "${file}"`);
     });
 
-    return { updated, deleted };
+    return {
+      updated,
+      deleted,
+      fromUniqueId,
+      toUniqueId,
+    };
   },
 };

package/src/lib/utils/fs/fsUtils.ts

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import path from 'path';
 import fg, { Options as fastGlobOptions } from 'fast-glob';
 import chokidar from 'chokidar';
 import { logger } from '@lib/utils/logger';
@@ -99,6 +100,23 @@ export const getModificationDate = (filePath: string): Date | null => {
   return modificationDate;
 };
 
+/**
+ * Removes empty directories upwards.
+ *
+ * @param dir - Path to a directory
+ */
+export const removeEmptyDirsUpwards = (dir: string): void => {
+  const isEmpty = fs.readdirSync(dir).length === 0;
+  if (isEmpty) {
+    try {
+      fs.rmdirSync(dir);
+    } catch (e) {
+      logger.debug(`Error deleting empty directory "${dir}": ${e}`);
+    }
+    removeEmptyDirsUpwards(path.dirname(dir));
+  }
+};
+
 /**
  * Watches for changes on a set of paths and attach listener to them
  *

package/src/lib/utils/module/moduleManager.ts

@@ -82,7 +82,11 @@ export const moduleManager = {
       throw e;
     }
     if (internalModuleCache[resolvedModulePath].onModuleLoad) {
-      internalModuleCache[resolvedModulePath].onModuleLoad({ config, store });
+      internalModuleCache[resolvedModulePath].onModuleLoad({
+        config,
+        store,
+        logger,
+      });
     }
     logger.debug(`Module ${resolvedModulePath} successfully loaded.`);
     return internalModuleCache[resolvedModulePath];

package/src/lib/utils/string/__tests__/stringUtils.test.ts

@@ -1,5 +1,10 @@
 import { logger } from '@lib/utils/logger';
-import { parseJsonString, parseURLSearchParams } from '../stringUtils';
+import {
+  isUniqueId,
+  parseJsonString,
+  parseUniqueId,
+  parseURLSearchParams,
+} from '../stringUtils';
 
 describe('String utils test', () => {
   describe('parseJsonString', () => {
@@ -27,4 +32,28 @@ describe('String utils test', () => {
       expect(parsedQuery).toEqual(expectedValue);
     });
   });
+
+  describe('parseUniqueId', () => {
+    it('parses a valid unique id and returns a date', () => {
+      const uniqueIdDate = parseUniqueId('2022-09-28_11-42-00.001712__7220');
+      expect(uniqueIdDate?.getTime()).toEqual(1664365320001);
+    });
+
+    it('parses a non valid unique id and returns null', () => {
+      const uniqueIdDate = parseUniqueId('non valid unique id');
+      expect(uniqueIdDate).toEqual(null);
+    });
+  });
+
+  describe('isUniqueId', () => {
+    it('returns true for a valid unique id', () => {
+      const result = isUniqueId('2022-09-28_11-42-00.001712__7220');
+      expect(result).toEqual(true);
+    });
+
+    it('returns false for a non valid unique id', () => {
+      const result = isUniqueId('non valid unique id');
+      expect(result).toEqual(false);
+    });
+  });
 });

package/src/lib/utils/string/stringUtils.ts

@@ -59,3 +59,35 @@ export const parseURLSearchParams = (
   });
   return obj;
 };
+
+/**
+ * Parses a unique id from Static Suite and returns a Date.
+ *
+ * @param uniqueId - A unique id from Static Suite
+ *
+ * @returns A date from that unique id, or null if it can be parsed.
+ */
+export const parseUniqueId = (uniqueId: string): Date | null => {
+  // todo - Do not use dates and use timestamps in all cases
+  //  to avoid having to fix offsets.
+  const date = new Date();
+  const dateOffset = -(date.getTimezoneOffset() * 60 * 1000);
+
+  const dateString = uniqueId.replace(
+    /(\d{4})-(\d{2})-(\d{2})_(\d{2})-(\d{2})-(\d{2})\.(\d{3}).*/,
+    '$1-$2-$3T$4:$5:$6.$7',
+  );
+  const parsedDate = Date.parse(dateString);
+  if (!Number.isNaN(parsedDate)) {
+    return new Date(parsedDate + dateOffset);
+  }
+  return null;
+};
+
+/**
+ * Checks that a string is a unique id.
+ *
+ * @param uniqueId - A unique id t be checked
+ */
+export const isUniqueId = (uniqueId: string): boolean =>
+  /(\d{4})-(\d{2})-(\d{2})_(\d{2})-(\d{2})-(\d{2})\.(\d{3}).*/.test(uniqueId);

package/dist/lib/query/queryRunner copy.d.ts

@@ -1,3 +0,0 @@
-import { QueryRunner } from './query.types';
-export declare const queryRunner: QueryRunner;
-//# sourceMappingURL=queryRunner%20copy.d.ts.map

package/dist/lib/query/queryRunner copy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryRunner copy.d.ts","sourceRoot":"","sources":["../../../src/lib/query/queryRunner copy.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,WAAW,EAIZ,MAAM,eAAe,CAAC;AAkBvB,eAAO,MAAM,WAAW,EAAE,WAiEzB,CAAC"}

package/dist/lib/query/queryRunner copy.js

@@ -1,87 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryRunner = void 0;
-const microtime_1 = __importDefault(require("microtime"));
-const config_1 = require("@lib/config");
-const store_1 = require("@lib/store");
-const logger_1 = require("@lib/utils/logger");
-const cache_1 = require("@lib/utils/cache");
-const queryManager_1 = require("./queryManager");
-const query_types_1 = require("./query.types");
-let count = 0;
-/**
- * Creates a QueryErrorResponse object ready to be returned to clients.
- *
- * @param message - Error message
- *
- * @returns A JSON object with an error key
- *
- * @internal
- */
-const createErrorResponse = (message) => {
-    logger_1.logger.error(message);
-    return { error: message };
-};
-exports.queryRunner = {
-    run: (queryId, args) => {
-        if (!config_1.config.queryDir) {
-            return createErrorResponse('No query directory ("queryDir") configured');
-        }
-        if (!queryId) {
-            return createErrorResponse('No query ID received');
-        }
-        const queryModuleInfo = queryManager_1.queryManager.getModuleGroupInfo().get(queryId);
-        if (!queryModuleInfo) {
-            return createErrorResponse(`Query module for ID ${queryId} not found`);
-        }
-        count += 1;
-        const startDate = microtime_1.default.now();
-        const argsString = JSON.stringify(args);
-        // Implement a query cache.
-        const cacheId = `${queryId}--${argsString}`;
-        let isCacheMiss = false;
-        const queryCache = cache_1.cache.bin('query');
-        let queryResult = queryCache.get(cacheId);
-        if (!queryResult) {
-            try {
-                const queryModule = queryModuleInfo.getModule();
-                const queryResponse = queryModule.default({
-                    store: store_1.store,
-                    args,
-                });
-                queryResult = {
-                    result: queryResponse?.result,
-                    contentType: queryResponse?.contentType || 'application/json',
-                    tags: queryResponse?.tags,
-                };
-                isCacheMiss = true;
-                if (queryResponse?.cacheable !== false) {
-                    queryCache.set(cacheId, queryResult);
-                }
-            }
-            catch (e) {
-                // Log error and rethrow.
-                logger_1.logger.error(`#${count} Query error: "${queryId}", args "${argsString}": ${e}`);
-                throw e;
-            }
-        }
-        const execTimeMs = (microtime_1.default.now() - startDate) / 1000;
-        const response = {
-            data: queryResult.result,
-            metadata: {
-                contentType: queryResult?.contentType || 'application/json',
-                execTimeMs,
-                cache: isCacheMiss ? query_types_1.CacheStatus.MISS : query_types_1.CacheStatus.HIT,
-                tags: queryResult.tags,
-            },
-        };
-        /*     logger.debug(
-          `#${count} Query "${queryId}" args "${argsString}" took ${execTimeMs} ms.`,
-        ); */
-        return response;
-    },
-    getCount: () => count,
-};