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

package/features/ListAllLockRecords/ListAllLockRecordsUseCase.js

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

package/features/ListAllLockRecords/ListAllLockRecordsUseCase.js.map

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

package/features/ListAllLockRecords/abstractions.d.ts

@@ -0,0 +1,40 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordPersistenceError } from "../../domain/errors.js";
+import type { CmsEntryListParams, CmsEntryMeta } from "@webiny/api-headless-cms/types";
+export type ListAllLockRecordsInput = Pick<CmsEntryListParams, "where" | "limit" | "sort" | "after">;
+export interface ListAllLockRecordsOutput {
+    items: ILockRecord[];
+    meta: CmsEntryMeta;
+}
+/**
+ * ListAllLockRecords Use Case - Lists all lock records without filtering
+ */
+export interface IListAllLockRecordsUseCase {
+    execute(input?: ListAllLockRecordsInput): Promise<Result<ListAllLockRecordsOutput, UseCaseError>>;
+}
+export interface IListAllLockRecordsUseCaseErrors {
+    persistence: LockRecordPersistenceError;
+}
+type UseCaseError = IListAllLockRecordsUseCaseErrors[keyof IListAllLockRecordsUseCaseErrors];
+export declare const ListAllLockRecordsUseCase: import("@webiny/di").Abstraction<IListAllLockRecordsUseCase>;
+export declare namespace ListAllLockRecordsUseCase {
+    type Interface = IListAllLockRecordsUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * ListAllLockRecordsRepository - Fetches all lock records from storage
+ */
+export interface IListAllLockRecordsRepository {
+    execute(input?: ListAllLockRecordsInput): Promise<Result<ListAllLockRecordsOutput, RepositoryError>>;
+}
+export interface IListAllLockRecordsRepositoryErrors {
+    persistence: LockRecordPersistenceError;
+}
+type RepositoryError = IListAllLockRecordsRepositoryErrors[keyof IListAllLockRecordsRepositoryErrors];
+export declare const ListAllLockRecordsRepository: import("@webiny/di").Abstraction<IListAllLockRecordsRepository>;
+export declare namespace ListAllLockRecordsRepository {
+    type Interface = IListAllLockRecordsRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/ListAllLockRecords/abstractions.js

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

package/features/ListAllLockRecords/abstractions.js.map

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

package/features/ListAllLockRecords/feature.d.ts

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

package/features/ListAllLockRecords/feature.js

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

package/features/ListAllLockRecords/feature.js.map

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

package/features/ListAllLockRecords/index.d.ts

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

package/features/ListAllLockRecords/index.js

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

package/features/ListAllLockRecords/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/ListLockRecords/ListLockRecordsRepository.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { ListLockRecordsRepository as RepositoryAbstraction, ListLockRecordsInput, ListLockRecordsOutput } from "./abstractions.js";
+import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+declare class ListLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private model;
+    private config;
+    private listEntries;
+    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, listEntries: ListLatestEntriesUseCase.Interface);
+    execute(input?: ListLockRecordsInput): Promise<Result<ListLockRecordsOutput, RepositoryAbstraction.Error>>;
+}
+export declare const ListLockRecordsRepository: typeof ListLockRecordsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListLockRecordsRepository>;
+};
+export {};

package/features/ListLockRecords/ListLockRecordsRepository.js

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

package/features/ListLockRecords/ListLockRecordsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ListLatestEntriesUseCase","ListLockRecordsRepository","RepositoryAbstraction","RecordLockingConfig","RecordLockingModel","LockRecord","LockRecordPersistenceError","convertWhereCondition","ListLockRecordsRepositoryImpl","constructor","model","config","listEntries","execute","input","params","where","result","isFail","fail","error","entries","meta","value","items","map","entry","timeout","ok","createImplementation","implementation","dependencies"],"sources":["ListLockRecordsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport {\n    ListLockRecordsRepository as RepositoryAbstraction,\n    ListLockRecordsInput,\n    ListLockRecordsOutput\n} from \"./abstractions.js\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/types.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition.js\";\n\nclass ListLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private listEntries: ListLatestEntriesUseCase.Interface\n    ) {}\n\n    async execute(\n        input?: ListLockRecordsInput\n    ): Promise<Result<ListLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const params = {\n                ...input,\n                where: convertWhereCondition(input?.where || {})\n            };\n\n            const result = await this.listEntries.execute<LockRecordValues>(this.model, params);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const { entries, meta } = result.value;\n\n            const items = entries.map(entry => new LockRecord(entry, this.config.timeout));\n\n            return Result.ok({\n                items,\n                meta\n            });\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const ListLockRecordsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListLockRecordsRepositoryImpl,\n    dependencies: [RecordLockingModel, RecordLockingConfig, ListLatestEntriesUseCase]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,wBAAwB,QAAQ,4DAA4D;AACrG,SACIC,yBAAyB,IAAIC,qBAAqB;AAItD,SAASC,mBAAmB,EAAEC,kBAAkB;AAChD,SAASC,UAAU;AAEnB,SAASC,0BAA0B;AACnC,SAASC,qBAAqB;AAE9B,MAAMC,6BAA6B,CAA4C;EAC3EC,WAAWA,CACCC,KAAmC,EACnCC,MAAqC,EACrCC,WAA+C,EACzD;IAAA,KAHUF,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;IAAA,KACrCC,WAA+C,GAA/CA,WAA+C;EACxD;EAEH,MAAMC,OAAOA,CACTC,KAA4B,EACuC;IACnE,IAAI;MACA,MAAMC,MAAM,GAAG;QACX,GAAGD,KAAK;QACRE,KAAK,EAAET,qBAAqB,CAACO,KAAK,EAAEE,KAAK,IAAI,CAAC,CAAC;MACnD,CAAC;MAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACL,WAAW,CAACC,OAAO,CAAmB,IAAI,CAACH,KAAK,EAAEK,MAAM,CAAC;MAEnF,IAAIE,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;QACjB,OAAOnB,MAAM,CAACoB,IAAI,CAAC,IAAIb,0BAA0B,CAACW,MAAM,CAACG,KAAK,CAAC,CAAC;MACpE;MAEA,MAAM;QAAEC,OAAO;QAAEC;MAAK,CAAC,GAAGL,MAAM,CAACM,KAAK;MAEtC,MAAMC,KAAK,GAAGH,OAAO,CAACI,GAAG,CAACC,KAAK,IAAI,IAAIrB,UAAU,CAACqB,KAAK,EAAE,IAAI,CAACf,MAAM,CAACgB,OAAO,CAAC,CAAC;MAE9E,OAAO5B,MAAM,CAAC6B,EAAE,CAAC;QACbJ,KAAK;QACLF;MACJ,CAAC,CAAC;IACN,CAAC,CAAC,OAAOF,KAAK,EAAE;MACZ,OAAOrB,MAAM,CAACoB,IAAI,CAAC,IAAIb,0BAA0B,CAACc,KAAc,CAAC,CAAC;IACtE;EACJ;AACJ;AAEA,OAAO,MAAMnB,yBAAyB,GAAGC,qBAAqB,CAAC2B,oBAAoB,CAAC;EAChFC,cAAc,EAAEtB,6BAA6B;EAC7CuB,YAAY,EAAE,CAAC3B,kBAAkB,EAAED,mBAAmB,EAAEH,wBAAwB;AACpF,CAAC,CAAC","ignoreList":[]}

package/features/ListLockRecords/ListLockRecordsUseCase.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { ListLockRecordsInput, ListLockRecordsOutput, ListLockRecordsRepository, ListLockRecordsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { RecordLockingConfig } from "../../domain/abstractions.js";
+declare class ListLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    private identityContext;
+    private config;
+    constructor(repository: ListLockRecordsRepository.Interface, identityContext: IdentityContext.Interface, config: RecordLockingConfig.Interface);
+    execute(input?: ListLockRecordsInput): Promise<Result<ListLockRecordsOutput, UseCaseAbstraction.Error>>;
+}
+export declare const ListLockRecordsUseCase: typeof ListLockRecordsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListLockRecordsUseCase>;
+};
+export {};

package/features/ListLockRecords/ListLockRecordsUseCase.js

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

package/features/ListLockRecords/ListLockRecordsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ListLockRecordsRepository","ListLockRecordsUseCase","UseCaseAbstraction","IdentityContext","RecordLockingConfig","ListLockRecordsUseCaseImpl","constructor","repository","identityContext","config","execute","input","identity","getIdentity","enhancedInput","where","createdBy_not","id","savedOn_gte","Date","getTime","timeout","toISOString","createImplementation","implementation","dependencies"],"sources":["ListLockRecordsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    ListLockRecordsInput,\n    ListLockRecordsOutput,\n    ListLockRecordsRepository,\n    ListLockRecordsUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { RecordLockingConfig } from \"~/domain/abstractions.js\";\n\nclass ListLockRecordsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private repository: ListLockRecordsRepository.Interface,\n        private identityContext: IdentityContext.Interface,\n        private config: RecordLockingConfig.Interface\n    ) {}\n\n    async execute(\n        input?: ListLockRecordsInput\n    ): Promise<Result<ListLockRecordsOutput, UseCaseAbstraction.Error>> {\n        const identity = this.identityContext.getIdentity();\n\n        // Filter out expired locks and exclude current user's locks\n        const enhancedInput: ListLockRecordsInput = {\n            ...input,\n            where: {\n                ...input?.where,\n                createdBy_not: identity.id,\n                savedOn_gte: new Date(new Date().getTime() - this.config.timeout).toISOString()\n            }\n        };\n\n        return await this.repository.execute(enhancedInput);\n    }\n}\n\nexport const ListLockRecordsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListLockRecordsUseCaseImpl,\n    dependencies: [ListLockRecordsRepository, IdentityContext, RecordLockingConfig]\n});\n"],"mappings":"AACA,SAGIA,yBAAyB,EACzBC,sBAAsB,IAAIC,kBAAkB;AAEhD,SAASC,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,mBAAmB;AAE5B,MAAMC,0BAA0B,CAAyC;EACrEC,WAAWA,CACCC,UAA+C,EAC/CC,eAA0C,EAC1CC,MAAqC,EAC/C;IAAA,KAHUF,UAA+C,GAA/CA,UAA+C;IAAA,KAC/CC,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,MAAqC,GAArCA,MAAqC;EAC9C;EAEH,MAAMC,OAAOA,CACTC,KAA4B,EACoC;IAChE,MAAMC,QAAQ,GAAG,IAAI,CAACJ,eAAe,CAACK,WAAW,CAAC,CAAC;;IAEnD;IACA,MAAMC,aAAmC,GAAG;MACxC,GAAGH,KAAK;MACRI,KAAK,EAAE;QACH,GAAGJ,KAAK,EAAEI,KAAK;QACfC,aAAa,EAAEJ,QAAQ,CAACK,EAAE;QAC1BC,WAAW,EAAE,IAAIC,IAAI,CAAC,IAAIA,IAAI,CAAC,CAAC,CAACC,OAAO,CAAC,CAAC,GAAG,IAAI,CAACX,MAAM,CAACY,OAAO,CAAC,CAACC,WAAW,CAAC;MAClF;IACJ,CAAC;IAED,OAAO,MAAM,IAAI,CAACf,UAAU,CAACG,OAAO,CAACI,aAAa,CAAC;EACvD;AACJ;AAEA,OAAO,MAAMb,sBAAsB,GAAGC,kBAAkB,CAACqB,oBAAoB,CAAC;EAC1EC,cAAc,EAAEnB,0BAA0B;EAC1CoB,YAAY,EAAE,CAACzB,yBAAyB,EAAEG,eAAe,EAAEC,mBAAmB;AAClF,CAAC,CAAC","ignoreList":[]}

package/features/ListLockRecords/abstractions.d.ts

@@ -0,0 +1,45 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordPersistenceError } from "../../domain/errors.js";
+import type { CmsEntryListParams, CmsEntryMeta } from "@webiny/api-headless-cms/types";
+import type { DateStringInterfaceGenerator, IdentityInterfaceGenerator, IdInterfaceGenerator } from "@webiny/api";
+export interface IListLockRecordsWhere extends IdInterfaceGenerator<"id">, IdentityInterfaceGenerator<"lockedBy">, IdentityInterfaceGenerator<"createdBy">, DateStringInterfaceGenerator<"lockedOn">, DateStringInterfaceGenerator<"updatedOn">, DateStringInterfaceGenerator<"savedOn">, DateStringInterfaceGenerator<"expiresOn"> {
+}
+export interface ListLockRecordsInput extends Pick<CmsEntryListParams, "limit" | "sort" | "after"> {
+    where?: IListLockRecordsWhere;
+}
+export interface ListLockRecordsOutput {
+    items: ILockRecord[];
+    meta: CmsEntryMeta;
+}
+/**
+ * ListLockRecords Use Case - Lists active lock records (filters out expired, excludes current user)
+ */
+export interface IListLockRecordsUseCase {
+    execute(input?: ListLockRecordsInput): Promise<Result<ListLockRecordsOutput, UseCaseError>>;
+}
+export interface IListLockRecordsUseCaseErrors {
+    persistence: LockRecordPersistenceError;
+}
+type UseCaseError = IListLockRecordsUseCaseErrors[keyof IListLockRecordsUseCaseErrors];
+export declare const ListLockRecordsUseCase: import("@webiny/di").Abstraction<IListLockRecordsUseCase>;
+export declare namespace ListLockRecordsUseCase {
+    type Interface = IListLockRecordsUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * ListLockRecordsRepository - Fetches lock records from storage with filtering
+ */
+export interface IListLockRecordsRepository {
+    execute(input?: ListLockRecordsInput): Promise<Result<ListLockRecordsOutput, RepositoryError>>;
+}
+export interface IListLockRecordsRepositoryErrors {
+    persistence: LockRecordPersistenceError;
+}
+type RepositoryError = IListLockRecordsRepositoryErrors[keyof IListLockRecordsRepositoryErrors];
+export declare const ListLockRecordsRepository: import("@webiny/di").Abstraction<IListLockRecordsRepository>;
+export declare namespace ListLockRecordsRepository {
+    type Interface = IListLockRecordsRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/ListLockRecords/abstractions.js

@@ -0,0 +1,17 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// Input/Output types
+
+/**
+ * ListLockRecords Use Case - Lists active lock records (filters out expired, excludes current user)
+ */
+
+export const ListLockRecordsUseCase = createAbstraction("ListLockRecordsUseCase");
+
+/**
+ * ListLockRecordsRepository - Fetches lock records from storage with filtering
+ */
+
+export const ListLockRecordsRepository = createAbstraction("ListLockRecordsRepository");
+
+//# sourceMappingURL=abstractions.js.map

package/features/ListLockRecords/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ListLockRecordsUseCase","ListLockRecordsRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport type { CmsEntryListParams, CmsEntryMeta } from \"@webiny/api-headless-cms/types\";\nimport type {\n    DateStringInterfaceGenerator,\n    IdentityInterfaceGenerator,\n    IdInterfaceGenerator\n} from \"@webiny/api\";\n\n// Input/Output types\nexport interface IListLockRecordsWhere\n    extends IdInterfaceGenerator<\"id\">,\n        IdentityInterfaceGenerator<\"lockedBy\">,\n        IdentityInterfaceGenerator<\"createdBy\">,\n        DateStringInterfaceGenerator<\"lockedOn\">,\n        DateStringInterfaceGenerator<\"updatedOn\">,\n        DateStringInterfaceGenerator<\"savedOn\">,\n        DateStringInterfaceGenerator<\"expiresOn\"> {}\n\nexport interface ListLockRecordsInput extends Pick<CmsEntryListParams, \"limit\" | \"sort\" | \"after\"> {\n    where?: IListLockRecordsWhere;\n}\n\nexport interface ListLockRecordsOutput {\n    items: ILockRecord[];\n    meta: CmsEntryMeta;\n}\n\n/**\n * ListLockRecords Use Case - Lists active lock records (filters out expired, excludes current user)\n */\nexport interface IListLockRecordsUseCase {\n    execute(input?: ListLockRecordsInput): Promise<Result<ListLockRecordsOutput, UseCaseError>>;\n}\n\nexport interface IListLockRecordsUseCaseErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype UseCaseError = IListLockRecordsUseCaseErrors[keyof IListLockRecordsUseCaseErrors];\n\nexport const ListLockRecordsUseCase =\n    createAbstraction<IListLockRecordsUseCase>(\"ListLockRecordsUseCase\");\n\nexport namespace ListLockRecordsUseCase {\n    export type Interface = IListLockRecordsUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * ListLockRecordsRepository - Fetches lock records from storage with filtering\n */\nexport interface IListLockRecordsRepository {\n    execute(input?: ListLockRecordsInput): Promise<Result<ListLockRecordsOutput, RepositoryError>>;\n}\n\nexport interface IListLockRecordsRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError = IListLockRecordsRepositoryErrors[keyof IListLockRecordsRepositoryErrors];\n\nexport const ListLockRecordsRepository = createAbstraction<IListLockRecordsRepository>(\n    \"ListLockRecordsRepository\"\n);\n\nexport namespace ListLockRecordsRepository {\n    export type Interface = IListLockRecordsRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAU/D;;AAmBA;AACA;AACA;;AAWA,OAAO,MAAMC,sBAAsB,GAC/BD,iBAAiB,CAA0B,wBAAwB,CAAC;;AAOxE;AACA;AACA;;AAWA,OAAO,MAAME,yBAAyB,GAAGF,iBAAiB,CACtD,2BACJ,CAAC","ignoreList":[]}

package/features/ListLockRecords/feature.d.ts

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

package/features/ListLockRecords/feature.js

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

package/features/ListLockRecords/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ListLockRecordsUseCase","ListLockRecordsRepository","ListLockRecordsFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListLockRecordsUseCase } from \"./ListLockRecordsUseCase.js\";\nimport { ListLockRecordsRepository } from \"./ListLockRecordsRepository.js\";\n\nexport const ListLockRecordsFeature = createFeature({\n    name: \"ListLockRecords\",\n    register(container) {\n        container.register(ListLockRecordsUseCase);\n        container.register(ListLockRecordsRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;AAElC,OAAO,MAAMC,sBAAsB,GAAGH,aAAa,CAAC;EAChDI,IAAI,EAAE,iBAAiB;EACvBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,sBAAsB,CAAC;IAC1CK,SAAS,CAACD,QAAQ,CAACH,yBAAyB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACpE;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/ListLockRecords/index.d.ts

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

package/features/ListLockRecords/index.js

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

package/features/ListLockRecords/index.js.map

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

package/features/LockEntry/LockEntryEventsDecorator.d.ts

@@ -0,0 +1,14 @@
+import { type LockEntryInput, LockEntryUseCase as UseCaseAbstraction, LockEntryUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import type { ILockRecord } from "../../domain/index.js";
+import { Result } from "@webiny/feature/api/index.js";
+declare class LockEntryErrorDecoratorImpl implements LockEntryUseCase.Interface {
+    private readonly eventPublisher;
+    private readonly decoratee;
+    constructor(eventPublisher: EventPublisher.Interface, decoratee: LockEntryUseCase.Interface);
+    execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const LockEntryEventsDecorator: typeof LockEntryErrorDecoratorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILockEntryUseCase>;
+};
+export {};

package/features/LockEntry/LockEntryEventsDecorator.js

@@ -0,0 +1,40 @@
+import { LockEntryUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { EntryAfterLockEvent, EntryBeforeLockEvent, EntryLockErrorEvent } from "./events.js";
+class LockEntryErrorDecoratorImpl {
+  constructor(eventPublisher, decoratee) {
+    this.eventPublisher = eventPublisher;
+    this.decoratee = decoratee;
+  }
+  async execute(input) {
+    // Publish before event
+    await this.eventPublisher.publish(new EntryBeforeLockEvent({
+      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 EntryLockErrorEvent({
+        id: input.id,
+        type: input.type,
+        error
+      }));
+      return result;
+    }
+
+    // Publish after event
+    await this.eventPublisher.publish(new EntryAfterLockEvent({
+      id: input.id,
+      type: input.type,
+      record: result.value
+    }));
+    return result;
+  }
+}
+export const LockEntryEventsDecorator = LockEntryUseCase.createDecorator({
+  decorator: LockEntryErrorDecoratorImpl,
+  dependencies: [EventPublisher]
+});
+
+//# sourceMappingURL=LockEntryEventsDecorator.js.map

package/features/LockEntry/LockEntryEventsDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LockEntryUseCase","EventPublisher","EntryAfterLockEvent","EntryBeforeLockEvent","EntryLockErrorEvent","LockEntryErrorDecoratorImpl","constructor","eventPublisher","decoratee","execute","input","publish","id","type","result","isFail","error","record","value","LockEntryEventsDecorator","createDecorator","decorator","dependencies"],"sources":["LockEntryEventsDecorator.ts"],"sourcesContent":["import {\n    type LockEntryInput,\n    LockEntryUseCase as UseCaseAbstraction,\n    LockEntryUseCase\n} from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\nimport type { ILockRecord } from \"~/domain/index.js\";\nimport { Result } from \"@webiny/feature/api/index.js\";\nimport { EntryAfterLockEvent, EntryBeforeLockEvent, EntryLockErrorEvent } from \"./events.js\";\n\nclass LockEntryErrorDecoratorImpl implements LockEntryUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: LockEntryUseCase.Interface\n    ) {}\n    async execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeLockEvent({\n                id: input.id,\n                type: input.type\n            })\n        );\n\n        const result = await this.decoratee.execute(input);\n\n        if (result.isFail()) {\n            const error = result.error;\n\n            await this.eventPublisher.publish(\n                new EntryLockErrorEvent({\n                    id: input.id,\n                    type: input.type,\n                    error\n                })\n            );\n\n            return result;\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new EntryAfterLockEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const LockEntryEventsDecorator = LockEntryUseCase.createDecorator({\n    decorator: LockEntryErrorDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"mappings":"AAAA,SAGIA,gBAAgB;AAEpB,SAASC,cAAc,QAAQ,0CAA0C;AAGzE,SAASC,mBAAmB,EAAEC,oBAAoB,EAAEC,mBAAmB;AAEvE,MAAMC,2BAA2B,CAAuC;EACpEC,WAAWA,CACUC,cAAwC,EACxCC,SAAqC,EACxD;IAAA,KAFmBD,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,SAAqC,GAArCA,SAAqC;EACvD;EACH,MAAMC,OAAOA,CAACC,KAAqB,EAA0D;IACzF;IACA,MAAM,IAAI,CAACH,cAAc,CAACI,OAAO,CAC7B,IAAIR,oBAAoB,CAAC;MACrBS,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG;IAChB,CAAC,CACL,CAAC;IAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,SAAS,CAACC,OAAO,CAACC,KAAK,CAAC;IAElD,IAAII,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMC,KAAK,GAAGF,MAAM,CAACE,KAAK;MAE1B,MAAM,IAAI,CAACT,cAAc,CAACI,OAAO,CAC7B,IAAIP,mBAAmB,CAAC;QACpBQ,EAAE,EAAEF,KAAK,CAACE,EAAE;QACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;QAChBG;MACJ,CAAC,CACL,CAAC;MAED,OAAOF,MAAM;IACjB;;IAEA;IACA,MAAM,IAAI,CAACP,cAAc,CAACI,OAAO,CAC7B,IAAIT,mBAAmB,CAAC;MACpBU,EAAE,EAAEF,KAAK,CAACE,EAAE;MACZC,IAAI,EAAEH,KAAK,CAACG,IAAI;MAChBI,MAAM,EAAEH,MAAM,CAACI;IACnB,CAAC,CACL,CAAC;IAED,OAAOJ,MAAM;EACjB;AACJ;AAEA,OAAO,MAAMK,wBAAwB,GAAGnB,gBAAgB,CAACoB,eAAe,CAAC;EACrEC,SAAS,EAAEhB,2BAA2B;EACtCiB,YAAY,EAAE,CAACrB,cAAc;AACjC,CAAC,CAAC","ignoreList":[]}

package/features/LockEntry/LockEntryRepository.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "@webiny/feature/api";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { LockEntryInput, LockEntryRepository as RepositoryAbstraction } from "./abstractions.js";
+import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class LockEntryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private model;
+    private config;
+    private createEntry;
+    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, createEntry: CreateEntryUseCase.Interface);
+    create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryAbstraction.Error>>;
+}
+export declare const LockEntryRepository: typeof LockEntryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILockEntryRepository>;
+};
+export {};

package/features/LockEntry/LockEntryRepository.js

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

package/features/LockEntry/LockEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","CreateEntryUseCase","LockEntryRepository","RepositoryAbstraction","RecordLockingConfig","RecordLockingModel","LockRecord","LockRecordPersistenceError","createLockRecordDatabaseId","LockEntryRepositoryImpl","constructor","model","config","createEntry","create","input","id","values","targetId","type","actions","result","execute","isFail","fail","error","entry","value","lockRecord","timeout","ok","createImplementation","implementation","dependencies"],"sources":["LockEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry\";\nimport type { CmsEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport { LockEntryInput, LockEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/types.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass LockEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private createEntry: CreateEntryUseCase.Interface\n    ) {}\n\n    async create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const id = createLockRecordDatabaseId(input.id);\n\n            const values: LockRecordValues = {\n                targetId: input.id,\n                type: input.type,\n                actions: []\n            };\n\n            const result = await this.createEntry.execute(this.model, {\n                id,\n                values\n            });\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const entry = result.value as CmsEntry<LockRecordValues>;\n            const lockRecord = new LockRecord(entry, this.config.timeout);\n\n            return Result.ok(lockRecord);\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const LockEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: LockEntryRepositoryImpl,\n    dependencies: [RecordLockingModel, RecordLockingConfig, CreateEntryUseCase]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,QAAQ,4DAA4D;AAE/F,SAAyBC,mBAAmB,IAAIC,qBAAqB;AACrE,SAASC,mBAAmB,EAAEC,kBAAkB;AAEhD,SAASC,UAAU;AAEnB,SAASC,0BAA0B;AACnC,SAASC,0BAA0B;AAEnC,MAAMC,uBAAuB,CAA4C;EACrEC,WAAWA,CACCC,KAAmC,EACnCC,MAAqC,EACrCC,WAAyC,EACnD;IAAA,KAHUF,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;IAAA,KACrCC,WAAyC,GAAzCA,WAAyC;EAClD;EAEH,MAAMC,MAAMA,CAACC,KAAqB,EAA6D;IAC3F,IAAI;MACA,MAAMC,EAAE,GAAGR,0BAA0B,CAACO,KAAK,CAACC,EAAE,CAAC;MAE/C,MAAMC,MAAwB,GAAG;QAC7BC,QAAQ,EAAEH,KAAK,CAACC,EAAE;QAClBG,IAAI,EAAEJ,KAAK,CAACI,IAAI;QAChBC,OAAO,EAAE;MACb,CAAC;MAED,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACR,WAAW,CAACS,OAAO,CAAC,IAAI,CAACX,KAAK,EAAE;QACtDK,EAAE;QACFC;MACJ,CAAC,CAAC;MAEF,IAAII,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;QACjB,OAAOvB,MAAM,CAACwB,IAAI,CAAC,IAAIjB,0BAA0B,CAACc,MAAM,CAACI,KAAK,CAAC,CAAC;MACpE;MAEA,MAAMC,KAAK,GAAGL,MAAM,CAACM,KAAmC;MACxD,MAAMC,UAAU,GAAG,IAAItB,UAAU,CAACoB,KAAK,EAAE,IAAI,CAACd,MAAM,CAACiB,OAAO,CAAC;MAE7D,OAAO7B,MAAM,CAAC8B,EAAE,CAACF,UAAU,CAAC;IAChC,CAAC,CAAC,OAAOH,KAAK,EAAE;MACZ,OAAOzB,MAAM,CAACwB,IAAI,CAAC,IAAIjB,0BAA0B,CAACkB,KAAc,CAAC,CAAC;IACtE;EACJ;AACJ;AAEA,OAAO,MAAMvB,mBAAmB,GAAGC,qBAAqB,CAAC4B,oBAAoB,CAAC;EAC1EC,cAAc,EAAEvB,uBAAuB;EACvCwB,YAAY,EAAE,CAAC5B,kBAAkB,EAAED,mBAAmB,EAAEH,kBAAkB;AAC9E,CAAC,CAAC","ignoreList":[]}

package/features/LockEntry/LockEntryUseCase.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { LockEntryUseCase as UseCaseAbstraction, LockEntryRepository, LockEntryInput } from "./abstractions.js";
+import { IsEntryLockedUseCase } from "../IsEntryLocked/abstractions.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class LockEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private isEntryLocked;
+    private repository;
+    constructor(isEntryLocked: IsEntryLockedUseCase.Interface, repository: LockEntryRepository.Interface);
+    execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const LockEntryUseCase: typeof LockEntryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILockEntryUseCase>;
+};
+export {};

package/features/LockEntry/LockEntryUseCase.js

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

package/features/LockEntry/LockEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","LockEntryUseCase","UseCaseAbstraction","LockEntryRepository","IsEntryLockedUseCase","EntryAlreadyLockedError","LockEntryError","LockEntryUseCaseImpl","constructor","isEntryLocked","repository","execute","input","lockedResult","isFail","fail","error","value","id","type","result","create","ok","createImplementation","implementation","dependencies"],"sources":["LockEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    LockEntryUseCase as UseCaseAbstraction,\n    LockEntryRepository,\n    LockEntryInput\n} from \"./abstractions.js\";\nimport { IsEntryLockedUseCase } from \"../IsEntryLocked/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { EntryAlreadyLockedError, LockEntryError } from \"~/domain/errors.js\";\n\nclass LockEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private isEntryLocked: IsEntryLockedUseCase.Interface,\n        private repository: LockEntryRepository.Interface\n    ) {}\n\n    async execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Check if entry is already locked\n        const lockedResult = await this.isEntryLocked.execute(input);\n\n        if (lockedResult.isFail()) {\n            return Result.fail(lockedResult.error);\n        }\n\n        if (lockedResult.value) {\n            return Result.fail(new EntryAlreadyLockedError({ id: input.id, type: input.type }));\n        }\n\n        // Create the lock\n        const result = await this.repository.create(input);\n\n        if (result.isFail()) {\n            return Result.fail(new LockEntryError(result.error));\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const LockEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: LockEntryUseCaseImpl,\n    dependencies: [IsEntryLockedUseCase, LockEntryRepository]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,gBAAgB,IAAIC,kBAAkB,EACtCC,mBAAmB;AAGvB,SAASC,oBAAoB;AAE7B,SAASC,uBAAuB,EAAEC,cAAc;AAEhD,MAAMC,oBAAoB,CAAyC;EAC/DC,WAAWA,CACCC,aAA6C,EAC7CC,UAAyC,EACnD;IAAA,KAFUD,aAA6C,GAA7CA,aAA6C;IAAA,KAC7CC,UAAyC,GAAzCA,UAAyC;EAClD;EAEH,MAAMC,OAAOA,CAACC,KAAqB,EAA0D;IACzF;IACA,MAAMC,YAAY,GAAG,MAAM,IAAI,CAACJ,aAAa,CAACE,OAAO,CAACC,KAAK,CAAC;IAE5D,IAAIC,YAAY,CAACC,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOd,MAAM,CAACe,IAAI,CAACF,YAAY,CAACG,KAAK,CAAC;IAC1C;IAEA,IAAIH,YAAY,CAACI,KAAK,EAAE;MACpB,OAAOjB,MAAM,CAACe,IAAI,CAAC,IAAIV,uBAAuB,CAAC;QAAEa,EAAE,EAAEN,KAAK,CAACM,EAAE;QAAEC,IAAI,EAAEP,KAAK,CAACO;MAAK,CAAC,CAAC,CAAC;IACvF;;IAEA;IACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACV,UAAU,CAACW,MAAM,CAACT,KAAK,CAAC;IAElD,IAAIQ,MAAM,CAACN,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOd,MAAM,CAACe,IAAI,CAAC,IAAIT,cAAc,CAACc,MAAM,CAACJ,KAAK,CAAC,CAAC;IACxD;IAEA,OAAOhB,MAAM,CAACsB,EAAE,CAACF,MAAM,CAACH,KAAK,CAAC;EAClC;AACJ;AAEA,OAAO,MAAMhB,gBAAgB,GAAGC,kBAAkB,CAACqB,oBAAoB,CAAC;EACpEC,cAAc,EAAEjB,oBAAoB;EACpCkB,YAAY,EAAE,CAACrB,oBAAoB,EAAED,mBAAmB;AAC5D,CAAC,CAAC","ignoreList":[]}

package/features/LockEntry/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 type { EntryAlreadyLockedError, LockEntryError, LockRecordPersistenceError } from "../../domain/errors.js";
+export interface LockEntryInput {
+    id: string;
+    type: LockRecordEntryType;
+}
+/**
+ * LockEntry Use Case - Creates a lock on an entry
+ */
+export interface ILockEntryUseCase {
+    execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseError>>;
+}
+export interface ILockEntryUseCaseErrors {
+    alreadyLocked: EntryAlreadyLockedError;
+    persistence: LockRecordPersistenceError;
+    lockError: LockEntryError;
+}
+type UseCaseError = ILockEntryUseCaseErrors[keyof ILockEntryUseCaseErrors];
+export declare const LockEntryUseCase: import("@webiny/di").Abstraction<ILockEntryUseCase>;
+export declare namespace LockEntryUseCase {
+    type Interface = ILockEntryUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * LockEntryRepository - Creates lock record in storage
+ */
+export interface ILockEntryRepository {
+    create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryError>>;
+}
+export interface ILockEntryRepositoryErrors {
+    persistence: LockRecordPersistenceError;
+}
+type RepositoryError = ILockEntryRepositoryErrors[keyof ILockEntryRepositoryErrors];
+export declare const LockEntryRepository: import("@webiny/di").Abstraction<ILockEntryRepository>;
+export declare namespace LockEntryRepository {
+    type Interface = ILockEntryRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/LockEntry/abstractions.js

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