@webiny/api-record-locking 5.40.0-beta.3

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_types","require","IRecordLockingLockRecordActionType","exports"],"sources":["types.ts"],"sourcesContent":["import {\n    CmsContext,\n    CmsEntry,\n    CmsEntryListParams,\n    CmsEntryMeta,\n    CmsError,\n    CmsIdentity,\n    CmsModel,\n    CmsModelManager\n} from \"@webiny/api-headless-cms/types\";\nimport { Topic } from \"@webiny/pubsub/types\";\nimport {\n    Context as IWebsocketsContext,\n    IWebsocketsContextObject\n} from \"@webiny/api-websockets/types\";\n\nexport { CmsError, CmsEntry };\n\nexport type IRecordLockingIdentity = CmsIdentity;\n\nexport type IRecordLockingModelManager = CmsModelManager<IRecordLockingLockRecordValues>;\n\nexport type IRecordLockingMeta = CmsEntryMeta;\n\nexport interface IHasFullAccessCallable {\n    (): Promise<boolean>;\n}\n\nexport interface IGetWebsocketsContextCallable {\n    (): IWebsocketsContextObject;\n}\n\nexport interface IGetIdentity {\n    (): IRecordLockingIdentity;\n}\n\nexport interface IRecordLockingLockRecordValues {\n    targetId: string;\n    type: IRecordLockingLockRecordEntryType;\n    actions?: IRecordLockingLockRecordAction[];\n}\nexport enum IRecordLockingLockRecordActionType {\n    requested = \"requested\",\n    approved = \"approved\",\n    denied = \"denied\"\n}\n\nexport interface IRecordLockingLockRecordRequestedAction {\n    type: IRecordLockingLockRecordActionType.requested;\n    message?: string;\n    createdOn: Date;\n    createdBy: IRecordLockingIdentity;\n}\n\nexport interface IRecordLockingLockRecordApprovedAction {\n    type: IRecordLockingLockRecordActionType.approved;\n    message?: string;\n    createdOn: Date;\n    createdBy: IRecordLockingIdentity;\n}\n\nexport interface IRecordLockingLockRecordDeniedAction {\n    type: IRecordLockingLockRecordActionType.denied;\n    message?: string;\n    createdOn: Date;\n    createdBy: IRecordLockingIdentity;\n}\n\nexport type IRecordLockingLockRecordAction =\n    | IRecordLockingLockRecordRequestedAction\n    | IRecordLockingLockRecordApprovedAction\n    | IRecordLockingLockRecordDeniedAction;\n\nexport interface IRecordLockingLockRecordObject {\n    id: string;\n    targetId: string;\n    type: IRecordLockingLockRecordEntryType;\n    lockedBy: IRecordLockingIdentity;\n    lockedOn: Date;\n    updatedOn: Date;\n    expiresOn: Date;\n    actions?: IRecordLockingLockRecordAction[];\n}\n\nexport interface IRecordLockingLockRecord extends IRecordLockingLockRecordObject {\n    toObject(): IRecordLockingLockRecordObject;\n    addAction(action: IRecordLockingLockRecordAction): void;\n    getUnlockRequested(): IRecordLockingLockRecordRequestedAction | undefined;\n    getUnlockApproved(): IRecordLockingLockRecordApprovedAction | undefined;\n    getUnlockDenied(): IRecordLockingLockRecordDeniedAction | undefined;\n}\n\n/**\n * Do not use any special chars other than #, as we use this to create lock record IDs.\n */\nexport type IRecordLockingLockRecordEntryType = string;\n\nexport type IRecordLockingListAllLockRecordsParams = Pick<\n    CmsEntryListParams,\n    \"where\" | \"limit\" | \"sort\" | \"after\"\n>;\n\nexport type IRecordLockingListLockRecordsParams = IRecordLockingListAllLockRecordsParams;\n\nexport interface IRecordLockingListAllLockRecordsResponse {\n    items: IRecordLockingLockRecord[];\n    meta: IRecordLockingMeta;\n}\n\nexport type IRecordLockingListLockRecordsResponse = IRecordLockingListAllLockRecordsResponse;\n\nexport interface IRecordLockingGetLockRecordParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n}\n\nexport interface IRecordLockingIsLockedParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n}\n\nexport interface IRecordLockingGetLockedEntryLockRecordParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n}\n\nexport interface IRecordLockingLockEntryParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n}\n\nexport interface IRecordLockingUpdateEntryLockParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n}\n\nexport interface IRecordLockingUnlockEntryParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n    force?: boolean;\n}\n\nexport interface IRecordLockingUnlockEntryRequestParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n}\n\nexport interface OnEntryBeforeLockTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n}\n\nexport interface OnEntryAfterLockTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n    record: IRecordLockingLockRecord;\n}\n\nexport interface OnEntryLockErrorTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n    error: CmsError;\n}\n\nexport interface OnEntryBeforeUnlockTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n    getIdentity: IGetIdentity;\n}\n\nexport interface OnEntryAfterUnlockTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n    record: IRecordLockingLockRecord;\n}\n\nexport interface OnEntryUnlockErrorTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n    error: CmsError;\n}\n\nexport interface OnEntryBeforeUnlockRequestTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n}\n\nexport interface OnEntryAfterUnlockRequestTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n    record: IRecordLockingLockRecord;\n}\n\nexport interface OnEntryUnlockRequestErrorTopicParams {\n    id: string;\n    type: IRecordLockingLockRecordEntryType;\n    error: CmsError;\n}\n\nexport interface IRecordLocking {\n    onEntryBeforeLock: Topic<OnEntryBeforeLockTopicParams>;\n    onEntryAfterLock: Topic<OnEntryAfterLockTopicParams>;\n    onEntryLockError: Topic<OnEntryLockErrorTopicParams>;\n    onEntryBeforeUnlock: Topic<OnEntryBeforeUnlockTopicParams>;\n    onEntryAfterUnlock: Topic<OnEntryAfterUnlockTopicParams>;\n    onEntryUnlockError: Topic<OnEntryUnlockErrorTopicParams>;\n    onEntryBeforeUnlockRequest: Topic<OnEntryBeforeUnlockRequestTopicParams>;\n    onEntryAfterUnlockRequest: Topic<OnEntryAfterUnlockRequestTopicParams>;\n    onEntryUnlockRequestError: Topic<OnEntryUnlockRequestErrorTopicParams>;\n    getModel(): Promise<CmsModel>;\n    listAllLockRecords(\n        params?: IRecordLockingListAllLockRecordsParams\n    ): Promise<IRecordLockingListAllLockRecordsResponse>;\n    /**\n     * Same call as listAllLockRecords, except this one will filter out records with expired lock.\n     */\n    listLockRecords(\n        params?: IRecordLockingListLockRecordsParams\n    ): Promise<IRecordLockingListLockRecordsResponse>;\n    getLockRecord(\n        params: IRecordLockingGetLockRecordParams\n    ): Promise<IRecordLockingLockRecord | null>;\n    isEntryLocked(params: IRecordLockingIsLockedParams): Promise<boolean>;\n    getLockedEntryLockRecord(\n        params: IRecordLockingGetLockedEntryLockRecordParams\n    ): Promise<IRecordLockingLockRecord | null>;\n    lockEntry(params: IRecordLockingLockEntryParams): Promise<IRecordLockingLockRecord>;\n    updateEntryLock(params: IRecordLockingUpdateEntryLockParams): Promise<IRecordLockingLockRecord>;\n    unlockEntry(params: IRecordLockingUnlockEntryParams): Promise<IRecordLockingLockRecord>;\n    unlockEntryRequest(\n        params: IRecordLockingUnlockEntryRequestParams\n    ): Promise<IRecordLockingLockRecord>;\n}\n\nexport interface Context extends CmsContext, IWebsocketsContext {\n    recordLocking: IRecordLocking;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AASwC,IAgC5BC,kCAAkC,GAAAC,OAAA,CAAAD,kCAAA,0BAAlCA,kCAAkC;EAAlCA,kCAAkC;EAAlCA,kCAAkC;EAAlCA,kCAAkC;EAAA,OAAlCA,kCAAkC;AAAA;AAmD9C;AACA;AACA","ignoreList":[]}

package/useCases/GetLockRecord/GetLockRecordUseCase.d.ts

@@ -0,0 +1,10 @@
+import { IGetLockRecordUseCase, IGetLockRecordUseCaseExecuteParams } from "../../abstractions/IGetLockRecordUseCase";
+import { IRecordLockingModelManager, IRecordLockingLockRecord } from "../../types";
+export interface IGetLockRecordUseCaseParams {
+    getManager(): Promise<IRecordLockingModelManager>;
+}
+export declare class GetLockRecordUseCase implements IGetLockRecordUseCase {
+    private readonly getManager;
+    constructor(params: IGetLockRecordUseCaseParams);
+    execute(input: IGetLockRecordUseCaseExecuteParams): Promise<IRecordLockingLockRecord | null>;
+}

package/useCases/GetLockRecord/GetLockRecordUseCase.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GetLockRecordUseCase = void 0;
+var _handlerGraphql = require("@webiny/handler-graphql");
+var _convertEntryToLockRecord = require("../../utils/convertEntryToLockRecord");
+var _lockRecordDatabaseId = require("../../utils/lockRecordDatabaseId");
+var _utils = require("@webiny/utils");
+class GetLockRecordUseCase {
+  constructor(params) {
+    this.getManager = params.getManager;
+  }
+  async execute(input) {
+    const recordId = (0, _lockRecordDatabaseId.createLockRecordDatabaseId)(input.id);
+    const id = (0, _utils.createIdentifier)({
+      id: recordId,
+      version: 1
+    });
+    try {
+      const manager = await this.getManager();
+      const result = await manager.get(id);
+      return (0, _convertEntryToLockRecord.convertEntryToLockRecord)(result);
+    } catch (ex) {
+      if (ex instanceof _handlerGraphql.NotFoundError) {
+        return null;
+      }
+      throw ex;
+    }
+  }
+}
+exports.GetLockRecordUseCase = GetLockRecordUseCase;
+
+//# sourceMappingURL=GetLockRecordUseCase.js.map

package/useCases/GetLockRecord/GetLockRecordUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_handlerGraphql","require","_convertEntryToLockRecord","_lockRecordDatabaseId","_utils","GetLockRecordUseCase","constructor","params","getManager","execute","input","recordId","createLockRecordDatabaseId","id","createIdentifier","version","manager","result","get","convertEntryToLockRecord","ex","NotFoundError","exports"],"sources":["GetLockRecordUseCase.ts"],"sourcesContent":["import {\n    IGetLockRecordUseCase,\n    IGetLockRecordUseCaseExecuteParams\n} from \"~/abstractions/IGetLockRecordUseCase\";\nimport { IRecordLockingModelManager, IRecordLockingLockRecord } from \"~/types\";\nimport { NotFoundError } from \"@webiny/handler-graphql\";\nimport { convertEntryToLockRecord } from \"~/utils/convertEntryToLockRecord\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId\";\nimport { createIdentifier } from \"@webiny/utils\";\n\nexport interface IGetLockRecordUseCaseParams {\n    getManager(): Promise<IRecordLockingModelManager>;\n}\n\nexport class GetLockRecordUseCase implements IGetLockRecordUseCase {\n    private readonly getManager: IGetLockRecordUseCaseParams[\"getManager\"];\n\n    public constructor(params: IGetLockRecordUseCaseParams) {\n        this.getManager = params.getManager;\n    }\n\n    public async execute(\n        input: IGetLockRecordUseCaseExecuteParams\n    ): Promise<IRecordLockingLockRecord | null> {\n        const recordId = createLockRecordDatabaseId(input.id);\n        const id = createIdentifier({\n            id: recordId,\n            version: 1\n        });\n        try {\n            const manager = await this.getManager();\n            const result = await manager.get(id);\n            return convertEntryToLockRecord(result);\n        } catch (ex) {\n            if (ex instanceof NotFoundError) {\n                return null;\n            }\n            throw ex;\n        }\n    }\n}\n"],"mappings":";;;;;;AAKA,IAAAA,eAAA,GAAAC,OAAA;AACA,IAAAC,yBAAA,GAAAD,OAAA;AACA,IAAAE,qBAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AAMO,MAAMI,oBAAoB,CAAkC;EAGxDC,WAAWA,CAACC,MAAmC,EAAE;IACpD,IAAI,CAACC,UAAU,GAAGD,MAAM,CAACC,UAAU;EACvC;EAEA,MAAaC,OAAOA,CAChBC,KAAyC,EACD;IACxC,MAAMC,QAAQ,GAAG,IAAAC,gDAA0B,EAACF,KAAK,CAACG,EAAE,CAAC;IACrD,MAAMA,EAAE,GAAG,IAAAC,uBAAgB,EAAC;MACxBD,EAAE,EAAEF,QAAQ;MACZI,OAAO,EAAE;IACb,CAAC,CAAC;IACF,IAAI;MACA,MAAMC,OAAO,GAAG,MAAM,IAAI,CAACR,UAAU,CAAC,CAAC;MACvC,MAAMS,MAAM,GAAG,MAAMD,OAAO,CAACE,GAAG,CAACL,EAAE,CAAC;MACpC,OAAO,IAAAM,kDAAwB,EAACF,MAAM,CAAC;IAC3C,CAAC,CAAC,OAAOG,EAAE,EAAE;MACT,IAAIA,EAAE,YAAYC,6BAAa,EAAE;QAC7B,OAAO,IAAI;MACf;MACA,MAAMD,EAAE;IACZ;EACJ;AACJ;AAACE,OAAA,CAAAjB,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/useCases/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.d.ts

@@ -0,0 +1,16 @@
+import { IGetLockRecordUseCase } from "../../abstractions/IGetLockRecordUseCase";
+import { IGetIdentity, IRecordLockingLockRecord } from "../../types";
+import { IGetLockedEntryLockRecordUseCase, IGetLockedEntryLockRecordUseCaseExecuteParams } from "../../abstractions/IGetLockedEntryLockRecordUseCase";
+import { IIsLocked } from "../../utils/isLockedFactory";
+export interface IGetLockedEntryLockRecordUseCaseParams {
+    getLockRecordUseCase: IGetLockRecordUseCase;
+    isLocked: IIsLocked;
+    getIdentity: IGetIdentity;
+}
+export declare class GetLockedEntryLockRecordUseCase implements IGetLockedEntryLockRecordUseCase {
+    private readonly getLockRecordUseCase;
+    private readonly isLocked;
+    private readonly getIdentity;
+    constructor(params: IGetLockedEntryLockRecordUseCaseParams);
+    execute(params: IGetLockedEntryLockRecordUseCaseExecuteParams): Promise<IRecordLockingLockRecord | null>;
+}

package/useCases/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GetLockedEntryLockRecordUseCase = void 0;
+class GetLockedEntryLockRecordUseCase {
+  constructor(params) {
+    this.getLockRecordUseCase = params.getLockRecordUseCase;
+    this.isLocked = params.isLocked;
+    this.getIdentity = params.getIdentity;
+  }
+  async execute(params) {
+    const result = await this.getLockRecordUseCase.execute(params);
+    if (!result?.lockedBy) {
+      return null;
+    }
+    const identity = this.getIdentity();
+    if (identity.id === result.lockedBy.id) {
+      return null;
+    }
+    return this.isLocked(result) ? result : null;
+  }
+}
+exports.GetLockedEntryLockRecordUseCase = GetLockedEntryLockRecordUseCase;
+
+//# sourceMappingURL=GetLockedEntryLockRecordUseCase.js.map

package/useCases/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetLockedEntryLockRecordUseCase","constructor","params","getLockRecordUseCase","isLocked","getIdentity","execute","result","lockedBy","identity","id","exports"],"sources":["GetLockedEntryLockRecordUseCase.ts"],"sourcesContent":["import { IGetLockRecordUseCase } from \"~/abstractions/IGetLockRecordUseCase\";\nimport { IGetIdentity, IRecordLockingLockRecord } from \"~/types\";\nimport {\n    IGetLockedEntryLockRecordUseCase,\n    IGetLockedEntryLockRecordUseCaseExecuteParams\n} from \"~/abstractions/IGetLockedEntryLockRecordUseCase\";\nimport { IIsLocked } from \"~/utils/isLockedFactory\";\n\nexport interface IGetLockedEntryLockRecordUseCaseParams {\n    getLockRecordUseCase: IGetLockRecordUseCase;\n    isLocked: IIsLocked;\n    getIdentity: IGetIdentity;\n}\n\nexport class GetLockedEntryLockRecordUseCase implements IGetLockedEntryLockRecordUseCase {\n    private readonly getLockRecordUseCase: IGetLockRecordUseCase;\n    private readonly isLocked: IIsLocked;\n    private readonly getIdentity: IGetIdentity;\n\n    public constructor(params: IGetLockedEntryLockRecordUseCaseParams) {\n        this.getLockRecordUseCase = params.getLockRecordUseCase;\n        this.isLocked = params.isLocked;\n        this.getIdentity = params.getIdentity;\n    }\n\n    public async execute(\n        params: IGetLockedEntryLockRecordUseCaseExecuteParams\n    ): Promise<IRecordLockingLockRecord | null> {\n        const result = await this.getLockRecordUseCase.execute(params);\n        if (!result?.lockedBy) {\n            return null;\n        }\n        const identity = this.getIdentity();\n        if (identity.id === result.lockedBy.id) {\n            return null;\n        }\n        return this.isLocked(result) ? result : null;\n    }\n}\n"],"mappings":";;;;;;AAcO,MAAMA,+BAA+B,CAA6C;EAK9EC,WAAWA,CAACC,MAA8C,EAAE;IAC/D,IAAI,CAACC,oBAAoB,GAAGD,MAAM,CAACC,oBAAoB;IACvD,IAAI,CAACC,QAAQ,GAAGF,MAAM,CAACE,QAAQ;IAC/B,IAAI,CAACC,WAAW,GAAGH,MAAM,CAACG,WAAW;EACzC;EAEA,MAAaC,OAAOA,CAChBJ,MAAqD,EACb;IACxC,MAAMK,MAAM,GAAG,MAAM,IAAI,CAACJ,oBAAoB,CAACG,OAAO,CAACJ,MAAM,CAAC;IAC9D,IAAI,CAACK,MAAM,EAAEC,QAAQ,EAAE;MACnB,OAAO,IAAI;IACf;IACA,MAAMC,QAAQ,GAAG,IAAI,CAACJ,WAAW,CAAC,CAAC;IACnC,IAAII,QAAQ,CAACC,EAAE,KAAKH,MAAM,CAACC,QAAQ,CAACE,EAAE,EAAE;MACpC,OAAO,IAAI;IACf;IACA,OAAO,IAAI,CAACN,QAAQ,CAACG,MAAM,CAAC,GAAGA,MAAM,GAAG,IAAI;EAChD;AACJ;AAACI,OAAA,CAAAX,+BAAA,GAAAA,+BAAA","ignoreList":[]}

package/useCases/IsEntryLocked/IsEntryLockedUseCase.d.ts

@@ -0,0 +1,16 @@
+import { IIsEntryLockedUseCase, IIsEntryLockedUseCaseExecuteParams } from "../../abstractions/IIsEntryLocked";
+import { IGetLockRecordUseCase } from "../../abstractions/IGetLockRecordUseCase";
+import { IIsLocked } from "../../utils/isLockedFactory";
+import { IGetIdentity } from "../../types";
+export interface IIsEntryLockedParams {
+    getLockRecordUseCase: IGetLockRecordUseCase;
+    isLocked: IIsLocked;
+    getIdentity: IGetIdentity;
+}
+export declare class IsEntryLockedUseCase implements IIsEntryLockedUseCase {
+    private readonly getLockRecordUseCase;
+    private readonly isLocked;
+    private readonly getIdentity;
+    constructor(params: IIsEntryLockedParams);
+    execute(params: IIsEntryLockedUseCaseExecuteParams): Promise<boolean>;
+}

package/useCases/IsEntryLocked/IsEntryLockedUseCase.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IsEntryLockedUseCase = void 0;
+var _handlerGraphql = require("@webiny/handler-graphql");
+class IsEntryLockedUseCase {
+  constructor(params) {
+    this.getLockRecordUseCase = params.getLockRecordUseCase;
+    this.isLocked = params.isLocked;
+    this.getIdentity = params.getIdentity;
+  }
+  async execute(params) {
+    try {
+      const result = await this.getLockRecordUseCase.execute(params);
+      if (!result) {
+        return false;
+      }
+      const identity = this.getIdentity();
+      if (result.lockedBy.id === identity.id) {
+        return false;
+      }
+      return this.isLocked(result);
+    } catch (ex) {
+      if (ex instanceof _handlerGraphql.NotFoundError === false) {
+        throw ex;
+      }
+      return false;
+    }
+  }
+}
+exports.IsEntryLockedUseCase = IsEntryLockedUseCase;
+
+//# sourceMappingURL=IsEntryLockedUseCase.js.map

package/useCases/IsEntryLocked/IsEntryLockedUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_handlerGraphql","require","IsEntryLockedUseCase","constructor","params","getLockRecordUseCase","isLocked","getIdentity","execute","result","identity","lockedBy","id","ex","NotFoundError","exports"],"sources":["IsEntryLockedUseCase.ts"],"sourcesContent":["import {\n    IIsEntryLockedUseCase,\n    IIsEntryLockedUseCaseExecuteParams\n} from \"~/abstractions/IIsEntryLocked\";\nimport { IGetLockRecordUseCase } from \"~/abstractions/IGetLockRecordUseCase\";\nimport { NotFoundError } from \"@webiny/handler-graphql\";\nimport { IIsLocked } from \"~/utils/isLockedFactory\";\nimport { IGetIdentity } from \"~/types\";\n\nexport interface IIsEntryLockedParams {\n    getLockRecordUseCase: IGetLockRecordUseCase;\n    isLocked: IIsLocked;\n    getIdentity: IGetIdentity;\n}\n\nexport class IsEntryLockedUseCase implements IIsEntryLockedUseCase {\n    private readonly getLockRecordUseCase: IGetLockRecordUseCase;\n    private readonly isLocked: IIsLocked;\n    private readonly getIdentity: IGetIdentity;\n\n    public constructor(params: IIsEntryLockedParams) {\n        this.getLockRecordUseCase = params.getLockRecordUseCase;\n        this.isLocked = params.isLocked;\n        this.getIdentity = params.getIdentity;\n    }\n\n    public async execute(params: IIsEntryLockedUseCaseExecuteParams): Promise<boolean> {\n        try {\n            const result = await this.getLockRecordUseCase.execute(params);\n            if (!result) {\n                return false;\n            }\n            const identity = this.getIdentity();\n            if (result.lockedBy.id === identity.id) {\n                return false;\n            }\n\n            return this.isLocked(result);\n        } catch (ex) {\n            if (ex instanceof NotFoundError === false) {\n                throw ex;\n            }\n            return false;\n        }\n    }\n}\n"],"mappings":";;;;;;AAKA,IAAAA,eAAA,GAAAC,OAAA;AAUO,MAAMC,oBAAoB,CAAkC;EAKxDC,WAAWA,CAACC,MAA4B,EAAE;IAC7C,IAAI,CAACC,oBAAoB,GAAGD,MAAM,CAACC,oBAAoB;IACvD,IAAI,CAACC,QAAQ,GAAGF,MAAM,CAACE,QAAQ;IAC/B,IAAI,CAACC,WAAW,GAAGH,MAAM,CAACG,WAAW;EACzC;EAEA,MAAaC,OAAOA,CAACJ,MAA0C,EAAoB;IAC/E,IAAI;MACA,MAAMK,MAAM,GAAG,MAAM,IAAI,CAACJ,oBAAoB,CAACG,OAAO,CAACJ,MAAM,CAAC;MAC9D,IAAI,CAACK,MAAM,EAAE;QACT,OAAO,KAAK;MAChB;MACA,MAAMC,QAAQ,GAAG,IAAI,CAACH,WAAW,CAAC,CAAC;MACnC,IAAIE,MAAM,CAACE,QAAQ,CAACC,EAAE,KAAKF,QAAQ,CAACE,EAAE,EAAE;QACpC,OAAO,KAAK;MAChB;MAEA,OAAO,IAAI,CAACN,QAAQ,CAACG,MAAM,CAAC;IAChC,CAAC,CAAC,OAAOI,EAAE,EAAE;MACT,IAAIA,EAAE,YAAYC,6BAAa,KAAK,KAAK,EAAE;QACvC,MAAMD,EAAE;MACZ;MACA,OAAO,KAAK;IAChB;EACJ;AACJ;AAACE,OAAA,CAAAb,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/useCases/KickOutCurrentUser/KickOutCurrentUserUseCase.d.ts

@@ -0,0 +1,12 @@
+import { IKickOutCurrentUserUseCase, IKickOutCurrentUserUseCaseExecuteParams } from "../../abstractions/IKickOutCurrentUserUseCase";
+import { IGetIdentity, IGetWebsocketsContextCallable } from "../../types";
+export interface IKickOutCurrentUserUseCaseParams {
+    getWebsockets: IGetWebsocketsContextCallable;
+    getIdentity: IGetIdentity;
+}
+export declare class KickOutCurrentUserUseCase implements IKickOutCurrentUserUseCase {
+    private readonly getWebsockets;
+    private readonly getIdentity;
+    constructor(params: IKickOutCurrentUserUseCaseParams);
+    execute(record: IKickOutCurrentUserUseCaseExecuteParams): Promise<void>;
+}

package/useCases/KickOutCurrentUser/KickOutCurrentUserUseCase.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KickOutCurrentUserUseCase = void 0;
+var _utils = require("@webiny/utils");
+class KickOutCurrentUserUseCase {
+  constructor(params) {
+    this.getWebsockets = params.getWebsockets;
+    this.getIdentity = params.getIdentity;
+  }
+  async execute(record) {
+    const {
+      lockedBy,
+      id
+    } = record;
+    const websockets = this.getWebsockets();
+    const {
+      id: entryId
+    } = (0, _utils.parseIdentifier)(id);
+    const identity = this.getIdentity();
+
+    /**
+     * We do not want any errors to leak out of this method.
+     * Just log the error, if any.
+     */
+    try {
+      await websockets.send({
+        id: lockedBy.id
+      }, {
+        action: `recordLocking.entry.kickOut.${entryId}`,
+        data: {
+          record: record.toObject(),
+          user: identity
+        }
+      });
+    } catch (ex) {
+      console.error(`Could not send the kickOut message to a user with identity id: ${lockedBy.id}. More info in next log line.`);
+      console.info(ex);
+    }
+  }
+}
+exports.KickOutCurrentUserUseCase = KickOutCurrentUserUseCase;
+
+//# sourceMappingURL=KickOutCurrentUserUseCase.js.map

package/useCases/KickOutCurrentUser/KickOutCurrentUserUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_utils","require","KickOutCurrentUserUseCase","constructor","params","getWebsockets","getIdentity","execute","record","lockedBy","id","websockets","entryId","parseIdentifier","identity","send","action","data","toObject","user","ex","console","error","info","exports"],"sources":["KickOutCurrentUserUseCase.ts"],"sourcesContent":["import {\n    IKickOutCurrentUserUseCase,\n    IKickOutCurrentUserUseCaseExecuteParams\n} from \"~/abstractions/IKickOutCurrentUserUseCase\";\nimport { IGetIdentity, IGetWebsocketsContextCallable } from \"~/types\";\nimport { parseIdentifier } from \"@webiny/utils\";\n\nexport interface IKickOutCurrentUserUseCaseParams {\n    getWebsockets: IGetWebsocketsContextCallable;\n    getIdentity: IGetIdentity;\n}\n\nexport class KickOutCurrentUserUseCase implements IKickOutCurrentUserUseCase {\n    private readonly getWebsockets: IGetWebsocketsContextCallable;\n    private readonly getIdentity: IGetIdentity;\n\n    public constructor(params: IKickOutCurrentUserUseCaseParams) {\n        this.getWebsockets = params.getWebsockets;\n        this.getIdentity = params.getIdentity;\n    }\n\n    public async execute(record: IKickOutCurrentUserUseCaseExecuteParams): Promise<void> {\n        const { lockedBy, id } = record;\n\n        const websockets = this.getWebsockets();\n\n        const { id: entryId } = parseIdentifier(id);\n\n        const identity = this.getIdentity();\n\n        /**\n         * We do not want any errors to leak out of this method.\n         * Just log the error, if any.\n         */\n        try {\n            await websockets.send(\n                { id: lockedBy.id },\n                {\n                    action: `recordLocking.entry.kickOut.${entryId}`,\n                    data: {\n                        record: record.toObject(),\n                        user: identity\n                    }\n                }\n            );\n        } catch (ex) {\n            console.error(\n                `Could not send the kickOut message to a user with identity id: ${lockedBy.id}. More info in next log line.`\n            );\n            console.info(ex);\n        }\n    }\n}\n"],"mappings":";;;;;;AAKA,IAAAA,MAAA,GAAAC,OAAA;AAOO,MAAMC,yBAAyB,CAAuC;EAIlEC,WAAWA,CAACC,MAAwC,EAAE;IACzD,IAAI,CAACC,aAAa,GAAGD,MAAM,CAACC,aAAa;IACzC,IAAI,CAACC,WAAW,GAAGF,MAAM,CAACE,WAAW;EACzC;EAEA,MAAaC,OAAOA,CAACC,MAA+C,EAAiB;IACjF,MAAM;MAAEC,QAAQ;MAAEC;IAAG,CAAC,GAAGF,MAAM;IAE/B,MAAMG,UAAU,GAAG,IAAI,CAACN,aAAa,CAAC,CAAC;IAEvC,MAAM;MAAEK,EAAE,EAAEE;IAAQ,CAAC,GAAG,IAAAC,sBAAe,EAACH,EAAE,CAAC;IAE3C,MAAMI,QAAQ,GAAG,IAAI,CAACR,WAAW,CAAC,CAAC;;IAEnC;AACR;AACA;AACA;IACQ,IAAI;MACA,MAAMK,UAAU,CAACI,IAAI,CACjB;QAAEL,EAAE,EAAED,QAAQ,CAACC;MAAG,CAAC,EACnB;QACIM,MAAM,EAAG,+BAA8BJ,OAAQ,EAAC;QAChDK,IAAI,EAAE;UACFT,MAAM,EAAEA,MAAM,CAACU,QAAQ,CAAC,CAAC;UACzBC,IAAI,EAAEL;QACV;MACJ,CACJ,CAAC;IACL,CAAC,CAAC,OAAOM,EAAE,EAAE;MACTC,OAAO,CAACC,KAAK,CACR,kEAAiEb,QAAQ,CAACC,EAAG,+BAClF,CAAC;MACDW,OAAO,CAACE,IAAI,CAACH,EAAE,CAAC;IACpB;EACJ;AACJ;AAACI,OAAA,CAAAtB,yBAAA,GAAAA,yBAAA","ignoreList":[]}

package/useCases/ListAllLockRecordsUseCase/ListAllLockRecordsUseCase.d.ts

@@ -0,0 +1,10 @@
+import { IListAllLockRecordsUseCase, IListAllLockRecordsUseCaseExecuteParams, IListAllLockRecordsUseCaseExecuteResponse } from "../../abstractions/IListAllLockRecordsUseCase";
+import { IRecordLockingModelManager } from "../../types";
+export interface IListAllLockRecordsUseCaseParams {
+    getManager(): Promise<IRecordLockingModelManager>;
+}
+export declare class ListAllLockRecordsUseCase implements IListAllLockRecordsUseCase {
+    private readonly getManager;
+    constructor(params: IListAllLockRecordsUseCaseParams);
+    execute(input: IListAllLockRecordsUseCaseExecuteParams): Promise<IListAllLockRecordsUseCaseExecuteResponse>;
+}

package/useCases/ListAllLockRecordsUseCase/ListAllLockRecordsUseCase.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListAllLockRecordsUseCase = void 0;
+var _convertEntryToLockRecord = require("../../utils/convertEntryToLockRecord");
+var _convertWhereCondition = require("../../utils/convertWhereCondition");
+class ListAllLockRecordsUseCase {
+  constructor(params) {
+    this.getManager = params.getManager;
+  }
+  async execute(input) {
+    try {
+      const manager = await this.getManager();
+      const params = {
+        ...input,
+        where: (0, _convertWhereCondition.convertWhereCondition)(input.where)
+      };
+      const [items, meta] = await manager.listLatest(params);
+      return {
+        items: items.map(_convertEntryToLockRecord.convertEntryToLockRecord),
+        meta
+      };
+    } catch (ex) {
+      throw ex;
+    }
+  }
+}
+exports.ListAllLockRecordsUseCase = ListAllLockRecordsUseCase;
+
+//# sourceMappingURL=ListAllLockRecordsUseCase.js.map

package/useCases/ListAllLockRecordsUseCase/ListAllLockRecordsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_convertEntryToLockRecord","require","_convertWhereCondition","ListAllLockRecordsUseCase","constructor","params","getManager","execute","input","manager","where","convertWhereCondition","items","meta","listLatest","map","convertEntryToLockRecord","ex","exports"],"sources":["ListAllLockRecordsUseCase.ts"],"sourcesContent":["import {\n    IListAllLockRecordsUseCase,\n    IListAllLockRecordsUseCaseExecuteParams,\n    IListAllLockRecordsUseCaseExecuteResponse\n} from \"~/abstractions/IListAllLockRecordsUseCase\";\nimport { IRecordLockingModelManager } from \"~/types\";\nimport { convertEntryToLockRecord } from \"~/utils/convertEntryToLockRecord\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition\";\n\nexport interface IListAllLockRecordsUseCaseParams {\n    getManager(): Promise<IRecordLockingModelManager>;\n}\n\nexport class ListAllLockRecordsUseCase implements IListAllLockRecordsUseCase {\n    private readonly getManager: () => Promise<IRecordLockingModelManager>;\n    public constructor(params: IListAllLockRecordsUseCaseParams) {\n        this.getManager = params.getManager;\n    }\n    public async execute(\n        input: IListAllLockRecordsUseCaseExecuteParams\n    ): Promise<IListAllLockRecordsUseCaseExecuteResponse> {\n        try {\n            const manager = await this.getManager();\n            const params: IListAllLockRecordsUseCaseExecuteParams = {\n                ...input,\n                where: convertWhereCondition(input.where)\n            };\n\n            const [items, meta] = await manager.listLatest(params);\n            return {\n                items: items.map(convertEntryToLockRecord),\n                meta\n            };\n        } catch (ex) {\n            throw ex;\n        }\n    }\n}\n"],"mappings":";;;;;;AAMA,IAAAA,yBAAA,GAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAD,OAAA;AAMO,MAAME,yBAAyB,CAAuC;EAElEC,WAAWA,CAACC,MAAwC,EAAE;IACzD,IAAI,CAACC,UAAU,GAAGD,MAAM,CAACC,UAAU;EACvC;EACA,MAAaC,OAAOA,CAChBC,KAA8C,EACI;IAClD,IAAI;MACA,MAAMC,OAAO,GAAG,MAAM,IAAI,CAACH,UAAU,CAAC,CAAC;MACvC,MAAMD,MAA+C,GAAG;QACpD,GAAGG,KAAK;QACRE,KAAK,EAAE,IAAAC,4CAAqB,EAACH,KAAK,CAACE,KAAK;MAC5C,CAAC;MAED,MAAM,CAACE,KAAK,EAAEC,IAAI,CAAC,GAAG,MAAMJ,OAAO,CAACK,UAAU,CAACT,MAAM,CAAC;MACtD,OAAO;QACHO,KAAK,EAAEA,KAAK,CAACG,GAAG,CAACC,kDAAwB,CAAC;QAC1CH;MACJ,CAAC;IACL,CAAC,CAAC,OAAOI,EAAE,EAAE;MACT,MAAMA,EAAE;IACZ;EACJ;AACJ;AAACC,OAAA,CAAAf,yBAAA,GAAAA,yBAAA","ignoreList":[]}

package/useCases/ListLockRecordsUseCase/ListLockRecordsUseCase.d.ts

@@ -0,0 +1,14 @@
+import { IListLockRecordsUseCase, IListLockRecordsUseCaseExecuteParams, IListLockRecordsUseCaseExecuteResponse } from "../../abstractions/IListLockRecordsUseCase";
+import { IGetIdentity } from "../../types";
+export interface IListLockRecordsUseCaseParams {
+    listAllLockRecordsUseCase: IListLockRecordsUseCase;
+    timeout: number;
+    getIdentity: IGetIdentity;
+}
+export declare class ListLockRecordsUseCase implements IListLockRecordsUseCase {
+    private readonly listAllLockRecordsUseCase;
+    private readonly timeout;
+    private readonly getIdentity;
+    constructor(params: IListLockRecordsUseCaseParams);
+    execute(input: IListLockRecordsUseCaseExecuteParams): Promise<IListLockRecordsUseCaseExecuteResponse>;
+}

package/useCases/ListLockRecordsUseCase/ListLockRecordsUseCase.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListLockRecordsUseCase = void 0;
+class ListLockRecordsUseCase {
+  constructor(params) {
+    this.listAllLockRecordsUseCase = params.listAllLockRecordsUseCase;
+    this.timeout = params.timeout;
+    this.getIdentity = params.getIdentity;
+  }
+  async execute(input) {
+    const identity = this.getIdentity();
+    return this.listAllLockRecordsUseCase.execute({
+      ...input,
+      where: {
+        ...input.where,
+        createdBy_not: identity.id,
+        savedOn_gte: new Date(new Date().getTime() - this.timeout)
+      }
+    });
+  }
+}
+exports.ListLockRecordsUseCase = ListLockRecordsUseCase;
+
+//# sourceMappingURL=ListLockRecordsUseCase.js.map

package/useCases/ListLockRecordsUseCase/ListLockRecordsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ListLockRecordsUseCase","constructor","params","listAllLockRecordsUseCase","timeout","getIdentity","execute","input","identity","where","createdBy_not","id","savedOn_gte","Date","getTime","exports"],"sources":["ListLockRecordsUseCase.ts"],"sourcesContent":["import {\n    IListLockRecordsUseCase,\n    IListLockRecordsUseCaseExecuteParams,\n    IListLockRecordsUseCaseExecuteResponse\n} from \"~/abstractions/IListLockRecordsUseCase\";\nimport { IGetIdentity } from \"~/types\";\n\nexport interface IListLockRecordsUseCaseParams {\n    listAllLockRecordsUseCase: IListLockRecordsUseCase;\n    timeout: number;\n    getIdentity: IGetIdentity;\n}\n\nexport class ListLockRecordsUseCase implements IListLockRecordsUseCase {\n    private readonly listAllLockRecordsUseCase: IListLockRecordsUseCase;\n    private readonly timeout: number;\n    private readonly getIdentity: IGetIdentity;\n\n    public constructor(params: IListLockRecordsUseCaseParams) {\n        this.listAllLockRecordsUseCase = params.listAllLockRecordsUseCase;\n        this.timeout = params.timeout;\n        this.getIdentity = params.getIdentity;\n    }\n    public async execute(\n        input: IListLockRecordsUseCaseExecuteParams\n    ): Promise<IListLockRecordsUseCaseExecuteResponse> {\n        const identity = this.getIdentity();\n        return this.listAllLockRecordsUseCase.execute({\n            ...input,\n            where: {\n                ...input.where,\n                createdBy_not: identity.id,\n                savedOn_gte: new Date(new Date().getTime() - this.timeout)\n            }\n        });\n    }\n}\n"],"mappings":";;;;;;AAaO,MAAMA,sBAAsB,CAAoC;EAK5DC,WAAWA,CAACC,MAAqC,EAAE;IACtD,IAAI,CAACC,yBAAyB,GAAGD,MAAM,CAACC,yBAAyB;IACjE,IAAI,CAACC,OAAO,GAAGF,MAAM,CAACE,OAAO;IAC7B,IAAI,CAACC,WAAW,GAAGH,MAAM,CAACG,WAAW;EACzC;EACA,MAAaC,OAAOA,CAChBC,KAA2C,EACI;IAC/C,MAAMC,QAAQ,GAAG,IAAI,CAACH,WAAW,CAAC,CAAC;IACnC,OAAO,IAAI,CAACF,yBAAyB,CAACG,OAAO,CAAC;MAC1C,GAAGC,KAAK;MACRE,KAAK,EAAE;QACH,GAAGF,KAAK,CAACE,KAAK;QACdC,aAAa,EAAEF,QAAQ,CAACG,EAAE;QAC1BC,WAAW,EAAE,IAAIC,IAAI,CAAC,IAAIA,IAAI,CAAC,CAAC,CAACC,OAAO,CAAC,CAAC,GAAG,IAAI,CAACV,OAAO;MAC7D;IACJ,CAAC,CAAC;EACN;AACJ;AAACW,OAAA,CAAAf,sBAAA,GAAAA,sBAAA","ignoreList":[]}

package/useCases/LockEntryUseCase/LockEntryUseCase.d.ts

@@ -0,0 +1,13 @@
+import { ILockEntryUseCase, ILockEntryUseCaseExecuteParams } from "../../abstractions/ILockEntryUseCase";
+import { IRecordLockingLockRecord, IRecordLockingModelManager } from "../../types";
+import { IIsEntryLockedUseCase } from "../../abstractions/IIsEntryLocked";
+export interface ILockEntryUseCaseParams {
+    isEntryLockedUseCase: IIsEntryLockedUseCase;
+    getManager(): Promise<IRecordLockingModelManager>;
+}
+export declare class LockEntryUseCase implements ILockEntryUseCase {
+    private readonly isEntryLockedUseCase;
+    private readonly getManager;
+    constructor(params: ILockEntryUseCaseParams);
+    execute(params: ILockEntryUseCaseExecuteParams): Promise<IRecordLockingLockRecord>;
+}

package/useCases/LockEntryUseCase/LockEntryUseCase.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LockEntryUseCase = void 0;
+var _error = _interopRequireDefault(require("@webiny/error"));
+var _convertEntryToLockRecord = require("../../utils/convertEntryToLockRecord");
+var _lockRecordDatabaseId = require("../../utils/lockRecordDatabaseId");
+var _handlerGraphql = require("@webiny/handler-graphql");
+class LockEntryUseCase {
+  constructor(params) {
+    this.isEntryLockedUseCase = params.isEntryLockedUseCase;
+    this.getManager = params.getManager;
+  }
+  async execute(params) {
+    let locked = false;
+    try {
+      locked = await this.isEntryLockedUseCase.execute(params);
+    } catch (ex) {
+      if (ex instanceof _handlerGraphql.NotFoundError === false) {
+        throw ex;
+      }
+      locked = false;
+    }
+    if (locked) {
+      throw new _error.default("Entry is already locked for editing.", "ENTRY_ALREADY_LOCKED", {
+        ...params
+      });
+    }
+    try {
+      const manager = await this.getManager();
+      const id = (0, _lockRecordDatabaseId.createLockRecordDatabaseId)(params.id);
+      const entry = await manager.create({
+        id,
+        targetId: params.id,
+        type: params.type,
+        actions: []
+      });
+      return (0, _convertEntryToLockRecord.convertEntryToLockRecord)(entry);
+    } catch (ex) {
+      throw new _error.default(`Could not lock entry: ${ex.message}`, ex.code || "LOCK_ENTRY_ERROR", {
+        ...ex.data
+      });
+    }
+  }
+}
+exports.LockEntryUseCase = LockEntryUseCase;
+
+//# sourceMappingURL=LockEntryUseCase.js.map

package/useCases/LockEntryUseCase/LockEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_error","_interopRequireDefault","require","_convertEntryToLockRecord","_lockRecordDatabaseId","_handlerGraphql","LockEntryUseCase","constructor","params","isEntryLockedUseCase","getManager","execute","locked","ex","NotFoundError","WebinyError","manager","id","createLockRecordDatabaseId","entry","create","targetId","type","actions","convertEntryToLockRecord","message","code","data","exports"],"sources":["LockEntryUseCase.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport {\n    ILockEntryUseCase,\n    ILockEntryUseCaseExecuteParams\n} from \"~/abstractions/ILockEntryUseCase\";\nimport {\n    IRecordLockingLockRecord,\n    IRecordLockingLockRecordValues,\n    IRecordLockingModelManager\n} from \"~/types\";\nimport { IIsEntryLockedUseCase } from \"~/abstractions/IIsEntryLocked\";\nimport { convertEntryToLockRecord } from \"~/utils/convertEntryToLockRecord\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId\";\nimport { NotFoundError } from \"@webiny/handler-graphql\";\n\nexport interface ILockEntryUseCaseParams {\n    isEntryLockedUseCase: IIsEntryLockedUseCase;\n    getManager(): Promise<IRecordLockingModelManager>;\n}\n\nexport class LockEntryUseCase implements ILockEntryUseCase {\n    private readonly isEntryLockedUseCase: IIsEntryLockedUseCase;\n    private readonly getManager: () => Promise<IRecordLockingModelManager>;\n\n    public constructor(params: ILockEntryUseCaseParams) {\n        this.isEntryLockedUseCase = params.isEntryLockedUseCase;\n        this.getManager = params.getManager;\n    }\n\n    public async execute(\n        params: ILockEntryUseCaseExecuteParams\n    ): Promise<IRecordLockingLockRecord> {\n        let locked = false;\n        try {\n            locked = await this.isEntryLockedUseCase.execute(params);\n        } catch (ex) {\n            if (ex instanceof NotFoundError === false) {\n                throw ex;\n            }\n            locked = false;\n        }\n        if (locked) {\n            throw new WebinyError(\"Entry is already locked for editing.\", \"ENTRY_ALREADY_LOCKED\", {\n                ...params\n            });\n        }\n        try {\n            const manager = await this.getManager();\n\n            const id = createLockRecordDatabaseId(params.id);\n            const entry = await manager.create<IRecordLockingLockRecordValues>({\n                id,\n                targetId: params.id,\n                type: params.type,\n                actions: []\n            });\n            return convertEntryToLockRecord(entry);\n        } catch (ex) {\n            throw new WebinyError(\n                `Could not lock entry: ${ex.message}`,\n                ex.code || \"LOCK_ENTRY_ERROR\",\n                {\n                    ...ex.data\n                }\n            );\n        }\n    }\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAWA,IAAAC,yBAAA,GAAAD,OAAA;AACA,IAAAE,qBAAA,GAAAF,OAAA;AACA,IAAAG,eAAA,GAAAH,OAAA;AAOO,MAAMI,gBAAgB,CAA8B;EAIhDC,WAAWA,CAACC,MAA+B,EAAE;IAChD,IAAI,CAACC,oBAAoB,GAAGD,MAAM,CAACC,oBAAoB;IACvD,IAAI,CAACC,UAAU,GAAGF,MAAM,CAACE,UAAU;EACvC;EAEA,MAAaC,OAAOA,CAChBH,MAAsC,EACL;IACjC,IAAII,MAAM,GAAG,KAAK;IAClB,IAAI;MACAA,MAAM,GAAG,MAAM,IAAI,CAACH,oBAAoB,CAACE,OAAO,CAACH,MAAM,CAAC;IAC5D,CAAC,CAAC,OAAOK,EAAE,EAAE;MACT,IAAIA,EAAE,YAAYC,6BAAa,KAAK,KAAK,EAAE;QACvC,MAAMD,EAAE;MACZ;MACAD,MAAM,GAAG,KAAK;IAClB;IACA,IAAIA,MAAM,EAAE;MACR,MAAM,IAAIG,cAAW,CAAC,sCAAsC,EAAE,sBAAsB,EAAE;QAClF,GAAGP;MACP,CAAC,CAAC;IACN;IACA,IAAI;MACA,MAAMQ,OAAO,GAAG,MAAM,IAAI,CAACN,UAAU,CAAC,CAAC;MAEvC,MAAMO,EAAE,GAAG,IAAAC,gDAA0B,EAACV,MAAM,CAACS,EAAE,CAAC;MAChD,MAAME,KAAK,GAAG,MAAMH,OAAO,CAACI,MAAM,CAAiC;QAC/DH,EAAE;QACFI,QAAQ,EAAEb,MAAM,CAACS,EAAE;QACnBK,IAAI,EAAEd,MAAM,CAACc,IAAI;QACjBC,OAAO,EAAE;MACb,CAAC,CAAC;MACF,OAAO,IAAAC,kDAAwB,EAACL,KAAK,CAAC;IAC1C,CAAC,CAAC,OAAON,EAAE,EAAE;MACT,MAAM,IAAIE,cAAW,CAChB,yBAAwBF,EAAE,CAACY,OAAQ,EAAC,EACrCZ,EAAE,CAACa,IAAI,IAAI,kBAAkB,EAC7B;QACI,GAAGb,EAAE,CAACc;MACV,CACJ,CAAC;IACL;EACJ;AACJ;AAACC,OAAA,CAAAtB,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/useCases/UnlockEntryUseCase/UnlockEntryUseCase.d.ts

@@ -0,0 +1,20 @@
+import { IUnlockEntryUseCase, IUnlockEntryUseCaseExecuteParams } from "../../abstractions/IUnlockEntryUseCase";
+import { IGetIdentity, IHasFullAccessCallable, IRecordLockingLockRecord, IRecordLockingModelManager } from "../../types";
+import { IGetLockRecordUseCase } from "../../abstractions/IGetLockRecordUseCase";
+import { IKickOutCurrentUserUseCase } from "../../abstractions/IKickOutCurrentUserUseCase";
+export interface IUnlockEntryUseCaseParams {
+    readonly getLockRecordUseCase: IGetLockRecordUseCase;
+    readonly kickOutCurrentUserUseCase: IKickOutCurrentUserUseCase;
+    getManager(): Promise<IRecordLockingModelManager>;
+    getIdentity: IGetIdentity;
+    hasFullAccess: IHasFullAccessCallable;
+}
+export declare class UnlockEntryUseCase implements IUnlockEntryUseCase {
+    private readonly getLockRecordUseCase;
+    private readonly kickOutCurrentUserUseCase;
+    private readonly getManager;
+    private readonly getIdentity;
+    private readonly hasFullAccess;
+    constructor(params: IUnlockEntryUseCaseParams);
+    execute(params: IUnlockEntryUseCaseExecuteParams): Promise<IRecordLockingLockRecord>;
+}

package/useCases/UnlockEntryUseCase/UnlockEntryUseCase.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnlockEntryUseCase = void 0;
+var _error = _interopRequireDefault(require("@webiny/error"));
+var _lockRecordDatabaseId = require("../../utils/lockRecordDatabaseId");
+var _validateSameIdentity = require("../../utils/validateSameIdentity");
+var _apiSecurity = require("@webiny/api-security");
+class UnlockEntryUseCase {
+  constructor(params) {
+    this.getLockRecordUseCase = params.getLockRecordUseCase;
+    this.kickOutCurrentUserUseCase = params.kickOutCurrentUserUseCase;
+    this.getManager = params.getManager;
+    this.getIdentity = params.getIdentity;
+    this.hasFullAccess = params.hasFullAccess;
+  }
+  async execute(params) {
+    const record = await this.getLockRecordUseCase.execute(params);
+    if (!record) {
+      throw new _error.default("Lock Record not found.", "LOCK_RECORD_NOT_FOUND", {
+        ...params
+      });
+    }
+
+    /**
+     * We need to validate that the user executing unlock is the same user that locked the entry.
+     * In case it is not the same user, there is a possibility that it is a user which has full access,
+     * and at that point, we allow unlocking, but we also need to message the user who locked the entry.
+     *
+     */
+    let kickOutCurrentUser = false;
+    try {
+      (0, _validateSameIdentity.validateSameIdentity)({
+        getIdentity: this.getIdentity,
+        target: record.lockedBy
+      });
+    } catch (ex) {
+      if (!params.force) {
+        throw ex;
+      }
+      const hasFullAccess = await this.hasFullAccess();
+      if (ex instanceof _apiSecurity.NotAuthorizedError === false || !hasFullAccess) {
+        throw ex;
+      }
+      kickOutCurrentUser = true;
+    }
+    try {
+      const manager = await this.getManager();
+      await manager.delete((0, _lockRecordDatabaseId.createLockRecordDatabaseId)(params.id));
+      if (!kickOutCurrentUser) {
+        return record;
+      }
+      await this.kickOutCurrentUserUseCase.execute(record);
+      return record;
+    } catch (ex) {
+      throw new _error.default(`Could not unlock entry: ${ex.message}`, ex.code || "UNLOCK_ENTRY_ERROR", {
+        ...ex.data
+      });
+    }
+  }
+}
+exports.UnlockEntryUseCase = UnlockEntryUseCase;
+
+//# sourceMappingURL=UnlockEntryUseCase.js.map

package/useCases/UnlockEntryUseCase/UnlockEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_error","_interopRequireDefault","require","_lockRecordDatabaseId","_validateSameIdentity","_apiSecurity","UnlockEntryUseCase","constructor","params","getLockRecordUseCase","kickOutCurrentUserUseCase","getManager","getIdentity","hasFullAccess","execute","record","WebinyError","kickOutCurrentUser","validateSameIdentity","target","lockedBy","ex","force","NotAuthorizedError","manager","delete","createLockRecordDatabaseId","id","message","code","data","exports"],"sources":["UnlockEntryUseCase.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport {\n    IUnlockEntryUseCase,\n    IUnlockEntryUseCaseExecuteParams\n} from \"~/abstractions/IUnlockEntryUseCase\";\nimport {\n    IGetIdentity,\n    IHasFullAccessCallable,\n    IRecordLockingLockRecord,\n    IRecordLockingModelManager\n} from \"~/types\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId\";\nimport { IGetLockRecordUseCase } from \"~/abstractions/IGetLockRecordUseCase\";\nimport { validateSameIdentity } from \"~/utils/validateSameIdentity\";\nimport { NotAuthorizedError } from \"@webiny/api-security\";\nimport { IKickOutCurrentUserUseCase } from \"~/abstractions/IKickOutCurrentUserUseCase\";\n\nexport interface IUnlockEntryUseCaseParams {\n    readonly getLockRecordUseCase: IGetLockRecordUseCase;\n    readonly kickOutCurrentUserUseCase: IKickOutCurrentUserUseCase;\n    getManager(): Promise<IRecordLockingModelManager>;\n    getIdentity: IGetIdentity;\n    hasFullAccess: IHasFullAccessCallable;\n}\n\nexport class UnlockEntryUseCase implements IUnlockEntryUseCase {\n    private readonly getLockRecordUseCase: IGetLockRecordUseCase;\n    private readonly kickOutCurrentUserUseCase: IKickOutCurrentUserUseCase;\n    private readonly getManager: () => Promise<IRecordLockingModelManager>;\n    private readonly getIdentity: IGetIdentity;\n    private readonly hasFullAccess: IHasFullAccessCallable;\n\n    public constructor(params: IUnlockEntryUseCaseParams) {\n        this.getLockRecordUseCase = params.getLockRecordUseCase;\n        this.kickOutCurrentUserUseCase = params.kickOutCurrentUserUseCase;\n        this.getManager = params.getManager;\n        this.getIdentity = params.getIdentity;\n        this.hasFullAccess = params.hasFullAccess;\n    }\n\n    public async execute(\n        params: IUnlockEntryUseCaseExecuteParams\n    ): Promise<IRecordLockingLockRecord> {\n        const record = await this.getLockRecordUseCase.execute(params);\n        if (!record) {\n            throw new WebinyError(\"Lock Record not found.\", \"LOCK_RECORD_NOT_FOUND\", {\n                ...params\n            });\n        }\n\n        /**\n         * We need to validate that the user executing unlock is the same user that locked the entry.\n         * In case it is not the same user, there is a possibility that it is a user which has full access,\n         * and at that point, we allow unlocking, but we also need to message the user who locked the entry.\n         *\n         */\n        let kickOutCurrentUser = false;\n        try {\n            validateSameIdentity({\n                getIdentity: this.getIdentity,\n                target: record.lockedBy\n            });\n        } catch (ex) {\n            if (!params.force) {\n                throw ex;\n            }\n            const hasFullAccess = await this.hasFullAccess();\n            if (ex instanceof NotAuthorizedError === false || !hasFullAccess) {\n                throw ex;\n            }\n\n            kickOutCurrentUser = true;\n        }\n\n        try {\n            const manager = await this.getManager();\n            await manager.delete(createLockRecordDatabaseId(params.id));\n\n            if (!kickOutCurrentUser) {\n                return record;\n            }\n            await this.kickOutCurrentUserUseCase.execute(record);\n            return record;\n        } catch (ex) {\n            throw new WebinyError(\n                `Could not unlock entry: ${ex.message}`,\n                ex.code || \"UNLOCK_ENTRY_ERROR\",\n                {\n                    ...ex.data\n                }\n            );\n        }\n    }\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAWA,IAAAC,qBAAA,GAAAD,OAAA;AAEA,IAAAE,qBAAA,GAAAF,OAAA;AACA,IAAAG,YAAA,GAAAH,OAAA;AAWO,MAAMI,kBAAkB,CAAgC;EAOpDC,WAAWA,CAACC,MAAiC,EAAE;IAClD,IAAI,CAACC,oBAAoB,GAAGD,MAAM,CAACC,oBAAoB;IACvD,IAAI,CAACC,yBAAyB,GAAGF,MAAM,CAACE,yBAAyB;IACjE,IAAI,CAACC,UAAU,GAAGH,MAAM,CAACG,UAAU;IACnC,IAAI,CAACC,WAAW,GAAGJ,MAAM,CAACI,WAAW;IACrC,IAAI,CAACC,aAAa,GAAGL,MAAM,CAACK,aAAa;EAC7C;EAEA,MAAaC,OAAOA,CAChBN,MAAwC,EACP;IACjC,MAAMO,MAAM,GAAG,MAAM,IAAI,CAACN,oBAAoB,CAACK,OAAO,CAACN,MAAM,CAAC;IAC9D,IAAI,CAACO,MAAM,EAAE;MACT,MAAM,IAAIC,cAAW,CAAC,wBAAwB,EAAE,uBAAuB,EAAE;QACrE,GAAGR;MACP,CAAC,CAAC;IACN;;IAEA;AACR;AACA;AACA;AACA;AACA;IACQ,IAAIS,kBAAkB,GAAG,KAAK;IAC9B,IAAI;MACA,IAAAC,0CAAoB,EAAC;QACjBN,WAAW,EAAE,IAAI,CAACA,WAAW;QAC7BO,MAAM,EAAEJ,MAAM,CAACK;MACnB,CAAC,CAAC;IACN,CAAC,CAAC,OAAOC,EAAE,EAAE;MACT,IAAI,CAACb,MAAM,CAACc,KAAK,EAAE;QACf,MAAMD,EAAE;MACZ;MACA,MAAMR,aAAa,GAAG,MAAM,IAAI,CAACA,aAAa,CAAC,CAAC;MAChD,IAAIQ,EAAE,YAAYE,+BAAkB,KAAK,KAAK,IAAI,CAACV,aAAa,EAAE;QAC9D,MAAMQ,EAAE;MACZ;MAEAJ,kBAAkB,GAAG,IAAI;IAC7B;IAEA,IAAI;MACA,MAAMO,OAAO,GAAG,MAAM,IAAI,CAACb,UAAU,CAAC,CAAC;MACvC,MAAMa,OAAO,CAACC,MAAM,CAAC,IAAAC,gDAA0B,EAAClB,MAAM,CAACmB,EAAE,CAAC,CAAC;MAE3D,IAAI,CAACV,kBAAkB,EAAE;QACrB,OAAOF,MAAM;MACjB;MACA,MAAM,IAAI,CAACL,yBAAyB,CAACI,OAAO,CAACC,MAAM,CAAC;MACpD,OAAOA,MAAM;IACjB,CAAC,CAAC,OAAOM,EAAE,EAAE;MACT,MAAM,IAAIL,cAAW,CAChB,2BAA0BK,EAAE,CAACO,OAAQ,EAAC,EACvCP,EAAE,CAACQ,IAAI,IAAI,oBAAoB,EAC/B;QACI,GAAGR,EAAE,CAACS;MACV,CACJ,CAAC;IACL;EACJ;AACJ;AAACC,OAAA,CAAAzB,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/useCases/UnlockRequestUseCase/UnlockEntryRequestUseCase.d.ts

@@ -0,0 +1,15 @@
+import { IUnlockEntryRequestUseCase, IUnlockEntryRequestUseCaseExecuteParams } from "../../abstractions/IUnlockEntryRequestUseCase";
+import { IGetIdentity, IRecordLockingLockRecord, IRecordLockingModelManager } from "../../types";
+import { IGetLockRecordUseCase } from "../../abstractions/IGetLockRecordUseCase";
+export interface IUnlockEntryRequestUseCaseParams {
+    getLockRecordUseCase: IGetLockRecordUseCase;
+    getManager: () => Promise<IRecordLockingModelManager>;
+    getIdentity: IGetIdentity;
+}
+export declare class UnlockEntryRequestUseCase implements IUnlockEntryRequestUseCase {
+    private readonly getLockRecordUseCase;
+    private readonly getManager;
+    private readonly getIdentity;
+    constructor(params: IUnlockEntryRequestUseCaseParams);
+    execute(params: IUnlockEntryRequestUseCaseExecuteParams): Promise<IRecordLockingLockRecord>;
+}