@strapi/core 0.0.0-experimental.f31889311d753b5f7d95198ae84d8fce1d156cd6 → 0.0.0-experimental.f56bca7c4d88bc4c61b6de9f65648d857cf242d9

package/dist/services/document-service/events.js

@@ -1,47 +1,59 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const strapiUtils = require("@strapi/utils");
-const populate = require("./utils/populate.js");
+'use strict';
+
+var strapiUtils = require('@strapi/utils');
+var populate = require('./utils/populate.js');
+
 const EVENTS = {
-  ENTRY_CREATE: "entry.create",
-  ENTRY_UPDATE: "entry.update",
-  ENTRY_DELETE: "entry.delete",
-  ENTRY_PUBLISH: "entry.publish",
-  ENTRY_UNPUBLISH: "entry.unpublish",
-  ENTRY_DRAFT_DISCARD: "entry.draft-discard"
+    ENTRY_CREATE: 'entry.create',
+    ENTRY_UPDATE: 'entry.update',
+    ENTRY_DELETE: 'entry.delete',
+    ENTRY_PUBLISH: 'entry.publish',
+    ENTRY_UNPUBLISH: 'entry.unpublish',
+    ENTRY_DRAFT_DISCARD: 'entry.draft-discard'
 };
-const createEventManager = (strapi, uid) => {
-  const populate$1 = populate.getDeepPopulate(uid, {});
-  const model = strapi.getModel(uid);
-  const emitEvent = async (eventName, entry) => {
-    let populatedEntry = entry;
-    if (![EVENTS.ENTRY_DELETE, EVENTS.ENTRY_UNPUBLISH].includes(eventName)) {
-      populatedEntry = await strapi.db.query(uid).findOne({ where: { id: entry.id }, populate: populate$1 });
-    }
-    const sanitizedEntry = await strapiUtils.sanitize.sanitizers.defaultSanitizeOutput(
-      {
-        schema: model,
-        getModel: (uid2) => strapi.getModel(uid2)
-      },
-      populatedEntry
-    );
-    await strapi.eventHub.emit(eventName, {
-      model: model.modelName,
-      uid: model.uid,
-      entry: sanitizedEntry
-    });
-  };
-  return {
-    /**
+/**
+ * Manager to trigger entry related events
+ *
+ * It will populate the entry if it is not a delete event.
+ * So the event payload will contain the full entry.
+ */ const createEventManager = (strapi, uid)=>{
+    const populate$1 = populate.getDeepPopulate(uid, {});
+    const model = strapi.getModel(uid);
+    const emitEvent = async (eventName, entry)=>{
+        // There is no need to populate the entry if it has been deleted
+        let populatedEntry = entry;
+        if (![
+            EVENTS.ENTRY_DELETE,
+            EVENTS.ENTRY_UNPUBLISH
+        ].includes(eventName)) {
+            populatedEntry = await strapi.db.query(uid).findOne({
+                where: {
+                    id: entry.id
+                },
+                populate: populate$1
+            });
+        }
+        const sanitizedEntry = await strapiUtils.sanitize.sanitizers.defaultSanitizeOutput({
+            schema: model,
+            getModel: (uid)=>strapi.getModel(uid)
+        }, populatedEntry);
+        await strapi.eventHub.emit(eventName, {
+            model: model.modelName,
+            uid: model.uid,
+            entry: sanitizedEntry
+        });
+    };
+    return {
+        /**
      * strapi.db.query might reuse the transaction used in the doc service request,
      * so this is executed after that transaction is committed.
-     */
-    emitEvent(eventName, entry) {
-      strapi.db.transaction(({ onCommit }) => {
-        onCommit(() => emitEvent(eventName, entry));
-      });
-    }
-  };
+     */ emitEvent (eventName, entry) {
+            strapi.db.transaction(({ onCommit })=>{
+                onCommit(()=>emitEvent(eventName, entry));
+            });
+        }
+    };
 };
+
 exports.createEventManager = createEventManager;
 //# sourceMappingURL=events.js.map

package/dist/services/document-service/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","sources":["../../../src/services/document-service/events.ts"],"sourcesContent":["import { UID, Utils, Modules, Core } from '@strapi/types';\nimport { sanitize } from '@strapi/utils';\n\nimport { getDeepPopulate } from './utils/populate';\n\nconst EVENTS = {\n  ENTRY_CREATE: 'entry.create',\n  ENTRY_UPDATE: 'entry.update',\n  ENTRY_DELETE: 'entry.delete',\n  ENTRY_PUBLISH: 'entry.publish',\n  ENTRY_UNPUBLISH: 'entry.unpublish',\n  ENTRY_DRAFT_DISCARD: 'entry.draft-discard',\n};\n\ntype EventName = Utils.Object.Values<typeof EVENTS>;\n\n/**\n * Manager to trigger entry related events\n *\n * It will populate the entry if it is not a delete event.\n * So the event payload will contain the full entry.\n */\nconst createEventManager = (strapi: Core.Strapi, uid: UID.Schema) => {\n  const populate = getDeepPopulate(uid, {});\n  const model = strapi.getModel(uid);\n\n  const emitEvent = async (eventName: EventName, entry: Modules.Documents.AnyDocument) => {\n    // There is no need to populate the entry if it has been deleted\n    let populatedEntry = entry;\n    if (![EVENTS.ENTRY_DELETE, EVENTS.ENTRY_UNPUBLISH].includes(eventName)) {\n      populatedEntry = await strapi.db.query(uid).findOne({ where: { id: entry.id }, populate });\n    }\n\n    const sanitizedEntry = await sanitize.sanitizers.defaultSanitizeOutput(\n      {\n        schema: model,\n        getModel: (uid) => strapi.getModel(uid as UID.Schema),\n      },\n      populatedEntry\n    );\n\n    await strapi.eventHub.emit(eventName, {\n      model: model.modelName,\n      uid: model.uid,\n      entry: sanitizedEntry,\n    });\n  };\n\n  return {\n    /**\n     * strapi.db.query might reuse the transaction used in the doc service request,\n     * so this is executed after that transaction is committed.\n     */\n    emitEvent(eventName: EventName, entry: Modules.Documents.AnyDocument) {\n      strapi.db.transaction(({ onCommit }) => {\n        onCommit(() => emitEvent(eventName, entry));\n      });\n    },\n  };\n};\n\nexport { createEventManager };\n"],"names":["populate","getDeepPopulate","sanitize","uid"],"mappings":";;;;AAKA,MAAM,SAAS;AAAA,EACb,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,eAAe;AAAA,EACf,iBAAiB;AAAA,EACjB,qBAAqB;AACvB;AAUM,MAAA,qBAAqB,CAAC,QAAqB,QAAoB;AACnE,QAAMA,aAAWC,SAAAA,gBAAgB,KAAK,CAAE,CAAA;AAClC,QAAA,QAAQ,OAAO,SAAS,GAAG;AAE3B,QAAA,YAAY,OAAO,WAAsB,UAAyC;AAEtF,QAAI,iBAAiB;AACjB,QAAA,CAAC,CAAC,OAAO,cAAc,OAAO,eAAe,EAAE,SAAS,SAAS,GAAG;AACtE,uBAAiB,MAAM,OAAO,GAAG,MAAM,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,MAAM,GAAG,GAAGD,UAAAA,WAAU,CAAA;AAAA,IAC3F;AAEM,UAAA,iBAAiB,MAAME,qBAAS,WAAW;AAAA,MAC/C;AAAA,QACE,QAAQ;AAAA,QACR,UAAU,CAACC,SAAQ,OAAO,SAASA,IAAiB;AAAA,MACtD;AAAA,MACA;AAAA,IAAA;AAGI,UAAA,OAAO,SAAS,KAAK,WAAW;AAAA,MACpC,OAAO,MAAM;AAAA,MACb,KAAK,MAAM;AAAA,MACX,OAAO;AAAA,IAAA,CACR;AAAA,EAAA;AAGI,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAKL,UAAU,WAAsB,OAAsC;AACpE,aAAO,GAAG,YAAY,CAAC,EAAE,eAAe;AACtC,iBAAS,MAAM,UAAU,WAAW,KAAK,CAAC;AAAA,MAAA,CAC3C;AAAA,IACH;AAAA,EAAA;AAEJ;;"}
+{"version":3,"file":"events.js","sources":["../../../src/services/document-service/events.ts"],"sourcesContent":["import type { UID, Utils, Modules, Core } from '@strapi/types';\nimport { sanitize } from '@strapi/utils';\n\nimport { getDeepPopulate } from './utils/populate';\n\nconst EVENTS = {\n  ENTRY_CREATE: 'entry.create',\n  ENTRY_UPDATE: 'entry.update',\n  ENTRY_DELETE: 'entry.delete',\n  ENTRY_PUBLISH: 'entry.publish',\n  ENTRY_UNPUBLISH: 'entry.unpublish',\n  ENTRY_DRAFT_DISCARD: 'entry.draft-discard',\n};\n\ntype EventName = Utils.Object.Values<typeof EVENTS>;\n\n/**\n * Manager to trigger entry related events\n *\n * It will populate the entry if it is not a delete event.\n * So the event payload will contain the full entry.\n */\nconst createEventManager = (strapi: Core.Strapi, uid: UID.Schema) => {\n  const populate = getDeepPopulate(uid, {});\n  const model = strapi.getModel(uid);\n\n  const emitEvent = async (eventName: EventName, entry: Modules.Documents.AnyDocument) => {\n    // There is no need to populate the entry if it has been deleted\n    let populatedEntry = entry;\n    if (![EVENTS.ENTRY_DELETE, EVENTS.ENTRY_UNPUBLISH].includes(eventName)) {\n      populatedEntry = await strapi.db.query(uid).findOne({ where: { id: entry.id }, populate });\n    }\n\n    const sanitizedEntry = await sanitize.sanitizers.defaultSanitizeOutput(\n      {\n        schema: model,\n        getModel: (uid) => strapi.getModel(uid as UID.Schema),\n      },\n      populatedEntry\n    );\n\n    await strapi.eventHub.emit(eventName, {\n      model: model.modelName,\n      uid: model.uid,\n      entry: sanitizedEntry,\n    });\n  };\n\n  return {\n    /**\n     * strapi.db.query might reuse the transaction used in the doc service request,\n     * so this is executed after that transaction is committed.\n     */\n    emitEvent(eventName: EventName, entry: Modules.Documents.AnyDocument) {\n      strapi.db.transaction(({ onCommit }) => {\n        onCommit(() => emitEvent(eventName, entry));\n      });\n    },\n  };\n};\n\nexport { createEventManager };\n"],"names":["EVENTS","ENTRY_CREATE","ENTRY_UPDATE","ENTRY_DELETE","ENTRY_PUBLISH","ENTRY_UNPUBLISH","ENTRY_DRAFT_DISCARD","createEventManager","strapi","uid","populate","getDeepPopulate","model","getModel","emitEvent","eventName","entry","populatedEntry","includes","db","query","findOne","where","id","sanitizedEntry","sanitize","sanitizers","defaultSanitizeOutput","schema","eventHub","emit","modelName","transaction","onCommit"],"mappings":";;;;;AAKA,MAAMA,MAAS,GAAA;IACbC,YAAc,EAAA,cAAA;IACdC,YAAc,EAAA,cAAA;IACdC,YAAc,EAAA,cAAA;IACdC,aAAe,EAAA,eAAA;IACfC,eAAiB,EAAA,iBAAA;IACjBC,mBAAqB,EAAA;AACvB,CAAA;AAIA;;;;;IAMA,MAAMC,kBAAqB,GAAA,CAACC,MAAqBC,EAAAA,GAAAA,GAAAA;IAC/C,MAAMC,UAAAA,GAAWC,wBAAgBF,CAAAA,GAAAA,EAAK,EAAC,CAAA;IACvC,MAAMG,KAAAA,GAAQJ,MAAOK,CAAAA,QAAQ,CAACJ,GAAAA,CAAAA;IAE9B,MAAMK,SAAAA,GAAY,OAAOC,SAAsBC,EAAAA,KAAAA,GAAAA;;AAE7C,QAAA,IAAIC,cAAiBD,GAAAA,KAAAA;AACrB,QAAA,IAAI,CAAC;AAAChB,YAAAA,MAAAA,CAAOG,YAAY;AAAEH,YAAAA,MAAAA,CAAOK;SAAgB,CAACa,QAAQ,CAACH,SAAY,CAAA,EAAA;YACtEE,cAAiB,GAAA,MAAMT,OAAOW,EAAE,CAACC,KAAK,CAACX,GAAAA,CAAAA,CAAKY,OAAO,CAAC;gBAAEC,KAAO,EAAA;AAAEC,oBAAAA,EAAAA,EAAIP,MAAMO;AAAG,iBAAA;AAAGb,0BAAAA;AAAS,aAAA,CAAA;AAC1F;AAEA,QAAA,MAAMc,iBAAiB,MAAMC,oBAAAA,CAASC,UAAU,CAACC,qBAAqB,CACpE;YACEC,MAAQhB,EAAAA,KAAAA;AACRC,YAAAA,QAAAA,EAAU,CAACJ,GAAAA,GAAQD,MAAOK,CAAAA,QAAQ,CAACJ,GAAAA;SAErCQ,EAAAA,cAAAA,CAAAA;AAGF,QAAA,MAAMT,MAAOqB,CAAAA,QAAQ,CAACC,IAAI,CAACf,SAAW,EAAA;AACpCH,YAAAA,KAAAA,EAAOA,MAAMmB,SAAS;AACtBtB,YAAAA,GAAAA,EAAKG,MAAMH,GAAG;YACdO,KAAOQ,EAAAA;AACT,SAAA,CAAA;AACF,KAAA;IAEA,OAAO;AACL;;;QAIAV,SAAAA,CAAAA,CAAUC,SAAoB,EAAEC,KAAoC,EAAA;AAClER,YAAAA,MAAAA,CAAOW,EAAE,CAACa,WAAW,CAAC,CAAC,EAAEC,QAAQ,EAAE,GAAA;gBACjCA,QAAS,CAAA,IAAMnB,UAAUC,SAAWC,EAAAA,KAAAA,CAAAA,CAAAA;AACtC,aAAA,CAAA;AACF;AACF,KAAA;AACF;;;;"}

package/dist/services/document-service/events.mjs

@@ -1,47 +1,57 @@
-import { sanitize } from "@strapi/utils";
-import { getDeepPopulate } from "./utils/populate.mjs";
+import { sanitize } from '@strapi/utils';
+import { getDeepPopulate } from './utils/populate.mjs';
+
 const EVENTS = {
-  ENTRY_CREATE: "entry.create",
-  ENTRY_UPDATE: "entry.update",
-  ENTRY_DELETE: "entry.delete",
-  ENTRY_PUBLISH: "entry.publish",
-  ENTRY_UNPUBLISH: "entry.unpublish",
-  ENTRY_DRAFT_DISCARD: "entry.draft-discard"
+    ENTRY_CREATE: 'entry.create',
+    ENTRY_UPDATE: 'entry.update',
+    ENTRY_DELETE: 'entry.delete',
+    ENTRY_PUBLISH: 'entry.publish',
+    ENTRY_UNPUBLISH: 'entry.unpublish',
+    ENTRY_DRAFT_DISCARD: 'entry.draft-discard'
 };
-const createEventManager = (strapi, uid) => {
-  const populate = getDeepPopulate(uid, {});
-  const model = strapi.getModel(uid);
-  const emitEvent = async (eventName, entry) => {
-    let populatedEntry = entry;
-    if (![EVENTS.ENTRY_DELETE, EVENTS.ENTRY_UNPUBLISH].includes(eventName)) {
-      populatedEntry = await strapi.db.query(uid).findOne({ where: { id: entry.id }, populate });
-    }
-    const sanitizedEntry = await sanitize.sanitizers.defaultSanitizeOutput(
-      {
-        schema: model,
-        getModel: (uid2) => strapi.getModel(uid2)
-      },
-      populatedEntry
-    );
-    await strapi.eventHub.emit(eventName, {
-      model: model.modelName,
-      uid: model.uid,
-      entry: sanitizedEntry
-    });
-  };
-  return {
-    /**
+/**
+ * Manager to trigger entry related events
+ *
+ * It will populate the entry if it is not a delete event.
+ * So the event payload will contain the full entry.
+ */ const createEventManager = (strapi, uid)=>{
+    const populate = getDeepPopulate(uid, {});
+    const model = strapi.getModel(uid);
+    const emitEvent = async (eventName, entry)=>{
+        // There is no need to populate the entry if it has been deleted
+        let populatedEntry = entry;
+        if (![
+            EVENTS.ENTRY_DELETE,
+            EVENTS.ENTRY_UNPUBLISH
+        ].includes(eventName)) {
+            populatedEntry = await strapi.db.query(uid).findOne({
+                where: {
+                    id: entry.id
+                },
+                populate
+            });
+        }
+        const sanitizedEntry = await sanitize.sanitizers.defaultSanitizeOutput({
+            schema: model,
+            getModel: (uid)=>strapi.getModel(uid)
+        }, populatedEntry);
+        await strapi.eventHub.emit(eventName, {
+            model: model.modelName,
+            uid: model.uid,
+            entry: sanitizedEntry
+        });
+    };
+    return {
+        /**
      * strapi.db.query might reuse the transaction used in the doc service request,
      * so this is executed after that transaction is committed.
-     */
-    emitEvent(eventName, entry) {
-      strapi.db.transaction(({ onCommit }) => {
-        onCommit(() => emitEvent(eventName, entry));
-      });
-    }
-  };
-};
-export {
-  createEventManager
+     */ emitEvent (eventName, entry) {
+            strapi.db.transaction(({ onCommit })=>{
+                onCommit(()=>emitEvent(eventName, entry));
+            });
+        }
+    };
 };
+
+export { createEventManager };
 //# sourceMappingURL=events.mjs.map

package/dist/services/document-service/events.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"events.mjs","sources":["../../../src/services/document-service/events.ts"],"sourcesContent":["import { UID, Utils, Modules, Core } from '@strapi/types';\nimport { sanitize } from '@strapi/utils';\n\nimport { getDeepPopulate } from './utils/populate';\n\nconst EVENTS = {\n  ENTRY_CREATE: 'entry.create',\n  ENTRY_UPDATE: 'entry.update',\n  ENTRY_DELETE: 'entry.delete',\n  ENTRY_PUBLISH: 'entry.publish',\n  ENTRY_UNPUBLISH: 'entry.unpublish',\n  ENTRY_DRAFT_DISCARD: 'entry.draft-discard',\n};\n\ntype EventName = Utils.Object.Values<typeof EVENTS>;\n\n/**\n * Manager to trigger entry related events\n *\n * It will populate the entry if it is not a delete event.\n * So the event payload will contain the full entry.\n */\nconst createEventManager = (strapi: Core.Strapi, uid: UID.Schema) => {\n  const populate = getDeepPopulate(uid, {});\n  const model = strapi.getModel(uid);\n\n  const emitEvent = async (eventName: EventName, entry: Modules.Documents.AnyDocument) => {\n    // There is no need to populate the entry if it has been deleted\n    let populatedEntry = entry;\n    if (![EVENTS.ENTRY_DELETE, EVENTS.ENTRY_UNPUBLISH].includes(eventName)) {\n      populatedEntry = await strapi.db.query(uid).findOne({ where: { id: entry.id }, populate });\n    }\n\n    const sanitizedEntry = await sanitize.sanitizers.defaultSanitizeOutput(\n      {\n        schema: model,\n        getModel: (uid) => strapi.getModel(uid as UID.Schema),\n      },\n      populatedEntry\n    );\n\n    await strapi.eventHub.emit(eventName, {\n      model: model.modelName,\n      uid: model.uid,\n      entry: sanitizedEntry,\n    });\n  };\n\n  return {\n    /**\n     * strapi.db.query might reuse the transaction used in the doc service request,\n     * so this is executed after that transaction is committed.\n     */\n    emitEvent(eventName: EventName, entry: Modules.Documents.AnyDocument) {\n      strapi.db.transaction(({ onCommit }) => {\n        onCommit(() => emitEvent(eventName, entry));\n      });\n    },\n  };\n};\n\nexport { createEventManager };\n"],"names":["uid"],"mappings":";;AAKA,MAAM,SAAS;AAAA,EACb,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,eAAe;AAAA,EACf,iBAAiB;AAAA,EACjB,qBAAqB;AACvB;AAUM,MAAA,qBAAqB,CAAC,QAAqB,QAAoB;AACnE,QAAM,WAAW,gBAAgB,KAAK,CAAE,CAAA;AAClC,QAAA,QAAQ,OAAO,SAAS,GAAG;AAE3B,QAAA,YAAY,OAAO,WAAsB,UAAyC;AAEtF,QAAI,iBAAiB;AACjB,QAAA,CAAC,CAAC,OAAO,cAAc,OAAO,eAAe,EAAE,SAAS,SAAS,GAAG;AACtE,uBAAiB,MAAM,OAAO,GAAG,MAAM,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,MAAM,GAAG,GAAG,SAAU,CAAA;AAAA,IAC3F;AAEM,UAAA,iBAAiB,MAAM,SAAS,WAAW;AAAA,MAC/C;AAAA,QACE,QAAQ;AAAA,QACR,UAAU,CAACA,SAAQ,OAAO,SAASA,IAAiB;AAAA,MACtD;AAAA,MACA;AAAA,IAAA;AAGI,UAAA,OAAO,SAAS,KAAK,WAAW;AAAA,MACpC,OAAO,MAAM;AAAA,MACb,KAAK,MAAM;AAAA,MACX,OAAO;AAAA,IAAA,CACR;AAAA,EAAA;AAGI,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAKL,UAAU,WAAsB,OAAsC;AACpE,aAAO,GAAG,YAAY,CAAC,EAAE,eAAe;AACtC,iBAAS,MAAM,UAAU,WAAW,KAAK,CAAC;AAAA,MAAA,CAC3C;AAAA,IACH;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"events.mjs","sources":["../../../src/services/document-service/events.ts"],"sourcesContent":["import type { UID, Utils, Modules, Core } from '@strapi/types';\nimport { sanitize } from '@strapi/utils';\n\nimport { getDeepPopulate } from './utils/populate';\n\nconst EVENTS = {\n  ENTRY_CREATE: 'entry.create',\n  ENTRY_UPDATE: 'entry.update',\n  ENTRY_DELETE: 'entry.delete',\n  ENTRY_PUBLISH: 'entry.publish',\n  ENTRY_UNPUBLISH: 'entry.unpublish',\n  ENTRY_DRAFT_DISCARD: 'entry.draft-discard',\n};\n\ntype EventName = Utils.Object.Values<typeof EVENTS>;\n\n/**\n * Manager to trigger entry related events\n *\n * It will populate the entry if it is not a delete event.\n * So the event payload will contain the full entry.\n */\nconst createEventManager = (strapi: Core.Strapi, uid: UID.Schema) => {\n  const populate = getDeepPopulate(uid, {});\n  const model = strapi.getModel(uid);\n\n  const emitEvent = async (eventName: EventName, entry: Modules.Documents.AnyDocument) => {\n    // There is no need to populate the entry if it has been deleted\n    let populatedEntry = entry;\n    if (![EVENTS.ENTRY_DELETE, EVENTS.ENTRY_UNPUBLISH].includes(eventName)) {\n      populatedEntry = await strapi.db.query(uid).findOne({ where: { id: entry.id }, populate });\n    }\n\n    const sanitizedEntry = await sanitize.sanitizers.defaultSanitizeOutput(\n      {\n        schema: model,\n        getModel: (uid) => strapi.getModel(uid as UID.Schema),\n      },\n      populatedEntry\n    );\n\n    await strapi.eventHub.emit(eventName, {\n      model: model.modelName,\n      uid: model.uid,\n      entry: sanitizedEntry,\n    });\n  };\n\n  return {\n    /**\n     * strapi.db.query might reuse the transaction used in the doc service request,\n     * so this is executed after that transaction is committed.\n     */\n    emitEvent(eventName: EventName, entry: Modules.Documents.AnyDocument) {\n      strapi.db.transaction(({ onCommit }) => {\n        onCommit(() => emitEvent(eventName, entry));\n      });\n    },\n  };\n};\n\nexport { createEventManager };\n"],"names":["EVENTS","ENTRY_CREATE","ENTRY_UPDATE","ENTRY_DELETE","ENTRY_PUBLISH","ENTRY_UNPUBLISH","ENTRY_DRAFT_DISCARD","createEventManager","strapi","uid","populate","getDeepPopulate","model","getModel","emitEvent","eventName","entry","populatedEntry","includes","db","query","findOne","where","id","sanitizedEntry","sanitize","sanitizers","defaultSanitizeOutput","schema","eventHub","emit","modelName","transaction","onCommit"],"mappings":";;;AAKA,MAAMA,MAAS,GAAA;IACbC,YAAc,EAAA,cAAA;IACdC,YAAc,EAAA,cAAA;IACdC,YAAc,EAAA,cAAA;IACdC,aAAe,EAAA,eAAA;IACfC,eAAiB,EAAA,iBAAA;IACjBC,mBAAqB,EAAA;AACvB,CAAA;AAIA;;;;;IAMA,MAAMC,kBAAqB,GAAA,CAACC,MAAqBC,EAAAA,GAAAA,GAAAA;IAC/C,MAAMC,QAAAA,GAAWC,eAAgBF,CAAAA,GAAAA,EAAK,EAAC,CAAA;IACvC,MAAMG,KAAAA,GAAQJ,MAAOK,CAAAA,QAAQ,CAACJ,GAAAA,CAAAA;IAE9B,MAAMK,SAAAA,GAAY,OAAOC,SAAsBC,EAAAA,KAAAA,GAAAA;;AAE7C,QAAA,IAAIC,cAAiBD,GAAAA,KAAAA;AACrB,QAAA,IAAI,CAAC;AAAChB,YAAAA,MAAAA,CAAOG,YAAY;AAAEH,YAAAA,MAAAA,CAAOK;SAAgB,CAACa,QAAQ,CAACH,SAAY,CAAA,EAAA;YACtEE,cAAiB,GAAA,MAAMT,OAAOW,EAAE,CAACC,KAAK,CAACX,GAAAA,CAAAA,CAAKY,OAAO,CAAC;gBAAEC,KAAO,EAAA;AAAEC,oBAAAA,EAAAA,EAAIP,MAAMO;AAAG,iBAAA;AAAGb,gBAAAA;AAAS,aAAA,CAAA;AAC1F;AAEA,QAAA,MAAMc,iBAAiB,MAAMC,QAAAA,CAASC,UAAU,CAACC,qBAAqB,CACpE;YACEC,MAAQhB,EAAAA,KAAAA;AACRC,YAAAA,QAAAA,EAAU,CAACJ,GAAAA,GAAQD,MAAOK,CAAAA,QAAQ,CAACJ,GAAAA;SAErCQ,EAAAA,cAAAA,CAAAA;AAGF,QAAA,MAAMT,MAAOqB,CAAAA,QAAQ,CAACC,IAAI,CAACf,SAAW,EAAA;AACpCH,YAAAA,KAAAA,EAAOA,MAAMmB,SAAS;AACtBtB,YAAAA,GAAAA,EAAKG,MAAMH,GAAG;YACdO,KAAOQ,EAAAA;AACT,SAAA,CAAA;AACF,KAAA;IAEA,OAAO;AACL;;;QAIAV,SAAAA,CAAAA,CAAUC,SAAoB,EAAEC,KAAoC,EAAA;AAClER,YAAAA,MAAAA,CAAOW,EAAE,CAACa,WAAW,CAAC,CAAC,EAAEC,QAAQ,EAAE,GAAA;gBACjCA,QAAS,CAAA,IAAMnB,UAAUC,SAAWC,EAAAA,KAAAA,CAAAA,CAAAA;AACtC,aAAA,CAAA;AACF;AACF,KAAA;AACF;;;;"}

package/dist/services/document-service/index.d.ts

@@ -6,6 +6,7 @@ import type { Core, Modules } from '@strapi/types';
  * - Apply default parameters to document actions
  *
  * @param strapi
+ * @param validator - validator for database entries
  * @returns DocumentService
  *
  * @example Access documents
@@ -13,5 +14,5 @@ import type { Core, Modules } from '@strapi/types';
  * const allArticles = strapi.documents('api::article.article').findMany(params)
  *
  */
-export declare const createDocumentService: (strapi: Core.Strapi) => Modules.Documents.Service;
+export declare const createDocumentService: (strapi: Core.Strapi, validator?: Modules.EntityValidator.EntityValidator) => Modules.Documents.Service;
 //# sourceMappingURL=index.d.ts.map

package/dist/services/document-service/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/document-service/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAO,MAAM,eAAe,CAAC;AAMxD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,WAAY,KAAK,MAAM,KAAG,QAAQ,SAAS,CAAC,OAmC7E,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/document-service/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAO,MAAM,eAAe,CAAC;AAQxD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,WACxB,KAAK,MAAM,cACR,QAAQ,eAAe,CAAC,eAAe,KACjD,QAAQ,SAAS,CAAC,OAmCpB,CAAC"}

package/dist/services/document-service/index.js

@@ -1,35 +1,56 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const errors = require("./middlewares/errors.js");
-const middlewareManager = require("./middlewares/middleware-manager.js");
-const repository = require("./repository.js");
-const data = require("./transform/data.js");
-const createDocumentService = (strapi) => {
-  const repositories = /* @__PURE__ */ new Map();
-  const middlewares = middlewareManager.createMiddlewareManager();
-  middlewares.use(errors.databaseErrorsMiddleware);
-  const factory = function factory2(uid) {
-    if (repositories.has(uid)) {
-      return repositories.get(uid);
-    }
-    const contentType = strapi.contentType(uid);
-    const repository$1 = repository.createContentTypeRepository(uid);
-    const instance = middlewares.wrapObject(
-      repository$1,
-      { uid, contentType },
-      {
-        exclude: ["updateComponents", "omitComponentData"]
-      }
-    );
-    repositories.set(uid, instance);
-    return instance;
-  };
-  return Object.assign(factory, {
-    utils: {
-      transformData: data.transformData
-    },
-    use: middlewares.use.bind(middlewares)
-  });
+'use strict';
+
+var errors = require('./middlewares/errors.js');
+var middlewareManager = require('./middlewares/middleware-manager.js');
+var repository = require('./repository.js');
+var data = require('./transform/data.js');
+var index = require('../entity-validator/index.js');
+
+/**
+ * Repository to :
+ * - Access documents via actions (findMany, findOne, create, update, delete, ...)
+ * - Execute middlewares on document actions
+ * - Apply default parameters to document actions
+ *
+ * @param strapi
+ * @param validator - validator for database entries
+ * @returns DocumentService
+ *
+ * @example Access documents
+ * const article = strapi.documents('api::article.article').create(params)
+ * const allArticles = strapi.documents('api::article.article').findMany(params)
+ *
+ */ const createDocumentService = (strapi, validator = index)=>{
+    // Cache the repositories (one per content type)
+    const repositories = new Map();
+    // Manager to handle document service middlewares
+    const middlewares = middlewareManager.createMiddlewareManager();
+    middlewares.use(errors.databaseErrorsMiddleware);
+    const factory = function factory(uid) {
+        if (repositories.has(uid)) {
+            return repositories.get(uid);
+        }
+        const contentType = strapi.contentType(uid);
+        const repository$1 = repository.createContentTypeRepository(uid, validator);
+        const instance = middlewares.wrapObject(repository$1, {
+            uid,
+            contentType
+        }, {
+            exclude: [
+                'updateComponents',
+                'omitComponentData'
+            ]
+        });
+        repositories.set(uid, instance);
+        return instance;
+    };
+    return Object.assign(factory, {
+        utils: {
+            transformData: data.transformData
+        },
+        use: middlewares.use.bind(middlewares)
+    });
 };
+
 exports.createDocumentService = createDocumentService;
 //# sourceMappingURL=index.js.map

package/dist/services/document-service/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/services/document-service/index.ts"],"sourcesContent":["import type { Core, Modules, UID } from '@strapi/types';\n\nimport { createMiddlewareManager, databaseErrorsMiddleware } from './middlewares';\nimport { createContentTypeRepository } from './repository';\nimport { transformData } from './transform/data';\n\n/**\n * Repository to :\n * - Access documents via actions (findMany, findOne, create, update, delete, ...)\n * - Execute middlewares on document actions\n * - Apply default parameters to document actions\n *\n * @param strapi\n * @returns DocumentService\n *\n * @example Access documents\n * const article = strapi.documents('api::article.article').create(params)\n * const allArticles = strapi.documents('api::article.article').findMany(params)\n *\n */\nexport const createDocumentService = (strapi: Core.Strapi): Modules.Documents.Service => {\n  // Cache the repositories (one per content type)\n  const repositories = new Map<string, Modules.Documents.ServiceInstance>();\n\n  // Manager to handle document service middlewares\n  const middlewares = createMiddlewareManager();\n  middlewares.use(databaseErrorsMiddleware);\n\n  const factory = function factory(uid: UID.ContentType) {\n    if (repositories.has(uid)) {\n      return repositories.get(uid)!;\n    }\n\n    const contentType = strapi.contentType(uid);\n    const repository = createContentTypeRepository(uid);\n\n    const instance = middlewares.wrapObject(\n      repository,\n      { uid, contentType },\n      {\n        exclude: ['updateComponents', 'omitComponentData'],\n      }\n    );\n\n    repositories.set(uid, instance);\n\n    return instance;\n  } as Modules.Documents.Service;\n\n  return Object.assign(factory, {\n    utils: {\n      transformData,\n    },\n    use: middlewares.use.bind(middlewares),\n  });\n};\n"],"names":["createMiddlewareManager","databaseErrorsMiddleware","factory","repository","createContentTypeRepository","transformData"],"mappings":";;;;;;AAoBa,MAAA,wBAAwB,CAAC,WAAmD;AAEjF,QAAA,mCAAmB;AAGzB,QAAM,cAAcA,kBAAAA;AACpB,cAAY,IAAIC,OAAAA,wBAAwB;AAElC,QAAA,UAAU,SAASC,SAAQ,KAAsB;AACjD,QAAA,aAAa,IAAI,GAAG,GAAG;AAClB,aAAA,aAAa,IAAI,GAAG;AAAA,IAC7B;AAEM,UAAA,cAAc,OAAO,YAAY,GAAG;AACpC,UAAAC,eAAaC,uCAA4B,GAAG;AAElD,UAAM,WAAW,YAAY;AAAA,MAC3BD;AAAAA,MACA,EAAE,KAAK,YAAY;AAAA,MACnB;AAAA,QACE,SAAS,CAAC,oBAAoB,mBAAmB;AAAA,MACnD;AAAA,IAAA;AAGW,iBAAA,IAAI,KAAK,QAAQ;AAEvB,WAAA;AAAA,EAAA;AAGF,SAAA,OAAO,OAAO,SAAS;AAAA,IAC5B,OAAO;AAAA,MAAA,eACLE,KAAA;AAAA,IACF;AAAA,IACA,KAAK,YAAY,IAAI,KAAK,WAAW;AAAA,EAAA,CACtC;AACH;;"}
+{"version":3,"file":"index.js","sources":["../../../src/services/document-service/index.ts"],"sourcesContent":["import type { Core, Modules, UID } from '@strapi/types';\n\nimport { createMiddlewareManager, databaseErrorsMiddleware } from './middlewares';\nimport { createContentTypeRepository } from './repository';\nimport { transformData } from './transform/data';\n\nimport entityValidator from '../entity-validator';\n\n/**\n * Repository to :\n * - Access documents via actions (findMany, findOne, create, update, delete, ...)\n * - Execute middlewares on document actions\n * - Apply default parameters to document actions\n *\n * @param strapi\n * @param validator - validator for database entries\n * @returns DocumentService\n *\n * @example Access documents\n * const article = strapi.documents('api::article.article').create(params)\n * const allArticles = strapi.documents('api::article.article').findMany(params)\n *\n */\nexport const createDocumentService = (\n  strapi: Core.Strapi,\n  validator: Modules.EntityValidator.EntityValidator = entityValidator\n): Modules.Documents.Service => {\n  // Cache the repositories (one per content type)\n  const repositories = new Map<string, Modules.Documents.ServiceInstance>();\n\n  // Manager to handle document service middlewares\n  const middlewares = createMiddlewareManager();\n  middlewares.use(databaseErrorsMiddleware);\n\n  const factory = function factory(uid: UID.ContentType) {\n    if (repositories.has(uid)) {\n      return repositories.get(uid)!;\n    }\n\n    const contentType = strapi.contentType(uid);\n    const repository = createContentTypeRepository(uid, validator);\n\n    const instance = middlewares.wrapObject(\n      repository,\n      { uid, contentType },\n      {\n        exclude: ['updateComponents', 'omitComponentData'],\n      }\n    );\n\n    repositories.set(uid, instance);\n\n    return instance;\n  } as Modules.Documents.Service;\n\n  return Object.assign(factory, {\n    utils: {\n      transformData,\n    },\n    use: middlewares.use.bind(middlewares),\n  });\n};\n"],"names":["createDocumentService","strapi","validator","entityValidator","repositories","Map","middlewares","createMiddlewareManager","use","databaseErrorsMiddleware","factory","uid","has","get","contentType","repository","createContentTypeRepository","instance","wrapObject","exclude","set","Object","assign","utils","transformData","bind"],"mappings":";;;;;;;;AAQA;;;;;;;;;;;;;;AAcC,IACYA,MAAAA,qBAAAA,GAAwB,CACnCC,MAAAA,EACAC,YAAqDC,KAAe,GAAA;;AAGpE,IAAA,MAAMC,eAAe,IAAIC,GAAAA,EAAAA;;AAGzB,IAAA,MAAMC,WAAcC,GAAAA,yCAAAA,EAAAA;AACpBD,IAAAA,WAAAA,CAAYE,GAAG,CAACC,+BAAAA,CAAAA;IAEhB,MAAMC,OAAAA,GAAU,SAASA,OAAAA,CAAQC,GAAoB,EAAA;QACnD,IAAIP,YAAAA,CAAaQ,GAAG,CAACD,GAAM,CAAA,EAAA;YACzB,OAAOP,YAAAA,CAAaS,GAAG,CAACF,GAAAA,CAAAA;AAC1B;QAEA,MAAMG,WAAAA,GAAcb,MAAOa,CAAAA,WAAW,CAACH,GAAAA,CAAAA;QACvC,MAAMI,YAAAA,GAAaC,uCAA4BL,GAAKT,EAAAA,SAAAA,CAAAA;AAEpD,QAAA,MAAMe,QAAWX,GAAAA,WAAAA,CAAYY,UAAU,CACrCH,YACA,EAAA;AAAEJ,YAAAA,GAAAA;AAAKG,YAAAA;SACP,EAAA;YACEK,OAAS,EAAA;AAAC,gBAAA,kBAAA;AAAoB,gBAAA;AAAoB;AACpD,SAAA,CAAA;QAGFf,YAAagB,CAAAA,GAAG,CAACT,GAAKM,EAAAA,QAAAA,CAAAA;QAEtB,OAAOA,QAAAA;AACT,KAAA;IAEA,OAAOI,MAAAA,CAAOC,MAAM,CAACZ,OAAS,EAAA;QAC5Ba,KAAO,EAAA;AACLC,2BAAAA;AACF,SAAA;AACAhB,QAAAA,GAAAA,EAAKF,WAAYE,CAAAA,GAAG,CAACiB,IAAI,CAACnB,WAAAA;AAC5B,KAAA,CAAA;AACF;;;;"}

package/dist/services/document-service/index.mjs

@@ -1,35 +1,54 @@
-import { databaseErrorsMiddleware } from "./middlewares/errors.mjs";
-import { createMiddlewareManager } from "./middlewares/middleware-manager.mjs";
-import { createContentTypeRepository } from "./repository.mjs";
-import { transformData } from "./transform/data.mjs";
-const createDocumentService = (strapi) => {
-  const repositories = /* @__PURE__ */ new Map();
-  const middlewares = createMiddlewareManager();
-  middlewares.use(databaseErrorsMiddleware);
-  const factory = function factory2(uid) {
-    if (repositories.has(uid)) {
-      return repositories.get(uid);
-    }
-    const contentType = strapi.contentType(uid);
-    const repository = createContentTypeRepository(uid);
-    const instance = middlewares.wrapObject(
-      repository,
-      { uid, contentType },
-      {
-        exclude: ["updateComponents", "omitComponentData"]
-      }
-    );
-    repositories.set(uid, instance);
-    return instance;
-  };
-  return Object.assign(factory, {
-    utils: {
-      transformData
-    },
-    use: middlewares.use.bind(middlewares)
-  });
-};
-export {
-  createDocumentService
+import { databaseErrorsMiddleware } from './middlewares/errors.mjs';
+import { createMiddlewareManager } from './middlewares/middleware-manager.mjs';
+import { createContentTypeRepository } from './repository.mjs';
+import { transformData } from './transform/data.mjs';
+import entityValidator from '../entity-validator/index.mjs';
+
+/**
+ * Repository to :
+ * - Access documents via actions (findMany, findOne, create, update, delete, ...)
+ * - Execute middlewares on document actions
+ * - Apply default parameters to document actions
+ *
+ * @param strapi
+ * @param validator - validator for database entries
+ * @returns DocumentService
+ *
+ * @example Access documents
+ * const article = strapi.documents('api::article.article').create(params)
+ * const allArticles = strapi.documents('api::article.article').findMany(params)
+ *
+ */ const createDocumentService = (strapi, validator = entityValidator)=>{
+    // Cache the repositories (one per content type)
+    const repositories = new Map();
+    // Manager to handle document service middlewares
+    const middlewares = createMiddlewareManager();
+    middlewares.use(databaseErrorsMiddleware);
+    const factory = function factory(uid) {
+        if (repositories.has(uid)) {
+            return repositories.get(uid);
+        }
+        const contentType = strapi.contentType(uid);
+        const repository = createContentTypeRepository(uid, validator);
+        const instance = middlewares.wrapObject(repository, {
+            uid,
+            contentType
+        }, {
+            exclude: [
+                'updateComponents',
+                'omitComponentData'
+            ]
+        });
+        repositories.set(uid, instance);
+        return instance;
+    };
+    return Object.assign(factory, {
+        utils: {
+            transformData
+        },
+        use: middlewares.use.bind(middlewares)
+    });
 };
+
+export { createDocumentService };
 //# sourceMappingURL=index.mjs.map

package/dist/services/document-service/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../../../src/services/document-service/index.ts"],"sourcesContent":["import type { Core, Modules, UID } from '@strapi/types';\n\nimport { createMiddlewareManager, databaseErrorsMiddleware } from './middlewares';\nimport { createContentTypeRepository } from './repository';\nimport { transformData } from './transform/data';\n\n/**\n * Repository to :\n * - Access documents via actions (findMany, findOne, create, update, delete, ...)\n * - Execute middlewares on document actions\n * - Apply default parameters to document actions\n *\n * @param strapi\n * @returns DocumentService\n *\n * @example Access documents\n * const article = strapi.documents('api::article.article').create(params)\n * const allArticles = strapi.documents('api::article.article').findMany(params)\n *\n */\nexport const createDocumentService = (strapi: Core.Strapi): Modules.Documents.Service => {\n  // Cache the repositories (one per content type)\n  const repositories = new Map<string, Modules.Documents.ServiceInstance>();\n\n  // Manager to handle document service middlewares\n  const middlewares = createMiddlewareManager();\n  middlewares.use(databaseErrorsMiddleware);\n\n  const factory = function factory(uid: UID.ContentType) {\n    if (repositories.has(uid)) {\n      return repositories.get(uid)!;\n    }\n\n    const contentType = strapi.contentType(uid);\n    const repository = createContentTypeRepository(uid);\n\n    const instance = middlewares.wrapObject(\n      repository,\n      { uid, contentType },\n      {\n        exclude: ['updateComponents', 'omitComponentData'],\n      }\n    );\n\n    repositories.set(uid, instance);\n\n    return instance;\n  } as Modules.Documents.Service;\n\n  return Object.assign(factory, {\n    utils: {\n      transformData,\n    },\n    use: middlewares.use.bind(middlewares),\n  });\n};\n"],"names":["factory"],"mappings":";;;;AAoBa,MAAA,wBAAwB,CAAC,WAAmD;AAEjF,QAAA,mCAAmB;AAGzB,QAAM,cAAc;AACpB,cAAY,IAAI,wBAAwB;AAElC,QAAA,UAAU,SAASA,SAAQ,KAAsB;AACjD,QAAA,aAAa,IAAI,GAAG,GAAG;AAClB,aAAA,aAAa,IAAI,GAAG;AAAA,IAC7B;AAEM,UAAA,cAAc,OAAO,YAAY,GAAG;AACpC,UAAA,aAAa,4BAA4B,GAAG;AAElD,UAAM,WAAW,YAAY;AAAA,MAC3B;AAAA,MACA,EAAE,KAAK,YAAY;AAAA,MACnB;AAAA,QACE,SAAS,CAAC,oBAAoB,mBAAmB;AAAA,MACnD;AAAA,IAAA;AAGW,iBAAA,IAAI,KAAK,QAAQ;AAEvB,WAAA;AAAA,EAAA;AAGF,SAAA,OAAO,OAAO,SAAS;AAAA,IAC5B,OAAO;AAAA,MACL;AAAA,IACF;AAAA,IACA,KAAK,YAAY,IAAI,KAAK,WAAW;AAAA,EAAA,CACtC;AACH;"}
+{"version":3,"file":"index.mjs","sources":["../../../src/services/document-service/index.ts"],"sourcesContent":["import type { Core, Modules, UID } from '@strapi/types';\n\nimport { createMiddlewareManager, databaseErrorsMiddleware } from './middlewares';\nimport { createContentTypeRepository } from './repository';\nimport { transformData } from './transform/data';\n\nimport entityValidator from '../entity-validator';\n\n/**\n * Repository to :\n * - Access documents via actions (findMany, findOne, create, update, delete, ...)\n * - Execute middlewares on document actions\n * - Apply default parameters to document actions\n *\n * @param strapi\n * @param validator - validator for database entries\n * @returns DocumentService\n *\n * @example Access documents\n * const article = strapi.documents('api::article.article').create(params)\n * const allArticles = strapi.documents('api::article.article').findMany(params)\n *\n */\nexport const createDocumentService = (\n  strapi: Core.Strapi,\n  validator: Modules.EntityValidator.EntityValidator = entityValidator\n): Modules.Documents.Service => {\n  // Cache the repositories (one per content type)\n  const repositories = new Map<string, Modules.Documents.ServiceInstance>();\n\n  // Manager to handle document service middlewares\n  const middlewares = createMiddlewareManager();\n  middlewares.use(databaseErrorsMiddleware);\n\n  const factory = function factory(uid: UID.ContentType) {\n    if (repositories.has(uid)) {\n      return repositories.get(uid)!;\n    }\n\n    const contentType = strapi.contentType(uid);\n    const repository = createContentTypeRepository(uid, validator);\n\n    const instance = middlewares.wrapObject(\n      repository,\n      { uid, contentType },\n      {\n        exclude: ['updateComponents', 'omitComponentData'],\n      }\n    );\n\n    repositories.set(uid, instance);\n\n    return instance;\n  } as Modules.Documents.Service;\n\n  return Object.assign(factory, {\n    utils: {\n      transformData,\n    },\n    use: middlewares.use.bind(middlewares),\n  });\n};\n"],"names":["createDocumentService","strapi","validator","entityValidator","repositories","Map","middlewares","createMiddlewareManager","use","databaseErrorsMiddleware","factory","uid","has","get","contentType","repository","createContentTypeRepository","instance","wrapObject","exclude","set","Object","assign","utils","transformData","bind"],"mappings":";;;;;;AAQA;;;;;;;;;;;;;;AAcC,IACYA,MAAAA,qBAAAA,GAAwB,CACnCC,MAAAA,EACAC,YAAqDC,eAAe,GAAA;;AAGpE,IAAA,MAAMC,eAAe,IAAIC,GAAAA,EAAAA;;AAGzB,IAAA,MAAMC,WAAcC,GAAAA,uBAAAA,EAAAA;AACpBD,IAAAA,WAAAA,CAAYE,GAAG,CAACC,wBAAAA,CAAAA;IAEhB,MAAMC,OAAAA,GAAU,SAASA,OAAAA,CAAQC,GAAoB,EAAA;QACnD,IAAIP,YAAAA,CAAaQ,GAAG,CAACD,GAAM,CAAA,EAAA;YACzB,OAAOP,YAAAA,CAAaS,GAAG,CAACF,GAAAA,CAAAA;AAC1B;QAEA,MAAMG,WAAAA,GAAcb,MAAOa,CAAAA,WAAW,CAACH,GAAAA,CAAAA;QACvC,MAAMI,UAAAA,GAAaC,4BAA4BL,GAAKT,EAAAA,SAAAA,CAAAA;AAEpD,QAAA,MAAMe,QAAWX,GAAAA,WAAAA,CAAYY,UAAU,CACrCH,UACA,EAAA;AAAEJ,YAAAA,GAAAA;AAAKG,YAAAA;SACP,EAAA;YACEK,OAAS,EAAA;AAAC,gBAAA,kBAAA;AAAoB,gBAAA;AAAoB;AACpD,SAAA,CAAA;QAGFf,YAAagB,CAAAA,GAAG,CAACT,GAAKM,EAAAA,QAAAA,CAAAA;QAEtB,OAAOA,QAAAA;AACT,KAAA;IAEA,OAAOI,MAAAA,CAAOC,MAAM,CAACZ,OAAS,EAAA;QAC5Ba,KAAO,EAAA;AACLC,YAAAA;AACF,SAAA;AACAhB,QAAAA,GAAAA,EAAKF,WAAYE,CAAAA,GAAG,CAACiB,IAAI,CAACnB,WAAAA;AAC5B,KAAA,CAAA;AACF;;;;"}

package/dist/services/document-service/internationalization.js

@@ -1,61 +1,77 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const strapiUtils = require("@strapi/utils");
-const fp = require("lodash/fp");
-const getDefaultLocale = async () => {
-  return strapi.plugin("i18n").service("locales").getDefaultLocale();
+'use strict';
+
+var strapiUtils = require('@strapi/utils');
+var fp = require('lodash/fp');
+
+const getDefaultLocale = async ()=>{
+    return strapi.plugin('i18n').service('locales').getDefaultLocale();
 };
-const defaultLocale = async (contentType, params) => {
-  if (!strapi.plugin("i18n").service("content-types").isLocalizedContentType(contentType)) {
+const defaultLocale = async (contentType, params)=>{
+    if (!strapi.plugin('i18n').service('content-types').isLocalizedContentType(contentType)) {
+        return params;
+    }
+    if (!params.locale) {
+        return fp.assoc('locale', await getDefaultLocale(), params);
+    }
     return params;
-  }
-  if (!params.locale) {
-    return fp.assoc("locale", await getDefaultLocale(), params);
-  }
-  return params;
 };
-const localeToLookup = (contentType, params) => {
-  if (!params.locale || !strapi.plugin("i18n").service("content-types").isLocalizedContentType(contentType)) {
-    return params;
-  }
-  if (typeof params.locale !== "string") {
-    throw new strapiUtils.errors.ValidationError(
-      `Invalid locale param ${String(params.locale)} provided. Document locales must be strings.`
-    );
-  }
-  return fp.assoc(["lookup", "locale"], params.locale, params);
+/**
+ * Add locale lookup query to the params
+ */ const localeToLookup = (contentType, params)=>{
+    if (!params.locale || !strapi.plugin('i18n').service('content-types').isLocalizedContentType(contentType)) {
+        return params;
+    }
+    if (typeof params.locale !== 'string') {
+        // localeToLookup accepts locales of '*'. This is because the document
+        // service functions that use this transform work with the '*' locale
+        // to return all locales.
+        throw new strapiUtils.errors.ValidationError(`Invalid locale param ${String(params.locale)} provided. Document locales must be strings.`);
+    }
+    return fp.assoc([
+        'lookup',
+        'locale'
+    ], params.locale, params);
 };
-const multiLocaleToLookup = (contentType, params) => {
-  if (!strapi.plugin("i18n").service("content-types").isLocalizedContentType(contentType)) {
+/**
+ * Add locale lookup query to the params
+ */ const multiLocaleToLookup = (contentType, params)=>{
+    if (!strapi.plugin('i18n').service('content-types').isLocalizedContentType(contentType)) {
+        return params;
+    }
+    if (params.locale) {
+        if (params.locale === '*') {
+            return params;
+        }
+        return fp.assoc([
+            'lookup',
+            'locale'
+        ], params.locale, params);
+    }
     return params;
-  }
-  if (params.locale) {
-    if (params.locale === "*") {
-      return params;
-    }
-    return fp.assoc(["lookup", "locale"], params.locale, params);
-  }
-  return params;
 };
-const localeToData = (contentType, params) => {
-  if (!strapi.plugin("i18n").service("content-types").isLocalizedContentType(contentType)) {
+/**
+ * Translate locale status parameter into the data that will be saved
+ */ const localeToData = (contentType, params)=>{
+    if (!strapi.plugin('i18n').service('content-types').isLocalizedContentType(contentType)) {
+        return params;
+    }
+    if (params.locale) {
+        const isValidLocale = typeof params.locale === 'string' && params.locale !== '*';
+        if (isValidLocale) {
+            return fp.assoc([
+                'data',
+                'locale'
+            ], params.locale, params);
+        }
+        throw new strapiUtils.errors.ValidationError(`Invalid locale param ${params.locale} provided. Document locales must be strings.`);
+    }
     return params;
-  }
-  if (params.locale) {
-    const isValidLocale = typeof params.locale === "string" && params.locale !== "*";
-    if (isValidLocale) {
-      return fp.assoc(["data", "locale"], params.locale, params);
-    }
-    throw new strapiUtils.errors.ValidationError(
-      `Invalid locale param ${params.locale} provided. Document locales must be strings.`
-    );
-  }
-  return params;
 };
 const defaultLocaleCurry = fp.curry(defaultLocale);
 const localeToLookupCurry = fp.curry(localeToLookup);
 const multiLocaleToLookupCurry = fp.curry(multiLocaleToLookup);
 const localeToDataCurry = fp.curry(localeToData);
+
 exports.defaultLocale = defaultLocaleCurry;
 exports.localeToData = localeToDataCurry;
 exports.localeToLookup = localeToLookupCurry;