blow-collection/lib/helpers.js

Simple in memory collection with Rx / Observable interface.

'use strict';
const rxjs_1 = require('rxjs');
const blow_query_1 = require('blow-query');
const blow_filters_1 = require('blow-filters');
const util_1 = require('util');
function get(obj, key, defaultValue) {
    return obj[key] || defaultValue;
}
exports.get = get;
function set(obj, key, value) {
    obj[key] = value;
    return obj;
}
exports.set = set;
function has(obj, key) {
    return !util_1.isUndefined(get(obj, key));
}
exports.has = has;
function dropReference(obj) {
    return Object.assign({}, obj);
}
exports.dropReference = dropReference;
function limit(data$, limit) {
    if (util_1.isNumber(limit) && limit > 0) {
        return data$.take(limit);
    }
    else {
        return data$;
    }
}
exports.limit = limit;
function skip(data$, skip) {
    if (util_1.isNumber(skip)) {
        return data$.skip(skip);
    }
    else {
        return data$;
    }
}
exports.skip = skip;
function sort(data$, sort) {
    if (Object.keys(sort).length) {
        return data$.toArray().mergeMap(rows => {
            const fields = Object.keys(sort);
            rows = rows.sort((rowA, rowB) => {
                for (const field of fields) {
                    if (rowA[field] > rowB[field]) {
                        return 1 * sort[field];
                    }
                    else if (rowA[field] < rowB[field]) {
                        return -1 * sort[field];
                    }
                }
                return 0;
            });
            return rxjs_1.Observable.from(rows);
        });
    }
    else {
        return data$;
    }
}
exports.sort = sort;
function prepareQuery(query) {
    if (util_1.isUndefined(query)) {
        query = {};
    }
    if (query instanceof blow_query_1.Query) {
        query = query.toJSON();
    }
    return query;
}
exports.prepareQuery = prepareQuery;
function where(data$, where, invert) {
    invert = invert || false;
    if (!Object.keys(where).length) {
        return data$;
    }
    let filter;
    if (invert) {
        filter = row => !blow_filters_1.filter(where)(row);
    }
    else {
        filter = blow_filters_1.filter(where);
    }
    return data$.filter(filter);
}
exports.where = where;
function filter(data$, query) {
    const defaultQuery = { where: {}, sort: {}, limit: -1, skip: 0 };
    query = prepareQuery(query);
    const q = Object.assign({}, defaultQuery, query);
    data$ = where(data$, q.where);
    data$ = sort(data$, q.sort);
    data$ = skip(data$, q.skip);
    data$ = limit(data$, q.limit);
    return data$;
}
exports.filter = filter;