@strapi/database 4.3.4 → 4.3.7

package/lib/query/helpers/join.js

@@ -32,7 +32,7 @@ const createJoin = (ctx, { alias, attributeName, attribute }) => {
 
   const tragetMeta = db.metadata.get(attribute.target);
 
-  const joinColumn = attribute.joinColumn;
+  const { joinColumn } = attribute;
 
   if (joinColumn) {
     const subAlias = qb.getAlias();
@@ -46,7 +46,7 @@ const createJoin = (ctx, { alias, attributeName, attribute }) => {
     return subAlias;
   }
 
-  const joinTable = attribute.joinTable;
+  const { joinTable } = attribute;
   if (joinTable) {
     return createPivotJoin(qb, joinTable, alias, tragetMeta);
   }
@@ -67,7 +67,7 @@ const applyJoin = (qb, join) => {
     orderBy,
   } = join;
 
-  qb[method](`${referencedTable} as ${alias}`, inner => {
+  qb[method](`${referencedTable} as ${alias}`, (inner) => {
     inner.on(`${rootTable}.${rootColumn}`, `${alias}.${referencedColumn}`);
 
     if (on) {
@@ -78,14 +78,14 @@ const applyJoin = (qb, join) => {
   });
 
   if (orderBy) {
-    Object.keys(orderBy).forEach(column => {
+    Object.keys(orderBy).forEach((column) => {
       const direction = orderBy[column];
       qb.orderBy(`${alias}.${column}`, direction);
     });
   }
 };
 
-const applyJoins = (qb, joins) => joins.forEach(join => applyJoin(qb, join));
+const applyJoins = (qb, joins) => joins.forEach((join) => applyJoin(qb, join));
 
 module.exports = {
   createJoin,

package/lib/query/helpers/order-by.js

@@ -24,7 +24,7 @@ const processOrderBy = (orderBy, ctx) => {
   }
 
   if (Array.isArray(orderBy)) {
-    return orderBy.flatMap(value => processOrderBy(value, ctx));
+    return orderBy.flatMap((value) => processOrderBy(value, ctx));
   }
 
   if (_.isPlainObject(orderBy)) {

package/lib/query/helpers/populate.js

@@ -5,7 +5,7 @@ const _ = require('lodash/fp');
 const types = require('../../types');
 const { fromRow } = require('./transform');
 
-const getRootLevelPopulate = meta => {
+const getRootLevelPopulate = (meta) => {
   const populate = {};
 
   for (const attributeName in meta.attributes) {
@@ -80,7 +80,7 @@ const processPopulate = (populate, ctx) => {
     }
 
     if (!types.isRelation(attribute.type)) {
-      throw new Error(`Invalid populate field. Expected a relation, got ${attribute.type}`);
+      continue;
     }
 
     // make sure id is present for future populate queries
@@ -130,21 +130,19 @@ const applyPopulate = async (results, populate, ctx) => {
 
     const isCount = populateValue.count === true;
 
-    const fromTargetRow = rowOrRows => fromRow(targetMeta, rowOrRows);
+    const fromTargetRow = (rowOrRows) => fromRow(targetMeta, rowOrRows);
 
     if (attribute.relation === 'oneToOne' || attribute.relation === 'manyToOne') {
       if (attribute.joinColumn) {
-        const {
-          name: joinColumnName,
-          referencedColumn: referencedColumnName,
-        } = attribute.joinColumn;
+        const { name: joinColumnName, referencedColumn: referencedColumnName } =
+          attribute.joinColumn;
 
         const referencedValues = _.uniq(
-          results.map(r => r[joinColumnName]).filter(value => !_.isNil(value))
+          results.map((r) => r[joinColumnName]).filter((value) => !_.isNil(value))
         );
 
         if (_.isEmpty(referencedValues)) {
-          results.forEach(result => {
+          results.forEach((result) => {
             result[key] = null;
           });
 
@@ -160,7 +158,7 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const map = _.groupBy(referencedColumnName, rows);
 
-        results.forEach(result => {
+        results.forEach((result) => {
           result[key] = fromTargetRow(_.first(map[result[joinColumnName]]));
         });
 
@@ -172,20 +170,18 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const qb = db.entityManager.createQueryBuilder(targetMeta.uid);
 
-        const {
-          name: joinColumnName,
-          referencedColumn: referencedColumnName,
-        } = joinTable.joinColumn;
+        const { name: joinColumnName, referencedColumn: referencedColumnName } =
+          joinTable.joinColumn;
 
         const alias = qb.getAlias();
         const joinColAlias = `${alias}.${joinColumnName}`;
 
         const referencedValues = _.uniq(
-          results.map(r => r[referencedColumnName]).filter(value => !_.isNil(value))
+          results.map((r) => r[referencedColumnName]).filter((value) => !_.isNil(value))
         );
 
         if (_.isEmpty(referencedValues)) {
-          results.forEach(result => {
+          results.forEach((result) => {
             result[key] = null;
           });
           continue;
@@ -208,7 +204,7 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const map = _.groupBy(joinColumnName, rows);
 
-        results.forEach(result => {
+        results.forEach((result) => {
           result[key] = fromTargetRow(_.first(map[result[referencedColumnName]]));
         });
 
@@ -218,17 +214,15 @@ const applyPopulate = async (results, populate, ctx) => {
       continue;
     } else if (attribute.relation === 'oneToMany') {
       if (attribute.joinColumn) {
-        const {
-          name: joinColumnName,
-          referencedColumn: referencedColumnName,
-        } = attribute.joinColumn;
+        const { name: joinColumnName, referencedColumn: referencedColumnName } =
+          attribute.joinColumn;
 
         const referencedValues = _.uniq(
-          results.map(r => r[joinColumnName]).filter(value => !_.isNil(value))
+          results.map((r) => r[joinColumnName]).filter((value) => !_.isNil(value))
         );
 
         if (_.isEmpty(referencedValues)) {
-          results.forEach(result => {
+          results.forEach((result) => {
             result[key] = null;
           });
           continue;
@@ -243,7 +237,7 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const map = _.groupBy(referencedColumnName, rows);
 
-        results.forEach(result => {
+        results.forEach((result) => {
           result[key] = fromTargetRow(map[result[joinColumnName]] || []);
         });
 
@@ -255,21 +249,19 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const qb = db.entityManager.createQueryBuilder(targetMeta.uid);
 
-        const {
-          name: joinColumnName,
-          referencedColumn: referencedColumnName,
-        } = joinTable.joinColumn;
+        const { name: joinColumnName, referencedColumn: referencedColumnName } =
+          joinTable.joinColumn;
 
         const alias = qb.getAlias();
         const joinColAlias = `${alias}.${joinColumnName}`;
 
         const referencedValues = _.uniq(
-          results.map(r => r[referencedColumnName]).filter(value => !_.isNil(value))
+          results.map((r) => r[referencedColumnName]).filter((value) => !_.isNil(value))
         );
 
         if (isCount) {
           if (_.isEmpty(referencedValues)) {
-            results.forEach(result => {
+            results.forEach((result) => {
               result[key] = { count: 0 };
             });
             continue;
@@ -295,7 +287,7 @@ const applyPopulate = async (results, populate, ctx) => {
             return map;
           }, {});
 
-          results.forEach(result => {
+          results.forEach((result) => {
             result[key] = map[result[referencedColumnName]] || { count: 0 };
           });
 
@@ -303,7 +295,7 @@ const applyPopulate = async (results, populate, ctx) => {
         }
 
         if (_.isEmpty(referencedValues)) {
-          results.forEach(result => {
+          results.forEach((result) => {
             result[key] = [];
           });
           continue;
@@ -326,7 +318,7 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const map = _.groupBy(joinColumnName, rows);
 
-        results.forEach(r => {
+        results.forEach((r) => {
           r[key] = fromTargetRow(map[r[referencedColumnName]] || []);
         });
         continue;
@@ -343,12 +335,12 @@ const applyPopulate = async (results, populate, ctx) => {
       const alias = qb.getAlias();
       const joinColAlias = `${alias}.${joinColumnName}`;
       const referencedValues = _.uniq(
-        results.map(r => r[referencedColumnName]).filter(value => !_.isNil(value))
+        results.map((r) => r[referencedColumnName]).filter((value) => !_.isNil(value))
       );
 
       if (isCount) {
         if (_.isEmpty(referencedValues)) {
-          results.forEach(result => {
+          results.forEach((result) => {
             result[key] = { count: 0 };
           });
           continue;
@@ -374,7 +366,7 @@ const applyPopulate = async (results, populate, ctx) => {
           return map;
         }, {});
 
-        results.forEach(result => {
+        results.forEach((result) => {
           result[key] = map[result[referencedColumnName]] || { count: 0 };
         });
 
@@ -382,7 +374,7 @@ const applyPopulate = async (results, populate, ctx) => {
       }
 
       if (_.isEmpty(referencedValues)) {
-        results.forEach(result => {
+        results.forEach((result) => {
           result[key] = [];
         });
         continue;
@@ -405,7 +397,7 @@ const applyPopulate = async (results, populate, ctx) => {
 
       const map = _.groupBy(joinColumnName, rows);
 
-      results.forEach(result => {
+      results.forEach((result) => {
         result[key] = fromTargetRow(map[result[referencedColumnName]] || []);
       });
 
@@ -419,11 +411,11 @@ const applyPopulate = async (results, populate, ctx) => {
         const { idColumn, typeColumn } = targetAttribute.morphColumn;
 
         const referencedValues = _.uniq(
-          results.map(r => r[idColumn.referencedColumn]).filter(value => !_.isNil(value))
+          results.map((r) => r[idColumn.referencedColumn]).filter((value) => !_.isNil(value))
         );
 
         if (_.isEmpty(referencedValues)) {
-          results.forEach(result => {
+          results.forEach((result) => {
             result[key] = null;
           });
 
@@ -439,7 +431,7 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const map = _.groupBy(idColumn.name, rows);
 
-        results.forEach(result => {
+        results.forEach((result) => {
           const matchingRows = map[result[idColumn.referencedColumn]];
 
           const matchingValue =
@@ -455,11 +447,11 @@ const applyPopulate = async (results, populate, ctx) => {
         const { idColumn, typeColumn } = morphColumn;
 
         const referencedValues = _.uniq(
-          results.map(r => r[idColumn.referencedColumn]).filter(value => !_.isNil(value))
+          results.map((r) => r[idColumn.referencedColumn]).filter((value) => !_.isNil(value))
         );
 
         if (_.isEmpty(referencedValues)) {
-          results.forEach(result => {
+          results.forEach((result) => {
             result[key] = attribute.relation === 'morphOne' ? null : [];
           });
 
@@ -494,7 +486,7 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const map = _.groupBy(idColumn.name, rows);
 
-        results.forEach(result => {
+        results.forEach((result) => {
           const matchingRows = map[result[idColumn.referencedColumn]];
 
           const matchingValue =
@@ -515,7 +507,7 @@ const applyPopulate = async (results, populate, ctx) => {
       // fetch join table to create the ids map then do the same as morphToOne without the first
 
       const referencedValues = _.uniq(
-        results.map(r => r[joinColumn.referencedColumn]).filter(value => !_.isNil(value))
+        results.map((r) => r[joinColumn.referencedColumn]).filter((value) => !_.isNil(value))
       );
 
       const qb = db.entityManager.createQueryBuilder(joinTable.name);
@@ -568,16 +560,16 @@ const applyPopulate = async (results, populate, ctx) => {
         map[type] = _.groupBy(idColumn.referencedColumn, rows);
       }
 
-      results.forEach(result => {
+      results.forEach((result) => {
         const joinResults = joinMap[result[joinColumn.referencedColumn]] || [];
 
-        const matchingRows = joinResults.flatMap(joinResult => {
+        const matchingRows = joinResults.flatMap((joinResult) => {
           const id = joinResult[idColumn.name];
           const type = joinResult[typeColumn.name];
 
-          const fromTargetRow = rowOrRows => fromRow(db.metadata.get(type), rowOrRows);
+          const fromTargetRow = (rowOrRows) => fromRow(db.metadata.get(type), rowOrRows);
 
-          return (map[type][id] || []).map(row => {
+          return (map[type][id] || []).map((row) => {
             return {
               [typeField]: type,
               ...fromTargetRow(row),
@@ -632,7 +624,7 @@ const applyPopulate = async (results, populate, ctx) => {
         map[type] = _.groupBy(idColumn.referencedColumn, rows);
       }
 
-      results.forEach(result => {
+      results.forEach((result) => {
         const id = result[idColumn.name];
         const type = result[typeColumn.name];
 
@@ -643,7 +635,7 @@ const applyPopulate = async (results, populate, ctx) => {
 
         const matchingRows = map[type][id];
 
-        const fromTargetRow = rowOrRows => fromRow(db.metadata.get(type), rowOrRows);
+        const fromTargetRow = (rowOrRows) => fromRow(db.metadata.get(type), rowOrRows);
 
         result[key] = fromTargetRow(_.first(matchingRows));
       });

package/lib/query/helpers/search.js

@@ -13,7 +13,7 @@ const applySearch = (knex, query, ctx) => {
 
   const searchColumns = ['id'];
 
-  const stringColumns = Object.keys(attributes).filter(attributeName => {
+  const stringColumns = Object.keys(attributes).filter((attributeName) => {
     const attribute = attributes[attributeName];
     return types.isString(attribute.type) && attribute.searchable !== false;
   });
@@ -21,7 +21,7 @@ const applySearch = (knex, query, ctx) => {
   searchColumns.push(...stringColumns);
 
   if (!_.isNaN(_.toNumber(query))) {
-    const numberColumns = Object.keys(attributes).filter(attributeName => {
+    const numberColumns = Object.keys(attributes).filter((attributeName) => {
       const attribute = attributes[attributeName];
       return types.isNumber(attribute.type) && attribute.searchable !== false;
     });
@@ -31,7 +31,7 @@ const applySearch = (knex, query, ctx) => {
 
   switch (db.dialect.client) {
     case 'postgres': {
-      searchColumns.forEach(attr => {
+      searchColumns.forEach((attr) => {
         const columnName = toColumnName(meta, attr);
         return knex.orWhereRaw(`??::text ILIKE ?`, [
           qb.aliasColumn(columnName),
@@ -42,7 +42,7 @@ const applySearch = (knex, query, ctx) => {
       break;
     }
     case 'sqlite': {
-      searchColumns.forEach(attr => {
+      searchColumns.forEach((attr) => {
         const columnName = toColumnName(meta, attr);
         return knex.orWhereRaw(`?? LIKE ? ESCAPE '\\'`, [
           qb.aliasColumn(columnName),
@@ -52,7 +52,7 @@ const applySearch = (knex, query, ctx) => {
       break;
     }
     case 'mysql': {
-      searchColumns.forEach(attr => {
+      searchColumns.forEach((attr) => {
         const columnName = toColumnName(meta, attr);
         return knex.orWhereRaw(`?? LIKE ?`, [
           qb.aliasColumn(columnName),

package/lib/query/helpers/transform.js

@@ -7,7 +7,7 @@ const { createField } = require('../../fields');
 
 const fromRow = (meta, row) => {
   if (Array.isArray(row)) {
-    return row.map(singleRow => fromRow(meta, singleRow));
+    return row.map((singleRow) => fromRow(meta, singleRow));
   }
 
   const { attributes } = meta;
@@ -48,7 +48,7 @@ const toRow = (meta, data = {}) => {
   }
 
   if (_.isArray(data)) {
-    return data.map(datum => toRow(meta, datum));
+    return data.map((datum) => toRow(meta, datum));
   }
 
   const { attributes } = meta;

package/lib/query/helpers/where.js

@@ -45,7 +45,7 @@ const CAST_OPERATORS = [
 
 const ARRAY_OPERATORS = ['$in', '$notIn', '$between'];
 
-const isOperator = key => OPERATORS.includes(key);
+const isOperator = (key) => OPERATORS.includes(key);
 
 const castValue = (value, attribute) => {
   if (!attribute) {
@@ -63,7 +63,7 @@ const castValue = (value, attribute) => {
 
 const processAttributeWhere = (attribute, where, operator = '$eq') => {
   if (_.isArray(where)) {
-    return where.map(sub => processAttributeWhere(attribute, sub, operator));
+    return where.map((sub) => processAttributeWhere(attribute, sub, operator));
   }
 
   if (!_.isPlainObject(where)) {
@@ -102,7 +102,7 @@ const processWhere = (where, ctx) => {
   }
 
   if (_.isArray(where)) {
-    return where.map(sub => processWhere(sub, ctx));
+    return where.map((sub) => processWhere(sub, ctx));
   }
 
   const processNested = (where, ctx) => {
@@ -124,7 +124,7 @@ const processWhere = (where, ctx) => {
 
     // if operator $and $or then loop over them
     if (GROUP_OPERATORS.includes(key)) {
-      filters[key] = value.map(sub => processNested(sub, ctx));
+      filters[key] = value.map((sub) => processNested(sub, ctx));
       continue;
     }
 
@@ -190,9 +190,9 @@ const processWhere = (where, ctx) => {
 // TODO: add type casting per operator at some point
 const applyOperator = (qb, column, operator, value) => {
   if (Array.isArray(value) && !ARRAY_OPERATORS.includes(operator)) {
-    return qb.where(subQB => {
-      value.forEach(subValue =>
-        subQB.orWhere(innerQB => {
+    return qb.where((subQB) => {
+      value.forEach((subValue) =>
+        subQB.orWhere((innerQB) => {
           applyOperator(innerQB, column, operator, subValue);
         })
       );
@@ -201,7 +201,7 @@ const applyOperator = (qb, column, operator, value) => {
 
   switch (operator) {
     case '$not': {
-      qb.whereNot(qb => applyWhereToColumn(qb, column, value));
+      qb.whereNot((qb) => applyWhereToColumn(qb, column, value));
       break;
     }
 
@@ -325,7 +325,7 @@ const applyWhereToColumn = (qb, column, columnWhere) => {
     return qb.where(column, columnWhere);
   }
 
-  Object.keys(columnWhere).forEach(operator => {
+  Object.keys(columnWhere).forEach((operator) => {
     const value = columnWhere[operator];
 
     applyOperator(qb, column, operator, value);
@@ -338,33 +338,33 @@ const applyWhere = (qb, where) => {
   }
 
   if (_.isArray(where)) {
-    return qb.where(subQB => where.forEach(subWhere => applyWhere(subQB, subWhere)));
+    return qb.where((subQB) => where.forEach((subWhere) => applyWhere(subQB, subWhere)));
   }
 
-  Object.keys(where).forEach(key => {
+  Object.keys(where).forEach((key) => {
     const value = where[key];
 
     if (key === '$and') {
-      return qb.where(subQB => {
-        value.forEach(v => applyWhere(subQB, v));
+      return qb.where((subQB) => {
+        value.forEach((v) => applyWhere(subQB, v));
       });
     }
 
     if (key === '$or') {
-      return qb.where(subQB => {
-        value.forEach(v => subQB.orWhere(inner => applyWhere(inner, v)));
+      return qb.where((subQB) => {
+        value.forEach((v) => subQB.orWhere((inner) => applyWhere(inner, v)));
       });
     }
 
     if (key === '$not') {
-      return qb.whereNot(qb => applyWhere(qb, value));
+      return qb.whereNot((qb) => applyWhere(qb, value));
     }
 
     applyWhereToColumn(qb, key, value);
   });
 };
 
-const fieldLowerFn = qb => {
+const fieldLowerFn = (qb) => {
   // Postgres requires string to be passed
   if (qb.client.config.client === 'postgres') {
     return 'LOWER(CAST(?? AS VARCHAR))';

package/lib/query/query-builder.js

@@ -225,15 +225,9 @@ const createQueryBuilder = (uid, db) => {
       this.select('id');
       const subQB = this.getKnexQuery();
 
-      const nestedSubQuery = db
-        .getConnection()
-        .select('id')
-        .from(subQB.as('subQuery'));
-
-      return db
-        .getConnection(tableName)
-        [state.type]()
-        .whereIn('id', nestedSubQuery);
+      const nestedSubQuery = db.getConnection().select('id').from(subQB.as('subQuery'));
+
+      return db.getConnection(tableName)[state.type]().whereIn('id', nestedSubQuery);
     },
 
     processState() {
@@ -263,11 +257,11 @@ const createQueryBuilder = (uid, db) => {
     },
 
     processSelect() {
-      state.select = state.select.map(field => helpers.toColumnName(meta, field));
+      state.select = state.select.map((field) => helpers.toColumnName(meta, field));
 
       if (this.shouldUseDistinct()) {
-        const joinsOrderByColumns = state.joins.flatMap(join => {
-          return _.keys(join.orderBy).map(key => this.aliasColumn(key, join.alias));
+        const joinsOrderByColumns = state.joins.flatMap((join) => {
+          return _.keys(join.orderBy).map((key) => this.aliasColumn(key, join.alias));
         });
         const orderByColumns = state.orderBy.map(({ column }) => column);
 
@@ -292,7 +286,7 @@ const createQueryBuilder = (uid, db) => {
 
       switch (state.type) {
         case 'select': {
-          qb.select(state.select.map(column => this.aliasColumn(column)));
+          qb.select(state.select.map((column) => this.aliasColumn(column)));
 
           if (this.shouldUseDistinct()) {
             qb.distinct();
@@ -337,6 +331,9 @@ const createQueryBuilder = (uid, db) => {
           db.truncate();
           break;
         }
+        default: {
+          throw new Error('Unknown query type');
+        }
       }
 
       if (state.transaction) {
@@ -374,7 +371,7 @@ const createQueryBuilder = (uid, db) => {
 
       // if there are joins and it is a delete or update use a sub query
       if (state.search) {
-        qb.where(subQb => {
+        qb.where((subQb) => {
           helpers.applySearch(subQb, state.search, { qb: this, db, uid });
         });
       }