@zintrust/core 0.1.1 → 0.1.2

package/src/tools/http/Http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Http.d.ts","sourceRoot":"","sources":["../../../../src/tools/http/Http.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAElF,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC;IACtD,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,YAAY,CAAC;IACnE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAAC;IAChE,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC;IACtC,MAAM,IAAI,YAAY,CAAC;IACvB,MAAM,IAAI,YAAY,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;CAChC;AAiJD;;;GAGG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;aACM,MAAM,GAAG,YAAY;IAI9B;;OAEG;cACO,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY;IAQ/D;;OAEG;aACM,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY;IAQ9D;;OAEG;eACQ,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY;IAQhE;;OAEG;gBACS,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY;EAOjE,CAAC;AAEH,eAAe,UAAU,CAAC"}

package/src/tools/http/Http.js

@@ -0,0 +1,171 @@
+/**
+ * Http Client - Fluent HTTP request builder
+ * Laravel-style HTTP client for making authenticated requests
+ *
+ * Usage:
+ *   await HttpClient.get('https://api.example.com/users').withAuth(token).send();
+ *   await HttpClient.post('https://api.example.com/users', data).withTimeout(5000).send();
+ */
+import { Env } from '../../config/env';
+import { Logger } from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { createHttpResponse } from './HttpResponse';
+/**
+ * Perform the actual request for a given state. Separated to keep the builder small
+ */
+async function performRequest(state) {
+    const timeout = state.timeout ?? Env.getInt('HTTP_TIMEOUT', 30000);
+    const controller = new AbortController();
+    let timeoutId;
+    if (timeout > 0) {
+        timeoutId = globalThis.setTimeout(() => controller.abort(), timeout);
+    }
+    const buildInit = () => {
+        const init = {
+            method: state.method,
+            headers: state.headers,
+            signal: controller.signal,
+        };
+        if (state.body !== undefined &&
+            state.body !== null &&
+            ['POST', 'PUT', 'PATCH'].includes(state.method)) {
+            init.body = state.body;
+        }
+        return init;
+    };
+    try {
+        const init = buildInit();
+        const startTime = Date.now();
+        const response = await globalThis.fetch(state.url, init);
+        const responseBody = await response.text();
+        const duration = Date.now() - startTime;
+        Logger.debug(`HTTP ${state.method} ${state.url}`, {
+            status: response.status,
+            duration: `${duration}ms`,
+            size: responseBody.length,
+        });
+        return createHttpResponse(response, responseBody);
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw ErrorFactory.createConnectionError(`HTTP request timeout after ${timeout}ms`, {
+                url: state.url,
+                method: state.method,
+                timeout,
+            });
+        }
+        throw ErrorFactory.createTryCatchError(`HTTP request failed: ${error.message}`, {
+            url: state.url,
+            method: state.method,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    finally {
+        if (timeoutId !== undefined) {
+            globalThis.clearTimeout(timeoutId);
+        }
+    }
+}
+/**
+ * Create request builder with fluent API
+ */
+const createRequestBuilder = (method, url, initialBody) => {
+    const state = {
+        method,
+        url,
+        headers: {
+            'User-Agent': 'Zintrust/1.0',
+        },
+        body: initialBody ? JSON.stringify(initialBody) : undefined,
+    };
+    const self = {
+        withHeader(name, value) {
+            state.headers[name] = value;
+            return self;
+        },
+        withHeaders(headers) {
+            Object.assign(state.headers, headers);
+            return self;
+        },
+        withAuth(token, scheme = 'Bearer') {
+            state.headers['Authorization'] = `${scheme} ${token}`;
+            return self;
+        },
+        withBasicAuth(username, password) {
+            const credentials = Buffer.from(`${username}:${password}`).toString('base64');
+            state.headers['Authorization'] = `Basic ${credentials}`;
+            return self;
+        },
+        withTimeout(ms) {
+            state.timeout = ms;
+            return self;
+        },
+        asJson() {
+            state.contentType = 'json';
+            state.headers['Content-Type'] = 'application/json';
+            return self;
+        },
+        asForm() {
+            state.contentType = 'form';
+            state.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+            return self;
+        },
+        async send() {
+            return performRequest(state);
+        },
+    };
+    return self;
+};
+/**
+ * HTTP Client - Sealed namespace for making HTTP requests
+ * Provides Laravel-style fluent API
+ */
+export const HttpClient = Object.freeze({
+    /**
+     * Make GET request
+     */
+    get(url) {
+        return createRequestBuilder('GET', url);
+    },
+    /**
+     * Make POST request
+     */
+    post(url, data) {
+        const builder = createRequestBuilder('POST', url, data);
+        if (data) {
+            builder.asJson();
+        }
+        return builder;
+    },
+    /**
+     * Make PUT request
+     */
+    put(url, data) {
+        const builder = createRequestBuilder('PUT', url, data);
+        if (data) {
+            builder.asJson();
+        }
+        return builder;
+    },
+    /**
+     * Make PATCH request
+     */
+    patch(url, data) {
+        const builder = createRequestBuilder('PATCH', url, data);
+        if (data) {
+            builder.asJson();
+        }
+        return builder;
+    },
+    /**
+     * Make DELETE request
+     */
+    delete(url, data) {
+        const builder = createRequestBuilder('DELETE', url, data);
+        if (data) {
+            builder.asJson();
+        }
+        return builder;
+    },
+});
+export default HttpClient;

package/src/tools/http/HttpResponse.d.ts

@@ -0,0 +1,32 @@
+/**
+ * HttpResponse - Response wrapper with utility methods
+ * Provides convenient access to response status, headers, body, and parsed JSON
+ */
+/**
+ * HTTP Response interface for convenience methods
+ */
+export interface IHttpResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+    json<T = unknown>(): T;
+    text(): string;
+    ok: boolean;
+    successful: boolean;
+    failed: boolean;
+    serverError: boolean;
+    clientError: boolean;
+    header(name: string): string | undefined;
+    hasHeader(name: string): boolean;
+    throwIfServerError(): IHttpResponse;
+    throwIfClientError(): IHttpResponse;
+}
+/**
+ * Create HTTP response from fetch Response
+ */
+export declare const createHttpResponse: (response: Response, body: string) => IHttpResponse;
+declare const _default: {
+    createHttpResponse: (response: Response, body: string) => IHttpResponse;
+};
+export default _default;
+//# sourceMappingURL=HttpResponse.d.ts.map

package/src/tools/http/HttpResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpResponse.d.ts","sourceRoot":"","sources":["../../../../src/tools/http/HttpResponse.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,CAAC,GAAG,OAAO,KAAK,CAAC,CAAC;IACvB,IAAI,IAAI,MAAM,CAAC;IACf,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACzC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,kBAAkB,IAAI,aAAa,CAAC;IACpC,kBAAkB,IAAI,aAAa,CAAC;CACrC;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,QAAQ,EAAE,MAAM,MAAM,KAAG,aAmFrE,CAAC;;mCAnF2C,QAAQ,QAAQ,MAAM,KAAG,aAAa;;AAqFnF,wBAEE"}

package/src/tools/http/HttpResponse.js

@@ -0,0 +1,80 @@
+/**
+ * HttpResponse - Response wrapper with utility methods
+ * Provides convenient access to response status, headers, body, and parsed JSON
+ */
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+/**
+ * Create HTTP response from fetch Response
+ */
+export const createHttpResponse = (response, body) => {
+    const statusCode = response.status;
+    const headers = Object.fromEntries(response.headers.entries());
+    const lowerHeaders = Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+    return {
+        get status() {
+            return statusCode;
+        },
+        get headers() {
+            return headers;
+        },
+        get body() {
+            return body;
+        },
+        json() {
+            try {
+                return JSON.parse(body);
+            }
+            catch (error) {
+                throw ErrorFactory.createValidationError('Failed to parse JSON response', {
+                    body: body.substring(0, 200), // Truncate for logging
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        },
+        text() {
+            return body;
+        },
+        get ok() {
+            return response.ok;
+        },
+        get successful() {
+            return statusCode >= 200 && statusCode < 300;
+        },
+        get failed() {
+            return !this.successful;
+        },
+        get serverError() {
+            return statusCode >= 500;
+        },
+        get clientError() {
+            return statusCode >= 400 && statusCode < 500;
+        },
+        header(name) {
+            return lowerHeaders[name.toLowerCase()];
+        },
+        hasHeader(name) {
+            return name.toLowerCase() in lowerHeaders;
+        },
+        throwIfServerError() {
+            if (this.serverError) {
+                throw ErrorFactory.createTryCatchError(`HTTP server error: ${this.status}`, {
+                    status: this.status,
+                    body: this.body.substring(0, 200),
+                });
+            }
+            return this;
+        },
+        throwIfClientError() {
+            if (this.clientError) {
+                throw ErrorFactory.createTryCatchError(`HTTP client error: ${this.status}`, {
+                    status: this.status,
+                    body: this.body.substring(0, 200),
+                });
+            }
+            return this;
+        },
+    };
+};
+export default {
+    createHttpResponse,
+};

package/src/tools/http/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * HTTP Client Tools - Export all HTTP utilities
+ */
+declare const _default: Readonly<{
+    HttpClient: Readonly<{
+        get(url: string): import("./Http").IHttpRequest;
+        post(url: string, data?: Record<string, unknown>): import("./Http").IHttpRequest;
+        put(url: string, data?: Record<string, unknown>): import("./Http").IHttpRequest;
+        patch(url: string, data?: Record<string, unknown>): import("./Http").IHttpRequest;
+        delete(url: string, data?: Record<string, unknown>): import("./Http").IHttpRequest;
+    }>;
+    createHttpResponse: (response: Response, body: string) => import("./HttpResponse").IHttpResponse;
+}>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/src/tools/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/http/index.ts"],"names":[],"mappings":"AAAA;;GAEG;;;;;;;;;;;AAKH,wBAGG"}

package/src/tools/http/index.js

@@ -0,0 +1,9 @@
+/**
+ * HTTP Client Tools - Export all HTTP utilities
+ */
+import { HttpClient } from './Http';
+import { createHttpResponse } from './HttpResponse';
+export default Object.freeze({
+    HttpClient,
+    createHttpResponse,
+});

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

@@ -0,0 +1,22 @@
+import { type AttachmentInput } from './attachments';
+export type SendMailInput = {
+    to: string | string[];
+    subject: string;
+    text: string;
+    html?: string;
+    from?: {
+        address?: string;
+        name?: string;
+    };
+    attachments?: AttachmentInput[];
+};
+export type SendMailResult = {
+    ok: boolean;
+    driver: 'sendgrid' | 'disabled' | 'smtp' | 'ses' | 'mailgun';
+    messageId?: string;
+};
+export declare const Mail: Readonly<{
+    send(input: SendMailInput): Promise<SendMailResult>;
+}>;
+export default Mail;
+//# sourceMappingURL=Mail.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Mail.d.ts","sourceRoot":"","sources":["../../../../src/tools/mail/Mail.ts"],"names":[],"mappings":"AAQA,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAG7E,MAAM,MAAM,aAAa,GAAG;IAC1B,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;QACL,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACF,WAAW,CAAC,EAAE,eAAe,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAkIF,eAAO,MAAM,IAAI;gBACG,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;EAqBzD,CAAC;AAEH,eAAe,IAAI,CAAC"}

package/src/tools/mail/Mail.js

@@ -0,0 +1,105 @@
+import { mailConfig } from '../../config/mail';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { MailgunDriver } from './drivers/Mailgun';
+import { SendGridDriver } from './drivers/SendGrid';
+import { SesDriver } from './drivers/Ses';
+import { SmtpDriver } from './drivers/Smtp';
+import { resolveAttachments } from './attachments';
+import { Storage } from '../storage';
+const resolveFrom = (input) => {
+    const address = input?.address ?? mailConfig.from.address;
+    const name = input?.name ?? mailConfig.from.name;
+    if (address.trim() === '') {
+        const err = ErrorFactory.createConfigError('Mail: missing from address (set MAIL_FROM_ADDRESS or pass from.address)');
+        throw err;
+    }
+    return { email: address, name: name.trim() === '' ? undefined : name };
+};
+function assertStorageDiskLike(value) {
+    if (typeof value !== 'object' || value === null) {
+        const err = ErrorFactory.createConfigError('Storage disk is invalid (expected object)');
+        throw err;
+    }
+    const v = value;
+    const driver = v['driver'];
+    if (typeof driver !== 'object' || driver === null) {
+        const err = ErrorFactory.createConfigError('Storage disk driver is invalid (expected object)');
+        throw err;
+    }
+    const d = driver;
+    if (typeof d['get'] !== 'function') {
+        const err = ErrorFactory.createConfigError('Storage disk driver is missing get()');
+        throw err;
+    }
+    if (typeof d['exists'] !== 'function') {
+        const err = ErrorFactory.createConfigError('Storage disk driver is missing exists()');
+        throw err;
+    }
+}
+const getDiskSafe = (disk) => {
+    const diskValue = Storage.getDisk(disk);
+    assertStorageDiskLike(diskValue);
+    return diskValue;
+};
+const createStorageWrapper = () => ({
+    async get(disk, path) {
+        const d = getDiskSafe(disk);
+        const result = await Promise.resolve(d.driver.get(d.config, path));
+        return result;
+    },
+    async exists(disk, path) {
+        const d = getDiskSafe(disk);
+        const result = await Promise.resolve(d.driver.exists(d.config, path));
+        return Boolean(result);
+    },
+});
+const sendWithDriver = async (driver, message) => {
+    if (driver.driver === 'sendgrid') {
+        const result = await SendGridDriver.send({ apiKey: driver.apiKey }, message);
+        return { ok: result.ok, driver: 'sendgrid', messageId: result.messageId };
+    }
+    if (driver.driver === 'mailgun') {
+        const result = await MailgunDriver.send({ apiKey: driver.apiKey, domain: driver.domain, baseUrl: driver.baseUrl }, message);
+        return { ok: result.ok, driver: 'mailgun', messageId: result.messageId };
+    }
+    if (driver.driver === 'smtp') {
+        const result = await SmtpDriver.send({
+            host: driver.host,
+            port: driver.port,
+            username: driver.username,
+            password: driver.password,
+            secure: driver.secure,
+        }, message);
+        return { ok: result.ok, driver: 'smtp', messageId: result.messageId };
+    }
+    if (driver.driver === 'ses') {
+        const result = await SesDriver.send({ region: driver.region }, message);
+        return { ok: result.ok, driver: 'ses', messageId: result.messageId };
+    }
+    // Config exists for future drivers, but implementations are intentionally CLI/runtime-safe and added incrementally.
+    {
+        const err = ErrorFactory.createConfigError(`Mail driver not implemented: ${mailConfig.default}`);
+        throw err;
+    }
+};
+export const Mail = Object.freeze({
+    async send(input) {
+        const driver = mailConfig.getDriver();
+        if (driver.driver === 'disabled') {
+            const err = ErrorFactory.createConfigError('Mail driver is disabled (set MAIL_DRIVER)');
+            throw err;
+        }
+        const from = resolveFrom(input.from);
+        const storage = createStorageWrapper();
+        const attachments = await resolveAttachments(input.attachments, { storage });
+        return sendWithDriver(driver, {
+            to: input.to,
+            from,
+            subject: input.subject,
+            text: input.text,
+            html: input.html,
+            attachments,
+        });
+    },
+});
+export default Mail;

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

@@ -0,0 +1,23 @@
+export type DiskAttachment = {
+    disk: string;
+    path: string;
+    filename?: string;
+};
+export type InlineAttachment = {
+    content: Buffer | string;
+    filename: string;
+};
+export type AttachmentInput = DiskAttachment | InlineAttachment;
+export type ResolvedAttachment = {
+    filename: string;
+    content: Buffer;
+};
+export type StorageLike = {
+    get: (disk: string, path: string) => Promise<Buffer> | Buffer;
+    exists?: (disk: string, path: string) => Promise<boolean> | boolean;
+    url?: (disk: string, path: string) => string;
+};
+export declare function resolveAttachments(attachments: Array<AttachmentInput> | undefined, options?: {
+    storage?: StorageLike;
+}): Promise<ResolvedAttachment[]>;
+//# sourceMappingURL=attachments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../../../../src/tools/mail/attachments.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC/E,MAAM,MAAM,gBAAgB,GAAG;IAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAC9E,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAEhE,MAAM,MAAM,kBAAkB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;IAC9D,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACpE,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CAC9C,CAAC;AAEF,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,GAAG,SAAS,EAC/C,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,WAAW,CAAA;CAAO,GACtC,OAAO,CAAC,kBAAkB,EAAE,CAAC,CA6B/B"}

package/src/tools/mail/attachments.js

@@ -0,0 +1,26 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+export async function resolveAttachments(attachments, options = {}) {
+    if (!attachments || attachments.length === 0)
+        return [];
+    const storage = options.storage;
+    const resolveOne = async (att) => {
+        if ('content' in att) {
+            const a = att;
+            const content = typeof a.content === 'string' ? Buffer.from(a.content) : a.content;
+            return { filename: a.filename, content };
+        }
+        // Disk-based attachment
+        const d = att;
+        if (!storage) {
+            throw ErrorFactory.createValidationError('Storage is required to resolve disk attachments');
+        }
+        const exists = storage.exists ? await Promise.resolve(storage.exists(d.disk, d.path)) : true;
+        if (!exists) {
+            throw ErrorFactory.createNotFoundError(`Attachment not found: ${d.disk}:${d.path}`);
+        }
+        const content = await Promise.resolve(storage.get(d.disk, d.path));
+        const filename = d.filename ?? d.path.split('/').pop() ?? 'attachment';
+        return { filename, content };
+    };
+    return Promise.all(attachments.map(resolveOne));
+}

package/src/tools/mail/drivers/BaseDriver.d.ts

@@ -0,0 +1,5 @@
+export declare const BaseDriver: Readonly<{
+    send(): Promise<unknown>;
+}>;
+export default BaseDriver;
+//# sourceMappingURL=BaseDriver.d.ts.map

package/src/tools/mail/drivers/BaseDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseDriver.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mail/drivers/BaseDriver.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;YACP,OAAO,CAAC,OAAO,CAAC;EAI9B,CAAC;AAEH,eAAe,UAAU,CAAC"}

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

@@ -0,0 +1,8 @@
+import { ErrorFactory } from '../../../exceptions/ZintrustError';
+export const BaseDriver = Object.freeze({
+    async send() {
+        await Promise.resolve();
+        throw ErrorFactory.createConfigError('Mail driver must implement send()');
+    },
+});
+export default BaseDriver;

package/src/tools/mail/drivers/Mailgun.d.ts

@@ -0,0 +1,31 @@
+export type MailgunConfig = {
+    apiKey: string;
+    domain: string;
+    baseUrl?: string;
+};
+export type MailAddress = {
+    email: string;
+    name?: string;
+};
+export type MailAttachment = {
+    filename: string;
+    content: Buffer;
+};
+export type MailMessage = {
+    to: string | string[];
+    from: MailAddress;
+    subject: string;
+    text: string;
+    html?: string;
+    attachments?: MailAttachment[];
+};
+export type SendResult = {
+    ok: boolean;
+    provider: 'mailgun';
+    messageId?: string;
+};
+export declare const MailgunDriver: Readonly<{
+    send(config: MailgunConfig, message: MailMessage): Promise<SendResult>;
+}>;
+export default MailgunDriver;
+//# sourceMappingURL=Mailgun.d.ts.map

package/src/tools/mail/drivers/Mailgun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mailgun.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mail/drivers/Mailgun.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AA2CF,eAAO,MAAM,aAAa;iBACL,aAAa,WAAW,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;EAuD5E,CAAC;AAEH,eAAe,aAAa,CAAC"}

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

@@ -0,0 +1,81 @@
+import { ErrorFactory } from '../../../exceptions/ZintrustError';
+const normalizeRecipients = (to) => (Array.isArray(to) ? to : [to]);
+const base64 = (value) => Buffer.from(value, 'utf8').toString('base64');
+const toArrayBuffer = (buf) => {
+    const ab = new ArrayBuffer(buf.byteLength);
+    new Uint8Array(ab).set(buf);
+    return ab;
+};
+const normalizeBaseUrl = (value) => {
+    let v = (value ?? '').trim();
+    if (v === '')
+        return 'https://api.mailgun.net';
+    // Avoid regex backtracking (Sonar S5852) by trimming trailing slashes in linear time.
+    while (v.endsWith('/'))
+        v = v.slice(0, -1);
+    return v;
+};
+const ensureConfig = (config) => {
+    const apiKey = (config.apiKey ?? '').trim();
+    const domain = (config.domain ?? '').trim();
+    const baseUrl = normalizeBaseUrl(config.baseUrl);
+    if (apiKey === '')
+        throw ErrorFactory.createConfigError('Mailgun: missing MAILGUN_API_KEY');
+    if (domain === '')
+        throw ErrorFactory.createConfigError('Mailgun: missing MAILGUN_DOMAIN');
+    return { apiKey, domain, baseUrl };
+};
+const ensureMessage = (message) => {
+    if (message.from.email.trim() === '') {
+        throw ErrorFactory.createConfigError('Mail: missing from.email');
+    }
+};
+export const MailgunDriver = Object.freeze({
+    async send(config, message) {
+        const { apiKey, domain, baseUrl } = ensureConfig(config);
+        ensureMessage(message);
+        const url = `${baseUrl}/v3/${encodeURIComponent(domain)}/messages`;
+        const form = new FormData();
+        const fromName = (message.from.name ?? '').trim();
+        const from = fromName === '' ? message.from.email : `${fromName} <${message.from.email}>`;
+        form.set('from', from);
+        form.set('to', normalizeRecipients(message.to).join(','));
+        form.set('subject', message.subject);
+        form.set('text', message.text);
+        if (typeof message.html === 'string' && message.html !== '') {
+            form.set('html', message.html);
+        }
+        if (message.attachments && message.attachments.length > 0) {
+            for (const a of message.attachments) {
+                // In Node.js, Buffer is a Uint8Array, which works as a BlobPart.
+                // In other runtimes, callers typically won't supply Buffer attachments.
+                const blob = new Blob([toArrayBuffer(a.content)]);
+                form.append('attachment', blob, a.filename);
+            }
+        }
+        const auth = `Basic ${base64('api:' + apiKey)}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: auth,
+            },
+            body: form,
+        });
+        if (res.ok) {
+            try {
+                const json = (await res.json());
+                const id = typeof json?.['id'] === 'string' ? json['id'] : undefined;
+                return { ok: true, provider: 'mailgun', messageId: id };
+            }
+            catch {
+                return { ok: true, provider: 'mailgun' };
+            }
+        }
+        const text = await res.text();
+        throw ErrorFactory.createConnectionError(`Mailgun send failed (${res.status})`, {
+            status: res.status,
+            body: text,
+        });
+    },
+});
+export default MailgunDriver;