@webiny/api-record-locking 0.0.0-unstable.06b2ede40f → 0.0.0-unstable.0d717d18dd

package/features/LockEntry/events.d.ts

@@ -0,0 +1,45 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+export interface EntryBeforeLockPayload {
+    id: string;
+    type: LockRecordEntryType;
+}
+export declare class EntryBeforeLockEvent extends DomainEvent<EntryBeforeLockPayload> {
+    eventType: "RecordLocking/Entry/BeforeLock";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeLockEvent>>;
+}
+export declare const EntryBeforeLockEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeLockEvent>>;
+export declare namespace EntryBeforeLockEventHandler {
+    type Interface = IEventHandler<EntryBeforeLockEvent>;
+    type Event = EntryBeforeLockEvent;
+}
+export interface EntryAfterLockPayload {
+    id: string;
+    type: LockRecordEntryType;
+    record: ILockRecord;
+}
+export declare class EntryAfterLockEvent extends DomainEvent<EntryAfterLockPayload> {
+    eventType: "RecordLocking/Entry/AfterLock";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterLockEvent>>;
+}
+export declare const EntryAfterLockEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterLockEvent>>;
+export declare namespace EntryAfterLockEventHandler {
+    type Interface = IEventHandler<EntryAfterLockEvent>;
+    type Event = EntryAfterLockEvent;
+}
+export interface EntryLockErrorPayload {
+    id: string;
+    type: LockRecordEntryType;
+    error: Error;
+}
+export declare class EntryLockErrorEvent extends DomainEvent<EntryLockErrorPayload> {
+    eventType: "RecordLocking/Entry/LockError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryLockErrorEvent>>;
+}
+export declare const EntryLockErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryLockErrorEvent>>;
+export declare namespace EntryLockErrorEventHandler {
+    type Interface = IEventHandler<EntryLockErrorEvent>;
+    type Event = EntryLockErrorEvent;
+}

package/features/LockEntry/events.js

@@ -0,0 +1,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class EntryBeforeLockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryBeforeLockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/BeforeLock";
+    }
+}
+const EntryBeforeLockEventHandler = createAbstraction("EntryBeforeLockEventHandler");
+class EntryAfterLockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryAfterLockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/AfterLock";
+    }
+}
+const EntryAfterLockEventHandler = createAbstraction("EntryAfterLockEventHandler");
+class EntryLockErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryLockErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/LockError";
+    }
+}
+const EntryLockErrorEventHandler = createAbstraction("EntryLockErrorEventHandler");
+export { EntryAfterLockEvent, EntryAfterLockEventHandler, EntryBeforeLockEvent, EntryBeforeLockEventHandler, EntryLockErrorEvent, EntryLockErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/LockEntry/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/LockEntry/events.js","sources":["../../../src/features/LockEntry/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\n\n// ============================================================================\n// EntryBeforeLock Event\n// ============================================================================\n\nexport interface EntryBeforeLockPayload {\n    id: string;\n    type: LockRecordEntryType;\n}\n\nexport class EntryBeforeLockEvent extends DomainEvent<EntryBeforeLockPayload> {\n    eventType = \"RecordLocking/Entry/BeforeLock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeLockEventHandler;\n    }\n}\n\nexport const EntryBeforeLockEventHandler = createAbstraction<IEventHandler<EntryBeforeLockEvent>>(\n    \"EntryBeforeLockEventHandler\"\n);\n\nexport namespace EntryBeforeLockEventHandler {\n    export type Interface = IEventHandler<EntryBeforeLockEvent>;\n    export type Event = EntryBeforeLockEvent;\n}\n\n// ============================================================================\n// EntryAfterLock Event\n// ============================================================================\n\nexport interface EntryAfterLockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    record: ILockRecord;\n}\n\nexport class EntryAfterLockEvent extends DomainEvent<EntryAfterLockPayload> {\n    eventType = \"RecordLocking/Entry/AfterLock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterLockEventHandler;\n    }\n}\n\nexport const EntryAfterLockEventHandler = createAbstraction<IEventHandler<EntryAfterLockEvent>>(\n    \"EntryAfterLockEventHandler\"\n);\n\nexport namespace EntryAfterLockEventHandler {\n    export type Interface = IEventHandler<EntryAfterLockEvent>;\n    export type Event = EntryAfterLockEvent;\n}\n\n// ============================================================================\n// EntryLockError Event\n// ============================================================================\n\nexport interface EntryLockErrorPayload {\n    id: string;\n    type: LockRecordEntryType;\n    error: Error;\n}\n\nexport class EntryLockErrorEvent extends DomainEvent<EntryLockErrorPayload> {\n    eventType = \"RecordLocking/Entry/LockError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryLockErrorEventHandler;\n    }\n}\n\nexport const EntryLockErrorEventHandler = createAbstraction<IEventHandler<EntryLockErrorEvent>>(\n    \"EntryLockErrorEventHandler\"\n);\n\nexport namespace EntryLockErrorEventHandler {\n    export type Interface = IEventHandler<EntryLockErrorEvent>;\n    export type Event = EntryLockErrorEvent;\n}\n"],"names":["EntryBeforeLockEvent","DomainEvent","EntryBeforeLockEventHandler","createAbstraction","EntryAfterLockEvent","EntryAfterLockEventHandler","EntryLockErrorEvent","EntryLockErrorEventHandler"],"mappings":";;AAeO,MAAMA,6BAA6BC;IAGtC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,8BAA8BC,kBACvC;AAkBG,MAAMC,4BAA4BH;IAGrC,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,6BAA6BF,kBACtC;AAkBG,MAAMG,4BAA4BL;IAGrC,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,6BAA6BJ,kBACtC"}

package/features/LockEntry/feature.d.ts

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

package/features/LockEntry/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { LockEntryUseCase } from "./LockEntryUseCase.js";
+import { LockEntryRepository } from "./LockEntryRepository.js";
+import { LockEntryEventsDecorator } from "./LockEntryEventsDecorator.js";
+const LockEntryFeature = createFeature({
+    name: "LockEntry",
+    register (container) {
+        container.register(LockEntryUseCase);
+        container.register(LockEntryRepository).inSingletonScope();
+        container.registerDecorator(LockEntryEventsDecorator);
+    }
+});
+export { LockEntryFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/LockEntry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/LockEntry/feature.js","sources":["../../../src/features/LockEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { LockEntryUseCase } from \"./LockEntryUseCase.js\";\nimport { LockEntryRepository } from \"./LockEntryRepository.js\";\nimport { LockEntryEventsDecorator } from \"./LockEntryEventsDecorator.js\";\n\nexport const LockEntryFeature = createFeature({\n    name: \"LockEntry\",\n    register(container) {\n        container.register(LockEntryUseCase);\n        container.register(LockEntryRepository).inSingletonScope();\n        container.registerDecorator(LockEntryEventsDecorator);\n    }\n});\n"],"names":["LockEntryFeature","createFeature","container","LockEntryUseCase","LockEntryRepository","LockEntryEventsDecorator"],"mappings":";;;;AAKO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,qBAAqB,gBAAgB;QACxDF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

package/features/LockEntry/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/LockEntry/index.js

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/RecordLockingFeature.d.ts

@@ -0,0 +1,15 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types";
+export interface RecordLockingParams {
+    /**
+     * Timeout in milliseconds after which a lock expires
+     */
+    timeout: number;
+    /**
+     * The CMS model for storing lock records
+     */
+    model: CmsModel;
+}
+export declare const RecordLockingFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container, context: RecordLockingParams): void;
+};

package/features/RecordLockingFeature.js

@@ -0,0 +1,34 @@
+import { createFeature } from "@webiny/feature/api";
+import { RecordLockingConfig, RecordLockingModel } from "../domain/abstractions.js";
+import { GetLockRecordFeature } from "./GetLockRecord/feature.js";
+import { GetLockedEntryLockRecordFeature } from "./GetLockedEntryLockRecord/feature.js";
+import { KickOutCurrentUserFeature } from "./KickOutCurrentUser/feature.js";
+import { ListLockRecordsFeature } from "./ListLockRecords/feature.js";
+import { ListAllLockRecordsFeature } from "./ListAllLockRecords/feature.js";
+import { IsEntryLockedFeature } from "./IsEntryLocked/feature.js";
+import { LockEntryFeature } from "./LockEntry/feature.js";
+import { UpdateEntryLockFeature } from "./UpdateEntryLock/feature.js";
+import { UnlockEntryFeature } from "./UnlockEntry/feature.js";
+import { UnlockEntryRequestFeature } from "./UnlockEntryRequest/feature.js";
+const RecordLockingFeature = createFeature({
+    name: "RecordLockingManagement",
+    register (container, params) {
+        container.registerInstance(RecordLockingConfig, {
+            timeout: params.timeout
+        });
+        container.registerInstance(RecordLockingModel, params.model);
+        GetLockRecordFeature.register(container);
+        GetLockedEntryLockRecordFeature.register(container);
+        KickOutCurrentUserFeature.register(container);
+        ListLockRecordsFeature.register(container);
+        ListAllLockRecordsFeature.register(container);
+        IsEntryLockedFeature.register(container);
+        LockEntryFeature.register(container);
+        UpdateEntryLockFeature.register(container);
+        UnlockEntryFeature.register(container);
+        UnlockEntryRequestFeature.register(container);
+    }
+});
+export { RecordLockingFeature };
+
+//# sourceMappingURL=RecordLockingFeature.js.map

package/features/RecordLockingFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/RecordLockingFeature.js","sources":["../../src/features/RecordLockingFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport { GetLockRecordFeature } from \"./GetLockRecord/feature.js\";\nimport { GetLockedEntryLockRecordFeature } from \"./GetLockedEntryLockRecord/feature.js\";\nimport { KickOutCurrentUserFeature } from \"./KickOutCurrentUser/feature.js\";\nimport { ListLockRecordsFeature } from \"./ListLockRecords/feature.js\";\nimport { ListAllLockRecordsFeature } from \"./ListAllLockRecords/feature.js\";\nimport { IsEntryLockedFeature } from \"./IsEntryLocked/feature.js\";\nimport { LockEntryFeature } from \"./LockEntry/feature.js\";\nimport { UpdateEntryLockFeature } from \"./UpdateEntryLock/feature.js\";\nimport { UnlockEntryFeature } from \"./UnlockEntry/feature.js\";\nimport { UnlockEntryRequestFeature } from \"./UnlockEntryRequest/feature.js\";\n\nexport interface RecordLockingParams {\n    /**\n     * Timeout in milliseconds after which a lock expires\n     */\n    timeout: number;\n    /**\n     * The CMS model for storing lock records\n     */\n    model: CmsModel;\n}\n\nexport const RecordLockingFeature = createFeature<RecordLockingParams>({\n    name: \"RecordLockingManagement\",\n    register(container, params) {\n        // Register domain abstractions\n        container.registerInstance(RecordLockingConfig, { timeout: params.timeout });\n        container.registerInstance(RecordLockingModel, params.model);\n\n        // Register all sub-features\n        GetLockRecordFeature.register(container);\n        GetLockedEntryLockRecordFeature.register(container);\n        KickOutCurrentUserFeature.register(container);\n        ListLockRecordsFeature.register(container);\n        ListAllLockRecordsFeature.register(container);\n        IsEntryLockedFeature.register(container);\n        LockEntryFeature.register(container);\n        UpdateEntryLockFeature.register(container);\n        UnlockEntryFeature.register(container);\n        UnlockEntryRequestFeature.register(container);\n    }\n});\n"],"names":["RecordLockingFeature","createFeature","container","params","RecordLockingConfig","RecordLockingModel","GetLockRecordFeature","GetLockedEntryLockRecordFeature","KickOutCurrentUserFeature","ListLockRecordsFeature","ListAllLockRecordsFeature","IsEntryLockedFeature","LockEntryFeature","UpdateEntryLockFeature","UnlockEntryFeature","UnlockEntryRequestFeature"],"mappings":";;;;;;;;;;;;AAyBO,MAAMA,uBAAuBC,cAAmC;IACnE,MAAM;IACN,UAASC,SAAS,EAAEC,MAAM;QAEtBD,UAAU,gBAAgB,CAACE,qBAAqB;YAAE,SAASD,OAAO,OAAO;QAAC;QAC1ED,UAAU,gBAAgB,CAACG,oBAAoBF,OAAO,KAAK;QAG3DG,qBAAqB,QAAQ,CAACJ;QAC9BK,gCAAgC,QAAQ,CAACL;QACzCM,0BAA0B,QAAQ,CAACN;QACnCO,uBAAuB,QAAQ,CAACP;QAChCQ,0BAA0B,QAAQ,CAACR;QACnCS,qBAAqB,QAAQ,CAACT;QAC9BU,iBAAiB,QAAQ,CAACV;QAC1BW,uBAAuB,QAAQ,CAACX;QAChCY,mBAAmB,QAAQ,CAACZ;QAC5Ba,0BAA0B,QAAQ,CAACb;IACvC;AACJ"}

package/features/UnlockEntry/UnlockEntryEventsDecorator.d.ts

@@ -0,0 +1,14 @@
+import { type UnlockEntryInput, UnlockEntryUseCase as UseCaseAbstraction, UnlockEntryUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ILockRecord } from "../../domain/index.js";
+import { Result } from "@webiny/feature/api/index.js";
+declare class UnlockEntryEventsDecoratorImpl implements UnlockEntryUseCase.Interface {
+    private readonly eventPublisher;
+    private readonly decoratee;
+    constructor(eventPublisher: EventPublisher.Interface, decoratee: UnlockEntryUseCase.Interface);
+    execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const UnlockEntryEventsDecorator: typeof UnlockEntryEventsDecoratorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUnlockEntryUseCase>;
+};
+export {};

package/features/UnlockEntry/UnlockEntryEventsDecorator.js

@@ -0,0 +1,41 @@
+import { UnlockEntryUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { EntryAfterUnlockEvent, EntryBeforeUnlockEvent, EntryUnlockErrorEvent } from "./events.js";
+class UnlockEntryEventsDecoratorImpl {
+    constructor(eventPublisher, decoratee){
+        this.eventPublisher = eventPublisher;
+        this.decoratee = decoratee;
+    }
+    async execute(input) {
+        await this.eventPublisher.publish(new EntryBeforeUnlockEvent({
+            id: input.id,
+            type: input.type,
+            force: input.force
+        }));
+        const result = await this.decoratee.execute(input);
+        if (result.isFail()) {
+            const error = result.error;
+            await this.eventPublisher.publish(new EntryUnlockErrorEvent({
+                id: input.id,
+                type: input.type,
+                error
+            }));
+            return result;
+        }
+        await this.eventPublisher.publish(new EntryAfterUnlockEvent({
+            id: input.id,
+            type: input.type,
+            record: result.value
+        }));
+        return result;
+    }
+}
+const UnlockEntryEventsDecorator = UnlockEntryUseCase.createDecorator({
+    decorator: UnlockEntryEventsDecoratorImpl,
+    dependencies: [
+        EventPublisher
+    ]
+});
+export { UnlockEntryEventsDecorator };
+
+//# sourceMappingURL=UnlockEntryEventsDecorator.js.map

package/features/UnlockEntry/UnlockEntryEventsDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntry/UnlockEntryEventsDecorator.js","sources":["../../../src/features/UnlockEntry/UnlockEntryEventsDecorator.ts"],"sourcesContent":["import {\n    type UnlockEntryInput,\n    UnlockEntryUseCase as UseCaseAbstraction,\n    UnlockEntryUseCase\n} from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/index.js\";\nimport { Result } from \"@webiny/feature/api/index.js\";\nimport { EntryAfterUnlockEvent, EntryBeforeUnlockEvent, EntryUnlockErrorEvent } from \"./events.js\";\n\nclass UnlockEntryEventsDecoratorImpl implements UnlockEntryUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: UnlockEntryUseCase.Interface\n    ) {}\n\n    async execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeUnlockEvent({\n                id: input.id,\n                type: input.type,\n                force: input.force\n            })\n        );\n\n        const result = await this.decoratee.execute(input);\n\n        if (result.isFail()) {\n            const error = result.error;\n\n            await this.eventPublisher.publish(\n                new EntryUnlockErrorEvent({\n                    id: input.id,\n                    type: input.type,\n                    error\n                })\n            );\n\n            return result;\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new EntryAfterUnlockEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const UnlockEntryEventsDecorator = UnlockEntryUseCase.createDecorator({\n    decorator: UnlockEntryEventsDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"names":["UnlockEntryEventsDecoratorImpl","eventPublisher","decoratee","input","EntryBeforeUnlockEvent","result","error","EntryUnlockErrorEvent","EntryAfterUnlockEvent","UnlockEntryEventsDecorator","UnlockEntryUseCase","EventPublisher"],"mappings":";;;AAUA,MAAMA;IACF,YACqBC,cAAwC,EACxCC,SAAuC,CAC1D;aAFmBD,cAAc,GAAdA;aACAC,SAAS,GAATA;IAClB;IAEH,MAAM,QAAQC,KAAuB,EAA0D;QAE3F,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,uBAAuB;YACvB,IAAID,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;YAChB,OAAOA,MAAM,KAAK;QACtB;QAGJ,MAAME,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACF;QAE5C,IAAIE,OAAO,MAAM,IAAI;YACjB,MAAMC,QAAQD,OAAO,KAAK;YAE1B,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,sBAAsB;gBACtB,IAAIJ,MAAM,EAAE;gBACZ,MAAMA,MAAM,IAAI;gBAChBG;YACJ;YAGJ,OAAOD;QACX;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,sBAAsB;YACtB,IAAIL,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;YAChB,QAAQE,OAAO,KAAK;QACxB;QAGJ,OAAOA;IACX;AACJ;AAEO,MAAMI,6BAA6BC,mBAAmB,eAAe,CAAC;IACzE,WAAWV;IACX,cAAc;QAACW;KAAe;AAClC"}

package/features/UnlockEntry/UnlockEntryRepository.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
+import { UnlockEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { RecordLockingModel } from "../../domain/abstractions.js";
+declare class UnlockEntryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private model;
+    private deleteEntry;
+    constructor(model: RecordLockingModel.Interface, deleteEntry: DeleteEntryUseCase.Interface);
+    delete(lockRecordId: string): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const UnlockEntryRepository: typeof UnlockEntryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUnlockEntryRepository>;
+};
+export {};

package/features/UnlockEntry/UnlockEntryRepository.js

@@ -0,0 +1,42 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
+import { createIdentifier } from "@webiny/utils";
+import { UnlockEntryRepository } from "./abstractions.js";
+import { RecordLockingModel } from "../../domain/abstractions.js";
+import { LockRecordNotFoundError, UnlockEntryError } from "../../domain/errors.js";
+import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
+class UnlockEntryRepositoryImpl {
+    constructor(model, deleteEntry){
+        this.model = model;
+        this.deleteEntry = deleteEntry;
+    }
+    async delete(lockRecordId) {
+        try {
+            const entryId = createLockRecordDatabaseId(lockRecordId);
+            const id = createIdentifier({
+                id: entryId,
+                version: 1
+            });
+            const result = await this.deleteEntry.execute(this.model, id, {
+                permanently: true
+            });
+            if (result.isFail()) {
+                if ("Cms/Entry/NotFound" === result.error.code) return Result.fail(new LockRecordNotFoundError());
+                return Result.fail(new UnlockEntryError(result.error));
+            }
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(new UnlockEntryError(error));
+        }
+    }
+}
+const UnlockEntryRepository_UnlockEntryRepository = UnlockEntryRepository.createImplementation({
+    implementation: UnlockEntryRepositoryImpl,
+    dependencies: [
+        RecordLockingModel,
+        DeleteEntryUseCase
+    ]
+});
+export { UnlockEntryRepository_UnlockEntryRepository as UnlockEntryRepository };
+
+//# sourceMappingURL=UnlockEntryRepository.js.map

package/features/UnlockEntry/UnlockEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntry/UnlockEntryRepository.js","sources":["../../../src/features/UnlockEntry/UnlockEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { UnlockEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { RecordLockingModel } from \"~/domain/abstractions.js\";\nimport { LockRecordNotFoundError, UnlockEntryError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass UnlockEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private deleteEntry: DeleteEntryUseCase.Interface\n    ) {}\n\n    async delete(lockRecordId: string): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = createLockRecordDatabaseId(lockRecordId);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const result = await this.deleteEntry.execute(this.model, id, {\n                permanently: true\n            });\n\n            if (result.isFail()) {\n                if (result.error.code === \"Cms/Entry/NotFound\") {\n                    return Result.fail(new LockRecordNotFoundError());\n                }\n                return Result.fail(new UnlockEntryError(result.error));\n            }\n\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new UnlockEntryError(error as Error));\n        }\n    }\n}\n\nexport const UnlockEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: UnlockEntryRepositoryImpl,\n    dependencies: [RecordLockingModel, DeleteEntryUseCase]\n});\n"],"names":["UnlockEntryRepositoryImpl","model","deleteEntry","lockRecordId","entryId","createLockRecordDatabaseId","id","createIdentifier","result","Result","LockRecordNotFoundError","UnlockEntryError","error","UnlockEntryRepository","RepositoryAbstraction","RecordLockingModel","DeleteEntryUseCase"],"mappings":";;;;;;;AAQA,MAAMA;IACF,YACYC,KAAmC,EACnCC,WAAyC,CACnD;aAFUD,KAAK,GAALA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,YAAoB,EAAsD;QACnF,IAAI;YACA,MAAMC,UAAUC,2BAA2BF;YAC3C,MAAMG,KAAKC,iBAAiB;gBACxB,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAEF,IAAI;gBAC1D,aAAa;YACjB;YAEA,IAAIE,OAAO,MAAM,IAAI;gBACjB,IAAIA,AAAsB,yBAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC;gBAE3B,OAAOD,OAAO,IAAI,CAAC,IAAIE,iBAAiBH,OAAO,KAAK;YACxD;YAEA,OAAOC,OAAO,EAAE;QACpB,EAAE,OAAOG,OAAO;YACZ,OAAOH,OAAO,IAAI,CAAC,IAAIE,iBAAiBC;QAC5C;IACJ;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBd;IAChB,cAAc;QAACe;QAAoBC;KAAmB;AAC1D"}

package/features/UnlockEntry/UnlockEntryUseCase.d.ts

@@ -0,0 +1,18 @@
+import { Result } from "@webiny/feature/api";
+import { UnlockEntryUseCase as UseCaseAbstraction, UnlockEntryRepository, UnlockEntryInput } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { KickOutCurrentUserUseCase } from "../KickOutCurrentUser/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class UnlockEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getLockRecord;
+    private kickOutCurrentUser;
+    private repository;
+    private identityContext;
+    constructor(getLockRecord: GetLockRecordUseCase.Interface, kickOutCurrentUser: KickOutCurrentUserUseCase.Interface, repository: UnlockEntryRepository.Interface, identityContext: IdentityContext.Interface);
+    execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const UnlockEntryUseCase: typeof UnlockEntryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUnlockEntryUseCase>;
+};
+export {};

package/features/UnlockEntry/UnlockEntryUseCase.js

@@ -0,0 +1,65 @@
+import { Result } from "@webiny/feature/api";
+import { UnlockEntryRepository, UnlockEntryUseCase } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { KickOutCurrentUserUseCase } from "../KickOutCurrentUser/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { IdentityMismatchError, LockRecordNotFoundError } from "../../domain/errors.js";
+import { hasFullAccessPermission } from "./hasFullAccessPermission.js";
+class UnlockEntryUseCaseImpl {
+    constructor(getLockRecord, kickOutCurrentUser, repository, identityContext){
+        this.getLockRecord = getLockRecord;
+        this.kickOutCurrentUser = kickOutCurrentUser;
+        this.repository = repository;
+        this.identityContext = identityContext;
+    }
+    async execute(input) {
+        const recordResult = await this.getLockRecord.execute(input);
+        if (recordResult.isFail()) {
+            if (recordResult.error instanceof LockRecordNotFoundError) await this.repository.delete(input.id);
+            return Result.fail(recordResult.error);
+        }
+        const record = recordResult.value;
+        if (record.isExpired()) {
+            await this.repository.delete(record.id);
+            const error = new LockRecordNotFoundError();
+            return Result.fail(error);
+        }
+        const identity = this.identityContext.getIdentity();
+        const isSameUser = record.lockedBy.id === identity.id;
+        let shouldKickOut = false;
+        if (!isSameUser) {
+            if (!input.force) {
+                const error = new IdentityMismatchError({
+                    currentId: identity.id,
+                    targetId: record.lockedBy.id
+                });
+                return Result.fail(error);
+            }
+            const hasAccess = await hasFullAccessPermission(this.identityContext);
+            if (!hasAccess) {
+                const error = new IdentityMismatchError({
+                    currentId: identity.id,
+                    targetId: record.lockedBy.id
+                });
+                return Result.fail(error);
+            }
+            shouldKickOut = true;
+        }
+        const deleteResult = await this.repository.delete(record.id);
+        if (deleteResult.isFail()) return Result.fail(deleteResult.error);
+        if (shouldKickOut) await this.kickOutCurrentUser.execute(record);
+        return Result.ok(record);
+    }
+}
+const UnlockEntryUseCase_UnlockEntryUseCase = UnlockEntryUseCase.createImplementation({
+    implementation: UnlockEntryUseCaseImpl,
+    dependencies: [
+        GetLockRecordUseCase,
+        KickOutCurrentUserUseCase,
+        UnlockEntryRepository,
+        IdentityContext
+    ]
+});
+export { UnlockEntryUseCase_UnlockEntryUseCase as UnlockEntryUseCase };
+
+//# sourceMappingURL=UnlockEntryUseCase.js.map

package/features/UnlockEntry/UnlockEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntry/UnlockEntryUseCase.js","sources":["../../../src/features/UnlockEntry/UnlockEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    UnlockEntryUseCase as UseCaseAbstraction,\n    UnlockEntryRepository,\n    UnlockEntryInput\n} from \"./abstractions.js\";\nimport { GetLockRecordUseCase } from \"../GetLockRecord/abstractions.js\";\nimport { KickOutCurrentUserUseCase } from \"../KickOutCurrentUser/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { LockRecordNotFoundError, IdentityMismatchError } from \"~/domain/errors.js\";\nimport { hasFullAccessPermission } from \"./hasFullAccessPermission.js\";\n\nclass UnlockEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getLockRecord: GetLockRecordUseCase.Interface,\n        private kickOutCurrentUser: KickOutCurrentUserUseCase.Interface,\n        private repository: UnlockEntryRepository.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    async execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Get the lock record\n        const recordResult = await this.getLockRecord.execute(input);\n\n        // If not found or expired, attempt cleanup and return error\n        if (recordResult.isFail()) {\n            if (recordResult.error instanceof LockRecordNotFoundError) {\n                // Try to cleanup any stale data\n                await this.repository.delete(input.id);\n            }\n\n            return Result.fail(recordResult.error);\n        }\n\n        const record = recordResult.value;\n\n        // If expired, cleanup and return error\n        if (record.isExpired()) {\n            await this.repository.delete(record.id);\n            const error = new LockRecordNotFoundError();\n            return Result.fail(error);\n        }\n\n        // Check if user is the owner\n        const identity = this.identityContext.getIdentity();\n        const isSameUser = record.lockedBy.id === identity.id;\n\n        let shouldKickOut = false;\n\n        // If not the owner, check if force unlock is allowed\n        if (!isSameUser) {\n            if (!input.force) {\n                const error = new IdentityMismatchError({\n                    currentId: identity.id,\n                    targetId: record.lockedBy.id\n                });\n                return Result.fail(error);\n            }\n\n            // Check if user has permission to force unlock\n            const hasAccess = await hasFullAccessPermission(this.identityContext);\n            if (!hasAccess) {\n                const error = new IdentityMismatchError({\n                    currentId: identity.id,\n                    targetId: record.lockedBy.id\n                });\n                return Result.fail(error);\n            }\n\n            shouldKickOut = true;\n        }\n\n        // Delete the lock record\n        const deleteResult = await this.repository.delete(record.id);\n\n        if (deleteResult.isFail()) {\n            return Result.fail(deleteResult.error);\n        }\n\n        // If forced by another user, kick out the original lock owner\n        if (shouldKickOut) {\n            await this.kickOutCurrentUser.execute(record);\n        }\n\n        return Result.ok(record);\n    }\n}\n\nexport const UnlockEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UnlockEntryUseCaseImpl,\n    dependencies: [\n        GetLockRecordUseCase,\n        KickOutCurrentUserUseCase,\n        UnlockEntryRepository,\n        IdentityContext\n    ]\n});\n"],"names":["UnlockEntryUseCaseImpl","getLockRecord","kickOutCurrentUser","repository","identityContext","input","recordResult","LockRecordNotFoundError","Result","record","error","identity","isSameUser","shouldKickOut","IdentityMismatchError","hasAccess","hasFullAccessPermission","deleteResult","UnlockEntryUseCase","UseCaseAbstraction","GetLockRecordUseCase","KickOutCurrentUserUseCase","UnlockEntryRepository","IdentityContext"],"mappings":";;;;;;;AAaA,MAAMA;IACF,YACYC,aAA6C,EAC7CC,kBAAuD,EACvDC,UAA2C,EAC3CC,eAA0C,CACpD;aAJUH,aAAa,GAAbA;aACAC,kBAAkB,GAAlBA;aACAC,UAAU,GAAVA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAM,QAAQC,KAAuB,EAA0D;QAE3F,MAAMC,eAAe,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAACD;QAGtD,IAAIC,aAAa,MAAM,IAAI;YACvB,IAAIA,aAAa,KAAK,YAAYC,yBAE9B,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACF,MAAM,EAAE;YAGzC,OAAOG,OAAO,IAAI,CAACF,aAAa,KAAK;QACzC;QAEA,MAAMG,SAASH,aAAa,KAAK;QAGjC,IAAIG,OAAO,SAAS,IAAI;YACpB,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA,OAAO,EAAE;YACtC,MAAMC,QAAQ,IAAIH;YAClB,OAAOC,OAAO,IAAI,CAACE;QACvB;QAGA,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAMC,aAAaH,OAAO,QAAQ,CAAC,EAAE,KAAKE,SAAS,EAAE;QAErD,IAAIE,gBAAgB;QAGpB,IAAI,CAACD,YAAY;YACb,IAAI,CAACP,MAAM,KAAK,EAAE;gBACd,MAAMK,QAAQ,IAAII,sBAAsB;oBACpC,WAAWH,SAAS,EAAE;oBACtB,UAAUF,OAAO,QAAQ,CAAC,EAAE;gBAChC;gBACA,OAAOD,OAAO,IAAI,CAACE;YACvB;YAGA,MAAMK,YAAY,MAAMC,wBAAwB,IAAI,CAAC,eAAe;YACpE,IAAI,CAACD,WAAW;gBACZ,MAAML,QAAQ,IAAII,sBAAsB;oBACpC,WAAWH,SAAS,EAAE;oBACtB,UAAUF,OAAO,QAAQ,CAAC,EAAE;gBAChC;gBACA,OAAOD,OAAO,IAAI,CAACE;YACvB;YAEAG,gBAAgB;QACpB;QAGA,MAAMI,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACR,OAAO,EAAE;QAE3D,IAAIQ,aAAa,MAAM,IACnB,OAAOT,OAAO,IAAI,CAACS,aAAa,KAAK;QAIzC,IAAIJ,eACA,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACJ;QAG1C,OAAOD,OAAO,EAAE,CAACC;IACrB;AACJ;AAEO,MAAMS,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBnB;IAChB,cAAc;QACVoB;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/UnlockEntry/abstractions.d.ts

@@ -0,0 +1,44 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+import { type LockRecordNotFoundError, LockRecordPersistenceError, type IdentityMismatchError, type UnlockEntryError } from "../../domain/errors.js";
+export interface UnlockEntryInput {
+    id: string;
+    type: LockRecordEntryType;
+    force?: boolean;
+}
+/**
+ * UnlockEntry Use Case - Unlocks an entry by deleting the lock record
+ */
+export interface IUnlockEntryUseCase {
+    execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseError>>;
+}
+export interface IUnlockEntryUseCaseErrors {
+    notFound: LockRecordNotFoundError;
+    notSameIdentity: IdentityMismatchError;
+    unlockError: UnlockEntryError;
+    persistence: LockRecordPersistenceError;
+}
+type UseCaseError = IUnlockEntryUseCaseErrors[keyof IUnlockEntryUseCaseErrors];
+export declare const UnlockEntryUseCase: import("@webiny/di").Abstraction<IUnlockEntryUseCase>;
+export declare namespace UnlockEntryUseCase {
+    type Interface = IUnlockEntryUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * UnlockEntryRepository - Deletes lock record from storage
+ */
+export interface IUnlockEntryRepository {
+    delete(lockRecordId: string): Promise<Result<void, RepositoryError>>;
+}
+export interface IUnlockEntryRepositoryErrors {
+    notFound: LockRecordNotFoundError;
+    unlockError: UnlockEntryError;
+}
+type RepositoryError = IUnlockEntryRepositoryErrors[keyof IUnlockEntryRepositoryErrors];
+export declare const UnlockEntryRepository: import("@webiny/di").Abstraction<IUnlockEntryRepository>;
+export declare namespace UnlockEntryRepository {
+    type Interface = IUnlockEntryRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/UnlockEntry/abstractions.js

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

package/features/UnlockEntry/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntry/abstractions.js","sources":["../../../src/features/UnlockEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\nimport {\n    type LockRecordNotFoundError,\n    LockRecordPersistenceError,\n    type IdentityMismatchError,\n    type UnlockEntryError\n} from \"~/domain/errors.js\";\n\n// Input types\nexport interface UnlockEntryInput {\n    id: string;\n    type: LockRecordEntryType;\n    force?: boolean;\n}\n\n/**\n * UnlockEntry Use Case - Unlocks an entry by deleting the lock record\n */\nexport interface IUnlockEntryUseCase {\n    execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface IUnlockEntryUseCaseErrors {\n    notFound: LockRecordNotFoundError;\n    notSameIdentity: IdentityMismatchError;\n    unlockError: UnlockEntryError;\n    persistence: LockRecordPersistenceError;\n}\n\ntype UseCaseError = IUnlockEntryUseCaseErrors[keyof IUnlockEntryUseCaseErrors];\n\nexport const UnlockEntryUseCase = createAbstraction<IUnlockEntryUseCase>(\"UnlockEntryUseCase\");\n\nexport namespace UnlockEntryUseCase {\n    export type Interface = IUnlockEntryUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * UnlockEntryRepository - Deletes lock record from storage\n */\nexport interface IUnlockEntryRepository {\n    delete(lockRecordId: string): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IUnlockEntryRepositoryErrors {\n    notFound: LockRecordNotFoundError;\n    unlockError: UnlockEntryError;\n}\n\ntype RepositoryError = IUnlockEntryRepositoryErrors[keyof IUnlockEntryRepositoryErrors];\n\nexport const UnlockEntryRepository =\n    createAbstraction<IUnlockEntryRepository>(\"UnlockEntryRepository\");\n\nexport namespace UnlockEntryRepository {\n    export type Interface = IUnlockEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["UnlockEntryUseCase","createAbstraction","UnlockEntryRepository"],"mappings":";AAkCO,MAAMA,qBAAqBC,kBAAuC;AAqBlE,MAAMC,wBACTD,kBAA0C"}

package/features/UnlockEntry/events.d.ts

@@ -0,0 +1,46 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+export interface EntryBeforeUnlockPayload {
+    id: string;
+    type: LockRecordEntryType;
+    force?: boolean;
+}
+export declare class EntryBeforeUnlockEvent extends DomainEvent<EntryBeforeUnlockPayload> {
+    eventType: "RecordLocking/Entry/BeforeUnlock";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnlockEvent>>;
+}
+export declare const EntryBeforeUnlockEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnlockEvent>>;
+export declare namespace EntryBeforeUnlockEventHandler {
+    type Interface = IEventHandler<EntryBeforeUnlockEvent>;
+    type Event = EntryBeforeUnlockEvent;
+}
+export interface EntryAfterUnlockPayload {
+    id: string;
+    type: LockRecordEntryType;
+    record: ILockRecord;
+}
+export declare class EntryAfterUnlockEvent extends DomainEvent<EntryAfterUnlockPayload> {
+    eventType: "RecordLocking/Entry/AfterUnlock";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnlockEvent>>;
+}
+export declare const EntryAfterUnlockEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnlockEvent>>;
+export declare namespace EntryAfterUnlockEventHandler {
+    type Interface = IEventHandler<EntryAfterUnlockEvent>;
+    type Event = EntryAfterUnlockEvent;
+}
+export interface EntryUnlockErrorPayload {
+    id: string;
+    type: LockRecordEntryType;
+    error: Error;
+}
+export declare class EntryUnlockErrorEvent extends DomainEvent<EntryUnlockErrorPayload> {
+    eventType: "RecordLocking/Entry/UnlockError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryUnlockErrorEvent>>;
+}
+export declare const EntryUnlockErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryUnlockErrorEvent>>;
+export declare namespace EntryUnlockErrorEventHandler {
+    type Interface = IEventHandler<EntryUnlockErrorEvent>;
+    type Event = EntryUnlockErrorEvent;
+}

package/features/UnlockEntry/events.js

@@ -0,0 +1,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class EntryBeforeUnlockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryBeforeUnlockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/BeforeUnlock";
+    }
+}
+const EntryBeforeUnlockEventHandler = createAbstraction("EntryBeforeUnlockEventHandler");
+class EntryAfterUnlockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryAfterUnlockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/AfterUnlock";
+    }
+}
+const EntryAfterUnlockEventHandler = createAbstraction("EntryAfterUnlockEventHandler");
+class EntryUnlockErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryUnlockErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/UnlockError";
+    }
+}
+const EntryUnlockErrorEventHandler = createAbstraction("EntryUnlockErrorEventHandler");
+export { EntryAfterUnlockEvent, EntryAfterUnlockEventHandler, EntryBeforeUnlockEvent, EntryBeforeUnlockEventHandler, EntryUnlockErrorEvent, EntryUnlockErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/UnlockEntry/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntry/events.js","sources":["../../../src/features/UnlockEntry/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\n\n// ============================================================================\n// EntryBeforeUnlock Event\n// ============================================================================\n\nexport interface EntryBeforeUnlockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    force?: boolean;\n}\n\nexport class EntryBeforeUnlockEvent extends DomainEvent<EntryBeforeUnlockPayload> {\n    eventType = \"RecordLocking/Entry/BeforeUnlock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeUnlockEventHandler;\n    }\n}\n\nexport const EntryBeforeUnlockEventHandler = createAbstraction<\n    IEventHandler<EntryBeforeUnlockEvent>\n>(\"EntryBeforeUnlockEventHandler\");\n\nexport namespace EntryBeforeUnlockEventHandler {\n    export type Interface = IEventHandler<EntryBeforeUnlockEvent>;\n    export type Event = EntryBeforeUnlockEvent;\n}\n\n// ============================================================================\n// EntryAfterUnlock Event\n// ============================================================================\n\nexport interface EntryAfterUnlockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    record: ILockRecord;\n}\n\nexport class EntryAfterUnlockEvent extends DomainEvent<EntryAfterUnlockPayload> {\n    eventType = \"RecordLocking/Entry/AfterUnlock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterUnlockEventHandler;\n    }\n}\n\nexport const EntryAfterUnlockEventHandler = createAbstraction<IEventHandler<EntryAfterUnlockEvent>>(\n    \"EntryAfterUnlockEventHandler\"\n);\n\nexport namespace EntryAfterUnlockEventHandler {\n    export type Interface = IEventHandler<EntryAfterUnlockEvent>;\n    export type Event = EntryAfterUnlockEvent;\n}\n\n// ============================================================================\n// EntryUnlockError Event\n// ============================================================================\n\nexport interface EntryUnlockErrorPayload {\n    id: string;\n    type: LockRecordEntryType;\n    error: Error;\n}\n\nexport class EntryUnlockErrorEvent extends DomainEvent<EntryUnlockErrorPayload> {\n    eventType = \"RecordLocking/Entry/UnlockError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryUnlockErrorEventHandler;\n    }\n}\n\nexport const EntryUnlockErrorEventHandler = createAbstraction<IEventHandler<EntryUnlockErrorEvent>>(\n    \"EntryUnlockErrorEventHandler\"\n);\n\nexport namespace EntryUnlockErrorEventHandler {\n    export type Interface = IEventHandler<EntryUnlockErrorEvent>;\n    export type Event = EntryUnlockErrorEvent;\n}\n"],"names":["EntryBeforeUnlockEvent","DomainEvent","EntryBeforeUnlockEventHandler","createAbstraction","EntryAfterUnlockEvent","EntryAfterUnlockEventHandler","EntryUnlockErrorEvent","EntryUnlockErrorEventHandler"],"mappings":";;AAgBO,MAAMA,+BAA+BC;IAGxC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,gCAAgCC,kBAE3C;AAiBK,MAAMC,8BAA8BH;IAGvC,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,+BAA+BF,kBACxC;AAkBG,MAAMG,8BAA8BL;IAGvC,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,+BAA+BJ,kBACxC"}

package/features/UnlockEntry/feature.d.ts

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

package/features/UnlockEntry/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { UnlockEntryUseCase } from "./UnlockEntryUseCase.js";
+import { UnlockEntryRepository } from "./UnlockEntryRepository.js";
+import { UnlockEntryEventsDecorator } from "./UnlockEntryEventsDecorator.js";
+const UnlockEntryFeature = createFeature({
+    name: "UnlockEntry",
+    register (container) {
+        container.register(UnlockEntryUseCase);
+        container.register(UnlockEntryRepository).inSingletonScope();
+        container.registerDecorator(UnlockEntryEventsDecorator);
+    }
+});
+export { UnlockEntryFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/UnlockEntry/feature.js.map

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

package/features/UnlockEntry/hasFullAccessPermission.d.ts

@@ -0,0 +1,2 @@
+import type { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+export declare const hasFullAccessPermission: (identityContext: IdentityContext.Interface) => Promise<boolean>;

package/features/UnlockEntry/hasFullAccessPermission.js

@@ -0,0 +1,9 @@
+const hasFullAccessPermission = async (identityContext)=>{
+    const hasFullAccess = await identityContext.hasFullAccess();
+    if (hasFullAccess) return true;
+    const permission = await identityContext.getPermission("recordLocking");
+    return permission?.canForceUnlock === true;
+};
+export { hasFullAccessPermission };
+
+//# sourceMappingURL=hasFullAccessPermission.js.map

package/features/UnlockEntry/hasFullAccessPermission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntry/hasFullAccessPermission.js","sources":["../../../src/features/UnlockEntry/hasFullAccessPermission.ts"],"sourcesContent":["import type { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { SecurityPermission } from \"@webiny/api-core/types/security.js\";\n\ninterface RecordLockingSecurityPermission extends SecurityPermission {\n    canForceUnlock?: boolean;\n}\n\nexport const hasFullAccessPermission = async (\n    identityContext: IdentityContext.Interface\n): Promise<boolean> => {\n    const hasFullAccess = await identityContext.hasFullAccess();\n    if (hasFullAccess) {\n        return true;\n    }\n\n    const permission =\n        await identityContext.getPermission<RecordLockingSecurityPermission>(\"recordLocking\");\n    return permission?.canForceUnlock === true;\n};\n"],"names":["hasFullAccessPermission","identityContext","hasFullAccess","permission"],"mappings":"AAOO,MAAMA,0BAA0B,OACnCC;IAEA,MAAMC,gBAAgB,MAAMD,gBAAgB,aAAa;IACzD,IAAIC,eACA,OAAO;IAGX,MAAMC,aACF,MAAMF,gBAAgB,aAAa,CAAkC;IACzE,OAAOE,YAAY,mBAAmB;AAC1C"}

package/features/UnlockEntry/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";