@autofleet/sheilta 1.2.5-beta → 1.2.6

package/lib/formatter/index.js

@@ -24,17 +24,19 @@ const formatOrder = ({ order = [], associationModels = [], }) => (order.length =
 const formatPage = page => page || utils_1.PAGE_DEFAULT;
 const formatPerPage = perPage => perPage || utils_1.PER_PAGE_DEFAULT;
 const formatInclude = (include, associationsMap = {}) => {
-    let formattedInclude = include.map(i => (Object.assign(Object.assign(Object.assign({}, i), { association: associationsMap[i.association || i.model], required: i.required !== 'false' }), (include.order && { order: formatOrder(include.order) }))));
+    let formattedInclude = include.map(i => (Object.assign(Object.assign({}, i), { association: associationsMap[i.association || i.model], required: i.required !== 'false' })));
     formattedInclude = formattedInclude.map(i => lodash_1.default.omit(i, ['model']));
     return formattedInclude;
 };
 const formatQuery = (query, associationModels) => Object.keys(query).reduce((acc, queryItemKey) => (Object.assign(Object.assign({}, acc), { [utils_1.isAttributeByAssociation(queryItemKey, associationModels)
         ? utils_1.wrapAttributeWithOperator(queryItemKey) : queryItemKey]: query[queryItemKey] })), {});
 const formatSearchTerm = (searchTerm, attributesToSend, rawAttributes) => ({
-    $or: attributesToSend.filter(attrKey => rawAttributes[attrKey].type.key === 'STRING').map(attr => ({
-        [attr]: {
-            $iLike: `%${searchTerm}%`,
-        },
+    $and: searchTerm.split(' ').map(term => ({
+        $or: attributesToSend.filter(attrKey => rawAttributes[attrKey].type.key === 'STRING').map(attr => ({
+            [attr]: {
+                $iLike: `%${term}%`,
+            },
+        })),
     })),
 });
 const formatPayload = ({ order, page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, include = [], query = {}, attributes = null, searchTerm = null, }, model) => {

package/lib/formatter/index.test.js

@@ -65,13 +65,67 @@ describe('formatting test', () => {
             });
             expect(JSON.stringify(query)).toBe(JSON.stringify({
                 $and: [{ 'json.field': { $gt: 4 } }, {
-                        $or: [
-                            {
-                                startTime: {
-                                    $iLike: `%${searchTerm}%`,
-                                },
+                        $and: [{
+                                $or: [
+                                    {
+                                        startTime: {
+                                            $iLike: `%${searchTerm}%`,
+                                        },
+                                    },
+                                ],
+                            }],
+                    }],
+            }));
+        });
+        it('query with searchTerm with spaces', () => {
+            const searchTerm = 'aviv good guy';
+            const splitSearch = searchTerm.split(' ');
+            const { query } = _1.default({
+                order: [],
+                query: {
+                    'json.field': {
+                        $gt: 4,
+                    },
+                },
+                searchTerm,
+            }, {
+                rawAttributes: {
+                    startTime: {
+                        type: {
+                            key: 'STRING',
+                        },
+                    },
+                    endTime: {
+                        type: {
+                            key: 'NUMBER',
+                        },
+                    },
+                },
+            });
+            expect(JSON.stringify(query)).toBe(JSON.stringify({
+                $and: [{ 'json.field': { $gt: 4 } }, {
+                        $and: [{
+                                $or: [
+                                    {
+                                        startTime: {
+                                            $iLike: `%${splitSearch[0]}%`,
+                                        },
+                                    }
+                                ],
+                            }, {
+                                $or: [{
+                                        startTime: {
+                                            $iLike: `%${splitSearch[1]}%`,
+                                        },
+                                    }],
                             },
-                        ],
+                            {
+                                $or: [{
+                                        startTime: {
+                                            $iLike: `%${splitSearch[2]}%`,
+                                        },
+                                    }],
+                            }],
                     }],
             }));
         });

package/lib/middleware/index.js

@@ -14,11 +14,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryFormatMiddleware = exports.queryValidationMiddleware = exports.newQueryFormatMiddleware = exports.newQueryValidationMiddleware = void 0;
 const errors_1 = require("@autofleet/errors");
+const joi_1 = require("joi");
 const formatter_1 = __importDefault(require("../formatter"));
 const validations_1 = require("../validations");
+const querySchema = joi_1.object({
+    query: joi_1.object(),
+    attributes: joi_1.array().items(joi_1.string()),
+    order: joi_1.array().items(joi_1.string()),
+    page: joi_1.number(),
+    perPage: joi_1.number(),
+    include: joi_1.array().items(joi_1.any()),
+});
 exports.newQueryValidationMiddleware = (inner = 'body') => model => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     const { query, attributes, order, page, perPage, include, } = req[inner];
     try {
+        const result = querySchema.validate(req[inner]);
+        if (result.error) {
+            throw new errors_1.BadRequest([result.error], null);
+        }
         validations_1.validatePayload({
             query,
             attributes,

package/lib/validations/index.js

@@ -69,18 +69,24 @@ const validatePagination = ({ page, perPage, }) => {
 const validateIncludePayload = (include, associations) => {
     const associationsKeys = Object.keys(associations);
     include.forEach((i) => {
+        var _a;
         validateQueryAttribute(i.model, associationsKeys);
-        const { rawAttributes } = associations[i.model].target;
-        if (include.where) {
-            validateQueryPayload(i.where, rawAttributes);
+        const target = (_a = associations[i.model]) === null || _a === void 0 ? void 0 : _a.target;
+        if (!target) {
+            utils_1.throwBadRequestError('model not found in associations');
         }
-        if (include.order) {
-            validateOrderAttributes(i.order, rawAttributes);
+        const { rawAttributes } = target;
+        const attributeKeys = Object.keys(rawAttributes);
+        if (i.where) {
+            validateQueryPayload(i.where, attributeKeys);
         }
-        if (include.attributes) {
-            validateAttributes(i.attributes, rawAttributes);
+        if (i.order) {
+            validateOrderAttributes(i.order, attributeKeys);
         }
-        if (!lodash_1.default.isNil(include.required) && !lodash_1.default.isBoolean(include.required)) {
+        if (i.attributes) {
+            validateAttributes(i.attributes, attributeKeys);
+        }
+        if (!lodash_1.default.isNil(i.required) && !lodash_1.default.isBoolean(i.required)) {
             utils_1.throwBadRequestError('include.required must be a boolean');
         }
     });
@@ -97,9 +103,12 @@ exports.validatePayload = ({ query = {}, order = [], attributes = [], include =
     }
     validateOrderAttributes(order, rawAttributes, associationModels);
     validateQueryPayload(query, rawAttributes, associationModels);
-    if (include.length) {
+    if (include.length && typeof include === 'object') {
         validateIncludePayload(include, model === null || model === void 0 ? void 0 : model.associations);
     }
+    else if (include && typeof include !== 'object') {
+        utils_1.throwBadRequestError('include must be an array');
+    }
     validatePagination({
         page,
         perPage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sheilta",
-  "version": "1.2.5-beta",
+  "version": "1.2.6",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -29,21 +29,22 @@
   "dependencies": {
     "@autofleet/errors": "^1.0.10",
     "@types/node": "^14.14.20",
+    "joi": "^17.9.2",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "typescript": "^3.9.5",
+    "@types/jest": "^24.9.0",
+    "@typescript-eslint/eslint-plugin": "^2.34.0",
+    "@typescript-eslint/parser": "^2.23.0",
     "eslint": "^6.8.0",
     "eslint-config-airbnb": "^16.1.0",
     "eslint-plugin-import": "^2.20.1",
-    "@typescript-eslint/eslint-plugin": "^2.34.0",
-    "@typescript-eslint/parser": "^2.23.0",
-    "typescript-eslint": "0.0.1-alpha.0",
-    "ts-jest": "^25.0.0",
     "jest": "^25.1.0",
-    "@types/jest": "^24.9.0"
+    "ts-jest": "^25.0.0",
+    "typescript": "^3.9.5",
+    "typescript-eslint": "0.0.1-alpha.0"
   },
   "files": [
     "lib/**/*"
   ]
-}
+}