@webiny/api-record-locking 0.0.0-unstable.a4f3e4ea8b → 0.0.0-unstable.a85ef555b2

package/features/UnlockEntry/UnlockEntryRepository.js

@@ -2,22 +2,23 @@ import { Result } from "@webiny/feature/api";
 import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
 import { createIdentifier } from "@webiny/utils";
 import { UnlockEntryRepository } from "./abstractions.js";
-import { RecordLockingModel } from "../../domain/abstractions.js";
+import { RecordLockingModelProvider } from "../../domain/abstractions.js";
 import { LockRecordNotFoundError, UnlockEntryError } from "../../domain/errors.js";
 import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
 class UnlockEntryRepositoryImpl {
-    constructor(model, deleteEntry){
-        this.model = model;
+    constructor(modelProvider, deleteEntry){
+        this.modelProvider = modelProvider;
         this.deleteEntry = deleteEntry;
     }
     async delete(lockRecordId) {
         try {
+            const model = await this.modelProvider.get();
             const entryId = createLockRecordDatabaseId(lockRecordId);
             const id = createIdentifier({
                 id: entryId,
                 version: 1
             });
-            const result = await this.deleteEntry.execute(this.model, id, {
+            const result = await this.deleteEntry.execute(model, id, {
                 permanently: true
             });
             if (result.isFail()) {
@@ -33,7 +34,7 @@ class UnlockEntryRepositoryImpl {
 const UnlockEntryRepository_UnlockEntryRepository = UnlockEntryRepository.createImplementation({
     implementation: UnlockEntryRepositoryImpl,
     dependencies: [
-        RecordLockingModel,
+        RecordLockingModelProvider,
         DeleteEntryUseCase
     ]
 });

package/features/UnlockEntry/UnlockEntryRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/UnlockEntry/UnlockEntryRepository.js","sources":["../../../src/features/UnlockEntry/UnlockEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { UnlockEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { RecordLockingModel } from \"~/domain/abstractions.js\";\nimport { LockRecordNotFoundError, UnlockEntryError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass UnlockEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private deleteEntry: DeleteEntryUseCase.Interface\n    ) {}\n\n    async delete(lockRecordId: string): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = createLockRecordDatabaseId(lockRecordId);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const result = await this.deleteEntry.execute(this.model, id, {\n                permanently: true\n            });\n\n            if (result.isFail()) {\n                if (result.error.code === \"Cms/Entry/NotFound\") {\n                    return Result.fail(new LockRecordNotFoundError());\n                }\n                return Result.fail(new UnlockEntryError(result.error));\n            }\n\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new UnlockEntryError(error as Error));\n        }\n    }\n}\n\nexport const UnlockEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: UnlockEntryRepositoryImpl,\n    dependencies: [RecordLockingModel, DeleteEntryUseCase]\n});\n"],"names":["UnlockEntryRepositoryImpl","model","deleteEntry","lockRecordId","entryId","createLockRecordDatabaseId","id","createIdentifier","result","Result","LockRecordNotFoundError","UnlockEntryError","error","UnlockEntryRepository","RepositoryAbstraction","RecordLockingModel","DeleteEntryUseCase"],"mappings":";;;;;;;AAQA,MAAMA;IACF,YACYC,KAAmC,EACnCC,WAAyC,CACnD;aAFUD,KAAK,GAALA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,YAAoB,EAAsD;QACnF,IAAI;YACA,MAAMC,UAAUC,2BAA2BF;YAC3C,MAAMG,KAAKC,iBAAiB;gBACxB,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAEF,IAAI;gBAC1D,aAAa;YACjB;YAEA,IAAIE,OAAO,MAAM,IAAI;gBACjB,IAAIA,AAAsB,yBAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC;gBAE3B,OAAOD,OAAO,IAAI,CAAC,IAAIE,iBAAiBH,OAAO,KAAK;YACxD;YAEA,OAAOC,OAAO,EAAE;QACpB,EAAE,OAAOG,OAAO;YACZ,OAAOH,OAAO,IAAI,CAAC,IAAIE,iBAAiBC;QAC5C;IACJ;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBd;IAChB,cAAc;QAACe;QAAoBC;KAAmB;AAC1D"}
+{"version":3,"file":"features/UnlockEntry/UnlockEntryRepository.js","sources":["../../../src/features/UnlockEntry/UnlockEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { UnlockEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { RecordLockingModelProvider } from \"~/domain/abstractions.js\";\nimport { LockRecordNotFoundError, UnlockEntryError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass UnlockEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private modelProvider: RecordLockingModelProvider.Interface,\n        private deleteEntry: DeleteEntryUseCase.Interface\n    ) {}\n\n    async delete(lockRecordId: string): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            const model = await this.modelProvider.get();\n\n            const entryId = createLockRecordDatabaseId(lockRecordId);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const result = await this.deleteEntry.execute(model, id, {\n                permanently: true\n            });\n\n            if (result.isFail()) {\n                if (result.error.code === \"Cms/Entry/NotFound\") {\n                    return Result.fail(new LockRecordNotFoundError());\n                }\n                return Result.fail(new UnlockEntryError(result.error));\n            }\n\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new UnlockEntryError(error as Error));\n        }\n    }\n}\n\nexport const UnlockEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: UnlockEntryRepositoryImpl,\n    dependencies: [RecordLockingModelProvider, DeleteEntryUseCase]\n});\n"],"names":["UnlockEntryRepositoryImpl","modelProvider","deleteEntry","lockRecordId","model","entryId","createLockRecordDatabaseId","id","createIdentifier","result","Result","LockRecordNotFoundError","UnlockEntryError","error","UnlockEntryRepository","RepositoryAbstraction","RecordLockingModelProvider","DeleteEntryUseCase"],"mappings":";;;;;;;AAQA,MAAMA;IACF,YACYC,aAAmD,EACnDC,WAAyC,CACnD;aAFUD,aAAa,GAAbA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,YAAoB,EAAsD;QACnF,IAAI;YACA,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;YAE1C,MAAMC,UAAUC,2BAA2BH;YAC3C,MAAMI,KAAKC,iBAAiB;gBACxB,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACL,OAAOG,IAAI;gBACrD,aAAa;YACjB;YAEA,IAAIE,OAAO,MAAM,IAAI;gBACjB,IAAIA,AAAsB,yBAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC;gBAE3B,OAAOD,OAAO,IAAI,CAAC,IAAIE,iBAAiBH,OAAO,KAAK;YACxD;YAEA,OAAOC,OAAO,EAAE;QACpB,EAAE,OAAOG,OAAO;YACZ,OAAOH,OAAO,IAAI,CAAC,IAAIE,iBAAiBC;QAC5C;IACJ;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBf;IAChB,cAAc;QAACgB;QAA4BC;KAAmB;AAClE"}

package/features/UnlockEntryRequest/UnlockEntryRequestRepository.d.ts

@@ -2,13 +2,13 @@ import { Result } from "@webiny/feature/api";
 import { UnlockEntryRequestRepository as RepositoryAbstraction } from "./abstractions.js";
 import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
 import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { RecordLockingModelProvider } from "../../domain/abstractions.js";
 import type { ILockRecord } from "../../domain/LockRecord.js";
-import type { CmsModel } from "@webiny/api-headless-cms/types";
 declare class UnlockEntryRequestRepositoryImpl implements RepositoryAbstraction.Interface {
     private updateEntry;
     private identityContext;
-    private model;
-    constructor(updateEntry: UpdateEntryUseCase.Interface, identityContext: IdentityContext.Interface, model: CmsModel);
+    private modelProvider;
+    constructor(updateEntry: UpdateEntryUseCase.Interface, identityContext: IdentityContext.Interface, modelProvider: RecordLockingModelProvider.Interface);
     update(record: ILockRecord): Promise<Result<ILockRecord, RepositoryAbstraction.Error>>;
 }
 export declare const UnlockEntryRequestRepository: typeof UnlockEntryRequestRepositoryImpl & {

package/features/UnlockEntryRequest/UnlockEntryRequestRepository.js

@@ -2,25 +2,26 @@ import { Result } from "@webiny/feature/api";
 import { UnlockEntryRequestRepository } from "./abstractions.js";
 import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
 import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
-import { RecordLockingModel } from "../../domain/abstractions.js";
+import { RecordLockingModelProvider } from "../../domain/abstractions.js";
 import { UnlockEntryRequestError } from "../../domain/errors.js";
 import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
 import { createIdentifier } from "@webiny/utils";
 class UnlockEntryRequestRepositoryImpl {
-    constructor(updateEntry, identityContext, model){
+    constructor(updateEntry, identityContext, modelProvider){
         this.updateEntry = updateEntry;
         this.identityContext = identityContext;
-        this.model = model;
+        this.modelProvider = modelProvider;
     }
     async update(record) {
         try {
+            const model = await this.modelProvider.get();
             const entryId = createLockRecordDatabaseId(record.id);
             const id = createIdentifier({
                 id: entryId,
                 version: 1
             });
             const recordValues = record.toObject();
-            const result = await this.identityContext.withoutAuthorization(async ()=>await this.updateEntry.execute(this.model, id, {
+            const result = await this.identityContext.withoutAuthorization(async ()=>await this.updateEntry.execute(model, id, {
                     ...recordValues,
                     values: recordValues
                 }));
@@ -36,7 +37,7 @@ const UnlockEntryRequestRepository_UnlockEntryRequestRepository = UnlockEntryReq
     dependencies: [
         UpdateEntryUseCase,
         IdentityContext,
-        RecordLockingModel
+        RecordLockingModelProvider
     ]
 });
 export { UnlockEntryRequestRepository_UnlockEntryRequestRepository as UnlockEntryRequestRepository };

package/features/UnlockEntryRequest/UnlockEntryRequestRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/UnlockEntryRequest/UnlockEntryRequestRepository.js","sources":["../../../src/features/UnlockEntryRequest/UnlockEntryRequestRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { UnlockEntryRequestRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { RecordLockingModel } from \"~/domain/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { UnlockEntryRequestError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\nimport { createIdentifier } from \"@webiny/utils\";\n\nclass UnlockEntryRequestRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private identityContext: IdentityContext.Interface,\n        private model: CmsModel\n    ) {}\n\n    async update(record: ILockRecord): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = createLockRecordDatabaseId(record.id);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const recordValues = record.toObject();\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                return await this.updateEntry.execute(this.model, id, {\n                    ...recordValues,\n                    values: recordValues\n                });\n            });\n\n            if (result.isFail()) {\n                return Result.fail(new UnlockEntryRequestError(result.error));\n            }\n\n            return Result.ok(record);\n        } catch (error) {\n            return Result.fail(new UnlockEntryRequestError(error as Error));\n        }\n    }\n}\n\nexport const UnlockEntryRequestRepository = RepositoryAbstraction.createImplementation({\n    implementation: UnlockEntryRequestRepositoryImpl,\n    dependencies: [UpdateEntryUseCase, IdentityContext, RecordLockingModel]\n});\n"],"names":["UnlockEntryRequestRepositoryImpl","updateEntry","identityContext","model","record","entryId","createLockRecordDatabaseId","id","createIdentifier","recordValues","result","Result","UnlockEntryRequestError","error","UnlockEntryRequestRepository","RepositoryAbstraction","UpdateEntryUseCase","IdentityContext","RecordLockingModel"],"mappings":";;;;;;;;AAWA,MAAMA;IACF,YACYC,WAAyC,EACzCC,eAA0C,EAC1CC,KAAe,CACzB;aAHUF,WAAW,GAAXA;aACAC,eAAe,GAAfA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,OAAOC,MAAmB,EAA6D;QACzF,IAAI;YACA,MAAMC,UAAUC,2BAA2BF,OAAO,EAAE;YACpD,MAAMG,KAAKC,iBAAiB;gBACxB,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,eAAeL,OAAO,QAAQ;YACpC,MAAMM,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,UACpD,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAEH,IAAI;oBAClD,GAAGE,YAAY;oBACf,QAAQA;gBACZ;YAGJ,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,wBAAwBF,OAAO,KAAK;YAG/D,OAAOC,OAAO,EAAE,CAACP;QACrB,EAAE,OAAOS,OAAO;YACZ,OAAOF,OAAO,IAAI,CAAC,IAAIC,wBAAwBC;QACnD;IACJ;AACJ;AAEO,MAAMC,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgBf;IAChB,cAAc;QAACgB;QAAoBC;QAAiBC;KAAmB;AAC3E"}
+{"version":3,"file":"features/UnlockEntryRequest/UnlockEntryRequestRepository.js","sources":["../../../src/features/UnlockEntryRequest/UnlockEntryRequestRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { UnlockEntryRequestRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { RecordLockingModelProvider } from \"~/domain/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { UnlockEntryRequestError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\nimport { createIdentifier } from \"@webiny/utils\";\n\nclass UnlockEntryRequestRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private identityContext: IdentityContext.Interface,\n        private modelProvider: RecordLockingModelProvider.Interface\n    ) {}\n\n    async update(record: ILockRecord): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const model = await this.modelProvider.get();\n\n            const entryId = createLockRecordDatabaseId(record.id);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const recordValues = record.toObject();\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                return await this.updateEntry.execute(model, id, {\n                    ...recordValues,\n                    values: recordValues\n                });\n            });\n\n            if (result.isFail()) {\n                return Result.fail(new UnlockEntryRequestError(result.error));\n            }\n\n            return Result.ok(record);\n        } catch (error) {\n            return Result.fail(new UnlockEntryRequestError(error as Error));\n        }\n    }\n}\n\nexport const UnlockEntryRequestRepository = RepositoryAbstraction.createImplementation({\n    implementation: UnlockEntryRequestRepositoryImpl,\n    dependencies: [UpdateEntryUseCase, IdentityContext, RecordLockingModelProvider]\n});\n"],"names":["UnlockEntryRequestRepositoryImpl","updateEntry","identityContext","modelProvider","record","model","entryId","createLockRecordDatabaseId","id","createIdentifier","recordValues","result","Result","UnlockEntryRequestError","error","UnlockEntryRequestRepository","RepositoryAbstraction","UpdateEntryUseCase","IdentityContext","RecordLockingModelProvider"],"mappings":";;;;;;;;AAUA,MAAMA;IACF,YACYC,WAAyC,EACzCC,eAA0C,EAC1CC,aAAmD,CAC7D;aAHUF,WAAW,GAAXA;aACAC,eAAe,GAAfA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,OAAOC,MAAmB,EAA6D;QACzF,IAAI;YACA,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;YAE1C,MAAMC,UAAUC,2BAA2BH,OAAO,EAAE;YACpD,MAAMI,KAAKC,iBAAiB;gBACxB,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,eAAeN,OAAO,QAAQ;YACpC,MAAMO,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,UACpD,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACN,OAAOG,IAAI;oBAC7C,GAAGE,YAAY;oBACf,QAAQA;gBACZ;YAGJ,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,wBAAwBF,OAAO,KAAK;YAG/D,OAAOC,OAAO,EAAE,CAACR;QACrB,EAAE,OAAOU,OAAO;YACZ,OAAOF,OAAO,IAAI,CAAC,IAAIC,wBAAwBC;QACnD;IACJ;AACJ;AAEO,MAAMC,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgBhB;IAChB,cAAc;QAACiB;QAAoBC;QAAiBC;KAA2B;AACnF"}

package/features/UpdateEntryLock/UpdateEntryLockRepository.d.ts

@@ -3,15 +3,16 @@ import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEnt
 import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
 import { Result } from "@webiny/feature/api";
 import { UpdateEntryLockRepository as RepositoryAbstraction } from "./abstractions.js";
-import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import { RecordLockingConfig } from "../../domain/abstractions.js";
+import { RecordLockingModelProvider } from "../../domain/abstractions.js";
 import type { ILockRecord } from "../../domain/LockRecord.js";
 declare class UpdateEntryLockRepositoryImpl implements RepositoryAbstraction.Interface {
-    private model;
+    private modelProvider;
     private config;
     private identityContext;
     private updateEntry;
     private getEntryById;
-    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, identityContext: IdentityContext.Interface, updateEntry: UpdateEntryUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface);
+    constructor(modelProvider: RecordLockingModelProvider.Interface, config: RecordLockingConfig.Interface, identityContext: IdentityContext.Interface, updateEntry: UpdateEntryUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface);
     update(lockRecordId: string, updateOwner: boolean): Promise<Result<ILockRecord, RepositoryAbstraction.Error>>;
 }
 export declare const UpdateEntryLockRepository: typeof UpdateEntryLockRepositoryImpl & {

package/features/UpdateEntryLock/UpdateEntryLockRepository.js

@@ -4,13 +4,13 @@ import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEn
 import { Result } from "@webiny/feature/api";
 import { createIdentifier } from "@webiny/utils";
 import { UpdateEntryLockRepository } from "./abstractions.js";
-import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import { RecordLockingConfig, RecordLockingModelProvider } from "../../domain/abstractions.js";
 import { LockRecord } from "../../domain/LockRecord.js";
 import { LockRecordPersistenceError } from "../../domain/errors.js";
 import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
 class UpdateEntryLockRepositoryImpl {
-    constructor(model, config, identityContext, updateEntry, getEntryById){
-        this.model = model;
+    constructor(modelProvider, config, identityContext, updateEntry, getEntryById){
+        this.modelProvider = modelProvider;
         this.config = config;
         this.identityContext = identityContext;
         this.updateEntry = updateEntry;
@@ -18,6 +18,7 @@ class UpdateEntryLockRepositoryImpl {
     }
     async update(lockRecordId, updateOwner) {
         try {
+            const model = await this.modelProvider.get();
             const entryId = createLockRecordDatabaseId(lockRecordId);
             const id = createIdentifier({
                 id: entryId,
@@ -33,9 +34,9 @@ class UpdateEntryLockRepositoryImpl {
                 updateData.createdBy = identity;
                 updateData.savedBy = identity;
             }
-            const result = await this.updateEntry.execute(this.model, id, updateData);
+            const result = await this.updateEntry.execute(model, id, updateData);
             if (result.isFail()) return Result.fail(new LockRecordPersistenceError(result.error));
-            const getResult = await this.getEntryById.execute(this.model, id);
+            const getResult = await this.getEntryById.execute(model, id);
             if (getResult.isFail()) return Result.fail(new LockRecordPersistenceError(getResult.error));
             const entry = getResult.value;
             const lockRecord = new LockRecord(entry, this.config.timeout);
@@ -48,7 +49,7 @@ class UpdateEntryLockRepositoryImpl {
 const UpdateEntryLockRepository_UpdateEntryLockRepository = UpdateEntryLockRepository.createImplementation({
     implementation: UpdateEntryLockRepositoryImpl,
     dependencies: [
-        RecordLockingModel,
+        RecordLockingModelProvider,
         RecordLockingConfig,
         IdentityContext,
         UpdateEntryUseCase,

package/features/UpdateEntryLock/UpdateEntryLockRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/UpdateEntryLock/UpdateEntryLockRepository.js","sources":["../../../src/features/UpdateEntryLock/UpdateEntryLockRepository.ts"],"sourcesContent":["import { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { Result } from \"@webiny/feature/api\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { UpdateEntryLockRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/types.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass UpdateEntryLockRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private identityContext: IdentityContext.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async update(\n        lockRecordId: string,\n        updateOwner: boolean\n    ): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = createLockRecordDatabaseId(lockRecordId);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const identity = this.identityContext.getIdentity();\n            const now = new Date().toISOString();\n\n            // Build update data\n            const updateData: any = {\n                savedOn: now\n            };\n\n            // If updating owner (expired lock), also update created fields\n            if (updateOwner) {\n                updateData.createdOn = now;\n                updateData.createdBy = identity;\n                updateData.savedBy = identity;\n            }\n\n            const result = await this.updateEntry.execute(this.model, id, updateData);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            // Fetch the updated entry to return full lock record\n            const getResult = await this.getEntryById.execute<LockRecordValues>(this.model, id);\n\n            if (getResult.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(getResult.error));\n            }\n\n            const entry = getResult.value;\n            const lockRecord = new LockRecord(entry, this.config.timeout);\n\n            return Result.ok(lockRecord);\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const UpdateEntryLockRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateEntryLockRepositoryImpl,\n    dependencies: [\n        RecordLockingModel,\n        RecordLockingConfig,\n        IdentityContext,\n        UpdateEntryUseCase,\n        GetEntryByIdUseCase\n    ]\n});\n"],"names":["UpdateEntryLockRepositoryImpl","model","config","identityContext","updateEntry","getEntryById","lockRecordId","updateOwner","entryId","createLockRecordDatabaseId","id","createIdentifier","identity","now","Date","updateData","result","Result","LockRecordPersistenceError","getResult","entry","lockRecord","LockRecord","error","UpdateEntryLockRepository","RepositoryAbstraction","RecordLockingModel","RecordLockingConfig","IdentityContext","UpdateEntryUseCase","GetEntryByIdUseCase"],"mappings":";;;;;;;;;;AAaA,MAAMA;IACF,YACYC,KAAmC,EACnCC,MAAqC,EACrCC,eAA0C,EAC1CC,WAAyC,EACzCC,YAA2C,CACrD;aALUJ,KAAK,GAALA;aACAC,MAAM,GAANA;aACAC,eAAe,GAAfA;aACAC,WAAW,GAAXA;aACAC,YAAY,GAAZA;IACT;IAEH,MAAM,OACFC,YAAoB,EACpBC,WAAoB,EACqC;QACzD,IAAI;YACA,MAAMC,UAAUC,2BAA2BH;YAC3C,MAAMI,KAAKC,iBAAiB;gBACxB,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;YACjD,MAAMC,MAAM,IAAIC,OAAO,WAAW;YAGlC,MAAMC,aAAkB;gBACpB,SAASF;YACb;YAGA,IAAIN,aAAa;gBACbQ,WAAW,SAAS,GAAGF;gBACvBE,WAAW,SAAS,GAAGH;gBACvBG,WAAW,OAAO,GAAGH;YACzB;YAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAEN,IAAIK;YAE9D,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAIlE,MAAMG,YAAY,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAmB,IAAI,CAAC,KAAK,EAAET;YAEhF,IAAIS,UAAU,MAAM,IAChB,OAAOF,OAAO,IAAI,CAAC,IAAIC,2BAA2BC,UAAU,KAAK;YAGrE,MAAMC,QAAQD,UAAU,KAAK;YAC7B,MAAME,aAAa,IAAIC,WAAWF,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5D,OAAOH,OAAO,EAAE,CAACI;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAON,OAAO,IAAI,CAAC,IAAIC,2BAA2BK;QACtD;IACJ;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAA0C,CAAC;IAChF,gBAAgBzB;IAChB,cAAc;QACV0B;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}
+{"version":3,"file":"features/UpdateEntryLock/UpdateEntryLockRepository.js","sources":["../../../src/features/UpdateEntryLock/UpdateEntryLockRepository.ts"],"sourcesContent":["import { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { Result } from \"@webiny/feature/api\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { UpdateEntryLockRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { RecordLockingConfig } from \"~/domain/abstractions.js\";\nimport { RecordLockingModelProvider } from \"~/domain/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/types.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass UpdateEntryLockRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private modelProvider: RecordLockingModelProvider.Interface,\n        private config: RecordLockingConfig.Interface,\n        private identityContext: IdentityContext.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async update(\n        lockRecordId: string,\n        updateOwner: boolean\n    ): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const model = await this.modelProvider.get();\n\n            const entryId = createLockRecordDatabaseId(lockRecordId);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const identity = this.identityContext.getIdentity();\n            const now = new Date().toISOString();\n\n            // Build update data\n            const updateData: any = {\n                savedOn: now\n            };\n\n            // If updating owner (expired lock), also update created fields\n            if (updateOwner) {\n                updateData.createdOn = now;\n                updateData.createdBy = identity;\n                updateData.savedBy = identity;\n            }\n\n            const result = await this.updateEntry.execute(model, id, updateData);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            // Fetch the updated entry to return full lock record\n            const getResult = await this.getEntryById.execute<LockRecordValues>(model, id);\n\n            if (getResult.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(getResult.error));\n            }\n\n            const entry = getResult.value;\n            const lockRecord = new LockRecord(entry, this.config.timeout);\n\n            return Result.ok(lockRecord);\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const UpdateEntryLockRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateEntryLockRepositoryImpl,\n    dependencies: [\n        RecordLockingModelProvider,\n        RecordLockingConfig,\n        IdentityContext,\n        UpdateEntryUseCase,\n        GetEntryByIdUseCase\n    ]\n});\n"],"names":["UpdateEntryLockRepositoryImpl","modelProvider","config","identityContext","updateEntry","getEntryById","lockRecordId","updateOwner","model","entryId","createLockRecordDatabaseId","id","createIdentifier","identity","now","Date","updateData","result","Result","LockRecordPersistenceError","getResult","entry","lockRecord","LockRecord","error","UpdateEntryLockRepository","RepositoryAbstraction","RecordLockingModelProvider","RecordLockingConfig","IdentityContext","UpdateEntryUseCase","GetEntryByIdUseCase"],"mappings":";;;;;;;;;;AAcA,MAAMA;IACF,YACYC,aAAmD,EACnDC,MAAqC,EACrCC,eAA0C,EAC1CC,WAAyC,EACzCC,YAA2C,CACrD;aALUJ,aAAa,GAAbA;aACAC,MAAM,GAANA;aACAC,eAAe,GAAfA;aACAC,WAAW,GAAXA;aACAC,YAAY,GAAZA;IACT;IAEH,MAAM,OACFC,YAAoB,EACpBC,WAAoB,EACqC;QACzD,IAAI;YACA,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;YAE1C,MAAMC,UAAUC,2BAA2BJ;YAC3C,MAAMK,KAAKC,iBAAiB;gBACxB,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;YACjD,MAAMC,MAAM,IAAIC,OAAO,WAAW;YAGlC,MAAMC,aAAkB;gBACpB,SAASF;YACb;YAGA,IAAIP,aAAa;gBACbS,WAAW,SAAS,GAAGF;gBACvBE,WAAW,SAAS,GAAGH;gBACvBG,WAAW,OAAO,GAAGH;YACzB;YAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACT,OAAOG,IAAIK;YAEzD,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAIlE,MAAMG,YAAY,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAmBZ,OAAOG;YAE3E,IAAIS,UAAU,MAAM,IAChB,OAAOF,OAAO,IAAI,CAAC,IAAIC,2BAA2BC,UAAU,KAAK;YAGrE,MAAMC,QAAQD,UAAU,KAAK;YAC7B,MAAME,aAAa,IAAIC,WAAWF,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5D,OAAOH,OAAO,EAAE,CAACI;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAON,OAAO,IAAI,CAAC,IAAIC,2BAA2BK;QACtD;IACJ;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAA0C,CAAC;IAChF,gBAAgB1B;IAChB,cAAc;QACV2B;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/graphql/RecordLockingGraphQLSchema.d.ts

@@ -0,0 +1,25 @@
+import { GraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { RecordLockingModelProvider } from "../domain/abstractions.js";
+/**
+ * The record locking GraphQL schema. The lock record type is rendered from the lock record model,
+ * which is loaded when the schema is composed.
+ */
+declare class RecordLockingGraphQLSchemaImpl implements GraphQLSchemaFactory.Interface {
+    private readonly tenantContext;
+    private readonly identityContext;
+    private readonly modelProvider;
+    private readonly listModelsUseCase;
+    private readonly fieldRegistry;
+    constructor(tenantContext: TenantContext.Interface, identityContext: IdentityContext.Interface, modelProvider: RecordLockingModelProvider.Interface, listModelsUseCase: ListModelsUseCase.Interface, fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface);
+    getSchemaKey(): Promise<string>;
+    execute(builder: GraphQLSchemaFactory.SchemaBuilder): Promise<GraphQLSchemaFactory.SchemaBuilder>;
+    private loadInputs;
+}
+export declare const RecordLockingGraphQLSchema: typeof RecordLockingGraphQLSchemaImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-graphql/graphql/abstractions.public.js").IGraphQLSchemaFactory>;
+};
+export {};

package/graphql/RecordLockingGraphQLSchema.js

@@ -0,0 +1,390 @@
+import { GraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { createModelSchemaKey } from "@webiny/api-headless-cms/utils/createModelSchemaKey.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { renderFields } from "@webiny/api-headless-cms/utils/renderFields.js";
+import { renderListFilterFields } from "@webiny/api-headless-cms/utils/renderListFilterFields.js";
+import { renderSortEnum } from "@webiny/api-headless-cms/utils/renderSortEnum.js";
+import { RecordLockingModelProvider } from "../domain/abstractions.js";
+import { IsEntryLockedUseCase } from "../features/IsEntryLocked/abstractions.js";
+import { GetLockRecordUseCase } from "../features/GetLockRecord/abstractions.js";
+import { GetLockedEntryLockRecordUseCase } from "../features/GetLockedEntryLockRecord/abstractions.js";
+import { ListLockRecordsUseCase } from "../features/ListLockRecords/abstractions.js";
+import { ListAllLockRecordsUseCase } from "../features/ListAllLockRecords/abstractions.js";
+import { LockEntryUseCase } from "../features/LockEntry/abstractions.js";
+import { UpdateEntryLockUseCase } from "../features/UpdateEntryLock/abstractions.js";
+import { UnlockEntryUseCase } from "../features/UnlockEntry/abstractions.js";
+import { UnlockEntryRequestUseCase } from "../features/UnlockEntryRequest/abstractions.js";
+import { resolve, resolveList } from "./resolve.js";
+import { checkPermissions } from "./checkPermissions.js";
+function renderTypeDefs(params) {
+    const { model, fieldRegistry } = params;
+    const models = params.models.filter((model)=>model.fields.length > 0);
+    const recordLockingFields = renderFields({
+        models,
+        model,
+        fields: model.fields,
+        type: "manage",
+        fieldRegistry
+    });
+    const listFilterFieldsRender = renderListFilterFields({
+        model,
+        fields: model.fields,
+        type: "manage",
+        fieldRegistry,
+        excludeFields: [
+            "entryId"
+        ]
+    });
+    const sortEnumRender = renderSortEnum({
+        model,
+        fields: model.fields,
+        fieldRegistry,
+        sorters: []
+    });
+    return `
+        ${recordLockingFields.map((f)=>f.typeDefs).join("\n")}
+
+        type RecordLockingError {
+            message: String
+            code: String
+            data: JSON
+            stack: String
+        }
+
+        enum RecordLockingRecordActionType {
+            requested
+            approved
+            denied
+        }
+
+        type RecordLockingIdentity {
+            id: String!
+            displayName: String
+            type: String
+        }
+
+        type RecordLockingRecordAction {
+            id: ID!
+            type: RecordLockingRecordActionType!
+            message: String
+            createdBy: RecordLockingIdentity!
+            createdOn: DateTime!
+        }
+
+        type RecordLockingRecord {
+            id: ID!
+            lockedBy: RecordLockingIdentity!
+            lockedOn: DateTime!
+            updatedOn: DateTime!
+            expiresOn: DateTime!
+            ${recordLockingFields.map((f)=>f.fields).join("\n")}
+        }
+
+        type RecordLockingIsEntryLockedResponse {
+            data: Boolean
+            error: RecordLockingError
+        }
+
+        type RecordLockingGetLockRecordResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingGetLockedEntryLockRecordResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingListLockRecordsResponse {
+            data: [RecordLockingRecord!]
+            error: RecordLockingError
+        }
+
+        type RecordLockingLockEntryResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingUpdateLockResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingUnlockEntryResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingUnlockEntryRequestResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        input RecordLockingListWhereInput {
+            ${listFilterFieldsRender.allFiltersAsString()}
+        }
+
+        enum RecordLockingListSorter {
+            ${sortEnumRender}
+        }
+
+        type RecordLockingQuery {
+            _empty: String
+        }
+
+        type RecordLockingMutation {
+            _empty: String
+        }
+
+        extend type RecordLockingQuery {
+            isEntryLocked(id: ID!, type: String!): RecordLockingIsEntryLockedResponse!
+            getLockRecord(id: ID!, type: String!): RecordLockingGetLockRecordResponse!
+            # Returns lock record or null - if entry is locked in context of the current user, does not throw an error like getLockRecord if no record in the DB
+            getLockedEntryLockRecord(id: ID!, type: String!): RecordLockingGetLockedEntryLockRecordResponse!
+            listAllLockRecords(
+                where: RecordLockingListWhereInput
+                sort: [RecordLockingListSorter!]
+                limit: Int
+                after: String
+            ): RecordLockingListLockRecordsResponse!
+            # Basically same as listAllLockRecords except this one will filter out records with expired lock.
+            listLockRecords(
+                where: RecordLockingListWhereInput
+                sort: [RecordLockingListSorter!]
+                limit: Int
+                after: String
+            ): RecordLockingListLockRecordsResponse!
+        }
+
+        extend type RecordLockingMutation {
+            lockEntry(id: ID!, type: String!): RecordLockingLockEntryResponse!
+            updateEntryLock(id: ID!, type: String!): RecordLockingUpdateLockResponse!
+            unlockEntry(id: ID!, type: String!, force: Boolean): RecordLockingUnlockEntryResponse!
+            unlockEntryRequest(
+                id: ID!
+                type: String!
+            ): RecordLockingUnlockEntryRequestResponse!
+        }
+
+        extend type Query {
+            recordLocking: RecordLockingQuery
+        }
+
+        extend type Mutation {
+            recordLocking: RecordLockingMutation
+        }
+    `;
+}
+function addQueryResolvers(builder) {
+    builder.addResolver({
+        path: "Query.recordLocking",
+        resolver: ()=>async ()=>({})
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.isEntryLocked",
+        dependencies: [
+            IdentityContext,
+            IsEntryLockedUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.getLockRecord",
+        dependencies: [
+            IdentityContext,
+            GetLockRecordUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.getLockedEntryLockRecord",
+        dependencies: [
+            IdentityContext,
+            GetLockedEntryLockRecordUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) return null;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.listLockRecords",
+        dependencies: [
+            IdentityContext,
+            ListLockRecordsUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolveList(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute(args);
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.listAllLockRecords",
+        dependencies: [
+            IdentityContext,
+            ListAllLockRecordsUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolveList(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute(args);
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+}
+function addMutationResolvers(builder) {
+    builder.addResolver({
+        path: "Mutation.recordLocking",
+        resolver: ()=>async ()=>({})
+    });
+    builder.addResolver({
+        path: "RecordLockingMutation.lockEntry",
+        dependencies: [
+            IdentityContext,
+            LockEntryUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingMutation.updateEntryLock",
+        dependencies: [
+            IdentityContext,
+            UpdateEntryLockUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingMutation.unlockEntry",
+        dependencies: [
+            IdentityContext,
+            UnlockEntryUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type,
+                        force: args.force
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingMutation.unlockEntryRequest",
+        dependencies: [
+            IdentityContext,
+            UnlockEntryRequestUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+}
+class RecordLockingGraphQLSchemaImpl {
+    constructor(tenantContext, identityContext, modelProvider, listModelsUseCase, fieldRegistry){
+        this.tenantContext = tenantContext;
+        this.identityContext = identityContext;
+        this.modelProvider = modelProvider;
+        this.listModelsUseCase = listModelsUseCase;
+        this.fieldRegistry = fieldRegistry;
+    }
+    async getSchemaKey() {
+        const inputs = await this.loadInputs();
+        if (!inputs) return "RecordLocking:no-tenant";
+        const modelKey = createModelSchemaKey([
+            inputs.model
+        ], inputs.models);
+        return `RecordLocking:${modelKey}`;
+    }
+    async execute(builder) {
+        const inputs = await this.loadInputs();
+        if (!inputs) return builder;
+        const { model, models } = inputs;
+        const typeDefs = renderTypeDefs({
+            model,
+            models,
+            fieldRegistry: this.fieldRegistry
+        });
+        builder.addTypeDefs(typeDefs);
+        addQueryResolvers(builder);
+        addMutationResolvers(builder);
+        return builder;
+    }
+    async loadInputs() {
+        if (!this.tenantContext.getTenant()) return null;
+        const model = await this.modelProvider.get();
+        const models = await this.identityContext.withoutAuthorization(async ()=>{
+            const result = await this.listModelsUseCase.execute({
+                includePrivate: false
+            });
+            if (result.isFail()) throw result.error;
+            return result.value;
+        });
+        return {
+            model,
+            models
+        };
+    }
+}
+const RecordLockingGraphQLSchema = GraphQLSchemaFactory.createImplementation({
+    implementation: RecordLockingGraphQLSchemaImpl,
+    dependencies: [
+        TenantContext,
+        IdentityContext,
+        RecordLockingModelProvider,
+        ListModelsUseCase,
+        CmsModelFieldToGraphQLRegistry
+    ]
+});
+export { RecordLockingGraphQLSchema };
+
+//# sourceMappingURL=RecordLockingGraphQLSchema.js.map