@webiny/api-headless-cms-ddb/operations/entry/dataLoaders.js

DynamoDB storage operations plugin for Headless CMS API.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DataLoadersHandler = void 0;
var _error = _interopRequireDefault(require("@webiny/error"));
var _DataLoaderCache = require("./dataLoader/DataLoaderCache");
var _dataLoader = require("./dataLoader");
var _utils = require("@webiny/utils");
class DataLoadersHandler {
  cache = new _DataLoaderCache.DataLoaderCache();
  constructor(params) {
    this.entity = params.entity;
  }
  async getAllEntryRevisions(params) {
    const ids = params.ids.map(id => {
      const {
        id: entryId
      } = (0, _utils.parseIdentifier)(id);
      return entryId;
    });
    return await this.loadMany("getAllEntryRevisions", params, ids);
  }
  async getRevisionById(params) {
    return await this.loadMany("getRevisionById", params, params.ids);
  }
  async getPublishedRevisionByEntryId(params) {
    const ids = params.ids.map(id => {
      const {
        id: entryId
      } = (0, _utils.parseIdentifier)(id);
      return entryId;
    });
    return await this.loadMany("getPublishedRevisionByEntryId", params, ids);
  }
  async getLatestRevisionByEntryId(params) {
    const ids = params.ids.map(id => {
      const {
        id: entryId
      } = (0, _utils.parseIdentifier)(id);
      return entryId;
    });
    return await this.loadMany("getLatestRevisionByEntryId", params, ids);
  }

  /**
   * TODO @ts-refactor
   * Maybe pass on the generics to DataLoader definition?
   */
  getLoader(name, params) {
    const {
      model
    } = params;
    const cacheParams = {
      tenant: model.tenant,
      locale: model.locale,
      name
    };
    let loader = this.cache.getDataLoader(cacheParams);
    if (loader) {
      return loader;
    }
    const factory = (0, _dataLoader.getDataLoaderFactory)(name);
    loader = factory({
      entity: this.entity,
      tenant: model.tenant,
      locale: model.locale
    });
    this.cache.setDataLoader(cacheParams, loader);
    return loader;
  }
  async loadMany(loader, params, ids) {
    let results = [];
    try {
      results = await this.getLoader(loader, params).loadMany(ids);
      if (Array.isArray(results) === true) {
        return results.reduce((acc, res) => {
          if (Array.isArray(res) === false) {
            if (res && res.message) {
              throw new _error.default(res.message, res.code, {
                ...res,
                data: JSON.stringify(res.data || {})
              });
            }
            throw new _error.default("Result from the data loader must be an array of arrays which contain requested items.", "DATA_LOADER_RESULTS_ERROR", {
              ...params,
              loader
            });
          }
          acc.push(...res);
          return acc;
        }, []);
      }
    } catch (ex) {
      throw new _error.default(ex.message || "Data loader error.", ex.code || "DATA_LOADER_ERROR", {
        error: ex,
        ...params,
        loader,
        ids
      });
    }
    throw new _error.default(`Data loader did not return array of items or empty array.`, "INVALID_DATA_LOADER_RESULT", {
      loader,
      ids,
      results
    });
  }
  clearAll(params) {
    this.cache.clearAll(params?.model);
  }
}
exports.DataLoadersHandler = DataLoadersHandler;

//# sourceMappingURL=dataLoaders.js.map