@social-mail/social-mail-web-server 1.4.973 → 1.4.976

package/package.json

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

package/src/common/globalEnv.ts

@@ -24,6 +24,11 @@ export const globalEnv = {
     cdn: process.env.SOCIAL_MAIL_CDN,
     path: process.env.SOCIAL_MAIL_PATH || "/",
     externalLogin: process.env.SOCIAL_MAIL_EXTERNAL_LOGIN,
+    dns: {
+        enabled: /^(true|yes)$/i.test(process.env.SOCIAL_MAIL_DNS_ENABLED),
+        soa: process.env.SOCIAL_MAIL_DNS_SOA || "somewhere somewhere.com",
+        letsEncryptPrefix: process.env.SOCIAL_MAIL_DNS_LE_PREFIX
+    },
     altHosts: (process.env.SOCIAL_MAIL_ALT_HOSTS || "").split(","),
     wildcardDomain: process.env.SOCIAL_MAIL_WILDCARD_DOMAIN,
     name: process.env.SOCIAL_MAIL_NAME || "Social Mail",

package/src/server/model/SocialMailContext.ts

@@ -44,6 +44,7 @@ import ServerActivity from "./entities/ServerActivity.js";
 import IncomingSmsSource from "./entities/IncomingSmsSource.js";
 import VerificationToken, { VerificationTokenAddress } from "./entities/VerificationToken.js";
 import MailboxFolder from "./entities/MailboxFolder.js";
+import HostedZone, { HostedZoneRecord, HostedZoneUser } from "./entities/HostedZone.js";
 
 @RegisterScoped
 export default class SocialMailContext extends EntityContext {
@@ -84,6 +85,12 @@ export default class SocialMailContext extends EntityContext {
 
     public hostedDomainUsers = this.model.register(DomainUser);
 
+    public hostedZones = this.model.register(HostedZone);
+
+    public hostedZoneRecords = this.model.register(HostedZoneRecord);
+
+    public hostedZoneUsers = this.model.register(HostedZoneUser);
+
     public domainRelays = this.model.register(DomainRelay);
 
     public domainKeys = this.model.register(DomainKey);

package/src/server/model/SocialMailContextEvents.ts

@@ -95,6 +95,8 @@ import VerificationToken from "./entities/VerificationToken.js";
 import VerificationTokenEvents from "./events/VerificationTokenEvents.js";
 import StoreTagEvents from "./events/StoreTagEvents.js";
 import StoreItemFolderTagEvents from "./events/StoreItemFolderTagEvents.js";
+import HostedZone, { HostedZoneRecord, HostedZoneUser } from "./entities/HostedZone.js";
+import HostedZoneEvents, { HostedZoneRecordEvents, HostedZoneUserEvents } from "./events/HostedZoneEvents.js";
 
 @RegisterSingleton
 export default class SocialMailContextEvents extends ContextEvents {
@@ -120,6 +122,9 @@ export default class SocialMailContextEvents extends ContextEvents {
         this.register(HostedDomain, HostedDomainEvents);
         this.register(DomainUser, DomainUserEvents);
         this.register(DomainKey, DomainKeyEvents);
+        this.register(HostedZone, HostedZoneEvents);
+        this.register(HostedZoneRecord, HostedZoneRecordEvents);
+        this.register(HostedZoneUser, HostedZoneUserEvents);
         this.register(Email, EmailEvents);
         this.register(EmailAddress, EmailAddressEvents);
         this.register(EmailEngagement, EmailEngagementEvents);

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

@@ -6,6 +6,7 @@ import type EmailAddress from "./EmailAddress.js";
 import { ContactDomain } from "./Contact.js";
 import type ServerActivity from "./ServerActivity.js";
 import type Mailbox from "./Mailbox.js";
+import type HostedZone from "./HostedZone.js";
 
 @Table("Domains")
 @Index({
@@ -34,4 +35,5 @@ export default class Domain {
     public contactDomains: ContactDomain[];
     activities: ServerActivity[];
     mailboxes: Mailbox[];
+    hostedZone: HostedZone;
 }

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

@@ -0,0 +1,115 @@
+import Column from "@entity-access/entity-access/dist/decorators/Column.js";
+import { RelateTo, RelateToOne } from "@entity-access/entity-access/dist/decorators/Relate.js";
+import Table from "@entity-access/entity-access/dist/decorators/Table.js";
+import Domain from "./Domain.js";
+import { EnumColumn } from "../../../common/columns.js";
+import Index from "@entity-access/entity-access/dist/decorators/Index.js";
+import { JsonProperty, ReadOnlyJsonProperty } from "@entity-access/server-pages/dist/services/ModelService.js";
+import Sql from "@entity-access/entity-access/dist/sql/Sql.js";
+import DateTime from "@entity-access/entity-access/dist/types/DateTime.js";
+import { User } from "./User.js";
+
+const { labels, column: TypeColumn} = EnumColumn(["A", "AAAA", "CNAME", "MX", "TXT", "PTR", "SRV", "CAA", "NS", "SOA" ] as const, 15, { default: () => "A"});
+
+
+@Table("HostedZones")
+export default class HostedZone {
+
+    @Column({ dataType: "BigInt", key: true })
+    @RelateToOne(Domain, {
+        property: (x) => x.domain,
+        inverseProperty: (x) => x.hostedZone
+    })
+    zoneID: number;
+
+    domain: Domain;
+    records: HostedZoneRecord[];
+    users: HostedZoneUser[];
+
+}
+
+@Table("HostedZoneUsers")
+export class HostedZoneUser {
+    @Column({ dataType: "BigInt", key: true })
+    @RelateTo(HostedZone, {
+        property: (x) => x.zone,
+        inverseProperty: (x) => x.users
+    })
+    zoneID: number;
+
+    @Column({ dataType: "BigInt", key: true })
+    @RelateTo(User, {
+        property: (x) => x.user,
+        inverseProperty: (x) => x.hostedZones
+    })
+    userID: number;
+
+    zone: HostedZone;
+    user: User;
+}
+
+
+@Table("HostedZoneRecords")
+@Index({
+    name: "IX_HostedZoneRecords_FQDN",
+    columns: [
+        { name: (x) => x.fqdn, descending: false }
+    ],
+    filter: (x) => x.fqdn !== null
+})
+export class HostedZoneRecord {
+
+    @Column({ dataType: "BigInt", key: true, generated: "identity"})
+    public recordID: number;
+
+    @Column({ dataType: "BigInt"})
+    @RelateTo(HostedZone, {
+        property: (x) => x.zone,
+        inverseProperty: (x) => x.records
+    })
+    public zoneID: number;
+
+    @Column({ dataType: "Boolean", default: () => false})
+    public disabled: boolean;
+
+    @Column({ dataType: "Boolean", default: () => false})
+    public readonly: boolean;
+
+    @Column({ dataType: "Char", length: 200})
+    public name: string;
+
+    @TypeColumn
+    @JsonProperty({ enum: labels })
+    public type: typeof labels[number];
+
+    @Column({ dataType: "Boolean", default: () => false })
+    public isAlias: boolean;
+
+    @Column({ dataType: "Char"})
+    public value: string;
+
+    @Column({ dataType: "Int"})
+    public ttl: number;
+
+    @Column({ default: () => Sql.date.now() })
+    public dateCreated: DateTime;
+
+    @Column({ default: () => Sql.date.now() })
+    public dateUpdated: DateTime;
+
+    @Column({ dataType: "Char", nullable: true})
+    public notes: string;
+
+    @Column({ nullable: true })
+    public expiryDate: DateTime;
+
+    @Column({ dataType: "Boolean", default: () => false})
+    public hosted: boolean;
+
+    @Column({ nullable: true})
+    @ReadOnlyJsonProperty
+    public fqdn: string;
+
+    public zone: HostedZone;
+
+}

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

@@ -18,6 +18,7 @@ import type UserPushSubscription from "./UserSubscriptions.js";
 import type { StoreUser } from "./Store.js";
 import type AccessToken from "./AccessToken.js";
 import { RelateTo } from "@entity-access/entity-access/dist/decorators/Relate.js";
+import type { HostedZoneUser } from "./HostedZone.js";
 
 export class ChangePassword {
 
@@ -147,6 +148,7 @@ export class User {
     // storeOrders: StoreBill[];
     stores: StoreUser[];
     closedEmails: Email[];
+    hostedZones: HostedZoneUser[];
 
     // [GraphService.toGraph]() {
     //     return {

package/src/server/model/events/HostedZoneEvents.ts

@@ -0,0 +1,164 @@
+import { IEntityQuery } from "@entity-access/entity-access/dist/model/IFilterWithParameter.js";
+import HostedZone, { HostedZoneRecord, HostedZoneUser } from "../entities/HostedZone.js";
+import AuthenticatedEvents from "./AuthenticatedEvents.js";
+import ChangeEntry from "@entity-access/entity-access/dist/model/changes/ChangeEntry.js";
+import { ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
+import SocialMailContext from "../SocialMailContext.js";
+import Sql from "@entity-access/entity-access/dist/sql/Sql.js";
+import DateTime from "@entity-access/entity-access/dist/types/DateTime.js";
+import { globalEnv } from "../../../common/globalEnv.js";
+
+export default class HostedZoneEvents extends AuthenticatedEvents<HostedZone> {
+
+    filter(query: IEntityQuery<HostedZone>) {
+        if (this.verify) {
+            this.sessionUser.ensureLoggedIn();
+        }
+        if (this.sessionUser.isAdmin) {
+            return query;
+        }
+        return query.where(this.sessionUser, (p) => (x) => x.users.some((u) => u.userID === p.userID));
+    }
+
+    async afterInsert(entity: HostedZone, entry: ChangeEntry<HostedZone>) {
+
+
+        await entry.loadNavigationAsync((x) => x.domain);
+
+        const { zoneID, domain: { name: domain } } = entity;
+
+        const dateCreated = DateTime.now;
+        const dateUpdated = dateCreated;
+
+        // add some default records...
+        const db = ServiceProvider.resolve(this, SocialMailContext);
+
+        const ttl = 8600;
+
+        await db.hostedZoneRecords.statements.insert({
+            zoneID,
+            dateCreated,
+            dateUpdated,
+            ttl,
+            name: "@",
+            type: "SOA",
+            value: globalEnv.dns.soa,
+            readonly: true,
+        });
+
+        await db.hostedZoneRecords.statements.insert({
+            zoneID,
+            dateCreated,
+            dateUpdated,
+            ttl,
+            name: "_acme-challenge",
+            type: "CNAME",
+            value: `${domain}.${globalEnv.dns.letsEncryptPrefix}`,
+            readonly: true,
+        });
+
+        await db.hostedZoneRecords.statements.insert({
+            zoneID,
+            dateCreated,
+            dateUpdated,
+            ttl,
+            name: "_dmarc",
+            type: "TXT",
+            value: `v=DMARC1; p=reject; rua=mailto:no-reply@${domain};`,
+            readonly: true,
+        });
+
+        await db.hostedZoneRecords.statements.insert({
+            zoneID,
+            dateCreated,
+            dateUpdated,
+            ttl,
+            type: "A",
+            name: "@",
+            value: "$IP$",
+            fqdn: `${domain}`,
+            readonly: true
+        });
+
+        await db.hostedZoneRecords.statements.insert({
+            zoneID,
+            dateCreated,
+            dateUpdated,
+            ttl,
+            type: "CNAME",
+            name: "www",
+            value: "$HOST$",
+            fqdn: `www.${domain}`,
+            readonly: true
+        });
+
+        await db.hostedZoneRecords.statements.insert({
+            zoneID,
+            dateCreated,
+            dateUpdated,
+            ttl,
+            type: "CNAME",
+            name: "*",
+            value: "$HOST$",
+            fqdn: `*.${domain}`,
+            readonly: true
+        });
+
+    }
+
+}
+
+export class HostedZoneRecordEvents extends AuthenticatedEvents<HostedZoneRecord> {
+
+    filter(query: IEntityQuery<HostedZoneRecord>) {
+        if (this.verify) {
+            this.sessionUser.ensureLoggedIn();
+        }
+        if (this.sessionUser.isAdmin) {
+            return query;
+        }
+        return query.where(this.sessionUser, (p) => (x) => x.zone.users.some((u) => u.userID === p.userID));
+    }
+
+    modify(query: IEntityQuery<HostedZoneRecord>) {
+        if (this.sessionUser.isAdmin) {
+            return query;
+        }
+        return query.where(void 0, (p) => (x) => x.readonly === false);
+    }
+
+    async afterInsert(entity: HostedZoneRecord, entry: ChangeEntry<HostedZoneRecord>) {
+        const db = ServiceProvider.resolve(this, SocialMailContext);
+        const prefix = (!entity.name || entity.name === "@") ? "" : entity.name + ".";
+        await db.hostedZoneRecords.where(entity, (p) => (x) => x.recordID === p.recordID)
+        .update({ prefix }, (p) => (x) => ({
+            fqdn: Sql.text.concat(
+                Sql.cast.asText(p.prefix),
+                Sql.cast.asText(x.zone.domain.name)) }));
+    }
+
+    async afterUpdate(entity: HostedZoneRecord, entry: ChangeEntry<HostedZoneRecord>) {
+        const db = ServiceProvider.resolve(this, SocialMailContext);
+        const prefix = (!entity.name || entity.name === "@") ? "" : entity.name + ".";
+        await db.hostedZoneRecords.where(entity, (p) => (x) => x.recordID === p.recordID)
+        .update({ prefix }, (p) => (x) => ({
+            fqdn: Sql.text.concat(
+                Sql.cast.asText(p.prefix),
+                Sql.cast.asText(x.zone.domain.name)) }));
+    }
+
+}
+
+export class HostedZoneUserEvents extends AuthenticatedEvents<HostedZoneUser> {
+
+    filter(query: IEntityQuery<HostedZoneUser>) {
+        if (this.verify) {
+            this.sessionUser.ensureLoggedIn();
+        }
+        if (this.sessionUser.isAdmin) {
+            return query;
+        }
+        return query.where(this.sessionUser, (p) => (x) => x.userID === p.userID);
+    }
+
+}

package/src/server/services/ui/renderUIClient.tsx

@@ -42,7 +42,8 @@ export const renderUIClient = async (page: Page, view?: string ) => {
                     path: globalEnv.path,
                     name: globalEnv.name,
                     cdn: globalEnv.cdn,
-                    externalLogin: globalEnv.externalLogin
+                    externalLogin: globalEnv.externalLogin,
+                    dnsEnabled: globalEnv.dns?.enabled
                 })};
             </script>
             <link rel="manifest" href="/pwa/manifest.json"/>