@webiny/app-record-locking 6.4.12-beta.4 → 6.5.0-beta.0

package/features/forceUnlock/feature.d.ts

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

package/features/forceUnlock/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ForceUnlockUseCase } from "./abstractions.js";
+import { ForceUnlockUseCase as external_ForceUnlockUseCase_js_ForceUnlockUseCase } from "./ForceUnlockUseCase.js";
+import { ForceUnlockGateway } from "./ForceUnlockGateway.js";
+const ForceUnlockFeature = createFeature({
+    name: "RecordLocking/ForceUnlock",
+    register (container) {
+        container.register(external_ForceUnlockUseCase_js_ForceUnlockUseCase);
+        container.register(ForceUnlockGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(ForceUnlockUseCase)
+        };
+    }
+});
+export { ForceUnlockFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/forceUnlock/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/forceUnlock/feature.js","sources":["../../../src/features/forceUnlock/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ForceUnlockUseCase as UseCase } from \"./abstractions.js\";\nimport { ForceUnlockUseCase } from \"./ForceUnlockUseCase.js\";\nimport { ForceUnlockGateway } from \"./ForceUnlockGateway.js\";\n\nexport const ForceUnlockFeature = createFeature({\n    name: \"RecordLocking/ForceUnlock\",\n    register(container) {\n        container.register(ForceUnlockUseCase);\n        container.register(ForceUnlockGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["ForceUnlockFeature","createFeature","container","ForceUnlockUseCase","ForceUnlockGateway","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/{domain/graphql/fields.js → features/graphqlFields.js}

@@ -28,4 +28,4 @@ const ERROR_FIELDS = `
 `;
 export { ERROR_FIELDS, LOCK_RECORD_FIELDS };
 
-//# sourceMappingURL=fields.js.map
+//# sourceMappingURL=graphqlFields.js.map

package/features/graphqlFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/graphqlFields.js","sources":["../../src/features/graphqlFields.ts"],"sourcesContent":["export const LOCK_RECORD_FIELDS = /* GraphQL */ `\n    id\n    lockedBy {\n        id\n        displayName\n        type\n    }\n    lockedOn\n    updatedOn\n    expiresOn\n    targetId\n    type\n    actions {\n        type\n        message\n        createdBy {\n            id\n            displayName\n            type\n        }\n        createdOn\n    }\n`;\n\nexport const ERROR_FIELDS = /* GraphQL */ `\n    message\n    code\n    data\n`;\n"],"names":["LOCK_RECORD_FIELDS","ERROR_FIELDS"],"mappings":"AAAO,MAAMA,qBAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;AAsBjD,CAAC;AAEM,MAAMC,eAA6B,CAAC;;;;AAI3C,CAAC"}

package/features/listLockRecords/ListLockRecordsGateway.d.ts

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

package/features/listLockRecords/ListLockRecordsGateway.js

@@ -0,0 +1,48 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ERROR_FIELDS, LOCK_RECORD_FIELDS } from "../graphqlFields.js";
+import { ListLockRecordsGateway } from "./abstractions.js";
+const LIST_LOCK_RECORDS_QUERY = `
+    query RecordLockingListLockedRecords(
+        $where: RecordLockingListWhereInput
+        $sort: [RecordLockingListSorter!]
+        $limit: Int
+        $after: String
+    ) {
+        recordLocking {
+            listLockRecords(where: $where, sort: $sort, limit: $limit, after: $after) {
+                data {
+                    ${LOCK_RECORD_FIELDS}
+                }
+                error {
+                    ${ERROR_FIELDS}
+                }
+            }
+        }
+    }
+`;
+class ListLockRecordsGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: LIST_LOCK_RECORDS_QUERY,
+            variables: {
+                where: params.where,
+                limit: params.limit ?? 100
+            }
+        });
+        const { data, error } = response.recordLocking.listLockRecords;
+        if (error) throw new Error(error.message);
+        return data || [];
+    }
+}
+const ListLockRecordsGateway_ListLockRecordsGateway = ListLockRecordsGateway.createImplementation({
+    implementation: ListLockRecordsGatewayImpl,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { ListLockRecordsGateway_ListLockRecordsGateway as ListLockRecordsGateway };
+
+//# sourceMappingURL=ListLockRecordsGateway.js.map

package/features/listLockRecords/ListLockRecordsGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/listLockRecords/ListLockRecordsGateway.js","sources":["../../../src/features/listLockRecords/ListLockRecordsGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/abstractions.js\";\nimport { LOCK_RECORD_FIELDS, ERROR_FIELDS } from \"~/features/graphqlFields.js\";\nimport {\n    ListLockRecordsGateway as GatewayAbstraction,\n    type IListLockRecordsParams\n} from \"./abstractions.js\";\nimport type { IRecordLockingError, IRecordLockingLockRecord } from \"~/types.js\";\n\ninterface ListLockRecordsResponse {\n    recordLocking: {\n        listLockRecords: {\n            data: IRecordLockingLockRecord[] | null;\n            error: IRecordLockingError | null;\n        };\n    };\n}\n\nconst LIST_LOCK_RECORDS_QUERY = /* GraphQL */ `\n    query RecordLockingListLockedRecords(\n        $where: RecordLockingListWhereInput\n        $sort: [RecordLockingListSorter!]\n        $limit: Int\n        $after: String\n    ) {\n        recordLocking {\n            listLockRecords(where: $where, sort: $sort, limit: $limit, after: $after) {\n                data {\n                    ${LOCK_RECORD_FIELDS}\n                }\n                error {\n                    ${ERROR_FIELDS}\n                }\n            }\n        }\n    }\n`;\n\nclass ListLockRecordsGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async execute(params: IListLockRecordsParams) {\n        const response = await this.client.execute<ListLockRecordsResponse>({\n            query: LIST_LOCK_RECORDS_QUERY,\n            variables: {\n                where: params.where,\n                limit: params.limit ?? 100\n            }\n        });\n\n        const { data, error } = response.recordLocking.listLockRecords;\n\n        if (error) {\n            throw new Error(error.message);\n        }\n\n        return data || [];\n    }\n}\n\nexport const ListLockRecordsGateway = GatewayAbstraction.createImplementation({\n    implementation: ListLockRecordsGatewayImpl,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["LIST_LOCK_RECORDS_QUERY","LOCK_RECORD_FIELDS","ERROR_FIELDS","ListLockRecordsGatewayImpl","client","params","response","data","error","Error","ListLockRecordsGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;;AAiBA,MAAMA,0BAAwC,CAAC;;;;;;;;;;oBAU3B,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;gBACP,OAAOK,OAAO,KAAK;gBACnB,OAAOA,OAAO,KAAK,IAAI;YAC3B;QACJ;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,aAAa,CAAC,eAAe;QAE9D,IAAIE,OACA,MAAM,IAAIC,MAAMD,MAAM,OAAO;QAGjC,OAAOD,QAAQ,EAAE;IACrB;AACJ;AAEO,MAAMG,gDAAyBC,uBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBR;IAChB,cAAc;QAACS;KAAkB;AACrC"}

package/features/listLockRecords/ListLockRecordsUseCase.d.ts

@@ -0,0 +1,10 @@
+import { ListLockRecordsUseCase as UseCaseAbstraction, ListLockRecordsGateway, type IListLockRecordsParams } from "./abstractions.js";
+declare class ListLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: ListLockRecordsGateway.Interface);
+    execute(params: IListLockRecordsParams): Promise<import("../../types.js").IRecordLockingLockRecord[]>;
+}
+export declare const ListLockRecordsUseCase: typeof ListLockRecordsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListLockRecordsUseCase>;
+};
+export {};

package/features/listLockRecords/ListLockRecordsUseCase.js

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

package/features/listLockRecords/ListLockRecordsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/listLockRecords/ListLockRecordsUseCase.js","sources":["../../../src/features/listLockRecords/ListLockRecordsUseCase.ts"],"sourcesContent":["import {\n    ListLockRecordsUseCase as UseCaseAbstraction,\n    ListLockRecordsGateway,\n    type IListLockRecordsParams\n} from \"./abstractions.js\";\n\nclass ListLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: ListLockRecordsGateway.Interface) {}\n\n    async execute(params: IListLockRecordsParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const ListLockRecordsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListLockRecordsUseCaseImpl,\n    dependencies: [ListLockRecordsGateway]\n});\n"],"names":["ListLockRecordsUseCaseImpl","gateway","params","ListLockRecordsUseCase","UseCaseAbstraction","ListLockRecordsGateway"],"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/listLockRecords/abstractions.d.ts

@@ -0,0 +1,22 @@
+import type { IRecordLockingLockRecord } from "../../types.js";
+export interface IListLockRecordsParams {
+    where?: {
+        id_in?: string[];
+        type?: string;
+    };
+    limit?: number;
+}
+export interface IListLockRecordsGateway {
+    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;
+}
+export declare const ListLockRecordsGateway: import("@webiny/di").Abstraction<IListLockRecordsGateway>;
+export declare namespace ListLockRecordsGateway {
+    type Interface = IListLockRecordsGateway;
+}
+export interface IListLockRecordsUseCase {
+    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;
+}
+export declare const ListLockRecordsUseCase: import("@webiny/di").Abstraction<IListLockRecordsUseCase>;
+export declare namespace ListLockRecordsUseCase {
+    type Interface = IListLockRecordsUseCase;
+}

package/features/listLockRecords/abstractions.js

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

package/features/listLockRecords/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/listLockRecords/abstractions.js","sources":["../../../src/features/listLockRecords/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { IRecordLockingLockRecord } from \"~/types.js\";\n\nexport interface IListLockRecordsParams {\n    where?: {\n        id_in?: string[];\n        type?: string;\n    };\n    limit?: number;\n}\n\nexport interface IListLockRecordsGateway {\n    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;\n}\n\nexport const ListLockRecordsGateway =\n    createAbstraction<IListLockRecordsGateway>(\"ListLockRecordsGateway\");\n\nexport namespace ListLockRecordsGateway {\n    export type Interface = IListLockRecordsGateway;\n}\n\nexport interface IListLockRecordsUseCase {\n    execute(params: IListLockRecordsParams): Promise<IRecordLockingLockRecord[]>;\n}\n\nexport const ListLockRecordsUseCase =\n    createAbstraction<IListLockRecordsUseCase>(\"ListLockRecordsUseCase\");\n\nexport namespace ListLockRecordsUseCase {\n    export type Interface = IListLockRecordsUseCase;\n}\n"],"names":["ListLockRecordsGateway","createAbstraction","ListLockRecordsUseCase"],"mappings":";AAeO,MAAMA,yBACTC,kBAA2C;AAUxC,MAAMC,yBACTD,kBAA2C"}

package/features/listLockRecords/feature.d.ts

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

package/features/listLockRecords/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ListLockRecordsUseCase } from "./abstractions.js";
+import { ListLockRecordsUseCase as external_ListLockRecordsUseCase_js_ListLockRecordsUseCase } from "./ListLockRecordsUseCase.js";
+import { ListLockRecordsGateway } from "./ListLockRecordsGateway.js";
+const ListLockRecordsFeature = createFeature({
+    name: "RecordLocking/ListLockRecords",
+    register (container) {
+        container.register(external_ListLockRecordsUseCase_js_ListLockRecordsUseCase);
+        container.register(ListLockRecordsGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(ListLockRecordsUseCase)
+        };
+    }
+});
+export { ListLockRecordsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/listLockRecords/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/listLockRecords/feature.js","sources":["../../../src/features/listLockRecords/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ListLockRecordsUseCase as UseCase } from \"./abstractions.js\";\nimport { ListLockRecordsUseCase } from \"./ListLockRecordsUseCase.js\";\nimport { ListLockRecordsGateway } from \"./ListLockRecordsGateway.js\";\n\nexport const ListLockRecordsFeature = createFeature({\n    name: \"RecordLocking/ListLockRecords\",\n    register(container) {\n        container.register(ListLockRecordsUseCase);\n        container.register(ListLockRecordsGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["ListLockRecordsFeature","createFeature","container","ListLockRecordsUseCase","ListLockRecordsGateway","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/permissions/abstractions.d.ts

@@ -1,5 +1,5 @@
 import type { Permissions } from "@webiny/app-admin/exports/admin/security.js";
-import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../domain/permissionsSchema.js";
+import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../permissions/permissionsSchema.js";
 export declare const RecordLockingPermissions: import("@webiny/di").Abstraction<{
     canAccess: (entityId: never) => boolean;
     canAction: (action: string, entityId: never) => boolean;

package/features/permissions/abstractions.js

@@ -1,5 +1,5 @@
 import { createPermissionsAbstraction } from "@webiny/app-admin/exports/admin/security.js";
-import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../domain/permissionsSchema.js";
+import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../permissions/permissionsSchema.js";
 const RecordLockingPermissions = createPermissionsAbstraction(RECORD_LOCKING_PERMISSIONS_SCHEMA);
 export { RecordLockingPermissions };
 

package/features/permissions/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/permissions/abstractions.js","sources":["../../../src/features/permissions/abstractions.ts"],"sourcesContent":["import { createPermissionsAbstraction } from \"@webiny/app-admin/exports/admin/security.js\";\nimport type { Permissions } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { RECORD_LOCKING_PERMISSIONS_SCHEMA } from \"~/domain/permissionsSchema.js\";\n\nexport const RecordLockingPermissions = createPermissionsAbstraction(\n    RECORD_LOCKING_PERMISSIONS_SCHEMA\n);\n\nexport namespace RecordLockingPermissions {\n    export type Interface = Permissions<typeof RECORD_LOCKING_PERMISSIONS_SCHEMA>;\n}\n"],"names":["RecordLockingPermissions","createPermissionsAbstraction","RECORD_LOCKING_PERMISSIONS_SCHEMA"],"mappings":";;AAIO,MAAMA,2BAA2BC,6BACpCC"}
+{"version":3,"file":"features/permissions/abstractions.js","sources":["../../../src/features/permissions/abstractions.ts"],"sourcesContent":["import { createPermissionsAbstraction } from \"@webiny/app-admin/exports/admin/security.js\";\nimport type { Permissions } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { RECORD_LOCKING_PERMISSIONS_SCHEMA } from \"~/permissions/permissionsSchema.js\";\n\nexport const RecordLockingPermissions = createPermissionsAbstraction(\n    RECORD_LOCKING_PERMISSIONS_SCHEMA\n);\n\nexport namespace RecordLockingPermissions {\n    export type Interface = Permissions<typeof RECORD_LOCKING_PERMISSIONS_SCHEMA>;\n}\n"],"names":["RecordLockingPermissions","createPermissionsAbstraction","RECORD_LOCKING_PERMISSIONS_SCHEMA"],"mappings":";;AAIO,MAAMA,2BAA2BC,6BACpCC"}

package/features/permissions/feature.d.ts

@@ -1,4 +1,4 @@
-export declare const RecordLockingPermissionsFeature: import("@webiny/feature/admin/createFeature.js").FeatureDefinition<{
+export declare const RecordLockingPermissionsFeature: import("@webiny/feature/admin").FeatureDefinition<{
     permissions: {
         canAccess: (entityId: never) => boolean;
         canAction: (action: string, entityId: never) => boolean;

package/features/permissions/feature.js

@@ -1,5 +1,5 @@
 import { createPermissionsFeature } from "@webiny/app-admin/exports/admin/security.js";
-import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../domain/permissionsSchema.js";
+import { RECORD_LOCKING_PERMISSIONS_SCHEMA } from "../../permissions/permissionsSchema.js";
 import { RecordLockingPermissions } from "./abstractions.js";
 const RecordLockingPermissionsFeature = createPermissionsFeature(RECORD_LOCKING_PERMISSIONS_SCHEMA, RecordLockingPermissions);
 export { RecordLockingPermissionsFeature };

package/features/permissions/feature.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/permissions/feature.js","sources":["../../../src/features/permissions/feature.ts"],"sourcesContent":["import { createPermissionsFeature } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { RECORD_LOCKING_PERMISSIONS_SCHEMA } from \"~/domain/permissionsSchema.js\";\nimport { RecordLockingPermissions } from \"./abstractions.js\";\n\nexport const RecordLockingPermissionsFeature = createPermissionsFeature(\n    RECORD_LOCKING_PERMISSIONS_SCHEMA,\n    RecordLockingPermissions\n);\n"],"names":["RecordLockingPermissionsFeature","createPermissionsFeature","RECORD_LOCKING_PERMISSIONS_SCHEMA","RecordLockingPermissions"],"mappings":";;;AAIO,MAAMA,kCAAkCC,yBAC3CC,mCACAC"}
+{"version":3,"file":"features/permissions/feature.js","sources":["../../../src/features/permissions/feature.ts"],"sourcesContent":["import { createPermissionsFeature } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { RECORD_LOCKING_PERMISSIONS_SCHEMA } from \"~/permissions/permissionsSchema.js\";\nimport { RecordLockingPermissions } from \"./abstractions.js\";\n\nexport const RecordLockingPermissionsFeature = createPermissionsFeature(\n    RECORD_LOCKING_PERMISSIONS_SCHEMA,\n    RecordLockingPermissions\n);\n"],"names":["RecordLockingPermissionsFeature","createPermissionsFeature","RECORD_LOCKING_PERMISSIONS_SCHEMA","RecordLockingPermissions"],"mappings":";;;AAIO,MAAMA,kCAAkCC,yBAC3CC,mCACAC"}

package/features/releaseLock/ReleaseLockGateway.d.ts

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

package/features/releaseLock/ReleaseLockGateway.js

@@ -0,0 +1,44 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/abstractions.js";
+import { ERROR_FIELDS, LOCK_RECORD_FIELDS } from "../graphqlFields.js";
+import { ReleaseLockGateway } from "./abstractions.js";
+const RELEASE_LOCK_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 ReleaseLockGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const response = await this.client.execute({
+            query: RELEASE_LOCK_MUTATION,
+            variables: {
+                id: params.id,
+                type: params.type,
+                force: false
+            }
+        });
+        const { data, error } = response.recordLocking.unlockEntry;
+        if (!data) throw new Error(error?.message || "Failed to release lock");
+        return data;
+    }
+}
+const ReleaseLockGateway_ReleaseLockGateway = ReleaseLockGateway.createImplementation({
+    implementation: ReleaseLockGatewayImpl,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { ReleaseLockGateway_ReleaseLockGateway as ReleaseLockGateway };
+
+//# sourceMappingURL=ReleaseLockGateway.js.map

package/features/releaseLock/ReleaseLockGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/releaseLock/ReleaseLockGateway.js","sources":["../../../src/features/releaseLock/ReleaseLockGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/abstractions.js\";\nimport { LOCK_RECORD_FIELDS, ERROR_FIELDS } from \"~/features/graphqlFields.js\";\nimport {\n    ReleaseLockGateway as GatewayAbstraction,\n    type IReleaseLockParams\n} from \"./abstractions.js\";\nimport type { IRecordLockingError, IRecordLockingLockRecord } from \"~/types.js\";\n\ninterface ReleaseLockResponse {\n    recordLocking: {\n        unlockEntry: {\n            data: IRecordLockingLockRecord | null;\n            error: IRecordLockingError | null;\n        };\n    };\n}\n\nconst RELEASE_LOCK_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 ReleaseLockGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async execute(params: IReleaseLockParams) {\n        const response = await this.client.execute<ReleaseLockResponse>({\n            query: RELEASE_LOCK_MUTATION,\n            variables: { id: params.id, type: params.type, force: false }\n        });\n\n        const { data, error } = response.recordLocking.unlockEntry;\n\n        if (!data) {\n            throw new Error(error?.message || \"Failed to release lock\");\n        }\n\n        return data;\n    }\n}\n\nexport const ReleaseLockGateway = GatewayAbstraction.createImplementation({\n    implementation: ReleaseLockGatewayImpl,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["RELEASE_LOCK_MUTATION","LOCK_RECORD_FIELDS","ERROR_FIELDS","ReleaseLockGatewayImpl","client","params","response","data","error","Error","ReleaseLockGateway","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;YAAM;QAChE;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/releaseLock/ReleaseLockUseCase.d.ts

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

package/features/releaseLock/ReleaseLockUseCase.js

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

package/features/releaseLock/ReleaseLockUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/releaseLock/ReleaseLockUseCase.js","sources":["../../../src/features/releaseLock/ReleaseLockUseCase.ts"],"sourcesContent":["import {\n    ReleaseLockUseCase as UseCaseAbstraction,\n    ReleaseLockGateway,\n    type IReleaseLockParams\n} from \"./abstractions.js\";\n\nclass ReleaseLockUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: ReleaseLockGateway.Interface) {}\n\n    async execute(params: IReleaseLockParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const ReleaseLockUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ReleaseLockUseCaseImpl,\n    dependencies: [ReleaseLockGateway]\n});\n"],"names":["ReleaseLockUseCaseImpl","gateway","params","ReleaseLockUseCase","UseCaseAbstraction","ReleaseLockGateway"],"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/releaseLock/abstractions.d.ts

@@ -0,0 +1,19 @@
+import type { IRecordLockingLockRecord } from "../../types.js";
+export interface IReleaseLockParams {
+    id: string;
+    type: string;
+}
+export interface IReleaseLockGateway {
+    execute(params: IReleaseLockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ReleaseLockGateway: import("@webiny/di").Abstraction<IReleaseLockGateway>;
+export declare namespace ReleaseLockGateway {
+    type Interface = IReleaseLockGateway;
+}
+export interface IReleaseLockUseCase {
+    execute(params: IReleaseLockParams): Promise<IRecordLockingLockRecord>;
+}
+export declare const ReleaseLockUseCase: import("@webiny/di").Abstraction<IReleaseLockUseCase>;
+export declare namespace ReleaseLockUseCase {
+    type Interface = IReleaseLockUseCase;
+}

package/features/releaseLock/abstractions.js

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

package/features/releaseLock/abstractions.js.map

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

package/features/releaseLock/feature.d.ts

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

package/features/releaseLock/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ReleaseLockUseCase } from "./abstractions.js";
+import { ReleaseLockUseCase as external_ReleaseLockUseCase_js_ReleaseLockUseCase } from "./ReleaseLockUseCase.js";
+import { ReleaseLockGateway } from "./ReleaseLockGateway.js";
+const ReleaseLockFeature = createFeature({
+    name: "RecordLocking/ReleaseLock",
+    register (container) {
+        container.register(external_ReleaseLockUseCase_js_ReleaseLockUseCase);
+        container.register(ReleaseLockGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(ReleaseLockUseCase)
+        };
+    }
+});
+export { ReleaseLockFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/releaseLock/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/releaseLock/feature.js","sources":["../../../src/features/releaseLock/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ReleaseLockUseCase as UseCase } from \"./abstractions.js\";\nimport { ReleaseLockUseCase } from \"./ReleaseLockUseCase.js\";\nimport { ReleaseLockGateway } from \"./ReleaseLockGateway.js\";\n\nexport const ReleaseLockFeature = createFeature({\n    name: \"RecordLocking/ReleaseLock\",\n    register(container) {\n        container.register(ReleaseLockUseCase);\n        container.register(ReleaseLockGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["ReleaseLockFeature","createFeature","container","ReleaseLockUseCase","ReleaseLockGateway","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/index.d.ts

@@ -1,7 +1,2 @@
 import React from "react";
-export * from "./components/RecordLockingProvider.js";
-export * from "./hooks/index.js";
-export interface RecordLockingProviderProps {
-    children: React.ReactNode;
-}
 export declare const RecordLocking: () => React.JSX.Element | null;

package/index.js

@@ -1,24 +1,23 @@
 import react from "react";
-import { Provider } from "@webiny/app";
 import { RegisterFeature, useWcp } from "@webiny/app-admin";
-import { RecordLockingProvider as RecordLockingProvider_js_RecordLockingProvider } from "./components/RecordLockingProvider.js";
-import { HeadlessCmsActionsAcoCell } from "./components/HeadlessCmsActionsAcoCell.js";
-import { HeadlessCmsContentEntry } from "./components/HeadlessCmsContentEntry/index.js";
-import { SecurityPermissions } from "./components/SecurityPermissions.js";
+import { RecordLockingFeature } from "./features/feature.js";
 import { RecordLockingPermissionsFeature } from "./features/permissions/feature.js";
-export * from "./components/RecordLockingProvider.js";
-export * from "./hooks/index.js";
-const RecordLockingHoc = (Component)=>function({ children }) {
-        return /*#__PURE__*/ react.createElement(Component, null, /*#__PURE__*/ react.createElement(RecordLockingProvider_js_RecordLockingProvider, null, children));
-    };
+import { RecordLockingPresenterFeature } from "./presentation/entryLocking/feature.js";
+import { ListLockRecordsPresenterFeature } from "./presentation/listLocking/feature.js";
+import { SecurityPermissions } from "./SecurityPermissions.js";
+import { RecordLockingModule } from "./RecordLockingModule.js";
 const RecordLocking = ()=>{
     const wcp = useWcp();
     if (!wcp.canUseRecordLocking()) return null;
     return /*#__PURE__*/ react.createElement(react.Fragment, null, /*#__PURE__*/ react.createElement(RegisterFeature, {
         feature: RecordLockingPermissionsFeature
-    }), /*#__PURE__*/ react.createElement(SecurityPermissions, null), /*#__PURE__*/ react.createElement(Provider, {
-        hoc: RecordLockingHoc
-    }), /*#__PURE__*/ react.createElement(HeadlessCmsActionsAcoCell, null), /*#__PURE__*/ react.createElement(HeadlessCmsContentEntry, null));
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: RecordLockingFeature
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: RecordLockingPresenterFeature
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: ListLockRecordsPresenterFeature
+    }), /*#__PURE__*/ react.createElement(SecurityPermissions, null), /*#__PURE__*/ react.createElement(RecordLockingModule, null));
 };
 export { RecordLocking };
 

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/index.tsx"],"sourcesContent":["import React from \"react\";\nimport { Provider } from \"@webiny/app\";\nimport { RegisterFeature } from \"@webiny/app-admin\";\nimport { RecordLockingProvider as RecordLockingProviderComponent } from \"~/components/RecordLockingProvider.js\";\nimport { HeadlessCmsActionsAcoCell } from \"~/components/HeadlessCmsActionsAcoCell.js\";\nimport { HeadlessCmsContentEntry } from \"~/components/HeadlessCmsContentEntry/index.js\";\nimport { useWcp } from \"@webiny/app-admin\";\nimport { SecurityPermissions } from \"~/components/SecurityPermissions.js\";\nimport { RecordLockingPermissionsFeature } from \"~/features/permissions/feature.js\";\n\nexport * from \"~/components/RecordLockingProvider.js\";\nexport * from \"~/hooks/index.js\";\n\nexport interface RecordLockingProviderProps {\n    children: React.ReactNode;\n}\n\nconst RecordLockingHoc = (Component: React.ComponentType<RecordLockingProviderProps>) => {\n    return function RecordLockingProvider({ children }: RecordLockingProviderProps) {\n        return (\n            <Component>\n                <RecordLockingProviderComponent>{children}</RecordLockingProviderComponent>\n            </Component>\n        );\n    };\n};\n\nexport const RecordLocking = () => {\n    const wcp = useWcp();\n\n    if (!wcp.canUseRecordLocking()) {\n        return null;\n    }\n\n    return (\n        <>\n            <RegisterFeature feature={RecordLockingPermissionsFeature} />\n            <SecurityPermissions />\n            <Provider hoc={RecordLockingHoc} />\n            <HeadlessCmsActionsAcoCell />\n            <HeadlessCmsContentEntry />\n        </>\n    );\n};\n"],"names":["RecordLockingHoc","Component","children","RecordLockingProviderComponent","RecordLocking","wcp","useWcp","RegisterFeature","RecordLockingPermissionsFeature","SecurityPermissions","Provider","HeadlessCmsActionsAcoCell","HeadlessCmsContentEntry"],"mappings":";;;;;;;;;;AAiBA,MAAMA,mBAAmB,CAACC,YACf,SAA+B,EAAEC,QAAQ,EAA8B;QAC1E,OAAO,WAAP,GACI,oBAACD,WAAAA,MAAAA,WAAAA,GACG,oBAACE,gDAA8BA,MAAED;IAG7C;AAGG,MAAME,gBAAgB;IACzB,MAAMC,MAAMC;IAEZ,IAAI,CAACD,IAAI,mBAAmB,IACxB,OAAO;IAGX,OAAO,WAAP,GACI,wDACI,oBAACE,iBAAeA;QAAC,SAASC;sBAC1B,oBAACC,qBAAmBA,OAAAA,WAAAA,GACpB,oBAACC,UAAQA;QAAC,KAAKV;sBACf,oBAACW,2BAAyBA,OAAAA,WAAAA,GAC1B,oBAACC,yBAAuBA;AAGpC"}
+{"version":3,"file":"index.js","sources":["../src/index.tsx"],"sourcesContent":["import React from \"react\";\nimport { RegisterFeature } from \"@webiny/app-admin\";\nimport { useWcp } from \"@webiny/app-admin\";\nimport { RecordLockingFeature } from \"~/features/feature.js\";\nimport { RecordLockingPermissionsFeature } from \"~/features/permissions/feature.js\";\nimport { RecordLockingPresenterFeature } from \"~/presentation/entryLocking/feature.js\";\nimport { ListLockRecordsPresenterFeature } from \"~/presentation/listLocking/feature.js\";\nimport { SecurityPermissions } from \"~/SecurityPermissions.js\";\nimport { RecordLockingModule } from \"~/RecordLockingModule.js\";\n\nexport const RecordLocking = () => {\n    const wcp = useWcp();\n\n    if (!wcp.canUseRecordLocking()) {\n        return null;\n    }\n\n    return (\n        <>\n            <RegisterFeature feature={RecordLockingPermissionsFeature} />\n            <RegisterFeature feature={RecordLockingFeature} />\n            <RegisterFeature feature={RecordLockingPresenterFeature} />\n            <RegisterFeature feature={ListLockRecordsPresenterFeature} />\n            <SecurityPermissions />\n            <RecordLockingModule />\n        </>\n    );\n};\n"],"names":["RecordLocking","wcp","useWcp","RegisterFeature","RecordLockingPermissionsFeature","RecordLockingFeature","RecordLockingPresenterFeature","ListLockRecordsPresenterFeature","SecurityPermissions","RecordLockingModule"],"mappings":";;;;;;;;AAUO,MAAMA,gBAAgB;IACzB,MAAMC,MAAMC;IAEZ,IAAI,CAACD,IAAI,mBAAmB,IACxB,OAAO;IAGX,OAAO,WAAP,GACI,wDACI,oBAACE,iBAAeA;QAAC,SAASC;sBAC1B,oBAACD,iBAAeA;QAAC,SAASE;sBAC1B,oBAACF,iBAAeA;QAAC,SAASG;sBAC1B,oBAACH,iBAAeA;QAAC,SAASI;sBAC1B,oBAACC,qBAAmBA,OAAAA,WAAAA,GACpB,oBAACC,qBAAmBA;AAGhC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/app-record-locking",
-	"version": "6.4.12-beta.4",
+	"version": "6.5.0-beta.0",
 	"type": "module",
 	"exports": {
 		".": "./index.js",
@@ -17,27 +17,23 @@
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@apollo/react-hooks": "3.1.5",
-		"@webiny/admin-ui": "6.4.12-beta.4",
-		"@webiny/app": "6.4.12-beta.4",
-		"@webiny/app-aco": "6.4.12-beta.4",
-		"@webiny/app-admin": "6.4.12-beta.4",
-		"@webiny/app-headless-cms": "6.4.12-beta.4",
-		"@webiny/app-websockets": "6.4.12-beta.4",
-		"@webiny/error": "6.4.12-beta.4",
-		"@webiny/icons": "6.4.12-beta.4",
-		"@webiny/utils": "6.4.12-beta.4",
-		"apollo-client": "2.6.10",
-		"apollo-link": "1.2.14",
-		"crypto-hash": "4.0.1",
-		"graphql-tag": "2.12.7",
+		"@webiny/admin-ui": "6.5.0-beta.0",
+		"@webiny/app": "6.5.0-beta.0",
+		"@webiny/app-admin": "6.5.0-beta.0",
+		"@webiny/app-headless-cms": "6.5.0-beta.0",
+		"@webiny/app-websockets": "6.5.0-beta.0",
+		"@webiny/feature": "6.5.0-beta.0",
+		"@webiny/icons": "6.5.0-beta.0",
+		"@webiny/utils": "6.5.0-beta.0",
+		"mobx": "6.16.1",
+		"mobx-react-lite": "4.1.1",
 		"react": "18.3.1",
 		"react-dom": "18.3.1"
 	},
 	"devDependencies": {
-		"@webiny/build-tools": "6.4.12-beta.4",
+		"@webiny/build-tools": "6.5.0-beta.0",
 		"rimraf": "6.1.3",
-		"typescript": "6.0.3"
+		"typescript": "7.0.2"
 	},
 	"publishConfig": {
 		"access": "public"

package/permissions/permissionsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions/permissionsSchema.js","sources":["../../src/permissions/permissionsSchema.ts"],"sourcesContent":["import { createPermissionSchema } from \"@webiny/app-admin\";\n\nexport const RECORD_LOCKING_PERMISSIONS_SCHEMA = createPermissionSchema({\n    prefix: \"recordLocking\",\n    fullAccess: { canForceUnlock: true }\n});\n"],"names":["RECORD_LOCKING_PERMISSIONS_SCHEMA","createPermissionSchema"],"mappings":";AAEO,MAAMA,oCAAoCC,uBAAuB;IACpE,QAAQ;IACR,YAAY;QAAE,gBAAgB;IAAK;AACvC"}

package/presentation/entryLocking/ContentEntryFormPresenterDecorator.d.ts

@@ -0,0 +1,23 @@
+import { type IContentEntryFormPresenter, type IContentEntryFormViewModel } from "@webiny/app-headless-cms/presentation/contentEntries/form/abstractions.js";
+import { RecordLockingPresenter } from "./abstractions.js";
+declare class ContentEntryFormPresenterWithLocking implements IContentEntryFormPresenter {
+    private lockingPresenter;
+    private original;
+    constructor(lockingPresenter: RecordLockingPresenter.Interface, original: IContentEntryFormPresenter);
+    get vm(): IContentEntryFormViewModel;
+    saveRevision(options?: {
+        skipValidation?: boolean;
+    }): Promise<boolean>;
+    publishRevision(): Promise<boolean>;
+    unpublishRevision(): Promise<boolean>;
+    deleteEntry(): Promise<boolean>;
+    loadRevision(id: string): Promise<void>;
+    setFolderId(folderId: string | null): void;
+    newEntry(initialValues?: Record<string, unknown>): void;
+    patchEntryMeta(...args: Parameters<IContentEntryFormPresenter["patchEntryMeta"]>): void;
+    reset(): void;
+}
+export declare const ContentEntryFormPresenterLockingDecorator: typeof ContentEntryFormPresenterWithLocking & {
+    __abstraction: import("@webiny/di").Abstraction<IContentEntryFormPresenter>;
+};
+export {};