@strapi/database 4.6.0-alpha.0 → 4.6.0-beta.0

package/lib/entity-manager/__tests__/relations-orderer.test.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const relationsOrderer = require('../relations-orderer');
+
+describe('relations orderer', () => {
+  test('connect at the end', () => {
+    const orderer = relationsOrderer(
+      [
+        { id: 2, order: 4 },
+        { id: 3, order: 10 },
+      ],
+      'id',
+      'order'
+    );
+
+    orderer.connect([{ id: 4, position: { end: true } }, { id: 5 }]);
+
+    expect(orderer.get()).toMatchObject([
+      { id: 2, order: 4 },
+      { id: 3, order: 10 },
+      { id: 4, order: 10.5 },
+      { id: 5, order: 10.5 },
+    ]);
+  });
+
+  test('connect at the start', () => {
+    const orderer = relationsOrderer(
+      [
+        { id: 2, order: 4 },
+        { id: 3, order: 10 },
+      ],
+      'id',
+      'order'
+    );
+
+    orderer.connect([{ id: 4, position: { start: true } }]);
+
+    expect(orderer.get()).toMatchObject([
+      { id: 4, order: 0.5 },
+      { id: 2, order: 4 },
+      { id: 3, order: 10 },
+    ]);
+  });
+
+  test('connect multiple relations', () => {
+    const orderer = relationsOrderer(
+      [
+        { id: 2, order: 4 },
+        { id: 3, order: 10 },
+      ],
+      'id',
+      'order'
+    );
+
+    orderer.connect([
+      { id: 4, position: { before: 2 } },
+      { id: 4, position: { before: 3 } },
+      { id: 5, position: { before: 4 } },
+    ]);
+
+    expect(orderer.get()).toMatchObject([
+      { id: 2, order: 4 },
+      { id: 5, order: 9.5 },
+      { id: 4, order: 9.5 },
+      { id: 3, order: 10 },
+    ]);
+  });
+
+  test('connect with no initial relations', () => {
+    const orderer = relationsOrderer([], 'id', 'order');
+
+    orderer.connect([
+      { id: 1, position: { start: true } },
+      { id: 2, position: { start: true } },
+      { id: 3, position: { after: 1 } },
+      { id: 1, position: { after: 2 } },
+    ]);
+
+    expect(orderer.get()).toMatchObject([
+      { id: 2, order: 0.5 },
+      { id: 1, order: 0.5 },
+      { id: 3, order: 0.5 },
+    ]);
+  });
+});

package/lib/entity-manager/index.js

@@ -3,6 +3,7 @@
 const {
   isUndefined,
   castArray,
+  compact,
   isNil,
   has,
   isString,
@@ -18,6 +19,7 @@ const {
   isNumber,
   map,
   difference,
+  uniqBy,
 } = require('lodash/fp');
 const types = require('../types');
 const { createField } = require('../fields');
@@ -37,6 +39,7 @@ const {
   deleteRelations,
   cleanOrderColumns,
 } = require('./regular-relations');
+const relationsOrderer = require('./relations-orderer');
 
 const toId = (value) => value.id || value;
 const toIds = (value) => castArray(value || []).map(toId);
@@ -75,7 +78,10 @@ const toAssocs = (data) => {
   }
 
   return {
-    connect: toIdArray(data?.connect),
+    connect: toIdArray(data?.connect).map((elm) => ({
+      id: elm.id,
+      position: elm.position ? elm.position : { end: true },
+    })),
     disconnect: toIdArray(data?.disconnect),
   };
 };
@@ -211,22 +217,19 @@ const createEntityManager = (db) => {
       }
 
       const dataToInsert = processData(metadata, data, { withDefaults: true });
-      let id;
 
-      const trx = await strapi.db.transaction();
-      try {
-        const res = await this.createQueryBuilder(uid)
-          .insert(dataToInsert)
-          .transacting(trx)
-          .execute();
+      const res = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
 
-        id = res[0].id || res[0];
+      const id = res[0].id || res[0];
 
+      const trx = await strapi.db.transaction();
+      try {
         await this.attachRelations(uid, id, data, { transaction: trx });
 
         await trx.commit();
       } catch (e) {
         await trx.rollback();
+        await this.createQueryBuilder(uid).where({ id }).delete().execute();
         throw e;
       }
 
@@ -285,7 +288,11 @@ const createEntityManager = (db) => {
         throw new Error('Update requires a where parameter');
       }
 
-      const entity = await this.createQueryBuilder(uid).select('id').where(where).first().execute();
+      const entity = await this.createQueryBuilder(uid)
+        .select('*')
+        .where(where)
+        .first()
+        .execute({ mapResults: false });
 
       if (!entity) {
         return null;
@@ -293,23 +300,19 @@ const createEntityManager = (db) => {
 
       const { id } = entity;
 
-      const trx = await strapi.db.transaction();
-      try {
-        const dataToUpdate = processData(metadata, data);
+      const dataToUpdate = processData(metadata, data);
 
-        if (!isEmpty(dataToUpdate)) {
-          await this.createQueryBuilder(uid)
-            .where({ id })
-            .update(dataToUpdate)
-            .transacting(trx)
-            .execute();
-        }
+      if (!isEmpty(dataToUpdate)) {
+        await this.createQueryBuilder(uid).where({ id }).update(dataToUpdate).execute();
+      }
 
+      const trx = await strapi.db.transaction();
+      try {
         await this.updateRelations(uid, id, data, { transaction: trx });
-
         await trx.commit();
       } catch (e) {
         await trx.rollback();
+        await this.createQueryBuilder(uid).where({ id }).update(entity).execute();
         throw e;
       }
 
@@ -372,10 +375,10 @@ const createEntityManager = (db) => {
 
       const { id } = entity;
 
+      await this.createQueryBuilder(uid).where({ id }).delete().execute();
+
       const trx = await strapi.db.transaction();
       try {
-        await this.createQueryBuilder(uid).where({ id }).delete().transacting(trx).execute();
-
         await this.deleteRelations(uid, id, { transaction: trx });
 
         await trx.commit();
@@ -564,7 +567,7 @@ const createEntityManager = (db) => {
           }
 
           // prepare new relations to insert
-          const insert = relsToAdd.map((data) => {
+          const insert = uniqBy('id', relsToAdd).map((data) => {
             return {
               [joinColumn.name]: id,
               [inverseJoinColumn.name]: data.id,
@@ -574,11 +577,23 @@ const createEntityManager = (db) => {
           });
 
           // add order value
-          if (hasOrderColumn(attribute)) {
-            insert.forEach((rel, idx) => {
-              rel[orderColumnName] = idx + 1;
+          if (cleanRelationData.set && hasOrderColumn(attribute)) {
+            insert.forEach((data, idx) => {
+              data[orderColumnName] = idx + 1;
+            });
+          } else if (cleanRelationData.connect && hasOrderColumn(attribute)) {
+            // use position attributes to calculate order
+            const orderMap = relationsOrderer([], inverseJoinColumn.name, joinTable.orderColumnName)
+              .connect(relsToAdd)
+              .get()
+              // set the order based on the order of the ids
+              .reduce((acc, rel, idx) => ({ ...acc, [rel.id]: idx }), {});
+
+            insert.forEach((row) => {
+              row[orderColumnName] = orderMap[row[inverseJoinColumn.name]];
             });
           }
+
           // add inv_order value
           if (hasInverseOrderColumn(attribute)) {
             const maxResults = await db
@@ -818,27 +833,53 @@ const createEntityManager = (db) => {
               }
 
               // prepare relations to insert
-              const insert = cleanRelationData.connect.map((relToAdd) => ({
+              const insert = uniqBy('id', cleanRelationData.connect).map((relToAdd) => ({
                 [joinColumn.name]: id,
                 [inverseJoinColumn.name]: relToAdd.id,
                 ...(joinTable.on || {}),
                 ...(relToAdd.__pivot || {}),
               }));
 
-              // add order value
               if (hasOrderColumn(attribute)) {
-                const orderMax = (
-                  await this.createQueryBuilder(joinTable.name)
-                    .max(orderColumnName)
-                    .where({ [joinColumn.name]: id })
-                    .where(joinTable.on || {})
-                    .first()
-                    .transacting(trx)
-                    .execute()
-                ).max;
+                // Get all adjacent relations and the one with the highest order
+                const adjacentRelations = await this.createQueryBuilder(joinTable.name)
+                  .where({
+                    $or: [
+                      {
+                        [joinColumn.name]: id,
+                        [inverseJoinColumn.name]: {
+                          $in: compact(
+                            cleanRelationData.connect.map(
+                              (r) => r.position?.after || r.position?.before
+                            )
+                          ),
+                        },
+                      },
+                      {
+                        [joinColumn.name]: id,
+                        [orderColumnName]: this.createQueryBuilder(joinTable.name)
+                          .max(orderColumnName)
+                          .where({ [joinColumn.name]: id })
+                          .where(joinTable.on || {})
+                          .transacting(trx)
+                          .getKnexQuery(),
+                      },
+                    ],
+                  })
+                  .where(joinTable.on || {})
+                  .transacting(trx)
+                  .execute();
 
-                insert.forEach((row, idx) => {
-                  row[orderColumnName] = orderMax + idx + 1;
+                const orderMap = relationsOrderer(
+                  adjacentRelations,
+                  inverseJoinColumn.name,
+                  joinTable.orderColumnName
+                )
+                  .connect(cleanRelationData.connect)
+                  .getOrderMap();
+
+                insert.forEach((row) => {
+                  row[orderColumnName] = orderMap[row[inverseJoinColumn.name]];
                 });
               }
 
@@ -904,7 +945,7 @@ const createEntityManager = (db) => {
                 continue;
               }
 
-              const insert = cleanRelationData.set.map((relToAdd) => ({
+              const insert = uniqBy('id', cleanRelationData.set).map((relToAdd) => ({
                 [joinColumn.name]: id,
                 [inverseJoinColumn.name]: relToAdd.id,
                 ...(joinTable.on || {}),

package/lib/entity-manager/regular-relations.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { map, isEmpty } = require('lodash/fp');
+const { randomBytes } = require('crypto');
 
 const {
   isBidirectional,
@@ -292,14 +293,15 @@ const cleanOrderColumnsForOldDatabases = async ({
   const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
 
   const now = new Date().valueOf();
+  const randomHex = randomBytes(16).toString('hex');
 
   if (hasOrderColumn(attribute) && id) {
-    const tempOrderTableName = `tempOrderTableName_${now}`;
+    const tempOrderTableName = `orderTable_${now}_${randomHex}`;
     try {
       await db.connection
         .raw(
           `
-          CREATE TEMPORARY TABLE :tempOrderTableName:
+          CREATE TABLE :tempOrderTableName:
             SELECT
               id,
               (
@@ -326,14 +328,12 @@ const cleanOrderColumnsForOldDatabases = async ({
         )
         .transacting(trx);
     } finally {
-      await db.connection
-        .raw(`DROP TEMPORARY TABLE IF EXISTS ??`, [tempOrderTableName])
-        .transacting(trx);
+      await db.connection.raw(`DROP TABLE IF EXISTS ??`, [tempOrderTableName]).transacting(trx);
     }
   }
 
   if (hasInverseOrderColumn(attribute) && !isEmpty(inverseRelIds)) {
-    const tempInvOrderTableName = `tempInvOrderTableName_${now}`;
+    const tempInvOrderTableName = `invOrderTable_${now}_${randomHex}`;
     try {
       await db.connection
         .raw(

package/lib/entity-manager/relations-orderer.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const _ = require('lodash/fp');
+
+/**
+ * Responsible for calculating the relations order when connecting them.
+ *
+ * The connect method takes an array of relations with positional attributes:
+ * - before: the id of the relation to connect before
+ * - after: the id of the relation to connect after
+ * - end: it should be at the end
+ * - start: it should be at the start
+ *
+ * Example:
+ *  - Having a connect array like:
+ *      [ { id: 4, before: 2 }, { id: 4, before: 3}, {id: 5, before: 4} ]
+ * - With the initial relations:
+ *      [ { id: 2, order: 4 }, { id: 3, order: 10 } ]
+ * - Step by step, going through the connect array, the array of relations would be:
+ *      [ { id: 4, order: 3.5 }, { id: 2, order: 4 }, { id: 3, order: 10 } ]
+ *      [ { id: 2, order: 4 }, { id: 4, order: 3.5 }, { id: 3, order: 10 } ]
+ *      [ { id: 2, order: 4 }, { id: 5, order: 3.5 },  { id: 4, order: 3.5 }, { id: 3, order: 10 } ]
+ * - The final step would be to recalculate fractional order values.
+ *      [ { id: 2, order: 4 }, { id: 5, order: 3.33 },  { id: 4, order: 3.66 }, { id: 3, order: 10 } ]
+ *
+ * Constraints:
+ * - Expects you will never connect a relation before / after one that does not exist
+ * - Expect initArr to have all relations referenced in the positional attributes
+ *
+ * @param {Array<*>} initArr - array of relations to initialize the class with
+ * @param {string} idColumn - the column name of the id
+ * @param {string} orderColumn - the column name of the order
+ * @return {*}
+ */
+const relationsOrderer = (initArr, idColumn, orderColumn) => {
+  const arr = _.castArray(initArr || []).map((r) => ({
+    init: true,
+    id: r[idColumn],
+    order: r[orderColumn],
+  }));
+
+  const maxOrder = _.maxBy('order', arr)?.order || 0;
+
+  // TODO: Improve performance by using a map
+  const findRelation = (id) => {
+    const idx = arr.findIndex((r) => r.id === id);
+    return { idx, relation: arr[idx] };
+  };
+
+  const removeRelation = (r) => {
+    const { idx } = findRelation(r.id);
+    if (idx >= 0) {
+      arr.splice(idx, 1);
+    }
+  };
+
+  const insertRelation = (r) => {
+    let idx;
+
+    if (r.position?.before) {
+      const { idx: _idx, relation } = findRelation(r.position.before);
+      if (relation.init) r.order = relation.order - 0.5;
+      else r.order = relation.order;
+      idx = _idx;
+    } else if (r.position?.after) {
+      const { idx: _idx, relation } = findRelation(r.position.after);
+      if (relation.init) r.order = relation.order + 0.5;
+      else r.order = relation.order;
+      idx = _idx + 1;
+    } else if (r.position?.start) {
+      r.order = 0.5;
+      idx = 0;
+    } else {
+      r.order = maxOrder + 0.5;
+      idx = arr.length;
+    }
+
+    // Insert the relation in the array
+    arr.splice(idx, 0, r);
+  };
+
+  return {
+    disconnect(relations) {
+      _.castArray(relations).forEach((relation) => {
+        removeRelation(relation);
+      });
+      return this;
+    },
+    connect(relations) {
+      _.castArray(relations).forEach((relation) => {
+        this.disconnect(relation);
+
+        try {
+          insertRelation(relation);
+        } catch (err) {
+          strapi.log.error(err);
+          throw new Error(
+            `Could not connect ${relation.id}, position ${JSON.stringify(
+              relation.position
+            )} is invalid`
+          );
+        }
+      });
+      return this;
+    },
+    get() {
+      return arr;
+    },
+    /**
+     * Get a map between the relation id and its order
+     */
+    getOrderMap() {
+      return _(arr)
+        .groupBy('order')
+        .reduce((acc, relations) => {
+          if (relations[0]?.init) return acc;
+          relations.forEach((relation, idx) => {
+            acc[relation.id] = Math.floor(relation.order) + (idx + 1) / (relations.length + 1);
+          });
+          return acc;
+        }, {});
+    },
+  };
+};
+
+module.exports = relationsOrderer;

package/lib/index.d.ts

@@ -31,7 +31,8 @@ type AttributeOperators<T, K extends keyof T> = {
 
 export type WhereParams<T> = {
   [K in keyof T]?: T[K] | T[K][] | AttributeOperators<T, K>;
-} & LogicalOperators<T>;
+} &
+  LogicalOperators<T>;
 
 type Sortables<T> = {
   // check sortable
@@ -157,7 +158,6 @@ export interface Database {
   lifecycles: LifecycleProvider;
   migrations: MigrationProvider;
   entityManager: EntityManager;
-  queryBuilder: any;
 
   query<T extends keyof AllTypes>(uid: T): QueryFromContentType<T>;
 }

package/lib/metadata/index.js

@@ -136,7 +136,7 @@ const createCompoLinkModelMeta = (baseModelMeta) => {
         type: 'string',
       },
       order: {
-        type: 'integer',
+        type: 'float',
         column: {
           unsigned: true,
           defaultTo: null,

package/lib/metadata/relations.js

@@ -231,7 +231,7 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
         type: 'string',
       },
       order: {
-        type: 'integer',
+        type: 'float',
         column: {
           unsigned: true,
         },
@@ -411,7 +411,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   let inverseOrderColumnName = _.snakeCase(`${meta.singularName}_order`);
 
   // if relation is self referencing
-  if (attribute.relation === 'manyToMany' && joinColumnName === inverseJoinColumnName) {
+  if (attribute.relation === 'manyToMany' && orderColumnName === inverseOrderColumnName) {
     inverseOrderColumnName = `inv_${inverseOrderColumnName}`;
   }
 
@@ -485,7 +485,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   // order
   if (isAnyToMany(attribute)) {
     metadataSchema.attributes[orderColumnName] = {
-      type: 'integer',
+      type: 'float',
       column: {
         unsigned: true,
         defaultTo: null,
@@ -502,7 +502,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   // inv order
   if (isBidirectional(attribute) && isManyToAny(attribute)) {
     metadataSchema.attributes[inverseOrderColumnName] = {
-      type: 'integer',
+      type: 'float',
       column: {
         unsigned: true,
         defaultTo: null,

package/lib/query/helpers/index.js

@@ -7,5 +7,4 @@ module.exports = {
   ...require('./populate'),
   ...require('./where'),
   ...require('./transform'),
-  ...require('./streams'),
 };

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

@@ -446,6 +446,11 @@ const morphToMany = async (input, ctx) => {
     .where({
       [joinColumn.name]: referencedValues,
       ...(joinTable.on || {}),
+      // If the populateValue contains an "on" property,
+      // only populate the types defined in it
+      ...('on' in populateValue
+        ? { [morphColumn.typeColumn.name]: Object.keys(populateValue.on) }
+        : {}),
     })
     .orderBy([joinColumn.name, 'order'])
     .execute({ mapResults: false });
@@ -470,6 +475,8 @@ const morphToMany = async (input, ctx) => {
   }, {});
 
   const map = {};
+  const { on, ...typePopulate } = populateValue;
+
   for (const type of Object.keys(idsByType)) {
     const ids = idsByType[type];
 
@@ -483,7 +490,7 @@ const morphToMany = async (input, ctx) => {
     const qb = db.entityManager.createQueryBuilder(type);
 
     const rows = await qb
-      .init(populateValue)
+      .init(on?.[type] ?? typePopulate)
       .addSelect(`${qb.alias}.${idColumn.referencedColumn}`)
       .where({ [idColumn.referencedColumn]: ids })
       .execute({ mapResults: false });
@@ -540,6 +547,8 @@ const morphToOne = async (input, ctx) => {
   }, {});
 
   const map = {};
+  const { on, ...typePopulate } = populateValue;
+
   for (const type of Object.keys(idsByType)) {
     const ids = idsByType[type];
 
@@ -552,7 +561,7 @@ const morphToOne = async (input, ctx) => {
     const qb = db.entityManager.createQueryBuilder(type);
 
     const rows = await qb
-      .init(populateValue)
+      .init(on?.[type] ?? typePopulate)
       .addSelect(`${qb.alias}.${idColumn.referencedColumn}`)
       .where({ [idColumn.referencedColumn]: ids })
       .execute({ mapResults: false });
@@ -579,7 +588,16 @@ const morphToOne = async (input, ctx) => {
 
 //  TODO: Omit limit & offset to avoid needing a query per result to avoid making too many queries
 const pickPopulateParams = (populate) => {
-  const fieldsToPick = ['select', 'count', 'where', 'populate', 'orderBy', 'filters', 'ordering'];
+  const fieldsToPick = [
+    'select',
+    'count',
+    'where',
+    'populate',
+    'orderBy',
+    'filters',
+    'ordering',
+    'on',
+  ];
 
   if (populate.count !== true) {
     fieldsToPick.push('limit', 'offset');

package/lib/query/helpers/where.js

@@ -53,7 +53,7 @@ const castValue = (value, attribute) => {
     return value;
   }
 
-  if (types.isScalar(attribute.type)) {
+  if (types.isScalar(attribute.type) && !isKnexQuery(value)) {
     const field = createField(attribute);
 
     return value === null ? null : field.toDB(value);

package/lib/query/query-builder.js

@@ -2,7 +2,6 @@
 
 const _ = require('lodash/fp');
 
-const { DatabaseError } = require('../errors');
 const helpers = require('./helpers');
 
 const createQueryBuilder = (uid, db, initialState = {}) => {
@@ -489,16 +488,6 @@ const createQueryBuilder = (uid, db, initialState = {}) => {
         db.dialect.transformErrors(error);
       }
     },
-
-    stream({ mapResults = true } = {}) {
-      if (state.type === 'select') {
-        return new helpers.ReadableQuery({ qb: this, db, uid, mapResults });
-      }
-
-      throw new DatabaseError(
-        `query-builder.stream() has been called with an unsupported query type: "${state.type}"`
-      );
-    },
   };
 };
 

package/lib/schema/index.d.ts

@@ -46,4 +46,4 @@ export interface SchemaProvider {
   drop(): Promise<void>;
 }
 
-export default function (db: Database): SchemaProvider;
+export default function(db: Database): SchemaProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.6.0-alpha.0",
+  "version": "4.6.0-beta.0",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "date-fns": "2.29.2",
-    "debug": "4.3.1",
+    "debug": "4.3.4",
     "fs-extra": "10.0.0",
     "knex": "1.0.7",
     "lodash": "4.17.21",
@@ -43,5 +43,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "b7a87dcffc6f44e18eedef92e354096ffe32ce0c"
+  "gitHead": "c0c3365ad801d088a6ab6c4eb95a014078429747"
 }

package/lib/query/helpers/streams/index.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = {
-  ReadableQuery: require('./readable'),
-};

package/lib/query/helpers/streams/readable.js

@@ -1,174 +0,0 @@
-'use strict';
-
-const { Readable } = require('stream');
-const { isFinite } = require('lodash/fp');
-
-const { applyPopulate } = require('../populate');
-const { fromRow } = require('../transform');
-
-const knexQueryDone = Symbol('knexQueryDone');
-const knexPerformingQuery = Symbol('knexPerformingQuery');
-
-class ReadableStrapiQuery extends Readable {
-  /**
-   * @param {object} options
-   * @param {ReturnType<typeof import('../../query-builder')>} options.qb The strapi query builder instance
-   * @param {string} options.uid The model uid
-   * @param {import('../../../index').Database} options.db The Database instance
-   * @param {boolean} [options.mapResults] The maximum number of entities to fetch per query
-   * @param {number} [options.batchSize] The maximum number of entities to fetch per query
-   */
-  constructor({ qb, db, uid, mapResults = true, batchSize = 500 }) {
-    super({ objectMode: true, highWaterMark: batchSize });
-
-    // Extract offset & limit from the query-builder's state
-    const { offset, limit } = qb.state;
-
-    // Original offset value
-    this._offset = isFinite(offset) ? offset : 0;
-
-    // Max amount of entities to fetch, force null as undefined value
-    this._limit = isFinite(limit) ? limit : null;
-
-    // Total amount of entities fetched
-    this._fetched = 0;
-
-    /**
-     * Original query
-     * @type {import('knex').Knex}
-     */
-    this._query = qb.getKnexQuery();
-
-    // Query Builder instance
-    this._qb = qb;
-
-    // Database related properties
-    this._db = db;
-    this._uid = uid;
-    this._meta = db.metadata.get(uid);
-
-    // Stream params
-    this._batchSize = batchSize;
-    this._mapResults = mapResults;
-
-    // States
-    this[knexPerformingQuery] = false;
-  }
-
-  _destroy(err, cb) {
-    // If the stream is destroyed while a query is being made, then wait for a
-    // kQueryDone event to be emitted before actually destroying the stream
-    if (this[knexPerformingQuery]) {
-      this.once(knexQueryDone, (er) => cb(err || er));
-    } else {
-      cb(err);
-    }
-  }
-
-  /**
-   * Custom ._read() implementation
-   *
-   *  NOTE: Here "size" means the number of entities to be read from the database.
-   *  Not the actual byte size, as it would means that we need to return partial entities.
-   *
-   * @param {number} size
-   */
-  async _read(size) {
-    const query = this._query;
-
-    // Remove the original offset & limit properties from the query
-    // Theoretically, they would be replaced by calling them again, but this is just to be sure
-    query.clear('limit').clear('offset');
-
-    // Define the maximum read size based on the limit and the requested size
-    // NOTE: size is equal to _batchSize by default. Since we want to allow customizing it on
-    // the fly, we need to use its value instead of batchSize when computing the maxReadSize value
-    const maxReadSize =
-      // if no limit is defined in the query, use the given size,
-      // otherwise, use the smallest value between the two
-      this._limit === null ? size : Math.min(size, this._limit);
-
-    // Compute the limit for the next query
-    const limit =
-      // If a limit is defined
-      this._limit !== null &&
-      // And reading `maxReadSize` would fetch too many entities (> _limit)
-      this._fetched + maxReadSize > this._limit
-        ? // Then adjust the limit so that it only get the remaining entities
-          this._limit - this._fetched
-        : // Else, use the max read size
-          maxReadSize;
-
-    // If we don't have anything left to read (_limit === _fetched),
-    // don't bother making the query and end the stream by pushing null
-    if (limit <= 0) {
-      this.push(null);
-      return;
-    }
-
-    // Compute the offset (base offset + number of entities already fetched)
-    const offset = this._offset + this._fetched;
-
-    // Update the query with the new values (offset + limit)
-    query.offset(offset).limit(limit);
-
-    // Lock the ._destroy()
-    this[knexPerformingQuery] = true;
-
-    let results;
-    let count;
-    let err;
-
-    try {
-      // Execute the query and store the results & count
-      results = await query;
-
-      const { populate } = this._qb.state;
-
-      // Apply populate if needed
-      if (populate) {
-        await applyPopulate(results, populate, { qb: this._qb, uid: this._uid, db: this._db });
-      }
-
-      // Map results if asked to
-      if (this._mapResults) {
-        results = fromRow(this._meta, results);
-      }
-
-      count = results.length;
-    } catch (e) {
-      err = e;
-    }
-
-    // Unlock the ._destroy()
-    this[knexPerformingQuery] = false;
-
-    // Tell ._destroy() that it's now safe to close the db connection
-    if (this.destroyed) {
-      this.emit(knexQueryDone);
-      return;
-    }
-
-    // If there is an error, destroy with the given error
-    if (err) {
-      this.destroy(err);
-      return;
-    }
-
-    // Update the amount of fetched entities
-    this._fetched += count;
-
-    // While there is at least one value to unpack
-    for (const result of results) {
-      this.push(result);
-    }
-
-    // If the amount of fetched entities is smaller than the
-    // maximum read size, Then push null to close the stream
-    if (this._fetched === this._limit || count < this._batchSize) {
-      this.push(null);
-    }
-  }
-}
-
-module.exports = ReadableStrapiQuery;