@strapi/database 4.14.4 → 4.14.6

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

@@ -1,102 +0,0 @@
-'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 to query the join column value if needed,
-    // so that we can apply the populate later on
-    if (attribute.joinColumn) {
-      qb.addSelect(attribute.joinColumn.name);
-    }
-
-    // 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/search.js

@@ -1,84 +0,0 @@
-'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/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;

package/lib/query/helpers/transform.js

@@ -1,84 +0,0 @@
-'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 of Object.keys(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,
-};