@webiny/api-record-locking 6.0.0-beta.0 → 6.0.0-rc.0

package/features/GetLockRecord/abstractions.d.ts

@@ -0,0 +1,41 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+import { LockRecordNotFoundError, type LockRecordPersistenceError } from "../../domain/errors.js";
+export interface GetLockRecordInput {
+    id: string;
+    type: LockRecordEntryType;
+}
+/**
+ * GetLockRecord Use Case - Retrieves a lock record for a given entry
+ */
+export interface IGetLockRecordUseCase {
+    execute(input: GetLockRecordInput): Promise<Result<ILockRecord, UseCaseError>>;
+}
+export interface IGetLockRecordUseCaseErrors {
+    notFound: LockRecordNotFoundError;
+    persistence: LockRecordPersistenceError;
+}
+type UseCaseError = IGetLockRecordUseCaseErrors[keyof IGetLockRecordUseCaseErrors];
+export declare const GetLockRecordUseCase: import("@webiny/di").Abstraction<IGetLockRecordUseCase>;
+export declare namespace GetLockRecordUseCase {
+    type Interface = IGetLockRecordUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * GetLockRecordRepository - Fetches lock record from storage
+ */
+export interface IGetLockRecordRepository {
+    get(id: string): Promise<Result<ILockRecord, RepositoryError>>;
+}
+export interface IGetLockRecordRepositoryErrors {
+    notFound: LockRecordNotFoundError;
+    persistence: LockRecordPersistenceError;
+}
+type RepositoryError = IGetLockRecordRepositoryErrors[keyof IGetLockRecordRepositoryErrors];
+export declare const GetLockRecordRepository: import("@webiny/di").Abstraction<IGetLockRecordRepository>;
+export declare namespace GetLockRecordRepository {
+    type Interface = IGetLockRecordRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/GetLockRecord/abstractions.js

@@ -0,0 +1,17 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// Input types
+
+/**
+ * GetLockRecord Use Case - Retrieves a lock record for a given entry
+ */
+
+export const GetLockRecordUseCase = createAbstraction("GetLockRecordUseCase");
+
+/**
+ * GetLockRecordRepository - Fetches lock record from storage
+ */
+
+export const GetLockRecordRepository = createAbstraction("GetLockRecordRepository");
+
+//# sourceMappingURL=abstractions.js.map

package/features/GetLockRecord/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetLockRecordUseCase","GetLockRecordRepository"],"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 { LockRecordNotFoundError, type LockRecordPersistenceError } from \"~/domain/errors.js\";\n\n// Input types\nexport interface GetLockRecordInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * GetLockRecord Use Case - Retrieves a lock record for a given entry\n */\nexport interface IGetLockRecordUseCase {\n    execute(input: GetLockRecordInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface IGetLockRecordUseCaseErrors {\n    notFound: LockRecordNotFoundError;\n    persistence: LockRecordPersistenceError;\n}\n\ntype UseCaseError = IGetLockRecordUseCaseErrors[keyof IGetLockRecordUseCaseErrors];\n\nexport const GetLockRecordUseCase =\n    createAbstraction<IGetLockRecordUseCase>(\"GetLockRecordUseCase\");\n\nexport namespace GetLockRecordUseCase {\n    export type Interface = IGetLockRecordUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * GetLockRecordRepository - Fetches lock record from storage\n */\nexport interface IGetLockRecordRepository {\n    get(id: string): Promise<Result<ILockRecord, RepositoryError>>;\n}\n\nexport interface IGetLockRecordRepositoryErrors {\n    notFound: LockRecordNotFoundError;\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError = IGetLockRecordRepositoryErrors[keyof IGetLockRecordRepositoryErrors];\n\nexport const GetLockRecordRepository =\n    createAbstraction<IGetLockRecordRepository>(\"GetLockRecordRepository\");\n\nexport namespace GetLockRecordRepository {\n    export type Interface = IGetLockRecordRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAMvD;;AAMA;AACA;AACA;;AAYA,OAAO,MAAMC,oBAAoB,GAC7BD,iBAAiB,CAAwB,sBAAsB,CAAC;;AAOpE;AACA;AACA;;AAYA,OAAO,MAAME,uBAAuB,GAChCF,iBAAiB,CAA2B,yBAAyB,CAAC","ignoreList":[]}

package/features/GetLockRecord/feature.d.ts

@@ -0,0 +1 @@
+export declare const GetLockRecordFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/GetLockRecord/feature.js

@@ -0,0 +1,12 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetLockRecordUseCase } from "./GetLockRecordUseCase.js";
+import { GetLockRecordRepository } from "./GetLockRecordRepository.js";
+export const GetLockRecordFeature = createFeature({
+  name: "GetLockRecord",
+  register(container) {
+    container.register(GetLockRecordUseCase);
+    container.register(GetLockRecordRepository).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/GetLockRecord/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetLockRecordUseCase","GetLockRecordRepository","GetLockRecordFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetLockRecordUseCase } from \"./GetLockRecordUseCase.js\";\nimport { GetLockRecordRepository } from \"./GetLockRecordRepository.js\";\n\nexport const GetLockRecordFeature = createFeature({\n    name: \"GetLockRecord\",\n    register(container) {\n        container.register(GetLockRecordUseCase);\n        container.register(GetLockRecordRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,oBAAoB;AAC7B,SAASC,uBAAuB;AAEhC,OAAO,MAAMC,oBAAoB,GAAGH,aAAa,CAAC;EAC9CI,IAAI,EAAE,eAAe;EACrBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,oBAAoB,CAAC;IACxCK,SAAS,CAACD,QAAQ,CAACH,uBAAuB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAClE;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/GetLockRecord/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./abstractions.js";
+export { GetLockRecordFeature } from "./feature.js";

package/features/GetLockRecord/index.js

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

package/features/GetLockRecord/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetLockRecordFeature"],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions.js\";\nexport { GetLockRecordFeature } from \"./feature.js\";\n"],"mappings":"AAAA;AACA,SAASA,oBAAoB","ignoreList":[]}

package/features/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { GetLockedEntryLockRecordUseCase as UseCaseAbstraction, GetLockedEntryLockRecordInput } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class GetLockedEntryLockRecordUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getLockRecord;
+    private identityContext;
+    constructor(getLockRecord: GetLockRecordUseCase.Interface, identityContext: IdentityContext.Interface);
+    execute(input: GetLockedEntryLockRecordInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const GetLockedEntryLockRecordUseCase: typeof GetLockedEntryLockRecordUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetLockedEntryLockRecordUseCase>;
+};
+export {};

package/features/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.js

@@ -0,0 +1,39 @@
+import { Result } from "@webiny/feature/api";
+import { GetLockedEntryLockRecordUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { LockRecordNotFoundError } from "../../domain/errors.js";
+class GetLockedEntryLockRecordUseCaseImpl {
+  constructor(getLockRecord, identityContext) {
+    this.getLockRecord = getLockRecord;
+    this.identityContext = identityContext;
+  }
+  async execute(input) {
+    // Get the lock record
+    const result = await this.getLockRecord.execute(input);
+
+    // If not found or error, return not found error
+    if (result.isFail()) {
+      return Result.fail(new LockRecordNotFoundError());
+    }
+    const record = result.value;
+    const identity = this.identityContext.getIdentity();
+
+    // Record is treated as "not found":
+    // - If locked by current user
+    // - If expired
+    const lockedByCurrentUser = record.lockedBy.id === identity.id;
+    if (record.isExpired() || lockedByCurrentUser) {
+      return Result.fail(new LockRecordNotFoundError());
+    }
+
+    // Locked by another user, return the record
+    return Result.ok(record);
+  }
+}
+export const GetLockedEntryLockRecordUseCase = UseCaseAbstraction.createImplementation({
+  implementation: GetLockedEntryLockRecordUseCaseImpl,
+  dependencies: [GetLockRecordUseCase, IdentityContext]
+});
+
+//# sourceMappingURL=GetLockedEntryLockRecordUseCase.js.map

package/features/GetLockedEntryLockRecord/GetLockedEntryLockRecordUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetLockedEntryLockRecordUseCase","UseCaseAbstraction","GetLockRecordUseCase","IdentityContext","LockRecordNotFoundError","GetLockedEntryLockRecordUseCaseImpl","constructor","getLockRecord","identityContext","execute","input","result","isFail","fail","record","value","identity","getIdentity","lockedByCurrentUser","lockedBy","id","isExpired","ok","createImplementation","implementation","dependencies"],"sources":["GetLockedEntryLockRecordUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetLockedEntryLockRecordUseCase as UseCaseAbstraction,\n    GetLockedEntryLockRecordInput\n} from \"./abstractions.js\";\nimport { GetLockRecordUseCase } from \"../GetLockRecord/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { LockRecordNotFoundError } from \"~/domain/errors.js\";\n\nclass GetLockedEntryLockRecordUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getLockRecord: GetLockRecordUseCase.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    async execute(\n        input: GetLockedEntryLockRecordInput\n    ): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Get the lock record\n        const result = await this.getLockRecord.execute(input);\n\n        // If not found or error, return not found error\n        if (result.isFail()) {\n            return Result.fail(new LockRecordNotFoundError());\n        }\n\n        const record = result.value;\n        const identity = this.identityContext.getIdentity();\n\n        // Record is treated as \"not found\":\n        // - If locked by current user\n        // - If expired\n        const lockedByCurrentUser = record.lockedBy.id === identity.id;\n\n        if (record.isExpired() || lockedByCurrentUser) {\n            return Result.fail(new LockRecordNotFoundError());\n        }\n\n        // Locked by another user, return the record\n        return Result.ok(record);\n    }\n}\n\nexport const GetLockedEntryLockRecordUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetLockedEntryLockRecordUseCaseImpl,\n    dependencies: [GetLockRecordUseCase, IdentityContext]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,+BAA+B,IAAIC,kBAAkB;AAGzD,SAASC,oBAAoB;AAC7B,SAASC,eAAe,QAAQ,2CAA2C;AAE3E,SAASC,uBAAuB;AAEhC,MAAMC,mCAAmC,CAAyC;EAC9EC,WAAWA,CACCC,aAA6C,EAC7CC,eAA0C,EACpD;IAAA,KAFUD,aAA6C,GAA7CA,aAA6C;IAAA,KAC7CC,eAA0C,GAA1CA,eAA0C;EACnD;EAEH,MAAMC,OAAOA,CACTC,KAAoC,EACkB;IACtD;IACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,aAAa,CAACE,OAAO,CAACC,KAAK,CAAC;;IAEtD;IACA,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOb,MAAM,CAACc,IAAI,CAAC,IAAIT,uBAAuB,CAAC,CAAC,CAAC;IACrD;IAEA,MAAMU,MAAM,GAAGH,MAAM,CAACI,KAAK;IAC3B,MAAMC,QAAQ,GAAG,IAAI,CAACR,eAAe,CAACS,WAAW,CAAC,CAAC;;IAEnD;IACA;IACA;IACA,MAAMC,mBAAmB,GAAGJ,MAAM,CAACK,QAAQ,CAACC,EAAE,KAAKJ,QAAQ,CAACI,EAAE;IAE9D,IAAIN,MAAM,CAACO,SAAS,CAAC,CAAC,IAAIH,mBAAmB,EAAE;MAC3C,OAAOnB,MAAM,CAACc,IAAI,CAAC,IAAIT,uBAAuB,CAAC,CAAC,CAAC;IACrD;;IAEA;IACA,OAAOL,MAAM,CAACuB,EAAE,CAACR,MAAM,CAAC;EAC5B;AACJ;AAEA,OAAO,MAAMd,+BAA+B,GAAGC,kBAAkB,CAACsB,oBAAoB,CAAC;EACnFC,cAAc,EAAEnB,mCAAmC;EACnDoB,YAAY,EAAE,CAACvB,oBAAoB,EAAEC,eAAe;AACxD,CAAC,CAAC","ignoreList":[]}

package/features/GetLockedEntryLockRecord/abstractions.d.ts

@@ -0,0 +1,26 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+import type { LockRecordNotFoundError } from "../../domain/errors.js";
+export interface GetLockedEntryLockRecordInput {
+    id: string;
+    type: LockRecordEntryType;
+}
+/**
+ * GetLockedEntryLockRecord Use Case
+ * Returns lock record ONLY if entry is locked by someone OTHER than current user
+ * Returns error if: not found, expired, or locked by current user
+ */
+export interface IGetLockedEntryLockRecordUseCase {
+    execute(input: GetLockedEntryLockRecordInput): Promise<Result<ILockRecord, UseCaseError>>;
+}
+export interface IGetLockedEntryLockRecordUseCaseErrors {
+    notFound: LockRecordNotFoundError;
+}
+type UseCaseError = IGetLockedEntryLockRecordUseCaseErrors[keyof IGetLockedEntryLockRecordUseCaseErrors];
+export declare const GetLockedEntryLockRecordUseCase: import("@webiny/di").Abstraction<IGetLockedEntryLockRecordUseCase>;
+export declare namespace GetLockedEntryLockRecordUseCase {
+    type Interface = IGetLockedEntryLockRecordUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/features/GetLockedEntryLockRecord/abstractions.js

@@ -0,0 +1,13 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// Input type
+
+/**
+ * GetLockedEntryLockRecord Use Case
+ * Returns lock record ONLY if entry is locked by someone OTHER than current user
+ * Returns error if: not found, expired, or locked by current user
+ */
+
+export const GetLockedEntryLockRecordUseCase = createAbstraction("GetLockedEntryLockRecordUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/GetLockedEntryLockRecord/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetLockedEntryLockRecordUseCase"],"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 { LockRecordNotFoundError } from \"~/domain/errors.js\";\n\n// Input type\nexport interface GetLockedEntryLockRecordInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * GetLockedEntryLockRecord Use Case\n * Returns lock record ONLY if entry is locked by someone OTHER than current user\n * Returns error if: not found, expired, or locked by current user\n */\nexport interface IGetLockedEntryLockRecordUseCase {\n    execute(input: GetLockedEntryLockRecordInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface IGetLockedEntryLockRecordUseCaseErrors {\n    notFound: LockRecordNotFoundError;\n}\n\ntype UseCaseError =\n    IGetLockedEntryLockRecordUseCaseErrors[keyof IGetLockedEntryLockRecordUseCaseErrors];\n\nexport const GetLockedEntryLockRecordUseCase = createAbstraction<IGetLockedEntryLockRecordUseCase>(\n    \"GetLockedEntryLockRecordUseCase\"\n);\n\nexport namespace GetLockedEntryLockRecordUseCase {\n    export type Interface = IGetLockedEntryLockRecordUseCase;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAMvD;;AAMA;AACA;AACA;AACA;AACA;;AAYA,OAAO,MAAMC,+BAA+B,GAAGD,iBAAiB,CAC5D,iCACJ,CAAC","ignoreList":[]}

package/features/GetLockedEntryLockRecord/feature.d.ts

@@ -0,0 +1 @@
+export declare const GetLockedEntryLockRecordFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/GetLockedEntryLockRecord/feature.js

@@ -0,0 +1,10 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetLockedEntryLockRecordUseCase } from "./GetLockedEntryLockRecordUseCase.js";
+export const GetLockedEntryLockRecordFeature = createFeature({
+  name: "GetLockedEntryLockRecord",
+  register(container) {
+    container.register(GetLockedEntryLockRecordUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/GetLockedEntryLockRecord/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetLockedEntryLockRecordUseCase","GetLockedEntryLockRecordFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetLockedEntryLockRecordUseCase } from \"./GetLockedEntryLockRecordUseCase.js\";\n\nexport const GetLockedEntryLockRecordFeature = createFeature({\n    name: \"GetLockedEntryLockRecord\",\n    register(container) {\n        container.register(GetLockedEntryLockRecordUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,+BAA+B;AAExC,OAAO,MAAMC,+BAA+B,GAAGF,aAAa,CAAC;EACzDG,IAAI,EAAE,0BAA0B;EAChCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,+BAA+B,CAAC;EACvD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/GetLockedEntryLockRecord/index.d.ts

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

package/features/GetLockedEntryLockRecord/index.js

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

package/features/GetLockedEntryLockRecord/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions.js\";\nexport * from \"./feature.js\";\n"],"mappings":"AAAA;AACA","ignoreList":[]}

package/features/IsEntryLocked/IsEntryLockedUseCase.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { IsEntryLockedUseCase as UseCaseAbstraction, IsEntryLockedInput } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+declare class IsEntryLockedUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getLockRecord;
+    private identityContext;
+    constructor(getLockRecord: GetLockRecordUseCase.Interface, identityContext: IdentityContext.Interface);
+    execute(input: IsEntryLockedInput): Promise<Result<boolean, UseCaseAbstraction.Error>>;
+}
+export declare const IsEntryLockedUseCase: typeof IsEntryLockedUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IIsEntryLockedUseCase>;
+};
+export {};

package/features/IsEntryLocked/IsEntryLockedUseCase.js

@@ -0,0 +1,39 @@
+import { Result } from "@webiny/feature/api";
+import { IsEntryLockedUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { LockRecordNotFoundError } from "../../domain/errors.js";
+class IsEntryLockedUseCaseImpl {
+  constructor(getLockRecord, identityContext) {
+    this.getLockRecord = getLockRecord;
+    this.identityContext = identityContext;
+  }
+  async execute(input) {
+    const result = await this.getLockRecord.execute(input);
+    if (result.isFail()) {
+      // If not found, entry is not locked
+      if (result.error instanceof LockRecordNotFoundError) {
+        return Result.ok(false);
+      }
+      // Propagate other errors
+      return Result.fail(result.error);
+    }
+    const record = result.value;
+
+    // If expired, entry is not locked
+    if (record.isExpired()) {
+      return Result.ok(false);
+    }
+
+    // Check if locked by someone else
+    const identity = this.identityContext.getIdentity();
+    const isLockedByOther = record.lockedBy.id !== identity.id;
+    return Result.ok(isLockedByOther);
+  }
+}
+export const IsEntryLockedUseCase = UseCaseAbstraction.createImplementation({
+  implementation: IsEntryLockedUseCaseImpl,
+  dependencies: [GetLockRecordUseCase, IdentityContext]
+});
+
+//# sourceMappingURL=IsEntryLockedUseCase.js.map

package/features/IsEntryLocked/IsEntryLockedUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","IsEntryLockedUseCase","UseCaseAbstraction","GetLockRecordUseCase","IdentityContext","LockRecordNotFoundError","IsEntryLockedUseCaseImpl","constructor","getLockRecord","identityContext","execute","input","result","isFail","error","ok","fail","record","value","isExpired","identity","getIdentity","isLockedByOther","lockedBy","id","createImplementation","implementation","dependencies"],"sources":["IsEntryLockedUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IsEntryLockedUseCase as UseCaseAbstraction, IsEntryLockedInput } from \"./abstractions.js\";\nimport { GetLockRecordUseCase } from \"../GetLockRecord/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { LockRecordNotFoundError } from \"~/domain/errors.js\";\n\nclass IsEntryLockedUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getLockRecord: GetLockRecordUseCase.Interface,\n        private identityContext: IdentityContext.Interface\n    ) {}\n\n    async execute(input: IsEntryLockedInput): Promise<Result<boolean, UseCaseAbstraction.Error>> {\n        const result = await this.getLockRecord.execute(input);\n\n        if (result.isFail()) {\n            // If not found, entry is not locked\n            if (result.error instanceof LockRecordNotFoundError) {\n                return Result.ok(false);\n            }\n            // Propagate other errors\n            return Result.fail(result.error);\n        }\n\n        const record = result.value;\n\n        // If expired, entry is not locked\n        if (record.isExpired()) {\n            return Result.ok(false);\n        }\n\n        // Check if locked by someone else\n        const identity = this.identityContext.getIdentity();\n        const isLockedByOther = record.lockedBy.id !== identity.id;\n\n        return Result.ok(isLockedByOther);\n    }\n}\n\nexport const IsEntryLockedUseCase = UseCaseAbstraction.createImplementation({\n    implementation: IsEntryLockedUseCaseImpl,\n    dependencies: [GetLockRecordUseCase, IdentityContext]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,oBAAoB,IAAIC,kBAAkB;AACnD,SAASC,oBAAoB;AAC7B,SAASC,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,uBAAuB;AAEhC,MAAMC,wBAAwB,CAAyC;EACnEC,WAAWA,CACCC,aAA6C,EAC7CC,eAA0C,EACpD;IAAA,KAFUD,aAA6C,GAA7CA,aAA6C;IAAA,KAC7CC,eAA0C,GAA1CA,eAA0C;EACnD;EAEH,MAAMC,OAAOA,CAACC,KAAyB,EAAsD;IACzF,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,aAAa,CAACE,OAAO,CAACC,KAAK,CAAC;IAEtD,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB;MACA,IAAID,MAAM,CAACE,KAAK,YAAYT,uBAAuB,EAAE;QACjD,OAAOL,MAAM,CAACe,EAAE,CAAC,KAAK,CAAC;MAC3B;MACA;MACA,OAAOf,MAAM,CAACgB,IAAI,CAACJ,MAAM,CAACE,KAAK,CAAC;IACpC;IAEA,MAAMG,MAAM,GAAGL,MAAM,CAACM,KAAK;;IAE3B;IACA,IAAID,MAAM,CAACE,SAAS,CAAC,CAAC,EAAE;MACpB,OAAOnB,MAAM,CAACe,EAAE,CAAC,KAAK,CAAC;IAC3B;;IAEA;IACA,MAAMK,QAAQ,GAAG,IAAI,CAACX,eAAe,CAACY,WAAW,CAAC,CAAC;IACnD,MAAMC,eAAe,GAAGL,MAAM,CAACM,QAAQ,CAACC,EAAE,KAAKJ,QAAQ,CAACI,EAAE;IAE1D,OAAOxB,MAAM,CAACe,EAAE,CAACO,eAAe,CAAC;EACrC;AACJ;AAEA,OAAO,MAAMrB,oBAAoB,GAAGC,kBAAkB,CAACuB,oBAAoB,CAAC;EACxEC,cAAc,EAAEpB,wBAAwB;EACxCqB,YAAY,EAAE,CAACxB,oBAAoB,EAAEC,eAAe;AACxD,CAAC,CAAC","ignoreList":[]}

package/features/IsEntryLocked/abstractions.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import type { LockRecordEntryType } from "../../domain/types.js";
+import type { LockRecordPersistenceError } from "../../domain/errors.js";
+export interface IsEntryLockedInput {
+    id: string;
+    type: LockRecordEntryType;
+}
+/**
+ * IsEntryLocked Use Case - Checks if an entry is locked by another user
+ * Returns true if locked by someone else, false if not locked or locked by current user
+ */
+export interface IIsEntryLockedUseCase {
+    execute(input: IsEntryLockedInput): Promise<Result<boolean, UseCaseError>>;
+}
+export interface IIsEntryLockedUseCaseErrors {
+    persistence: LockRecordPersistenceError;
+}
+type UseCaseError = IIsEntryLockedUseCaseErrors[keyof IIsEntryLockedUseCaseErrors];
+export declare const IsEntryLockedUseCase: import("@webiny/di").Abstraction<IIsEntryLockedUseCase>;
+export declare namespace IsEntryLockedUseCase {
+    type Interface = IIsEntryLockedUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/features/IsEntryLocked/abstractions.js

@@ -0,0 +1,12 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// Input types
+
+/**
+ * IsEntryLocked Use Case - Checks if an entry is locked by another user
+ * Returns true if locked by someone else, false if not locked or locked by current user
+ */
+
+export const IsEntryLockedUseCase = createAbstraction("IsEntryLockedUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/IsEntryLocked/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","IsEntryLockedUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\nimport type { LockRecordPersistenceError } from \"~/domain/errors.js\";\n\n// Input types\nexport interface IsEntryLockedInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * IsEntryLocked Use Case - Checks if an entry is locked by another user\n * Returns true if locked by someone else, false if not locked or locked by current user\n */\nexport interface IIsEntryLockedUseCase {\n    execute(input: IsEntryLockedInput): Promise<Result<boolean, UseCaseError>>;\n}\n\nexport interface IIsEntryLockedUseCaseErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype UseCaseError = IIsEntryLockedUseCaseErrors[keyof IIsEntryLockedUseCaseErrors];\n\nexport const IsEntryLockedUseCase =\n    createAbstraction<IIsEntryLockedUseCase>(\"IsEntryLockedUseCase\");\n\nexport namespace IsEntryLockedUseCase {\n    export type Interface = IIsEntryLockedUseCase;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAKvD;;AAMA;AACA;AACA;AACA;;AAWA,OAAO,MAAMC,oBAAoB,GAC7BD,iBAAiB,CAAwB,sBAAsB,CAAC","ignoreList":[]}

package/features/IsEntryLocked/feature.d.ts

@@ -0,0 +1 @@
+export declare const IsEntryLockedFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/IsEntryLocked/feature.js

@@ -0,0 +1,10 @@
+import { createFeature } from "@webiny/feature/api";
+import { IsEntryLockedUseCase } from "./IsEntryLockedUseCase.js";
+export const IsEntryLockedFeature = createFeature({
+  name: "IsEntryLocked",
+  register(container) {
+    container.register(IsEntryLockedUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/IsEntryLocked/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","IsEntryLockedUseCase","IsEntryLockedFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { IsEntryLockedUseCase } from \"./IsEntryLockedUseCase.js\";\n\nexport const IsEntryLockedFeature = createFeature({\n    name: \"IsEntryLocked\",\n    register(container) {\n        container.register(IsEntryLockedUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,oBAAoB;AAE7B,OAAO,MAAMC,oBAAoB,GAAGF,aAAa,CAAC;EAC9CG,IAAI,EAAE,eAAe;EACrBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,oBAAoB,CAAC;EAC5C;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/IsEntryLocked/index.d.ts

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

package/features/IsEntryLocked/index.js

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

package/features/IsEntryLocked/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions.js\";\n"],"mappings":"AAAA","ignoreList":[]}

package/features/KickOutCurrentUser/KickOutCurrentUserUseCase.d.ts

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

package/features/KickOutCurrentUser/KickOutCurrentUserUseCase.js

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

package/features/KickOutCurrentUser/KickOutCurrentUserUseCase.js.map

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

package/features/KickOutCurrentUser/abstractions.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+/**
+ * KickOutCurrentUser Use Case - Sends websocket message to notify locked-out user
+ */
+export interface IKickOutCurrentUserUseCase {
+    execute(record: ILockRecord): Promise<Result<void, UseCaseError>>;
+}
+export interface IKickOutCurrentUserUseCaseErrors {
+}
+type UseCaseError = IKickOutCurrentUserUseCaseErrors[keyof IKickOutCurrentUserUseCaseErrors];
+export declare const KickOutCurrentUserUseCase: import("@webiny/di").Abstraction<IKickOutCurrentUserUseCase>;
+export declare namespace KickOutCurrentUserUseCase {
+    type Interface = IKickOutCurrentUserUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/features/KickOutCurrentUser/abstractions.js

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

package/features/KickOutCurrentUser/abstractions.js.map

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

package/features/KickOutCurrentUser/feature.d.ts

@@ -0,0 +1 @@
+export declare const KickOutCurrentUserFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/KickOutCurrentUser/feature.js

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

package/features/KickOutCurrentUser/feature.js.map

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

package/features/KickOutCurrentUser/index.d.ts

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

package/features/KickOutCurrentUser/index.js

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

package/features/KickOutCurrentUser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions.js\";\n"],"mappings":"AAAA","ignoreList":[]}

package/features/ListAllLockRecords/ListAllLockRecordsRepository.d.ts

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

package/features/ListAllLockRecords/ListAllLockRecordsRepository.js

@@ -0,0 +1,43 @@
+import { Result } from "@webiny/feature/api";
+import { ListAllLockRecordsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import { LockRecordPersistenceError } from "../../domain/errors.js";
+import { convertWhereCondition } from "../../utils/convertWhereCondition.js";
+import { LockRecord } from "../../domain/LockRecord.js";
+class ListAllLockRecordsRepositoryImpl {
+  constructor(config, listEntries, model) {
+    this.config = config;
+    this.listEntries = listEntries;
+    this.model = model;
+  }
+  async execute(input) {
+    try {
+      const params = {
+        ...input,
+        where: convertWhereCondition(input?.where)
+      };
+      const result = await this.listEntries.execute(this.model, params);
+      if (result.isFail()) {
+        return Result.fail(new LockRecordPersistenceError(result.error));
+      }
+      const {
+        entries,
+        meta
+      } = result.value;
+      const items = entries.map(entry => new LockRecord(entry, this.config.timeout));
+      return Result.ok({
+        items,
+        meta
+      });
+    } catch (error) {
+      return Result.fail(new LockRecordPersistenceError(error));
+    }
+  }
+}
+export const ListAllLockRecordsRepository = RepositoryAbstraction.createImplementation({
+  implementation: ListAllLockRecordsRepositoryImpl,
+  dependencies: [RecordLockingConfig, ListLatestEntriesUseCase, RecordLockingModel]
+});
+
+//# sourceMappingURL=ListAllLockRecordsRepository.js.map

package/features/ListAllLockRecords/ListAllLockRecordsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ListAllLockRecordsRepository","RepositoryAbstraction","ListLatestEntriesUseCase","RecordLockingConfig","RecordLockingModel","LockRecordPersistenceError","convertWhereCondition","LockRecord","ListAllLockRecordsRepositoryImpl","constructor","config","listEntries","model","execute","input","params","where","result","isFail","fail","error","entries","meta","value","items","map","entry","timeout","ok","createImplementation","implementation","dependencies"],"sources":["ListAllLockRecordsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    ListAllLockRecordsRepository as RepositoryAbstraction,\n    ListAllLockRecordsInput,\n    ListAllLockRecordsOutput\n} from \"./abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/index.js\";\n\nclass ListAllLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private config: RecordLockingConfig.Interface,\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private model: CmsModel\n    ) {}\n\n    async execute(\n        input?: ListAllLockRecordsInput\n    ): Promise<Result<ListAllLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const params = {\n                ...input,\n                where: convertWhereCondition(input?.where)\n            };\n\n            const result = await this.listEntries.execute<LockRecordValues>(this.model, params);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const { entries, meta } = result.value;\n\n            const items = entries.map(entry => new LockRecord(entry, this.config.timeout));\n\n            return Result.ok({\n                items,\n                meta\n            });\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const ListAllLockRecordsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListAllLockRecordsRepositoryImpl,\n    dependencies: [RecordLockingConfig, ListLatestEntriesUseCase, RecordLockingModel]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,4BAA4B,IAAIC,qBAAqB;AAIzD,SAASC,wBAAwB,QAAQ,4DAA4D;AACrG,SAASC,mBAAmB,EAAEC,kBAAkB;AAEhD,SAASC,0BAA0B;AACnC,SAASC,qBAAqB;AAC9B,SAASC,UAAU;AAGnB,MAAMC,gCAAgC,CAA4C;EAC9EC,WAAWA,CACCC,MAAqC,EACrCC,WAA+C,EAC/CC,KAAe,EACzB;IAAA,KAHUF,MAAqC,GAArCA,MAAqC;IAAA,KACrCC,WAA+C,GAA/CA,WAA+C;IAAA,KAC/CC,KAAe,GAAfA,KAAe;EACxB;EAEH,MAAMC,OAAOA,CACTC,KAA+B,EACuC;IACtE,IAAI;MACA,MAAMC,MAAM,GAAG;QACX,GAAGD,KAAK;QACRE,KAAK,EAAEV,qBAAqB,CAACQ,KAAK,EAAEE,KAAK;MAC7C,CAAC;MAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,WAAW,CAACE,OAAO,CAAmB,IAAI,CAACD,KAAK,EAAEG,MAAM,CAAC;MAEnF,IAAIE,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;QACjB,OAAOnB,MAAM,CAACoB,IAAI,CAAC,IAAId,0BAA0B,CAACY,MAAM,CAACG,KAAK,CAAC,CAAC;MACpE;MAEA,MAAM;QAAEC,OAAO;QAAEC;MAAK,CAAC,GAAGL,MAAM,CAACM,KAAK;MAEtC,MAAMC,KAAK,GAAGH,OAAO,CAACI,GAAG,CAACC,KAAK,IAAI,IAAInB,UAAU,CAACmB,KAAK,EAAE,IAAI,CAAChB,MAAM,CAACiB,OAAO,CAAC,CAAC;MAE9E,OAAO5B,MAAM,CAAC6B,EAAE,CAAC;QACbJ,KAAK;QACLF;MACJ,CAAC,CAAC;IACN,CAAC,CAAC,OAAOF,KAAK,EAAE;MACZ,OAAOrB,MAAM,CAACoB,IAAI,CAAC,IAAId,0BAA0B,CAACe,KAAc,CAAC,CAAC;IACtE;EACJ;AACJ;AAEA,OAAO,MAAMpB,4BAA4B,GAAGC,qBAAqB,CAAC4B,oBAAoB,CAAC;EACnFC,cAAc,EAAEtB,gCAAgC;EAChDuB,YAAY,EAAE,CAAC5B,mBAAmB,EAAED,wBAAwB,EAAEE,kBAAkB;AACpF,CAAC,CAAC","ignoreList":[]}

package/features/ListAllLockRecords/ListAllLockRecordsUseCase.d.ts

@@ -0,0 +1,11 @@
+import { Result } from "@webiny/feature/api";
+import { ListAllLockRecordsUseCase as UseCaseAbstraction, ListAllLockRecordsRepository, ListAllLockRecordsInput, ListAllLockRecordsOutput } from "./abstractions.js";
+declare class ListAllLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: ListAllLockRecordsRepository.Interface);
+    execute(input?: ListAllLockRecordsInput): Promise<Result<ListAllLockRecordsOutput, UseCaseAbstraction.Error>>;
+}
+export declare const ListAllLockRecordsUseCase: typeof ListAllLockRecordsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListAllLockRecordsUseCase>;
+};
+export {};