@webiny/app-record-locking 0.0.0-unstable.ac6ebf63c6 → 0.0.0-unstable.b6d7105cee

package/RecordLockingModule.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const RecordLockingModule: () => React.JSX.Element;

package/RecordLockingModule.js

@@ -0,0 +1,74 @@
+import react from "react";
+import { observer } from "mobx-react-lite";
+import { useContainer, useRouter } from "@webiny/app";
+import { useWebsockets } from "@webiny/app-websockets";
+import { useDialogs } from "@webiny/app-admin";
+import { OverlayLoader } from "@webiny/admin-ui";
+import { parseIdentifier } from "@webiny/utils";
+import { ContentEntryFormContent } from "@webiny/app-headless-cms/presentation/contentEntries/views/layout/index.js";
+import { RecordLockingPresenter } from "./presentation/entryLocking/abstractions.js";
+import { LockedEntryOverlay } from "./presentation/entryLocking/components/LockedEntryOverlay.js";
+import { RecordLockingCellActionsDecorator } from "./presentation/listLocking/components/LockIndicatorCell.js";
+import { SingleEntryContentDecorator } from "./presentation/entryLocking/SingleEntryContentDecorator.js";
+import { useContentEntryFormPresenter } from "@webiny/app-headless-cms/presentation/contentEntries/form/useContentEntryFormPresenter.js";
+const ContentDecorator = ContentEntryFormContent.createDecorator((Original)=>observer(function(props) {
+        const container = useContainer();
+        const formPresenter = useContentEntryFormPresenter();
+        const websockets = useWebsockets();
+        const router = useRouter();
+        const { showDialog } = useDialogs();
+        const presenter = react.useMemo(()=>container.resolve(RecordLockingPresenter), [
+            container
+        ]);
+        const entry = formPresenter.vm.entry;
+        const model = formPresenter.vm.model;
+        react.useEffect(()=>{
+            if (!entry?.id) return;
+            presenter.init(entry.id, model.modelId);
+            return ()=>presenter.dispose();
+        }, [
+            entry?.id,
+            model.modelId
+        ]);
+        react.useEffect(()=>{
+            if (!entry?.id) return;
+            const { id } = parseIdentifier(entry.id);
+            const sub = websockets.onMessage(`recordLocking.entry.kickOut.${id}`, (incoming)=>presenter.handleKickOut(incoming.data));
+            return ()=>{
+                sub.off();
+            };
+        }, [
+            entry?.id,
+            model.modelId
+        ]);
+        react.useEffect(()=>{
+            if ("kicked-out" !== presenter.vm.status) return;
+            router.unblockTransition();
+            showDialog({
+                title: "Entry was forcefully unlocked!",
+                content: /*#__PURE__*/ react.createElement(react.Fragment, null, "The entry you were editing was forcefully unlocked by", " ", /*#__PURE__*/ react.createElement("strong", null, presenter.vm.lockRecord?.lockedBy?.displayName || "Unknown user"), ". Unfortunately, this means you lost the unsaved changes."),
+                acceptLabel: "Ok",
+                onClose: void 0,
+                cancelLabel: null
+            });
+        }, [
+            presenter.vm.status
+        ]);
+        if (!entry?.id) return /*#__PURE__*/ react.createElement(Original, props);
+        if ("checking" === presenter.vm.status) return /*#__PURE__*/ react.createElement("div", {
+            className: "h-screen w-screen fixed top-0 left-0 z-20"
+        }, /*#__PURE__*/ react.createElement(OverlayLoader, {
+            text: "Checking record status..."
+        }));
+        if ("locked" === presenter.vm.status) return /*#__PURE__*/ react.createElement(LockedEntryOverlay, {
+            vm: presenter.vm,
+            entryTitle: entry.meta?.title,
+            onForceUnlock: ()=>presenter.forceUnlock(),
+            onNavigateBack: ()=>router.goBack()
+        });
+        return /*#__PURE__*/ react.createElement(Original, props);
+    }));
+const RecordLockingModule = ()=>/*#__PURE__*/ react.createElement(react.Fragment, null, /*#__PURE__*/ react.createElement(ContentDecorator, null), /*#__PURE__*/ react.createElement(SingleEntryContentDecorator, null), /*#__PURE__*/ react.createElement(RecordLockingCellActionsDecorator, null));
+export { RecordLockingModule };
+
+//# sourceMappingURL=RecordLockingModule.js.map

package/RecordLockingModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordLockingModule.js","sources":["../src/RecordLockingModule.tsx"],"sourcesContent":["import React from \"react\";\nimport { observer } from \"mobx-react-lite\";\nimport { useContainer, useRouter } from \"@webiny/app\";\nimport { useWebsockets } from \"@webiny/app-websockets\";\nimport { useDialogs } from \"@webiny/app-admin\";\nimport { OverlayLoader } from \"@webiny/admin-ui\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { ContentEntryFormContent } from \"@webiny/app-headless-cms/presentation/contentEntries/views/layout/index.js\";\nimport { RecordLockingPresenter } from \"~/presentation/entryLocking/abstractions.js\";\nimport { LockedEntryOverlay } from \"~/presentation/entryLocking/components/LockedEntryOverlay.js\";\nimport { RecordLockingCellActionsDecorator } from \"~/presentation/listLocking/components/LockIndicatorCell.js\";\nimport { SingleEntryContentDecorator } from \"~/presentation/entryLocking/SingleEntryContentDecorator.js\";\nimport { useContentEntryFormPresenter } from \"@webiny/app-headless-cms/presentation/contentEntries/form/useContentEntryFormPresenter.js\";\nimport type { IKickOutData } from \"~/presentation/entryLocking/abstractions.js\";\nimport type { IncomingGenericData } from \"@webiny/app-websockets\";\n\ninterface KickOutMessage extends IncomingGenericData {\n    data: IKickOutData;\n}\n\nconst ContentDecorator = ContentEntryFormContent.createDecorator(Original => {\n    return observer(function RecordLockingContent(props) {\n        const container = useContainer();\n        const formPresenter = useContentEntryFormPresenter();\n        const websockets = useWebsockets();\n        const router = useRouter();\n        const { showDialog } = useDialogs();\n\n        const presenter = React.useMemo(\n            () => container.resolve(RecordLockingPresenter),\n            [container]\n        );\n\n        const entry = formPresenter.vm.entry;\n        const model = formPresenter.vm.model;\n\n        React.useEffect(() => {\n            if (!entry?.id) {\n                return;\n            }\n            presenter.init(entry.id, model.modelId);\n            return () => presenter.dispose();\n        }, [entry?.id, model.modelId]);\n\n        React.useEffect(() => {\n            if (!entry?.id) {\n                return;\n            }\n            const { id } = parseIdentifier(entry.id);\n            const sub = websockets.onMessage<KickOutMessage>(\n                `recordLocking.entry.kickOut.${id}`,\n                incoming => presenter.handleKickOut(incoming.data)\n            );\n            return () => {\n                sub.off();\n            };\n        }, [entry?.id, model.modelId]);\n\n        React.useEffect(() => {\n            if (presenter.vm.status !== \"kicked-out\") {\n                return;\n            }\n\n            router.unblockTransition();\n            showDialog({\n                title: \"Entry was forcefully unlocked!\",\n                content: (\n                    <>\n                        The entry you were editing was forcefully unlocked by{\" \"}\n                        <strong>\n                            {presenter.vm.lockRecord?.lockedBy?.displayName || \"Unknown user\"}\n                        </strong>\n                        . Unfortunately, this means you lost the unsaved changes.\n                    </>\n                ),\n                acceptLabel: \"Ok\",\n                onClose: undefined,\n                cancelLabel: null\n            });\n        }, [presenter.vm.status]);\n\n        if (!entry?.id) {\n            return <Original {...props} />;\n        }\n\n        if (presenter.vm.status === \"checking\") {\n            return (\n                <div className={\"h-screen w-screen fixed top-0 left-0 z-20\"}>\n                    <OverlayLoader text={\"Checking record status...\"} />\n                </div>\n            );\n        }\n\n        if (presenter.vm.status === \"locked\") {\n            return (\n                <LockedEntryOverlay\n                    vm={presenter.vm}\n                    entryTitle={entry.meta?.title}\n                    onForceUnlock={() => presenter.forceUnlock()}\n                    onNavigateBack={() => router.goBack()}\n                />\n            );\n        }\n\n        return <Original {...props} />;\n    });\n});\n\nexport const RecordLockingModule = () => {\n    return (\n        <>\n            <ContentDecorator />\n            <SingleEntryContentDecorator />\n            <RecordLockingCellActionsDecorator />\n        </>\n    );\n};\n"],"names":["ContentDecorator","ContentEntryFormContent","Original","observer","props","container","useContainer","formPresenter","useContentEntryFormPresenter","websockets","useWebsockets","router","useRouter","showDialog","useDialogs","presenter","React","RecordLockingPresenter","entry","model","id","parseIdentifier","sub","incoming","undefined","OverlayLoader","LockedEntryOverlay","RecordLockingModule","SingleEntryContentDecorator","RecordLockingCellActionsDecorator"],"mappings":";;;;;;;;;;;;;AAoBA,MAAMA,mBAAmBC,wBAAwB,eAAe,CAACC,CAAAA,WACtDC,SAAS,SAA8BC,KAAK;QAC/C,MAAMC,YAAYC;QAClB,MAAMC,gBAAgBC;QACtB,MAAMC,aAAaC;QACnB,MAAMC,SAASC;QACf,MAAM,EAAEC,UAAU,EAAE,GAAGC;QAEvB,MAAMC,YAAYC,MAAAA,OAAa,CAC3B,IAAMX,UAAU,OAAO,CAACY,yBACxB;YAACZ;SAAU;QAGf,MAAMa,QAAQX,cAAc,EAAE,CAAC,KAAK;QACpC,MAAMY,QAAQZ,cAAc,EAAE,CAAC,KAAK;QAEpCS,MAAAA,SAAe,CAAC;YACZ,IAAI,CAACE,OAAO,IACR;YAEJH,UAAU,IAAI,CAACG,MAAM,EAAE,EAAEC,MAAM,OAAO;YACtC,OAAO,IAAMJ,UAAU,OAAO;QAClC,GAAG;YAACG,OAAO;YAAIC,MAAM,OAAO;SAAC;QAE7BH,MAAAA,SAAe,CAAC;YACZ,IAAI,CAACE,OAAO,IACR;YAEJ,MAAM,EAAEE,EAAE,EAAE,GAAGC,gBAAgBH,MAAM,EAAE;YACvC,MAAMI,MAAMb,WAAW,SAAS,CAC5B,CAAC,4BAA4B,EAAEW,IAAI,EACnCG,CAAAA,WAAYR,UAAU,aAAa,CAACQ,SAAS,IAAI;YAErD,OAAO;gBACHD,IAAI,GAAG;YACX;QACJ,GAAG;YAACJ,OAAO;YAAIC,MAAM,OAAO;SAAC;QAE7BH,MAAAA,SAAe,CAAC;YACZ,IAAID,AAAwB,iBAAxBA,UAAU,EAAE,CAAC,MAAM,EACnB;YAGJJ,OAAO,iBAAiB;YACxBE,WAAW;gBACP,OAAO;gBACP,SAAS,WAAT,GACI,0CAAE,yDACwD,mBACtD,oBAAC,gBACIE,UAAU,EAAE,CAAC,UAAU,EAAE,UAAU,eAAe,iBAC9C;gBAIjB,aAAa;gBACb,SAASS;gBACT,aAAa;YACjB;QACJ,GAAG;YAACT,UAAU,EAAE,CAAC,MAAM;SAAC;QAExB,IAAI,CAACG,OAAO,IACR,OAAO,WAAP,GAAO,oBAAChB,UAAaE;QAGzB,IAAIW,AAAwB,eAAxBA,UAAU,EAAE,CAAC,MAAM,EACnB,OAAO,WAAP,GACI,oBAAC;YAAI,WAAW;yBACZ,oBAACU,eAAaA;YAAC,MAAM;;QAKjC,IAAIV,AAAwB,aAAxBA,UAAU,EAAE,CAAC,MAAM,EACnB,OAAO,WAAP,GACI,oBAACW,oBAAkBA;YACf,IAAIX,UAAU,EAAE;YAChB,YAAYG,MAAM,IAAI,EAAE;YACxB,eAAe,IAAMH,UAAU,WAAW;YAC1C,gBAAgB,IAAMJ,OAAO,MAAM;;QAK/C,OAAO,WAAP,GAAO,oBAACT,UAAaE;IACzB;AAGG,MAAMuB,sBAAsB,IACxB,WAAP,GACI,wDACI,oBAAC3B,kBAAgBA,OAAAA,WAAAA,GACjB,oBAAC4B,6BAA2BA,OAAAA,WAAAA,GAC5B,oBAACC,mCAAiCA"}

package/SecurityPermissions.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SecurityPermissions: () => React.JSX.Element;

package/SecurityPermissions.js

@@ -0,0 +1,15 @@
+import react from "react";
+import { AdminConfig } from "@webiny/app-admin";
+import { ReactComponent } from "@webiny/icons/lock.svg";
+import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "./permissions/permissionsSchema.js";
+const { Security: Security } = AdminConfig;
+const SecurityPermissions = ()=>/*#__PURE__*/ react.createElement(AdminConfig, null, /*#__PURE__*/ react.createElement(Security.Permissions, {
+        name: "record-locking",
+        title: "Record Locking",
+        description: "Manage Record Locking permissions.",
+        icon: /*#__PURE__*/ react.createElement(ReactComponent, null),
+        schema: RECORD_LOCKING_PERMISSIONS_SCHEMA
+    }));
+export { SecurityPermissions };
+
+//# sourceMappingURL=SecurityPermissions.js.map

package/SecurityPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityPermissions.js","sources":["../src/SecurityPermissions.tsx"],"sourcesContent":["import React from \"react\";\nimport { AdminConfig } from \"@webiny/app-admin\";\nimport { ReactComponent as LockIcon } from \"@webiny/icons/lock.svg\";\nimport { RECORD_LOCKING_PERMISSIONS_SCHEMA } from \"~/permissions/permissionsSchema.js\";\n\nconst { Security } = AdminConfig;\n\nexport const SecurityPermissions = () => {\n    return (\n        <AdminConfig>\n            <Security.Permissions\n                name=\"record-locking\"\n                title=\"Record Locking\"\n                description=\"Manage Record Locking permissions.\"\n                icon={<LockIcon />}\n                schema={RECORD_LOCKING_PERMISSIONS_SCHEMA}\n            />\n        </AdminConfig>\n    );\n};\n"],"names":["Security","AdminConfig","SecurityPermissions","LockIcon","RECORD_LOCKING_PERMISSIONS_SCHEMA"],"mappings":";;;;AAKA,MAAM,EAAEA,UAAAA,QAAQ,EAAE,GAAGC;AAEd,MAAMC,sBAAsB,IACxB,WAAP,GACI,oBAACD,aAAWA,MAAAA,WAAAA,GACR,oBAACD,SAAS,WAAW;QACjB,MAAK;QACL,OAAM;QACN,aAAY;QACZ,oBAAM,oBAACG,gBAAQA;QACf,QAAQC"}

package/features/acquireLock/AcquireLockGateway.d.ts

@@ -0,0 +1,12 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { AcquireLockGateway as GatewayAbstraction, type IAcquireLockParams } from "./abstractions.js";
+import type { IRecordLockingLockRecord } from "../../types.js";
+declare class AcquireLockGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    execute(params: IAcquireLockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const AcquireLockGateway: typeof AcquireLockGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IAcquireLockGateway>;
+};
+export {};

package/features/acquireLock/AcquireLockGateway.js

@@ -0,0 +1,43 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ERROR_FIELDS, LOCK_RECORD_FIELDS } from "../graphqlFields.js";
+import { AcquireLockGateway } from "./abstractions.js";
+const ACQUIRE_LOCK_MUTATION = `
+    mutation RecordLockingUpdateEntryLock($id: ID!, $type: String!) {
+        recordLocking {
+            updateEntryLock(id: $id, type: $type) {
+                data {
+                    ${LOCK_RECORD_FIELDS}
+                }
+                error {
+                    ${ERROR_FIELDS}
+                }
+            }
+        }
+    }
+`;
+class AcquireLockGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: ACQUIRE_LOCK_MUTATION,
+            variables: {
+                id: params.id,
+                type: params.type
+            }
+        });
+        const { data, error } = response.recordLocking.updateEntryLock;
+        if (!data) throw new Error(error?.message || "Failed to acquire lock");
+        return data;
+    }
+}
+const AcquireLockGateway_AcquireLockGateway = AcquireLockGateway.createImplementation({
+    implementation: AcquireLockGatewayImpl,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { AcquireLockGateway_AcquireLockGateway as AcquireLockGateway };
+
+//# sourceMappingURL=AcquireLockGateway.js.map

package/features/acquireLock/AcquireLockGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/acquireLock/AcquireLockGateway.js","sources":["../../../src/features/acquireLock/AcquireLockGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/abstractions.js\";\nimport { LOCK_RECORD_FIELDS, ERROR_FIELDS } from \"~/features/graphqlFields.js\";\nimport {\n    AcquireLockGateway as GatewayAbstraction,\n    type IAcquireLockParams\n} from \"./abstractions.js\";\nimport type { IRecordLockingError, IRecordLockingLockRecord } from \"~/types.js\";\n\ninterface AcquireLockResponse {\n    recordLocking: {\n        updateEntryLock: {\n            data: IRecordLockingLockRecord | null;\n            error: IRecordLockingError | null;\n        };\n    };\n}\n\nconst ACQUIRE_LOCK_MUTATION = /* GraphQL */ `\n    mutation RecordLockingUpdateEntryLock($id: ID!, $type: String!) {\n        recordLocking {\n            updateEntryLock(id: $id, type: $type) {\n                data {\n                    ${LOCK_RECORD_FIELDS}\n                }\n                error {\n                    ${ERROR_FIELDS}\n                }\n            }\n        }\n    }\n`;\n\nclass AcquireLockGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async execute(params: IAcquireLockParams) {\n        const response = await this.client.execute<AcquireLockResponse>({\n            query: ACQUIRE_LOCK_MUTATION,\n            variables: { id: params.id, type: params.type }\n        });\n\n        const { data, error } = response.recordLocking.updateEntryLock;\n\n        if (!data) {\n            throw new Error(error?.message || \"Failed to acquire lock\");\n        }\n\n        return data;\n    }\n}\n\nexport const AcquireLockGateway = GatewayAbstraction.createImplementation({\n    implementation: AcquireLockGatewayImpl,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["ACQUIRE_LOCK_MUTATION","LOCK_RECORD_FIELDS","ERROR_FIELDS","AcquireLockGatewayImpl","client","params","response","data","error","Error","AcquireLockGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;;AAiBA,MAAMA,wBAAsC,CAAC;;;;;oBAKzB,EAAEC,mBAAmB;;;oBAGrB,EAAEC,aAAa;;;;;AAKnC,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,QAAQC,MAA0B,EAAE;QACtC,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAsB;YAC5D,OAAON;YACP,WAAW;gBAAE,IAAIK,OAAO,EAAE;gBAAE,MAAMA,OAAO,IAAI;YAAC;QAClD;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,aAAa,CAAC,eAAe;QAE9D,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBR;IAChB,cAAc;QAACS;KAAkB;AACrC"}

package/features/acquireLock/AcquireLockUseCase.d.ts

@@ -0,0 +1,10 @@
+import { AcquireLockUseCase as UseCaseAbstraction, AcquireLockGateway, type IAcquireLockParams } from "./abstractions.js";
+declare class AcquireLockUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: AcquireLockGateway.Interface);
+    execute(params: IAcquireLockParams): Promise<import("../../types.js").IRecordLockingLockRecord>;
+}
+export declare const AcquireLockUseCase: typeof AcquireLockUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IAcquireLockUseCase>;
+};
+export {};

package/features/acquireLock/AcquireLockUseCase.js

@@ -0,0 +1,18 @@
+import { AcquireLockGateway, AcquireLockUseCase } from "./abstractions.js";
+class AcquireLockUseCaseImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        return this.gateway.execute(params);
+    }
+}
+const AcquireLockUseCase_AcquireLockUseCase = AcquireLockUseCase.createImplementation({
+    implementation: AcquireLockUseCaseImpl,
+    dependencies: [
+        AcquireLockGateway
+    ]
+});
+export { AcquireLockUseCase_AcquireLockUseCase as AcquireLockUseCase };
+
+//# sourceMappingURL=AcquireLockUseCase.js.map

package/features/acquireLock/AcquireLockUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/acquireLock/AcquireLockUseCase.js","sources":["../../../src/features/acquireLock/AcquireLockUseCase.ts"],"sourcesContent":["import {\n    AcquireLockUseCase as UseCaseAbstraction,\n    AcquireLockGateway,\n    type IAcquireLockParams\n} from \"./abstractions.js\";\n\nclass AcquireLockUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: AcquireLockGateway.Interface) {}\n\n    async execute(params: IAcquireLockParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const AcquireLockUseCase = UseCaseAbstraction.createImplementation({\n    implementation: AcquireLockUseCaseImpl,\n    dependencies: [AcquireLockGateway]\n});\n"],"names":["AcquireLockUseCaseImpl","gateway","params","AcquireLockUseCase","UseCaseAbstraction","AcquireLockGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAAqC,CAAE;aAAvCA,OAAO,GAAPA;IAAwC;IAE5D,MAAM,QAAQC,MAA0B,EAAE;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBJ;IAChB,cAAc;QAACK;KAAmB;AACtC"}

package/features/acquireLock/abstractions.d.ts

@@ -0,0 +1,19 @@
+import type { IRecordLockingLockRecord } from "../../types.js";
+export interface IAcquireLockParams {
+    id: string;
+    type: string;
+}
+export interface IAcquireLockGateway {
+    execute(params: IAcquireLockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const AcquireLockGateway: import("@webiny/di").Abstraction<IAcquireLockGateway>;
+export declare namespace AcquireLockGateway {
+    type Interface = IAcquireLockGateway;
+}
+export interface IAcquireLockUseCase {
+    execute(params: IAcquireLockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const AcquireLockUseCase: import("@webiny/di").Abstraction<IAcquireLockUseCase>;
+export declare namespace AcquireLockUseCase {
+    type Interface = IAcquireLockUseCase;
+}

package/features/acquireLock/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const AcquireLockGateway = createAbstraction("AcquireLockGateway");
+const AcquireLockUseCase = createAbstraction("AcquireLockUseCase");
+export { AcquireLockGateway, AcquireLockUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/acquireLock/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/acquireLock/abstractions.js","sources":["../../../src/features/acquireLock/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { IRecordLockingLockRecord } from \"~/types.js\";\n\nexport interface IAcquireLockParams {\n    id: string;\n    type: string;\n}\n\nexport interface IAcquireLockGateway {\n    execute(params: IAcquireLockParams): Promise<IRecordLockingLockRecord>;\n}\n\nexport const AcquireLockGateway = createAbstraction<IAcquireLockGateway>(\"AcquireLockGateway\");\n\nexport namespace AcquireLockGateway {\n    export type Interface = IAcquireLockGateway;\n}\n\nexport interface IAcquireLockUseCase {\n    execute(params: IAcquireLockParams): Promise<IRecordLockingLockRecord>;\n}\n\nexport const AcquireLockUseCase = createAbstraction<IAcquireLockUseCase>(\"AcquireLockUseCase\");\n\nexport namespace AcquireLockUseCase {\n    export type Interface = IAcquireLockUseCase;\n}\n"],"names":["AcquireLockGateway","createAbstraction","AcquireLockUseCase"],"mappings":";AAYO,MAAMA,qBAAqBC,kBAAuC;AAUlE,MAAMC,qBAAqBD,kBAAuC"}

package/features/acquireLock/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const AcquireLockFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").IAcquireLockUseCase;
+}, []>;

package/features/acquireLock/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { AcquireLockUseCase } from "./abstractions.js";
+import { AcquireLockUseCase as external_AcquireLockUseCase_js_AcquireLockUseCase } from "./AcquireLockUseCase.js";
+import { AcquireLockGateway } from "./AcquireLockGateway.js";
+const AcquireLockFeature = createFeature({
+    name: "RecordLocking/AcquireLock",
+    register (container) {
+        container.register(external_AcquireLockUseCase_js_AcquireLockUseCase);
+        container.register(AcquireLockGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(AcquireLockUseCase)
+        };
+    }
+});
+export { AcquireLockFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/acquireLock/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/acquireLock/feature.js","sources":["../../../src/features/acquireLock/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { AcquireLockUseCase as UseCase } from \"./abstractions.js\";\nimport { AcquireLockUseCase } from \"./AcquireLockUseCase.js\";\nimport { AcquireLockGateway } from \"./AcquireLockGateway.js\";\n\nexport const AcquireLockFeature = createFeature({\n    name: \"RecordLocking/AcquireLock\",\n    register(container) {\n        container.register(AcquireLockUseCase);\n        container.register(AcquireLockGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["AcquireLockFeature","createFeature","container","AcquireLockUseCase","AcquireLockGateway","UseCase"],"mappings":";;;;AAKO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,oBAAoB,gBAAgB;IAC3D;IACA,SAAQF,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACG;QAC/B;IACJ;AACJ"}

package/features/checkLockStatus/CheckLockStatusGateway.d.ts

@@ -0,0 +1,12 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { CheckLockStatusGateway as GatewayAbstraction, type ICheckLockStatusParams } from "./abstractions.js";
+import type { IRecordLockingLockRecord } from "../../types.js";
+declare class CheckLockStatusGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    execute(params: ICheckLockStatusParams): Promise<IRecordLockingLockRecord | null>;
+}
+export declare const CheckLockStatusGateway: typeof CheckLockStatusGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICheckLockStatusGateway>;
+};
+export {};

package/features/checkLockStatus/CheckLockStatusGateway.js

@@ -0,0 +1,43 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ERROR_FIELDS, LOCK_RECORD_FIELDS } from "../graphqlFields.js";
+import { CheckLockStatusGateway } from "./abstractions.js";
+const CHECK_LOCK_STATUS_QUERY = `
+    query RecordLockingGetLockedEntryLockRecord($id: ID!, $type: String!) {
+        recordLocking {
+            getLockedEntryLockRecord(id: $id, type: $type) {
+                data {
+                    ${LOCK_RECORD_FIELDS}
+                }
+                error {
+                    ${ERROR_FIELDS}
+                }
+            }
+        }
+    }
+`;
+class CheckLockStatusGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: CHECK_LOCK_STATUS_QUERY,
+            variables: {
+                id: params.id,
+                type: params.type
+            }
+        });
+        const { data, error } = response.recordLocking.getLockedEntryLockRecord;
+        if (error) throw new Error(error.message);
+        return data;
+    }
+}
+const CheckLockStatusGateway_CheckLockStatusGateway = CheckLockStatusGateway.createImplementation({
+    implementation: CheckLockStatusGatewayImpl,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { CheckLockStatusGateway_CheckLockStatusGateway as CheckLockStatusGateway };
+
+//# sourceMappingURL=CheckLockStatusGateway.js.map

package/features/checkLockStatus/CheckLockStatusGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/checkLockStatus/CheckLockStatusGateway.js","sources":["../../../src/features/checkLockStatus/CheckLockStatusGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/abstractions.js\";\nimport { LOCK_RECORD_FIELDS, ERROR_FIELDS } from \"~/features/graphqlFields.js\";\nimport {\n    CheckLockStatusGateway as GatewayAbstraction,\n    type ICheckLockStatusParams\n} from \"./abstractions.js\";\nimport type { IRecordLockingError, IRecordLockingLockRecord } from \"~/types.js\";\n\ninterface CheckLockStatusResponse {\n    recordLocking: {\n        getLockedEntryLockRecord: {\n            data: IRecordLockingLockRecord | null;\n            error: IRecordLockingError | null;\n        };\n    };\n}\n\nconst CHECK_LOCK_STATUS_QUERY = /* GraphQL */ `\n    query RecordLockingGetLockedEntryLockRecord($id: ID!, $type: String!) {\n        recordLocking {\n            getLockedEntryLockRecord(id: $id, type: $type) {\n                data {\n                    ${LOCK_RECORD_FIELDS}\n                }\n                error {\n                    ${ERROR_FIELDS}\n                }\n            }\n        }\n    }\n`;\n\nclass CheckLockStatusGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async execute(params: ICheckLockStatusParams) {\n        const response = await this.client.execute<CheckLockStatusResponse>({\n            query: CHECK_LOCK_STATUS_QUERY,\n            variables: { id: params.id, type: params.type }\n        });\n\n        const { data, error } = response.recordLocking.getLockedEntryLockRecord;\n\n        if (error) {\n            throw new Error(error.message);\n        }\n\n        return data;\n    }\n}\n\nexport const CheckLockStatusGateway = GatewayAbstraction.createImplementation({\n    implementation: CheckLockStatusGatewayImpl,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["CHECK_LOCK_STATUS_QUERY","LOCK_RECORD_FIELDS","ERROR_FIELDS","CheckLockStatusGatewayImpl","client","params","response","data","error","Error","CheckLockStatusGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;;AAiBA,MAAMA,0BAAwC,CAAC;;;;;oBAK3B,EAAEC,mBAAmB;;;oBAGrB,EAAEC,aAAa;;;;;AAKnC,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,QAAQC,MAA8B,EAAE;QAC1C,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA0B;YAChE,OAAON;YACP,WAAW;gBAAE,IAAIK,OAAO,EAAE;gBAAE,MAAMA,OAAO,IAAI;YAAC;QAClD;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,aAAa,CAAC,wBAAwB;QAEvE,IAAIE,OACA,MAAM,IAAIC,MAAMD,MAAM,OAAO;QAGjC,OAAOD;IACX;AACJ;AAEO,MAAMG,gDAAyBC,uBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBR;IAChB,cAAc;QAACS;KAAkB;AACrC"}

package/features/checkLockStatus/CheckLockStatusUseCase.d.ts

@@ -0,0 +1,10 @@
+import { CheckLockStatusUseCase as UseCaseAbstraction, CheckLockStatusGateway, type ICheckLockStatusParams } from "./abstractions.js";
+declare class CheckLockStatusUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: CheckLockStatusGateway.Interface);
+    execute(params: ICheckLockStatusParams): Promise<import("../../types.js").IRecordLockingLockRecord | null>;
+}
+export declare const CheckLockStatusUseCase: typeof CheckLockStatusUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICheckLockStatusUseCase>;
+};
+export {};

package/features/checkLockStatus/CheckLockStatusUseCase.js

@@ -0,0 +1,18 @@
+import { CheckLockStatusGateway, CheckLockStatusUseCase } from "./abstractions.js";
+class CheckLockStatusUseCaseImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        return this.gateway.execute(params);
+    }
+}
+const CheckLockStatusUseCase_CheckLockStatusUseCase = CheckLockStatusUseCase.createImplementation({
+    implementation: CheckLockStatusUseCaseImpl,
+    dependencies: [
+        CheckLockStatusGateway
+    ]
+});
+export { CheckLockStatusUseCase_CheckLockStatusUseCase as CheckLockStatusUseCase };
+
+//# sourceMappingURL=CheckLockStatusUseCase.js.map

package/features/checkLockStatus/CheckLockStatusUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/checkLockStatus/CheckLockStatusUseCase.js","sources":["../../../src/features/checkLockStatus/CheckLockStatusUseCase.ts"],"sourcesContent":["import {\n    CheckLockStatusUseCase as UseCaseAbstraction,\n    CheckLockStatusGateway,\n    type ICheckLockStatusParams\n} from \"./abstractions.js\";\n\nclass CheckLockStatusUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: CheckLockStatusGateway.Interface) {}\n\n    async execute(params: ICheckLockStatusParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const CheckLockStatusUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CheckLockStatusUseCaseImpl,\n    dependencies: [CheckLockStatusGateway]\n});\n"],"names":["CheckLockStatusUseCaseImpl","gateway","params","CheckLockStatusUseCase","UseCaseAbstraction","CheckLockStatusGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAAyC,CAAE;aAA3CA,OAAO,GAAPA;IAA4C;IAEhE,MAAM,QAAQC,MAA8B,EAAE;QAC1C,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,gDAAyBC,uBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBJ;IAChB,cAAc;QAACK;KAAuB;AAC1C"}

package/features/checkLockStatus/abstractions.d.ts

@@ -0,0 +1,19 @@
+import type { IRecordLockingLockRecord } from "../../types.js";
+export interface ICheckLockStatusParams {
+    id: string;
+    type: string;
+}
+export interface ICheckLockStatusGateway {
+    execute(params: ICheckLockStatusParams): Promise<IRecordLockingLockRecord | null>;
+}
+export declare const CheckLockStatusGateway: import("@webiny/di").Abstraction<ICheckLockStatusGateway>;
+export declare namespace CheckLockStatusGateway {
+    type Interface = ICheckLockStatusGateway;
+}
+export interface ICheckLockStatusUseCase {
+    execute(params: ICheckLockStatusParams): Promise<IRecordLockingLockRecord | null>;
+}
+export declare const CheckLockStatusUseCase: import("@webiny/di").Abstraction<ICheckLockStatusUseCase>;
+export declare namespace CheckLockStatusUseCase {
+    type Interface = ICheckLockStatusUseCase;
+}

package/features/checkLockStatus/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const CheckLockStatusGateway = createAbstraction("CheckLockStatusGateway");
+const CheckLockStatusUseCase = createAbstraction("CheckLockStatusUseCase");
+export { CheckLockStatusGateway, CheckLockStatusUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/checkLockStatus/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/checkLockStatus/abstractions.js","sources":["../../../src/features/checkLockStatus/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { IRecordLockingLockRecord } from \"~/types.js\";\n\nexport interface ICheckLockStatusParams {\n    id: string;\n    type: string;\n}\n\nexport interface ICheckLockStatusGateway {\n    execute(params: ICheckLockStatusParams): Promise<IRecordLockingLockRecord | null>;\n}\n\nexport const CheckLockStatusGateway =\n    createAbstraction<ICheckLockStatusGateway>(\"CheckLockStatusGateway\");\n\nexport namespace CheckLockStatusGateway {\n    export type Interface = ICheckLockStatusGateway;\n}\n\nexport interface ICheckLockStatusUseCase {\n    execute(params: ICheckLockStatusParams): Promise<IRecordLockingLockRecord | null>;\n}\n\nexport const CheckLockStatusUseCase =\n    createAbstraction<ICheckLockStatusUseCase>(\"CheckLockStatusUseCase\");\n\nexport namespace CheckLockStatusUseCase {\n    export type Interface = ICheckLockStatusUseCase;\n}\n"],"names":["CheckLockStatusGateway","createAbstraction","CheckLockStatusUseCase"],"mappings":";AAYO,MAAMA,yBACTC,kBAA2C;AAUxC,MAAMC,yBACTD,kBAA2C"}

package/features/checkLockStatus/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const CheckLockStatusFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").ICheckLockStatusUseCase;
+}, []>;

package/features/checkLockStatus/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { CheckLockStatusUseCase } from "./abstractions.js";
+import { CheckLockStatusUseCase as external_CheckLockStatusUseCase_js_CheckLockStatusUseCase } from "./CheckLockStatusUseCase.js";
+import { CheckLockStatusGateway } from "./CheckLockStatusGateway.js";
+const CheckLockStatusFeature = createFeature({
+    name: "RecordLocking/CheckLockStatus",
+    register (container) {
+        container.register(external_CheckLockStatusUseCase_js_CheckLockStatusUseCase);
+        container.register(CheckLockStatusGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(CheckLockStatusUseCase)
+        };
+    }
+});
+export { CheckLockStatusFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/checkLockStatus/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/checkLockStatus/feature.js","sources":["../../../src/features/checkLockStatus/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { CheckLockStatusUseCase as UseCase } from \"./abstractions.js\";\nimport { CheckLockStatusUseCase } from \"./CheckLockStatusUseCase.js\";\nimport { CheckLockStatusGateway } from \"./CheckLockStatusGateway.js\";\n\nexport const CheckLockStatusFeature = createFeature({\n    name: \"RecordLocking/CheckLockStatus\",\n    register(container) {\n        container.register(CheckLockStatusUseCase);\n        container.register(CheckLockStatusGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["CheckLockStatusFeature","createFeature","container","CheckLockStatusUseCase","CheckLockStatusGateway","UseCase"],"mappings":";;;;AAKO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,wBAAwB,gBAAgB;IAC/D;IACA,SAAQF,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACG;QAC/B;IACJ;AACJ"}

package/features/feature.d.ts

@@ -0,0 +1 @@
+export declare const RecordLockingFeature: import("@webiny/feature/admin").FeatureDefinition<any, []>;

package/features/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { AcquireLockFeature } from "./acquireLock/feature.js";
+import { ReleaseLockFeature } from "./releaseLock/feature.js";
+import { ForceUnlockFeature } from "./forceUnlock/feature.js";
+import { CheckLockStatusFeature } from "./checkLockStatus/feature.js";
+import { ListLockRecordsFeature } from "./listLockRecords/feature.js";
+const RecordLockingFeature = createFeature({
+    name: "RecordLocking",
+    register (container) {
+        AcquireLockFeature.register(container);
+        ReleaseLockFeature.register(container);
+        ForceUnlockFeature.register(container);
+        CheckLockStatusFeature.register(container);
+        ListLockRecordsFeature.register(container);
+    }
+});
+export { RecordLockingFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/feature.js","sources":["../../src/features/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { AcquireLockFeature } from \"./acquireLock/feature.js\";\nimport { ReleaseLockFeature } from \"./releaseLock/feature.js\";\nimport { ForceUnlockFeature } from \"./forceUnlock/feature.js\";\nimport { CheckLockStatusFeature } from \"./checkLockStatus/feature.js\";\nimport { ListLockRecordsFeature } from \"./listLockRecords/feature.js\";\n\nexport const RecordLockingFeature = createFeature({\n    name: \"RecordLocking\",\n    register(container) {\n        AcquireLockFeature.register(container);\n        ReleaseLockFeature.register(container);\n        ForceUnlockFeature.register(container);\n        CheckLockStatusFeature.register(container);\n        ListLockRecordsFeature.register(container);\n    }\n});\n"],"names":["RecordLockingFeature","createFeature","container","AcquireLockFeature","ReleaseLockFeature","ForceUnlockFeature","CheckLockStatusFeature","ListLockRecordsFeature"],"mappings":";;;;;;AAOO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdC,mBAAmB,QAAQ,CAACD;QAC5BE,mBAAmB,QAAQ,CAACF;QAC5BG,mBAAmB,QAAQ,CAACH;QAC5BI,uBAAuB,QAAQ,CAACJ;QAChCK,uBAAuB,QAAQ,CAACL;IACpC;AACJ"}

package/features/forceUnlock/ForceUnlockGateway.d.ts

@@ -0,0 +1,12 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ForceUnlockGateway as GatewayAbstraction, type IForceUnlockParams } from "./abstractions.js";
+import type { IRecordLockingLockRecord } from "../../types.js";
+declare class ForceUnlockGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    execute(params: IForceUnlockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ForceUnlockGateway: typeof ForceUnlockGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IForceUnlockGateway>;
+};
+export {};

package/features/forceUnlock/ForceUnlockGateway.js

@@ -0,0 +1,44 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ERROR_FIELDS, LOCK_RECORD_FIELDS } from "../graphqlFields.js";
+import { ForceUnlockGateway } from "./abstractions.js";
+const FORCE_UNLOCK_MUTATION = `
+    mutation RecordLockingUnlockEntry($id: ID!, $type: String!, $force: Boolean) {
+        recordLocking {
+            unlockEntry(id: $id, type: $type, force: $force) {
+                data {
+                    ${LOCK_RECORD_FIELDS}
+                }
+                error {
+                    ${ERROR_FIELDS}
+                }
+            }
+        }
+    }
+`;
+class ForceUnlockGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: FORCE_UNLOCK_MUTATION,
+            variables: {
+                id: params.id,
+                type: params.type,
+                force: true
+            }
+        });
+        const { data, error } = response.recordLocking.unlockEntry;
+        if (!data) throw new Error(error?.message || "Failed to force unlock");
+        return data;
+    }
+}
+const ForceUnlockGateway_ForceUnlockGateway = ForceUnlockGateway.createImplementation({
+    implementation: ForceUnlockGatewayImpl,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { ForceUnlockGateway_ForceUnlockGateway as ForceUnlockGateway };
+
+//# sourceMappingURL=ForceUnlockGateway.js.map

package/features/forceUnlock/ForceUnlockGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/forceUnlock/ForceUnlockGateway.js","sources":["../../../src/features/forceUnlock/ForceUnlockGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/abstractions.js\";\nimport { LOCK_RECORD_FIELDS, ERROR_FIELDS } from \"~/features/graphqlFields.js\";\nimport {\n    ForceUnlockGateway as GatewayAbstraction,\n    type IForceUnlockParams\n} from \"./abstractions.js\";\nimport type { IRecordLockingError, IRecordLockingLockRecord } from \"~/types.js\";\n\ninterface ForceUnlockResponse {\n    recordLocking: {\n        unlockEntry: {\n            data: IRecordLockingLockRecord | null;\n            error: IRecordLockingError | null;\n        };\n    };\n}\n\nconst FORCE_UNLOCK_MUTATION = /* GraphQL */ `\n    mutation RecordLockingUnlockEntry($id: ID!, $type: String!, $force: Boolean) {\n        recordLocking {\n            unlockEntry(id: $id, type: $type, force: $force) {\n                data {\n                    ${LOCK_RECORD_FIELDS}\n                }\n                error {\n                    ${ERROR_FIELDS}\n                }\n            }\n        }\n    }\n`;\n\nclass ForceUnlockGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async execute(params: IForceUnlockParams) {\n        const response = await this.client.execute<ForceUnlockResponse>({\n            query: FORCE_UNLOCK_MUTATION,\n            variables: { id: params.id, type: params.type, force: true }\n        });\n\n        const { data, error } = response.recordLocking.unlockEntry;\n\n        if (!data) {\n            throw new Error(error?.message || \"Failed to force unlock\");\n        }\n\n        return data;\n    }\n}\n\nexport const ForceUnlockGateway = GatewayAbstraction.createImplementation({\n    implementation: ForceUnlockGatewayImpl,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["FORCE_UNLOCK_MUTATION","LOCK_RECORD_FIELDS","ERROR_FIELDS","ForceUnlockGatewayImpl","client","params","response","data","error","Error","ForceUnlockGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;;AAiBA,MAAMA,wBAAsC,CAAC;;;;;oBAKzB,EAAEC,mBAAmB;;;oBAGrB,EAAEC,aAAa;;;;;AAKnC,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,QAAQC,MAA0B,EAAE;QACtC,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAsB;YAC5D,OAAON;YACP,WAAW;gBAAE,IAAIK,OAAO,EAAE;gBAAE,MAAMA,OAAO,IAAI;gBAAE,OAAO;YAAK;QAC/D;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,aAAa,CAAC,WAAW;QAE1D,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBR;IAChB,cAAc;QAACS;KAAkB;AACrC"}

package/features/forceUnlock/ForceUnlockUseCase.d.ts

@@ -0,0 +1,10 @@
+import { ForceUnlockUseCase as UseCaseAbstraction, ForceUnlockGateway, type IForceUnlockParams } from "./abstractions.js";
+declare class ForceUnlockUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: ForceUnlockGateway.Interface);
+    execute(params: IForceUnlockParams): Promise<import("../../types.js").IRecordLockingLockRecord>;
+}
+export declare const ForceUnlockUseCase: typeof ForceUnlockUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IForceUnlockUseCase>;
+};
+export {};

package/features/forceUnlock/ForceUnlockUseCase.js

@@ -0,0 +1,18 @@
+import { ForceUnlockGateway, ForceUnlockUseCase } from "./abstractions.js";
+class ForceUnlockUseCaseImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        return this.gateway.execute(params);
+    }
+}
+const ForceUnlockUseCase_ForceUnlockUseCase = ForceUnlockUseCase.createImplementation({
+    implementation: ForceUnlockUseCaseImpl,
+    dependencies: [
+        ForceUnlockGateway
+    ]
+});
+export { ForceUnlockUseCase_ForceUnlockUseCase as ForceUnlockUseCase };
+
+//# sourceMappingURL=ForceUnlockUseCase.js.map

package/features/forceUnlock/ForceUnlockUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/forceUnlock/ForceUnlockUseCase.js","sources":["../../../src/features/forceUnlock/ForceUnlockUseCase.ts"],"sourcesContent":["import {\n    ForceUnlockUseCase as UseCaseAbstraction,\n    ForceUnlockGateway,\n    type IForceUnlockParams\n} from \"./abstractions.js\";\n\nclass ForceUnlockUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: ForceUnlockGateway.Interface) {}\n\n    async execute(params: IForceUnlockParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const ForceUnlockUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ForceUnlockUseCaseImpl,\n    dependencies: [ForceUnlockGateway]\n});\n"],"names":["ForceUnlockUseCaseImpl","gateway","params","ForceUnlockUseCase","UseCaseAbstraction","ForceUnlockGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAAqC,CAAE;aAAvCA,OAAO,GAAPA;IAAwC;IAE5D,MAAM,QAAQC,MAA0B,EAAE;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBJ;IAChB,cAAc;QAACK;KAAmB;AACtC"}

package/features/forceUnlock/abstractions.d.ts

@@ -0,0 +1,19 @@
+import type { IRecordLockingLockRecord } from "../../types.js";
+export interface IForceUnlockParams {
+    id: string;
+    type: string;
+}
+export interface IForceUnlockGateway {
+    execute(params: IForceUnlockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ForceUnlockGateway: import("@webiny/di").Abstraction<IForceUnlockGateway>;
+export declare namespace ForceUnlockGateway {
+    type Interface = IForceUnlockGateway;
+}
+export interface IForceUnlockUseCase {
+    execute(params: IForceUnlockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ForceUnlockUseCase: import("@webiny/di").Abstraction<IForceUnlockUseCase>;
+export declare namespace ForceUnlockUseCase {
+    type Interface = IForceUnlockUseCase;
+}

package/features/forceUnlock/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const ForceUnlockGateway = createAbstraction("ForceUnlockGateway");
+const ForceUnlockUseCase = createAbstraction("ForceUnlockUseCase");
+export { ForceUnlockGateway, ForceUnlockUseCase };
+
+//# sourceMappingURL=abstractions.js.map