@zintrust/core 0.1.0 → 0.1.2

package/src/tools/broadcast/drivers/Pusher.js

@@ -0,0 +1,75 @@
+import { ErrorFactory } from '../../../exceptions/ZintrustError';
+import { createHash, createHmac } from '../../../node-singletons/crypto';
+const md5Hex = (data) => createHash('md5').update(data).digest('hex');
+const buildQueryString = (params) => {
+    const keys = Object.keys(params).sort((a, b) => a.localeCompare(b));
+    return keys
+        .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(params[key] ?? '')}`)
+        .join('&');
+};
+const buildBaseUrl = (cluster) => {
+    const normalized = cluster.trim();
+    if (normalized === '')
+        return 'https://api.pusherapp.com';
+    return `https://api-${normalized}.pusher.com`;
+};
+const ensureConfig = (config) => {
+    if (config.appId.trim() === '') {
+        throw ErrorFactory.createConfigError('Pusher broadcast misconfigured: PUSHER_APP_ID is required');
+    }
+    if (config.key.trim() === '') {
+        throw ErrorFactory.createConfigError('Pusher broadcast misconfigured: PUSHER_APP_KEY is required');
+    }
+    if (config.secret.trim() === '') {
+        throw ErrorFactory.createConfigError('Pusher broadcast misconfigured: PUSHER_APP_SECRET is required');
+    }
+};
+const signRequest = (params) => {
+    const stringToSign = `${params.method}\n${params.path}\n${params.queryString}`;
+    return createHmac('sha256', params.secret).update(stringToSign).digest('hex');
+};
+export const PusherDriver = Object.freeze({
+    async send(config, channel, event, data) {
+        ensureConfig(config);
+        const payload = {
+            name: event,
+            channels: [channel],
+            data: JSON.stringify(data ?? null),
+        };
+        const body = JSON.stringify(payload);
+        const path = `/apps/${config.appId}/events`;
+        const authTimestamp = String(Math.floor(Date.now() / 1000));
+        const queryParams = {
+            auth_key: config.key,
+            auth_timestamp: authTimestamp,
+            auth_version: '1.0',
+            body_md5: md5Hex(body),
+        };
+        const queryString = buildQueryString(queryParams);
+        const authSignature = signRequest({ method: 'POST', path, secret: config.secret, queryString });
+        const baseUrl = buildBaseUrl(config.cluster);
+        const url = `${baseUrl}${path}?${queryString}&auth_signature=${authSignature}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+            },
+            body,
+        });
+        if (!res.ok) {
+            let responseBody;
+            try {
+                responseBody = await res.text();
+            }
+            catch {
+                responseBody = undefined;
+            }
+            throw ErrorFactory.createTryCatchError(`Pusher broadcast request failed (${res.status})`, {
+                status: res.status,
+                body: responseBody,
+            });
+        }
+        return { ok: true };
+    },
+});
+export default PusherDriver;

package/src/tools/broadcast/drivers/Redis.d.ts

@@ -0,0 +1,19 @@
+export type IRedisPublishClient = {
+    connect?: () => Promise<void>;
+    publish(channel: string, message: string): Promise<number>;
+};
+export type RedisBroadcastDriverConfig = {
+    driver: 'redis';
+    host: string;
+    port: number;
+    password: string;
+    channelPrefix: string;
+};
+export declare const RedisDriver: {
+    readonly send: (config: RedisBroadcastDriverConfig, channel: string, event: string, data: unknown) => Promise<{
+        ok: boolean;
+        published: number;
+    }>;
+};
+export default RedisDriver;
+//# sourceMappingURL=Redis.d.ts.map

package/src/tools/broadcast/drivers/Redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Redis.d.ts","sourceRoot":"","sources":["../../../../../src/tools/broadcast/drivers/Redis.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC5D,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAiBF,eAAO,MAAM,WAAW;4BAsDD,0BAA0B,WAAW,MAAM,SAAS,MAAM,QAAQ,OAAO;;;;CAmB5F,CAAC;AAEL,eAAe,WAAW,CAAC"}

package/src/tools/broadcast/drivers/Redis.js

@@ -0,0 +1,73 @@
+import { ErrorFactory } from '../../../exceptions/ZintrustError';
+const buildRedisUrl = (config) => {
+    const host = (config.host ?? '').trim();
+    const port = Number(config.port);
+    if (!host)
+        throw ErrorFactory.createConfigError('Redis broadcast driver requires host');
+    if (!Number.isFinite(port) || port <= 0) {
+        throw ErrorFactory.createConfigError('Redis broadcast driver requires a valid port');
+    }
+    const password = (config.password ?? '').trim();
+    const authPart = password ? `:${encodeURIComponent(password)}@` : '';
+    return `redis://${authPart}${host}:${port}`;
+};
+export const RedisDriver = (() => {
+    let client = null;
+    let connected = false;
+    const ensureClient = async (config) => {
+        // Always validate config even if a client is already cached
+        const url = buildRedisUrl(config);
+        if (connected && client !== null)
+            return client;
+        // Import lazily so package is optional for environments that don't use Redis
+        try {
+            const mod = (await import('redis'));
+            client = mod.createClient({ url });
+            if (typeof client.connect === 'function') {
+                try {
+                    await client.connect();
+                    connected = true;
+                }
+                catch (err) {
+                    connected = false;
+                    throw ErrorFactory.createTryCatchError('Redis broadcast driver failed to connect', err);
+                }
+            }
+            else {
+                connected = true;
+            }
+        }
+        catch {
+            const globalFake = globalThis
+                .__fakeRedisClient;
+            if (globalFake === undefined) {
+                throw ErrorFactory.createConfigError("Redis broadcast driver requires the 'redis' package or a test fake client set in globalThis.__fakeRedisClient");
+            }
+            client = globalFake;
+            connected = true;
+        }
+        if (client === null)
+            throw ErrorFactory.createConfigError('Redis client could not be initialized');
+        return client;
+    };
+    const normalizePrefix = (value) => {
+        const prefix = (value ?? '').trim();
+        return prefix || 'broadcast:';
+    };
+    return {
+        async send(config, channel, event, data) {
+            const cli = await ensureClient(config);
+            const fullChannel = `${normalizePrefix(config.channelPrefix)}${channel}`;
+            let message;
+            try {
+                message = JSON.stringify({ event, data });
+            }
+            catch (err) {
+                throw ErrorFactory.createTryCatchError('Failed to serialize broadcast payload', err);
+            }
+            const published = await cli.publish(fullChannel, message);
+            return { ok: true, published };
+        },
+    };
+})();
+export default RedisDriver;

package/src/tools/broadcast/drivers/RedisHttps.d.ts

@@ -0,0 +1,14 @@
+export type RedisHttpsBroadcastDriverConfig = {
+    driver: 'redishttps';
+    endpoint: string;
+    token: string;
+    channelPrefix: string;
+};
+export declare const RedisHttpsDriver: Readonly<{
+    send(config: RedisHttpsBroadcastDriverConfig, channel: string, event: string, data: unknown): Promise<{
+        ok: boolean;
+        published: number | undefined;
+    }>;
+}>;
+export default RedisHttpsDriver;
+//# sourceMappingURL=RedisHttps.d.ts.map

package/src/tools/broadcast/drivers/RedisHttps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisHttps.d.ts","sourceRoot":"","sources":["../../../../../src/tools/broadcast/drivers/RedisHttps.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAsBF,eAAO,MAAM,gBAAgB;iBAEjB,+BAA+B,WAC9B,MAAM,SACR,MAAM,QACP,OAAO;;;;EAmCf,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/src/tools/broadcast/drivers/RedisHttps.js

@@ -0,0 +1,50 @@
+import { Env } from '../../../config/env';
+import { ErrorFactory } from '../../../exceptions/ZintrustError';
+import { HttpClient } from '../../http/Http';
+const normalizePrefix = (value) => {
+    const prefix = (value ?? '').trim();
+    return prefix || 'broadcast:';
+};
+const validateConfig = (config) => {
+    const endpoint = (config.endpoint ?? '').trim();
+    const token = (config.token ?? '').trim();
+    if (!endpoint) {
+        throw ErrorFactory.createConfigError('Redis HTTPS broadcast driver requires REDIS_HTTPS_ENDPOINT');
+    }
+    if (!token) {
+        throw ErrorFactory.createConfigError('Redis HTTPS broadcast driver requires REDIS_HTTPS_TOKEN');
+    }
+};
+export const RedisHttpsDriver = Object.freeze({
+    async send(config, channel, event, data) {
+        validateConfig(config);
+        let message;
+        try {
+            message = JSON.stringify({ event, data });
+        }
+        catch (err) {
+            throw ErrorFactory.createTryCatchError('Failed to serialize broadcast payload', err);
+        }
+        const fullChannel = `${normalizePrefix(config.channelPrefix)}${channel}`;
+        const timeout = Env.getInt('REDIS_HTTPS_TIMEOUT', 5000);
+        const response = await HttpClient.post(config.endpoint, {
+            command: 'PUBLISH',
+            channel: fullChannel,
+            message,
+        })
+            .withAuth(config.token)
+            .withTimeout(timeout)
+            .send();
+        response.throwIfServerError();
+        response.throwIfClientError();
+        const published = (() => {
+            const trimmed = response.body.trim();
+            const asNum = Number(trimmed);
+            if (!Number.isFinite(asNum))
+                return undefined;
+            return asNum;
+        })();
+        return { ok: true, published };
+    },
+});
+export default RedisHttpsDriver;

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

@@ -0,0 +1,7 @@
+export { Broadcast } from './Broadcast';
+export { BaseDriver } from './drivers/BaseDriver';
+export { InMemoryDriver } from './drivers/InMemory';
+export { PusherDriver } from './drivers/Pusher';
+export { RedisDriver } from './drivers/Redis';
+export { RedisHttpsDriver } from './drivers/RedisHttps';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/broadcast/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC"}

package/src/tools/broadcast/index.js

@@ -0,0 +1,6 @@
+export { Broadcast } from './Broadcast';
+export { BaseDriver } from './drivers/BaseDriver';
+export { InMemoryDriver } from './drivers/InMemory';
+export { PusherDriver } from './drivers/Pusher';
+export { RedisDriver } from './drivers/Redis';
+export { RedisHttpsDriver } from './drivers/RedisHttps';

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

@@ -0,0 +1,51 @@
+/**
+ * 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 { type IHttpResponse } from './HttpResponse';
+export type { IHttpResponse } from './HttpResponse';
+/**
+ * HTTP Request builder interface
+ */
+export interface IHttpRequest {
+    withHeader(name: string, value: string): IHttpRequest;
+    withHeaders(headers: Record<string, string>): IHttpRequest;
+    withAuth(token: string, scheme?: 'Bearer' | 'Basic'): IHttpRequest;
+    withBasicAuth(username: string, password: string): IHttpRequest;
+    withTimeout(ms: number): IHttpRequest;
+    asJson(): IHttpRequest;
+    asForm(): IHttpRequest;
+    send(): Promise<IHttpResponse>;
+}
+/**
+ * HTTP Client - Sealed namespace for making HTTP requests
+ * Provides Laravel-style fluent API
+ */
+export declare const HttpClient: Readonly<{
+    /**
+     * Make GET request
+     */
+    get(url: string): IHttpRequest;
+    /**
+     * Make POST request
+     */
+    post(url: string, data?: Record<string, unknown>): IHttpRequest;
+    /**
+     * Make PUT request
+     */
+    put(url: string, data?: Record<string, unknown>): IHttpRequest;
+    /**
+     * Make PATCH request
+     */
+    patch(url: string, data?: Record<string, unknown>): IHttpRequest;
+    /**
+     * Make DELETE request
+     */
+    delete(url: string, data?: Record<string, unknown>): IHttpRequest;
+}>;
+export default HttpClient;
+//# sourceMappingURL=Http.d.ts.map

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"}