@zyno-io/dk-server-foundation 26.216.430

package/src/services/logger.ts

@@ -0,0 +1,258 @@
+import { ClassType } from '@deepkit/core';
+import { DefaultFormatter, LogData, Logger, LoggerFormatter, LoggerLevel } from '@deepkit/logger';
+import { DatabaseError } from '@deepkit/orm';
+import { AxiosError, isAxiosError } from 'axios';
+import debug from 'debug';
+import { pino, stdTimeFunctions } from 'pino';
+
+import { isDevFeatureEnabled } from '../app/config';
+import { isDevelopment, isTest } from '../app/const';
+import { DecoratedError, getContext, isError, reportError, withContextData } from '../helpers';
+import { r } from '../app/resolver';
+
+export const shouldUsePinoPretty = isDevFeatureEnabled(process.env.ENABLE_PINO_PRETTY);
+export const shouldUseSingleLine = isDevFeatureEnabled(process.env.ENABLE_PINO_SINGLE_LINE);
+export const LoggerContextProps: string[] = ['http', 'job'];
+export const LoggerContextSymbol = Symbol('LoggerContext');
+
+const PinoSeverityMap = {
+    [LoggerLevel.none]: 'DEFAULT',
+    [LoggerLevel.alert]: 'ALERT',
+    [LoggerLevel.error]: 'ERROR',
+    [LoggerLevel.warning]: 'WARNING',
+    [LoggerLevel.log]: 'NOTICE',
+    [LoggerLevel.info]: 'INFO',
+    [LoggerLevel.debug]: 'DEBUG',
+    [LoggerLevel.debug2]: 'DEBUG'
+} as const;
+type Severity = (typeof PinoSeverityMap)[keyof typeof PinoSeverityMap];
+const InvertedPinoSeverityMap: Record<Severity, number> = {
+    DEFAULT: LoggerLevel.none,
+    ALERT: LoggerLevel.alert,
+    ERROR: LoggerLevel.error,
+    WARNING: LoggerLevel.warning,
+    NOTICE: LoggerLevel.log,
+    INFO: LoggerLevel.info,
+    DEBUG: LoggerLevel.debug
+} as const;
+
+const logStream = shouldUsePinoPretty
+    ? (() => {
+          // eslint-disable-next-line @typescript-eslint/no-require-imports
+          const PinoPretty = require('pino-pretty');
+          return PinoPretty.default({
+              colorize: true,
+              singleLine: shouldUseSingleLine,
+              messageFormat: '\x1b[35m{scope} \x1b[36m{message}',
+              ignore: 'scope',
+              level: process.env.LOG_LEVEL || (process.env.NODE_ENV === 'production' ? 'info' : 'debug'),
+              levelFirst: true,
+              levelKey: 'severity',
+              customLevels: Object.entries(InvertedPinoSeverityMap)
+                  .map(([severity, level]) => `${severity}:${level}`)
+                  .join(','),
+              messageKey: 'message',
+              customColors: 'alert:bgRed,error:red,warning:yellow,notice:green,info:blue,debug:gray,default:white',
+              sync: isTest
+          });
+      })()
+    : undefined;
+
+export const pinoLogger = pino(
+    {
+        formatters: {
+            level: label => ({ severity: label }),
+            bindings: isDevelopment ? () => ({ pid: process.pid }) : () => ({})
+        },
+        timestamp: stdTimeFunctions.isoTime,
+        messageKey: 'message',
+        customLevels: InvertedPinoSeverityMap,
+        useOnlyCustomLevels: true,
+        level: 'DEFAULT'
+    },
+    logStream
+);
+
+export class ExtendedLogger extends Logger {
+    protected scopeData?: LogData;
+
+    addFormatter(formatter: LoggerFormatter): void {
+        // - the server:start command injects DefaultFormatter after logger is instantiated
+        // - the message that's transformed by DefaultFormatter is not used by the default JSON transport
+        // - the color remover only removes colors from the prop the JSON transport *isn't* using
+        // so don't allow the default formatter to be added, then use our custom JSON formatter
+        // to read the original message prop after the color has been stripped
+        if (formatter instanceof DefaultFormatter) {
+            return;
+        }
+
+        super.addFormatter(formatter);
+    }
+
+    scoped(shortName: string, data?: LogData): ExtendedLogger {
+        const name = this.scope.length ? `${this.scope}:${shortName}` : shortName;
+
+        // If data is provided, always create a new instance to avoid sharing scopeData
+        // between different callers (e.g., different SIP dialogs with different callIds)
+        if (data) {
+            const scoped = new ExtendedLogger(this.transporter, this.formatter, name);
+            scoped.level = this.level;
+            // Inherit parent's scopeData and merge with provided data
+            scoped.scopeData = { ...this.scopeData, ...data };
+            return scoped;
+        }
+
+        // For bare scoped loggers (no data), use caching
+        if (!this.scopes[name]) {
+            const scoped = new ExtendedLogger(this.transporter, this.formatter, name);
+            scoped.level = this.level;
+            if (this.scopeData) {
+                scoped.scopeData = { ...this.scopeData };
+            }
+            this.scopes[name] = scoped;
+        }
+
+        return this.scopes[name] as ExtendedLogger;
+    }
+
+    // the first parameter can be a string or an object
+    // if the first parameter is a string, the second can be an object
+    // any funkier configurations than that, and we start stuffing indexed args onto the data object
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    protected send(messages: any[], level: LoggerLevel, data?: LogData) {
+        let err = isError(messages[0]) ? messages.shift() : isError(messages[1]) ? messages.splice(1, 1).shift() : undefined;
+        const message = typeof messages[0] === 'string' ? messages.shift() : '';
+        if (messages.length === 1 && typeof messages[0] === 'object') {
+            data = Object.assign(data ?? {}, messages[0]);
+        } else if (messages.length) {
+            data = data || {};
+            messages.forEach((msg, idx) => {
+                data![`arg${idx}`] = msg;
+            });
+        } else {
+            data = undefined;
+        }
+
+        if (!err && data && 'err' in data) {
+            err = data.err;
+            delete data.err;
+        }
+
+        if (this.scopeData) {
+            data = Object.assign(data ?? {}, this.scopeData);
+        }
+
+        const strippedMessage = this.stripColors(message);
+
+        // clean up errors that are too large and don't provide value to us
+        if (err instanceof DatabaseError) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            delete (err as any).entity;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            delete (err as any).classSchema;
+        } else if (isAxiosError(err)) {
+            err = transformAxiosError(err);
+        }
+
+        pinoLogger[PinoSeverityMap[level]](
+            {
+                ...(err && { err }),
+                ...(this.scope && { scope: this.scope }),
+                ...data,
+                ...this.getContextProps()
+            },
+            strippedMessage
+        );
+
+        if (err || level === LoggerLevel.alert || level === LoggerLevel.error) {
+            this.handleError(level, strippedMessage, err, data);
+        }
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    debug(...message: any[]): void {
+        if (!debug(this.scope).enabled) return;
+        this.send(message, LoggerLevel.debug);
+    }
+
+    getContextProps() {
+        const context = getContext();
+        if (!context) return;
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const entries: [string, any][] = [];
+        for (const prop of LoggerContextProps) {
+            if (context[prop]) {
+                entries.push([prop, context[prop]]);
+            }
+        }
+        if (context[LoggerContextSymbol]) {
+            for (const [key, value] of Object.entries(context[LoggerContextSymbol])) {
+                entries.push([key, value]);
+            }
+        }
+        if (!entries.length) return;
+
+        return Object.fromEntries(entries);
+    }
+
+    stripColors(message: string) {
+        return message.includes('<') ? message.replace(/<(\/)?([a-zA-Z]+)>/g, '') : message;
+    }
+
+    setScopeData(data?: LogData) {
+        this.scopeData = data;
+        return this;
+    }
+
+    handleError(level: LoggerLevel, message: string | undefined, err: Error | undefined, data: LogData | undefined): void {
+        const resolvedErr = message && message !== 'Controller error' ? new Error(message) : (err ?? new Error('Unknown error'));
+        (resolvedErr as DecoratedError).cause = resolvedErr !== err ? err : undefined;
+        reportError(level, resolvedErr, {
+            data,
+            scope: this.scope || undefined,
+            scopeData: this.scopeData,
+            ...this.getContextProps()
+        });
+    }
+}
+
+export function createLogger(subject: string | InstanceType<ClassType>, defaultData?: LogData) {
+    const name = typeof subject === 'string' ? subject : subject.constructor.name;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return r<ExtendedLogger>(Logger as any)
+        .scoped(name)
+        .setScopeData(defaultData);
+}
+
+export function withLoggerContext<T>(data: LogData, fn: () => Promise<T>): Promise<T> {
+    const existingContext = getContext();
+    return withContextData(
+        {
+            [LoggerContextSymbol]: {
+                ...existingContext?.[LoggerContextSymbol],
+                ...data
+            }
+        },
+        fn
+    );
+}
+
+function transformAxiosError(err: AxiosError) {
+    return {
+        code: err.code,
+        message: err.message,
+        stack: err.stack,
+        request: {
+            url: err.config?.url,
+            method: err.config?.method,
+            headers: err.config?.headers,
+            data: err.config?.data
+        },
+        response: {
+            status: err.response?.status,
+            headers: err.response?.headers,
+            data: err.response?.data
+        }
+    };
+}

package/src/services/mail/index.ts

@@ -0,0 +1,117 @@
+import { ClassType } from '@deepkit/core';
+import { ScopedLogger } from '@deepkit/logger';
+
+import { BaseAppConfig } from '../../app';
+import { toError } from '../../helpers';
+import { PostmarkProvider } from './postmark';
+import { SmtpProvider } from './smtp';
+
+const senderSuffix = process.env.APP_ENV !== 'production' ? ` (${process.env.APP_ENV}) ` : '';
+const subjectPrefix = process.env.APP_ENV !== 'production' ? `[${process.env.APP_ENV}] ` : '';
+
+export abstract class MailTemplate<T> {
+    constructor(protected data: T) {}
+    abstract subject: string;
+    abstract generateHtml(): string;
+    generateText(): string | void {
+        /** */
+    }
+}
+
+export interface MessageProperties {
+    from?: {
+        name?: string;
+        address: string;
+    };
+    to: {
+        name?: string;
+        address: string;
+    };
+    replyTo?: {
+        name?: string;
+        address: string;
+    };
+    subject: string;
+    message: string;
+    plainMessage?: string;
+    attachments?: {
+        name: string;
+        content: Buffer;
+        contentType: string;
+        cid?: string;
+    }[];
+}
+
+export interface TemplateMessageProperties<T> extends Omit<MessageProperties, 'subject' | 'message' | 'plainMessage'> {
+    template: ClassType<MailTemplate<T>>;
+    data: T;
+}
+
+export interface PreparedMessageProperties extends Omit<MessageProperties, 'to' | 'from' | 'replyTo'> {
+    to: string;
+    from: string;
+    replyTo?: string;
+}
+
+export interface MailProvider {
+    send(message: PreparedMessageProperties): Promise<string>;
+}
+
+export class MailService {
+    provider: MailProvider;
+
+    constructor(
+        private config: BaseAppConfig,
+        private logger: ScopedLogger
+    ) {
+        if (this.config.MAIL_PROVIDER === 'postmark') {
+            this.provider = new PostmarkProvider(this.config, logger);
+        } else if (this.config.MAIL_PROVIDER === 'smtp') {
+            this.provider = new SmtpProvider(this.config, logger);
+        } else {
+            throw new Error('Unsupported mail provider');
+        }
+    }
+
+    async send(params: MessageProperties) {
+        const preparedParams = this.prepare(params);
+        await this.sendPrepared(preparedParams);
+    }
+
+    async sendFromTemplate<T>(params: TemplateMessageProperties<T>) {
+        const preparedParams = this.prepareFromTemplate(params);
+        await this.sendPrepared(preparedParams);
+    }
+
+    prepare(params: MessageProperties): PreparedMessageProperties {
+        const fromName = params.from?.name || this.config.MAIL_FROM_NAME;
+        const fromAddressPrefix = fromName ? `"${fromName}${senderSuffix}" ` : '';
+        const fromAddress = params.from?.address || this.config.MAIL_FROM;
+        const replyToPrefix = params.replyTo?.name ? `"${params.replyTo.name}" ` : '';
+        const toAddressPrefix = params.to.name ? `"${params.to.name}" ` : '';
+        return {
+            ...params,
+            from: `${fromAddressPrefix}<${fromAddress}>`,
+            to: `${toAddressPrefix}<${params.to.address}>`,
+            replyTo: params.replyTo ? `${replyToPrefix}<${params.replyTo.address}>` : undefined,
+            subject: `${subjectPrefix}${params.subject}`
+        };
+    }
+
+    prepareFromTemplate<T>(params: TemplateMessageProperties<T>): PreparedMessageProperties {
+        const tpl = new params.template(params.data);
+        const message = tpl.generateHtml();
+        const plainMessage = tpl.generateText() ?? undefined;
+        return this.prepare({ ...params, message, plainMessage, subject: tpl.subject });
+    }
+
+    async sendPrepared(message: PreparedMessageProperties) {
+        try {
+            const messageId = await this.provider.send(message);
+            this.logger.info('Email sent', { to: message.to, subject: message.subject, messageId });
+        } catch (err) {
+            this.logger.error('Failed to send email', err, { to: message.to, subject: message.subject });
+            throw toError('Failed to send email', err);
+        }
+    }
+}

package/src/services/mail/postmark.ts

@@ -0,0 +1,37 @@
+import { ScopedLogger } from '@deepkit/logger';
+import { ServerClient } from 'postmark';
+
+import { BaseAppConfig } from '../../app';
+import type { MailProvider, PreparedMessageProperties } from '.';
+
+export class PostmarkProvider implements MailProvider {
+    private postmarkClient = new ServerClient(this.config.POSTMARK_SECRET!);
+
+    constructor(
+        private config: BaseAppConfig,
+        private logger: ScopedLogger
+    ) {
+        if (!this.config.POSTMARK_SECRET) {
+            throw new Error('POSTMARK_SECRET is not set');
+        }
+    }
+
+    async send(message: PreparedMessageProperties): Promise<string> {
+        const response = await this.postmarkClient.sendEmail({
+            From: message.from,
+            To: message.to,
+            Subject: message.subject,
+            HtmlBody: message.message,
+            TextBody: message.plainMessage,
+            ReplyTo: message.replyTo,
+            Attachments: message.attachments?.map(attachment => ({
+                Name: attachment.name,
+                Content: attachment.content.toString('base64'),
+                ContentType: attachment.contentType,
+                ContentID: attachment.cid ?? null,
+                ContentLength: attachment.content.length
+            }))
+        });
+        return response.MessageID;
+    }
+}

package/src/services/mail/smtp.ts

@@ -0,0 +1,46 @@
+import { ScopedLogger } from '@deepkit/logger';
+import { createTransport } from 'nodemailer';
+
+import { BaseAppConfig } from '../../app';
+import type { MailProvider, PreparedMessageProperties } from '.';
+
+export class SmtpProvider implements MailProvider {
+    private transporter = createTransport({
+        host: this.config.SMTP_HOST,
+        port: this.config.SMTP_PORT,
+        secure: this.config.SMTP_TLS,
+        auth: this.config.SMTP_USER
+            ? {
+                  user: this.config.SMTP_USER,
+                  pass: this.config.SMTP_PASSWORD_SECRET
+              }
+            : undefined
+    });
+
+    constructor(
+        private config: BaseAppConfig,
+        private logger: ScopedLogger
+    ) {
+        if (!this.config.SMTP_HOST) {
+            throw new Error('SMTP_HOST is not set');
+        }
+    }
+
+    async send(message: PreparedMessageProperties): Promise<string> {
+        const response = await this.transporter.sendMail({
+            from: message.from,
+            to: message.to,
+            subject: message.subject,
+            html: message.message,
+            text: message.plainMessage,
+            replyTo: message.replyTo,
+            attachments: message.attachments?.map(attachment => ({
+                filename: attachment.name,
+                content: attachment.content,
+                contentType: attachment.contentType,
+                cid: attachment.cid
+            }))
+        });
+        return response.messageId;
+    }
+}