@zintrust/core 0.1.40 → 0.1.42

package/src/proxy/postgres/PostgresProxyServer.js

@@ -0,0 +1,178 @@
+import * as Deps from '../SqlProxyServerDeps.js';
+import { Pool } from 'pg';
+const resolveDatabaseConfig = (overrides = {}) => {
+    const dbHost = overrides.dbHost ?? Deps.Env.DB_HOST ?? '127.0.0.1';
+    const dbPort = overrides.dbPort ?? Deps.Env.DB_PORT_POSTGRESQL ?? 5432;
+    const dbName = overrides.dbName ?? Deps.Env.DB_DATABASE_POSTGRESQL ?? 'postgres';
+    const dbUser = overrides.dbUser ?? Deps.Env.DB_USERNAME_POSTGRESQL ?? 'postgres';
+    const dbPass = overrides.dbPass ?? Deps.Env.DB_PASSWORD_POSTGRESQL ?? '';
+    const connectionLimit = overrides.connectionLimit ?? Deps.Env.POSTGRES_PROXY_POOL_LIMIT;
+    return { dbHost, dbPort, dbName, dbUser, dbPass, connectionLimit };
+};
+const resolveConfig = (overrides = {}) => {
+    const proxyConfig = Deps.resolveBaseConfig(overrides, 'POSTGRES');
+    const dbConfig = resolveDatabaseConfig(overrides);
+    const signingConfig = Deps.resolveBaseSigningConfig(overrides, 'POSTGRES');
+    const poolOptions = {
+        host: dbConfig.dbHost,
+        port: dbConfig.dbPort,
+        database: dbConfig.dbName,
+        user: dbConfig.dbUser,
+        password: dbConfig.dbPass,
+        max: dbConfig.connectionLimit <= 0 ? 50 : dbConfig.connectionLimit,
+    };
+    return {
+        host: proxyConfig.host,
+        port: proxyConfig.port,
+        maxBodyBytes: proxyConfig.maxBodyBytes,
+        poolOptions,
+        signing: {
+            keyId: signingConfig.keyId,
+            secret: signingConfig.secret,
+            require: signingConfig.requireSigning,
+            windowMs: signingConfig.signingWindowMs,
+        },
+        statements: Deps.loadStatementRegistry('POSTGRES'),
+    };
+};
+const normalizeSql = (sql) => {
+    if (!sql.includes('?'))
+        return sql;
+    let index = 0;
+    return sql.replaceAll('?', () => {
+        index += 1;
+        return `$${index}`;
+    });
+};
+const handleEndpoint = (path, result) => {
+    if (path === '/zin/postgres/query') {
+        return { status: 200, body: { rows: result.rows, rowCount: result.rowCount } };
+    }
+    if (path === '/zin/postgres/queryOne') {
+        const row = result.rows[0] ?? null;
+        return { status: 200, body: { row } };
+    }
+    if (path === '/zin/postgres/exec') {
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                meta: { changes: result.rowCount },
+            },
+        };
+    }
+    if (path === '/zin/postgres/statement') {
+        return { status: 200, body: { rows: result.rows, rowCount: result.rowCount } };
+    }
+    return Deps.ErrorHandler.toProxyError(404, 'NOT_FOUND', 'Unknown endpoint');
+};
+const handleStatementRequest = async (params) => {
+    const resolved = Deps.resolveStatementOrError(params.statements, params.payload);
+    if (!resolved.ok)
+        return resolved.response;
+    try {
+        const normalizedSql = normalizeSql(resolved.value.sql);
+        const result = await params.pool.query(normalizedSql, resolved.value.params);
+        const rows = (result.rows ?? []);
+        const rowCount = result.rowCount ?? rows.length ?? 0;
+        if (!resolved.value.mutating) {
+            return handleEndpoint('/zin/postgres/statement', { rows, rowCount });
+        }
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                meta: { changes: rowCount },
+            },
+        };
+    }
+    catch (error) {
+        Deps.Logger.error('[PostgresProxyServer] Statement execution failed', {
+            path: params.request.path,
+            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, 'POSTGRES_ERROR', String(error));
+    }
+};
+const handleSqlRequest = async (params) => {
+    const sqlValidation = Deps.validateSqlPayload(params.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 sql = normalizeSql(sqlValidation.sql ?? '');
+        const result = await params.pool.query(sql, sqlValidation.params ?? []);
+        return handleEndpoint(params.request.path, {
+            rows: (result.rows ?? []),
+            rowCount: result.rowCount ?? result.rows?.length ?? 0,
+        });
+    }
+    catch (error) {
+        return Deps.ErrorHandler.toProxyError(500, 'POSTGRES_ERROR', String(error));
+    }
+};
+const createBackend = (pool, statements) => ({
+    name: 'postgres',
+    async handle(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/postgres/statement') {
+            return handleStatementRequest({
+                pool,
+                statements,
+                request,
+                payload: parsed.value,
+            });
+        }
+        return handleSqlRequest({ pool, request, payload: parsed.value });
+    },
+    async health() {
+        try {
+            await pool.query('SELECT 1');
+            return { status: 200, body: { status: 'healthy' } };
+        }
+        catch (error) {
+            return Deps.ErrorHandler.toProxyError(503, 'UNHEALTHY', String(error));
+        }
+    },
+});
+export const PostgresProxyServer = Object.freeze({
+    async start(overrides = {}) {
+        const config = resolveConfig(overrides);
+        try {
+            Deps.Logger.info(`Postgres proxy config: proxyHost=${config.host} proxyPort=${config.port} dbHost=${String(config.poolOptions.host)} dbPort=${String(config.poolOptions.port)} dbName=${String(config.poolOptions.database)} dbUser=${String(config.poolOptions.user)}`);
+        }
+        catch {
+            // noop - logging must not block startup
+        }
+        const pool = new Pool(config.poolOptions);
+        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, 'PostgresProxyServer');
+                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(`Postgres proxy listening on http://${config.host}:${config.port}`);
+    },
+});
+export default PostgresProxyServer;

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

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

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

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

package/src/proxy/postgres/register.js

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

package/src/proxy/redis/RedisProxyServer.d.ts

@@ -0,0 +1,12 @@
+import { type BaseProxyOverrides } from '../ProxyServerUtils';
+type ProxyOverrides = BaseProxyOverrides & Partial<{
+    redisHost: string;
+    redisPort: number;
+    redisPassword: string;
+    redisDb: number;
+}>;
+export declare const RedisProxyServer: Readonly<{
+    start(overrides?: ProxyOverrides): Promise<void>;
+}>;
+export default RedisProxyServer;
+//# sourceMappingURL=RedisProxyServer.d.ts.map

package/src/proxy/redis/RedisProxyServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisProxyServer.d.ts","sourceRoot":"","sources":["../../../../src/proxy/redis/RedisProxyServer.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAC;AAiBjC,KAAK,cAAc,GAAG,kBAAkB,GACtC,OAAO,CAAC;IACN,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAyNL,eAAO,MAAM,gBAAgB;sBACJ,cAAc,GAAQ,OAAO,CAAC,IAAI,CAAC;EAqB1D,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/src/proxy/redis/RedisProxyServer.js

@@ -0,0 +1,192 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+import { createProxyServer } from '../ProxyServer.js';
+import { resolveBaseConfig, resolveBaseSigningConfig, verifyRequestSignature, } from '../ProxyServerUtils.js';
+import { RequestValidator } from '../RequestValidator.js';
+const resolveRedisConfig = (overrides = {}) => {
+    const host = overrides.redisHost ?? Env.get('REDIS_PROXY_TARGET_HOST', Env.get('REDIS_HOST', '127.0.0.1'));
+    const port = overrides.redisPort ?? Env.getInt('REDIS_PROXY_TARGET_PORT', Env.getInt('REDIS_PORT', 6379));
+    const password = overrides.redisPassword ??
+        Env.get('REDIS_PROXY_TARGET_PASSWORD', Env.get('REDIS_PASSWORD', ''));
+    const db = overrides.redisDb ?? Env.getInt('REDIS_PROXY_TARGET_DB', Env.getInt('REDIS_DB', 0));
+    return { host, port, password, db };
+};
+const resolveConfig = (overrides = {}) => {
+    const proxyConfig = resolveBaseConfig(overrides, 'REDIS');
+    const redisConfig = resolveRedisConfig(overrides);
+    const signingConfig = resolveBaseSigningConfig(overrides, 'REDIS');
+    return {
+        host: proxyConfig.host,
+        port: proxyConfig.port,
+        maxBodyBytes: proxyConfig.maxBodyBytes,
+        redis: redisConfig,
+        signing: {
+            keyId: signingConfig.keyId,
+            secret: signingConfig.secret,
+            require: signingConfig.requireSigning,
+            windowMs: signingConfig.signingWindowMs,
+        },
+    };
+};
+const validateCommandPayload = (payload) => {
+    const command = payload['command'];
+    const args = Array.isArray(payload['args']) ? payload['args'] : [];
+    if (typeof command !== 'string' || command.trim() === '') {
+        return { valid: false, error: { code: 'VALIDATION_ERROR', message: 'command is required' } };
+    }
+    return { valid: true, command, args };
+};
+const getRedisModule = async () => {
+    const mod = await import('ioredis');
+    return mod;
+};
+const createClient = async (config) => {
+    const module = (await getRedisModule());
+    const moduleDefault = module['default'];
+    const candidates = [
+        module['Redis'],
+        module['default'],
+        moduleDefault?.['Redis'],
+        moduleDefault?.['default'],
+        module,
+    ];
+    const RedisCtor = candidates.find((candidate) => typeof candidate === 'function');
+    if (typeof RedisCtor !== 'function') {
+        throw ErrorFactory.createConfigError("Redis proxy could not resolve a Redis constructor from 'ioredis'.");
+    }
+    const maxReconnectRetries = Math.max(0, Env.getInt('REDIS_PROXY_CONNECT_MAX_RETRIES', 3));
+    const reconnectBaseMs = Math.max(50, Env.getInt('REDIS_PROXY_CONNECT_RETRY_BASE_MS', 200));
+    const reconnectCapMs = Math.max(reconnectBaseMs, Env.getInt('REDIS_PROXY_CONNECT_RETRY_CAP_MS', 2000));
+    const client = new RedisCtor({
+        host: config.redis.host,
+        port: config.redis.port,
+        password: config.redis.password,
+        db: config.redis.db,
+        maxRetriesPerRequest: 1,
+        enableOfflineQueue: false,
+        lazyConnect: true,
+        reconnectOnError: () => false,
+        retryStrategy: (times) => {
+            if (times > maxReconnectRetries) {
+                return null;
+            }
+            return Math.min(times * reconnectBaseMs, reconnectCapMs);
+        },
+    });
+    let lastErrorLogAt = 0;
+    client.on('error', (error) => {
+        const now = Date.now();
+        if (now - lastErrorLogAt < 5000) {
+            return;
+        }
+        lastErrorLogAt = now;
+        Logger.warn('[RedisProxyServer] redis client error', error);
+    });
+    if (typeof client.connect === 'function') {
+        await client.connect();
+    }
+    return client;
+};
+const executeCommand = async (client, command, args) => {
+    const trimmed = command.trim();
+    const lower = trimmed.toLowerCase();
+    const candidate = client[lower];
+    if (typeof candidate === 'function') {
+        return candidate.apply(client, args);
+    }
+    if (typeof client.call === 'function') {
+        return client.call(trimmed, ...args);
+    }
+    throw ErrorFactory.createValidationError(`Unsupported Redis command: ${trimmed}`);
+};
+const createBackend = (config) => ({
+    name: 'redis',
+    handle: async (request) => {
+        const methodError = RequestValidator.requirePost(request.method);
+        if (methodError) {
+            return {
+                status: 405,
+                body: { code: methodError.code, message: methodError.message },
+            };
+        }
+        if (request.path !== '/zin/redis/command') {
+            return { status: 404, body: { code: 'NOT_FOUND', message: 'Unknown endpoint' } };
+        }
+        const parsed = RequestValidator.parseJson(request.body);
+        if (!parsed.ok) {
+            return { status: 400, body: { code: parsed.error.code, message: parsed.error.message } };
+        }
+        const validated = validateCommandPayload(parsed.value);
+        if (!validated.valid) {
+            return {
+                status: 400,
+                body: {
+                    code: validated.error?.code ?? 'VALIDATION_ERROR',
+                    message: validated.error?.message ?? 'Invalid request',
+                },
+            };
+        }
+        const command = validated.command ?? '';
+        if (command.trim() === '') {
+            return {
+                status: 400,
+                body: { code: 'VALIDATION_ERROR', message: 'command is required' },
+            };
+        }
+        try {
+            const client = await createClient(config);
+            try {
+                const result = await executeCommand(client, command, validated.args ?? []);
+                return { status: 200, body: { result } };
+            }
+            finally {
+                await client.quit();
+            }
+        }
+        catch (error) {
+            return ErrorHandler.toProxyError(500, 'REDIS_PROXY_ERROR', String(error));
+        }
+    },
+    health: async () => {
+        try {
+            const client = await createClient(config);
+            const pingFn = client.ping;
+            if (typeof pingFn === 'function') {
+                await pingFn.apply(client);
+            }
+            else {
+                await executeCommand(client, 'PING', []);
+            }
+            await client.quit();
+            return { status: 200, body: { status: 'healthy' } };
+        }
+        catch (error) {
+            Logger.warn('[RedisProxyServer] health check failed', error);
+            return { status: 503, body: { status: 'unhealthy', error: String(error) } };
+        }
+    },
+});
+export const RedisProxyServer = Object.freeze({
+    async start(overrides = {}) {
+        const config = resolveConfig(overrides);
+        const backend = createBackend(config);
+        const server = createProxyServer({
+            host: config.host,
+            port: config.port,
+            maxBodyBytes: config.maxBodyBytes,
+            backend,
+            verify: async (req, body) => {
+                const verified = await verifyRequestSignature(req, body, config, 'RedisProxyServer');
+                if (!verified.ok && verified.error) {
+                    return { ok: false, status: verified.error.status, message: verified.error.message };
+                }
+                return { ok: true };
+            },
+        });
+        await server.start();
+        Logger.info(`[redis-proxy] Listening on http://${config.host}:${config.port}`);
+    },
+});
+export default RedisProxyServer;

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

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

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

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

package/src/proxy/redis/register.js

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

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":"AA4BA,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;AAoUH,eAAO,MAAM,eAAe;sBACH,cAAc,GAAQ,OAAO,CAAC,IAAI,CAAC;EA2B1D,CAAC;AAEH,eAAe,eAAe,CAAC"}