emailengine-app 2.68.1 → 2.69.0

package/lib/api-routes/blocklist-routes.js

@@ -0,0 +1,337 @@
+'use strict';
+
+const Boom = require('@hapi/boom');
+const Joi = require('joi');
+const { redis } = require('../db');
+const { Account } = require('../account');
+const getSecret = require('../get-secret');
+const { lists } = require('../lists');
+const { failAction } = require('../tools');
+const { handleError } = require('./route-helpers');
+const { accountIdSchema } = require('../schemas');
+const { REDIS_PREFIX } = require('../consts');
+
+async function init(args) {
+    const { server, call, CORS_CONFIG } = args;
+
+    server.route({
+        method: 'GET',
+        path: '/v1/blocklists',
+
+        async handler(request) {
+            try {
+                return await lists.list(request.query.page, request.query.pageSize);
+            } catch (err) {
+                handleError(request, err);
+            }
+        },
+
+        options: {
+            description: 'List blocklists',
+            notes: 'List blocklists with blocked addresses',
+            tags: ['api', 'Blocklists'],
+
+            plugins: {},
+
+            auth: {
+                strategy: 'api-token',
+                mode: 'required'
+            },
+            cors: CORS_CONFIG,
+
+            validate: {
+                options: {
+                    stripUnknown: false,
+                    abortEarly: false,
+                    convert: true
+                },
+                failAction,
+
+                query: Joi.object({
+                    page: Joi.number()
+                        .integer()
+                        .min(0)
+                        .max(1024 * 1024)
+                        .default(0)
+                        .example(0)
+                        .description('Page number (zero indexed, so use 0 for first page)')
+                        .label('PageNumber'),
+                    pageSize: Joi.number().integer().min(1).max(1000).default(20).example(20).description('How many entries per page').label('PageSize')
+                }).label('PageListsRequest')
+            },
+
+            response: {
+                schema: Joi.object({
+                    total: Joi.number().integer().example(120).description('How many matching entries').label('TotalNumber'),
+                    page: Joi.number().integer().example(0).description('Current page (0-based index)').label('PageNumber'),
+                    pages: Joi.number().integer().example(24).description('Total page count').label('PagesNumber'),
+
+                    blocklists: Joi.array()
+                        .items(
+                            Joi.object({
+                                listId: Joi.string().max(256).required().example('example').description('List ID'),
+                                count: Joi.number().integer().example(12).description('Count of blocked addresses in this list')
+                            }).label('BlocklistsResponseItem')
+                        )
+                        .label('BlocklistsEntries')
+                }).label('BlocklistsResponse'),
+                failAction: 'log'
+            }
+        }
+    });
+
+    server.route({
+        method: 'GET',
+        path: '/v1/blocklist/{listId}',
+
+        async handler(request) {
+            try {
+                return await lists.listContent(request.params.listId, request.query.page, request.query.pageSize);
+            } catch (err) {
+                handleError(request, err);
+            }
+        },
+
+        options: {
+            description: 'List blocklist entries',
+            notes: 'List blocked addresses for a list',
+            tags: ['api', 'Blocklists'],
+
+            plugins: {},
+
+            auth: {
+                strategy: 'api-token',
+                mode: 'required'
+            },
+            cors: CORS_CONFIG,
+
+            validate: {
+                options: {
+                    stripUnknown: false,
+                    abortEarly: false,
+                    convert: true
+                },
+                failAction,
+
+                params: Joi.object({
+                    listId: Joi.string()
+                        .hostname()
+                        .example('test-list')
+                        .description('List ID. Must use a subdomain name format. Lists are registered ad-hoc, so a new identifier defines a new list.')
+                        .label('ListID')
+                        .required()
+                }).label('BlocklistListRequest'),
+
+                query: Joi.object({
+                    page: Joi.number()
+                        .integer()
+                        .min(0)
+                        .max(1024 * 1024)
+                        .default(0)
+                        .example(0)
+                        .description('Page number (zero indexed, so use 0 for first page)')
+                        .label('PageNumber'),
+                    pageSize: Joi.number().integer().min(1).max(1000).default(20).example(20).description('How many entries per page').label('PageSize')
+                }).label('PageListsRequest')
+            },
+
+            response: {
+                schema: Joi.object({
+                    listId: Joi.string().max(256).required().example('example').description('List ID'),
+                    total: Joi.number().integer().example(120).description('How many matching entries').label('TotalNumber'),
+                    page: Joi.number().integer().example(0).description('Current page (0-based index)').label('PageNumber'),
+                    pages: Joi.number().integer().example(24).description('Total page count').label('PagesNumber'),
+                    addresses: Joi.array()
+                        .items(
+                            Joi.object({
+                                recipient: Joi.string().email().example('user@example.com').description('Listed email address').required(),
+                                account: accountIdSchema.required().required(),
+                                messageId: Joi.string().example('<test123@example.com>').description('Message ID'),
+                                source: Joi.string().example('api').description('Which mechanism was used to add the entry'),
+                                reason: Joi.string().example('api').description('Why this entry was added'),
+                                remoteAddress: Joi.string()
+                                    .ip({
+                                        version: ['ipv4', 'ipv6'],
+                                        cidr: 'optional'
+                                    })
+                                    .description('Which IP address triggered the entry'),
+                                userAgent: Joi.string().example('Mozilla/5.0 (Macintosh)').description('Which user agent triggered the entry'),
+                                created: Joi.date().iso().example('2021-02-17T13:43:18.860Z').description('The time this entry was added or updated').required()
+                            }).label('BlocklistListResponseItem')
+                        )
+                        .label('BlocklistListEntries')
+                }).label('BlocklistListResponse'),
+                failAction: 'log'
+            }
+        }
+    });
+
+    server.route({
+        method: 'POST',
+        path: '/v1/blocklist/{listId}',
+        async handler(request) {
+            let accountObject = new Account({
+                redis,
+                account: request.payload.account,
+                call,
+                secret: await getSecret(),
+                timeout: request.headers['x-ee-timeout']
+            });
+
+            try {
+                // throws if account does not exist
+                await accountObject.loadAccountData();
+
+                let added = await redis.eeListAdd(
+                    `${REDIS_PREFIX}lists:unsub:lists`,
+                    `${REDIS_PREFIX}lists:unsub:entries:${request.params.listId}`,
+                    request.params.listId,
+                    request.payload.recipient.toLowerCase().trim(),
+                    JSON.stringify({
+                        recipient: request.payload.recipient,
+                        account: request.payload.account,
+                        source: 'api',
+                        reason: request.payload.reason,
+                        remoteAddress: request.app.ip,
+                        userAgent: request.headers['user-agent'],
+                        created: new Date().toISOString()
+                    })
+                );
+
+                return {
+                    success: true,
+                    added: !!added
+                };
+            } catch (err) {
+                request.logger.error({ msg: 'API request failed', err });
+                if (Boom.isBoom(err)) {
+                    throw err;
+                }
+                let error = Boom.boomify(err, { statusCode: err.statusCode || 500 });
+                if (err.code) {
+                    error.output.payload.code = err.code;
+                }
+                if (err.details) {
+                    error.output.payload.details = err.details;
+                }
+                throw error;
+            }
+        },
+        options: {
+            description: 'Add to blocklist',
+            notes: 'Add an email address to a blocklist',
+            tags: ['api', 'Blocklists'],
+
+            auth: {
+                strategy: 'api-token',
+                mode: 'required'
+            },
+            cors: CORS_CONFIG,
+
+            validate: {
+                options: {
+                    stripUnknown: false,
+                    abortEarly: false,
+                    convert: true
+                },
+                failAction,
+
+                params: Joi.object({
+                    listId: Joi.string()
+                        .hostname()
+                        .example('test-list')
+                        .description('List ID. Must use a subdomain name format. Lists are registered ad-hoc, so a new identifier defines a new list.')
+                        .label('ListID')
+                        .required()
+                }).label('BlocklistListRequest'),
+
+                payload: Joi.object({
+                    account: accountIdSchema.required(),
+                    recipient: Joi.string().empty('').email().example('user@example.com').description('Email address to add to the list').required(),
+                    reason: Joi.string().empty('').default('block').description('Identifier for the blocking reason')
+                }).label('BlocklistListAddPayload')
+            },
+
+            response: {
+                schema: Joi.object({
+                    success: Joi.boolean().example(true).description('Was the request successful').label('BlocklistListAddSuccess'),
+                    added: Joi.boolean().example(true).description('Was the address added to the list')
+                }).label('BlocklistListAddResponse'),
+                failAction: 'log'
+            }
+        }
+    });
+
+    server.route({
+        method: 'DELETE',
+        path: '/v1/blocklist/{listId}',
+
+        async handler(request) {
+            try {
+                let exists = await redis.hexists(`${REDIS_PREFIX}lists:unsub:lists`, request.params.listId);
+                if (!exists) {
+                    let message = 'Requested blocklist was not found';
+                    let error = Boom.boomify(new Error(message), { statusCode: 404 });
+                    throw error;
+                }
+
+                let deleted = await redis.eeListRemove(
+                    `${REDIS_PREFIX}lists:unsub:lists`,
+                    `${REDIS_PREFIX}lists:unsub:entries:${request.params.listId}`,
+                    request.params.listId,
+                    request.query.recipient.toLowerCase().trim()
+                );
+
+                return {
+                    deleted: !!deleted
+                };
+            } catch (err) {
+                handleError(request, err);
+            }
+        },
+        options: {
+            description: 'Remove from blocklist',
+            notes: 'Delete a blocked email address from a list',
+            tags: ['api', 'Blocklists'],
+
+            plugins: {},
+
+            auth: {
+                strategy: 'api-token',
+                mode: 'required'
+            },
+            cors: CORS_CONFIG,
+
+            validate: {
+                options: {
+                    stripUnknown: false,
+                    abortEarly: false,
+                    convert: true
+                },
+                failAction,
+
+                params: Joi.object({
+                    listId: Joi.string()
+                        .hostname()
+                        .example('test-list')
+                        .description('List ID. Must use a subdomain name format. Lists are registered ad-hoc, so a new identifier defines a new list.')
+                        .label('ListID')
+                        .required()
+                }).label('BlocklistListRequest'),
+
+                query: Joi.object({
+                    recipient: Joi.string().empty('').email().example('user@example.com').description('Email address to remove from the list').required()
+                }).label('RecipientQuery')
+            },
+
+            response: {
+                schema: Joi.object({
+                    deleted: Joi.boolean().truthy('Y', 'true', '1').falsy('N', 'false', 0).default(true).description('Was the address removed from the list')
+                }).label('DeleteBlocklistResponse'),
+                failAction: 'log'
+            }
+        }
+    });
+}
+
+module.exports = init;

package/lib/api-routes/delivery-test-routes.js

@@ -0,0 +1,321 @@
+'use strict';
+
+const Boom = require('@hapi/boom');
+const Joi = require('joi');
+const { fetch: fetchCmd } = require('undici');
+const { redis } = require('../db');
+const { Account } = require('../account');
+const { Gateway } = require('../gateway');
+const getSecret = require('../get-secret');
+const { failAction, httpAgent } = require('../tools');
+const { accountIdSchema } = require('../schemas');
+const { REDIS_PREFIX } = require('../consts');
+const packageData = require('../../package.json');
+
+async function init(args) {
+    const { server, call, CORS_CONFIG, SMTP_TEST_HOST } = args;
+
+    server.route({
+        method: 'POST',
+        path: '/v1/delivery-test/account/{account}',
+        async handler(request) {
+            let accountObject = new Account({
+                redis,
+                account: request.params.account,
+                call,
+                secret: await getSecret(),
+                timeout: request.headers['x-ee-timeout']
+            });
+
+            try {
+                // throws if account does not exist
+                let accountData = await accountObject.loadAccountData();
+
+                request.logger.info({ msg: 'Requested SMTP delivery test', account: request.params.account });
+
+                let headers = {
+                    'Content-Type': 'application/json',
+                    'User-Agent': `${packageData.name}/${packageData.version} (+${packageData.homepage})`
+                };
+
+                let res = await fetchCmd(`${SMTP_TEST_HOST}/test-address`, {
+                    method: 'post',
+                    body: JSON.stringify({
+                        version: packageData.version,
+                        requestor: '@postalsys/emailengine-app'
+                    }),
+                    headers,
+                    dispatcher: httpAgent.retry
+                });
+
+                if (!res.ok) {
+                    let err = new Error(`Invalid response: ${res.status} ${res.statusText}`);
+                    err.statusCode = res.status;
+
+                    try {
+                        err.details = await res.json();
+                    } catch (err) {
+                        // ignore
+                    }
+
+                    throw err;
+                }
+
+                let testAccount = await res.json();
+                if (!testAccount || !testAccount.user) {
+                    let err = new Error(`Invalid test account`);
+                    err.statusCode = 500;
+
+                    try {
+                        err.details = testAccount;
+                    } catch (err) {
+                        // ignore
+                    }
+
+                    throw err;
+                }
+
+                if (request.payload.gateway) {
+                    // try to load the gateway, throws if not set
+                    let gatewayObject = new Gateway({ redis, gateway: request.payload.gateway, call, secret: await getSecret() });
+                    await gatewayObject.loadGatewayData();
+                }
+
+                try {
+                    let now = new Date().toISOString();
+                    let queueResponse = await accountObject.queueMessage(
+                        {
+                            account: accountData.account,
+                            subject: `Delivery test ${now}`,
+                            text: `Hello
+
+This is an automated email to test deliverability settings. If you see this email, you can safely delete it.
+
+${now}`,
+                            html: `<p>Hello</p>
+<p>This is an automated email to test deliverability settings. If you see this email, you can safely delete it.</p>
+<p>${now}</p>`,
+                            from: {
+                                name: accountData.name,
+                                address: accountData.email
+                            },
+                            to: [{ name: 'Delivery Test Server', address: testAccount.address }],
+                            copy: false,
+                            gateway: request.payload.gateway,
+                            feedbackKey: `${REDIS_PREFIX}test-send:${testAccount.user}`,
+                            deliveryAttempts: 1
+                        },
+                        { source: 'test' }
+                    );
+
+                    return {
+                        success: !!queueResponse.queueId,
+                        deliveryTest: testAccount.user
+                    };
+                } catch (err) {
+                    return {
+                        error: err.message
+                    };
+                }
+            } catch (err) {
+                request.logger.error({ msg: 'API request failed', err });
+                if (Boom.isBoom(err)) {
+                    throw err;
+                }
+                let error = Boom.boomify(err, { statusCode: err.statusCode || 500 });
+                if (err.code) {
+                    error.output.payload.code = err.code;
+                }
+                if (err.details) {
+                    error.output.payload.details = err.details;
+                }
+                throw error;
+            }
+        },
+        options: {
+            description: 'Create delivery test',
+            notes: 'Initiate a delivery test',
+            tags: ['api', 'Delivery Test'],
+
+            auth: {
+                strategy: 'api-token',
+                mode: 'required'
+            },
+            cors: CORS_CONFIG,
+
+            validate: {
+                options: {
+                    stripUnknown: false,
+                    abortEarly: false,
+                    convert: true
+                },
+                failAction,
+
+                params: Joi.object({
+                    account: accountIdSchema.required()
+                }),
+
+                payload: Joi.object({
+                    gateway: Joi.string().allow(false, null).empty('').max(256).example(false).description('Optional gateway ID').label('DeliveryTestGateway')
+                }).label('DeliveryStartRequest')
+            },
+
+            response: {
+                schema: Joi.object({
+                    success: Joi.boolean().example(true).description('Was the test started').label('ResponseDeliveryStartSuccess'),
+                    deliveryTest: Joi.string()
+                        .guid({
+                            version: ['uuidv4', 'uuidv5']
+                        })
+                        .example('6420a6ad-7f82-4e4f-8112-82a9dad1f34d')
+                        .description('Test ID')
+                }).label('DeliveryStartResponse'),
+                failAction: 'log'
+            }
+        }
+    });
+
+    server.route({
+        method: 'GET',
+        path: '/v1/delivery-test/check/{deliveryTest}',
+        async handler(request) {
+            try {
+                request.logger.info({ msg: 'Requested SMTP delivery test check', deliveryTest: request.params.deliveryTest });
+
+                let deliveryStatus = (await redis.hgetall(`${REDIS_PREFIX}test-send:${request.params.deliveryTest}`)) || {};
+                if (deliveryStatus.success === 'false') {
+                    let err = new Error(`Failed to deliver email`);
+                    err.statusCode = 500;
+                    err.details = deliveryStatus;
+                    throw err;
+                }
+
+                let headers = {
+                    'Content-Type': 'application/json',
+                    'User-Agent': `${packageData.name}/${packageData.version} (+${packageData.homepage})`
+                };
+
+                let res = await fetchCmd(`${SMTP_TEST_HOST}/test-address/${request.params.deliveryTest}`, {
+                    method: 'get',
+                    headers,
+                    dispatcher: httpAgent.retry
+                });
+
+                if (!res.ok) {
+                    let err = new Error(`Invalid response: ${res.status} ${res.statusText}`);
+                    err.statusCode = res.status;
+
+                    try {
+                        err.details = await res.json();
+                    } catch (err) {
+                        // ignore
+                    }
+
+                    throw err;
+                }
+
+                let testResponse = await res.json();
+
+                let success = testResponse && testResponse.status === 'success'; //Default
+
+                if (testResponse && success) {
+                    let mainSig =
+                        testResponse.dkim &&
+                        testResponse.dkim.results &&
+                        testResponse.dkim.results.find(entry => entry && entry.status && entry.status.result === 'pass' && entry.status.aligned);
+
+                    if (!mainSig) {
+                        mainSig =
+                            testResponse.dkim &&
+                            testResponse.dkim.results &&
+                            testResponse.dkim.results.find(entry => entry && entry.status && entry.status.result === 'pass');
+                    }
+
+                    if (!mainSig) {
+                        mainSig = testResponse.dkim && testResponse.dkim.results && testResponse.dkim.results[0];
+                    }
+
+                    testResponse.mainSig = mainSig || {
+                        status: {
+                            result: 'none'
+                        }
+                    };
+
+                    if (testResponse.spf && testResponse.spf.status && testResponse.spf.status.comment) {
+                        testResponse.spf.status.comment = testResponse.spf.status.comment.replace(/^[^:\s]+:s*/, '');
+                    }
+                }
+
+                if (testResponse) {
+                    if (testResponse.status === 'success') {
+                        delete testResponse.status;
+                    }
+                    delete testResponse.user;
+                }
+
+                return Object.assign({ success }, testResponse || {});
+            } catch (err) {
+                request.logger.error({ msg: 'API request failed', err });
+                if (Boom.isBoom(err)) {
+                    throw err;
+                }
+                let error = Boom.boomify(err, { statusCode: err.statusCode || 500 });
+                if (err.code) {
+                    error.output.payload.code = err.code;
+                }
+                if (err.details) {
+                    error.output.payload.details = err.details;
+                }
+                throw error;
+            }
+        },
+        options: {
+            description: 'Check test status',
+            notes: 'Check delivery test status',
+            tags: ['api', 'Delivery Test'],
+
+            auth: {
+                strategy: 'api-token',
+                mode: 'required'
+            },
+            cors: CORS_CONFIG,
+
+            validate: {
+                options: {
+                    stripUnknown: false,
+                    abortEarly: false,
+                    convert: true
+                },
+                failAction,
+
+                params: Joi.object({
+                    deliveryTest: Joi.string()
+                        .guid({
+                            version: ['uuidv4', 'uuidv5']
+                        })
+                        .example('6420a6ad-7f82-4e4f-8112-82a9dad1f34d')
+                        .required()
+                        .description('Test ID')
+                }).label('DeliveryCheckParams')
+            },
+
+            response: {
+                schema: Joi.object({
+                    success: Joi.boolean().example(true).description('Was the test completed').label('ResponseDeliveryCheckSuccess'),
+                    dkim: Joi.object().unknown().description('DKIM results').label('DkimResults'),
+                    spf: Joi.object().unknown().description('SPF results').label('SpfResults'),
+                    dmarc: Joi.object().unknown().description('DMARC results').label('DmarcResults'),
+                    bimi: Joi.object().unknown().description('BIMI results').label('BimiResults'),
+                    arc: Joi.object().unknown().description('ARC results').label('ArcResults'),
+                    mainSig: Joi.object()
+                        .unknown()
+                        .description('Primary DKIM signature. `status.aligned` should be set, otherwise DKIM check should not be considered as passed.')
+                        .label('MainSignature')
+                }).label('DeliveryCheckResponse'),
+                failAction: 'log'
+            }
+        }
+    });
+}
+
+module.exports = init;

package/lib/api-routes/export-routes.js

@@ -8,18 +8,7 @@ const { failAction } = require('../tools');
 const { accountIdSchema, exportRequestSchema, exportStatusSchema, exportListSchema, exportIdSchema } = require('../schemas');
 const getSecret = require('../get-secret');
 const { createDecryptStream } = require('../stream-encrypt');
-
-function handleError(request, err) {
-    request.logger.error({ msg: 'API request failed', err });
-    if (Boom.isBoom(err)) {
-        throw err;
-    }
-    const error = Boom.boomify(err, { statusCode: err.statusCode || 500 });
-    if (err.code) {
-        error.output.payload.code = err.code;
-    }
-    throw error;
-}
+const { handleError } = require('./route-helpers');
 
 async function init(args) {
     const { server, CORS_CONFIG } = args;