@zintrust/core 0.4.17 → 0.4.19

package/src/proxy/mongodb/MongoDBProxyServer.ts

@@ -1,328 +0,0 @@
-import { Env } from '@config/env';
-import { Logger } from '@config/logger';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import type { IncomingMessage } from '@node-singletons/http';
-import { ErrorHandler } from '@proxy/ErrorHandler';
-import type { ProxyBackend, ProxyResponse } from '@proxy/ProxyBackend';
-import type { ProxySigningConfig } from '@proxy/ProxyConfig';
-import { createProxyServer } from '@proxy/ProxyServer';
-import { resolveProxySigningConfig } from '@proxy/ProxySigningConfigResolver';
-import { verifyProxySignatureIfNeeded } from '@proxy/ProxySigningRequest';
-import { RequestValidator } from '@proxy/RequestValidator';
-
-type MongoCollectionLike = Record<string, unknown>;
-type MongoDatabaseLike = {
-  collection: (name: string) => MongoCollectionLike;
-};
-type MongoClientLike = {
-  connect: () => Promise<void>;
-  db: (name: string) => MongoDatabaseLike;
-  close: () => Promise<void>;
-};
-
-type ProxyConfig = {
-  host: string;
-  port: number;
-  maxBodyBytes: number;
-  mongoOptions: {
-    uri: string;
-    database: string;
-  };
-  signing: ProxySigningConfig;
-};
-
-type ProxyOverrides = Partial<{
-  host: string;
-  port: number;
-  maxBodyBytes: number;
-  mongoUri: string;
-  mongoDb: string;
-  requireSigning: boolean;
-  keyId: string;
-  secret: string;
-  signingWindowMs: number;
-}>;
-
-const resolveProxyConfig = (
-  overrides: ProxyOverrides = {}
-): {
-  host: string;
-  port: number;
-  maxBodyBytes: number;
-} => {
-  const host = overrides?.host ?? Env.get('MONGODB_PROXY_HOST', Env.HOST ?? '127.0.0.1');
-  const port = overrides.port ?? Env.getInt('MONGODB_PROXY_PORT', Env.PORT ?? 3000);
-  const maxBodyBytes =
-    overrides.maxBodyBytes ?? Env.getInt('MONGODB_PROXY_MAX_BODY_BYTES', Env.MAX_BODY_SIZE ?? 0);
-
-  return { host, port, maxBodyBytes };
-};
-
-const resolveMongoConfig = (
-  overrides: ProxyOverrides = {}
-): {
-  uri: string;
-  database: string;
-} => {
-  const uri = overrides.mongoUri ?? Env.get('MONGO_URI', 'mongodb://localhost:27017');
-  const database = overrides.mongoDb ?? Env.get('MONGO_DB', 'zintrust');
-
-  return { uri, database };
-};
-
-const resolveSigningConfig = (
-  overrides: ProxyOverrides = {}
-): {
-  keyId: string;
-  secret: string;
-  requireSigning: boolean;
-  signingWindowMs: number;
-} =>
-  resolveProxySigningConfig(overrides, {
-    keyIdEnvVar: 'MONGODB_PROXY_KEY_ID',
-    secretEnvVar: 'MONGODB_PROXY_SECRET',
-    requireEnvVar: 'MONGODB_PROXY_REQUIRE_SIGNING',
-    windowEnvVar: 'MONGODB_PROXY_SIGNING_WINDOW_MS',
-  });
-
-const resolveConfig = (overrides: ProxyOverrides = {}): ProxyConfig => {
-  const proxyConfig = resolveProxyConfig(overrides);
-  const mongoConfig = resolveMongoConfig(overrides);
-  const signingConfig = resolveSigningConfig(overrides);
-
-  return {
-    host: proxyConfig.host,
-    port: proxyConfig.port,
-    maxBodyBytes: proxyConfig.maxBodyBytes,
-    mongoOptions: mongoConfig,
-    signing: {
-      keyId: signingConfig.keyId,
-      secret: signingConfig.secret,
-      require: signingConfig.requireSigning,
-      windowMs: signingConfig.signingWindowMs,
-    },
-  };
-};
-
-const validateOperationPayload = (
-  payload: Record<string, unknown>
-): {
-  valid: boolean;
-  operation?: string;
-  collection?: string;
-  args?: Record<string, unknown>;
-  error?: { code: string; message: string };
-} => {
-  const operation = payload['operation'];
-  const collection = payload['collection'];
-  const args = payload['args'];
-
-  if (typeof operation !== 'string' || operation.trim() === '') {
-    return {
-      valid: false,
-      error: { code: 'VALIDATION_ERROR', message: 'operation is required' },
-    };
-  }
-
-  if (typeof collection !== 'string' || collection.trim() === '') {
-    return {
-      valid: false,
-      error: { code: 'VALIDATION_ERROR', message: 'collection is required' },
-    };
-  }
-
-  return {
-    valid: true,
-    operation,
-    collection,
-    args: (args as Record<string, unknown>) ?? {},
-  };
-};
-
-const getMongoModule = async (): Promise<{ MongoClient: new (uri: string) => MongoClientLike }> => {
-  const mongoModule = (await import('mongodb')) as { MongoClient?: unknown };
-  const MongoDBClient = mongoModule.MongoClient;
-  if (typeof MongoDBClient !== 'function') {
-    throw ErrorFactory.createDatabaseError('MongoDB driver is unavailable');
-  }
-  return { MongoClient: MongoDBClient as new (uri: string) => MongoClientLike };
-};
-
-const createMongoClient = async (uri: string): Promise<MongoClientLike> => {
-  const { MongoClient: MongoDBClient } = await getMongoModule();
-  const client = new MongoDBClient(uri);
-  await client.connect();
-  return client;
-};
-
-const callMethod = async (
-  coll: MongoCollectionLike,
-  methodName: string,
-  ...params: unknown[]
-): Promise<unknown> => {
-  const method = (coll as unknown as Record<string, unknown>)[methodName];
-  if (typeof method === 'function') {
-    const result = (method as (...input: unknown[]) => unknown)(...params);
-    if (result !== null && typeof result === 'object' && 'toArray' in result) {
-      const toArray = (result as { toArray?: () => Promise<unknown> }).toArray;
-      if (typeof toArray === 'function') {
-        return toArray();
-      }
-    }
-    return result;
-  }
-  throw ErrorFactory.createDatabaseError(`Method ${methodName} not found on collection`);
-};
-
-const OPERATION_HANDLERS = Object.freeze({
-  find: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'find', args['filter'] ?? {}),
-  findOne: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'findOne', args['filter'] ?? {}),
-  insertOne: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'insertOne', args['document'] ?? {}),
-  insertMany: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'insertMany', (args['documents'] as unknown[]) ?? []),
-  updateOne: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'updateOne', args['filter'] ?? {}, args['update'] ?? {}),
-  updateMany: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'updateMany', args['filter'] ?? {}, args['update'] ?? {}),
-  deleteOne: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'deleteOne', args['filter'] ?? {}),
-  deleteMany: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'deleteMany', args['filter'] ?? {}),
-  countDocuments: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'countDocuments', args['filter'] ?? {}),
-  aggregate: async (coll: MongoCollectionLike, args: Record<string, unknown>) =>
-    callMethod(coll, 'aggregate', (args['pipeline'] as unknown[]) ?? []),
-} as const);
-
-const executeOperation = async (
-  client: MongoClientLike,
-  dbName: string,
-  collectionName: string,
-  operation: string,
-  args: Record<string, unknown>
-): Promise<unknown> => {
-  const db = client.db(dbName);
-  const coll = db.collection(collectionName);
-
-  if (Object.prototype.hasOwnProperty.call(OPERATION_HANDLERS, operation)) {
-    const handler = OPERATION_HANDLERS[operation as keyof typeof OPERATION_HANDLERS];
-    return handler(coll, args);
-  }
-
-  throw ErrorFactory.createDatabaseError(`Unsupported MongoDB operation: ${String(operation)}`);
-};
-
-const createBackend = (client: MongoClientLike, config: ProxyConfig): ProxyBackend => ({
-  name: 'mongodb',
-  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/mongodb/operation') {
-      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 = validateOperationPayload(parsed.value);
-    if (!validated.valid) {
-      return {
-        status: 400,
-        body: {
-          code: validated.error?.code ?? 'VALIDATION_ERROR',
-          message: validated.error?.message ?? 'Invalid request',
-        },
-      };
-    }
-
-    try {
-      const result = await executeOperation(
-        client,
-        config.mongoOptions.database,
-        validated.collection ?? '',
-        validated.operation ?? '',
-        validated.args ?? {}
-      );
-
-      return { status: 200, body: { success: true, result } };
-    } catch (error) {
-      Logger.error('MongoDB proxy operation failed', { error });
-      return ErrorHandler.toProxyError(500, 'MONGODB_PROXY_ERROR', String(error));
-    }
-  },
-  health: async (): Promise<ProxyResponse> => {
-    try {
-      client.db(config.mongoOptions.database);
-      await Promise.resolve();
-      return { status: 200, body: { status: 'ok' } };
-    } catch (error) {
-      await Promise.resolve();
-      return { status: 503, body: { status: 'unhealthy', error: String(error) } };
-    }
-  },
-  shutdown: async (): Promise<void> => {
-    await client.close();
-  },
-});
-
-const createVerifier = (
-  config: ProxyConfig
-): ((
-  req: IncomingMessage,
-  body: string
-) => Promise<{ ok: true } | { ok: false; status: number; message: string }>) => {
-  return async (req, body) => {
-    const verified = await verifyProxySignatureIfNeeded(req, body, config.signing);
-    if (!verified.ok) {
-      const error = verified.error ?? { status: 401, message: 'Unauthorized' };
-      return { ok: false as const, status: error.status, message: error.message };
-    }
-
-    return { ok: true as const };
-  };
-};
-
-export const MongoDBProxyServer = Object.freeze({
-  async start(overrides: ProxyOverrides = {}) {
-    const config = resolveConfig(overrides);
-    Logger.info(
-      `Starting MongoDB proxy on ${config.host}:${config.port} → ${config.mongoOptions.uri}`
-    );
-
-    const client = await createMongoClient(config.mongoOptions.uri);
-    const backend = createBackend(client, config);
-    const verifier = createVerifier(config);
-
-    const server = createProxyServer({
-      host: config.host,
-      port: config.port,
-      maxBodyBytes: config.maxBodyBytes,
-      backend,
-      verify: verifier,
-    });
-
-    await server.start();
-    Logger.info(`✓ MongoDB proxy listening on ${config.host}:${config.port}`);
-
-    return {
-      server,
-      client,
-      async close() {
-        await server.stop();
-        await client.close();
-        Logger.info('MongoDB proxy server closed');
-      },
-    };
-  },
-});

package/src/proxy/mongodb/register.ts

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

package/src/proxy/mysql/MySqlProxyServer.ts

@@ -1,275 +0,0 @@
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import type { ProxyBackend, ProxyResponse } from '@proxy/ProxyBackend';
-import type { ProxySigningConfig } from '@proxy/ProxyConfig';
-import { type BaseProxyOverrides } from '@proxy/ProxyServerUtils';
-import type { SqlProxyDatabaseOverrides } from '@proxy/SqlProxyDbOverrides';
-import * as Deps from '@proxy/SqlProxyServerDeps';
-import { createPool, type Pool, type PoolOptions } from 'mysql2/promise';
-
-type ProxyConfig = {
-  host: string;
-  port: number;
-  maxBodyBytes: number;
-  poolOptions: PoolOptions;
-  signing: ProxySigningConfig;
-  statements?: Record<string, string>;
-};
-
-type ProxyOverrides = BaseProxyOverrides & SqlProxyDatabaseOverrides;
-
-const resolveDatabaseConfig = (
-  overrides: ProxyOverrides = {}
-): {
-  dbHost: string;
-  dbPort: number;
-  dbName: string;
-  dbUser: string;
-  dbPass: string;
-  connectionLimit: number;
-} => {
-  const dbHost =
-    overrides.dbHost ?? Deps.Env.get('MYSQL_DB_HOST', Deps.Env.get('DB_HOST', '127.0.0.1'));
-  const dbPort =
-    overrides.dbPort ?? Deps.Env.getInt('MYSQL_DB_PORT', Deps.Env.getInt('DB_PORT', 3306));
-  const dbName =
-    overrides.dbName ?? Deps.Env.get('MYSQL_DB_DATABASE', Deps.Env.get('DB_DATABASE', 'zintrust'));
-  const dbUser =
-    overrides.dbUser ?? Deps.Env.get('MYSQL_DB_USERNAME', Deps.Env.get('DB_USERNAME', 'root'));
-  const dbPass =
-    overrides.dbPass ?? Deps.Env.get('MYSQL_DB_PASSWORD', Deps.Env.get('DB_PASSWORD', 'pass'));
-  const connectionLimit = overrides.connectionLimit ?? Deps.Env.MYSQL_PROXY_POOL_LIMIT;
-
-  return { dbHost, dbPort, dbName, dbUser, dbPass, connectionLimit };
-};
-
-const resolveConfig = (overrides: ProxyOverrides = {}): ProxyConfig => {
-  const proxyConfig = Deps.resolveBaseConfig(overrides, 'MYSQL');
-  const dbConfig = resolveDatabaseConfig(overrides);
-  const signingConfig = Deps.resolveBaseSigningConfig(overrides, 'MYSQL');
-
-  const poolOptions: PoolOptions = {
-    host: dbConfig.dbHost,
-    port: dbConfig.dbPort,
-    database: dbConfig.dbName,
-    user: dbConfig.dbUser,
-    password: dbConfig.dbPass,
-    waitForConnections: true,
-    connectionLimit: dbConfig.connectionLimit <= 0 ? 50 : dbConfig.connectionLimit,
-    queueLimit: 0,
-    enableKeepAlive: true,
-    keepAliveInitialDelay: 0,
-    namedPlaceholders: true,
-  };
-
-  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('MYSQL'),
-  };
-};
-
-const normalizeResult = (
-  rows: unknown
-): {
-  rows: Record<string, unknown>[];
-  rowCount: number;
-  lastInsertId?: number | string | bigint;
-} => {
-  if (Array.isArray(rows)) {
-    return { rows: rows as Record<string, unknown>[], rowCount: rows.length };
-  }
-  if (rows !== null && rows !== undefined && typeof rows === 'object') {
-    const input = rows as { affectedRows?: number; insertId?: number | string | bigint };
-    const affectedRows = Number.isFinite(input.affectedRows) ? Number(input.affectedRows) : 0;
-    const insertId = input.insertId;
-    const lastInsertId =
-      typeof insertId === 'number' || typeof insertId === 'string' || typeof insertId === 'bigint'
-        ? insertId
-        : undefined;
-    return { rows: [], rowCount: affectedRows, lastInsertId };
-  }
-  return { rows: [], rowCount: 0 };
-};
-
-const handleEndpoint = (path: string, rows: unknown): ProxyResponse => {
-  if (path === '/zin/mysql/query') {
-    return { status: 200, body: normalizeResult(rows) };
-  }
-
-  if (path === '/zin/mysql/queryOne') {
-    if (Array.isArray(rows)) {
-      return { status: 200, body: { row: (rows[0] as unknown) ?? null } };
-    }
-    return { status: 200, body: { row: null } };
-  }
-
-  if (path === '/zin/mysql/exec') {
-    const normalized = normalizeResult(rows);
-    return {
-      status: 200,
-      body: {
-        ok: true,
-        meta: { changes: normalized.rowCount, lastRowId: normalized.lastInsertId },
-      },
-    };
-  }
-
-  return Deps.ErrorHandler.toProxyError(404, 'NOT_FOUND', 'Unknown endpoint');
-};
-
-const handleStatementRequest = async (params: {
-  pool: Pool;
-  statements: Record<string, string> | undefined;
-  request: { path: string };
-  payload: Record<string, unknown>;
-}): Promise<ProxyResponse> => {
-  const resolved = Deps.resolveStatementOrError(params.statements, params.payload);
-  if (!resolved.ok) return resolved.response;
-
-  try {
-    const [rows] = await params.pool.query(resolved.value.sql, resolved.value.params);
-
-    const normalized = normalizeResult(rows);
-    if (!resolved.value.mutating) {
-      return { status: 200, body: { rows: normalized.rows, rowCount: normalized.rowCount } };
-    }
-
-    return {
-      status: 200,
-      body: {
-        ok: true,
-        meta: { changes: normalized.rowCount, lastRowId: normalized.lastInsertId },
-      },
-    };
-  } catch (error) {
-    Deps.Logger.error('[MySQLProxyServer] 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, 'MYSQL_ERROR', String(error));
-  }
-};
-
-const handleSqlRequest = async (params: {
-  pool: Pool;
-  request: { path: string };
-  payload: Record<string, unknown>;
-}): Promise<ProxyResponse> => {
-  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 [rows] = await params.pool.query(sqlValidation.sql ?? '', sqlValidation.params ?? []);
-    return handleEndpoint(params.request.path, rows);
-  } catch (error) {
-    Deps.Logger.error('[MySQLProxyServer] Query execution failed', {
-      path: params.request.path,
-      sqlPreview: String(sqlValidation.sql ?? '').slice(0, 160),
-      paramsCount: Array.isArray(sqlValidation.params) ? sqlValidation.params.length : 0,
-      error: error instanceof Error ? error.message : String(error),
-    });
-    return Deps.ErrorHandler.toProxyError(500, 'MYSQL_ERROR', String(error));
-  }
-};
-
-const createBackend = (
-  pool: Pool,
-  statements: Record<string, string> | undefined
-): ProxyBackend => ({
-  name: 'mysql',
-  async handle(request): Promise<ProxyResponse> {
-    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/mysql/statement') {
-      return handleStatementRequest({
-        pool,
-        statements,
-        request,
-        payload: parsed.value,
-      });
-    }
-
-    return handleSqlRequest({ pool, request, payload: parsed.value });
-  },
-  async health(): Promise<ProxyResponse> {
-    try {
-      await pool.query('SELECT 1');
-      return { status: 200, body: { status: 'healthy' } };
-    } catch (error) {
-      Deps.Logger.error('[MySQLProxyServer] Health check failed', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return Deps.ErrorHandler.toProxyError(503, 'UNHEALTHY', String(error));
-    }
-  },
-});
-
-export const MySqlProxyServer = Object.freeze({
-  async start(overrides: ProxyOverrides = {}): Promise<void> {
-    const config = resolveConfig(overrides);
-    const signingHasKeyId = config.signing.keyId.trim() !== '';
-    const signingHasSecret = config.signing.secret.trim() !== '';
-
-    if (config.signing.require && (!signingHasKeyId || !signingHasSecret)) {
-      throw ErrorFactory.createConfigError(
-        `MySQL proxy signing is required but credentials are missing. ` +
-          `Set MYSQL_PROXY_KEY_ID and MYSQL_PROXY_SECRET (fallbacks: APP_NAME and APP_KEY). ` +
-          `Resolved state: keyId=${config.signing.keyId || '<empty>'}, hasSecret=${String(signingHasSecret)}, ` +
-          `cwd=${typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : '<unknown>'}`
-      );
-    }
-
-    // Debug: surface resolved config so we can compare watch vs non-watch runs
-    try {
-      Deps.Logger.info(
-        `MySQL 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)} requireSigning=${String(config.signing.require)} keyId=${config.signing.keyId} hasSecret=${String(config.signing.secret.trim() !== '')} signingWindowMs=${String(config.signing.windowMs)}`
-      );
-    } catch {
-      // noop - logging must not block startup
-    }
-
-    const pool = createPool(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, 'MySQLProxyServer');
-        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(`MySQL proxy listening on http://${config.host}:${config.port}`);
-  },
-});
-
-export default MySqlProxyServer;

package/src/proxy/mysql/register.ts

@@ -1,6 +0,0 @@
-import { ProxyRegistry } from '@proxy/ProxyRegistry';
-
-ProxyRegistry.register({
-  name: 'mysql',
-  description: 'MySQL HTTP proxy server',
-});