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

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

package/features/UnlockEntry/events.js.map

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","DomainEvent","EntryBeforeUnlockEvent","eventType","getHandlerAbstraction","EntryBeforeUnlockHandler","EntryAfterUnlockEvent","EntryAfterUnlockHandler","EntryUnlockErrorEvent","EntryUnlockErrorHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\n\n// ============================================================================\n// EntryBeforeUnlock Event\n// ============================================================================\n\nexport interface EntryBeforeUnlockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    force?: boolean;\n}\n\nexport class EntryBeforeUnlockEvent extends DomainEvent<EntryBeforeUnlockPayload> {\n    eventType = \"RecordLocking/Entry/BeforeUnlock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeUnlockHandler;\n    }\n}\n\nexport const EntryBeforeUnlockHandler = createAbstraction<IEventHandler<EntryBeforeUnlockEvent>>(\n    \"EntryBeforeUnlockHandler\"\n);\n\nexport namespace EntryBeforeUnlockHandler {\n    export type Interface = IEventHandler<EntryBeforeUnlockEvent>;\n    export type Event = EntryBeforeUnlockEvent;\n}\n\n// ============================================================================\n// EntryAfterUnlock Event\n// ============================================================================\n\nexport interface EntryAfterUnlockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    record: ILockRecord;\n}\n\nexport class EntryAfterUnlockEvent extends DomainEvent<EntryAfterUnlockPayload> {\n    eventType = \"RecordLocking/Entry/AfterUnlock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterUnlockHandler;\n    }\n}\n\nexport const EntryAfterUnlockHandler =\n    createAbstraction<IEventHandler<EntryAfterUnlockEvent>>(\"EntryAfterUnlockHandler\");\n\nexport namespace EntryAfterUnlockHandler {\n    export type Interface = IEventHandler<EntryAfterUnlockEvent>;\n    export type Event = EntryAfterUnlockEvent;\n}\n\n// ============================================================================\n// EntryUnlockError Event\n// ============================================================================\n\nexport interface EntryUnlockErrorPayload {\n    id: string;\n    type: LockRecordEntryType;\n    error: Error;\n}\n\nexport class EntryUnlockErrorEvent extends DomainEvent<EntryUnlockErrorPayload> {\n    eventType = \"RecordLocking/Entry/UnlockError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryUnlockErrorHandler;\n    }\n}\n\nexport const EntryUnlockErrorHandler =\n    createAbstraction<IEventHandler<EntryUnlockErrorEvent>>(\"EntryUnlockErrorHandler\");\n\nexport namespace EntryUnlockErrorHandler {\n    export type Interface = IEventHandler<EntryUnlockErrorEvent>;\n    export type Event = EntryUnlockErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,WAAW,QAAQ,0CAA0C;;AAKtE;AACA;AACA;;AAQA,OAAO,MAAMC,sBAAsB,SAASD,WAAW,CAA2B;EAC9EE,SAAS,GAAG,kCAAkC;EAE9CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,wBAAwB;EACnC;AACJ;AAEA,OAAO,MAAMA,wBAAwB,GAAGL,iBAAiB,CACrD,0BACJ,CAAC;;AAOD;AACA;AACA;;AAQA,OAAO,MAAMM,qBAAqB,SAASL,WAAW,CAA0B;EAC5EE,SAAS,GAAG,iCAAiC;EAE7CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,uBAAuB;EAClC;AACJ;AAEA,OAAO,MAAMA,uBAAuB,GAChCP,iBAAiB,CAAuC,yBAAyB,CAAC;;AAOtF;AACA;AACA;;AAQA,OAAO,MAAMQ,qBAAqB,SAASP,WAAW,CAA0B;EAC5EE,SAAS,GAAG,iCAAiC;EAE7CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,uBAAuB;EAClC;AACJ;AAEA,OAAO,MAAMA,uBAAuB,GAChCT,iBAAiB,CAAuC,yBAAyB,CAAC","ignoreList":[]}
+{"version":3,"file":"features/UnlockEntry/events.js","sources":["../../../src/features/UnlockEntry/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\n\n// ============================================================================\n// EntryBeforeUnlock Event\n// ============================================================================\n\nexport interface EntryBeforeUnlockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    force?: boolean;\n}\n\nexport class EntryBeforeUnlockEvent extends DomainEvent<EntryBeforeUnlockPayload> {\n    eventType = \"RecordLocking/Entry/BeforeUnlock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeUnlockEventHandler;\n    }\n}\n\nexport const EntryBeforeUnlockEventHandler = createAbstraction<\n    IEventHandler<EntryBeforeUnlockEvent>\n>(\"EntryBeforeUnlockEventHandler\");\n\nexport namespace EntryBeforeUnlockEventHandler {\n    export type Interface = IEventHandler<EntryBeforeUnlockEvent>;\n    export type Event = EntryBeforeUnlockEvent;\n}\n\n// ============================================================================\n// EntryAfterUnlock Event\n// ============================================================================\n\nexport interface EntryAfterUnlockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    record: ILockRecord;\n}\n\nexport class EntryAfterUnlockEvent extends DomainEvent<EntryAfterUnlockPayload> {\n    eventType = \"RecordLocking/Entry/AfterUnlock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterUnlockEventHandler;\n    }\n}\n\nexport const EntryAfterUnlockEventHandler = createAbstraction<IEventHandler<EntryAfterUnlockEvent>>(\n    \"EntryAfterUnlockEventHandler\"\n);\n\nexport namespace EntryAfterUnlockEventHandler {\n    export type Interface = IEventHandler<EntryAfterUnlockEvent>;\n    export type Event = EntryAfterUnlockEvent;\n}\n\n// ============================================================================\n// EntryUnlockError Event\n// ============================================================================\n\nexport interface EntryUnlockErrorPayload {\n    id: string;\n    type: LockRecordEntryType;\n    error: Error;\n}\n\nexport class EntryUnlockErrorEvent extends DomainEvent<EntryUnlockErrorPayload> {\n    eventType = \"RecordLocking/Entry/UnlockError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryUnlockErrorEventHandler;\n    }\n}\n\nexport const EntryUnlockErrorEventHandler = createAbstraction<IEventHandler<EntryUnlockErrorEvent>>(\n    \"EntryUnlockErrorEventHandler\"\n);\n\nexport namespace EntryUnlockErrorEventHandler {\n    export type Interface = IEventHandler<EntryUnlockErrorEvent>;\n    export type Event = EntryUnlockErrorEvent;\n}\n"],"names":["EntryBeforeUnlockEvent","DomainEvent","EntryBeforeUnlockEventHandler","createAbstraction","EntryAfterUnlockEvent","EntryAfterUnlockEventHandler","EntryUnlockErrorEvent","EntryUnlockErrorEventHandler"],"mappings":";;AAgBO,MAAMA,+BAA+BC;IAGxC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,gCAAgCC,kBAE3C;AAiBK,MAAMC,8BAA8BH;IAGvC,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,+BAA+BF,kBACxC;AAkBG,MAAMG,8BAA8BL;IAGvC,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,+BAA+BJ,kBACxC"}

package/features/UnlockEntry/feature.d.ts

@@ -1 +1,4 @@
-export declare const UnlockEntryFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;
+export declare const UnlockEntryFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/UnlockEntry/feature.js

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

package/features/UnlockEntry/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","UnlockEntryUseCase","UnlockEntryRepository","UnlockEntryEventsDecorator","UnlockEntryFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UnlockEntryUseCase } from \"./UnlockEntryUseCase.js\";\nimport { UnlockEntryRepository } from \"./UnlockEntryRepository.js\";\nimport { UnlockEntryEventsDecorator } from \"./UnlockEntryEventsDecorator.js\";\n\nexport const UnlockEntryFeature = createFeature({\n    name: \"UnlockEntry\",\n    register(container) {\n        container.register(UnlockEntryUseCase);\n        container.register(UnlockEntryRepository).inSingletonScope();\n        container.registerDecorator(UnlockEntryEventsDecorator);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,kBAAkB;AAC3B,SAASC,qBAAqB;AAC9B,SAASC,0BAA0B;AAEnC,OAAO,MAAMC,kBAAkB,GAAGJ,aAAa,CAAC;EAC5CK,IAAI,EAAE,aAAa;EACnBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACL,kBAAkB,CAAC;IACtCM,SAAS,CAACD,QAAQ,CAACJ,qBAAqB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAC5DD,SAAS,CAACE,iBAAiB,CAACN,0BAA0B,CAAC;EAC3D;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/UnlockEntry/feature.js","sources":["../../../src/features/UnlockEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UnlockEntryUseCase } from \"./UnlockEntryUseCase.js\";\nimport { UnlockEntryRepository } from \"./UnlockEntryRepository.js\";\nimport { UnlockEntryEventsDecorator } from \"./UnlockEntryEventsDecorator.js\";\n\nexport const UnlockEntryFeature = createFeature({\n    name: \"UnlockEntry\",\n    register(container) {\n        container.register(UnlockEntryUseCase);\n        container.register(UnlockEntryRepository).inSingletonScope();\n        container.registerDecorator(UnlockEntryEventsDecorator);\n    }\n});\n"],"names":["UnlockEntryFeature","createFeature","container","UnlockEntryUseCase","UnlockEntryRepository","UnlockEntryEventsDecorator"],"mappings":";;;;AAKO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;QAC1DF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

package/features/UnlockEntry/hasFullAccessPermission.d.ts

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

package/features/UnlockEntry/hasFullAccessPermission.js

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