@webiny/api-record-locking 0.0.0-unstable.e53eceafb5 → 0.0.0-unstable.e6f0dc8ca7

package/features/LockEntry/abstractions.d.ts

@@ -0,0 +1,41 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+import type { EntryAlreadyLockedError, LockEntryError, LockRecordPersistenceError } from "../../domain/errors.js";
+export interface LockEntryInput {
+    id: string;
+    type: LockRecordEntryType;
+}
+/**
+ * LockEntry Use Case - Creates a lock on an entry
+ */
+export interface ILockEntryUseCase {
+    execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseError>>;
+}
+export interface ILockEntryUseCaseErrors {
+    alreadyLocked: EntryAlreadyLockedError;
+    persistence: LockRecordPersistenceError;
+    lockError: LockEntryError;
+}
+type UseCaseError = ILockEntryUseCaseErrors[keyof ILockEntryUseCaseErrors];
+export declare const LockEntryUseCase: import("@webiny/di").Abstraction<ILockEntryUseCase>;
+export declare namespace LockEntryUseCase {
+    type Interface = ILockEntryUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * LockEntryRepository - Creates lock record in storage
+ */
+export interface ILockEntryRepository {
+    create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryError>>;
+}
+export interface ILockEntryRepositoryErrors {
+    persistence: LockRecordPersistenceError;
+}
+type RepositoryError = ILockEntryRepositoryErrors[keyof ILockEntryRepositoryErrors];
+export declare const LockEntryRepository: import("@webiny/di").Abstraction<ILockEntryRepository>;
+export declare namespace LockEntryRepository {
+    type Interface = ILockEntryRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/LockEntry/abstractions.js

@@ -0,0 +1,17 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// Input types
+
+/**
+ * LockEntry Use Case - Creates a lock on an entry
+ */
+
+export const LockEntryUseCase = createAbstraction("LockEntryUseCase");
+
+/**
+ * LockEntryRepository - Creates lock record in storage
+ */
+
+export const LockEntryRepository = createAbstraction("LockEntryRepository");
+
+//# sourceMappingURL=abstractions.js.map

package/features/LockEntry/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","LockEntryUseCase","LockEntryRepository"],"sources":["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 type {\n    EntryAlreadyLockedError,\n    LockEntryError,\n    LockRecordPersistenceError\n} from \"~/domain/errors.js\";\n\n// Input types\nexport interface LockEntryInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * LockEntry Use Case - Creates a lock on an entry\n */\nexport interface ILockEntryUseCase {\n    execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface ILockEntryUseCaseErrors {\n    alreadyLocked: EntryAlreadyLockedError;\n    persistence: LockRecordPersistenceError;\n    lockError: LockEntryError;\n}\n\ntype UseCaseError = ILockEntryUseCaseErrors[keyof ILockEntryUseCaseErrors];\n\nexport const LockEntryUseCase = createAbstraction<ILockEntryUseCase>(\"LockEntryUseCase\");\n\nexport namespace LockEntryUseCase {\n    export type Interface = ILockEntryUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * LockEntryRepository - Creates lock record in storage\n */\nexport interface ILockEntryRepository {\n    create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryError>>;\n}\n\nexport interface ILockEntryRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError = ILockEntryRepositoryErrors[keyof ILockEntryRepositoryErrors];\n\nexport const LockEntryRepository = createAbstraction<ILockEntryRepository>(\"LockEntryRepository\");\n\nexport namespace LockEntryRepository {\n    export type Interface = ILockEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAUvD;;AAMA;AACA;AACA;;AAaA,OAAO,MAAMC,gBAAgB,GAAGD,iBAAiB,CAAoB,kBAAkB,CAAC;;AAOxF;AACA;AACA;;AAWA,OAAO,MAAME,mBAAmB,GAAGF,iBAAiB,CAAuB,qBAAqB,CAAC","ignoreList":[]}

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,40 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+
+// ============================================================================
+// EntryBeforeLock Event
+// ============================================================================
+
+export class EntryBeforeLockEvent extends DomainEvent {
+  eventType = "RecordLocking/Entry/BeforeLock";
+  getHandlerAbstraction() {
+    return EntryBeforeLockEventHandler;
+  }
+}
+export const EntryBeforeLockEventHandler = createAbstraction("EntryBeforeLockEventHandler");
+
+// ============================================================================
+// EntryAfterLock Event
+// ============================================================================
+
+export class EntryAfterLockEvent extends DomainEvent {
+  eventType = "RecordLocking/Entry/AfterLock";
+  getHandlerAbstraction() {
+    return EntryAfterLockEventHandler;
+  }
+}
+export const EntryAfterLockEventHandler = createAbstraction("EntryAfterLockEventHandler");
+
+// ============================================================================
+// EntryLockError Event
+// ============================================================================
+
+export class EntryLockErrorEvent extends DomainEvent {
+  eventType = "RecordLocking/Entry/LockError";
+  getHandlerAbstraction() {
+    return EntryLockErrorEventHandler;
+  }
+}
+export const EntryLockErrorEventHandler = createAbstraction("EntryLockErrorEventHandler");
+
+//# sourceMappingURL=events.js.map

package/features/LockEntry/events.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","EntryBeforeLockEvent","eventType","getHandlerAbstraction","EntryBeforeLockEventHandler","EntryAfterLockEvent","EntryAfterLockEventHandler","EntryLockErrorEvent","EntryLockErrorEventHandler"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,WAAW,QAAQ,mDAAmD;;AAK/E;AACA;AACA;;AAOA,OAAO,MAAMC,oBAAoB,SAASD,WAAW,CAAyB;EAC1EE,SAAS,GAAG,gCAAgC;EAE5CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,2BAA2B;EACtC;AACJ;AAEA,OAAO,MAAMA,2BAA2B,GAAGL,iBAAiB,CACxD,6BACJ,CAAC;;AAOD;AACA;AACA;;AAQA,OAAO,MAAMM,mBAAmB,SAASL,WAAW,CAAwB;EACxEE,SAAS,GAAG,+BAA+B;EAE3CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,0BAA0B;EACrC;AACJ;AAEA,OAAO,MAAMA,0BAA0B,GAAGP,iBAAiB,CACvD,4BACJ,CAAC;;AAOD;AACA;AACA;;AAQA,OAAO,MAAMQ,mBAAmB,SAASP,WAAW,CAAwB;EACxEE,SAAS,GAAG,+BAA+B;EAE3CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,0BAA0B;EACrC;AACJ;AAEA,OAAO,MAAMA,0BAA0B,GAAGT,iBAAiB,CACvD,4BACJ,CAAC","ignoreList":[]}

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,14 @@
+import { createFeature } from "@webiny/feature/api";
+import { LockEntryUseCase } from "./LockEntryUseCase.js";
+import { LockEntryRepository } from "./LockEntryRepository.js";
+import { LockEntryEventsDecorator } from "./LockEntryEventsDecorator.js";
+export const LockEntryFeature = createFeature({
+  name: "LockEntry",
+  register(container) {
+    container.register(LockEntryUseCase);
+    container.register(LockEntryRepository).inSingletonScope();
+    container.registerDecorator(LockEntryEventsDecorator);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/LockEntry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","LockEntryUseCase","LockEntryRepository","LockEntryEventsDecorator","LockEntryFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,gBAAgB;AACzB,SAASC,mBAAmB;AAC5B,SAASC,wBAAwB;AAEjC,OAAO,MAAMC,gBAAgB,GAAGJ,aAAa,CAAC;EAC1CK,IAAI,EAAE,WAAW;EACjBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACL,gBAAgB,CAAC;IACpCM,SAAS,CAACD,QAAQ,CAACJ,mBAAmB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAC1DD,SAAS,CAACE,iBAAiB,CAACN,wBAAwB,CAAC;EACzD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/LockEntry/index.d.ts

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

package/features/LockEntry/index.js

@@ -0,0 +1,3 @@
+export * from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/LockEntry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions.js\";\n"],"mappings":"AAAA","ignoreList":[]}

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,36 @@
+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";
+export const RecordLockingFeature = createFeature({
+  name: "RecordLockingManagement",
+  register(container, params) {
+    // Register domain abstractions
+    container.registerInstance(RecordLockingConfig, {
+      timeout: params.timeout
+    });
+    container.registerInstance(RecordLockingModel, params.model);
+
+    // Register all sub-features
+    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);
+  }
+});
+
+//# sourceMappingURL=RecordLockingFeature.js.map

package/features/RecordLockingFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","RecordLockingConfig","RecordLockingModel","GetLockRecordFeature","GetLockedEntryLockRecordFeature","KickOutCurrentUserFeature","ListLockRecordsFeature","ListAllLockRecordsFeature","IsEntryLockedFeature","LockEntryFeature","UpdateEntryLockFeature","UnlockEntryFeature","UnlockEntryRequestFeature","RecordLockingFeature","name","register","container","params","registerInstance","timeout","model"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,mBAAmB,EAAEC,kBAAkB;AAChD,SAASC,oBAAoB;AAC7B,SAASC,+BAA+B;AACxC,SAASC,yBAAyB;AAClC,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;AAClC,SAASC,oBAAoB;AAC7B,SAASC,gBAAgB;AACzB,SAASC,sBAAsB;AAC/B,SAASC,kBAAkB;AAC3B,SAASC,yBAAyB;AAalC,OAAO,MAAMC,oBAAoB,GAAGb,aAAa,CAAsB;EACnEc,IAAI,EAAE,yBAAyB;EAC/BC,QAAQA,CAACC,SAAS,EAAEC,MAAM,EAAE;IACxB;IACAD,SAAS,CAACE,gBAAgB,CAACjB,mBAAmB,EAAE;MAAEkB,OAAO,EAAEF,MAAM,CAACE;IAAQ,CAAC,CAAC;IAC5EH,SAAS,CAACE,gBAAgB,CAAChB,kBAAkB,EAAEe,MAAM,CAACG,KAAK,CAAC;;IAE5D;IACAjB,oBAAoB,CAACY,QAAQ,CAACC,SAAS,CAAC;IACxCZ,+BAA+B,CAACW,QAAQ,CAACC,SAAS,CAAC;IACnDX,yBAAyB,CAACU,QAAQ,CAACC,SAAS,CAAC;IAC7CV,sBAAsB,CAACS,QAAQ,CAACC,SAAS,CAAC;IAC1CT,yBAAyB,CAACQ,QAAQ,CAACC,SAAS,CAAC;IAC7CR,oBAAoB,CAACO,QAAQ,CAACC,SAAS,CAAC;IACxCP,gBAAgB,CAACM,QAAQ,CAACC,SAAS,CAAC;IACpCN,sBAAsB,CAACK,QAAQ,CAACC,SAAS,CAAC;IAC1CL,kBAAkB,CAACI,QAAQ,CAACC,SAAS,CAAC;IACtCJ,yBAAyB,CAACG,QAAQ,CAACC,SAAS,CAAC;EACjD;AACJ,CAAC,CAAC","ignoreList":[]}

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) {
+    // Publish before event
+    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;
+    }
+
+    // Publish after event
+    await this.eventPublisher.publish(new EntryAfterUnlockEvent({
+      id: input.id,
+      type: input.type,
+      record: result.value
+    }));
+    return result;
+  }
+}
+export const UnlockEntryEventsDecorator = UnlockEntryUseCase.createDecorator({
+  decorator: UnlockEntryEventsDecoratorImpl,
+  dependencies: [EventPublisher]
+});
+
+//# sourceMappingURL=UnlockEntryEventsDecorator.js.map

package/features/UnlockEntry/UnlockEntryEventsDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UnlockEntryUseCase","EventPublisher","EntryAfterUnlockEvent","EntryBeforeUnlockEvent","EntryUnlockErrorEvent","UnlockEntryEventsDecoratorImpl","constructor","eventPublisher","decoratee","execute","input","publish","id","type","force","result","isFail","error","record","value","UnlockEntryEventsDecorator","createDecorator","decorator","dependencies"],"sources":["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"],"mappings":"AAAA,SAGIA,kBAAkB;AAEtB,SAASC,cAAc,QAAQ,mDAAmD;AAGlF,SAASC,qBAAqB,EAAEC,sBAAsB,EAAEC,qBAAqB;AAE7E,MAAMC,8BAA8B,CAAyC;EACzEC,WAAWA,CACUC,cAAwC,EACxCC,SAAuC,EAC1D;IAAA,KAFmBD,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,SAAuC,GAAvCA,SAAuC;EACzD;EAEH,MAAMC,OAAOA,CAACC,KAAuB,EAA0D;IAC3F;IACA,MAAM,IAAI,CAACH,cAAc,CAACI,OAAO,CAC7B,IAAIR,sBAAsB,CAAC;MACvBS,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;MAChBC,KAAK,EAAEJ,KAAK,CAACI;IACjB,CAAC,CACL,CAAC;IAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACP,SAAS,CAACC,OAAO,CAACC,KAAK,CAAC;IAElD,IAAIK,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMC,KAAK,GAAGF,MAAM,CAACE,KAAK;MAE1B,MAAM,IAAI,CAACV,cAAc,CAACI,OAAO,CAC7B,IAAIP,qBAAqB,CAAC;QACtBQ,EAAE,EAAEF,KAAK,CAACE,EAAE;QACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;QAChBI;MACJ,CAAC,CACL,CAAC;MAED,OAAOF,MAAM;IACjB;;IAEA;IACA,MAAM,IAAI,CAACR,cAAc,CAACI,OAAO,CAC7B,IAAIT,qBAAqB,CAAC;MACtBU,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;MAChBK,MAAM,EAAEH,MAAM,CAACI;IACnB,CAAC,CACL,CAAC;IAED,OAAOJ,MAAM;EACjB;AACJ;AAEA,OAAO,MAAMK,0BAA0B,GAAGpB,kBAAkB,CAACqB,eAAe,CAAC;EACzEC,SAAS,EAAEjB,8BAA8B;EACzCkB,YAAY,EAAE,CAACtB,cAAc;AACjC,CAAC,CAAC","ignoreList":[]}

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,40 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
+import { createIdentifier } from "@webiny/utils";
+import { UnlockEntryRepository as RepositoryAbstraction } 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 (result.error.code === "Cms/Entry/NotFound") {
+          return Result.fail(new LockRecordNotFoundError());
+        }
+        return Result.fail(new UnlockEntryError(result.error));
+      }
+      return Result.ok();
+    } catch (error) {
+      return Result.fail(new UnlockEntryError(error));
+    }
+  }
+}
+export const UnlockEntryRepository = RepositoryAbstraction.createImplementation({
+  implementation: UnlockEntryRepositoryImpl,
+  dependencies: [RecordLockingModel, DeleteEntryUseCase]
+});
+
+//# sourceMappingURL=UnlockEntryRepository.js.map

package/features/UnlockEntry/UnlockEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","DeleteEntryUseCase","createIdentifier","UnlockEntryRepository","RepositoryAbstraction","RecordLockingModel","LockRecordNotFoundError","UnlockEntryError","createLockRecordDatabaseId","UnlockEntryRepositoryImpl","constructor","model","deleteEntry","delete","lockRecordId","entryId","id","version","result","execute","permanently","isFail","error","code","fail","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,QAAQ,4DAA4D;AAC/F,SAASC,gBAAgB,QAAQ,eAAe;AAChD,SAASC,qBAAqB,IAAIC,qBAAqB;AACvD,SAASC,kBAAkB;AAC3B,SAASC,uBAAuB,EAAEC,gBAAgB;AAClD,SAASC,0BAA0B;AAEnC,MAAMC,yBAAyB,CAA4C;EACvEC,WAAWA,CACCC,KAAmC,EACnCC,WAAyC,EACnD;IAAA,KAFUD,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,WAAyC,GAAzCA,WAAyC;EAClD;EAEH,MAAMC,MAAMA,CAACC,YAAoB,EAAsD;IACnF,IAAI;MACA,MAAMC,OAAO,GAAGP,0BAA0B,CAACM,YAAY,CAAC;MACxD,MAAME,EAAE,GAAGd,gBAAgB,CAAC;QACxBc,EAAE,EAAED,OAAO;QACXE,OAAO,EAAE;MACb,CAAC,CAAC;MAEF,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,WAAW,CAACO,OAAO,CAAC,IAAI,CAACR,KAAK,EAAEK,EAAE,EAAE;QAC1DI,WAAW,EAAE;MACjB,CAAC,CAAC;MAEF,IAAIF,MAAM,CAACG,MAAM,CAAC,CAAC,EAAE;QACjB,IAAIH,MAAM,CAACI,KAAK,CAACC,IAAI,KAAK,oBAAoB,EAAE;UAC5C,OAAOvB,MAAM,CAACwB,IAAI,CAAC,IAAIlB,uBAAuB,CAAC,CAAC,CAAC;QACrD;QACA,OAAON,MAAM,CAACwB,IAAI,CAAC,IAAIjB,gBAAgB,CAACW,MAAM,CAACI,KAAK,CAAC,CAAC;MAC1D;MAEA,OAAOtB,MAAM,CAACyB,EAAE,CAAC,CAAC;IACtB,CAAC,CAAC,OAAOH,KAAK,EAAE;MACZ,OAAOtB,MAAM,CAACwB,IAAI,CAAC,IAAIjB,gBAAgB,CAACe,KAAc,CAAC,CAAC;IAC5D;EACJ;AACJ;AAEA,OAAO,MAAMnB,qBAAqB,GAAGC,qBAAqB,CAACsB,oBAAoB,CAAC;EAC5EC,cAAc,EAAElB,yBAAyB;EACzCmB,YAAY,EAAE,CAACvB,kBAAkB,EAAEJ,kBAAkB;AACzD,CAAC,CAAC","ignoreList":[]}

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,81 @@
+import { Result } from "@webiny/feature/api";
+import { UnlockEntryUseCase as UseCaseAbstraction, UnlockEntryRepository } 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 { LockRecordNotFoundError, IdentityMismatchError } 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) {
+    // Get the lock record
+    const recordResult = await this.getLockRecord.execute(input);
+
+    // If not found or expired, attempt cleanup and return error
+    if (recordResult.isFail()) {
+      if (recordResult.error instanceof LockRecordNotFoundError) {
+        // Try to cleanup any stale data
+        await this.repository.delete(input.id);
+      }
+      return Result.fail(recordResult.error);
+    }
+    const record = recordResult.value;
+
+    // If expired, cleanup and return error
+    if (record.isExpired()) {
+      await this.repository.delete(record.id);
+      const error = new LockRecordNotFoundError();
+      return Result.fail(error);
+    }
+
+    // Check if user is the owner
+    const identity = this.identityContext.getIdentity();
+    const isSameUser = record.lockedBy.id === identity.id;
+    let shouldKickOut = false;
+
+    // If not the owner, check if force unlock is allowed
+    if (!isSameUser) {
+      if (!input.force) {
+        const error = new IdentityMismatchError({
+          currentId: identity.id,
+          targetId: record.lockedBy.id
+        });
+        return Result.fail(error);
+      }
+
+      // Check if user has permission to force unlock
+      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;
+    }
+
+    // Delete the lock record
+    const deleteResult = await this.repository.delete(record.id);
+    if (deleteResult.isFail()) {
+      return Result.fail(deleteResult.error);
+    }
+
+    // If forced by another user, kick out the original lock owner
+    if (shouldKickOut) {
+      await this.kickOutCurrentUser.execute(record);
+    }
+    return Result.ok(record);
+  }
+}
+export const UnlockEntryUseCase = UseCaseAbstraction.createImplementation({
+  implementation: UnlockEntryUseCaseImpl,
+  dependencies: [GetLockRecordUseCase, KickOutCurrentUserUseCase, UnlockEntryRepository, IdentityContext]
+});
+
+//# sourceMappingURL=UnlockEntryUseCase.js.map

package/features/UnlockEntry/UnlockEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","UnlockEntryUseCase","UseCaseAbstraction","UnlockEntryRepository","GetLockRecordUseCase","KickOutCurrentUserUseCase","IdentityContext","LockRecordNotFoundError","IdentityMismatchError","hasFullAccessPermission","UnlockEntryUseCaseImpl","constructor","getLockRecord","kickOutCurrentUser","repository","identityContext","execute","input","recordResult","isFail","error","delete","id","fail","record","value","isExpired","identity","getIdentity","isSameUser","lockedBy","shouldKickOut","force","currentId","targetId","hasAccess","deleteResult","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"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","ignoreList":[]}

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,17 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// Input types
+
+/**
+ * UnlockEntry Use Case - Unlocks an entry by deleting the lock record
+ */
+
+export const UnlockEntryUseCase = createAbstraction("UnlockEntryUseCase");
+
+/**
+ * UnlockEntryRepository - Deletes lock record from storage
+ */
+
+export const UnlockEntryRepository = createAbstraction("UnlockEntryRepository");
+
+//# sourceMappingURL=abstractions.js.map

package/features/UnlockEntry/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","UnlockEntryUseCase","UnlockEntryRepository"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAWvD;;AAOA;AACA;AACA;;AAcA,OAAO,MAAMC,kBAAkB,GAAGD,iBAAiB,CAAsB,oBAAoB,CAAC;;AAO9F;AACA;AACA;;AAYA,OAAO,MAAME,qBAAqB,GAC9BF,iBAAiB,CAAyB,uBAAuB,CAAC","ignoreList":[]}