@strapi/database 4.0.0-beta.0

package/lib/query/helpers/search.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const _ = require('lodash/fp');
+
+const types = require('../../types');
+const { toColumnName } = require('./transform');
+
+const applySearch = (knex, query, ctx) => {
+  const { qb, uid, db } = ctx;
+  const meta = db.metadata.get(uid);
+
+  const { attributes } = meta;
+
+  const searchColumns = ['id'];
+
+  const stringColumns = Object.keys(attributes).filter(attributeName => {
+    const attribute = attributes[attributeName];
+    return types.isString(attribute.type) && attribute.searchable !== false;
+  });
+
+  searchColumns.push(...stringColumns);
+
+  if (!_.isNaN(_.toNumber(query))) {
+    const numberColumns = Object.keys(attributes).filter(attributeName => {
+      const attribute = attributes[attributeName];
+      return types.isNumber(attribute.type) && attribute.searchable !== false;
+    });
+
+    searchColumns.push(...numberColumns);
+  }
+
+  switch (db.dialect.client) {
+    case 'postgres': {
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`??::text ILIKE ?`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
+
+      break;
+    }
+    case 'sqlite': {
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`?? LIKE ? ESCAPE '\\'`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
+      break;
+    }
+    case 'mysql': {
+      searchColumns.forEach(attr => {
+        const columnName = toColumnName(meta, attr);
+        return knex.orWhereRaw(`?? LIKE ?`, [
+          qb.aliasColumn(columnName),
+          `%${escapeQuery(query, '*%\\')}%`,
+        ]);
+      });
+      break;
+    }
+    default: {
+      // do nothing
+    }
+  }
+};
+
+const escapeQuery = (query, charsToEscape, escapeChar = '\\') => {
+  return query
+    .split('')
+    .reduce(
+      (escapedQuery, char) =>
+        charsToEscape.includes(char)
+          ? `${escapedQuery}${escapeChar}${char}`
+          : `${escapedQuery}${char}`,
+      ''
+    );
+};
+
+module.exports = {
+  applySearch,
+};

package/lib/query/helpers/transform.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const _ = require('lodash/fp');
+
+const types = require('../../types');
+const { createField } = require('../../fields');
+
+const fromRow = (meta, row) => {
+  if (Array.isArray(row)) {
+    return row.map(singleRow => fromRow(meta, singleRow));
+  }
+
+  const { attributes } = meta;
+
+  if (_.isNil(row)) {
+    return null;
+  }
+
+  const obj = {};
+
+  for (const column in row) {
+    if (!_.has(column, meta.columnToAttribute)) {
+      continue;
+    }
+
+    const attributeName = meta.columnToAttribute[column];
+    const attribute = attributes[attributeName];
+
+    if (types.isScalar(attribute.type)) {
+      const field = createField(attribute);
+
+      const val = row[column] === null ? null : field.fromDB(row[column]);
+
+      obj[attributeName] = val;
+    }
+
+    if (types.isRelation(attribute.type)) {
+      obj[attributeName] = row[column];
+    }
+  }
+
+  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

@@ -0,0 +1,322 @@
+'use strict';
+
+const _ = require('lodash/fp');
+
+const types = require('../../types');
+const { createJoin } = require('./join');
+const { toColumnName } = require('./transform');
+
+const GROUP_OPERATORS = ['$and', '$or'];
+const OPERATORS = [
+  '$not',
+  '$in',
+  '$notIn',
+  '$eq',
+  '$ne',
+  '$gt',
+  '$gte',
+  '$lt',
+  '$lte',
+  '$null',
+  '$notNull',
+  '$between',
+  '$startsWith',
+  '$endsWith',
+  '$contains',
+  '$notContains',
+  '$containsi',
+  '$notContainsi',
+];
+
+const ARRAY_OPERATORS = ['$in', '$notIn', '$between'];
+
+const isOperator = key => OPERATORS.includes(key);
+
+/**
+ * Process where parameter
+ * @param {Object} where
+ * @param {Object} ctx
+ * @param {number} depth
+ * @returns {Object}
+ */
+const processWhere = (where, ctx, depth = 0) => {
+  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) => {
+    if (!_.isPlainObject(where)) {
+      return where;
+    }
+
+    return processWhere(where, ctx, depth + 1);
+  };
+
+  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 = meta.attributes[key];
+
+    // if operator $and $or then loop over them
+    if (GROUP_OPERATORS.includes(key)) {
+      filters[key] = value.map(sub => processNested(sub, ctx));
+      continue;
+    }
+
+    if (key === '$not') {
+      filters[key] = processNested(value, ctx);
+      continue;
+    }
+
+    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;
+    }
+
+    if (!attribute) {
+      filters[qb.aliasColumn(key, alias)] = processNested(value, ctx);
+
+      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)
+
+      // attribute
+      const subAlias = createJoin(ctx, {
+        alias: alias || qb.alias,
+        uid,
+        attributeName: key,
+        attribute,
+      });
+
+      let nestedWhere = processNested(value, {
+        db,
+        qb,
+        alias: subAlias,
+        uid: attribute.target,
+      });
+
+      if (!_.isPlainObject(nestedWhere) || isOperator(_.keys(nestedWhere)[0])) {
+        nestedWhere = { [qb.aliasColumn('id', subAlias)]: nestedWhere };
+      }
+
+      // TODO: use a better merge logic (push to $and when collisions)
+      Object.assign(filters, nestedWhere);
+
+      continue;
+    }
+
+    if (types.isScalar(attribute.type)) {
+      const columnName = toColumnName(meta, key);
+
+      // TODO: cast to DB type
+      filters[qb.aliasColumn(columnName, alias)] = processNested(value, ctx);
+      continue;
+    }
+
+    throw new Error(`You cannot filter on ${attribute.type} types`);
+  }
+
+  return filters;
+};
+
+const applyOperator = (qb, column, operator, value) => {
+  if (Array.isArray(value) && !ARRAY_OPERATORS.includes(operator)) {
+    return qb.where(subQB => {
+      value.forEach(subValue =>
+        subQB.orWhere(innerQB => {
+          applyOperator(innerQB, column, operator, subValue);
+        })
+      );
+    });
+  }
+
+  switch (operator) {
+    case '$not': {
+      qb.whereNot(qb => applyWhereToColumn(qb, column, value));
+      break;
+    }
+
+    case '$in': {
+      qb.whereIn(column, _.castArray(value));
+      break;
+    }
+
+    case '$notIn': {
+      qb.whereNotIn(column, _.castArray(value));
+      break;
+    }
+
+    case '$eq': {
+      if (value === null) {
+        qb.whereNull(column);
+        break;
+      }
+
+      qb.where(column, value);
+      break;
+    }
+    case '$ne': {
+      if (value === null) {
+        qb.whereNotNull(column);
+        break;
+      }
+
+      qb.where(column, '<>', value);
+      break;
+    }
+    case '$gt': {
+      qb.where(column, '>', value);
+      break;
+    }
+    case '$gte': {
+      qb.where(column, '>=', value);
+      break;
+    }
+    case '$lt': {
+      qb.where(column, '<', value);
+      break;
+    }
+    case '$lte': {
+      qb.where(column, '<=', value);
+      break;
+    }
+    case '$null': {
+      // TODO: make this better
+      if (value) {
+        qb.whereNull(column);
+      }
+      break;
+    }
+    case '$notNull': {
+      if (value) {
+        qb.whereNotNull(column);
+      }
+
+      break;
+    }
+    case '$between': {
+      qb.whereBetween(column, value);
+      break;
+    }
+
+    // TODO: add casting logic
+    case '$startsWith': {
+      qb.where(column, 'like', `${value}%`);
+      break;
+    }
+    case '$endsWith': {
+      qb.where(column, 'like', `%${value}`);
+      break;
+    }
+    case '$contains': {
+      qb.where(column, 'like', `%${value}%`);
+      break;
+    }
+
+    case '$notContains': {
+      qb.whereNot(column, 'like', `%${value}%`);
+      break;
+    }
+
+    case '$containsi': {
+      qb.whereRaw(`${fieldLowerFn(qb)} LIKE LOWER(?)`, [column, `%${value}%`]);
+      break;
+    }
+
+    case '$notContainsi': {
+      qb.whereRaw(`${fieldLowerFn(qb)} NOT LIKE LOWER(?)`, [column, `%${value}%`]);
+      break;
+    }
+
+    // TODO: json operators
+
+    // TODO: relational operators every/some/exists/size ...
+
+    default: {
+      throw new Error(`Undefined operator ${operator}`);
+    }
+  }
+};
+
+const applyWhereToColumn = (qb, column, columnWhere) => {
+  if (!_.isPlainObject(columnWhere)) {
+    if (Array.isArray(columnWhere)) {
+      return qb.whereIn(column, columnWhere);
+    }
+
+    return qb.where(column, columnWhere);
+  }
+
+  // TODO: handle casing
+  Object.keys(columnWhere).forEach(operator => {
+    const value = columnWhere[operator];
+
+    applyOperator(qb, column, operator, value);
+  });
+};
+
+const applyWhere = (qb, where) => {
+  if (!_.isArray(where) && !_.isPlainObject(where)) {
+    throw new Error('Where must be an array or an object');
+  }
+
+  if (_.isArray(where)) {
+    return qb.where(subQB => where.forEach(subWhere => applyWhere(subQB, subWhere)));
+  }
+
+  Object.keys(where).forEach(key => {
+    const value = where[key];
+
+    if (key === '$and') {
+      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)));
+      });
+    }
+
+    if (key === '$not') {
+      return qb.whereNot(qb => applyWhere(qb, value));
+    }
+
+    applyWhereToColumn(qb, key, value);
+  });
+};
+
+const fieldLowerFn = qb => {
+  // Postgres requires string to be passed
+  if (qb.client.config.client === 'postgres') {
+    return 'LOWER(CAST(?? AS VARCHAR))';
+  }
+
+  return 'LOWER(??)';
+};
+
+module.exports = {
+  applyWhere,
+  processWhere,
+};

package/lib/query/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const createQueryBuilder = require('./query-builder');
+
+module.exports = {
+  createQueryBuilder,
+};