@timshel_npm/maildev 3.1.1

package/dist/lib/outgoing.d.ts

@@ -0,0 +1,40 @@
+export interface OutgoingOptions {
+    host?: string;
+    port?: number;
+    secure?: boolean;
+    auth?: {
+        user: string;
+        pass: string;
+    };
+    autoRelayAddress?: string;
+    autoRelayRules?: string | {
+        allow?: string;
+        deny?: string;
+    }[];
+}
+export declare class Outgoing {
+    port: number;
+    host: string;
+    secure: boolean;
+    autoRelay: boolean;
+    autoRelayAddress: string | undefined;
+    autoRelayRules: {
+        allow?: string;
+        deny?: string;
+    }[] | undefined;
+    auth: {
+        user: string;
+        pass: string;
+    } | undefined;
+    client: any;
+    emailQueue: any;
+    constructor(options?: OutgoingOptions);
+    getOutgoingHost(): string;
+    close(): void;
+    setAutoRelayMode(enabled: boolean, emailAddress: string | undefined, rules: {
+        allow?: string;
+        deny?: string;
+    }[] | string | undefined): void;
+    isAutoRelayEnabled(): boolean;
+    relayMail(emailObject: any, emailStream: any, isAutoRelay: any, callback: any): void;
+}

package/dist/lib/outgoing.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Outgoing = void 0;
+/**
+ * MailDev - outgoing
+ */
+const SMTPConnection = require("nodemailer/lib/smtp-connection");
+const async = require("async");
+const fs = require("fs");
+const logger = require("./logger");
+const wildstring = require("wildstring");
+class Outgoing {
+    constructor(options) {
+        var _a, _b, _c;
+        this.autoRelay = false;
+        wildstring.caseSensitive = false;
+        this.secure = (_a = options === null || options === void 0 ? void 0 : options.secure) !== null && _a !== void 0 ? _a : false;
+        this.host = (_b = options === null || options === void 0 ? void 0 : options.host) !== null && _b !== void 0 ? _b : "localhost";
+        this.port = (_c = options === null || options === void 0 ? void 0 : options.port) !== null && _c !== void 0 ? _c : (this.secure ? 465 : 25);
+        this.auth = options === null || options === void 0 ? void 0 : options.auth;
+        createClient(this);
+        // Create a queue to sent out the emails
+        // We use a queue so we don't run into concurrency issues
+        this.emailQueue = async.queue((task, callback) => {
+            const relayCallback = function (err, result) {
+                task.callback && task.callback(err, result);
+                callback(err, result);
+            };
+            relayMail(this, task.emailObject, task.emailStream, task.isAutoRelay, relayCallback);
+        }, 1);
+        if ((options === null || options === void 0 ? void 0 : options.autoRelayAddress) || (options === null || options === void 0 ? void 0 : options.autoRelayRules)) {
+            this.setAutoRelayMode(true, options === null || options === void 0 ? void 0 : options.autoRelayAddress, options === null || options === void 0 ? void 0 : options.autoRelayRules);
+        }
+    }
+    getOutgoingHost() {
+        return this.host;
+    }
+    close() {
+        if (this.client) {
+            this.client.close();
+        }
+    }
+    setAutoRelayMode(enabled, emailAddress, rules) {
+        this.autoRelay = enabled;
+        this.autoRelayAddress = emailAddress;
+        if (rules) {
+            if (typeof rules === "string") {
+                try {
+                    rules = JSON.parse(fs.readFileSync(rules, "utf8"));
+                }
+                catch (err) {
+                    logger.error(`Error reading rules file at ${rules}: ${err}`);
+                    throw err;
+                }
+            }
+            if (Array.isArray(rules)) {
+                this.autoRelayRules = rules;
+            }
+        }
+        if (this.autoRelay) {
+            const msg = ["Auto-Relay mode on"];
+            if (this.autoRelayAddress) {
+                msg.push(`Relaying all emails to ${this.autoRelayAddress}`);
+            }
+            if (this.autoRelayRules) {
+                msg.push(`Relay rules: ${JSON.stringify(this.autoRelayRules)}`);
+            }
+            logger.info(msg.join(", "));
+        }
+    }
+    isAutoRelayEnabled() {
+        return this.autoRelay;
+    }
+    relayMail(emailObject, emailStream, isAutoRelay, callback) {
+        this.emailQueue.push({ emailObject, emailStream, isAutoRelay, callback });
+    }
+}
+exports.Outgoing = Outgoing;
+function createClient(outgoing) {
+    var _a, _b;
+    try {
+        outgoing.client = new SMTPConnection({
+            port: outgoing.port,
+            host: outgoing.host,
+            secure: outgoing.secure,
+            auth: outgoing.auth || false,
+            tls: { rejectUnauthorized: false },
+            debug: true,
+        });
+        outgoing.client.on("error", function (err) {
+            logger.error("SMTP Connection error for outgoing email: ", err);
+        });
+        logger.info("MailDev outgoing SMTP Server %s:%d (user:%s, pass:%s, secure:%s)", outgoing.host, outgoing.port, (_a = outgoing === null || outgoing === void 0 ? void 0 : outgoing.auth) === null || _a === void 0 ? void 0 : _a.user, ((_b = outgoing === null || outgoing === void 0 ? void 0 : outgoing.auth) === null || _b === void 0 ? void 0 : _b.pass) ? "####" : undefined, outgoing.secure ? "yes" : "no");
+    }
+    catch (err) {
+        logger.error("Error during configuration of SMTP Server for outgoing email", err);
+    }
+}
+function relayMail(outgoing, emailObject, emailStream, isAutoRelay, done) {
+    if (isAutoRelay && outgoing.autoRelayAddress) {
+        emailObject.to = [{ address: outgoing.autoRelayAddress }];
+        emailObject.envelope.to = [{ address: outgoing.autoRelayAddress, args: false }];
+    }
+    let recipients = emailObject.envelope.to.map(getAddressFromAddressObject);
+    if (isAutoRelay && outgoing.autoRelayRules) {
+        recipients = getAutoRelayableRecipients(recipients, outgoing.autoRelayRules);
+    }
+    // Fail silently with auth relay mode on
+    if (recipients.length === 0) {
+        return done("Email had no recipients");
+    }
+    const mailSendCallback = function (err) {
+        if (err) {
+            logger.error("Outgoing client login error: ", err);
+            return done(err);
+        }
+        const sender = getAddressFromAddressObject(emailObject.envelope.from);
+        outgoing.client.send({
+            from: sender,
+            to: recipients,
+        }, emailStream, function (err) {
+            outgoing.client.quit();
+            createClient(outgoing);
+            if (err) {
+                logger.error("Mail Delivery Error: ", err);
+                return done(err);
+            }
+            logger.log("Mail Delivered: ", emailObject.subject);
+            return done();
+        });
+    };
+    const mailConnectCallback = function (err) {
+        if (err) {
+            logger.error("Outgoing connection error: ", err);
+            return done(err);
+        }
+        if (outgoing.auth) {
+            outgoing.client.login(outgoing.auth, mailSendCallback);
+        }
+        else {
+            mailSendCallback(err);
+        }
+    };
+    outgoing.client.connect(mailConnectCallback);
+}
+// Fallback to the object if the address key isn't defined
+function getAddressFromAddressObject(addressObj) {
+    return typeof addressObj.address !== "undefined" ? addressObj.address : addressObj;
+}
+function getAutoRelayableRecipients(recipients, rules) {
+    return recipients.filter(function (email) {
+        return validateAutoRelayRules(email, rules);
+    });
+}
+function validateAutoRelayRules(email, rules) {
+    return rules.reduce(function (result, rule) {
+        const toMatch = rule.allow || rule.deny || "";
+        const isMatch = wildstring.match(toMatch, email);
+        // Override previous rule if it matches
+        return isMatch ? !!rule.allow : result;
+    }, true);
+}

package/dist/lib/routes.d.ts

@@ -0,0 +1,2 @@
+import { MailServer } from "./mailserver";
+export declare function routes(app: any, mailserver: MailServer, basePathname: string): void;

package/dist/lib/routes.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routes = routes;
+/**
+ * MailDev - routes
+ */
+const express = require("express");
+const compression = require("compression");
+const pkg = require("../../package.json");
+const { filterEmails } = require("./utils");
+const emailRegexp = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+function routes(app, mailserver, basePathname) {
+    const router = express.Router();
+    // Get all emails Enveloppe
+    router.get("/envelope", compression(), function (req, res) {
+        res.json(mailserver.getAllEnvelope());
+    });
+    // Get all emails
+    router.get("/email", compression(), function (req, res) {
+        mailserver
+            .getAllEmail()
+            .then((mails) => res.json(req.query ? filterEmails(mails, req.query) : mails))
+            .catch((err) => res.status(500).json({ error: err.message }));
+    });
+    // Get single email
+    router.get("/email/:id", function (req, res) {
+        mailserver
+            .getEmail(req.params.id)
+            .then((mail) => {
+            mail.envelope.isRead = true; // Mark the email as 'read'
+            res.json(mail);
+        })
+            .catch((err) => res.status(404).json({ error: err.message }));
+    });
+    // Read email
+    // router.patch('/email/:id/read', function (req, res) {
+    //  mailserver.readEmail(req.params.id, function (err, email) {
+    //    if (err) return res.status(500).json({ error: err.message })
+    //    res.json(true)
+    //  })
+    // })
+    // Read all emails
+    router.patch("/email/read-all", function (req, res) {
+        const count = mailserver.readAllEmail();
+        res.json(count);
+    });
+    // Delete all emails
+    router.delete("/email/all", function (req, res) {
+        mailserver
+            .deleteAllEmail()
+            .then((count) => res.json(count))
+            .catch((err) => res.status(500).json({ error: err.message }));
+    });
+    // Delete email by id
+    router.delete("/email/:id", function (req, res) {
+        mailserver
+            .deleteEmail(req.params.id)
+            .then((deleted) => res.json(deleted))
+            .catch((err) => res.status(500).json({ error: err.message }));
+    });
+    // Get Email HTML
+    router.get("/email/:id/html", function (req, res) {
+        // Use the headers over hostname to include any port
+        const baseUrl = req.headers.host + (req.baseUrl || "");
+        mailserver
+            .getEmailHTML(req.params.id, baseUrl)
+            .then((html) => res.send(html))
+            .catch((err) => res.status(404).json({ error: err.message }));
+    });
+    // Serve Attachments
+    router.get("/email/:id/attachment/:filename", function (req, res) {
+        mailserver
+            .getEmailAttachment(req.params.id, req.params.filename)
+            .then((attachement) => {
+            res.contentType(attachement.contentType);
+            res.send(attachement.content);
+        })
+            .catch((err) => res.status(404).json({ error: err.message }));
+    });
+    // Serve email.eml
+    router.get("/email/:id/download", function (req, res) {
+        mailserver
+            .getEmailEml(req.params.id)
+            .then(([contentType, filename, stream]) => {
+            res.setHeader("Content-disposition", "attachment; filename=" + filename);
+            res.contentType(contentType);
+            stream.pipe(res);
+        })
+            .catch((err) => res.status(404).json({ error: err.message }));
+    });
+    // Get email source from .eml file
+    router.get("/email/:id/source", function (req, res) {
+        mailserver
+            .getRawEmail(req.params.id)
+            .then((stream) => stream.pipe(res))
+            .catch((err) => res.status(404).json({ error: err.message }));
+    });
+    // Get any config settings for display
+    router.get("/config", function (req, res) {
+        res.json({
+            version: pkg.version,
+            smtpPort: mailserver.port,
+            isOutgoingEnabled: mailserver.isOutgoingEnabled(),
+            outgoingHost: mailserver.getOutgoingHost(),
+        });
+    });
+    // Relay the email
+    router.post("/email/:id/relay/:relayTo?", function (req, res) {
+        mailserver
+            .getEmail(req.params.id)
+            .then((mail) => {
+            if (req.params.relayTo) {
+                if (emailRegexp.test(req.params.relayTo)) {
+                    mail.to = [{ address: req.params.relayTo, name: "" }];
+                    mail.envelope.to = [{ address: req.params.relayTo, name: "" }];
+                }
+                else {
+                    return res.status(400).json({
+                        error: "Incorrect email address provided :" + req.params.relayTo,
+                    });
+                }
+            }
+            return mailserver
+                .relayMail(mail, false)
+                .then(() => res.json(true))
+                .catch((err) => res.status(500).json({ error: err.message }));
+        })
+            .catch((err) => res.status(404).json({ error: err.message }));
+    });
+    // Health check
+    router.get("/healthz", function (req, res) {
+        res.json(true);
+    });
+    router.get("/reloadMailsFromDirectory", function (req, res) {
+        mailserver.loadMailsFromDirectory();
+        res.json(true);
+    });
+    app.use(basePathname, router);
+}

package/dist/lib/type.d.ts

@@ -0,0 +1,228 @@
+import type * as MailParser from "mailparser";
+/**
+ * Structured object for headers with arguments.
+ *
+ * `content-type: text/plain; CHARSET="UTF-8"` =>
+ * ```
+ * {
+ *     "value": "text/plain",
+ *     "params": {
+ *         "charset": "UTF-8"
+ *     }
+ * }
+ * ```
+ */
+export interface StructuredHeader extends MailParser.StructuredHeader {
+    /**
+     * The main value.
+     */
+    value: string;
+    /**
+     * Additional arguments.
+     */
+    params: {
+        [key: string]: string;
+    };
+}
+/**
+ * Possible types of a header value.
+ */
+export type HeaderValue = string[];
+/**
+ * A Map object with lowercase header keys.
+ */
+export type HeadersMap = Map<string, HeaderValue>;
+/**
+ * Address object.
+ */
+export interface AddressObject {
+    /**
+     * An array with address details.
+     */
+    value: EmailAddress[];
+    /**
+     * A formatted address string for HTML context.
+     */
+    html: string;
+    /**
+     * A formatted address string for plaintext context.
+     */
+    text: string;
+}
+/**
+ * Address details.
+ */
+export interface EmailAddress {
+    /**
+     * The email address.
+     */
+    address: string;
+    /**
+     * The name part of the email/group.
+     */
+    name: string;
+}
+/**
+ * A Map object with lowercase header keys.
+ */
+export type Headers = {
+    date: Date | undefined;
+    contentType: StructuredHeader | undefined;
+    contentDisposition: StructuredHeader | undefined;
+    dkimSignature: StructuredHeader[];
+    from: AddressObject | undefined;
+    to: AddressObject | undefined;
+    cc: AddressObject | undefined;
+    bcc: AddressObject | undefined;
+    sender: AddressObject | undefined;
+    replyTo: AddressObject | undefined;
+    deliveredTo: AddressObject | undefined;
+    dispositionNotificationTo: AddressObject | undefined;
+    received: string[];
+    priority: string | undefined;
+    headers: HeadersMap;
+};
+/**
+ * An array of raw header lines
+ */
+export type HeaderLines = ReadonlyArray<{
+    key: string;
+    line: string;
+}>;
+/**
+ * COmmon part of the Attachment object.
+ */
+export interface Attachment extends MailParser.Attachment {
+    /**
+     * Message type.
+     */
+    type: "attachment";
+    /**
+     * If true then this attachment should not be offered for download
+     * (at least not in the main attachments list).
+     */
+    related: boolean;
+    /**
+     * Attachment contents.
+     */
+    content: Buffer;
+    /**
+     * MIME type of the message.
+     */
+    contentType: string;
+    /**
+     * Content disposition type for the attachment,
+     * most probably `'attachment'`.
+     */
+    contentDisposition: string;
+    /**
+     * File name of the attachment.
+     */
+    filename?: string | undefined;
+    /**
+     * A Map value that holds MIME headers for the attachment node.
+     */
+    headers: HeadersMap;
+    /**
+     * An array of raw header lines for the attachment node.
+     */
+    headerLines: HeaderLines;
+    /**
+     * A MD5 hash of the message content.
+     */
+    checksum: string;
+    /**
+     * Message size in bytes.
+     */
+    size: number;
+    /**
+     * The header value from `Content-ID`.
+     */
+    contentId?: string | undefined;
+    /**
+     * `contentId` without `<` and `>`.
+     */
+    cid?: string | undefined;
+    generatedFileName: string;
+}
+export interface ParsedMail {
+    /**
+     * An array of attachments.
+     */
+    attachments: Attachment[];
+    /**
+     * A Map object with lowercase header keys.
+     *
+     * - All address headers are converted into address objects.
+     * - `references` is a string if only a single reference-id exists or an
+     *    array if multiple ids exist.
+     * - `date` value is a Date object.
+     */
+    headers: Headers;
+    /**
+     * An array of raw header lines
+     */
+    headerLines: HeaderLines;
+    /**
+     * The HTML body of the message.
+     *
+     * Sets to `false` when there is no HTML body.
+     *
+     * If the message included embedded images as cid: urls then these are all
+     * replaced with base64 formatted data: URIs.
+     */
+    html: string | false;
+    /**
+     * The plaintext body of the message.
+     */
+    text?: string | undefined;
+    /**
+     * The plaintext body of the message formatted as HTML.
+     */
+    textAsHtml?: string | undefined;
+    /**
+     * The subject line.
+     */
+    subject?: string | undefined;
+    /**
+     * An array of referenced Message-ID values.
+     */
+    references: string[];
+    /**
+     * A Date object for the `Date:` header.
+     */
+    date: Date;
+    to: EmailAddress[];
+    from: EmailAddress[];
+    cc: EmailAddress[];
+    bcc: EmailAddress[];
+    replyTo: EmailAddress[];
+    /**
+     * The In-Reply-To value string.
+     */
+    inReplyTo: string[];
+    /**
+     * The Message-ID value string.
+     */
+    messageId?: string | undefined;
+    /**
+     * Priority of the e-mail.
+     */
+    priority: "normal" | "low" | "high";
+}
+export interface Envelope {
+    id: string;
+    from: EmailAddress[];
+    to: EmailAddress[];
+    date: Date;
+    subject?: string | undefined;
+    hasAttachment: boolean;
+    isRead: boolean;
+}
+export interface Mail extends ParsedMail {
+    id: string;
+    calculatedBcc: EmailAddress[];
+    size: number;
+    sizeHuman: string;
+    envelope: Envelope;
+}

package/dist/lib/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function makeId(): string;
+export declare function formatBytes(bytes: number, decimals?: number): string;
+export declare function filterEmails(emails: string[], query: any): string[];
+export declare function delay(ms: any): Promise<void>;

package/dist/lib/utils.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeId = makeId;
+exports.formatBytes = formatBytes;
+exports.filterEmails = filterEmails;
+exports.delay = delay;
+// Create an unique id, length 8 characters
+function makeId() {
+    let text = "";
+    const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    for (let i = 0; i < 8; i++) {
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    }
+    return text;
+}
+// Format bytes
+// Source: https://stackoverflow.com/a/18650828/3143704
+function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return "0 bytes";
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ["bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+}
+function lookup(obj, path) {
+    const parts = path.split(".");
+    const base = obj[parts[0]];
+    if (!base)
+        return;
+    if (parts.length === 1) {
+        return base;
+    }
+    const next = parts.slice(1).join(".");
+    if (Array.isArray(base)) {
+        return base.map((el) => {
+            return lookup(el, next);
+        });
+    }
+    else {
+        return lookup(base, next);
+    }
+}
+function filterEmails(emails, query) {
+    return emails.filter((email) => {
+        const hits = [];
+        for (const key in query) {
+            if (Object.hasOwnProperty.call(query, key)) {
+                const element = query[key];
+                const value = lookup(email, key);
+                if (Array.isArray(value)) {
+                    hits.push(value.includes(element));
+                }
+                else {
+                    hits.push(value === element);
+                }
+            }
+        }
+        return !hits.includes(false);
+    });
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/lib/web.d.ts

@@ -0,0 +1,32 @@
+/**
+ * MailDev - web
+ */
+import { MailServer } from "./mailserver";
+export interface WebOptions {
+    port?: number;
+    host?: string;
+    basePathname?: string;
+    auth?: {
+        user: string;
+        pass: string;
+    };
+    ssl?: {
+        cert: string;
+        key: string;
+    };
+}
+export declare class Web {
+    protocol: string;
+    port: number;
+    host: string;
+    basePathname: string;
+    /**
+     * Keep record of all connections to close them on shutdown
+     */
+    connections: {};
+    server: any;
+    io: any;
+    constructor(mailserver: MailServer, options?: WebOptions);
+    listen(): Promise<void>;
+    close(): Promise<void>;
+}