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

Fraud Protection - Node.js SDK

import { __awaiter } from "tslib";
import fetch from 'node-fetch';
import { Agent } from 'https';
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 = {
            agent: new Agent({ 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));
    }
    sendRequest(_a) {
        return __awaiter(this, arguments, void 0, function* ({ 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 = Object.assign(Object.assign({}, this.requestOptions), { body: JSON.stringify(payload), signal: args === null || args === void 0 ? void 0 : args.controller.signal });
            return fetch(url.toString(), requestConfig);
        });
    }
    validate(request, event, requestMetadata) {
        return __awaiter(this, void 0, void 0, function* () {
            const controller = new AbortController();
            const timeoutId = setTimeout(() => controller.abort('DataDome Fraud API timeout'), this.timeout);
            try {
                const response = yield this.sendRequest({
                    operation: Operation.VALIDATE,
                    request,
                    requestMetadata,
                    event,
                    args: {
                        controller,
                    },
                });
                const result = yield (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) {
                if ((error === null || error === void 0 ? void 0 : error.name) === 'AbortError' && controller.signal.aborted) {
                    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);
            }
        });
    }
    collect(request, event, requestMetadata) {
        return __awaiter(this, void 0, void 0, function* () {
            const response = yield this.sendRequest({
                operation: Operation.COLLECT,
                request,
                requestMetadata,
                event,
            });
            if (response.ok) {
                return { status: ResponseStatus.OK };
            }
            else {
                const json = yield response.json();
                return Object.assign({ status: ResponseStatus.FAILURE }, json);
            }
        });
    }
}
//# sourceMappingURL=datadome.js.map