@strapi/database 4.4.3 → 4.5.0-beta.0

package/lib/query/helpers/populate/process.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const _ = require('lodash/fp');
+
+const types = require('../../../types');
+
+const getRootLevelPopulate = (meta) => {
+  const populate = {};
+
+  for (const attributeName of Object.keys(meta.attributes)) {
+    const attribute = meta.attributes[attributeName];
+    if (attribute.type === 'relation') {
+      populate[attributeName] = true;
+    }
+  }
+
+  return populate;
+};
+
+/**
+ * Converts and prepares the query for populate
+ *
+ * @param {boolean|string[]|object} populate populate param
+ * @param {object} ctx query context
+ * @param {object} ctx.db database instance
+ * @param {object} ctx.qb query builder instance
+ * @param {string} ctx.uid model uid
+ */
+const processPopulate = (populate, ctx) => {
+  const { qb, db, uid } = ctx;
+  const meta = db.metadata.get(uid);
+
+  let populateMap = {};
+
+  if (populate === false || _.isNil(populate)) {
+    return null;
+  }
+
+  if (populate === true) {
+    populateMap = getRootLevelPopulate(meta);
+  } else if (Array.isArray(populate)) {
+    for (const key of populate) {
+      const [root, ...rest] = key.split('.');
+
+      if (rest.length > 0) {
+        const subPopulate = rest.join('.');
+
+        if (populateMap[root]) {
+          if (populateMap[root] === true) {
+            populateMap[root] = {
+              populate: [subPopulate],
+            };
+          } else {
+            populateMap[root].populate = [subPopulate].concat(populateMap[root].populate || []);
+          }
+        } else {
+          populateMap[root] = {
+            populate: [subPopulate],
+          };
+        }
+      } else {
+        populateMap[root] = populateMap[root] ? populateMap[root] : true;
+      }
+    }
+  } else {
+    populateMap = populate;
+  }
+
+  if (!_.isPlainObject(populateMap)) {
+    throw new Error('Populate must be an object');
+  }
+
+  const finalPopulate = {};
+  for (const key of Object.keys(populateMap)) {
+    const attribute = meta.attributes[key];
+
+    if (!attribute) {
+      continue;
+    }
+
+    if (!types.isRelation(attribute.type)) {
+      continue;
+    }
+
+    // make sure id is present for future populate queries
+    if (_.has('id', meta.attributes)) {
+      qb.addSelect('id');
+    }
+
+    finalPopulate[key] = populateMap[key];
+  }
+
+  return finalPopulate;
+};
+
+module.exports = processPopulate;

package/lib/query/helpers/where.js

@@ -6,6 +6,7 @@ const types = require('../../types');
 const { createField } = require('../../fields');
 const { createJoin } = require('./join');
 const { toColumnName } = require('./transform');
+const { isKnexQuery } = require('../../utils/knex');
 
 const GROUP_OPERATORS = ['$and', '$or'];
 const OPERATORS = [
@@ -206,12 +207,12 @@ const applyOperator = (qb, column, operator, value) => {
     }
 
     case '$in': {
-      qb.whereIn(column, _.castArray(value));
+      qb.whereIn(column, isKnexQuery(value) ? value : _.castArray(value));
       break;
     }
 
     case '$notIn': {
-      qb.whereNotIn(column, _.castArray(value));
+      qb.whereNotIn(column, isKnexQuery(value) ? value : _.castArray(value));
       break;
     }
 

package/lib/query/query-builder.js

@@ -4,33 +4,41 @@ const _ = require('lodash/fp');
 
 const helpers = require('./helpers');
 
-const createQueryBuilder = (uid, db) => {
+const createQueryBuilder = (uid, db, initialState = {}) => {
   const meta = db.metadata.get(uid);
   const { tableName } = meta;
 
-  const state = {
-    type: 'select',
-    select: [],
-    count: null,
-    max: null,
-    first: false,
-    data: null,
-    where: [],
-    joins: [],
-    populate: null,
-    limit: null,
-    offset: null,
-    transaction: null,
-    forUpdate: false,
-    orderBy: [],
-    groupBy: [],
-  };
+  const state = _.defaults(
+    {
+      type: 'select',
+      select: [],
+      count: null,
+      max: null,
+      first: false,
+      data: null,
+      where: [],
+      joins: [],
+      populate: null,
+      limit: null,
+      offset: null,
+      transaction: null,
+      forUpdate: false,
+      onConflict: null,
+      merge: null,
+      ignore: false,
+      orderBy: [],
+      groupBy: [],
+      increments: [],
+      decrements: [],
+      aliasCounter: 0,
+    },
+    initialState
+  );
 
-  let counter = 0;
   const getAlias = () => {
-    const alias = `t${counter}`;
+    const alias = `t${state.aliasCounter}`;
 
-    counter += 1;
+    state.aliasCounter += 1;
 
     return alias;
   };
@@ -40,6 +48,10 @@ const createQueryBuilder = (uid, db) => {
     getAlias,
     state,
 
+    clone() {
+      return createQueryBuilder(uid, db, state);
+    },
+
     select(args) {
       state.type = 'select';
       state.select = _.uniq(_.castArray(args));
@@ -60,6 +72,24 @@ const createQueryBuilder = (uid, db) => {
       return this;
     },
 
+    onConflict(args) {
+      state.onConflict = args;
+
+      return this;
+    },
+
+    merge(args) {
+      state.merge = args;
+
+      return this;
+    },
+
+    ignore() {
+      state.ignore = true;
+
+      return this;
+    },
+
     delete() {
       state.type = 'delete';
 
@@ -77,6 +107,20 @@ const createQueryBuilder = (uid, db) => {
       return this;
     },
 
+    increment(column, amount = 1) {
+      state.type = 'update';
+      state.increments.push({ column, amount });
+
+      return this;
+    },
+
+    decrement(column, amount = 1) {
+      state.type = 'update';
+      state.decrements.push({ column, amount });
+
+      return this;
+    },
+
     count(count = 'id') {
       state.type = 'count';
       state.count = count;
@@ -195,7 +239,24 @@ const createQueryBuilder = (uid, db) => {
     },
 
     join(join) {
-      state.joins.push(join);
+      if (!join.targetField) {
+        state.joins.push(join);
+        return this;
+      }
+
+      const model = db.metadata.get(uid);
+      const attribute = model.attributes[join.targetField];
+
+      helpers.createJoin(
+        { db, qb: this },
+        {
+          alias: this.alias,
+          refAlias: join.alias,
+          attributeName: join.targetField,
+          attribute,
+        }
+      );
+
       return this;
     },
 
@@ -325,7 +386,9 @@ const createQueryBuilder = (uid, db) => {
           break;
         }
         case 'update': {
-          qb.update(state.data);
+          if (state.data) {
+            qb.update(state.data);
+          }
           break;
         }
         case 'delete': {
@@ -350,6 +413,22 @@ const createQueryBuilder = (uid, db) => {
         qb.forUpdate();
       }
 
+      if (!_.isEmpty(state.increments)) {
+        state.increments.forEach((incr) => qb.increment(incr.column, incr.amount));
+      }
+
+      if (!_.isEmpty(state.decrements)) {
+        state.decrements.forEach((decr) => qb.decrement(decr.column, decr.amount));
+      }
+
+      if (state.onConflict) {
+        if (state.merge) {
+          qb.onConflict(state.onConflict).merge(state.merge);
+        } else if (state.ignore) {
+          qb.onConflict(state.onConflict).ignore();
+        }
+      }
+
       if (state.limit) {
         qb.limit(state.limit);
       }

package/lib/tests/knex-utils.test.e2e.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { createStrapiInstance } = require('../../../../../test/helpers/strapi');
+const { isKnexQuery } = require('../utils/knex');
+
+let strapi;
+
+describe('knex', () => {
+  beforeAll(async () => {
+    strapi = await createStrapiInstance();
+  });
+
+  afterAll(async () => {
+    await strapi.destroy();
+  });
+
+  describe('isKnexQuery', () => {
+    test('knex query: true', () => {
+      const res = isKnexQuery(strapi.db.connection('strapi_core_store_settings'));
+      expect(res).toBe(true);
+    });
+
+    test('knex raw: true', () => {
+      const res = isKnexQuery(strapi.db.connection.raw('SELECT * FROM strapi_core_store_settings'));
+      expect(res).toBe(true);
+    });
+
+    test.each([[''], [{}], [[]], [2], [new Date()]])('%s: false', (value) => {
+      const res = isKnexQuery(value);
+      expect(res).toBe(false);
+    });
+  });
+});

package/lib/utils/knex.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const KnexBuilder = require('knex/lib/query/querybuilder');
+const KnexRaw = require('knex/lib/raw');
+
+const isKnexQuery = (value) => {
+  return value instanceof KnexBuilder || value instanceof KnexRaw;
+};
+
+module.exports = {
+  isKnexQuery,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.4.3",
+  "version": "4.5.0-beta.0",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -42,5 +42,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "f99314ead7f0fdf82b921b9d8f0282a91e952ca8"
+  "gitHead": "ee98b9a9cbb6e0e07e781ff9e87eb170c72e50df"
 }