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

package/README.md

@@ -1,10 +1,11 @@
 # @webiny/api-record-locking
-[![](https://img.shields.io/npm/dw/@webiny/api-record-locking.svg)](https://www.npmjs.com/package/@webiny/api-record-locking) 
-[![](https://img.shields.io/npm/v/@webiny/api-record-locking.svg)](https://www.npmjs.com/package/@webiny/api-record-locking)
-[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
-
-## Install
-```
-yarn add @webiny/api-record-locking
-```
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/domain/LockRecord.d.ts

@@ -0,0 +1,45 @@
+import type { CmsEntry } from "@webiny/api-headless-cms/types";
+import type { CmsIdentity } from "@webiny/api-headless-cms/types";
+import type { LockRecordAction, LockRecordApprovedAction, LockRecordDeniedAction, LockRecordEntryType, LockRecordObject, LockRecordRequestedAction, LockRecordValues } from "./types.js";
+export interface ILockRecord {
+    readonly id: string;
+    readonly targetId: string;
+    readonly type: LockRecordEntryType;
+    readonly lockedBy: CmsIdentity;
+    readonly lockedOn: Date;
+    readonly updatedOn: Date;
+    readonly expiresOn: Date;
+    readonly actions?: LockRecordAction[];
+    toObject(): LockRecordObject;
+    addAction(action: LockRecordAction): void;
+    getUnlockRequested(): LockRecordRequestedAction | undefined;
+    getUnlockApproved(): LockRecordApprovedAction | undefined;
+    getUnlockDenied(): LockRecordDeniedAction | undefined;
+    isExpired(): boolean;
+}
+export type LockRecordParams = Pick<CmsEntry<LockRecordValues>, "entryId" | "values" | "createdBy" | "createdOn" | "savedOn">;
+export declare class LockRecord implements ILockRecord {
+    private readonly _id;
+    private readonly _targetId;
+    private readonly _type;
+    private readonly _lockedBy;
+    private readonly _lockedOn;
+    private readonly _updatedOn;
+    private readonly _expiresOn;
+    private _actions?;
+    get id(): string;
+    get targetId(): string;
+    get type(): LockRecordEntryType;
+    get lockedBy(): CmsIdentity;
+    get lockedOn(): Date;
+    get updatedOn(): Date;
+    get expiresOn(): Date;
+    get actions(): LockRecordAction[] | undefined;
+    constructor(input: LockRecordParams, timeout: number);
+    toObject(): LockRecordObject;
+    addAction(action: LockRecordAction): void;
+    getUnlockRequested(): LockRecordRequestedAction | undefined;
+    getUnlockApproved(): LockRecordApprovedAction | undefined;
+    getUnlockDenied(): LockRecordDeniedAction | undefined;
+    isExpired(): boolean;
+}

package/{utils/convertEntryToLockRecord.js → domain/LockRecord.js}

@@ -1,17 +1,7 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.convertEntryToLockRecord = exports.HeadlessCmsLockRecord = void 0;
-var _types = require("../types");
-var _lockRecordDatabaseId = require("./lockRecordDatabaseId");
-var _calculateExpiresOn = require("./calculateExpiresOn");
-const convertEntryToLockRecord = (entry, timeout) => {
-  return new HeadlessCmsLockRecord(entry, timeout);
-};
-exports.convertEntryToLockRecord = convertEntryToLockRecord;
-class HeadlessCmsLockRecord {
+import { RecordLockingLockRecordActionType } from "./types.js";
+import { removeLockRecordDatabasePrefix } from "../utils/lockRecordDatabaseId.js";
+import { calculateExpiresOn } from "./calculateExpiresOn.js";
+export class LockRecord {
   get id() {
     return this._id;
   }
@@ -37,13 +27,13 @@ class HeadlessCmsLockRecord {
     return this._actions;
   }
   constructor(input, timeout) {
-    this._id = (0, _lockRecordDatabaseId.removeLockRecordDatabasePrefix)(input.entryId);
+    this._id = removeLockRecordDatabasePrefix(input.entryId);
     this._targetId = input.values.targetId;
     this._type = input.values.type;
     this._lockedBy = input.createdBy;
     this._lockedOn = new Date(input.createdOn);
     this._updatedOn = new Date(input.savedOn);
-    this._expiresOn = (0, _calculateExpiresOn.calculateExpiresOn)(input, timeout);
+    this._expiresOn = calculateExpiresOn(input.savedOn, timeout);
     this._actions = input.values.actions;
   }
   toObject() {
@@ -68,24 +58,23 @@ class HeadlessCmsLockRecord {
     if (!this._actions?.length) {
       return undefined;
     }
-    return this._actions.find(action => action.type === _types.RecordLockingLockRecordActionType.requested);
+    return this._actions.find(action => action.type === RecordLockingLockRecordActionType.requested);
   }
   getUnlockApproved() {
     if (!this._actions?.length) {
       return undefined;
     }
-    return this._actions.find(action => action.type === _types.RecordLockingLockRecordActionType.approved);
+    return this._actions.find(action => action.type === RecordLockingLockRecordActionType.approved);
   }
   getUnlockDenied() {
     if (!this._actions?.length) {
       return undefined;
     }
-    return this._actions.find(action => action.type === _types.RecordLockingLockRecordActionType.denied);
+    return this._actions.find(action => action.type === RecordLockingLockRecordActionType.denied);
   }
   isExpired() {
     return this._expiresOn.getTime() < new Date().getTime();
   }
 }
-exports.HeadlessCmsLockRecord = HeadlessCmsLockRecord;
 
-//# sourceMappingURL=convertEntryToLockRecord.js.map
+//# sourceMappingURL=LockRecord.js.map

package/domain/LockRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RecordLockingLockRecordActionType","removeLockRecordDatabasePrefix","calculateExpiresOn","LockRecord","id","_id","targetId","_targetId","type","_type","lockedBy","_lockedBy","lockedOn","_lockedOn","updatedOn","_updatedOn","expiresOn","_expiresOn","actions","_actions","constructor","input","timeout","entryId","values","createdBy","Date","createdOn","savedOn","toObject","addAction","action","push","getUnlockRequested","length","undefined","find","requested","getUnlockApproved","approved","getUnlockDenied","denied","isExpired","getTime"],"sources":["LockRecord.ts"],"sourcesContent":["import type { CmsEntry } from \"@webiny/api-headless-cms/types\";\nimport type { CmsIdentity } from \"@webiny/api-headless-cms/types\";\nimport { RecordLockingLockRecordActionType } from \"./types.js\";\nimport type {\n    LockRecordAction,\n    LockRecordApprovedAction,\n    LockRecordDeniedAction,\n    LockRecordEntryType,\n    LockRecordObject,\n    LockRecordRequestedAction,\n    LockRecordValues\n} from \"./types.js\";\nimport { removeLockRecordDatabasePrefix } from \"~/utils/lockRecordDatabaseId.js\";\nimport { calculateExpiresOn } from \"./calculateExpiresOn.js\";\n\nexport interface ILockRecord {\n    readonly id: string;\n    readonly targetId: string;\n    readonly type: LockRecordEntryType;\n    readonly lockedBy: CmsIdentity;\n    readonly lockedOn: Date;\n    readonly updatedOn: Date;\n    readonly expiresOn: Date;\n    readonly actions?: LockRecordAction[];\n\n    toObject(): LockRecordObject;\n    addAction(action: LockRecordAction): void;\n    getUnlockRequested(): LockRecordRequestedAction | undefined;\n    getUnlockApproved(): LockRecordApprovedAction | undefined;\n    getUnlockDenied(): LockRecordDeniedAction | undefined;\n    isExpired(): boolean;\n}\n\nexport type LockRecordParams = Pick<\n    CmsEntry<LockRecordValues>,\n    \"entryId\" | \"values\" | \"createdBy\" | \"createdOn\" | \"savedOn\"\n>;\n\nexport class LockRecord implements ILockRecord {\n    private readonly _id: string;\n    private readonly _targetId: string;\n    private readonly _type: LockRecordEntryType;\n    private readonly _lockedBy: CmsIdentity;\n    private readonly _lockedOn: Date;\n    private readonly _updatedOn: Date;\n    private readonly _expiresOn: Date;\n    private _actions?: LockRecordAction[];\n\n    public get id(): string {\n        return this._id;\n    }\n\n    public get targetId(): string {\n        return this._targetId;\n    }\n\n    public get type(): LockRecordEntryType {\n        return this._type;\n    }\n\n    public get lockedBy(): CmsIdentity {\n        return this._lockedBy;\n    }\n\n    public get lockedOn(): Date {\n        return this._lockedOn;\n    }\n\n    public get updatedOn(): Date {\n        return this._updatedOn;\n    }\n\n    public get expiresOn(): Date {\n        return this._expiresOn;\n    }\n\n    public get actions(): LockRecordAction[] | undefined {\n        return this._actions;\n    }\n\n    public constructor(input: LockRecordParams, timeout: number) {\n        this._id = removeLockRecordDatabasePrefix(input.entryId);\n        this._targetId = input.values.targetId;\n        this._type = input.values.type;\n        this._lockedBy = input.createdBy;\n        this._lockedOn = new Date(input.createdOn);\n        this._updatedOn = new Date(input.savedOn);\n        this._expiresOn = calculateExpiresOn(input.savedOn, timeout);\n        this._actions = input.values.actions;\n    }\n\n    public toObject(): LockRecordObject {\n        return {\n            id: this._id,\n            targetId: this._targetId,\n            type: this._type,\n            lockedBy: this._lockedBy,\n            lockedOn: this._lockedOn,\n            updatedOn: this._updatedOn,\n            expiresOn: this._expiresOn,\n            actions: this._actions\n        };\n    }\n\n    public addAction(action: LockRecordAction): void {\n        if (!this._actions) {\n            this._actions = [];\n        }\n        this._actions.push(action);\n    }\n\n    public getUnlockRequested(): LockRecordRequestedAction | undefined {\n        if (!this._actions?.length) {\n            return undefined;\n        }\n        return this._actions.find(\n            (action): action is LockRecordRequestedAction =>\n                action.type === RecordLockingLockRecordActionType.requested\n        );\n    }\n\n    public getUnlockApproved(): LockRecordApprovedAction | undefined {\n        if (!this._actions?.length) {\n            return undefined;\n        }\n        return this._actions.find(\n            (action): action is LockRecordApprovedAction =>\n                action.type === RecordLockingLockRecordActionType.approved\n        );\n    }\n\n    public getUnlockDenied(): LockRecordDeniedAction | undefined {\n        if (!this._actions?.length) {\n            return undefined;\n        }\n        return this._actions.find(\n            (action): action is LockRecordDeniedAction =>\n                action.type === RecordLockingLockRecordActionType.denied\n        );\n    }\n\n    public isExpired(): boolean {\n        return this._expiresOn.getTime() < new Date().getTime();\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/domain/RecordLockingModel.d.ts

@@ -0,0 +1,9 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+export declare const RECORD_LOCKING_MODEL_ID = "wbyRecordLock";
+declare class RecordLockingPrivateModelImpl implements ModelFactory.Interface {
+    execute(builder: ModelFactory.Builder): Promise<import("@webiny/api-headless-cms/features/modelBuilder/index.js").PrivateModelBuilder[]>;
+}
+export declare const RecordLockingModel: typeof RecordLockingPrivateModelImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/modelBuilder/abstractions").IModelFactory>;
+};
+export {};

package/domain/RecordLockingModel.js

@@ -0,0 +1,29 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+export const RECORD_LOCKING_MODEL_ID = "wbyRecordLock";
+class RecordLockingPrivateModelImpl {
+  async execute(builder) {
+    return [builder.private({
+      modelId: RECORD_LOCKING_MODEL_ID,
+      name: "Record Lock Tracking"
+    }).fields(fields => ({
+      targetId: fields.text().label("Target ID").required("Target ID is required."),
+      type: fields.text().label("Record Type").required("Record type is required."),
+      actions: fields.object().label("Actions").list().fields(fields => ({
+        type: fields.text().label("Action Type").required("Action type is required."),
+        message: fields.text().label("Message"),
+        createdBy: fields.object().label("Created By").required("Created by is required.").fields(fields => ({
+          id: fields.text().label("ID").required("ID is required."),
+          displayName: fields.text().label("Display Name").required("Display name is required."),
+          type: fields.text().label("Type").required("Type is required.")
+        })),
+        createdOn: fields.datetime().label("Created On").required("Created on is required.").withoutTimezone()
+      }))
+    }))];
+  }
+}
+export const RecordLockingModel = ModelFactory.createImplementation({
+  implementation: RecordLockingPrivateModelImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=RecordLockingModel.js.map

package/domain/RecordLockingModel.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ModelFactory","RECORD_LOCKING_MODEL_ID","RecordLockingPrivateModelImpl","execute","builder","private","modelId","name","fields","targetId","text","label","required","type","actions","object","list","message","createdBy","id","displayName","createdOn","datetime","withoutTimezone","RecordLockingModel","createImplementation","implementation","dependencies"],"sources":["RecordLockingModel.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\n\nexport const RECORD_LOCKING_MODEL_ID = \"wbyRecordLock\";\n\nclass RecordLockingPrivateModelImpl implements ModelFactory.Interface {\n    public async execute(builder: ModelFactory.Builder) {\n        return [\n            builder\n                .private({\n                    modelId: RECORD_LOCKING_MODEL_ID,\n                    name: \"Record Lock Tracking\"\n                })\n                .fields(fields => ({\n                    targetId: fields.text().label(\"Target ID\").required(\"Target ID is required.\"),\n                    type: fields.text().label(\"Record Type\").required(\"Record type is required.\"),\n                    actions: fields\n                        .object()\n                        .label(\"Actions\")\n                        .list()\n                        .fields(fields => ({\n                            type: fields\n                                .text()\n                                .label(\"Action Type\")\n                                .required(\"Action type is required.\"),\n                            message: fields.text().label(\"Message\"),\n                            createdBy: fields\n                                .object()\n                                .label(\"Created By\")\n                                .required(\"Created by is required.\")\n                                .fields(fields => ({\n                                    id: fields.text().label(\"ID\").required(\"ID is required.\"),\n                                    displayName: fields\n                                        .text()\n                                        .label(\"Display Name\")\n                                        .required(\"Display name is required.\"),\n                                    type: fields.text().label(\"Type\").required(\"Type is required.\")\n                                })),\n                            createdOn: fields\n                                .datetime()\n                                .label(\"Created On\")\n                                .required(\"Created on is required.\")\n                                .withoutTimezone()\n                        }))\n                }))\n        ];\n    }\n}\n\nexport const RecordLockingModel = ModelFactory.createImplementation({\n    implementation: RecordLockingPrivateModelImpl,\n    dependencies: []\n});\n"],"mappings":"AAAA,SAASA,YAAY,QAAQ,yDAAyD;AAEtF,OAAO,MAAMC,uBAAuB,GAAG,eAAe;AAEtD,MAAMC,6BAA6B,CAAmC;EAClE,MAAaC,OAAOA,CAACC,OAA6B,EAAE;IAChD,OAAO,CACHA,OAAO,CACFC,OAAO,CAAC;MACLC,OAAO,EAAEL,uBAAuB;MAChCM,IAAI,EAAE;IACV,CAAC,CAAC,CACDC,MAAM,CAACA,MAAM,KAAK;MACfC,QAAQ,EAAED,MAAM,CAACE,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,WAAW,CAAC,CAACC,QAAQ,CAAC,wBAAwB,CAAC;MAC7EC,IAAI,EAAEL,MAAM,CAACE,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,aAAa,CAAC,CAACC,QAAQ,CAAC,0BAA0B,CAAC;MAC7EE,OAAO,EAAEN,MAAM,CACVO,MAAM,CAAC,CAAC,CACRJ,KAAK,CAAC,SAAS,CAAC,CAChBK,IAAI,CAAC,CAAC,CACNR,MAAM,CAACA,MAAM,KAAK;QACfK,IAAI,EAAEL,MAAM,CACPE,IAAI,CAAC,CAAC,CACNC,KAAK,CAAC,aAAa,CAAC,CACpBC,QAAQ,CAAC,0BAA0B,CAAC;QACzCK,OAAO,EAAET,MAAM,CAACE,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,SAAS,CAAC;QACvCO,SAAS,EAAEV,MAAM,CACZO,MAAM,CAAC,CAAC,CACRJ,KAAK,CAAC,YAAY,CAAC,CACnBC,QAAQ,CAAC,yBAAyB,CAAC,CACnCJ,MAAM,CAACA,MAAM,KAAK;UACfW,EAAE,EAAEX,MAAM,CAACE,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,IAAI,CAAC,CAACC,QAAQ,CAAC,iBAAiB,CAAC;UACzDQ,WAAW,EAAEZ,MAAM,CACdE,IAAI,CAAC,CAAC,CACNC,KAAK,CAAC,cAAc,CAAC,CACrBC,QAAQ,CAAC,2BAA2B,CAAC;UAC1CC,IAAI,EAAEL,MAAM,CAACE,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,MAAM,CAAC,CAACC,QAAQ,CAAC,mBAAmB;QAClE,CAAC,CAAC,CAAC;QACPS,SAAS,EAAEb,MAAM,CACZc,QAAQ,CAAC,CAAC,CACVX,KAAK,CAAC,YAAY,CAAC,CACnBC,QAAQ,CAAC,yBAAyB,CAAC,CACnCW,eAAe,CAAC;MACzB,CAAC,CAAC;IACV,CAAC,CAAC,CAAC,CACV;EACL;AACJ;AAEA,OAAO,MAAMC,kBAAkB,GAAGxB,YAAY,CAACyB,oBAAoB,CAAC;EAChEC,cAAc,EAAExB,6BAA6B;EAC7CyB,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

package/domain/abstractions.d.ts

@@ -0,0 +1,18 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+/**
+ * RecordLockingConfig - Configuration for record locking timeout
+ */
+export interface IRecordLockingConfig {
+    /**
+     * Timeout in milliseconds after which a lock expires
+     */
+    timeout: number;
+}
+export declare const RecordLockingConfig: import("@webiny/di").Abstraction<IRecordLockingConfig>;
+export declare namespace RecordLockingConfig {
+    type Interface = IRecordLockingConfig;
+}
+export declare const RecordLockingModel: import("@webiny/di").Abstraction<CmsModel>;
+export declare namespace RecordLockingModel {
+    type Interface = CmsModel;
+}

package/domain/abstractions.js

@@ -0,0 +1,10 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * RecordLockingConfig - Configuration for record locking timeout
+ */
+
+export const RecordLockingConfig = createAbstraction("RecordLockingConfig");
+export const RecordLockingModel = createAbstraction("RecordLockingModel");
+
+//# sourceMappingURL=abstractions.js.map

package/domain/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","RecordLockingConfig","RecordLockingModel"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\n/**\n * RecordLockingConfig - Configuration for record locking timeout\n */\nexport interface IRecordLockingConfig {\n    /**\n     * Timeout in milliseconds after which a lock expires\n     */\n    timeout: number;\n}\n\nexport const RecordLockingConfig = createAbstraction<IRecordLockingConfig>(\"RecordLockingConfig\");\n\nexport namespace RecordLockingConfig {\n    export type Interface = IRecordLockingConfig;\n}\n\nexport const RecordLockingModel = createAbstraction<CmsModel>(\"RecordLockingModel\");\n\nexport namespace RecordLockingModel {\n    export type Interface = CmsModel;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAGvD;AACA;AACA;;AAQA,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC;AAMjG,OAAO,MAAME,kBAAkB,GAAGF,iBAAiB,CAAW,oBAAoB,CAAC","ignoreList":[]}

package/domain/calculateExpiresOn.d.ts

@@ -0,0 +1 @@
+export declare const calculateExpiresOn: (savedOn: string | undefined, timeout: number) => Date;

package/domain/calculateExpiresOn.js

@@ -0,0 +1,9 @@
+export const calculateExpiresOn = (savedOn, timeout) => {
+  if (!savedOn) {
+    throw new Error("Missing savedOn property.");
+  }
+  const savedOnDate = new Date(savedOn);
+  return new Date(savedOnDate.getTime() + timeout);
+};
+
+//# sourceMappingURL=calculateExpiresOn.js.map

package/domain/calculateExpiresOn.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["calculateExpiresOn","savedOn","timeout","Error","savedOnDate","Date","getTime"],"sources":["calculateExpiresOn.ts"],"sourcesContent":["export const calculateExpiresOn = (savedOn: string | undefined, timeout: number): Date => {\n    if (!savedOn) {\n        throw new Error(\"Missing savedOn property.\");\n    }\n    const savedOnDate = new Date(savedOn);\n\n    return new Date(savedOnDate.getTime() + timeout);\n};\n"],"mappings":"AAAA,OAAO,MAAMA,kBAAkB,GAAGA,CAACC,OAA2B,EAAEC,OAAe,KAAW;EACtF,IAAI,CAACD,OAAO,EAAE;IACV,MAAM,IAAIE,KAAK,CAAC,2BAA2B,CAAC;EAChD;EACA,MAAMC,WAAW,GAAG,IAAIC,IAAI,CAACJ,OAAO,CAAC;EAErC,OAAO,IAAII,IAAI,CAACD,WAAW,CAACE,OAAO,CAAC,CAAC,GAAGJ,OAAO,CAAC;AACpD,CAAC","ignoreList":[]}

package/domain/errors.d.ts

@@ -0,0 +1,71 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class EntryAlreadyLockedError extends BaseError<{
+    id: string;
+    type: string;
+}> {
+    readonly code: "RecordLocking/Entry/AlreadyLockedError";
+    constructor(data: {
+        id: string;
+        type: string;
+    });
+}
+export declare class LockRecordNotFoundError extends BaseError {
+    readonly code: "RecordLocking/LockRecord/NotFoundError";
+    constructor();
+}
+export declare class LockRecordPersistenceError extends BaseError {
+    readonly code: "RecordLocking/LockRecord/PersistenceError";
+    constructor(error: Error);
+}
+export declare class IdentityMismatchError extends BaseError<{
+    currentId: string;
+    targetId: string;
+}> {
+    readonly code: "RecordLocking/Identity/MismatchError";
+    constructor(data: {
+        currentId: string;
+        targetId: string;
+    });
+}
+export declare class UnlockEntryError extends BaseError {
+    readonly code: "RecordLocking/Entry/UnlockError";
+    constructor(error: Error);
+}
+export declare class LockEntryError extends BaseError {
+    readonly code: "RecordLocking/Entry/LockError";
+    constructor(error: Error);
+}
+export declare class UpdateEntryLockError extends BaseError {
+    readonly code: "RecordLocking/Entry/UpdateLockError";
+    constructor(error: Error);
+}
+export declare class IdentityMissingError extends BaseError {
+    readonly code: "RecordLocking/Identity/MissingError";
+    constructor();
+}
+export declare class EntryNotLockedError extends BaseError<{
+    id: string;
+    type: string;
+}> {
+    readonly code: "RecordLocking/Entry/NotLockedError";
+    constructor(data: {
+        id: string;
+        type: string;
+    });
+}
+export declare class UnlockRequestAlreadySentError extends BaseError<{
+    id: string;
+    type: string;
+    identityId: string;
+}> {
+    readonly code: "RecordLocking/Entry/UnlockRequestAlreadySentError";
+    constructor(data: {
+        id: string;
+        type: string;
+        identityId: string;
+    });
+}
+export declare class UnlockEntryRequestError extends BaseError {
+    readonly code: "RecordLocking/Entry/UnlockRequestError";
+    constructor(error: Error);
+}

package/domain/errors.js

@@ -0,0 +1,95 @@
+import { BaseError } from "@webiny/feature/api";
+export class EntryAlreadyLockedError extends BaseError {
+  code = "RecordLocking/Entry/AlreadyLockedError";
+  constructor(data) {
+    super({
+      message: "Entry is already locked for editing.",
+      data
+    });
+  }
+}
+export class LockRecordNotFoundError extends BaseError {
+  code = "RecordLocking/LockRecord/NotFoundError";
+  constructor() {
+    super({
+      message: "Lock record not found."
+    });
+  }
+}
+export class LockRecordPersistenceError extends BaseError {
+  code = "RecordLocking/LockRecord/PersistenceError";
+  constructor(error) {
+    super({
+      message: error.message
+    });
+  }
+}
+export class IdentityMismatchError extends BaseError {
+  code = "RecordLocking/Identity/MismatchError";
+  constructor(data) {
+    super({
+      message: "Identity mismatch - cannot perform action.",
+      data
+    });
+  }
+}
+export class UnlockEntryError extends BaseError {
+  code = "RecordLocking/Entry/UnlockError";
+  constructor(error) {
+    super({
+      message: `Could not unlock entry: ${error.message}`
+    });
+  }
+}
+export class LockEntryError extends BaseError {
+  code = "RecordLocking/Entry/LockError";
+  constructor(error) {
+    super({
+      message: `Could not lock entry: ${error.message}`
+    });
+  }
+}
+export class UpdateEntryLockError extends BaseError {
+  code = "RecordLocking/Entry/UpdateLockError";
+  constructor(error) {
+    super({
+      message: `Could not update entry lock: ${error.message}`
+    });
+  }
+}
+export class IdentityMissingError extends BaseError {
+  code = "RecordLocking/Identity/MissingError";
+  constructor() {
+    super({
+      message: "Identity is missing."
+    });
+  }
+}
+export class EntryNotLockedError extends BaseError {
+  code = "RecordLocking/Entry/NotLockedError";
+  constructor(data) {
+    super({
+      message: "Entry is not locked.",
+      data
+    });
+  }
+}
+export class UnlockRequestAlreadySentError extends BaseError {
+  code = "RecordLocking/Entry/UnlockRequestAlreadySentError";
+  constructor(data) {
+    super({
+      message: "Unlock request already sent.",
+      data
+    });
+  }
+}
+export class UnlockEntryRequestError extends BaseError {
+  code = "RecordLocking/Entry/UnlockRequestError";
+  constructor(error) {
+    super({
+      message: `Could not request unlock: ${error.message}`
+    });
+  }
+}
+
+//# sourceMappingURL=errors.js.map

package/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseError","EntryAlreadyLockedError","code","constructor","data","message","LockRecordNotFoundError","LockRecordPersistenceError","error","IdentityMismatchError","UnlockEntryError","LockEntryError","UpdateEntryLockError","IdentityMissingError","EntryNotLockedError","UnlockRequestAlreadySentError","UnlockEntryRequestError"],"sources":["errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class EntryAlreadyLockedError extends BaseError<{ id: string; type: string }> {\n    override readonly code = \"RecordLocking/Entry/AlreadyLockedError\" as const;\n\n    constructor(data: { id: string; type: string }) {\n        super({\n            message: \"Entry is already locked for editing.\",\n            data\n        });\n    }\n}\n\nexport class LockRecordNotFoundError extends BaseError {\n    override readonly code = \"RecordLocking/LockRecord/NotFoundError\" as const;\n\n    constructor() {\n        super({\n            message: \"Lock record not found.\"\n        });\n    }\n}\n\nexport class LockRecordPersistenceError extends BaseError {\n    override readonly code = \"RecordLocking/LockRecord/PersistenceError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: error.message\n        });\n    }\n}\n\nexport class IdentityMismatchError extends BaseError<{ currentId: string; targetId: string }> {\n    override readonly code = \"RecordLocking/Identity/MismatchError\" as const;\n\n    constructor(data: { currentId: string; targetId: string }) {\n        super({\n            message: \"Identity mismatch - cannot perform action.\",\n            data\n        });\n    }\n}\n\nexport class UnlockEntryError extends BaseError {\n    override readonly code = \"RecordLocking/Entry/UnlockError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: `Could not unlock entry: ${error.message}`\n        });\n    }\n}\n\nexport class LockEntryError extends BaseError {\n    override readonly code = \"RecordLocking/Entry/LockError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: `Could not lock entry: ${error.message}`\n        });\n    }\n}\n\nexport class UpdateEntryLockError extends BaseError {\n    override readonly code = \"RecordLocking/Entry/UpdateLockError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: `Could not update entry lock: ${error.message}`\n        });\n    }\n}\n\nexport class IdentityMissingError extends BaseError {\n    override readonly code = \"RecordLocking/Identity/MissingError\" as const;\n\n    constructor() {\n        super({\n            message: \"Identity is missing.\"\n        });\n    }\n}\n\nexport class EntryNotLockedError extends BaseError<{ id: string; type: string }> {\n    override readonly code = \"RecordLocking/Entry/NotLockedError\" as const;\n\n    constructor(data: { id: string; type: string }) {\n        super({\n            message: \"Entry is not locked.\",\n            data\n        });\n    }\n}\n\nexport class UnlockRequestAlreadySentError extends BaseError<{\n    id: string;\n    type: string;\n    identityId: string;\n}> {\n    override readonly code = \"RecordLocking/Entry/UnlockRequestAlreadySentError\" as const;\n\n    constructor(data: { id: string; type: string; identityId: string }) {\n        super({\n            message: \"Unlock request already sent.\",\n            data\n        });\n    }\n}\n\nexport class UnlockEntryRequestError extends BaseError {\n    override readonly code = \"RecordLocking/Entry/UnlockRequestError\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: `Could not request unlock: ${error.message}`\n        });\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,qBAAqB;AAE/C,OAAO,MAAMC,uBAAuB,SAASD,SAAS,CAA+B;EAC/DE,IAAI,GAAG,wCAAwC;EAEjEC,WAAWA,CAACC,IAAkC,EAAE;IAC5C,KAAK,CAAC;MACFC,OAAO,EAAE,sCAAsC;MAC/CD;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAME,uBAAuB,SAASN,SAAS,CAAC;EACjCE,IAAI,GAAG,wCAAwC;EAEjEC,WAAWA,CAAA,EAAG;IACV,KAAK,CAAC;MACFE,OAAO,EAAE;IACb,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAME,0BAA0B,SAASP,SAAS,CAAC;EACpCE,IAAI,GAAG,2CAA2C;EAEpEC,WAAWA,CAACK,KAAY,EAAE;IACtB,KAAK,CAAC;MACFH,OAAO,EAAEG,KAAK,CAACH;IACnB,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMI,qBAAqB,SAAST,SAAS,CAA0C;EACxEE,IAAI,GAAG,sCAAsC;EAE/DC,WAAWA,CAACC,IAA6C,EAAE;IACvD,KAAK,CAAC;MACFC,OAAO,EAAE,4CAA4C;MACrDD;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMM,gBAAgB,SAASV,SAAS,CAAC;EAC1BE,IAAI,GAAG,iCAAiC;EAE1DC,WAAWA,CAACK,KAAY,EAAE;IACtB,KAAK,CAAC;MACFH,OAAO,EAAE,2BAA2BG,KAAK,CAACH,OAAO;IACrD,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMM,cAAc,SAASX,SAAS,CAAC;EACxBE,IAAI,GAAG,+BAA+B;EAExDC,WAAWA,CAACK,KAAY,EAAE;IACtB,KAAK,CAAC;MACFH,OAAO,EAAE,yBAAyBG,KAAK,CAACH,OAAO;IACnD,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMO,oBAAoB,SAASZ,SAAS,CAAC;EAC9BE,IAAI,GAAG,qCAAqC;EAE9DC,WAAWA,CAACK,KAAY,EAAE;IACtB,KAAK,CAAC;MACFH,OAAO,EAAE,gCAAgCG,KAAK,CAACH,OAAO;IAC1D,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMQ,oBAAoB,SAASb,SAAS,CAAC;EAC9BE,IAAI,GAAG,qCAAqC;EAE9DC,WAAWA,CAAA,EAAG;IACV,KAAK,CAAC;MACFE,OAAO,EAAE;IACb,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMS,mBAAmB,SAASd,SAAS,CAA+B;EAC3DE,IAAI,GAAG,oCAAoC;EAE7DC,WAAWA,CAACC,IAAkC,EAAE;IAC5C,KAAK,CAAC;MACFC,OAAO,EAAE,sBAAsB;MAC/BD;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMW,6BAA6B,SAASf,SAAS,CAIzD;EACmBE,IAAI,GAAG,mDAAmD;EAE5EC,WAAWA,CAACC,IAAsD,EAAE;IAChE,KAAK,CAAC;MACFC,OAAO,EAAE,8BAA8B;MACvCD;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMY,uBAAuB,SAAShB,SAAS,CAAC;EACjCE,IAAI,GAAG,wCAAwC;EAEjEC,WAAWA,CAACK,KAAY,EAAE;IACtB,KAAK,CAAC;MACFH,OAAO,EAAE,6BAA6BG,KAAK,CAACH,OAAO;IACvD,CAAC,CAAC;EACN;AACJ","ignoreList":[]}

package/domain/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./errors.js";
+export * from "./LockRecord.js";
+export * from "./types.js";

package/domain/index.js

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

package/domain/index.js.map

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

package/domain/types.d.ts

@@ -0,0 +1,44 @@
+import type { CmsIdentity } from "@webiny/api-headless-cms/types";
+/**
+ * Do not use any special chars other than #, as we use this to create lock record IDs.
+ */
+export type LockRecordEntryType = string;
+export declare enum RecordLockingLockRecordActionType {
+    requested = "requested",
+    approved = "approved",
+    denied = "denied"
+}
+export interface LockRecordRequestedAction {
+    type: RecordLockingLockRecordActionType.requested;
+    message?: string;
+    createdOn: Date;
+    createdBy: CmsIdentity;
+}
+export interface LockRecordApprovedAction {
+    type: RecordLockingLockRecordActionType.approved;
+    message?: string;
+    createdOn: Date;
+    createdBy: CmsIdentity;
+}
+export interface LockRecordDeniedAction {
+    type: RecordLockingLockRecordActionType.denied;
+    message?: string;
+    createdOn: Date;
+    createdBy: CmsIdentity;
+}
+export type LockRecordAction = LockRecordRequestedAction | LockRecordApprovedAction | LockRecordDeniedAction;
+export interface LockRecordValues {
+    targetId: string;
+    type: LockRecordEntryType;
+    actions?: LockRecordAction[];
+}
+export interface LockRecordObject {
+    id: string;
+    targetId: string;
+    type: LockRecordEntryType;
+    lockedBy: CmsIdentity;
+    lockedOn: Date;
+    updatedOn: Date;
+    expiresOn: Date;
+    actions?: LockRecordAction[];
+}

package/domain/types.js

@@ -0,0 +1,12 @@
+/**
+ * Do not use any special chars other than #, as we use this to create lock record IDs.
+ */
+
+export let RecordLockingLockRecordActionType = /*#__PURE__*/function (RecordLockingLockRecordActionType) {
+  RecordLockingLockRecordActionType["requested"] = "requested";
+  RecordLockingLockRecordActionType["approved"] = "approved";
+  RecordLockingLockRecordActionType["denied"] = "denied";
+  return RecordLockingLockRecordActionType;
+}({});
+
+//# sourceMappingURL=types.js.map

package/domain/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RecordLockingLockRecordActionType"],"sources":["types.ts"],"sourcesContent":["import type { CmsIdentity } from \"@webiny/api-headless-cms/types\";\n\n/**\n * Do not use any special chars other than #, as we use this to create lock record IDs.\n */\nexport type LockRecordEntryType = string;\n\nexport enum RecordLockingLockRecordActionType {\n    requested = \"requested\",\n    approved = \"approved\",\n    denied = \"denied\"\n}\n\nexport interface LockRecordRequestedAction {\n    type: RecordLockingLockRecordActionType.requested;\n    message?: string;\n    createdOn: Date;\n    createdBy: CmsIdentity;\n}\n\nexport interface LockRecordApprovedAction {\n    type: RecordLockingLockRecordActionType.approved;\n    message?: string;\n    createdOn: Date;\n    createdBy: CmsIdentity;\n}\n\nexport interface LockRecordDeniedAction {\n    type: RecordLockingLockRecordActionType.denied;\n    message?: string;\n    createdOn: Date;\n    createdBy: CmsIdentity;\n}\n\nexport type LockRecordAction =\n    | LockRecordRequestedAction\n    | LockRecordApprovedAction\n    | LockRecordDeniedAction;\n\nexport interface LockRecordValues {\n    targetId: string;\n    type: LockRecordEntryType;\n    actions?: LockRecordAction[];\n}\n\nexport interface LockRecordObject {\n    id: string;\n    targetId: string;\n    type: LockRecordEntryType;\n    lockedBy: CmsIdentity;\n    lockedOn: Date;\n    updatedOn: Date;\n    expiresOn: Date;\n    actions?: LockRecordAction[];\n}\n"],"mappings":"AAEA;AACA;AACA;;AAGA,WAAYA,iCAAiC,0BAAjCA,iCAAiC;EAAjCA,iCAAiC;EAAjCA,iCAAiC;EAAjCA,iCAAiC;EAAA,OAAjCA,iCAAiC;AAAA","ignoreList":[]}

package/features/GetLockRecord/GetLockRecordRepository.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "@webiny/feature/api";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { GetLockRecordRepository as RepositoryAbstraction } from "./abstractions.js";
+import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class GetLockRecordRepositoryImpl implements RepositoryAbstraction.Interface {
+    private model;
+    private config;
+    private getEntryById;
+    constructor(model: RecordLockingModel.Interface, config: RecordLockingConfig.Interface, getEntryById: GetEntryByIdUseCase.Interface);
+    get(id: string): Promise<Result<ILockRecord, RepositoryAbstraction.Error>>;
+}
+export declare const GetLockRecordRepository: typeof GetLockRecordRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetLockRecordRepository>;
+};
+export {};

package/features/GetLockRecord/GetLockRecordRepository.js

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { createIdentifier } from "@webiny/utils";
+import { GetLockRecordRepository as RepositoryAbstraction } from "./abstractions.js";
+import { RecordLockingConfig, RecordLockingModel } from "../../domain/abstractions.js";
+import { LockRecord } from "../../domain/LockRecord.js";
+import { LockRecordNotFoundError, LockRecordPersistenceError } from "../../domain/errors.js";
+import { createLockRecordDatabaseId } from "../../utils/lockRecordDatabaseId.js";
+class GetLockRecordRepositoryImpl {
+  constructor(model, config, getEntryById) {
+    this.model = model;
+    this.config = config;
+    this.getEntryById = getEntryById;
+  }
+  async get(id) {
+    const recordId = createLockRecordDatabaseId(id);
+    const entryId = createIdentifier({
+      id: recordId,
+      version: 1
+    });
+    const result = await this.getEntryById.execute(this.model, entryId);
+    if (result.isFail()) {
+      if (result.error.code === "Cms/Entry/NotFound") {
+        return Result.fail(new LockRecordNotFoundError());
+      }
+      return Result.fail(new LockRecordPersistenceError(result.error));
+    }
+    const entry = result.value;
+    return Result.ok(new LockRecord(entry, this.config.timeout));
+  }
+}
+export const GetLockRecordRepository = RepositoryAbstraction.createImplementation({
+  implementation: GetLockRecordRepositoryImpl,
+  dependencies: [RecordLockingModel, RecordLockingConfig, GetEntryByIdUseCase]
+});
+
+//# sourceMappingURL=GetLockRecordRepository.js.map

package/features/GetLockRecord/GetLockRecordRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetEntryByIdUseCase","createIdentifier","GetLockRecordRepository","RepositoryAbstraction","RecordLockingConfig","RecordLockingModel","LockRecord","LockRecordNotFoundError","LockRecordPersistenceError","createLockRecordDatabaseId","GetLockRecordRepositoryImpl","constructor","model","config","getEntryById","get","id","recordId","entryId","version","result","execute","isFail","error","code","fail","entry","value","ok","timeout","createImplementation","implementation","dependencies"],"sources":["GetLockRecordRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { GetLockRecordRepository 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 { LockRecordNotFoundError, LockRecordPersistenceError } from \"~/domain/errors.js\";\nimport { createLockRecordDatabaseId } from \"~/utils/lockRecordDatabaseId.js\";\n\nclass GetLockRecordRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async get(id: string): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        const recordId = createLockRecordDatabaseId(id);\n        const entryId = createIdentifier({\n            id: recordId,\n            version: 1\n        });\n\n        const result = await this.getEntryById.execute<LockRecordValues>(this.model, entryId);\n\n        if (result.isFail()) {\n            if (result.error.code === \"Cms/Entry/NotFound\") {\n                return Result.fail(new LockRecordNotFoundError());\n            }\n\n            return Result.fail(new LockRecordPersistenceError(result.error));\n        }\n\n        const entry = result.value;\n\n        return Result.ok(new LockRecord(entry, this.config.timeout));\n    }\n}\n\nexport const GetLockRecordRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetLockRecordRepositoryImpl,\n    dependencies: [RecordLockingModel, RecordLockingConfig, GetEntryByIdUseCase]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,mBAAmB,QAAQ,6DAA6D;AACjG,SAASC,gBAAgB,QAAQ,eAAe;AAChD,SAASC,uBAAuB,IAAIC,qBAAqB;AACzD,SAASC,mBAAmB,EAAEC,kBAAkB;AAEhD,SAASC,UAAU;AAEnB,SAASC,uBAAuB,EAAEC,0BAA0B;AAC5D,SAASC,0BAA0B;AAEnC,MAAMC,2BAA2B,CAA4C;EACzEC,WAAWA,CACCC,KAAmC,EACnCC,MAAqC,EACrCC,YAA2C,EACrD;IAAA,KAHUF,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;IAAA,KACrCC,YAA2C,GAA3CA,YAA2C;EACpD;EAEH,MAAMC,GAAGA,CAACC,EAAU,EAA6D;IAC7E,MAAMC,QAAQ,GAAGR,0BAA0B,CAACO,EAAE,CAAC;IAC/C,MAAME,OAAO,GAAGjB,gBAAgB,CAAC;MAC7Be,EAAE,EAAEC,QAAQ;MACZE,OAAO,EAAE;IACb,CAAC,CAAC;IAEF,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,YAAY,CAACO,OAAO,CAAmB,IAAI,CAACT,KAAK,EAAEM,OAAO,CAAC;IAErF,IAAIE,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;MACjB,IAAIF,MAAM,CAACG,KAAK,CAACC,IAAI,KAAK,oBAAoB,EAAE;QAC5C,OAAOzB,MAAM,CAAC0B,IAAI,CAAC,IAAIlB,uBAAuB,CAAC,CAAC,CAAC;MACrD;MAEA,OAAOR,MAAM,CAAC0B,IAAI,CAAC,IAAIjB,0BAA0B,CAACY,MAAM,CAACG,KAAK,CAAC,CAAC;IACpE;IAEA,MAAMG,KAAK,GAAGN,MAAM,CAACO,KAAK;IAE1B,OAAO5B,MAAM,CAAC6B,EAAE,CAAC,IAAItB,UAAU,CAACoB,KAAK,EAAE,IAAI,CAACb,MAAM,CAACgB,OAAO,CAAC,CAAC;EAChE;AACJ;AAEA,OAAO,MAAM3B,uBAAuB,GAAGC,qBAAqB,CAAC2B,oBAAoB,CAAC;EAC9EC,cAAc,EAAErB,2BAA2B;EAC3CsB,YAAY,EAAE,CAAC3B,kBAAkB,EAAED,mBAAmB,EAAEJ,mBAAmB;AAC/E,CAAC,CAAC","ignoreList":[]}

package/features/GetLockRecord/GetLockRecordUseCase.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { GetLockRecordUseCase as UseCaseAbstraction, GetLockRecordRepository, GetLockRecordInput } from "./abstractions.js";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class GetLockRecordUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetLockRecordRepository.Interface);
+    execute(input: GetLockRecordInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const GetLockRecordUseCase: typeof GetLockRecordUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetLockRecordUseCase>;
+};
+export {};

package/features/GetLockRecord/GetLockRecordUseCase.js

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

package/features/GetLockRecord/GetLockRecordUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetLockRecordUseCase","UseCaseAbstraction","GetLockRecordRepository","GetLockRecordUseCaseImpl","constructor","repository","execute","input","get","id","createImplementation","implementation","dependencies"],"sources":["GetLockRecordUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetLockRecordUseCase as UseCaseAbstraction,\n    GetLockRecordRepository,\n    GetLockRecordInput\n} from \"./abstractions.js\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\n\nclass GetLockRecordUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetLockRecordRepository.Interface) {}\n\n    async execute(\n        input: GetLockRecordInput\n    ): Promise<Result<ILockRecord, UseCaseAbstraction.Error>> {\n        return await this.repository.get(input.id);\n    }\n}\n\nexport const GetLockRecordUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetLockRecordUseCaseImpl,\n    dependencies: [GetLockRecordRepository]\n});\n"],"mappings":"AACA,SACIA,oBAAoB,IAAIC,kBAAkB,EAC1CC,uBAAuB;AAK3B,MAAMC,wBAAwB,CAAyC;EACnEC,WAAWA,CAASC,UAA6C,EAAE;IAAA,KAA/CA,UAA6C,GAA7CA,UAA6C;EAAG;EAEpE,MAAMC,OAAOA,CACTC,KAAyB,EAC6B;IACtD,OAAO,MAAM,IAAI,CAACF,UAAU,CAACG,GAAG,CAACD,KAAK,CAACE,EAAE,CAAC;EAC9C;AACJ;AAEA,OAAO,MAAMT,oBAAoB,GAAGC,kBAAkB,CAACS,oBAAoB,CAAC;EACxEC,cAAc,EAAER,wBAAwB;EACxCS,YAAY,EAAE,CAACV,uBAAuB;AAC1C,CAAC,CAAC","ignoreList":[]}