@social-mail/social-mail-web-server 1.7.310 → 1.7.311

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@social-mail/social-mail-web-server",
-  "version": "1.7.310",
+  "version": "1.7.311",
   "description": "## Phase 1",
   "main": "index.js",
   "type": "module",

package/src/common/cacheFor.ts

@@ -19,7 +19,14 @@ export class ObjectCache<T> {
         return tc;
     }
 
-    clear(name: keyof T) {
+    clear(name?: keyof T) {
+        if (!name) {
+            for (const element of this.cache.values()) {
+                element.clear();
+            }
+            this.cache.clear();
+            return;
+        }
         this.cache.get(name)?.clear();
     }
 };

package/src/server/services/files/SiteDiskContentCache.ts

@@ -4,7 +4,7 @@ import { join } from "path";
 import BaseDiskCache from "../../../common/BaseDiskCache.js";
 import { globalEnv } from "../../../common/globalEnv.js";
 import MessagingService from "../message-events/MessagingService.js";
-import { readdir } from "fs/promises";
+import { ObjectCache } from "../../../common/cacheFor.js";
 
 @RegisterSingleton
 export default class SiteDiskContentCache extends ServiceObject {
@@ -12,26 +12,16 @@ export default class SiteDiskContentCache extends ServiceObject {
     @Inject
     ms: MessagingService;
 
-    htmlFileCache = new BaseDiskCache({
-        root: join(globalEnv.tmpDir, "site-cache", "html-files"),
+    cache: ObjectCache<any> = new ObjectCache();
+
+    htmlCache = new BaseDiskCache({
+        root: join(globalEnv.tmpDir, "site-html-cache", "html"),
         keepTTLSeconds: 24*60*60
     });
 
     postInit() {
         this.ms.snapshotRefresh.on(({ folderID }) => {
-
-
-            if (folderID === 0) {
-                // we need to refresh everything...
-                this.htmlFileCache.clear().catch(console.error);
-                return;
-
-            }
-
-            // at zero all host to snapshot map will be stored
-            this.htmlFileCache.clearFolder("0").catch(console.error);
-            this.htmlFileCache.clearFolder(folderID.toString()).catch(console.error);
-
+            this.cache.clear();
         });
     }
 

package/src/server/services/files/WebSiteContentService.ts

@@ -12,15 +12,20 @@ import TempFileService from "../../storage/TempFileService.js";
 import MessagingService from "../message-events/MessagingService.js";
 import SiteDiskContentCache from "./SiteDiskContentCache.js";
 import SocialMailContext from "../../model/SocialMailContext.js";
+import { cacheFor, ICacheContainer, ObjectCache } from "../../../common/cacheFor.js";
 
 @RegisterScoped
-export default class WebSiteContentService {
+export default class WebSiteContentService
+    extends ServiceObject
+    implements ICacheContainer<WebSiteContentService> {
 
     @Inject
     dbConfig: DBConfig;
 
     @Inject
-    cache: SiteDiskContentCache;
+    siteCache: SiteDiskContentCache;
+
+    cache: ObjectCache<WebSiteContentService>;
 
     @Inject
     tfs: TempFileService;
@@ -28,32 +33,34 @@ export default class WebSiteContentService {
     @Inject
     db: SocialMailContext;
 
+    postInit() {
+        this.cache = this.siteCache.cache;
+    }
+
+    @cacheFor()
     async getCurrentSnapshotFolder(host) {
-        return this.cache.htmlFileCache.getOrCreateJsonAsync<{ snapshotFolderID }>(`0/snapshot/${host}`, async () => {
-            const file = await this.db.appFiles
-                .where({ host }, (p) =>
-                    (x) => x.currentVersionWebSites
-                        .some((w) => w.hosts
-                            .some((h) => h.host === p.host)))
-                .first();
-            if (!file) {
-                return null;
-            }
-            const { appFileID } = file;
-            return { snapshotFolderID: appFileID };
-        });
+        const file = await this.db.appFiles
+            .where({ host }, (p) =>
+                (x) => x.currentVersionWebSites
+                    .some((w) => w.hosts
+                        .some((h) => h.host === p.host)))
+            .first();
+        if (!file) {
+            return null;
+        }
+        const { appFileID } = file;
+        return { snapshotFolderID: appFileID };
     }
 
+    @cacheFor()
     async getWebSite(host) {
-        return this.cache.htmlFileCache.getOrCreateJsonAsync(`0/${host}`, async () => {
-            const folder = await this.db.websiteFolders.where({ host }, (p) => (x) => x.hosts.some((s) => s.host === p.host))
-                .first();
-            if (!folder) {
-                return null;
-            }
-            const { folderID, currency, fromEmail, supportEmail } = folder;
-            return { folderID, currency, fromEmail, supportEmail };
-        });
+        const folder = await this.db.websiteFolders.where({ host }, (p) => (x) => x.hosts.some((s) => s.host === p.host))
+            .first();
+        if (!folder) {
+            return null;
+        }
+        const { folderID, currency, fromEmail, supportEmail } = folder;
+        return { folderID, currency, fromEmail, supportEmail };
     }
 
     async getFile(folderID, ... path: string[]) {
@@ -64,22 +71,21 @@ export default class WebSiteContentService {
         return this.tfs.downloadFileContent(fileInfo.fileContentID, fileInfo);
     }
 
+    @cacheFor()
     async getFileInfo(folderID, ... path: string[]): Promise<{ name, contentType, appFileID, url, fileContentID }> {
-        return await this.cache.htmlFileCache.getOrCreateJsonAsync<{ name, contentType, appFileID, url, fileContentID }>(join(folderID, ... path), async () => {
-            const [top, ... paths] = path;
-            const child = await this.db.appFiles
-                .where({ folderID, top },(p) => (x) => x.parentID === p.folderID && x.name === p.top)
-                .orderBy(void 0, (p) => (x) => x.isDeleted)
-                .include((x) => x.fileContent)
-                .first();
-            if (!child) {
-                return null;
-            }
-            if (paths.length === 0) {
-                return { name: child.name, contentType: child.contentType, appFileID: child.appFileID, url: child.url, fileContentID: child.fileContentID };
-            }
-            return await this.getFileInfo(child.appFileID, ... paths);
-        });
+        const [top, ... paths] = path;
+        const child = await this.db.appFiles
+            .where({ folderID, top },(p) => (x) => x.parentID === p.folderID && x.name === p.top)
+            .orderBy(void 0, (p) => (x) => x.isDeleted)
+            .include((x) => x.fileContent)
+            .first();
+        if (!child) {
+            return null;
+        }
+        if (paths.length === 0) {
+            return { name: child.name, contentType: child.contentType, appFileID: child.appFileID, url: child.url, fileContentID: child.fileContentID };
+        }
+        return await this.getFileInfo(child.appFileID, ... paths);
     }
 
     async getSnapshotFile({ snapshotFolderID }, path: string[]) {
@@ -105,14 +111,14 @@ export default class WebSiteContentService {
             return file;
         }
         const htmlFilePath = join(folderID.toString(), "transformed", ... path);
-        return this.cache.htmlFileCache.getOrCreateAsync(htmlFilePath, async (cf) => {
+        return this.siteCache.htmlCache.getOrCreateAsync(htmlFilePath, async (cf) => {
             await this.transformHtml(file, cf);
         });
     }
 
     async transformHtml(src: LocalFile, dest: LocalFile) {
 
-        const packageReplacements = await this.cache.htmlFileCache.getOrCreateJsonAsync("packages", async () => {
+        const packageReplacements = await this.siteCache.htmlCache.getOrCreateJsonAsync("packages", async () => {
             const config = this.dbConfig;
 
             const packages = [