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

package/features/UnlockEntryRequest/UnlockEntryRequestEventsDecorator.js

@@ -0,0 +1,40 @@
+import { UnlockEntryRequestUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { EntryAfterUnlockRequestEvent, EntryBeforeUnlockRequestEvent, EntryUnlockRequestErrorEvent } from "./events.js";
+class UnlockEntryRequestEventsDecoratorImpl {
+    constructor(eventPublisher, decoratee){
+        this.eventPublisher = eventPublisher;
+        this.decoratee = decoratee;
+    }
+    async execute(input) {
+        await this.eventPublisher.publish(new EntryBeforeUnlockRequestEvent({
+            id: input.id,
+            type: input.type
+        }));
+        const result = await this.decoratee.execute(input);
+        if (result.isFail()) {
+            const error = result.error;
+            await this.eventPublisher.publish(new EntryUnlockRequestErrorEvent({
+                id: input.id,
+                type: input.type,
+                error
+            }));
+            return result;
+        }
+        await this.eventPublisher.publish(new EntryAfterUnlockRequestEvent({
+            id: input.id,
+            type: input.type,
+            record: result.value
+        }));
+        return result;
+    }
+}
+const UnlockEntryRequestEventsDecorator = UnlockEntryRequestUseCase.createDecorator({
+    decorator: UnlockEntryRequestEventsDecoratorImpl,
+    dependencies: [
+        EventPublisher
+    ]
+});
+export { UnlockEntryRequestEventsDecorator };
+
+//# sourceMappingURL=UnlockEntryRequestEventsDecorator.js.map

package/features/UnlockEntryRequest/UnlockEntryRequestEventsDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntryRequest/UnlockEntryRequestEventsDecorator.js","sources":["../../../src/features/UnlockEntryRequest/UnlockEntryRequestEventsDecorator.ts"],"sourcesContent":["import {\n    type UnlockEntryRequestInput,\n    UnlockEntryRequestUseCase as UseCaseAbstraction,\n    UnlockEntryRequestUseCase\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 {\n    EntryAfterUnlockRequestEvent,\n    EntryBeforeUnlockRequestEvent,\n    EntryUnlockRequestErrorEvent\n} from \"./events.js\";\n\nclass UnlockEntryRequestEventsDecoratorImpl implements UnlockEntryRequestUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: UnlockEntryRequestUseCase.Interface\n    ) {}\n\n    async execute(\n        input: UnlockEntryRequestInput\n    ): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeUnlockRequestEvent({\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 EntryUnlockRequestErrorEvent({\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 EntryAfterUnlockRequestEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const UnlockEntryRequestEventsDecorator = UnlockEntryRequestUseCase.createDecorator({\n    decorator: UnlockEntryRequestEventsDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"names":["UnlockEntryRequestEventsDecoratorImpl","eventPublisher","decoratee","input","EntryBeforeUnlockRequestEvent","result","error","EntryUnlockRequestErrorEvent","EntryAfterUnlockRequestEvent","UnlockEntryRequestEventsDecorator","UnlockEntryRequestUseCase","EventPublisher"],"mappings":";;;AAcA,MAAMA;IACF,YACqBC,cAAwC,EACxCC,SAA8C,CACjE;aAFmBD,cAAc,GAAdA;aACAC,SAAS,GAATA;IAClB;IAEH,MAAM,QACFC,KAA8B,EACwB;QAEtD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,8BAA8B;YAC9B,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,6BAA6B;gBAC7B,IAAIJ,MAAM,EAAE;gBACZ,MAAMA,MAAM,IAAI;gBAChBG;YACJ;YAGJ,OAAOD;QACX;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,6BAA6B;YAC7B,IAAIL,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;YAChB,QAAQE,OAAO,KAAK;QACxB;QAGJ,OAAOA;IACX;AACJ;AAEO,MAAMI,oCAAoCC,0BAA0B,eAAe,CAAC;IACvF,WAAWV;IACX,cAAc;QAACW;KAAe;AAClC"}

package/features/UnlockEntryRequest/UnlockEntryRequestRepository.d.ts

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

package/features/UnlockEntryRequest/UnlockEntryRequestRepository.js

@@ -0,0 +1,44 @@
+import { Result } from "@webiny/feature/api";
+import { UnlockEntryRequestRepository } from "./abstractions.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { RecordLockingModel } from "../../domain/abstractions.js";
+import { UnlockEntryRequestError } from "../../domain/errors.js";
+import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
+import { createIdentifier } from "@webiny/utils";
+class UnlockEntryRequestRepositoryImpl {
+    constructor(updateEntry, identityContext, model){
+        this.updateEntry = updateEntry;
+        this.identityContext = identityContext;
+        this.model = model;
+    }
+    async update(record) {
+        try {
+            const entryId = createLockRecordDatabaseId(record.id);
+            const id = createIdentifier({
+                id: entryId,
+                version: 1
+            });
+            const recordValues = record.toObject();
+            const result = await this.identityContext.withoutAuthorization(async ()=>await this.updateEntry.execute(this.model, id, {
+                    ...recordValues,
+                    values: recordValues
+                }));
+            if (result.isFail()) return Result.fail(new UnlockEntryRequestError(result.error));
+            return Result.ok(record);
+        } catch (error) {
+            return Result.fail(new UnlockEntryRequestError(error));
+        }
+    }
+}
+const UnlockEntryRequestRepository_UnlockEntryRequestRepository = UnlockEntryRequestRepository.createImplementation({
+    implementation: UnlockEntryRequestRepositoryImpl,
+    dependencies: [
+        UpdateEntryUseCase,
+        IdentityContext,
+        RecordLockingModel
+    ]
+});
+export { UnlockEntryRequestRepository_UnlockEntryRequestRepository as UnlockEntryRequestRepository };
+
+//# sourceMappingURL=UnlockEntryRequestRepository.js.map

package/features/UnlockEntryRequest/UnlockEntryRequestRepository.js.map

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

package/features/UnlockEntryRequest/UnlockEntryRequestUseCase.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "@webiny/feature/api";
+import { UnlockEntryRequestUseCase as UseCaseAbstraction, UnlockEntryRequestRepository, UnlockEntryRequestInput } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class UnlockEntryRequestUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getLockRecord;
+    private repository;
+    private identityContext;
+    constructor(getLockRecord: GetLockRecordUseCase.Interface, repository: UnlockEntryRequestRepository.Interface, identityContext: IdentityContext.Interface);
+    execute(input: UnlockEntryRequestInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const UnlockEntryRequestUseCase: typeof UnlockEntryRequestUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUnlockEntryRequestUseCase>;
+};
+export {};

package/features/UnlockEntryRequest/UnlockEntryRequestUseCase.js

@@ -0,0 +1,75 @@
+import { Result } from "@webiny/feature/api";
+import { UnlockEntryRequestRepository, UnlockEntryRequestUseCase } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { EntryNotLockedError, LockRecordNotFoundError, LockRecordPersistenceError, UnlockRequestAlreadySentError } from "../../domain/errors.js";
+import { RecordLockingLockRecordActionType } from "../../domain/types.js";
+class UnlockEntryRequestUseCaseImpl {
+    constructor(getLockRecord, repository, identityContext){
+        this.getLockRecord = getLockRecord;
+        this.repository = repository;
+        this.identityContext = identityContext;
+    }
+    async execute(input) {
+        const recordResult = await this.getLockRecord.execute(input);
+        if (recordResult.isFail()) {
+            if (recordResult.error instanceof LockRecordNotFoundError) {
+                const error = new EntryNotLockedError({
+                    id: input.id,
+                    type: input.type
+                });
+                return Result.fail(error);
+            }
+            return Result.fail(new LockRecordPersistenceError(recordResult.error));
+        }
+        const record = recordResult.value;
+        if (record.isExpired()) {
+            const error = new EntryNotLockedError({
+                id: input.id,
+                type: input.type
+            });
+            return Result.fail(error);
+        }
+        const unlockRequested = record.getUnlockRequested();
+        if (unlockRequested) {
+            const currentIdentity = this.identityContext.getIdentity();
+            if (unlockRequested.createdBy.id !== currentIdentity.id) {
+                const error = new UnlockRequestAlreadySentError({
+                    id: input.id,
+                    type: input.type,
+                    identityId: unlockRequested.createdBy.id
+                });
+                return Result.fail(error);
+            }
+            const approved = record.getUnlockApproved();
+            const denied = record.getUnlockDenied();
+            if (approved || denied) return Result.ok(record);
+            const error = new UnlockRequestAlreadySentError({
+                id: input.id,
+                type: input.type,
+                identityId: unlockRequested.createdBy.id
+            });
+            return Result.fail(error);
+        }
+        const identity = this.identityContext.getIdentity();
+        record.addAction({
+            type: RecordLockingLockRecordActionType.requested,
+            createdOn: new Date(),
+            createdBy: identity
+        });
+        const updateResult = await this.repository.update(record);
+        if (updateResult.isFail()) return Result.fail(updateResult.error);
+        return Result.ok(record);
+    }
+}
+const UnlockEntryRequestUseCase_UnlockEntryRequestUseCase = UnlockEntryRequestUseCase.createImplementation({
+    implementation: UnlockEntryRequestUseCaseImpl,
+    dependencies: [
+        GetLockRecordUseCase,
+        UnlockEntryRequestRepository,
+        IdentityContext
+    ]
+});
+export { UnlockEntryRequestUseCase_UnlockEntryRequestUseCase as UnlockEntryRequestUseCase };
+
+//# sourceMappingURL=UnlockEntryRequestUseCase.js.map

package/features/UnlockEntryRequest/UnlockEntryRequestUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntryRequest/UnlockEntryRequestUseCase.js","sources":["../../../src/features/UnlockEntryRequest/UnlockEntryRequestUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    UnlockEntryRequestUseCase as UseCaseAbstraction,\n    UnlockEntryRequestRepository,\n    UnlockEntryRequestInput\n} from \"./abstractions.js\";\nimport { GetLockRecordUseCase } from \"../GetLockRecord/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport {\n    EntryNotLockedError,\n    UnlockRequestAlreadySentError,\n    LockRecordNotFoundError,\n    LockRecordPersistenceError\n} from \"~/domain/errors.js\";\nimport { RecordLockingLockRecordActionType } from \"~/domain/types.js\";\n\nclass UnlockEntryRequestUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getLockRecord: GetLockRecordUseCase.Interface,\n        private repository: UnlockEntryRequestRepository.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    async execute(\n        input: UnlockEntryRequestInput\n    ): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Get the lock record\n        const recordResult = await this.getLockRecord.execute(input);\n\n        // If not found, it means entry is not locked\n        if (recordResult.isFail()) {\n            if (recordResult.error instanceof LockRecordNotFoundError) {\n                const error = new EntryNotLockedError({ id: input.id, type: input.type });\n                return Result.fail(error);\n            }\n            // Other errors\n            return Result.fail(new LockRecordPersistenceError(recordResult.error));\n        }\n\n        const record = recordResult.value;\n\n        // If expired, entry is not locked\n        if (record.isExpired()) {\n            const error = new EntryNotLockedError({ id: input.id, type: input.type });\n            return Result.fail(error);\n        }\n\n        // Check if unlock request already exists\n        const unlockRequested = record.getUnlockRequested();\n        if (unlockRequested) {\n            const currentIdentity = this.identityContext.getIdentity();\n\n            // If a different user already requested unlock, deny\n            if (unlockRequested.createdBy.id !== currentIdentity.id) {\n                const error = new UnlockRequestAlreadySentError({\n                    id: input.id,\n                    type: input.type,\n                    identityId: unlockRequested.createdBy.id\n                });\n                return Result.fail(error);\n            }\n\n            // If same user but already approved or denied, return the record\n            const approved = record.getUnlockApproved();\n            const denied = record.getUnlockDenied();\n            if (approved || denied) {\n                return Result.ok(record);\n            }\n\n            // If same user and pending, treat as duplicate\n            const error = new UnlockRequestAlreadySentError({\n                id: input.id,\n                type: input.type,\n                identityId: unlockRequested.createdBy.id\n            });\n            return Result.fail(error);\n        }\n\n        // Add unlock request action\n        const identity = this.identityContext.getIdentity();\n        record.addAction({\n            type: RecordLockingLockRecordActionType.requested,\n            createdOn: new Date(),\n            createdBy: identity\n        });\n\n        // Update the record\n        const updateResult = await this.repository.update(record);\n\n        if (updateResult.isFail()) {\n            return Result.fail(updateResult.error);\n        }\n\n        return Result.ok(record);\n    }\n}\n\nexport const UnlockEntryRequestUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UnlockEntryRequestUseCaseImpl,\n    dependencies: [GetLockRecordUseCase, UnlockEntryRequestRepository, IdentityContext]\n});\n"],"names":["UnlockEntryRequestUseCaseImpl","getLockRecord","repository","identityContext","input","recordResult","LockRecordNotFoundError","error","EntryNotLockedError","Result","LockRecordPersistenceError","record","unlockRequested","currentIdentity","UnlockRequestAlreadySentError","approved","denied","identity","RecordLockingLockRecordActionType","Date","updateResult","UnlockEntryRequestUseCase","UseCaseAbstraction","GetLockRecordUseCase","UnlockEntryRequestRepository","IdentityContext"],"mappings":";;;;;;AAiBA,MAAMA;IACF,YACYC,aAA6C,EAC7CC,UAAkD,EAClDC,eAA0C,CACpD;aAHUF,aAAa,GAAbA;aACAC,UAAU,GAAVA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAM,QACFC,KAA8B,EACwB;QAEtD,MAAMC,eAAe,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAACD;QAGtD,IAAIC,aAAa,MAAM,IAAI;YACvB,IAAIA,aAAa,KAAK,YAAYC,yBAAyB;gBACvD,MAAMC,QAAQ,IAAIC,oBAAoB;oBAAE,IAAIJ,MAAM,EAAE;oBAAE,MAAMA,MAAM,IAAI;gBAAC;gBACvE,OAAOK,OAAO,IAAI,CAACF;YACvB;YAEA,OAAOE,OAAO,IAAI,CAAC,IAAIC,2BAA2BL,aAAa,KAAK;QACxE;QAEA,MAAMM,SAASN,aAAa,KAAK;QAGjC,IAAIM,OAAO,SAAS,IAAI;YACpB,MAAMJ,QAAQ,IAAIC,oBAAoB;gBAAE,IAAIJ,MAAM,EAAE;gBAAE,MAAMA,MAAM,IAAI;YAAC;YACvE,OAAOK,OAAO,IAAI,CAACF;QACvB;QAGA,MAAMK,kBAAkBD,OAAO,kBAAkB;QACjD,IAAIC,iBAAiB;YACjB,MAAMC,kBAAkB,IAAI,CAAC,eAAe,CAAC,WAAW;YAGxD,IAAID,gBAAgB,SAAS,CAAC,EAAE,KAAKC,gBAAgB,EAAE,EAAE;gBACrD,MAAMN,QAAQ,IAAIO,8BAA8B;oBAC5C,IAAIV,MAAM,EAAE;oBACZ,MAAMA,MAAM,IAAI;oBAChB,YAAYQ,gBAAgB,SAAS,CAAC,EAAE;gBAC5C;gBACA,OAAOH,OAAO,IAAI,CAACF;YACvB;YAGA,MAAMQ,WAAWJ,OAAO,iBAAiB;YACzC,MAAMK,SAASL,OAAO,eAAe;YACrC,IAAII,YAAYC,QACZ,OAAOP,OAAO,EAAE,CAACE;YAIrB,MAAMJ,QAAQ,IAAIO,8BAA8B;gBAC5C,IAAIV,MAAM,EAAE;gBACZ,MAAMA,MAAM,IAAI;gBAChB,YAAYQ,gBAAgB,SAAS,CAAC,EAAE;YAC5C;YACA,OAAOH,OAAO,IAAI,CAACF;QACvB;QAGA,MAAMU,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjDN,OAAO,SAAS,CAAC;YACb,MAAMO,kCAAkC,SAAS;YACjD,WAAW,IAAIC;YACf,WAAWF;QACf;QAGA,MAAMG,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACT;QAElD,IAAIS,aAAa,MAAM,IACnB,OAAOX,OAAO,IAAI,CAACW,aAAa,KAAK;QAGzC,OAAOX,OAAO,EAAE,CAACE;IACrB;AACJ;AAEO,MAAMU,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBtB;IAChB,cAAc;QAACuB;QAAsBC;QAA8BC;KAAgB;AACvF"}

package/features/UnlockEntryRequest/abstractions.d.ts

@@ -0,0 +1,42 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+import type { EntryNotLockedError, UnlockRequestAlreadySentError, UnlockEntryRequestError, LockRecordPersistenceError } from "../../domain/errors.js";
+export interface UnlockEntryRequestInput {
+    id: string;
+    type: LockRecordEntryType;
+}
+/**
+ * UnlockEntryRequest Use Case - Adds unlock request to lock record
+ */
+export interface IUnlockEntryRequestUseCase {
+    execute(input: UnlockEntryRequestInput): Promise<Result<ILockRecord, UseCaseError>>;
+}
+export interface IUnlockEntryRequestUseCaseErrors {
+    notLocked: EntryNotLockedError;
+    alreadySent: UnlockRequestAlreadySentError;
+    persistence: LockRecordPersistenceError;
+    requestError: UnlockEntryRequestError;
+}
+type UseCaseError = IUnlockEntryRequestUseCaseErrors[keyof IUnlockEntryRequestUseCaseErrors];
+export declare const UnlockEntryRequestUseCase: import("@webiny/di").Abstraction<IUnlockEntryRequestUseCase>;
+export declare namespace UnlockEntryRequestUseCase {
+    type Interface = IUnlockEntryRequestUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * UnlockEntryRequestRepository - Updates lock record with unlock request
+ */
+export interface IUnlockEntryRequestRepository {
+    update(record: ILockRecord): Promise<Result<ILockRecord, RepositoryError>>;
+}
+export interface IUnlockEntryRequestRepositoryErrors {
+    persistence: UnlockEntryRequestError;
+}
+type RepositoryError = IUnlockEntryRequestRepositoryErrors[keyof IUnlockEntryRequestRepositoryErrors];
+export declare const UnlockEntryRequestRepository: import("@webiny/di").Abstraction<IUnlockEntryRequestRepository>;
+export declare namespace UnlockEntryRequestRepository {
+    type Interface = IUnlockEntryRequestRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/UnlockEntryRequest/abstractions.js

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

package/features/UnlockEntryRequest/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntryRequest/abstractions.js","sources":["../../../src/features/UnlockEntryRequest/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    EntryNotLockedError,\n    UnlockRequestAlreadySentError,\n    UnlockEntryRequestError,\n    LockRecordPersistenceError\n} from \"~/domain/errors.js\";\n\n// Input type\nexport interface UnlockEntryRequestInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * UnlockEntryRequest Use Case - Adds unlock request to lock record\n */\nexport interface IUnlockEntryRequestUseCase {\n    execute(input: UnlockEntryRequestInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface IUnlockEntryRequestUseCaseErrors {\n    notLocked: EntryNotLockedError;\n    alreadySent: UnlockRequestAlreadySentError;\n    persistence: LockRecordPersistenceError;\n    requestError: UnlockEntryRequestError;\n}\n\ntype UseCaseError = IUnlockEntryRequestUseCaseErrors[keyof IUnlockEntryRequestUseCaseErrors];\n\nexport const UnlockEntryRequestUseCase = createAbstraction<IUnlockEntryRequestUseCase>(\n    \"UnlockEntryRequestUseCase\"\n);\n\nexport namespace UnlockEntryRequestUseCase {\n    export type Interface = IUnlockEntryRequestUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * UnlockEntryRequestRepository - Updates lock record with unlock request\n */\nexport interface IUnlockEntryRequestRepository {\n    update(record: ILockRecord): Promise<Result<ILockRecord, RepositoryError>>;\n}\n\nexport interface IUnlockEntryRequestRepositoryErrors {\n    persistence: UnlockEntryRequestError;\n}\n\ntype RepositoryError =\n    IUnlockEntryRequestRepositoryErrors[keyof IUnlockEntryRequestRepositoryErrors];\n\nexport const UnlockEntryRequestRepository = createAbstraction<IUnlockEntryRequestRepository>(\n    \"UnlockEntryRequestRepository\"\n);\n\nexport namespace UnlockEntryRequestRepository {\n    export type Interface = IUnlockEntryRequestRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["UnlockEntryRequestUseCase","createAbstraction","UnlockEntryRequestRepository"],"mappings":";AAiCO,MAAMA,4BAA4BC,kBACrC;AAsBG,MAAMC,+BAA+BD,kBACxC"}

package/features/UnlockEntryRequest/events.d.ts

@@ -0,0 +1,45 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+export interface EntryBeforeUnlockRequestPayload {
+    id: string;
+    type: LockRecordEntryType;
+}
+export declare class EntryBeforeUnlockRequestEvent extends DomainEvent<EntryBeforeUnlockRequestPayload> {
+    eventType: "RecordLocking/Entry/BeforeUnlockRequest";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnlockRequestEvent>>;
+}
+export declare const EntryBeforeUnlockRequestEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeUnlockRequestEvent>>;
+export declare namespace EntryBeforeUnlockRequestEventHandler {
+    type Interface = IEventHandler<EntryBeforeUnlockRequestEvent>;
+    type Event = EntryBeforeUnlockRequestEvent;
+}
+export interface EntryAfterUnlockRequestPayload {
+    id: string;
+    type: LockRecordEntryType;
+    record: ILockRecord;
+}
+export declare class EntryAfterUnlockRequestEvent extends DomainEvent<EntryAfterUnlockRequestPayload> {
+    eventType: "RecordLocking/Entry/AfterUnlockRequest";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnlockRequestEvent>>;
+}
+export declare const EntryAfterUnlockRequestEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterUnlockRequestEvent>>;
+export declare namespace EntryAfterUnlockRequestEventHandler {
+    type Interface = IEventHandler<EntryAfterUnlockRequestEvent>;
+    type Event = EntryAfterUnlockRequestEvent;
+}
+export interface EntryUnlockRequestErrorPayload {
+    id: string;
+    type: LockRecordEntryType;
+    error: Error;
+}
+export declare class EntryUnlockRequestErrorEvent extends DomainEvent<EntryUnlockRequestErrorPayload> {
+    eventType: "RecordLocking/Entry/UnlockRequestError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryUnlockRequestErrorEvent>>;
+}
+export declare const EntryUnlockRequestErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryUnlockRequestErrorEvent>>;
+export declare namespace EntryUnlockRequestErrorEventHandler {
+    type Interface = IEventHandler<EntryUnlockRequestErrorEvent>;
+    type Event = EntryUnlockRequestErrorEvent;
+}

package/features/UnlockEntryRequest/events.js

@@ -0,0 +1,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class EntryBeforeUnlockRequestEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryBeforeUnlockRequestEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/BeforeUnlockRequest";
+    }
+}
+const EntryBeforeUnlockRequestEventHandler = createAbstraction("EntryBeforeUnlockRequestEventHandler");
+class EntryAfterUnlockRequestEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryAfterUnlockRequestEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/AfterUnlockRequest";
+    }
+}
+const EntryAfterUnlockRequestEventHandler = createAbstraction("EntryAfterUnlockRequestEventHandler");
+class EntryUnlockRequestErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return EntryUnlockRequestErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "RecordLocking/Entry/UnlockRequestError";
+    }
+}
+const EntryUnlockRequestErrorEventHandler = createAbstraction("EntryUnlockRequestErrorEventHandler");
+export { EntryAfterUnlockRequestEvent, EntryAfterUnlockRequestEventHandler, EntryBeforeUnlockRequestEvent, EntryBeforeUnlockRequestEventHandler, EntryUnlockRequestErrorEvent, EntryUnlockRequestErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/UnlockEntryRequest/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntryRequest/events.js","sources":["../../../src/features/UnlockEntryRequest/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// EntryBeforeUnlockRequest Event\n// ============================================================================\n\nexport interface EntryBeforeUnlockRequestPayload {\n    id: string;\n    type: LockRecordEntryType;\n}\n\nexport class EntryBeforeUnlockRequestEvent extends DomainEvent<EntryBeforeUnlockRequestPayload> {\n    eventType = \"RecordLocking/Entry/BeforeUnlockRequest\" as const;\n\n    getHandlerAbstraction() {\n        return EntryBeforeUnlockRequestEventHandler;\n    }\n}\n\nexport const EntryBeforeUnlockRequestEventHandler = createAbstraction<\n    IEventHandler<EntryBeforeUnlockRequestEvent>\n>(\"EntryBeforeUnlockRequestEventHandler\");\n\nexport namespace EntryBeforeUnlockRequestEventHandler {\n    export type Interface = IEventHandler<EntryBeforeUnlockRequestEvent>;\n    export type Event = EntryBeforeUnlockRequestEvent;\n}\n\n// ============================================================================\n// EntryAfterUnlockRequest Event\n// ============================================================================\n\nexport interface EntryAfterUnlockRequestPayload {\n    id: string;\n    type: LockRecordEntryType;\n    record: ILockRecord;\n}\n\nexport class EntryAfterUnlockRequestEvent extends DomainEvent<EntryAfterUnlockRequestPayload> {\n    eventType = \"RecordLocking/Entry/AfterUnlockRequest\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterUnlockRequestEventHandler;\n    }\n}\n\nexport const EntryAfterUnlockRequestEventHandler = createAbstraction<\n    IEventHandler<EntryAfterUnlockRequestEvent>\n>(\"EntryAfterUnlockRequestEventHandler\");\n\nexport namespace EntryAfterUnlockRequestEventHandler {\n    export type Interface = IEventHandler<EntryAfterUnlockRequestEvent>;\n    export type Event = EntryAfterUnlockRequestEvent;\n}\n\n// ============================================================================\n// EntryUnlockRequestError Event\n// ============================================================================\n\nexport interface EntryUnlockRequestErrorPayload {\n    id: string;\n    type: LockRecordEntryType;\n    error: Error;\n}\n\nexport class EntryUnlockRequestErrorEvent extends DomainEvent<EntryUnlockRequestErrorPayload> {\n    eventType = \"RecordLocking/Entry/UnlockRequestError\" as const;\n\n    getHandlerAbstraction() {\n        return EntryUnlockRequestErrorEventHandler;\n    }\n}\n\nexport const EntryUnlockRequestErrorEventHandler = createAbstraction<\n    IEventHandler<EntryUnlockRequestErrorEvent>\n>(\"EntryUnlockRequestErrorEventHandler\");\n\nexport namespace EntryUnlockRequestErrorEventHandler {\n    export type Interface = IEventHandler<EntryUnlockRequestErrorEvent>;\n    export type Event = EntryUnlockRequestErrorEvent;\n}\n"],"names":["EntryBeforeUnlockRequestEvent","DomainEvent","EntryBeforeUnlockRequestEventHandler","createAbstraction","EntryAfterUnlockRequestEvent","EntryAfterUnlockRequestEventHandler","EntryUnlockRequestErrorEvent","EntryUnlockRequestErrorEventHandler"],"mappings":";;AAeO,MAAMA,sCAAsCC;IAG/C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,uCAAuCC,kBAElD;AAiBK,MAAMC,qCAAqCH;IAG9C,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,sCAAsCF,kBAEjD;AAiBK,MAAMG,qCAAqCL;IAG9C,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,sCAAsCJ,kBAEjD"}

package/features/UnlockEntryRequest/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const UnlockEntryRequestFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/UnlockEntryRequest/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { UnlockEntryRequestUseCase } from "./UnlockEntryRequestUseCase.js";
+import { UnlockEntryRequestRepository } from "./UnlockEntryRequestRepository.js";
+import { UnlockEntryRequestEventsDecorator } from "./UnlockEntryRequestEventsDecorator.js";
+const UnlockEntryRequestFeature = createFeature({
+    name: "UnlockEntryRequest",
+    register (container) {
+        container.register(UnlockEntryRequestUseCase);
+        container.register(UnlockEntryRequestRepository).inSingletonScope();
+        container.registerDecorator(UnlockEntryRequestEventsDecorator);
+    }
+});
+export { UnlockEntryRequestFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/UnlockEntryRequest/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UnlockEntryRequest/feature.js","sources":["../../../src/features/UnlockEntryRequest/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UnlockEntryRequestUseCase } from \"./UnlockEntryRequestUseCase.js\";\nimport { UnlockEntryRequestRepository } from \"./UnlockEntryRequestRepository.js\";\nimport { UnlockEntryRequestEventsDecorator } from \"./UnlockEntryRequestEventsDecorator.js\";\n\nexport const UnlockEntryRequestFeature = createFeature({\n    name: \"UnlockEntryRequest\",\n    register(container) {\n        container.register(UnlockEntryRequestUseCase);\n        container.register(UnlockEntryRequestRepository).inSingletonScope();\n        container.registerDecorator(UnlockEntryRequestEventsDecorator);\n    }\n});\n"],"names":["UnlockEntryRequestFeature","createFeature","container","UnlockEntryRequestUseCase","UnlockEntryRequestRepository","UnlockEntryRequestEventsDecorator"],"mappings":";;;;AAKO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,8BAA8B,gBAAgB;QACjEF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

package/features/UnlockEntryRequest/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./abstractions.js";
+export * from "./events.js";
+export * from "./feature.js";

package/features/UnlockEntryRequest/index.js

@@ -0,0 +1,3 @@
+export * from "./abstractions.js";
+export * from "./events.js";
+export * from "./feature.js";

package/features/UpdateEntryLock/UpdateEntryLockRepository.d.ts

@@ -0,0 +1,20 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { Result } from "@webiny/feature/api";
+import { UpdateEntryLockRepository as RepositoryAbstraction } from "./abstractions.js";
+import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class UpdateEntryLockRepositoryImpl implements RepositoryAbstraction.Interface {
+    private model;
+    private config;
+    private identityContext;
+    private updateEntry;
+    private getEntryById;
+    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, identityContext: IdentityContext.Interface, updateEntry: UpdateEntryUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface);
+    update(lockRecordId: string, updateOwner: boolean): Promise<Result<ILockRecord, RepositoryAbstraction.Error>>;
+}
+export declare const UpdateEntryLockRepository: typeof UpdateEntryLockRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateEntryLockRepository>;
+};
+export {};

package/features/UpdateEntryLock/UpdateEntryLockRepository.js

@@ -0,0 +1,60 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { Result } from "@webiny/feature/api";
+import { createIdentifier } from "@webiny/utils";
+import { UpdateEntryLockRepository } 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 UpdateEntryLockRepositoryImpl {
+    constructor(model, config, identityContext, updateEntry, getEntryById){
+        this.model = model;
+        this.config = config;
+        this.identityContext = identityContext;
+        this.updateEntry = updateEntry;
+        this.getEntryById = getEntryById;
+    }
+    async update(lockRecordId, updateOwner) {
+        try {
+            const entryId = createLockRecordDatabaseId(lockRecordId);
+            const id = createIdentifier({
+                id: entryId,
+                version: 1
+            });
+            const identity = this.identityContext.getIdentity();
+            const now = new Date().toISOString();
+            const updateData = {
+                savedOn: now
+            };
+            if (updateOwner) {
+                updateData.createdOn = now;
+                updateData.createdBy = identity;
+                updateData.savedBy = identity;
+            }
+            const result = await this.updateEntry.execute(this.model, id, updateData);
+            if (result.isFail()) return Result.fail(new LockRecordPersistenceError(result.error));
+            const getResult = await this.getEntryById.execute(this.model, id);
+            if (getResult.isFail()) return Result.fail(new LockRecordPersistenceError(getResult.error));
+            const entry = getResult.value;
+            const lockRecord = new LockRecord(entry, this.config.timeout);
+            return Result.ok(lockRecord);
+        } catch (error) {
+            return Result.fail(new LockRecordPersistenceError(error));
+        }
+    }
+}
+const UpdateEntryLockRepository_UpdateEntryLockRepository = UpdateEntryLockRepository.createImplementation({
+    implementation: UpdateEntryLockRepositoryImpl,
+    dependencies: [
+        RecordLockingModel,
+        RecordLockingConfig,
+        IdentityContext,
+        UpdateEntryUseCase,
+        GetEntryByIdUseCase
+    ]
+});
+export { UpdateEntryLockRepository_UpdateEntryLockRepository as UpdateEntryLockRepository };
+
+//# sourceMappingURL=UpdateEntryLockRepository.js.map

package/features/UpdateEntryLock/UpdateEntryLockRepository.js.map

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

package/features/UpdateEntryLock/UpdateEntryLockUseCase.d.ts

@@ -0,0 +1,18 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateEntryLockUseCase as UseCaseAbstraction, UpdateEntryLockRepository, UpdateEntryLockInput } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { LockEntryUseCase } from "../LockEntry/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class UpdateEntryLockUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getLockRecord;
+    private lockEntry;
+    private repository;
+    private identityContext;
+    constructor(getLockRecord: GetLockRecordUseCase.Interface, lockEntry: LockEntryUseCase.Interface, repository: UpdateEntryLockRepository.Interface, identityContext: IdentityContext.Interface);
+    execute(input: UpdateEntryLockInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateEntryLockUseCase: typeof UpdateEntryLockUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateEntryLockUseCase>;
+};
+export {};

package/features/UpdateEntryLock/UpdateEntryLockUseCase.js

@@ -0,0 +1,51 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateEntryLockRepository, UpdateEntryLockUseCase } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { LockEntryUseCase } from "../LockEntry/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { IdentityMismatchError, LockRecordNotFoundError, UpdateEntryLockError } from "../../domain/errors.js";
+class UpdateEntryLockUseCaseImpl {
+    constructor(getLockRecord, lockEntry, repository, identityContext){
+        this.getLockRecord = getLockRecord;
+        this.lockEntry = lockEntry;
+        this.repository = repository;
+        this.identityContext = identityContext;
+    }
+    async execute(input) {
+        const recordResult = await this.getLockRecord.execute(input);
+        if (recordResult.isFail()) {
+            if (recordResult.error instanceof LockRecordNotFoundError) {
+                const lockResult = await this.lockEntry.execute(input);
+                if (lockResult.isFail()) return Result.fail(new UpdateEntryLockError(lockResult.error));
+                return Result.ok(lockResult.value);
+            }
+            return Result.fail(recordResult.error);
+        }
+        const record = recordResult.value;
+        if (record.isExpired()) {
+            const updateResult = await this.repository.update(record.id, true);
+            if (updateResult.isFail()) return Result.fail(new UpdateEntryLockError(updateResult.error));
+            return Result.ok(updateResult.value);
+        }
+        const identity = this.identityContext.getIdentity();
+        if (record.lockedBy.id !== identity.id) return Result.fail(new IdentityMismatchError({
+            currentId: identity.id,
+            targetId: record.lockedBy.id
+        }));
+        const updateResult = await this.repository.update(record.id, false);
+        if (updateResult.isFail()) return Result.fail(new UpdateEntryLockError(updateResult.error));
+        return Result.ok(updateResult.value);
+    }
+}
+const UpdateEntryLockUseCase_UpdateEntryLockUseCase = UpdateEntryLockUseCase.createImplementation({
+    implementation: UpdateEntryLockUseCaseImpl,
+    dependencies: [
+        GetLockRecordUseCase,
+        LockEntryUseCase,
+        UpdateEntryLockRepository,
+        IdentityContext
+    ]
+});
+export { UpdateEntryLockUseCase_UpdateEntryLockUseCase as UpdateEntryLockUseCase };
+
+//# sourceMappingURL=UpdateEntryLockUseCase.js.map

package/features/UpdateEntryLock/UpdateEntryLockUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/UpdateEntryLock/UpdateEntryLockUseCase.js","sources":["../../../src/features/UpdateEntryLock/UpdateEntryLockUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    UpdateEntryLockUseCase as UseCaseAbstraction,\n    UpdateEntryLockRepository,\n    UpdateEntryLockInput\n} from \"./abstractions.js\";\nimport { GetLockRecordUseCase } from \"../GetLockRecord/abstractions.js\";\nimport { LockEntryUseCase } from \"../LockEntry/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport {\n    LockRecordNotFoundError,\n    IdentityMismatchError,\n    UpdateEntryLockError\n} from \"~/domain/errors.js\";\n\nclass UpdateEntryLockUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getLockRecord: GetLockRecordUseCase.Interface,\n        private lockEntry: LockEntryUseCase.Interface,\n        private repository: UpdateEntryLockRepository.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    async execute(\n        input: UpdateEntryLockInput\n    ): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Try to get existing lock record\n        const recordResult = await this.getLockRecord.execute(input);\n\n        // If doesn't exist, create a new lock\n        if (recordResult.isFail()) {\n            if (recordResult.error instanceof LockRecordNotFoundError) {\n                const lockResult = await this.lockEntry.execute(input);\n                if (lockResult.isFail()) {\n                    return Result.fail(new UpdateEntryLockError(lockResult.error));\n                }\n                return Result.ok(lockResult.value);\n            }\n            return Result.fail(recordResult.error);\n        }\n\n        const record = recordResult.value;\n\n        // If expired, update with current user as new owner\n        if (record.isExpired()) {\n            const updateResult = await this.repository.update(record.id, true);\n            if (updateResult.isFail()) {\n                return Result.fail(new UpdateEntryLockError(updateResult.error));\n            }\n            return Result.ok(updateResult.value);\n        }\n\n        // If not expired, validate same owner\n        const identity = this.identityContext.getIdentity();\n        if (record.lockedBy.id !== identity.id) {\n            return Result.fail(\n                new IdentityMismatchError({\n                    currentId: identity.id,\n                    targetId: record.lockedBy.id\n                })\n            );\n        }\n\n        // Update timestamp only\n        const updateResult = await this.repository.update(record.id, false);\n        if (updateResult.isFail()) {\n            return Result.fail(new UpdateEntryLockError(updateResult.error));\n        }\n\n        return Result.ok(updateResult.value);\n    }\n}\n\nexport const UpdateEntryLockUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UpdateEntryLockUseCaseImpl,\n    dependencies: [\n        GetLockRecordUseCase,\n        LockEntryUseCase,\n        UpdateEntryLockRepository,\n        IdentityContext\n    ]\n});\n"],"names":["UpdateEntryLockUseCaseImpl","getLockRecord","lockEntry","repository","identityContext","input","recordResult","LockRecordNotFoundError","lockResult","Result","UpdateEntryLockError","record","updateResult","identity","IdentityMismatchError","UpdateEntryLockUseCase","UseCaseAbstraction","GetLockRecordUseCase","LockEntryUseCase","UpdateEntryLockRepository","IdentityContext"],"mappings":";;;;;;AAgBA,MAAMA;IACF,YACYC,aAA6C,EAC7CC,SAAqC,EACrCC,UAA+C,EAC/CC,eAA0C,CACpD;aAJUH,aAAa,GAAbA;aACAC,SAAS,GAATA;aACAC,UAAU,GAAVA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAM,QACFC,KAA2B,EAC2B;QAEtD,MAAMC,eAAe,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAACD;QAGtD,IAAIC,aAAa,MAAM,IAAI;YACvB,IAAIA,aAAa,KAAK,YAAYC,yBAAyB;gBACvD,MAAMC,aAAa,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACH;gBAChD,IAAIG,WAAW,MAAM,IACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC,qBAAqBF,WAAW,KAAK;gBAEhE,OAAOC,OAAO,EAAE,CAACD,WAAW,KAAK;YACrC;YACA,OAAOC,OAAO,IAAI,CAACH,aAAa,KAAK;QACzC;QAEA,MAAMK,SAASL,aAAa,KAAK;QAGjC,IAAIK,OAAO,SAAS,IAAI;YACpB,MAAMC,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACD,OAAO,EAAE,EAAE;YAC7D,IAAIC,aAAa,MAAM,IACnB,OAAOH,OAAO,IAAI,CAAC,IAAIC,qBAAqBE,aAAa,KAAK;YAElE,OAAOH,OAAO,EAAE,CAACG,aAAa,KAAK;QACvC;QAGA,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,IAAIF,OAAO,QAAQ,CAAC,EAAE,KAAKE,SAAS,EAAE,EAClC,OAAOJ,OAAO,IAAI,CACd,IAAIK,sBAAsB;YACtB,WAAWD,SAAS,EAAE;YACtB,UAAUF,OAAO,QAAQ,CAAC,EAAE;QAChC;QAKR,MAAMC,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACD,OAAO,EAAE,EAAE;QAC7D,IAAIC,aAAa,MAAM,IACnB,OAAOH,OAAO,IAAI,CAAC,IAAIC,qBAAqBE,aAAa,KAAK;QAGlE,OAAOH,OAAO,EAAE,CAACG,aAAa,KAAK;IACvC;AACJ;AAEO,MAAMG,gDAAyBC,uBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBhB;IAChB,cAAc;QACViB;QACAC;QACAC;QACAC;KACH;AACL"}