@webiny/api-audit-logs 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

package/subscriptions/headlessCms/handlers/AuditLogEntryAfterUpdateEventHandler.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogEntryAfterUpdateEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/AuditLogEntryAfterUpdateEventHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { EntryAfterUpdateEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass AuditLogEntryAfterUpdateEventHandlerImpl implements EntryAfterUpdateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.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 recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.ENTRY_REVISION.UPDATE,\n                message: \"Entry revision updated\",\n                content: { before: original, after: entry },\n                entityId: entry.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogEntryAfterUpdateEventHandlerImpl","recordAuditLog","event","model","entry","original","recordResult","AUDIT","error","WebinyError","AuditLogEntryAfterUpdateEventHandler","EntryAfterUpdateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGH,MAAM,OAAO;QAEhD,IAAIC,MAAM,SAAS,EACf;QAGJ,IAAI;YACA,MAAMG,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,cAAc,CAAC,MAAM;gBAC/C,SAAS;gBACT,SAAS;oBAAE,QAAQF;oBAAU,OAAOD;gBAAM;gBAC1C,UAAUA,MAAM,EAAE;YACtB;YACA,IAAIE,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,uCACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBX;IAChB,cAAc;QAACY;KAAsB;AACzC"}

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

@@ -0,0 +1,11 @@
+import { EntryRevisionAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/CreateEntryRevisionFrom/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class AuditLogEntryRevisionAfterCreateHandlerImpl implements EntryRevisionAfterCreateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.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,36 @@
+import _webiny_error from "@webiny/error";
+import { EntryRevisionAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/CreateEntryRevisionFrom/index.js";
+import { AUDIT } from "../../../config.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+class AuditLogEntryRevisionAfterCreateHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        const { model, entry } = event.payload;
+        if (model.isPrivate) return;
+        try {
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.HEADLESS_CMS.ENTRY_REVISION.CREATE,
+                message: "Entry revision created",
+                content: entry,
+                entityId: entry.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw _webiny_error.from(error, {
+                message: "Error while executing AuditLogEntryRevisionAfterCreateHandler",
+                code: "AUDIT_LOGS_AFTER_ENTRY_REVISION_CREATE_HANDLER"
+            });
+        }
+    }
+}
+const AuditLogEntryRevisionAfterCreateEventHandler = EntryRevisionAfterCreateEventHandler.createImplementation({
+    implementation: AuditLogEntryRevisionAfterCreateHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { AuditLogEntryRevisionAfterCreateEventHandler };
+
+//# sourceMappingURL=AuditLogEntryRevisionAfterCreateEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogEntryRevisionAfterCreateEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/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 { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\n\nclass AuditLogEntryRevisionAfterCreateHandlerImpl\n    implements EntryRevisionAfterCreateEventHandler.Interface\n{\n    constructor(private recordAuditLog: RecordAuditLogUseCase.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 recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.ENTRY_REVISION.CREATE,\n                message: \"Entry revision created\",\n                content: entry,\n                entityId: entry.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogEntryRevisionAfterCreateHandlerImpl","recordAuditLog","event","model","entry","recordResult","AUDIT","error","WebinyError","AuditLogEntryRevisionAfterCreateEventHandler","EntryRevisionAfterCreateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IAGF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAiD,EAAiB;QAC3E,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAEtC,IAAIC,MAAM,SAAS,EACf;QAGJ,IAAI;YACA,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,cAAc,CAAC,MAAM;gBAC/C,SAAS;gBACT,SAASF;gBACT,UAAUA,MAAM,EAAE;YACtB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,+CACTC,qCAAqC,oBAAoB,CAAC;IACtD,gBAAgBV;IAChB,cAAc;QAACW;KAAsB;AACzC"}

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

@@ -0,0 +1,11 @@
+import { EntryRevisionAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntryRevision/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class AuditLogEntryRevisionAfterDeleteEventHandlerImpl implements EntryRevisionAfterDeleteEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.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,36 @@
+import _webiny_error from "@webiny/error";
+import { EntryRevisionAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntryRevision/index.js";
+import { AUDIT } from "../../../config.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+class AuditLogEntryRevisionAfterDeleteEventHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        const { model, entry } = event.payload;
+        if (model.isPrivate) return;
+        try {
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.HEADLESS_CMS.ENTRY_REVISION.DELETE,
+                message: "Entry revision deleted",
+                content: entry,
+                entityId: entry.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw _webiny_error.from(error, {
+                message: "Error while executing AuditLogEntryRevisionAfterDeleteEventHandler",
+                code: "AUDIT_LOGS_AFTER_ENTRY_REVISION_DELETE_HANDLER"
+            });
+        }
+    }
+}
+const AuditLogEntryRevisionAfterDeleteEventHandler = EntryRevisionAfterDeleteEventHandler.createImplementation({
+    implementation: AuditLogEntryRevisionAfterDeleteEventHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { AuditLogEntryRevisionAfterDeleteEventHandler };
+
+//# sourceMappingURL=AuditLogEntryRevisionAfterDeleteEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogEntryRevisionAfterDeleteEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/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 { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\n\nclass AuditLogEntryRevisionAfterDeleteEventHandlerImpl\n    implements EntryRevisionAfterDeleteEventHandler.Interface\n{\n    constructor(private recordAuditLog: RecordAuditLogUseCase.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 recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.ENTRY_REVISION.DELETE,\n                message: \"Entry revision deleted\",\n                content: entry,\n                entityId: entry.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogEntryRevisionAfterDeleteEventHandlerImpl","recordAuditLog","event","model","entry","recordResult","AUDIT","error","WebinyError","AuditLogEntryRevisionAfterDeleteEventHandler","EntryRevisionAfterDeleteEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IAGF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAiD,EAAiB;QAC3E,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAEtC,IAAIC,MAAM,SAAS,EACf;QAGJ,IAAI;YACA,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,cAAc,CAAC,MAAM;gBAC/C,SAAS;gBACT,SAASF;gBACT,UAAUA,MAAM,EAAE;YACtB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,+CACTC,qCAAqC,oBAAoB,CAAC;IACtD,gBAAgBV;IAChB,cAAc;QAACW;KAAsB;AACzC"}

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

@@ -0,0 +1,11 @@
+import { GroupAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/CreateGroup/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class AuditLogGroupAfterCreateEventHandlerImpl implements GroupAfterCreateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.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,35 @@
+import _webiny_error from "@webiny/error";
+import { GroupAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/CreateGroup/index.js";
+import { AUDIT } from "../../../config.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+class AuditLogGroupAfterCreateEventHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        const { group } = event.payload;
+        try {
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.HEADLESS_CMS.GROUP.CREATE,
+                message: "Group created",
+                content: group,
+                entityId: group.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw _webiny_error.from(error, {
+                message: "Error while executing AuditLogGroupAfterCreateEventHandler",
+                code: "AUDIT_LOGS_AFTER_GROUP_CREATE_HANDLER"
+            });
+        }
+    }
+}
+const AuditLogGroupAfterCreateEventHandler = GroupAfterCreateEventHandler.createImplementation({
+    implementation: AuditLogGroupAfterCreateEventHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { AuditLogGroupAfterCreateEventHandler };
+
+//# sourceMappingURL=AuditLogGroupAfterCreateEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogGroupAfterCreateEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/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 { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\n\nclass AuditLogGroupAfterCreateEventHandlerImpl implements GroupAfterCreateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: GroupAfterCreateEventHandler.Event): Promise<void> {\n        const { group } = event.payload;\n\n        try {\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.GROUP.CREATE,\n                message: \"Group created\",\n                content: group,\n                entityId: group.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogGroupAfterCreateEventHandlerImpl","recordAuditLog","event","group","recordResult","AUDIT","error","WebinyError","AuditLogGroupAfterCreateEventHandler","GroupAfterCreateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,IAAI;YACA,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,KAAK,CAAC,MAAM;gBACtC,SAAS;gBACT,SAASF;gBACT,UAAUA,MAAM,EAAE;YACtB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,uCACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

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

@@ -0,0 +1,11 @@
+import { GroupAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/DeleteGroup/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class AuditLogGroupAfterDeleteHandlerEventImpl implements GroupAfterDeleteEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.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,35 @@
+import _webiny_error from "@webiny/error";
+import { GroupAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/DeleteGroup/index.js";
+import { AUDIT } from "../../../config.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+class AuditLogGroupAfterDeleteHandlerEventImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        const { group } = event.payload;
+        try {
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.HEADLESS_CMS.GROUP.DELETE,
+                message: "Group deleted",
+                content: group,
+                entityId: group.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw _webiny_error.from(error, {
+                message: "Error while executing AuditLogGroupAfterDeleteHandlerEvent",
+                code: "AUDIT_LOGS_AFTER_GROUP_DELETE_HANDLER"
+            });
+        }
+    }
+}
+const AuditLogGroupAfterDeleteEventHandler = GroupAfterDeleteEventHandler.createImplementation({
+    implementation: AuditLogGroupAfterDeleteHandlerEventImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { AuditLogGroupAfterDeleteEventHandler };
+
+//# sourceMappingURL=AuditLogGroupAfterDeleteEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogGroupAfterDeleteEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/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 { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\n\nclass AuditLogGroupAfterDeleteHandlerEventImpl implements GroupAfterDeleteEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: GroupAfterDeleteEventHandler.Event): Promise<void> {\n        const { group } = event.payload;\n\n        try {\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.GROUP.DELETE,\n                message: \"Group deleted\",\n                content: group,\n                entityId: group.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogGroupAfterDeleteHandlerEventImpl","recordAuditLog","event","group","recordResult","AUDIT","error","WebinyError","AuditLogGroupAfterDeleteEventHandler","GroupAfterDeleteEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,IAAI;YACA,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,KAAK,CAAC,MAAM;gBACtC,SAAS;gBACT,SAASF;gBACT,UAAUA,MAAM,EAAE;YACtB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,uCACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

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

@@ -0,0 +1,11 @@
+import { GroupAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/UpdateGroup/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class AuditLogGroupAfterUpdateEventHandlerImpl implements GroupAfterUpdateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.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,38 @@
+import _webiny_error from "@webiny/error";
+import { GroupAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentModelGroup/UpdateGroup/index.js";
+import { AUDIT } from "../../../config.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+class AuditLogGroupAfterUpdateEventHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        const { group, original } = event.payload;
+        try {
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.HEADLESS_CMS.GROUP.UPDATE,
+                message: "Group updated",
+                content: {
+                    before: original,
+                    after: group
+                },
+                entityId: group.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw _webiny_error.from(error, {
+                message: "Error while executing AuditLogGroupAfterUpdateEventHandler",
+                code: "AUDIT_LOGS_AFTER_GROUP_UPDATE_HANDLER"
+            });
+        }
+    }
+}
+const AuditLogGroupAfterUpdateEventHandler = GroupAfterUpdateEventHandler.createImplementation({
+    implementation: AuditLogGroupAfterUpdateEventHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { AuditLogGroupAfterUpdateEventHandler };
+
+//# sourceMappingURL=AuditLogGroupAfterUpdateEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogGroupAfterUpdateEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/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 { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\n\nclass AuditLogGroupAfterUpdateEventHandlerImpl implements GroupAfterUpdateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: GroupAfterUpdateEventHandler.Event): Promise<void> {\n        const { group, original } = event.payload;\n\n        try {\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.GROUP.UPDATE,\n                message: \"Group updated\",\n                content: { before: original, after: group },\n                entityId: group.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogGroupAfterUpdateEventHandlerImpl","recordAuditLog","event","group","original","recordResult","AUDIT","error","WebinyError","AuditLogGroupAfterUpdateEventHandler","GroupAfterUpdateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF,MAAM,OAAO;QAEzC,IAAI;YACA,MAAMG,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,KAAK,CAAC,MAAM;gBACtC,SAAS;gBACT,SAAS;oBAAE,QAAQF;oBAAU,OAAOD;gBAAM;gBAC1C,UAAUA,MAAM,EAAE;YACtB;YACA,IAAIE,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,uCACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBV;IAChB,cAAc;QAACW;KAAsB;AACzC"}

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

@@ -0,0 +1,11 @@
+import { ModelAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentModel/CreateModel/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class AuditLogModelAfterCreateEventHandlerImpl implements ModelAfterCreateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.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,35 @@
+import _webiny_error from "@webiny/error";
+import { ModelAfterCreateEventHandler } from "@webiny/api-headless-cms/features/contentModel/CreateModel/index.js";
+import { AUDIT } from "../../../config.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+class AuditLogModelAfterCreateEventHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        const { model } = event.payload;
+        try {
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.HEADLESS_CMS.MODEL.CREATE,
+                message: "Model created",
+                content: model,
+                entityId: model.modelId
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw _webiny_error.from(error, {
+                message: "Error while executing AuditLogModelAfterCreateEventHandler",
+                code: "AUDIT_LOGS_AFTER_MODEL_CREATE_HANDLER"
+            });
+        }
+    }
+}
+const AuditLogModelAfterCreateEventHandler = ModelAfterCreateEventHandler.createImplementation({
+    implementation: AuditLogModelAfterCreateEventHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { AuditLogModelAfterCreateEventHandler };
+
+//# sourceMappingURL=AuditLogModelAfterCreateEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogModelAfterCreateEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/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 { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\n\nclass AuditLogModelAfterCreateEventHandlerImpl implements ModelAfterCreateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: ModelAfterCreateEventHandler.Event): Promise<void> {\n        const { model } = event.payload;\n\n        try {\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.MODEL.CREATE,\n                message: \"Model created\",\n                content: model,\n                entityId: model.modelId\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogModelAfterCreateEventHandlerImpl","recordAuditLog","event","model","recordResult","AUDIT","error","WebinyError","AuditLogModelAfterCreateEventHandler","ModelAfterCreateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,IAAI;YACA,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,KAAK,CAAC,MAAM;gBACtC,SAAS;gBACT,SAASF;gBACT,UAAUA,MAAM,OAAO;YAC3B;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,uCACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

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

@@ -0,0 +1,11 @@
+import { ModelAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModel/DeleteModel/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class AuditLogModelAfterDeleteEventHandlerImpl implements ModelAfterDeleteEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.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,35 @@
+import _webiny_error from "@webiny/error";
+import { ModelAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModel/DeleteModel/index.js";
+import { AUDIT } from "../../../config.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+class AuditLogModelAfterDeleteEventHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        const { model } = event.payload;
+        try {
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.HEADLESS_CMS.MODEL.DELETE,
+                message: "Model deleted",
+                content: model,
+                entityId: model.modelId
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw _webiny_error.from(error, {
+                message: "Error while executing AuditLogModelAfterDeleteEventHandler",
+                code: "AUDIT_LOGS_AFTER_MODEL_DELETE_HANDLER"
+            });
+        }
+    }
+}
+const AuditLogModelAfterDeleteEventHandler = ModelAfterDeleteEventHandler.createImplementation({
+    implementation: AuditLogModelAfterDeleteEventHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { AuditLogModelAfterDeleteEventHandler };
+
+//# sourceMappingURL=AuditLogModelAfterDeleteEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogModelAfterDeleteEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/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 { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\n\nclass AuditLogModelAfterDeleteEventHandlerImpl implements ModelAfterDeleteEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: ModelAfterDeleteEventHandler.Event): Promise<void> {\n        const { model } = event.payload;\n\n        try {\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.MODEL.DELETE,\n                message: \"Model deleted\",\n                content: model,\n                entityId: model.modelId\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogModelAfterDeleteEventHandlerImpl","recordAuditLog","event","model","recordResult","AUDIT","error","WebinyError","AuditLogModelAfterDeleteEventHandler","ModelAfterDeleteEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,IAAI;YACA,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,KAAK,CAAC,MAAM;gBACtC,SAAS;gBACT,SAASF;gBACT,UAAUA,MAAM,OAAO;YAC3B;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,uCACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

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

@@ -0,0 +1,11 @@
+import { ModelAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentModel/UpdateModel/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class AuditLogModelAfterUpdateEventHandlerImpl implements ModelAfterUpdateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.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,38 @@
+import _webiny_error from "@webiny/error";
+import { ModelAfterUpdateEventHandler } from "@webiny/api-headless-cms/features/contentModel/UpdateModel/index.js";
+import { AUDIT } from "../../../config.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+class AuditLogModelAfterUpdateEventHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        const { model, original } = event.payload;
+        try {
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.HEADLESS_CMS.MODEL.UPDATE,
+                message: "Model updated",
+                content: {
+                    before: original,
+                    after: model
+                },
+                entityId: model.modelId
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw _webiny_error.from(error, {
+                message: "Error while executing AuditLogModelAfterUpdateEventHandler",
+                code: "AUDIT_LOGS_AFTER_MODEL_UPDATE_HANDLER"
+            });
+        }
+    }
+}
+const AuditLogModelAfterUpdateEventHandler = ModelAfterUpdateEventHandler.createImplementation({
+    implementation: AuditLogModelAfterUpdateEventHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { AuditLogModelAfterUpdateEventHandler };
+
+//# sourceMappingURL=AuditLogModelAfterUpdateEventHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/headlessCms/handlers/AuditLogModelAfterUpdateEventHandler.js","sources":["../../../../src/subscriptions/headlessCms/handlers/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 { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\n\nclass AuditLogModelAfterUpdateEventHandlerImpl implements ModelAfterUpdateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: ModelAfterUpdateEventHandler.Event): Promise<void> {\n        const { model, original } = event.payload;\n\n        try {\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.HEADLESS_CMS.MODEL.UPDATE,\n                message: \"Model updated\",\n                content: { before: original, after: model },\n                entityId: model.modelId\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\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: [RecordAuditLogUseCase]\n    });\n"],"names":["AuditLogModelAfterUpdateEventHandlerImpl","recordAuditLog","event","model","original","recordResult","AUDIT","error","WebinyError","AuditLogModelAfterUpdateEventHandler","ModelAfterUpdateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF,MAAM,OAAO;QAEzC,IAAI;YACA,MAAMG,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,YAAY,CAAC,KAAK,CAAC,MAAM;gBACtC,SAAS;gBACT,SAAS;oBAAE,QAAQF;oBAAU,OAAOD;gBAAM;gBAC1C,UAAUA,MAAM,OAAO;YAC3B;YACA,IAAIE,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,cAAAA,IAAgB,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,uCACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBV;IAChB,cAAc;QAACW;KAAsB;AACzC"}

package/subscriptions/headlessCms/index.d.ts

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

package/subscriptions/headlessCms/index.js

@@ -1,31 +1,33 @@
-"use strict";
-
-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);
+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";
+const createHeadlessCmsHooks = (container)=>{
+    container.register(AuditLogEntryAfterCreateEventHandler);
+    container.register(AuditLogEntryAfterUpdateEventHandler);
+    container.register(AuditLogEntryAfterDeleteEventHandler);
+    container.register(AuditLogEntryAfterPublishEventHandler);
+    container.register(AuditLogEntryAfterUnpublishEventHandler);
+    container.register(AuditLogEntryAfterRestoreFromBinEventHandler);
+    container.register(AuditLogEntryRevisionAfterCreateEventHandler);
+    container.register(AuditLogEntryRevisionAfterDeleteEventHandler);
+    container.register(AuditLogModelAfterCreateEventHandler);
+    container.register(AuditLogModelAfterUpdateEventHandler);
+    container.register(AuditLogModelAfterDeleteEventHandler);
+    container.register(AuditLogGroupAfterCreateEventHandler);
+    container.register(AuditLogGroupAfterUpdateEventHandler);
+    container.register(AuditLogGroupAfterDeleteEventHandler);
 };
-exports.createHeadlessCmsHooks = createHeadlessCmsHooks;
+export { createHeadlessCmsHooks };
 
 //# sourceMappingURL=index.js.map