@strapi/database 4.0.0-next.9 → 4.0.0

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

@@ -4,19 +4,23 @@ const _ = require('lodash/fp');
 
 const types = require('../../types');
 const { createJoin } = require('./join');
+const { toColumnName } = require('./transform');
 
-// TODO: convert field names to columns names
 const processOrderBy = (orderBy, ctx) => {
-  const { db, uid, qb, alias = qb.alias } = ctx;
+  const { db, uid, qb, alias } = ctx;
+  const meta = db.metadata.get(uid);
+  const { attributes } = meta;
 
   if (typeof orderBy === 'string') {
-    const attribute = db.metadata.get(uid).attributes[orderBy];
+    const attribute = attributes[orderBy];
 
     if (!attribute) {
       throw new Error(`Attribute ${orderBy} not found on model ${uid}`);
     }
 
-    return [{ column: `${alias}.${orderBy}` }];
+    const columnName = toColumnName(meta, orderBy);
+
+    return [{ column: qb.aliasColumn(columnName, alias) }];
   }
 
   if (Array.isArray(orderBy)) {
@@ -26,15 +30,25 @@ const processOrderBy = (orderBy, ctx) => {
   if (_.isPlainObject(orderBy)) {
     return Object.entries(orderBy).flatMap(([key, direction]) => {
       const value = orderBy[key];
-      const attribute = db.metadata.get(uid).attributes[key];
+      const attribute = attributes[key];
 
       if (!attribute) {
         throw new Error(`Attribute ${key} not found on model ${uid}`);
       }
 
+      if (types.isScalar(attribute.type)) {
+        const columnName = toColumnName(meta, key);
+
+        return { column: qb.aliasColumn(columnName, alias), order: direction };
+      }
+
       if (attribute.type === 'relation') {
-        // TODO: pass down some filters (e.g published at)
-        const subAlias = createJoin(ctx, { alias, uid, attributeName: key, attribute });
+        const subAlias = createJoin(ctx, {
+          alias: alias || qb.alias,
+          uid,
+          attributeName: key,
+          attribute,
+        });
 
         return processOrderBy(value, {
           db,
@@ -44,10 +58,6 @@ const processOrderBy = (orderBy, ctx) => {
         });
       }
 
-      if (types.isScalar(attribute.type)) {
-        return { column: `${alias}.${key}`, order: direction };
-      }
-
       throw new Error(`You cannot order on ${attribute.type} types`);
     });
   }

package/lib/query/helpers/populate.js

@@ -33,7 +33,7 @@ const processPopulate = (populate, ctx) => {
 
   let populateMap = {};
 
-  if (populate === false) {
+  if (populate === false || _.isNil(populate)) {
     return null;
   }
 
@@ -94,8 +94,17 @@ const processPopulate = (populate, ctx) => {
   return finalPopulate;
 };
 
-//  Omit limit & offset to avoid needing a query per result to avoid making too many queries
-const pickPopulateParams = _.pick(['select', 'count', 'where', 'populate', 'orderBy']);
+//  TODO: Omit limit & offset to avoid needing a query per result to avoid making too many queries
+const pickPopulateParams = _.pick([
+  'select',
+  'count',
+  'where',
+  'populate',
+  'orderBy',
+  'limit',
+  'offset',
+  'filters',
+]);
 
 // TODO: cleanup code
 // TODO: create aliases for pivot columns
@@ -114,7 +123,11 @@ const applyPopulate = async (results, populate, ctx) => {
     const attribute = meta.attributes[key];
     const targetMeta = db.metadata.get(attribute.target);
 
-    const populateValue = pickPopulateParams(populate[key]);
+    const populateValue = {
+      filters: qb.state.filters,
+      ...pickPopulateParams(populate[key]),
+    };
+
     const isCount = populateValue.count === true;
 
     const fromTargetRow = rowOrRows => fromRow(targetMeta, rowOrRows);
@@ -181,7 +194,7 @@ const applyPopulate = async (results, populate, ctx) => {
         const rows = await qb
           .init(populateValue)
           .join({
-            alias: alias,
+            alias,
             referencedTable: joinTable.name,
             referencedColumn: joinTable.inverseJoinColumn.name,
             rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -265,7 +278,7 @@ const applyPopulate = async (results, populate, ctx) => {
           const rows = await qb
             .init(populateValue)
             .join({
-              alias: alias,
+              alias,
               referencedTable: joinTable.name,
               referencedColumn: joinTable.inverseJoinColumn.name,
               rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -299,7 +312,7 @@ const applyPopulate = async (results, populate, ctx) => {
         const rows = await qb
           .init(populateValue)
           .join({
-            alias: alias,
+            alias,
             referencedTable: joinTable.name,
             referencedColumn: joinTable.inverseJoinColumn.name,
             rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -344,7 +357,7 @@ const applyPopulate = async (results, populate, ctx) => {
         const rows = await qb
           .init(populateValue)
           .join({
-            alias: alias,
+            alias,
             referencedTable: joinTable.name,
             referencedColumn: joinTable.inverseJoinColumn.name,
             rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -378,7 +391,7 @@ const applyPopulate = async (results, populate, ctx) => {
       const rows = await qb
         .init(populateValue)
         .join({
-          alias: alias,
+          alias,
           referencedTable: joinTable.name,
           referencedColumn: joinTable.inverseJoinColumn.name,
           rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -461,7 +474,7 @@ const applyPopulate = async (results, populate, ctx) => {
         const rows = await qb
           .init(populateValue)
           .join({
-            alias: alias,
+            alias,
             referencedTable: joinTable.name,
             referencedColumn: joinColumn.name,
             rootColumn: joinColumn.referencedColumn,
@@ -538,6 +551,12 @@ const applyPopulate = async (results, populate, ctx) => {
       for (const type in idsByType) {
         const ids = idsByType[type];
 
+        // type was removed but still in morph relation
+        if (!db.metadata.get(type)) {
+          map[type] = {};
+          continue;
+        }
+
         const qb = db.entityManager.createQueryBuilder(type);
 
         const rows = await qb
@@ -596,6 +615,12 @@ const applyPopulate = async (results, populate, ctx) => {
       for (const type in idsByType) {
         const ids = idsByType[type];
 
+        // type was removed but still in morph relation
+        if (!db.metadata.get(type)) {
+          map[type] = {};
+          continue;
+        }
+
         const qb = db.entityManager.createQueryBuilder(type);
 
         const rows = await qb

package/lib/query/helpers/search.js

@@ -3,11 +3,13 @@
 const _ = require('lodash/fp');
 
 const types = require('../../types');
+const { toColumnName } = require('./transform');
 
-const applySearch = (qb, query, ctx) => {
-  const { alias, uid, db } = ctx;
+const applySearch = (knex, query, ctx) => {
+  const { qb, uid, db } = ctx;
+  const meta = db.metadata.get(uid);
 
-  const { attributes } = db.metadata.get(uid);
+  const { attributes } = meta;
 
   const searchColumns = ['id'];
 
@@ -29,22 +31,34 @@ const applySearch = (qb, query, ctx) => {
 
   switch (db.dialect.client) {
     case 'postgres': {
-      searchColumns.forEach(attr =>
-        qb.orWhereRaw(`"${alias}"."${attr}"::text ILIKE ?`, `%${escapeQuery(query, '*%\\')}%`)
-      );
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`??::text ILIKE ?`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
 
       break;
     }
     case 'sqlite': {
-      searchColumns.forEach(attr =>
-        qb.orWhereRaw(`"${alias}"."${attr}" LIKE ? ESCAPE '\\'`, `%${escapeQuery(query, '*%\\')}%`)
-      );
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`?? LIKE ? ESCAPE '\\'`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
       break;
     }
     case 'mysql': {
-      searchColumns.forEach(attr =>
-        qb.orWhereRaw(`\`${alias}\`.\`${attr}\` LIKE ?`, `%${escapeQuery(query, '*%\\')}%`)
-      );
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`?? LIKE ?`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
       break;
     }
     default: {

package/lib/query/helpers/transform.js

@@ -5,12 +5,12 @@ const _ = require('lodash/fp');
 const types = require('../../types');
 const { createField } = require('../../fields');
 
-const fromRow = (metadata, row) => {
+const fromRow = (meta, row) => {
   if (Array.isArray(row)) {
-    return row.map(singleRow => fromRow(metadata, singleRow));
+    return row.map(singleRow => fromRow(meta, singleRow));
   }
 
-  const { attributes } = metadata;
+  const { attributes } = meta;
 
   if (_.isNil(row)) {
     return null;
@@ -19,25 +19,16 @@ const fromRow = (metadata, row) => {
   const obj = {};
 
   for (const column in row) {
-    // to field Name
-    const attributeName = column;
-
-    if (!attributes[attributeName]) {
-      // ignore value that are not related to an attribute (join columns ...)
+    if (!_.has(column, meta.columnToAttribute)) {
       continue;
     }
 
+    const attributeName = meta.columnToAttribute[column];
     const attribute = attributes[attributeName];
 
     if (types.isScalar(attribute.type)) {
-      // TODO: we convert to column name
-      // TODO: handle default value too
-      // TODO: format data & use dialect to know which type they support (json particularly)
-
       const field = createField(attribute);
 
-      // TODO: validate data on creation
-      // field.validate(data[attributeName]);
       const val = row[column] === null ? null : field.fromDB(row[column]);
 
       obj[attributeName] = val;
@@ -51,6 +42,43 @@ const fromRow = (metadata, row) => {
   return obj;
 };
 
+const toRow = (meta, data = {}) => {
+  if (_.isNil(data)) {
+    return data;
+  }
+
+  if (_.isArray(data)) {
+    return data.map(datum => toRow(meta, datum));
+  }
+
+  const { attributes } = meta;
+
+  for (const key in data) {
+    const attribute = attributes[key];
+
+    if (!attribute || attribute.columnName === key) {
+      continue;
+    }
+
+    data[attribute.columnName] = data[key];
+    delete data[key];
+  }
+
+  return data;
+};
+
+const toColumnName = (meta, name) => {
+  const attribute = meta.attributes[name];
+
+  if (!attribute) {
+    return name;
+  }
+
+  return attribute.columnName || name;
+};
+
 module.exports = {
+  toRow,
   fromRow,
+  toColumnName,
 };

package/lib/query/helpers/where.js

@@ -3,7 +3,9 @@
 const _ = require('lodash/fp');
 
 const types = require('../../types');
+const { createField } = require('../../fields');
 const { createJoin } = require('./join');
+const { toColumnName } = require('./transform');
 
 const GROUP_OPERATORS = ['$and', '$or'];
 const OPERATORS = [
@@ -19,8 +21,6 @@ const OPERATORS = [
   '$null',
   '$notNull',
   '$between',
-  // '$like',
-  // '$regexp',
   '$startsWith',
   '$endsWith',
   '$contains',
@@ -29,10 +29,65 @@ const OPERATORS = [
   '$notContainsi',
 ];
 
+const CAST_OPERATORS = [
+  '$not',
+  '$in',
+  '$notIn',
+  '$eq',
+  '$ne',
+  '$gt',
+  '$gte',
+  '$lt',
+  '$lte',
+  '$between',
+];
+
 const ARRAY_OPERATORS = ['$in', '$notIn', '$between'];
 
 const isOperator = key => OPERATORS.includes(key);
 
+const castValue = (value, attribute) => {
+  if (!attribute) {
+    return value;
+  }
+
+  if (types.isScalar(attribute.type)) {
+    const field = createField(attribute);
+
+    return value === null ? null : field.toDB(value);
+  }
+
+  return value;
+};
+
+const processAttributeWhere = (attribute, where, operator = '$eq') => {
+  if (_.isArray(where)) {
+    return where.map(sub => processAttributeWhere(attribute, sub, operator));
+  }
+
+  if (!_.isPlainObject(where)) {
+    if (CAST_OPERATORS.includes(operator)) {
+      return castValue(where, attribute);
+    }
+
+    return where;
+  }
+
+  const filters = {};
+
+  for (const key in where) {
+    const value = where[key];
+
+    if (!isOperator(key)) {
+      throw new Error(`Undefined attribute level operator ${key}`);
+    }
+
+    filters[key] = processAttributeWhere(attribute, value, key);
+  }
+
+  return filters;
+};
+
 /**
  * Process where parameter
  * @param {Object} where
@@ -40,9 +95,13 @@ const isOperator = key => OPERATORS.includes(key);
  * @param {number} depth
  * @returns {Object}
  */
-const processWhere = (where, ctx, depth = 0) => {
-  if (depth === 0 && !_.isPlainObject(where)) {
-    throw new Error('Where must be an object');
+const processWhere = (where, ctx) => {
+  if (!_.isArray(where) && !_.isPlainObject(where)) {
+    throw new Error('Where must be an array or an object');
+  }
+
+  if (_.isArray(where)) {
+    return where.map(sub => processWhere(sub, ctx));
   }
 
   const processNested = (where, ctx) => {
@@ -50,17 +109,17 @@ const processWhere = (where, ctx, depth = 0) => {
       return where;
     }
 
-    return processWhere(where, ctx, depth + 1);
+    return processWhere(where, ctx);
   };
 
-  const { db, uid, qb, alias = qb.alias } = ctx;
+  const { db, uid, qb, alias } = ctx;
+  const meta = db.metadata.get(uid);
 
   const filters = {};
 
   // for each key in where
   for (const key in where) {
     const value = where[key];
-    const attribute = db.metadata.get(uid).attributes[key];
 
     // if operator $and $or then loop over them
     if (GROUP_OPERATORS.includes(key)) {
@@ -74,36 +133,24 @@ const processWhere = (where, ctx, depth = 0) => {
     }
 
     if (isOperator(key)) {
-      if (depth == 0) {
-        throw new Error(
-          `Only $and, $or and $not can by used as root level operators. Found ${key}.`
-        );
-      }
-
-      filters[key] = processNested(value, ctx);
-      continue;
+      throw new Error(`Only $and, $or and $not can by used as root level operators. Found ${key}.`);
     }
 
-    if (!attribute) {
-      // TODO: if targeting a column name instead of an attribute
+    const attribute = meta.attributes[key];
 
-      // if key as an alias don't add one
-      if (key.indexOf('.') >= 0) {
-        filters[key] = processNested(value, ctx);
-      } else {
-        filters[`${alias || qb.alias}.${key}`] = processNested(value, ctx);
-      }
+    if (!attribute) {
+      filters[qb.aliasColumn(key, alias)] = processAttributeWhere(null, value);
       continue;
-
-      // throw new Error(`Attribute ${key} not found on model ${uid}`);
     }
 
-    // move to if else to check for scalar / relation / components & throw for other types
-    if (attribute.type === 'relation') {
-      // TODO: pass down some filters (e.g published at)
-
+    if (types.isRelation(attribute.type)) {
       // attribute
-      const subAlias = createJoin(ctx, { alias, uid, attributeName: key, attribute });
+      const subAlias = createJoin(ctx, {
+        alias: alias || qb.alias,
+        uid,
+        attributeName: key,
+        attribute,
+      });
 
       let nestedWhere = processNested(value, {
         db,
@@ -113,7 +160,7 @@ const processWhere = (where, ctx, depth = 0) => {
       });
 
       if (!_.isPlainObject(nestedWhere) || isOperator(_.keys(nestedWhere)[0])) {
-        nestedWhere = { [`${subAlias}.id`]: nestedWhere };
+        nestedWhere = { [qb.aliasColumn('id', subAlias)]: nestedWhere };
       }
 
       // TODO: use a better merge logic (push to $and when collisions)
@@ -123,9 +170,11 @@ const processWhere = (where, ctx, depth = 0) => {
     }
 
     if (types.isScalar(attribute.type)) {
-      // TODO: convert attribute name to column name
-      // TODO: cast to DB type
-      filters[`${alias || qb.alias}.${key}`] = processNested(value, ctx);
+      const columnName = toColumnName(meta, key);
+      const aliasedColumnName = qb.aliasColumn(columnName, alias);
+
+      filters[aliasedColumnName] = processAttributeWhere(attribute, value);
+
       continue;
     }
 
@@ -135,6 +184,7 @@ const processWhere = (where, ctx, depth = 0) => {
   return filters;
 };
 
+// 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 => {
@@ -197,7 +247,6 @@ const applyOperator = (qb, column, operator, value) => {
       break;
     }
     case '$null': {
-      // TODO: make this better
       if (value) {
         qb.whereNull(column);
       }
@@ -207,26 +256,12 @@ const applyOperator = (qb, column, operator, value) => {
       if (value) {
         qb.whereNotNull(column);
       }
-
       break;
     }
     case '$between': {
       qb.whereBetween(column, value);
       break;
     }
-    // case '$regexp': {
-    //   // TODO:
-    //
-    // break;
-    // }
-    // // string
-    // // TODO: use $case to make it case insensitive
-    // case '$like': {
-    //   qb.where(column, 'like', value);
-    // break;
-    // }
-
-    // TODO: add casting logic
     case '$startsWith': {
       qb.where(column, 'like', `${value}%`);
       break;
@@ -260,7 +295,7 @@ const applyOperator = (qb, column, operator, value) => {
     // TODO: relational operators every/some/exists/size ...
 
     default: {
-      throw new Error(`Undefined operator ${operator}`);
+      throw new Error(`Undefined attribute level operator ${operator}`);
     }
   }
 };
@@ -274,7 +309,6 @@ const applyWhereToColumn = (qb, column, columnWhere) => {
     return qb.where(column, columnWhere);
   }
 
-  // TODO: handle casing
   Object.keys(columnWhere).forEach(operator => {
     const value = columnWhere[operator];
 
@@ -283,12 +317,12 @@ const applyWhereToColumn = (qb, column, columnWhere) => {
 };
 
 const applyWhere = (qb, where) => {
-  if (Array.isArray(where)) {
-    return qb.where(subQB => where.forEach(subWhere => applyWhere(subQB, subWhere)));
+  if (!_.isArray(where) && !_.isPlainObject(where)) {
+    throw new Error('Where must be an array or an object');
   }
 
-  if (!_.isPlainObject(where)) {
-    throw new Error('Where must be an object');
+  if (_.isArray(where)) {
+    return qb.where(subQB => where.forEach(subWhere => applyWhere(subQB, subWhere)));
   }
 
   Object.keys(where).forEach(key => {
@@ -316,9 +350,10 @@ const applyWhere = (qb, where) => {
 
 const fieldLowerFn = qb => {
   // Postgres requires string to be passed
-  if (qb.client.config.client === 'pg') {
+  if (qb.client.config.client === 'postgres') {
     return 'LOWER(CAST(?? AS VARCHAR))';
   }
+
   return 'LOWER(??)';
 };