@webiny/api-audit-logs 0.0.0-unstable.0156a4c312

package/AuditLogsFeature.d.ts

@@ -0,0 +1,8 @@
+import { type Container } from "@webiny/feature/api";
+export interface AuditLogsFeatureConfig {
+    deleteLogsAfterDays?: number;
+}
+export declare const AuditLogsFeature: {
+    name: string;
+    register(container: Container, context?: AuditLogsFeatureConfig | undefined): void;
+};

package/AuditLogsFeature.js

@@ -0,0 +1,32 @@
+import { createFeature } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+import { AuditLogsConfig } from "./abstractions.js";
+import { AuditLogPermissionsFeature } from "./features/AuditLogPermissions/feature.js";
+import { CreateAuditLogFeature } from "./features/CreateAuditLog/feature.js";
+import { UpdateAuditLogFeature } from "./features/UpdateAuditLog/feature.js";
+import { GetAuditLogFeature } from "./features/GetAuditLog/feature.js";
+import { ListAuditLogsFeature } from "./features/ListAuditLogs/feature.js";
+import { RecordAuditLogFeature } from "./features/RecordAuditLog/feature.js";
+import { createSubscriptionHooks } from "./subscriptions/index.js";
+import { AuditLogsGraphQLSchema } from "./graphql/AuditLogsGraphQLSchema.js";
+const getDeleteLogsAfterDays = (days)=>days && days > 0 ? days : 60;
+const AuditLogsFeature = createFeature({
+    name: "AuditLogs",
+    register (container, config = {}) {
+        if (!container.resolve(FeatureFlags).get().isEnabled("auditLogs")) return;
+        container.registerInstance(AuditLogsConfig, {
+            deleteLogsAfterDays: getDeleteLogsAfterDays(config.deleteLogsAfterDays)
+        });
+        AuditLogPermissionsFeature.register(container);
+        CreateAuditLogFeature.register(container);
+        UpdateAuditLogFeature.register(container);
+        GetAuditLogFeature.register(container);
+        ListAuditLogsFeature.register(container);
+        RecordAuditLogFeature.register(container);
+        container.register(AuditLogsGraphQLSchema);
+        createSubscriptionHooks(container);
+    }
+});
+export { AuditLogsFeature };
+
+//# sourceMappingURL=AuditLogsFeature.js.map

package/AuditLogsFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuditLogsFeature.js","sources":["../src/AuditLogsFeature.ts"],"sourcesContent":["import { createFeature, type Container } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { AuditLogsConfig } from \"./abstractions.js\";\nimport { AuditLogPermissionsFeature } from \"./features/AuditLogPermissions/feature.js\";\nimport { CreateAuditLogFeature } from \"./features/CreateAuditLog/feature.js\";\nimport { UpdateAuditLogFeature } from \"./features/UpdateAuditLog/feature.js\";\nimport { GetAuditLogFeature } from \"./features/GetAuditLog/feature.js\";\nimport { ListAuditLogsFeature } from \"./features/ListAuditLogs/feature.js\";\nimport { RecordAuditLogFeature } from \"./features/RecordAuditLog/feature.js\";\nimport { createSubscriptionHooks } from \"./subscriptions/index.js\";\nimport { AuditLogsGraphQLSchema } from \"./graphql/AuditLogsGraphQLSchema.js\";\n\nexport interface AuditLogsFeatureConfig {\n    deleteLogsAfterDays?: number;\n}\n\nconst getDeleteLogsAfterDays = (days?: number): number => {\n    return days && days > 0 ? days : 60;\n};\n\nexport const AuditLogsFeature = createFeature({\n    name: \"AuditLogs\",\n    register(container: Container, config: AuditLogsFeatureConfig = {}) {\n        // Audit logs are license-gated — check at register time (license is fresh pre-register) so\n        // nothing wires up without the entitlement.\n        if (!container.resolve(FeatureFlags).get().isEnabled(\"auditLogs\")) {\n            return;\n        }\n\n        container.registerInstance(AuditLogsConfig, {\n            deleteLogsAfterDays: getDeleteLogsAfterDays(config.deleteLogsAfterDays)\n        });\n        AuditLogPermissionsFeature.register(container);\n        CreateAuditLogFeature.register(container);\n        UpdateAuditLogFeature.register(container);\n        GetAuditLogFeature.register(container);\n        ListAuditLogsFeature.register(container);\n        RecordAuditLogFeature.register(container);\n        container.register(AuditLogsGraphQLSchema);\n\n        createSubscriptionHooks(container);\n    }\n});\n"],"names":["getDeleteLogsAfterDays","days","AuditLogsFeature","createFeature","container","config","FeatureFlags","AuditLogsConfig","AuditLogPermissionsFeature","CreateAuditLogFeature","UpdateAuditLogFeature","GetAuditLogFeature","ListAuditLogsFeature","RecordAuditLogFeature","AuditLogsGraphQLSchema","createSubscriptionHooks"],"mappings":";;;;;;;;;;;AAgBA,MAAMA,yBAAyB,CAACC,OACrBA,QAAQA,OAAO,IAAIA,OAAO;AAG9B,MAAMC,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAoB,EAAEC,SAAiC,CAAC,CAAC;QAG9D,IAAI,CAACD,UAAU,OAAO,CAACE,cAAc,GAAG,GAAG,SAAS,CAAC,cACjD;QAGJF,UAAU,gBAAgB,CAACG,iBAAiB;YACxC,qBAAqBP,uBAAuBK,OAAO,mBAAmB;QAC1E;QACAG,2BAA2B,QAAQ,CAACJ;QACpCK,sBAAsB,QAAQ,CAACL;QAC/BM,sBAAsB,QAAQ,CAACN;QAC/BO,mBAAmB,QAAQ,CAACP;QAC5BQ,qBAAqB,QAAQ,CAACR;QAC9BS,sBAAsB,QAAQ,CAACT;QAC/BA,UAAU,QAAQ,CAACU;QAEnBC,wBAAwBX;IAC5B;AACJ"}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/api-audit-logs
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/abstractions.d.ts

@@ -0,0 +1,15 @@
+import type { IStorage } from "./storage/abstractions/Storage.js";
+/**
+ * AuditLogsConfig - How many days audit logs are kept before they expire.
+ */
+export interface IAuditLogsConfig {
+    deleteLogsAfterDays: number;
+}
+export declare const AuditLogsConfig: import("@webiny/di").Abstraction<IAuditLogsConfig>;
+export declare namespace AuditLogsConfig {
+    type Interface = IAuditLogsConfig;
+}
+export declare const AuditLogsStorage: import("@webiny/di").Abstraction<IStorage>;
+export declare namespace AuditLogsStorage {
+    type Interface = IStorage;
+}

package/abstractions.js

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

package/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions.js","sources":["../src/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IStorage } from \"~/storage/abstractions/Storage.js\";\n\n/**\n * AuditLogsConfig - How many days audit logs are kept before they expire.\n */\nexport interface IAuditLogsConfig {\n    deleteLogsAfterDays: number;\n}\n\nexport const AuditLogsConfig = createAbstraction<IAuditLogsConfig>(\"AuditLogsConfig\");\n\nexport namespace AuditLogsConfig {\n    export type Interface = IAuditLogsConfig;\n}\n\nexport const AuditLogsStorage = createAbstraction<IStorage>(\"AuditLogsStorage\");\n\nexport namespace AuditLogsStorage {\n    export type Interface = IStorage;\n}\n"],"names":["AuditLogsConfig","createAbstraction","AuditLogsStorage"],"mappings":";AAUO,MAAMA,kBAAkBC,kBAAoC;AAM5D,MAAMC,mBAAmBD,kBAA4B"}

package/config.d.ts

@@ -0,0 +1 @@
+export declare const AUDIT: import("./types").AuditObject;

package/config.js

@@ -0,0 +1,6 @@
+import { getAuditObject } from "./utils/getAuditObject.js";
+import { apps } from "@webiny/common-audit-logs";
+const AUDIT = getAuditObject(apps);
+export { AUDIT };
+
+//# sourceMappingURL=config.js.map

package/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sources":["../src/config.ts"],"sourcesContent":["import { getAuditObject } from \"~/utils/getAuditObject.js\";\nimport { apps } from \"@webiny/common-audit-logs\";\n\nexport const AUDIT = getAuditObject(apps);\n"],"names":["AUDIT","getAuditObject","apps"],"mappings":";;AAGO,MAAMA,QAAQC,eAAeC"}

package/domain/errors.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class AuditLogPersistenceError extends BaseError {
+    readonly code: "AuditLogs/AuditLog/PersistenceError";
+    constructor(error: Error);
+}

package/domain/errors.js

@@ -0,0 +1,11 @@
+import { BaseError } from "@webiny/feature/api";
+class AuditLogPersistenceError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message
+        }), this.code = "AuditLogs/AuditLog/PersistenceError";
+    }
+}
+export { AuditLogPersistenceError };
+
+//# sourceMappingURL=errors.js.map

package/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/errors.js","sources":["../../src/domain/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class AuditLogPersistenceError extends BaseError {\n    override readonly code = \"AuditLogs/AuditLog/PersistenceError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: error.message\n        });\n    }\n}\n"],"names":["AuditLogPersistenceError","BaseError","error"],"mappings":";AAEO,MAAMA,iCAAiCC;IAG1C,YAAYC,KAAY,CAAE;QACtB,KAAK,CAAC;YACF,SAASA,MAAM,OAAO;QAC1B,SALc,IAAI,GAAG;IAMzB;AACJ"}

package/events/AuditLogAfterCreateEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogAfterCreatePayload } from "./abstractions.js";
+export declare class AuditLogAfterCreateEvent extends DomainEvent<AuditLogAfterCreatePayload> {
+    eventType: "auditLog.afterCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<AuditLogAfterCreatePayload>>>;
+}

package/events/AuditLogAfterCreateEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogAfterCreateHandler } from "./abstractions.js";
+class AuditLogAfterCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return AuditLogAfterCreateHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "auditLog.afterCreate";
+    }
+}
+export { AuditLogAfterCreateEvent };
+
+//# sourceMappingURL=AuditLogAfterCreateEvent.js.map

package/events/AuditLogAfterCreateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events/AuditLogAfterCreateEvent.js","sources":["../../src/events/AuditLogAfterCreateEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { AuditLogAfterCreateHandler, AuditLogAfterCreatePayload } from \"./abstractions.js\";\n\nexport class AuditLogAfterCreateEvent extends DomainEvent<AuditLogAfterCreatePayload> {\n    eventType = \"auditLog.afterCreate\" as const;\n\n    getHandlerAbstraction() {\n        return AuditLogAfterCreateHandler;\n    }\n}\n"],"names":["AuditLogAfterCreateEvent","DomainEvent","AuditLogAfterCreateHandler"],"mappings":";;AAGO,MAAMA,iCAAiCC;IAG1C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/events/AuditLogAfterUpdateEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogAfterUpdatePayload } from "./abstractions.js";
+export declare class AuditLogAfterUpdateEvent extends DomainEvent<AuditLogAfterUpdatePayload> {
+    eventType: "auditLog.afterUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<AuditLogAfterUpdatePayload>>>;
+}

package/events/AuditLogAfterUpdateEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogAfterUpdateHandler } from "./abstractions.js";
+class AuditLogAfterUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return AuditLogAfterUpdateHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "auditLog.afterUpdate";
+    }
+}
+export { AuditLogAfterUpdateEvent };
+
+//# sourceMappingURL=AuditLogAfterUpdateEvent.js.map

package/events/AuditLogAfterUpdateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events/AuditLogAfterUpdateEvent.js","sources":["../../src/events/AuditLogAfterUpdateEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { AuditLogAfterUpdateHandler, AuditLogAfterUpdatePayload } from \"./abstractions.js\";\n\nexport class AuditLogAfterUpdateEvent extends DomainEvent<AuditLogAfterUpdatePayload> {\n    eventType = \"auditLog.afterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return AuditLogAfterUpdateHandler;\n    }\n}\n"],"names":["AuditLogAfterUpdateEvent","DomainEvent","AuditLogAfterUpdateHandler"],"mappings":";;AAGO,MAAMA,iCAAiCC;IAG1C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/events/AuditLogBeforeCreateEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogBeforeCreatePayload } from "./abstractions.js";
+export declare class AuditLogBeforeCreateEvent extends DomainEvent<AuditLogBeforeCreatePayload> {
+    eventType: "auditLog.beforeCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<AuditLogBeforeCreatePayload>>>;
+}

package/events/AuditLogBeforeCreateEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogBeforeCreateHandler } from "./abstractions.js";
+class AuditLogBeforeCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return AuditLogBeforeCreateHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "auditLog.beforeCreate";
+    }
+}
+export { AuditLogBeforeCreateEvent };
+
+//# sourceMappingURL=AuditLogBeforeCreateEvent.js.map

package/events/AuditLogBeforeCreateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events/AuditLogBeforeCreateEvent.js","sources":["../../src/events/AuditLogBeforeCreateEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { AuditLogBeforeCreateHandler, AuditLogBeforeCreatePayload } from \"./abstractions.js\";\n\nexport class AuditLogBeforeCreateEvent extends DomainEvent<AuditLogBeforeCreatePayload> {\n    eventType = \"auditLog.beforeCreate\" as const;\n\n    getHandlerAbstraction() {\n        return AuditLogBeforeCreateHandler;\n    }\n}\n"],"names":["AuditLogBeforeCreateEvent","DomainEvent","AuditLogBeforeCreateHandler"],"mappings":";;AAGO,MAAMA,kCAAkCC;IAG3C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/events/AuditLogBeforeUpdateEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogBeforeUpdatePayload } from "./abstractions.js";
+export declare class AuditLogBeforeUpdateEvent extends DomainEvent<AuditLogBeforeUpdatePayload> {
+    eventType: "auditLog.beforeUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<AuditLogBeforeUpdatePayload>>>;
+}

package/events/AuditLogBeforeUpdateEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { AuditLogBeforeUpdateHandler } from "./abstractions.js";
+class AuditLogBeforeUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return AuditLogBeforeUpdateHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "auditLog.beforeUpdate";
+    }
+}
+export { AuditLogBeforeUpdateEvent };
+
+//# sourceMappingURL=AuditLogBeforeUpdateEvent.js.map

package/events/AuditLogBeforeUpdateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events/AuditLogBeforeUpdateEvent.js","sources":["../../src/events/AuditLogBeforeUpdateEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { AuditLogBeforeUpdateHandler, AuditLogBeforeUpdatePayload } from \"./abstractions.js\";\n\nexport class AuditLogBeforeUpdateEvent extends DomainEvent<AuditLogBeforeUpdatePayload> {\n    eventType = \"auditLog.beforeUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return AuditLogBeforeUpdateHandler;\n    }\n}\n"],"names":["AuditLogBeforeUpdateEvent","DomainEvent","AuditLogBeforeUpdateHandler"],"mappings":";;AAGO,MAAMA,kCAAkCC;IAG3C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/events/abstractions.d.ts

@@ -0,0 +1,38 @@
+import type { DomainEvent, IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IAuditLog } from "../storage/types.js";
+export interface AuditLogBeforeCreatePayload {
+    auditLog: IAuditLog;
+    setAuditLog(auditLog: Partial<IAuditLog>): void;
+}
+export declare const AuditLogBeforeCreateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<AuditLogBeforeCreatePayload>>>;
+export declare namespace AuditLogBeforeCreateHandler {
+    type Interface = IEventHandler<DomainEvent<AuditLogBeforeCreatePayload>>;
+    type Event = DomainEvent<AuditLogBeforeCreatePayload>;
+}
+export interface AuditLogAfterCreatePayload {
+    auditLog: IAuditLog;
+}
+export declare const AuditLogAfterCreateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<AuditLogAfterCreatePayload>>>;
+export declare namespace AuditLogAfterCreateHandler {
+    type Interface = IEventHandler<DomainEvent<AuditLogAfterCreatePayload>>;
+    type Event = DomainEvent<AuditLogAfterCreatePayload>;
+}
+export interface AuditLogBeforeUpdatePayload {
+    auditLog: IAuditLog;
+    original: IAuditLog;
+    setAuditLog(auditLog: Partial<IAuditLog>): void;
+}
+export declare const AuditLogBeforeUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<AuditLogBeforeUpdatePayload>>>;
+export declare namespace AuditLogBeforeUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<AuditLogBeforeUpdatePayload>>;
+    type Event = DomainEvent<AuditLogBeforeUpdatePayload>;
+}
+export interface AuditLogAfterUpdatePayload {
+    auditLog: IAuditLog;
+    original: IAuditLog;
+}
+export declare const AuditLogAfterUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<AuditLogAfterUpdatePayload>>>;
+export declare namespace AuditLogAfterUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<AuditLogAfterUpdatePayload>>;
+    type Event = DomainEvent<AuditLogAfterUpdatePayload>;
+}

package/events/abstractions.js

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

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 {};