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

package/features/ListAuditLogs/abstractions.d.ts

@@ -0,0 +1,55 @@
+import type { Result } from "@webiny/feature/api";
+import type { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import type { IListAuditLogsParams } from "../../types.js";
+import type { IListAuditLogsResultMeta } from "../../types.js";
+import type { IAuditLog } from "../../storage/types.js";
+import type { IStorageListParams } from "../../storage/abstractions/Storage.js";
+import type { IStorageListSuccessResultMeta } from "../../storage/abstractions/Storage.js";
+import type { AuditLogPersistenceError } from "../../domain/errors.js";
+export interface ListAuditLogsOutput {
+    items: IAuditLog[];
+    meta: IListAuditLogsResultMeta;
+}
+/**
+ * ListAuditLogs Use Case - Lists audit logs of the current tenant. Needs access to all audit logs.
+ */
+export interface IListAuditLogsUseCase {
+    execute(params: IListAuditLogsParams): Promise<Result<ListAuditLogsOutput, UseCaseError>>;
+}
+export interface IListAuditLogsUseCaseErrors {
+    notAuthorized: NotAuthorizedError;
+    persistence: AuditLogPersistenceError;
+}
+type UseCaseError = IListAuditLogsUseCaseErrors[keyof IListAuditLogsUseCaseErrors];
+export declare const ListAuditLogsUseCase: import("@webiny/di").Abstraction<IListAuditLogsUseCase>;
+export declare namespace ListAuditLogsUseCase {
+    type Interface = IListAuditLogsUseCase;
+    type Output = ListAuditLogsOutput;
+    type Error = UseCaseError;
+}
+/**
+ * ListAuditLogsRepository - Lists audit logs of the current tenant.
+ */
+export interface IListAuditLogsRepository {
+    list(params: IListAuditLogsParams): Promise<Result<ListAuditLogsOutput, AuditLogPersistenceError>>;
+}
+export declare const ListAuditLogsRepository: import("@webiny/di").Abstraction<IListAuditLogsRepository>;
+export declare namespace ListAuditLogsRepository {
+    type Interface = IListAuditLogsRepository;
+}
+export interface ListAuditLogsGatewayOutput {
+    items: IAuditLog[];
+    meta: IStorageListSuccessResultMeta;
+}
+/**
+ * ListAuditLogsGateway - Lists audit logs from the audit logs storage.
+ */
+export interface IListAuditLogsGateway {
+    list(params: IStorageListParams): Promise<ListAuditLogsGatewayOutput>;
+}
+export declare const ListAuditLogsGateway: import("@webiny/di").Abstraction<IListAuditLogsGateway>;
+export declare namespace ListAuditLogsGateway {
+    type Interface = IListAuditLogsGateway;
+    type Output = ListAuditLogsGatewayOutput;
+}
+export {};

package/features/ListAuditLogs/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ListAuditLogsUseCase = createAbstraction("ListAuditLogsUseCase");
+const ListAuditLogsRepository = createAbstraction("ListAuditLogsRepository");
+const ListAuditLogsGateway = createAbstraction("ListAuditLogsGateway");
+export { ListAuditLogsGateway, ListAuditLogsRepository, ListAuditLogsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/ListAuditLogs/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListAuditLogs/abstractions.js","sources":["../../../src/features/ListAuditLogs/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport type { IListAuditLogsParams } from \"~/types.js\";\nimport type { IListAuditLogsResultMeta } from \"~/types.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport type { IStorageListParams } from \"~/storage/abstractions/Storage.js\";\nimport type { IStorageListSuccessResultMeta } from \"~/storage/abstractions/Storage.js\";\nimport type { AuditLogPersistenceError } from \"~/domain/errors.js\";\n\nexport interface ListAuditLogsOutput {\n    items: IAuditLog[];\n    meta: IListAuditLogsResultMeta;\n}\n\n/**\n * ListAuditLogs Use Case - Lists audit logs of the current tenant. Needs access to all audit logs.\n */\nexport interface IListAuditLogsUseCase {\n    execute(params: IListAuditLogsParams): Promise<Result<ListAuditLogsOutput, UseCaseError>>;\n}\n\nexport interface IListAuditLogsUseCaseErrors {\n    notAuthorized: NotAuthorizedError;\n    persistence: AuditLogPersistenceError;\n}\n\ntype UseCaseError = IListAuditLogsUseCaseErrors[keyof IListAuditLogsUseCaseErrors];\n\nexport const ListAuditLogsUseCase =\n    createAbstraction<IListAuditLogsUseCase>(\"ListAuditLogsUseCase\");\n\nexport namespace ListAuditLogsUseCase {\n    export type Interface = IListAuditLogsUseCase;\n    export type Output = ListAuditLogsOutput;\n    export type Error = UseCaseError;\n}\n\n/**\n * ListAuditLogsRepository - Lists audit logs of the current tenant.\n */\nexport interface IListAuditLogsRepository {\n    list(\n        params: IListAuditLogsParams\n    ): Promise<Result<ListAuditLogsOutput, AuditLogPersistenceError>>;\n}\n\nexport const ListAuditLogsRepository =\n    createAbstraction<IListAuditLogsRepository>(\"ListAuditLogsRepository\");\n\nexport namespace ListAuditLogsRepository {\n    export type Interface = IListAuditLogsRepository;\n}\n\nexport interface ListAuditLogsGatewayOutput {\n    items: IAuditLog[];\n    meta: IStorageListSuccessResultMeta;\n}\n\n/**\n * ListAuditLogsGateway - Lists audit logs from the audit logs storage.\n */\nexport interface IListAuditLogsGateway {\n    list(params: IStorageListParams): Promise<ListAuditLogsGatewayOutput>;\n}\n\nexport const ListAuditLogsGateway =\n    createAbstraction<IListAuditLogsGateway>(\"ListAuditLogsGateway\");\n\nexport namespace ListAuditLogsGateway {\n    export type Interface = IListAuditLogsGateway;\n    export type Output = ListAuditLogsGatewayOutput;\n}\n"],"names":["ListAuditLogsUseCase","createAbstraction","ListAuditLogsRepository","ListAuditLogsGateway"],"mappings":";AA6BO,MAAMA,uBACTC,kBAAyC;AAiBtC,MAAMC,0BACTD,kBAA4C;AAkBzC,MAAME,uBACTF,kBAAyC"}

package/features/ListAuditLogs/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ListAuditLogsFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/ListAuditLogs/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListAuditLogsUseCase } from "./ListAuditLogsUseCase.js";
+import { ListAuditLogsRepository } from "./ListAuditLogsRepository.js";
+import { ListAuditLogsGateway } from "./ListAuditLogsGateway.js";
+const ListAuditLogsFeature = createFeature({
+    name: "AuditLogs/ListAuditLogs",
+    register (container) {
+        container.register(ListAuditLogsUseCase);
+        container.register(ListAuditLogsRepository).inSingletonScope();
+        container.register(ListAuditLogsGateway).inSingletonScope();
+    }
+});
+export { ListAuditLogsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/ListAuditLogs/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListAuditLogs/feature.js","sources":["../../../src/features/ListAuditLogs/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListAuditLogsUseCase } from \"./ListAuditLogsUseCase.js\";\nimport { ListAuditLogsRepository } from \"./ListAuditLogsRepository.js\";\nimport { ListAuditLogsGateway } from \"./ListAuditLogsGateway.js\";\n\nexport const ListAuditLogsFeature = createFeature({\n    name: \"AuditLogs/ListAuditLogs\",\n    register(container) {\n        container.register(ListAuditLogsUseCase);\n        container.register(ListAuditLogsRepository).inSingletonScope();\n        container.register(ListAuditLogsGateway).inSingletonScope();\n    }\n});\n"],"names":["ListAuditLogsFeature","createFeature","container","ListAuditLogsUseCase","ListAuditLogsRepository","ListAuditLogsGateway"],"mappings":";;;;AAKO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,yBAAyB,gBAAgB;QAC5DF,UAAU,QAAQ,CAACG,sBAAsB,gBAAgB;IAC7D;AACJ"}

package/features/RecordAuditLog/RecordAuditLogUseCase.d.ts

@@ -0,0 +1,30 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { CreateAuditLogUseCase } from "../../features/CreateAuditLog/abstractions.js";
+import { ListAuditLogsUseCase } from "../../features/ListAuditLogs/abstractions.js";
+import { UpdateAuditLogUseCase } from "../../features/UpdateAuditLog/abstractions.js";
+import type { IAuditLog } from "../../storage/types.js";
+import { RecordAuditLogUseCase as UseCaseAbstraction } from "./abstractions.js";
+/**
+ * Records audit logs for things the current identity did. Writes happen without authorization,
+ * because the identity doing the audited action doesn't need audit log permissions.
+ *
+ * An action with a `newEntryDelay` merges into the entity's latest audit log when that log is
+ * newer than the delay, instead of creating a new one. A failure on that path is logged and
+ * nothing is recorded.
+ */
+declare class RecordAuditLogUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly createAuditLog;
+    private readonly listAuditLogs;
+    private readonly updateAuditLog;
+    private readonly identityContext;
+    private readonly logger;
+    constructor(createAuditLog: CreateAuditLogUseCase.Interface, listAuditLogs: ListAuditLogsUseCase.Interface, updateAuditLog: UpdateAuditLogUseCase.Interface, identityContext: IdentityContext.Interface, logger: Logger.Interface);
+    execute(input: UseCaseAbstraction.Input): Promise<Result<IAuditLog | null, UseCaseAbstraction.Error>>;
+    private createOrMergeAuditLog;
+}
+export declare const RecordAuditLogUseCase: typeof RecordAuditLogUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRecordAuditLogUseCase>;
+};
+export {};

package/features/RecordAuditLog/RecordAuditLogUseCase.js

@@ -0,0 +1,108 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { CreateAuditLogUseCase } from "../CreateAuditLog/abstractions.js";
+import { ListAuditLogsUseCase } from "../ListAuditLogs/abstractions.js";
+import { UpdateAuditLogUseCase } from "../UpdateAuditLog/abstractions.js";
+import { RecordAuditLogUseCase } from "./abstractions.js";
+const createAuditLogDelayDate = (delay)=>{
+    const date = new Date();
+    date.setTime(date.getTime() - 1000 * delay);
+    return date;
+};
+class RecordAuditLogUseCaseImpl {
+    constructor(createAuditLog, listAuditLogs, updateAuditLog, identityContext, logger){
+        this.createAuditLog = createAuditLog;
+        this.listAuditLogs = listAuditLogs;
+        this.updateAuditLog = updateAuditLog;
+        this.identityContext = identityContext;
+        this.logger = logger;
+    }
+    async execute(input) {
+        const { audit, message, content, entityId } = input;
+        if (!this.identityContext.getIdentity()?.id) {
+            this.logger.debug("No identity, skipping audit log creation.");
+            return Result.ok(null);
+        }
+        const payload = {
+            message,
+            app: audit.app.app,
+            entityId,
+            entity: audit.entity.type,
+            action: audit.action.type,
+            content,
+            tags: []
+        };
+        const delay = audit.action.newEntryDelay || 0;
+        return await this.identityContext.withoutAuthorization(async ()=>{
+            if (delay > 0) try {
+                return await this.createOrMergeAuditLog(payload, delay);
+            } catch (error) {
+                this.logger.warn({
+                    error
+                }, "Could not create or merge an audit log.");
+                return Result.ok(null);
+            }
+            return await this.createAuditLog.execute(payload);
+        });
+    }
+    async createOrMergeAuditLog(payload, delay) {
+        const createdOnGte = createAuditLogDelayDate(delay);
+        const listResult = await this.listAuditLogs.execute({
+            app: payload.app,
+            entityId: payload.entityId,
+            limit: 1,
+            createdOn_gte: createdOnGte,
+            sort: "DESC"
+        });
+        if (listResult.isFail()) {
+            this.logger.warn({
+                error: listResult.error
+            }, "Could not list audit logs to merge into.");
+            return Result.ok(null);
+        }
+        const original = listResult.value.items[0];
+        if (!original) {
+            const createResult = await this.createAuditLog.execute(payload);
+            if (createResult.isFail()) {
+                this.logger.warn({
+                    error: createResult.error
+                }, "Could not create an audit log.");
+                return Result.ok(null);
+            }
+            return Result.ok(createResult.value);
+        }
+        let content = payload.content;
+        if (original.content) {
+            const beforePayloadData = JSON.parse(original.content)?.before;
+            if (beforePayloadData) content = {
+                before: beforePayloadData,
+                after: payload.content?.after
+            };
+        }
+        const updateResult = await this.updateAuditLog.execute(original, {
+            message: payload.message,
+            content
+        });
+        if (updateResult.isFail()) {
+            this.logger.warn({
+                error: updateResult.error
+            }, "Could not merge an audit log.");
+            return Result.ok(null);
+        }
+        return Result.ok(updateResult.value);
+    }
+}
+const RecordAuditLogUseCase_RecordAuditLogUseCase = RecordAuditLogUseCase.createImplementation({
+    implementation: RecordAuditLogUseCaseImpl,
+    dependencies: [
+        CreateAuditLogUseCase,
+        ListAuditLogsUseCase,
+        UpdateAuditLogUseCase,
+        IdentityContext,
+        Logger
+    ]
+});
+export { RecordAuditLogUseCase_RecordAuditLogUseCase as RecordAuditLogUseCase };
+
+//# sourceMappingURL=RecordAuditLogUseCase.js.map

package/features/RecordAuditLog/RecordAuditLogUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/RecordAuditLog/RecordAuditLogUseCase.js","sources":["../../../src/features/RecordAuditLog/RecordAuditLogUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { CreateAuditLogUseCase } from \"~/features/CreateAuditLog/abstractions.js\";\nimport { ListAuditLogsUseCase } from \"~/features/ListAuditLogs/abstractions.js\";\nimport { UpdateAuditLogUseCase } from \"~/features/UpdateAuditLog/abstractions.js\";\nimport type { AuditLogPayload } from \"~/types.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport { RecordAuditLogUseCase as UseCaseAbstraction } from \"./abstractions.js\";\n\nconst createAuditLogDelayDate = (delay: number): Date => {\n    const date = new Date();\n    date.setTime(date.getTime() - delay * 1000);\n    return date;\n};\n\n/**\n * Records audit logs for things the current identity did. Writes happen without authorization,\n * because the identity doing the audited action doesn't need audit log permissions.\n *\n * An action with a `newEntryDelay` merges into the entity's latest audit log when that log is\n * newer than the delay, instead of creating a new one. A failure on that path is logged and\n * nothing is recorded.\n */\nclass RecordAuditLogUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private readonly createAuditLog: CreateAuditLogUseCase.Interface,\n        private readonly listAuditLogs: ListAuditLogsUseCase.Interface,\n        private readonly updateAuditLog: UpdateAuditLogUseCase.Interface,\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly logger: Logger.Interface\n    ) {}\n\n    public async execute(\n        input: UseCaseAbstraction.Input\n    ): Promise<Result<IAuditLog | null, UseCaseAbstraction.Error>> {\n        const { audit, message, content, entityId } = input;\n\n        if (!this.identityContext.getIdentity()?.id) {\n            this.logger.debug(\"No identity, skipping audit log creation.\");\n            return Result.ok(null);\n        }\n\n        const payload: AuditLogPayload = {\n            message,\n            app: audit.app.app,\n            entityId,\n            entity: audit.entity.type,\n            action: audit.action.type,\n            content,\n            tags: []\n        };\n\n        const delay = audit.action.newEntryDelay || 0;\n\n        return await this.identityContext.withoutAuthorization(async () => {\n            if (delay > 0) {\n                try {\n                    return await this.createOrMergeAuditLog(payload, delay);\n                } catch (error) {\n                    this.logger.warn({ error }, \"Could not create or merge an audit log.\");\n                    return Result.ok(null);\n                }\n            }\n            return await this.createAuditLog.execute(payload);\n        });\n    }\n\n    private async createOrMergeAuditLog(\n        payload: AuditLogPayload,\n        delay: number\n    ): Promise<Result<IAuditLog | null, UseCaseAbstraction.Error>> {\n        const createdOnGte = createAuditLogDelayDate(delay);\n        const listResult = await this.listAuditLogs.execute({\n            app: payload.app,\n            entityId: payload.entityId,\n            limit: 1,\n            createdOn_gte: createdOnGte,\n            sort: \"DESC\"\n        });\n        if (listResult.isFail()) {\n            this.logger.warn(\n                { error: listResult.error },\n                \"Could not list audit logs to merge into.\"\n            );\n            return Result.ok(null);\n        }\n\n        const original = listResult.value.items[0];\n        if (!original) {\n            const createResult = await this.createAuditLog.execute(payload);\n            if (createResult.isFail()) {\n                this.logger.warn({ error: createResult.error }, \"Could not create an audit log.\");\n                return Result.ok(null);\n            }\n            return Result.ok(createResult.value);\n        }\n\n        // Update the latest audit log with the new \"after\" payload, keeping its original \"before\".\n        // Only the message and the content change: the original log keeps everything else,\n        // including any tags it was created with.\n        let content = payload.content;\n        if (original.content) {\n            const beforePayloadData = JSON.parse(original.content)?.before;\n            if (beforePayloadData) {\n                content = {\n                    before: beforePayloadData,\n                    after: payload.content?.after\n                };\n            }\n        }\n\n        const updateResult = await this.updateAuditLog.execute(original, {\n            message: payload.message,\n            content\n        });\n        if (updateResult.isFail()) {\n            this.logger.warn({ error: updateResult.error }, \"Could not merge an audit log.\");\n            return Result.ok(null);\n        }\n\n        return Result.ok(updateResult.value);\n    }\n}\n\nexport const RecordAuditLogUseCase = UseCaseAbstraction.createImplementation({\n    implementation: RecordAuditLogUseCaseImpl,\n    dependencies: [\n        CreateAuditLogUseCase,\n        ListAuditLogsUseCase,\n        UpdateAuditLogUseCase,\n        IdentityContext,\n        Logger\n    ]\n});\n"],"names":["createAuditLogDelayDate","delay","date","Date","RecordAuditLogUseCaseImpl","createAuditLog","listAuditLogs","updateAuditLog","identityContext","logger","input","audit","message","content","entityId","Result","payload","error","createdOnGte","listResult","original","createResult","beforePayloadData","JSON","updateResult","RecordAuditLogUseCase","UseCaseAbstraction","CreateAuditLogUseCase","ListAuditLogsUseCase","UpdateAuditLogUseCase","IdentityContext","Logger"],"mappings":";;;;;;;AAUA,MAAMA,0BAA0B,CAACC;IAC7B,MAAMC,OAAO,IAAIC;IACjBD,KAAK,OAAO,CAACA,KAAK,OAAO,KAAKD,AAAQ,OAARA;IAC9B,OAAOC;AACX;AAUA,MAAME;IACF,YACqBC,cAA+C,EAC/CC,aAA6C,EAC7CC,cAA+C,EAC/CC,eAA0C,EAC1CC,MAAwB,CAC3C;aALmBJ,cAAc,GAAdA;aACAC,aAAa,GAAbA;aACAC,cAAc,GAAdA;aACAC,eAAe,GAAfA;aACAC,MAAM,GAANA;IAClB;IAEH,MAAa,QACTC,KAA+B,EAC4B;QAC3D,MAAM,EAAEC,KAAK,EAAEC,OAAO,EAAEC,OAAO,EAAEC,QAAQ,EAAE,GAAGJ;QAE9C,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,IAAI,IAAI;YACzC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YAClB,OAAOK,OAAO,EAAE,CAAC;QACrB;QAEA,MAAMC,UAA2B;YAC7BJ;YACA,KAAKD,MAAM,GAAG,CAAC,GAAG;YAClBG;YACA,QAAQH,MAAM,MAAM,CAAC,IAAI;YACzB,QAAQA,MAAM,MAAM,CAAC,IAAI;YACzBE;YACA,MAAM,EAAE;QACZ;QAEA,MAAMZ,QAAQU,MAAM,MAAM,CAAC,aAAa,IAAI;QAE5C,OAAO,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;YACnD,IAAIV,QAAQ,GACR,IAAI;gBACA,OAAO,MAAM,IAAI,CAAC,qBAAqB,CAACe,SAASf;YACrD,EAAE,OAAOgB,OAAO;gBACZ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;oBAAEA;gBAAM,GAAG;gBAC5B,OAAOF,OAAO,EAAE,CAAC;YACrB;YAEJ,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACC;QAC7C;IACJ;IAEA,MAAc,sBACVA,OAAwB,EACxBf,KAAa,EAC8C;QAC3D,MAAMiB,eAAelB,wBAAwBC;QAC7C,MAAMkB,aAAa,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;YAChD,KAAKH,QAAQ,GAAG;YAChB,UAAUA,QAAQ,QAAQ;YAC1B,OAAO;YACP,eAAeE;YACf,MAAM;QACV;QACA,IAAIC,WAAW,MAAM,IAAI;YACrB,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ;gBAAE,OAAOA,WAAW,KAAK;YAAC,GAC1B;YAEJ,OAAOJ,OAAO,EAAE,CAAC;QACrB;QAEA,MAAMK,WAAWD,WAAW,KAAK,CAAC,KAAK,CAAC,EAAE;QAC1C,IAAI,CAACC,UAAU;YACX,MAAMC,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACL;YACvD,IAAIK,aAAa,MAAM,IAAI;gBACvB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;oBAAE,OAAOA,aAAa,KAAK;gBAAC,GAAG;gBAChD,OAAON,OAAO,EAAE,CAAC;YACrB;YACA,OAAOA,OAAO,EAAE,CAACM,aAAa,KAAK;QACvC;QAKA,IAAIR,UAAUG,QAAQ,OAAO;QAC7B,IAAII,SAAS,OAAO,EAAE;YAClB,MAAME,oBAAoBC,KAAK,KAAK,CAACH,SAAS,OAAO,GAAG;YACxD,IAAIE,mBACAT,UAAU;gBACN,QAAQS;gBACR,OAAON,QAAQ,OAAO,EAAE;YAC5B;QAER;QAEA,MAAMQ,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACJ,UAAU;YAC7D,SAASJ,QAAQ,OAAO;YACxBH;QACJ;QACA,IAAIW,aAAa,MAAM,IAAI;YACvB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAE,OAAOA,aAAa,KAAK;YAAC,GAAG;YAChD,OAAOT,OAAO,EAAE,CAAC;QACrB;QAEA,OAAOA,OAAO,EAAE,CAACS,aAAa,KAAK;IACvC;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAAuC,CAAC;IACzE,gBAAgBtB;IAChB,cAAc;QACVuB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/RecordAuditLog/abstractions.d.ts

@@ -0,0 +1,26 @@
+import type { Result } from "@webiny/feature/api";
+import type { GenericRecord } from "@webiny/api/types.js";
+import type { AuditAction } from "../../types.js";
+import type { IAuditLog } from "../../storage/types.js";
+import type { CreateAuditLogUseCase } from "../../features/CreateAuditLog/abstractions.js";
+export interface RecordAuditLogInput {
+    audit: AuditAction;
+    message: string;
+    content: GenericRecord;
+    entityId: string;
+}
+/**
+ * RecordAuditLog Use Case - Records an audit log for something the current identity did. Returns
+ * null when nothing was recorded: there's no identity, or merging into an earlier log failed.
+ */
+export interface IRecordAuditLogUseCase {
+    execute(input: RecordAuditLogInput): Promise<Result<IAuditLog | null, UseCaseError>>;
+}
+type UseCaseError = CreateAuditLogUseCase.Error;
+export declare const RecordAuditLogUseCase: import("@webiny/di").Abstraction<IRecordAuditLogUseCase>;
+export declare namespace RecordAuditLogUseCase {
+    type Interface = IRecordAuditLogUseCase;
+    type Input = RecordAuditLogInput;
+    type Error = UseCaseError;
+}
+export {};

package/features/RecordAuditLog/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const RecordAuditLogUseCase = createAbstraction("RecordAuditLogUseCase");
+export { RecordAuditLogUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/RecordAuditLog/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/RecordAuditLog/abstractions.js","sources":["../../../src/features/RecordAuditLog/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport type { AuditAction } from \"~/types.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport type { CreateAuditLogUseCase } from \"~/features/CreateAuditLog/abstractions.js\";\n\nexport interface RecordAuditLogInput {\n    audit: AuditAction;\n    message: string;\n    content: GenericRecord;\n    entityId: string;\n}\n\n/**\n * RecordAuditLog Use Case - Records an audit log for something the current identity did. Returns\n * null when nothing was recorded: there's no identity, or merging into an earlier log failed.\n */\nexport interface IRecordAuditLogUseCase {\n    execute(input: RecordAuditLogInput): Promise<Result<IAuditLog | null, UseCaseError>>;\n}\n\ntype UseCaseError = CreateAuditLogUseCase.Error;\n\nexport const RecordAuditLogUseCase =\n    createAbstraction<IRecordAuditLogUseCase>(\"RecordAuditLogUseCase\");\n\nexport namespace RecordAuditLogUseCase {\n    export type Interface = IRecordAuditLogUseCase;\n    export type Input = RecordAuditLogInput;\n    export type Error = UseCaseError;\n}\n"],"names":["RecordAuditLogUseCase","createAbstraction"],"mappings":";AAwBO,MAAMA,wBACTC,kBAA0C"}

package/features/RecordAuditLog/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const RecordAuditLogFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/RecordAuditLog/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { RecordAuditLogUseCase } from "./RecordAuditLogUseCase.js";
+const RecordAuditLogFeature = createFeature({
+    name: "AuditLogs/RecordAuditLog",
+    register (container) {
+        container.register(RecordAuditLogUseCase);
+    }
+});
+export { RecordAuditLogFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/RecordAuditLog/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/RecordAuditLog/feature.js","sources":["../../../src/features/RecordAuditLog/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { RecordAuditLogUseCase } from \"./RecordAuditLogUseCase.js\";\n\nexport const RecordAuditLogFeature = createFeature({\n    name: \"AuditLogs/RecordAuditLog\",\n    register(container) {\n        container.register(RecordAuditLogUseCase);\n    }\n});\n"],"names":["RecordAuditLogFeature","createFeature","container","RecordAuditLogUseCase"],"mappings":";;AAGO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/UpdateAuditLog/UpdateAuditLogGateway.d.ts

@@ -0,0 +1,12 @@
+import { AuditLogsStorage } from "../../abstractions.js";
+import type { IAuditLog } from "../../storage/types.js";
+import { UpdateAuditLogGateway as Abstraction } from "./abstractions.js";
+declare class UpdateAuditLogGatewayImpl implements Abstraction.Interface {
+    private readonly storage;
+    constructor(storage: AuditLogsStorage.Interface);
+    update(auditLog: IAuditLog): Promise<IAuditLog>;
+}
+export declare const UpdateAuditLogGateway: typeof UpdateAuditLogGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateAuditLogGateway>;
+};
+export {};

package/features/UpdateAuditLog/UpdateAuditLogGateway.js

@@ -0,0 +1,23 @@
+import { AuditLogsStorage } from "../../abstractions.js";
+import { UpdateAuditLogGateway } from "./abstractions.js";
+class UpdateAuditLogGatewayImpl {
+    constructor(storage){
+        this.storage = storage;
+    }
+    async update(auditLog) {
+        const result = await this.storage.store({
+            data: auditLog
+        });
+        if (!result.success) throw result.error;
+        return result.data;
+    }
+}
+const UpdateAuditLogGateway_UpdateAuditLogGateway = UpdateAuditLogGateway.createImplementation({
+    implementation: UpdateAuditLogGatewayImpl,
+    dependencies: [
+        AuditLogsStorage
+    ]
+});
+export { UpdateAuditLogGateway_UpdateAuditLogGateway as UpdateAuditLogGateway };
+
+//# sourceMappingURL=UpdateAuditLogGateway.js.map

package/features/UpdateAuditLog/UpdateAuditLogGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateAuditLog/UpdateAuditLogGateway.js","sources":["../../../src/features/UpdateAuditLog/UpdateAuditLogGateway.ts"],"sourcesContent":["import { AuditLogsStorage } from \"~/abstractions.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport { UpdateAuditLogGateway as Abstraction } from \"./abstractions.js\";\n\nclass UpdateAuditLogGatewayImpl implements Abstraction.Interface {\n    public constructor(private readonly storage: AuditLogsStorage.Interface) {}\n\n    public async update(auditLog: IAuditLog): Promise<IAuditLog> {\n        const result = await this.storage.store({ data: auditLog });\n        if (!result.success) {\n            throw result.error;\n        }\n        return result.data;\n    }\n}\n\nexport const UpdateAuditLogGateway = Abstraction.createImplementation({\n    implementation: UpdateAuditLogGatewayImpl,\n    dependencies: [AuditLogsStorage]\n});\n"],"names":["UpdateAuditLogGatewayImpl","storage","auditLog","result","UpdateAuditLogGateway","Abstraction","AuditLogsStorage"],"mappings":";;AAIA,MAAMA;IACF,YAAoCC,OAAmC,CAAE;aAArCA,OAAO,GAAPA;IAAsC;IAE1E,MAAa,OAAOC,QAAmB,EAAsB;QACzD,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,MAAMD;QAAS;QACzD,IAAI,CAACC,OAAO,OAAO,EACf,MAAMA,OAAO,KAAK;QAEtB,OAAOA,OAAO,IAAI;IACtB;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAAgC,CAAC;IAClE,gBAAgBL;IAChB,cAAc;QAACM;KAAiB;AACpC"}

package/features/UpdateAuditLog/UpdateAuditLogRepository.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { AuditLogPersistenceError } from "../../domain/errors.js";
+import type { IAuditLog } from "../../storage/types.js";
+import { UpdateAuditLogRepository as Abstraction } from "./abstractions.js";
+import { UpdateAuditLogGateway } from "./abstractions.js";
+declare class UpdateAuditLogRepositoryImpl implements Abstraction.Interface {
+    private readonly gateway;
+    constructor(gateway: UpdateAuditLogGateway.Interface);
+    update(auditLog: IAuditLog): Promise<Result<IAuditLog, AuditLogPersistenceError>>;
+}
+export declare const UpdateAuditLogRepository: typeof UpdateAuditLogRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateAuditLogRepository>;
+};
+export {};

package/features/UpdateAuditLog/UpdateAuditLogRepository.js

@@ -0,0 +1,25 @@
+import { Result } from "@webiny/feature/api";
+import { AuditLogPersistenceError } from "../../domain/errors.js";
+import { UpdateAuditLogGateway, UpdateAuditLogRepository } from "./abstractions.js";
+class UpdateAuditLogRepositoryImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async update(auditLog) {
+        try {
+            const updated = await this.gateway.update(auditLog);
+            return Result.ok(updated);
+        } catch (error) {
+            return Result.fail(new AuditLogPersistenceError(error));
+        }
+    }
+}
+const UpdateAuditLogRepository_UpdateAuditLogRepository = UpdateAuditLogRepository.createImplementation({
+    implementation: UpdateAuditLogRepositoryImpl,
+    dependencies: [
+        UpdateAuditLogGateway
+    ]
+});
+export { UpdateAuditLogRepository_UpdateAuditLogRepository as UpdateAuditLogRepository };
+
+//# sourceMappingURL=UpdateAuditLogRepository.js.map

package/features/UpdateAuditLog/UpdateAuditLogRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateAuditLog/UpdateAuditLogRepository.js","sources":["../../../src/features/UpdateAuditLog/UpdateAuditLogRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { AuditLogPersistenceError } from \"~/domain/errors.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport { UpdateAuditLogRepository as Abstraction } from \"./abstractions.js\";\nimport { UpdateAuditLogGateway } from \"./abstractions.js\";\n\nclass UpdateAuditLogRepositoryImpl implements Abstraction.Interface {\n    public constructor(private readonly gateway: UpdateAuditLogGateway.Interface) {}\n\n    public async update(auditLog: IAuditLog): Promise<Result<IAuditLog, AuditLogPersistenceError>> {\n        try {\n            const updated = await this.gateway.update(auditLog);\n            return Result.ok(updated);\n        } catch (error) {\n            return Result.fail(new AuditLogPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const UpdateAuditLogRepository = Abstraction.createImplementation({\n    implementation: UpdateAuditLogRepositoryImpl,\n    dependencies: [UpdateAuditLogGateway]\n});\n"],"names":["UpdateAuditLogRepositoryImpl","gateway","auditLog","updated","Result","error","AuditLogPersistenceError","UpdateAuditLogRepository","Abstraction","UpdateAuditLogGateway"],"mappings":";;;AAMA,MAAMA;IACF,YAAoCC,OAAwC,CAAE;aAA1CA,OAAO,GAAPA;IAA2C;IAE/E,MAAa,OAAOC,QAAmB,EAAwD;QAC3F,IAAI;YACA,MAAMC,UAAU,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAACD;YAC1C,OAAOE,OAAO,EAAE,CAACD;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAOD,OAAO,IAAI,CAAC,IAAIE,yBAAyBD;QACpD;IACJ;AACJ;AAEO,MAAME,oDAA2BC,yBAAAA,oBAAgC,CAAC;IACrE,gBAAgBR;IAChB,cAAc;QAACS;KAAsB;AACzC"}

package/features/UpdateAuditLog/UpdateAuditLogUseCase.d.ts

@@ -0,0 +1,18 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogPermissions } from "../../features/AuditLogPermissions/abstractions.js";
+import type { AuditLogPayload } from "../../types.js";
+import type { IAuditLog } from "../../storage/types.js";
+import { UpdateAuditLogUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { UpdateAuditLogRepository } from "./abstractions.js";
+declare class UpdateAuditLogUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly repository;
+    private readonly permissions;
+    private readonly eventPublisher;
+    constructor(repository: UpdateAuditLogRepository.Interface, permissions: AuditLogPermissions.Interface, eventPublisher: EventPublisher.Interface);
+    execute(original: IAuditLog, payload: Partial<AuditLogPayload>): Promise<Result<IAuditLog, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateAuditLogUseCase: typeof UpdateAuditLogUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateAuditLogUseCase>;
+};
+export {};

package/features/UpdateAuditLog/UpdateAuditLogUseCase.js

@@ -0,0 +1,53 @@
+import { Result } from "@webiny/feature/api";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogPermissions } from "../AuditLogPermissions/abstractions.js";
+import { AuditLogAfterUpdateEvent, AuditLogBeforeUpdateEvent } from "../../events/index.js";
+import { UpdateAuditLogRepository, UpdateAuditLogUseCase } from "./abstractions.js";
+class UpdateAuditLogUseCaseImpl {
+    constructor(repository, permissions, eventPublisher){
+        this.repository = repository;
+        this.permissions = permissions;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(original, payload) {
+        let content = original.content;
+        if (payload.content) content = JSON.stringify(payload.content);
+        const auditLog = {
+            ...original,
+            ...payload,
+            content
+        };
+        const canAccess = await this.permissions.canAccess(auditLog.action);
+        if (!canAccess) return Result.fail(new NotAuthorizedError({
+            message: "You cannot access audit logs."
+        }));
+        const beforeUpdateEvent = new AuditLogBeforeUpdateEvent({
+            original,
+            auditLog,
+            setAuditLog (input) {
+                Object.assign(auditLog, input);
+            }
+        });
+        await this.eventPublisher.publish(beforeUpdateEvent);
+        const result = await this.repository.update(auditLog);
+        if (result.isFail()) return Result.fail(result.error);
+        const afterUpdateEvent = new AuditLogAfterUpdateEvent({
+            original,
+            auditLog
+        });
+        await this.eventPublisher.publish(afterUpdateEvent);
+        return Result.ok(result.value);
+    }
+}
+const UpdateAuditLogUseCase_UpdateAuditLogUseCase = UpdateAuditLogUseCase.createImplementation({
+    implementation: UpdateAuditLogUseCaseImpl,
+    dependencies: [
+        UpdateAuditLogRepository,
+        AuditLogPermissions,
+        EventPublisher
+    ]
+});
+export { UpdateAuditLogUseCase_UpdateAuditLogUseCase as UpdateAuditLogUseCase };
+
+//# sourceMappingURL=UpdateAuditLogUseCase.js.map

package/features/UpdateAuditLog/UpdateAuditLogUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateAuditLog/UpdateAuditLogUseCase.js","sources":["../../../src/features/UpdateAuditLog/UpdateAuditLogUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { AuditLogPermissions } from \"~/features/AuditLogPermissions/abstractions.js\";\nimport { AuditLogBeforeUpdateEvent } from \"~/events/index.js\";\nimport { AuditLogAfterUpdateEvent } from \"~/events/index.js\";\nimport type { AuditLogPayload } from \"~/types.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport { UpdateAuditLogUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { UpdateAuditLogRepository } from \"./abstractions.js\";\n\nclass UpdateAuditLogUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private readonly repository: UpdateAuditLogRepository.Interface,\n        private readonly permissions: AuditLogPermissions.Interface,\n        private readonly eventPublisher: EventPublisher.Interface\n    ) {}\n\n    public async execute(\n        original: IAuditLog,\n        payload: Partial<AuditLogPayload>\n    ): Promise<Result<IAuditLog, UseCaseAbstraction.Error>> {\n        let content = original.content;\n        if (payload.content) {\n            content = JSON.stringify(payload.content);\n        }\n\n        const auditLog: IAuditLog = {\n            ...original,\n            ...payload,\n            content\n        };\n\n        const canAccess = await this.permissions.canAccess(auditLog.action);\n        if (!canAccess) {\n            return Result.fail(\n                new NotAuthorizedError({ message: \"You cannot access audit logs.\" })\n            );\n        }\n\n        const beforeUpdateEvent = new AuditLogBeforeUpdateEvent({\n            original,\n            auditLog,\n            setAuditLog(input) {\n                Object.assign(auditLog, input);\n            }\n        });\n        await this.eventPublisher.publish(beforeUpdateEvent);\n\n        const result = await this.repository.update(auditLog);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const afterUpdateEvent = new AuditLogAfterUpdateEvent({ original, auditLog });\n        await this.eventPublisher.publish(afterUpdateEvent);\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const UpdateAuditLogUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UpdateAuditLogUseCaseImpl,\n    dependencies: [UpdateAuditLogRepository, AuditLogPermissions, EventPublisher]\n});\n"],"names":["UpdateAuditLogUseCaseImpl","repository","permissions","eventPublisher","original","payload","content","JSON","auditLog","canAccess","Result","NotAuthorizedError","beforeUpdateEvent","AuditLogBeforeUpdateEvent","input","Object","result","afterUpdateEvent","AuditLogAfterUpdateEvent","UpdateAuditLogUseCase","UseCaseAbstraction","UpdateAuditLogRepository","AuditLogPermissions","EventPublisher"],"mappings":";;;;;;AAWA,MAAMA;IACF,YACqBC,UAA8C,EAC9CC,WAA0C,EAC1CC,cAAwC,CAC3D;aAHmBF,UAAU,GAAVA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;IAClB;IAEH,MAAa,QACTC,QAAmB,EACnBC,OAAiC,EACmB;QACpD,IAAIC,UAAUF,SAAS,OAAO;QAC9B,IAAIC,QAAQ,OAAO,EACfC,UAAUC,KAAK,SAAS,CAACF,QAAQ,OAAO;QAG5C,MAAMG,WAAsB;YACxB,GAAGJ,QAAQ;YACX,GAAGC,OAAO;YACVC;QACJ;QAEA,MAAMG,YAAY,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAACD,SAAS,MAAM;QAClE,IAAI,CAACC,WACD,OAAOC,OAAO,IAAI,CACd,IAAIC,mBAAmB;YAAE,SAAS;QAAgC;QAI1E,MAAMC,oBAAoB,IAAIC,0BAA0B;YACpDT;YACAI;YACA,aAAYM,KAAK;gBACbC,OAAO,MAAM,CAACP,UAAUM;YAC5B;QACJ;QACA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACF;QAElC,MAAMI,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACR;QAC5C,IAAIQ,OAAO,MAAM,IACb,OAAON,OAAO,IAAI,CAACM,OAAO,KAAK;QAGnC,MAAMC,mBAAmB,IAAIC,yBAAyB;YAAEd;YAAUI;QAAS;QAC3E,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACS;QAElC,OAAOP,OAAO,EAAE,CAACM,OAAO,KAAK;IACjC;AACJ;AAEO,MAAMG,8CAAwBC,sBAAAA,oBAAuC,CAAC;IACzE,gBAAgBpB;IAChB,cAAc;QAACqB;QAA0BC;QAAqBC;KAAe;AACjF"}

package/features/UpdateAuditLog/abstractions.d.ts

@@ -0,0 +1,42 @@
+import type { Result } from "@webiny/feature/api";
+import type { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import type { AuditLogPayload } from "../../types.js";
+import type { IAuditLog } from "../../storage/types.js";
+import type { AuditLogPersistenceError } from "../../domain/errors.js";
+/**
+ * UpdateAuditLog Use Case - Updates an existing audit log with new values.
+ */
+export interface IUpdateAuditLogUseCase {
+    execute(original: IAuditLog, payload: Partial<AuditLogPayload>): Promise<Result<IAuditLog, UseCaseError>>;
+}
+export interface IUpdateAuditLogUseCaseErrors {
+    notAuthorized: NotAuthorizedError;
+    persistence: AuditLogPersistenceError;
+}
+type UseCaseError = IUpdateAuditLogUseCaseErrors[keyof IUpdateAuditLogUseCaseErrors];
+export declare const UpdateAuditLogUseCase: import("@webiny/di").Abstraction<IUpdateAuditLogUseCase>;
+export declare namespace UpdateAuditLogUseCase {
+    type Interface = IUpdateAuditLogUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * UpdateAuditLogRepository - Stores an updated audit log.
+ */
+export interface IUpdateAuditLogRepository {
+    update(auditLog: IAuditLog): Promise<Result<IAuditLog, AuditLogPersistenceError>>;
+}
+export declare const UpdateAuditLogRepository: import("@webiny/di").Abstraction<IUpdateAuditLogRepository>;
+export declare namespace UpdateAuditLogRepository {
+    type Interface = IUpdateAuditLogRepository;
+}
+/**
+ * UpdateAuditLogGateway - Writes an updated audit log to the audit logs storage.
+ */
+export interface IUpdateAuditLogGateway {
+    update(auditLog: IAuditLog): Promise<IAuditLog>;
+}
+export declare const UpdateAuditLogGateway: import("@webiny/di").Abstraction<IUpdateAuditLogGateway>;
+export declare namespace UpdateAuditLogGateway {
+    type Interface = IUpdateAuditLogGateway;
+}
+export {};

package/features/UpdateAuditLog/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/api";
+const UpdateAuditLogUseCase = createAbstraction("UpdateAuditLogUseCase");
+const UpdateAuditLogRepository = createAbstraction("UpdateAuditLogRepository");
+const UpdateAuditLogGateway = createAbstraction("UpdateAuditLogGateway");
+export { UpdateAuditLogGateway, UpdateAuditLogRepository, UpdateAuditLogUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/UpdateAuditLog/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateAuditLog/abstractions.js","sources":["../../../src/features/UpdateAuditLog/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport type { AuditLogPayload } from \"~/types.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport type { AuditLogPersistenceError } from \"~/domain/errors.js\";\n\n/**\n * UpdateAuditLog Use Case - Updates an existing audit log with new values.\n */\nexport interface IUpdateAuditLogUseCase {\n    execute(\n        original: IAuditLog,\n        payload: Partial<AuditLogPayload>\n    ): Promise<Result<IAuditLog, UseCaseError>>;\n}\n\nexport interface IUpdateAuditLogUseCaseErrors {\n    notAuthorized: NotAuthorizedError;\n    persistence: AuditLogPersistenceError;\n}\n\ntype UseCaseError = IUpdateAuditLogUseCaseErrors[keyof IUpdateAuditLogUseCaseErrors];\n\nexport const UpdateAuditLogUseCase =\n    createAbstraction<IUpdateAuditLogUseCase>(\"UpdateAuditLogUseCase\");\n\nexport namespace UpdateAuditLogUseCase {\n    export type Interface = IUpdateAuditLogUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * UpdateAuditLogRepository - Stores an updated audit log.\n */\nexport interface IUpdateAuditLogRepository {\n    update(auditLog: IAuditLog): Promise<Result<IAuditLog, AuditLogPersistenceError>>;\n}\n\nexport const UpdateAuditLogRepository = createAbstraction<IUpdateAuditLogRepository>(\n    \"UpdateAuditLogRepository\"\n);\n\nexport namespace UpdateAuditLogRepository {\n    export type Interface = IUpdateAuditLogRepository;\n}\n\n/**\n * UpdateAuditLogGateway - Writes an updated audit log to the audit logs storage.\n */\nexport interface IUpdateAuditLogGateway {\n    update(auditLog: IAuditLog): Promise<IAuditLog>;\n}\n\nexport const UpdateAuditLogGateway =\n    createAbstraction<IUpdateAuditLogGateway>(\"UpdateAuditLogGateway\");\n\nexport namespace UpdateAuditLogGateway {\n    export type Interface = IUpdateAuditLogGateway;\n}\n"],"names":["UpdateAuditLogUseCase","createAbstraction","UpdateAuditLogRepository","UpdateAuditLogGateway"],"mappings":";AAwBO,MAAMA,wBACTC,kBAA0C;AAcvC,MAAMC,2BAA2BD,kBACpC;AAcG,MAAME,wBACTF,kBAA0C"}

package/features/UpdateAuditLog/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const UpdateAuditLogFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/UpdateAuditLog/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateAuditLogUseCase } from "./UpdateAuditLogUseCase.js";
+import { UpdateAuditLogRepository } from "./UpdateAuditLogRepository.js";
+import { UpdateAuditLogGateway } from "./UpdateAuditLogGateway.js";
+const UpdateAuditLogFeature = createFeature({
+    name: "AuditLogs/UpdateAuditLog",
+    register (container) {
+        container.register(UpdateAuditLogUseCase);
+        container.register(UpdateAuditLogRepository).inSingletonScope();
+        container.register(UpdateAuditLogGateway).inSingletonScope();
+    }
+});
+export { UpdateAuditLogFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/UpdateAuditLog/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateAuditLog/feature.js","sources":["../../../src/features/UpdateAuditLog/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateAuditLogUseCase } from \"./UpdateAuditLogUseCase.js\";\nimport { UpdateAuditLogRepository } from \"./UpdateAuditLogRepository.js\";\nimport { UpdateAuditLogGateway } from \"./UpdateAuditLogGateway.js\";\n\nexport const UpdateAuditLogFeature = createFeature({\n    name: \"AuditLogs/UpdateAuditLog\",\n    register(container) {\n        container.register(UpdateAuditLogUseCase);\n        container.register(UpdateAuditLogRepository).inSingletonScope();\n        container.register(UpdateAuditLogGateway).inSingletonScope();\n    }\n});\n"],"names":["UpdateAuditLogFeature","createFeature","container","UpdateAuditLogUseCase","UpdateAuditLogRepository","UpdateAuditLogGateway"],"mappings":";;;;AAKO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,0BAA0B,gBAAgB;QAC7DF,UAAU,QAAQ,CAACG,uBAAuB,gBAAgB;IAC9D;AACJ"}

package/graphql/AuditLogsGraphQLSchema.d.ts

@@ -0,0 +1,10 @@
+import { CoreGraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { GraphQLSchemaBuilder } from "@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js";
+declare class AuditLogsGraphQLSchemaImpl implements CoreGraphQLSchemaFactory.Interface {
+    getSchemaKey: () => string;
+    execute(builder: GraphQLSchemaBuilder.Interface): CoreGraphQLSchemaFactory.Return;
+}
+export declare const AuditLogsGraphQLSchema: typeof AuditLogsGraphQLSchemaImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-graphql/graphql/abstractions.core.js").ICoreGraphQLSchemaFactory>;
+};
+export {};