ntfy-reverse-proxy 2.0.4 → 2.1.0

package/build/src/worker/handlers.js

@@ -9,6 +9,15 @@ import { respond } from './pipeline/respond.js';
 import { route } from './pipeline/route.js';
 import { send } from './pipeline/send.js';
 import { split } from './pipeline/split.js';
+function shouldNotifyError(ctx, category) {
+    if (ctx['error_topic'] === undefined) {
+        return false;
+    }
+    if (ctx['error_events'] === undefined) {
+        return true;
+    }
+    return ctx['error_events'].includes(category);
+}
 async function handleRequest(request, config, kv) {
     try {
         const received = await receive(request, config['settings']['base_domain']);
@@ -17,7 +26,8 @@ async function handleRequest(request, config, kv) {
         }
         if (received['error'] !== undefined) {
             return new Response(JSON.stringify({
-                status: 'error', message: received['error'],
+                status: 'error',
+                message: received['error'],
             }, null, 2), {
                 status: 405,
                 headers: { 'Content-Type': 'application/json' },
@@ -33,7 +43,8 @@ async function handleRequest(request, config, kv) {
             || routed['resolvedServers'] === undefined
             || routed['primaryServer'] === undefined) {
             return new Response(JSON.stringify({
-                status: 'error', message: routed['error'] ?? 'No context found',
+                status: 'error',
+                message: routed['error'] ?? 'No context found',
             }, null, 2), {
                 status: 404,
                 headers: { 'Content-Type': 'application/json' },
@@ -43,30 +54,32 @@ async function handleRequest(request, config, kv) {
         const resolvedServers = routed['resolvedServers'];
         const primaryServer = routed['primaryServer'];
         const authResult = authenticate({
-            type: 'http', ...(ctx['token'] !== undefined ? { token: ctx['token'] } : {}),
+            type: 'http',
+            ...((ctx['token'] !== undefined) ? { token: ctx['token'] } : {}),
         }, {
-            authorization: received['headers'].get('authorization') ?? undefined, from: undefined,
+            authorization: received['headers'].get('authorization') ?? undefined,
+            from: undefined,
         });
         if (authResult['authenticated'] === false) {
-            if (ctx['error_topic'] !== undefined) {
+            if (ctx['error_topic'] !== undefined && shouldNotifyError(ctx, 'authentication') === true) {
                 try {
-                    const errorAttachmentHeaderEntries = [...received['headers'].entries()].map((entry) => {
-                        const entryName = entry[0];
-                        const entryValue = entry[1];
-                        if (entryName.toLowerCase() === 'authorization') {
+                    const authErrorAttachmentHeaderEntries = [...received['headers'].entries()].map((entry) => {
+                        const authEntryName = entry[0];
+                        const authEntryValue = entry[1];
+                        if (authEntryName.toLowerCase() === 'authorization') {
                             return [
-                                entryName,
+                                authEntryName,
                                 'REDACTED',
                             ];
                         }
                         return [
-                            entryName,
-                            entryValue,
+                            authEntryName,
+                            authEntryValue,
                         ];
                     });
-                    const errorAttachmentHeaders = Object.fromEntries(errorAttachmentHeaderEntries);
-                    const errorAttachmentParsed = parse(received['rawBody'], received['headers']);
-                    const errorAttachmentData = {
+                    const authErrorAttachmentHeaders = Object.fromEntries(authErrorAttachmentHeaderEntries);
+                    const authErrorAttachmentParsed = parse(received['rawBody'], received['headers']);
+                    const authErrorAttachmentData = {
                         timestamp: new Date().toISOString(),
                         error: {
                             type: 'authentication',
@@ -80,20 +93,20 @@ async function handleRequest(request, config, kv) {
                         request: {
                             method: received['method'],
                             url: received['url'],
-                            headers: errorAttachmentHeaders,
-                            ...(received['cfProperties'] !== undefined ? { cf: received['cfProperties'] } : {}),
+                            headers: authErrorAttachmentHeaders,
+                            ...((received['cfProperties'] !== undefined) ? { cf: received['cfProperties'] } : {}),
                         },
                         response: {
                             status: 403,
                         },
                         body: {
-                            type: errorAttachmentParsed['type'],
-                            ...(errorAttachmentParsed['json'] !== undefined ? { json: errorAttachmentParsed['json'] } : {}),
-                            ...(errorAttachmentParsed['text'] !== undefined ? { text: errorAttachmentParsed['text'] } : {}),
+                            type: authErrorAttachmentParsed['type'],
+                            ...((authErrorAttachmentParsed['json'] !== undefined) ? { json: authErrorAttachmentParsed['json'] } : {}),
+                            ...((authErrorAttachmentParsed['text'] !== undefined) ? { text: authErrorAttachmentParsed['text'] } : {}),
                         },
                     };
-                    const errorAttachmentJson = JSON.stringify(errorAttachmentData, null, 2);
-                    const errorAttachmentBuffer = new TextEncoder().encode(errorAttachmentJson).buffer;
+                    const authErrorAttachmentJson = JSON.stringify(authErrorAttachmentData, null, 2);
+                    const authErrorAttachmentBuffer = new TextEncoder().encode(authErrorAttachmentJson).buffer;
                     await send({
                         messages: [],
                         servers: resolvedServers,
@@ -101,7 +114,7 @@ async function handleRequest(request, config, kv) {
                         topic: ctx['error_topic'],
                         mode: ctx['mode'],
                         visitorIp: received['headers'].get('cf-connecting-ip') ?? undefined,
-                        attachment: errorAttachmentBuffer,
+                        attachment: authErrorAttachmentBuffer,
                         filename: 'error-debug.json',
                         attachmentHeaders: { 'X-Title': 'Authentication Error' },
                     });
@@ -110,7 +123,8 @@ async function handleRequest(request, config, kv) {
                 }
             }
             return new Response(JSON.stringify({
-                status: 'error', message: 'Unauthorized',
+                status: 'error',
+                message: 'Unauthorized',
             }, null, 2), {
                 status: 403,
                 headers: { 'Content-Type': 'application/json' },
@@ -119,7 +133,8 @@ async function handleRequest(request, config, kv) {
         const parsed = parse(received['rawBody'], received['headers']);
         if (parsed['type'] === 'unknown') {
             return new Response(JSON.stringify({
-                status: 'error', message: 'Unknown content type',
+                status: 'error',
+                message: 'Unknown content type',
             }, null, 2), {
                 status: 400,
                 headers: { 'Content-Type': 'application/json' },
@@ -128,7 +143,9 @@ async function handleRequest(request, config, kv) {
         const rawBodyJsonStr = (parsed['json'] !== undefined) ? JSON.stringify(parsed['json']) : '';
         const rawBodyText = parsed['text'] ?? ((rawBodyJsonStr.length > 0) ? rawBodyJsonStr : undefined);
         const debugRawRequestStr = JSON.stringify({
-            debug: 'raw_request', type: parsed['type'], body: rawBodyText ?? '(binary)',
+            debug: 'raw_request',
+            type: parsed['type'],
+            body: rawBodyText ?? '(binary)',
         });
         console.info(debugRawRequestStr);
         const input = parsed['json']
@@ -140,43 +157,43 @@ async function handleRequest(request, config, kv) {
             interpreted = await interpret(ctx['interpreter'], input, (kv !== undefined) ? { kv } : {});
         }
         catch (err) {
-            const errorName = (err instanceof Error) ? err.name : 'Error';
-            const errorMessage = (err instanceof Error) ? err.message : 'Unknown interpretation error';
-            const errorStack = (err instanceof Error) ? err.stack : undefined;
-            let errorIssues = undefined;
+            const interpretErrorName = (err instanceof Error) ? err.name : 'Error';
+            const interpretErrorMessage = (err instanceof Error) ? err.message : 'Unknown interpretation error';
+            const interpretErrorStack = (err instanceof Error) ? err.stack : undefined;
+            let interpretErrorIssues = undefined;
             if (err instanceof Error
                 && err.name === 'ZodError'
                 && 'issues' in err) {
-                const errorIssuesRaw = Reflect.get(err, 'issues');
-                if (Array.isArray(errorIssuesRaw) === true) {
-                    errorIssues = errorIssuesRaw;
+                const interpretErrorIssuesRaw = Reflect.get(err, 'issues');
+                if (Array.isArray(interpretErrorIssuesRaw) === true) {
+                    interpretErrorIssues = interpretErrorIssuesRaw;
                 }
             }
-            if (ctx['error_topic'] !== undefined) {
+            if (ctx['error_topic'] !== undefined && shouldNotifyError(ctx, 'interpretation') === true) {
                 try {
-                    const errorAttachmentHeaderEntries = [...received['headers'].entries()].map((entry) => {
-                        const entryName = entry[0];
-                        const entryValue = entry[1];
-                        if (entryName.toLowerCase() === 'authorization') {
+                    const interpretErrorAttachmentHeaderEntries = [...received['headers'].entries()].map((entry) => {
+                        const interpretEntryName = entry[0];
+                        const interpretEntryValue = entry[1];
+                        if (interpretEntryName.toLowerCase() === 'authorization') {
                             return [
-                                entryName,
+                                interpretEntryName,
                                 'REDACTED',
                             ];
                         }
                         return [
-                            entryName,
-                            entryValue,
+                            interpretEntryName,
+                            interpretEntryValue,
                         ];
                     });
-                    const errorAttachmentHeaders = Object.fromEntries(errorAttachmentHeaderEntries);
-                    const errorAttachmentData = {
+                    const interpretErrorAttachmentHeaders = Object.fromEntries(interpretErrorAttachmentHeaderEntries);
+                    const interpretErrorAttachmentData = {
                         timestamp: new Date().toISOString(),
                         error: {
                             type: 'interpretation',
-                            name: errorName,
-                            message: errorMessage,
-                            ...(errorStack !== undefined ? { stack: errorStack } : {}),
-                            ...(errorIssues !== undefined ? { issues: errorIssues } : {}),
+                            name: interpretErrorName,
+                            message: interpretErrorMessage,
+                            ...((interpretErrorStack !== undefined) ? { stack: interpretErrorStack } : {}),
+                            ...((interpretErrorIssues !== undefined) ? { issues: interpretErrorIssues } : {}),
                         },
                         context: {
                             name: ctx['name'],
@@ -186,20 +203,20 @@ async function handleRequest(request, config, kv) {
                         request: {
                             method: received['method'],
                             url: received['url'],
-                            headers: errorAttachmentHeaders,
-                            ...(received['cfProperties'] !== undefined ? { cf: received['cfProperties'] } : {}),
+                            headers: interpretErrorAttachmentHeaders,
+                            ...((received['cfProperties'] !== undefined) ? { cf: received['cfProperties'] } : {}),
                         },
                         response: {
                             status: 422,
                         },
                         body: {
                             type: parsed['type'],
-                            ...(parsed['json'] !== undefined ? { json: parsed['json'] } : {}),
-                            ...(parsed['text'] !== undefined ? { text: parsed['text'] } : {}),
+                            ...((parsed['json'] !== undefined) ? { json: parsed['json'] } : {}),
+                            ...((parsed['text'] !== undefined) ? { text: parsed['text'] } : {}),
                         },
                     };
-                    const errorAttachmentJson = JSON.stringify(errorAttachmentData, null, 2);
-                    const errorAttachmentBuffer = new TextEncoder().encode(errorAttachmentJson).buffer;
+                    const interpretErrorAttachmentJson = JSON.stringify(interpretErrorAttachmentData, null, 2);
+                    const interpretErrorAttachmentBuffer = new TextEncoder().encode(interpretErrorAttachmentJson).buffer;
                     await send({
                         messages: [],
                         servers: resolvedServers,
@@ -207,7 +224,7 @@ async function handleRequest(request, config, kv) {
                         topic: ctx['error_topic'],
                         mode: ctx['mode'],
                         visitorIp: received['headers'].get('cf-connecting-ip') ?? undefined,
-                        attachment: errorAttachmentBuffer,
+                        attachment: interpretErrorAttachmentBuffer,
                         filename: 'error-debug.json',
                         attachmentHeaders: { 'X-Title': 'Interpretation Error' },
                     });
@@ -216,7 +233,8 @@ async function handleRequest(request, config, kv) {
                 }
             }
             return new Response(JSON.stringify({
-                status: 'error', message: errorMessage,
+                status: 'error',
+                message: interpretErrorMessage,
             }, null, 2), {
                 status: 422,
                 headers: { 'Content-Type': 'application/json' },
@@ -263,11 +281,13 @@ async function handleRequest(request, config, kv) {
         return response;
     }
     catch (err) {
-        const errorMessage = (err instanceof Error) ? err.message : 'Internal server error';
+        const fatalErrorMessage = (err instanceof Error) ? err.message : 'Internal server error';
         const body = (config['settings']['show_response_output'] === true) ? {
-            status: 'error', message: errorMessage,
+            status: 'error',
+            message: fatalErrorMessage,
         } : {
-            status: 'error', message: 'Internal server error',
+            status: 'error',
+            message: 'Internal server error',
         };
         return new Response(JSON.stringify(body, null, 2), {
             status: 500,
@@ -276,158 +296,174 @@ async function handleRequest(request, config, kv) {
     }
 }
 async function handleEmail(rawEmail, from, config, kv) {
-    const parsed = await parseEmail(rawEmail);
-    const debugRawEmailStr = JSON.stringify({
-        debug: 'raw_email', from, to: parsed['to'], subject: parsed['subject'], rawEmail,
-    });
-    console.info(debugRawEmailStr);
-    const recipientLocalPart = parsed['to'].split('@')[0] ?? '';
-    const routed = route('email', recipientLocalPart, config);
-    if (routed['error'] !== undefined
-        || routed['context'] === undefined
-        || routed['resolvedServers'] === undefined
-        || routed['primaryServer'] === undefined) {
-        return;
-    }
-    const ctx = routed['context'];
-    const resolvedServers = routed['resolvedServers'];
-    const primaryServer = routed['primaryServer'];
-    const authResult = authenticate({
-        type: 'email', ...(ctx['allowed_from'] !== undefined ? { allowed_from: ctx['allowed_from'] } : {}),
-    }, {
-        authorization: undefined, from,
-    });
-    if (authResult['authenticated'] === false) {
-        if (ctx['error_topic'] !== undefined) {
-            try {
-                const errorAttachmentData = {
-                    timestamp: new Date().toISOString(),
-                    error: {
-                        type: 'authentication',
-                        message: authResult['reason'],
-                    },
-                    context: {
-                        name: ctx['name'],
-                        interpreter: ctx['interpreter'],
-                        stage: 'authentication',
-                    },
-                    email: {
-                        from,
-                        to: parsed['to'],
-                        subject: parsed['subject'],
-                        textBody: parsed['textBody'],
-                    },
-                };
-                const errorAttachmentJson = JSON.stringify(errorAttachmentData, null, 2);
-                const errorAttachmentBuffer = new TextEncoder().encode(errorAttachmentJson).buffer;
-                await send({
-                    messages: [],
-                    servers: resolvedServers,
-                    primaryServer,
-                    topic: ctx['error_topic'],
-                    mode: ctx['mode'],
-                    attachment: errorAttachmentBuffer,
-                    filename: 'error-debug.json',
-                    attachmentHeaders: { 'X-Title': 'Email Authentication Error' },
-                });
-            }
-            catch {
-            }
-        }
-        return;
-    }
-    const emailInput = {
-        subject: parsed['subject'],
-        textBody: parsed['textBody'],
-        from: parsed['from'],
-        to: parsed['to'],
-    };
-    let interpreted = undefined;
     try {
-        interpreted = await interpret(ctx['interpreter'], emailInput, (kv !== undefined) ? { kv } : {});
-    }
-    catch (err) {
-        const errorName = (err instanceof Error) ? err.name : 'Error';
-        const errorMessage = (err instanceof Error) ? err.message : 'Unknown interpretation error';
-        const errorStack = (err instanceof Error) ? err.stack : undefined;
-        let errorIssues = undefined;
-        if (err instanceof Error
-            && err.name === 'ZodError'
-            && 'issues' in err) {
-            const errorIssuesRaw = Reflect.get(err, 'issues');
-            if (Array.isArray(errorIssuesRaw) === true) {
-                errorIssues = errorIssuesRaw;
+        const parsed = await parseEmail(rawEmail);
+        const debugRawEmailStr = JSON.stringify({
+            debug: 'raw_email',
+            from,
+            to: parsed['to'],
+            subject: parsed['subject'],
+            rawEmail,
+        });
+        console.info(debugRawEmailStr);
+        const recipientLocalPart = parsed['to'].split('@')[0] ?? '';
+        const routed = route('email', recipientLocalPart, config);
+        if (routed['error'] !== undefined
+            || routed['context'] === undefined
+            || routed['resolvedServers'] === undefined
+            || routed['primaryServer'] === undefined) {
+            return;
+        }
+        const ctx = routed['context'];
+        const resolvedServers = routed['resolvedServers'];
+        const primaryServer = routed['primaryServer'];
+        const authResult = authenticate({
+            type: 'email',
+            ...((ctx['allowed_from'] !== undefined) ? { allowed_from: ctx['allowed_from'] } : {}),
+        }, {
+            authorization: undefined,
+            from,
+        });
+        if (authResult['authenticated'] === false) {
+            if (ctx['error_topic'] !== undefined && shouldNotifyError(ctx, 'authentication') === true) {
+                try {
+                    const authErrorAttachmentData = {
+                        timestamp: new Date().toISOString(),
+                        error: {
+                            type: 'authentication',
+                            message: authResult['reason'],
+                        },
+                        context: {
+                            name: ctx['name'],
+                            interpreter: ctx['interpreter'],
+                            stage: 'authentication',
+                        },
+                        email: {
+                            from,
+                            to: parsed['to'],
+                            subject: parsed['subject'],
+                            textBody: parsed['textBody'],
+                        },
+                    };
+                    const authErrorAttachmentJson = JSON.stringify(authErrorAttachmentData, null, 2);
+                    const authErrorAttachmentBuffer = new TextEncoder().encode(authErrorAttachmentJson).buffer;
+                    await send({
+                        messages: [],
+                        servers: resolvedServers,
+                        primaryServer,
+                        topic: ctx['error_topic'],
+                        mode: ctx['mode'],
+                        attachment: authErrorAttachmentBuffer,
+                        filename: 'error-debug.json',
+                        attachmentHeaders: { 'X-Title': 'Email Authentication Error' },
+                    });
+                }
+                catch {
+                }
             }
+            return;
+        }
+        const emailInput = {
+            subject: parsed['subject'],
+            textBody: parsed['textBody'],
+            from: parsed['from'],
+            to: parsed['to'],
+        };
+        let interpreted = undefined;
+        try {
+            interpreted = await interpret(ctx['interpreter'], emailInput, (kv !== undefined) ? { kv } : {});
         }
-        if (ctx['error_topic'] !== undefined) {
-            try {
-                const errorAttachmentData = {
-                    timestamp: new Date().toISOString(),
-                    error: {
-                        type: 'interpretation',
-                        name: errorName,
-                        message: errorMessage,
-                        ...(errorStack !== undefined ? { stack: errorStack } : {}),
-                        ...(errorIssues !== undefined ? { issues: errorIssues } : {}),
-                    },
-                    context: {
-                        name: ctx['name'],
-                        interpreter: ctx['interpreter'],
-                        stage: 'interpretation',
-                    },
-                    email: {
-                        from,
-                        to: parsed['to'],
-                        subject: parsed['subject'],
-                        textBody: parsed['textBody'],
-                    },
-                };
-                const errorAttachmentJson = JSON.stringify(errorAttachmentData, null, 2);
-                const errorAttachmentBuffer = new TextEncoder().encode(errorAttachmentJson).buffer;
-                await send({
-                    messages: [],
-                    servers: resolvedServers,
-                    primaryServer,
-                    topic: ctx['error_topic'],
-                    mode: ctx['mode'],
-                    attachment: errorAttachmentBuffer,
-                    filename: 'error-debug.json',
-                    attachmentHeaders: { 'X-Title': 'Email Interpretation Error' },
-                });
+        catch (err) {
+            const errorName = (err instanceof Error) ? err.name : 'Error';
+            const errorMessage = (err instanceof Error) ? err.message : 'Unknown interpretation error';
+            const errorStack = (err instanceof Error) ? err.stack : undefined;
+            let errorIssues = undefined;
+            if (err instanceof Error
+                && err.name === 'ZodError'
+                && 'issues' in err) {
+                const errorIssuesRaw = Reflect.get(err, 'issues');
+                if (Array.isArray(errorIssuesRaw) === true) {
+                    errorIssues = errorIssuesRaw;
+                }
             }
-            catch {
+            if (ctx['error_topic'] !== undefined && shouldNotifyError(ctx, 'interpretation') === true) {
+                try {
+                    const interpretErrorAttachmentData = {
+                        timestamp: new Date().toISOString(),
+                        error: {
+                            type: 'interpretation',
+                            name: errorName,
+                            message: errorMessage,
+                            ...((errorStack !== undefined) ? { stack: errorStack } : {}),
+                            ...((errorIssues !== undefined) ? { issues: errorIssues } : {}),
+                        },
+                        context: {
+                            name: ctx['name'],
+                            interpreter: ctx['interpreter'],
+                            stage: 'interpretation',
+                        },
+                        email: {
+                            from,
+                            to: parsed['to'],
+                            subject: parsed['subject'],
+                            textBody: parsed['textBody'],
+                        },
+                    };
+                    const interpretErrorAttachmentJson = JSON.stringify(interpretErrorAttachmentData, null, 2);
+                    const interpretErrorAttachmentBuffer = new TextEncoder().encode(interpretErrorAttachmentJson).buffer;
+                    await send({
+                        messages: [],
+                        servers: resolvedServers,
+                        primaryServer,
+                        topic: ctx['error_topic'],
+                        mode: ctx['mode'],
+                        attachment: interpretErrorAttachmentBuffer,
+                        filename: 'error-debug.json',
+                        attachmentHeaders: { 'X-Title': 'Email Interpretation Error' },
+                    });
+                }
+                catch {
+                }
             }
+            return;
         }
-        return;
-    }
-    if (interpreted === null) {
-        return;
+        if (interpreted === null) {
+            return;
+        }
+        if (interpreted['notification']['title'] === undefined) {
+            Reflect.set(interpreted['notification'], 'title', ctx['name']);
+        }
+        const formatted = format(interpreted['notification'], {
+            showVisitorInfo: ctx['show_visitor_info'],
+        });
+        const messages = split(formatted['body'], formatted['headers']);
+        const sendResult = await send({
+            messages,
+            servers: resolvedServers,
+            primaryServer,
+            topic: ctx['topic'],
+            mode: ctx['mode'],
+            attachment: interpreted['attachment'],
+            filename: interpreted['notification']['filename'],
+        });
+        const debugLogStr = JSON.stringify({
+            context: ctx['name'],
+            interpreter: ctx['interpreter'],
+            servers: sendResult['results'],
+            bodySize: formatted['body'].length,
+            parts: messages.length,
+        }, null, 2);
+        console.info(debugLogStr);
     }
-    if (interpreted['notification']['title'] === undefined) {
-        Reflect.set(interpreted['notification'], 'title', ctx['name']);
+    catch (err) {
+        const fatalErrorMessage = (err instanceof Error) ? err.message : 'Unknown error';
+        const fatalDebugStr = JSON.stringify({
+            debug: 'fatal_email_error',
+            error: fatalErrorMessage,
+        });
+        console.info(fatalDebugStr);
     }
-    const formatted = format(interpreted['notification'], {
-        showVisitorInfo: ctx['show_visitor_info'],
-    });
-    const messages = split(formatted['body'], formatted['headers']);
-    const sendResult = await send({
-        messages,
-        servers: resolvedServers,
-        primaryServer,
-        topic: ctx['topic'],
-        mode: ctx['mode'],
-        attachment: interpreted['attachment'],
-        filename: interpreted['notification']['filename'],
-    });
-    const debugLogStr = JSON.stringify({
-        context: ctx['name'],
-        interpreter: ctx['interpreter'],
-        servers: sendResult['results'],
-        bodySize: formatted['body'].length,
-        parts: messages.length,
-    }, null, 2);
-    console.info(debugLogStr);
     return;
 }
-export { handleEmail, handleRequest, };
+export { handleEmail, handleRequest, shouldNotifyError, };
 //# sourceMappingURL=handlers.js.map