Add cache to webserver

ExternalCommands/External.ws.ws.js

@@ -13,7 +13,7 @@ export default class WsCommand extends SourceCommand {
    * @param {IContext} context
    * @returns {Promise<ICommandResult>}
    */
-  async #loadDataAsync(sourceName, context) {
+  async _loadDataAsync(sourceName, context) {
     const [connectionName, command] = await Promise.all([
       this.connectionName.getValueAsync(context),
       this.toCustomFormatHtmlAsync(context),

Models/CacheCommands/BaseCacheUtil.js

@@ -0,0 +1,20 @@
+import ConnectionInfo from "../Connection/ConnectionInfo";
+export default class BaseCacheUtil {
+  /**@type {ConnectionInfo}*/
+  connectionInfo;
+  channel;
+
+  /**@param {ConnectionInfo} */
+  constractor(connectionInfo,settings) {
+    this.connectionInfo = connectionInfo;
+    this.settings = settings
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  connectAsync() {}
+
+  /**@returns {Promise<void>} */
+  createDeleteChannel() {}
+}

Models/CacheCommands/RabbitMQCacheUtil.js

@@ -0,0 +1,51 @@
+import ConnectionInfo from "../Connection/ConnectionInfo.js";
+import BaseCacheUtil from "./BaseCacheUtil.js";
+import * as ampq from "amqplib/callback_api";
+import RabbitMQSetting from "./RabbitMqSetting.js";
+export default class RabbitMQCacheUtil extends BaseCacheUtil {
+  /**@type {ConnectionInfo}*/
+  connectionInfo;
+  /**@type {RabbitMQSetting} */
+  settings;
+  /** @type {ampq.Channel} */
+  channel;
+
+  /**
+   * @param {ConnectionInfo}
+   * @param {RabbitMQSetting} settings
+   */
+  constractor(connectionInfo, settings) {
+    super(connectionInfo,settings);
+  }
+  /**
+   * @returns {Promise<void>}
+   */
+  connectAsync() {
+    return new Promise((resolve, reject) => {
+      ampq.connect(this.settings.address, function (error0, connection) {
+        if (error0) {
+          reject(error0);
+        }
+        connection.createChannel(function (error1, channel) {
+          if (error1) {
+            reject(error1);
+          }
+          this.channel = channel;
+          resolve();
+        });
+      });
+    });
+  }
+  /**
+   * @param {string} queueName
+   * @returns {Promise<void>}
+   */
+  createDeleteChannel(queueName) {
+    channel.assertQueue(queueName, {
+      durable: true,
+    });
+    this.channel.consume(queueName, async function (msg) {
+      await this.connection.deleteAllCache();
+    });
+  }
+}

Models/CacheCommands/RabbitMqSetting.js

@@ -0,0 +1,5 @@
+export default class RabbitMQSetting {
+    /** @type {string} */
+    address;
+  }
+

Models/Connection/ConnectionInfo.js

@@ -3,7 +3,7 @@ import DataSourceCollection from "../../renderEngine/Source/DataSourceCollection
 import IRoutingRequest from "../IRoutingRequest.js";
 import Request from "../request.js";
 import ILoadPageResult from "./ILoadPageResult.js";
-
+import CacheResult from "../options/CacheResult.js";
 export default class ConnectionInfo {
   /** @type {string} */
   name;
@@ -69,4 +69,21 @@ export default class ConnectionInfo {
       );
     }
   }
+  /**
+   *
+   * @param {string} key
+   * @returns {Promise<CacheResult|null>}
+   */
+  async loadContentAsync(key) {}
+
+  /**
+   * @param {string} key
+   * @param {string} content
+   * @param {NodeJS.Dict<string>} properties
+   * @returns {Promise<void>}
+   */
+  async addCacheContentAsync(key, content, properties) {}
+
+  /** @returns {Promise<void>} */
+  async deleteAllCache() {}
 }

Models/Connection/SqliteConnectionInfo.js

@@ -4,6 +4,8 @@ import SqliteSettingData from "./SqliteSettingData.js";
 import DataSourceCollection from "../../renderEngine/Source/DataSourceCollection.js";
 import CancellationToken from "../../renderEngine/Cancellation/CancellationToken.js";
 import Request from "../request.js";
+import CacheResult from "./../options/CacheResult.js";
+
 export default class SqliteConnectionInfo extends ConnectionInfo {
   /** @type {SqliteSettingData} */
   settings;
@@ -36,9 +38,9 @@ export default class SqliteConnectionInfo extends ConnectionInfo {
           }
         });
       });
-      const retVal = new DataSourceCollection(
-       [ Array.isArray(rows) ? rows : [rows]]
-      );
+      const retVal = new DataSourceCollection([
+        Array.isArray(rows) ? rows : [rows],
+      ]);
 
       return retVal;
     } finally {
@@ -47,7 +49,6 @@ export default class SqliteConnectionInfo extends ConnectionInfo {
       }
     }
   }
-
   /**
    * @param {Request} request
    * @param {CancellationToken} cancellationToken
@@ -59,4 +60,83 @@ export default class SqliteConnectionInfo extends ConnectionInfo {
   async testConnectionAsync() {
     throw new Error("test connection is not supported in sqlite");
   }
+
+  /**
+   *
+   * @param {string} key
+   * @param {CancellationToken} cancellationToken
+   * @returns {Promise<CacheResult|null>}
+   */
+  async loadContentAsync(key, cancellationToken) {
+    /**@type {sqlite3.Database} */
+    let database;
+    try {
+      database = new sqlite3.Database(this.settings.dbPath);
+      const result = await this.#executeSqliteQuery(
+        database,
+        `SELECT * FROM ${this.settings.tableName}  WHERE key = ?`,
+        [key]
+      );
+      return result[0];
+    } finally {
+      if (database) {
+        database.close();
+      }
+    }
+  }
+
+  /**
+   * @param {string} key
+   * @param {string} content
+   * @param {NodeJS.Dict<string>} properties
+   * @returns {Promise<void>}
+   */
+  async addCacheContentAsync(key, content, properties) {
+    const database = new sqlite3.Database(this.settings.dbPath);
+    try {
+      const query = `
+      BEGIN TRANSACTION;
+      WITH Selected AS (
+        SELECT * FROM ${this.settings.tableName} WHERE key = ?
+      )
+      DELETE FROM ${this.settings.tableName} WHERE key = ? AND EXISTS (SELECT 1 FROM Selected);
+      INSERT INTO ${this.settings.tableName} (key, content, properties) VALUES (?, ?, ?);
+      COMMIT TRANSACTION;
+    `;
+      const result = this.#executeSqliteQuery(database, query, [
+        key,
+        content,
+        JSON.stringify(properties),
+      ]);
+      return result;
+    } catch (err) {
+      throw new Error("error in add cache  : " + err);
+    } finally {
+      if (database) {
+        database.close();
+      }
+    }
+  }
+  /**
+   *
+   * @param {sqlite3.Database} db
+   * @param {string} query
+   * @param {any[]} params
+   * @returns {Promise<any[]>}
+   */
+  #executeSqliteQuery(db, query, params = []) {
+    return new Promise((resolve, reject) => {
+      db.all(query, params, (err, rows) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(rows);
+        }
+      });
+    });
+  }
+  /** @returns {Promise<void>} */
+  async deleteAllCache() {
+    return this.#executeSqliteQuery(`DELETE FROM ${this.settings.tableName}`);
+  }
 }

Models/Connection/SqliteSettingData.js

@@ -3,4 +3,6 @@ export default class SqlSettingData {
   dbPath;
   /** @type {string} */
   query;
+  /** @type {string} */
+  tableName
 }

Models/ServiceSettings.js

@@ -15,6 +15,8 @@ export default class ServiceSettings {
   callConnection;
   /** @type {ConnectionInfo} */
   ilUpdateConnection;
+  /** @type {ConnectionInfo} */
+  cacheConnection;
   /**
    * @param {HostServiceOptions} options
    */
@@ -33,6 +35,15 @@ export default class ServiceSettings {
     if ("ilupdate" in this._connections) {
       this.ilUpdateConnection = this._connections.ilupdate;
     }
+    if ("cacheconnection" in this._connections) {
+      this.cacheConnection = this._connections.cacheconnection;
+    }
+    if (
+      options.CacheSettings?.isEnabled &&
+      !("cacheconnection" in this._connections)
+    ) {
+      throw new Error("must add cacheConnection if you set Cache to true");
+    }
   }
 
   /**

Models/options/CacheResult.js

@@ -0,0 +1,8 @@
+export default class CacheResult {
+  /**@type {string} */
+  key;
+  /** @type {string} */
+  content;
+  /**@type {NodeJS.Dict<string>}*/
+  properties;
+}

Models/options/CacheSettings.js

@@ -0,0 +1,13 @@
+export default class CacheSettings {
+  /**@type {string[]} */
+  responseHeaders;
+  /**@type {string[]} */
+  requestMethods;
+  /** @type {boolean} */
+  isEnabled;
+  //for now is rabbit
+  /** @type {"Rabbit"} */
+  utilType
+  /**@type { NodeJS.Dict<string> } */
+  utilSetting
+}

Models/options/hostServiceOptions.js

@@ -1,4 +1,5 @@
 import IStreamerEngineOptions from "./IStreamerEngineOptions.js";
+import CacheSettings from "./CacheSettings.js";
 
 export default class HostServiceOptions {
   /**@type {"Sql"|"Edge"|"File"} */
@@ -15,4 +16,6 @@ export default class HostServiceOptions {
   Streamer;
   /**@type {NodeJS.Dict<any>} */
   Settings;
+  /**@type {CacheSettings}*/
+  CacheSettings;
 }