@webiny/api-record-locking 6.3.0-beta.4 → 6.4.0-beta.0

package/features/UpdateEntryLock/UpdateEntryLockUseCase.js

@@ -1,62 +1,51 @@
 import { Result } from "@webiny/feature/api";
-import { UpdateEntryLockUseCase as UseCaseAbstraction, UpdateEntryLockRepository } from "./abstractions.js";
+import { UpdateEntryLockRepository, UpdateEntryLockUseCase } from "./abstractions.js";
 import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
 import { LockEntryUseCase } from "../LockEntry/abstractions.js";
 import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
-import { LockRecordNotFoundError, IdentityMismatchError, UpdateEntryLockError } from "../../domain/errors.js";
+import { IdentityMismatchError, LockRecordNotFoundError, UpdateEntryLockError } from "../../domain/errors.js";
 class UpdateEntryLockUseCaseImpl {
-  constructor(getLockRecord, lockEntry, repository, identityContext) {
-    this.getLockRecord = getLockRecord;
-    this.lockEntry = lockEntry;
-    this.repository = repository;
-    this.identityContext = identityContext;
-  }
-  async execute(input) {
-    // Try to get existing lock record
-    const recordResult = await this.getLockRecord.execute(input);
-
-    // If doesn't exist, create a new lock
-    if (recordResult.isFail()) {
-      if (recordResult.error instanceof LockRecordNotFoundError) {
-        const lockResult = await this.lockEntry.execute(input);
-        if (lockResult.isFail()) {
-          return Result.fail(new UpdateEntryLockError(lockResult.error));
-        }
-        return Result.ok(lockResult.value);
-      }
-      return Result.fail(recordResult.error);
+    constructor(getLockRecord, lockEntry, repository, identityContext){
+        this.getLockRecord = getLockRecord;
+        this.lockEntry = lockEntry;
+        this.repository = repository;
+        this.identityContext = identityContext;
     }
-    const record = recordResult.value;
-
-    // If expired, update with current user as new owner
-    if (record.isExpired()) {
-      const updateResult = await this.repository.update(record.id, true);
-      if (updateResult.isFail()) {
-        return Result.fail(new UpdateEntryLockError(updateResult.error));
-      }
-      return Result.ok(updateResult.value);
-    }
-
-    // If not expired, validate same owner
-    const identity = this.identityContext.getIdentity();
-    if (record.lockedBy.id !== identity.id) {
-      return Result.fail(new IdentityMismatchError({
-        currentId: identity.id,
-        targetId: record.lockedBy.id
-      }));
-    }
-
-    // Update timestamp only
-    const updateResult = await this.repository.update(record.id, false);
-    if (updateResult.isFail()) {
-      return Result.fail(new UpdateEntryLockError(updateResult.error));
+    async execute(input) {
+        const recordResult = await this.getLockRecord.execute(input);
+        if (recordResult.isFail()) {
+            if (recordResult.error instanceof LockRecordNotFoundError) {
+                const lockResult = await this.lockEntry.execute(input);
+                if (lockResult.isFail()) return Result.fail(new UpdateEntryLockError(lockResult.error));
+                return Result.ok(lockResult.value);
+            }
+            return Result.fail(recordResult.error);
+        }
+        const record = recordResult.value;
+        if (record.isExpired()) {
+            const updateResult = await this.repository.update(record.id, true);
+            if (updateResult.isFail()) return Result.fail(new UpdateEntryLockError(updateResult.error));
+            return Result.ok(updateResult.value);
+        }
+        const identity = this.identityContext.getIdentity();
+        if (record.lockedBy.id !== identity.id) return Result.fail(new IdentityMismatchError({
+            currentId: identity.id,
+            targetId: record.lockedBy.id
+        }));
+        const updateResult = await this.repository.update(record.id, false);
+        if (updateResult.isFail()) return Result.fail(new UpdateEntryLockError(updateResult.error));
+        return Result.ok(updateResult.value);
     }
-    return Result.ok(updateResult.value);
-  }
 }
-export const UpdateEntryLockUseCase = UseCaseAbstraction.createImplementation({
-  implementation: UpdateEntryLockUseCaseImpl,
-  dependencies: [GetLockRecordUseCase, LockEntryUseCase, UpdateEntryLockRepository, IdentityContext]
+const UpdateEntryLockUseCase_UpdateEntryLockUseCase = UpdateEntryLockUseCase.createImplementation({
+    implementation: UpdateEntryLockUseCaseImpl,
+    dependencies: [
+        GetLockRecordUseCase,
+        LockEntryUseCase,
+        UpdateEntryLockRepository,
+        IdentityContext
+    ]
 });
+export { UpdateEntryLockUseCase_UpdateEntryLockUseCase as UpdateEntryLockUseCase };
 
 //# sourceMappingURL=UpdateEntryLockUseCase.js.map

package/features/UpdateEntryLock/UpdateEntryLockUseCase.js.map

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

package/features/UpdateEntryLock/abstractions.js

@@ -1,17 +1,6 @@
 import { createAbstraction } from "@webiny/feature/api";
-
-// Input types
-
-/**
- * UpdateEntryLock Use Case - Updates lock timestamp to keep it alive
- */
-
-export const UpdateEntryLockUseCase = createAbstraction("UpdateEntryLockUseCase");
-
-/**
- * UpdateEntryLockRepository - Updates lock record in storage
- */
-
-export const UpdateEntryLockRepository = createAbstraction("UpdateEntryLockRepository");
+const UpdateEntryLockUseCase = createAbstraction("UpdateEntryLockUseCase");
+const UpdateEntryLockRepository = createAbstraction("UpdateEntryLockRepository");
+export { UpdateEntryLockRepository, UpdateEntryLockUseCase };
 
 //# sourceMappingURL=abstractions.js.map

package/features/UpdateEntryLock/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"names":["createAbstraction","UpdateEntryLockUseCase","UpdateEntryLockRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { ILockRecord } from \"~/domain/LockRecord.js\";\nimport type { LockRecordEntryType } from \"~/domain/types.js\";\nimport type {\n    LockRecordNotFoundError,\n    LockRecordPersistenceError,\n    IdentityMismatchError,\n    UpdateEntryLockError\n} from \"~/domain/errors.js\";\n\n// Input types\nexport interface UpdateEntryLockInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * UpdateEntryLock Use Case - Updates lock timestamp to keep it alive\n */\nexport interface IUpdateEntryLockUseCase {\n    execute(input: UpdateEntryLockInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface IUpdateEntryLockUseCaseErrors {\n    notFound: LockRecordNotFoundError;\n    notSameIdentity: IdentityMismatchError;\n    persistence: LockRecordPersistenceError;\n    updateError: UpdateEntryLockError;\n}\n\ntype UseCaseError = IUpdateEntryLockUseCaseErrors[keyof IUpdateEntryLockUseCaseErrors];\n\nexport const UpdateEntryLockUseCase =\n    createAbstraction<IUpdateEntryLockUseCase>(\"UpdateEntryLockUseCase\");\n\nexport namespace UpdateEntryLockUseCase {\n    export type Interface = IUpdateEntryLockUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * UpdateEntryLockRepository - Updates lock record in storage\n */\nexport interface IUpdateEntryLockRepository {\n    update(\n        lockRecordId: string,\n        updateOwner: boolean\n    ): Promise<Result<ILockRecord, RepositoryError>>;\n}\n\nexport interface IUpdateEntryLockRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError = IUpdateEntryLockRepositoryErrors[keyof IUpdateEntryLockRepositoryErrors];\n\nexport const UpdateEntryLockRepository = createAbstraction<IUpdateEntryLockRepository>(\n    \"UpdateEntryLockRepository\"\n);\n\nexport namespace UpdateEntryLockRepository {\n    export type Interface = IUpdateEntryLockRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAWvD;;AAMA;AACA;AACA;;AAcA,OAAO,MAAMC,sBAAsB,GAC/BD,iBAAiB,CAA0B,wBAAwB,CAAC;;AAOxE;AACA;AACA;;AAcA,OAAO,MAAME,yBAAyB,GAAGF,iBAAiB,CACtD,2BACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"features/UpdateEntryLock/abstractions.js","sources":["../../../src/features/UpdateEntryLock/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    LockRecordNotFoundError,\n    LockRecordPersistenceError,\n    IdentityMismatchError,\n    UpdateEntryLockError\n} from \"~/domain/errors.js\";\n\n// Input types\nexport interface UpdateEntryLockInput {\n    id: string;\n    type: LockRecordEntryType;\n}\n\n/**\n * UpdateEntryLock Use Case - Updates lock timestamp to keep it alive\n */\nexport interface IUpdateEntryLockUseCase {\n    execute(input: UpdateEntryLockInput): Promise<Result<ILockRecord, UseCaseError>>;\n}\n\nexport interface IUpdateEntryLockUseCaseErrors {\n    notFound: LockRecordNotFoundError;\n    notSameIdentity: IdentityMismatchError;\n    persistence: LockRecordPersistenceError;\n    updateError: UpdateEntryLockError;\n}\n\ntype UseCaseError = IUpdateEntryLockUseCaseErrors[keyof IUpdateEntryLockUseCaseErrors];\n\nexport const UpdateEntryLockUseCase =\n    createAbstraction<IUpdateEntryLockUseCase>(\"UpdateEntryLockUseCase\");\n\nexport namespace UpdateEntryLockUseCase {\n    export type Interface = IUpdateEntryLockUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * UpdateEntryLockRepository - Updates lock record in storage\n */\nexport interface IUpdateEntryLockRepository {\n    update(\n        lockRecordId: string,\n        updateOwner: boolean\n    ): Promise<Result<ILockRecord, RepositoryError>>;\n}\n\nexport interface IUpdateEntryLockRepositoryErrors {\n    persistence: LockRecordPersistenceError;\n}\n\ntype RepositoryError = IUpdateEntryLockRepositoryErrors[keyof IUpdateEntryLockRepositoryErrors];\n\nexport const UpdateEntryLockRepository = createAbstraction<IUpdateEntryLockRepository>(\n    \"UpdateEntryLockRepository\"\n);\n\nexport namespace UpdateEntryLockRepository {\n    export type Interface = IUpdateEntryLockRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["UpdateEntryLockUseCase","createAbstraction","UpdateEntryLockRepository"],"mappings":";AAiCO,MAAMA,yBACTC,kBAA2C;AAuBxC,MAAMC,4BAA4BD,kBACrC"}

package/features/UpdateEntryLock/feature.js

@@ -1,12 +1,13 @@
 import { createFeature } from "@webiny/feature/api";
 import { UpdateEntryLockUseCase } from "./UpdateEntryLockUseCase.js";
 import { UpdateEntryLockRepository } from "./UpdateEntryLockRepository.js";
-export const UpdateEntryLockFeature = createFeature({
-  name: "UpdateEntryLock",
-  register(container) {
-    container.register(UpdateEntryLockUseCase);
-    container.register(UpdateEntryLockRepository).inSingletonScope();
-  }
+const UpdateEntryLockFeature = createFeature({
+    name: "UpdateEntryLock",
+    register (container) {
+        container.register(UpdateEntryLockUseCase);
+        container.register(UpdateEntryLockRepository).inSingletonScope();
+    }
 });
+export { UpdateEntryLockFeature };
 
 //# sourceMappingURL=feature.js.map

package/features/UpdateEntryLock/feature.js.map

@@ -1 +1 @@
-{"version":3,"names":["createFeature","UpdateEntryLockUseCase","UpdateEntryLockRepository","UpdateEntryLockFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateEntryLockUseCase } from \"./UpdateEntryLockUseCase.js\";\nimport { UpdateEntryLockRepository } from \"./UpdateEntryLockRepository.js\";\n\nexport const UpdateEntryLockFeature = createFeature({\n    name: \"UpdateEntryLock\",\n    register(container) {\n        container.register(UpdateEntryLockUseCase);\n        container.register(UpdateEntryLockRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;AAElC,OAAO,MAAMC,sBAAsB,GAAGH,aAAa,CAAC;EAChDI,IAAI,EAAE,iBAAiB;EACvBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,sBAAsB,CAAC;IAC1CK,SAAS,CAACD,QAAQ,CAACH,yBAAyB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACpE;AACJ,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/UpdateEntryLock/feature.js","sources":["../../../src/features/UpdateEntryLock/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateEntryLockUseCase } from \"./UpdateEntryLockUseCase.js\";\nimport { UpdateEntryLockRepository } from \"./UpdateEntryLockRepository.js\";\n\nexport const UpdateEntryLockFeature = createFeature({\n    name: \"UpdateEntryLock\",\n    register(container) {\n        container.register(UpdateEntryLockUseCase);\n        container.register(UpdateEntryLockRepository).inSingletonScope();\n    }\n});\n"],"names":["UpdateEntryLockFeature","createFeature","container","UpdateEntryLockUseCase","UpdateEntryLockRepository"],"mappings":";;;AAIO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,2BAA2B,gBAAgB;IAClE;AACJ"}

package/features/UpdateEntryLock/index.js

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

package/graphql/checkPermissions.js

@@ -1,14 +1,10 @@
 import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
 import { NotAuthorizedError } from "@webiny/api-core/features/security/shared";
-/**
- * Simple permission check. Only authenticated users can access the websockets API via GraphQL
- */
-export const checkPermissions = async context => {
-  const identityContext = context.container.resolve(IdentityContext);
-  const identity = identityContext.getIdentity();
-  if (identity.isAnonymous()) {
-    throw new NotAuthorizedError();
-  }
+const checkPermissions = async (context)=>{
+    const identityContext = context.container.resolve(IdentityContext);
+    const identity = identityContext.getIdentity();
+    if (identity.isAnonymous()) throw new NotAuthorizedError();
 };
+export { checkPermissions };
 
 //# sourceMappingURL=checkPermissions.js.map

package/graphql/checkPermissions.js.map

@@ -1 +1 @@
-{"version":3,"names":["IdentityContext","NotAuthorizedError","checkPermissions","context","identityContext","container","resolve","identity","getIdentity","isAnonymous"],"sources":["checkPermissions.ts"],"sourcesContent":["import { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared\";\nimport type { ApiCoreContext } from \"@webiny/api-core/types/core.js\";\n\n/**\n * Simple permission check. Only authenticated users can access the websockets API via GraphQL\n */\nexport const checkPermissions = async (context: ApiCoreContext): Promise<void> => {\n    const identityContext = context.container.resolve(IdentityContext);\n    const identity = identityContext.getIdentity();\n\n    if (identity.isAnonymous()) {\n        throw new NotAuthorizedError();\n    }\n};\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,6DAA6D;AAC7F,SAASC,kBAAkB,QAAQ,2CAA2C;AAG9E;AACA;AACA;AACA,OAAO,MAAMC,gBAAgB,GAAG,MAAOC,OAAuB,IAAoB;EAC9E,MAAMC,eAAe,GAAGD,OAAO,CAACE,SAAS,CAACC,OAAO,CAACN,eAAe,CAAC;EAClE,MAAMO,QAAQ,GAAGH,eAAe,CAACI,WAAW,CAAC,CAAC;EAE9C,IAAID,QAAQ,CAACE,WAAW,CAAC,CAAC,EAAE;IACxB,MAAM,IAAIR,kBAAkB,CAAC,CAAC;EAClC;AACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"graphql/checkPermissions.js","sources":["../../src/graphql/checkPermissions.ts"],"sourcesContent":["import { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared\";\nimport type { ApiCoreContext } from \"@webiny/api-core/types/core.js\";\n\n/**\n * Simple permission check. Only authenticated users can access the websockets API via GraphQL\n */\nexport const checkPermissions = async (context: ApiCoreContext): Promise<void> => {\n    const identityContext = context.container.resolve(IdentityContext);\n    const identity = identityContext.getIdentity();\n\n    if (identity.isAnonymous()) {\n        throw new NotAuthorizedError();\n    }\n};\n"],"names":["checkPermissions","context","identityContext","IdentityContext","identity","NotAuthorizedError"],"mappings":";;AAOO,MAAMA,mBAAmB,OAAOC;IACnC,MAAMC,kBAAkBD,QAAQ,SAAS,CAAC,OAAO,CAACE;IAClD,MAAMC,WAAWF,gBAAgB,WAAW;IAE5C,IAAIE,SAAS,WAAW,IACpB,MAAM,IAAIC;AAElB"}

package/graphql/resolve.js

@@ -1,22 +1,20 @@
 import { ErrorResponse, ListErrorResponse, ListResponse, Response } from "@webiny/handler-graphql";
-export const resolve = async cb => {
-  try {
-    const result = await cb();
-    return new Response(result);
-  } catch (ex) {
-    return new ErrorResponse(ex);
-  }
+const resolve = async (cb)=>{
+    try {
+        const result = await cb();
+        return new Response(result);
+    } catch (ex) {
+        return new ErrorResponse(ex);
+    }
 };
-export const resolveList = async cb => {
-  try {
-    const {
-      items,
-      meta
-    } = await cb();
-    return new ListResponse(items, meta);
-  } catch (ex) {
-    return new ListErrorResponse(ex);
-  }
+const resolveList = async (cb)=>{
+    try {
+        const { items, meta } = await cb();
+        return new ListResponse(items, meta);
+    } catch (ex) {
+        return new ListErrorResponse(ex);
+    }
 };
+export { resolve, resolveList };
 
 //# sourceMappingURL=resolve.js.map

package/graphql/resolve.js.map

@@ -1 +1 @@
-{"version":3,"names":["ErrorResponse","ListErrorResponse","ListResponse","Response","resolve","cb","result","ex","resolveList","items","meta"],"sources":["resolve.ts"],"sourcesContent":["import { ErrorResponse, ListErrorResponse, ListResponse, Response } from \"@webiny/handler-graphql\";\nimport type { IRecordLockingMeta } from \"~/types.js\";\n\nexport const resolve = async <T>(cb: () => Promise<T>): Promise<Response<T> | ErrorResponse> => {\n    try {\n        const result = await cb();\n        return new Response<T>(result);\n    } catch (ex) {\n        return new ErrorResponse(ex);\n    }\n};\n\nexport interface IListResponse<T> {\n    items: T[];\n    meta: IRecordLockingMeta;\n}\n\nexport const resolveList = async <T>(\n    cb: () => Promise<IListResponse<T>>\n): Promise<Response<T[]> | ErrorResponse> => {\n    try {\n        const { items, meta } = await cb();\n        return new ListResponse(items, meta);\n    } catch (ex) {\n        return new ListErrorResponse(ex);\n    }\n};\n"],"mappings":"AAAA,SAASA,aAAa,EAAEC,iBAAiB,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,yBAAyB;AAGlG,OAAO,MAAMC,OAAO,GAAG,MAAUC,EAAoB,IAA2C;EAC5F,IAAI;IACA,MAAMC,MAAM,GAAG,MAAMD,EAAE,CAAC,CAAC;IACzB,OAAO,IAAIF,QAAQ,CAAIG,MAAM,CAAC;EAClC,CAAC,CAAC,OAAOC,EAAE,EAAE;IACT,OAAO,IAAIP,aAAa,CAACO,EAAE,CAAC;EAChC;AACJ,CAAC;AAOD,OAAO,MAAMC,WAAW,GAAG,MACvBH,EAAmC,IACM;EACzC,IAAI;IACA,MAAM;MAAEI,KAAK;MAAEC;IAAK,CAAC,GAAG,MAAML,EAAE,CAAC,CAAC;IAClC,OAAO,IAAIH,YAAY,CAACO,KAAK,EAAEC,IAAI,CAAC;EACxC,CAAC,CAAC,OAAOH,EAAE,EAAE;IACT,OAAO,IAAIN,iBAAiB,CAACM,EAAE,CAAC;EACpC;AACJ,CAAC","ignoreList":[]}
+{"version":3,"file":"graphql/resolve.js","sources":["../../src/graphql/resolve.ts"],"sourcesContent":["import { ErrorResponse, ListErrorResponse, ListResponse, Response } from \"@webiny/handler-graphql\";\nimport type { IRecordLockingMeta } from \"~/types.js\";\n\nexport const resolve = async <T>(cb: () => Promise<T>): Promise<Response<T> | ErrorResponse> => {\n    try {\n        const result = await cb();\n        return new Response<T>(result);\n    } catch (ex) {\n        return new ErrorResponse(ex);\n    }\n};\n\nexport interface IListResponse<T> {\n    items: T[];\n    meta: IRecordLockingMeta;\n}\n\nexport const resolveList = async <T>(\n    cb: () => Promise<IListResponse<T>>\n): Promise<Response<T[]> | ErrorResponse> => {\n    try {\n        const { items, meta } = await cb();\n        return new ListResponse(items, meta);\n    } catch (ex) {\n        return new ListErrorResponse(ex);\n    }\n};\n"],"names":["resolve","cb","result","Response","ex","ErrorResponse","resolveList","items","meta","ListResponse","ListErrorResponse"],"mappings":";AAGO,MAAMA,UAAU,OAAUC;IAC7B,IAAI;QACA,MAAMC,SAAS,MAAMD;QACrB,OAAO,IAAIE,SAAYD;IAC3B,EAAE,OAAOE,IAAI;QACT,OAAO,IAAIC,cAAcD;IAC7B;AACJ;AAOO,MAAME,cAAc,OACvBL;IAEA,IAAI;QACA,MAAM,EAAEM,KAAK,EAAEC,IAAI,EAAE,GAAG,MAAMP;QAC9B,OAAO,IAAIQ,aAAaF,OAAOC;IACnC,EAAE,OAAOJ,IAAI;QACT,OAAO,IAAIM,kBAAkBN;IACjC;AACJ"}

package/graphql/schema.js

@@ -13,35 +13,35 @@ import { LockEntryUseCase } from "../features/LockEntry/abstractions.js";
 import { UpdateEntryLockUseCase } from "../features/UpdateEntryLock/abstractions.js";
 import { UnlockEntryUseCase } from "../features/UnlockEntry/abstractions.js";
 import { UnlockEntryRequestUseCase } from "../features/UnlockEntryRequest/abstractions.js";
-export const createGraphQLSchema = async params => {
-  const model = params.model;
-  const models = params.models.filter(model => {
-    return model.fields.length > 0;
-  });
-  const fieldRegistry = params.fieldRegistry;
-  const recordLockingFields = renderFields({
-    models,
-    model,
-    fields: model.fields,
-    type: "manage",
-    fieldRegistry
-  });
-  const listFilterFieldsRender = renderListFilterFields({
-    model,
-    fields: model.fields,
-    type: "manage",
-    fieldRegistry,
-    excludeFields: ["entryId"]
-  });
-  const sortEnumRender = renderSortEnum({
-    model,
-    fields: model.fields,
-    fieldRegistry,
-    sorters: []
-  });
-  const plugin = createGraphQLSchemaPlugin({
-    typeDefs: /* GraphQL */`
-            ${recordLockingFields.map(f => f.typeDefs).join("\n")}
+const createGraphQLSchema = async (params)=>{
+    const model = params.model;
+    const models = params.models.filter((model)=>model.fields.length > 0);
+    const fieldRegistry = params.fieldRegistry;
+    const recordLockingFields = renderFields({
+        models,
+        model,
+        fields: model.fields,
+        type: "manage",
+        fieldRegistry
+    });
+    const listFilterFieldsRender = renderListFilterFields({
+        model,
+        fields: model.fields,
+        type: "manage",
+        fieldRegistry,
+        excludeFields: [
+            "entryId"
+        ]
+    });
+    const sortEnumRender = renderSortEnum({
+        model,
+        fields: model.fields,
+        fieldRegistry,
+        sorters: []
+    });
+    const plugin = createGraphQLSchemaPlugin({
+        typeDefs: `
+            ${recordLockingFields.map((f)=>f.typeDefs).join("\n")}
 
             type RecordLockingError {
                 message: String
@@ -76,7 +76,7 @@ export const createGraphQLSchema = async params => {
                 lockedOn: DateTime!
                 updatedOn: DateTime!
                 expiresOn: DateTime!
-                ${recordLockingFields.map(f => f.fields).join("\n")}
+                ${recordLockingFields.map((f)=>f.fields).join("\n")}
             }
 
             type RecordLockingIsEntryLockedResponse {
@@ -173,143 +173,125 @@ export const createGraphQLSchema = async params => {
                 recordLocking: RecordLockingMutation
             }
         `,
-    resolvers: {
-      Query: {
-        recordLocking: async () => ({})
-      },
-      Mutation: {
-        recordLocking: async () => ({})
-      },
-      RecordLockingQuery: {
-        async isEntryLocked(_, args, context) {
-          return resolve(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(IsEntryLockedUseCase);
-            const result = await useCase.execute({
-              id: args.id,
-              type: args.type
-            });
-            if (result.isFail()) {
-              throw result.error;
+        resolvers: {
+            Query: {
+                recordLocking: async ()=>({})
+            },
+            Mutation: {
+                recordLocking: async ()=>({})
+            },
+            RecordLockingQuery: {
+                async isEntryLocked (_, args, context) {
+                    return resolve(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(IsEntryLockedUseCase);
+                        const result = await useCase.execute({
+                            id: args.id,
+                            type: args.type
+                        });
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+                },
+                async getLockRecord (_, args, context) {
+                    return resolve(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(GetLockRecordUseCase);
+                        const result = await useCase.execute({
+                            id: args.id,
+                            type: args.type
+                        });
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+                },
+                async getLockedEntryLockRecord (_, args, context) {
+                    return resolve(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(GetLockedEntryLockRecordUseCase);
+                        const result = await useCase.execute({
+                            id: args.id,
+                            type: args.type
+                        });
+                        if (result.isFail()) return null;
+                        return result.value;
+                    });
+                },
+                async listLockRecords (_, args, context) {
+                    return resolveList(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(ListLockRecordsUseCase);
+                        const result = await useCase.execute(args);
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+                },
+                listAllLockRecords (_, args, context) {
+                    return resolveList(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(ListAllLockRecordsUseCase);
+                        const result = await useCase.execute(args);
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+                }
+            },
+            RecordLockingMutation: {
+                async lockEntry (_, args, context) {
+                    return resolve(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(LockEntryUseCase);
+                        const result = await useCase.execute({
+                            id: args.id,
+                            type: args.type
+                        });
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+                },
+                async updateEntryLock (_, args, context) {
+                    return resolve(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(UpdateEntryLockUseCase);
+                        const result = await useCase.execute({
+                            id: args.id,
+                            type: args.type
+                        });
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+                },
+                async unlockEntry (_, args, context) {
+                    return resolve(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(UnlockEntryUseCase);
+                        const result = await useCase.execute({
+                            id: args.id,
+                            type: args.type,
+                            force: args.force
+                        });
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+                },
+                async unlockEntryRequest (_, args, context) {
+                    return resolve(async ()=>{
+                        await checkPermissions(context);
+                        const useCase = context.container.resolve(UnlockEntryRequestUseCase);
+                        const result = await useCase.execute({
+                            id: args.id,
+                            type: args.type
+                        });
+                        if (result.isFail()) throw result.error;
+                        return result.value;
+                    });
+                }
             }
-            return result.value;
-          });
-        },
-        async getLockRecord(_, args, context) {
-          return resolve(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(GetLockRecordUseCase);
-            const result = await useCase.execute({
-              id: args.id,
-              type: args.type
-            });
-            if (result.isFail()) {
-              throw result.error;
-            }
-            return result.value;
-          });
-        },
-        async getLockedEntryLockRecord(_, args, context) {
-          return resolve(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(GetLockedEntryLockRecordUseCase);
-            const result = await useCase.execute({
-              id: args.id,
-              type: args.type
-            });
-            // Returns null if not found/expired/locked by current user
-            if (result.isFail()) {
-              return null;
-            }
-            return result.value;
-          });
-        },
-        async listLockRecords(_, args, context) {
-          return resolveList(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(ListLockRecordsUseCase);
-            const result = await useCase.execute(args);
-            if (result.isFail()) {
-              throw result.error;
-            }
-            return result.value;
-          });
-        },
-        listAllLockRecords(_, args, context) {
-          return resolveList(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(ListAllLockRecordsUseCase);
-            const result = await useCase.execute(args);
-            if (result.isFail()) {
-              throw result.error;
-            }
-            return result.value;
-          });
-        }
-      },
-      RecordLockingMutation: {
-        async lockEntry(_, args, context) {
-          return resolve(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(LockEntryUseCase);
-            const result = await useCase.execute({
-              id: args.id,
-              type: args.type
-            });
-            if (result.isFail()) {
-              throw result.error;
-            }
-            return result.value;
-          });
-        },
-        async updateEntryLock(_, args, context) {
-          return resolve(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(UpdateEntryLockUseCase);
-            const result = await useCase.execute({
-              id: args.id,
-              type: args.type
-            });
-            if (result.isFail()) {
-              throw result.error;
-            }
-            return result.value;
-          });
-        },
-        async unlockEntry(_, args, context) {
-          return resolve(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(UnlockEntryUseCase);
-            const result = await useCase.execute({
-              id: args.id,
-              type: args.type,
-              force: args.force
-            });
-            if (result.isFail()) {
-              throw result.error;
-            }
-            return result.value;
-          });
-        },
-        async unlockEntryRequest(_, args, context) {
-          return resolve(async () => {
-            await checkPermissions(context);
-            const useCase = context.container.resolve(UnlockEntryRequestUseCase);
-            const result = await useCase.execute({
-              id: args.id,
-              type: args.type
-            });
-            if (result.isFail()) {
-              throw result.error;
-            }
-            return result.value;
-          });
         }
-      }
-    }
-  });
-  plugin.name = "recordLocking.graphql.schema.locking";
-  return plugin;
+    });
+    plugin.name = "recordLocking.graphql.schema.locking";
+    return plugin;
 };
+export { createGraphQLSchema };
 
 //# sourceMappingURL=schema.js.map