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

package/features/GetAuditLog/abstractions.js

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

package/features/GetAuditLog/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/GetAuditLog/abstractions.js","sources":["../../../src/features/GetAuditLog/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 { IAuditLog } from \"~/storage/types.js\";\nimport type { IStorageFetchParams } from \"~/storage/abstractions/Storage.js\";\nimport type { AuditLogPersistenceError } from \"~/domain/errors.js\";\n\n/**\n * GetAuditLog Use Case - Gets an audit log of the current tenant by its id.\n */\nexport interface IGetAuditLogUseCase {\n    execute(id: string): Promise<Result<IAuditLog, UseCaseError>>;\n}\n\nexport interface IGetAuditLogUseCaseErrors {\n    notAuthorized: NotAuthorizedError;\n    persistence: AuditLogPersistenceError;\n}\n\ntype UseCaseError = IGetAuditLogUseCaseErrors[keyof IGetAuditLogUseCaseErrors];\n\nexport const GetAuditLogUseCase = createAbstraction<IGetAuditLogUseCase>(\"GetAuditLogUseCase\");\n\nexport namespace GetAuditLogUseCase {\n    export type Interface = IGetAuditLogUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * GetAuditLogRepository - Fetches an audit log of the current tenant.\n */\nexport interface IGetAuditLogRepository {\n    get(id: string): Promise<Result<IAuditLog, AuditLogPersistenceError>>;\n}\n\nexport const GetAuditLogRepository =\n    createAbstraction<IGetAuditLogRepository>(\"GetAuditLogRepository\");\n\nexport namespace GetAuditLogRepository {\n    export type Interface = IGetAuditLogRepository;\n}\n\n/**\n * GetAuditLogGateway - Reads an audit log from the audit logs storage.\n */\nexport interface IGetAuditLogGateway {\n    get(params: IStorageFetchParams): Promise<IAuditLog>;\n}\n\nexport const GetAuditLogGateway = createAbstraction<IGetAuditLogGateway>(\"GetAuditLogGateway\");\n\nexport namespace GetAuditLogGateway {\n    export type Interface = IGetAuditLogGateway;\n}\n"],"names":["GetAuditLogUseCase","createAbstraction","GetAuditLogRepository","GetAuditLogGateway"],"mappings":";AAqBO,MAAMA,qBAAqBC,kBAAuC;AAclE,MAAMC,wBACTD,kBAA0C;AAavC,MAAME,qBAAqBF,kBAAuC"}

package/features/GetAuditLog/feature.d.ts

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

package/features/GetAuditLog/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetAuditLogUseCase } from "./GetAuditLogUseCase.js";
+import { GetAuditLogRepository } from "./GetAuditLogRepository.js";
+import { GetAuditLogGateway } from "./GetAuditLogGateway.js";
+const GetAuditLogFeature = createFeature({
+    name: "AuditLogs/GetAuditLog",
+    register (container) {
+        container.register(GetAuditLogUseCase);
+        container.register(GetAuditLogRepository).inSingletonScope();
+        container.register(GetAuditLogGateway).inSingletonScope();
+    }
+});
+export { GetAuditLogFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/GetAuditLog/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/GetAuditLog/feature.js","sources":["../../../src/features/GetAuditLog/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetAuditLogUseCase } from \"./GetAuditLogUseCase.js\";\nimport { GetAuditLogRepository } from \"./GetAuditLogRepository.js\";\nimport { GetAuditLogGateway } from \"./GetAuditLogGateway.js\";\n\nexport const GetAuditLogFeature = createFeature({\n    name: \"AuditLogs/GetAuditLog\",\n    register(container) {\n        container.register(GetAuditLogUseCase);\n        container.register(GetAuditLogRepository).inSingletonScope();\n        container.register(GetAuditLogGateway).inSingletonScope();\n    }\n});\n"],"names":["GetAuditLogFeature","createFeature","container","GetAuditLogUseCase","GetAuditLogRepository","GetAuditLogGateway"],"mappings":";;;;AAKO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;QAC1DF,UAAU,QAAQ,CAACG,oBAAoB,gBAAgB;IAC3D;AACJ"}

package/features/ListAuditLogs/ListAuditLogsGateway.d.ts

@@ -0,0 +1,12 @@
+import { AuditLogsStorage } from "../../abstractions.js";
+import type { IStorageListParams } from "../../storage/abstractions/Storage.js";
+import { ListAuditLogsGateway as Abstraction } from "./abstractions.js";
+declare class ListAuditLogsGatewayImpl implements Abstraction.Interface {
+    private readonly storage;
+    constructor(storage: AuditLogsStorage.Interface);
+    list(params: IStorageListParams): Promise<Abstraction.Output>;
+}
+export declare const ListAuditLogsGateway: typeof ListAuditLogsGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListAuditLogsGateway>;
+};
+export {};

package/features/ListAuditLogs/ListAuditLogsGateway.js

@@ -0,0 +1,24 @@
+import { AuditLogsStorage } from "../../abstractions.js";
+import { ListAuditLogsGateway } from "./abstractions.js";
+class ListAuditLogsGatewayImpl {
+    constructor(storage){
+        this.storage = storage;
+    }
+    async list(params) {
+        const result = await this.storage.list(params);
+        if (!result.success) throw result.error;
+        return {
+            items: result.data,
+            meta: result.meta
+        };
+    }
+}
+const ListAuditLogsGateway_ListAuditLogsGateway = ListAuditLogsGateway.createImplementation({
+    implementation: ListAuditLogsGatewayImpl,
+    dependencies: [
+        AuditLogsStorage
+    ]
+});
+export { ListAuditLogsGateway_ListAuditLogsGateway as ListAuditLogsGateway };
+
+//# sourceMappingURL=ListAuditLogsGateway.js.map

package/features/ListAuditLogs/ListAuditLogsGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListAuditLogs/ListAuditLogsGateway.js","sources":["../../../src/features/ListAuditLogs/ListAuditLogsGateway.ts"],"sourcesContent":["import { AuditLogsStorage } from \"~/abstractions.js\";\nimport type { IStorageListParams } from \"~/storage/abstractions/Storage.js\";\nimport { ListAuditLogsGateway as Abstraction } from \"./abstractions.js\";\n\nclass ListAuditLogsGatewayImpl implements Abstraction.Interface {\n    public constructor(private readonly storage: AuditLogsStorage.Interface) {}\n\n    public async list(params: IStorageListParams): Promise<Abstraction.Output> {\n        const result = await this.storage.list(params);\n        if (!result.success) {\n            throw result.error;\n        }\n        return {\n            items: result.data,\n            meta: result.meta\n        };\n    }\n}\n\nexport const ListAuditLogsGateway = Abstraction.createImplementation({\n    implementation: ListAuditLogsGatewayImpl,\n    dependencies: [AuditLogsStorage]\n});\n"],"names":["ListAuditLogsGatewayImpl","storage","params","result","ListAuditLogsGateway","Abstraction","AuditLogsStorage"],"mappings":";;AAIA,MAAMA;IACF,YAAoCC,OAAmC,CAAE;aAArCA,OAAO,GAAPA;IAAsC;IAE1E,MAAa,KAAKC,MAA0B,EAA+B;QACvE,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAACD;QACvC,IAAI,CAACC,OAAO,OAAO,EACf,MAAMA,OAAO,KAAK;QAEtB,OAAO;YACH,OAAOA,OAAO,IAAI;YAClB,MAAMA,OAAO,IAAI;QACrB;IACJ;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBL;IAChB,cAAc;QAACM;KAAiB;AACpC"}

package/features/ListAuditLogs/ListAuditLogsRepository.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { AuditLogPersistenceError } from "../../domain/errors.js";
+import type { IListAuditLogsParams } from "../../types.js";
+import { ListAuditLogsRepository as Abstraction } from "./abstractions.js";
+import { ListAuditLogsGateway } from "./abstractions.js";
+import type { ListAuditLogsOutput } from "./abstractions.js";
+declare class ListAuditLogsRepositoryImpl implements Abstraction.Interface {
+    private readonly gateway;
+    private readonly tenantContext;
+    constructor(gateway: ListAuditLogsGateway.Interface, tenantContext: TenantContext.Interface);
+    list(params: IListAuditLogsParams): Promise<Result<ListAuditLogsOutput, AuditLogPersistenceError>>;
+}
+export declare const ListAuditLogsRepository: typeof ListAuditLogsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListAuditLogsRepository>;
+};
+export {};

package/features/ListAuditLogs/ListAuditLogsRepository.js

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { AuditLogPersistenceError } from "../../domain/errors.js";
+import { ListAuditLogsGateway, ListAuditLogsRepository } from "./abstractions.js";
+class ListAuditLogsRepositoryImpl {
+    constructor(gateway, tenantContext){
+        this.gateway = gateway;
+        this.tenantContext = tenantContext;
+    }
+    async list(params) {
+        try {
+            const storageParams = {
+                ...params,
+                tenant: this.tenantContext.getTenant().id
+            };
+            const { items, meta } = await this.gateway.list(storageParams);
+            return Result.ok({
+                items,
+                meta: {
+                    cursor: meta.after || null,
+                    hasMoreItems: meta.hasMoreItems
+                }
+            });
+        } catch (error) {
+            return Result.fail(new AuditLogPersistenceError(error));
+        }
+    }
+}
+const ListAuditLogsRepository_ListAuditLogsRepository = ListAuditLogsRepository.createImplementation({
+    implementation: ListAuditLogsRepositoryImpl,
+    dependencies: [
+        ListAuditLogsGateway,
+        TenantContext
+    ]
+});
+export { ListAuditLogsRepository_ListAuditLogsRepository as ListAuditLogsRepository };
+
+//# sourceMappingURL=ListAuditLogsRepository.js.map

package/features/ListAuditLogs/ListAuditLogsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListAuditLogs/ListAuditLogsRepository.js","sources":["../../../src/features/ListAuditLogs/ListAuditLogsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { AuditLogPersistenceError } from \"~/domain/errors.js\";\nimport type { IListAuditLogsParams } from \"~/types.js\";\nimport type { IStorageListParams } from \"~/storage/abstractions/Storage.js\";\nimport { ListAuditLogsRepository as Abstraction } from \"./abstractions.js\";\nimport { ListAuditLogsGateway } from \"./abstractions.js\";\nimport type { ListAuditLogsOutput } from \"./abstractions.js\";\n\nclass ListAuditLogsRepositoryImpl implements Abstraction.Interface {\n    public constructor(\n        private readonly gateway: ListAuditLogsGateway.Interface,\n        private readonly tenantContext: TenantContext.Interface\n    ) {}\n\n    public async list(\n        params: IListAuditLogsParams\n    ): Promise<Result<ListAuditLogsOutput, AuditLogPersistenceError>> {\n        try {\n            const storageParams = {\n                ...params,\n                tenant: this.tenantContext.getTenant().id\n            } as unknown as IStorageListParams;\n\n            const { items, meta } = await this.gateway.list(storageParams);\n\n            return Result.ok({\n                items,\n                meta: {\n                    cursor: meta.after || null,\n                    hasMoreItems: meta.hasMoreItems\n                }\n            });\n        } catch (error) {\n            return Result.fail(new AuditLogPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const ListAuditLogsRepository = Abstraction.createImplementation({\n    implementation: ListAuditLogsRepositoryImpl,\n    dependencies: [ListAuditLogsGateway, TenantContext]\n});\n"],"names":["ListAuditLogsRepositoryImpl","gateway","tenantContext","params","storageParams","items","meta","Result","error","AuditLogPersistenceError","ListAuditLogsRepository","Abstraction","ListAuditLogsGateway","TenantContext"],"mappings":";;;;AASA,MAAMA;IACF,YACqBC,OAAuC,EACvCC,aAAsC,CACzD;aAFmBD,OAAO,GAAPA;aACAC,aAAa,GAAbA;IAClB;IAEH,MAAa,KACTC,MAA4B,EACkC;QAC9D,IAAI;YACA,MAAMC,gBAAgB;gBAClB,GAAGD,MAAM;gBACT,QAAQ,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,EAAE;YAC7C;YAEA,MAAM,EAAEE,KAAK,EAAEC,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAACF;YAEhD,OAAOG,OAAO,EAAE,CAAC;gBACbF;gBACA,MAAM;oBACF,QAAQC,KAAK,KAAK,IAAI;oBACtB,cAAcA,KAAK,YAAY;gBACnC;YACJ;QACJ,EAAE,OAAOE,OAAO;YACZ,OAAOD,OAAO,IAAI,CAAC,IAAIE,yBAAyBD;QACpD;IACJ;AACJ;AAEO,MAAME,kDAA0BC,wBAAAA,oBAAgC,CAAC;IACpE,gBAAgBX;IAChB,cAAc;QAACY;QAAsBC;KAAc;AACvD"}

package/features/ListAuditLogs/ListAuditLogsUseCase.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { AuditLogPermissions } from "../../features/AuditLogPermissions/abstractions.js";
+import type { IListAuditLogsParams } from "../../types.js";
+import { ListAuditLogsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ListAuditLogsRepository } from "./abstractions.js";
+declare class ListAuditLogsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly repository;
+    private readonly permissions;
+    constructor(repository: ListAuditLogsRepository.Interface, permissions: AuditLogPermissions.Interface);
+    execute(params: IListAuditLogsParams): Promise<Result<UseCaseAbstraction.Output, UseCaseAbstraction.Error>>;
+}
+export declare const ListAuditLogsUseCase: typeof ListAuditLogsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListAuditLogsUseCase>;
+};
+export {};

package/features/ListAuditLogs/ListAuditLogsUseCase.js

@@ -0,0 +1,27 @@
+import { Result } from "@webiny/feature/api";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { AuditLogPermissions } from "../AuditLogPermissions/abstractions.js";
+import { ListAuditLogsRepository, ListAuditLogsUseCase } from "./abstractions.js";
+class ListAuditLogsUseCaseImpl {
+    constructor(repository, permissions){
+        this.repository = repository;
+        this.permissions = permissions;
+    }
+    async execute(params) {
+        const canAccess = await this.permissions.canAccessAll();
+        if (!canAccess) return Result.fail(new NotAuthorizedError({
+            message: "You cannot access audit logs."
+        }));
+        return await this.repository.list(params);
+    }
+}
+const ListAuditLogsUseCase_ListAuditLogsUseCase = ListAuditLogsUseCase.createImplementation({
+    implementation: ListAuditLogsUseCaseImpl,
+    dependencies: [
+        ListAuditLogsRepository,
+        AuditLogPermissions
+    ]
+});
+export { ListAuditLogsUseCase_ListAuditLogsUseCase as ListAuditLogsUseCase };
+
+//# sourceMappingURL=ListAuditLogsUseCase.js.map

package/features/ListAuditLogs/ListAuditLogsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListAuditLogs/ListAuditLogsUseCase.js","sources":["../../../src/features/ListAuditLogs/ListAuditLogsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport { AuditLogPermissions } from \"~/features/AuditLogPermissions/abstractions.js\";\nimport type { IListAuditLogsParams } from \"~/types.js\";\nimport { ListAuditLogsUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { ListAuditLogsRepository } from \"./abstractions.js\";\n\nclass ListAuditLogsUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private readonly repository: ListAuditLogsRepository.Interface,\n        private readonly permissions: AuditLogPermissions.Interface\n    ) {}\n\n    public async execute(\n        params: IListAuditLogsParams\n    ): Promise<Result<UseCaseAbstraction.Output, UseCaseAbstraction.Error>> {\n        const canAccess = await this.permissions.canAccessAll();\n        if (!canAccess) {\n            return Result.fail(\n                new NotAuthorizedError({ message: \"You cannot access audit logs.\" })\n            );\n        }\n\n        return await this.repository.list(params);\n    }\n}\n\nexport const ListAuditLogsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListAuditLogsUseCaseImpl,\n    dependencies: [ListAuditLogsRepository, AuditLogPermissions]\n});\n"],"names":["ListAuditLogsUseCaseImpl","repository","permissions","params","canAccess","Result","NotAuthorizedError","ListAuditLogsUseCase","UseCaseAbstraction","ListAuditLogsRepository","AuditLogPermissions"],"mappings":";;;;AAOA,MAAMA;IACF,YACqBC,UAA6C,EAC7CC,WAA0C,CAC7D;aAFmBD,UAAU,GAAVA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAa,QACTC,MAA4B,EACwC;QACpE,MAAMC,YAAY,MAAM,IAAI,CAAC,WAAW,CAAC,YAAY;QACrD,IAAI,CAACA,WACD,OAAOC,OAAO,IAAI,CACd,IAAIC,mBAAmB;YAAE,SAAS;QAAgC;QAI1E,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAACH;IACtC;AACJ;AAEO,MAAMI,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBR;IAChB,cAAc;QAACS;QAAyBC;KAAoB;AAChE"}

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":"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"}

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