lupine.api 1.0.41

package/src/api/server-content-type.ts

@@ -0,0 +1,82 @@
+export const serverContentType: { [key: string]: string } = {
+  txt: 'text/plain',
+  htm: 'text/html',
+  html: 'text/html',
+  xhtml: 'application/xhtml+xml',
+  xml: 'text/xml',
+  css: 'text/css',
+  js: 'text/javascript',
+  wasm: 'application/wasm',
+  json: 'application/json',
+  csv: 'text/csv',
+  yaml: 'application/x-yaml',
+  md: 'text/markdown',
+  yml: 'application/x-yaml',
+  map: 'application/json',
+  rss: 'application/rss+xml',
+
+  gif: 'image/gif',
+  jpeg: 'image/jpeg',
+  jpg: 'image/jpeg',
+  tif: 'image/tiff',
+  tiff: 'image/tiff',
+  png: 'image/png',
+  svg: 'image/svg+xml',
+  bmp: 'image/bmp',
+  webp: 'image/webp',
+  heic: 'image/heic',
+  heif: 'image/heif',
+  avif: 'image/avif',
+  swf: 'application/x-shockwave-flash',
+  ico: 'image/x-icon',
+  cur: 'image/x-icon',
+
+  pdf: 'application/pdf',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  odt: 'application/vnd.oasis.opendocument.text',
+  ods: 'application/vnd.oasis.opendocument.spreadsheet',
+  odp: 'application/vnd.oasis.opendocument.presentation',
+  ppt: 'application/vnd.ms-powerpoint',
+  rtf: 'application/rtf',
+
+  woff: 'font/woff',
+  woff2: 'font/woff2',
+  ttf: 'font/ttf',
+  otf: 'font/otf',
+  eot: 'application/vnd.ms-fontobject',
+
+  mp3: 'audio/mpeg',
+  wav: 'audio/x-wav',
+  wma: 'audio/x-ms-wma',
+  mp4: 'video/mp4',
+  mpeg: 'video/mpeg',
+  avi: 'video/x-msvideo',
+  wmv: 'video/x-ms-wmv',
+  ogg: 'audio/ogg',
+  oga: 'audio/ogg',
+  ogv: 'video/ogg',
+  webm: 'video/webm',
+  m4a: 'audio/mp4',
+  aac: 'audio/aac',
+  flac: 'audio/flac',
+  mid: 'audio/midi',
+  midi: 'audio/midi',
+  '3gp': 'video/3gpp',
+  '3g2': 'video/3gpp2',
+  mov: 'video/quicktime',
+  mkv: 'video/x-matroska',
+  m4v: 'video/mp4',
+
+  jar: 'application/java-archive',
+  gz: 'application/gzip',
+  tar: 'application/x-tar',
+  rar: 'application/vnd.rar',
+  zip: 'application/zip',
+  '7z': 'application/x-7z-compressed',
+  sh: 'application/x-sh',
+  bat: 'application/x-msdownload',
+};

package/src/api/server-render.ts

@@ -0,0 +1,216 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ServerResponse } from 'http';
+import { FsUtils, Logger } from '../lib';
+import { getWebEnv } from '../lib';
+import { ServerRequest } from '../models/locals-props';
+import { ToClientDelivery } from './to-client-delivery';
+import { IToClientDelivery } from '../models/to-client-delivery-props';
+import { JsonObject } from '../models/json-object';
+import { getTemplateCache } from './api-cache';
+import { apiStorage } from './api-shared-storage';
+import { SimpleStorageDataProps } from '../models';
+import { RuntimeRequire } from '../lib/runtime-require';
+
+const logger = new Logger('StaticServer');
+
+export type RenderPageFunctionsType = {
+  fetchData: (url: string, postData: string | JsonObject) => Promise<any>;
+  [key: string]: Function;
+};
+let renderPageFunctions: RenderPageFunctionsType = {
+  fetchData: async (url: string, postData: string | JsonObject) => {
+    throw new Error('Method not implemented');
+  },
+};
+export const getRenderPageFunctions = () => renderPageFunctions;
+// for the FE code to fetch data in SSR
+export const bindRenderPageFunctions = (calls: RenderPageFunctionsType) => {
+  for (let k in calls) {
+    renderPageFunctions[k] = calls[k];
+  }
+};
+
+export type PageResultType = {
+  content: string;
+  title: string;
+  metaData: string;
+  themeName: string;
+  globalCss: string;
+};
+type _LupineJs = {
+  generatePage: (props: any, toClientDelivery: IToClientDelivery) => Promise<PageResultType>;
+};
+
+export const isServerSideRenderUrl = (urlWithoutQuery: string) => {
+  /*
+    ""                            -->   ""
+    "name"                        -->   ""
+    "name.txt"                    -->   "txt"
+    ".htpasswd"                   -->   ""
+    "name.with.many.dots.myext"   -->   "myext"
+  */
+  const ext = urlWithoutQuery.slice(((urlWithoutQuery.lastIndexOf('.') - 1) >>> 0) + 2);
+  return ext === '' || ext === 'html';
+};
+
+// If the folder contains index.html and index.js, then the js will be used to render
+const findNearestRoot = async (cachedHtml: any, webRoot: string, urlWithoutQuery: string) => {
+  if (urlWithoutQuery === '/' || urlWithoutQuery === '/index.html') {
+    return webRoot;
+  }
+  if (urlWithoutQuery.endsWith('/')) {
+    urlWithoutQuery = urlWithoutQuery.slice(0, -1);
+  }
+
+  // cache sub folders whether it has both index.html and js, or virtual path
+  if (!cachedHtml['_sub_:' + webRoot]) {
+    cachedHtml['_sub_:' + webRoot] = {};
+  }
+
+  const cacheRoots = cachedHtml['_sub_:' + webRoot];
+  let nearRoot = path.join(webRoot, urlWithoutQuery);
+  if (cacheRoots[nearRoot] === '1') {
+    return nearRoot;
+  }
+
+  while (
+    cacheRoots[nearRoot] === '0' ||
+    !(await FsUtils.pathExist(path.join(nearRoot, 'index.html'))) ||
+    !(await FsUtils.pathExist(path.join(nearRoot, 'index.js')))
+  ) {
+    cacheRoots[nearRoot] = '0';
+    nearRoot = path.dirname(nearRoot);
+    if (cacheRoots[nearRoot] === '1' || nearRoot.length <= webRoot.length) {
+      break;
+    }
+  }
+  if (nearRoot.length <= webRoot.length) {
+    nearRoot = webRoot;
+  } else {
+    cacheRoots[nearRoot] = '1';
+  }
+  return nearRoot;
+};
+
+const titleText = '<!--META-TITLE-->';
+const metaTextStart = '<!--META-ENV-START-->';
+const metaTextEnd = '<!--META-ENV-END-->';
+const containerText = '<div class="lupine-root">'; // '</div>'
+type CachedHtmlProps = {
+  content: string;
+  webEnv: { [k: string]: string };
+  // serverConfig: { [k: string]: any };
+  titleIndex: number;
+  metaIndexStart: number;
+  metaIndexEnd: number;
+  containerIndex: number;
+  _lupineJs: _LupineJs;
+};
+export const serverSideRenderPage = async (
+  appName: string,
+  webRoot: string,
+  urlWithoutQuery: string,
+  urlQuery: string,
+  req: ServerRequest,
+  res: ServerResponse
+) => {
+  console.log(`=========SSR, root: ${webRoot}, url: ${urlWithoutQuery}`);
+
+  // cache multiple folders
+  const cachedHtml = getTemplateCache();
+
+  // in order to support virtual path and also sub folders, here needs to find nearest sub folder which contains index.js
+  const nearRoot = await findNearestRoot(cachedHtml, webRoot, urlWithoutQuery);
+
+  if (!cachedHtml[nearRoot]) {
+    // the FE code needs to export _lupineJs
+    // const lupinJs = await import(webRoot + '/index.js');
+    const gThis = await RuntimeRequire.loadModuleIsolated(path.join(nearRoot, 'index.js'), { _lupineJs: null });
+    // const lupinJs = require(path.join(nearRoot, 'index.js'));
+    if (!gThis || !gThis._lupineJs) {
+      throw new Error('_lupineJs is not defined');
+    }
+
+    console.log(`=========load lupine: `, gThis);
+    const _lupineJs = gThis._lupineJs() as _LupineJs;
+
+    const content = await fs.promises.readFile(path.join(nearRoot, 'index.html'));
+    const contentWithEnv = content.toString();
+    cachedHtml[nearRoot] = {
+      content: contentWithEnv,
+      webEnv: getWebEnv(appName),
+      titleIndex: contentWithEnv.indexOf(titleText),
+      metaIndexStart: contentWithEnv.indexOf(metaTextStart),
+      metaIndexEnd: contentWithEnv.indexOf(metaTextEnd),
+      containerIndex: contentWithEnv.indexOf(containerText),
+      _lupineJs: _lupineJs,
+    } as CachedHtmlProps;
+  }
+
+  const props = {
+    url: urlWithoutQuery,
+    // urlSections: urlWithoutQuery.split('/').filter((i) => !!i),
+    query: Object.fromEntries(new URLSearchParams(urlQuery || '')), //new URLSearchParams(urlQuery || ''),
+    urlParameters: {},
+    renderPageFunctions: renderPageFunctions,
+  };
+
+  const _lupineJs = cachedHtml[nearRoot]._lupineJs;
+  const currentCache = cachedHtml[nearRoot] as CachedHtmlProps;
+  const webSetting = await apiStorage.getWebAll();
+  const webSettingShortKey: SimpleStorageDataProps = {};
+  for (let item of Object.keys(webSetting)) {
+    const newItem = item.substring(4);
+    webSettingShortKey[newItem] = webSetting[item];
+  }
+  // const webSetting = AppConfig.get(AppConfig.WEB_SETTINGS_KEY) || {};
+  const clientDelivery = new ToClientDelivery(currentCache.webEnv, webSettingShortKey, req.locals.cookies());
+  const page = await _lupineJs.generatePage(props, clientDelivery);
+  // console.log(`=========load lupin: `, content);
+
+  const allowOrigin = req.headers.origin && req.headers.origin !== 'null' ? req.headers.origin : '*';
+  res.setHeader('Access-Control-Allow-Origin', allowOrigin);
+  res.writeHead(200, { 'Content-Type': 'text/html' });
+  // res.writeHead(200, { 'Content-Type': 'text/html', 'Content-Encoding': 'gzip' });
+
+  // const s = zlib.createGzip();
+  // stream.pipeline(s, res, (err) => {
+  //   s.write(cachedHtml.content.substring(0, cachedHtml.titleIndex).replace('<!--META-THEME-->', page.themeName));
+  //   s.write(page.title);
+  //   s.write(cachedHtml.content.substring(cachedHtml.titleIndex + titleText.length, cachedHtml.metaIndex));
+  //   s.write(page.metaData);
+  //   s.write(page.globalCss);
+  //   s.write(
+  //     cachedHtml.content.substring(cachedHtml.metaIndex + metaText.length, cachedHtml.containerIndex + containerText.length)
+  //   )
+  //   s.write(page.content);
+  //   s.write(cachedHtml.content.substring(cachedHtml.containerIndex + containerText.length), (err) => {
+  //     s.flush();
+  //     res.end();
+  //   });
+  // });
+
+  // data-theme and title
+  res.write(currentCache.content.substring(0, currentCache.titleIndex).replace('<!--META-THEME-->', page.themeName));
+  res.write(page.title);
+  res.write(currentCache.content.substring(currentCache.titleIndex + titleText.length, currentCache.metaIndexStart));
+  // meta data
+  res.write(page.metaData);
+  res.write(page.globalCss);
+  res.write('<script id="web-env" type="application/json">' + JSON.stringify(currentCache.webEnv) + '</script>');
+  res.write('<script id="web-setting" type="application/json">' + JSON.stringify(webSettingShortKey) + '</script>');
+  res.write(
+    currentCache.content.substring(
+      currentCache.metaIndexEnd + metaTextEnd.length,
+      currentCache.containerIndex + containerText.length
+    )
+  );
+  // content
+  res.write(page.content);
+  res.write(currentCache.content.substring(currentCache.containerIndex + containerText.length));
+
+  // const html = index.toString().replace('<div class="lupine-root"></div>', content);
+  // handler200(res, html);
+  res.end();
+};

package/src/api/shell-service.ts

@@ -0,0 +1,66 @@
+import { spawn, ChildProcessWithoutNullStreams } from 'child_process';
+import os from 'os';
+import { MiniWebSocket } from './mini-web-socket';
+import { Duplex } from 'stream';
+
+// This is only used in debug mode (no clusters)
+export class ShellService {
+  private _shell?: ChildProcessWithoutNullStreams;
+  private _socket: Duplex;
+  private _miniWebSocket: MiniWebSocket;
+
+  constructor(socket: Duplex, miniWebSocket: MiniWebSocket) {
+    this._socket = socket;
+    this._miniWebSocket = miniWebSocket;
+    try {
+      const shellCmd: string = this.getDefaultShell();
+      this._shell = spawn(shellCmd, [], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      console.error(error);
+      this._miniWebSocket.sendMessage(this._socket!, JSON.stringify({ error: error }));
+      return;
+    }
+
+    this._shell.stdout.on('data', (data) => {
+      this._miniWebSocket.sendMessage(this._socket!, data.toString());
+    });
+    this._shell.stderr.on('data', (data) => {
+      this._miniWebSocket.sendMessage(this._socket!, data.toString());
+    });
+    this._shell.on('exit', (code, signal) => {
+      this._miniWebSocket.sendMessage(this._socket!, `Shell exited with code ${code}, signal ${signal}`);
+      this._shell = undefined;
+    });
+  }
+
+  getDefaultShell() {
+    const platform = os.platform();
+    if (platform === 'win32') {
+      return process.env.COMSPEC || 'cmd.exe';
+    }
+    return process.env.SHELL || 'bash';
+  }
+
+  public stop() {
+    this._shell?.kill();
+    this._shell = undefined;
+  }
+
+  public isRunning() {
+    return this._shell !== undefined;
+  }
+
+  public getShell() {
+    return this._shell;
+  }
+
+  public cmd(cmd: string) {
+    if (this._shell && this._shell.stdin.writable) {
+      this._shell.stdin.write(cmd + '\n');
+    } else {
+      this._miniWebSocket.sendMessage(this._socket!, 'Shell is not available.');
+    }
+  }
+}

package/src/api/simple-storage.ts

@@ -0,0 +1,80 @@
+import * as fs from 'fs/promises';
+import { ISimpleStorage, SimpleStorageDataProps } from '../models/simple-storage-props';
+
+// This class is used by both BE and FE (cookie for SSR).
+export class SimpleStorage implements ISimpleStorage {
+  private settings: SimpleStorageDataProps = {};
+  private dirty: boolean = false;
+
+  constructor(settings: SimpleStorageDataProps) {
+    this.settings = settings;
+  }
+
+  setContent(settings: SimpleStorageDataProps) {
+    this.settings = settings;
+    this.dirty = true;
+  }
+  async saveContent(filePath: string) {
+    await fs.writeFile(filePath, JSON.stringify(this.settings));
+    this.dirty = false;
+  }
+
+  set Dirty(dirty: boolean) {
+    this.dirty = dirty;
+  }
+  get Dirty(): boolean {
+    return this.dirty;
+  }
+
+  contains(key: string): boolean {
+    return key in this.settings;
+  }
+  size(): number {
+    return Object.keys(this.settings).length;
+  }
+  set(key: string, value: string) {
+    this.dirty = true;
+    if (typeof value === 'undefined') {
+      delete this.settings[key];
+    } else {
+      this.settings[key] = value;
+    }
+  }
+
+  getWithPrefix(prefixKey: string): SimpleStorageDataProps {
+    // get all key startswith prefixKey
+    const result: SimpleStorageDataProps = {};
+    for (let key in this.settings) {
+      if (key.startsWith(prefixKey)) {
+        result[key] = this.settings[key];
+      }
+    }
+    return result;
+  }
+
+  get(key: string, defaultValue: string): string {
+    return key in this.settings ? this.settings[key] : defaultValue;
+  }
+  getInt(key: string, defaultValue: number): number {
+    if (key in this.settings) {
+      const i = parseInt(this.settings[key]);
+      if (!isNaN(i)) {
+        return i;
+      }
+    }
+    return defaultValue;
+  }
+  getBoolean(key: string, defaultValue: boolean): boolean {
+    return key in this.settings
+      ? this.settings[key] === '1' || this.settings[key].toLowerCase() === 'true'
+      : defaultValue;
+  }
+  getJson(key: string, defaultValue: object): object {
+    if (key in this.settings) {
+      try {
+        return JSON.parse(this.settings[key]);
+      } catch (error) {}
+    }
+    return defaultValue;
+  }
+}

package/src/api/static-server.ts

@@ -0,0 +1,125 @@
+// const request = require('request');
+import * as fs from 'fs';
+import * as path from 'path';
+import { ServerResponse } from 'http';
+import { Logger } from '../lib';
+import { ServerRequest } from '../models/locals-props';
+import { handler200, handler404, handler500 } from './handle-status';
+import { isServerSideRenderUrl, serverSideRenderPage } from './server-render';
+import { serverContentType } from './server-content-type';
+import { apiCache } from './api-cache';
+
+export class StaticServer {
+  logger = new Logger('StaticServer');
+
+  private async sendFile(realPath: string, requestPath: string, res: ServerResponse) {
+    try {
+      // const text = fs.readFileSync(realPath);
+      // createReadStream has default autoClose(true)
+      // https://nodejs.org/api/fs.html#fscreatereadstreampath-options
+      const fileStream = fs.createReadStream(realPath);
+      fileStream.on('error', (error) => {
+        this.logger.warn(`File not found: ${realPath}`);
+        handler404(res);
+        return true;
+      });
+      fileStream.on('open', () => {
+        let ext = path.extname(realPath);
+        ext = ext ? ext.slice(1) : 'unknown';
+        const contentType = serverContentType[ext] || 'application/octet-stream';
+        res.writeHead(200, {
+          'Content-Type': contentType + '; charset=UTF-8',
+        });
+      });
+      fileStream.on('end', function () {
+        res.end();
+      });
+      // res.write(text);
+      // res.end();
+      fileStream.pipe(res);
+
+      return true;
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        this.logger.warn(`File not found: ${realPath}`);
+        handler200(res, `File not found: ${requestPath}`);
+      } else {
+        this.logger.error(`Error for: ${realPath}`, err);
+        handler200(res, 'Service failed: ' + err.message);
+      }
+      return true;
+    }
+  }
+
+  async processRequest(req: ServerRequest, res: ServerResponse, rootUrl?: string) {
+    this.logger.info(`StaticServer, url: ${req.locals.url}, host: ${req.locals.host}, rootUrl: ${rootUrl}`);
+
+    const hostPath = apiCache.getAsyncStore().hostPath;
+    const urlSplit = (rootUrl || req.locals.urlWithoutQuery).split('?');
+    const fullPath = path.join(hostPath.webPath, urlSplit[0]);
+
+    const jumpToServerSideRender = () => {
+      const error = new Error();
+      (error as any).code = 'ENOENT';
+      // jump to serverSideRenderPage
+      throw error;
+    };
+    try {
+      if (urlSplit[0] === '/' || urlSplit[0] === '/index.html') {
+        jumpToServerSideRender();
+      }
+
+      // if fullPath doesn't exist, it will throw ENOENT error
+      const realPath = await fs.promises.realpath(fullPath);
+      console.log(`request: ${realPath}`);
+      // for security reason, the requested file should be inside of wwwRoot
+      if (realPath.substring(0, hostPath.webPath.length) !== hostPath.webPath) {
+        this.logger.warn(`ACCESS DENIED: ${urlSplit[0]}`);
+        handler200(res, `ACCESS DENIED: ${urlSplit[0]}`);
+        return true;
+      }
+
+      let finalPath = '';
+      if ((await fs.promises.lstat(realPath)).isDirectory()) {
+        if ((await fs.promises.lstat(path.join(realPath, 'index.js'))).isFile()) {
+          // because it's directory, it means index.html, and if it has index.js, it will jump to serverSideRenderPage
+          jumpToServerSideRender();
+        }
+        // if index.js doesn't exist, it will send index.html
+        finalPath = path.join(realPath, 'index.html');
+      } else {
+        // it's a file, and if it's index.html and the same directory has index.js, it will jump to serverSideRenderPage
+        if (realPath.endsWith('/index.html') && (await fs.promises.lstat(path.join(path.dirname(realPath), 'index.js'))).isFile()) {
+          jumpToServerSideRender();
+        }
+        finalPath = realPath;
+      }
+
+      // now we need to send finalPath file. If finalPath doesn't exist, it will cause error and jump to serverSideRenderPage
+      try {
+        const allowOrigin = (req.headers.origin && req.headers.origin !== 'null') ? req.headers.origin : '*';
+        res.setHeader('Access-Control-Allow-Origin', allowOrigin);
+
+        await this.sendFile(finalPath, urlSplit[0], res);
+      } catch (err: any) {
+        this.logger.warn(`File not found: ${urlSplit[0]}`);
+        handler200(res, `File not found: ${urlSplit[0]}`);
+      }
+      return true;
+    } catch (err: any) {
+      // file doesn't exist
+      if (err.code === 'ENOENT') {
+        if (isServerSideRenderUrl(urlSplit[0])) {
+          serverSideRenderPage(hostPath.appName, hostPath.webPath, urlSplit[0], urlSplit[1], req, res);
+        } else {
+          this.logger.error(`File not found: ${urlSplit[0]}`);
+          handler404(res, `File not found: ${urlSplit[0]}`);
+        }
+      } else {
+        this.logger.error(`Error for: ${urlSplit[0]}`, err);
+        handler500(res, `processRequest error: ${err.message}`);
+      }
+      return true;
+    }
+  }
+}

package/src/api/to-client-delivery.ts

@@ -0,0 +1,26 @@
+import { IToClientDelivery } from '../models/to-client-delivery-props';
+import { ISimpleStorage } from '../models/simple-storage-props';
+
+export class ToClientDelivery implements IToClientDelivery {
+  private webEnv: { [k: string]: string };
+  private webSetting: { [k: string]: string };
+  private cookies: ISimpleStorage;
+
+  constructor(webEnv: { [k: string]: string }, webSetting: { [k: string]: string }, cookies: ISimpleStorage) {
+    this.webEnv = webEnv;
+    this.webSetting = webSetting;
+    this.cookies = cookies;
+  }
+
+  public getWebEnv() {
+    return this.webEnv;
+  }
+
+  public getWebSetting() {
+    return this.webSetting;
+  }
+
+  public getServerCookie() {
+    return this.cookies;
+  }
+}

package/src/app/app-cache.ts

@@ -0,0 +1,55 @@
+/**
+ * A simple settings/config class for storing key/value pairs in memory
+ */
+
+import { AppCacheGlobal, AppCacheKeys, IAppCache } from '../models/app-cache-props';
+// For cross clusters sharing, use AppSharedStorage
+// ApiCache doesn't share cross clusters
+// Since apis and app are independent, so AppCache in apis and app are different instances.
+// That's why replaceInstance is used to copy data from app to apis,
+// and also AppCache is not shared cross app and apis, so `set` is only supposed to be called when app starts
+export class AppCache implements IAppCache {
+  private static instance: AppCache;
+
+  cacheMap: { [key: string]: any } = {};
+
+  private constructor() {}
+
+  public static getInstance(): AppCache {
+    if (!AppCache.instance) {
+      AppCache.instance = new AppCache();
+    }
+    return AppCache.instance;
+  }
+
+  clear(appName: string | undefined) {
+    const preKey = appName + '.';
+    Object.keys(this.cacheMap).forEach((key) => {
+      if (!appName || key.startsWith(preKey)) {
+        delete this.cacheMap[key];
+      }
+    });
+  }
+
+  get(appName: string, key: string) {
+    return this.cacheMap[`${appName}.${key}`];
+  }
+
+  set(appName: string, key: string, value: any) {
+    if (typeof value === 'undefined') {
+      delete this.cacheMap[`${appName}.${key}`];
+    } else {
+      this.cacheMap[`${appName}.${key}`] = value;
+    }
+  }
+
+  clearTemplateCache() {
+    const appList = this.get(AppCacheGlobal, AppCacheKeys.APP_LIST) as string[];
+    appList.forEach((appName) => {
+      this.set(appName, AppCacheKeys.TEMPLATE, undefined);
+    });
+  }
+}
+
+// this can be used in app, but in api, it should use getAppCache()
+export const appCache = /* @__PURE__ */ AppCache.getInstance();