@webiny/api-record-locking 6.3.0 → 6.4.0-beta.0

package/features/LockEntry/LockEntryEventsDecorator.js.map

@@ -1 +1 @@
-{"version":3,"names":["LockEntryUseCase","EventPublisher","EntryAfterLockEvent","EntryBeforeLockEvent","EntryLockErrorEvent","LockEntryErrorDecoratorImpl","constructor","eventPublisher","decoratee","execute","input","publish","id","type","result","isFail","error","record","value","LockEntryEventsDecorator","createDecorator","decorator","dependencies"],"sources":["LockEntryEventsDecorator.ts"],"sourcesContent":["import {\n    type LockEntryInput,\n    LockEntryUseCase as UseCaseAbstraction,\n    LockEntryUseCase\n} from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/index.js\";\nimport { Result } from \"@webiny/feature/api/index.js\";\nimport { EntryAfterLockEvent, EntryBeforeLockEvent, EntryLockErrorEvent } from \"./events.js\";\n\nclass LockEntryErrorDecoratorImpl implements LockEntryUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: LockEntryUseCase.Interface\n    ) {}\n    async execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeLockEvent({\n                id: input.id,\n                type: input.type\n            })\n        );\n\n        const result = await this.decoratee.execute(input);\n\n        if (result.isFail()) {\n            const error = result.error;\n\n            await this.eventPublisher.publish(\n                new EntryLockErrorEvent({\n                    id: input.id,\n                    type: input.type,\n                    error\n                })\n            );\n\n            return result;\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new EntryAfterLockEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const LockEntryEventsDecorator = LockEntryUseCase.createDecorator({\n    decorator: LockEntryErrorDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"mappings":"AAAA,SAGIA,gBAAgB;AAEpB,SAASC,cAAc,QAAQ,mDAAmD;AAGlF,SAASC,mBAAmB,EAAEC,oBAAoB,EAAEC,mBAAmB;AAEvE,MAAMC,2BAA2B,CAAuC;EACpEC,WAAWA,CACUC,cAAwC,EACxCC,SAAqC,EACxD;IAAA,KAFmBD,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,SAAqC,GAArCA,SAAqC;EACvD;EACH,MAAMC,OAAOA,CAACC,KAAqB,EAA0D;IACzF;IACA,MAAM,IAAI,CAACH,cAAc,CAACI,OAAO,CAC7B,IAAIR,oBAAoB,CAAC;MACrBS,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG;IAChB,CAAC,CACL,CAAC;IAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,SAAS,CAACC,OAAO,CAACC,KAAK,CAAC;IAElD,IAAII,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMC,KAAK,GAAGF,MAAM,CAACE,KAAK;MAE1B,MAAM,IAAI,CAACT,cAAc,CAACI,OAAO,CAC7B,IAAIP,mBAAmB,CAAC;QACpBQ,EAAE,EAAEF,KAAK,CAACE,EAAE;QACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;QAChBG;MACJ,CAAC,CACL,CAAC;MAED,OAAOF,MAAM;IACjB;;IAEA;IACA,MAAM,IAAI,CAACP,cAAc,CAACI,OAAO,CAC7B,IAAIT,mBAAmB,CAAC;MACpBU,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;MAChBI,MAAM,EAAEH,MAAM,CAACI;IACnB,CAAC,CACL,CAAC;IAED,OAAOJ,MAAM;EACjB;AACJ;AAEA,OAAO,MAAMK,wBAAwB,GAAGnB,gBAAgB,CAACoB,eAAe,CAAC;EACrEC,SAAS,EAAEhB,2BAA2B;EACtCiB,YAAY,EAAE,CAACrB,cAAc;AACjC,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/LockEntry/LockEntryEventsDecorator.js","sources":["../../../src/features/LockEntry/LockEntryEventsDecorator.ts"],"sourcesContent":["import {\n    type LockEntryInput,\n    LockEntryUseCase as UseCaseAbstraction,\n    LockEntryUseCase\n} from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/index.js\";\nimport { Result } from \"@webiny/feature/api/index.js\";\nimport { EntryAfterLockEvent, EntryBeforeLockEvent, EntryLockErrorEvent } from \"./events.js\";\n\nclass LockEntryErrorDecoratorImpl implements LockEntryUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: LockEntryUseCase.Interface\n    ) {}\n    async execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeLockEvent({\n                id: input.id,\n                type: input.type\n            })\n        );\n\n        const result = await this.decoratee.execute(input);\n\n        if (result.isFail()) {\n            const error = result.error;\n\n            await this.eventPublisher.publish(\n                new EntryLockErrorEvent({\n                    id: input.id,\n                    type: input.type,\n                    error\n                })\n            );\n\n            return result;\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new EntryAfterLockEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const LockEntryEventsDecorator = LockEntryUseCase.createDecorator({\n    decorator: LockEntryErrorDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"names":["LockEntryErrorDecoratorImpl","eventPublisher","decoratee","input","EntryBeforeLockEvent","result","error","EntryLockErrorEvent","EntryAfterLockEvent","LockEntryEventsDecorator","LockEntryUseCase","EventPublisher"],"mappings":";;;AAUA,MAAMA;IACF,YACqBC,cAAwC,EACxCC,SAAqC,CACxD;aAFmBD,cAAc,GAAdA;aACAC,SAAS,GAATA;IAClB;IACH,MAAM,QAAQC,KAAqB,EAA0D;QAEzF,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,qBAAqB;YACrB,IAAID,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;QACpB;QAGJ,MAAME,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACF;QAE5C,IAAIE,OAAO,MAAM,IAAI;YACjB,MAAMC,QAAQD,OAAO,KAAK;YAE1B,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,oBAAoB;gBACpB,IAAIJ,MAAM,EAAE;gBACZ,MAAMA,MAAM,IAAI;gBAChBG;YACJ;YAGJ,OAAOD;QACX;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,oBAAoB;YACpB,IAAIL,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;YAChB,QAAQE,OAAO,KAAK;QACxB;QAGJ,OAAOA;IACX;AACJ;AAEO,MAAMI,2BAA2BC,iBAAiB,eAAe,CAAC;IACrE,WAAWV;IACX,cAAc;QAACW;KAAe;AAClC"}

package/features/LockEntry/LockEntryRepository.js

@@ -1,42 +1,45 @@
 import { Result } from "@webiny/feature/api";
 import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
-import { LockEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { LockEntryRepository } from "./abstractions.js";
 import { RecordLockingConfig, RecordLockingModel } 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;
-    this.config = config;
-    this.createEntry = createEntry;
-  }
-  async create(input) {
-    try {
-      const id = createLockRecordDatabaseId(input.id);
-      const values = {
-        targetId: input.id,
-        type: input.type,
-        actions: []
-      };
-      const result = await this.createEntry.execute(this.model, {
-        id,
-        values
-      });
-      if (result.isFail()) {
-        return Result.fail(new LockRecordPersistenceError(result.error));
-      }
-      const entry = result.value;
-      const lockRecord = new LockRecord(entry, this.config.timeout);
-      return Result.ok(lockRecord);
-    } catch (error) {
-      return Result.fail(new LockRecordPersistenceError(error));
+    constructor(model, config, createEntry){
+        this.model = model;
+        this.config = config;
+        this.createEntry = createEntry;
+    }
+    async create(input) {
+        try {
+            const id = createLockRecordDatabaseId(input.id);
+            const values = {
+                targetId: input.id,
+                type: input.type,
+                actions: []
+            };
+            const result = await this.createEntry.execute(this.model, {
+                id,
+                values
+            });
+            if (result.isFail()) return Result.fail(new LockRecordPersistenceError(result.error));
+            const entry = result.value;
+            const lockRecord = new LockRecord(entry, this.config.timeout);
+            return Result.ok(lockRecord);
+        } catch (error) {
+            return Result.fail(new LockRecordPersistenceError(error));
+        }
     }
-  }
 }
-export const LockEntryRepository = RepositoryAbstraction.createImplementation({
-  implementation: LockEntryRepositoryImpl,
-  dependencies: [RecordLockingModel, RecordLockingConfig, CreateEntryUseCase]
+const LockEntryRepository_LockEntryRepository = LockEntryRepository.createImplementation({
+    implementation: LockEntryRepositoryImpl,
+    dependencies: [
+        RecordLockingModel,
+        RecordLockingConfig,
+        CreateEntryUseCase
+    ]
 });
+export { LockEntryRepository_LockEntryRepository as LockEntryRepository };
 
 //# sourceMappingURL=LockEntryRepository.js.map

package/features/LockEntry/LockEntryRepository.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","CreateEntryUseCase","LockEntryRepository","RepositoryAbstraction","RecordLockingConfig","RecordLockingModel","LockRecord","LockRecordPersistenceError","createLockRecordDatabaseId","LockEntryRepositoryImpl","constructor","model","config","createEntry","create","input","id","values","targetId","type","actions","result","execute","isFail","fail","error","entry","value","lockRecord","timeout","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,QAAQ,4DAA4D;AAE/F,SAAyBC,mBAAmB,IAAIC,qBAAqB;AACrE,SAASC,mBAAmB,EAAEC,kBAAkB;AAEhD,SAASC,UAAU;AAEnB,SAASC,0BAA0B;AACnC,SAASC,0BAA0B;AAEnC,MAAMC,uBAAuB,CAA4C;EACrEC,WAAWA,CACCC,KAAmC,EACnCC,MAAqC,EACrCC,WAAyC,EACnD;IAAA,KAHUF,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;IAAA,KACrCC,WAAyC,GAAzCA,WAAyC;EAClD;EAEH,MAAMC,MAAMA,CAACC,KAAqB,EAA6D;IAC3F,IAAI;MACA,MAAMC,EAAE,GAAGR,0BAA0B,CAACO,KAAK,CAACC,EAAE,CAAC;MAE/C,MAAMC,MAAwB,GAAG;QAC7BC,QAAQ,EAAEH,KAAK,CAACC,EAAE;QAClBG,IAAI,EAAEJ,KAAK,CAACI,IAAI;QAChBC,OAAO,EAAE;MACb,CAAC;MAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACR,WAAW,CAACS,OAAO,CAAC,IAAI,CAACX,KAAK,EAAE;QACtDK,EAAE;QACFC;MACJ,CAAC,CAAC;MAEF,IAAII,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;QACjB,OAAOvB,MAAM,CAACwB,IAAI,CAAC,IAAIjB,0BAA0B,CAACc,MAAM,CAACI,KAAK,CAAC,CAAC;MACpE;MAEA,MAAMC,KAAK,GAAGL,MAAM,CAACM,KAAmC;MACxD,MAAMC,UAAU,GAAG,IAAItB,UAAU,CAACoB,KAAK,EAAE,IAAI,CAACd,MAAM,CAACiB,OAAO,CAAC;MAE7D,OAAO7B,MAAM,CAAC8B,EAAE,CAACF,UAAU,CAAC;IAChC,CAAC,CAAC,OAAOH,KAAK,EAAE;MACZ,OAAOzB,MAAM,CAACwB,IAAI,CAAC,IAAIjB,0BAA0B,CAACkB,KAAc,CAAC,CAAC;IACtE;EACJ;AACJ;AAEA,OAAO,MAAMvB,mBAAmB,GAAGC,qBAAqB,CAAC4B,oBAAoB,CAAC;EAC1EC,cAAc,EAAEvB,uBAAuB;EACvCwB,YAAY,EAAE,CAAC5B,kBAAkB,EAAED,mBAAmB,EAAEH,kBAAkB;AAC9E,CAAC,CAAC","ignoreList":[]}
+{"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"}

package/features/LockEntry/LockEntryUseCase.js

@@ -1,36 +1,31 @@
 import { Result } from "@webiny/feature/api";
-import { LockEntryUseCase as UseCaseAbstraction, LockEntryRepository } from "./abstractions.js";
+import { LockEntryRepository, LockEntryUseCase } from "./abstractions.js";
 import { IsEntryLockedUseCase } from "../IsEntryLocked/abstractions.js";
 import { EntryAlreadyLockedError, LockEntryError } from "../../domain/errors.js";
 class LockEntryUseCaseImpl {
-  constructor(isEntryLocked, repository) {
-    this.isEntryLocked = isEntryLocked;
-    this.repository = repository;
-  }
-  async execute(input) {
-    // Check if entry is already locked
-    const lockedResult = await this.isEntryLocked.execute(input);
-    if (lockedResult.isFail()) {
-      return Result.fail(lockedResult.error);
+    constructor(isEntryLocked, repository){
+        this.isEntryLocked = isEntryLocked;
+        this.repository = repository;
     }
-    if (lockedResult.value) {
-      return Result.fail(new EntryAlreadyLockedError({
-        id: input.id,
-        type: input.type
-      }));
+    async execute(input) {
+        const lockedResult = await this.isEntryLocked.execute(input);
+        if (lockedResult.isFail()) return Result.fail(lockedResult.error);
+        if (lockedResult.value) return Result.fail(new EntryAlreadyLockedError({
+            id: input.id,
+            type: input.type
+        }));
+        const result = await this.repository.create(input);
+        if (result.isFail()) return Result.fail(new LockEntryError(result.error));
+        return Result.ok(result.value);
     }
-
-    // Create the lock
-    const result = await this.repository.create(input);
-    if (result.isFail()) {
-      return Result.fail(new LockEntryError(result.error));
-    }
-    return Result.ok(result.value);
-  }
 }
-export const LockEntryUseCase = UseCaseAbstraction.createImplementation({
-  implementation: LockEntryUseCaseImpl,
-  dependencies: [IsEntryLockedUseCase, LockEntryRepository]
+const LockEntryUseCase_LockEntryUseCase = LockEntryUseCase.createImplementation({
+    implementation: LockEntryUseCaseImpl,
+    dependencies: [
+        IsEntryLockedUseCase,
+        LockEntryRepository
+    ]
 });
+export { LockEntryUseCase_LockEntryUseCase as LockEntryUseCase };
 
 //# sourceMappingURL=LockEntryUseCase.js.map

package/features/LockEntry/LockEntryUseCase.js.map

@@ -1 +1 @@
-{"version":3,"names":["Result","LockEntryUseCase","UseCaseAbstraction","LockEntryRepository","IsEntryLockedUseCase","EntryAlreadyLockedError","LockEntryError","LockEntryUseCaseImpl","constructor","isEntryLocked","repository","execute","input","lockedResult","isFail","fail","error","value","id","type","result","create","ok","createImplementation","implementation","dependencies"],"sources":["LockEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    LockEntryUseCase as UseCaseAbstraction,\n    LockEntryRepository,\n    LockEntryInput\n} from \"./abstractions.js\";\nimport { IsEntryLockedUseCase } from \"../IsEntryLocked/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { EntryAlreadyLockedError, LockEntryError } from \"~/domain/errors.js\";\n\nclass LockEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private isEntryLocked: IsEntryLockedUseCase.Interface,\n        private repository: LockEntryRepository.Interface\n    ) {}\n\n    async execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Check if entry is already locked\n        const lockedResult = await this.isEntryLocked.execute(input);\n\n        if (lockedResult.isFail()) {\n            return Result.fail(lockedResult.error);\n        }\n\n        if (lockedResult.value) {\n            return Result.fail(new EntryAlreadyLockedError({ id: input.id, type: input.type }));\n        }\n\n        // Create the lock\n        const result = await this.repository.create(input);\n\n        if (result.isFail()) {\n            return Result.fail(new LockEntryError(result.error));\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const LockEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: LockEntryUseCaseImpl,\n    dependencies: [IsEntryLockedUseCase, LockEntryRepository]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,gBAAgB,IAAIC,kBAAkB,EACtCC,mBAAmB;AAGvB,SAASC,oBAAoB;AAE7B,SAASC,uBAAuB,EAAEC,cAAc;AAEhD,MAAMC,oBAAoB,CAAyC;EAC/DC,WAAWA,CACCC,aAA6C,EAC7CC,UAAyC,EACnD;IAAA,KAFUD,aAA6C,GAA7CA,aAA6C;IAAA,KAC7CC,UAAyC,GAAzCA,UAAyC;EAClD;EAEH,MAAMC,OAAOA,CAACC,KAAqB,EAA0D;IACzF;IACA,MAAMC,YAAY,GAAG,MAAM,IAAI,CAACJ,aAAa,CAACE,OAAO,CAACC,KAAK,CAAC;IAE5D,IAAIC,YAAY,CAACC,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOd,MAAM,CAACe,IAAI,CAACF,YAAY,CAACG,KAAK,CAAC;IAC1C;IAEA,IAAIH,YAAY,CAACI,KAAK,EAAE;MACpB,OAAOjB,MAAM,CAACe,IAAI,CAAC,IAAIV,uBAAuB,CAAC;QAAEa,EAAE,EAAEN,KAAK,CAACM,EAAE;QAAEC,IAAI,EAAEP,KAAK,CAACO;MAAK,CAAC,CAAC,CAAC;IACvF;;IAEA;IACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACV,UAAU,CAACW,MAAM,CAACT,KAAK,CAAC;IAElD,IAAIQ,MAAM,CAACN,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOd,MAAM,CAACe,IAAI,CAAC,IAAIT,cAAc,CAACc,MAAM,CAACJ,KAAK,CAAC,CAAC;IACxD;IAEA,OAAOhB,MAAM,CAACsB,EAAE,CAACF,MAAM,CAACH,KAAK,CAAC;EAClC;AACJ;AAEA,OAAO,MAAMhB,gBAAgB,GAAGC,kBAAkB,CAACqB,oBAAoB,CAAC;EACpEC,cAAc,EAAEjB,oBAAoB;EACpCkB,YAAY,EAAE,CAACrB,oBAAoB,EAAED,mBAAmB;AAC5D,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/LockEntry/LockEntryUseCase.js","sources":["../../../src/features/LockEntry/LockEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    LockEntryUseCase as UseCaseAbstraction,\n    LockEntryRepository,\n    LockEntryInput\n} from \"./abstractions.js\";\nimport { IsEntryLockedUseCase } from \"../IsEntryLocked/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { EntryAlreadyLockedError, LockEntryError } from \"~/domain/errors.js\";\n\nclass LockEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private isEntryLocked: IsEntryLockedUseCase.Interface,\n        private repository: LockEntryRepository.Interface\n    ) {}\n\n    async execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Check if entry is already locked\n        const lockedResult = await this.isEntryLocked.execute(input);\n\n        if (lockedResult.isFail()) {\n            return Result.fail(lockedResult.error);\n        }\n\n        if (lockedResult.value) {\n            return Result.fail(new EntryAlreadyLockedError({ id: input.id, type: input.type }));\n        }\n\n        // Create the lock\n        const result = await this.repository.create(input);\n\n        if (result.isFail()) {\n            return Result.fail(new LockEntryError(result.error));\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const LockEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: LockEntryUseCaseImpl,\n    dependencies: [IsEntryLockedUseCase, LockEntryRepository]\n});\n"],"names":["LockEntryUseCaseImpl","isEntryLocked","repository","input","lockedResult","Result","EntryAlreadyLockedError","result","LockEntryError","LockEntryUseCase","UseCaseAbstraction","IsEntryLockedUseCase","LockEntryRepository"],"mappings":";;;;AAUA,MAAMA;IACF,YACYC,aAA6C,EAC7CC,UAAyC,CACnD;aAFUD,aAAa,GAAbA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,KAAqB,EAA0D;QAEzF,MAAMC,eAAe,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAACD;QAEtD,IAAIC,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAACD,aAAa,KAAK;QAGzC,IAAIA,aAAa,KAAK,EAClB,OAAOC,OAAO,IAAI,CAAC,IAAIC,wBAAwB;YAAE,IAAIH,MAAM,EAAE;YAAE,MAAMA,MAAM,IAAI;QAAC;QAIpF,MAAMI,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACJ;QAE5C,IAAII,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAAC,IAAIG,eAAeD,OAAO,KAAK;QAGtD,OAAOF,OAAO,EAAE,CAACE,OAAO,KAAK;IACjC;AACJ;AAEO,MAAME,oCAAmBC,iBAAAA,oBAAuC,CAAC;IACpE,gBAAgBV;IAChB,cAAc;QAACW;QAAsBC;KAAoB;AAC7D"}

package/features/LockEntry/abstractions.js

@@ -1,17 +1,6 @@
 import { createAbstraction } from "@webiny/feature/api";
-
-// Input types
-
-/**
- * LockEntry Use Case - Creates a lock on an entry
- */
-
-export const LockEntryUseCase = createAbstraction("LockEntryUseCase");
-
-/**
- * LockEntryRepository - Creates lock record in storage
- */
-
-export const LockEntryRepository = createAbstraction("LockEntryRepository");
+const LockEntryUseCase = createAbstraction("LockEntryUseCase");
+const LockEntryRepository = createAbstraction("LockEntryRepository");
+export { LockEntryRepository, LockEntryUseCase };
 
 //# sourceMappingURL=abstractions.js.map

package/features/LockEntry/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","LockEntryUseCase","LockEntryRepository"],"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 { LockRecordEntryType } from \"~/domain/types.js\";\nimport type {\n    EntryAlreadyLockedError,\n    LockEntryError,\n    LockRecordPersistenceError\n} from \"~/domain/errors.js\";\n\n// Input types\nexport interface LockEntryInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * LockEntry Use Case - Creates a lock on an entry\n */\nexport interface ILockEntryUseCase {\n    execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface ILockEntryUseCaseErrors {\n    alreadyLocked: EntryAlreadyLockedError;\n    persistence: LockRecordPersistenceError;\n    lockError: LockEntryError;\n}\n\ntype UseCaseError = ILockEntryUseCaseErrors[keyof ILockEntryUseCaseErrors];\n\nexport const LockEntryUseCase = createAbstraction<ILockEntryUseCase>(\"LockEntryUseCase\");\n\nexport namespace LockEntryUseCase {\n    export type Interface = ILockEntryUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * LockEntryRepository - Creates lock record in storage\n */\nexport interface ILockEntryRepository {\n    create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryError>>;\n}\n\nexport interface ILockEntryRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError = ILockEntryRepositoryErrors[keyof ILockEntryRepositoryErrors];\n\nexport const LockEntryRepository = createAbstraction<ILockEntryRepository>(\"LockEntryRepository\");\n\nexport namespace LockEntryRepository {\n    export type Interface = ILockEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAUvD;;AAMA;AACA;AACA;;AAaA,OAAO,MAAMC,gBAAgB,GAAGD,iBAAiB,CAAoB,kBAAkB,CAAC;;AAOxF;AACA;AACA;;AAWA,OAAO,MAAME,mBAAmB,GAAGF,iBAAiB,CAAuB,qBAAqB,CAAC","ignoreList":[]}
+{"version":3,"file":"features/LockEntry/abstractions.js","sources":["../../../src/features/LockEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\nimport type {\n    EntryAlreadyLockedError,\n    LockEntryError,\n    LockRecordPersistenceError\n} from \"~/domain/errors.js\";\n\n// Input types\nexport interface LockEntryInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * LockEntry Use Case - Creates a lock on an entry\n */\nexport interface ILockEntryUseCase {\n    execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface ILockEntryUseCaseErrors {\n    alreadyLocked: EntryAlreadyLockedError;\n    persistence: LockRecordPersistenceError;\n    lockError: LockEntryError;\n}\n\ntype UseCaseError = ILockEntryUseCaseErrors[keyof ILockEntryUseCaseErrors];\n\nexport const LockEntryUseCase = createAbstraction<ILockEntryUseCase>(\"LockEntryUseCase\");\n\nexport namespace LockEntryUseCase {\n    export type Interface = ILockEntryUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * LockEntryRepository - Creates lock record in storage\n */\nexport interface ILockEntryRepository {\n    create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryError>>;\n}\n\nexport interface ILockEntryRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError = ILockEntryRepositoryErrors[keyof ILockEntryRepositoryErrors];\n\nexport const LockEntryRepository = createAbstraction<ILockEntryRepository>(\"LockEntryRepository\");\n\nexport namespace LockEntryRepository {\n    export type Interface = ILockEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["LockEntryUseCase","createAbstraction","LockEntryRepository"],"mappings":";AA+BO,MAAMA,mBAAmBC,kBAAqC;AAoB9D,MAAMC,sBAAsBD,kBAAwC"}

package/features/LockEntry/events.js

@@ -1,40 +1,32 @@
 import { createAbstraction } from "@webiny/feature/api";
 import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
-
-// ============================================================================
-// EntryBeforeLock Event
-// ============================================================================
-
-export class EntryBeforeLockEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/BeforeLock";
-  getHandlerAbstraction() {
-    return EntryBeforeLockEventHandler;
-  }
+class EntryBeforeLockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryBeforeLockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/BeforeLock";
+    }
 }
-export const EntryBeforeLockEventHandler = createAbstraction("EntryBeforeLockEventHandler");
-
-// ============================================================================
-// EntryAfterLock Event
-// ============================================================================
-
-export class EntryAfterLockEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/AfterLock";
-  getHandlerAbstraction() {
-    return EntryAfterLockEventHandler;
-  }
+const EntryBeforeLockEventHandler = createAbstraction("EntryBeforeLockEventHandler");
+class EntryAfterLockEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryAfterLockEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/AfterLock";
+    }
 }
-export const EntryAfterLockEventHandler = createAbstraction("EntryAfterLockEventHandler");
-
-// ============================================================================
-// EntryLockError Event
-// ============================================================================
-
-export class EntryLockErrorEvent extends DomainEvent {
-  eventType = "RecordLocking/Entry/LockError";
-  getHandlerAbstraction() {
-    return EntryLockErrorEventHandler;
-  }
+const EntryAfterLockEventHandler = createAbstraction("EntryAfterLockEventHandler");
+class EntryLockErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryLockErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/LockError";
+    }
 }
-export const EntryLockErrorEventHandler = createAbstraction("EntryLockErrorEventHandler");
+const EntryLockErrorEventHandler = createAbstraction("EntryLockErrorEventHandler");
+export { EntryAfterLockEvent, EntryAfterLockEventHandler, EntryBeforeLockEvent, EntryBeforeLockEventHandler, EntryLockErrorEvent, EntryLockErrorEventHandler };
 
 //# sourceMappingURL=events.js.map

package/features/LockEntry/events.js.map

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","DomainEvent","EntryBeforeLockEvent","eventType","getHandlerAbstraction","EntryBeforeLockEventHandler","EntryAfterLockEvent","EntryAfterLockEventHandler","EntryLockErrorEvent","EntryLockErrorEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\n\n// ============================================================================\n// EntryBeforeLock Event\n// ============================================================================\n\nexport interface EntryBeforeLockPayload {\n    id: string;\n    type: LockRecordEntryType;\n}\n\nexport class EntryBeforeLockEvent extends DomainEvent<EntryBeforeLockPayload> {\n    eventType = \"RecordLocking/Entry/BeforeLock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeLockEventHandler;\n    }\n}\n\nexport const EntryBeforeLockEventHandler = createAbstraction<IEventHandler<EntryBeforeLockEvent>>(\n    \"EntryBeforeLockEventHandler\"\n);\n\nexport namespace EntryBeforeLockEventHandler {\n    export type Interface = IEventHandler<EntryBeforeLockEvent>;\n    export type Event = EntryBeforeLockEvent;\n}\n\n// ============================================================================\n// EntryAfterLock Event\n// ============================================================================\n\nexport interface EntryAfterLockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    record: ILockRecord;\n}\n\nexport class EntryAfterLockEvent extends DomainEvent<EntryAfterLockPayload> {\n    eventType = \"RecordLocking/Entry/AfterLock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterLockEventHandler;\n    }\n}\n\nexport const EntryAfterLockEventHandler = createAbstraction<IEventHandler<EntryAfterLockEvent>>(\n    \"EntryAfterLockEventHandler\"\n);\n\nexport namespace EntryAfterLockEventHandler {\n    export type Interface = IEventHandler<EntryAfterLockEvent>;\n    export type Event = EntryAfterLockEvent;\n}\n\n// ============================================================================\n// EntryLockError Event\n// ============================================================================\n\nexport interface EntryLockErrorPayload {\n    id: string;\n    type: LockRecordEntryType;\n    error: Error;\n}\n\nexport class EntryLockErrorEvent extends DomainEvent<EntryLockErrorPayload> {\n    eventType = \"RecordLocking/Entry/LockError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryLockErrorEventHandler;\n    }\n}\n\nexport const EntryLockErrorEventHandler = createAbstraction<IEventHandler<EntryLockErrorEvent>>(\n    \"EntryLockErrorEventHandler\"\n);\n\nexport namespace EntryLockErrorEventHandler {\n    export type Interface = IEventHandler<EntryLockErrorEvent>;\n    export type Event = EntryLockErrorEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,WAAW,QAAQ,mDAAmD;;AAK/E;AACA;AACA;;AAOA,OAAO,MAAMC,oBAAoB,SAASD,WAAW,CAAyB;EAC1EE,SAAS,GAAG,gCAAgC;EAE5CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,2BAA2B;EACtC;AACJ;AAEA,OAAO,MAAMA,2BAA2B,GAAGL,iBAAiB,CACxD,6BACJ,CAAC;;AAOD;AACA;AACA;;AAQA,OAAO,MAAMM,mBAAmB,SAASL,WAAW,CAAwB;EACxEE,SAAS,GAAG,+BAA+B;EAE3CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,0BAA0B;EACrC;AACJ;AAEA,OAAO,MAAMA,0BAA0B,GAAGP,iBAAiB,CACvD,4BACJ,CAAC;;AAOD;AACA;AACA;;AAQA,OAAO,MAAMQ,mBAAmB,SAASP,WAAW,CAAwB;EACxEE,SAAS,GAAG,+BAA+B;EAE3CC,qBAAqBA,CAAA,EAAG;IACpB,OAAOK,0BAA0B;EACrC;AACJ;AAEA,OAAO,MAAMA,0BAA0B,GAAGT,iBAAiB,CACvD,4BACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"features/LockEntry/events.js","sources":["../../../src/features/LockEntry/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\n\n// ============================================================================\n// EntryBeforeLock Event\n// ============================================================================\n\nexport interface EntryBeforeLockPayload {\n    id: string;\n    type: LockRecordEntryType;\n}\n\nexport class EntryBeforeLockEvent extends DomainEvent<EntryBeforeLockPayload> {\n    eventType = \"RecordLocking/Entry/BeforeLock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeLockEventHandler;\n    }\n}\n\nexport const EntryBeforeLockEventHandler = createAbstraction<IEventHandler<EntryBeforeLockEvent>>(\n    \"EntryBeforeLockEventHandler\"\n);\n\nexport namespace EntryBeforeLockEventHandler {\n    export type Interface = IEventHandler<EntryBeforeLockEvent>;\n    export type Event = EntryBeforeLockEvent;\n}\n\n// ============================================================================\n// EntryAfterLock Event\n// ============================================================================\n\nexport interface EntryAfterLockPayload {\n    id: string;\n    type: LockRecordEntryType;\n    record: ILockRecord;\n}\n\nexport class EntryAfterLockEvent extends DomainEvent<EntryAfterLockPayload> {\n    eventType = \"RecordLocking/Entry/AfterLock\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterLockEventHandler;\n    }\n}\n\nexport const EntryAfterLockEventHandler = createAbstraction<IEventHandler<EntryAfterLockEvent>>(\n    \"EntryAfterLockEventHandler\"\n);\n\nexport namespace EntryAfterLockEventHandler {\n    export type Interface = IEventHandler<EntryAfterLockEvent>;\n    export type Event = EntryAfterLockEvent;\n}\n\n// ============================================================================\n// EntryLockError Event\n// ============================================================================\n\nexport interface EntryLockErrorPayload {\n    id: string;\n    type: LockRecordEntryType;\n    error: Error;\n}\n\nexport class EntryLockErrorEvent extends DomainEvent<EntryLockErrorPayload> {\n    eventType = \"RecordLocking/Entry/LockError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryLockErrorEventHandler;\n    }\n}\n\nexport const EntryLockErrorEventHandler = createAbstraction<IEventHandler<EntryLockErrorEvent>>(\n    \"EntryLockErrorEventHandler\"\n);\n\nexport namespace EntryLockErrorEventHandler {\n    export type Interface = IEventHandler<EntryLockErrorEvent>;\n    export type Event = EntryLockErrorEvent;\n}\n"],"names":["EntryBeforeLockEvent","DomainEvent","EntryBeforeLockEventHandler","createAbstraction","EntryAfterLockEvent","EntryAfterLockEventHandler","EntryLockErrorEvent","EntryLockErrorEventHandler"],"mappings":";;AAeO,MAAMA,6BAA6BC;IAGtC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,8BAA8BC,kBACvC;AAkBG,MAAMC,4BAA4BH;IAGrC,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,6BAA6BF,kBACtC;AAkBG,MAAMG,4BAA4BL;IAGrC,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,6BAA6BJ,kBACtC"}

package/features/LockEntry/feature.js

@@ -2,13 +2,14 @@ import { createFeature } from "@webiny/feature/api";
 import { LockEntryUseCase } from "./LockEntryUseCase.js";
 import { LockEntryRepository } from "./LockEntryRepository.js";
 import { LockEntryEventsDecorator } from "./LockEntryEventsDecorator.js";
-export const LockEntryFeature = createFeature({
-  name: "LockEntry",
-  register(container) {
-    container.register(LockEntryUseCase);
-    container.register(LockEntryRepository).inSingletonScope();
-    container.registerDecorator(LockEntryEventsDecorator);
-  }
+const LockEntryFeature = createFeature({
+    name: "LockEntry",
+    register (container) {
+        container.register(LockEntryUseCase);
+        container.register(LockEntryRepository).inSingletonScope();
+        container.registerDecorator(LockEntryEventsDecorator);
+    }
 });
+export { LockEntryFeature };
 
 //# sourceMappingURL=feature.js.map

package/features/LockEntry/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","LockEntryUseCase","LockEntryRepository","LockEntryEventsDecorator","LockEntryFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { LockEntryUseCase } from \"./LockEntryUseCase.js\";\nimport { LockEntryRepository } from \"./LockEntryRepository.js\";\nimport { LockEntryEventsDecorator } from \"./LockEntryEventsDecorator.js\";\n\nexport const LockEntryFeature = createFeature({\n    name: \"LockEntry\",\n    register(container) {\n        container.register(LockEntryUseCase);\n        container.register(LockEntryRepository).inSingletonScope();\n        container.registerDecorator(LockEntryEventsDecorator);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,gBAAgB;AACzB,SAASC,mBAAmB;AAC5B,SAASC,wBAAwB;AAEjC,OAAO,MAAMC,gBAAgB,GAAGJ,aAAa,CAAC;EAC1CK,IAAI,EAAE,WAAW;EACjBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACL,gBAAgB,CAAC;IACpCM,SAAS,CAACD,QAAQ,CAACJ,mBAAmB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAC1DD,SAAS,CAACE,iBAAiB,CAACN,wBAAwB,CAAC;EACzD;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/LockEntry/feature.js","sources":["../../../src/features/LockEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { LockEntryUseCase } from \"./LockEntryUseCase.js\";\nimport { LockEntryRepository } from \"./LockEntryRepository.js\";\nimport { LockEntryEventsDecorator } from \"./LockEntryEventsDecorator.js\";\n\nexport const LockEntryFeature = createFeature({\n    name: \"LockEntry\",\n    register(container) {\n        container.register(LockEntryUseCase);\n        container.register(LockEntryRepository).inSingletonScope();\n        container.registerDecorator(LockEntryEventsDecorator);\n    }\n});\n"],"names":["LockEntryFeature","createFeature","container","LockEntryUseCase","LockEntryRepository","LockEntryEventsDecorator"],"mappings":";;;;AAKO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,qBAAqB,gBAAgB;QACxDF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

package/features/LockEntry/index.js

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

package/features/RecordLockingFeature.js

@@ -10,27 +10,25 @@ import { LockEntryFeature } from "./LockEntry/feature.js";
 import { UpdateEntryLockFeature } from "./UpdateEntryLock/feature.js";
 import { UnlockEntryFeature } from "./UnlockEntry/feature.js";
 import { UnlockEntryRequestFeature } from "./UnlockEntryRequest/feature.js";
-export const RecordLockingFeature = createFeature({
-  name: "RecordLockingManagement",
-  register(container, params) {
-    // Register domain abstractions
-    container.registerInstance(RecordLockingConfig, {
-      timeout: params.timeout
-    });
-    container.registerInstance(RecordLockingModel, params.model);
-
-    // Register all sub-features
-    GetLockRecordFeature.register(container);
-    GetLockedEntryLockRecordFeature.register(container);
-    KickOutCurrentUserFeature.register(container);
-    ListLockRecordsFeature.register(container);
-    ListAllLockRecordsFeature.register(container);
-    IsEntryLockedFeature.register(container);
-    LockEntryFeature.register(container);
-    UpdateEntryLockFeature.register(container);
-    UnlockEntryFeature.register(container);
-    UnlockEntryRequestFeature.register(container);
-  }
+const RecordLockingFeature = createFeature({
+    name: "RecordLockingManagement",
+    register (container, params) {
+        container.registerInstance(RecordLockingConfig, {
+            timeout: params.timeout
+        });
+        container.registerInstance(RecordLockingModel, params.model);
+        GetLockRecordFeature.register(container);
+        GetLockedEntryLockRecordFeature.register(container);
+        KickOutCurrentUserFeature.register(container);
+        ListLockRecordsFeature.register(container);
+        ListAllLockRecordsFeature.register(container);
+        IsEntryLockedFeature.register(container);
+        LockEntryFeature.register(container);
+        UpdateEntryLockFeature.register(container);
+        UnlockEntryFeature.register(container);
+        UnlockEntryRequestFeature.register(container);
+    }
 });
+export { RecordLockingFeature };
 
 //# sourceMappingURL=RecordLockingFeature.js.map

package/features/RecordLockingFeature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","RecordLockingConfig","RecordLockingModel","GetLockRecordFeature","GetLockedEntryLockRecordFeature","KickOutCurrentUserFeature","ListLockRecordsFeature","ListAllLockRecordsFeature","IsEntryLockedFeature","LockEntryFeature","UpdateEntryLockFeature","UnlockEntryFeature","UnlockEntryRequestFeature","RecordLockingFeature","name","register","container","params","registerInstance","timeout","model"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,mBAAmB,EAAEC,kBAAkB;AAChD,SAASC,oBAAoB;AAC7B,SAASC,+BAA+B;AACxC,SAASC,yBAAyB;AAClC,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;AAClC,SAASC,oBAAoB;AAC7B,SAASC,gBAAgB;AACzB,SAASC,sBAAsB;AAC/B,SAASC,kBAAkB;AAC3B,SAASC,yBAAyB;AAalC,OAAO,MAAMC,oBAAoB,GAAGb,aAAa,CAAsB;EACnEc,IAAI,EAAE,yBAAyB;EAC/BC,QAAQA,CAACC,SAAS,EAAEC,MAAM,EAAE;IACxB;IACAD,SAAS,CAACE,gBAAgB,CAACjB,mBAAmB,EAAE;MAAEkB,OAAO,EAAEF,MAAM,CAACE;IAAQ,CAAC,CAAC;IAC5EH,SAAS,CAACE,gBAAgB,CAAChB,kBAAkB,EAAEe,MAAM,CAACG,KAAK,CAAC;;IAE5D;IACAjB,oBAAoB,CAACY,QAAQ,CAACC,SAAS,CAAC;IACxCZ,+BAA+B,CAACW,QAAQ,CAACC,SAAS,CAAC;IACnDX,yBAAyB,CAACU,QAAQ,CAACC,SAAS,CAAC;IAC7CV,sBAAsB,CAACS,QAAQ,CAACC,SAAS,CAAC;IAC1CT,yBAAyB,CAACQ,QAAQ,CAACC,SAAS,CAAC;IAC7CR,oBAAoB,CAACO,QAAQ,CAACC,SAAS,CAAC;IACxCP,gBAAgB,CAACM,QAAQ,CAACC,SAAS,CAAC;IACpCN,sBAAsB,CAACK,QAAQ,CAACC,SAAS,CAAC;IAC1CL,kBAAkB,CAACI,QAAQ,CAACC,SAAS,CAAC;IACtCJ,yBAAyB,CAACG,QAAQ,CAACC,SAAS,CAAC;EACjD;AACJ,CAAC,CAAC","ignoreList":[]}
+{"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"}

package/features/UnlockEntry/UnlockEntryEventsDecorator.js

@@ -2,40 +2,40 @@ import { UnlockEntryUseCase } from "./abstractions.js";
 import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
 import { EntryAfterUnlockEvent, EntryBeforeUnlockEvent, EntryUnlockErrorEvent } from "./events.js";
 class UnlockEntryEventsDecoratorImpl {
-  constructor(eventPublisher, decoratee) {
-    this.eventPublisher = eventPublisher;
-    this.decoratee = decoratee;
-  }
-  async execute(input) {
-    // Publish before event
-    await this.eventPublisher.publish(new EntryBeforeUnlockEvent({
-      id: input.id,
-      type: input.type,
-      force: input.force
-    }));
-    const result = await this.decoratee.execute(input);
-    if (result.isFail()) {
-      const error = result.error;
-      await this.eventPublisher.publish(new EntryUnlockErrorEvent({
-        id: input.id,
-        type: input.type,
-        error
-      }));
-      return result;
+    constructor(eventPublisher, decoratee){
+        this.eventPublisher = eventPublisher;
+        this.decoratee = decoratee;
+    }
+    async execute(input) {
+        await this.eventPublisher.publish(new EntryBeforeUnlockEvent({
+            id: input.id,
+            type: input.type,
+            force: input.force
+        }));
+        const result = await this.decoratee.execute(input);
+        if (result.isFail()) {
+            const error = result.error;
+            await this.eventPublisher.publish(new EntryUnlockErrorEvent({
+                id: input.id,
+                type: input.type,
+                error
+            }));
+            return result;
+        }
+        await this.eventPublisher.publish(new EntryAfterUnlockEvent({
+            id: input.id,
+            type: input.type,
+            record: result.value
+        }));
+        return result;
     }
-
-    // Publish after event
-    await this.eventPublisher.publish(new EntryAfterUnlockEvent({
-      id: input.id,
-      type: input.type,
-      record: result.value
-    }));
-    return result;
-  }
 }
-export const UnlockEntryEventsDecorator = UnlockEntryUseCase.createDecorator({
-  decorator: UnlockEntryEventsDecoratorImpl,
-  dependencies: [EventPublisher]
+const UnlockEntryEventsDecorator = UnlockEntryUseCase.createDecorator({
+    decorator: UnlockEntryEventsDecoratorImpl,
+    dependencies: [
+        EventPublisher
+    ]
 });
+export { UnlockEntryEventsDecorator };
 
 //# sourceMappingURL=UnlockEntryEventsDecorator.js.map

package/features/UnlockEntry/UnlockEntryEventsDecorator.js.map

@@ -1 +1 @@
-{"version":3,"names":["UnlockEntryUseCase","EventPublisher","EntryAfterUnlockEvent","EntryBeforeUnlockEvent","EntryUnlockErrorEvent","UnlockEntryEventsDecoratorImpl","constructor","eventPublisher","decoratee","execute","input","publish","id","type","force","result","isFail","error","record","value","UnlockEntryEventsDecorator","createDecorator","decorator","dependencies"],"sources":["UnlockEntryEventsDecorator.ts"],"sourcesContent":["import {\n    type UnlockEntryInput,\n    UnlockEntryUseCase as UseCaseAbstraction,\n    UnlockEntryUseCase\n} from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/index.js\";\nimport { Result } from \"@webiny/feature/api/index.js\";\nimport { EntryAfterUnlockEvent, EntryBeforeUnlockEvent, EntryUnlockErrorEvent } from \"./events.js\";\n\nclass UnlockEntryEventsDecoratorImpl implements UnlockEntryUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: UnlockEntryUseCase.Interface\n    ) {}\n\n    async execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeUnlockEvent({\n                id: input.id,\n                type: input.type,\n                force: input.force\n            })\n        );\n\n        const result = await this.decoratee.execute(input);\n\n        if (result.isFail()) {\n            const error = result.error;\n\n            await this.eventPublisher.publish(\n                new EntryUnlockErrorEvent({\n                    id: input.id,\n                    type: input.type,\n                    error\n                })\n            );\n\n            return result;\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new EntryAfterUnlockEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const UnlockEntryEventsDecorator = UnlockEntryUseCase.createDecorator({\n    decorator: UnlockEntryEventsDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"mappings":"AAAA,SAGIA,kBAAkB;AAEtB,SAASC,cAAc,QAAQ,mDAAmD;AAGlF,SAASC,qBAAqB,EAAEC,sBAAsB,EAAEC,qBAAqB;AAE7E,MAAMC,8BAA8B,CAAyC;EACzEC,WAAWA,CACUC,cAAwC,EACxCC,SAAuC,EAC1D;IAAA,KAFmBD,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,SAAuC,GAAvCA,SAAuC;EACzD;EAEH,MAAMC,OAAOA,CAACC,KAAuB,EAA0D;IAC3F;IACA,MAAM,IAAI,CAACH,cAAc,CAACI,OAAO,CAC7B,IAAIR,sBAAsB,CAAC;MACvBS,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;MAChBC,KAAK,EAAEJ,KAAK,CAACI;IACjB,CAAC,CACL,CAAC;IAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACP,SAAS,CAACC,OAAO,CAACC,KAAK,CAAC;IAElD,IAAIK,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMC,KAAK,GAAGF,MAAM,CAACE,KAAK;MAE1B,MAAM,IAAI,CAACV,cAAc,CAACI,OAAO,CAC7B,IAAIP,qBAAqB,CAAC;QACtBQ,EAAE,EAAEF,KAAK,CAACE,EAAE;QACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;QAChBI;MACJ,CAAC,CACL,CAAC;MAED,OAAOF,MAAM;IACjB;;IAEA;IACA,MAAM,IAAI,CAACR,cAAc,CAACI,OAAO,CAC7B,IAAIT,qBAAqB,CAAC;MACtBU,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;MAChBK,MAAM,EAAEH,MAAM,CAACI;IACnB,CAAC,CACL,CAAC;IAED,OAAOJ,MAAM;EACjB;AACJ;AAEA,OAAO,MAAMK,0BAA0B,GAAGpB,kBAAkB,CAACqB,eAAe,CAAC;EACzEC,SAAS,EAAEjB,8BAA8B;EACzCkB,YAAY,EAAE,CAACtB,cAAc;AACjC,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/UnlockEntry/UnlockEntryEventsDecorator.js","sources":["../../../src/features/UnlockEntry/UnlockEntryEventsDecorator.ts"],"sourcesContent":["import {\n    type UnlockEntryInput,\n    UnlockEntryUseCase as UseCaseAbstraction,\n    UnlockEntryUseCase\n} from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/index.js\";\nimport { Result } from \"@webiny/feature/api/index.js\";\nimport { EntryAfterUnlockEvent, EntryBeforeUnlockEvent, EntryUnlockErrorEvent } from \"./events.js\";\n\nclass UnlockEntryEventsDecoratorImpl implements UnlockEntryUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: UnlockEntryUseCase.Interface\n    ) {}\n\n    async execute(input: UnlockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeUnlockEvent({\n                id: input.id,\n                type: input.type,\n                force: input.force\n            })\n        );\n\n        const result = await this.decoratee.execute(input);\n\n        if (result.isFail()) {\n            const error = result.error;\n\n            await this.eventPublisher.publish(\n                new EntryUnlockErrorEvent({\n                    id: input.id,\n                    type: input.type,\n                    error\n                })\n            );\n\n            return result;\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new EntryAfterUnlockEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const UnlockEntryEventsDecorator = UnlockEntryUseCase.createDecorator({\n    decorator: UnlockEntryEventsDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"names":["UnlockEntryEventsDecoratorImpl","eventPublisher","decoratee","input","EntryBeforeUnlockEvent","result","error","EntryUnlockErrorEvent","EntryAfterUnlockEvent","UnlockEntryEventsDecorator","UnlockEntryUseCase","EventPublisher"],"mappings":";;;AAUA,MAAMA;IACF,YACqBC,cAAwC,EACxCC,SAAuC,CAC1D;aAFmBD,cAAc,GAAdA;aACAC,SAAS,GAATA;IAClB;IAEH,MAAM,QAAQC,KAAuB,EAA0D;QAE3F,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,uBAAuB;YACvB,IAAID,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;YAChB,OAAOA,MAAM,KAAK;QACtB;QAGJ,MAAME,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACF;QAE5C,IAAIE,OAAO,MAAM,IAAI;YACjB,MAAMC,QAAQD,OAAO,KAAK;YAE1B,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,sBAAsB;gBACtB,IAAIJ,MAAM,EAAE;gBACZ,MAAMA,MAAM,IAAI;gBAChBG;YACJ;YAGJ,OAAOD;QACX;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,sBAAsB;YACtB,IAAIL,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;YAChB,QAAQE,OAAO,KAAK;QACxB;QAGJ,OAAOA;IACX;AACJ;AAEO,MAAMI,6BAA6BC,mBAAmB,eAAe,CAAC;IACzE,WAAWV;IACX,cAAc;QAACW;KAAe;AAClC"}

package/features/UnlockEntry/UnlockEntryRepository.js

@@ -1,40 +1,42 @@
 import { Result } from "@webiny/feature/api";
 import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
 import { createIdentifier } from "@webiny/utils";
-import { UnlockEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { UnlockEntryRepository } from "./abstractions.js";
 import { RecordLockingModel } from "../../domain/abstractions.js";
 import { LockRecordNotFoundError, UnlockEntryError } from "../../domain/errors.js";
 import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
 class UnlockEntryRepositoryImpl {
-  constructor(model, deleteEntry) {
-    this.model = model;
-    this.deleteEntry = deleteEntry;
-  }
-  async delete(lockRecordId) {
-    try {
-      const entryId = createLockRecordDatabaseId(lockRecordId);
-      const id = createIdentifier({
-        id: entryId,
-        version: 1
-      });
-      const result = await this.deleteEntry.execute(this.model, id, {
-        permanently: true
-      });
-      if (result.isFail()) {
-        if (result.error.code === "Cms/Entry/NotFound") {
-          return Result.fail(new LockRecordNotFoundError());
+    constructor(model, deleteEntry){
+        this.model = model;
+        this.deleteEntry = deleteEntry;
+    }
+    async delete(lockRecordId) {
+        try {
+            const entryId = createLockRecordDatabaseId(lockRecordId);
+            const id = createIdentifier({
+                id: entryId,
+                version: 1
+            });
+            const result = await this.deleteEntry.execute(this.model, id, {
+                permanently: true
+            });
+            if (result.isFail()) {
+                if ("Cms/Entry/NotFound" === result.error.code) return Result.fail(new LockRecordNotFoundError());
+                return Result.fail(new UnlockEntryError(result.error));
+            }
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(new UnlockEntryError(error));
         }
-        return Result.fail(new UnlockEntryError(result.error));
-      }
-      return Result.ok();
-    } catch (error) {
-      return Result.fail(new UnlockEntryError(error));
     }
-  }
 }
-export const UnlockEntryRepository = RepositoryAbstraction.createImplementation({
-  implementation: UnlockEntryRepositoryImpl,
-  dependencies: [RecordLockingModel, DeleteEntryUseCase]
+const UnlockEntryRepository_UnlockEntryRepository = UnlockEntryRepository.createImplementation({
+    implementation: UnlockEntryRepositoryImpl,
+    dependencies: [
+        RecordLockingModel,
+        DeleteEntryUseCase
+    ]
 });
+export { UnlockEntryRepository_UnlockEntryRepository as UnlockEntryRepository };
 
 //# sourceMappingURL=UnlockEntryRepository.js.map