@datadome/fraud-sdk-node/dist-es/datadome.js

Fraud Protection - Node.js SDK

import { URL } from 'url';
import { DataDomeRequest, ResponseAction, ResponseStatus, } from './model';
import { DATADOME_ENDPOINT, DATADOME_TIMEOUT } from './constants';
function getDefaultOptions() {
    return {
        logger: console,
        timeout: DATADOME_TIMEOUT,
        endpoint: DATADOME_ENDPOINT,
    };
}
export var Operation;
(function (Operation) {
    Operation["VALIDATE"] = "validate";
    Operation["COLLECT"] = "collect";
})(Operation || (Operation = {}));
export class DataDome {
    constructor(key, options = {}) {
        const defaultOptions = getDefaultOptions();
        const finalParameters = Object.assign({}, defaultOptions, options);
        const { endpoint, logger, timeout } = finalParameters;
        this.endpoint = endpoint;
        this.timeout = timeout;
        this.logger = logger;
        this.requestOptions = {
            keepalive: true,
            headers: {
                Accept: 'application/json',
                Connection: 'keep-alive',
                'Content-Type': 'application/json',
                'x-api-key': key,
            },
            method: 'POST',
        };
        if (!this.endpoint.toLowerCase().startsWith('https://') &&
            !this.endpoint.toLowerCase().startsWith('http://')) {
            this.logger.warn(`Endpoint ${this.endpoint} is not a valid URL. Defaulting to ${defaultOptions.endpoint}`);
            this.endpoint = defaultOptions.endpoint;
        }
    }
    buildPayload(request, event, requestMetadata) {
        return event.mergeWith(new DataDomeRequest(request, requestMetadata));
    }
    async sendRequest({ operation, request, requestMetadata, event, args, }) {
        const endpoint = this.endpoint.endsWith('/') ? this.endpoint.slice(0, -1) : this.endpoint;
        const url = new URL(endpoint + '/v1/' + operation + '/' + event.action);
        const payload = this.buildPayload(request, event, requestMetadata);
        this.logger.debug(`url: ${url}`);
        this.logger.debug(`body: ${JSON.stringify(payload)}`);
        const requestConfig = {
            ...this.requestOptions,
            body: JSON.stringify(payload),
            signal: args === null || args === void 0 ? void 0 : args.controller.signal,
        };
        return fetch(url.toString(), requestConfig);
    }
    async validate(request, event, requestMetadata) {
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort('DataDome Fraud API timeout'), this.timeout);
        try {
            const response = await this.sendRequest({
                operation: Operation.VALIDATE,
                request,
                requestMetadata,
                event,
                args: {
                    controller,
                },
            });
            const result = await (response === null || response === void 0 ? void 0 : response.json());
            if (response === null || response === void 0 ? void 0 : response.ok) {
                result.status = ResponseStatus.OK;
            }
            else {
                result.status = ResponseStatus.FAILURE;
                result.action = ResponseAction.ALLOW;
                this.logger.error(`Error on API response: ${JSON.stringify(result)}`);
            }
            return result;
        }
        catch (error) {
            const isAbortError = (error === null || error === void 0 ? void 0 : error.name) === 'AbortError' ||
                (error === null || error === void 0 ? void 0 : error.name) === 'TimeoutError' ||
                controller.signal.aborted;
            if (isAbortError) {
                return {
                    action: ResponseAction.ALLOW,
                    status: ResponseStatus.TIMEOUT,
                    message: `Request timed out after ${this.timeout} milliseconds`,
                };
            }
            else {
                return {
                    action: ResponseAction.ALLOW,
                    status: ResponseStatus.FAILURE,
                    message: `Request failed :${error}`,
                };
            }
        }
        finally {
            clearTimeout(timeoutId);
        }
    }
    async collect(request, event, requestMetadata) {
        const response = await this.sendRequest({
            operation: Operation.COLLECT,
            request,
            requestMetadata,
            event,
        });
        if (response.ok) {
            return { status: ResponseStatus.OK };
        }
        else {
            const json = await response.json();
            return { status: ResponseStatus.FAILURE, ...json };
        }
    }
}
//# sourceMappingURL=datadome.js.map