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

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,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ListAllLockRecordsUseCase = createAbstraction("ListAllLockRecordsUseCase");
+const ListAllLockRecordsRepository = createAbstraction("ListAllLockRecordsRepository");
+export { ListAllLockRecordsRepository, ListAllLockRecordsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/ListAllLockRecords/abstractions.js.map

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

package/features/ListAllLockRecords/feature.d.ts

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

package/features/ListAllLockRecords/feature.js

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

package/features/ListAllLockRecords/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListAllLockRecords/feature.js","sources":["../../../src/features/ListAllLockRecords/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListAllLockRecordsUseCase } from \"./ListAllLockRecordsUseCase.js\";\nimport { ListAllLockRecordsRepository } from \"./ListAllLockRecordsRepository.js\";\n\nexport const ListAllLockRecordsFeature = createFeature({\n    name: \"ListAllLockRecords\",\n    register(container) {\n        container.register(ListAllLockRecordsUseCase);\n        container.register(ListAllLockRecordsRepository).inSingletonScope();\n    }\n});\n"],"names":["ListAllLockRecordsFeature","createFeature","container","ListAllLockRecordsUseCase","ListAllLockRecordsRepository"],"mappings":";;;AAIO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,8BAA8B,gBAAgB;IACrE;AACJ"}

package/features/ListAllLockRecords/index.d.ts

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

package/features/ListAllLockRecords/index.js

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

package/features/ListLockRecords/ListLockRecordsRepository.d.ts

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

package/features/ListLockRecords/ListLockRecordsRepository.js

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

package/features/ListLockRecords/ListLockRecordsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListLockRecords/ListLockRecordsRepository.js","sources":["../../../src/features/ListLockRecords/ListLockRecordsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport {\n    ListLockRecordsRepository as RepositoryAbstraction,\n    ListLockRecordsInput,\n    ListLockRecordsOutput\n} from \"./abstractions.js\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/types.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport { convertWhereCondition } from \"~/utils/convertWhereCondition.js\";\n\nclass ListLockRecordsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface\n    ) {}\n\n    async execute(\n        input?: ListLockRecordsInput\n    ): Promise<Result<ListLockRecordsOutput, RepositoryAbstraction.Error>> {\n        try {\n            const params = {\n                ...input,\n                where: this.cmsWhereMapper.map({\n                    input: convertWhereCondition(input?.where),\n                    fields: this.model.fields\n                })\n            };\n\n            const result = await this.listEntries.execute<LockRecordValues>(this.model, params);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const { entries, meta } = result.value;\n\n            const items = entries.map(entry => new LockRecord(entry, this.config.timeout));\n\n            return Result.ok({\n                items,\n                meta\n            });\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const ListLockRecordsRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListLockRecordsRepositoryImpl,\n    dependencies: [\n        RecordLockingModel,\n        RecordLockingConfig,\n        ListLatestEntriesUseCase,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ListLockRecordsRepositoryImpl","model","config","listEntries","cmsWhereMapper","input","params","convertWhereCondition","result","Result","LockRecordPersistenceError","entries","meta","items","entry","LockRecord","error","ListLockRecordsRepository","RepositoryAbstraction","RecordLockingModel","RecordLockingConfig","ListLatestEntriesUseCase","CmsWhereMapper"],"mappings":";;;;;;;;AAcA,MAAMA;IACF,YACYC,KAAmC,EACnCC,MAAqC,EACrCC,WAA+C,EAC/CC,cAAwC,CAClD;aAJUH,KAAK,GAALA;aACAC,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QACFC,KAA4B,EACuC;QACnE,IAAI;YACA,MAAMC,SAAS;gBACX,GAAGD,KAAK;gBACR,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;oBAC3B,OAAOE,sBAAsBF,OAAO;oBACpC,QAAQ,IAAI,CAAC,KAAK,CAAC,MAAM;gBAC7B;YACJ;YAEA,MAAMG,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAmB,IAAI,CAAC,KAAK,EAAEF;YAE5E,IAAIE,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAGlE,MAAM,EAAEG,OAAO,EAAEC,IAAI,EAAE,GAAGJ,OAAO,KAAK;YAEtC,MAAMK,QAAQF,QAAQ,GAAG,CAACG,CAAAA,QAAS,IAAIC,WAAWD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5E,OAAOL,OAAO,EAAE,CAAC;gBACbI;gBACAD;YACJ;QACJ,EAAE,OAAOI,OAAO;YACZ,OAAOP,OAAO,IAAI,CAAC,IAAIC,2BAA2BM;QACtD;IACJ;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAA0C,CAAC;IAChF,gBAAgBlB;IAChB,cAAc;QACVmB;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/ListLockRecords/ListLockRecordsUseCase.d.ts

@@ -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/security/IdentityContext/index.js";
+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,33 @@
+import { ListLockRecordsRepository, ListLockRecordsUseCase } from "./abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { RecordLockingConfig } from "../../domain/abstractions.js";
+class ListLockRecordsUseCaseImpl {
+    constructor(repository, identityContext, config){
+        this.repository = repository;
+        this.identityContext = identityContext;
+        this.config = config;
+    }
+    async execute(input) {
+        const identity = this.identityContext.getIdentity();
+        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);
+    }
+}
+const ListLockRecordsUseCase_ListLockRecordsUseCase = ListLockRecordsUseCase.createImplementation({
+    implementation: ListLockRecordsUseCaseImpl,
+    dependencies: [
+        ListLockRecordsRepository,
+        IdentityContext,
+        RecordLockingConfig
+    ]
+});
+export { ListLockRecordsUseCase_ListLockRecordsUseCase as ListLockRecordsUseCase };
+
+//# sourceMappingURL=ListLockRecordsUseCase.js.map

package/features/ListLockRecords/ListLockRecordsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListLockRecords/ListLockRecordsUseCase.js","sources":["../../../src/features/ListLockRecords/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/security/IdentityContext/index.js\";\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"],"names":["ListLockRecordsUseCaseImpl","repository","identityContext","config","input","identity","enhancedInput","Date","ListLockRecordsUseCase","UseCaseAbstraction","ListLockRecordsRepository","IdentityContext","RecordLockingConfig"],"mappings":";;;AAUA,MAAMA;IACF,YACYC,UAA+C,EAC/CC,eAA0C,EAC1CC,MAAqC,CAC/C;aAHUF,UAAU,GAAVA;aACAC,eAAe,GAAfA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,QACFC,KAA4B,EACoC;QAChE,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QAGjD,MAAMC,gBAAsC;YACxC,GAAGF,KAAK;YACR,OAAO;gBACH,GAAGA,OAAO,KAAK;gBACf,eAAeC,SAAS,EAAE;gBAC1B,aAAa,IAAIE,KAAK,IAAIA,OAAO,OAAO,KAAK,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW;YACjF;QACJ;QAEA,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACD;IACzC;AACJ;AAEO,MAAME,gDAAyBC,uBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBT;IAChB,cAAc;QAACU;QAA2BC;QAAiBC;KAAoB;AACnF"}

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,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ListLockRecordsUseCase = createAbstraction("ListLockRecordsUseCase");
+const ListLockRecordsRepository = createAbstraction("ListLockRecordsRepository");
+export { ListLockRecordsRepository, ListLockRecordsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/ListLockRecords/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListLockRecords/abstractions.js","sources":["../../../src/features/ListLockRecords/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\n        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"],"names":["ListLockRecordsUseCase","createAbstraction","ListLockRecordsRepository"],"mappings":";AA2CO,MAAMA,yBACTC,kBAA2C;AAoBxC,MAAMC,4BAA4BD,kBACrC"}

package/features/ListLockRecords/feature.d.ts

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

package/features/ListLockRecords/feature.js

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

package/features/ListLockRecords/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ListLockRecords/feature.js","sources":["../../../src/features/ListLockRecords/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"],"names":["ListLockRecordsFeature","createFeature","container","ListLockRecordsUseCase","ListLockRecordsRepository"],"mappings":";;;AAIO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,2BAA2B,gBAAgB;IAClE;AACJ"}

package/features/ListLockRecords/index.d.ts

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

package/features/ListLockRecords/index.js

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

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/index.js";
+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/index.js";
+import { EntryAfterLockEvent, EntryBeforeLockEvent, EntryLockErrorEvent } from "./events.js";
+class LockEntryErrorDecoratorImpl {
+    constructor(eventPublisher, decoratee){
+        this.eventPublisher = eventPublisher;
+        this.decoratee = decoratee;
+    }
+    async execute(input) {
+        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;
+        }
+        await this.eventPublisher.publish(new EntryAfterLockEvent({
+            id: input.id,
+            type: input.type,
+            record: result.value
+        }));
+        return result;
+    }
+}
+const LockEntryEventsDecorator = LockEntryUseCase.createDecorator({
+    decorator: LockEntryErrorDecoratorImpl,
+    dependencies: [
+        EventPublisher
+    ]
+});
+export { LockEntryEventsDecorator };
+
+//# sourceMappingURL=LockEntryEventsDecorator.js.map

package/features/LockEntry/LockEntryEventsDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/LockEntry/LockEntryEventsDecorator.js","sources":["../../../src/features/LockEntry/LockEntryEventsDecorator.ts"],"sourcesContent":["import {\n    type LockEntryInput,\n    LockEntryUseCase as UseCaseAbstraction,\n    LockEntryUseCase\n} from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ILockRecord } from \"~/domain/index.js\";\nimport { Result } from \"@webiny/feature/api/index.js\";\nimport { EntryAfterLockEvent, EntryBeforeLockEvent, EntryLockErrorEvent } from \"./events.js\";\n\nclass LockEntryErrorDecoratorImpl implements LockEntryUseCase.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly decoratee: LockEntryUseCase.Interface\n    ) {}\n    async execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Publish before event\n        await this.eventPublisher.publish(\n            new EntryBeforeLockEvent({\n                id: input.id,\n                type: input.type\n            })\n        );\n\n        const result = await this.decoratee.execute(input);\n\n        if (result.isFail()) {\n            const error = result.error;\n\n            await this.eventPublisher.publish(\n                new EntryLockErrorEvent({\n                    id: input.id,\n                    type: input.type,\n                    error\n                })\n            );\n\n            return result;\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new EntryAfterLockEvent({\n                id: input.id,\n                type: input.type,\n                record: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const LockEntryEventsDecorator = LockEntryUseCase.createDecorator({\n    decorator: LockEntryErrorDecoratorImpl,\n    dependencies: [EventPublisher]\n});\n"],"names":["LockEntryErrorDecoratorImpl","eventPublisher","decoratee","input","EntryBeforeLockEvent","result","error","EntryLockErrorEvent","EntryAfterLockEvent","LockEntryEventsDecorator","LockEntryUseCase","EventPublisher"],"mappings":";;;AAUA,MAAMA;IACF,YACqBC,cAAwC,EACxCC,SAAqC,CACxD;aAFmBD,cAAc,GAAdA;aACAC,SAAS,GAATA;IAClB;IACH,MAAM,QAAQC,KAAqB,EAA0D;QAEzF,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,qBAAqB;YACrB,IAAID,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;QACpB;QAGJ,MAAME,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACF;QAE5C,IAAIE,OAAO,MAAM,IAAI;YACjB,MAAMC,QAAQD,OAAO,KAAK;YAE1B,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,oBAAoB;gBACpB,IAAIJ,MAAM,EAAE;gBACZ,MAAMA,MAAM,IAAI;gBAChBG;YACJ;YAGJ,OAAOD;QACX;QAGA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,oBAAoB;YACpB,IAAIL,MAAM,EAAE;YACZ,MAAMA,MAAM,IAAI;YAChB,QAAQE,OAAO,KAAK;QACxB;QAGJ,OAAOA;IACX;AACJ;AAEO,MAAMI,2BAA2BC,iBAAiB,eAAe,CAAC;IACrE,WAAWV;IACX,cAAc;QAACW;KAAe;AAClC"}

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

package/features/LockEntry/LockEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/LockEntry/LockEntryRepository.js","sources":["../../../src/features/LockEntry/LockEntryRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry\";\nimport type { CmsEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport { LockEntryInput, LockEntryRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { RecordLockingConfig, RecordLockingModel } from \"~/domain/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { LockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordValues } from \"~/domain/types.js\";\nimport { LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass LockEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private createEntry: CreateEntryUseCase.Interface\n    ) {}\n\n    async create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const id = createLockRecordDatabaseId(input.id);\n\n            const values: LockRecordValues = {\n                targetId: input.id,\n                type: input.type,\n                actions: []\n            };\n\n            const result = await this.createEntry.execute(this.model, {\n                id,\n                values\n            });\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            const entry = result.value as CmsEntry<LockRecordValues>;\n            const lockRecord = new LockRecord(entry, this.config.timeout);\n\n            return Result.ok(lockRecord);\n        } catch (error) {\n            return Result.fail(new LockRecordPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const LockEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: LockEntryRepositoryImpl,\n    dependencies: [RecordLockingModel, RecordLockingConfig, CreateEntryUseCase]\n});\n"],"names":["LockEntryRepositoryImpl","model","config","createEntry","input","id","createLockRecordDatabaseId","values","result","Result","LockRecordPersistenceError","entry","lockRecord","LockRecord","error","LockEntryRepository","RepositoryAbstraction","RecordLockingModel","RecordLockingConfig","CreateEntryUseCase"],"mappings":";;;;;;;AAWA,MAAMA;IACF,YACYC,KAAmC,EACnCC,MAAqC,EACrCC,WAAyC,CACnD;aAHUF,KAAK,GAALA;aACAC,MAAM,GAANA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAAqB,EAA6D;QAC3F,IAAI;YACA,MAAMC,KAAKC,2BAA2BF,MAAM,EAAE;YAE9C,MAAMG,SAA2B;gBAC7B,UAAUH,MAAM,EAAE;gBAClB,MAAMA,MAAM,IAAI;gBAChB,SAAS,EAAE;YACf;YAEA,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE;gBACtDH;gBACAE;YACJ;YAEA,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2BF,OAAO,KAAK;YAGlE,MAAMG,QAAQH,OAAO,KAAK;YAC1B,MAAMI,aAAa,IAAIC,WAAWF,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;YAE5D,OAAOF,OAAO,EAAE,CAACG;QACrB,EAAE,OAAOE,OAAO;YACZ,OAAOL,OAAO,IAAI,CAAC,IAAIC,2BAA2BI;QACtD;IACJ;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAA0C,CAAC;IAC1E,gBAAgBhB;IAChB,cAAc;QAACiB;QAAoBC;QAAqBC;KAAmB;AAC/E"}

package/features/LockEntry/LockEntryUseCase.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,31 @@
+import { Result } from "@webiny/feature/api";
+import { LockEntryRepository, LockEntryUseCase } from "./abstractions.js";
+import { IsEntryLockedUseCase } from "../IsEntryLocked/abstractions.js";
+import { EntryAlreadyLockedError, LockEntryError } from "../../domain/errors.js";
+class LockEntryUseCaseImpl {
+    constructor(isEntryLocked, repository){
+        this.isEntryLocked = isEntryLocked;
+        this.repository = repository;
+    }
+    async execute(input) {
+        const lockedResult = await this.isEntryLocked.execute(input);
+        if (lockedResult.isFail()) return Result.fail(lockedResult.error);
+        if (lockedResult.value) return Result.fail(new EntryAlreadyLockedError({
+            id: input.id,
+            type: input.type
+        }));
+        const result = await this.repository.create(input);
+        if (result.isFail()) return Result.fail(new LockEntryError(result.error));
+        return Result.ok(result.value);
+    }
+}
+const LockEntryUseCase_LockEntryUseCase = LockEntryUseCase.createImplementation({
+    implementation: LockEntryUseCaseImpl,
+    dependencies: [
+        IsEntryLockedUseCase,
+        LockEntryRepository
+    ]
+});
+export { LockEntryUseCase_LockEntryUseCase as LockEntryUseCase };
+
+//# sourceMappingURL=LockEntryUseCase.js.map

package/features/LockEntry/LockEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/LockEntry/LockEntryUseCase.js","sources":["../../../src/features/LockEntry/LockEntryUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    LockEntryUseCase as UseCaseAbstraction,\n    LockEntryRepository,\n    LockEntryInput\n} from \"./abstractions.js\";\nimport { IsEntryLockedUseCase } from \"../IsEntryLocked/abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport { EntryAlreadyLockedError, LockEntryError } from \"~/domain/errors.js\";\n\nclass LockEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private isEntryLocked: IsEntryLockedUseCase.Interface,\n        private repository: LockEntryRepository.Interface\n    ) {}\n\n    async execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        // Check if entry is already locked\n        const lockedResult = await this.isEntryLocked.execute(input);\n\n        if (lockedResult.isFail()) {\n            return Result.fail(lockedResult.error);\n        }\n\n        if (lockedResult.value) {\n            return Result.fail(new EntryAlreadyLockedError({ id: input.id, type: input.type }));\n        }\n\n        // Create the lock\n        const result = await this.repository.create(input);\n\n        if (result.isFail()) {\n            return Result.fail(new LockEntryError(result.error));\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const LockEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: LockEntryUseCaseImpl,\n    dependencies: [IsEntryLockedUseCase, LockEntryRepository]\n});\n"],"names":["LockEntryUseCaseImpl","isEntryLocked","repository","input","lockedResult","Result","EntryAlreadyLockedError","result","LockEntryError","LockEntryUseCase","UseCaseAbstraction","IsEntryLockedUseCase","LockEntryRepository"],"mappings":";;;;AAUA,MAAMA;IACF,YACYC,aAA6C,EAC7CC,UAAyC,CACnD;aAFUD,aAAa,GAAbA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,KAAqB,EAA0D;QAEzF,MAAMC,eAAe,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAACD;QAEtD,IAAIC,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAACD,aAAa,KAAK;QAGzC,IAAIA,aAAa,KAAK,EAClB,OAAOC,OAAO,IAAI,CAAC,IAAIC,wBAAwB;YAAE,IAAIH,MAAM,EAAE;YAAE,MAAMA,MAAM,IAAI;QAAC;QAIpF,MAAMI,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACJ;QAE5C,IAAII,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAAC,IAAIG,eAAeD,OAAO,KAAK;QAGtD,OAAOF,OAAO,EAAE,CAACE,OAAO,KAAK;IACjC;AACJ;AAEO,MAAME,oCAAmBC,iBAAAA,oBAAuC,CAAC;IACpE,gBAAgBV;IAChB,cAAc;QAACW;QAAsBC;KAAoB;AAC7D"}

package/features/LockEntry/abstractions.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,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const LockEntryUseCase = createAbstraction("LockEntryUseCase");
+const LockEntryRepository = createAbstraction("LockEntryRepository");
+export { LockEntryRepository, LockEntryUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/LockEntry/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/LockEntry/abstractions.js","sources":["../../../src/features/LockEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\nimport type {\n    EntryAlreadyLockedError,\n    LockEntryError,\n    LockRecordPersistenceError\n} from \"~/domain/errors.js\";\n\n// Input types\nexport interface LockEntryInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * LockEntry Use Case - Creates a lock on an entry\n */\nexport interface ILockEntryUseCase {\n    execute(input: LockEntryInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface ILockEntryUseCaseErrors {\n    alreadyLocked: EntryAlreadyLockedError;\n    persistence: LockRecordPersistenceError;\n    lockError: LockEntryError;\n}\n\ntype UseCaseError = ILockEntryUseCaseErrors[keyof ILockEntryUseCaseErrors];\n\nexport const LockEntryUseCase = createAbstraction<ILockEntryUseCase>(\"LockEntryUseCase\");\n\nexport namespace LockEntryUseCase {\n    export type Interface = ILockEntryUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * LockEntryRepository - Creates lock record in storage\n */\nexport interface ILockEntryRepository {\n    create(input: LockEntryInput): Promise<Result<ILockRecord, RepositoryError>>;\n}\n\nexport interface ILockEntryRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError = ILockEntryRepositoryErrors[keyof ILockEntryRepositoryErrors];\n\nexport const LockEntryRepository = createAbstraction<ILockEntryRepository>(\"LockEntryRepository\");\n\nexport namespace LockEntryRepository {\n    export type Interface = ILockEntryRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["LockEntryUseCase","createAbstraction","LockEntryRepository"],"mappings":";AA+BO,MAAMA,mBAAmBC,kBAAqC;AAoB9D,MAAMC,sBAAsBD,kBAAwC"}

package/features/LockEntry/events.d.ts

@@ -0,0 +1,45 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+export interface EntryBeforeLockPayload {
+    id: string;
+    type: LockRecordEntryType;
+}
+export declare class EntryBeforeLockEvent extends DomainEvent<EntryBeforeLockPayload> {
+    eventType: "RecordLocking/Entry/BeforeLock";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryBeforeLockEvent>>;
+}
+export declare const EntryBeforeLockEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryBeforeLockEvent>>;
+export declare namespace EntryBeforeLockEventHandler {
+    type Interface = IEventHandler<EntryBeforeLockEvent>;
+    type Event = EntryBeforeLockEvent;
+}
+export interface EntryAfterLockPayload {
+    id: string;
+    type: LockRecordEntryType;
+    record: ILockRecord;
+}
+export declare class EntryAfterLockEvent extends DomainEvent<EntryAfterLockPayload> {
+    eventType: "RecordLocking/Entry/AfterLock";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryAfterLockEvent>>;
+}
+export declare const EntryAfterLockEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterLockEvent>>;
+export declare namespace EntryAfterLockEventHandler {
+    type Interface = IEventHandler<EntryAfterLockEvent>;
+    type Event = EntryAfterLockEvent;
+}
+export interface EntryLockErrorPayload {
+    id: string;
+    type: LockRecordEntryType;
+    error: Error;
+}
+export declare class EntryLockErrorEvent extends DomainEvent<EntryLockErrorPayload> {
+    eventType: "RecordLocking/Entry/LockError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<EntryLockErrorEvent>>;
+}
+export declare const EntryLockErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryLockErrorEvent>>;
+export declare namespace EntryLockErrorEventHandler {
+    type Interface = IEventHandler<EntryLockErrorEvent>;
+    type Event = EntryLockErrorEvent;
+}