kuzzle 2.19.12 → 2.20.1

package/lib/core/shared/repository.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,469 +19,383 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-"use strict";
-
-const Bluebird = require("bluebird");
-
-const cacheDbEnum = require("../cache/cacheDbEnum");
-const kerror = require("../../kerror");
-
-/**
- * @class Repository
- * @property {Kuzzle} kuzzle
- * @property {string} index
- * @property {number} ttl
- * @property {?string} collection
- * @property {function} ObjectConstructor
- * @property {cacheDbEnum} cacheDb
- * @property {Store} store
- */
-class Repository {
-  /**
-   * @param {{cache: cacheDbEnum, store: Store}} [options]
-   * @constructor
-   */
-  constructor({ cache = cacheDbEnum.INTERNAL, store = null } = {}) {
-    this.ttl = global.kuzzle.config.repositories.common.cacheTTL;
-    this.collection = null;
-    this.ObjectConstructor = null;
-    this.store = store;
-    this.index = store ? store.index : global.kuzzle.internalIndex.index;
-    this.cacheDb = cache;
-  }
-
-  /**
-   * @param {string} id
-   * @returns {Promise} resolves on a new ObjectConstructor()
-   */
-  async loadOneFromDatabase(id) {
-    let response;
-
-    try {
-      response = await this.store.get(this.collection, id);
-    } catch (error) {
-      if (error.status === 404) {
-        throw kerror.get("services", "storage", "not_found", id);
-      }
-
-      throw error;
-    }
-
-    if (response._id) {
-      const dto = {};
-
-      if (response._source) {
-        Object.assign(dto, response._source, { _id: response._id });
-      } else {
-        Object.assign(dto, response);
-      }
-
-      return this.fromDTO(dto);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-
-    return null;
-  }
-
-  /**
-   *
-   * @param {string[]|object[]} _ids
-   * @returns {Promise<object>}
-   */
-  async loadMultiFromDatabase(ids) {
-    const { items } = await this.store.mGet(this.collection, ids);
-
-    if (items.length === 0) {
-      return [];
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = void 0;
+const cacheDbEnum_1 = __importDefault(require("../cache/cacheDbEnum"));
+const kerror = __importStar(require("../../kerror"));
+class Repository {
+    constructor({ cache = cacheDbEnum_1.default.INTERNAL, store = null } = {}) {
+        this.ttl = global.kuzzle.config.repositories.common.cacheTTL;
+        this.collection = null;
+        this.ObjectConstructor = null;
+        this.store = store;
+        this.index = store ? store.index : global.kuzzle.internalIndex.index;
+        this.cacheDb = cache;
     }
-
-    return Bluebird.map(items, (doc) =>
-      this.fromDTO(Object.assign({}, doc._source, { _id: doc._id }))
-    );
-  }
-
-  /**
-   * Search in database corresponding repository according to a query
-   *
-   * @param {object} searchBody
-   * @param {object} [options] - optional search arguments (from, size, scroll)
-   * @returns {Promise}
-   */
-  async search(searchBody, options = {}) {
-    const response = await this.store.search(
-      this.collection,
-      searchBody,
-      options
-    );
-
-    return this._formatSearchResults(response);
-  }
-
-  /**
-   * Scroll over a paginated search request
-   * @param {string} scrollId
-   * @param {string} [ttl]
-   */
-  async scroll(scrollId, ttl) {
-    const response = await this.store.scroll(scrollId, ttl);
-
-    return this._formatSearchResults(response);
-  }
-
-  /**
-   * Loads an object from Cache. Returns a promise that resolves either to the
-   * retrieved object of null in case it is not found.
-   *
-   * The opts object currently accepts one optional parameter: key, which forces
-   * the cache key to fetch.
-   * In case the key is not provided, it defaults to repos/<index>/<collection>/<id>, i.e.: repos/%kuzzle/users/12
-   *
-   * @param {string} id - The id of the object to get
-   * @param {object} [options] - Optional options.
-   * @returns {Promise}
-   */
-  async loadFromCache(id, options = {}) {
-    const key = options.key || this.getCacheKey(id);
-    let response;
-
-    try {
-      response = await global.kuzzle.ask(`core:cache:${this.cacheDb}:get`, key);
-
-      if (response === null) {
+    async loadOneFromDatabase(id) {
+        let response;
+        try {
+            response = await this.store.get(this.collection, id);
+        }
+        catch (error) {
+            if (error.status === 404) {
+                throw kerror.get("services", "storage", "not_found", id);
+            }
+            throw error;
+        }
+        if (response._id) {
+            const dto = {};
+            if (response._source) {
+                Object.assign(dto, response._source, { _id: response._id });
+            }
+            else {
+                Object.assign(dto, response);
+            }
+            return this.fromDTO(dto);
+        }
         return null;
-      }
-
-      return await this.fromDTO(Object.assign({}, JSON.parse(response)));
-    } catch (err) {
-      throw kerror.get("services", "cache", "read_failed", err.message);
     }
-  }
-
-  /**
-   * Loads an object from Cache or from the Database if not available in Cache.
-   * Returns a promise that resolves either to the
-   * retrieved object of null in case it is not found.
-   *
-   * If the object is not found in Cache and found in the Database,
-   * it will be written to cache also.
-   *
-   * The opts object currently accepts one optional parameter: key, which forces
-   * the cache key to fetch.
-   * In case the key is not provided, it defaults to <collection>/id
-   * (e.g. users/12)
-   *
-   * @param {string} id - The id of the object to get
-   * @param {object} [options] - Optional options.
-   * @returns {Promise}
-   */
-  async load(id, options = {}) {
-    if (this.cacheDb === cacheDbEnum.NONE) {
-      return this.loadOneFromDatabase(id);
+    async loadMultiFromDatabase(ids) {
+        const { items } = await this.store.mGet(this.collection, ids);
+        if (items.length === 0) {
+            return [];
+        }
+        const promises = [];
+        for (const item of items) {
+            promises.push(this.fromDTO({
+                ...item._source,
+                _id: item._id,
+            }));
+        }
+        const objects = await Promise.all(promises);
+        return objects;
     }
-
-    const object = await this.loadFromCache(id, options);
-
-    if (object === null) {
-      if (this.store === null) {
-        return null;
-      }
-
-      const objectFromDatabase = await this.loadOneFromDatabase(id);
-
-      if (objectFromDatabase !== null) {
-        await this.persistToCache(objectFromDatabase);
-      }
-
-      return objectFromDatabase;
+    /**
+     * Search in database corresponding repository according to a query
+     *
+     * @param {object} searchBody
+     * @param {object} [options] - optional search arguments (from, size, scroll)
+     * @returns {Promise}
+     */
+    async search(searchBody, options = {}) {
+        const response = await this.store.search(this.collection, searchBody, options);
+        return this.formatSearchResults(response);
     }
-
-    await this.refreshCacheTTL(object);
-
-    return object;
-  }
-
-  /**
-   * Persists the given object in the collection that is attached to the repository.
-   *
-   * @param {Profile|Role|User} object - The object to persist
-   * @param {object} [options] - The persistence options
-   * @returns {Promise}
-   */
-  persistToDatabase(object, options = {}) {
-    const method = options.method || "createOrReplace";
-
-    if (method === "create") {
-      return this.store.create(
-        this.collection,
-        this.serializeToDatabase(object),
-        { ...options, id: object._id }
-      );
+    /**
+     * Scroll over a paginated search request
+     */
+    async scroll(scrollId, ttl) {
+        const response = await this.store.scroll(scrollId, ttl);
+        return this.formatSearchResults(response);
     }
-
-    return this.store[method](
-      this.collection,
-      object._id,
-      this.serializeToDatabase(object),
-      options
-    );
-  }
-
-  /**
-   * Given an object with an id, delete it from the configured storage engines
-   *
-   * @param {object} object - The object to delete
-   * The options optional parameters currently accepts only 1 option:
-   *   key: if provided, removes the given key instead of the default one (<collection>/<id>)
-   * @param {object} [options] - optional options for the current operation
-   * @returns {Promise}
-   */
-  delete(object, options = {}) {
-    const promises = [];
-
-    if (this.cacheDb !== cacheDbEnum.NONE) {
-      promises.push(this.deleteFromCache(object._id, options));
+    /**
+     * Loads an object from Cache. Returns a promise that resolves either to the
+     * retrieved object of null in case it is not found.
+     *
+     * The opts object currently accepts one optional parameter: key, which forces
+     * the cache key to fetch.
+     * In case the key is not provided, it defaults to repos/<index>/<collection>/<id>, i.e.: repos/%kuzzle/users/12
+     *
+     * @param id - The id of the object to get
+     * @param options.key - Cache key.
+     */
+    async loadFromCache(id, options = {}) {
+        const key = options.key || this.getCacheKey(id);
+        let response;
+        try {
+            response = await global.kuzzle.ask(`core:cache:${this.cacheDb}:get`, key);
+            if (response === null) {
+                return null;
+            }
+            return await this.fromDTO(Object.assign({}, JSON.parse(response)));
+        }
+        catch (err) {
+            throw kerror.get("services", "cache", "read_failed", err.message);
+        }
     }
-
-    if (this.store) {
-      promises.push(this.deleteFromDatabase(object._id, options));
+    /**
+     * Loads an object from Cache or from the Database if not available in Cache.
+     * Returns a promise that resolves either to the
+     * retrieved object of null in case it is not found.
+     *
+     * If the object is not found in Cache and found in the Database,
+     * it will be written to cache also.
+     *
+     * The opts object currently accepts one optional parameter: key, which forces
+     * the cache key to fetch.
+     * In case the key is not provided, it defaults to <collection>/id
+     * (e.g. users/12)
+     *
+     * @param id - The id of the object to get
+     * @param options.key - Optional cache key
+     */
+    async load(id, options = {}) {
+        if (this.cacheDb === cacheDbEnum_1.default.NONE) {
+            return this.loadOneFromDatabase(id);
+        }
+        const object = await this.loadFromCache(id, options);
+        if (object === null) {
+            if (this.store === null) {
+                return null;
+            }
+            const objectFromDatabase = await this.loadOneFromDatabase(id);
+            if (objectFromDatabase !== null) {
+                await this.persistToCache(objectFromDatabase);
+            }
+            return objectFromDatabase;
+        }
+        await this.refreshCacheTTL(object);
+        return object;
     }
-
-    return Bluebird.all(promises);
-  }
-
-  /**
-   * Delete repository from database according to its id
-   *
-   * @param {string} id
-   * @param {object} [options]
-   */
-  deleteFromDatabase(id, options = {}) {
-    return this.store.delete(this.collection, id, options);
-  }
-
-  /**
-   * Persists the given ObjectConstructor object in cache.
-   * The opts optional parameters currently accept 2 options:
-   *   key: if provided, stores the object to the given key instead of the
-   *        default one (<collection>/<id>)
-   *   ttl: if provided, overrides the default ttl set on the repository for
-   *        the current operation.
-   *
-   * @param {object} object - The object to persist
-   * @param {object} [options] - Optional options for the current operation
-   * @returns {Promise}
-   */
-  async persistToCache(object, options = {}) {
-    const key = options.key || this.getCacheKey(object._id);
-    const value = JSON.stringify(this.serializeToCache(object));
-    const ttl = options.ttl !== undefined ? options.ttl : this.ttl;
-
-    await global.kuzzle.ask(`core:cache:${this.cacheDb}:store`, key, value, {
-      ttl,
-    });
-
-    return object;
-  }
-
-  /**
-   * Removes the object from the Cache Engine
-   * The opts optional parameters currently accepts only 1 option:
-   *   key: if provided, removes the given key instead of the default one (<collection>/<id>)
-   *
-   * @param {string} id
-   * @param {object} [options] - optional options for the current operation
-   * @returns {Promise}
-   */
-  deleteFromCache(id, options = {}) {
-    const key = options.key || this.getCacheKey(id);
-
-    return global.kuzzle.ask(`core:cache:${this.cacheDb}:del`, key);
-  }
-
-  /**
-   * @param {object} object
-   * @param {object} [options] - optional options for the current operation
-   * @returns {Promise}
-   */
-  refreshCacheTTL(object, options = {}) {
-    const key = options.key || this.getCacheKey(object._id);
-    let ttl;
-
-    if (options.ttl !== undefined) {
-      ttl = options.ttl;
-    } else if (object.ttl !== undefined) {
-      // if a TTL has been defined at the entry creation, we should
-      // use it
-      ttl = object.ttl;
-    } else {
-      ttl = this.ttl;
+    /**
+     * Persists the given object in the collection that is attached to the repository.
+     *
+     * @param object - The object to persist
+     * @param options.method -
+     * @returns {Promise}
+     */
+    persistToDatabase(object, options = {}) {
+        const method = options.method || "createOrReplace";
+        if (method === "create") {
+            return this.store.create(this.collection, this.serializeToDatabase(object), { ...options, id: object._id });
+        }
+        return this.store[method](this.collection, object._id, this.serializeToDatabase(object), options);
     }
-
-    if (ttl > 0) {
-      return global.kuzzle.ask(`core:cache:${this.cacheDb}:expire`, key, ttl);
+    /**
+     * Given an object with an id, delete it from the configured storage engines
+     *
+     * @param object - The object to delete
+     * @param options.key - if provided, removes the given key instead of the default one (<collection>/<id>)
+     */
+    async delete(object, options = {}) {
+        const promises = [];
+        if (this.cacheDb !== cacheDbEnum_1.default.NONE) {
+            promises.push(this.deleteFromCache(object._id, options));
+        }
+        if (this.store) {
+            promises.push(this.deleteFromDatabase(object._id, options));
+        }
+        await Promise.all(promises);
     }
-
-    return global.kuzzle.ask(`core:cache:${this.cacheDb}:persist`, key);
-  }
-
-  /**
-   * @param {object} object
-   * @param {object} [options] - optional options for the current operation
-   * @returns {*}
-   */
-  expireFromCache(object, options = {}) {
-    const key = options.key || this.getCacheKey(object._id);
-    return global.kuzzle.ask(`core:cache:${this.cacheDb}:expire`, key, -1);
-  }
-
-  /**
-   * Serializes the object before being persisted to cache.
-   *
-   * @param {object} object - The object to serialize
-   * @returns {object}
-   */
-  serializeToCache(object) {
-    return this.toDTO(object);
-  }
-
-  /**
-   * Serializes the object before being persisted to the database.
-   *
-   * @param {object} object - The object to serialize
-   * @returns {object}
-   */
-  serializeToDatabase(object) {
-    const dto = this.toDTO(object);
-    delete dto._id;
-    return dto;
-  }
-
-  /**
-   * @param {string} id
-   */
-  getCacheKey(id) {
-    return `repos/${this.index}/${this.collection}/${id}`;
-  }
-
-  /**
-   * @param {object} dto
-   * @returns {Promise<ObjectConstructor>}
-   */
-  async fromDTO(dto) {
-    const o = new this.ObjectConstructor();
-    Object.assign(o, dto);
-
-    return o;
-  }
-
-  /**
-   * @param {ObjectConstructor} o
-   * @returns {object}
-   */
-  toDTO(o) {
-    return Object.assign({}, o);
-  }
-
-  /**
-   * Recursively delete all objects in repository with a scroll
-   *
-   * @param {object} options - ES options (refresh)
-   * @param {object} part
-   * @returns {Promise<integer>} total deleted objects
-   */
-  async truncate(options) {
-    // Allows safe overrides, as _truncate is called recursively
-    return this._truncate(options);
-  }
-
-  /**
-   * Do not override this: this function calls itself.
-   * @private
-   */
-  async _truncate(options, part = null) {
-    if (part === null) {
-      const objects = await this.search(
-        {},
-        { refresh: options.refresh, scroll: "5s", size: 100 }
-      );
-      const deleted = await this._truncatePart(objects, options);
-
-      if (objects.hits.length < objects.total) {
-        const total = await this._truncate(options, {
-          fetched: objects.hits.length,
-          scrollId: objects.scrollId,
-          total: objects.total,
+    /**
+     * Delete repository from database according to its id
+     */
+    deleteFromDatabase(id, options = {}) {
+        return this.store.delete(this.collection, id, options);
+    }
+    /**
+     * Persists the given ObjectConstructor object in cache.
+     *
+     * @param object - The object to persist
+     * @param options.key - if provided, stores the object to the given key instead of the default one (<collection>/<id>)
+     * @param options.ttl - if provided, overrides the default ttl set on the repository for the current operation
+     */
+    async persistToCache(object, options = {}) {
+        const key = options.key || this.getCacheKey(object._id);
+        const value = JSON.stringify(this.serializeToCache(object));
+        const ttl = options.ttl !== undefined ? options.ttl : this.ttl;
+        await global.kuzzle.ask(`core:cache:${this.cacheDb}:store`, key, value, {
+            ttl,
         });
-
-        return deleted + total;
-      }
-
-      return deleted;
+        return object;
     }
-
-    const objects = await this.scroll(part.scrollId, "5s");
-    const deleted = await this._truncatePart(objects, options);
-
-    part.fetched += objects.hits.length;
-
-    if (part.fetched < part.total) {
-      part.scrollId = objects.scrollId;
-
-      const total = await this._truncate(options, part);
-      return deleted + total;
+    /**
+     * Removes the object from the Cache Engine
+     *
+     * @param id
+     * @param options.key - if provided, stores the object to the given key instead of the default one (<collection>/<id>)
+     */
+    async deleteFromCache(id, options = {}) {
+        const key = options.key || this.getCacheKey(id);
+        await global.kuzzle.ask(`core:cache:${this.cacheDb}:del`, key);
     }
-
-    return deleted;
-  }
-
-  /**
-   * @param {Array} objects
-   * @param {object} options
-   * @returns {Promise<integer>} count of deleted objects
-   * @private
-   */
-  async _truncatePart(objects, options) {
-    return Bluebird.map(objects.hits, async (object) => {
-      // profile and role repositories have protected objects, we can't delete
-      // them
-      const protectedObjects =
-        ["profiles", "roles"].indexOf(this.collection) !== -1
-          ? ["admin", "default", "anonymous"]
-          : [];
-
-      if (protectedObjects.indexOf(object._id) !== -1) {
-        return 0;
-      }
-
-      const loaded = await this.load(object._id);
-      await this.delete(loaded, options);
-
-      return 1;
-    }).reduce((total, deleted) => total + deleted, 0);
-  }
-
-  /**
-   * Given a raw search response from ES, returns a {total: int, hits: []} object
-   * @param {object} raw
-   * @returns {Promise<object>}
-   * @private
-   */
-  async _formatSearchResults(raw) {
-    const result = {
-      aggregations: raw.aggregations,
-      hits: [],
-      scrollId: raw.scrollId,
-      total: raw.total,
-    };
-
-    if (raw.hits && raw.hits.length > 0) {
-      result.hits = await Bluebird.map(raw.hits, (doc) => {
-        return this.fromDTO(Object.assign({}, doc._source, { _id: doc._id }));
-      });
+    /**
+     * @param object
+     * @param options.key - if provided, stores the object to the given key instead of the default one (<collection>/<id>)
+     * @param options.ttl - if provided, overrides the default ttl set on the repository for the current operation
+     */
+    refreshCacheTTL(object, options = {}) {
+        const key = options.key || this.getCacheKey(object._id);
+        let ttl;
+        if (options.ttl !== undefined) {
+            ttl = options.ttl;
+        }
+        else if (object.ttl !== undefined) {
+            // if a TTL has been defined at the entry creation, we should
+            // use it
+            ttl = object.ttl;
+        }
+        else {
+            ttl = this.ttl;
+        }
+        if (ttl > 0) {
+            return global.kuzzle.ask(`core:cache:${this.cacheDb}:expire`, key, ttl);
+        }
+        return global.kuzzle.ask(`core:cache:${this.cacheDb}:persist`, key);
+    }
+    /**
+     * @param object
+     * @param options.key - if provided, stores the object to the given key instead of the default one (<collection>/<id>)
+     */
+    async expireFromCache(object, options = {}) {
+        const key = options.key || this.getCacheKey(object._id);
+        await global.kuzzle.ask(`core:cache:${this.cacheDb}:expire`, key, -1);
+    }
+    /**
+     * Serializes the object before being persisted to cache.
+     *
+     * @param object - The object to serialize
+     */
+    serializeToCache(object) {
+        return this.toDTO(object);
+    }
+    /**
+     * Serializes the object before being persisted to the database.
+     *
+     * @param object - The object to serialize
+     */
+    serializeToDatabase(object) {
+        const dto = this.toDTO(object);
+        delete dto._id;
+        return dto;
+    }
+    /**
+     * @param {string} id
+     */
+    getCacheKey(id) {
+        return `repos/${this.index}/${this.collection}/${id}`;
+    }
+    /**
+     * @param {object} dto
+     * @returns {Promise<ObjectConstructor>}
+     */
+    async fromDTO(dto) {
+        const o = new this.ObjectConstructor();
+        Object.assign(o, dto);
+        return o;
+    }
+    /**
+     * @param {ObjectConstructor} o
+     * @returns {object}
+     */
+    toDTO(o) {
+        return Object.assign({}, o);
+    }
+    /**
+     * Recursively delete all objects in repository with a scroll
+     *
+     * @param {object} options - ES options (refresh)
+     * @param {object} part
+     * @returns {Promise<integer>} total deleted objects
+     */
+    async truncate(options) {
+        // Allows safe overrides, as _truncate is called recursively
+        return this._truncate(options);
+    }
+    /**
+     * Do not override this: this function calls itself.
+     */
+    async _truncate(options, part = null) {
+        if (part === null) {
+            const objects = await this.search({}, { refresh: options.refresh, scroll: "5s", size: 100 });
+            const deleted = await this.truncatePart(objects, options);
+            if (objects.hits.length < objects.total) {
+                const total = await this._truncate(options, {
+                    fetched: objects.hits.length,
+                    scrollId: objects.scrollId,
+                    total: objects.total,
+                });
+                return deleted + total;
+            }
+            return deleted;
+        }
+        const objects = await this.scroll(part.scrollId, "5s");
+        const deleted = await this.truncatePart(objects, options);
+        part.fetched += objects.hits.length;
+        if (part.fetched < part.total) {
+            part.scrollId = objects.scrollId;
+            const total = await this._truncate(options, part);
+            return deleted + total;
+        }
+        return deleted;
+    }
+    /**
+     * @param {Array} objects
+     * @param {object} options
+     * @returns {Promise<integer>} count of deleted objects
+     */
+    async truncatePart(objects, options) {
+        const promises = [];
+        const processObject = async (object) => {
+            // profile and role repositories have protected objects, we can't delete
+            // them
+            const protectedObjects = ["profiles", "roles"].indexOf(this.collection) !== -1
+                ? ["admin", "default", "anonymous"]
+                : [];
+            if (protectedObjects.indexOf(object._id) !== -1) {
+                return 0;
+            }
+            const loaded = await this.load(object._id);
+            await this.delete(loaded, options);
+            return 1;
+        };
+        for (const hit of objects.hits) {
+            promises.push(processObject(hit));
+        }
+        const results = await Promise.all(promises);
+        return results.reduce((total, deleted) => total + deleted, 0);
+    }
+    /**
+     * Given a raw search response from ES, returns a {total: int, hits: []} object
+     * @param {object} raw
+     * @returns {Promise<object>}
+     * @private
+     */
+    async formatSearchResults(raw) {
+        const result = {
+            aggregations: raw.aggregations,
+            hits: [],
+            scrollId: raw.scrollId,
+            total: raw.total,
+        };
+        if (raw.hits && raw.hits.length > 0) {
+            const promises = [];
+            for (const hit of raw.hits) {
+                promises.push(this.fromDTO({
+                    ...hit._source,
+                    _id: hit._id,
+                }));
+            }
+            result.hits = await Promise.all(promises);
+        }
+        return result;
     }
-
-    return result;
-  }
 }
-
-module.exports = Repository;
+exports.Repository = Repository;
+//# sourceMappingURL=repository.js.map