@webiny/api-headless-cms-ddb 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/operations/entry/dataLoader/getPublishedRevisionByEntryId.d.ts

@@ -0,0 +1,4 @@
+import DataLoader from "dataloader";
+import type { CmsStorageEntry } from "@webiny/api-headless-cms/types/index.js";
+import type { IDataLoaderParams } from "./types.js";
+export declare const createGetPublishedRevisionByEntryId: (params: IDataLoaderParams) => DataLoader<string, CmsStorageEntry<import("@webiny/api-headless-cms/types/types.js").CmsEntryValues>[], string>;

package/operations/entry/dataLoader/getPublishedRevisionByEntryId.js

@@ -0,0 +1,40 @@
+import dataloader from "dataloader";
+import { cleanupItems } from "@webiny/db-dynamodb/utils/cleanup.js";
+import { createPartitionKey, createPublishedSortKey } from "../keys.js";
+import { parseIdentifier } from "@webiny/utils";
+import { createBatchScheduleFn } from "./createBatchScheduleFn.js";
+const createGetPublishedRevisionByEntryId = (params)=>{
+    const { entity, tenant, modelId } = params;
+    const publishedKey = createPublishedSortKey();
+    return new dataloader(async (ids)=>{
+        const reader = entity.createEntityReader();
+        const keys = new Set();
+        for (const id of ids){
+            const partitionKey = createPartitionKey({
+                tenant,
+                id
+            });
+            if (!keys.has(partitionKey)) {
+                keys.add(partitionKey);
+                reader.get({
+                    PK: partitionKey,
+                    SK: publishedKey
+                });
+            }
+        }
+        const records = await reader.execute();
+        const items = cleanupItems(entity.entity, records).map((item)=>item.data);
+        return ids.map((id)=>{
+            const { id: entryId } = parseIdentifier(id);
+            return items.filter((item)=>{
+                if (item.modelId !== modelId) return false;
+                return entryId === item.entryId;
+            });
+        });
+    }, {
+        batchScheduleFn: createBatchScheduleFn()
+    });
+};
+export { createGetPublishedRevisionByEntryId };
+
+//# sourceMappingURL=getPublishedRevisionByEntryId.js.map

package/operations/entry/dataLoader/getPublishedRevisionByEntryId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/dataLoader/getPublishedRevisionByEntryId.js","sources":["../../../../src/operations/entry/dataLoader/getPublishedRevisionByEntryId.ts"],"sourcesContent":["import DataLoader from \"dataloader\";\nimport { cleanupItems } from \"@webiny/db-dynamodb/utils/cleanup.js\";\nimport type { CmsStorageEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport { createPartitionKey, createPublishedSortKey } from \"~/operations/entry/keys.js\";\nimport type { IDataLoaderParams } from \"./types.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { createBatchScheduleFn } from \"./createBatchScheduleFn.js\";\n\nexport const createGetPublishedRevisionByEntryId = (params: IDataLoaderParams) => {\n    const { entity, tenant, modelId } = params;\n\n    const publishedKey = createPublishedSortKey();\n    return new DataLoader<string, CmsStorageEntry[]>(\n        async ids => {\n            const reader = entity.createEntityReader();\n\n            const keys = new Set<string>();\n\n            for (const id of ids) {\n                const partitionKey = createPartitionKey({\n                    tenant,\n                    id\n                });\n                if (keys.has(partitionKey)) {\n                    continue;\n                }\n                keys.add(partitionKey);\n                reader.get({\n                    PK: partitionKey,\n                    SK: publishedKey\n                });\n            }\n\n            const records = await reader.execute();\n            const items = cleanupItems(entity.entity, records).map(item => {\n                return item.data;\n            });\n\n            return ids.map(id => {\n                const { id: entryId } = parseIdentifier(id);\n                return items.filter(item => {\n                    if (item.modelId !== modelId) {\n                        return false;\n                    }\n                    return entryId === item.entryId;\n                });\n            });\n        },\n        {\n            batchScheduleFn: createBatchScheduleFn()\n        }\n    );\n};\n"],"names":["createGetPublishedRevisionByEntryId","params","entity","tenant","modelId","publishedKey","createPublishedSortKey","DataLoader","ids","reader","keys","Set","id","partitionKey","createPartitionKey","records","items","cleanupItems","item","entryId","parseIdentifier","createBatchScheduleFn"],"mappings":";;;;;AAQO,MAAMA,sCAAsC,CAACC;IAChD,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEC,OAAO,EAAE,GAAGH;IAEpC,MAAMI,eAAeC;IACrB,OAAO,IAAIC,WACP,OAAMC;QACF,MAAMC,SAASP,OAAO,kBAAkB;QAExC,MAAMQ,OAAO,IAAIC;QAEjB,KAAK,MAAMC,MAAMJ,IAAK;YAClB,MAAMK,eAAeC,mBAAmB;gBACpCX;gBACAS;YACJ;YACA,KAAIF,KAAK,GAAG,CAACG;gBAGbH,KAAK,GAAG,CAACG;gBACTJ,OAAO,GAAG,CAAC;oBACP,IAAII;oBACJ,IAAIR;gBACR;;QACJ;QAEA,MAAMU,UAAU,MAAMN,OAAO,OAAO;QACpC,MAAMO,QAAQC,aAAaf,OAAO,MAAM,EAAEa,SAAS,GAAG,CAACG,CAAAA,OAC5CA,KAAK,IAAI;QAGpB,OAAOV,IAAI,GAAG,CAACI,CAAAA;YACX,MAAM,EAAE,IAAIO,OAAO,EAAE,GAAGC,gBAAgBR;YACxC,OAAOI,MAAM,MAAM,CAACE,CAAAA;gBAChB,IAAIA,KAAK,OAAO,KAAKd,SACjB,OAAO;gBAEX,OAAOe,YAAYD,KAAK,OAAO;YACnC;QACJ;IACJ,GACA;QACI,iBAAiBG;IACrB;AAER"}

package/operations/entry/dataLoader/getRevisionById.d.ts

@@ -0,0 +1,4 @@
+import DataLoader from "dataloader";
+import type { CmsStorageEntry } from "@webiny/api-headless-cms/types/index.js";
+import type { IDataLoaderParams } from "./types.js";
+export declare const createGetRevisionById: (params: IDataLoaderParams) => DataLoader<string, CmsStorageEntry<import("@webiny/api-headless-cms/types/types.js").CmsEntryValues>[], string>;

package/operations/entry/dataLoader/getRevisionById.js

@@ -0,0 +1,42 @@
+import dataloader from "dataloader";
+import { cleanupItems } from "@webiny/db-dynamodb/utils/cleanup.js";
+import { createPartitionKey, createRevisionSortKey } from "../keys.js";
+import { parseIdentifier } from "@webiny/utils";
+import { createBatchScheduleFn } from "./createBatchScheduleFn.js";
+const createGetRevisionById = (params)=>{
+    const { entity, tenant, modelId } = params;
+    return new dataloader(async (ids)=>{
+        const reader = entity.createEntityReader();
+        const keys = new Set();
+        for (const id of ids){
+            const partitionKey = createPartitionKey({
+                tenant,
+                id
+            });
+            const { version } = parseIdentifier(id);
+            if (null === version) continue;
+            const sortKey = createRevisionSortKey({
+                version
+            });
+            const key = `${partitionKey}__${sortKey}`;
+            if (!keys.has(key)) {
+                keys.add(key);
+                reader.get({
+                    PK: partitionKey,
+                    SK: sortKey
+                });
+            }
+        }
+        const records = await reader.execute();
+        const items = cleanupItems(entity.entity, records).map((item)=>item.data);
+        return ids.map((id)=>items.filter((item)=>{
+                if (item.modelId !== modelId) return false;
+                return id === item.id;
+            }));
+    }, {
+        batchScheduleFn: createBatchScheduleFn()
+    });
+};
+export { createGetRevisionById };
+
+//# sourceMappingURL=getRevisionById.js.map

package/operations/entry/dataLoader/getRevisionById.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/dataLoader/getRevisionById.js","sources":["../../../../src/operations/entry/dataLoader/getRevisionById.ts"],"sourcesContent":["import DataLoader from \"dataloader\";\nimport type { CmsStorageEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport { cleanupItems } from \"@webiny/db-dynamodb/utils/cleanup.js\";\nimport { createPartitionKey, createRevisionSortKey } from \"~/operations/entry/keys.js\";\nimport type { IDataLoaderParams } from \"./types.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { createBatchScheduleFn } from \"./createBatchScheduleFn.js\";\n\nexport const createGetRevisionById = (params: IDataLoaderParams) => {\n    const { entity, tenant, modelId } = params;\n\n    return new DataLoader<string, CmsStorageEntry[]>(\n        async ids => {\n            const reader = entity.createEntityReader();\n\n            const keys = new Set<string>();\n\n            for (const id of ids) {\n                const partitionKey = createPartitionKey({\n                    tenant,\n                    id\n                });\n                const { version } = parseIdentifier(id);\n                if (version === null) {\n                    continue;\n                }\n                const sortKey = createRevisionSortKey({\n                    version\n                });\n                const key = `${partitionKey}__${sortKey}`;\n                if (keys.has(key)) {\n                    continue;\n                }\n                keys.add(key);\n\n                reader.get({\n                    PK: partitionKey,\n                    SK: sortKey\n                });\n            }\n\n            const records = await reader.execute();\n            const items = cleanupItems(entity.entity, records).map(item => {\n                return item.data;\n            });\n\n            return ids.map(id => {\n                return items.filter(item => {\n                    if (item.modelId !== modelId) {\n                        return false;\n                    }\n                    return id === item.id;\n                });\n            });\n        },\n        {\n            batchScheduleFn: createBatchScheduleFn()\n        }\n    );\n};\n"],"names":["createGetRevisionById","params","entity","tenant","modelId","DataLoader","ids","reader","keys","Set","id","partitionKey","createPartitionKey","version","parseIdentifier","sortKey","createRevisionSortKey","key","records","items","cleanupItems","item","createBatchScheduleFn"],"mappings":";;;;;AAQO,MAAMA,wBAAwB,CAACC;IAClC,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEC,OAAO,EAAE,GAAGH;IAEpC,OAAO,IAAII,WACP,OAAMC;QACF,MAAMC,SAASL,OAAO,kBAAkB;QAExC,MAAMM,OAAO,IAAIC;QAEjB,KAAK,MAAMC,MAAMJ,IAAK;YAClB,MAAMK,eAAeC,mBAAmB;gBACpCT;gBACAO;YACJ;YACA,MAAM,EAAEG,OAAO,EAAE,GAAGC,gBAAgBJ;YACpC,IAAIG,AAAY,SAAZA,SACA;YAEJ,MAAME,UAAUC,sBAAsB;gBAClCH;YACJ;YACA,MAAMI,MAAM,GAAGN,aAAa,EAAE,EAAEI,SAAS;YACzC,KAAIP,KAAK,GAAG,CAACS;gBAGbT,KAAK,GAAG,CAACS;gBAETV,OAAO,GAAG,CAAC;oBACP,IAAII;oBACJ,IAAII;gBACR;;QACJ;QAEA,MAAMG,UAAU,MAAMX,OAAO,OAAO;QACpC,MAAMY,QAAQC,aAAalB,OAAO,MAAM,EAAEgB,SAAS,GAAG,CAACG,CAAAA,OAC5CA,KAAK,IAAI;QAGpB,OAAOf,IAAI,GAAG,CAACI,CAAAA,KACJS,MAAM,MAAM,CAACE,CAAAA;gBAChB,IAAIA,KAAK,OAAO,KAAKjB,SACjB,OAAO;gBAEX,OAAOM,OAAOW,KAAK,EAAE;YACzB;IAER,GACA;QACI,iBAAiBC;IACrB;AAER"}

package/operations/entry/dataLoader/index.d.ts

@@ -0,0 +1,8 @@
+import type DataLoader from "dataloader";
+import type { IDataLoaderParams } from "./types.js";
+export * from "./DataLoaderCache.js";
+interface Callable {
+    (params: IDataLoaderParams): DataLoader<any, any>;
+}
+export type DataLoaders = "getAllEntryRevisions" | "getRevisionById" | "getPublishedRevisionByEntryId" | "getLatestRevisionByEntryId";
+export declare const getDataLoaderFactory: (name: string) => Callable;

package/operations/entry/dataLoader/index.js

@@ -0,0 +1,18 @@
+import { createGetAllEntryRevisions } from "./getAllEntryRevisions.js";
+import { createGetLatestRevisionByEntryId } from "./getLatestRevisionByEntryId.js";
+import { createGetPublishedRevisionByEntryId } from "./getPublishedRevisionByEntryId.js";
+import { createGetRevisionById } from "./getRevisionById.js";
+export * from "./DataLoaderCache.js";
+const dataLoaders = {
+    getAllEntryRevisions: createGetAllEntryRevisions,
+    getLatestRevisionByEntryId: createGetLatestRevisionByEntryId,
+    getPublishedRevisionByEntryId: createGetPublishedRevisionByEntryId,
+    getRevisionById: createGetRevisionById
+};
+const getDataLoaderFactory = (name)=>{
+    if (!dataLoaders[name]) throw new Error(`Missing data loader "${name}".`);
+    return dataLoaders[name];
+};
+export { getDataLoaderFactory };
+
+//# sourceMappingURL=index.js.map

package/operations/entry/dataLoader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/dataLoader/index.js","sources":["../../../../src/operations/entry/dataLoader/index.ts"],"sourcesContent":["import type DataLoader from \"dataloader\";\nimport type { IDataLoaderParams } from \"./types.js\";\nimport { createGetAllEntryRevisions } from \"./getAllEntryRevisions.js\";\nimport { createGetLatestRevisionByEntryId } from \"./getLatestRevisionByEntryId.js\";\nimport { createGetPublishedRevisionByEntryId } from \"./getPublishedRevisionByEntryId.js\";\nimport { createGetRevisionById } from \"./getRevisionById.js\";\n\nexport * from \"./DataLoaderCache.js\";\n\ninterface Callable {\n    (params: IDataLoaderParams): DataLoader<any, any>;\n}\n\nconst dataLoaders: Record<string, Callable> = {\n    getAllEntryRevisions: createGetAllEntryRevisions,\n    getLatestRevisionByEntryId: createGetLatestRevisionByEntryId,\n    getPublishedRevisionByEntryId: createGetPublishedRevisionByEntryId,\n    getRevisionById: createGetRevisionById\n};\n\nexport type DataLoaders =\n    | \"getAllEntryRevisions\"\n    | \"getRevisionById\"\n    | \"getPublishedRevisionByEntryId\"\n    | \"getLatestRevisionByEntryId\";\n\nexport const getDataLoaderFactory = (name: string) => {\n    if (!dataLoaders[name]) {\n        throw new Error(`Missing data loader \"${name}\".`);\n    }\n    return dataLoaders[name];\n};\n"],"names":["dataLoaders","createGetAllEntryRevisions","createGetLatestRevisionByEntryId","createGetPublishedRevisionByEntryId","createGetRevisionById","getDataLoaderFactory","name","Error"],"mappings":";;;;;AAaA,MAAMA,cAAwC;IAC1C,sBAAsBC;IACtB,4BAA4BC;IAC5B,+BAA+BC;IAC/B,iBAAiBC;AACrB;AAQO,MAAMC,uBAAuB,CAACC;IACjC,IAAI,CAACN,WAAW,CAACM,KAAK,EAClB,MAAM,IAAIC,MAAM,CAAC,qBAAqB,EAAED,KAAK,EAAE,CAAC;IAEpD,OAAON,WAAW,CAACM,KAAK;AAC5B"}

package/operations/entry/dataLoader/types.d.ts

@@ -0,0 +1,6 @@
+import type { IEntryEntity } from "../../../definitions/types.js";
+export interface IDataLoaderParams {
+    entity: IEntryEntity;
+    tenant: string;
+    modelId: string;
+}

package/operations/entry/dataLoaders.d.ts

@@ -1,42 +1,26 @@
-import { CmsStorageEntry, CmsModel } from "@webiny/api-headless-cms/types";
-import { Entity } from "dynamodb-toolbox";
-export interface GetAllEntryRevisionsParams {
+import type { CmsEntryValues, CmsModel, CmsStorageEntry } from "@webiny/api-headless-cms/types/index.js";
+import type { DataLoadersHandlerInterfaceClearAllParams, IDataLoadersHandler, IEntryEntity } from "../../types.js";
+interface DataLoaderParams {
+    model: Pick<CmsModel, "tenant" | "modelId">;
     ids: readonly string[];
-    model: CmsModel;
 }
-export interface GetRevisionByIdParams {
-    ids: readonly string[];
-    model: CmsModel;
-}
-export interface GetPublishedRevisionByEntryIdParams {
-    ids: readonly string[];
-    model: CmsModel;
-}
-export interface GetLatestRevisionByEntryIdParams {
-    ids: readonly string[];
-    model: CmsModel;
-}
-interface ClearLoaderParams {
-    model: CmsModel;
-    entry?: CmsStorageEntry;
-}
-interface DataLoadersHandlerParams {
-    entity: Entity<any>;
+interface IDataLoadersHandlerParams {
+    entity: IEntryEntity;
 }
-export declare class DataLoadersHandler {
-    private readonly loaders;
+export declare class DataLoadersHandler implements IDataLoadersHandler {
     private readonly entity;
-    constructor(params: DataLoadersHandlerParams);
-    getAllEntryRevisions(params: GetAllEntryRevisionsParams): Promise<CmsStorageEntry[]>;
-    getRevisionById(params: GetRevisionByIdParams): Promise<CmsStorageEntry[]>;
-    getPublishedRevisionByEntryId(params: GetPublishedRevisionByEntryIdParams): Promise<CmsStorageEntry[]>;
-    getLatestRevisionByEntryId(params: GetLatestRevisionByEntryIdParams): Promise<CmsStorageEntry[]>;
+    private readonly cache;
+    constructor(params: IDataLoadersHandlerParams);
+    getAllEntryRevisions<T extends CmsEntryValues = CmsEntryValues>(params: DataLoaderParams): Promise<CmsStorageEntry<T>[]>;
+    getRevisionById<T extends CmsEntryValues = CmsEntryValues>(params: DataLoaderParams): Promise<CmsStorageEntry<T>[]>;
+    getPublishedRevisionByEntryId<T extends CmsEntryValues = CmsEntryValues>(params: DataLoaderParams): Promise<CmsStorageEntry<T>[]>;
+    getLatestRevisionByEntryId<T extends CmsEntryValues = CmsEntryValues>(params: DataLoaderParams): Promise<CmsStorageEntry<T>[]>;
     /**
      * TODO @ts-refactor
      * Maybe pass on the generics to DataLoader definition?
      */
     private getLoader;
     private loadMany;
-    clearAll(params: Omit<ClearLoaderParams, "entry">): void;
+    clearAll(params?: DataLoadersHandlerInterfaceClearAllParams): void;
 }
 export {};

package/operations/entry/dataLoaders.js

@@ -1,321 +1,90 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DataLoadersHandler = void 0;
-
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _dataloader = _interopRequireDefault(require("dataloader"));
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _query = require("@webiny/db-dynamodb/utils/query");
-
-var _keys = require("./keys");
-
-var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
-
-var _utils = require("@webiny/utils");
-
-var _batchRead = require("@webiny/db-dynamodb/utils/batchRead");
-
-const getAllEntryRevisions = params => {
-  const {
-    entity,
-    model
-  } = params;
-  const {
-    tenant,
-    locale
-  } = model;
-  return new _dataloader.default(async ids => {
-    const results = {};
-
-    for (const id of ids) {
-      const queryAllParams = {
-        entity,
-        partitionKey: (0, _keys.createPartitionKey)({
-          tenant,
-          locale,
-          id
-        }),
-        options: {
-          beginsWith: "REV#"
-        }
-      };
-      const items = await (0, _query.queryAll)(queryAllParams);
-      results[id] = (0, _cleanup.cleanupItems)(entity, items);
-    }
-
-    return ids.map(id => {
-      return results[id] || [];
-    });
-  });
-};
-
-const getRevisionById = params => {
-  const {
-    entity,
-    model
-  } = params;
-  const {
-    locale,
-    tenant
-  } = model;
-  return new _dataloader.default(async ids => {
-    const queries = ids.reduce((collection, id) => {
-      const partitionKey = (0, _keys.createPartitionKey)({
-        tenant,
-        locale,
-        id
-      });
-      const {
-        version
-      } = (0, _utils.parseIdentifier)(id);
-
-      if (version === null) {
-        return collection;
-      }
-
-      const sortKey = (0, _keys.createRevisionSortKey)({
-        version
-      });
-      const keys = `${partitionKey}__${sortKey}`;
-
-      if (collection[keys]) {
-        return collection;
-      }
-
-      collection[keys] = entity.getBatch({
-        PK: partitionKey,
-        SK: sortKey
-      });
-      return collection;
-      /**
-       * We cast as any because there is no return type defined.
-       */
-    }, {});
-    const records = await (0, _batchRead.batchReadAll)({
-      table: entity.table,
-      items: Object.values(queries)
-    });
-    const items = (0, _cleanup.cleanupItems)(entity, records);
-    return ids.map(id => {
-      return items.filter(item => {
-        return id === item.id;
-      });
-    });
-  });
-};
-
-const getPublishedRevisionByEntryId = params => {
-  const {
-    entity,
-    model
-  } = params;
-  const {
-    locale,
-    tenant
-  } = model;
-  const publishedKey = (0, _keys.createPublishedSortKey)();
-  return new _dataloader.default(async ids => {
-    const queries = ids.reduce((collection, id) => {
-      const partitionKey = (0, _keys.createPartitionKey)({
-        tenant,
-        locale,
-        id
-      });
-
-      if (collection[partitionKey]) {
-        return collection;
-      }
-
-      collection[partitionKey] = entity.getBatch({
-        PK: partitionKey,
-        SK: publishedKey
-      });
-      return collection;
-      /**
-       * We cast as any because there is no return type defined.
-       */
-    }, {});
-    const records = await (0, _batchRead.batchReadAll)({
-      table: entity.table,
-      items: Object.values(queries)
-    });
-    const items = (0, _cleanup.cleanupItems)(entity, records);
-    return ids.map(id => {
-      const {
-        id: entryId
-      } = (0, _utils.parseIdentifier)(id);
-      return items.filter(item => {
-        return entryId === item.entryId;
-      });
-    });
-  });
-};
-
-const getLatestRevisionByEntryId = params => {
-  const {
-    entity,
-    model
-  } = params;
-  const {
-    locale,
-    tenant
-  } = model;
-  const latestKey = (0, _keys.createLatestSortKey)();
-  return new _dataloader.default(async ids => {
-    const queries = ids.reduce((collection, id) => {
-      const partitionKey = (0, _keys.createPartitionKey)({
-        tenant,
-        locale,
-        id
-      });
-
-      if (collection[partitionKey]) {
-        return collection;
-      }
-
-      collection[partitionKey] = entity.getBatch({
-        PK: partitionKey,
-        SK: latestKey
-      });
-      return collection;
-      /**
-       * We cast as any because there is no return type defined.
-       */
-    }, {});
-    const records = await (0, _batchRead.batchReadAll)({
-      table: entity.table,
-      items: Object.values(queries)
-    });
-    const items = (0, _cleanup.cleanupItems)(entity, records);
-    return ids.map(id => {
-      const {
-        id: entryId
-      } = (0, _utils.parseIdentifier)(id);
-      return items.filter(item => {
-        return entryId === item.entryId;
-      });
-    });
-  });
-};
-
-const dataLoaders = {
-  getAllEntryRevisions,
-  getRevisionById,
-  getPublishedRevisionByEntryId,
-  getLatestRevisionByEntryId
-};
-const loaderNames = Object.keys(dataLoaders);
-
+import error from "@webiny/error";
+import { DataLoaderCache } from "./dataLoader/DataLoaderCache.js";
+import { getDataLoaderFactory } from "./dataLoader/index.js";
+import { parseIdentifier } from "@webiny/utils";
 class DataLoadersHandler {
-  constructor(params) {
-    (0, _defineProperty2.default)(this, "loaders", new Map());
-    (0, _defineProperty2.default)(this, "entity", void 0);
-    this.entity = params.entity;
-  }
-
-  async getAllEntryRevisions(params) {
-    return await this.loadMany("getAllEntryRevisions", params, params.ids);
-  }
-
-  async getRevisionById(params) {
-    return await this.loadMany("getRevisionById", params, params.ids);
-  }
-
-  async getPublishedRevisionByEntryId(params) {
-    return await this.loadMany("getPublishedRevisionByEntryId", params, params.ids);
-  }
-
-  async getLatestRevisionByEntryId(params) {
-    return await this.loadMany("getLatestRevisionByEntryId", params, params.ids);
-  }
-  /**
-   * TODO @ts-refactor
-   * Maybe pass on the generics to DataLoader definition?
-   */
-
-
-  getLoader(name, params) {
-    if (!dataLoaders[name]) {
-      throw new _error.default("Unknown data loader.", "UNKNOWN_DATA_LOADER", {
-        name
-      });
+    constructor(params){
+        this.cache = new DataLoaderCache();
+        this.entity = params.entity;
     }
-
-    const {
-      model
-    } = params;
-    const {
-      tenant,
-      locale
-    } = model;
-    const loaderKey = `${name}-${tenant}-${locale}-${model.modelId}`;
-
-    if (!this.loaders.has(loaderKey)) {
-      this.loaders.set(loaderKey, dataLoaders[name]((0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-        entity: this.entity
-      })));
+    async getAllEntryRevisions(params) {
+        const ids = params.ids.map((id)=>{
+            const { id: entryId } = parseIdentifier(id);
+            return entryId;
+        });
+        return await this.loadMany("getAllEntryRevisions", params, ids);
     }
-
-    return this.loaders.get(loaderKey);
-  }
-
-  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, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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", (0, _objectSpread2.default)((0, _objectSpread2.default)({}, params), {}, {
-              loader
-            }));
-          }
-
-          acc.push(...res);
-          return acc;
-        }, []);
-      }
-    } catch (ex) {
-      throw new _error.default(ex.message || "Data loader error.", ex.code || "DATA_LOADER_ERROR", (0, _objectSpread2.default)((0, _objectSpread2.default)({
-        error: ex
-      }, params), {}, {
-        loader,
-        ids
-      }));
+    async getRevisionById(params) {
+        return await this.loadMany("getRevisionById", params, params.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) {
-    for (const name of loaderNames) {
-      const loader = this.getLoader(name, params);
-      loader.clearAll();
+    async getPublishedRevisionByEntryId(params) {
+        const ids = params.ids.map((id)=>{
+            const { id: entryId } = parseIdentifier(id);
+            return entryId;
+        });
+        return await this.loadMany("getPublishedRevisionByEntryId", params, ids);
+    }
+    async getLatestRevisionByEntryId(params) {
+        const ids = params.ids.map((id)=>{
+            const { id: entryId } = parseIdentifier(id);
+            return entryId;
+        });
+        return await this.loadMany("getLatestRevisionByEntryId", params, ids);
+    }
+    getLoader(name, params) {
+        const { model } = params;
+        const cacheParams = {
+            tenant: model.tenant,
+            modelId: model.modelId,
+            name
+        };
+        let loader = this.cache.getDataLoader(cacheParams);
+        if (loader) return loader;
+        const factory = getDataLoaderFactory(name);
+        loader = factory({
+            entity: this.entity,
+            tenant: model.tenant,
+            modelId: model.modelId
+        });
+        this.cache.setDataLoader(cacheParams, loader);
+        return loader;
+    }
+    async loadMany(loader, params, ids) {
+        let results = [];
+        try {
+            results = await this.getLoader(loader, params).loadMany(ids);
+            if (true === Array.isArray(results)) return results.reduce((acc, res)=>{
+                if (false === Array.isArray(res)) {
+                    if (res && res.message) throw new error(res.message, res.code, {
+                        ...res,
+                        data: JSON.stringify(res.data || {})
+                    });
+                    throw new error("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(ex.message || "Data loader error.", ex.code || "DATA_LOADER_ERROR", {
+                error: ex,
+                ...params,
+                loader,
+                ids
+            });
+        }
+        throw new error("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);
     }
-  }
-
 }
+export { DataLoadersHandler };
 
-exports.DataLoadersHandler = DataLoadersHandler;
+//# sourceMappingURL=dataLoaders.js.map