@zintrust/redis-rpc 2.4.3 → 2.4.4

package/dist/server.js

@@ -18,33 +18,169 @@ const json = (response, status, payload) => {
     });
     response.end(JSON.stringify(payload));
 };
+const getHeaderSecret = (request) => {
+    const raw = request.headers['x-redis-rpc-secret'];
+    if (Array.isArray(raw)) {
+        return raw[0] ?? '';
+    }
+    return typeof raw === 'string' ? raw : '';
+};
+const previewSecret = (value) => value.slice(0, 5);
+const logStep = (step, details) => {
+    Logger.debug(`[redis-rpc][server] ${step}`, details);
+};
+const getRequestContext = (request, settings) => {
+    const method = request.method ?? '';
+    const url = new URL(request.url || '/', `http://${request.headers.host || 'localhost'}`);
+    const headerSecret = getHeaderSecret(request);
+    const settingsSecret = settings.secret || '';
+    return {
+        method,
+        url,
+        headerSecret,
+        settingsSecret,
+    };
+};
+const logRequestReceived = (context) => {
+    logStep('request.received', {
+        method: context.method,
+        path: context.url.pathname,
+        host: context.url.host,
+        headerSecretPreview: previewSecret(context.headerSecret),
+        settingsSecretPreview: previewSecret(context.settingsSecret),
+    });
+};
+const isHealthRoute = (context) => context.method === 'GET' && context.url.pathname === '/health';
+const isRpcRoute = (context) => context.method === 'POST' && context.url.pathname === '/rpc';
+const logHealthRoute = (prefix, path) => {
+    logStep('route.health', {
+        path,
+        prefix,
+    });
+};
+const logRouteCheck = (context) => {
+    logStep('route.check', {
+        method: context.method,
+        path: context.url.pathname,
+        isRpcRoute: isRpcRoute(context),
+    });
+};
+const logRouteNotFound = (context) => {
+    logStep('route.notFound', {
+        method: context.method,
+        path: context.url.pathname,
+    });
+};
+const validateRequestSecret = (context) => {
+    logStep('secret.validate.start', {
+        headerSecretPreview: previewSecret(context.headerSecret),
+        settingsSecretPreview: previewSecret(context.settingsSecret),
+    });
+    const secretMatches = context.settingsSecret !== '' && context.headerSecret === context.settingsSecret;
+    logStep('secret.validate.result', {
+        headerSecretPreview: previewSecret(context.headerSecret),
+        settingsSecretPreview: previewSecret(context.settingsSecret),
+        secretMatches,
+    });
+    return secretMatches;
+};
+const logSecretValidationFailure = (context) => {
+    logStep('secret.validate.failed', {
+        headerSecretPreview: previewSecret(context.headerSecret),
+        settingsSecretPreview: previewSecret(context.settingsSecret),
+    });
+};
+const readRpcBody = async (request) => {
+    logStep('body.read.start', {});
+    const bodyText = await readBody(request);
+    logStep('body.read.complete', {
+        length: bodyText.length,
+        isEmpty: bodyText.trim().length === 0,
+    });
+    try {
+        const body = (bodyText.trim().length === 0 ? {} : JSON.parse(bodyText));
+        logStep('body.parse.complete', {
+            requestId: body.requestId ?? null,
+            service: String(body.service || ''),
+            method: String(body.method || ''),
+            hasPayload: body.payload !== undefined,
+        });
+        return body;
+    }
+    catch (error) {
+        logStep('body.parse.failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+};
+const dispatchRpcRequest = async (backend, body) => {
+    logStep('dispatch.start', {
+        requestId: body.requestId ?? null,
+        service: String(body.service || ''),
+        method: String(body.method || ''),
+    });
+    const result = await backend.dispatch(String(body.service || ''), String(body.method || ''), body.payload ?? {});
+    logStep('dispatch.complete', {
+        requestId: body.requestId ?? null,
+        service: String(body.service || ''),
+        method: String(body.method || ''),
+    });
+    return result;
+};
+const sendRpcSuccess = (response, requestId, result) => {
+    json(response, 200, { ok: true, requestId, result, error: null });
+    logStep('response.sent', {
+        status: 200,
+        requestId,
+    });
+};
+const handleRequestError = (response, error) => {
+    const payload = toErrorPayload(error);
+    logStep('request.error', {
+        status: payload.status,
+        message: payload.body && typeof payload.body === 'object' && 'message' in payload.body
+            ? String(payload.body.message ?? '')
+            : '',
+    });
+    json(response, payload.status, payload.body);
+};
+const handleRpcRequest = async (request, response, context, backend) => {
+    logRouteCheck(context);
+    if (!isRpcRoute(context)) {
+        logRouteNotFound(context);
+        throw createRpcNotFoundError('Unknown Redis RPC route');
+    }
+    if (!validateRequestSecret(context)) {
+        logSecretValidationFailure(context);
+        throw createRpcUnauthorizedError('Invalid Redis RPC secret');
+    }
+    const body = await readRpcBody(request);
+    const result = await dispatchRpcRequest(backend, body);
+    sendRpcSuccess(response, body.requestId ?? null, result);
+};
+const handleHealthRequest = (response, backend) => {
+    logHealthRoute(backend.prefix, '/health');
+    json(response, 200, { ok: true, service: 'redis-rpc', prefix: backend.prefix });
+};
+const handleIncomingRequest = async (request, response, settings, backend) => {
+    const context = getRequestContext(request, settings);
+    logRequestReceived(context);
+    if (isHealthRoute(context)) {
+        handleHealthRequest(response, backend);
+        return;
+    }
+    await handleRpcRequest(request, response, context, backend);
+};
 export const createRedisRpcServer = (options = {}) => {
     const settings = { ...rpcServerOptions(), ...options };
     const backend = isObject(options.backend)
         ? options.backend
         : createRedisRpcBackend(settings);
-    const server = http.createServer(async (request, response) => {
-        try {
-            const url = new URL(request.url || '/', `http://${request.headers.host || 'localhost'}`);
-            if (request.method === 'GET' && url.pathname === '/health') {
-                json(response, 200, { ok: true, service: 'redis-rpc', prefix: backend.prefix });
-                return;
-            }
-            if (request.method !== 'POST' || url.pathname !== '/rpc') {
-                throw createRpcNotFoundError('Unknown Redis RPC route');
-            }
-            if (!settings.secret || request.headers['x-redis-rpc-secret'] !== settings.secret) {
-                throw createRpcUnauthorizedError('Invalid Redis RPC secret');
-            }
-            const bodyText = await readBody(request);
-            const body = (bodyText.trim().length === 0 ? {} : JSON.parse(bodyText));
-            const result = await backend.dispatch(String(body.service || ''), String(body.method || ''), body.payload ?? {});
-            json(response, 200, { ok: true, requestId: body.requestId ?? null, result, error: null });
-        }
-        catch (error) {
-            const payload = toErrorPayload(error);
-            json(response, payload.status, payload.body);
-        }
+    const server = http.createServer((request, response) => {
+        void handleIncomingRequest(request, response, settings, backend).catch((error) => {
+            handleRequestError(response, error);
+        });
     });
     return { server, backend, settings };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/redis-rpc",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "description": "Redis RPC backend for BullMQ queue operations in ZinTrust.",
   "private": false,
   "type": "module",