@energica-city/shared-amplify-utils/dist/middleware/graphql/GraphQLRequestLogger.js

Shared utilities for AWS Amplify projects

import { logger } from '../../log';
import { sanitizeObject } from '../utils/sanitization';
import { extractEventInfo, setupStructuredLogging } from './utils';
function summarizeResponse(response, config) {
    const { excludeResponseFields = [], maxDepth = 5 } = config;
    if (response === null)
        return { responseType: 'null', isNull: true };
    if (response === undefined)
        return { responseType: 'undefined', isUndefined: true };
    if (Array.isArray(response)) {
        return {
            responseType: 'array',
            isArray: true,
            length: response.length,
            sample: response.length > 0
                ? sanitizeObject(response[0], {
                    excludeFields: excludeResponseFields,
                    maxDepth,
                })
                : undefined,
        };
    }
    if (typeof response === 'object') {
        return {
            responseType: 'object',
            isObject: true,
            response: sanitizeObject(response, {
                excludeFields: excludeResponseFields,
                maxDepth,
            }),
        };
    }
    return { responseType: typeof response, response };
}
function summarizeEvent(event, config) {
    const { excludeEventFields = [], maxDepth = 5, logArguments = true, logIdentity = true, } = config;
    const base = extractEventInfo(event);
    const out = { ...base };
    if (logArguments && event?.arguments) {
        out.arguments = sanitizeObject(event.arguments, {
            excludeFields: excludeEventFields,
            maxDepth,
        });
    }
    if (logIdentity && event?.identity) {
        out.identity = sanitizeObject(event.identity, {
            excludeFields: excludeEventFields,
            maxDepth,
        });
    }
    return out;
}
export function createGraphQLRequestLogger(config = {}) {
    const { defaultContext = {} } = config;
    return async (input, next) => {
        const start = Date.now();
        try {
            setupStructuredLogging(input, true, {
                ...defaultContext,
                middleware: 'GraphQLRequestLogger',
            });
            const eventInfo = summarizeEvent(input.event, config);
            logger.info('GraphQL request started', {
                event: eventInfo,
                timestamp: new Date().toISOString(),
            });
            const result = await next();
            const duration = Date.now() - start;
            const responseInfo = summarizeResponse(result, config);
            logger.info('GraphQL request completed', {
                response: responseInfo,
                duration,
                success: true,
            });
            return result;
        }
        catch (error) {
            const duration = Date.now() - start;
            logger.error('GraphQL request failed', {
                error: error instanceof Error ? error.message : String(error),
                stack: error instanceof Error ? error.stack : undefined,
                duration,
                success: false,
                middleware: 'GraphQLRequestLogger',
            });
            throw error;
        }
    };
}
//# sourceMappingURL=GraphQLRequestLogger.js.map