@webiny/api-audit-logs 6.0.0-alpha.5 → 6.0.0-rc.0

package/subscriptions/headlessCms/handlers/AuditLogEntryRevisionAfterCreateEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","EntryRevisionAfterCreateEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogEntryRevisionAfterCreateHandlerImpl","constructor","context","handle","event","model","entry","payload","isPrivate","createAuditLog","HEADLESS_CMS","ENTRY_REVISION","CREATE","id","error","from","message","code","AuditLogEntryRevisionAfterCreateEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogEntryRevisionAfterCreateEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryRevisionAfterCreateEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntryRevisionFrom/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogEntryRevisionAfterCreateHandlerImpl\n    implements EntryRevisionAfterCreateEventHandler.Interface\n{\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: EntryRevisionAfterCreateEventHandler.Event): Promise<void> {\n        const { model, entry } = event.payload;\n\n        if (model.isPrivate) {\n            return;\n        }\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY_REVISION.CREATE);\n\n            await createAuditLog(\"Entry revision created\", entry, entry.id, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogEntryRevisionAfterCreateHandler\",\n                code: \"AUDIT_LOGS_AFTER_ENTRY_REVISION_CREATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogEntryRevisionAfterCreateEventHandler =\n    EntryRevisionAfterCreateEventHandler.createImplementation({\n        implementation: AuditLogEntryRevisionAfterCreateHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,oCAAoC,QAAQ,iFAAiF;AACtI,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,2CAA2C,CAEjD;EACIC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAiD,EAAiB;IAC3E,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;IAEtC,IAAIF,KAAK,CAACG,SAAS,EAAE;MACjB;IACJ;IAEA,IAAI;MACA,MAAMC,cAAc,GAAGX,cAAc,CAACD,KAAK,CAACa,YAAY,CAACC,cAAc,CAACC,MAAM,CAAC;MAE/E,MAAMH,cAAc,CAAC,wBAAwB,EAAEH,KAAK,EAAEA,KAAK,CAACO,EAAE,EAAE,IAAI,CAACX,OAAO,CAAC;IACjF,CAAC,CAAC,OAAOY,KAAK,EAAE;MACZ,MAAMnB,WAAW,CAACoB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,+DAA+D;QACxEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,4CAA4C,GACrDtB,oCAAoC,CAACuB,oBAAoB,CAAC;EACtDC,cAAc,EAAEpB,2CAA2C;EAC3DqB,YAAY,EAAE,CAACtB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/headlessCms/handlers/AuditLogEntryRevisionAfterDeleteEventHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryRevisionAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntryRevision/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogEntryRevisionAfterDeleteEventHandlerImpl implements EntryRevisionAfterDeleteEventHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: EntryRevisionAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const AuditLogEntryRevisionAfterDeleteEventHandler: typeof AuditLogEntryRevisionAfterDeleteEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntryRevision/events").EntryRevisionAfterDeleteEvent>>;
+};
+export {};

package/subscriptions/headlessCms/handlers/AuditLogEntryRevisionAfterDeleteEventHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { EntryRevisionAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntryRevision/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogEntryRevisionAfterDeleteEventHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      model,
+      entry
+    } = event.payload;
+    if (model.isPrivate) {
+      return;
+    }
+    try {
+      const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY_REVISION.DELETE);
+      await createAuditLog("Entry revision deleted", entry, entry.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogEntryRevisionAfterDeleteEventHandler",
+        code: "AUDIT_LOGS_AFTER_ENTRY_REVISION_DELETE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogEntryRevisionAfterDeleteEventHandler = EntryRevisionAfterDeleteEventHandler.createImplementation({
+  implementation: AuditLogEntryRevisionAfterDeleteEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogEntryRevisionAfterDeleteEventHandler.js.map

package/subscriptions/headlessCms/handlers/AuditLogEntryRevisionAfterDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","EntryRevisionAfterDeleteEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogEntryRevisionAfterDeleteEventHandlerImpl","constructor","context","handle","event","model","entry","payload","isPrivate","createAuditLog","HEADLESS_CMS","ENTRY_REVISION","DELETE","id","error","from","message","code","AuditLogEntryRevisionAfterDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogEntryRevisionAfterDeleteEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryRevisionAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntryRevision/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogEntryRevisionAfterDeleteEventHandlerImpl\n    implements EntryRevisionAfterDeleteEventHandler.Interface\n{\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: EntryRevisionAfterDeleteEventHandler.Event): Promise<void> {\n        const { model, entry } = event.payload;\n\n        if (model.isPrivate) {\n            return;\n        }\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY_REVISION.DELETE);\n\n            await createAuditLog(\"Entry revision deleted\", entry, entry.id, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogEntryRevisionAfterDeleteEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_ENTRY_REVISION_DELETE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogEntryRevisionAfterDeleteEventHandler =\n    EntryRevisionAfterDeleteEventHandler.createImplementation({\n        implementation: AuditLogEntryRevisionAfterDeleteEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,oCAAoC,QAAQ,6EAA6E;AAClI,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,gDAAgD,CAEtD;EACIC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAiD,EAAiB;IAC3E,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;IAEtC,IAAIF,KAAK,CAACG,SAAS,EAAE;MACjB;IACJ;IAEA,IAAI;MACA,MAAMC,cAAc,GAAGX,cAAc,CAACD,KAAK,CAACa,YAAY,CAACC,cAAc,CAACC,MAAM,CAAC;MAE/E,MAAMH,cAAc,CAAC,wBAAwB,EAAEH,KAAK,EAAEA,KAAK,CAACO,EAAE,EAAE,IAAI,CAACX,OAAO,CAAC;IACjF,CAAC,CAAC,OAAOY,KAAK,EAAE;MACZ,MAAMnB,WAAW,CAACoB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,oEAAoE;QAC7EC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,4CAA4C,GACrDtB,oCAAoC,CAACuB,oBAAoB,CAAC;EACtDC,cAAc,EAAEpB,gDAAgD;EAChEqB,YAAY,EAAE,CAACtB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterCreateEventHandler.d.ts

@@ -0,0 +1,11 @@
+import { GroupAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/CreateGroup/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogGroupAfterCreateEventHandlerImpl implements GroupAfterCreateEventHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: GroupAfterCreateEventHandler.Event): Promise<void>;
+}
+export declare const AuditLogGroupAfterCreateEventHandler: typeof AuditLogGroupAfterCreateEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentModelGroup/CreateGroup/events").GroupAfterCreateEvent>>;
+};
+export {};

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterCreateEventHandler.js

@@ -0,0 +1,30 @@
+import WebinyError from "@webiny/error";
+import { GroupAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/CreateGroup/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogGroupAfterCreateEventHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      group
+    } = event.payload;
+    try {
+      const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.GROUP.CREATE);
+      await createAuditLog("Group created", group, group.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogGroupAfterCreateEventHandler",
+        code: "AUDIT_LOGS_AFTER_GROUP_CREATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogGroupAfterCreateEventHandler = GroupAfterCreateEventHandler.createImplementation({
+  implementation: AuditLogGroupAfterCreateEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogGroupAfterCreateEventHandler.js.map

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterCreateEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","GroupAfterCreateEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogGroupAfterCreateEventHandlerImpl","constructor","context","handle","event","group","payload","createAuditLog","HEADLESS_CMS","GROUP","CREATE","id","error","from","message","code","AuditLogGroupAfterCreateEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogGroupAfterCreateEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { GroupAfterCreateEventHandler } from \"@webiny/api-headless-cms/features/contentModelGroup/CreateGroup/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogGroupAfterCreateEventHandlerImpl implements GroupAfterCreateEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: GroupAfterCreateEventHandler.Event): Promise<void> {\n        const { group } = event.payload;\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.GROUP.CREATE);\n\n            await createAuditLog(\"Group created\", group, group.id, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogGroupAfterCreateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_GROUP_CREATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogGroupAfterCreateEventHandler =\n    GroupAfterCreateEventHandler.createImplementation({\n        implementation: AuditLogGroupAfterCreateEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,4BAA4B,QAAQ,0EAA0E;AACvH,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC;IAAM,CAAC,GAAGD,KAAK,CAACE,OAAO;IAE/B,IAAI;MACA,MAAMC,cAAc,GAAGT,cAAc,CAACD,KAAK,CAACW,YAAY,CAACC,KAAK,CAACC,MAAM,CAAC;MAEtE,MAAMH,cAAc,CAAC,eAAe,EAAEF,KAAK,EAAEA,KAAK,CAACM,EAAE,EAAE,IAAI,CAACT,OAAO,CAAC;IACxE,CAAC,CAAC,OAAOU,KAAK,EAAE;MACZ,MAAMjB,WAAW,CAACkB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,4DAA4D;QACrEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CpB,4BAA4B,CAACqB,oBAAoB,CAAC;EAC9CC,cAAc,EAAElB,wCAAwC;EACxDmB,YAAY,EAAE,CAACpB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterDeleteEventHandler.d.ts

@@ -0,0 +1,11 @@
+import { GroupAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/DeleteGroup/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogGroupAfterDeleteHandlerEventImpl implements GroupAfterDeleteEventHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: GroupAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const AuditLogGroupAfterDeleteEventHandler: typeof AuditLogGroupAfterDeleteHandlerEventImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentModelGroup/DeleteGroup/events").GroupAfterDeleteEvent>>;
+};
+export {};

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterDeleteEventHandler.js

@@ -0,0 +1,30 @@
+import WebinyError from "@webiny/error";
+import { GroupAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/DeleteGroup/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogGroupAfterDeleteHandlerEventImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      group
+    } = event.payload;
+    try {
+      const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.GROUP.DELETE);
+      await createAuditLog("Group deleted", group, group.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogGroupAfterDeleteHandlerEvent",
+        code: "AUDIT_LOGS_AFTER_GROUP_DELETE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogGroupAfterDeleteEventHandler = GroupAfterDeleteEventHandler.createImplementation({
+  implementation: AuditLogGroupAfterDeleteHandlerEventImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogGroupAfterDeleteEventHandler.js.map

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","GroupAfterDeleteEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogGroupAfterDeleteHandlerEventImpl","constructor","context","handle","event","group","payload","createAuditLog","HEADLESS_CMS","GROUP","DELETE","id","error","from","message","code","AuditLogGroupAfterDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogGroupAfterDeleteEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { GroupAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentModelGroup/DeleteGroup/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogGroupAfterDeleteHandlerEventImpl implements GroupAfterDeleteEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: GroupAfterDeleteEventHandler.Event): Promise<void> {\n        const { group } = event.payload;\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.GROUP.DELETE);\n\n            await createAuditLog(\"Group deleted\", group, group.id, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogGroupAfterDeleteHandlerEvent\",\n                code: \"AUDIT_LOGS_AFTER_GROUP_DELETE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogGroupAfterDeleteEventHandler =\n    GroupAfterDeleteEventHandler.createImplementation({\n        implementation: AuditLogGroupAfterDeleteHandlerEventImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,4BAA4B,QAAQ,0EAA0E;AACvH,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC;IAAM,CAAC,GAAGD,KAAK,CAACE,OAAO;IAE/B,IAAI;MACA,MAAMC,cAAc,GAAGT,cAAc,CAACD,KAAK,CAACW,YAAY,CAACC,KAAK,CAACC,MAAM,CAAC;MAEtE,MAAMH,cAAc,CAAC,eAAe,EAAEF,KAAK,EAAEA,KAAK,CAACM,EAAE,EAAE,IAAI,CAACT,OAAO,CAAC;IACxE,CAAC,CAAC,OAAOU,KAAK,EAAE;MACZ,MAAMjB,WAAW,CAACkB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,4DAA4D;QACrEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CpB,4BAA4B,CAACqB,oBAAoB,CAAC;EAC9CC,cAAc,EAAElB,wCAAwC;EACxDmB,YAAY,EAAE,CAACpB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterUpdateEventHandler.d.ts

@@ -0,0 +1,11 @@
+import { GroupAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/UpdateGroup/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogGroupAfterUpdateEventHandlerImpl implements GroupAfterUpdateEventHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: GroupAfterUpdateEventHandler.Event): Promise<void>;
+}
+export declare const AuditLogGroupAfterUpdateEventHandler: typeof AuditLogGroupAfterUpdateEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentModelGroup/UpdateGroup/events").GroupAfterUpdateEvent>>;
+};
+export {};

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterUpdateEventHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { GroupAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/UpdateGroup/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogGroupAfterUpdateEventHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      group,
+      original
+    } = event.payload;
+    try {
+      const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.GROUP.UPDATE);
+      await createAuditLog("Group updated", {
+        before: original,
+        after: group
+      }, group.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogGroupAfterUpdateEventHandler",
+        code: "AUDIT_LOGS_AFTER_GROUP_UPDATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogGroupAfterUpdateEventHandler = GroupAfterUpdateEventHandler.createImplementation({
+  implementation: AuditLogGroupAfterUpdateEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogGroupAfterUpdateEventHandler.js.map

package/subscriptions/headlessCms/handlers/AuditLogGroupAfterUpdateEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","GroupAfterUpdateEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogGroupAfterUpdateEventHandlerImpl","constructor","context","handle","event","group","original","payload","createAuditLog","HEADLESS_CMS","GROUP","UPDATE","before","after","id","error","from","message","code","AuditLogGroupAfterUpdateEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogGroupAfterUpdateEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { GroupAfterUpdateEventHandler } from \"@webiny/api-headless-cms/features/contentModelGroup/UpdateGroup/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogGroupAfterUpdateEventHandlerImpl implements GroupAfterUpdateEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: GroupAfterUpdateEventHandler.Event): Promise<void> {\n        const { group, original } = event.payload;\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.GROUP.UPDATE);\n\n            await createAuditLog(\n                \"Group updated\",\n                { before: original, after: group },\n                group.id,\n                this.context\n            );\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogGroupAfterUpdateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_GROUP_UPDATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogGroupAfterUpdateEventHandler =\n    GroupAfterUpdateEventHandler.createImplementation({\n        implementation: AuditLogGroupAfterUpdateEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,4BAA4B,QAAQ,0EAA0E;AACvH,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAS,CAAC,GAAGF,KAAK,CAACG,OAAO;IAEzC,IAAI;MACA,MAAMC,cAAc,GAAGV,cAAc,CAACD,KAAK,CAACY,YAAY,CAACC,KAAK,CAACC,MAAM,CAAC;MAEtE,MAAMH,cAAc,CAChB,eAAe,EACf;QAAEI,MAAM,EAAEN,QAAQ;QAAEO,KAAK,EAAER;MAAM,CAAC,EAClCA,KAAK,CAACS,EAAE,EACR,IAAI,CAACZ,OACT,CAAC;IACL,CAAC,CAAC,OAAOa,KAAK,EAAE;MACZ,MAAMpB,WAAW,CAACqB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,4DAA4D;QACrEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CvB,4BAA4B,CAACwB,oBAAoB,CAAC;EAC9CC,cAAc,EAAErB,wCAAwC;EACxDsB,YAAY,EAAE,CAACvB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/headlessCms/handlers/AuditLogModelAfterCreateEventHandler.d.ts

@@ -0,0 +1,11 @@
+import { ModelAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentModel/CreateModel/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogModelAfterCreateEventHandlerImpl implements ModelAfterCreateEventHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: ModelAfterCreateEventHandler.Event): Promise<void>;
+}
+export declare const AuditLogModelAfterCreateEventHandler: typeof AuditLogModelAfterCreateEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentModel/CreateModel/events").ModelAfterCreateEvent>>;
+};
+export {};

package/subscriptions/headlessCms/handlers/AuditLogModelAfterCreateEventHandler.js

@@ -0,0 +1,30 @@
+import WebinyError from "@webiny/error";
+import { ModelAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentModel/CreateModel/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogModelAfterCreateEventHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      model
+    } = event.payload;
+    try {
+      const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.MODEL.CREATE);
+      await createAuditLog("Model created", model, model.modelId, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogModelAfterCreateEventHandler",
+        code: "AUDIT_LOGS_AFTER_MODEL_CREATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogModelAfterCreateEventHandler = ModelAfterCreateEventHandler.createImplementation({
+  implementation: AuditLogModelAfterCreateEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogModelAfterCreateEventHandler.js.map

package/subscriptions/headlessCms/handlers/AuditLogModelAfterCreateEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","ModelAfterCreateEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogModelAfterCreateEventHandlerImpl","constructor","context","handle","event","model","payload","createAuditLog","HEADLESS_CMS","MODEL","CREATE","modelId","error","from","message","code","AuditLogModelAfterCreateEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogModelAfterCreateEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { ModelAfterCreateEventHandler } from \"@webiny/api-headless-cms/features/contentModel/CreateModel/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogModelAfterCreateEventHandlerImpl implements ModelAfterCreateEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: ModelAfterCreateEventHandler.Event): Promise<void> {\n        const { model } = event.payload;\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.MODEL.CREATE);\n\n            await createAuditLog(\"Model created\", model, model.modelId, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogModelAfterCreateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_MODEL_CREATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogModelAfterCreateEventHandler =\n    ModelAfterCreateEventHandler.createImplementation({\n        implementation: AuditLogModelAfterCreateEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,4BAA4B,QAAQ,qEAAqE;AAClH,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC;IAAM,CAAC,GAAGD,KAAK,CAACE,OAAO;IAE/B,IAAI;MACA,MAAMC,cAAc,GAAGT,cAAc,CAACD,KAAK,CAACW,YAAY,CAACC,KAAK,CAACC,MAAM,CAAC;MAEtE,MAAMH,cAAc,CAAC,eAAe,EAAEF,KAAK,EAAEA,KAAK,CAACM,OAAO,EAAE,IAAI,CAACT,OAAO,CAAC;IAC7E,CAAC,CAAC,OAAOU,KAAK,EAAE;MACZ,MAAMjB,WAAW,CAACkB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,4DAA4D;QACrEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CpB,4BAA4B,CAACqB,oBAAoB,CAAC;EAC9CC,cAAc,EAAElB,wCAAwC;EACxDmB,YAAY,EAAE,CAACpB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/headlessCms/handlers/AuditLogModelAfterDeleteEventHandler.d.ts

@@ -0,0 +1,11 @@
+import { ModelAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModel/DeleteModel/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogModelAfterDeleteEventHandlerImpl implements ModelAfterDeleteEventHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: ModelAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const AuditLogModelAfterDeleteEventHandler: typeof AuditLogModelAfterDeleteEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentModel/DeleteModel/events").ModelAfterDeleteEvent>>;
+};
+export {};

package/subscriptions/headlessCms/handlers/AuditLogModelAfterDeleteEventHandler.js

@@ -0,0 +1,30 @@
+import WebinyError from "@webiny/error";
+import { ModelAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModel/DeleteModel/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogModelAfterDeleteEventHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      model
+    } = event.payload;
+    try {
+      const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.MODEL.DELETE);
+      await createAuditLog("Model deleted", model, model.modelId, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogModelAfterDeleteEventHandler",
+        code: "AUDIT_LOGS_AFTER_MODEL_DELETE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogModelAfterDeleteEventHandler = ModelAfterDeleteEventHandler.createImplementation({
+  implementation: AuditLogModelAfterDeleteEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogModelAfterDeleteEventHandler.js.map

package/subscriptions/headlessCms/handlers/AuditLogModelAfterDeleteEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","ModelAfterDeleteEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogModelAfterDeleteEventHandlerImpl","constructor","context","handle","event","model","payload","createAuditLog","HEADLESS_CMS","MODEL","DELETE","modelId","error","from","message","code","AuditLogModelAfterDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogModelAfterDeleteEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { ModelAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentModel/DeleteModel/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogModelAfterDeleteEventHandlerImpl implements ModelAfterDeleteEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: ModelAfterDeleteEventHandler.Event): Promise<void> {\n        const { model } = event.payload;\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.MODEL.DELETE);\n\n            await createAuditLog(\"Model deleted\", model, model.modelId, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogModelAfterDeleteEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_MODEL_DELETE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogModelAfterDeleteEventHandler =\n    ModelAfterDeleteEventHandler.createImplementation({\n        implementation: AuditLogModelAfterDeleteEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,4BAA4B,QAAQ,qEAAqE;AAClH,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC;IAAM,CAAC,GAAGD,KAAK,CAACE,OAAO;IAE/B,IAAI;MACA,MAAMC,cAAc,GAAGT,cAAc,CAACD,KAAK,CAACW,YAAY,CAACC,KAAK,CAACC,MAAM,CAAC;MAEtE,MAAMH,cAAc,CAAC,eAAe,EAAEF,KAAK,EAAEA,KAAK,CAACM,OAAO,EAAE,IAAI,CAACT,OAAO,CAAC;IAC7E,CAAC,CAAC,OAAOU,KAAK,EAAE;MACZ,MAAMjB,WAAW,CAACkB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,4DAA4D;QACrEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CpB,4BAA4B,CAACqB,oBAAoB,CAAC;EAC9CC,cAAc,EAAElB,wCAAwC;EACxDmB,YAAY,EAAE,CAACpB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/headlessCms/handlers/AuditLogModelAfterUpdateEventHandler.d.ts

@@ -0,0 +1,11 @@
+import { ModelAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentModel/UpdateModel/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogModelAfterUpdateEventHandlerImpl implements ModelAfterUpdateEventHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: ModelAfterUpdateEventHandler.Event): Promise<void>;
+}
+export declare const AuditLogModelAfterUpdateEventHandler: typeof AuditLogModelAfterUpdateEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentModel/UpdateModel/events").ModelAfterUpdateEvent>>;
+};
+export {};

package/subscriptions/headlessCms/handlers/AuditLogModelAfterUpdateEventHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { ModelAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentModel/UpdateModel/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogModelAfterUpdateEventHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      model,
+      original
+    } = event.payload;
+    try {
+      const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.MODEL.UPDATE);
+      await createAuditLog("Model updated", {
+        before: original,
+        after: model
+      }, model.modelId, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogModelAfterUpdateEventHandler",
+        code: "AUDIT_LOGS_AFTER_MODEL_UPDATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogModelAfterUpdateEventHandler = ModelAfterUpdateEventHandler.createImplementation({
+  implementation: AuditLogModelAfterUpdateEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogModelAfterUpdateEventHandler.js.map

package/subscriptions/headlessCms/handlers/AuditLogModelAfterUpdateEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","ModelAfterUpdateEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogModelAfterUpdateEventHandlerImpl","constructor","context","handle","event","model","original","payload","createAuditLog","HEADLESS_CMS","MODEL","UPDATE","before","after","modelId","error","from","message","code","AuditLogModelAfterUpdateEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogModelAfterUpdateEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { ModelAfterUpdateEventHandler } from \"@webiny/api-headless-cms/features/contentModel/UpdateModel/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogModelAfterUpdateEventHandlerImpl implements ModelAfterUpdateEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: ModelAfterUpdateEventHandler.Event): Promise<void> {\n        const { model, original } = event.payload;\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.MODEL.UPDATE);\n\n            await createAuditLog(\n                \"Model updated\",\n                { before: original, after: model },\n                model.modelId,\n                this.context\n            );\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogModelAfterUpdateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_MODEL_UPDATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogModelAfterUpdateEventHandler =\n    ModelAfterUpdateEventHandler.createImplementation({\n        implementation: AuditLogModelAfterUpdateEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,4BAA4B,QAAQ,qEAAqE;AAClH,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,wCAAwC,CAAmD;EAC7FC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAS,CAAC,GAAGF,KAAK,CAACG,OAAO;IAEzC,IAAI;MACA,MAAMC,cAAc,GAAGV,cAAc,CAACD,KAAK,CAACY,YAAY,CAACC,KAAK,CAACC,MAAM,CAAC;MAEtE,MAAMH,cAAc,CAChB,eAAe,EACf;QAAEI,MAAM,EAAEN,QAAQ;QAAEO,KAAK,EAAER;MAAM,CAAC,EAClCA,KAAK,CAACS,OAAO,EACb,IAAI,CAACZ,OACT,CAAC;IACL,CAAC,CAAC,OAAOa,KAAK,EAAE;MACZ,MAAMpB,WAAW,CAACqB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,4DAA4D;QACrEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CvB,4BAA4B,CAACwB,oBAAoB,CAAC;EAC9CC,cAAc,EAAErB,wCAAwC;EACxDsB,YAAY,EAAE,CAACvB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/headlessCms/index.d.ts

@@ -1,2 +1,2 @@
-import type { AuditLogsContext } from "../../types";
+import type { AuditLogsContext } from "../../types.js";
 export declare const createHeadlessCmsHooks: (context: AuditLogsContext) => void;

package/subscriptions/headlessCms/index.js

@@ -1,31 +1,37 @@
-"use strict";
+import { AuditLogEntryAfterCreateEventHandler } from "./handlers/AuditLogEntryAfterCreateEventHandler.js";
+import { AuditLogEntryAfterUpdateEventHandler } from "./handlers/AuditLogEntryAfterUpdateEventHandler.js";
+import { AuditLogEntryAfterDeleteEventHandler } from "./handlers/AuditLogEntryAfterDeleteEventHandler.js";
+import { AuditLogEntryAfterPublishEventHandler } from "./handlers/AuditLogEntryAfterPublishEventHandler.js";
+import { AuditLogEntryAfterUnpublishEventHandler } from "./handlers/AuditLogEntryAfterUnpublishEventHandler.js";
+import { AuditLogEntryAfterRestoreFromBinEventHandler } from "./handlers/AuditLogEntryAfterRestoreFromBinEventHandler.js";
+import { AuditLogEntryRevisionAfterCreateEventHandler } from "./handlers/AuditLogEntryRevisionAfterCreateEventHandler.js";
+import { AuditLogEntryRevisionAfterDeleteEventHandler } from "./handlers/AuditLogEntryRevisionAfterDeleteEventHandler.js";
+import { AuditLogModelAfterCreateEventHandler } from "./handlers/AuditLogModelAfterCreateEventHandler.js";
+import { AuditLogModelAfterUpdateEventHandler } from "./handlers/AuditLogModelAfterUpdateEventHandler.js";
+import { AuditLogModelAfterDeleteEventHandler } from "./handlers/AuditLogModelAfterDeleteEventHandler.js";
+import { AuditLogGroupAfterCreateEventHandler } from "./handlers/AuditLogGroupAfterCreateEventHandler.js";
+import { AuditLogGroupAfterUpdateEventHandler } from "./handlers/AuditLogGroupAfterUpdateEventHandler.js";
+import { AuditLogGroupAfterDeleteEventHandler } from "./handlers/AuditLogGroupAfterDeleteEventHandler.js";
+export const createHeadlessCmsHooks = context => {
+  // Register entry handlers
+  context.container.register(AuditLogEntryAfterCreateEventHandler);
+  context.container.register(AuditLogEntryAfterUpdateEventHandler);
+  context.container.register(AuditLogEntryAfterDeleteEventHandler);
+  context.container.register(AuditLogEntryAfterPublishEventHandler);
+  context.container.register(AuditLogEntryAfterUnpublishEventHandler);
+  context.container.register(AuditLogEntryAfterRestoreFromBinEventHandler);
+  context.container.register(AuditLogEntryRevisionAfterCreateEventHandler);
+  context.container.register(AuditLogEntryRevisionAfterDeleteEventHandler);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createHeadlessCmsHooks = void 0;
-var _models = require("./models");
-var _groups = require("./groups");
-var _entries = require("./entries");
-const createHeadlessCmsHooks = context => {
-  // groups
-  (0, _groups.onGroupAfterCreateHook)(context);
-  (0, _groups.onGroupAfterUpdateHook)(context);
-  (0, _groups.onGroupAfterDeleteHook)(context);
-  // models
-  (0, _models.onModelAfterCreateHook)(context);
-  (0, _models.onModelAfterUpdateHook)(context);
-  (0, _models.onModelAfterDeleteHook)(context);
-  // entries
-  (0, _entries.onEntryAfterCreateHook)(context);
-  (0, _entries.onEntryAfterUpdateHook)(context);
-  (0, _entries.onEntryAfterDeleteHook)(context);
-  (0, _entries.onEntryAfterRestoreFromTrashHook)(context);
-  (0, _entries.onEntryAfterPublishHook)(context);
-  (0, _entries.onEntryAfterUnpublishHook)(context);
-  (0, _entries.onEntryRevisionAfterCreateHook)(context);
-  (0, _entries.onEntryRevisionAfterDeleteHook)(context);
+  // Register model handlers
+  context.container.register(AuditLogModelAfterCreateEventHandler);
+  context.container.register(AuditLogModelAfterUpdateEventHandler);
+  context.container.register(AuditLogModelAfterDeleteEventHandler);
+
+  // Register group handlers
+  context.container.register(AuditLogGroupAfterCreateEventHandler);
+  context.container.register(AuditLogGroupAfterUpdateEventHandler);
+  context.container.register(AuditLogGroupAfterDeleteEventHandler);
 };
-exports.createHeadlessCmsHooks = createHeadlessCmsHooks;
 
 //# sourceMappingURL=index.js.map

package/subscriptions/headlessCms/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_models","require","_groups","_entries","createHeadlessCmsHooks","context","onGroupAfterCreateHook","onGroupAfterUpdateHook","onGroupAfterDeleteHook","onModelAfterCreateHook","onModelAfterUpdateHook","onModelAfterDeleteHook","onEntryAfterCreateHook","onEntryAfterUpdateHook","onEntryAfterDeleteHook","onEntryAfterRestoreFromTrashHook","onEntryAfterPublishHook","onEntryAfterUnpublishHook","onEntryRevisionAfterCreateHook","onEntryRevisionAfterDeleteHook","exports"],"sources":["index.ts"],"sourcesContent":["import { onModelAfterCreateHook, onModelAfterDeleteHook, onModelAfterUpdateHook } from \"./models\";\nimport { onGroupAfterCreateHook, onGroupAfterDeleteHook, onGroupAfterUpdateHook } from \"./groups\";\nimport {\n    onEntryAfterCreateHook,\n    onEntryAfterUpdateHook,\n    onEntryAfterDeleteHook,\n    onEntryAfterPublishHook,\n    onEntryAfterUnpublishHook,\n    onEntryRevisionAfterCreateHook,\n    onEntryRevisionAfterDeleteHook,\n    onEntryAfterRestoreFromTrashHook\n} from \"./entries\";\nimport type { AuditLogsContext } from \"~/types\";\n\nexport const createHeadlessCmsHooks = (context: AuditLogsContext) => {\n    // groups\n    onGroupAfterCreateHook(context);\n    onGroupAfterUpdateHook(context);\n    onGroupAfterDeleteHook(context);\n    // models\n    onModelAfterCreateHook(context);\n    onModelAfterUpdateHook(context);\n    onModelAfterDeleteHook(context);\n    // entries\n    onEntryAfterCreateHook(context);\n    onEntryAfterUpdateHook(context);\n    onEntryAfterDeleteHook(context);\n    onEntryAfterRestoreFromTrashHook(context);\n    onEntryAfterPublishHook(context);\n    onEntryAfterUnpublishHook(context);\n    onEntryRevisionAfterCreateHook(context);\n    onEntryRevisionAfterDeleteHook(context);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AAYO,MAAMG,sBAAsB,GAAIC,OAAyB,IAAK;EACjE;EACA,IAAAC,8BAAsB,EAACD,OAAO,CAAC;EAC/B,IAAAE,8BAAsB,EAACF,OAAO,CAAC;EAC/B,IAAAG,8BAAsB,EAACH,OAAO,CAAC;EAC/B;EACA,IAAAI,8BAAsB,EAACJ,OAAO,CAAC;EAC/B,IAAAK,8BAAsB,EAACL,OAAO,CAAC;EAC/B,IAAAM,8BAAsB,EAACN,OAAO,CAAC;EAC/B;EACA,IAAAO,+BAAsB,EAACP,OAAO,CAAC;EAC/B,IAAAQ,+BAAsB,EAACR,OAAO,CAAC;EAC/B,IAAAS,+BAAsB,EAACT,OAAO,CAAC;EAC/B,IAAAU,yCAAgC,EAACV,OAAO,CAAC;EACzC,IAAAW,gCAAuB,EAACX,OAAO,CAAC;EAChC,IAAAY,kCAAyB,EAACZ,OAAO,CAAC;EAClC,IAAAa,uCAA8B,EAACb,OAAO,CAAC;EACvC,IAAAc,uCAA8B,EAACd,OAAO,CAAC;AAC3C,CAAC;AAACe,OAAA,CAAAhB,sBAAA,GAAAA,sBAAA","ignoreList":[]}
+{"version":3,"names":["AuditLogEntryAfterCreateEventHandler","AuditLogEntryAfterUpdateEventHandler","AuditLogEntryAfterDeleteEventHandler","AuditLogEntryAfterPublishEventHandler","AuditLogEntryAfterUnpublishEventHandler","AuditLogEntryAfterRestoreFromBinEventHandler","AuditLogEntryRevisionAfterCreateEventHandler","AuditLogEntryRevisionAfterDeleteEventHandler","AuditLogModelAfterCreateEventHandler","AuditLogModelAfterUpdateEventHandler","AuditLogModelAfterDeleteEventHandler","AuditLogGroupAfterCreateEventHandler","AuditLogGroupAfterUpdateEventHandler","AuditLogGroupAfterDeleteEventHandler","createHeadlessCmsHooks","context","container","register"],"sources":["index.ts"],"sourcesContent":["import type { AuditLogsContext } from \"~/types.js\";\nimport { AuditLogEntryAfterCreateEventHandler } from \"./handlers/AuditLogEntryAfterCreateEventHandler.js\";\nimport { AuditLogEntryAfterUpdateEventHandler } from \"./handlers/AuditLogEntryAfterUpdateEventHandler.js\";\nimport { AuditLogEntryAfterDeleteEventHandler } from \"./handlers/AuditLogEntryAfterDeleteEventHandler.js\";\nimport { AuditLogEntryAfterPublishEventHandler } from \"./handlers/AuditLogEntryAfterPublishEventHandler.js\";\nimport { AuditLogEntryAfterUnpublishEventHandler } from \"./handlers/AuditLogEntryAfterUnpublishEventHandler.js\";\nimport { AuditLogEntryAfterRestoreFromBinEventHandler } from \"./handlers/AuditLogEntryAfterRestoreFromBinEventHandler.js\";\nimport { AuditLogEntryRevisionAfterCreateEventHandler } from \"./handlers/AuditLogEntryRevisionAfterCreateEventHandler.js\";\nimport { AuditLogEntryRevisionAfterDeleteEventHandler } from \"./handlers/AuditLogEntryRevisionAfterDeleteEventHandler.js\";\nimport { AuditLogModelAfterCreateEventHandler } from \"./handlers/AuditLogModelAfterCreateEventHandler.js\";\nimport { AuditLogModelAfterUpdateEventHandler } from \"./handlers/AuditLogModelAfterUpdateEventHandler.js\";\nimport { AuditLogModelAfterDeleteEventHandler } from \"./handlers/AuditLogModelAfterDeleteEventHandler.js\";\nimport { AuditLogGroupAfterCreateEventHandler } from \"./handlers/AuditLogGroupAfterCreateEventHandler.js\";\nimport { AuditLogGroupAfterUpdateEventHandler } from \"./handlers/AuditLogGroupAfterUpdateEventHandler.js\";\nimport { AuditLogGroupAfterDeleteEventHandler } from \"./handlers/AuditLogGroupAfterDeleteEventHandler.js\";\n\nexport const createHeadlessCmsHooks = (context: AuditLogsContext) => {\n    // Register entry handlers\n    context.container.register(AuditLogEntryAfterCreateEventHandler);\n    context.container.register(AuditLogEntryAfterUpdateEventHandler);\n    context.container.register(AuditLogEntryAfterDeleteEventHandler);\n    context.container.register(AuditLogEntryAfterPublishEventHandler);\n    context.container.register(AuditLogEntryAfterUnpublishEventHandler);\n    context.container.register(AuditLogEntryAfterRestoreFromBinEventHandler);\n    context.container.register(AuditLogEntryRevisionAfterCreateEventHandler);\n    context.container.register(AuditLogEntryRevisionAfterDeleteEventHandler);\n\n    // Register model handlers\n    context.container.register(AuditLogModelAfterCreateEventHandler);\n    context.container.register(AuditLogModelAfterUpdateEventHandler);\n    context.container.register(AuditLogModelAfterDeleteEventHandler);\n\n    // Register group handlers\n    context.container.register(AuditLogGroupAfterCreateEventHandler);\n    context.container.register(AuditLogGroupAfterUpdateEventHandler);\n    context.container.register(AuditLogGroupAfterDeleteEventHandler);\n};\n"],"mappings":"AACA,SAASA,oCAAoC;AAC7C,SAASC,oCAAoC;AAC7C,SAASC,oCAAoC;AAC7C,SAASC,qCAAqC;AAC9C,SAASC,uCAAuC;AAChD,SAASC,4CAA4C;AACrD,SAASC,4CAA4C;AACrD,SAASC,4CAA4C;AACrD,SAASC,oCAAoC;AAC7C,SAASC,oCAAoC;AAC7C,SAASC,oCAAoC;AAC7C,SAASC,oCAAoC;AAC7C,SAASC,oCAAoC;AAC7C,SAASC,oCAAoC;AAE7C,OAAO,MAAMC,sBAAsB,GAAIC,OAAyB,IAAK;EACjE;EACAA,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACjB,oCAAoC,CAAC;EAChEe,OAAO,CAACC,SAAS,CAACC,QAAQ,CAAChB,oCAAoC,CAAC;EAChEc,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACf,oCAAoC,CAAC;EAChEa,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACd,qCAAqC,CAAC;EACjEY,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACb,uCAAuC,CAAC;EACnEW,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACZ,4CAA4C,CAAC;EACxEU,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACX,4CAA4C,CAAC;EACxES,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACV,4CAA4C,CAAC;;EAExE;EACAQ,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACT,oCAAoC,CAAC;EAChEO,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACR,oCAAoC,CAAC;EAChEM,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACP,oCAAoC,CAAC;;EAEhE;EACAK,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACN,oCAAoC,CAAC;EAChEI,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACL,oCAAoC,CAAC;EAChEG,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACJ,oCAAoC,CAAC;AACpE,CAAC","ignoreList":[]}

package/subscriptions/index.d.ts

@@ -1,2 +1,2 @@
-import type { AuditLogsContext } from "../types";
+import type { AuditLogsContext } from "../types.js";
 export declare const createSubscriptionHooks: (context: AuditLogsContext) => void;

package/subscriptions/index.js

@@ -1,25 +1,16 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createSubscriptionHooks = void 0;
-var _fileManager = require("./fileManager");
-var _headlessCms = require("./headlessCms");
-var _security = require("./security");
-var _i18n = require("./i18n");
-var _mailer = require("./mailer");
-var _aco = require("./aco");
-var _apw = require("./apw");
-const createSubscriptionHooks = context => {
-  (0, _fileManager.createFileManagerHooks)(context);
-  (0, _headlessCms.createHeadlessCmsHooks)(context);
-  (0, _security.createSecurityHooks)(context);
-  (0, _i18n.createI18NHooks)(context);
-  (0, _mailer.createMailerHooks)(context);
-  (0, _aco.createAcoHooks)(context);
-  context.wcp.canUseFeature("advancedPublishingWorkflow") && (0, _apw.createApwHooks)(context);
+import { createFileManagerHooks } from "./fileManager/index.js";
+import { createHeadlessCmsHooks } from "./headlessCms/index.js";
+import { createSecurityHooks } from "./security/index.js";
+import { createMailerHooks } from "./mailer/index.js";
+import { createAcoHooks } from "./aco/index.js";
+import { createWebsiteBuilderHooks } from "./websiteBuilder/index.js";
+export const createSubscriptionHooks = context => {
+  createFileManagerHooks(context);
+  createHeadlessCmsHooks(context);
+  createSecurityHooks(context);
+  createMailerHooks(context);
+  createAcoHooks(context);
+  createWebsiteBuilderHooks(context);
 };
-exports.createSubscriptionHooks = createSubscriptionHooks;
 
 //# sourceMappingURL=index.js.map

package/subscriptions/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_fileManager","require","_headlessCms","_security","_i18n","_mailer","_aco","_apw","createSubscriptionHooks","context","createFileManagerHooks","createHeadlessCmsHooks","createSecurityHooks","createI18NHooks","createMailerHooks","createAcoHooks","wcp","canUseFeature","createApwHooks","exports"],"sources":["index.ts"],"sourcesContent":["import { createFileManagerHooks } from \"./fileManager\";\nimport { createHeadlessCmsHooks } from \"./headlessCms\";\nimport { createSecurityHooks } from \"./security\";\nimport { createI18NHooks } from \"./i18n\";\nimport { createMailerHooks } from \"./mailer\";\nimport { createAcoHooks } from \"./aco\";\nimport { createApwHooks } from \"./apw\";\nimport type { AuditLogsContext } from \"~/types\";\n\nexport const createSubscriptionHooks = (context: AuditLogsContext) => {\n    createFileManagerHooks(context);\n    createHeadlessCmsHooks(context);\n    createSecurityHooks(context);\n    createI18NHooks(context);\n    createMailerHooks(context);\n    createAcoHooks(context);\n    context.wcp.canUseFeature(\"advancedPublishingWorkflow\") && createApwHooks(context);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,KAAA,GAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,IAAA,GAAAL,OAAA;AACA,IAAAM,IAAA,GAAAN,OAAA;AAGO,MAAMO,uBAAuB,GAAIC,OAAyB,IAAK;EAClE,IAAAC,mCAAsB,EAACD,OAAO,CAAC;EAC/B,IAAAE,mCAAsB,EAACF,OAAO,CAAC;EAC/B,IAAAG,6BAAmB,EAACH,OAAO,CAAC;EAC5B,IAAAI,qBAAe,EAACJ,OAAO,CAAC;EACxB,IAAAK,yBAAiB,EAACL,OAAO,CAAC;EAC1B,IAAAM,mBAAc,EAACN,OAAO,CAAC;EACvBA,OAAO,CAACO,GAAG,CAACC,aAAa,CAAC,4BAA4B,CAAC,IAAI,IAAAC,mBAAc,EAACT,OAAO,CAAC;AACtF,CAAC;AAACU,OAAA,CAAAX,uBAAA,GAAAA,uBAAA","ignoreList":[]}
+{"version":3,"names":["createFileManagerHooks","createHeadlessCmsHooks","createSecurityHooks","createMailerHooks","createAcoHooks","createWebsiteBuilderHooks","createSubscriptionHooks","context"],"sources":["index.ts"],"sourcesContent":["import { createFileManagerHooks } from \"./fileManager/index.js\";\nimport { createHeadlessCmsHooks } from \"./headlessCms/index.js\";\nimport { createSecurityHooks } from \"./security/index.js\";\nimport { createMailerHooks } from \"./mailer/index.js\";\nimport { createAcoHooks } from \"./aco/index.js\";\nimport { createWebsiteBuilderHooks } from \"~/subscriptions/websiteBuilder/index.js\";\nimport type { AuditLogsContext } from \"~/types.js\";\n\nexport const createSubscriptionHooks = (context: AuditLogsContext) => {\n    createFileManagerHooks(context);\n    createHeadlessCmsHooks(context);\n    createSecurityHooks(context);\n    createMailerHooks(context);\n    createAcoHooks(context);\n    createWebsiteBuilderHooks(context);\n};\n"],"mappings":"AAAA,SAASA,sBAAsB;AAC/B,SAASC,sBAAsB;AAC/B,SAASC,mBAAmB;AAC5B,SAASC,iBAAiB;AAC1B,SAASC,cAAc;AACvB,SAASC,yBAAyB;AAGlC,OAAO,MAAMC,uBAAuB,GAAIC,OAAyB,IAAK;EAClEP,sBAAsB,CAACO,OAAO,CAAC;EAC/BN,sBAAsB,CAACM,OAAO,CAAC;EAC/BL,mBAAmB,CAACK,OAAO,CAAC;EAC5BJ,iBAAiB,CAACI,OAAO,CAAC;EAC1BH,cAAc,CAACG,OAAO,CAAC;EACvBF,yBAAyB,CAACE,OAAO,CAAC;AACtC,CAAC","ignoreList":[]}

package/subscriptions/mailer/handlers/AuditLogMailerSettingsAfterSaveHandler.d.ts

@@ -0,0 +1,11 @@
+import { MailerSettingsAfterSaveHandler } from "@webiny/api-mailer/features/SaveSettings/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogMailerSettingsAfterSaveHandlerImpl implements MailerSettingsAfterSaveHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: MailerSettingsAfterSaveHandler.Event): Promise<void>;
+}
+export declare const AuditLogMailerSettingsAfterSaveHandler: typeof AuditLogMailerSettingsAfterSaveHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-core/features/EventPublisher").DomainEvent<import("@webiny/api-mailer/features/SaveSettings/abstractions").MailerSettingsAfterSavePayload>>>;
+};
+export {};

package/subscriptions/mailer/handlers/AuditLogMailerSettingsAfterSaveHandler.js

@@ -0,0 +1,32 @@
+import WebinyError from "@webiny/error";
+import { MailerSettingsAfterSaveHandler } from "@webiny/api-mailer/features/SaveSettings/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+class AuditLogMailerSettingsAfterSaveHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    try {
+      const {
+        settings
+      } = event.payload;
+      const createAuditLog = getAuditConfig(AUDIT.MAILER.SETTINGS.UPDATE);
+      await createAuditLog("Settings updated", {
+        after: settings
+      }, "-", this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogMailerSettingsAfterSaveHandler",
+        code: "AUDIT_LOGS_AFTER_MAILER_SETTINGS_SAVE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogMailerSettingsAfterSaveHandler = MailerSettingsAfterSaveHandler.createImplementation({
+  implementation: AuditLogMailerSettingsAfterSaveHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogMailerSettingsAfterSaveHandler.js.map

package/subscriptions/mailer/handlers/AuditLogMailerSettingsAfterSaveHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","MailerSettingsAfterSaveHandler","AuditLogsContext","AUDIT","getAuditConfig","AuditLogMailerSettingsAfterSaveHandlerImpl","constructor","context","handle","event","settings","payload","createAuditLog","MAILER","SETTINGS","UPDATE","after","error","from","message","code","AuditLogMailerSettingsAfterSaveHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogMailerSettingsAfterSaveHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { MailerSettingsAfterSaveHandler } from \"@webiny/api-mailer/features/SaveSettings/index.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\n\nclass AuditLogMailerSettingsAfterSaveHandlerImpl\n    implements MailerSettingsAfterSaveHandler.Interface\n{\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: MailerSettingsAfterSaveHandler.Event): Promise<void> {\n        try {\n            const { settings } = event.payload;\n            const createAuditLog = getAuditConfig(AUDIT.MAILER.SETTINGS.UPDATE);\n\n            await createAuditLog(\"Settings updated\", { after: settings }, \"-\", this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogMailerSettingsAfterSaveHandler\",\n                code: \"AUDIT_LOGS_AFTER_MAILER_SETTINGS_SAVE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogMailerSettingsAfterSaveHandler =\n    MailerSettingsAfterSaveHandler.createImplementation({\n        implementation: AuditLogMailerSettingsAfterSaveHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,8BAA8B,QAAQ,mDAAmD;AAClG,SAASC,gBAAgB;AACzB,SAASC,KAAK;AACd,SAASC,cAAc;AAEvB,MAAMC,0CAA0C,CAEhD;EACIC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAA2C,EAAiB;IACrE,IAAI;MACA,MAAM;QAAEC;MAAS,CAAC,GAAGD,KAAK,CAACE,OAAO;MAClC,MAAMC,cAAc,GAAGR,cAAc,CAACD,KAAK,CAACU,MAAM,CAACC,QAAQ,CAACC,MAAM,CAAC;MAEnE,MAAMH,cAAc,CAAC,kBAAkB,EAAE;QAAEI,KAAK,EAAEN;MAAS,CAAC,EAAE,GAAG,EAAE,IAAI,CAACH,OAAO,CAAC;IACpF,CAAC,CAAC,OAAOU,KAAK,EAAE;MACZ,MAAMjB,WAAW,CAACkB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,8DAA8D;QACvEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,sCAAsC,GAC/CpB,8BAA8B,CAACqB,oBAAoB,CAAC;EAChDC,cAAc,EAAElB,0CAA0C;EAC1DmB,YAAY,EAAE,CAACtB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}