@social-mail/social-mail-web-server 1.7.60 → 1.7.63

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.79";
+    const version = "1.4.80";
 
     const existing = await config.getValue(UIPackageConfig, false);
     if (existing) {

package/src/server/services/EmailAddressService.ts

@@ -15,6 +15,15 @@ export default class EmailAddressService implements ICacheContainer<EmailAddress
 
     cache: ObjectCache<EmailAddressService>;
 
+    @cacheFor()
+    public async getHostedDomain(name: string) {
+        using scope = globalServices.createScope();
+        const db = scope.resolve(SocialMailContext);
+        return await db.hostedDomains.where({ name }, (p) => (x) => x.domain.name === p.name)
+            .include((x) => x.domain)
+            .first();
+    }
+
     @cacheFor()
     public async getOrCreateDomain(name: string) {
         name = name.toLocaleLowerCase().trim();

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

@@ -45,6 +45,7 @@ export const renderUIClient = async (page: Page, view?: string, addScript?: stri
                     path: globalEnv.path,
                     name: globalEnv.name,
                     cdn: globalEnv.cdn,
+                    signupEnabled: globalEnv.signupEnabled,
                     externalLogin: globalEnv.externalLogin,
                     dnsEnabled: globalEnv.dns?.enabled
                 })};

package/src/wwwroot/routes/social-mail/user/password/reset/post.tsx

@@ -0,0 +1,128 @@
+import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
+import Inject from "@entity-access/entity-access/dist/di/di.js";
+import Page from "@entity-access/server-pages/dist/Page.js";
+import { Prepare } from "@entity-access/server-pages/dist/decorators/Prepare.js";
+import SocialMailContext from "../../../../../../server/model/SocialMailContext.js";
+import CryptoService from "../../../../../../server/services/CryptoService.js";
+import EmailAddressService from "../../../../../../server/services/EmailAddressService.js";
+import CaptchaService from "../../../../../../server/services/captcha/CaptchaService.js";
+import { IVerification } from "../../../../../../server/services/captcha/IVerification.js";
+import ExternalOtpInService from "../../../../../../server/services/external-otp-in/ExternalOtpInService.js";
+
+export interface ISignup {
+    username: string;
+    userID: number;
+    phoneNumber: string;
+    captcha: IVerification;
+    phone: IVerification;
+    password: string;
+}
+
+@Prepare.parseJsonBody
+export default class extends Page {
+
+    @Inject
+    captchaService: CaptchaService;
+
+    @Inject
+    cryptoService: CryptoService;
+
+    @Inject
+    emailAddressService: EmailAddressService;
+
+    @Inject
+    ois: ExternalOtpInService;
+
+
+    @Inject
+    db: SocialMailContext;
+
+    async run() {
+
+        const { db } = this;
+
+        db.verifyFilters = false;
+        db.raiseEvents = false;
+
+        const model = this.body as ISignup;
+
+        model.username = model.username?.trim();
+        if (!model.username) {
+            throw new EntityAccessError("Username is required");
+        }
+        const [username, domain] = model.username.split("@");
+
+        model.username = username?.trim()?.toLocaleLowerCase()?.replace(/[\.\-]/g, "") + "@" + domain;
+
+        model.phoneNumber = `+${model.phoneNumber.replace(/[^0-9]/g, "")}`;
+
+        // console.log(model);
+
+        // verify captcha...
+        await this.captchaService.verify(model.captcha as any);
+
+        const user = await db.users.where(model, (p) => (x) => x.userName === p.username)
+            .first();
+
+        if (!user) {
+            throw new EntityAccessError(`Username ${model.username} not found, make sure it is complete email address.`);
+        }
+
+        if (!model.phone.id) {
+
+
+            // check if phone exists...
+            const phone = await db.userAuthFactors
+                .where(model, (p) => (x) =>
+                    x.user.userName === p.username
+                    && x.phoneNumber === p.phoneNumber
+                )
+                .first();
+
+            if (!phone) {
+                throw new EntityAccessError(`No phone number is associated with this user, please contact us at support@neurospeech.com .`);
+            }
+
+            if (!model.phone.id) {
+                const v = await this.ois.create([model.phoneNumber]);
+                model.phone.id = v.verificationID as any;
+                model.phone.code = v.accessCode;
+                model.phone.smsConfig = v.externalConfig;
+                return this.json(model);
+            }
+
+        }
+
+        if(model.phone.id) {
+            // verify...
+            const v = await db.verificationTokens.statements.select({} , { verificationID: model.phone.id as any });
+            if (!v.verified) {
+                return this.json(model);
+            }
+            model.phone.verified = "true";
+        }
+
+        if (!model.password) {
+            return this.json(model);
+        }
+
+        if (model.password.length < 7) {
+            throw new EntityAccessError("Password is cannot be less than 7 characters");
+        }
+
+        if (/\s/i.test(model.password)) {
+            throw new EntityAccessError("Password must not any whitespace characters");
+        }
+
+        const passwordSalt = this.cryptoService.generateSalt();
+        const passwordHash = this.cryptoService.hash(passwordSalt, model.password);
+        model.userID = user.userID;
+        await db.users.where(user, (p) => (x) => x.userID === p.userID)
+            .update({ passwordSalt, passwordHash}, (p) => (x) => ({
+                passwordHash: p.passwordHash,
+                passwordSalt: p.passwordSalt
+            }));
+        return this.json(model);
+    }
+
+}

package/src/wwwroot/routes/social-mail/user/signup/get.tsx

@@ -0,0 +1,9 @@
+import Page from "@entity-access/server-pages/dist/Page.js";
+import { renderUIClient } from "../../../../../server/services/ui/renderUIClient.js";
+
+export default class extends Page {
+
+    async run() {
+        return renderUIClient(this, "dist/public/users/signup/SignupPage");
+    }
+}

package/src/wwwroot/routes/social-mail/user/signup/post.tsx

@@ -1,42 +1,45 @@
-import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
 import Inject from "@entity-access/entity-access/dist/di/di.js";
-import DateTime from "@entity-access/entity-access/dist/types/DateTime.js";
 import Page from "@entity-access/server-pages/dist/Page.js";
 import { Prepare } from "@entity-access/server-pages/dist/decorators/Prepare.js";
+import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
+import DateTime from "@entity-access/entity-access/dist/types/DateTime.js";
+import { readFileSync } from "fs";
 import SocialMailContext from "../../../../../server/model/SocialMailContext.js";
+import VerificationToken from "../../../../../server/model/entities/VerificationToken.js";
 import CryptoService from "../../../../../server/services/CryptoService.js";
 import EmailAddressService from "../../../../../server/services/EmailAddressService.js";
 import CaptchaService from "../../../../../server/services/captcha/CaptchaService.js";
-import { IVerification } from "../../../../../server/services/captcha/IVerification.js";
 import ExternalOtpInService from "../../../../../server/services/external-otp-in/ExternalOtpInService.js";
-import { randomUUID } from "crypto";
-import { ContactAddress } from "../../../../../server/model/entities/Contact.js";
-import WebSiteService from "../../../../../server/services/files/WebSiteService.js";
-import { StoreAccountAddress } from "../../../../../server/model/entities/StoreAddress.js";
-import VerificationToken from "../../../../../server/model/entities/VerificationToken.js";
 
 export interface ISignup {
     userID: number;
+    username: string;
+    emailAddress: string;
     password: string;
     name: string;
     phoneNumber: string;
-    emailAddress: string;
     isdCode?: string;
     country: string;
     captcha: Partial<VerificationToken>;
     phone: Partial<VerificationToken>;
-    email: Partial<VerificationToken>;
-    billing?: Partial<StoreAccountAddress>;
-    shipping?: Partial<StoreAccountAddress>;
 }
 
-/**
- * External Signup is used for signing up for Blog or Store.
- */
+const ensureUsername = (name: string) => {
+
+    const json = JSON.parse(readFileSync("./content/json/bad-names.json","utf8")) as { reserved: string[], partial: string[] };
+
+    if(json.reserved.includes(name)) {
+        throw new EntityAccessError("Username is reserved.");
+    }
+    for (const iterator of json.partial) {
+        if (name.includes(iterator)) {
+            throw new EntityAccessError("Username is not acceptable.");
+        }
+    }
+};
 
 @Prepare.parseJsonBody
-@Prepare.authorize
-export default class ExternalSignup extends Page {
+export default class extends Page {
 
     @Inject
     captchaService: CaptchaService;
@@ -53,9 +56,6 @@ export default class ExternalSignup extends Page {
     @Inject
     db: SocialMailContext;
 
-    @Inject
-    websiteService: WebSiteService;
-
     async run() {
 
         const { db } = this;
@@ -65,24 +65,40 @@ export default class ExternalSignup extends Page {
 
         const model = this.body as ISignup;
 
-        model.emailAddress = model.email.verifyAddresses;
-        model.phoneNumber = model.phone.verifyAddresses;
+        model.emailAddress = model.emailAddress.trim().toLowerCase();
+
+        const [username, domain] = model.emailAddress.split("@", 2);
+        model.username = username;
 
-        const w = await this.websiteService.get(this.request.hostName);
-        const storeID = w.folderID;
-        if (!storeID) {
-            throw new EntityAccessError(`Signup not allowed`);
+        if (!/\p{Letter}[\p{Letter}\.\-0-9]{0,50}/iu.test(username)) {
+            throw new EntityAccessError(`Invalid email address`);
         }
 
         model.password = model.password?.trim();
-        if (!model.emailAddress) {
-            throw new EntityAccessError("Email is required");
+        model.username = model.username?.trim()?.toLowerCase();
+        if (!model.username) {
+            throw new EntityAccessError("Username is required");
+        }
+        ensureUsername(model.username);
+        if (!model.password) {
+            throw new EntityAccessError("Password is required");
+        }
+
+        if (model.password.length < 7) {
+            throw new EntityAccessError("Password is cannot be less than 7 characters");
+        }
+
+        if (/\s/i.test(model.password)) {
+            throw new EntityAccessError("Password must not any whitespace characters");
         }
 
         model.phoneNumber = `+${model.phoneNumber.replace(/[^0-9]/g, "")}`;
 
+        // console.log(model);
+
         // check if phone number already exists...
-        for(const v1 of [model.captcha, model.email, model.phone]) {
+
+        for(const v1 of [model.captcha, model.phone]) {
             const { verificationID , accessCode } = v1;
             const vr = await db.verificationTokens.statements.select({}, { verificationID, accessCode });
             if (!vr.verified) {
@@ -90,27 +106,26 @@ export default class ExternalSignup extends Page {
             }
         }
 
-        const { emailAddress, phoneNumber } = model;
-        const emailExists = await db.storeAccountEmails.where({ emailAddress, storeID}, (p) => (x) =>
-                x.emailAddress.emailAddress === p.emailAddress
-                && x.storeAccount.storeID === p.storeID
-            )
+        const hostedDomain = await this.emailAddressService.getHostedDomain(domain);
+        if(!hostedDomain || !hostedDomain.allowSignup) {
+            throw new EntityAccessError(`Signup for email address ${model.emailAddress} not allowed for domain ${domain}`);
+        }
+        const emailAddress = model.emailAddress;
+        const user = await db.mailboxes.where({ emailAddress}, (p) => (x) => x.emailAddress.emailAddress === p.emailAddress)
             .some();
-        if (emailExists) {
+        if (user) {
             throw new EntityAccessError(`Email address already exists.`);
         }
 
-        // check if phone exists...
-        const exists = await db.storeAccountPhones
-            .where({ phoneNumber, storeID }, (p) => (x) => x.phoneNumberE64 === p.phoneNumber
-                && x.storeAccount.storeID === p.storeID
-            ).some();
 
+        // check if phone exists...
+        const exists = await db.users
+            .where(model, (p) => (x) => x.uniquePhoneNumber === p.phoneNumber)
+            .some();
         if (exists) {
             throw new EntityAccessError(`Phone number is already registered.`);
         }
 
-        model.password = randomUUID();
         const passwordSalt = this.cryptoService.generateSalt();
         const passwordHash = this.cryptoService.hash(passwordSalt, model.password);
 
@@ -118,30 +133,23 @@ export default class ExternalSignup extends Page {
         const phoneNumberE64 = model.phoneNumber;
         const name = model.name;
 
-        let billingAddress: StoreAccountAddress;
-        let shippingAddress: StoreAccountAddress;
-        const addresses = [];
-        if (model.billing?.title) {
-            billingAddress = db.storeAccountAddresses.add(model.billing);
-            addresses.push(billingAddress);
-        }
-        if (model.shipping?.title) {
-            shippingAddress = db.storeAccountAddresses.add(model.shipping);
-            addresses.push(shippingAddress);
-        }
-
-        const emailAddressID = await this.emailAddressService.getId(model.emailAddress, model.name);
+        const mailboxID = await this.emailAddressService.getId(emailAddress, name);
+        const { domainID } = hostedDomain;
 
         // create user...
         const account = db.users.add({
-            /** This is to make customer user unique per store */
-            userName: storeID + ":" + model.emailAddress ,
+            userName: model.emailAddress ,
             displayName: name,
             passwordSalt,
             passwordHash,
             multiFactor: false,
             dateUpdated: dateCreated,
-            isExternal: true,
+            uniquePhoneNumber: phoneNumberE64,
+            roles: [
+                db.userRoles.add({
+                    roleName: "User"
+                })
+            ],
             authFactors: [
                 db.userAuthFactors.add({
                     phoneNumber: phoneNumberE64,
@@ -149,66 +157,43 @@ export default class ExternalSignup extends Page {
                     method: "otp-in",
                     dateUpdated: dateCreated
                 })
-            ]
-        });
-
-        const contact = db.storeAccounts.add({
-            dateCreated,
-            user: account,
-            storeID,
-            /** This is important as name must be unique in the ledger */
-            name: `${model.name}(${emailAddressID})`,
-            head: "Customer",
-            emails: [
-                db.storeAccountEmails.add({
-                    emailAddressID
-                })
             ],
-            phones: [
-                db.storeAccountPhones.add({
-                    phoneNumberE64
+            userMailboxes:[
+                db.userMailboxes.add({
+                    mailbox: db.mailboxes.add({
+                        mailboxID,
+                        domainID,
+                        uniqueAddress: model.username.replace(/[\-\.]/g, "") + "@" + hostedDomain.domain.name,
+                        maxStorage: 1024*1024*1024
+                    })
                 })
-            ],
-            addresses
+            ]
         });
 
         await db.saveChanges();
 
-        if (billingAddress) {
-            contact.billingAddressID = billingAddress.addressID;
-        }
-        if (shippingAddress) {
-            contact.shippingAddressID = shippingAddress.addressID;
-        }
-        if (addresses.length) {
-            await db.saveChanges();
-        }
+        // todo pending delete
+        // await this.captchaService.delete(model.captcha as any);
 
-        // Todo: delete captcha
+        model.userID = account.userID;
 
-        const userID = model.userID = account.userID;
+        const start = DateTime.now;
 
-        // lets login here...
+        // add login cookie..
+        const expiry = start.addDays(30);
 
-        const dateUpdated = DateTime.now;
-        const start = dateUpdated;
-        const expiry = dateUpdated.addDays(30);
-
-        // create login session...
-        const loginSession = await db.loginSessions.statements.insert({
-            userID,
-            dateUpdated,
+        model.userID = account.userID;
+        const session = await db.loginSessions.statements.insert({
+            userID: account.userID,
             start,
             expiry,
-            invalid: false,
-            verificationID: model.phone.verificationID as any,
-            status: "created"
+            status: "created",
+            invalid: false
         });
-
         await this.sessionUser.setAuthCookie({
-            userID: loginSession.userID,
-            id: loginSession.sessionID,
-            expiry: expiry.asJSDate,
+            userID: session.userID,
+            id: session.sessionID,
+            expiry: session.expiry.asJSDate,
             version: "1.1",
             active: true
         });