@social-mail/social-mail-web-server 1.7.261 → 1.7.263

package/package.json

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

package/src/server/model/entities/DomainReputation.ts

@@ -0,0 +1,15 @@
+import Column from "@entity-access/entity-access/dist/decorators/Column.js";
+import Table from "@entity-access/entity-access/dist/decorators/Table.js";
+
+@Table("DomainReputations")
+export default class DomainReputation {
+
+    @Column({ dataType: "Char", length: 400, key: true })
+    public name: string;
+
+    @Column({ dataType: "Int", default: () => 0})
+    public received: number;
+
+    @Column({ dataType: "Int", default: () => 0})
+    public failed: number;
+}

package/src/server/seed/ui/seed-ui.ts

@@ -3,7 +3,7 @@ import semver from "semver";
 
 export default async function seedUI(config: DBConfig) {
 
-    const version = "1.4.175";
+    const version = "1.4.176";
 
     const existing = await config.getValue(UIPackageConfig, false);
     if (existing) {

package/src/server/services/EmailAddressService.ts

@@ -116,6 +116,16 @@ export default class EmailAddressService implements ICacheContainer<EmailAddress
             .first();
     }
 
+    @cacheFor()
+    public async getHostedMailboxByAddress(address: string) {
+        address = address.trim().toLowerCase();
+        using scope = globalServices.createScope();
+        const db = scope.resolve(SocialMailContext);
+        return await db.mailboxes.where({ address }, (p) => (x) => x.emailAddress.emailAddress === p.address)
+            .include((x) => x.emailAddress)
+            .first();
+    }
+
     @cacheFor()
     public async isHostedChannelID(emailAddressID) {
         using scope = globalServices.createScope();

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

@@ -17,6 +17,8 @@ export default class MessagingService extends ServiceObject {
 
     refreshDns: IMessageChannel<{ serverID }>;
 
+    reputationCleared: IMessageChannel;
+
     @Inject
     private pgEvents: PgEvents;
 
@@ -24,6 +26,7 @@ export default class MessagingService extends ServiceObject {
         this.channelRefresh = this.segment(`web-site-channel-host-clear-${globalEnv.serverID}`);
         this.refreshDns = this.segment("refresh-dns");
         this.snapshotRefresh = this.segment(`snapshot-refresh-${globalEnv.serverID}`);
+        this.reputationCleared = this.segment(`reputation-cleared-${globalEnv.serverID}`);
     }
 
     notify(messageName: string, data: any): any {

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

@@ -17,21 +17,27 @@ export default class ChannelService {
     @Inject
     private db: SocialMailContext;
 
-    async getAccess(senderID: number, channel: Mailbox) {
+    async getAccess({ senderID, senderAddress, recipientChannel }: { senderAddress?: string, senderID?: number, recipientChannel: Mailbox }) {
 
-        if (!channel.isPrivateChannel && !channel.requiresMembershipApproval) {
+        if (!recipientChannel.isPrivateChannel && !recipientChannel.requiresMembershipApproval) {
             // we should accept everything...
-            return { channel };
+            return { channel: recipientChannel };
         }
 
-        const { mailboxID } = channel;
+        const { mailboxID } = recipientChannel;
+
+        let q = this.db.mailboxContacts.where({ mailboxID }, (p) => (x) => x.mailboxID === p.mailboxID);
+
+        q = senderAddress
+            ? q.where({ senderAddress}, (p) => (x) =>  x.emailAddress.emailAddress === p.senderAddress)
+            : q.where({ senderID}, (p) => (x) => x.emailAddressID === p.senderID);
 
         const mailboxContact = await this.db.mailboxContacts
             .where({ senderID, mailboxID}, (p) => (x) => x.mailboxID === p.mailboxID
                 && x.emailAddressID === p.senderID)
             .first();
 
-        if (channel.isPrivateChannel) {
+        if (recipientChannel.isPrivateChannel) {
             if (!mailboxContact) {
                 throw new SmtpError("Only active members of channel can send message to channel", SmtpStatusCodes.DeliveryNotPermitted);
             }
@@ -40,7 +46,7 @@ export default class ChannelService {
         if (mailboxContact?.blocked) {
             throw new SmtpError("Only active members of channel can send message to channel", SmtpStatusCodes.DeliveryNotPermitted);
         }
-        return { channel, mailboxContact };
+        return { channel: recipientChannel, mailboxContact };
     }
 
     async subscribe(mailboxID: number, emailAddressID: number) {
@@ -73,7 +79,7 @@ export default class ChannelService {
         const { senderID } = entity.email;
         const channel = await this.db.mailboxes.where({ emailAddressID },(p) => (x) => x.mailboxID === p.emailAddressID)
             .first();
-        const { mailboxContact } = await this.getAccess(senderID, channel );
+        const { mailboxContact } = await this.getAccess({ senderID, recipientChannel: channel } );
         const isActiveSubscriber = mailboxContact && (mailboxContact.isOwner || mailboxContact.canContribute || mailboxContact.status === "active");
 
         if(isActiveSubscriber) {

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

@@ -0,0 +1,44 @@
+import Inject, { RegisterSingleton, ServiceObject, ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
+import { cacheFor, ICacheContainer, ObjectCache } from "../../../common/cacheFor.js";
+import { SmtpStatusCodes } from "../client/SmtpStatusCodes.js";
+import SmtpError from "./SmtpError.js";
+import SocialMailContext from "../../model/SocialMailContext.js";
+import MessagingService from "../../services/message-events/MessagingService.js";
+
+@RegisterSingleton
+export default class DomainReputationService
+    extends ServiceObject
+    implements ICacheContainer<DomainReputationService> {
+
+    cache: ObjectCache<DomainReputationService>;
+
+    @Inject
+    ms: MessagingService;
+
+    @cacheFor()
+    async checkReputation(domainName: string) {
+        using scope = ServiceProvider.createScope(this);
+        const db = scope.resolve(SocialMailContext);
+
+        domainName = domainName.trim().toLowerCase();
+
+        const reputation = await db.domains.where({ domainName }, (p) => (x) => x.name === p.domainName)
+            .first();
+
+        if (!reputation) {
+            return;
+        }
+
+        const { failed } = reputation;
+
+        if (failed > 3) {
+            if (failed > (reputation.received / 10)) {
+                throw new SmtpError("Sender Blocked for 24 Hours", SmtpStatusCodes.SenderBlocked);
+            }
+        }
+    }
+
+    postInit() {
+        this.ms.reputationCleared.on(() => this.cache?.clear("checkReputation"));
+    }
+}

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

@@ -25,6 +25,8 @@ import { serverActivities } from "../../model/entities/ServerActivity.js";
 import AccessTokenService from "./AccessTokenService.js";
 import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
 import TagService from "../../services/tags/TagService.js";
+import DomainReputationService from "./DomainReputationService.js";
+import MessagingService from "../../services/message-events/MessagingService.js";
 
 const stripBrackets = (text: string) => {
     if (!text) {
@@ -97,11 +99,19 @@ export default class MailReceiverService {
     @Inject
     private tagService: TagService;
 
+    @Inject
+    private domainReputation: DomainReputationService;
+
+    @Inject
+    private ms: MessagingService;
+
     private session: smtpServer.SMTPServerSession;
 
     private from: smtpServer.SMTPServerAddress;
 
-    private sender: EmailAddress;
+    private fromDomain: string;
+
+    // private sender: EmailAddress;
 
     private recipients: Map<string, Mailbox>;
 
@@ -129,20 +139,11 @@ export default class MailReceiverService {
 
         this.from = address;
 
-        const sender = this.sender = await this.emailAddressService.getEmailAddressFrom(address.address);
-        const { mailbox, domainID } = sender;
+        const domain = this.fromDomain = this.from.address.split("@",2).pop();
 
-        const reputation = await this.db.domains.where({ domainID }, (p) => (x) => x.domainID === p.domainID)
-            .first();
-
-        const { failed } = reputation;
-
-        if (failed > 3) {
-            if (failed > (reputation.received / 10)) {
-                throw new SmtpError("Sender Blocked for 24 Hours", SmtpStatusCodes.SenderBlocked);
-            }
-        }
+        await this.domainReputation.checkReputation(domain);
 
+        const mailbox = await this.emailAddressService.getHostedMailboxByAddress(address.address);
         if (mailbox && !mailbox.isExternal) {
             if (!this.session.user) {
                 console.error(`Login required for ${address.address}`);
@@ -159,13 +160,11 @@ export default class MailReceiverService {
             throw new SmtpError("Unknown sequence of commands", SmtpStatusCodes.BadCommandSequence);
         }
 
-        const domainID = this.sender.domainID;
-
         const mailbox = await this.db.mailboxes
             .where(address, (p) => (x) => x.emailAddress.emailAddress === p.address)
             .first();
         if (mailbox == null) {
-            await this.addDomainActivity(domainID, "rcpt-not-found");
+            await this.addDomainActivity("rcpt-not-found");
 
             // update domain reputation
             throw new SmtpError(`Mailbox ${address.address} not found`, SmtpStatusCodes.MailboxUnavailable);
@@ -174,7 +173,7 @@ export default class MailReceiverService {
             throw new SmtpError("Mailbox full", SmtpStatusCodes.InsufficientStorage);
         }
 
-        await this.addDomainActivity(domainID, "mail-received");
+        await this.addDomainActivity("mail-received");
 
         // check if email is blocked...
         const mailboxID = mailbox.mailboxID;
@@ -200,26 +199,41 @@ export default class MailReceiverService {
 
         if (mailbox.isChannel) {
             const channelService = ServiceProvider.resolve(this, ChannelService);
-            await channelService.getAccess(this.sender.emailAddressID, mailbox);
+            await channelService.getAccess({
+                senderAddress: address.address,
+                recipientChannel: mailbox
+            });
         }
 
         this.recipients.set(address.address, mailbox);
     }
 
-    async addDomainActivity(domainID: number, activity: serverActivities) {
+    async addDomainActivity(activity: serverActivities) {
         const ipAddress = this.session.remoteAddress;
+
+        const domainID = await this.emailAddressService.getOrCreateDomain(this.fromDomain);
+
         await this.db.serverActivities.statements.insert({
             domainID,
             activity,
             ipAddress
         });
 
-        await this.db.domains
+        const [d] = await this.db.domains
             .where({ domainID }, (p) => (x) => x.domainID === p.domainID)
-            .update(void 0, (p) => (x) => ({
+            .updateSelect(void 0, (p) => (x) => ({
                 received: Sql.coll.sum(x.activities.map((a) => a.activity === "mail-received" ? 1 : 0)),
                 failed: Sql.coll.sum(x.activities.map((a) => a.activity === "rcpt-not-found" ? 1 : 0)),
             }));
+
+        if (activity === "rcpt-not-found") {
+            if (d?.failed > 3) {
+                if (d.failed > (d.received / 10)) {
+                    // clear on reputation change
+                    this.ms.reputationCleared.notify("");
+                }
+            }
+        }
     }
 
     async acceptData(stream: smtpServer.SMTPServerDataStream): Promise<void> {

package/src/server/workflows/daily/DailyWorkflow.ts

@@ -11,6 +11,7 @@ import IndexAppFilesWorkflow from "../search/IndexAppFilesWorkflow.js";
 import DbLockService from "../../services/db-lock/DbLockService.js";
 import PendingPostReceiveWorkflow from "../pending/PendingPostReceiveWorkflow.js";
 import PendingReferencesWorkflow from "../pending/PendingReferencesWorkflow.js";
+import MessagingService from "../../services/message-events/MessagingService.js";
 
 export default class DailyWorkflow extends Workflow<any,any> {
 
@@ -42,7 +43,8 @@ export default class DailyWorkflow extends Workflow<any,any> {
     async startSync(
         index: number,
         @Inject db?: SocialMailContext,
-        @Inject lockService?: DbLockService
+        @Inject lockService?: DbLockService,
+        @Inject ms?: MessagingService
     ) {
         // fetch all sync items...
         db.verifyFilters = false;
@@ -77,6 +79,8 @@ export default class DailyWorkflow extends Workflow<any,any> {
             .limit(1000)
             .delete(void 0, (p) => (x) => x.activityID !== null);
 
+        await ms.reputationCleared.notify("Reputation cleared");
+
         // deactivate all expired sessions...
         await db.loginSessions
             .where(void 0, (p) => (x) => x.expiry <= (Sql.date.now()))