@zintrust/core 0.1.0 → 0.1.2

package/src/tools/mail/drivers/Smtp.js

@@ -0,0 +1,327 @@
+import { generateUuid } from '../../../common/uuid';
+import { ErrorFactory } from '../../../exceptions/ZintrustError';
+import * as net from '../../../node-singletons/net';
+import * as tls from '../../../node-singletons/tls';
+const normalizeRecipients = (to) => (Array.isArray(to) ? to : [to]);
+const toBase64 = (value) => Buffer.from(value, 'utf8').toString('base64');
+const isNodeRuntime = () => typeof process !== 'undefined' && typeof process.versions?.node === 'string';
+const validateConfig = (config) => {
+    if (!isNodeRuntime()) {
+        throw ErrorFactory.createConfigError('SMTP driver requires Node.js runtime');
+    }
+    if (config.host.trim() === '') {
+        throw ErrorFactory.createConfigError('SMTP: missing MAIL_HOST');
+    }
+    if (!Number.isFinite(config.port) || config.port <= 0) {
+        throw ErrorFactory.createConfigError('SMTP: invalid MAIL_PORT');
+    }
+};
+const createSocket = async (config, implicitTls) => {
+    validateConfig(config);
+    return new Promise((resolve, reject) => {
+        const onError = (err) => {
+            reject(ErrorFactory.createConnectionError('SMTP connection failed', {
+                host: config.host,
+                port: config.port,
+                secure: implicitTls,
+                error: err,
+            }));
+        };
+        const socket = implicitTls
+            ? tls.connect({
+                host: config.host,
+                port: config.port,
+                servername: config.host,
+            })
+            : net.connect({ host: config.host, port: config.port });
+        if (implicitTls) {
+            socket.once('secureConnect', () => resolve(socket));
+        }
+        else {
+            socket.once('connect', () => resolve(socket));
+        }
+        socket.once('error', onError);
+    });
+};
+const upgradeToStartTls = async (socket, host) => {
+    return new Promise((resolve, reject) => {
+        const tlsSocket = tls.connect({ socket, servername: host });
+        tlsSocket.once('secureConnect', () => {
+            resolve(tlsSocket);
+        });
+        tlsSocket.once('error', (err) => {
+            reject(ErrorFactory.createConnectionError('SMTP STARTTLS upgrade failed', {
+                host,
+                error: err,
+            }));
+        });
+    });
+};
+const createLineReader = (socket) => {
+    let buffer = '';
+    const waiters = [];
+    const wake = () => {
+        while (waiters.length > 0) {
+            const w = waiters.shift();
+            if (w)
+                w();
+        }
+    };
+    const onData = (data) => {
+        buffer += data.toString('utf8');
+        wake();
+    };
+    socket.on('data', onData);
+    const tryReadLineFromBuffer = () => {
+        const idx = buffer.indexOf('\n');
+        if (idx < 0)
+            return undefined;
+        const line = buffer.slice(0, idx + 1);
+        buffer = buffer.slice(idx + 1);
+        return line.replaceAll(/\r?\n$/, '');
+    };
+    const readLine = async () => {
+        const immediate = tryReadLineFromBuffer();
+        if (typeof immediate === 'string')
+            return immediate;
+        await new Promise((resolve) => waiters.push(resolve));
+        return readLine();
+    };
+    const readMultiline = async (code, message) => {
+        const line = await readLine();
+        const nextCodeStr = line.slice(0, 3);
+        const nextCode = Number.parseInt(nextCodeStr, 10);
+        const nextMsg = line.length > 4 ? line.slice(4) : '';
+        const nextMessage = `${message}\n${nextMsg}`.trim();
+        if (Number.isFinite(nextCode) && nextCode === code && line[3] === ' ')
+            return nextMessage;
+        return readMultiline(code, nextMessage);
+    };
+    const readResponse = async () => {
+        const first = await readLine();
+        const codeStr = first.slice(0, 3);
+        const code = Number.parseInt(codeStr, 10);
+        if (!Number.isFinite(code)) {
+            throw ErrorFactory.createConnectionError('SMTP: invalid response code', { first });
+        }
+        let message = first.length > 4 ? first.slice(4) : '';
+        // Multiline response: "250-..." then "250 ..."
+        if (first[3] === '-') {
+            message = await readMultiline(code, message);
+        }
+        return { code, message };
+    };
+    const close = () => {
+        socket.off('data', onData);
+    };
+    return { readResponse, close };
+};
+const writeLine = async (socket, line) => {
+    return new Promise((resolve, reject) => {
+        socket.write(`${line}\r\n`, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+};
+const assertCode = (res, expected, context) => {
+    const allowed = Array.isArray(expected) ? expected : [expected];
+    if (!allowed.includes(res.code)) {
+        throw ErrorFactory.createConnectionError(`SMTP: unexpected response for ${context}`, {
+            expected: allowed,
+            got: res.code,
+            message: res.message,
+        });
+    }
+};
+const hasCapability = (res, capability) => {
+    const cap = capability.trim().toUpperCase();
+    if (cap === '')
+        return false;
+    return res.message
+        .split('\n')
+        .some((line) => line.trim().toUpperCase().startsWith(cap) || line.trim().toUpperCase().includes(cap));
+};
+const doEhlo = async (socket, reader) => {
+    await writeLine(socket, 'EHLO zintrust');
+    const res = await reader.readResponse();
+    assertCode(res, 250, 'EHLO');
+    return res;
+};
+const doAuthLoginIfNeeded = async (socket, reader, config) => {
+    const username = config.username ?? '';
+    const password = config.password ?? '';
+    const wantsAuth = username.trim() !== '' || password.trim() !== '';
+    if (!wantsAuth)
+        return;
+    if (username.trim() === '' || password.trim() === '') {
+        throw ErrorFactory.createConfigError('SMTP: both MAIL_USERNAME and MAIL_PASSWORD are required');
+    }
+    await writeLine(socket, 'AUTH LOGIN');
+    const auth1 = await reader.readResponse();
+    assertCode(auth1, 334, 'AUTH LOGIN');
+    await writeLine(socket, toBase64(username));
+    const auth2 = await reader.readResponse();
+    assertCode(auth2, 334, 'AUTH username');
+    await writeLine(socket, toBase64(password));
+    const auth3 = await reader.readResponse();
+    assertCode(auth3, 235, 'AUTH password');
+};
+const doMailFrom = async (socket, reader, fromEmail) => {
+    await writeLine(socket, `MAIL FROM:<${fromEmail}>`);
+    const mailFrom = await reader.readResponse();
+    assertCode(mailFrom, [250, 251], 'MAIL FROM');
+};
+const doRcptToAll = async (socket, reader, recipients) => {
+    if (recipients.length === 0) {
+        throw ErrorFactory.createValidationError('SMTP: missing recipients');
+    }
+    await recipients.reduce(async (prev, rcpt) => {
+        await prev;
+        await writeLine(socket, `RCPT TO:<${rcpt}>`);
+        const rcptRes = await reader.readResponse();
+        assertCode(rcptRes, [250, 251], 'RCPT TO');
+    }, Promise.resolve());
+};
+const doData = async (socket, reader, message) => {
+    await writeLine(socket, 'DATA');
+    const dataRes = await reader.readResponse();
+    assertCode(dataRes, 354, 'DATA');
+    const raw = buildRfc2822Message(message);
+    const stuffed = dotStuff(raw);
+    await new Promise((resolve, reject) => {
+        socket.write(`${stuffed}\r\n.\r\n`, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+    const queued = await reader.readResponse();
+    assertCode(queued, 250, 'message body');
+};
+const doQuit = async (socket, reader) => {
+    await writeLine(socket, 'QUIT');
+    const quit = await reader.readResponse();
+    assertCode(quit, [221, 250], 'QUIT');
+};
+const buildRfc2822Message = (msg) => {
+    const toList = normalizeRecipients(msg.to);
+    const fromNameRaw = msg.from.name;
+    const fromName = typeof fromNameRaw === 'string' ? fromNameRaw.trim() : '';
+    const fromHeader = fromName === '' ? msg.from.email : `${fromName} <${msg.from.email}>`;
+    const toHeader = toList.join(', ');
+    const subject = msg.subject;
+    const headers = [
+        `From: ${fromHeader}`,
+        `To: ${toHeader}`,
+        `Subject: ${subject}`,
+        'MIME-Version: 1.0',
+    ];
+    const attachParts = (attachments, innerBody) => {
+        const mixedBoundary = `mixed_${generateUuid().replaceAll('-', '')}`;
+        const lines = [];
+        lines.push(`Content-Type: multipart/mixed; boundary="${mixedBoundary}"`, '', `--${mixedBoundary}`, innerBody);
+        // attachments
+        for (const a of attachments) {
+            const b64 = a.content.toString('base64');
+            lines.push(`--${mixedBoundary}`, `Content-Type: application/octet-stream; name="${a.filename}"`, 'Content-Transfer-Encoding: base64', `Content-Disposition: attachment; filename="${a.filename}"`, '');
+            // break base64 into 76 char lines per RFC
+            for (let i = 0; i < b64.length; i += 76) {
+                lines.push(b64.slice(i, i + 76));
+            }
+        }
+        lines.push(`--${mixedBoundary}--`, '');
+        return lines.join('\r\n');
+    };
+    if (typeof msg.html === 'string' && msg.html !== '') {
+        const boundary = `zintrust_${generateUuid().replaceAll('-', '')}`;
+        headers.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
+        const parts = [
+            `--${boundary}`,
+            'Content-Type: text/plain; charset=utf-8',
+            'Content-Transfer-Encoding: 7bit',
+            '',
+            msg.text,
+            `--${boundary}`,
+            'Content-Type: text/html; charset=utf-8',
+            'Content-Transfer-Encoding: 7bit',
+            '',
+            msg.html,
+            `--${boundary}--`,
+            '',
+        ];
+        const inner = `${parts.join('\r\n')}`;
+        if (msg.attachments && msg.attachments.length > 0) {
+            // wrap in multipart/mixed
+            const mixed = attachParts(msg.attachments, inner);
+            return `${headers.join('\r\n')}\r\n\r\n${mixed}`;
+        }
+        return `${headers.join('\r\n')}\r\n\r\n${inner}`;
+    }
+    // plain text
+    if (msg.attachments && msg.attachments.length > 0) {
+        const inner = ['Content-Type: text/plain; charset=utf-8', '', msg.text, ''].join('\r\n');
+        const mixed = attachParts(msg.attachments, inner);
+        return `${headers.join('\r\n')}\r\n\r\n${mixed}`;
+    }
+    headers.push('Content-Type: text/plain; charset=utf-8');
+    return `${headers.join('\r\n')}\r\n\r\n${msg.text}\r\n`;
+};
+const dotStuff = (data) => data
+    .replaceAll(/\r?\n/g, '\r\n')
+    .split('\r\n')
+    .map((line) => (line.startsWith('.') ? `.${line}` : line))
+    .join('\r\n');
+export const SmtpDriver = Object.freeze({
+    /**
+     * NOTE: This is a minimal SMTP implementation intended for Node.js runtimes.
+     * - `secure=true` means TLS from the start (SMTPS).
+     * - `secure='starttls'` performs STARTTLS after EHLO.
+     */
+    async send(config, message) {
+        let mode = 'none';
+        if (config.secure === true)
+            mode = 'tls';
+        if (config.secure === 'starttls')
+            mode = 'starttls';
+        let socket = await createSocket(config, mode === 'tls');
+        let reader = createLineReader(socket);
+        try {
+            const greeting = await reader.readResponse();
+            assertCode(greeting, 220, 'greeting');
+            const ehlo = await doEhlo(socket, reader);
+            if (mode === 'starttls') {
+                const supportsStartTls = hasCapability(ehlo, 'STARTTLS');
+                if (!supportsStartTls) {
+                    throw ErrorFactory.createConnectionError('SMTP server does not support STARTTLS');
+                }
+                await writeLine(socket, 'STARTTLS');
+                const startTls = await reader.readResponse();
+                assertCode(startTls, 220, 'STARTTLS');
+                // Swap reader/socket to the upgraded TLS stream
+                reader.close();
+                socket = await upgradeToStartTls(socket, config.host);
+                reader = createLineReader(socket);
+                // RFC: EHLO again after STARTTLS
+                await doEhlo(socket, reader);
+            }
+            await doAuthLoginIfNeeded(socket, reader, config);
+            await doMailFrom(socket, reader, message.from.email);
+            await doRcptToAll(socket, reader, normalizeRecipients(message.to));
+            await doData(socket, reader, message);
+            await doQuit(socket, reader);
+            return { ok: true, provider: 'smtp' };
+        }
+        catch (err) {
+            throw ErrorFactory.createConnectionError('SMTP send failed', { error: err });
+        }
+        finally {
+            reader.close();
+            socket.end();
+        }
+    },
+});
+export default SmtpDriver;

package/src/tools/mail/templates/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Mail Templates (Core)
+ *
+ * This folder contains reusable email templates used by core mail tooling.
+ * Templates may be organized into subfolders (e.g., `auth/`, `orders/`) with
+ * both rich HTML and plain-text variants.
+ */
+export type MailTemplate = {
+    subject: string;
+    text: string;
+    html?: string;
+};
+export type MailTemplateRegistry = Record<string, unknown>;
+export declare const MailTemplateRenderer: Readonly<{
+    renderString: (template: string, data: Record<string, unknown>) => string;
+    render(template: MailTemplate, data: Record<string, unknown>): MailTemplate;
+}>;
+export declare const MailTemplates: Readonly<{
+    auth: Readonly<{
+        welcome: Readonly<{
+            subject: string;
+            text: string;
+            html: string;
+        }>;
+    }>;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/src/tools/mail/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mail/templates/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAW3D,eAAO,MAAM,oBAAoB;6BATD,MAAM,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM;qBAY3D,YAAY,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY;EAO3E,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;EASO,CAAC"}

package/src/tools/mail/templates/index.js

@@ -0,0 +1,35 @@
+/**
+ * Mail Templates (Core)
+ *
+ * This folder contains reusable email templates used by core mail tooling.
+ * Templates may be organized into subfolders (e.g., `auth/`, `orders/`) with
+ * both rich HTML and plain-text variants.
+ */
+const renderString = (template, data) => {
+    let out = template;
+    for (const [key, value] of Object.entries(data)) {
+        const replacement = value === null || value === undefined ? '' : String(value);
+        out = out.replaceAll(new RegExp(String.raw `{{\s*${key}\s*}}`, 'g'), replacement);
+    }
+    return out;
+};
+export const MailTemplateRenderer = Object.freeze({
+    renderString,
+    render(template, data) {
+        return {
+            subject: renderString(template.subject, data),
+            text: renderString(template.text, data),
+            html: typeof template.html === 'string' ? renderString(template.html, data) : undefined,
+        };
+    },
+});
+export const MailTemplates = Object.freeze({
+    auth: Object.freeze({
+        // Example template. Apps can add their own workflows under app/Toolkit/Mail.
+        welcome: Object.freeze({
+            subject: 'Welcome, {{name}}!',
+            text: 'Hi {{name}},\n\nWelcome to Zintrust.',
+            html: '<p>Hi {{name}},</p><p>Welcome to Zintrust.</p>',
+        }),
+    }),
+});

package/src/tools/mail/templates/markdown/index.d.ts

@@ -0,0 +1,17 @@
+export declare const loadTemplate: (name: string) => {
+    subject?: string;
+    preheader?: string;
+    variables?: string[];
+    content: string;
+};
+export { listTemplates, renderTemplate } from '../../templates/markdown/registry';
+declare const _default: {
+    loadTemplate: (name: string) => {
+        subject?: string;
+        preheader?: string;
+        variables?: string[];
+        content: string;
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/src/tools/mail/templates/markdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/tools/mail/templates/markdown/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,GACvB,MAAM,MAAM,KACX;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAkD/E,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;;yBArD1E,MAAM,KACX;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;;AAsDlF,wBAAgC"}

package/src/tools/mail/templates/markdown/index.js

@@ -0,0 +1,49 @@
+import { readFileSync } from '../../../../node-singletons/fs';
+import { join } from '../../../../node-singletons/path';
+export const loadTemplate = (name) => {
+    // name e.g. 'auth/welcome'
+    const parts = name.split('/');
+    // Safe parser for top comment metadata <!-- Key: Value --> lines to avoid regex backtracking
+    const dir = join(process.cwd(), 'src', 'tools', 'mail', 'templates', 'markdown', ...parts.slice(0, -1));
+    const leaf = parts.at(-1) ?? '';
+    const filePath = join(dir, `${leaf}.md`);
+    const raw = readFileSync(filePath, 'utf-8');
+    const meta = {};
+    const parseMetaLine = (line) => {
+        // Must start with <!-- and end with --> exactly; trim the inner part and split at first colon
+        if (!line.startsWith('<!--') || !line.endsWith('-->'))
+            return null;
+        const inner = line.slice('<!--'.length, -'-->'.length).trim();
+        const idx = inner.indexOf(':');
+        if (idx === -1)
+            return null;
+        const key = inner.slice(0, idx).trim().toLowerCase();
+        const val = inner.slice(idx + 1).trim();
+        if (!key)
+            return null;
+        return [key, val];
+    };
+    // Parse top comment metadata <!-- Key: Value --> lines
+    const lines = raw.split(/\r?\n/);
+    let i = 0;
+    for (; i < lines.length; i++) {
+        const kv = parseMetaLine(lines[i]);
+        if (!kv)
+            break;
+        const [key, val] = kv;
+        if (key === 'subject')
+            meta.subject = val;
+        if (key === 'preheader')
+            meta.preheader = val;
+        if (key === 'variables') {
+            meta.variables = val
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+    }
+    const content = lines.slice(i).join('\n').trim();
+    return { content, ...meta };
+};
+export { listTemplates, renderTemplate } from '../../templates/markdown/registry';
+export default { loadTemplate };

package/src/tools/mail/templates/markdown/registry.d.ts

@@ -0,0 +1,15 @@
+import { loadTemplate } from '../../templates/markdown';
+export declare const listTemplates: () => string[];
+export declare const renderTemplate: (name: string, vars?: Record<string, unknown>) => {
+    html: string;
+    meta: ReturnType<typeof loadTemplate>;
+};
+declare const _default: {
+    listTemplates: () => string[];
+    renderTemplate: (name: string, vars?: Record<string, unknown>) => {
+        html: string;
+        meta: ReturnType<typeof loadTemplate>;
+    };
+};
+export default _default;
+//# sourceMappingURL=registry.d.ts.map

package/src/tools/mail/templates/markdown/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../../src/tools/mail/templates/markdown/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AA2BxD,eAAO,MAAM,aAAa,QAAO,MAAM,EAEtC,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,EACZ,OAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,KACjC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;CAKvD,CAAC;;yBAZ+B,MAAM,EAAE;2BAKjC,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC5B;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;KAAE;;AAO1D,wBAAiD"}

package/src/tools/mail/templates/markdown/registry.js

@@ -0,0 +1,34 @@
+import { loadTemplate } from '../../templates/markdown';
+import { validateTemplateMeta } from '../../templates/markdown/validator';
+import { readdirSync, statSync } from '../../../../node-singletons/fs';
+import { join, relative } from '../../../../node-singletons/path';
+import { MarkdownRenderer } from '../../../templates';
+const BASE = join(process.cwd(), 'src', 'tools', 'mail', 'templates', 'markdown');
+const walkDir = (dir, base = dir) => {
+    const entries = readdirSync(dir);
+    let files = [];
+    for (const e of entries) {
+        const p = join(dir, e);
+        const s = statSync(p);
+        if (s.isDirectory()) {
+            files = files.concat(walkDir(p, base));
+            continue;
+        }
+        if (e.endsWith('.md')) {
+            const rel = relative(base, p).replaceAll('\\', '/');
+            const withoutExt = rel.toLowerCase().endsWith('.md') ? rel.slice(0, -3) : rel;
+            files.push(withoutExt);
+        }
+    }
+    return files;
+};
+export const listTemplates = () => {
+    return walkDir(BASE);
+};
+export const renderTemplate = (name, vars = {}) => {
+    const tpl = loadTemplate(name);
+    validateTemplateMeta(name, tpl);
+    const html = MarkdownRenderer.render(tpl.content, vars);
+    return { html, meta: tpl };
+};
+export default { listTemplates, renderTemplate };

package/src/tools/mail/templates/markdown/validator.d.ts

@@ -0,0 +1,16 @@
+export declare const validateTemplateMeta: (name: string, tpl: {
+    subject?: string;
+    preheader?: string;
+    variables?: string[];
+    content: string;
+}) => true;
+declare const _default: {
+    validateTemplateMeta: (name: string, tpl: {
+        subject?: string;
+        preheader?: string;
+        variables?: string[];
+        content: string;
+    }) => true;
+};
+export default _default;
+//# sourceMappingURL=validator.d.ts.map

package/src/tools/mail/templates/markdown/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../../../../src/tools/mail/templates/markdown/validator.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,GAC/B,MAAM,MAAM,EACZ,KAAK;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,KACA,IA0BF,CAAC;;iCAjCM,MAAM,OACP;QACH,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;KACjB,KACA,IAAI;;AA4BP,wBAAwC"}

package/src/tools/mail/templates/markdown/validator.js

@@ -0,0 +1,24 @@
+import { ErrorFactory } from '../../../../exceptions/ZintrustError';
+export const validateTemplateMeta = (name, tpl) => {
+    if (tpl.subject === null || tpl.subject === undefined || tpl.subject.trim() === '') {
+        throw ErrorFactory.createValidationError('Template missing subject', { name });
+    }
+    const placeholders = new Set();
+    const rx = /{{\s*([a-zA-Z0-9_.-]+)\s*}}/g;
+    let m;
+    while ((m = rx.exec(tpl.content)) !== null) {
+        placeholders.add(m[1]);
+    }
+    const metaVars = new Set((tpl.variables ?? []).map((s) => s.trim()).filter(Boolean));
+    const missingInContent = Array.from(metaVars).filter((v) => !placeholders.has(v));
+    const missingInMeta = Array.from(placeholders).filter((v) => !metaVars.has(v));
+    if (missingInContent.length > 0 || missingInMeta.length > 0) {
+        throw ErrorFactory.createValidationError('Template variables mismatch', {
+            name,
+            missingInContent,
+            missingInMeta,
+        });
+    }
+    return true;
+};
+export default { validateTemplateMeta };

package/src/tools/mail/testing.d.ts

@@ -0,0 +1,41 @@
+type SentRecord = {
+    to: string[];
+    subject: string;
+    text: string;
+    html?: string;
+    from?: {
+        address?: string;
+        name?: string;
+    };
+    attachments?: Array<{
+        filename: string;
+        content: Buffer;
+    }>;
+};
+type FakeSendInput = {
+    to: string | string[];
+    subject: string;
+    text: string;
+    html?: string;
+    from?: {
+        address?: string;
+        name?: string;
+    };
+    attachments?: Array<{
+        filename: string;
+        content: Buffer;
+    }>;
+};
+export declare const MailFake: Readonly<{
+    _sent: Array<SentRecord>;
+    send(input: FakeSendInput): Promise<{
+        ok: boolean;
+        driver: string;
+    }>;
+    assertSent(predicate: (r: SentRecord) => boolean): void;
+    assertNotSent(predicate: (r: SentRecord) => boolean): void;
+    getSent(): SentRecord[];
+    reset(): void;
+}>;
+export default MailFake;
+//# sourceMappingURL=testing.d.ts.map

package/src/tools/mail/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../../../src/tools/mail/testing.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,GAAG;IAChB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D,CAAC;AAEF,eAAO,MAAM,QAAQ;WACN,KAAK,CAAC,UAAU,CAAC;gBAEZ,aAAa,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;0BAcpD,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO;6BAMvB,CAAC,CAAC,EAAE,UAAU,KAAK,OAAO;;;EAanD,CAAC;AAEH,eAAe,QAAQ,CAAC"}

package/src/tools/mail/testing.js

@@ -0,0 +1,34 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+export const MailFake = Object.freeze({
+    _sent: [],
+    async send(input) {
+        const to = Array.isArray(input.to) ? input.to : [input.to];
+        this._sent.push({
+            to,
+            subject: input.subject,
+            text: input.text,
+            html: input.html,
+            from: input.from,
+            attachments: input.attachments,
+        });
+        await Promise.resolve();
+        return { ok: true, driver: 'disabled' };
+    },
+    assertSent(predicate) {
+        if (!this._sent.some(predicate)) {
+            throw ErrorFactory.createValidationError('Expected a sent mail matching predicate');
+        }
+    },
+    assertNotSent(predicate) {
+        if (this._sent.some(predicate)) {
+            throw ErrorFactory.createValidationError('Expected no sent mail matching predicate');
+        }
+    },
+    getSent() {
+        return this._sent.slice();
+    },
+    reset() {
+        this._sent.length = 0;
+    },
+});
+export default MailFake;

package/src/tools/notification/Driver.d.ts

@@ -0,0 +1,11 @@
+export interface INotificationDriver {
+    send(recipient: string, message: string, options?: Record<string, unknown>): Promise<unknown>;
+}
+export type NotificationPayload = {
+    recipient: string;
+    message: string;
+    options?: Record<string, unknown>;
+};
+declare const _default: INotificationDriver;
+export default _default;
+//# sourceMappingURL=Driver.d.ts.map

package/src/tools/notification/Driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Driver.d.ts","sourceRoot":"","sources":["../../../../src/tools/notification/Driver.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/F;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;wBAE8B,mBAAmB;AAAnD,wBAAoD"}

package/src/tools/notification/Driver.js

@@ -0,0 +1 @@
+export default {};