@webiny/api-record-locking 6.3.0-beta.4 → 6.4.0-beta.0

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.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/security/IdentityContext/index.js";
-import { LockRecordNotFoundError, IdentityMismatchError } from "../../domain/errors.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/security/IdentityContext/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { LockRecordNotFoundError, IdentityMismatchError } from \"~/domain/errors.js\";\nimport { hasFullAccessPermission } from \"./hasFullAccessPermission.js\";\n\nclass UnlockEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getLockRecord: GetLockRecordUseCase.Interface,\n        private kickOutCurrentUser: KickOutCurrentUserUseCase.Interface,\n        private repository: UnlockEntryRepository.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    async execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Get the lock record\n        const recordResult = await this.getLockRecord.execute(input);\n\n        // If not found or expired, attempt cleanup and return error\n        if (recordResult.isFail()) {\n            if (recordResult.error instanceof LockRecordNotFoundError) {\n                // Try to cleanup any stale data\n                await this.repository.delete(input.id);\n            }\n\n            return Result.fail(recordResult.error);\n        }\n\n        const record = recordResult.value;\n\n        // If expired, cleanup and return error\n        if (record.isExpired()) {\n            await this.repository.delete(record.id);\n            const error = new LockRecordNotFoundError();\n            return Result.fail(error);\n        }\n\n        // Check if user is the owner\n        const identity = this.identityContext.getIdentity();\n        const isSameUser = record.lockedBy.id === identity.id;\n\n        let shouldKickOut = false;\n\n        // If not the owner, check if force unlock is allowed\n        if (!isSameUser) {\n            if (!input.force) {\n                const error = new IdentityMismatchError({\n                    currentId: identity.id,\n                    targetId: record.lockedBy.id\n                });\n                return Result.fail(error);\n            }\n\n            // Check if user has permission to force unlock\n            const hasAccess = await hasFullAccessPermission(this.identityContext);\n            if (!hasAccess) {\n                const error = new IdentityMismatchError({\n                    currentId: identity.id,\n                    targetId: record.lockedBy.id\n                });\n                return Result.fail(error);\n            }\n\n            shouldKickOut = true;\n        }\n\n        // Delete the lock record\n        const deleteResult = await this.repository.delete(record.id);\n\n        if (deleteResult.isFail()) {\n            return Result.fail(deleteResult.error);\n        }\n\n        // If forced by another user, kick out the original lock owner\n        if (shouldKickOut) {\n            await this.kickOutCurrentUser.execute(record);\n        }\n\n        return Result.ok(record);\n    }\n}\n\nexport const UnlockEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UnlockEntryUseCaseImpl,\n    dependencies: [\n        GetLockRecordUseCase,\n        KickOutCurrentUserUseCase,\n        UnlockEntryRepository,\n        IdentityContext\n    ]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,kBAAkB,IAAIC,kBAAkB,EACxCC,qBAAqB;AAGzB,SAASC,oBAAoB;AAC7B,SAASC,yBAAyB;AAClC,SAASC,eAAe,QAAQ,6DAA6D;AAE7F,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.js

@@ -1,40 +1,32 @@
 import { createAbstraction } from "@webiny/feature/api";
 import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
-
-// ============================================================================
-// EntryBeforeUnlock Event
-// ============================================================================
-
-export class EntryBeforeUnlockEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/BeforeUnlock";
-  getHandlerAbstraction() {
-    return EntryBeforeUnlockEventHandler;
-  }
+class EntryBeforeUnlockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryBeforeUnlockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/BeforeUnlock";
+    }
 }
-export const EntryBeforeUnlockEventHandler = createAbstraction("EntryBeforeUnlockEventHandler");
-
-// ============================================================================
-// EntryAfterUnlock Event
-// ============================================================================
-
-export class EntryAfterUnlockEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/AfterUnlock";
-  getHandlerAbstraction() {
-    return EntryAfterUnlockEventHandler;
-  }
+const EntryBeforeUnlockEventHandler = createAbstraction("EntryBeforeUnlockEventHandler");
+class EntryAfterUnlockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryAfterUnlockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/AfterUnlock";
+    }
 }
-export const EntryAfterUnlockEventHandler = createAbstraction("EntryAfterUnlockEventHandler");
-
-// ============================================================================
-// EntryUnlockError Event
-// ============================================================================
-
-export class EntryUnlockErrorEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/UnlockError";
-  getHandlerAbstraction() {
-    return EntryUnlockErrorEventHandler;
-  }
+const EntryAfterUnlockEventHandler = createAbstraction("EntryAfterUnlockEventHandler");
+class EntryUnlockErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryUnlockErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/UnlockError";
+    }
 }
-export const EntryUnlockErrorEventHandler = createAbstraction("EntryUnlockErrorEventHandler");
+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","EntryBeforeUnlockEventHandler","EntryAfterUnlockEvent","EntryAfterUnlockEventHandler","EntryUnlockErrorEvent","EntryUnlockErrorEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\n\n// ============================================================================\n// 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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,WAAW,QAAQ,mDAAmD;;AAK/E;AACA;AACA;;AAQA,OAAO,MAAMC,sBAAsB,SAASD,WAAW,CAA2B;EAC9EE,SAAS,GAAG,kCAAkC;EAE9CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,6BAA6B;EACxC;AACJ;AAEA,OAAO,MAAMA,6BAA6B,GAAGL,iBAAiB,CAE5D,+BAA+B,CAAC;;AAOlC;AACA;AACA;;AAQA,OAAO,MAAMM,qBAAqB,SAASL,WAAW,CAA0B;EAC5EE,SAAS,GAAG,iCAAiC;EAE7CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,4BAA4B;EACvC;AACJ;AAEA,OAAO,MAAMA,4BAA4B,GAAGP,iBAAiB,CACzD,8BACJ,CAAC;;AAOD;AACA;AACA;;AAQA,OAAO,MAAMQ,qBAAqB,SAASP,WAAW,CAA0B;EAC5EE,SAAS,GAAG,iCAAiC;EAE7CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,4BAA4B;EACvC;AACJ;AAEA,OAAO,MAAMA,4BAA4B,GAAGT,iBAAiB,CACzD,8BACJ,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.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.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 === true;
+const hasFullAccessPermission = async (identityContext)=>{
+    const hasFullAccess = await identityContext.hasFullAccess();
+    if (hasFullAccess) return true;
+    const permission = await identityContext.getPermission("recordLocking");
+    return permission?.canForceUnlock === true;
 };
+export { hasFullAccessPermission };
 
 //# sourceMappingURL=hasFullAccessPermission.js.map

package/features/UnlockEntry/hasFullAccessPermission.js.map

@@ -1 +1 @@
-{"version":3,"names":["hasFullAccessPermission","identityContext","hasFullAccess","permission","getPermission","canForceUnlock"],"sources":["hasFullAccessPermission.ts"],"sourcesContent":["import type { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { SecurityPermission } from \"@webiny/api-core/types/security.js\";\n\ninterface RecordLockingSecurityPermission extends SecurityPermission {\n    canForceUnlock?: boolean;\n}\n\nexport const hasFullAccessPermission = async (\n    identityContext: IdentityContext.Interface\n): Promise<boolean> => {\n    const hasFullAccess = await identityContext.hasFullAccess();\n    if (hasFullAccess) {\n        return true;\n    }\n\n    const permission =\n        await identityContext.getPermission<RecordLockingSecurityPermission>(\"recordLocking\");\n    return permission?.canForceUnlock === true;\n};\n"],"mappings":"AAOA,OAAO,MAAMA,uBAAuB,GAAG,MACnCC,eAA0C,IACvB;EACnB,MAAMC,aAAa,GAAG,MAAMD,eAAe,CAACC,aAAa,CAAC,CAAC;EAC3D,IAAIA,aAAa,EAAE;IACf,OAAO,IAAI;EACf;EAEA,MAAMC,UAAU,GACZ,MAAMF,eAAe,CAACG,aAAa,CAAkC,eAAe,CAAC;EACzF,OAAOD,UAAU,EAAEE,cAAc,KAAK,IAAI;AAC9C,CAAC","ignoreList":[]}
+{"version":3,"file":"features/UnlockEntry/hasFullAccessPermission.js","sources":["../../../src/features/UnlockEntry/hasFullAccessPermission.ts"],"sourcesContent":["import type { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { SecurityPermission } from \"@webiny/api-core/types/security.js\";\n\ninterface RecordLockingSecurityPermission extends SecurityPermission {\n    canForceUnlock?: boolean;\n}\n\nexport const hasFullAccessPermission = async (\n    identityContext: IdentityContext.Interface\n): Promise<boolean> => {\n    const hasFullAccess = await identityContext.hasFullAccess();\n    if (hasFullAccess) {\n        return true;\n    }\n\n    const permission =\n        await identityContext.getPermission<RecordLockingSecurityPermission>(\"recordLocking\");\n    return permission?.canForceUnlock === true;\n};\n"],"names":["hasFullAccessPermission","identityContext","hasFullAccess","permission"],"mappings":"AAOO,MAAMA,0BAA0B,OACnCC;IAEA,MAAMC,gBAAgB,MAAMD,gBAAgB,aAAa;IACzD,IAAIC,eACA,OAAO;IAGX,MAAMC,aACF,MAAMF,gBAAgB,aAAa,CAAkC;IACzE,OAAOE,YAAY,mBAAmB;AAC1C"}

package/features/UnlockEntry/index.js

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

package/features/UnlockEntryRequest/UnlockEntryRequestEventsDecorator.js

@@ -2,39 +2,39 @@ import { UnlockEntryRequestUseCase } from "./abstractions.js";
 import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
 import { EntryAfterUnlockRequestEvent, EntryBeforeUnlockRequestEvent, EntryUnlockRequestErrorEvent } from "./events.js";
 class UnlockEntryRequestEventsDecoratorImpl {
-  constructor(eventPublisher, decoratee) {
-    this.eventPublisher = eventPublisher;
-    this.decoratee = decoratee;
-  }
-  async execute(input) {
-    // Publish before event
-    await this.eventPublisher.publish(new EntryBeforeUnlockRequestEvent({
-      id: input.id,
-      type: input.type
-    }));
-    const result = await this.decoratee.execute(input);
-    if (result.isFail()) {
-      const error = result.error;
-      await this.eventPublisher.publish(new EntryUnlockRequestErrorEvent({
-        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 EntryBeforeUnlockRequestEvent({
+            id: input.id,
+            type: input.type
+        }));
+        const result = await this.decoratee.execute(input);
+        if (result.isFail()) {
+            const error = result.error;
+            await this.eventPublisher.publish(new EntryUnlockRequestErrorEvent({
+                id: input.id,
+                type: input.type,
+                error
+            }));
+            return result;
+        }
+        await this.eventPublisher.publish(new EntryAfterUnlockRequestEvent({
+            id: input.id,
+            type: input.type,
+            record: result.value
+        }));
+        return result;
     }
-
-    // Publish after event
-    await this.eventPublisher.publish(new EntryAfterUnlockRequestEvent({
-      id: input.id,
-      type: input.type,
-      record: result.value
-    }));
-    return result;
-  }
 }
-export const UnlockEntryRequestEventsDecorator = UnlockEntryRequestUseCase.createDecorator({
-  decorator: UnlockEntryRequestEventsDecoratorImpl,
-  dependencies: [EventPublisher]
+const UnlockEntryRequestEventsDecorator = UnlockEntryRequestUseCase.createDecorator({
+    decorator: UnlockEntryRequestEventsDecoratorImpl,
+    dependencies: [
+        EventPublisher
+    ]
 });
+export { UnlockEntryRequestEventsDecorator };
 
 //# sourceMappingURL=UnlockEntryRequestEventsDecorator.js.map

package/features/UnlockEntryRequest/UnlockEntryRequestEventsDecorator.js.map

@@ -1 +1 @@
-{"version":3,"names":["UnlockEntryRequestUseCase","EventPublisher","EntryAfterUnlockRequestEvent","EntryBeforeUnlockRequestEvent","EntryUnlockRequestErrorEvent","UnlockEntryRequestEventsDecoratorImpl","constructor","eventPublisher","decoratee","execute","input","publish","id","type","result","isFail","error","record","value","UnlockEntryRequestEventsDecorator","createDecorator","decorator","dependencies"],"sources":["UnlockEntryRequestEventsDecorator.ts"],"sourcesContent":["import {\n    type UnlockEntryRequestInput,\n    UnlockEntryRequestUseCase as UseCaseAbstraction,\n    UnlockEntryRequestUseCase\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 {\n    EntryAfterUnlockRequestEvent,\n    EntryBeforeUnlockRequestEvent,\n    EntryUnlockRequestErrorEvent\n} from \"./events.js\";\n\nclass UnlockEntryRequestEventsDecoratorImpl implements UnlockEntryRequestUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: UnlockEntryRequestUseCase.Interface\n    ) {}\n\n    async execute(\n        input: UnlockEntryRequestInput\n    ): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeUnlockRequestEvent({\n                id: input.id,\n                type: input.type\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 EntryUnlockRequestErrorEvent({\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 EntryAfterUnlockRequestEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const UnlockEntryRequestEventsDecorator = UnlockEntryRequestUseCase.createDecorator({\n    decorator: UnlockEntryRequestEventsDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"mappings":"AAAA,SAGIA,yBAAyB;AAE7B,SAASC,cAAc,QAAQ,mDAAmD;AAGlF,SACIC,4BAA4B,EAC5BC,6BAA6B,EAC7BC,4BAA4B;AAGhC,MAAMC,qCAAqC,CAAgD;EACvFC,WAAWA,CACUC,cAAwC,EACxCC,SAA8C,EACjE;IAAA,KAFmBD,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,SAA8C,GAA9CA,SAA8C;EAChE;EAEH,MAAMC,OAAOA,CACTC,KAA8B,EACwB;IACtD;IACA,MAAM,IAAI,CAACH,cAAc,CAACI,OAAO,CAC7B,IAAIR,6BAA6B,CAAC;MAC9BS,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG;IAChB,CAAC,CACL,CAAC;IAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,SAAS,CAACC,OAAO,CAACC,KAAK,CAAC;IAElD,IAAII,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMC,KAAK,GAAGF,MAAM,CAACE,KAAK;MAE1B,MAAM,IAAI,CAACT,cAAc,CAACI,OAAO,CAC7B,IAAIP,4BAA4B,CAAC;QAC7BQ,EAAE,EAAEF,KAAK,CAACE,EAAE;QACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;QAChBG;MACJ,CAAC,CACL,CAAC;MAED,OAAOF,MAAM;IACjB;;IAEA;IACA,MAAM,IAAI,CAACP,cAAc,CAACI,OAAO,CAC7B,IAAIT,4BAA4B,CAAC;MAC7BU,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;MAChBI,MAAM,EAAEH,MAAM,CAACI;IACnB,CAAC,CACL,CAAC;IAED,OAAOJ,MAAM;EACjB;AACJ;AAEA,OAAO,MAAMK,iCAAiC,GAAGnB,yBAAyB,CAACoB,eAAe,CAAC;EACvFC,SAAS,EAAEhB,qCAAqC;EAChDiB,YAAY,EAAE,CAACrB,cAAc;AACjC,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/UnlockEntryRequest/UnlockEntryRequestEventsDecorator.js","sources":["../../../src/features/UnlockEntryRequest/UnlockEntryRequestEventsDecorator.ts"],"sourcesContent":["import {\n    type UnlockEntryRequestInput,\n    UnlockEntryRequestUseCase as UseCaseAbstraction,\n    UnlockEntryRequestUseCase\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 {\n    EntryAfterUnlockRequestEvent,\n    EntryBeforeUnlockRequestEvent,\n    EntryUnlockRequestErrorEvent\n} from \"./events.js\";\n\nclass UnlockEntryRequestEventsDecoratorImpl implements UnlockEntryRequestUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: UnlockEntryRequestUseCase.Interface\n    ) {}\n\n    async execute(\n        input: UnlockEntryRequestInput\n    ): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeUnlockRequestEvent({\n                id: input.id,\n                type: input.type\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 EntryUnlockRequestErrorEvent({\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 EntryAfterUnlockRequestEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const UnlockEntryRequestEventsDecorator = UnlockEntryRequestUseCase.createDecorator({\n    decorator: UnlockEntryRequestEventsDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"names":["UnlockEntryRequestEventsDecoratorImpl","eventPublisher","decoratee","input","EntryBeforeUnlockRequestEvent","result","error","EntryUnlockRequestErrorEvent","EntryAfterUnlockRequestEvent","UnlockEntryRequestEventsDecorator","UnlockEntryRequestUseCase","EventPublisher"],"mappings":";;;AAcA,MAAMA;IACF,YACqBC,cAAwC,EACxCC,SAA8C,CACjE;aAFmBD,cAAc,GAAdA;aACAC,SAAS,GAATA;IAClB;IAEH,MAAM,QACFC,KAA8B,EACwB;QAEtD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,8BAA8B;YAC9B,IAAID,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;QACpB;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,6BAA6B;gBAC7B,IAAIJ,MAAM,EAAE;gBACZ,MAAMA,MAAM,IAAI;gBAChBG;YACJ;YAGJ,OAAOD;QACX;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,6BAA6B;YAC7B,IAAIL,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;YAChB,QAAQE,OAAO,KAAK;QACxB;QAGJ,OAAOA;IACX;AACJ;AAEO,MAAMI,oCAAoCC,0BAA0B,eAAe,CAAC;IACvF,WAAWV;IACX,cAAc;QAACW;KAAe;AAClC"}

package/features/UnlockEntryRequest/UnlockEntryRequestRepository.js

@@ -1,5 +1,5 @@
 import { Result } from "@webiny/feature/api";
-import { UnlockEntryRequestRepository as RepositoryAbstraction } from "./abstractions.js";
+import { UnlockEntryRequestRepository } from "./abstractions.js";
 import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
 import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
 import { RecordLockingModel } from "../../domain/abstractions.js";
@@ -7,37 +7,38 @@ import { UnlockEntryRequestError } from "../../domain/errors.js";
 import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
 import { createIdentifier } from "@webiny/utils";
 class UnlockEntryRequestRepositoryImpl {
-  constructor(updateEntry, identityContext, model) {
-    this.updateEntry = updateEntry;
-    this.identityContext = identityContext;
-    this.model = model;
-  }
-  async update(record) {
-    try {
-      const entryId = createLockRecordDatabaseId(record.id);
-      const id = createIdentifier({
-        id: entryId,
-        version: 1
-      });
-      const recordValues = record.toObject();
-      const result = await this.identityContext.withoutAuthorization(async () => {
-        return await this.updateEntry.execute(this.model, id, {
-          ...recordValues,
-          values: recordValues
-        });
-      });
-      if (result.isFail()) {
-        return Result.fail(new UnlockEntryRequestError(result.error));
-      }
-      return Result.ok(record);
-    } catch (error) {
-      return Result.fail(new UnlockEntryRequestError(error));
+    constructor(updateEntry, identityContext, model){
+        this.updateEntry = updateEntry;
+        this.identityContext = identityContext;
+        this.model = model;
+    }
+    async update(record) {
+        try {
+            const entryId = createLockRecordDatabaseId(record.id);
+            const id = createIdentifier({
+                id: entryId,
+                version: 1
+            });
+            const recordValues = record.toObject();
+            const result = await this.identityContext.withoutAuthorization(async ()=>await this.updateEntry.execute(this.model, id, {
+                    ...recordValues,
+                    values: recordValues
+                }));
+            if (result.isFail()) return Result.fail(new UnlockEntryRequestError(result.error));
+            return Result.ok(record);
+        } catch (error) {
+            return Result.fail(new UnlockEntryRequestError(error));
+        }
     }
-  }
 }
-export const UnlockEntryRequestRepository = RepositoryAbstraction.createImplementation({
-  implementation: UnlockEntryRequestRepositoryImpl,
-  dependencies: [UpdateEntryUseCase, IdentityContext, RecordLockingModel]
+const UnlockEntryRequestRepository_UnlockEntryRequestRepository = UnlockEntryRequestRepository.createImplementation({
+    implementation: UnlockEntryRequestRepositoryImpl,
+    dependencies: [
+        UpdateEntryUseCase,
+        IdentityContext,
+        RecordLockingModel
+    ]
 });
+export { UnlockEntryRequestRepository_UnlockEntryRequestRepository as UnlockEntryRequestRepository };
 
 //# sourceMappingURL=UnlockEntryRequestRepository.js.map

package/features/UnlockEntryRequest/UnlockEntryRequestRepository.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","UnlockEntryRequestRepository","RepositoryAbstraction","UpdateEntryUseCase","IdentityContext","RecordLockingModel","UnlockEntryRequestError","createLockRecordDatabaseId","createIdentifier","UnlockEntryRequestRepositoryImpl","constructor","updateEntry","identityContext","model","update","record","entryId","id","version","recordValues","toObject","result","withoutAuthorization","execute","values","isFail","fail","error","ok","createImplementation","implementation","dependencies"],"sources":["UnlockEntryRequestRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { UnlockEntryRequestRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { RecordLockingModel } from \"~/domain/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { UnlockEntryRequestError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\nimport { createIdentifier } from \"@webiny/utils\";\n\nclass UnlockEntryRequestRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private identityContext: IdentityContext.Interface,\n        private model: CmsModel\n    ) {}\n\n    async update(record: ILockRecord): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = createLockRecordDatabaseId(record.id);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const recordValues = record.toObject();\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                return await this.updateEntry.execute(this.model, id, {\n                    ...recordValues,\n                    values: recordValues\n                });\n            });\n\n            if (result.isFail()) {\n                return Result.fail(new UnlockEntryRequestError(result.error));\n            }\n\n            return Result.ok(record);\n        } catch (error) {\n            return Result.fail(new UnlockEntryRequestError(error as Error));\n        }\n    }\n}\n\nexport const UnlockEntryRequestRepository = RepositoryAbstraction.createImplementation({\n    implementation: UnlockEntryRequestRepositoryImpl,\n    dependencies: [UpdateEntryUseCase, IdentityContext, RecordLockingModel]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,4BAA4B,IAAIC,qBAAqB;AAC9D,SAASC,kBAAkB,QAAQ,4DAA4D;AAC/F,SAASC,eAAe,QAAQ,6DAA6D;AAC7F,SAASC,kBAAkB;AAG3B,SAASC,uBAAuB;AAChC,SAASC,0BAA0B;AACnC,SAASC,gBAAgB,QAAQ,eAAe;AAEhD,MAAMC,gCAAgC,CAA4C;EAC9EC,WAAWA,CACCC,WAAyC,EACzCC,eAA0C,EAC1CC,KAAe,EACzB;IAAA,KAHUF,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,KAAe,GAAfA,KAAe;EACxB;EAEH,MAAMC,MAAMA,CAACC,MAAmB,EAA6D;IACzF,IAAI;MACA,MAAMC,OAAO,GAAGT,0BAA0B,CAACQ,MAAM,CAACE,EAAE,CAAC;MACrD,MAAMA,EAAE,GAAGT,gBAAgB,CAAC;QACxBS,EAAE,EAAED,OAAO;QACXE,OAAO,EAAE;MACb,CAAC,CAAC;MAEF,MAAMC,YAAY,GAAGJ,MAAM,CAACK,QAAQ,CAAC,CAAC;MACtC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACT,eAAe,CAACU,oBAAoB,CAAC,YAAY;QACvE,OAAO,MAAM,IAAI,CAACX,WAAW,CAACY,OAAO,CAAC,IAAI,CAACV,KAAK,EAAEI,EAAE,EAAE;UAClD,GAAGE,YAAY;UACfK,MAAM,EAAEL;QACZ,CAAC,CAAC;MACN,CAAC,CAAC;MAEF,IAAIE,MAAM,CAACI,MAAM,CAAC,CAAC,EAAE;QACjB,OAAOzB,MAAM,CAAC0B,IAAI,CAAC,IAAIpB,uBAAuB,CAACe,MAAM,CAACM,KAAK,CAAC,CAAC;MACjE;MAEA,OAAO3B,MAAM,CAAC4B,EAAE,CAACb,MAAM,CAAC;IAC5B,CAAC,CAAC,OAAOY,KAAK,EAAE;MACZ,OAAO3B,MAAM,CAAC0B,IAAI,CAAC,IAAIpB,uBAAuB,CAACqB,KAAc,CAAC,CAAC;IACnE;EACJ;AACJ;AAEA,OAAO,MAAM1B,4BAA4B,GAAGC,qBAAqB,CAAC2B,oBAAoB,CAAC;EACnFC,cAAc,EAAErB,gCAAgC;EAChDsB,YAAY,EAAE,CAAC5B,kBAAkB,EAAEC,eAAe,EAAEC,kBAAkB;AAC1E,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/UnlockEntryRequest/UnlockEntryRequestRepository.js","sources":["../../../src/features/UnlockEntryRequest/UnlockEntryRequestRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { UnlockEntryRequestRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { RecordLockingModel } from \"~/domain/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { UnlockEntryRequestError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\nimport { createIdentifier } from \"@webiny/utils\";\n\nclass UnlockEntryRequestRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private identityContext: IdentityContext.Interface,\n        private model: CmsModel\n    ) {}\n\n    async update(record: ILockRecord): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = createLockRecordDatabaseId(record.id);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const recordValues = record.toObject();\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                return await this.updateEntry.execute(this.model, id, {\n                    ...recordValues,\n                    values: recordValues\n                });\n            });\n\n            if (result.isFail()) {\n                return Result.fail(new UnlockEntryRequestError(result.error));\n            }\n\n            return Result.ok(record);\n        } catch (error) {\n            return Result.fail(new UnlockEntryRequestError(error as Error));\n        }\n    }\n}\n\nexport const UnlockEntryRequestRepository = RepositoryAbstraction.createImplementation({\n    implementation: UnlockEntryRequestRepositoryImpl,\n    dependencies: [UpdateEntryUseCase, IdentityContext, RecordLockingModel]\n});\n"],"names":["UnlockEntryRequestRepositoryImpl","updateEntry","identityContext","model","record","entryId","createLockRecordDatabaseId","id","createIdentifier","recordValues","result","Result","UnlockEntryRequestError","error","UnlockEntryRequestRepository","RepositoryAbstraction","UpdateEntryUseCase","IdentityContext","RecordLockingModel"],"mappings":";;;;;;;;AAWA,MAAMA;IACF,YACYC,WAAyC,EACzCC,eAA0C,EAC1CC,KAAe,CACzB;aAHUF,WAAW,GAAXA;aACAC,eAAe,GAAfA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,OAAOC,MAAmB,EAA6D;QACzF,IAAI;YACA,MAAMC,UAAUC,2BAA2BF,OAAO,EAAE;YACpD,MAAMG,KAAKC,iBAAiB;gBACxB,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,eAAeL,OAAO,QAAQ;YACpC,MAAMM,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,UACpD,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAEH,IAAI;oBAClD,GAAGE,YAAY;oBACf,QAAQA;gBACZ;YAGJ,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,wBAAwBF,OAAO,KAAK;YAG/D,OAAOC,OAAO,EAAE,CAACP;QACrB,EAAE,OAAOS,OAAO;YACZ,OAAOF,OAAO,IAAI,CAAC,IAAIC,wBAAwBC;QACnD;IACJ;AACJ;AAEO,MAAMC,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgBf;IAChB,cAAc;QAACgB;QAAoBC;QAAiBC;KAAmB;AAC3E"}