@webiny/api-record-locking 0.0.0-unstable.06b2ede40f

package/types.d.ts

@@ -0,0 +1,182 @@
+import type { CmsContext, CmsEntryListParams, CmsEntryMeta, CmsIdentity, CmsModel, CmsModelManager } from "@webiny/api-headless-cms/types";
+import { CmsEntry, CmsError } from "@webiny/api-headless-cms/types";
+import type { Topic } from "@webiny/pubsub/types";
+import type { Context as IWebsocketsContext, IWebsocketsContextObject } from "@webiny/api-websockets/types";
+import type { SecurityPermission } from "@webiny/api-security/types";
+export { CmsError, CmsEntry };
+export type IRecordLockingIdentity = CmsIdentity;
+export type IRecordLockingModelManager = CmsModelManager<IRecordLockingLockRecordValues>;
+export type IRecordLockingMeta = CmsEntryMeta;
+export interface IHasRecordLockingAccessCallable {
+    (): Promise<boolean>;
+}
+export interface IGetWebsocketsContextCallable {
+    (): IWebsocketsContextObject;
+}
+export interface IGetIdentity {
+    (): IRecordLockingIdentity;
+}
+export interface IRecordLockingLockRecordValues {
+    targetId: string;
+    type: IRecordLockingLockRecordEntryType;
+    actions?: IRecordLockingLockRecordAction[];
+}
+export declare enum RecordLockingLockRecordActionType {
+    requested = "requested",
+    approved = "approved",
+    denied = "denied"
+}
+export interface IRecordLockingLockRecordRequestedAction {
+    type: RecordLockingLockRecordActionType.requested;
+    message?: string;
+    createdOn: Date;
+    createdBy: IRecordLockingIdentity;
+}
+export interface IRecordLockingLockRecordApprovedAction {
+    type: RecordLockingLockRecordActionType.approved;
+    message?: string;
+    createdOn: Date;
+    createdBy: IRecordLockingIdentity;
+}
+export interface IRecordLockingLockRecordDeniedAction {
+    type: RecordLockingLockRecordActionType.denied;
+    message?: string;
+    createdOn: Date;
+    createdBy: IRecordLockingIdentity;
+}
+export type IRecordLockingLockRecordAction = IRecordLockingLockRecordRequestedAction | IRecordLockingLockRecordApprovedAction | IRecordLockingLockRecordDeniedAction;
+export interface IRecordLockingLockRecordObject {
+    id: string;
+    targetId: string;
+    type: IRecordLockingLockRecordEntryType;
+    lockedBy: IRecordLockingIdentity;
+    lockedOn: Date;
+    updatedOn: Date;
+    expiresOn: Date;
+    actions?: IRecordLockingLockRecordAction[];
+}
+export interface IRecordLockingLockRecord extends IRecordLockingLockRecordObject {
+    toObject(): IRecordLockingLockRecordObject;
+    addAction(action: IRecordLockingLockRecordAction): void;
+    getUnlockRequested(): IRecordLockingLockRecordRequestedAction | undefined;
+    getUnlockApproved(): IRecordLockingLockRecordApprovedAction | undefined;
+    getUnlockDenied(): IRecordLockingLockRecordDeniedAction | undefined;
+    isExpired(): boolean;
+}
+/**
+ * Do not use any special chars other than #, as we use this to create lock record IDs.
+ */
+export type IRecordLockingLockRecordEntryType = string;
+export type IRecordLockingListAllLockRecordsParams = Pick<CmsEntryListParams, "where" | "limit" | "sort" | "after">;
+export type IRecordLockingListLockRecordsParams = IRecordLockingListAllLockRecordsParams;
+export interface IRecordLockingListAllLockRecordsResponse {
+    items: IRecordLockingLockRecord[];
+    meta: IRecordLockingMeta;
+}
+export type IRecordLockingListLockRecordsResponse = IRecordLockingListAllLockRecordsResponse;
+export interface IRecordLockingGetLockRecordParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+}
+export interface IRecordLockingIsLockedParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+}
+export interface IRecordLockingGetLockedEntryLockRecordParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+}
+export interface IRecordLockingLockEntryParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+}
+export interface IRecordLockingUpdateEntryLockParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+}
+export interface IRecordLockingUnlockEntryParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+    force?: boolean;
+}
+export interface IRecordLockingUnlockEntryRequestParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+}
+export interface OnEntryBeforeLockTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+}
+export interface OnEntryAfterLockTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+    record: IRecordLockingLockRecord;
+}
+export interface OnEntryLockErrorTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+    error: CmsError;
+}
+export interface OnEntryBeforeUnlockTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+    getIdentity: IGetIdentity;
+}
+export interface OnEntryAfterUnlockTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+    record: IRecordLockingLockRecord;
+}
+export interface OnEntryUnlockErrorTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+    error: CmsError;
+}
+export interface OnEntryBeforeUnlockRequestTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+}
+export interface OnEntryAfterUnlockRequestTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+    record: IRecordLockingLockRecord;
+}
+export interface OnEntryUnlockRequestErrorTopicParams {
+    id: string;
+    type: IRecordLockingLockRecordEntryType;
+    error: CmsError;
+}
+export interface IRecordLocking {
+    /**
+     * In milliseconds.
+     */
+    getTimeout: () => number;
+    onEntryBeforeLock: Topic<OnEntryBeforeLockTopicParams>;
+    onEntryAfterLock: Topic<OnEntryAfterLockTopicParams>;
+    onEntryLockError: Topic<OnEntryLockErrorTopicParams>;
+    onEntryBeforeUnlock: Topic<OnEntryBeforeUnlockTopicParams>;
+    onEntryAfterUnlock: Topic<OnEntryAfterUnlockTopicParams>;
+    onEntryUnlockError: Topic<OnEntryUnlockErrorTopicParams>;
+    onEntryBeforeUnlockRequest: Topic<OnEntryBeforeUnlockRequestTopicParams>;
+    onEntryAfterUnlockRequest: Topic<OnEntryAfterUnlockRequestTopicParams>;
+    onEntryUnlockRequestError: Topic<OnEntryUnlockRequestErrorTopicParams>;
+    getModel(): Promise<CmsModel>;
+    listAllLockRecords(params?: IRecordLockingListAllLockRecordsParams): Promise<IRecordLockingListAllLockRecordsResponse>;
+    /**
+     * Same call as listAllLockRecords, except this one will filter out records with expired lock.
+     */
+    listLockRecords(params?: IRecordLockingListLockRecordsParams): Promise<IRecordLockingListLockRecordsResponse>;
+    getLockRecord(params: IRecordLockingGetLockRecordParams): Promise<IRecordLockingLockRecord | null>;
+    isEntryLocked(params: IRecordLockingIsLockedParams): Promise<boolean>;
+    getLockedEntryLockRecord(params: IRecordLockingGetLockedEntryLockRecordParams): Promise<IRecordLockingLockRecord | null>;
+    lockEntry(params: IRecordLockingLockEntryParams): Promise<IRecordLockingLockRecord>;
+    updateEntryLock(params: IRecordLockingUpdateEntryLockParams): Promise<IRecordLockingLockRecord>;
+    unlockEntry(params: IRecordLockingUnlockEntryParams): Promise<IRecordLockingLockRecord>;
+    unlockEntryRequest(params: IRecordLockingUnlockEntryRequestParams): Promise<IRecordLockingLockRecord>;
+}
+export interface Context extends CmsContext, IWebsocketsContext {
+    recordLocking: IRecordLocking;
+}
+export interface RecordLockingSecurityPermission extends SecurityPermission {
+    canForceUnlock?: string;
+}

package/types.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CmsEntry", {
+  enumerable: true,
+  get: function () {
+    return _types.CmsEntry;
+  }
+});
+Object.defineProperty(exports, "CmsError", {
+  enumerable: true,
+  get: function () {
+    return _types.CmsError;
+  }
+});
+exports.RecordLockingLockRecordActionType = void 0;
+var _types = require("@webiny/api-headless-cms/types");
+let RecordLockingLockRecordActionType = exports.RecordLockingLockRecordActionType = /*#__PURE__*/function (RecordLockingLockRecordActionType) {
+  RecordLockingLockRecordActionType["requested"] = "requested";
+  RecordLockingLockRecordActionType["approved"] = "approved";
+  RecordLockingLockRecordActionType["denied"] = "denied";
+  return RecordLockingLockRecordActionType;
+}({});
+/**
+ * Do not use any special chars other than #, as we use this to create lock record IDs.
+ */
+
+//# sourceMappingURL=types.js.map

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_types","require","RecordLockingLockRecordActionType","exports"],"sources":["types.ts"],"sourcesContent":["import type {\n    CmsContext,\n    CmsEntryListParams,\n    CmsEntryMeta,\n    CmsIdentity,\n    CmsModel,\n    CmsModelManager\n} from \"@webiny/api-headless-cms/types\";\nimport { CmsEntry, CmsError } from \"@webiny/api-headless-cms/types\";\nimport type { Topic } from \"@webiny/pubsub/types\";\nimport type {\n    Context as IWebsocketsContext,\n    IWebsocketsContextObject\n} from \"@webiny/api-websockets/types\";\nimport type { SecurityPermission } from \"@webiny/api-security/types\";\n\nexport { CmsError, CmsEntry };\n\nexport type IRecordLockingIdentity = CmsIdentity;\n\nexport type IRecordLockingModelManager = CmsModelManager<IRecordLockingLockRecordValues>;\n\nexport type IRecordLockingMeta = CmsEntryMeta;\n\nexport interface IHasRecordLockingAccessCallable {\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 RecordLockingLockRecordActionType {\n    requested = \"requested\",\n    approved = \"approved\",\n    denied = \"denied\"\n}\n\nexport interface IRecordLockingLockRecordRequestedAction {\n    type: RecordLockingLockRecordActionType.requested;\n    message?: string;\n    createdOn: Date;\n    createdBy: IRecordLockingIdentity;\n}\n\nexport interface IRecordLockingLockRecordApprovedAction {\n    type: RecordLockingLockRecordActionType.approved;\n    message?: string;\n    createdOn: Date;\n    createdBy: IRecordLockingIdentity;\n}\n\nexport interface IRecordLockingLockRecordDeniedAction {\n    type: RecordLockingLockRecordActionType.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    isExpired(): boolean;\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    /**\n     * In milliseconds.\n     */\n    getTimeout: () => number;\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\nexport interface RecordLockingSecurityPermission extends SecurityPermission {\n    canForceUnlock?: string;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAQA,IAAAA,MAAA,GAAAC,OAAA;AAAoE,IAiCxDC,iCAAiC,GAAAC,OAAA,CAAAD,iCAAA,0BAAjCA,iCAAiC;EAAjCA,iCAAiC;EAAjCA,iCAAiC;EAAjCA,iCAAiC;EAAA,OAAjCA,iCAAiC;AAAA;AAoD7C;AACA;AACA","ignoreList":[]}

package/useCases/GetLockRecord/GetLockRecordUseCase.d.ts

@@ -0,0 +1,16 @@
+import type { IGetLockRecordUseCase, IGetLockRecordUseCaseExecuteParams } from "../../abstractions/IGetLockRecordUseCase";
+import type { IRecordLockingLockRecord, IRecordLockingModelManager } from "../../types";
+import type { ConvertEntryToLockRecordCb } from "../types";
+import type { Security } from "@webiny/api-security/types";
+export interface IGetLockRecordUseCaseParams {
+    getManager(): Promise<IRecordLockingModelManager>;
+    getSecurity(): Pick<Security, "withoutAuthorization">;
+    convert: ConvertEntryToLockRecordCb;
+}
+export declare class GetLockRecordUseCase implements IGetLockRecordUseCase {
+    private readonly getManager;
+    private readonly getSecurity;
+    private readonly convert;
+    constructor(params: IGetLockRecordUseCaseParams);
+    execute(input: IGetLockRecordUseCaseExecuteParams): Promise<IRecordLockingLockRecord | null>;
+}

package/useCases/GetLockRecord/GetLockRecordUseCase.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GetLockRecordUseCase = void 0;
+var _handlerGraphql = require("@webiny/handler-graphql");
+var _lockRecordDatabaseId = require("../../utils/lockRecordDatabaseId");
+var _utils = require("@webiny/utils");
+class GetLockRecordUseCase {
+  constructor(params) {
+    this.getManager = params.getManager;
+    this.getSecurity = params.getSecurity;
+    this.convert = params.convert;
+  }
+  async execute(input) {
+    const recordId = (0, _lockRecordDatabaseId.createLockRecordDatabaseId)(input.id);
+    const id = (0, _utils.createIdentifier)({
+      id: recordId,
+      version: 1
+    });
+    const security = this.getSecurity();
+    try {
+      const manager = await this.getManager();
+      return await security.withoutAuthorization(async () => {
+        const result = await manager.get(id);
+        return this.convert(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","_lockRecordDatabaseId","_utils","GetLockRecordUseCase","constructor","params","getManager","getSecurity","convert","execute","input","recordId","createLockRecordDatabaseId","id","createIdentifier","version","security","manager","withoutAuthorization","result","get","ex","NotFoundError","exports"],"sources":["GetLockRecordUseCase.ts"],"sourcesContent":["import type {\n    IGetLockRecordUseCase,\n    IGetLockRecordUseCaseExecuteParams\n} from \"~/abstractions/IGetLockRecordUseCase\";\nimport type { IRecordLockingLockRecord, IRecordLockingModelManager } from \"~/types\";\nimport { NotFoundError } from \"@webiny/handler-graphql\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport type { ConvertEntryToLockRecordCb } from \"~/useCases/types\";\nimport type { Security } from \"@webiny/api-security/types\";\n\nexport interface IGetLockRecordUseCaseParams {\n    getManager(): Promise<IRecordLockingModelManager>;\n    getSecurity(): Pick<Security, \"withoutAuthorization\">;\n    convert: ConvertEntryToLockRecordCb;\n}\n\nexport class GetLockRecordUseCase implements IGetLockRecordUseCase {\n    private readonly getManager: IGetLockRecordUseCaseParams[\"getManager\"];\n    private readonly getSecurity: IGetLockRecordUseCaseParams[\"getSecurity\"];\n    private readonly convert: ConvertEntryToLockRecordCb;\n\n    public constructor(params: IGetLockRecordUseCaseParams) {\n        this.getManager = params.getManager;\n        this.getSecurity = params.getSecurity;\n        this.convert = params.convert;\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        const security = this.getSecurity();\n        try {\n            const manager = await this.getManager();\n            return await security.withoutAuthorization(async () => {\n                const result = await manager.get(id);\n                return this.convert(result);\n            });\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,qBAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AAUO,MAAMG,oBAAoB,CAAkC;EAKxDC,WAAWA,CAACC,MAAmC,EAAE;IACpD,IAAI,CAACC,UAAU,GAAGD,MAAM,CAACC,UAAU;IACnC,IAAI,CAACC,WAAW,GAAGF,MAAM,CAACE,WAAW;IACrC,IAAI,CAACC,OAAO,GAAGH,MAAM,CAACG,OAAO;EACjC;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,MAAMC,QAAQ,GAAG,IAAI,CAACT,WAAW,CAAC,CAAC;IACnC,IAAI;MACA,MAAMU,OAAO,GAAG,MAAM,IAAI,CAACX,UAAU,CAAC,CAAC;MACvC,OAAO,MAAMU,QAAQ,CAACE,oBAAoB,CAAC,YAAY;QACnD,MAAMC,MAAM,GAAG,MAAMF,OAAO,CAACG,GAAG,CAACP,EAAE,CAAC;QACpC,OAAO,IAAI,CAACL,OAAO,CAACW,MAAM,CAAC;MAC/B,CAAC,CAAC;IACN,CAAC,CAAC,OAAOE,EAAE,EAAE;MACT,IAAIA,EAAE,YAAYC,6BAAa,EAAE;QAC7B,OAAO,IAAI;MACf;MACA,MAAMD,EAAE;IACZ;EACJ;AACJ;AAACE,OAAA,CAAApB,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/useCases/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.d.ts

@@ -0,0 +1,16 @@
+import type { IGetLockRecordUseCase } from "../../abstractions/IGetLockRecordUseCase";
+import type { IGetIdentity, IRecordLockingLockRecord } from "../../types";
+import type { IGetLockedEntryLockRecordUseCase, IGetLockedEntryLockRecordUseCaseExecuteParams } from "../../abstractions/IGetLockedEntryLockRecordUseCase";
+export interface IGetLockedEntryLockRecordUseCaseParams {
+    getLockRecordUseCase: IGetLockRecordUseCase;
+    getIdentity: IGetIdentity;
+}
+/**
+ * This use case is used to get a lock record for an entry - and the entry is still locked by someone other than the current user.
+ */
+export declare class GetLockedEntryLockRecordUseCase implements IGetLockedEntryLockRecordUseCase {
+    private readonly getLockRecordUseCase;
+    private readonly getIdentity;
+    constructor(params: IGetLockedEntryLockRecordUseCaseParams);
+    execute(params: IGetLockedEntryLockRecordUseCaseExecuteParams): Promise<IRecordLockingLockRecord | null>;
+}

package/useCases/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GetLockedEntryLockRecordUseCase = void 0;
+/**
+ * This use case is used to get a lock record for an entry - and the entry is still locked by someone other than the current user.
+ */
+class GetLockedEntryLockRecordUseCase {
+  constructor(params) {
+    this.getLockRecordUseCase = params.getLockRecordUseCase;
+    this.getIdentity = params.getIdentity;
+  }
+  async execute(params) {
+    const result = await this.getLockRecordUseCase.execute(params);
+    if (!result?.lockedBy?.id || result.isExpired()) {
+      return null;
+    }
+    const identity = this.getIdentity();
+    if (identity.id === result.lockedBy.id) {
+      return null;
+    }
+    return result;
+  }
+}
+exports.GetLockedEntryLockRecordUseCase = GetLockedEntryLockRecordUseCase;
+
+//# sourceMappingURL=GetLockedEntryLockRecordUseCase.js.map

package/useCases/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetLockedEntryLockRecordUseCase","constructor","params","getLockRecordUseCase","getIdentity","execute","result","lockedBy","id","isExpired","identity","exports"],"sources":["GetLockedEntryLockRecordUseCase.ts"],"sourcesContent":["import type { IGetLockRecordUseCase } from \"~/abstractions/IGetLockRecordUseCase\";\nimport type { IGetIdentity, IRecordLockingLockRecord } from \"~/types\";\nimport type {\n    IGetLockedEntryLockRecordUseCase,\n    IGetLockedEntryLockRecordUseCaseExecuteParams\n} from \"~/abstractions/IGetLockedEntryLockRecordUseCase\";\n\nexport interface IGetLockedEntryLockRecordUseCaseParams {\n    getLockRecordUseCase: IGetLockRecordUseCase;\n    getIdentity: IGetIdentity;\n}\n\n/**\n * This use case is used to get a lock record for an entry - and the entry is still locked by someone other than the current user.\n */\nexport class GetLockedEntryLockRecordUseCase implements IGetLockedEntryLockRecordUseCase {\n    private readonly getLockRecordUseCase: IGetLockRecordUseCase;\n    private readonly getIdentity: IGetIdentity;\n\n    public constructor(params: IGetLockedEntryLockRecordUseCaseParams) {\n        this.getLockRecordUseCase = params.getLockRecordUseCase;\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?.id || result.isExpired()) {\n            return null;\n        }\n        const identity = this.getIdentity();\n        if (identity.id === result.lockedBy.id) {\n            return null;\n        }\n        return result;\n    }\n}\n"],"mappings":";;;;;;AAYA;AACA;AACA;AACO,MAAMA,+BAA+B,CAA6C;EAI9EC,WAAWA,CAACC,MAA8C,EAAE;IAC/D,IAAI,CAACC,oBAAoB,GAAGD,MAAM,CAACC,oBAAoB;IACvD,IAAI,CAACC,WAAW,GAAGF,MAAM,CAACE,WAAW;EACzC;EAEA,MAAaC,OAAOA,CAChBH,MAAqD,EACb;IACxC,MAAMI,MAAM,GAAG,MAAM,IAAI,CAACH,oBAAoB,CAACE,OAAO,CAACH,MAAM,CAAC;IAC9D,IAAI,CAACI,MAAM,EAAEC,QAAQ,EAAEC,EAAE,IAAIF,MAAM,CAACG,SAAS,CAAC,CAAC,EAAE;MAC7C,OAAO,IAAI;IACf;IACA,MAAMC,QAAQ,GAAG,IAAI,CAACN,WAAW,CAAC,CAAC;IACnC,IAAIM,QAAQ,CAACF,EAAE,KAAKF,MAAM,CAACC,QAAQ,CAACC,EAAE,EAAE;MACpC,OAAO,IAAI;IACf;IACA,OAAOF,MAAM;EACjB;AACJ;AAACK,OAAA,CAAAX,+BAAA,GAAAA,+BAAA","ignoreList":[]}

package/useCases/IsEntryLocked/IsEntryLockedUseCase.d.ts

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

package/useCases/IsEntryLocked/IsEntryLockedUseCase.js

@@ -0,0 +1,31 @@
+"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.getIdentity = params.getIdentity;
+  }
+  async execute(params) {
+    try {
+      const result = await this.getLockRecordUseCase.execute(params);
+      if (!result || result.isExpired()) {
+        return false;
+      }
+      const identity = this.getIdentity();
+      return result.lockedBy.id !== identity.id;
+    } 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","getIdentity","execute","result","isExpired","identity","lockedBy","id","ex","NotFoundError","exports"],"sources":["IsEntryLockedUseCase.ts"],"sourcesContent":["import type {\n    IIsEntryLockedUseCase,\n    IIsEntryLockedUseCaseExecuteParams\n} from \"~/abstractions/IIsEntryLocked\";\nimport type { IGetLockRecordUseCase } from \"~/abstractions/IGetLockRecordUseCase\";\nimport { NotFoundError } from \"@webiny/handler-graphql\";\nimport type { IGetIdentity } from \"~/types\";\n\nexport interface IIsEntryLockedParams {\n    getLockRecordUseCase: IGetLockRecordUseCase;\n    getIdentity: IGetIdentity;\n}\n\nexport class IsEntryLockedUseCase implements IIsEntryLockedUseCase {\n    private readonly getLockRecordUseCase: IGetLockRecordUseCase;\n    private readonly getIdentity: IGetIdentity;\n\n    public constructor(params: IIsEntryLockedParams) {\n        this.getLockRecordUseCase = params.getLockRecordUseCase;\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 || result.isExpired()) {\n                return false;\n            }\n            const identity = this.getIdentity();\n\n            return result.lockedBy.id !== identity.id;\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;AAQO,MAAMC,oBAAoB,CAAkC;EAIxDC,WAAWA,CAACC,MAA4B,EAAE;IAC7C,IAAI,CAACC,oBAAoB,GAAGD,MAAM,CAACC,oBAAoB;IACvD,IAAI,CAACC,WAAW,GAAGF,MAAM,CAACE,WAAW;EACzC;EAEA,MAAaC,OAAOA,CAACH,MAA0C,EAAoB;IAC/E,IAAI;MACA,MAAMI,MAAM,GAAG,MAAM,IAAI,CAACH,oBAAoB,CAACE,OAAO,CAACH,MAAM,CAAC;MAC9D,IAAI,CAACI,MAAM,IAAIA,MAAM,CAACC,SAAS,CAAC,CAAC,EAAE;QAC/B,OAAO,KAAK;MAChB;MACA,MAAMC,QAAQ,GAAG,IAAI,CAACJ,WAAW,CAAC,CAAC;MAEnC,OAAOE,MAAM,CAACG,QAAQ,CAACC,EAAE,KAAKF,QAAQ,CAACE,EAAE;IAC7C,CAAC,CAAC,OAAOC,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 type { IKickOutCurrentUserUseCase, IKickOutCurrentUserUseCaseExecuteParams } from "../../abstractions/IKickOutCurrentUserUseCase";
+import type { 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 type {\n    IKickOutCurrentUserUseCase,\n    IKickOutCurrentUserUseCaseExecuteParams\n} from \"~/abstractions/IKickOutCurrentUserUseCase\";\nimport type { 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,EAAE,+BAA+BJ,OAAO,EAAE;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,CACT,kEAAkEb,QAAQ,CAACC,EAAE,+BACjF,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,13 @@
+import type { IListAllLockRecordsUseCase, IListAllLockRecordsUseCaseExecuteParams, IListAllLockRecordsUseCaseExecuteResponse } from "../../abstractions/IListAllLockRecordsUseCase";
+import type { IRecordLockingModelManager } from "../../types";
+import type { ConvertEntryToLockRecordCb } from "../types";
+export interface IListAllLockRecordsUseCaseParams {
+    getManager(): Promise<IRecordLockingModelManager>;
+    convert: ConvertEntryToLockRecordCb;
+}
+export declare class ListAllLockRecordsUseCase implements IListAllLockRecordsUseCase {
+    private readonly getManager;
+    private readonly convert;
+    constructor(params: IListAllLockRecordsUseCaseParams);
+    execute(input: IListAllLockRecordsUseCaseExecuteParams): Promise<IListAllLockRecordsUseCaseExecuteResponse>;
+}

package/useCases/ListAllLockRecordsUseCase/ListAllLockRecordsUseCase.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListAllLockRecordsUseCase = void 0;
+var _convertWhereCondition = require("../../utils/convertWhereCondition");
+class ListAllLockRecordsUseCase {
+  constructor(params) {
+    this.getManager = params.getManager;
+    this.convert = params.convert;
+  }
+  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(item => {
+          return this.convert(item);
+        }),
+        meta
+      };
+    } catch (ex) {
+      throw ex;
+    }
+  }
+}
+exports.ListAllLockRecordsUseCase = ListAllLockRecordsUseCase;
+
+//# sourceMappingURL=ListAllLockRecordsUseCase.js.map

package/useCases/ListAllLockRecordsUseCase/ListAllLockRecordsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_convertWhereCondition","require","ListAllLockRecordsUseCase","constructor","params","getManager","convert","execute","input","manager","where","convertWhereCondition","items","meta","listLatest","map","item","ex","exports"],"sources":["ListAllLockRecordsUseCase.ts"],"sourcesContent":["import type {\n    IListAllLockRecordsUseCase,\n    IListAllLockRecordsUseCaseExecuteParams,\n    IListAllLockRecordsUseCaseExecuteResponse\n} from \"~/abstractions/IListAllLockRecordsUseCase\";\nimport type { IRecordLockingModelManager } from \"~/types\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition\";\nimport type { ConvertEntryToLockRecordCb } from \"~/useCases/types\";\n\nexport interface IListAllLockRecordsUseCaseParams {\n    getManager(): Promise<IRecordLockingModelManager>;\n    convert: ConvertEntryToLockRecordCb;\n}\n\nexport class ListAllLockRecordsUseCase implements IListAllLockRecordsUseCase {\n    private readonly getManager: () => Promise<IRecordLockingModelManager>;\n    private readonly convert: ConvertEntryToLockRecordCb;\n\n    public constructor(params: IListAllLockRecordsUseCaseParams) {\n        this.getManager = params.getManager;\n        this.convert = params.convert;\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(item => {\n                    return this.convert(item);\n                }),\n                meta\n            };\n        } catch (ex) {\n            throw ex;\n        }\n    }\n}\n"],"mappings":";;;;;;AAMA,IAAAA,sBAAA,GAAAC,OAAA;AAQO,MAAMC,yBAAyB,CAAuC;EAIlEC,WAAWA,CAACC,MAAwC,EAAE;IACzD,IAAI,CAACC,UAAU,GAAGD,MAAM,CAACC,UAAU;IACnC,IAAI,CAACC,OAAO,GAAGF,MAAM,CAACE,OAAO;EACjC;EACA,MAAaC,OAAOA,CAChBC,KAA8C,EACI;IAClD,IAAI;MACA,MAAMC,OAAO,GAAG,MAAM,IAAI,CAACJ,UAAU,CAAC,CAAC;MACvC,MAAMD,MAA+C,GAAG;QACpD,GAAGI,KAAK;QACRE,KAAK,EAAE,IAAAC,4CAAqB,EAACH,KAAK,CAACE,KAAK;MAC5C,CAAC;MAED,MAAM,CAACE,KAAK,EAAEC,IAAI,CAAC,GAAG,MAAMJ,OAAO,CAACK,UAAU,CAACV,MAAM,CAAC;MACtD,OAAO;QACHQ,KAAK,EAAEA,KAAK,CAACG,GAAG,CAACC,IAAI,IAAI;UACrB,OAAO,IAAI,CAACV,OAAO,CAACU,IAAI,CAAC;QAC7B,CAAC,CAAC;QACFH;MACJ,CAAC;IACL,CAAC,CAAC,OAAOI,EAAE,EAAE;MACT,MAAMA,EAAE;IACZ;EACJ;AACJ;AAACC,OAAA,CAAAhB,yBAAA,GAAAA,yBAAA","ignoreList":[]}

package/useCases/ListLockRecordsUseCase/ListLockRecordsUseCase.d.ts

@@ -0,0 +1,14 @@
+import type { IListLockRecordsUseCase, IListLockRecordsUseCaseExecuteParams, IListLockRecordsUseCaseExecuteResponse } from "../../abstractions/IListLockRecordsUseCase";
+import type { 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 type {\n    IListLockRecordsUseCase,\n    IListLockRecordsUseCaseExecuteParams,\n    IListLockRecordsUseCaseExecuteResponse\n} from \"~/abstractions/IListLockRecordsUseCase\";\nimport type { 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,21 @@
+import type { ILockEntryUseCase, ILockEntryUseCaseExecuteParams } from "../../abstractions/ILockEntryUseCase";
+import type { IRecordLockingLockRecord, IRecordLockingModelManager } from "../../types";
+import type { IIsEntryLockedUseCase } from "../../abstractions/IIsEntryLocked";
+import type { ConvertEntryToLockRecordCb } from "../types";
+import type { Security, SecurityIdentity } from "@webiny/api-security/types";
+export interface ILockEntryUseCaseParams {
+    isEntryLockedUseCase: IIsEntryLockedUseCase;
+    getManager(): Promise<IRecordLockingModelManager>;
+    getSecurity(): Pick<Security, "withoutAuthorization">;
+    getIdentity(): SecurityIdentity;
+    convert: ConvertEntryToLockRecordCb;
+}
+export declare class LockEntryUseCase implements ILockEntryUseCase {
+    private readonly isEntryLockedUseCase;
+    private readonly getManager;
+    private readonly getSecurity;
+    private readonly getIdentity;
+    private readonly convert;
+    constructor(params: ILockEntryUseCaseParams);
+    execute(params: ILockEntryUseCaseExecuteParams): Promise<IRecordLockingLockRecord>;
+}