@social-mail/social-mail-web-server 1.7.232 → 1.7.233

package/src/server/services/message-events/PgEvents.ts

@@ -0,0 +1,153 @@
+/* eslint-disable no-console */
+import Inject, { RegisterSingleton } from "@entity-access/entity-access/dist/di/di.js";
+import pg from "pg";
+import sleep from "../../../common/sleep.js";
+import { globalEnv } from "../../../common/globalEnv.js";
+import LockFile from "../../storage/LockFile.js";
+
+export type messageTypes = string;
+
+@RegisterSingleton
+export default class PgEvents {
+
+
+    private _client: Promise<pg.Client>;
+    private _running: Promise<any>;
+
+    private handlers: Map<string,{ original: messageTypes, listening: boolean, handler: (message: messageTypes, payload) => any}[]> = new Map();
+    private added: string[] = [];
+    private removed: string[] = [];
+
+    private get client() {
+        return this._client ??= (async () => {
+            try {
+                const c = new pg.Client(globalEnv.pgEvents);
+                await c.connect();
+                c.on("error", () => {
+                    try {
+                        c.end().catch(console.error);
+                    } catch (error) {
+                        console.error(error);
+                    }
+                    this._client = null;
+                });
+                c.on("end", () => this._client = null);
+                c.on("notification", async ({ channel, payload}) => {
+                    try {
+                        console.log(`Notification received ${channel}`);
+                        const fx = this.handlers.get(channel);
+                        if (fx) {
+                            for (const { original, handler } of fx) {
+                                try {
+                                    const p = handler(original as any, JSON.parse(payload));
+                                    if (p?.then) {
+                                        p.catch(console.error);
+                                    }
+                                } catch (e) {
+                                    console.error(e);
+                                }
+                            }
+                        }
+                    } catch (error) {
+                        console.error(error);
+                    }
+                });
+                return c;
+            } catch (error) {
+                console.error(error);
+            }
+        })();
+    }
+
+    async emit(message: messageTypes, payload) {
+        /**
+         * Improve sending messages by queueing
+         */
+        try {
+            let lastError = null;
+            for(let i=0;i<10;i++) {
+
+                // locking queue messages
+                using fx = await LockFile.lock(`pg-events-msg${message}`);
+
+                const id = "social_" + message.replace(/[^a-zA-Z0-9]/g, "_");
+                const c = new pg.Client(globalEnv.pgEvents);
+                try {
+                    await c.connect();
+                    await c.query("select pg_notify($1,$2)", [ id, JSON.stringify(payload || null)]);
+                    break;
+                } catch (e) {
+                    lastError = e;
+                    continue;
+                } finally {
+                    await c.end();
+                }
+            }
+            if (lastError) {
+                console.error(lastError);
+            }
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    async listen(message: messageTypes, fx: (msg: messageTypes, payload: any) => any): Promise<AsyncDisposable> {
+
+        const id = "social_" + message.replace(/[^a-zA-Z0-9]/g, "_");
+        let handlers = this.handlers.get(id);
+        if(!handlers) {
+            handlers = [];
+            this.handlers.set(id, handlers);
+        }
+        handlers.push({ original: message, listening: false, handler: fx });
+        // client.query(`LISTEN ${id}`).catch(console.error);
+        console.log(`Listening for ${message} as ${id} on pg`);
+        this.added.push(id);
+        this.update().catch(console.error);
+        return {
+            [Symbol.asyncDispose]: async () => {
+                try {
+                    this.handlers.delete(id);
+                    this.removed.push(id);
+                    this.update().catch(console.error);
+                } catch (error) {
+                    console.warn(error);
+                }
+            }
+        };
+    }
+
+    private update() {
+        return this._running ??= (async () => {
+            while(this.handlers.size) {
+               try {
+                    const c = await this.client;
+                    if (!c) {
+                        await sleep(3000);
+                        continue;
+                    }
+                    if (this.added.length) {
+                        const added = [... this.added];
+                        this.added.length = 0;
+                        for (const iterator of added) {
+                            await c.query(`LISTEN ${iterator};`);
+                        }
+                    }
+                    if (this.removed.length) {
+                        const removed = [... this.removed];
+                        this.removed.length = 0;
+                        for (const iterator of removed) {
+                            await c.query(`UNLISTEN ${iterator};`);
+                        }
+                    }
+                    await c.query("select 1;");
+                } catch (error) {
+                    console.error(error);
+                }
+                await sleep(30000);
+            }
+            this._running = null;
+        })();
+    }
+
+}

package/src/server/smtp/services/WebSiteChannelService.ts

@@ -1,32 +1,13 @@
 
 import Inject, { RegisterScoped, RegisterSingleton, RegisterTransient, ServiceCollection, ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
 import SocialMailContext from "../../model/SocialMailContext.js";
-import GlobalEvents from "../../../common/GlobalEvents.js";
 import { cacheFor, ICacheContainer, ObjectCache } from "../../../common/cacheFor.js";
+import MessagingService from "../../services/message-events/MessagingService.js";
 
 export default class WebSiteChannelService implements ICacheContainer<WebSiteChannelService> {
 
     cache: ObjectCache<WebSiteChannelService>;
 
-    @Inject
-    globalEvents: GlobalEvents;
-
-    // @cacheFor()
-    // async getMailboxes(host: string) {
-    //     using scope = ServiceProvider.createScope(this);
-    //     const db = scope.resolve(SocialMailContext);
-
-    //     host = host?.toLocaleLowerCase() ?? "localhost";
-
-    //     const mailboxes = await db.mailboxes.where({ host}, (p) => (x) =>
-    //             x.websiteChannels
-    //                 .some((w) => w.website.hosts
-    //                     .some((h)=> h.host === p.host)))
-    //         .toArray();
-
-    //     return mailboxes.map((x) => x.mailboxID);
-    // }
-
     @cacheFor()
     async getChannelAssociations(host: string) {
         using scope = ServiceProvider.createScope(this);
@@ -57,11 +38,13 @@ export default class WebSiteChannelService implements ICacheContainer<WebSiteCha
     }
 
     clear() {
-        this.globalEvents.notify("web-site-channel-host-clear" as any, {} as any);
+        const ms = ServiceProvider.resolve(this, MessagingService).channelRefresh;
+        ms.notify("clear");
     }
 
     protected postInit() {
-        this.globalEvents.on("web-site-channel-host-clear" as any, () => this.cache?.clear("getChannelAssociations") );
+        const ms = ServiceProvider.resolve(this, MessagingService).channelRefresh;
+        ms.on(() => this.cache?.clear("getChannelAssociations") );
     }
 
 }

package/src/server/workflows/dns/SyncDnsZoneRecordsWorkflow.ts

@@ -6,8 +6,8 @@ import SocialMailContext from "../../model/SocialMailContext.js";
 import EmailAddressService from "../../services/EmailAddressService.js";
 import Sql from "@entity-access/entity-access/dist/sql/Sql.js";
 import { globalEnv } from "../../../common/globalEnv.js";
-import GlobalEvents from "../../../common/GlobalEvents.js";
 import StringFormat from "../../../common/StringFormat.js";
+import MessagingService from "../../services/message-events/MessagingService.js";
 
 const toUnixDateAndHour = (date: Date | DateTime, d = DateTime.from(date)) =>
     `${StringFormat.fixed(d.year, 4)}${StringFormat.fixed(d.month)}${StringFormat.fixed(d.day)}${StringFormat.fixed(d.hour)}`;
@@ -35,11 +35,11 @@ export default class SyncDnsZoneRecordsWorkflow extends Workflow {
     @UniqueActivity
     async notifyDns(
         @Inject db?: SocialMailContext,
-        @Inject ge?: GlobalEvents
+        @Inject ms?: MessagingService
     ) {
         const zoneID = this.input;
         await db.hostedZones.statements.update({ dateSigned: null, dateUpdated: DateTime.now }, { zoneID });
-        ge.notify("refresh-dns", { serverID:  globalEnv.serverID });
+        ms.refreshDns.notify({ serverID:  globalEnv.serverID });
     }
 
     @UniqueActivity