@zintrust/core 3.5.1 → 3.5.2

package/src/proxy/smtp/SmtpProxyServer.d.ts

@@ -0,0 +1,19 @@
+type ProxyOverrides = Partial<{
+    host: string;
+    port: number;
+    maxBodyBytes: number;
+    smtpHost: string;
+    smtpPort: number;
+    smtpUsername: string;
+    smtpPassword: string;
+    smtpSecure: boolean | string;
+    requireSigning: boolean;
+    keyId: string;
+    secret: string;
+    signingWindowMs: number;
+}>;
+export declare const SmtpProxyServer: Readonly<{
+    start(overrides?: ProxyOverrides): Promise<void>;
+}>;
+export default SmtpProxyServer;
+//# sourceMappingURL=SmtpProxyServer.d.ts.map

package/src/proxy/smtp/SmtpProxyServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SmtpProxyServer.d.ts","sourceRoot":"","sources":["../../../../src/proxy/smtp/SmtpProxyServer.ts"],"names":[],"mappings":"AAyBA,KAAK,cAAc,GAAG,OAAO,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC,CAAC;AA6UH,eAAO,MAAM,eAAe;sBACH,cAAc,GAAQ,OAAO,CAAC,IAAI,CAAC;EA2B1D,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/src/proxy/smtp/SmtpProxyServer.js

@@ -0,0 +1,294 @@
+import { SystemTraceBridge } from '../../trace/SystemTraceBridge.js';
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { isNonEmptyString, isObject } from '../../helper/index.js';
+import { SmtpDriver } from '../../tools/mail/drivers/Smtp.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+import { createProxyServer } from '../ProxyServer.js';
+import { resolveProxySigningConfig } from '../ProxySigningConfigResolver.js';
+import { extractSigningHeaders, verifyProxySignatureIfNeeded } from '../ProxySigningRequest.js';
+import { RequestValidator } from '../RequestValidator.js';
+import { SigningService } from '../SigningService.js';
+const normalizeSecure = (value) => {
+    if (value === true || value === false)
+        return value;
+    if (typeof value === 'string') {
+        const raw = value.trim().toLowerCase();
+        if (raw === '')
+            return undefined;
+        if (raw === 'starttls')
+            return 'starttls';
+        if (['tls', 'ssl', 'smtps', 'implicit', 'true', '1', 'yes', 'y'].includes(raw))
+            return true;
+        if (['false', '0', 'no', 'n'].includes(raw))
+            return false;
+    }
+    return undefined;
+};
+const resolveProxyConfig = (overrides = {}) => {
+    const host = overrides.host ?? Env.get('SMTP_PROXY_HOST', Env.HOST ?? '127.0.0.1');
+    const port = overrides.port ?? Env.getInt('SMTP_PROXY_PORT', Env.PORT ?? 8794);
+    const maxBodyBytes = overrides.maxBodyBytes ?? Env.getInt('SMTP_PROXY_MAX_BODY_BYTES', Env.MAX_BODY_SIZE ?? 131072);
+    return { host, port, maxBodyBytes };
+};
+const resolveSmtpConfig = (overrides = {}) => {
+    const host = overrides.smtpHost ?? Env.get('MAIL_HOST', '');
+    const port = overrides.smtpPort ?? Env.getInt('MAIL_PORT', 587);
+    const username = overrides.smtpUsername ?? Env.get('MAIL_USERNAME', '');
+    const password = overrides.smtpPassword ?? Env.get('MAIL_PASSWORD', '');
+    const secureRaw = overrides.smtpSecure ?? Env.get('MAIL_SECURE', '');
+    const secure = normalizeSecure(secureRaw) ?? false;
+    return { host, port, username, password, secure };
+};
+const resolveSigningConfig = (overrides = {}) => resolveProxySigningConfig(overrides, {
+    keyIdEnvVar: 'SMTP_PROXY_KEY_ID',
+    secretEnvVar: 'SMTP_PROXY_SECRET',
+    requireEnvVar: 'SMTP_PROXY_REQUIRE_SIGNING',
+    windowEnvVar: 'SMTP_PROXY_SIGNING_WINDOW_MS',
+});
+const resolveConfig = (overrides = {}) => {
+    const proxyConfig = resolveProxyConfig(overrides);
+    const smtpConfig = resolveSmtpConfig(overrides);
+    const signingConfig = resolveSigningConfig(overrides);
+    return {
+        host: proxyConfig.host,
+        port: proxyConfig.port,
+        maxBodyBytes: proxyConfig.maxBodyBytes,
+        smtp: smtpConfig,
+        signing: {
+            keyId: signingConfig.keyId,
+            secret: signingConfig.secret,
+            require: signingConfig.requireSigning,
+            windowMs: signingConfig.signingWindowMs,
+        },
+    };
+};
+const validateSmtpConfig = (config) => {
+    if (config.host.trim() === '') {
+        throw ErrorFactory.createConfigError('SMTP proxy missing MAIL_HOST');
+    }
+    if (!Number.isFinite(config.port) || config.port <= 0) {
+        throw ErrorFactory.createConfigError('SMTP proxy MAIL_PORT must be a positive integer');
+    }
+    const username = config.username ?? '';
+    const password = config.password ?? '';
+    if ((username.trim() !== '' && password.trim() === '') ||
+        (username.trim() === '' && password.trim() !== '')) {
+        throw ErrorFactory.createConfigError('SMTP proxy requires both MAIL_USERNAME and MAIL_PASSWORD');
+    }
+};
+const verifySignatureIfNeeded = async (req, body, config) => {
+    const headers = extractSigningHeaders(req);
+    if (SigningService.shouldVerify(config.signing, headers)) {
+        const verified = await verifyProxySignatureIfNeeded(req, body, config.signing);
+        if (!verified.ok) {
+            const normalizedSigning = typeof SigningService['normalizeConfig'] === 'function'
+                ? SigningService['normalizeConfig'](config.signing)
+                : config.signing;
+            Logger.warn('[SmtpProxy] Signing verification failed', {
+                code: 'INVALID_SIGNATURE',
+                message: verified.error?.message ?? 'Invalid signature',
+                keyId: headers['x-zt-key-id'],
+                expectedKeyId: normalizedSigning.keyId,
+                requireSigning: normalizedSigning.require,
+            });
+            return {
+                ok: false,
+                error: {
+                    status: verified.error?.status ?? 401,
+                    message: verified.error?.message ?? 'Unauthorized',
+                },
+            };
+        }
+    }
+    return { ok: true };
+};
+const isRecord = (value) => isObject(value);
+const parseAttachment = (value) => {
+    if (!isRecord(value)) {
+        return {
+            ok: false,
+            error: { code: 'VALIDATION_ERROR', message: 'attachments must be objects' },
+        };
+    }
+    const filename = value['filename'];
+    const contentBase64 = value['contentBase64'];
+    if (!isNonEmptyString(filename)) {
+        return {
+            ok: false,
+            error: { code: 'VALIDATION_ERROR', message: 'attachment filename is required' },
+        };
+    }
+    if (!isNonEmptyString(contentBase64)) {
+        return {
+            ok: false,
+            error: { code: 'VALIDATION_ERROR', message: 'attachment contentBase64 is required' },
+        };
+    }
+    const content = Buffer.from(contentBase64, 'base64');
+    return { ok: true, value: { filename, content } };
+};
+const parseTo = (value) => {
+    if (typeof value === 'string' || Array.isArray(value)) {
+        return { ok: true, value: value };
+    }
+    return {
+        ok: false,
+        error: { code: 'VALIDATION_ERROR', message: 'to must be a string or array' },
+    };
+};
+const parseFrom = (value) => {
+    if (!isRecord(value)) {
+        return { ok: false, error: { code: 'VALIDATION_ERROR', message: 'from is required' } };
+    }
+    const email = value['email'];
+    const name = value['name'];
+    if (!isNonEmptyString(email)) {
+        return { ok: false, error: { code: 'VALIDATION_ERROR', message: 'from.email is required' } };
+    }
+    return {
+        ok: true,
+        value: {
+            email,
+            name: isNonEmptyString(name) ? name : undefined,
+        },
+    };
+};
+const parseHtml = (value) => {
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    if (typeof value === 'string')
+        return { ok: true, value };
+    return { ok: false, error: { code: 'VALIDATION_ERROR', message: 'html must be a string' } };
+};
+const parseAttachments = (value) => {
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    if (!Array.isArray(value)) {
+        return {
+            ok: false,
+            error: { code: 'VALIDATION_ERROR', message: 'attachments must be an array' },
+        };
+    }
+    const attachments = [];
+    for (const entry of value) {
+        const parsed = parseAttachment(entry);
+        if (!parsed.ok)
+            return parsed;
+        attachments.push(parsed.value);
+    }
+    return { ok: true, value: attachments };
+};
+const parseMessagePayload = (payload) => {
+    const messageRaw = payload['message'];
+    if (!isRecord(messageRaw)) {
+        return { ok: false, error: { code: 'VALIDATION_ERROR', message: 'message is required' } };
+    }
+    const toParsed = parseTo(messageRaw['to']);
+    if (!toParsed.ok)
+        return toParsed;
+    const fromParsed = parseFrom(messageRaw['from']);
+    if (!fromParsed.ok)
+        return fromParsed;
+    const subject = messageRaw['subject'];
+    if (typeof subject !== 'string' || subject.trim() === '') {
+        return { ok: false, error: { code: 'VALIDATION_ERROR', message: 'subject is required' } };
+    }
+    const text = messageRaw['text'];
+    if (typeof text !== 'string' || text.trim() === '') {
+        return { ok: false, error: { code: 'VALIDATION_ERROR', message: 'text is required' } };
+    }
+    const htmlParsed = parseHtml(messageRaw['html']);
+    if (!htmlParsed.ok)
+        return htmlParsed;
+    const attachmentsParsed = parseAttachments(messageRaw['attachments']);
+    if (!attachmentsParsed.ok)
+        return attachmentsParsed;
+    return {
+        ok: true,
+        value: {
+            to: toParsed.value,
+            from: fromParsed.value,
+            subject,
+            text,
+            html: htmlParsed.value,
+            attachments: attachmentsParsed.value,
+        },
+    };
+};
+const createBackend = (config) => ({
+    name: 'smtp',
+    handle: async (request) => {
+        const methodError = RequestValidator.requirePost(request.method);
+        Logger.info('[SmtpProxy] Received request', { path: request.path, method: request.method });
+        if (methodError) {
+            return ErrorHandler.toProxyError(405, methodError.code, methodError.message);
+        }
+        if (request.path !== '/zin/smtp/send') {
+            Logger.warn('[SmtpProxy] 404 Not Found', { path: request.path });
+            return ErrorHandler.toProxyError(404, 'NOT_FOUND', 'Unknown endpoint');
+        }
+        const parsed = RequestValidator.parseJson(request.body);
+        if (!parsed.ok) {
+            return ErrorHandler.toProxyError(400, parsed.error.code, parsed.error.message);
+        }
+        const messageValidation = parseMessagePayload(parsed.value);
+        if (!messageValidation.ok) {
+            return ErrorHandler.toProxyError(400, messageValidation.error.code, messageValidation.error.message);
+        }
+        try {
+            Logger.info('[SmtpProxy] Sending email via SmtpDriver', { to: messageValidation.value.to });
+            await SmtpDriver.send(config.smtp, messageValidation.value);
+            SystemTraceBridge.emitMail(Array.isArray(messageValidation.value.to)
+                ? messageValidation.value.to.join(', ')
+                : messageValidation.value.to, messageValidation.value.subject, undefined, messageValidation.value.text, messageValidation.value.html);
+            Logger.info('[SmtpProxy] Email sent successfully');
+            return { status: 200, body: { ok: true } };
+        }
+        catch (error) {
+            Logger.error('[SmtpProxy] Failed to send email', error);
+            return ErrorHandler.toProxyError(500, 'SMTP_PROXY_ERROR', String(error));
+        }
+    },
+    async health() {
+        try {
+            validateSmtpConfig(config.smtp);
+            await Promise.resolve();
+            return { status: 200, body: { status: 'healthy' } };
+        }
+        catch (error) {
+            return ErrorHandler.toProxyError(503, 'UNHEALTHY', String(error));
+        }
+    },
+});
+const createVerifier = (config) => async (req, body) => {
+    const verified = await verifySignatureIfNeeded(req, body, config);
+    if (!verified.ok && verified.error) {
+        return { ok: false, status: verified.error.status, message: verified.error.message };
+    }
+    return { ok: true };
+};
+export const SmtpProxyServer = Object.freeze({
+    async start(overrides = {}) {
+        const config = resolveConfig(overrides);
+        validateSmtpConfig(config.smtp);
+        try {
+            Logger.info(`SMTP proxy config: proxyHost=${config.host} proxyPort=${config.port} smtpHost=${String(config.smtp.host)} smtpPort=${String(config.smtp.port)} smtpUser=${String(config.smtp.username ?? '')}`);
+        }
+        catch {
+            // noop
+        }
+        const backend = createBackend(config);
+        const server = createProxyServer({
+            host: config.host,
+            port: config.port,
+            maxBodyBytes: config.maxBodyBytes,
+            backend,
+            verify: createVerifier(config),
+        });
+        await server.start();
+        Logger.info(`SMTP proxy listening on http://${config.host}:${config.port}`);
+    },
+});
+export default SmtpProxyServer;

package/src/proxy/smtp/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/src/proxy/smtp/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/proxy/smtp/register.ts"],"names":[],"mappings":""}

package/src/proxy/smtp/register.js

@@ -0,0 +1,5 @@
+import { ProxyRegistry } from '../ProxyRegistry.js';
+ProxyRegistry.register({
+    name: 'smtp',
+    description: 'SMTP HTTP proxy server',
+});

package/src/proxy/sqlserver/SqlServerProxyServer.d.ts

@@ -0,0 +1,8 @@
+import { type BaseProxyOverrides } from '../ProxyServerUtils.js';
+import type { SqlProxyDatabaseOverrides } from '../SqlProxyDbOverrides.js';
+type ProxyOverrides = BaseProxyOverrides & SqlProxyDatabaseOverrides;
+export declare const SqlServerProxyServer: Readonly<{
+    start(overrides?: ProxyOverrides): Promise<void>;
+}>;
+export {};
+//# sourceMappingURL=SqlServerProxyServer.d.ts.map

package/src/proxy/sqlserver/SqlServerProxyServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqlServerProxyServer.d.ts","sourceRoot":"","sources":["../../../../src/proxy/sqlserver/SqlServerProxyServer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAA0B,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAepG,KAAK,cAAc,GAAG,kBAAkB,GAAG,yBAAyB,CAAC;AAiPrE,eAAO,MAAM,oBAAoB;sBACR,cAAc,GAAQ,OAAO,CAAC,IAAI,CAAC;EAwC1D,CAAC"}

package/src/proxy/sqlserver/SqlServerProxyServer.js

@@ -0,0 +1,208 @@
+import { SystemTraceBridge } from '../../trace/SystemTraceBridge.js';
+import * as Deps from '../SqlProxyServerDeps.js';
+const resolveDatabaseConfig = (overrides = {}) => {
+    const dbHost = overrides.dbHost ?? Deps.Env.get('DB_HOST_MSSQL', Deps.Env.get('DB_HOST', '127.0.0.1'));
+    const dbPort = overrides.dbPort ?? Deps.Env.getInt('DB_PORT_MSSQL', 1433);
+    const dbName = overrides.dbName ?? Deps.Env.get('DB_DATABASE_MSSQL', 'zintrust');
+    const dbUser = overrides.dbUser ?? Deps.Env.get('DB_USERNAME_MSSQL', 'sa');
+    const dbPass = overrides.dbPass ?? Deps.Env.get('DB_PASSWORD_MSSQL', '');
+    const connectionLimit = overrides.connectionLimit ?? Deps.Env.getInt('SQLSERVER_PROXY_POOL_LIMIT', 10);
+    return { dbHost, dbPort, dbName, dbUser, dbPass, connectionLimit };
+};
+const resolveConfig = (overrides = {}) => {
+    const proxyConfig = Deps.resolveBaseConfig(overrides, 'SQLSERVER');
+    const dbConfig = resolveDatabaseConfig(overrides);
+    const signingConfig = Deps.resolveBaseSigningConfig(overrides, 'SQLSERVER');
+    const poolConfig = {
+        server: dbConfig.dbHost,
+        port: dbConfig.dbPort,
+        database: dbConfig.dbName,
+        user: dbConfig.dbUser,
+        password: dbConfig.dbPass,
+        pool: {
+            max: dbConfig.connectionLimit,
+            min: 0,
+            idleTimeoutMillis: 30000,
+        },
+        options: {
+            encrypt: false,
+            trustServerCertificate: true,
+        },
+    };
+    return {
+        host: proxyConfig.host,
+        port: proxyConfig.port,
+        maxBodyBytes: proxyConfig.maxBodyBytes,
+        poolConfig,
+        signing: {
+            keyId: signingConfig.keyId,
+            secret: signingConfig.secret,
+            require: signingConfig.requireSigning,
+            windowMs: signingConfig.signingWindowMs,
+        },
+        statements: Deps.loadStatementRegistry('SQLSERVER'),
+    };
+};
+const validateQueryPayload = (payload) => {
+    const base = Deps.validateSqlPayload(payload);
+    if (!base.valid) {
+        return { valid: false, error: base.error };
+    }
+    if (base.sql.trim() === '') {
+        return { valid: false, error: { code: 'VALIDATION_ERROR', message: 'sql is required' } };
+    }
+    return { valid: true, sql: base.sql, params: base.params };
+};
+const getSqlModule = async () => {
+    const mod = await import('mssql');
+    return mod;
+};
+const createPool = async (config) => {
+    const mod = await getSqlModule();
+    const connect = mod['connect'];
+    return connect(config);
+};
+const executeQuery = async (pool, sqlQuery, params) => {
+    const requestFunc = pool['request'];
+    const request = requestFunc();
+    params.forEach((param, index) => {
+        const inputFunc = request['input'];
+        inputFunc(`param${index}`, param);
+    });
+    const queryFunc = request['query'];
+    return queryFunc(sqlQuery);
+};
+const handleEndpoint = (path, result) => {
+    const rows = result['recordset'];
+    const rowsAffected = result['rowsAffected'];
+    if (path === '/zin/sqlserver/query') {
+        return { status: 200, body: { rows, rowCount: rowsAffected[0] ?? 0 } };
+    }
+    if (path === '/zin/sqlserver/queryOne') {
+        const firstRow = Array.isArray(rows) ? rows[0] : null;
+        return { status: 200, body: { row: firstRow ?? null } };
+    }
+    if (path === '/zin/sqlserver/exec') {
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                meta: { changes: rowsAffected[0] ?? 0 },
+            },
+        };
+    }
+    if (path === '/zin/sqlserver/statement') {
+        // Statement endpoint returns query-shaped response for non-mutating SQL.
+        return { status: 200, body: { rows, rowCount: rowsAffected[0] ?? 0 } };
+    }
+    return Deps.ErrorHandler.toProxyError(404, 'NOT_FOUND', 'Unknown endpoint');
+};
+const toMutatingStatementResponse = (result) => {
+    const rowsAffected = result['rowsAffected'];
+    return {
+        status: 200,
+        body: {
+            ok: true,
+            meta: { changes: rowsAffected[0] ?? 0 },
+        },
+    };
+};
+const handleStatementRequest = async (pool, statements, requestPath, payload) => {
+    const resolved = Deps.resolveStatementOrError(statements, payload);
+    if (!resolved.ok)
+        return resolved.response;
+    try {
+        const startedAt = Date.now();
+        const result = await executeQuery(pool, resolved.value.sql, resolved.value.params);
+        SystemTraceBridge.emitQuery(resolved.value.sql, resolved.value.params, Date.now() - startedAt, 'sqlserver-proxy');
+        if (!resolved.value.mutating)
+            return handleEndpoint('/zin/sqlserver/statement', result);
+        return toMutatingStatementResponse(result);
+    }
+    catch (error) {
+        Deps.Logger.error('[SqlServerProxyServer] Statement execution failed', {
+            path: requestPath,
+            statementId: resolved.value.statementId,
+            mutating: resolved.value.mutating,
+            paramsCount: resolved.value.params.length,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return Deps.ErrorHandler.toProxyError(500, 'SQLSERVER_ERROR', String(error));
+    }
+};
+const handleSqlRequest = async (pool, requestPath, payload) => {
+    const sqlValidation = validateQueryPayload(payload);
+    if (!sqlValidation.valid) {
+        const error = sqlValidation.error ?? {
+            code: 'VALIDATION_ERROR',
+            message: 'Invalid SQL payload',
+        };
+        return Deps.ErrorHandler.toProxyError(400, error.code, error.message);
+    }
+    try {
+        const startedAt = Date.now();
+        const result = await executeQuery(pool, sqlValidation.sql ?? '', sqlValidation.params ?? []);
+        SystemTraceBridge.emitQuery(sqlValidation.sql ?? '', sqlValidation.params ?? [], Date.now() - startedAt, 'sqlserver-proxy');
+        return handleEndpoint(requestPath, result);
+    }
+    catch (error) {
+        return Deps.ErrorHandler.toProxyError(500, 'SQLSERVER_ERROR', String(error));
+    }
+};
+const handleProxyRequest = async (pool, statements, request) => {
+    const validationError = Deps.validateProxyRequest(request);
+    if (validationError !== null)
+        return validationError;
+    const parsed = Deps.parseJsonBody(request.body);
+    if ('status' in parsed)
+        return parsed;
+    if (request.path === '/zin/sqlserver/statement') {
+        return handleStatementRequest(pool, statements, request.path, parsed.value);
+    }
+    return handleSqlRequest(pool, request.path, parsed.value);
+};
+const createBackend = (pool, statements) => ({
+    name: 'sqlserver',
+    handle: async (request) => handleProxyRequest(pool, statements, request),
+    health: async () => {
+        try {
+            await executeQuery(pool, 'SELECT 1', []);
+            return { status: 200, body: { status: 'healthy' } };
+        }
+        catch (error) {
+            return Deps.ErrorHandler.toProxyError(503, 'UNHEALTHY', String(error));
+        }
+    },
+    shutdown: async () => {
+        const closeFunc = pool['close'];
+        await closeFunc();
+    },
+});
+export const SqlServerProxyServer = Object.freeze({
+    async start(overrides = {}) {
+        const config = resolveConfig(overrides);
+        try {
+            Deps.Logger.info(`SQL Server proxy config: proxyHost=${config.host} proxyPort=${config.port} dbHost=${String(config.poolConfig['server'])} dbPort=${String(config.poolConfig['port'])} dbName=${String(config.poolConfig['database'])} dbUser=${String(config.poolConfig['user'])}`);
+        }
+        catch {
+            // noop - logging must not block startup
+        }
+        const pool = await createPool(config.poolConfig);
+        const backend = createBackend(pool, config.statements);
+        const proxy = Deps.createProxyServer({
+            host: config.host,
+            port: config.port,
+            maxBodyBytes: config.maxBodyBytes,
+            backend,
+            verify: async (req, body) => {
+                const verified = await Deps.verifyRequestSignature(req, body, config, 'SqlServerProxyServer');
+                if (!verified.ok && verified.error) {
+                    return { ok: false, status: verified.error.status, message: verified.error.message };
+                }
+                return { ok: true };
+            },
+        });
+        await proxy.start();
+        Deps.Logger.info(`✓ SQL Server proxy listening on ${config.host}:${config.port}`);
+    },
+});

package/src/proxy/sqlserver/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/src/proxy/sqlserver/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/proxy/sqlserver/register.ts"],"names":[],"mappings":""}

package/src/proxy/sqlserver/register.js

@@ -0,0 +1,5 @@
+import { ProxyRegistry } from '../ProxyRegistry.js';
+ProxyRegistry.register({
+    name: 'sqlserver',
+    description: 'SQL Server HTTP proxy',
+});

package/src/proxy-index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ZinTrust Proxy - Proxy-only integrations
+ * Contains proxy utilities and proxy-specific functionality
+ */
+export { ZintrustD1Proxy } from './proxy/d1/ZintrustD1Proxy.js';
+export { ZintrustEmailProxy } from './proxy/email/ZintrustEmailProxy.js';
+export { ErrorHandler } from './proxy/ErrorHandler.js';
+export { ZintrustKvProxy } from './proxy/kv/ZintrustKvProxy.js';
+export { RequestValidator } from './proxy/RequestValidator.js';
+export { WorkerSigning } from './proxy/WorkerSigning.js';
+//# sourceMappingURL=proxy-index.d.ts.map

package/src/proxy-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-index.d.ts","sourceRoot":"","sources":["../../src/proxy-index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC"}

package/src/proxy-index.js

@@ -0,0 +1,10 @@
+/**
+ * ZinTrust Proxy - Proxy-only integrations
+ * Contains proxy utilities and proxy-specific functionality
+ */
+export { ZintrustD1Proxy } from './proxy/d1/ZintrustD1Proxy.js';
+export { ZintrustEmailProxy } from './proxy/email/ZintrustEmailProxy.js';
+export { ErrorHandler } from './proxy/ErrorHandler.js';
+export { ZintrustKvProxy } from './proxy/kv/ZintrustKvProxy.js';
+export { RequestValidator } from './proxy/RequestValidator.js';
+export { WorkerSigning } from './proxy/WorkerSigning.js';

package/src/proxy.d.ts

@@ -0,0 +1,7 @@
+export { ZintrustD1Proxy } from './proxy/d1/ZintrustD1Proxy.js';
+export { ZintrustEmailProxy } from './proxy/email/ZintrustEmailProxy.js';
+export { ErrorHandler } from './proxy/ErrorHandler.js';
+export { ZintrustKvProxy } from './proxy/kv/ZintrustKvProxy.js';
+export { RequestValidator } from './proxy/RequestValidator.js';
+export { WorkerSigning } from './proxy/WorkerSigning.js';
+//# sourceMappingURL=proxy.d.ts.map

package/src/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/proxy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC"}

package/src/proxy.js

@@ -0,0 +1,6 @@
+export { ZintrustD1Proxy } from './proxy/d1/ZintrustD1Proxy.js';
+export { ZintrustEmailProxy } from './proxy/email/ZintrustEmailProxy.js';
+export { ErrorHandler } from './proxy/ErrorHandler.js';
+export { ZintrustKvProxy } from './proxy/kv/ZintrustKvProxy.js';
+export { RequestValidator } from './proxy/RequestValidator.js';
+export { WorkerSigning } from './proxy/WorkerSigning.js';

package/src/queue-index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Queue Exports
+ * Provides queue utilities and types
+ */
+export { resolveDeduplicationLockKey } from './tools/queue/DeduplicationKey.js';
+export { createLockProvider, getLockProvider, registerLockProvider } from './tools/queue/LockProvider.js';
+export { Queue, resolveLockPrefix } from './tools/queue/Queue.js';
+export type { BullMQPayload, QueueMessage } from './tools/queue/Queue.js';
+export { JobHeartbeatStore } from './tools/queue/JobHeartbeatStore.js';
+export { JobStateTracker } from './tools/queue/JobStateTracker.js';
+export { TimeoutManager } from './tools/queue/TimeoutManager.js';
+export { autoRegisterJobStateTrackerPersistenceFromEnv, createJobStateTrackerDbPersistence, } from './tools/queue/JobStateTrackerDbPersistence.js';
+export { RedisKeys } from './tools/redis/RedisKeyManager.js';
+//# sourceMappingURL=queue-index.d.ts.map

package/src/queue-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-index.d.ts","sourceRoot":"","sources":["../../src/queue-index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChG,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EACL,6CAA6C,EAC7C,kCAAkC,GACnC,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC"}

package/src/queue-index.js

@@ -0,0 +1,12 @@
+/**
+ * Queue Exports
+ * Provides queue utilities and types
+ */
+export { resolveDeduplicationLockKey } from './tools/queue/DeduplicationKey.js';
+export { createLockProvider, getLockProvider, registerLockProvider } from './tools/queue/LockProvider.js';
+export { Queue, resolveLockPrefix } from './tools/queue/Queue.js';
+export { JobHeartbeatStore } from './tools/queue/JobHeartbeatStore.js';
+export { JobStateTracker } from './tools/queue/JobStateTracker.js';
+export { TimeoutManager } from './tools/queue/TimeoutManager.js';
+export { autoRegisterJobStateTrackerPersistenceFromEnv, createJobStateTrackerDbPersistence, } from './tools/queue/JobStateTrackerDbPersistence.js';
+export { RedisKeys } from './tools/redis/RedisKeyManager.js';

package/src/redis-index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ZinTrust Redis - Redis key management utilities
+ * Contains Redis key helpers and BullMQ-safe queue name generation
+ */
+export { RedisKeys, createRedisKey, extractOriginalKey, getBullMQSafeQueueName, getPrefix, isAppKey, type RedisKeyType, } from './tools/redis/RedisKeyManager.js';
+export type { RedisConfig } from './config/type.js';
+export { createRedisConnection } from './config/workers.js';
+export type { RedisTransportOptions } from './tools/redis/RedisTransport.js';
+export { isZedgiRedisExecutorRegistered, registerZedgiRedisExecutor, resolveRedisTransportMode, type RedisTransportMode, } from './tools/redis/RedisTransport.js';
+//# sourceMappingURL=redis-index.d.ts.map