all files / src/ utils.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
 
1×
1×
1×
1×
1×
 
1×
 
 
8×
 
 
 
7×
7×
 
 
 
 
 
 
 
 
 
 
14×
14×
7×
7×
7×
6×
 
1×
 
 
7×
7×
7×
 
 
 
12×
 
 
 
 
 
16×
 
 
 
 
 
 
3×
 
 
 
 
 
15×
156×
 
 
 
156×
4×
4×
 
152×
 
 
 
 
 
 
 
 
 
 
 
 
"use strict";
 
let R = require("ramda");
let hl = require("highland");
let restify = require("restify");
let request = require("superagent");
let requestCB = require("./request");
 
module.exports = {
 
    "setCacheEndpoint": endpoint => {
        return R.test(/dev/, endpoint) ? endpoint : endpoint.replace("org-", "");
    },
 
    "addMeta": list => {
        const time = Date.now();
        return {
            "data": {
                "type": "articles",
                "attributes": {
                    "timestamp": time - (time % 60000)
                }
            },
            "included": list
        };
    },
 
    "sendResponse": (logger, res, next) => (err, result) => {
        if (err) {
            logger.error("Sections Request Error", err);
            logger.timeEnd('Finished Sections Request');
            if (R.has("status", err) && R.has("message", err) && R.has(err.status, restify)) {
                next(new restify[err.status](err.message));
            } else {
                next(new restify.InternalServerError(err.stack));
            }
        } else {
            logger.timeEnd('Finished Sections Request');
            res.charSet('utf-8');
            res.send(result);
        }
    },
 
    "notFound": message => hl(push => push({
        "message": message,
        "status": "NotFoundError"
    })),
 
    "getArticlesInParallel": (logger, getArticle, notFound, stream) => {
        return stream
            .map(R.compose(parseInt, R.last, R.split(".")))
            .uniq()
            .map(getArticle)
            .parallel(40)
            .compact()
            .errors(err => {
                logger.error("Sections Request. Error retrieving article", err);
            })
            .otherwise(notFound)
            .collect();
    },
 
    "makeArticleRequest": (logger, articleEndpoint, source, publicationId) => hl.wrapCallback((id, cb) => {
        request
            .get(`${articleEndpoint}/${source}/${publicationId}/articles/${id}`)
            .timeout(3000)
            .end((err, res) => {
                if (err || res.error) {
                    logger.error('error requesting article', {article_id: id, err_msg: err.message});
                    cb(res ? res.body : err);
                } else {
                    cb(null, res.body);
                }
            });
    }),
 
    "makeArticleRequestCB": R.curry((config, logger, articleEndpoint, source, publicationId, id) => {
        return hl(requestCB(config).execute(`${articleEndpoint}/${source}/${publicationId}/articles/${id}`).then(R.prop('body')))
            .errors(err => {
                logger.error('error requesting article', {article_id: id, err_msg: err.message, err_stack: err.stack});
            });
    })
};