machinomy/lib/transport.js

Micropayments powered by Ethereum

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const logger_1 = require("@machinomy/logger");
const accept_payment_request_1 = require("./accept_payment_request");
const accept_payment_response_1 = require("./accept_payment_response");
const accept_token_request_1 = require("./accept_token_request");
const accept_token_response_1 = require("./accept_token_response");
const PaymentRequiredRequest_1 = require("./PaymentRequiredRequest");
const PaymentRequiredResponse_1 = require("./PaymentRequiredResponse");
const Exceptions_1 = require("./Exceptions");
let req = require('request');
const request = (opts) => {
    return new Promise((resolve, reject) => {
        req(opts, (err, res) => {
            if (err) {
                reject(err);
            }
            resolve(res);
        });
    });
};
const LOG = new logger_1.default('transport');
// noinspection MagicNumberJS
exports.STATUS_CODES = {
    PAYMENT_REQUIRED: 402,
    OK: 200
};
/**
 * Parse response headers and return the token.
 *
 * @param {object} response
 * @return {string}
 */
const extractPaywallToken = (response) => {
    let token = response.headers['paywall-token'];
    if (token) {
        LOG.info('Got token from the server');
        return token;
    }
    else {
        throw new Error('Can not find a token in the response');
    }
};
class Transport {
    /**
     * Request URI sending a paywall token.
     * @return {Promise<object>}
     */
    getWithToken(uri, token, opts = {}) {
        let headers = {
            'authorization': 'Paywall ' + token
        };
        LOG.info(`Getting ${uri} using access token ${token}`);
        if (opts.onWillLoad) {
            opts.onWillLoad();
        }
        return this.get(uri, headers).then(result => {
            if (opts.onDidLoad) {
                opts.onDidLoad();
            }
            return result;
        });
    }
    get(uri, headers) {
        let options = {
            method: 'GET',
            uri: uri,
            headers: headers
        };
        LOG.info(`Getting ${uri} using headers and options`, headers, options);
        return request(options);
    }
    /**
     * Request token from the server's gateway
     * @param {string} uri - Full url to the gateway.
     * @param {Payment} payment
     * @param {{uri: string, headers: object, onWillPreflight: function, onDidPreflight: function, onWillOpenChannel: function, onDidOpenChannel: function, onWillSendPayment: function, onDidSendPayment: function, onWillLoad: function, onDidLoad: function}} opts
     * @return {Promise<string>}
     */
    requestToken(uri, payment, opts = {}) {
        if (!payment.tokenContract) {
            delete payment.tokenContract;
        }
        let options = {
            method: 'POST',
            uri: uri,
            json: true,
            body: payment
        };
        LOG.info('Getting request token in exchange for payment', payment);
        if (opts.onWillSendPayment) {
            opts.onWillSendPayment();
        }
        return request(options).then(extractPaywallToken).then(result => {
            if (opts.onDidSendPayment) {
                opts.onDidSendPayment();
            }
            return result;
        });
    }
    async doPayment(paymentRequest, gateway) {
        const options = {
            method: 'POST',
            uri: gateway,
            json: true,
            headers: {
                'Content-Type': 'application/json'
            },
            credentials: 'include',
            body: accept_payment_request_1.AcceptPaymentRequestSerde.instance.serialize(paymentRequest)
        };
        const res = await request(options);
        return accept_payment_response_1.AcceptPaymentResponseSerde.instance.deserialize(res.body);
    }
    async doVerify(tokenRequest, gateway) {
        const options = {
            method: 'POST',
            uri: gateway,
            json: true,
            headers: {
                'Content-Type': 'application/json'
            },
            credentials: 'include',
            body: accept_token_request_1.AcceptTokenRequestSerde.instance.serialize(tokenRequest)
        };
        const res = await request(options);
        return accept_token_response_1.AcceptTokenResponseSerde.instance.deserialize(res.body);
    }
    async paymentRequired(paymentRequiredRequest, gateway) {
        const options = {
            method: 'GET',
            uri: PaymentRequiredRequest_1.PaymentRequiredRequestSerializer.instance.serialize(paymentRequiredRequest, gateway),
            credentials: 'include'
        };
        const res = await request(options);
        switch (res.statusCode) {
            case exports.STATUS_CODES.PAYMENT_REQUIRED:
            case exports.STATUS_CODES.OK:
                return PaymentRequiredResponse_1.PaymentRequiredResponseSerializer.instance.deserialize(res.headers);
            default:
                throw new Exceptions_1.BadResponseError();
        }
    }
}
exports.Transport = Transport;
/**
 * Build Transport instance.
 */
exports.build = () => {
    return new Transport();
};
//# sourceMappingURL=transport.js.map