@webiny/api-record-locking 6.6.0-alpha.6 → 6.6.0-alpha.8

package/RecordLockingAppFeature.js

@@ -1,18 +1,18 @@
 import { createFeature } from "@webiny/feature/api";
 import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
 import { RecordLockingModel } from "./domain/RecordLockingModel.js";
-import { RecordLockingAppConfig } from "./domain/RecordLockingAppConfig.js";
+import { RecordLockingFeature } from "./features/RecordLockingFeature.js";
+import { RecordLockingGraphQLSchema } from "./graphql/RecordLockingGraphQLSchema.js";
 import { getTimeout } from "./utils/getTimeout.js";
-import { RecordLockingContextualSchema } from "./graphql/RecordLockingContextualSchema.js";
 const RecordLockingAppFeature = createFeature({
     name: "RecordLockingApp",
     register (container, params) {
         if (!container.resolve(FeatureFlags).get().isEnabled("recordLocking")) return;
         container.register(RecordLockingModel);
-        container.registerInstance(RecordLockingAppConfig, {
+        RecordLockingFeature.register(container, {
             timeout: getTimeout(params?.timeout)
         });
-        container.register(RecordLockingContextualSchema);
+        container.register(RecordLockingGraphQLSchema);
     }
 });
 export { RecordLockingAppFeature };

package/RecordLockingAppFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"RecordLockingAppFeature.js","sources":["../src/RecordLockingAppFeature.ts"],"sourcesContent":["import { type Container, createFeature } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { RecordLockingModel } from \"~/domain/RecordLockingModel.js\";\nimport { RecordLockingAppConfig } from \"~/domain/RecordLockingAppConfig.js\";\nimport { getTimeout } from \"~/utils/getTimeout.js\";\nimport { RecordLockingContextualSchema } from \"~/graphql/RecordLockingContextualSchema.js\";\n\nexport interface IRecordLockingAppFeatureParams {\n    /**\n     * A number of seconds after the last activity to wait before the record is automatically unlocked.\n     */\n    timeout?: number;\n}\n\nexport const RecordLockingAppFeature = createFeature<IRecordLockingAppFeatureParams>({\n    name: \"RecordLockingApp\",\n    register(container: Container, params: IRecordLockingAppFeatureParams) {\n        // Record locking is license-gated — check at register time (license is fresh pre-register)\n        // so nothing wires up without the entitlement.\n        if (!container.resolve(FeatureFlags).get().isEnabled(\"recordLocking\")) {\n            return;\n        }\n\n        container.register(RecordLockingModel);\n        container.registerInstance(RecordLockingAppConfig, {\n            timeout: getTimeout(params?.timeout)\n        });\n        container.register(RecordLockingContextualSchema);\n    }\n});\n"],"names":["RecordLockingAppFeature","createFeature","container","params","FeatureFlags","RecordLockingModel","RecordLockingAppConfig","getTimeout","RecordLockingContextualSchema"],"mappings":";;;;;;AAcO,MAAMA,0BAA0BC,cAA8C;IACjF,MAAM;IACN,UAASC,SAAoB,EAAEC,MAAsC;QAGjE,IAAI,CAACD,UAAU,OAAO,CAACE,cAAc,GAAG,GAAG,SAAS,CAAC,kBACjD;QAGJF,UAAU,QAAQ,CAACG;QACnBH,UAAU,gBAAgB,CAACI,wBAAwB;YAC/C,SAASC,WAAWJ,QAAQ;QAChC;QACAD,UAAU,QAAQ,CAACM;IACvB;AACJ"}
+{"version":3,"file":"RecordLockingAppFeature.js","sources":["../src/RecordLockingAppFeature.ts"],"sourcesContent":["import { type Container, createFeature } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { RecordLockingModel } from \"~/domain/RecordLockingModel.js\";\nimport { RecordLockingFeature } from \"~/features/RecordLockingFeature.js\";\nimport { RecordLockingGraphQLSchema } from \"~/graphql/RecordLockingGraphQLSchema.js\";\nimport { getTimeout } from \"~/utils/getTimeout.js\";\n\nexport interface IRecordLockingAppFeatureParams {\n    /**\n     * A number of seconds after the last activity to wait before the record is automatically unlocked.\n     */\n    timeout?: number;\n}\n\nexport const RecordLockingAppFeature = createFeature<IRecordLockingAppFeatureParams>({\n    name: \"RecordLockingApp\",\n    register(container: Container, params: IRecordLockingAppFeatureParams) {\n        // Record locking is license-gated — check at register time (license is fresh pre-register)\n        // so nothing wires up without the entitlement.\n        if (!container.resolve(FeatureFlags).get().isEnabled(\"recordLocking\")) {\n            return;\n        }\n\n        container.register(RecordLockingModel);\n        RecordLockingFeature.register(container, {\n            timeout: getTimeout(params?.timeout)\n        });\n        container.register(RecordLockingGraphQLSchema);\n    }\n});\n"],"names":["RecordLockingAppFeature","createFeature","container","params","FeatureFlags","RecordLockingModel","RecordLockingFeature","getTimeout","RecordLockingGraphQLSchema"],"mappings":";;;;;;AAcO,MAAMA,0BAA0BC,cAA8C;IACjF,MAAM;IACN,UAASC,SAAoB,EAAEC,MAAsC;QAGjE,IAAI,CAACD,UAAU,OAAO,CAACE,cAAc,GAAG,GAAG,SAAS,CAAC,kBACjD;QAGJF,UAAU,QAAQ,CAACG;QACnBC,qBAAqB,QAAQ,CAACJ,WAAW;YACrC,SAASK,WAAWJ,QAAQ;QAChC;QACAD,UAAU,QAAQ,CAACM;IACvB;AACJ"}

package/domain/abstractions.d.ts

@@ -12,7 +12,13 @@ export declare const RecordLockingConfig: import("@webiny/di").Abstraction<IReco
 export declare namespace RecordLockingConfig {
     type Interface = IRecordLockingConfig;
 }
-export declare const RecordLockingModel: import("@webiny/di").Abstraction<CmsModel>;
-export declare namespace RecordLockingModel {
-    type Interface = CmsModel;
+/**
+ * RecordLockingModelProvider - Fetches the private CMS model that stores lock records.
+ */
+export interface IRecordLockingModelProvider {
+    get(): Promise<CmsModel>;
+}
+export declare const RecordLockingModelProvider: import("@webiny/di").Abstraction<IRecordLockingModelProvider>;
+export declare namespace RecordLockingModelProvider {
+    type Interface = IRecordLockingModelProvider;
 }

package/domain/abstractions.js

@@ -1,6 +1,6 @@
 import { createAbstraction } from "@webiny/feature/api";
 const RecordLockingConfig = createAbstraction("RecordLockingConfig");
-const RecordLockingModel = createAbstraction("RecordLockingModel");
-export { RecordLockingConfig, RecordLockingModel };
+const RecordLockingModelProvider = createAbstraction("RecordLockingModelProvider");
+export { RecordLockingConfig, RecordLockingModelProvider };
 
 //# sourceMappingURL=abstractions.js.map

package/domain/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain/abstractions.js","sources":["../../src/domain/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\n/**\n * RecordLockingConfig - Configuration for record locking timeout\n */\nexport interface IRecordLockingConfig {\n    /**\n     * Timeout in milliseconds after which a lock expires\n     */\n    timeout: number;\n}\n\nexport const RecordLockingConfig = createAbstraction<IRecordLockingConfig>(\"RecordLockingConfig\");\n\nexport namespace RecordLockingConfig {\n    export type Interface = IRecordLockingConfig;\n}\n\nexport const RecordLockingModel = createAbstraction<CmsModel>(\"RecordLockingModel\");\n\nexport namespace RecordLockingModel {\n    export type Interface = CmsModel;\n}\n"],"names":["RecordLockingConfig","createAbstraction","RecordLockingModel"],"mappings":";AAaO,MAAMA,sBAAsBC,kBAAwC;AAMpE,MAAMC,qBAAqBD,kBAA4B"}
+{"version":3,"file":"domain/abstractions.js","sources":["../../src/domain/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\n/**\n * RecordLockingConfig - Configuration for record locking timeout\n */\nexport interface IRecordLockingConfig {\n    /**\n     * Timeout in milliseconds after which a lock expires\n     */\n    timeout: number;\n}\n\nexport const RecordLockingConfig = createAbstraction<IRecordLockingConfig>(\"RecordLockingConfig\");\n\nexport namespace RecordLockingConfig {\n    export type Interface = IRecordLockingConfig;\n}\n\n/**\n * RecordLockingModelProvider - Fetches the private CMS model that stores lock records.\n */\nexport interface IRecordLockingModelProvider {\n    get(): Promise<CmsModel>;\n}\n\nexport const RecordLockingModelProvider = createAbstraction<IRecordLockingModelProvider>(\n    \"RecordLockingModelProvider\"\n);\n\nexport namespace RecordLockingModelProvider {\n    export type Interface = IRecordLockingModelProvider;\n}\n"],"names":["RecordLockingConfig","createAbstraction","RecordLockingModelProvider"],"mappings":";AAaO,MAAMA,sBAAsBC,kBAAwC;AAapE,MAAMC,6BAA6BD,kBACtC"}

package/features/GetLockRecord/GetLockRecordRepository.d.ts

@@ -1,13 +1,14 @@
 import { Result } from "@webiny/feature/api";
 import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
 import { GetLockRecordRepository 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 GetLockRecordRepositoryImpl implements RepositoryAbstraction.Interface {
-    private model;
+    private modelProvider;
     private config;
     private getEntryById;
-    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, getEntryById: GetEntryByIdUseCase.Interface);
+    constructor(modelProvider: RecordLockingModelProvider.Interface, config: RecordLockingConfig.Interface, getEntryById: GetEntryByIdUseCase.Interface);
     get(id: string): Promise<Result<ILockRecord, RepositoryAbstraction.Error>>;
 }
 export declare const GetLockRecordRepository: typeof GetLockRecordRepositoryImpl & {

package/features/GetLockRecord/GetLockRecordRepository.js

@@ -2,35 +2,40 @@ import { Result } from "@webiny/feature/api";
 import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
 import { createIdentifier } from "@webiny/utils";
 import { GetLockRecordRepository } from "./abstractions.js";
-import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import { RecordLockingConfig, RecordLockingModelProvider } from "../../domain/abstractions.js";
 import { LockRecord } from "../../domain/LockRecord.js";
 import { LockRecordNotFoundError, LockRecordPersistenceError } from "../../domain/errors.js";
 import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
 class GetLockRecordRepositoryImpl {
-    constructor(model, config, getEntryById){
-        this.model = model;
+    constructor(modelProvider, config, getEntryById){
+        this.modelProvider = modelProvider;
         this.config = config;
         this.getEntryById = getEntryById;
     }
     async get(id) {
-        const recordId = createLockRecordDatabaseId(id);
-        const entryId = createIdentifier({
-            id: recordId,
-            version: 1
-        });
-        const result = await this.getEntryById.execute(this.model, entryId);
-        if (result.isFail()) {
-            if ("Cms/Entry/NotFound" === result.error.code) return Result.fail(new LockRecordNotFoundError());
-            return Result.fail(new LockRecordPersistenceError(result.error));
+        try {
+            const model = await this.modelProvider.get();
+            const recordId = createLockRecordDatabaseId(id);
+            const entryId = createIdentifier({
+                id: recordId,
+                version: 1
+            });
+            const result = await this.getEntryById.execute(model, entryId);
+            if (result.isFail()) {
+                if ("Cms/Entry/NotFound" === result.error.code) return Result.fail(new LockRecordNotFoundError());
+                return Result.fail(new LockRecordPersistenceError(result.error));
+            }
+            const entry = result.value;
+            return Result.ok(new LockRecord(entry, this.config.timeout));
+        } catch (error) {
+            return Result.fail(new LockRecordPersistenceError(error));
         }
-        const entry = result.value;
-        return Result.ok(new LockRecord(entry, this.config.timeout));
     }
 }
 const GetLockRecordRepository_GetLockRecordRepository = GetLockRecordRepository.createImplementation({
     implementation: GetLockRecordRepositoryImpl,
     dependencies: [
-        RecordLockingModel,
+        RecordLockingModelProvider,
         RecordLockingConfig,
         GetEntryByIdUseCase
     ]

package/features/GetLockRecord/GetLockRecordRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/GetLockRecord/GetLockRecordRepository.js","sources":["../../../src/features/GetLockRecord/GetLockRecordRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { GetLockRecordRepository 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 { LockRecordNotFoundError, LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass GetLockRecordRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async get(id: string): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        const recordId = createLockRecordDatabaseId(id);\n        const entryId = createIdentifier({\n            id: recordId,\n            version: 1\n        });\n\n        const result = await this.getEntryById.execute<LockRecordValues>(this.model, entryId);\n\n        if (result.isFail()) {\n            if (result.error.code === \"Cms/Entry/NotFound\") {\n                return Result.fail(new LockRecordNotFoundError());\n            }\n\n            return Result.fail(new LockRecordPersistenceError(result.error));\n        }\n\n        const entry = result.value;\n\n        return Result.ok(new LockRecord(entry, this.config.timeout));\n    }\n}\n\nexport const GetLockRecordRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetLockRecordRepositoryImpl,\n    dependencies: [RecordLockingModel, RecordLockingConfig, GetEntryByIdUseCase]\n});\n"],"names":["GetLockRecordRepositoryImpl","model","config","getEntryById","id","recordId","createLockRecordDatabaseId","entryId","createIdentifier","result","Result","LockRecordNotFoundError","LockRecordPersistenceError","entry","LockRecord","GetLockRecordRepository","RepositoryAbstraction","RecordLockingModel","RecordLockingConfig","GetEntryByIdUseCase"],"mappings":";;;;;;;;AAWA,MAAMA;IACF,YACYC,KAAmC,EACnCC,MAAqC,EACrCC,YAA2C,CACrD;aAHUF,KAAK,GAALA;aACAC,MAAM,GAANA;aACAC,YAAY,GAAZA;IACT;IAEH,MAAM,IAAIC,EAAU,EAA6D;QAC7E,MAAMC,WAAWC,2BAA2BF;QAC5C,MAAMG,UAAUC,iBAAiB;YAC7B,IAAIH;YACJ,SAAS;QACb;QAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAmB,IAAI,CAAC,KAAK,EAAEF;QAE7E,IAAIE,OAAO,MAAM,IAAI;YACjB,IAAIA,AAAsB,yBAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC;YAG3B,OAAOD,OAAO,IAAI,CAAC,IAAIE,2BAA2BH,OAAO,KAAK;QAClE;QAEA,MAAMI,QAAQJ,OAAO,KAAK;QAE1B,OAAOC,OAAO,EAAE,CAAC,IAAII,WAAWD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;IAC9D;AACJ;AAEO,MAAME,kDAA0BC,wBAAAA,oBAA0C,CAAC;IAC9E,gBAAgBhB;IAChB,cAAc;QAACiB;QAAoBC;QAAqBC;KAAoB;AAChF"}
+{"version":3,"file":"features/GetLockRecord/GetLockRecordRepository.js","sources":["../../../src/features/GetLockRecord/GetLockRecordRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { GetLockRecordRepository 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 { LockRecordNotFoundError, LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass GetLockRecordRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private modelProvider: RecordLockingModelProvider.Interface,\n        private config: RecordLockingConfig.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async get(id: string): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const model = await this.modelProvider.get();\n\n            const recordId = createLockRecordDatabaseId(id);\n            const entryId = createIdentifier({\n                id: recordId,\n                version: 1\n            });\n\n            const result = await this.getEntryById.execute<LockRecordValues>(model, entryId);\n\n            if (result.isFail()) {\n                if (result.error.code === \"Cms/Entry/NotFound\") {\n                    return Result.fail(new LockRecordNotFoundError());\n                }\n\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const entry = result.value;\n\n            return Result.ok(new LockRecord(entry, this.config.timeout));\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const GetLockRecordRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetLockRecordRepositoryImpl,\n    dependencies: [RecordLockingModelProvider, RecordLockingConfig, GetEntryByIdUseCase]\n});\n"],"names":["GetLockRecordRepositoryImpl","modelProvider","config","getEntryById","id","model","recordId","createLockRecordDatabaseId","entryId","createIdentifier","result","Result","LockRecordNotFoundError","LockRecordPersistenceError","entry","LockRecord","error","GetLockRecordRepository","RepositoryAbstraction","RecordLockingModelProvider","RecordLockingConfig","GetEntryByIdUseCase"],"mappings":";;;;;;;;AAYA,MAAMA;IACF,YACYC,aAAmD,EACnDC,MAAqC,EACrCC,YAA2C,CACrD;aAHUF,aAAa,GAAbA;aACAC,MAAM,GAANA;aACAC,YAAY,GAAZA;IACT;IAEH,MAAM,IAAIC,EAAU,EAA6D;QAC7E,IAAI;YACA,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;YAE1C,MAAMC,WAAWC,2BAA2BH;YAC5C,MAAMI,UAAUC,iBAAiB;gBAC7B,IAAIH;gBACJ,SAAS;YACb;YAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAAmBL,OAAOG;YAExE,IAAIE,OAAO,MAAM,IAAI;gBACjB,IAAIA,AAAsB,yBAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC;gBAG3B,OAAOD,OAAO,IAAI,CAAC,IAAIE,2BAA2BH,OAAO,KAAK;YAClE;YAEA,MAAMI,QAAQJ,OAAO,KAAK;YAE1B,OAAOC,OAAO,EAAE,CAAC,IAAII,WAAWD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;QAC9D,EAAE,OAAOE,OAAO;YACZ,OAAOL,OAAO,IAAI,CAAC,IAAIE,2BAA2BG;QACtD;IACJ;AACJ;AAEO,MAAMC,kDAA0BC,wBAAAA,oBAA0C,CAAC;IAC9E,gBAAgBlB;IAChB,cAAc;QAACmB;QAA4BC;QAAqBC;KAAoB;AACxF"}

package/features/ListAllLockRecords/ListAllLockRecordsRepository.d.ts

@@ -1,15 +1,15 @@
 import { Result } from "@webiny/feature/api";
 import { ListAllLockRecordsRepository as RepositoryAbstraction, ListAllLockRecordsInput, ListAllLockRecordsOutput } from "./abstractions.js";
 import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
-import type { CmsModel } from "@webiny/api-headless-cms/types";
 import { CmsWhereMapper } from "@webiny/api-headless-cms";
 import { RecordLockingConfig } from "../../domain/abstractions.js";
+import { RecordLockingModelProvider } from "../../domain/abstractions.js";
 declare class ListAllLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {
     private config;
     private listEntries;
-    private model;
+    private modelProvider;
     private cmsWhereMapper;
-    constructor(config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface, model: CmsModel, cmsWhereMapper: CmsWhereMapper.Interface);
+    constructor(config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface, modelProvider: RecordLockingModelProvider.Interface, cmsWhereMapper: CmsWhereMapper.Interface);
     execute(input?: ListAllLockRecordsInput): Promise<Result<ListAllLockRecordsOutput, RepositoryAbstraction.Error>>;
 }
 export declare const ListAllLockRecordsRepository: typeof ListAllLockRecordsRepositoryImpl & {

package/features/ListAllLockRecords/ListAllLockRecordsRepository.js

@@ -2,27 +2,28 @@ import { Result } from "@webiny/feature/api";
 import { ListAllLockRecordsRepository } from "./abstractions.js";
 import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
 import { CmsWhereMapper } from "@webiny/api-headless-cms";
-import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import { RecordLockingConfig, RecordLockingModelProvider } from "../../domain/abstractions.js";
 import { LockRecordPersistenceError } from "../../domain/errors.js";
 import { convertWhereCondition } from "../../utils/convertWhereCondition.js";
 import { LockRecord } from "../../domain/LockRecord.js";
 class ListAllLockRecordsRepositoryImpl {
-    constructor(config, listEntries, model, cmsWhereMapper){
+    constructor(config, listEntries, modelProvider, cmsWhereMapper){
         this.config = config;
         this.listEntries = listEntries;
-        this.model = model;
+        this.modelProvider = modelProvider;
         this.cmsWhereMapper = cmsWhereMapper;
     }
     async execute(input) {
         try {
+            const model = await this.modelProvider.get();
             const params = {
                 ...input,
                 where: this.cmsWhereMapper.map({
                     input: convertWhereCondition(input?.where),
-                    fields: this.model.fields
+                    fields: model.fields
                 })
             };
-            const result = await this.listEntries.execute(this.model, params);
+            const result = await this.listEntries.execute(model, params);
             if (result.isFail()) return Result.fail(new LockRecordPersistenceError(result.error));
             const { entries, meta } = result.value;
             const items = entries.map((entry)=>new LockRecord(entry, this.config.timeout));
@@ -40,7 +41,7 @@ const ListAllLockRecordsRepository_ListAllLockRecordsRepository = ListAllLockRec
     dependencies: [
         RecordLockingConfig,
         ListLatestEntriesUseCase,
-        RecordLockingModel,
+        RecordLockingModelProvider,
         CmsWhereMapper
     ]
 });

package/features/ListAllLockRecords/ListAllLockRecordsRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/ListAllLockRecords/ListAllLockRecordsRepository.js","sources":["../../../src/features/ListAllLockRecords/ListAllLockRecordsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    ListAllLockRecordsRepository as RepositoryAbstraction,\n    ListAllLockRecordsInput,\n    ListAllLockRecordsOutput\n} from \"./abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/index.js\";\n\nclass ListAllLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private config: RecordLockingConfig.Interface,\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private model: CmsModel,\n        private cmsWhereMapper: CmsWhereMapper.Interface\n    ) {}\n\n    async execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const params = {\n                ...input,\n                where: this.cmsWhereMapper.map({\n                    input: convertWhereCondition(input?.where),\n                    fields: this.model.fields\n                })\n            };\n\n            const result = await this.listEntries.execute<LockRecordValues>(this.model, params);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const { entries, meta } = result.value;\n\n            const items = entries.map(entry => new LockRecord(entry, this.config.timeout));\n\n            return Result.ok({\n                items,\n                meta\n            });\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const ListAllLockRecordsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListAllLockRecordsRepositoryImpl,\n    dependencies: [\n        RecordLockingConfig,\n        ListLatestEntriesUseCase,\n        RecordLockingModel,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ListAllLockRecordsRepositoryImpl","config","listEntries","model","cmsWhereMapper","input","params","convertWhereCondition","result","Result","LockRecordPersistenceError","entries","meta","items","entry","LockRecord","error","ListAllLockRecordsRepository","RepositoryAbstraction","RecordLockingConfig","ListLatestEntriesUseCase","RecordLockingModel","CmsWhereMapper"],"mappings":";;;;;;;;AAeA,MAAMA;IACF,YACYC,MAAqC,EACrCC,WAA+C,EAC/CC,KAAe,EACfC,cAAwC,CAClD;aAJUH,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,KAAK,GAALA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QACFC,KAA+B,EACuC;QACtE,IAAI;YACA,MAAMC,SAAS;gBACX,GAAGD,KAAK;gBACR,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;oBAC3B,OAAOE,sBAAsBF,OAAO;oBACpC,QAAQ,IAAI,CAAC,KAAK,CAAC,MAAM;gBAC7B;YACJ;YAEA,MAAMG,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAmB,IAAI,CAAC,KAAK,EAAEF;YAE5E,IAAIE,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAGlE,MAAM,EAAEG,OAAO,EAAEC,IAAI,EAAE,GAAGJ,OAAO,KAAK;YAEtC,MAAMK,QAAQF,QAAQ,GAAG,CAACG,CAAAA,QAAS,IAAIC,WAAWD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5E,OAAOL,OAAO,EAAE,CAAC;gBACbI;gBACAD;YACJ;QACJ,EAAE,OAAOI,OAAO;YACZ,OAAOP,OAAO,IAAI,CAAC,IAAIC,2BAA2BM;QACtD;IACJ;AACJ;AAEO,MAAMC,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgBlB;IAChB,cAAc;QACVmB;QACAC;QACAC;QACAC;KACH;AACL"}
+{"version":3,"file":"features/ListAllLockRecords/ListAllLockRecordsRepository.js","sources":["../../../src/features/ListAllLockRecords/ListAllLockRecordsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    ListAllLockRecordsRepository as RepositoryAbstraction,\n    ListAllLockRecordsInput,\n    ListAllLockRecordsOutput\n} from \"./abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport { RecordLockingConfig } from \"~/domain/abstractions.js\";\nimport { RecordLockingModelProvider } from \"~/domain/abstractions.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/index.js\";\n\nclass ListAllLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private config: RecordLockingConfig.Interface,\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private modelProvider: RecordLockingModelProvider.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface\n    ) {}\n\n    async execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const model = await this.modelProvider.get();\n\n            const params = {\n                ...input,\n                where: this.cmsWhereMapper.map({\n                    input: convertWhereCondition(input?.where),\n                    fields: model.fields\n                })\n            };\n\n            const result = await this.listEntries.execute<LockRecordValues>(model, params);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const { entries, meta } = result.value;\n\n            const items = entries.map(entry => new LockRecord(entry, this.config.timeout));\n\n            return Result.ok({\n                items,\n                meta\n            });\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const ListAllLockRecordsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListAllLockRecordsRepositoryImpl,\n    dependencies: [\n        RecordLockingConfig,\n        ListLatestEntriesUseCase,\n        RecordLockingModelProvider,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ListAllLockRecordsRepositoryImpl","config","listEntries","modelProvider","cmsWhereMapper","input","model","params","convertWhereCondition","result","Result","LockRecordPersistenceError","entries","meta","items","entry","LockRecord","error","ListAllLockRecordsRepository","RepositoryAbstraction","RecordLockingConfig","ListLatestEntriesUseCase","RecordLockingModelProvider","CmsWhereMapper"],"mappings":";;;;;;;;AAeA,MAAMA;IACF,YACYC,MAAqC,EACrCC,WAA+C,EAC/CC,aAAmD,EACnDC,cAAwC,CAClD;aAJUH,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,aAAa,GAAbA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QACFC,KAA+B,EACuC;QACtE,IAAI;YACA,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;YAE1C,MAAMC,SAAS;gBACX,GAAGF,KAAK;gBACR,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;oBAC3B,OAAOG,sBAAsBH,OAAO;oBACpC,QAAQC,MAAM,MAAM;gBACxB;YACJ;YAEA,MAAMG,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAmBH,OAAOC;YAEvE,IAAIE,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAGlE,MAAM,EAAEG,OAAO,EAAEC,IAAI,EAAE,GAAGJ,OAAO,KAAK;YAEtC,MAAMK,QAAQF,QAAQ,GAAG,CAACG,CAAAA,QAAS,IAAIC,WAAWD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5E,OAAOL,OAAO,EAAE,CAAC;gBACbI;gBACAD;YACJ;QACJ,EAAE,OAAOI,OAAO;YACZ,OAAOP,OAAO,IAAI,CAAC,IAAIC,2BAA2BM;QACtD;IACJ;AACJ;AAEO,MAAMC,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgBnB;IAChB,cAAc;QACVoB;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/ListLockRecords/ListLockRecordsRepository.d.ts

@@ -1,14 +1,15 @@
 import { Result } from "@webiny/feature/api";
 import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
 import { ListLockRecordsRepository as RepositoryAbstraction, ListLockRecordsInput, ListLockRecordsOutput } from "./abstractions.js";
-import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import { RecordLockingConfig } from "../../domain/abstractions.js";
+import { RecordLockingModelProvider } from "../../domain/abstractions.js";
 import { CmsWhereMapper } from "@webiny/api-headless-cms";
 declare class ListLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {
-    private model;
+    private modelProvider;
     private config;
     private listEntries;
     private cmsWhereMapper;
-    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface, cmsWhereMapper: CmsWhereMapper.Interface);
+    constructor(modelProvider: RecordLockingModelProvider.Interface, config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface, cmsWhereMapper: CmsWhereMapper.Interface);
     execute(input?: ListLockRecordsInput): Promise<Result<ListLockRecordsOutput, RepositoryAbstraction.Error>>;
 }
 export declare const ListLockRecordsRepository: typeof ListLockRecordsRepositoryImpl & {

package/features/ListLockRecords/ListLockRecordsRepository.js

@@ -1,28 +1,29 @@
 import { Result } from "@webiny/feature/api";
 import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
 import { ListLockRecordsRepository } 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 { CmsWhereMapper } from "@webiny/api-headless-cms";
 import { convertWhereCondition } from "../../utils/convertWhereCondition.js";
 class ListLockRecordsRepositoryImpl {
-    constructor(model, config, listEntries, cmsWhereMapper){
-        this.model = model;
+    constructor(modelProvider, config, listEntries, cmsWhereMapper){
+        this.modelProvider = modelProvider;
         this.config = config;
         this.listEntries = listEntries;
         this.cmsWhereMapper = cmsWhereMapper;
     }
     async execute(input) {
         try {
+            const model = await this.modelProvider.get();
             const params = {
                 ...input,
                 where: this.cmsWhereMapper.map({
                     input: convertWhereCondition(input?.where),
-                    fields: this.model.fields
+                    fields: model.fields
                 })
             };
-            const result = await this.listEntries.execute(this.model, params);
+            const result = await this.listEntries.execute(model, params);
             if (result.isFail()) return Result.fail(new LockRecordPersistenceError(result.error));
             const { entries, meta } = result.value;
             const items = entries.map((entry)=>new LockRecord(entry, this.config.timeout));
@@ -38,7 +39,7 @@ class ListLockRecordsRepositoryImpl {
 const ListLockRecordsRepository_ListLockRecordsRepository = ListLockRecordsRepository.createImplementation({
     implementation: ListLockRecordsRepositoryImpl,
     dependencies: [
-        RecordLockingModel,
+        RecordLockingModelProvider,
         RecordLockingConfig,
         ListLatestEntriesUseCase,
         CmsWhereMapper

package/features/ListLockRecords/ListLockRecordsRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/ListLockRecords/ListLockRecordsRepository.js","sources":["../../../src/features/ListLockRecords/ListLockRecordsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport {\n    ListLockRecordsRepository as RepositoryAbstraction,\n    ListLockRecordsInput,\n    ListLockRecordsOutput\n} from \"./abstractions.js\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/types.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition.js\";\n\nclass ListLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface\n    ) {}\n\n    async execute(\n        input?: ListLockRecordsInput\n    ): Promise<Result<ListLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const params = {\n                ...input,\n                where: this.cmsWhereMapper.map({\n                    input: convertWhereCondition(input?.where),\n                    fields: this.model.fields\n                })\n            };\n\n            const result = await this.listEntries.execute<LockRecordValues>(this.model, params);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const { entries, meta } = result.value;\n\n            const items = entries.map(entry => new LockRecord(entry, this.config.timeout));\n\n            return Result.ok({\n                items,\n                meta\n            });\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const ListLockRecordsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListLockRecordsRepositoryImpl,\n    dependencies: [\n        RecordLockingModel,\n        RecordLockingConfig,\n        ListLatestEntriesUseCase,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ListLockRecordsRepositoryImpl","model","config","listEntries","cmsWhereMapper","input","params","convertWhereCondition","result","Result","LockRecordPersistenceError","entries","meta","items","entry","LockRecord","error","ListLockRecordsRepository","RepositoryAbstraction","RecordLockingModel","RecordLockingConfig","ListLatestEntriesUseCase","CmsWhereMapper"],"mappings":";;;;;;;;AAcA,MAAMA;IACF,YACYC,KAAmC,EACnCC,MAAqC,EACrCC,WAA+C,EAC/CC,cAAwC,CAClD;aAJUH,KAAK,GAALA;aACAC,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QACFC,KAA4B,EACuC;QACnE,IAAI;YACA,MAAMC,SAAS;gBACX,GAAGD,KAAK;gBACR,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;oBAC3B,OAAOE,sBAAsBF,OAAO;oBACpC,QAAQ,IAAI,CAAC,KAAK,CAAC,MAAM;gBAC7B;YACJ;YAEA,MAAMG,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAmB,IAAI,CAAC,KAAK,EAAEF;YAE5E,IAAIE,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAGlE,MAAM,EAAEG,OAAO,EAAEC,IAAI,EAAE,GAAGJ,OAAO,KAAK;YAEtC,MAAMK,QAAQF,QAAQ,GAAG,CAACG,CAAAA,QAAS,IAAIC,WAAWD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5E,OAAOL,OAAO,EAAE,CAAC;gBACbI;gBACAD;YACJ;QACJ,EAAE,OAAOI,OAAO;YACZ,OAAOP,OAAO,IAAI,CAAC,IAAIC,2BAA2BM;QACtD;IACJ;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAA0C,CAAC;IAChF,gBAAgBlB;IAChB,cAAc;QACVmB;QACAC;QACAC;QACAC;KACH;AACL"}
+{"version":3,"file":"features/ListLockRecords/ListLockRecordsRepository.js","sources":["../../../src/features/ListLockRecords/ListLockRecordsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport {\n    ListLockRecordsRepository as RepositoryAbstraction,\n    ListLockRecordsInput,\n    ListLockRecordsOutput\n} from \"./abstractions.js\";\nimport { RecordLockingConfig } from \"~/domain/abstractions.js\";\nimport { RecordLockingModelProvider } from \"~/domain/abstractions.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/types.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition.js\";\n\nclass ListLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private modelProvider: RecordLockingModelProvider.Interface,\n        private config: RecordLockingConfig.Interface,\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface\n    ) {}\n\n    async execute(\n        input?: ListLockRecordsInput\n    ): Promise<Result<ListLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const model = await this.modelProvider.get();\n\n            const params = {\n                ...input,\n                where: this.cmsWhereMapper.map({\n                    input: convertWhereCondition(input?.where),\n                    fields: model.fields\n                })\n            };\n\n            const result = await this.listEntries.execute<LockRecordValues>(model, params);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const { entries, meta } = result.value;\n\n            const items = entries.map(entry => new LockRecord(entry, this.config.timeout));\n\n            return Result.ok({\n                items,\n                meta\n            });\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const ListLockRecordsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListLockRecordsRepositoryImpl,\n    dependencies: [\n        RecordLockingModelProvider,\n        RecordLockingConfig,\n        ListLatestEntriesUseCase,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ListLockRecordsRepositoryImpl","modelProvider","config","listEntries","cmsWhereMapper","input","model","params","convertWhereCondition","result","Result","LockRecordPersistenceError","entries","meta","items","entry","LockRecord","error","ListLockRecordsRepository","RepositoryAbstraction","RecordLockingModelProvider","RecordLockingConfig","ListLatestEntriesUseCase","CmsWhereMapper"],"mappings":";;;;;;;;AAeA,MAAMA;IACF,YACYC,aAAmD,EACnDC,MAAqC,EACrCC,WAA+C,EAC/CC,cAAwC,CAClD;aAJUH,aAAa,GAAbA;aACAC,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QACFC,KAA4B,EACuC;QACnE,IAAI;YACA,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;YAE1C,MAAMC,SAAS;gBACX,GAAGF,KAAK;gBACR,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;oBAC3B,OAAOG,sBAAsBH,OAAO;oBACpC,QAAQC,MAAM,MAAM;gBACxB;YACJ;YAEA,MAAMG,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAmBH,OAAOC;YAEvE,IAAIE,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAGlE,MAAM,EAAEG,OAAO,EAAEC,IAAI,EAAE,GAAGJ,OAAO,KAAK;YAEtC,MAAMK,QAAQF,QAAQ,GAAG,CAACG,CAAAA,QAAS,IAAIC,WAAWD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5E,OAAOL,OAAO,EAAE,CAAC;gBACbI;gBACAD;YACJ;QACJ,EAAE,OAAOI,OAAO;YACZ,OAAOP,OAAO,IAAI,CAAC,IAAIC,2BAA2BM;QACtD;IACJ;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAA0C,CAAC;IAChF,gBAAgBnB;IAChB,cAAc;QACVoB;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/LockEntry/LockEntryRepository.d.ts

@@ -1,13 +1,14 @@
 import { Result } from "@webiny/feature/api";
 import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
 import { LockEntryInput, LockEntryRepository 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 LockEntryRepositoryImpl implements RepositoryAbstraction.Interface {
-    private model;
+    private modelProvider;
     private config;
     private createEntry;
-    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, createEntry: CreateEntryUseCase.Interface);
+    constructor(modelProvider: RecordLockingModelProvider.Interface, config: RecordLockingConfig.Interface, createEntry: CreateEntryUseCase.Interface);
     create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryAbstraction.Error>>;
 }
 export declare const LockEntryRepository: typeof LockEntryRepositoryImpl & {

package/features/LockEntry/LockEntryRepository.js

@@ -1,25 +1,26 @@
 import { Result } from "@webiny/feature/api";
 import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
 import { LockEntryRepository } 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 LockEntryRepositoryImpl {
-    constructor(model, config, createEntry){
-        this.model = model;
+    constructor(modelProvider, config, createEntry){
+        this.modelProvider = modelProvider;
         this.config = config;
         this.createEntry = createEntry;
     }
     async create(input) {
         try {
+            const model = await this.modelProvider.get();
             const id = createLockRecordDatabaseId(input.id);
             const values = {
                 targetId: input.id,
                 type: input.type,
                 actions: []
             };
-            const result = await this.createEntry.execute(this.model, {
+            const result = await this.createEntry.execute(model, {
                 id,
                 values
             });
@@ -35,7 +36,7 @@ class LockEntryRepositoryImpl {
 const LockEntryRepository_LockEntryRepository = LockEntryRepository.createImplementation({
     implementation: LockEntryRepositoryImpl,
     dependencies: [
-        RecordLockingModel,
+        RecordLockingModelProvider,
         RecordLockingConfig,
         CreateEntryUseCase
     ]

package/features/LockEntry/LockEntryRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/LockEntry/LockEntryRepository.js","sources":["../../../src/features/LockEntry/LockEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry\";\nimport type { CmsEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport { LockEntryInput, LockEntryRepository 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 LockEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private createEntry: CreateEntryUseCase.Interface\n    ) {}\n\n    async create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const id = createLockRecordDatabaseId(input.id);\n\n            const values: LockRecordValues = {\n                targetId: input.id,\n                type: input.type,\n                actions: []\n            };\n\n            const result = await this.createEntry.execute(this.model, {\n                id,\n                values\n            });\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const entry = result.value as CmsEntry<LockRecordValues>;\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 LockEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: LockEntryRepositoryImpl,\n    dependencies: [RecordLockingModel, RecordLockingConfig, CreateEntryUseCase]\n});\n"],"names":["LockEntryRepositoryImpl","model","config","createEntry","input","id","createLockRecordDatabaseId","values","result","Result","LockRecordPersistenceError","entry","lockRecord","LockRecord","error","LockEntryRepository","RepositoryAbstraction","RecordLockingModel","RecordLockingConfig","CreateEntryUseCase"],"mappings":";;;;;;;AAWA,MAAMA;IACF,YACYC,KAAmC,EACnCC,MAAqC,EACrCC,WAAyC,CACnD;aAHUF,KAAK,GAALA;aACAC,MAAM,GAANA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAAqB,EAA6D;QAC3F,IAAI;YACA,MAAMC,KAAKC,2BAA2BF,MAAM,EAAE;YAE9C,MAAMG,SAA2B;gBAC7B,UAAUH,MAAM,EAAE;gBAClB,MAAMA,MAAM,IAAI;gBAChB,SAAS,EAAE;YACf;YAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE;gBACtDH;gBACAE;YACJ;YAEA,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAGlE,MAAMG,QAAQH,OAAO,KAAK;YAC1B,MAAMI,aAAa,IAAIC,WAAWF,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5D,OAAOF,OAAO,EAAE,CAACG;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAOL,OAAO,IAAI,CAAC,IAAIC,2BAA2BI;QACtD;IACJ;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAA0C,CAAC;IAC1E,gBAAgBhB;IAChB,cAAc;QAACiB;QAAoBC;QAAqBC;KAAmB;AAC/E"}
+{"version":3,"file":"features/LockEntry/LockEntryRepository.js","sources":["../../../src/features/LockEntry/LockEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry\";\nimport type { CmsEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport { LockEntryInput, LockEntryRepository 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 LockEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private modelProvider: RecordLockingModelProvider.Interface,\n        private config: RecordLockingConfig.Interface,\n        private createEntry: CreateEntryUseCase.Interface\n    ) {}\n\n    async create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const model = await this.modelProvider.get();\n\n            const id = createLockRecordDatabaseId(input.id);\n\n            const values: LockRecordValues = {\n                targetId: input.id,\n                type: input.type,\n                actions: []\n            };\n\n            const result = await this.createEntry.execute(model, {\n                id,\n                values\n            });\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const entry = result.value as CmsEntry<LockRecordValues>;\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 LockEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: LockEntryRepositoryImpl,\n    dependencies: [RecordLockingModelProvider, RecordLockingConfig, CreateEntryUseCase]\n});\n"],"names":["LockEntryRepositoryImpl","modelProvider","config","createEntry","input","model","id","createLockRecordDatabaseId","values","result","Result","LockRecordPersistenceError","entry","lockRecord","LockRecord","error","LockEntryRepository","RepositoryAbstraction","RecordLockingModelProvider","RecordLockingConfig","CreateEntryUseCase"],"mappings":";;;;;;;AAYA,MAAMA;IACF,YACYC,aAAmD,EACnDC,MAAqC,EACrCC,WAAyC,CACnD;aAHUF,aAAa,GAAbA;aACAC,MAAM,GAANA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAAqB,EAA6D;QAC3F,IAAI;YACA,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;YAE1C,MAAMC,KAAKC,2BAA2BH,MAAM,EAAE;YAE9C,MAAMI,SAA2B;gBAC7B,UAAUJ,MAAM,EAAE;gBAClB,MAAMA,MAAM,IAAI;gBAChB,SAAS,EAAE;YACf;YAEA,MAAMK,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACJ,OAAO;gBACjDC;gBACAE;YACJ;YAEA,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAGlE,MAAMG,QAAQH,OAAO,KAAK;YAC1B,MAAMI,aAAa,IAAIC,WAAWF,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5D,OAAOF,OAAO,EAAE,CAACG;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAOL,OAAO,IAAI,CAAC,IAAIC,2BAA2BI;QACtD;IACJ;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAA0C,CAAC;IAC1E,gBAAgBjB;IAChB,cAAc;QAACkB;QAA4BC;QAAqBC;KAAmB;AACvF"}

package/features/RecordLockingFeature.d.ts

@@ -1,13 +1,8 @@
-import type { CmsModel } from "@webiny/api-headless-cms/types";
 export interface RecordLockingParams {
     /**
      * Timeout in milliseconds after which a lock expires
      */
     timeout: number;
-    /**
-     * The CMS model for storing lock records
-     */
-    model: CmsModel;
 }
 export declare const RecordLockingFeature: {
     name: string;

package/features/RecordLockingFeature.js

@@ -1,5 +1,6 @@
 import { createFeature } from "@webiny/feature/api";
-import { RecordLockingConfig, RecordLockingModel } from "../domain/abstractions.js";
+import { RecordLockingConfig } from "../domain/abstractions.js";
+import { RecordLockingModelProvider } from "./RecordLockingModelProvider.js";
 import { GetLockRecordFeature } from "./GetLockRecord/feature.js";
 import { GetLockedEntryLockRecordFeature } from "./GetLockedEntryLockRecord/feature.js";
 import { KickOutCurrentUserFeature } from "./KickOutCurrentUser/feature.js";
@@ -16,7 +17,7 @@ const RecordLockingFeature = createFeature({
         container.registerInstance(RecordLockingConfig, {
             timeout: params.timeout
         });
-        container.registerInstance(RecordLockingModel, params.model);
+        container.register(RecordLockingModelProvider);
         GetLockRecordFeature.register(container);
         GetLockedEntryLockRecordFeature.register(container);
         KickOutCurrentUserFeature.register(container);

package/features/RecordLockingFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/RecordLockingFeature.js","sources":["../../src/features/RecordLockingFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport { GetLockRecordFeature } from \"./GetLockRecord/feature.js\";\nimport { GetLockedEntryLockRecordFeature } from \"./GetLockedEntryLockRecord/feature.js\";\nimport { KickOutCurrentUserFeature } from \"./KickOutCurrentUser/feature.js\";\nimport { ListLockRecordsFeature } from \"./ListLockRecords/feature.js\";\nimport { ListAllLockRecordsFeature } from \"./ListAllLockRecords/feature.js\";\nimport { IsEntryLockedFeature } from \"./IsEntryLocked/feature.js\";\nimport { LockEntryFeature } from \"./LockEntry/feature.js\";\nimport { UpdateEntryLockFeature } from \"./UpdateEntryLock/feature.js\";\nimport { UnlockEntryFeature } from \"./UnlockEntry/feature.js\";\nimport { UnlockEntryRequestFeature } from \"./UnlockEntryRequest/feature.js\";\n\nexport interface RecordLockingParams {\n    /**\n     * Timeout in milliseconds after which a lock expires\n     */\n    timeout: number;\n    /**\n     * The CMS model for storing lock records\n     */\n    model: CmsModel;\n}\n\nexport const RecordLockingFeature = createFeature<RecordLockingParams>({\n    name: \"RecordLockingManagement\",\n    register(container, params) {\n        // Register domain abstractions\n        container.registerInstance(RecordLockingConfig, { timeout: params.timeout });\n        container.registerInstance(RecordLockingModel, params.model);\n\n        // Register all sub-features\n        GetLockRecordFeature.register(container);\n        GetLockedEntryLockRecordFeature.register(container);\n        KickOutCurrentUserFeature.register(container);\n        ListLockRecordsFeature.register(container);\n        ListAllLockRecordsFeature.register(container);\n        IsEntryLockedFeature.register(container);\n        LockEntryFeature.register(container);\n        UpdateEntryLockFeature.register(container);\n        UnlockEntryFeature.register(container);\n        UnlockEntryRequestFeature.register(container);\n    }\n});\n"],"names":["RecordLockingFeature","createFeature","container","params","RecordLockingConfig","RecordLockingModel","GetLockRecordFeature","GetLockedEntryLockRecordFeature","KickOutCurrentUserFeature","ListLockRecordsFeature","ListAllLockRecordsFeature","IsEntryLockedFeature","LockEntryFeature","UpdateEntryLockFeature","UnlockEntryFeature","UnlockEntryRequestFeature"],"mappings":";;;;;;;;;;;;AAyBO,MAAMA,uBAAuBC,cAAmC;IACnE,MAAM;IACN,UAASC,SAAS,EAAEC,MAAM;QAEtBD,UAAU,gBAAgB,CAACE,qBAAqB;YAAE,SAASD,OAAO,OAAO;QAAC;QAC1ED,UAAU,gBAAgB,CAACG,oBAAoBF,OAAO,KAAK;QAG3DG,qBAAqB,QAAQ,CAACJ;QAC9BK,gCAAgC,QAAQ,CAACL;QACzCM,0BAA0B,QAAQ,CAACN;QACnCO,uBAAuB,QAAQ,CAACP;QAChCQ,0BAA0B,QAAQ,CAACR;QACnCS,qBAAqB,QAAQ,CAACT;QAC9BU,iBAAiB,QAAQ,CAACV;QAC1BW,uBAAuB,QAAQ,CAACX;QAChCY,mBAAmB,QAAQ,CAACZ;QAC5Ba,0BAA0B,QAAQ,CAACb;IACvC;AACJ"}
+{"version":3,"file":"features/RecordLockingFeature.js","sources":["../../src/features/RecordLockingFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { RecordLockingConfig } from \"~/domain/abstractions.js\";\nimport { RecordLockingModelProvider } from \"./RecordLockingModelProvider.js\";\nimport { GetLockRecordFeature } from \"./GetLockRecord/feature.js\";\nimport { GetLockedEntryLockRecordFeature } from \"./GetLockedEntryLockRecord/feature.js\";\nimport { KickOutCurrentUserFeature } from \"./KickOutCurrentUser/feature.js\";\nimport { ListLockRecordsFeature } from \"./ListLockRecords/feature.js\";\nimport { ListAllLockRecordsFeature } from \"./ListAllLockRecords/feature.js\";\nimport { IsEntryLockedFeature } from \"./IsEntryLocked/feature.js\";\nimport { LockEntryFeature } from \"./LockEntry/feature.js\";\nimport { UpdateEntryLockFeature } from \"./UpdateEntryLock/feature.js\";\nimport { UnlockEntryFeature } from \"./UnlockEntry/feature.js\";\nimport { UnlockEntryRequestFeature } from \"./UnlockEntryRequest/feature.js\";\n\nexport interface RecordLockingParams {\n    /**\n     * Timeout in milliseconds after which a lock expires\n     */\n    timeout: number;\n}\n\nexport const RecordLockingFeature = createFeature<RecordLockingParams>({\n    name: \"RecordLockingManagement\",\n    register(container, params) {\n        // Register domain abstractions\n        container.registerInstance(RecordLockingConfig, { timeout: params.timeout });\n        container.register(RecordLockingModelProvider);\n\n        // Register all sub-features\n        GetLockRecordFeature.register(container);\n        GetLockedEntryLockRecordFeature.register(container);\n        KickOutCurrentUserFeature.register(container);\n        ListLockRecordsFeature.register(container);\n        ListAllLockRecordsFeature.register(container);\n        IsEntryLockedFeature.register(container);\n        LockEntryFeature.register(container);\n        UpdateEntryLockFeature.register(container);\n        UnlockEntryFeature.register(container);\n        UnlockEntryRequestFeature.register(container);\n    }\n});\n"],"names":["RecordLockingFeature","createFeature","container","params","RecordLockingConfig","RecordLockingModelProvider","GetLockRecordFeature","GetLockedEntryLockRecordFeature","KickOutCurrentUserFeature","ListLockRecordsFeature","ListAllLockRecordsFeature","IsEntryLockedFeature","LockEntryFeature","UpdateEntryLockFeature","UnlockEntryFeature","UnlockEntryRequestFeature"],"mappings":";;;;;;;;;;;;;AAqBO,MAAMA,uBAAuBC,cAAmC;IACnE,MAAM;IACN,UAASC,SAAS,EAAEC,MAAM;QAEtBD,UAAU,gBAAgB,CAACE,qBAAqB;YAAE,SAASD,OAAO,OAAO;QAAC;QAC1ED,UAAU,QAAQ,CAACG;QAGnBC,qBAAqB,QAAQ,CAACJ;QAC9BK,gCAAgC,QAAQ,CAACL;QACzCM,0BAA0B,QAAQ,CAACN;QACnCO,uBAAuB,QAAQ,CAACP;QAChCQ,0BAA0B,QAAQ,CAACR;QACnCS,qBAAqB,QAAQ,CAACT;QAC9BU,iBAAiB,QAAQ,CAACV;QAC1BW,uBAAuB,QAAQ,CAACX;QAChCY,mBAAmB,QAAQ,CAACZ;QAC5Ba,0BAA0B,QAAQ,CAACb;IACvC;AACJ"}

package/features/RecordLockingModelProvider.d.ts

@@ -0,0 +1,18 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { RecordLockingModelProvider as Abstraction } from "../domain/abstractions.js";
+/**
+ * Resolves the lock record model on demand.
+ *
+ * No memoization: `ModelsFetcher` already caches the model list per request. No
+ * `withoutAuthorization` either: the model is private, so access control lets every identity read it.
+ */
+declare class RecordLockingModelProviderImpl implements Abstraction.Interface {
+    private getModel;
+    constructor(getModel: GetModelUseCase.Interface);
+    get(): Promise<CmsModel>;
+}
+export declare const RecordLockingModelProvider: typeof RecordLockingModelProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/domain/abstractions.js").IRecordLockingModelProvider>;
+};
+export {};

package/features/RecordLockingModelProvider.js

@@ -0,0 +1,22 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { RecordLockingModelProvider } from "../domain/abstractions.js";
+import { RECORD_LOCKING_MODEL_ID } from "../domain/RecordLockingModel.js";
+class RecordLockingModelProviderImpl {
+    constructor(getModel){
+        this.getModel = getModel;
+    }
+    async get() {
+        const result = await this.getModel.execute(RECORD_LOCKING_MODEL_ID);
+        if (result.isFail()) throw result.error;
+        return result.value;
+    }
+}
+const RecordLockingModelProvider_RecordLockingModelProvider = RecordLockingModelProvider.createImplementation({
+    implementation: RecordLockingModelProviderImpl,
+    dependencies: [
+        GetModelUseCase
+    ]
+});
+export { RecordLockingModelProvider_RecordLockingModelProvider as RecordLockingModelProvider };
+
+//# sourceMappingURL=RecordLockingModelProvider.js.map

package/features/RecordLockingModelProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/RecordLockingModelProvider.js","sources":["../../src/features/RecordLockingModelProvider.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { RecordLockingModelProvider as Abstraction } from \"~/domain/abstractions.js\";\nimport { RECORD_LOCKING_MODEL_ID } from \"~/domain/RecordLockingModel.js\";\n\n/**\n * Resolves the lock record model on demand.\n *\n * No memoization: `ModelsFetcher` already caches the model list per request. No\n * `withoutAuthorization` either: the model is private, so access control lets every identity read it.\n */\nclass RecordLockingModelProviderImpl implements Abstraction.Interface {\n    constructor(private getModel: GetModelUseCase.Interface) {}\n\n    async get(): Promise<CmsModel> {\n        const result = await this.getModel.execute(RECORD_LOCKING_MODEL_ID);\n        if (result.isFail()) {\n            throw result.error;\n        }\n        return result.value;\n    }\n}\n\nexport const RecordLockingModelProvider = Abstraction.createImplementation({\n    implementation: RecordLockingModelProviderImpl,\n    dependencies: [GetModelUseCase]\n});\n"],"names":["RecordLockingModelProviderImpl","getModel","result","RECORD_LOCKING_MODEL_ID","RecordLockingModelProvider","Abstraction","GetModelUseCase"],"mappings":";;;AAWA,MAAMA;IACF,YAAoBC,QAAmC,CAAE;aAArCA,QAAQ,GAARA;IAAsC;IAE1D,MAAM,MAAyB;QAC3B,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACC;QAC3C,IAAID,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;QAEtB,OAAOA,OAAO,KAAK;IACvB;AACJ;AAEO,MAAME,wDAA6BC,2BAAAA,oBAAgC,CAAC;IACvE,gBAAgBL;IAChB,cAAc;QAACM;KAAgB;AACnC"}

package/features/UnlockEntry/UnlockEntryRepository.d.ts

@@ -1,11 +1,11 @@
 import { Result } from "@webiny/feature/api";
 import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
 import { UnlockEntryRepository as RepositoryAbstraction } from "./abstractions.js";
-import { RecordLockingModel } from "../../domain/abstractions.js";
+import { RecordLockingModelProvider } from "../../domain/abstractions.js";
 declare class UnlockEntryRepositoryImpl implements RepositoryAbstraction.Interface {
-    private model;
+    private modelProvider;
     private deleteEntry;
-    constructor(model: RecordLockingModel.Interface, deleteEntry: DeleteEntryUseCase.Interface);
+    constructor(modelProvider: RecordLockingModelProvider.Interface, deleteEntry: DeleteEntryUseCase.Interface);
     delete(lockRecordId: string): Promise<Result<void, RepositoryAbstraction.Error>>;
 }
 export declare const UnlockEntryRepository: typeof UnlockEntryRepositoryImpl & {

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
     ]
 });