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

package/events/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events/abstractions.js","sources":["../../src/events/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { DomainEvent, IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\n\n// ============================================================================\n// AuditLogBeforeCreate Event\n// ============================================================================\n\nexport interface AuditLogBeforeCreatePayload {\n    auditLog: IAuditLog;\n    setAuditLog(auditLog: Partial<IAuditLog>): void;\n}\n\nexport const AuditLogBeforeCreateHandler = createAbstraction<\n    IEventHandler<DomainEvent<AuditLogBeforeCreatePayload>>\n>(\"AuditLogBeforeCreateHandler\");\n\nexport namespace AuditLogBeforeCreateHandler {\n    export type Interface = IEventHandler<DomainEvent<AuditLogBeforeCreatePayload>>;\n    export type Event = DomainEvent<AuditLogBeforeCreatePayload>;\n}\n\n// ============================================================================\n// AuditLogAfterCreate Event\n// ============================================================================\n\nexport interface AuditLogAfterCreatePayload {\n    auditLog: IAuditLog;\n}\n\nexport const AuditLogAfterCreateHandler = createAbstraction<\n    IEventHandler<DomainEvent<AuditLogAfterCreatePayload>>\n>(\"AuditLogAfterCreateHandler\");\n\nexport namespace AuditLogAfterCreateHandler {\n    export type Interface = IEventHandler<DomainEvent<AuditLogAfterCreatePayload>>;\n    export type Event = DomainEvent<AuditLogAfterCreatePayload>;\n}\n\n// ============================================================================\n// AuditLogBeforeUpdate Event\n// ============================================================================\n\nexport interface AuditLogBeforeUpdatePayload {\n    auditLog: IAuditLog;\n    original: IAuditLog;\n    setAuditLog(auditLog: Partial<IAuditLog>): void;\n}\n\nexport const AuditLogBeforeUpdateHandler = createAbstraction<\n    IEventHandler<DomainEvent<AuditLogBeforeUpdatePayload>>\n>(\"AuditLogBeforeUpdateHandler\");\n\nexport namespace AuditLogBeforeUpdateHandler {\n    export type Interface = IEventHandler<DomainEvent<AuditLogBeforeUpdatePayload>>;\n    export type Event = DomainEvent<AuditLogBeforeUpdatePayload>;\n}\n\n// ============================================================================\n// AuditLogAfterUpdate Event\n// ============================================================================\n\nexport interface AuditLogAfterUpdatePayload {\n    auditLog: IAuditLog;\n    original: IAuditLog;\n}\n\nexport const AuditLogAfterUpdateHandler = createAbstraction<\n    IEventHandler<DomainEvent<AuditLogAfterUpdatePayload>>\n>(\"AuditLogAfterUpdateHandler\");\n\nexport namespace AuditLogAfterUpdateHandler {\n    export type Interface = IEventHandler<DomainEvent<AuditLogAfterUpdatePayload>>;\n    export type Event = DomainEvent<AuditLogAfterUpdatePayload>;\n}\n"],"names":["AuditLogBeforeCreateHandler","createAbstraction","AuditLogAfterCreateHandler","AuditLogBeforeUpdateHandler","AuditLogAfterUpdateHandler"],"mappings":";AAaO,MAAMA,8BAA8BC,kBAEzC;AAeK,MAAMC,6BAA6BD,kBAExC;AAiBK,MAAME,8BAA8BF,kBAEzC;AAgBK,MAAMG,6BAA6BH,kBAExC"}

package/events/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./abstractions.js";
+export * from "./AuditLogBeforeCreateEvent.js";
+export * from "./AuditLogAfterCreateEvent.js";
+export * from "./AuditLogBeforeUpdateEvent.js";
+export * from "./AuditLogAfterUpdateEvent.js";

package/events/index.js

@@ -0,0 +1,5 @@
+export * from "./abstractions.js";
+export * from "./AuditLogBeforeCreateEvent.js";
+export * from "./AuditLogAfterCreateEvent.js";
+export * from "./AuditLogBeforeUpdateEvent.js";
+export * from "./AuditLogAfterUpdateEvent.js";

package/features/AuditLogPermissions/AuditLogPermissions.d.ts

@@ -0,0 +1,15 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { AuditLogPermissions as Abstraction } from "./abstractions.js";
+/**
+ * Full access ("*"), access to all audit logs ("al.*"), or access to the action ("al.<action>").
+ */
+declare class AuditLogPermissionsImpl implements Abstraction.Interface {
+    private readonly identityContext;
+    constructor(identityContext: IdentityContext.Interface);
+    canAccessAll(): Promise<boolean>;
+    canAccess(action: string): Promise<boolean>;
+}
+export declare const AuditLogPermissions: typeof AuditLogPermissionsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IAuditLogPermissions>;
+};
+export {};

package/features/AuditLogPermissions/AuditLogPermissions.js

@@ -0,0 +1,24 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { AuditLogPermissions } from "./abstractions.js";
+class AuditLogPermissionsImpl {
+    constructor(identityContext){
+        this.identityContext = identityContext;
+    }
+    async canAccessAll() {
+        const permissions = await this.identityContext.getPermissions("al.*");
+        return permissions.some((permission)=>"*" === permission.name || "al.*" === permission.name);
+    }
+    async canAccess(action) {
+        const permissions = await this.identityContext.getPermissions("al.*");
+        return permissions.some((permission)=>"*" === permission.name || "al.*" === permission.name || permission.name === `al.${action}`);
+    }
+}
+const AuditLogPermissions_AuditLogPermissions = AuditLogPermissions.createImplementation({
+    implementation: AuditLogPermissionsImpl,
+    dependencies: [
+        IdentityContext
+    ]
+});
+export { AuditLogPermissions_AuditLogPermissions as AuditLogPermissions };
+
+//# sourceMappingURL=AuditLogPermissions.js.map

package/features/AuditLogPermissions/AuditLogPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/AuditLogPermissions/AuditLogPermissions.js","sources":["../../../src/features/AuditLogPermissions/AuditLogPermissions.ts"],"sourcesContent":["import { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport { AuditLogPermissions as Abstraction } from \"./abstractions.js\";\n\n/**\n * Full access (\"*\"), access to all audit logs (\"al.*\"), or access to the action (\"al.<action>\").\n */\nclass AuditLogPermissionsImpl implements Abstraction.Interface {\n    public constructor(private readonly identityContext: IdentityContext.Interface) {}\n\n    public async canAccessAll(): Promise<boolean> {\n        const permissions = await this.identityContext.getPermissions(\"al.*\");\n\n        return permissions.some(permission => {\n            return permission.name === \"*\" || permission.name === \"al.*\";\n        });\n    }\n\n    public async canAccess(action: string): Promise<boolean> {\n        const permissions = await this.identityContext.getPermissions(\"al.*\");\n\n        return permissions.some(permission => {\n            return (\n                permission.name === \"*\" ||\n                permission.name === \"al.*\" ||\n                permission.name === `al.${action}`\n            );\n        });\n    }\n}\n\nexport const AuditLogPermissions = Abstraction.createImplementation({\n    implementation: AuditLogPermissionsImpl,\n    dependencies: [IdentityContext]\n});\n"],"names":["AuditLogPermissionsImpl","identityContext","permissions","permission","action","AuditLogPermissions","Abstraction","IdentityContext"],"mappings":";;AAMA,MAAMA;IACF,YAAoCC,eAA0C,CAAE;aAA5CA,eAAe,GAAfA;IAA6C;IAEjF,MAAa,eAAiC;QAC1C,MAAMC,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC;QAE9D,OAAOA,YAAY,IAAI,CAACC,CAAAA,aACbA,AAAoB,QAApBA,WAAW,IAAI,IAAYA,AAAoB,WAApBA,WAAW,IAAI;IAEzD;IAEA,MAAa,UAAUC,MAAc,EAAoB;QACrD,MAAMF,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC;QAE9D,OAAOA,YAAY,IAAI,CAACC,CAAAA,aAEhBA,AAAoB,QAApBA,WAAW,IAAI,IACfA,AAAoB,WAApBA,WAAW,IAAI,IACfA,WAAW,IAAI,KAAK,CAAC,GAAG,EAAEC,QAAQ;IAG9C;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgBN;IAChB,cAAc;QAACO;KAAgB;AACnC"}

package/features/AuditLogPermissions/abstractions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AuditLogPermissions - Whether the current identity may access audit logs.
+ */
+export interface IAuditLogPermissions {
+    canAccess(action: string): Promise<boolean>;
+    canAccessAll(): Promise<boolean>;
+}
+export declare const AuditLogPermissions: import("@webiny/di").Abstraction<IAuditLogPermissions>;
+export declare namespace AuditLogPermissions {
+    type Interface = IAuditLogPermissions;
+}

package/features/AuditLogPermissions/abstractions.js

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

package/features/AuditLogPermissions/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/AuditLogPermissions/abstractions.js","sources":["../../../src/features/AuditLogPermissions/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\n/**\n * AuditLogPermissions - Whether the current identity may access audit logs.\n */\nexport interface IAuditLogPermissions {\n    // Access to audit logs of one action.\n    canAccess(action: string): Promise<boolean>;\n    // Access to audit logs of every action.\n    canAccessAll(): Promise<boolean>;\n}\n\nexport const AuditLogPermissions = createAbstraction<IAuditLogPermissions>(\"AuditLogPermissions\");\n\nexport namespace AuditLogPermissions {\n    export type Interface = IAuditLogPermissions;\n}\n"],"names":["AuditLogPermissions","createAbstraction"],"mappings":";AAYO,MAAMA,sBAAsBC,kBAAwC"}

package/features/AuditLogPermissions/feature.d.ts

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

package/features/AuditLogPermissions/feature.js

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

package/features/AuditLogPermissions/feature.js.map

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

package/features/CreateAuditLog/CreateAuditLogGateway.d.ts

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

package/features/CreateAuditLog/CreateAuditLogGateway.js

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

package/features/CreateAuditLog/CreateAuditLogGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CreateAuditLog/CreateAuditLogGateway.js","sources":["../../../src/features/CreateAuditLog/CreateAuditLogGateway.ts"],"sourcesContent":["import { AuditLogsStorage } from \"~/abstractions.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport { CreateAuditLogGateway as Abstraction } from \"./abstractions.js\";\n\nclass CreateAuditLogGatewayImpl implements Abstraction.Interface {\n    public constructor(private readonly storage: AuditLogsStorage.Interface) {}\n\n    public async create(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 CreateAuditLogGateway = Abstraction.createImplementation({\n    implementation: CreateAuditLogGatewayImpl,\n    dependencies: [AuditLogsStorage]\n});\n"],"names":["CreateAuditLogGatewayImpl","storage","auditLog","result","CreateAuditLogGateway","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/CreateAuditLog/CreateAuditLogRepository.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 { CreateAuditLogRepository as Abstraction } from "./abstractions.js";
+import { CreateAuditLogGateway } from "./abstractions.js";
+declare class CreateAuditLogRepositoryImpl implements Abstraction.Interface {
+    private readonly gateway;
+    constructor(gateway: CreateAuditLogGateway.Interface);
+    create(auditLog: IAuditLog): Promise<Result<IAuditLog, AuditLogPersistenceError>>;
+}
+export declare const CreateAuditLogRepository: typeof CreateAuditLogRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateAuditLogRepository>;
+};
+export {};

package/features/CreateAuditLog/CreateAuditLogRepository.js

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

package/features/CreateAuditLog/CreateAuditLogRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CreateAuditLog/CreateAuditLogRepository.js","sources":["../../../src/features/CreateAuditLog/CreateAuditLogRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { AuditLogPersistenceError } from \"~/domain/errors.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport { CreateAuditLogRepository as Abstraction } from \"./abstractions.js\";\nimport { CreateAuditLogGateway } from \"./abstractions.js\";\n\nclass CreateAuditLogRepositoryImpl implements Abstraction.Interface {\n    public constructor(private readonly gateway: CreateAuditLogGateway.Interface) {}\n\n    public async create(auditLog: IAuditLog): Promise<Result<IAuditLog, AuditLogPersistenceError>> {\n        try {\n            const created = await this.gateway.create(auditLog);\n            return Result.ok(created);\n        } catch (error) {\n            return Result.fail(new AuditLogPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const CreateAuditLogRepository = Abstraction.createImplementation({\n    implementation: CreateAuditLogRepositoryImpl,\n    dependencies: [CreateAuditLogGateway]\n});\n"],"names":["CreateAuditLogRepositoryImpl","gateway","auditLog","created","Result","error","AuditLogPersistenceError","CreateAuditLogRepository","Abstraction","CreateAuditLogGateway"],"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/CreateAuditLog/CreateAuditLogUseCase.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogsConfig } from "../../abstractions.js";
+import { AuditLogPermissions } from "../../features/AuditLogPermissions/abstractions.js";
+import type { AuditLogPayload } from "../../types.js";
+import type { IAuditLog } from "../../storage/types.js";
+import { CreateAuditLogUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { CreateAuditLogRepository } from "./abstractions.js";
+declare class CreateAuditLogUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly repository;
+    private readonly permissions;
+    private readonly eventPublisher;
+    private readonly identityContext;
+    private readonly tenantContext;
+    private readonly config;
+    constructor(repository: CreateAuditLogRepository.Interface, permissions: AuditLogPermissions.Interface, eventPublisher: EventPublisher.Interface, identityContext: IdentityContext.Interface, tenantContext: TenantContext.Interface, config: AuditLogsConfig.Interface);
+    execute(payload: AuditLogPayload): Promise<Result<IAuditLog, UseCaseAbstraction.Error>>;
+}
+export declare const CreateAuditLogUseCase: typeof CreateAuditLogUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateAuditLogUseCase>;
+};
+export {};

package/features/CreateAuditLog/CreateAuditLogUseCase.js

@@ -0,0 +1,70 @@
+import { mdbid } from "@webiny/utils/mdbid.js";
+import { Result } from "@webiny/feature/api";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogsConfig } from "../../abstractions.js";
+import { AuditLogPermissions } from "../AuditLogPermissions/abstractions.js";
+import { AuditLogAfterCreateEvent, AuditLogBeforeCreateEvent } from "../../events/index.js";
+import { convertExpiresAtDaysToDate } from "../../utils/expiresAt.js";
+import { CreateAuditLogRepository, CreateAuditLogUseCase } from "./abstractions.js";
+class CreateAuditLogUseCaseImpl {
+    constructor(repository, permissions, eventPublisher, identityContext, tenantContext, config){
+        this.repository = repository;
+        this.permissions = permissions;
+        this.eventPublisher = eventPublisher;
+        this.identityContext = identityContext;
+        this.tenantContext = tenantContext;
+        this.config = config;
+    }
+    async execute(payload) {
+        const identity = this.identityContext.getIdentity();
+        const expiresAt = convertExpiresAtDaysToDate(this.config.deleteLogsAfterDays);
+        const auditLog = {
+            id: mdbid(),
+            tenant: this.tenantContext.getTenant().id,
+            createdBy: {
+                id: identity.id,
+                type: identity.type,
+                displayName: identity.displayName || "unknown"
+            },
+            createdOn: new Date(),
+            ...payload,
+            content: JSON.stringify(payload.content),
+            expiresAt
+        };
+        const canAccess = await this.permissions.canAccess(auditLog.action);
+        if (!canAccess) return Result.fail(new NotAuthorizedError({
+            message: "You cannot access audit logs."
+        }));
+        const beforeCreateEvent = new AuditLogBeforeCreateEvent({
+            auditLog,
+            setAuditLog (input) {
+                Object.assign(auditLog, input);
+            }
+        });
+        await this.eventPublisher.publish(beforeCreateEvent);
+        const result = await this.repository.create(auditLog);
+        if (result.isFail()) return Result.fail(result.error);
+        const afterCreateEvent = new AuditLogAfterCreateEvent({
+            auditLog
+        });
+        await this.eventPublisher.publish(afterCreateEvent);
+        return Result.ok(result.value);
+    }
+}
+const CreateAuditLogUseCase_CreateAuditLogUseCase = CreateAuditLogUseCase.createImplementation({
+    implementation: CreateAuditLogUseCaseImpl,
+    dependencies: [
+        CreateAuditLogRepository,
+        AuditLogPermissions,
+        EventPublisher,
+        IdentityContext,
+        TenantContext,
+        AuditLogsConfig
+    ]
+});
+export { CreateAuditLogUseCase_CreateAuditLogUseCase as CreateAuditLogUseCase };
+
+//# sourceMappingURL=CreateAuditLogUseCase.js.map

package/features/CreateAuditLog/CreateAuditLogUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CreateAuditLog/CreateAuditLogUseCase.js","sources":["../../../src/features/CreateAuditLog/CreateAuditLogUseCase.ts"],"sourcesContent":["import { mdbid } from \"@webiny/utils/mdbid.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { AuditLogsConfig } from \"~/abstractions.js\";\nimport { AuditLogPermissions } from \"~/features/AuditLogPermissions/abstractions.js\";\nimport { AuditLogBeforeCreateEvent } from \"~/events/index.js\";\nimport { AuditLogAfterCreateEvent } from \"~/events/index.js\";\nimport { convertExpiresAtDaysToDate } from \"~/utils/expiresAt.js\";\nimport type { AuditLogPayload } from \"~/types.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport { CreateAuditLogUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { CreateAuditLogRepository } from \"./abstractions.js\";\n\nclass CreateAuditLogUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private readonly repository: CreateAuditLogRepository.Interface,\n        private readonly permissions: AuditLogPermissions.Interface,\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly config: AuditLogsConfig.Interface\n    ) {}\n\n    public async execute(\n        payload: AuditLogPayload\n    ): Promise<Result<IAuditLog, UseCaseAbstraction.Error>> {\n        const identity = this.identityContext.getIdentity();\n        const expiresAt = convertExpiresAtDaysToDate(this.config.deleteLogsAfterDays);\n\n        const auditLog: IAuditLog = {\n            id: mdbid(),\n            tenant: this.tenantContext.getTenant().id,\n            createdBy: {\n                id: identity.id,\n                type: identity.type,\n                displayName: identity.displayName || \"unknown\"\n            },\n            createdOn: new Date(),\n            ...payload,\n            content: JSON.stringify(payload.content),\n            expiresAt\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 beforeCreateEvent = new AuditLogBeforeCreateEvent({\n            auditLog,\n            setAuditLog(input) {\n                Object.assign(auditLog, input);\n            }\n        });\n        await this.eventPublisher.publish(beforeCreateEvent);\n\n        const result = await this.repository.create(auditLog);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const afterCreateEvent = new AuditLogAfterCreateEvent({ auditLog });\n        await this.eventPublisher.publish(afterCreateEvent);\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const CreateAuditLogUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateAuditLogUseCaseImpl,\n    dependencies: [\n        CreateAuditLogRepository,\n        AuditLogPermissions,\n        EventPublisher,\n        IdentityContext,\n        TenantContext,\n        AuditLogsConfig\n    ]\n});\n"],"names":["CreateAuditLogUseCaseImpl","repository","permissions","eventPublisher","identityContext","tenantContext","config","payload","identity","expiresAt","convertExpiresAtDaysToDate","auditLog","mdbid","Date","JSON","canAccess","Result","NotAuthorizedError","beforeCreateEvent","AuditLogBeforeCreateEvent","input","Object","result","afterCreateEvent","AuditLogAfterCreateEvent","CreateAuditLogUseCase","UseCaseAbstraction","CreateAuditLogRepository","AuditLogPermissions","EventPublisher","IdentityContext","TenantContext","AuditLogsConfig"],"mappings":";;;;;;;;;;;AAgBA,MAAMA;IACF,YACqBC,UAA8C,EAC9CC,WAA0C,EAC1CC,cAAwC,EACxCC,eAA0C,EAC1CC,aAAsC,EACtCC,MAAiC,CACpD;aANmBL,UAAU,GAAVA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;aACAC,eAAe,GAAfA;aACAC,aAAa,GAAbA;aACAC,MAAM,GAANA;IAClB;IAEH,MAAa,QACTC,OAAwB,EAC4B;QACpD,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAMC,YAAYC,2BAA2B,IAAI,CAAC,MAAM,CAAC,mBAAmB;QAE5E,MAAMC,WAAsB;YACxB,IAAIC;YACJ,QAAQ,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,EAAE;YACzC,WAAW;gBACP,IAAIJ,SAAS,EAAE;gBACf,MAAMA,SAAS,IAAI;gBACnB,aAAaA,SAAS,WAAW,IAAI;YACzC;YACA,WAAW,IAAIK;YACf,GAAGN,OAAO;YACV,SAASO,KAAK,SAAS,CAACP,QAAQ,OAAO;YACvCE;QACJ;QAEA,MAAMM,YAAY,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAACJ,SAAS,MAAM;QAClE,IAAI,CAACI,WACD,OAAOC,OAAO,IAAI,CACd,IAAIC,mBAAmB;YAAE,SAAS;QAAgC;QAI1E,MAAMC,oBAAoB,IAAIC,0BAA0B;YACpDR;YACA,aAAYS,KAAK;gBACbC,OAAO,MAAM,CAACV,UAAUS;YAC5B;QACJ;QACA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACF;QAElC,MAAMI,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACX;QAC5C,IAAIW,OAAO,MAAM,IACb,OAAON,OAAO,IAAI,CAACM,OAAO,KAAK;QAGnC,MAAMC,mBAAmB,IAAIC,yBAAyB;YAAEb;QAAS;QACjE,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACY;QAElC,OAAOP,OAAO,EAAE,CAACM,OAAO,KAAK;IACjC;AACJ;AAEO,MAAMG,8CAAwBC,sBAAAA,oBAAuC,CAAC;IACzE,gBAAgB1B;IAChB,cAAc;QACV2B;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/CreateAuditLog/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";
+/**
+ * CreateAuditLog Use Case - Creates an audit log in the current tenant, as the current identity.
+ */
+export interface ICreateAuditLogUseCase {
+    execute(payload: AuditLogPayload): Promise<Result<IAuditLog, UseCaseError>>;
+}
+export interface ICreateAuditLogUseCaseErrors {
+    notAuthorized: NotAuthorizedError;
+    persistence: AuditLogPersistenceError;
+}
+type UseCaseError = ICreateAuditLogUseCaseErrors[keyof ICreateAuditLogUseCaseErrors];
+export declare const CreateAuditLogUseCase: import("@webiny/di").Abstraction<ICreateAuditLogUseCase>;
+export declare namespace CreateAuditLogUseCase {
+    type Interface = ICreateAuditLogUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * CreateAuditLogRepository - Stores a new audit log.
+ */
+export interface ICreateAuditLogRepository {
+    create(auditLog: IAuditLog): Promise<Result<IAuditLog, AuditLogPersistenceError>>;
+}
+export declare const CreateAuditLogRepository: import("@webiny/di").Abstraction<ICreateAuditLogRepository>;
+export declare namespace CreateAuditLogRepository {
+    type Interface = ICreateAuditLogRepository;
+}
+/**
+ * CreateAuditLogGateway - Writes a new audit log to the audit logs storage.
+ */
+export interface ICreateAuditLogGateway {
+    create(auditLog: IAuditLog): Promise<IAuditLog>;
+}
+export declare const CreateAuditLogGateway: import("@webiny/di").Abstraction<ICreateAuditLogGateway>;
+export declare namespace CreateAuditLogGateway {
+    type Interface = ICreateAuditLogGateway;
+}
+export {};

package/features/CreateAuditLog/abstractions.js

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

package/features/CreateAuditLog/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CreateAuditLog/abstractions.js","sources":["../../../src/features/CreateAuditLog/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 * CreateAuditLog Use Case - Creates an audit log in the current tenant, as the current identity.\n */\nexport interface ICreateAuditLogUseCase {\n    execute(payload: AuditLogPayload): Promise<Result<IAuditLog, UseCaseError>>;\n}\n\nexport interface ICreateAuditLogUseCaseErrors {\n    notAuthorized: NotAuthorizedError;\n    persistence: AuditLogPersistenceError;\n}\n\ntype UseCaseError = ICreateAuditLogUseCaseErrors[keyof ICreateAuditLogUseCaseErrors];\n\nexport const CreateAuditLogUseCase =\n    createAbstraction<ICreateAuditLogUseCase>(\"CreateAuditLogUseCase\");\n\nexport namespace CreateAuditLogUseCase {\n    export type Interface = ICreateAuditLogUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * CreateAuditLogRepository - Stores a new audit log.\n */\nexport interface ICreateAuditLogRepository {\n    create(auditLog: IAuditLog): Promise<Result<IAuditLog, AuditLogPersistenceError>>;\n}\n\nexport const CreateAuditLogRepository = createAbstraction<ICreateAuditLogRepository>(\n    \"CreateAuditLogRepository\"\n);\n\nexport namespace CreateAuditLogRepository {\n    export type Interface = ICreateAuditLogRepository;\n}\n\n/**\n * CreateAuditLogGateway - Writes a new audit log to the audit logs storage.\n */\nexport interface ICreateAuditLogGateway {\n    create(auditLog: IAuditLog): Promise<IAuditLog>;\n}\n\nexport const CreateAuditLogGateway =\n    createAbstraction<ICreateAuditLogGateway>(\"CreateAuditLogGateway\");\n\nexport namespace CreateAuditLogGateway {\n    export type Interface = ICreateAuditLogGateway;\n}\n"],"names":["CreateAuditLogUseCase","createAbstraction","CreateAuditLogRepository","CreateAuditLogGateway"],"mappings":";AAqBO,MAAMA,wBACTC,kBAA0C;AAcvC,MAAMC,2BAA2BD,kBACpC;AAcG,MAAME,wBACTF,kBAA0C"}

package/features/CreateAuditLog/feature.d.ts

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

package/features/CreateAuditLog/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateAuditLogUseCase } from "./CreateAuditLogUseCase.js";
+import { CreateAuditLogRepository } from "./CreateAuditLogRepository.js";
+import { CreateAuditLogGateway } from "./CreateAuditLogGateway.js";
+const CreateAuditLogFeature = createFeature({
+    name: "AuditLogs/CreateAuditLog",
+    register (container) {
+        container.register(CreateAuditLogUseCase);
+        container.register(CreateAuditLogRepository).inSingletonScope();
+        container.register(CreateAuditLogGateway).inSingletonScope();
+    }
+});
+export { CreateAuditLogFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/CreateAuditLog/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CreateAuditLog/feature.js","sources":["../../../src/features/CreateAuditLog/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateAuditLogUseCase } from \"./CreateAuditLogUseCase.js\";\nimport { CreateAuditLogRepository } from \"./CreateAuditLogRepository.js\";\nimport { CreateAuditLogGateway } from \"./CreateAuditLogGateway.js\";\n\nexport const CreateAuditLogFeature = createFeature({\n    name: \"AuditLogs/CreateAuditLog\",\n    register(container) {\n        container.register(CreateAuditLogUseCase);\n        container.register(CreateAuditLogRepository).inSingletonScope();\n        container.register(CreateAuditLogGateway).inSingletonScope();\n    }\n});\n"],"names":["CreateAuditLogFeature","createFeature","container","CreateAuditLogUseCase","CreateAuditLogRepository","CreateAuditLogGateway"],"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/features/GetAuditLog/GetAuditLogGateway.d.ts

@@ -0,0 +1,13 @@
+import { AuditLogsStorage } from "../../abstractions.js";
+import type { IAuditLog } from "../../storage/types.js";
+import type { IStorageFetchParams } from "../../storage/abstractions/Storage.js";
+import { GetAuditLogGateway as Abstraction } from "./abstractions.js";
+declare class GetAuditLogGatewayImpl implements Abstraction.Interface {
+    private readonly storage;
+    constructor(storage: AuditLogsStorage.Interface);
+    get(params: IStorageFetchParams): Promise<IAuditLog>;
+}
+export declare const GetAuditLogGateway: typeof GetAuditLogGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetAuditLogGateway>;
+};
+export {};

package/features/GetAuditLog/GetAuditLogGateway.js

@@ -0,0 +1,21 @@
+import { AuditLogsStorage } from "../../abstractions.js";
+import { GetAuditLogGateway } from "./abstractions.js";
+class GetAuditLogGatewayImpl {
+    constructor(storage){
+        this.storage = storage;
+    }
+    async get(params) {
+        const result = await this.storage.fetch(params);
+        if (!result.success) throw result.error;
+        return result.data;
+    }
+}
+const GetAuditLogGateway_GetAuditLogGateway = GetAuditLogGateway.createImplementation({
+    implementation: GetAuditLogGatewayImpl,
+    dependencies: [
+        AuditLogsStorage
+    ]
+});
+export { GetAuditLogGateway_GetAuditLogGateway as GetAuditLogGateway };
+
+//# sourceMappingURL=GetAuditLogGateway.js.map

package/features/GetAuditLog/GetAuditLogGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/GetAuditLog/GetAuditLogGateway.js","sources":["../../../src/features/GetAuditLog/GetAuditLogGateway.ts"],"sourcesContent":["import { AuditLogsStorage } from \"~/abstractions.js\";\nimport type { IAuditLog } from \"~/storage/types.js\";\nimport type { IStorageFetchParams } from \"~/storage/abstractions/Storage.js\";\nimport { GetAuditLogGateway as Abstraction } from \"./abstractions.js\";\n\nclass GetAuditLogGatewayImpl implements Abstraction.Interface {\n    public constructor(private readonly storage: AuditLogsStorage.Interface) {}\n\n    public async get(params: IStorageFetchParams): Promise<IAuditLog> {\n        const result = await this.storage.fetch(params);\n        if (!result.success) {\n            throw result.error;\n        }\n        return result.data;\n    }\n}\n\nexport const GetAuditLogGateway = Abstraction.createImplementation({\n    implementation: GetAuditLogGatewayImpl,\n    dependencies: [AuditLogsStorage]\n});\n"],"names":["GetAuditLogGatewayImpl","storage","params","result","GetAuditLogGateway","Abstraction","AuditLogsStorage"],"mappings":";;AAKA,MAAMA;IACF,YAAoCC,OAAmC,CAAE;aAArCA,OAAO,GAAPA;IAAsC;IAE1E,MAAa,IAAIC,MAA2B,EAAsB;QAC9D,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAACD;QACxC,IAAI,CAACC,OAAO,OAAO,EACf,MAAMA,OAAO,KAAK;QAEtB,OAAOA,OAAO,IAAI;IACtB;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAgC,CAAC;IAC/D,gBAAgBL;IAChB,cAAc;QAACM;KAAiB;AACpC"}

package/features/GetAuditLog/GetAuditLogRepository.d.ts

@@ -0,0 +1,16 @@
+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 { IAuditLog } from "../../storage/types.js";
+import { GetAuditLogRepository as Abstraction } from "./abstractions.js";
+import { GetAuditLogGateway } from "./abstractions.js";
+declare class GetAuditLogRepositoryImpl implements Abstraction.Interface {
+    private readonly gateway;
+    private readonly tenantContext;
+    constructor(gateway: GetAuditLogGateway.Interface, tenantContext: TenantContext.Interface);
+    get(id: string): Promise<Result<IAuditLog, AuditLogPersistenceError>>;
+}
+export declare const GetAuditLogRepository: typeof GetAuditLogRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetAuditLogRepository>;
+};
+export {};

package/features/GetAuditLog/GetAuditLogRepository.js

@@ -0,0 +1,32 @@
+import { Result } from "@webiny/feature/api";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { AuditLogPersistenceError } from "../../domain/errors.js";
+import { GetAuditLogGateway, GetAuditLogRepository } from "./abstractions.js";
+class GetAuditLogRepositoryImpl {
+    constructor(gateway, tenantContext){
+        this.gateway = gateway;
+        this.tenantContext = tenantContext;
+    }
+    async get(id) {
+        try {
+            const tenant = this.tenantContext.getTenant().id;
+            const auditLog = await this.gateway.get({
+                id,
+                tenant
+            });
+            return Result.ok(auditLog);
+        } catch (error) {
+            return Result.fail(new AuditLogPersistenceError(error));
+        }
+    }
+}
+const GetAuditLogRepository_GetAuditLogRepository = GetAuditLogRepository.createImplementation({
+    implementation: GetAuditLogRepositoryImpl,
+    dependencies: [
+        GetAuditLogGateway,
+        TenantContext
+    ]
+});
+export { GetAuditLogRepository_GetAuditLogRepository as GetAuditLogRepository };
+
+//# sourceMappingURL=GetAuditLogRepository.js.map

package/features/GetAuditLog/GetAuditLogRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/GetAuditLog/GetAuditLogRepository.js","sources":["../../../src/features/GetAuditLog/GetAuditLogRepository.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 { IAuditLog } from \"~/storage/types.js\";\nimport { GetAuditLogRepository as Abstraction } from \"./abstractions.js\";\nimport { GetAuditLogGateway } from \"./abstractions.js\";\n\nclass GetAuditLogRepositoryImpl implements Abstraction.Interface {\n    public constructor(\n        private readonly gateway: GetAuditLogGateway.Interface,\n        private readonly tenantContext: TenantContext.Interface\n    ) {}\n\n    public async get(id: string): Promise<Result<IAuditLog, AuditLogPersistenceError>> {\n        try {\n            const tenant = this.tenantContext.getTenant().id;\n            const auditLog = await this.gateway.get({ id, tenant });\n            return Result.ok(auditLog);\n        } catch (error) {\n            return Result.fail(new AuditLogPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const GetAuditLogRepository = Abstraction.createImplementation({\n    implementation: GetAuditLogRepositoryImpl,\n    dependencies: [GetAuditLogGateway, TenantContext]\n});\n"],"names":["GetAuditLogRepositoryImpl","gateway","tenantContext","id","tenant","auditLog","Result","error","AuditLogPersistenceError","GetAuditLogRepository","Abstraction","GetAuditLogGateway","TenantContext"],"mappings":";;;;AAOA,MAAMA;IACF,YACqBC,OAAqC,EACrCC,aAAsC,CACzD;aAFmBD,OAAO,GAAPA;aACAC,aAAa,GAAbA;IAClB;IAEH,MAAa,IAAIC,EAAU,EAAwD;QAC/E,IAAI;YACA,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,EAAE;YAChD,MAAMC,WAAW,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC;gBAAEF;gBAAIC;YAAO;YACrD,OAAOE,OAAO,EAAE,CAACD;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAOD,OAAO,IAAI,CAAC,IAAIE,yBAAyBD;QACpD;IACJ;AACJ;AAEO,MAAME,8CAAwBC,sBAAAA,oBAAgC,CAAC;IAClE,gBAAgBV;IAChB,cAAc;QAACW;QAAoBC;KAAc;AACrD"}

package/features/GetAuditLog/GetAuditLogUseCase.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { AuditLogPermissions } from "../../features/AuditLogPermissions/abstractions.js";
+import type { IAuditLog } from "../../storage/types.js";
+import { GetAuditLogUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetAuditLogRepository } from "./abstractions.js";
+declare class GetAuditLogUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly repository;
+    private readonly permissions;
+    constructor(repository: GetAuditLogRepository.Interface, permissions: AuditLogPermissions.Interface);
+    execute(id: string): Promise<Result<IAuditLog, UseCaseAbstraction.Error>>;
+}
+export declare const GetAuditLogUseCase: typeof GetAuditLogUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetAuditLogUseCase>;
+};
+export {};

package/features/GetAuditLog/GetAuditLogUseCase.js

@@ -0,0 +1,29 @@
+import { Result } from "@webiny/feature/api";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { AuditLogPermissions } from "../AuditLogPermissions/abstractions.js";
+import { GetAuditLogRepository, GetAuditLogUseCase } from "./abstractions.js";
+class GetAuditLogUseCaseImpl {
+    constructor(repository, permissions){
+        this.repository = repository;
+        this.permissions = permissions;
+    }
+    async execute(id) {
+        const result = await this.repository.get(id);
+        if (result.isFail()) return Result.fail(result.error);
+        const canAccess = await this.permissions.canAccess(result.value.action);
+        if (!canAccess) return Result.fail(new NotAuthorizedError({
+            message: "You cannot access audit logs."
+        }));
+        return Result.ok(result.value);
+    }
+}
+const GetAuditLogUseCase_GetAuditLogUseCase = GetAuditLogUseCase.createImplementation({
+    implementation: GetAuditLogUseCaseImpl,
+    dependencies: [
+        GetAuditLogRepository,
+        AuditLogPermissions
+    ]
+});
+export { GetAuditLogUseCase_GetAuditLogUseCase as GetAuditLogUseCase };
+
+//# sourceMappingURL=GetAuditLogUseCase.js.map

package/features/GetAuditLog/GetAuditLogUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/GetAuditLog/GetAuditLogUseCase.js","sources":["../../../src/features/GetAuditLog/GetAuditLogUseCase.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 { IAuditLog } from \"~/storage/types.js\";\nimport { GetAuditLogUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetAuditLogRepository } from \"./abstractions.js\";\n\nclass GetAuditLogUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private readonly repository: GetAuditLogRepository.Interface,\n        private readonly permissions: AuditLogPermissions.Interface\n    ) {}\n\n    public async execute(id: string): Promise<Result<IAuditLog, UseCaseAbstraction.Error>> {\n        const result = await this.repository.get(id);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const canAccess = await this.permissions.canAccess(result.value.action);\n        if (!canAccess) {\n            return Result.fail(\n                new NotAuthorizedError({ message: \"You cannot access audit logs.\" })\n            );\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const GetAuditLogUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetAuditLogUseCaseImpl,\n    dependencies: [GetAuditLogRepository, AuditLogPermissions]\n});\n"],"names":["GetAuditLogUseCaseImpl","repository","permissions","id","result","Result","canAccess","NotAuthorizedError","GetAuditLogUseCase","UseCaseAbstraction","GetAuditLogRepository","AuditLogPermissions"],"mappings":";;;;AAOA,MAAMA;IACF,YACqBC,UAA2C,EAC3CC,WAA0C,CAC7D;aAFmBD,UAAU,GAAVA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAa,QAAQC,EAAU,EAAwD;QACnF,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAACD;QACzC,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAGnC,MAAME,YAAY,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAACF,OAAO,KAAK,CAAC,MAAM;QACtE,IAAI,CAACE,WACD,OAAOD,OAAO,IAAI,CACd,IAAIE,mBAAmB;YAAE,SAAS;QAAgC;QAI1E,OAAOF,OAAO,EAAE,CAACD,OAAO,KAAK;IACjC;AACJ;AAEO,MAAMI,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBT;IAChB,cAAc;QAACU;QAAuBC;KAAoB;AAC9D"}

package/features/GetAuditLog/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 { IAuditLog } from "../../storage/types.js";
+import type { IStorageFetchParams } from "../../storage/abstractions/Storage.js";
+import type { AuditLogPersistenceError } from "../../domain/errors.js";
+/**
+ * GetAuditLog Use Case - Gets an audit log of the current tenant by its id.
+ */
+export interface IGetAuditLogUseCase {
+    execute(id: string): Promise<Result<IAuditLog, UseCaseError>>;
+}
+export interface IGetAuditLogUseCaseErrors {
+    notAuthorized: NotAuthorizedError;
+    persistence: AuditLogPersistenceError;
+}
+type UseCaseError = IGetAuditLogUseCaseErrors[keyof IGetAuditLogUseCaseErrors];
+export declare const GetAuditLogUseCase: import("@webiny/di").Abstraction<IGetAuditLogUseCase>;
+export declare namespace GetAuditLogUseCase {
+    type Interface = IGetAuditLogUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * GetAuditLogRepository - Fetches an audit log of the current tenant.
+ */
+export interface IGetAuditLogRepository {
+    get(id: string): Promise<Result<IAuditLog, AuditLogPersistenceError>>;
+}
+export declare const GetAuditLogRepository: import("@webiny/di").Abstraction<IGetAuditLogRepository>;
+export declare namespace GetAuditLogRepository {
+    type Interface = IGetAuditLogRepository;
+}
+/**
+ * GetAuditLogGateway - Reads an audit log from the audit logs storage.
+ */
+export interface IGetAuditLogGateway {
+    get(params: IStorageFetchParams): Promise<IAuditLog>;
+}
+export declare const GetAuditLogGateway: import("@webiny/di").Abstraction<IGetAuditLogGateway>;
+export declare namespace GetAuditLogGateway {
+    type Interface = IGetAuditLogGateway;
+}
+export {};