Typescript migration:

* utils/resources.js
* validation/constraints.js (only server side)

server/utils/resources.ts

@@ -0,0 +1,271 @@
+import _ from "lodash";
+
+import CONSTRAINTS from "../validation/constraints";
+import ErrorTypes from "../utils/errorTypes";
+import Logger from "../logger";
+import {Constraints, forConstraints, isConstraints} from "../validation/validator";
+import {Request, Response} from "express";
+
+export type Entity = {[key: string]: any};
+
+export type RestParams = {
+    q?: string;
+
+    _sortField?: string;
+    _sortDir?: string;
+
+    _page: number;
+    _perPage: number;
+
+    filters?: FilterClause;
+};
+
+export type OrderByClause = {query: string, params: any[]};
+export type LimitOffsetClause = {query: string, params: any[]};
+export type FilterClause = {query: string, params: any[]};
+
+function respond(res: Response, httpCode: number, data: any, type: string): void {
+    switch (type) {
+        case 'html':
+            res.writeHead(httpCode, {'Content-Type': 'text/html'});
+            res.end(data);
+        break;
+
+        default:
+            res.writeHead(httpCode, {'Content-Type': 'application/json'});
+            res.end(JSON.stringify(data));
+        break;
+    }
+}
+
+function orderByClause(
+    restParams: RestParams,
+    defaultSortField: string,
+    allowedSortFields: string[]
+): OrderByClause {
+    let sortField = _.includes(allowedSortFields, restParams._sortField) ? restParams._sortField : undefined;
+    if (!sortField) {
+        sortField = defaultSortField;
+    }
+
+    return {
+        query: 'ORDER BY ' + sortField + ' ' + (restParams._sortDir === 'ASC' ? 'ASC' : 'DESC'),
+        params: []
+    };
+}
+
+function limitOffsetClause(restParams: RestParams): LimitOffsetClause {
+    const page = restParams._page;
+    const perPage = restParams._perPage;
+
+    return {
+        query: 'LIMIT ? OFFSET ?',
+        params: [perPage, ((page - 1) * perPage)]
+    };
+}
+
+function escapeForLikePattern(str: string): string {
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/%/g, '\\%')
+        .replace(/_/g, '\\_');
+}
+
+function filterCondition(restParams: RestParams, filterFields: string[]): FilterClause {
+    if (_.isEmpty(filterFields)) {
+        return {
+            query: '1 = 1',
+            params: []
+        };
+    }
+
+    let query = _.join(
+        _.map(filterFields, function (field) {
+            return 'LOWER(' + field + ') LIKE ?';
+        }),
+        ' OR '
+    );
+
+    query += ' ESCAPE \'\\\'';
+
+    const search = '%' + (_.isString(restParams.q) ? escapeForLikePattern(_.toLower(restParams.q.trim())) : '') + '%';
+    const params = _.times(filterFields.length, _.constant(search));
+
+    return {
+        query: query,
+        params: params
+    };
+}
+
+function getConstrainedValues(data: {[key: string]: any}, constraints: Constraints): {[key: string]: any} {
+    const values: {[key: string]: any} = {};
+    _.each(_.keys(constraints), (key: string): void => {
+        const value = data[key];
+        values[key] =
+            _.isUndefined(value) && key in constraints && !_.isUndefined(constraints[key].default)
+                ? constraints[key].default
+                : value;
+    });
+    return values;
+}
+
+export function getData (req: Request): any {
+    return _.extend({}, req.body, req.params, req.query);
+}
+
+// TODO: Promisify.
+export function getValidRestParams(
+    type: string,
+    subtype: string,
+    req: Request,
+    callback: (err: {data: any, type: {code: number}} | null, restParams?: RestParams) => void
+) {
+    const restConstraints = CONSTRAINTS.rest as {[key: string]: any};
+    let constraints: Constraints;
+    if (!(type in restConstraints) || !isConstraints(restConstraints[type])) {
+        Logger.tag('validation', 'rest').error('Unknown REST resource type: {}', type);
+        return callback({data: 'Internal error.', type: ErrorTypes.internalError});
+    }
+    constraints = restConstraints[type];
+
+    let filterConstraints: Constraints = {};
+    if (subtype) {
+        const subtypeFilters = subtype + 'Filters';
+        const constraintsObj = CONSTRAINTS as {[key: string]: any};
+        if (!(subtypeFilters in constraintsObj) || !isConstraints(constraintsObj[subtypeFilters])) {
+            Logger.tag('validation', 'rest').error('Unknown REST resource subtype: {}', subtype);
+            return callback({data: 'Internal error.', type: ErrorTypes.internalError});
+        }
+        filterConstraints = constraintsObj[subtypeFilters];
+    }
+
+    const data = getData(req);
+
+    const restParams = getConstrainedValues(data, constraints);
+    const filterParams = getConstrainedValues(data, filterConstraints);
+
+    const areValidParams = forConstraints(constraints, false);
+    const areValidFilters = forConstraints(filterConstraints, false);
+    if (!areValidParams(restParams) || !areValidFilters(filterParams)) {
+        return callback({data: 'Invalid REST parameters.', type: ErrorTypes.badRequest});
+    }
+
+    restParams.filters = filterParams;
+
+    callback(null, restParams as RestParams);
+}
+
+export function filter (entities: {[key: string]: Entity}, allowedFilterFields: string[], restParams: RestParams) {
+    let query = restParams.q;
+    if (query) {
+        query = _.toLower(query.trim());
+    }
+
+    function queryMatches(entity: Entity): boolean {
+        if (!query) {
+            return true;
+        }
+        return _.some(allowedFilterFields, (field: string): boolean => {
+            if (!query) {
+                return true;
+            }
+            let value = entity[field];
+            if (_.isNumber(value)) {
+                value = value.toString();
+            }
+
+            if (!_.isString(value) || _.isEmpty(value)) {
+                return false;
+            }
+
+            value = _.toLower(value);
+            if (field === 'mac') {
+                return _.includes(value.replace(/:/g, ''), query.replace(/:/g, ''));
+            }
+
+            return _.includes(value, query);
+        });
+    }
+
+    const filters = restParams.filters;
+
+    function filtersMatch(entity: Entity): boolean {
+        if (_.isEmpty(filters)) {
+            return true;
+        }
+
+        return _.every(filters, (value: any, key: string): boolean => {
+            if (_.isUndefined(value)) {
+                return true;
+            }
+            if (_.startsWith(key, 'has')) {
+                const entityKey = key.substr(3, 1).toLowerCase() + key.substr(4);
+                return _.isEmpty(entity[entityKey]).toString() !== value;
+            }
+            return entity[key] === value;
+        });
+    }
+
+    return _.filter(entities, function (entity) {
+        return queryMatches(entity) && filtersMatch(entity);
+    });
+}
+
+export function sort<T>(entities: ArrayLike<T>, allowedSortFields: string[], restParams: RestParams): ArrayLike<T> {
+    const sortField = _.includes(allowedSortFields, restParams._sortField) ? restParams._sortField : undefined;
+    if (!sortField) {
+        return entities;
+    }
+
+    const sorted: T[] = _.sortBy(entities, [sortField]);
+    if (restParams._sortDir === 'ASC') {
+        return sorted;
+    } else {
+        return _.reverse(sorted);
+    }
+}
+
+export function getPageEntities (entities: Entity[], restParams: RestParams) {
+    const page = restParams._page;
+    const perPage = restParams._perPage;
+
+    return entities.slice((page - 1) * perPage, page * perPage);
+}
+
+export {filterCondition as whereCondition};
+
+export function filterClause (
+    restParams: RestParams,
+    defaultSortField: string,
+    allowedSortFields: string[],
+    filterFields: string[],
+): FilterClause {
+    const orderBy = orderByClause(
+        restParams,
+        defaultSortField,
+        allowedSortFields
+    );
+    const limitOffset = limitOffsetClause(restParams);
+
+    const filter = filterCondition(
+        restParams,
+        filterFields
+    );
+
+    return {
+        query: filter.query + ' ' + orderBy.query + ' ' + limitOffset.query,
+        params: _.concat(filter.params, orderBy.params, limitOffset.params)
+    };
+}
+
+export function success (res: Response, data: any) {
+    respond(res, 200, data, 'json');
+}
+
+export function successHtml (res: Response, html: string) {
+    respond(res, 200, html, 'html');
+}
+
+export function error (res: Response, err: {data: any, type: {code: number}}) {
+    respond(res, err.type.code, err.data, 'json');
+}