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

package/features/KickOutCurrentUser/KickOutCurrentUserUseCase.js

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

package/features/KickOutCurrentUser/KickOutCurrentUserUseCase.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","IdentityContext","WebsocketService","parseIdentifier","KickOutCurrentUserUseCase","UseCaseAbstraction","KickOutCurrentUserUseCaseImpl","constructor","identityContext","websocketService","execute","record","ok","lockedBy","id","entryId","identity","getIdentity","send","action","data","toObject","user","createImplementation","implementation","dependencies","optional"],"sources":["KickOutCurrentUserUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,gBAAgB,QAAQ,2DAA2D;AAC5F,SAASC,eAAe,QAAQ,eAAe;AAC/C,SAASC,yBAAyB,IAAIC,kBAAkB;AAGxD,MAAMC,6BAA6B,CAAyC;EACxEC,WAAWA,CACCC,eAA0C,EAC1CC,gBAA6C,EACvD;IAAA,KAFUD,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,gBAA6C,GAA7CA,gBAA6C;EACtD;EAEH,MAAMC,OAAOA,CAACC,MAAmB,EAAmD;IAChF,IAAI,CAAC,IAAI,CAACF,gBAAgB,EAAE;MACxB,OAAOT,MAAM,CAACY,EAAE,CAAC,CAAC;IACtB;IAEA,MAAM;MAAEC,QAAQ;MAAEC;IAAG,CAAC,GAAGH,MAAM;IAE/B,MAAM;MAAEG,EAAE,EAAEC;IAAQ,CAAC,GAAGZ,eAAe,CAACW,EAAE,CAAC;IAC3C,MAAME,QAAQ,GAAG,IAAI,CAACR,eAAe,CAACS,WAAW,CAAC,CAAC;IAEnD,MAAM,IAAI,CAACR,gBAAgB,CAACS,IAAI,CAC5B;MAAEJ,EAAE,EAAED,QAAQ,CAACC;IAAG,CAAC,EACnB;MACIK,MAAM,EAAE,+BAA+BJ,OAAO,EAAE;MAChDK,IAAI,EAAE;QACFT,MAAM,EAAEA,MAAM,CAACU,QAAQ,CAAC,CAAC;QACzBC,IAAI,EAAEN;MACV;IACJ,CACJ,CAAC;IAED,OAAOhB,MAAM,CAACY,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAMR,yBAAyB,GAAGC,kBAAkB,CAACkB,oBAAoB,CAAC;EAC7EC,cAAc,EAAElB,6BAA6B;EAC7CmB,YAAY,EAAE,CAACxB,eAAe,EAAE,CAACC,gBAAgB,EAAE;IAAEwB,QAAQ,EAAE;EAAK,CAAC,CAAC;AAC1E,CAAC,CAAC","ignoreList":[]}
+{"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/KickOutCurrentUser/abstractions.js

@@ -1,9 +1,5 @@
 import { createAbstraction } from "@webiny/feature/api";
-
-/**
- * KickOutCurrentUser Use Case - Sends websocket message to notify locked-out user
- */
-
-export const KickOutCurrentUserUseCase = createAbstraction("KickOutCurrentUserUseCase");
+const KickOutCurrentUserUseCase = createAbstraction("KickOutCurrentUserUseCase");
+export { KickOutCurrentUserUseCase };
 
 //# sourceMappingURL=abstractions.js.map

package/features/KickOutCurrentUser/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","KickOutCurrentUserUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\n\n/**\n * KickOutCurrentUser Use Case - Sends websocket message to notify locked-out user\n */\nexport interface IKickOutCurrentUserUseCase {\n    execute(record: ILockRecord): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IKickOutCurrentUserUseCaseErrors {\n    // This use case swallows errors and logs them, so no errors are exposed\n}\n\ntype UseCaseError = IKickOutCurrentUserUseCaseErrors[keyof IKickOutCurrentUserUseCaseErrors];\n\nexport const KickOutCurrentUserUseCase = createAbstraction<IKickOutCurrentUserUseCase>(\n    \"KickOutCurrentUserUseCase\"\n);\n\nexport namespace KickOutCurrentUserUseCase {\n    export type Interface = IKickOutCurrentUserUseCase;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAIvD;AACA;AACA;;AAWA,OAAO,MAAMC,yBAAyB,GAAGD,iBAAiB,CACtD,2BACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"features/KickOutCurrentUser/abstractions.js","sources":["../../../src/features/KickOutCurrentUser/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\n\n/**\n * KickOutCurrentUser Use Case - Sends websocket message to notify locked-out user\n */\nexport interface IKickOutCurrentUserUseCase {\n    execute(record: ILockRecord): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IKickOutCurrentUserUseCaseErrors {\n    // This use case swallows errors and logs them, so no errors are exposed\n}\n\ntype UseCaseError = IKickOutCurrentUserUseCaseErrors[keyof IKickOutCurrentUserUseCaseErrors];\n\nexport const KickOutCurrentUserUseCase = createAbstraction<IKickOutCurrentUserUseCase>(\n    \"KickOutCurrentUserUseCase\"\n);\n\nexport namespace KickOutCurrentUserUseCase {\n    export type Interface = IKickOutCurrentUserUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["KickOutCurrentUserUseCase","createAbstraction"],"mappings":";AAiBO,MAAMA,4BAA4BC,kBACrC"}

package/features/KickOutCurrentUser/feature.d.ts

@@ -1 +1,4 @@
-export declare const KickOutCurrentUserFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;
+export declare const KickOutCurrentUserFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/KickOutCurrentUser/feature.js

@@ -1,10 +1,11 @@
 import { createFeature } from "@webiny/feature/api";
 import { KickOutCurrentUserUseCase } from "./KickOutCurrentUserUseCase.js";
-export const KickOutCurrentUserFeature = createFeature({
-  name: "KickOutCurrentUser",
-  register(container) {
-    container.register(KickOutCurrentUserUseCase);
-  }
+const KickOutCurrentUserFeature = createFeature({
+    name: "KickOutCurrentUser",
+    register (container) {
+        container.register(KickOutCurrentUserUseCase);
+    }
 });
+export { KickOutCurrentUserFeature };
 
 //# sourceMappingURL=feature.js.map

package/features/KickOutCurrentUser/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","KickOutCurrentUserUseCase","KickOutCurrentUserFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { KickOutCurrentUserUseCase } from \"./KickOutCurrentUserUseCase.js\";\n\nexport const KickOutCurrentUserFeature = createFeature({\n    name: \"KickOutCurrentUser\",\n    register(container) {\n        container.register(KickOutCurrentUserUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,yBAAyB;AAElC,OAAO,MAAMC,yBAAyB,GAAGF,aAAa,CAAC;EACnDG,IAAI,EAAE,oBAAoB;EAC1BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,yBAAyB,CAAC;EACjD;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/KickOutCurrentUser/feature.js","sources":["../../../src/features/KickOutCurrentUser/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { KickOutCurrentUserUseCase } from \"./KickOutCurrentUserUseCase.js\";\n\nexport const KickOutCurrentUserFeature = createFeature({\n    name: \"KickOutCurrentUser\",\n    register(container) {\n        container.register(KickOutCurrentUserUseCase);\n    }\n});\n"],"names":["KickOutCurrentUserFeature","createFeature","container","KickOutCurrentUserUseCase"],"mappings":";;AAGO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/KickOutCurrentUser/index.js

@@ -1,3 +1 @@
 export * from "./abstractions.js";
-
-//# sourceMappingURL=index.js.map

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 { RecordLockingConfig } from "../../domain/abstractions.js";
 import type { CmsModel } from "@webiny/api-headless-cms/types";
+import { CmsWhereMapper } from "@webiny/api-headless-cms";
+import { RecordLockingConfig } 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 cmsWhereMapper;
+    constructor(config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface, model: CmsModel, cmsWhereMapper: CmsWhereMapper.Interface);
     execute(input?: ListAllLockRecordsInput): Promise<Result<ListAllLockRecordsOutput, RepositoryAbstraction.Error>>;
 }
 export declare const ListAllLockRecordsRepository: typeof ListAllLockRecordsRepositoryImpl & {

package/features/ListAllLockRecords/ListAllLockRecordsRepository.js

@@ -1,43 +1,49 @@
 import { Result } from "@webiny/feature/api";
-import { ListAllLockRecordsRepository as RepositoryAbstraction } from "./abstractions.js";
+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 { LockRecordPersistenceError } from "../../domain/errors.js";
 import { convertWhereCondition } from "../../utils/convertWhereCondition.js";
 import { LockRecord } from "../../domain/LockRecord.js";
 class ListAllLockRecordsRepositoryImpl {
-  constructor(config, listEntries, model) {
-    this.config = config;
-    this.listEntries = listEntries;
-    this.model = model;
-  }
-  async execute(input) {
-    try {
-      const params = {
-        ...input,
-        where: convertWhereCondition(input?.where)
-      };
-      const result = await this.listEntries.execute(this.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));
-      return Result.ok({
-        items,
-        meta
-      });
-    } catch (error) {
-      return Result.fail(new LockRecordPersistenceError(error));
+    constructor(config, listEntries, model, cmsWhereMapper){
+        this.config = config;
+        this.listEntries = listEntries;
+        this.model = model;
+        this.cmsWhereMapper = cmsWhereMapper;
+    }
+    async execute(input) {
+        try {
+            const params = {
+                ...input,
+                where: this.cmsWhereMapper.map({
+                    input: convertWhereCondition(input?.where),
+                    fields: this.model.fields
+                })
+            };
+            const result = await this.listEntries.execute(this.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));
+            return Result.ok({
+                items,
+                meta
+            });
+        } catch (error) {
+            return Result.fail(new LockRecordPersistenceError(error));
+        }
     }
-  }
 }
-export const ListAllLockRecordsRepository = RepositoryAbstraction.createImplementation({
-  implementation: ListAllLockRecordsRepositoryImpl,
-  dependencies: [RecordLockingConfig, ListLatestEntriesUseCase, RecordLockingModel]
+const ListAllLockRecordsRepository_ListAllLockRecordsRepository = ListAllLockRecordsRepository.createImplementation({
+    implementation: ListAllLockRecordsRepositoryImpl,
+    dependencies: [
+        RecordLockingConfig,
+        ListLatestEntriesUseCase,
+        RecordLockingModel,
+        CmsWhereMapper
+    ]
 });
+export { ListAllLockRecordsRepository_ListAllLockRecordsRepository as ListAllLockRecordsRepository };
 
 //# sourceMappingURL=ListAllLockRecordsRepository.js.map

package/features/ListAllLockRecords/ListAllLockRecordsRepository.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","ListAllLockRecordsRepository","RepositoryAbstraction","ListLatestEntriesUseCase","RecordLockingConfig","RecordLockingModel","LockRecordPersistenceError","convertWhereCondition","LockRecord","ListAllLockRecordsRepositoryImpl","constructor","config","listEntries","model","execute","input","params","where","result","isFail","fail","error","entries","meta","value","items","map","entry","timeout","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,4BAA4B,IAAIC,qBAAqB;AAIzD,SAASC,wBAAwB,QAAQ,4DAA4D;AACrG,SAASC,mBAAmB,EAAEC,kBAAkB;AAEhD,SAASC,0BAA0B;AACnC,SAASC,qBAAqB;AAC9B,SAASC,UAAU;AAGnB,MAAMC,gCAAgC,CAA4C;EAC9EC,WAAWA,CACCC,MAAqC,EACrCC,WAA+C,EAC/CC,KAAe,EACzB;IAAA,KAHUF,MAAqC,GAArCA,MAAqC;IAAA,KACrCC,WAA+C,GAA/CA,WAA+C;IAAA,KAC/CC,KAAe,GAAfA,KAAe;EACxB;EAEH,MAAMC,OAAOA,CACTC,KAA+B,EACuC;IACtE,IAAI;MACA,MAAMC,MAAM,GAAG;QACX,GAAGD,KAAK;QACRE,KAAK,EAAEV,qBAAqB,CAACQ,KAAK,EAAEE,KAAK;MAC7C,CAAC;MAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,WAAW,CAACE,OAAO,CAAmB,IAAI,CAACD,KAAK,EAAEG,MAAM,CAAC;MAEnF,IAAIE,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;QACjB,OAAOnB,MAAM,CAACoB,IAAI,CAAC,IAAId,0BAA0B,CAACY,MAAM,CAACG,KAAK,CAAC,CAAC;MACpE;MAEA,MAAM;QAAEC,OAAO;QAAEC;MAAK,CAAC,GAAGL,MAAM,CAACM,KAAK;MAEtC,MAAMC,KAAK,GAAGH,OAAO,CAACI,GAAG,CAACC,KAAK,IAAI,IAAInB,UAAU,CAACmB,KAAK,EAAE,IAAI,CAAChB,MAAM,CAACiB,OAAO,CAAC,CAAC;MAE9E,OAAO5B,MAAM,CAAC6B,EAAE,CAAC;QACbJ,KAAK;QACLF;MACJ,CAAC,CAAC;IACN,CAAC,CAAC,OAAOF,KAAK,EAAE;MACZ,OAAOrB,MAAM,CAACoB,IAAI,CAAC,IAAId,0BAA0B,CAACe,KAAc,CAAC,CAAC;IACtE;EACJ;AACJ;AAEA,OAAO,MAAMpB,4BAA4B,GAAGC,qBAAqB,CAAC4B,oBAAoB,CAAC;EACnFC,cAAc,EAAEtB,gCAAgC;EAChDuB,YAAY,EAAE,CAAC5B,mBAAmB,EAAED,wBAAwB,EAAEE,kBAAkB;AACpF,CAAC,CAAC","ignoreList":[]}
+{"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"}

package/features/ListAllLockRecords/ListAllLockRecordsUseCase.js

@@ -1,15 +1,18 @@
-import { ListAllLockRecordsUseCase as UseCaseAbstraction, ListAllLockRecordsRepository } from "./abstractions.js";
+import { ListAllLockRecordsRepository, ListAllLockRecordsUseCase } from "./abstractions.js";
 class ListAllLockRecordsUseCaseImpl {
-  constructor(repository) {
-    this.repository = repository;
-  }
-  async execute(input) {
-    return await this.repository.execute(input);
-  }
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(input) {
+        return await this.repository.execute(input);
+    }
 }
-export const ListAllLockRecordsUseCase = UseCaseAbstraction.createImplementation({
-  implementation: ListAllLockRecordsUseCaseImpl,
-  dependencies: [ListAllLockRecordsRepository]
+const ListAllLockRecordsUseCase_ListAllLockRecordsUseCase = ListAllLockRecordsUseCase.createImplementation({
+    implementation: ListAllLockRecordsUseCaseImpl,
+    dependencies: [
+        ListAllLockRecordsRepository
+    ]
 });
+export { ListAllLockRecordsUseCase_ListAllLockRecordsUseCase as ListAllLockRecordsUseCase };
 
 //# sourceMappingURL=ListAllLockRecordsUseCase.js.map

package/features/ListAllLockRecords/ListAllLockRecordsUseCase.js.map

@@ -1 +1 @@
-{"version":3,"names":["ListAllLockRecordsUseCase","UseCaseAbstraction","ListAllLockRecordsRepository","ListAllLockRecordsUseCaseImpl","constructor","repository","execute","input","createImplementation","implementation","dependencies"],"sources":["ListAllLockRecordsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    ListAllLockRecordsUseCase as UseCaseAbstraction,\n    ListAllLockRecordsRepository,\n    ListAllLockRecordsInput,\n    ListAllLockRecordsOutput\n} from \"./abstractions.js\";\n\nclass ListAllLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: ListAllLockRecordsRepository.Interface) {}\n\n    async execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, UseCaseAbstraction.Error>> {\n        return await this.repository.execute(input);\n    }\n}\n\nexport const ListAllLockRecordsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListAllLockRecordsUseCaseImpl,\n    dependencies: [ListAllLockRecordsRepository]\n});\n"],"mappings":"AACA,SACIA,yBAAyB,IAAIC,kBAAkB,EAC/CC,4BAA4B;AAKhC,MAAMC,6BAA6B,CAAyC;EACxEC,WAAWA,CAASC,UAAkD,EAAE;IAAA,KAApDA,UAAkD,GAAlDA,UAAkD;EAAG;EAEzE,MAAMC,OAAOA,CACTC,KAA+B,EACoC;IACnE,OAAO,MAAM,IAAI,CAACF,UAAU,CAACC,OAAO,CAACC,KAAK,CAAC;EAC/C;AACJ;AAEA,OAAO,MAAMP,yBAAyB,GAAGC,kBAAkB,CAACO,oBAAoB,CAAC;EAC7EC,cAAc,EAAEN,6BAA6B;EAC7CO,YAAY,EAAE,CAACR,4BAA4B;AAC/C,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/ListAllLockRecords/ListAllLockRecordsUseCase.js","sources":["../../../src/features/ListAllLockRecords/ListAllLockRecordsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    ListAllLockRecordsUseCase as UseCaseAbstraction,\n    ListAllLockRecordsRepository,\n    ListAllLockRecordsInput,\n    ListAllLockRecordsOutput\n} from \"./abstractions.js\";\n\nclass ListAllLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: ListAllLockRecordsRepository.Interface) {}\n\n    async execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, UseCaseAbstraction.Error>> {\n        return await this.repository.execute(input);\n    }\n}\n\nexport const ListAllLockRecordsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListAllLockRecordsUseCaseImpl,\n    dependencies: [ListAllLockRecordsRepository]\n});\n"],"names":["ListAllLockRecordsUseCaseImpl","repository","input","ListAllLockRecordsUseCase","UseCaseAbstraction","ListAllLockRecordsRepository"],"mappings":";AAQA,MAAMA;IACF,YAAoBC,UAAkD,CAAE;aAApDA,UAAU,GAAVA;IAAqD;IAEzE,MAAM,QACFC,KAA+B,EACoC;QACnE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACzC;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBJ;IAChB,cAAc;QAACK;KAA6B;AAChD"}

package/features/ListAllLockRecords/abstractions.js

@@ -1,17 +1,6 @@
 import { createAbstraction } from "@webiny/feature/api";
-
-// Input/Output types
-
-/**
- * ListAllLockRecords Use Case - Lists all lock records without filtering
- */
-
-export const ListAllLockRecordsUseCase = createAbstraction("ListAllLockRecordsUseCase");
-
-/**
- * ListAllLockRecordsRepository - Fetches all lock records from storage
- */
-
-export const ListAllLockRecordsRepository = createAbstraction("ListAllLockRecordsRepository");
+const ListAllLockRecordsUseCase = createAbstraction("ListAllLockRecordsUseCase");
+const ListAllLockRecordsRepository = createAbstraction("ListAllLockRecordsRepository");
+export { ListAllLockRecordsRepository, ListAllLockRecordsUseCase };
 
 //# sourceMappingURL=abstractions.js.map

package/features/ListAllLockRecords/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","ListAllLockRecordsUseCase","ListAllLockRecordsRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport type { CmsEntryListParams, CmsEntryMeta } from \"@webiny/api-headless-cms/types\";\n\n// Input/Output types\nexport type ListAllLockRecordsInput = Pick<\n    CmsEntryListParams,\n    \"where\" | \"limit\" | \"sort\" | \"after\"\n>;\n\nexport interface ListAllLockRecordsOutput {\n    items: ILockRecord[];\n    meta: CmsEntryMeta;\n}\n\n/**\n * ListAllLockRecords Use Case - Lists all lock records without filtering\n */\nexport interface IListAllLockRecordsUseCase {\n    execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, UseCaseError>>;\n}\n\nexport interface IListAllLockRecordsUseCaseErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype UseCaseError = IListAllLockRecordsUseCaseErrors[keyof IListAllLockRecordsUseCaseErrors];\n\nexport const ListAllLockRecordsUseCase = createAbstraction<IListAllLockRecordsUseCase>(\n    \"ListAllLockRecordsUseCase\"\n);\n\nexport namespace ListAllLockRecordsUseCase {\n    export type Interface = IListAllLockRecordsUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * ListAllLockRecordsRepository - Fetches all lock records from storage\n */\nexport interface IListAllLockRecordsRepository {\n    execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, RepositoryError>>;\n}\n\nexport interface IListAllLockRecordsRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError =\n    IListAllLockRecordsRepositoryErrors[keyof IListAllLockRecordsRepositoryErrors];\n\nexport const ListAllLockRecordsRepository = createAbstraction<IListAllLockRecordsRepository>(\n    \"ListAllLockRecordsRepository\"\n);\n\nexport namespace ListAllLockRecordsRepository {\n    export type Interface = IListAllLockRecordsRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAMvD;;AAWA;AACA;AACA;;AAaA,OAAO,MAAMC,yBAAyB,GAAGD,iBAAiB,CACtD,2BACJ,CAAC;;AAOD;AACA;AACA;;AAcA,OAAO,MAAME,4BAA4B,GAAGF,iBAAiB,CACzD,8BACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"features/ListAllLockRecords/abstractions.js","sources":["../../../src/features/ListAllLockRecords/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport type { CmsEntryListParams, CmsEntryMeta } from \"@webiny/api-headless-cms/types\";\n\n// Input/Output types\nexport type ListAllLockRecordsInput = Pick<\n    CmsEntryListParams,\n    \"where\" | \"limit\" | \"sort\" | \"after\"\n>;\n\nexport interface ListAllLockRecordsOutput {\n    items: ILockRecord[];\n    meta: CmsEntryMeta;\n}\n\n/**\n * ListAllLockRecords Use Case - Lists all lock records without filtering\n */\nexport interface IListAllLockRecordsUseCase {\n    execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, UseCaseError>>;\n}\n\nexport interface IListAllLockRecordsUseCaseErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype UseCaseError = IListAllLockRecordsUseCaseErrors[keyof IListAllLockRecordsUseCaseErrors];\n\nexport const ListAllLockRecordsUseCase = createAbstraction<IListAllLockRecordsUseCase>(\n    \"ListAllLockRecordsUseCase\"\n);\n\nexport namespace ListAllLockRecordsUseCase {\n    export type Interface = IListAllLockRecordsUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * ListAllLockRecordsRepository - Fetches all lock records from storage\n */\nexport interface IListAllLockRecordsRepository {\n    execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, RepositoryError>>;\n}\n\nexport interface IListAllLockRecordsRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError =\n    IListAllLockRecordsRepositoryErrors[keyof IListAllLockRecordsRepositoryErrors];\n\nexport const ListAllLockRecordsRepository = createAbstraction<IListAllLockRecordsRepository>(\n    \"ListAllLockRecordsRepository\"\n);\n\nexport namespace ListAllLockRecordsRepository {\n    export type Interface = IListAllLockRecordsRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["ListAllLockRecordsUseCase","createAbstraction","ListAllLockRecordsRepository"],"mappings":";AAgCO,MAAMA,4BAA4BC,kBACrC;AAwBG,MAAMC,+BAA+BD,kBACxC"}

package/features/ListAllLockRecords/feature.d.ts

@@ -1 +1,4 @@
-export declare const ListAllLockRecordsFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;
+export declare const ListAllLockRecordsFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/ListAllLockRecords/feature.js

@@ -1,12 +1,13 @@
 import { createFeature } from "@webiny/feature/api";
 import { ListAllLockRecordsUseCase } from "./ListAllLockRecordsUseCase.js";
 import { ListAllLockRecordsRepository } from "./ListAllLockRecordsRepository.js";
-export const ListAllLockRecordsFeature = createFeature({
-  name: "ListAllLockRecords",
-  register(container) {
-    container.register(ListAllLockRecordsUseCase);
-    container.register(ListAllLockRecordsRepository).inSingletonScope();
-  }
+const ListAllLockRecordsFeature = createFeature({
+    name: "ListAllLockRecords",
+    register (container) {
+        container.register(ListAllLockRecordsUseCase);
+        container.register(ListAllLockRecordsRepository).inSingletonScope();
+    }
 });
+export { ListAllLockRecordsFeature };
 
 //# sourceMappingURL=feature.js.map

package/features/ListAllLockRecords/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","ListAllLockRecordsUseCase","ListAllLockRecordsRepository","ListAllLockRecordsFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListAllLockRecordsUseCase } from \"./ListAllLockRecordsUseCase.js\";\nimport { ListAllLockRecordsRepository } from \"./ListAllLockRecordsRepository.js\";\n\nexport const ListAllLockRecordsFeature = createFeature({\n    name: \"ListAllLockRecords\",\n    register(container) {\n        container.register(ListAllLockRecordsUseCase);\n        container.register(ListAllLockRecordsRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,yBAAyB;AAClC,SAASC,4BAA4B;AAErC,OAAO,MAAMC,yBAAyB,GAAGH,aAAa,CAAC;EACnDI,IAAI,EAAE,oBAAoB;EAC1BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,yBAAyB,CAAC;IAC7CK,SAAS,CAACD,QAAQ,CAACH,4BAA4B,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACvE;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/ListAllLockRecords/feature.js","sources":["../../../src/features/ListAllLockRecords/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListAllLockRecordsUseCase } from \"./ListAllLockRecordsUseCase.js\";\nimport { ListAllLockRecordsRepository } from \"./ListAllLockRecordsRepository.js\";\n\nexport const ListAllLockRecordsFeature = createFeature({\n    name: \"ListAllLockRecords\",\n    register(container) {\n        container.register(ListAllLockRecordsUseCase);\n        container.register(ListAllLockRecordsRepository).inSingletonScope();\n    }\n});\n"],"names":["ListAllLockRecordsFeature","createFeature","container","ListAllLockRecordsUseCase","ListAllLockRecordsRepository"],"mappings":";;;AAIO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,8BAA8B,gBAAgB;IACrE;AACJ"}

package/features/ListAllLockRecords/index.js

@@ -1,4 +1,2 @@
 export * from "./abstractions.js";
 export * from "./feature.js";
-
-//# sourceMappingURL=index.js.map

package/features/ListLockRecords/ListLockRecordsRepository.d.ts

@@ -2,11 +2,13 @@ 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 { CmsWhereMapper } from "@webiny/api-headless-cms";
 declare class ListLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {
     private model;
     private config;
     private listEntries;
-    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface);
+    private cmsWhereMapper;
+    constructor(model: RecordLockingModel.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,43 +1,49 @@
 import { Result } from "@webiny/feature/api";
 import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
-import { ListLockRecordsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ListLockRecordsRepository } from "./abstractions.js";
 import { RecordLockingConfig, RecordLockingModel } 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;
-    this.config = config;
-    this.listEntries = listEntries;
-  }
-  async execute(input) {
-    try {
-      const params = {
-        ...input,
-        where: convertWhereCondition(input?.where || {})
-      };
-      const result = await this.listEntries.execute(this.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));
-      return Result.ok({
-        items,
-        meta
-      });
-    } catch (error) {
-      return Result.fail(new LockRecordPersistenceError(error));
+    constructor(model, config, listEntries, cmsWhereMapper){
+        this.model = model;
+        this.config = config;
+        this.listEntries = listEntries;
+        this.cmsWhereMapper = cmsWhereMapper;
+    }
+    async execute(input) {
+        try {
+            const params = {
+                ...input,
+                where: this.cmsWhereMapper.map({
+                    input: convertWhereCondition(input?.where),
+                    fields: this.model.fields
+                })
+            };
+            const result = await this.listEntries.execute(this.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));
+            return Result.ok({
+                items,
+                meta
+            });
+        } catch (error) {
+            return Result.fail(new LockRecordPersistenceError(error));
+        }
     }
-  }
 }
-export const ListLockRecordsRepository = RepositoryAbstraction.createImplementation({
-  implementation: ListLockRecordsRepositoryImpl,
-  dependencies: [RecordLockingModel, RecordLockingConfig, ListLatestEntriesUseCase]
+const ListLockRecordsRepository_ListLockRecordsRepository = ListLockRecordsRepository.createImplementation({
+    implementation: ListLockRecordsRepositoryImpl,
+    dependencies: [
+        RecordLockingModel,
+        RecordLockingConfig,
+        ListLatestEntriesUseCase,
+        CmsWhereMapper
+    ]
 });
+export { ListLockRecordsRepository_ListLockRecordsRepository as ListLockRecordsRepository };
 
 //# sourceMappingURL=ListLockRecordsRepository.js.map

package/features/ListLockRecords/ListLockRecordsRepository.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","ListLatestEntriesUseCase","ListLockRecordsRepository","RepositoryAbstraction","RecordLockingConfig","RecordLockingModel","LockRecord","LockRecordPersistenceError","convertWhereCondition","ListLockRecordsRepositoryImpl","constructor","model","config","listEntries","execute","input","params","where","result","isFail","fail","error","entries","meta","value","items","map","entry","timeout","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,wBAAwB,QAAQ,4DAA4D;AACrG,SACIC,yBAAyB,IAAIC,qBAAqB;AAItD,SAASC,mBAAmB,EAAEC,kBAAkB;AAChD,SAASC,UAAU;AAEnB,SAASC,0BAA0B;AACnC,SAASC,qBAAqB;AAE9B,MAAMC,6BAA6B,CAA4C;EAC3EC,WAAWA,CACCC,KAAmC,EACnCC,MAAqC,EACrCC,WAA+C,EACzD;IAAA,KAHUF,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;IAAA,KACrCC,WAA+C,GAA/CA,WAA+C;EACxD;EAEH,MAAMC,OAAOA,CACTC,KAA4B,EACuC;IACnE,IAAI;MACA,MAAMC,MAAM,GAAG;QACX,GAAGD,KAAK;QACRE,KAAK,EAAET,qBAAqB,CAACO,KAAK,EAAEE,KAAK,IAAI,CAAC,CAAC;MACnD,CAAC;MAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACL,WAAW,CAACC,OAAO,CAAmB,IAAI,CAACH,KAAK,EAAEK,MAAM,CAAC;MAEnF,IAAIE,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;QACjB,OAAOnB,MAAM,CAACoB,IAAI,CAAC,IAAIb,0BAA0B,CAACW,MAAM,CAACG,KAAK,CAAC,CAAC;MACpE;MAEA,MAAM;QAAEC,OAAO;QAAEC;MAAK,CAAC,GAAGL,MAAM,CAACM,KAAK;MAEtC,MAAMC,KAAK,GAAGH,OAAO,CAACI,GAAG,CAACC,KAAK,IAAI,IAAIrB,UAAU,CAACqB,KAAK,EAAE,IAAI,CAACf,MAAM,CAACgB,OAAO,CAAC,CAAC;MAE9E,OAAO5B,MAAM,CAAC6B,EAAE,CAAC;QACbJ,KAAK;QACLF;MACJ,CAAC,CAAC;IACN,CAAC,CAAC,OAAOF,KAAK,EAAE;MACZ,OAAOrB,MAAM,CAACoB,IAAI,CAAC,IAAIb,0BAA0B,CAACc,KAAc,CAAC,CAAC;IACtE;EACJ;AACJ;AAEA,OAAO,MAAMnB,yBAAyB,GAAGC,qBAAqB,CAAC2B,oBAAoB,CAAC;EAChFC,cAAc,EAAEtB,6BAA6B;EAC7CuB,YAAY,EAAE,CAAC3B,kBAAkB,EAAED,mBAAmB,EAAEH,wBAAwB;AACpF,CAAC,CAAC","ignoreList":[]}
+{"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"}

package/features/ListLockRecords/ListLockRecordsUseCase.d.ts

@@ -1,6 +1,6 @@
 import { Result } from "@webiny/feature/api";
 import { ListLockRecordsInput, ListLockRecordsOutput, ListLockRecordsRepository, ListLockRecordsUseCase as UseCaseAbstraction } from "./abstractions.js";
-import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
 import { RecordLockingConfig } from "../../domain/abstractions.js";
 declare class ListLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {
     private repository;

package/features/ListLockRecords/ListLockRecordsUseCase.js

@@ -1,30 +1,33 @@
-import { ListLockRecordsRepository, ListLockRecordsUseCase as UseCaseAbstraction } from "./abstractions.js";
-import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { ListLockRecordsRepository, ListLockRecordsUseCase } from "./abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
 import { RecordLockingConfig } from "../../domain/abstractions.js";
 class ListLockRecordsUseCaseImpl {
-  constructor(repository, identityContext, config) {
-    this.repository = repository;
-    this.identityContext = identityContext;
-    this.config = config;
-  }
-  async execute(input) {
-    const identity = this.identityContext.getIdentity();
-
-    // Filter out expired locks and exclude current user's locks
-    const enhancedInput = {
-      ...input,
-      where: {
-        ...input?.where,
-        createdBy_not: identity.id,
-        savedOn_gte: new Date(new Date().getTime() - this.config.timeout).toISOString()
-      }
-    };
-    return await this.repository.execute(enhancedInput);
-  }
+    constructor(repository, identityContext, config){
+        this.repository = repository;
+        this.identityContext = identityContext;
+        this.config = config;
+    }
+    async execute(input) {
+        const identity = this.identityContext.getIdentity();
+        const enhancedInput = {
+            ...input,
+            where: {
+                ...input?.where,
+                createdBy_not: identity.id,
+                savedOn_gte: new Date(new Date().getTime() - this.config.timeout).toISOString()
+            }
+        };
+        return await this.repository.execute(enhancedInput);
+    }
 }
-export const ListLockRecordsUseCase = UseCaseAbstraction.createImplementation({
-  implementation: ListLockRecordsUseCaseImpl,
-  dependencies: [ListLockRecordsRepository, IdentityContext, RecordLockingConfig]
+const ListLockRecordsUseCase_ListLockRecordsUseCase = ListLockRecordsUseCase.createImplementation({
+    implementation: ListLockRecordsUseCaseImpl,
+    dependencies: [
+        ListLockRecordsRepository,
+        IdentityContext,
+        RecordLockingConfig
+    ]
 });
+export { ListLockRecordsUseCase_ListLockRecordsUseCase as ListLockRecordsUseCase };
 
 //# sourceMappingURL=ListLockRecordsUseCase.js.map