@webiny/api-record-locking 0.0.0-unstable.6844005670 → 0.0.0-unstable.7be00a75a9

package/features/RecordLockingFeature.js

@@ -10,27 +10,25 @@ 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);
-  }
+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

@@ -1 +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({\n    name: \"RecordLockingManagement\",\n    register(container, params: RecordLockingParams) {\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,CAAC;EAC9Cc,IAAI,EAAE,yBAAyB;EAC/BC,QAAQA,CAACC,SAAS,EAAEC,MAA2B,EAAE;IAC7C;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":[]}
+{"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

@@ -1,5 +1,5 @@
 import { type UnlockEntryInput, UnlockEntryUseCase as UseCaseAbstraction, UnlockEntryUseCase } from "./abstractions.js";
-import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+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 {

package/features/UnlockEntry/UnlockEntryEventsDecorator.js

@@ -1,41 +1,41 @@
 import { UnlockEntryUseCase } from "./abstractions.js";
-import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+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;
+    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;
     }
-
-    // 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]
+const UnlockEntryEventsDecorator = UnlockEntryUseCase.createDecorator({
+    decorator: UnlockEntryEventsDecoratorImpl,
+    dependencies: [
+        EventPublisher
+    ]
 });
+export { UnlockEntryEventsDecorator };
 
 //# sourceMappingURL=UnlockEntryEventsDecorator.js.map

package/features/UnlockEntry/UnlockEntryEventsDecorator.js.map

@@ -1 +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\";\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,0CAA0C;AAGzE,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":[]}
+{"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.js

@@ -1,40 +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 as RepositoryAbstraction } from "./abstractions.js";
+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 (result.error.code === "Cms/Entry/NotFound") {
-          return Result.fail(new LockRecordNotFoundError());
+    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));
         }
-        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]
+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

@@ -1 +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":[]}
+{"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

@@ -2,7 +2,7 @@ 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/IdentityContext";
+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;

package/features/UnlockEntry/UnlockEntryUseCase.js

@@ -1,81 +1,65 @@
 import { Result } from "@webiny/feature/api";
-import { UnlockEntryUseCase as UseCaseAbstraction, UnlockEntryRepository } from "./abstractions.js";
+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/IdentityContext";
-import { LockRecordNotFoundError, IdentityMismatchError } from "../../domain/errors.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) {
-    // 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;
+    constructor(getLockRecord, kickOutCurrentUser, repository, identityContext){
+        this.getLockRecord = getLockRecord;
+        this.kickOutCurrentUser = kickOutCurrentUser;
+        this.repository = repository;
+        this.identityContext = identityContext;
     }
-
-    // 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);
+    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);
     }
-    return Result.ok(record);
-  }
 }
-export const UnlockEntryUseCase = UseCaseAbstraction.createImplementation({
-  implementation: UnlockEntryUseCaseImpl,
-  dependencies: [GetLockRecordUseCase, KickOutCurrentUserUseCase, UnlockEntryRepository, IdentityContext]
+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

@@ -1 +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/IdentityContext\";\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":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,kBAAkB,IAAIC,kBAAkB,EACxCC,qBAAqB;AAGzB,SAASC,oBAAoB;AAC7B,SAASC,yBAAyB;AAClC,SAASC,eAAe,QAAQ,2CAA2C;AAE3E,SAASC,uBAAuB,EAAEC,qBAAqB;AACvD,SAASC,uBAAuB;AAEhC,MAAMC,sBAAsB,CAAyC;EACjEC,WAAWA,CACCC,aAA6C,EAC7CC,kBAAuD,EACvDC,UAA2C,EAC3CC,eAA0C,EACpD;IAAA,KAJUH,aAA6C,GAA7CA,aAA6C;IAAA,KAC7CC,kBAAuD,GAAvDA,kBAAuD;IAAA,KACvDC,UAA2C,GAA3CA,UAA2C;IAAA,KAC3CC,eAA0C,GAA1CA,eAA0C;EACnD;EAEH,MAAMC,OAAOA,CAACC,KAAuB,EAA0D;IAC3F;IACA,MAAMC,YAAY,GAAG,MAAM,IAAI,CAACN,aAAa,CAACI,OAAO,CAACC,KAAK,CAAC;;IAE5D;IACA,IAAIC,YAAY,CAACC,MAAM,CAAC,CAAC,EAAE;MACvB,IAAID,YAAY,CAACE,KAAK,YAAYb,uBAAuB,EAAE;QACvD;QACA,MAAM,IAAI,CAACO,UAAU,CAACO,MAAM,CAACJ,KAAK,CAACK,EAAE,CAAC;MAC1C;MAEA,OAAOtB,MAAM,CAACuB,IAAI,CAACL,YAAY,CAACE,KAAK,CAAC;IAC1C;IAEA,MAAMI,MAAM,GAAGN,YAAY,CAACO,KAAK;;IAEjC;IACA,IAAID,MAAM,CAACE,SAAS,CAAC,CAAC,EAAE;MACpB,MAAM,IAAI,CAACZ,UAAU,CAACO,MAAM,CAACG,MAAM,CAACF,EAAE,CAAC;MACvC,MAAMF,KAAK,GAAG,IAAIb,uBAAuB,CAAC,CAAC;MAC3C,OAAOP,MAAM,CAACuB,IAAI,CAACH,KAAK,CAAC;IAC7B;;IAEA;IACA,MAAMO,QAAQ,GAAG,IAAI,CAACZ,eAAe,CAACa,WAAW,CAAC,CAAC;IACnD,MAAMC,UAAU,GAAGL,MAAM,CAACM,QAAQ,CAACR,EAAE,KAAKK,QAAQ,CAACL,EAAE;IAErD,IAAIS,aAAa,GAAG,KAAK;;IAEzB;IACA,IAAI,CAACF,UAAU,EAAE;MACb,IAAI,CAACZ,KAAK,CAACe,KAAK,EAAE;QACd,MAAMZ,KAAK,GAAG,IAAIZ,qBAAqB,CAAC;UACpCyB,SAAS,EAAEN,QAAQ,CAACL,EAAE;UACtBY,QAAQ,EAAEV,MAAM,CAACM,QAAQ,CAACR;QAC9B,CAAC,CAAC;QACF,OAAOtB,MAAM,CAACuB,IAAI,CAACH,KAAK,CAAC;MAC7B;;MAEA;MACA,MAAMe,SAAS,GAAG,MAAM1B,uBAAuB,CAAC,IAAI,CAACM,eAAe,CAAC;MACrE,IAAI,CAACoB,SAAS,EAAE;QACZ,MAAMf,KAAK,GAAG,IAAIZ,qBAAqB,CAAC;UACpCyB,SAAS,EAAEN,QAAQ,CAACL,EAAE;UACtBY,QAAQ,EAAEV,MAAM,CAACM,QAAQ,CAACR;QAC9B,CAAC,CAAC;QACF,OAAOtB,MAAM,CAACuB,IAAI,CAACH,KAAK,CAAC;MAC7B;MAEAW,aAAa,GAAG,IAAI;IACxB;;IAEA;IACA,MAAMK,YAAY,GAAG,MAAM,IAAI,CAACtB,UAAU,CAACO,MAAM,CAACG,MAAM,CAACF,EAAE,CAAC;IAE5D,IAAIc,YAAY,CAACjB,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOnB,MAAM,CAACuB,IAAI,CAACa,YAAY,CAAChB,KAAK,CAAC;IAC1C;;IAEA;IACA,IAAIW,aAAa,EAAE;MACf,MAAM,IAAI,CAAClB,kBAAkB,CAACG,OAAO,CAACQ,MAAM,CAAC;IACjD;IAEA,OAAOxB,MAAM,CAACqC,EAAE,CAACb,MAAM,CAAC;EAC5B;AACJ;AAEA,OAAO,MAAMvB,kBAAkB,GAAGC,kBAAkB,CAACoC,oBAAoB,CAAC;EACtEC,cAAc,EAAE7B,sBAAsB;EACtC8B,YAAY,EAAE,CACVpC,oBAAoB,EACpBC,yBAAyB,EACzBF,qBAAqB,EACrBG,eAAe;AAEvB,CAAC,CAAC","ignoreList":[]}
+{"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.js

@@ -1,17 +1,6 @@
 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");
+const UnlockEntryUseCase = createAbstraction("UnlockEntryUseCase");
+const UnlockEntryRepository = createAbstraction("UnlockEntryRepository");
+export { UnlockEntryRepository, UnlockEntryUseCase };
 
 //# sourceMappingURL=abstractions.js.map

package/features/UnlockEntry/abstractions.js.map

@@ -1 +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":[]}
+{"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

@@ -1,5 +1,5 @@
-import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
-import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+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 {
@@ -11,8 +11,8 @@ export declare class EntryBeforeUnlockEvent extends DomainEvent<EntryBeforeUnloc
     eventType: "RecordLocking/Entry/BeforeUnlock";
     getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnlockEvent>>;
 }
-export declare const EntryBeforeUnlockHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnlockEvent>>;
-export declare namespace EntryBeforeUnlockHandler {
+export declare const EntryBeforeUnlockEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnlockEvent>>;
+export declare namespace EntryBeforeUnlockEventHandler {
     type Interface = IEventHandler<EntryBeforeUnlockEvent>;
     type Event = EntryBeforeUnlockEvent;
 }
@@ -25,8 +25,8 @@ export declare class EntryAfterUnlockEvent extends DomainEvent<EntryAfterUnlockP
     eventType: "RecordLocking/Entry/AfterUnlock";
     getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnlockEvent>>;
 }
-export declare const EntryAfterUnlockHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnlockEvent>>;
-export declare namespace EntryAfterUnlockHandler {
+export declare const EntryAfterUnlockEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnlockEvent>>;
+export declare namespace EntryAfterUnlockEventHandler {
     type Interface = IEventHandler<EntryAfterUnlockEvent>;
     type Event = EntryAfterUnlockEvent;
 }
@@ -39,8 +39,8 @@ export declare class EntryUnlockErrorEvent extends DomainEvent<EntryUnlockErrorP
     eventType: "RecordLocking/Entry/UnlockError";
     getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryUnlockErrorEvent>>;
 }
-export declare const EntryUnlockErrorHandler: import("@webiny/di").Abstraction<IEventHandler<EntryUnlockErrorEvent>>;
-export declare namespace EntryUnlockErrorHandler {
+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

@@ -1,40 +1,32 @@
 import { createAbstraction } from "@webiny/feature/api";
-import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
-
-// ============================================================================
-// EntryBeforeUnlock Event
-// ============================================================================
-
-export class EntryBeforeUnlockEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/BeforeUnlock";
-  getHandlerAbstraction() {
-    return EntryBeforeUnlockHandler;
-  }
+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";
+    }
 }
-export const EntryBeforeUnlockHandler = createAbstraction("EntryBeforeUnlockHandler");
-
-// ============================================================================
-// EntryAfterUnlock Event
-// ============================================================================
-
-export class EntryAfterUnlockEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/AfterUnlock";
-  getHandlerAbstraction() {
-    return EntryAfterUnlockHandler;
-  }
+const EntryBeforeUnlockEventHandler = createAbstraction("EntryBeforeUnlockEventHandler");
+class EntryAfterUnlockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryAfterUnlockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/AfterUnlock";
+    }
 }
-export const EntryAfterUnlockHandler = createAbstraction("EntryAfterUnlockHandler");
-
-// ============================================================================
-// EntryUnlockError Event
-// ============================================================================
-
-export class EntryUnlockErrorEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/UnlockError";
-  getHandlerAbstraction() {
-    return EntryUnlockErrorHandler;
-  }
+const EntryAfterUnlockEventHandler = createAbstraction("EntryAfterUnlockEventHandler");
+class EntryUnlockErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryUnlockErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/UnlockError";
+    }
 }
-export const EntryUnlockErrorHandler = createAbstraction("EntryUnlockErrorHandler");
+const EntryUnlockErrorEventHandler = createAbstraction("EntryUnlockErrorEventHandler");
+export { EntryAfterUnlockEvent, EntryAfterUnlockEventHandler, EntryBeforeUnlockEvent, EntryBeforeUnlockEventHandler, EntryUnlockErrorEvent, EntryUnlockErrorEventHandler };
 
 //# sourceMappingURL=events.js.map