@strapi/database 4.0.0-next.8 → 4.0.2

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(??)';
 };
 

package/lib/query/query-builder.js

@@ -29,22 +29,17 @@ const createQueryBuilder = (uid, db) => {
   return {
     alias: getAlias(),
     getAlias,
+    state,
 
     select(args) {
       state.type = 'select';
-      state.select = _.uniq(_.castArray(args)).map(col => this.aliasColumn(col));
+      state.select = _.uniq(_.castArray(args));
 
       return this;
     },
 
     addSelect(args) {
-      _.uniq(_.castArray(args))
-        .map(col => this.aliasColumn(col))
-        .forEach(toSelect => {
-          if (!state.select.includes(toSelect)) {
-            state.select.push(toSelect);
-          }
-        });
+      state.select = _.uniq([...state.select, ..._.castArray(args)]);
 
       return this;
     },
@@ -62,6 +57,10 @@ const createQueryBuilder = (uid, db) => {
       return this;
     },
 
+    ref(name) {
+      return db.connection.ref(helpers.toColumnName(meta, name));
+    },
+
     update(data) {
       state.type = 'update';
       state.data = data;
@@ -77,9 +76,11 @@ const createQueryBuilder = (uid, db) => {
     },
 
     where(where = {}) {
-      const processedWhere = helpers.processWhere(where, { qb: this, uid, db });
+      if (!_.isPlainObject(where)) {
+        throw new Error('Where must be an object');
+      }
 
-      state.where.push(processedWhere);
+      state.where.push(where);
 
       return this;
     },
@@ -95,7 +96,7 @@ const createQueryBuilder = (uid, db) => {
     },
 
     orderBy(orderBy) {
-      state.orderBy = helpers.processOrderBy(orderBy, { qb: this, uid, db });
+      state.orderBy = orderBy;
       return this;
     },
 
@@ -105,7 +106,7 @@ const createQueryBuilder = (uid, db) => {
     },
 
     populate(populate) {
-      state.populate = helpers.processPopulate(populate, { qb: this, uid, db });
+      state.populate = populate;
       return this;
     },
 
@@ -115,7 +116,7 @@ const createQueryBuilder = (uid, db) => {
     },
 
     init(params = {}) {
-      const { _q, where, select, limit, offset, orderBy, groupBy, populate } = params;
+      const { _q, filters, where, select, limit, offset, orderBy, groupBy, populate } = params;
 
       if (!_.isNil(where)) {
         this.where(where);
@@ -151,9 +152,17 @@ const createQueryBuilder = (uid, db) => {
         this.populate(populate);
       }
 
+      if (!_.isNil(filters)) {
+        this.filters(filters);
+      }
+
       return this;
     },
 
+    filters(filters) {
+      state.filters = filters;
+    },
+
     first() {
       state.first = true;
       return this;
@@ -164,43 +173,111 @@ const createQueryBuilder = (uid, db) => {
       return this;
     },
 
-    aliasColumn(columnName) {
-      if (typeof columnName !== 'string') {
-        return columnName;
+    mustUseAlias() {
+      return ['select', 'count'].includes(state.type);
+    },
+
+    aliasColumn(key, alias) {
+      if (typeof key !== 'string') {
+        return key;
+      }
+
+      if (key.indexOf('.') >= 0) {
+        return key;
+      }
+
+      if (!_.isNil(alias)) {
+        return `${alias}.${key}`;
       }
 
-      if (columnName.indexOf('.') >= 0) return columnName;
-      return this.alias + '.' + columnName;
+      return this.mustUseAlias() ? `${this.alias}.${key}` : key;
     },
 
     raw(...args) {
       return db.connection.raw(...args);
     },
 
-    getKnexQuery() {
-      const aliasedTableName = state.type === 'insert' ? tableName : { [this.alias]: tableName };
+    shouldUseSubQuery() {
+      return ['delete', 'update'].includes(state.type) && state.joins.length > 0;
+    },
+
+    runSubQuery() {
+      this.select('id');
+      const subQB = this.getKnexQuery();
 
-      const qb = db.connection(aliasedTableName);
+      const nestedSubQuery = db
+        .getConnection()
+        .select('id')
+        .from(subQB.as('subQuery'));
 
+      return db
+        .getConnection(tableName)
+        [state.type]()
+        .whereIn('id', nestedSubQuery);
+    },
+
+    processState() {
+      state.orderBy = helpers.processOrderBy(state.orderBy, { qb: this, uid, db });
+
+      if (!_.isNil(state.filters)) {
+        if (_.isFunction(state.filters)) {
+          const filters = state.filters({ qb: this, uid, meta, db });
+
+          if (!_.isNil(filters)) {
+            state.where.push(filters);
+          }
+        } else {
+          state.where.push(state.filters);
+        }
+      }
+
+      state.where = helpers.processWhere(state.where, { qb: this, uid, db });
+      state.populate = helpers.processPopulate(state.populate, { qb: this, uid, db });
+      state.data = helpers.toRow(meta, state.data);
+
+      this.processSelect();
+    },
+
+    shouldUseDistinct() {
+      return state.joins.length > 0 && _.isEmpty(state.groupBy);
+    },
+
+    processSelect() {
+      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 orderByColumns = state.orderBy.map(({ column }) => column);
+
+        state.select = _.uniq([...joinsOrderByColumns, ...orderByColumns, ...state.select]);
+      }
+    },
+
+    getKnexQuery() {
       if (!state.type) {
         this.select('*');
       }
 
+      const aliasedTableName = this.mustUseAlias() ? `${tableName} as ${this.alias}` : tableName;
+
+      const qb = db.getConnection(aliasedTableName);
+
+      if (this.shouldUseSubQuery()) {
+        return this.runSubQuery();
+      }
+
+      this.processState();
+
       switch (state.type) {
         case 'select': {
-          if (state.select.length === 0) {
-            state.select = [this.aliasColumn('*')];
-          }
+          qb.select(state.select.map(column => this.aliasColumn(column)));
 
-          if (state.joins.length > 0 && !state.groupBy) {
-            // add a discting when making joins and if we don't have a groupBy
-            // TODO: make sure we return the right data
-            qb.distinct(`${this.alias}.id`);
-            // TODO: add column if they aren't there already
-            state.select.unshift(...state.orderBy.map(({ column }) => column));
+          if (this.shouldUseDistinct()) {
+            qb.distinct();
           }
 
-          qb.select(state.select);
           break;
         }
         case 'count': {
@@ -218,14 +295,17 @@ const createQueryBuilder = (uid, db) => {
         }
         case 'update': {
           qb.update(state.data);
-
           break;
         }
         case 'delete': {
-          qb.del();
+          qb.delete();
 
           break;
         }
+        case 'truncate': {
+          db.truncate();
+          break;
+        }
       }
 
       if (state.limit) {
@@ -248,13 +328,15 @@ const createQueryBuilder = (uid, db) => {
         qb.groupBy(state.groupBy);
       }
 
+      // if there are joins and it is a delete or update use a sub query
       if (state.where) {
         helpers.applyWhere(qb, state.where);
       }
 
+      // if there are joins and it is a delete or update use a sub query
       if (state.search) {
         qb.where(subQb => {
-          helpers.applySearch(subQb, state.search, { alias: this.alias, db, uid });
+          helpers.applySearch(subQb, state.search, { qb: this, db, uid });
         });
       }
 

package/lib/schema/__tests__/schema-diff.test.js

@@ -1,8 +1,21 @@
 'use strict';
 
-const { diffSchemas } = require('../schema-diff');
+const createSchemaDiff = require('../diff');
 
+let diffSchemas;
 describe('diffSchemas', () => {
+  beforeEach(() => {
+    const schemaDiff = createSchemaDiff({
+      dialect: {
+        usesForeignKeys() {
+          return true;
+        },
+      },
+    });
+
+    diffSchemas = schemaDiff.diff.bind(schemaDiff);
+  });
+
   test('New Table', () => {
     const testTable = {
       name: 'my_table',