@webiny/api-record-locking 0.0.0-unstable.7be00a75a9 → 0.0.0-unstable.7c2def32a7

package/RecordLockingAppFeature.d.ts

@@ -0,0 +1,11 @@
+import { type Container } from "@webiny/feature/api";
+export interface IRecordLockingAppFeatureParams {
+    /**
+     * A number of seconds after the last activity to wait before the record is automatically unlocked.
+     */
+    timeout?: number;
+}
+export declare const RecordLockingAppFeature: {
+    name: string;
+    register(container: Container, context: IRecordLockingAppFeatureParams): void;
+};

package/RecordLockingAppFeature.js

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

package/RecordLockingAppFeature.js.map

@@ -0,0 +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 { 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/RecordLockingModel.js

@@ -5,7 +5,8 @@ class RecordLockingPrivateModelImpl {
         return [
             builder.private({
                 modelId: RECORD_LOCKING_MODEL_ID,
-                name: "Record Lock Tracking"
+                name: "Record Lock Tracking",
+                lifecycleEvents: false
             }).fields((fields)=>({
                     targetId: fields.text().label("Target ID").required("Target ID is required."),
                     type: fields.text().label("Record Type").required("Record type is required."),

package/domain/RecordLockingModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain/RecordLockingModel.js","sources":["../../src/domain/RecordLockingModel.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\n\nexport const RECORD_LOCKING_MODEL_ID = \"wbyRecordLock\";\n\nclass RecordLockingPrivateModelImpl implements ModelFactory.Interface {\n    public async execute(builder: ModelFactory.Builder) {\n        return [\n            builder\n                .private({\n                    modelId: RECORD_LOCKING_MODEL_ID,\n                    name: \"Record Lock Tracking\"\n                })\n                .fields(fields => ({\n                    targetId: fields.text().label(\"Target ID\").required(\"Target ID is required.\"),\n                    type: fields.text().label(\"Record Type\").required(\"Record type is required.\"),\n                    actions: fields\n                        .object()\n                        .label(\"Actions\")\n                        .list()\n                        .fields(fields => ({\n                            type: fields\n                                .text()\n                                .label(\"Action Type\")\n                                .required(\"Action type is required.\"),\n                            message: fields.text().label(\"Message\"),\n                            createdBy: fields\n                                .object()\n                                .label(\"Created By\")\n                                .required(\"Created by is required.\")\n                                .fields(fields => ({\n                                    id: fields.text().label(\"ID\").required(\"ID is required.\"),\n                                    displayName: fields\n                                        .text()\n                                        .label(\"Display Name\")\n                                        .required(\"Display name is required.\"),\n                                    type: fields.text().label(\"Type\").required(\"Type is required.\")\n                                })),\n                            createdOn: fields\n                                .datetime()\n                                .label(\"Created On\")\n                                .required(\"Created on is required.\")\n                                .withoutTimezone()\n                        }))\n                }))\n        ];\n    }\n}\n\nexport const RecordLockingModel = ModelFactory.createImplementation({\n    implementation: RecordLockingPrivateModelImpl,\n    dependencies: []\n});\n"],"names":["RECORD_LOCKING_MODEL_ID","RecordLockingPrivateModelImpl","builder","fields","RecordLockingModel","ModelFactory"],"mappings":";AAEO,MAAMA,0BAA0B;AAEvC,MAAMC;IACF,MAAa,QAAQC,OAA6B,EAAE;QAChD,OAAO;YACHA,QACK,OAAO,CAAC;gBACL,SAASF;gBACT,MAAM;YACV,GACC,MAAM,CAACG,CAAAA,SAAW;oBACf,UAAUA,OAAO,IAAI,GAAG,KAAK,CAAC,aAAa,QAAQ,CAAC;oBACpD,MAAMA,OAAO,IAAI,GAAG,KAAK,CAAC,eAAe,QAAQ,CAAC;oBAClD,SAASA,OACJ,MAAM,GACN,KAAK,CAAC,WACN,IAAI,GACJ,MAAM,CAACA,CAAAA,SAAW;4BACf,MAAMA,OACD,IAAI,GACJ,KAAK,CAAC,eACN,QAAQ,CAAC;4BACd,SAASA,OAAO,IAAI,GAAG,KAAK,CAAC;4BAC7B,WAAWA,OACN,MAAM,GACN,KAAK,CAAC,cACN,QAAQ,CAAC,2BACT,MAAM,CAACA,CAAAA,SAAW;oCACf,IAAIA,OAAO,IAAI,GAAG,KAAK,CAAC,MAAM,QAAQ,CAAC;oCACvC,aAAaA,OACR,IAAI,GACJ,KAAK,CAAC,gBACN,QAAQ,CAAC;oCACd,MAAMA,OAAO,IAAI,GAAG,KAAK,CAAC,QAAQ,QAAQ,CAAC;gCAC/C;4BACJ,WAAWA,OACN,QAAQ,GACR,KAAK,CAAC,cACN,QAAQ,CAAC,2BACT,eAAe;wBACxB;gBACR;SACP;IACL;AACJ;AAEO,MAAMC,qBAAqBC,aAAa,oBAAoB,CAAC;IAChE,gBAAgBJ;IAChB,cAAc,EAAE;AACpB"}
+{"version":3,"file":"domain/RecordLockingModel.js","sources":["../../src/domain/RecordLockingModel.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\n\nexport const RECORD_LOCKING_MODEL_ID = \"wbyRecordLock\";\n\nclass RecordLockingPrivateModelImpl implements ModelFactory.Interface {\n    public async execute(builder: ModelFactory.Builder) {\n        return [\n            builder\n                .private({\n                    modelId: RECORD_LOCKING_MODEL_ID,\n                    name: \"Record Lock Tracking\",\n                    lifecycleEvents: false\n                })\n                .fields(fields => ({\n                    targetId: fields.text().label(\"Target ID\").required(\"Target ID is required.\"),\n                    type: fields.text().label(\"Record Type\").required(\"Record type is required.\"),\n                    actions: fields\n                        .object()\n                        .label(\"Actions\")\n                        .list()\n                        .fields(fields => ({\n                            type: fields\n                                .text()\n                                .label(\"Action Type\")\n                                .required(\"Action type is required.\"),\n                            message: fields.text().label(\"Message\"),\n                            createdBy: fields\n                                .object()\n                                .label(\"Created By\")\n                                .required(\"Created by is required.\")\n                                .fields(fields => ({\n                                    id: fields.text().label(\"ID\").required(\"ID is required.\"),\n                                    displayName: fields\n                                        .text()\n                                        .label(\"Display Name\")\n                                        .required(\"Display name is required.\"),\n                                    type: fields.text().label(\"Type\").required(\"Type is required.\")\n                                })),\n                            createdOn: fields\n                                .datetime()\n                                .label(\"Created On\")\n                                .required(\"Created on is required.\")\n                                .withoutTimezone()\n                        }))\n                }))\n        ];\n    }\n}\n\nexport const RecordLockingModel = ModelFactory.createImplementation({\n    implementation: RecordLockingPrivateModelImpl,\n    dependencies: []\n});\n"],"names":["RECORD_LOCKING_MODEL_ID","RecordLockingPrivateModelImpl","builder","fields","RecordLockingModel","ModelFactory"],"mappings":";AAEO,MAAMA,0BAA0B;AAEvC,MAAMC;IACF,MAAa,QAAQC,OAA6B,EAAE;QAChD,OAAO;YACHA,QACK,OAAO,CAAC;gBACL,SAASF;gBACT,MAAM;gBACN,iBAAiB;YACrB,GACC,MAAM,CAACG,CAAAA,SAAW;oBACf,UAAUA,OAAO,IAAI,GAAG,KAAK,CAAC,aAAa,QAAQ,CAAC;oBACpD,MAAMA,OAAO,IAAI,GAAG,KAAK,CAAC,eAAe,QAAQ,CAAC;oBAClD,SAASA,OACJ,MAAM,GACN,KAAK,CAAC,WACN,IAAI,GACJ,MAAM,CAACA,CAAAA,SAAW;4BACf,MAAMA,OACD,IAAI,GACJ,KAAK,CAAC,eACN,QAAQ,CAAC;4BACd,SAASA,OAAO,IAAI,GAAG,KAAK,CAAC;4BAC7B,WAAWA,OACN,MAAM,GACN,KAAK,CAAC,cACN,QAAQ,CAAC,2BACT,MAAM,CAACA,CAAAA,SAAW;oCACf,IAAIA,OAAO,IAAI,GAAG,KAAK,CAAC,MAAM,QAAQ,CAAC;oCACvC,aAAaA,OACR,IAAI,GACJ,KAAK,CAAC,gBACN,QAAQ,CAAC;oCACd,MAAMA,OAAO,IAAI,GAAG,KAAK,CAAC,QAAQ,QAAQ,CAAC;gCAC/C;4BACJ,WAAWA,OACN,QAAQ,GACR,KAAK,CAAC,cACN,QAAQ,CAAC,2BACT,eAAe;wBACxB;gBACR;SACP;IACL;AACJ;AAEO,MAAMC,qBAAqBC,aAAa,oBAAoB,CAAC;IAChE,gBAAgBJ;IAChB,cAAc,EAAE;AACpB"}

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/KickOutCurrentUser/KickOutCurrentUserUseCase.d.ts

@@ -1,12 +1,12 @@
 import { Result } from "@webiny/feature/api";
 import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
-import { WebsocketService } from "@webiny/api-websockets/features/WebsocketService/index.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/features/SendToIdentity/abstractions.js";
 import { KickOutCurrentUserUseCase as UseCaseAbstraction } from "./abstractions.js";
 import type { ILockRecord } from "../../domain/index.js";
 declare class KickOutCurrentUserUseCaseImpl implements UseCaseAbstraction.Interface {
     private identityContext;
-    private websocketService?;
-    constructor(identityContext: IdentityContext.Interface, websocketService?: WebsocketService.Interface | undefined);
+    private sendToIdentity;
+    constructor(identityContext: IdentityContext.Interface, sendToIdentity: WebsocketsSendToIdentityUseCase.Interface);
     execute(record: ILockRecord): Promise<Result<void, UseCaseAbstraction.Error>>;
 }
 export declare const KickOutCurrentUserUseCase: typeof KickOutCurrentUserUseCaseImpl & {

package/features/KickOutCurrentUser/KickOutCurrentUserUseCase.js

@@ -1,19 +1,18 @@
 import { Result } from "@webiny/feature/api";
 import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
-import { WebsocketService } from "@webiny/api-websockets/features/WebsocketService/index.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/features/SendToIdentity/abstractions.js";
 import { parseIdentifier } from "@webiny/utils";
 import { KickOutCurrentUserUseCase } from "./abstractions.js";
 class KickOutCurrentUserUseCaseImpl {
-    constructor(identityContext, websocketService){
+    constructor(identityContext, sendToIdentity){
         this.identityContext = identityContext;
-        this.websocketService = websocketService;
+        this.sendToIdentity = sendToIdentity;
     }
     async execute(record) {
-        if (!this.websocketService) return Result.ok();
         const { lockedBy, id } = record;
         const { id: entryId } = parseIdentifier(id);
         const identity = this.identityContext.getIdentity();
-        await this.websocketService.send({
+        await this.sendToIdentity.execute({
             id: lockedBy.id
         }, {
             action: `recordLocking.entry.kickOut.${entryId}`,
@@ -29,12 +28,7 @@ const KickOutCurrentUserUseCase_KickOutCurrentUserUseCase = KickOutCurrentUserUs
     implementation: KickOutCurrentUserUseCaseImpl,
     dependencies: [
         IdentityContext,
-        [
-            WebsocketService,
-            {
-                optional: true
-            }
-        ]
+        WebsocketsSendToIdentityUseCase
     ]
 });
 export { KickOutCurrentUserUseCase_KickOutCurrentUserUseCase as KickOutCurrentUserUseCase };

package/features/KickOutCurrentUser/KickOutCurrentUserUseCase.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/KickOutCurrentUser/KickOutCurrentUserUseCase.js","sources":["../../../src/features/KickOutCurrentUser/KickOutCurrentUserUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { WebsocketService } from \"@webiny/api-websockets/features/WebsocketService/index.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { KickOutCurrentUserUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { ILockRecord } from \"~/domain/index.js\";\n\nclass KickOutCurrentUserUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private websocketService?: WebsocketService.Interface\n    ) {}\n\n    async execute(record: ILockRecord): Promise<Result<void, UseCaseAbstraction.Error>> {\n        if (!this.websocketService) {\n            return Result.ok();\n        }\n\n        const { lockedBy, id } = record;\n\n        const { id: entryId } = parseIdentifier(id);\n        const identity = this.identityContext.getIdentity();\n\n        await this.websocketService.send(\n            { id: lockedBy.id },\n            {\n                action: `recordLocking.entry.kickOut.${entryId}`,\n                data: {\n                    record: record.toObject(),\n                    user: identity\n                }\n            }\n        );\n\n        return Result.ok();\n    }\n}\n\nexport const KickOutCurrentUserUseCase = UseCaseAbstraction.createImplementation({\n    implementation: KickOutCurrentUserUseCaseImpl,\n    dependencies: [IdentityContext, [WebsocketService, { optional: true }]]\n});\n"],"names":["KickOutCurrentUserUseCaseImpl","identityContext","websocketService","record","Result","lockedBy","id","entryId","parseIdentifier","identity","KickOutCurrentUserUseCase","UseCaseAbstraction","IdentityContext","WebsocketService"],"mappings":";;;;;AAOA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,gBAA6C,CACvD;aAFUD,eAAe,GAAfA;aACAC,gBAAgB,GAAhBA;IACT;IAEH,MAAM,QAAQC,MAAmB,EAAmD;QAChF,IAAI,CAAC,IAAI,CAAC,gBAAgB,EACtB,OAAOC,OAAO,EAAE;QAGpB,MAAM,EAAEC,QAAQ,EAAEC,EAAE,EAAE,GAAGH;QAEzB,MAAM,EAAE,IAAII,OAAO,EAAE,GAAGC,gBAAgBF;QACxC,MAAMG,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QAEjD,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAC5B;YAAE,IAAIJ,SAAS,EAAE;QAAC,GAClB;YACI,QAAQ,CAAC,4BAA4B,EAAEE,SAAS;YAChD,MAAM;gBACF,QAAQJ,OAAO,QAAQ;gBACvB,MAAMM;YACV;QACJ;QAGJ,OAAOL,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMM,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBX;IAChB,cAAc;QAACY;QAAiB;YAACC;YAAkB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAC3E"}
+{"version":3,"file":"features/KickOutCurrentUser/KickOutCurrentUserUseCase.js","sources":["../../../src/features/KickOutCurrentUser/KickOutCurrentUserUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { WebsocketsSendToIdentityUseCase } from \"@webiny/api-websockets/features/SendToIdentity/abstractions.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { KickOutCurrentUserUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { ILockRecord } from \"~/domain/index.js\";\n\nclass KickOutCurrentUserUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private sendToIdentity: WebsocketsSendToIdentityUseCase.Interface\n    ) {}\n\n    async execute(record: ILockRecord): Promise<Result<void, UseCaseAbstraction.Error>> {\n        const { lockedBy, id } = record;\n\n        const { id: entryId } = parseIdentifier(id);\n        const identity = this.identityContext.getIdentity();\n\n        await this.sendToIdentity.execute(\n            { id: lockedBy.id },\n            {\n                action: `recordLocking.entry.kickOut.${entryId}`,\n                data: {\n                    record: record.toObject(),\n                    user: identity\n                }\n            }\n        );\n\n        return Result.ok();\n    }\n}\n\nexport const KickOutCurrentUserUseCase = UseCaseAbstraction.createImplementation({\n    implementation: KickOutCurrentUserUseCaseImpl,\n    dependencies: [IdentityContext, WebsocketsSendToIdentityUseCase]\n});\n"],"names":["KickOutCurrentUserUseCaseImpl","identityContext","sendToIdentity","record","lockedBy","id","entryId","parseIdentifier","identity","Result","KickOutCurrentUserUseCase","UseCaseAbstraction","IdentityContext","WebsocketsSendToIdentityUseCase"],"mappings":";;;;;AAOA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,cAAyD,CACnE;aAFUD,eAAe,GAAfA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,MAAmB,EAAmD;QAChF,MAAM,EAAEC,QAAQ,EAAEC,EAAE,EAAE,GAAGF;QAEzB,MAAM,EAAE,IAAIG,OAAO,EAAE,GAAGC,gBAAgBF;QACxC,MAAMG,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QAEjD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B;YAAE,IAAIJ,SAAS,EAAE;QAAC,GAClB;YACI,QAAQ,CAAC,4BAA4B,EAAEE,SAAS;YAChD,MAAM;gBACF,QAAQH,OAAO,QAAQ;gBACvB,MAAMK;YACV;QACJ;QAGJ,OAAOC,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBX;IAChB,cAAc;QAACY;QAAiBC;KAAgC;AACpE"}

package/features/ListAllLockRecords/ListAllLockRecordsRepository.d.ts

@@ -1,13 +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 { CmsWhereMapper } from "@webiny/api-headless-cms";
 import { RecordLockingConfig } from "../../domain/abstractions.js";
-import type { CmsModel } from "@webiny/api-headless-cms/types";
+import { RecordLockingModelProvider } from "../../domain/abstractions.js";
 declare class ListAllLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {
     private config;
     private listEntries;
-    private model;
-    constructor(config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface, model: CmsModel);
+    private modelProvider;
+    private cmsWhereMapper;
+    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

@@ -1,23 +1,29 @@
 import { Result } from "@webiny/feature/api";
 import { ListAllLockRecordsRepository } from "./abstractions.js";
 import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
-import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import { CmsWhereMapper } from "@webiny/api-headless-cms";
+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){
+    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: convertWhereCondition(input?.where)
+                where: this.cmsWhereMapper.map({
+                    input: convertWhereCondition(input?.where),
+                    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));
@@ -35,7 +41,8 @@ const ListAllLockRecordsRepository_ListAllLockRecordsRepository = ListAllLockRec
     dependencies: [
         RecordLockingConfig,
         ListLatestEntriesUseCase,
-        RecordLockingModel
+        RecordLockingModelProvider,
+        CmsWhereMapper
     ]
 });
 export { ListAllLockRecordsRepository_ListAllLockRecordsRepository as ListAllLockRecordsRepository };

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 { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\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    ) {}\n\n    async execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const params = {\n                ...input,\n                where: convertWhereCondition(input?.where)\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: [RecordLockingConfig, ListLatestEntriesUseCase, RecordLockingModel]\n});\n"],"names":["ListAllLockRecordsRepositoryImpl","config","listEntries","model","input","params","convertWhereCondition","result","Result","LockRecordPersistenceError","entries","meta","items","entry","LockRecord","error","ListAllLockRecordsRepository","RepositoryAbstraction","RecordLockingConfig","ListLatestEntriesUseCase","RecordLockingModel"],"mappings":";;;;;;;AAcA,MAAMA;IACF,YACYC,MAAqC,EACrCC,WAA+C,EAC/CC,KAAe,CACzB;aAHUF,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,QACFC,KAA+B,EACuC;QACtE,IAAI;YACA,MAAMC,SAAS;gBACX,GAAGD,KAAK;gBACR,OAAOE,sBAAsBF,OAAO;YACxC;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,gBAAgBjB;IAChB,cAAc;QAACkB;QAAqBC;QAA0BC;KAAmB;AACrF"}
+{"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,12 +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;
-    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface);
+    private cmsWhereMapper;
+    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,23 +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){
-        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: convertWhereCondition(input?.where || {})
+                where: this.cmsWhereMapper.map({
+                    input: convertWhereCondition(input?.where),
+                    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));
@@ -33,9 +39,10 @@ class ListLockRecordsRepositoryImpl {
 const ListLockRecordsRepository_ListLockRecordsRepository = ListLockRecordsRepository.createImplementation({
     implementation: ListLockRecordsRepositoryImpl,
     dependencies: [
-        RecordLockingModel,
+        RecordLockingModelProvider,
         RecordLockingConfig,
-        ListLatestEntriesUseCase
+        ListLatestEntriesUseCase,
+        CmsWhereMapper
     ]
 });
 export { ListLockRecordsRepository_ListLockRecordsRepository as ListLockRecordsRepository };

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 { 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    ) {}\n\n    async execute(\n        input?: ListLockRecordsInput\n    ): Promise<Result<ListLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const params = {\n                ...input,\n                where: convertWhereCondition(input?.where || {})\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: [RecordLockingModel, RecordLockingConfig, ListLatestEntriesUseCase]\n});\n"],"names":["ListLockRecordsRepositoryImpl","model","config","listEntries","input","params","convertWhereCondition","result","Result","LockRecordPersistenceError","entries","meta","items","entry","LockRecord","error","ListLockRecordsRepository","RepositoryAbstraction","RecordLockingModel","RecordLockingConfig","ListLatestEntriesUseCase"],"mappings":";;;;;;;AAaA,MAAMA;IACF,YACYC,KAAmC,EACnCC,MAAqC,EACrCC,WAA+C,CACzD;aAHUF,KAAK,GAALA;aACAC,MAAM,GAANA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,QACFC,KAA4B,EACuC;QACnE,IAAI;YACA,MAAMC,SAAS;gBACX,GAAGD,KAAK;gBACR,OAAOE,sBAAsBF,OAAO,SAAS,CAAC;YAClD;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,gBAAgBjB;IAChB,cAAc;QAACkB;QAAoBC;QAAqBC;KAAyB;AACrF"}
+{"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"}