@webiny/api-audit-logs 6.0.0-beta.0 → 6.0.0-rc.1

package/subscriptions/fileManager/handlers/AuditLogFileAfterDeleteHandler.d.ts

@@ -0,0 +1,11 @@
+import { FileAfterDeleteHandler } from "@webiny/api-file-manager/features/file/DeleteFile/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogFileAfterDeleteHandlerImpl implements FileAfterDeleteHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: FileAfterDeleteHandler.Event): Promise<void>;
+}
+export declare const AuditLogFileAfterDeleteHandler: typeof AuditLogFileAfterDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-file-manager/features/file/DeleteFile/events").FileAfterDeleteEvent>>;
+};
+export {};

package/subscriptions/fileManager/handlers/AuditLogFileAfterDeleteHandler.js

@@ -0,0 +1,30 @@
+import WebinyError from "@webiny/error";
+import { FileAfterDeleteHandler } from "@webiny/api-file-manager/features/file/DeleteFile/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+class AuditLogFileAfterDeleteHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    try {
+      const {
+        file
+      } = event.payload;
+      const createAuditLog = getAuditConfig(AUDIT.FILE_MANAGER.FILE.DELETE);
+      await createAuditLog("File deleted", file, file.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogFileAfterDeleteHandler",
+        code: "AUDIT_LOGS_AFTER_FILE_DELETE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogFileAfterDeleteHandler = FileAfterDeleteHandler.createImplementation({
+  implementation: AuditLogFileAfterDeleteHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogFileAfterDeleteHandler.js.map

package/subscriptions/fileManager/handlers/AuditLogFileAfterDeleteHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","FileAfterDeleteHandler","AuditLogsContext","AUDIT","getAuditConfig","AuditLogFileAfterDeleteHandlerImpl","constructor","context","handle","event","file","payload","createAuditLog","FILE_MANAGER","FILE","DELETE","id","error","from","message","code","AuditLogFileAfterDeleteHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogFileAfterDeleteHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { FileAfterDeleteHandler } from \"@webiny/api-file-manager/features/file/DeleteFile/index.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\n\nclass AuditLogFileAfterDeleteHandlerImpl implements FileAfterDeleteHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: FileAfterDeleteHandler.Event): Promise<void> {\n        try {\n            const { file } = event.payload;\n            const createAuditLog = getAuditConfig(AUDIT.FILE_MANAGER.FILE.DELETE);\n\n            await createAuditLog(\"File deleted\", file, file.id, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogFileAfterDeleteHandler\",\n                code: \"AUDIT_LOGS_AFTER_FILE_DELETE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogFileAfterDeleteHandler = FileAfterDeleteHandler.createImplementation({\n    implementation: AuditLogFileAfterDeleteHandlerImpl,\n    dependencies: [AuditLogsContext]\n});\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,sBAAsB,QAAQ,4DAA4D;AACnG,SAASC,gBAAgB;AACzB,SAASC,KAAK;AACd,SAASC,cAAc;AAEvB,MAAMC,kCAAkC,CAA6C;EACjFC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAmC,EAAiB;IAC7D,IAAI;MACA,MAAM;QAAEC;MAAK,CAAC,GAAGD,KAAK,CAACE,OAAO;MAC9B,MAAMC,cAAc,GAAGR,cAAc,CAACD,KAAK,CAACU,YAAY,CAACC,IAAI,CAACC,MAAM,CAAC;MAErE,MAAMH,cAAc,CAAC,cAAc,EAAEF,IAAI,EAAEA,IAAI,CAACM,EAAE,EAAE,IAAI,CAACT,OAAO,CAAC;IACrE,CAAC,CAAC,OAAOU,KAAK,EAAE;MACZ,MAAMjB,WAAW,CAACkB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,sDAAsD;QAC/DC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,8BAA8B,GAAGpB,sBAAsB,CAACqB,oBAAoB,CAAC;EACtFC,cAAc,EAAElB,kCAAkC;EAClDmB,YAAY,EAAE,CAACtB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/fileManager/handlers/AuditLogFileAfterUpdateHandler.d.ts

@@ -0,0 +1,11 @@
+import { FileAfterUpdateHandler } from "@webiny/api-file-manager/features/file/UpdateFile/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogFileAfterUpdateHandlerImpl implements FileAfterUpdateHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: FileAfterUpdateHandler.Event): Promise<void>;
+}
+export declare const AuditLogFileAfterUpdateHandler: typeof AuditLogFileAfterUpdateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-file-manager/features/file/UpdateFile/events").FileAfterUpdateEvent>>;
+};
+export {};

package/subscriptions/fileManager/handlers/AuditLogFileAfterUpdateHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { FileAfterUpdateHandler } from "@webiny/api-file-manager/features/file/UpdateFile/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+class AuditLogFileAfterUpdateHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    try {
+      const {
+        file,
+        original
+      } = event.payload;
+      const createAuditLog = getAuditConfig(AUDIT.FILE_MANAGER.FILE.UPDATE);
+      await createAuditLog("File updated", {
+        before: original,
+        after: file
+      }, file.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogFileAfterUpdateHandler",
+        code: "AUDIT_LOGS_AFTER_FILE_UPDATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogFileAfterUpdateHandler = FileAfterUpdateHandler.createImplementation({
+  implementation: AuditLogFileAfterUpdateHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogFileAfterUpdateHandler.js.map

package/subscriptions/fileManager/handlers/AuditLogFileAfterUpdateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","FileAfterUpdateHandler","AuditLogsContext","AUDIT","getAuditConfig","AuditLogFileAfterUpdateHandlerImpl","constructor","context","handle","event","file","original","payload","createAuditLog","FILE_MANAGER","FILE","UPDATE","before","after","id","error","from","message","code","AuditLogFileAfterUpdateHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogFileAfterUpdateHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { FileAfterUpdateHandler } from \"@webiny/api-file-manager/features/file/UpdateFile/index.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\n\nclass AuditLogFileAfterUpdateHandlerImpl implements FileAfterUpdateHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: FileAfterUpdateHandler.Event): Promise<void> {\n        try {\n            const { file, original } = event.payload;\n            const createAuditLog = getAuditConfig(AUDIT.FILE_MANAGER.FILE.UPDATE);\n\n            await createAuditLog(\n                \"File updated\",\n                { before: original, after: file },\n                file.id,\n                this.context\n            );\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogFileAfterUpdateHandler\",\n                code: \"AUDIT_LOGS_AFTER_FILE_UPDATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogFileAfterUpdateHandler = FileAfterUpdateHandler.createImplementation({\n    implementation: AuditLogFileAfterUpdateHandlerImpl,\n    dependencies: [AuditLogsContext]\n});\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,sBAAsB,QAAQ,4DAA4D;AACnG,SAASC,gBAAgB;AACzB,SAASC,KAAK;AACd,SAASC,cAAc;AAEvB,MAAMC,kCAAkC,CAA6C;EACjFC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAmC,EAAiB;IAC7D,IAAI;MACA,MAAM;QAAEC,IAAI;QAAEC;MAAS,CAAC,GAAGF,KAAK,CAACG,OAAO;MACxC,MAAMC,cAAc,GAAGT,cAAc,CAACD,KAAK,CAACW,YAAY,CAACC,IAAI,CAACC,MAAM,CAAC;MAErE,MAAMH,cAAc,CAChB,cAAc,EACd;QAAEI,MAAM,EAAEN,QAAQ;QAAEO,KAAK,EAAER;MAAK,CAAC,EACjCA,IAAI,CAACS,EAAE,EACP,IAAI,CAACZ,OACT,CAAC;IACL,CAAC,CAAC,OAAOa,KAAK,EAAE;MACZ,MAAMpB,WAAW,CAACqB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,sDAAsD;QAC/DC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,8BAA8B,GAAGvB,sBAAsB,CAACwB,oBAAoB,CAAC;EACtFC,cAAc,EAAErB,kCAAkC;EAClDsB,YAAY,EAAE,CAACzB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/fileManager/handlers/AuditLogSettingsAfterUpdateHandler.d.ts

@@ -0,0 +1,11 @@
+import { SettingsAfterUpdateHandler } from "@webiny/api-file-manager/features/settings/UpdateSettings/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+declare class AuditLogSettingsAfterUpdateHandlerImpl implements SettingsAfterUpdateHandler.Interface {
+    private context;
+    constructor(context: AuditLogsContext.Interface);
+    handle(event: SettingsAfterUpdateHandler.Event): Promise<void>;
+}
+export declare const AuditLogSettingsAfterUpdateHandler: typeof AuditLogSettingsAfterUpdateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-file-manager/features/settings/UpdateSettings/events").SettingsAfterUpdateEvent>>;
+};
+export {};

package/subscriptions/fileManager/handlers/AuditLogSettingsAfterUpdateHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { SettingsAfterUpdateHandler } from "@webiny/api-file-manager/features/settings/UpdateSettings/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+class AuditLogSettingsAfterUpdateHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    try {
+      const {
+        settings,
+        original
+      } = event.payload;
+      const createAuditLog = getAuditConfig(AUDIT.FILE_MANAGER.SETTINGS.UPDATE);
+      await createAuditLog("Settings updated", {
+        before: original,
+        after: settings
+      }, "-", this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogSettingsAfterUpdateHandler",
+        code: "AUDIT_LOGS_AFTER_SETTINGS_UPDATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogSettingsAfterUpdateHandler = SettingsAfterUpdateHandler.createImplementation({
+  implementation: AuditLogSettingsAfterUpdateHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogSettingsAfterUpdateHandler.js.map

package/subscriptions/fileManager/handlers/AuditLogSettingsAfterUpdateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","SettingsAfterUpdateHandler","AuditLogsContext","AUDIT","getAuditConfig","AuditLogSettingsAfterUpdateHandlerImpl","constructor","context","handle","event","settings","original","payload","createAuditLog","FILE_MANAGER","SETTINGS","UPDATE","before","after","error","from","message","code","AuditLogSettingsAfterUpdateHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogSettingsAfterUpdateHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { SettingsAfterUpdateHandler } from \"@webiny/api-file-manager/features/settings/UpdateSettings/index.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\n\nclass AuditLogSettingsAfterUpdateHandlerImpl implements SettingsAfterUpdateHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: SettingsAfterUpdateHandler.Event): Promise<void> {\n        try {\n            const { settings, original } = event.payload;\n            const createAuditLog = getAuditConfig(AUDIT.FILE_MANAGER.SETTINGS.UPDATE);\n\n            await createAuditLog(\n                \"Settings updated\",\n                { before: original, after: settings },\n                \"-\",\n                this.context\n            );\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogSettingsAfterUpdateHandler\",\n                code: \"AUDIT_LOGS_AFTER_SETTINGS_UPDATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogSettingsAfterUpdateHandler = SettingsAfterUpdateHandler.createImplementation({\n    implementation: AuditLogSettingsAfterUpdateHandlerImpl,\n    dependencies: [AuditLogsContext]\n});\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,0BAA0B,QAAQ,oEAAoE;AAC/G,SAASC,gBAAgB;AACzB,SAASC,KAAK;AACd,SAASC,cAAc;AAEvB,MAAMC,sCAAsC,CAAiD;EACzFC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAuC,EAAiB;IACjE,IAAI;MACA,MAAM;QAAEC,QAAQ;QAAEC;MAAS,CAAC,GAAGF,KAAK,CAACG,OAAO;MAC5C,MAAMC,cAAc,GAAGT,cAAc,CAACD,KAAK,CAACW,YAAY,CAACC,QAAQ,CAACC,MAAM,CAAC;MAEzE,MAAMH,cAAc,CAChB,kBAAkB,EAClB;QAAEI,MAAM,EAAEN,QAAQ;QAAEO,KAAK,EAAER;MAAS,CAAC,EACrC,GAAG,EACH,IAAI,CAACH,OACT,CAAC;IACL,CAAC,CAAC,OAAOY,KAAK,EAAE;MACZ,MAAMnB,WAAW,CAACoB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,0DAA0D;QACnEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,kCAAkC,GAAGtB,0BAA0B,CAACuB,oBAAoB,CAAC;EAC9FC,cAAc,EAAEpB,sCAAsC;EACtDqB,YAAY,EAAE,CAACxB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/subscriptions/fileManager/index.d.ts

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

package/subscriptions/fileManager/index.js

@@ -1,17 +1,15 @@
-"use strict";
+import { AuditLogFileAfterCreateHandler } from "./handlers/AuditLogFileAfterCreateHandler.js";
+import { AuditLogFileAfterUpdateHandler } from "./handlers/AuditLogFileAfterUpdateHandler.js";
+import { AuditLogFileAfterDeleteHandler } from "./handlers/AuditLogFileAfterDeleteHandler.js";
+import { AuditLogSettingsAfterUpdateHandler } from "./handlers/AuditLogSettingsAfterUpdateHandler.js";
+export const createFileManagerHooks = context => {
+  // Register file event handlers
+  context.container.register(AuditLogFileAfterCreateHandler);
+  context.container.register(AuditLogFileAfterUpdateHandler);
+  context.container.register(AuditLogFileAfterDeleteHandler);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createFileManagerHooks = void 0;
-var _files = require("./files");
-var _settings = require("./settings");
-const createFileManagerHooks = context => {
-  (0, _files.onFileAfterCreateHook)(context);
-  (0, _files.onFileAfterUpdateHook)(context);
-  (0, _files.onFileAfterDeleteHook)(context);
-  (0, _settings.onSettingsAfterUpdateHook)(context);
+  // Register settings event handlers
+  context.container.register(AuditLogSettingsAfterUpdateHandler);
 };
-exports.createFileManagerHooks = createFileManagerHooks;
 
 //# sourceMappingURL=index.js.map

package/subscriptions/fileManager/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_files","require","_settings","createFileManagerHooks","context","onFileAfterCreateHook","onFileAfterUpdateHook","onFileAfterDeleteHook","onSettingsAfterUpdateHook","exports"],"sources":["index.ts"],"sourcesContent":["import { onFileAfterCreateHook, onFileAfterUpdateHook, onFileAfterDeleteHook } from \"./files\";\nimport { onSettingsAfterUpdateHook } from \"./settings\";\n\nimport { AuditLogsContext } from \"~/types\";\n\nexport const createFileManagerHooks = (context: AuditLogsContext) => {\n    onFileAfterCreateHook(context);\n    onFileAfterUpdateHook(context);\n    onFileAfterDeleteHook(context);\n    onSettingsAfterUpdateHook(context);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAIO,MAAME,sBAAsB,GAAIC,OAAyB,IAAK;EACjE,IAAAC,4BAAqB,EAACD,OAAO,CAAC;EAC9B,IAAAE,4BAAqB,EAACF,OAAO,CAAC;EAC9B,IAAAG,4BAAqB,EAACH,OAAO,CAAC;EAC9B,IAAAI,mCAAyB,EAACJ,OAAO,CAAC;AACtC,CAAC;AAACK,OAAA,CAAAN,sBAAA,GAAAA,sBAAA","ignoreList":[]}
+{"version":3,"names":["AuditLogFileAfterCreateHandler","AuditLogFileAfterUpdateHandler","AuditLogFileAfterDeleteHandler","AuditLogSettingsAfterUpdateHandler","createFileManagerHooks","context","container","register"],"sources":["index.ts"],"sourcesContent":["import { AuditLogFileAfterCreateHandler } from \"./handlers/AuditLogFileAfterCreateHandler.js\";\nimport { AuditLogFileAfterUpdateHandler } from \"./handlers/AuditLogFileAfterUpdateHandler.js\";\nimport { AuditLogFileAfterDeleteHandler } from \"./handlers/AuditLogFileAfterDeleteHandler.js\";\nimport { AuditLogSettingsAfterUpdateHandler } from \"./handlers/AuditLogSettingsAfterUpdateHandler.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nexport const createFileManagerHooks = (context: AuditLogsContext.Interface) => {\n    // Register file event handlers\n    context.container.register(AuditLogFileAfterCreateHandler);\n    context.container.register(AuditLogFileAfterUpdateHandler);\n    context.container.register(AuditLogFileAfterDeleteHandler);\n\n    // Register settings event handlers\n    context.container.register(AuditLogSettingsAfterUpdateHandler);\n};\n"],"mappings":"AAAA,SAASA,8BAA8B;AACvC,SAASC,8BAA8B;AACvC,SAASC,8BAA8B;AACvC,SAASC,kCAAkC;AAG3C,OAAO,MAAMC,sBAAsB,GAAIC,OAAmC,IAAK;EAC3E;EACAA,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACP,8BAA8B,CAAC;EAC1DK,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACN,8BAA8B,CAAC;EAC1DI,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACL,8BAA8B,CAAC;;EAE1D;EACAG,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACJ,kCAAkC,CAAC;AAClE,CAAC","ignoreList":[]}

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

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

package/subscriptions/headlessCms/handlers/AuditLogEntryAfterCreateEventHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { EntryAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+class AuditLogEntryAfterCreateHandlerImpl {
+  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.CREATE);
+      await createAuditLog("Entry created", entry, entry.entryId, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogEntryAfterCreateHandler",
+        code: "AUDIT_LOGS_AFTER_ENTRY_CREATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogEntryAfterCreateEventHandler = EntryAfterCreateEventHandler.createImplementation({
+  implementation: AuditLogEntryAfterCreateHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogEntryAfterCreateEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","EntryAfterCreateEventHandler","AuditLogsContext","AUDIT","getAuditConfig","AuditLogEntryAfterCreateHandlerImpl","constructor","context","handle","event","model","entry","payload","isPrivate","createAuditLog","HEADLESS_CMS","ENTRY","CREATE","entryId","error","from","message","code","AuditLogEntryAfterCreateEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogEntryAfterCreateEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryAfterCreateEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\n\nclass AuditLogEntryAfterCreateHandlerImpl implements EntryAfterCreateEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: EntryAfterCreateEventHandler.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.CREATE);\n\n            await createAuditLog(\"Entry created\", entry, entry.entryId, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogEntryAfterCreateHandler\",\n                code: \"AUDIT_LOGS_AFTER_ENTRY_CREATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogEntryAfterCreateEventHandler =\n    EntryAfterCreateEventHandler.createImplementation({\n        implementation: AuditLogEntryAfterCreateHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,4BAA4B,QAAQ,qEAAqE;AAClH,SAASC,gBAAgB;AACzB,SAASC,KAAK;AACd,SAASC,cAAc;AAEvB,MAAMC,mCAAmC,CAAmD;EACxFC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;IAEtC,IAAIF,KAAK,CAACG,SAAS,EAAE;MACjB;IACJ;IAEA,IAAI;MACA,MAAMC,cAAc,GAAGV,cAAc,CAACD,KAAK,CAACY,YAAY,CAACC,KAAK,CAACC,MAAM,CAAC;MAEtE,MAAMH,cAAc,CAAC,eAAe,EAAEH,KAAK,EAAEA,KAAK,CAACO,OAAO,EAAE,IAAI,CAACX,OAAO,CAAC;IAC7E,CAAC,CAAC,OAAOY,KAAK,EAAE;MACZ,MAAMnB,WAAW,CAACoB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,uDAAuD;QAChEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CtB,4BAA4B,CAACuB,oBAAoB,CAAC;EAC9CC,cAAc,EAAEpB,mCAAmC;EACnDqB,YAAY,EAAE,CAACxB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

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

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

package/subscriptions/headlessCms/handlers/AuditLogEntryAfterDeleteEventHandler.js

@@ -0,0 +1,40 @@
+import WebinyError from "@webiny/error";
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogEntryAfterDeleteHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      model,
+      entry,
+      permanent
+    } = event.payload;
+    if (model.isPrivate) {
+      return;
+    }
+    try {
+      if (permanent) {
+        const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY.DELETE);
+        await createAuditLog("Entry deleted", entry, entry.entryId, this.context);
+      } else {
+        const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY.MOVE_TO_TRASH);
+        await createAuditLog("Entry moved to trash", entry, entry.entryId, this.context);
+      }
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogEntryAfterDeleteHandler",
+        code: "AUDIT_LOGS_AFTER_ENTRY_DELETE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogEntryAfterDeleteEventHandler = EntryAfterDeleteEventHandler.createImplementation({
+  implementation: AuditLogEntryAfterDeleteHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogEntryAfterDeleteEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","EntryAfterDeleteEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogEntryAfterDeleteHandlerImpl","constructor","context","handle","event","model","entry","permanent","payload","isPrivate","createAuditLog","HEADLESS_CMS","ENTRY","DELETE","entryId","MOVE_TO_TRASH","error","from","message","code","AuditLogEntryAfterDeleteEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogEntryAfterDeleteEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogEntryAfterDeleteHandlerImpl implements EntryAfterDeleteEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { model, entry, permanent } = event.payload;\n\n        if (model.isPrivate) {\n            return;\n        }\n\n        try {\n            if (permanent) {\n                const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY.DELETE);\n                await createAuditLog(\"Entry deleted\", entry, entry.entryId, this.context);\n            } else {\n                const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY.MOVE_TO_TRASH);\n                await createAuditLog(\"Entry moved to trash\", entry, entry.entryId, this.context);\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogEntryAfterDeleteHandler\",\n                code: \"AUDIT_LOGS_AFTER_ENTRY_DELETE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogEntryAfterDeleteEventHandler =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: AuditLogEntryAfterDeleteHandlerImpl,\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,mCAAmC,CAAmD;EACxFC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC,KAAK;MAAEC;IAAU,CAAC,GAAGH,KAAK,CAACI,OAAO;IAEjD,IAAIH,KAAK,CAACI,SAAS,EAAE;MACjB;IACJ;IAEA,IAAI;MACA,IAAIF,SAAS,EAAE;QACX,MAAMG,cAAc,GAAGZ,cAAc,CAACD,KAAK,CAACc,YAAY,CAACC,KAAK,CAACC,MAAM,CAAC;QACtE,MAAMH,cAAc,CAAC,eAAe,EAAEJ,KAAK,EAAEA,KAAK,CAACQ,OAAO,EAAE,IAAI,CAACZ,OAAO,CAAC;MAC7E,CAAC,MAAM;QACH,MAAMQ,cAAc,GAAGZ,cAAc,CAACD,KAAK,CAACc,YAAY,CAACC,KAAK,CAACG,aAAa,CAAC;QAC7E,MAAML,cAAc,CAAC,sBAAsB,EAAEJ,KAAK,EAAEA,KAAK,CAACQ,OAAO,EAAE,IAAI,CAACZ,OAAO,CAAC;MACpF;IACJ,CAAC,CAAC,OAAOc,KAAK,EAAE;MACZ,MAAMrB,WAAW,CAACsB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,uDAAuD;QAChEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CxB,4BAA4B,CAACyB,oBAAoB,CAAC;EAC9CC,cAAc,EAAEtB,mCAAmC;EACnDuB,YAAY,EAAE,CAACxB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

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

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

package/subscriptions/headlessCms/handlers/AuditLogEntryAfterPublishEventHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { EntryAfterPublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogEntryAfterPublishEventHandlerImpl {
+  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.PUBLISH);
+      await createAuditLog("Entry revision published", entry, entry.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogEntryAfterPublishEventHandler",
+        code: "AUDIT_LOGS_AFTER_ENTRY_REVISION_PUBLISH_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogEntryAfterPublishEventHandler = EntryAfterPublishEventHandler.createImplementation({
+  implementation: AuditLogEntryAfterPublishEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogEntryAfterPublishEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","EntryAfterPublishEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogEntryAfterPublishEventHandlerImpl","constructor","context","handle","event","model","entry","payload","isPrivate","createAuditLog","HEADLESS_CMS","ENTRY_REVISION","PUBLISH","id","error","from","message","code","AuditLogEntryAfterPublishEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogEntryAfterPublishEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryAfterPublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogEntryAfterPublishEventHandlerImpl implements EntryAfterPublishEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: EntryAfterPublishEventHandler.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.PUBLISH);\n\n            await createAuditLog(\"Entry revision published\", entry, entry.id, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogEntryAfterPublishEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_ENTRY_REVISION_PUBLISH_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogEntryAfterPublishEventHandler =\n    EntryAfterPublishEventHandler.createImplementation({\n        implementation: AuditLogEntryAfterPublishEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,6BAA6B,QAAQ,sEAAsE;AACpH,SAASC,KAAK;AACd,SAASC,cAAc;AACvB,SAASC,gBAAgB;AAEzB,MAAMC,yCAAyC,CAAoD;EAC/FC,WAAWA,CAASC,OAAmC,EAAE;IAAA,KAArCA,OAAmC,GAAnCA,OAAmC;EAAG;EAE1D,MAAMC,MAAMA,CAACC,KAA0C,EAAiB;IACpE,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,OAAO,CAAC;MAEhF,MAAMH,cAAc,CAAC,0BAA0B,EAAEH,KAAK,EAAEA,KAAK,CAACO,EAAE,EAAE,IAAI,CAACX,OAAO,CAAC;IACnF,CAAC,CAAC,OAAOY,KAAK,EAAE;MACZ,MAAMnB,WAAW,CAACoB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,6DAA6D;QACtEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,qCAAqC,GAC9CtB,6BAA6B,CAACuB,oBAAoB,CAAC;EAC/CC,cAAc,EAAEpB,yCAAyC;EACzDqB,YAAY,EAAE,CAACtB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

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

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

package/subscriptions/headlessCms/handlers/AuditLogEntryAfterRestoreFromBinEventHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { EntryAfterRestoreFromBinEventHandler } from "@webiny/api-headless-cms/features/contentEntry/RestoreEntryFromBin/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogEntryAfterRestoreFromBinEventHandlerImpl {
+  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.RESTORE_FROM_TRASH);
+      await createAuditLog("Entry restored from trash", entry, entry.entryId, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogEntryAfterRestoreFromBinEventHandler",
+        code: "AUDIT_LOGS_AFTER_ENTRY_RESTORE_FROM_TRASH_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogEntryAfterRestoreFromBinEventHandler = EntryAfterRestoreFromBinEventHandler.createImplementation({
+  implementation: AuditLogEntryAfterRestoreFromBinEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogEntryAfterRestoreFromBinEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","EntryAfterRestoreFromBinEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogEntryAfterRestoreFromBinEventHandlerImpl","constructor","context","handle","event","model","entry","payload","isPrivate","createAuditLog","HEADLESS_CMS","ENTRY","RESTORE_FROM_TRASH","entryId","error","from","message","code","AuditLogEntryAfterRestoreFromBinEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogEntryAfterRestoreFromBinEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryAfterRestoreFromBinEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/RestoreEntryFromBin/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogEntryAfterRestoreFromBinEventHandlerImpl\n    implements EntryAfterRestoreFromBinEventHandler.Interface\n{\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: EntryAfterRestoreFromBinEventHandler.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.RESTORE_FROM_TRASH);\n            await createAuditLog(\"Entry restored from trash\", entry, entry.entryId, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogEntryAfterRestoreFromBinEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_ENTRY_RESTORE_FROM_TRASH_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogEntryAfterRestoreFromBinEventHandler =\n    EntryAfterRestoreFromBinEventHandler.createImplementation({\n        implementation: AuditLogEntryAfterRestoreFromBinEventHandlerImpl,\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,KAAK,CAACC,kBAAkB,CAAC;MAClF,MAAMH,cAAc,CAAC,2BAA2B,EAAEH,KAAK,EAAEA,KAAK,CAACO,OAAO,EAAE,IAAI,CAACX,OAAO,CAAC;IACzF,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/AuditLogEntryAfterUnpublishEventHandler.d.ts

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

package/subscriptions/headlessCms/handlers/AuditLogEntryAfterUnpublishEventHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { EntryAfterUnpublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogEntryAfterUnpublishEventHandlerImpl {
+  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.UNPUBLISH);
+      await createAuditLog("Entry revision unpublished", entry, entry.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogEntryAfterUnpublishEventHandler",
+        code: "AUDIT_LOGS_AFTER_ENTRY_REVISION_UNPUBLISH_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogEntryAfterUnpublishEventHandler = EntryAfterUnpublishEventHandler.createImplementation({
+  implementation: AuditLogEntryAfterUnpublishEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogEntryAfterUnpublishEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","EntryAfterUnpublishEventHandler","AUDIT","getAuditConfig","AuditLogsContext","AuditLogEntryAfterUnpublishEventHandlerImpl","constructor","context","handle","event","model","entry","payload","isPrivate","createAuditLog","HEADLESS_CMS","ENTRY_REVISION","UNPUBLISH","id","error","from","message","code","AuditLogEntryAfterUnpublishEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogEntryAfterUnpublishEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryAfterUnpublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UnpublishEntry/index.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\n\nclass AuditLogEntryAfterUnpublishEventHandlerImpl\n    implements EntryAfterUnpublishEventHandler.Interface\n{\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: EntryAfterUnpublishEventHandler.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.UNPUBLISH);\n\n            await createAuditLog(\"Entry revision unpublished\", entry, entry.id, this.context);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogEntryAfterUnpublishEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_ENTRY_REVISION_UNPUBLISH_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogEntryAfterUnpublishEventHandler =\n    EntryAfterUnpublishEventHandler.createImplementation({\n        implementation: AuditLogEntryAfterUnpublishEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,+BAA+B,QAAQ,wEAAwE;AACxH,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,KAA4C,EAAiB;IACtE,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,SAAS,CAAC;MAElF,MAAMH,cAAc,CAAC,4BAA4B,EAAEH,KAAK,EAAEA,KAAK,CAACO,EAAE,EAAE,IAAI,CAACX,OAAO,CAAC;IACrF,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,uCAAuC,GAChDtB,+BAA+B,CAACuB,oBAAoB,CAAC;EACjDC,cAAc,EAAEpB,2CAA2C;EAC3DqB,YAAY,EAAE,CAACtB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

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

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

package/subscriptions/headlessCms/handlers/AuditLogEntryAfterUpdateEventHandler.js

@@ -0,0 +1,38 @@
+import WebinyError from "@webiny/error";
+import { EntryAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+class AuditLogEntryAfterUpdateEventHandlerImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async handle(event) {
+    const {
+      model,
+      entry,
+      original
+    } = event.payload;
+    if (model.isPrivate) {
+      return;
+    }
+    try {
+      const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY_REVISION.UPDATE);
+      await createAuditLog("Entry revision updated", {
+        before: original,
+        after: entry
+      }, entry.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogEntryAfterUpdateEventHandler",
+        code: "AUDIT_LOGS_AFTER_ENTRY_REVISION_UPDATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogEntryAfterUpdateEventHandler = EntryAfterUpdateEventHandler.createImplementation({
+  implementation: AuditLogEntryAfterUpdateEventHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogEntryAfterUpdateEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","EntryAfterUpdateEventHandler","AuditLogsContext","AUDIT","getAuditConfig","AuditLogEntryAfterUpdateEventHandlerImpl","constructor","context","handle","event","model","entry","original","payload","isPrivate","createAuditLog","HEADLESS_CMS","ENTRY_REVISION","UPDATE","before","after","id","error","from","message","code","AuditLogEntryAfterUpdateEventHandler","createImplementation","implementation","dependencies"],"sources":["AuditLogEntryAfterUpdateEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryAfterUpdateEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { AuditLogsContext } from \"~/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\nimport { getAuditConfig } from \"~/utils/getAuditConfig.js\";\n\nclass AuditLogEntryAfterUpdateEventHandlerImpl implements EntryAfterUpdateEventHandler.Interface {\n    constructor(private context: AuditLogsContext.Interface) {}\n\n    async handle(event: EntryAfterUpdateEventHandler.Event): Promise<void> {\n        const { model, entry, original } = event.payload;\n\n        if (model.isPrivate) {\n            return;\n        }\n\n        try {\n            const createAuditLog = getAuditConfig(AUDIT.HEADLESS_CMS.ENTRY_REVISION.UPDATE);\n\n            await createAuditLog(\n                \"Entry revision updated\",\n                { before: original, after: entry },\n                entry.id,\n                this.context\n            );\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing AuditLogEntryAfterUpdateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_ENTRY_REVISION_UPDATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const AuditLogEntryAfterUpdateEventHandler =\n    EntryAfterUpdateEventHandler.createImplementation({\n        implementation: AuditLogEntryAfterUpdateEventHandlerImpl,\n        dependencies: [AuditLogsContext]\n    });\n"],"mappings":"AAAA,OAAOA,WAAW,MAAM,eAAe;AACvC,SAASC,4BAA4B,QAAQ,qEAAqE;AAClH,SAASC,gBAAgB;AACzB,SAASC,KAAK;AACd,SAASC,cAAc;AAEvB,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,KAAK;MAAEC;IAAS,CAAC,GAAGH,KAAK,CAACI,OAAO;IAEhD,IAAIH,KAAK,CAACI,SAAS,EAAE;MACjB;IACJ;IAEA,IAAI;MACA,MAAMC,cAAc,GAAGX,cAAc,CAACD,KAAK,CAACa,YAAY,CAACC,cAAc,CAACC,MAAM,CAAC;MAE/E,MAAMH,cAAc,CAChB,wBAAwB,EACxB;QAAEI,MAAM,EAAEP,QAAQ;QAAEQ,KAAK,EAAET;MAAM,CAAC,EAClCA,KAAK,CAACU,EAAE,EACR,IAAI,CAACd,OACT,CAAC;IACL,CAAC,CAAC,OAAOe,KAAK,EAAE;MACZ,MAAMtB,WAAW,CAACuB,IAAI,CAACD,KAAK,EAAE;QAC1BE,OAAO,EAAE,4DAA4D;QACrEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,oCAAoC,GAC7CzB,4BAA4B,CAAC0B,oBAAoB,CAAC;EAC9CC,cAAc,EAAEvB,wCAAwC;EACxDwB,YAAY,EAAE,CAAC3B,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

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

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

package/subscriptions/headlessCms/handlers/AuditLogEntryRevisionAfterCreateEventHandler.js

@@ -0,0 +1,34 @@
+import WebinyError from "@webiny/error";
+import { EntryRevisionAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/CreateEntryRevisionFrom/index.js";
+import { AUDIT } from "../../../config.js";
+import { getAuditConfig } from "../../../utils/getAuditConfig.js";
+import { AuditLogsContext } from "../../../abstractions.js";
+class AuditLogEntryRevisionAfterCreateHandlerImpl {
+  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.CREATE);
+      await createAuditLog("Entry revision created", entry, entry.id, this.context);
+    } catch (error) {
+      throw WebinyError.from(error, {
+        message: "Error while executing AuditLogEntryRevisionAfterCreateHandler",
+        code: "AUDIT_LOGS_AFTER_ENTRY_REVISION_CREATE_HANDLER"
+      });
+    }
+  }
+}
+export const AuditLogEntryRevisionAfterCreateEventHandler = EntryRevisionAfterCreateEventHandler.createImplementation({
+  implementation: AuditLogEntryRevisionAfterCreateHandlerImpl,
+  dependencies: [AuditLogsContext]
+});
+
+//# sourceMappingURL=AuditLogEntryRevisionAfterCreateEventHandler.js.map