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

package/features/UpdateEntryLock/UpdateEntryLockRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["IdentityContext","UpdateEntryUseCase","GetEntryByIdUseCase","Result","createIdentifier","UpdateEntryLockRepository","RepositoryAbstraction","RecordLockingConfig","RecordLockingModel","LockRecord","LockRecordPersistenceError","createLockRecordDatabaseId","UpdateEntryLockRepositoryImpl","constructor","model","config","identityContext","updateEntry","getEntryById","update","lockRecordId","updateOwner","entryId","id","version","identity","getIdentity","now","Date","toISOString","updateData","savedOn","createdOn","createdBy","savedBy","result","execute","isFail","fail","error","getResult","entry","value","lockRecord","timeout","ok","createImplementation","implementation","dependencies"],"sources":["UpdateEntryLockRepository.ts"],"sourcesContent":["import { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { Result } from \"@webiny/feature/api\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { UpdateEntryLockRepository 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 UpdateEntryLockRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private model: RecordLockingModel.Interface,\n        private config: RecordLockingConfig.Interface,\n        private identityContext: IdentityContext.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async update(\n        lockRecordId: string,\n        updateOwner: boolean\n    ): Promise<Result<ILockRecord, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = createLockRecordDatabaseId(lockRecordId);\n            const id = createIdentifier({\n                id: entryId,\n                version: 1\n            });\n\n            const identity = this.identityContext.getIdentity();\n            const now = new Date().toISOString();\n\n            // Build update data\n            const updateData: any = {\n                savedOn: now\n            };\n\n            // If updating owner (expired lock), also update created fields\n            if (updateOwner) {\n                updateData.createdOn = now;\n                updateData.createdBy = identity;\n                updateData.savedBy = identity;\n            }\n\n            const result = await this.updateEntry.execute(this.model, id, updateData);\n\n            if (result.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(result.error));\n            }\n\n            // Fetch the updated entry to return full lock record\n            const getResult = await this.getEntryById.execute<LockRecordValues>(this.model, id);\n\n            if (getResult.isFail()) {\n                return Result.fail(new LockRecordPersistenceError(getResult.error));\n            }\n\n            const entry = getResult.value;\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 UpdateEntryLockRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateEntryLockRepositoryImpl,\n    dependencies: [\n        RecordLockingModel,\n        RecordLockingConfig,\n        IdentityContext,\n        UpdateEntryUseCase,\n        GetEntryByIdUseCase\n    ]\n});\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,kBAAkB,QAAQ,4DAA4D;AAC/F,SAASC,mBAAmB,QAAQ,6DAA6D;AACjG,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,gBAAgB,QAAQ,eAAe;AAChD,SAASC,yBAAyB,IAAIC,qBAAqB;AAC3D,SAASC,mBAAmB,EAAEC,kBAAkB;AAEhD,SAASC,UAAU;AAEnB,SAASC,0BAA0B;AACnC,SAASC,0BAA0B;AAEnC,MAAMC,6BAA6B,CAA4C;EAC3EC,WAAWA,CACCC,KAAmC,EACnCC,MAAqC,EACrCC,eAA0C,EAC1CC,WAAyC,EACzCC,YAA2C,EACrD;IAAA,KALUJ,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;IAAA,KACrCC,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,YAA2C,GAA3CA,YAA2C;EACpD;EAEH,MAAMC,MAAMA,CACRC,YAAoB,EACpBC,WAAoB,EACqC;IACzD,IAAI;MACA,MAAMC,OAAO,GAAGX,0BAA0B,CAACS,YAAY,CAAC;MACxD,MAAMG,EAAE,GAAGnB,gBAAgB,CAAC;QACxBmB,EAAE,EAAED,OAAO;QACXE,OAAO,EAAE;MACb,CAAC,CAAC;MAEF,MAAMC,QAAQ,GAAG,IAAI,CAACT,eAAe,CAACU,WAAW,CAAC,CAAC;MACnD,MAAMC,GAAG,GAAG,IAAIC,IAAI,CAAC,CAAC,CAACC,WAAW,CAAC,CAAC;;MAEpC;MACA,MAAMC,UAAe,GAAG;QACpBC,OAAO,EAAEJ;MACb,CAAC;;MAED;MACA,IAAIN,WAAW,EAAE;QACbS,UAAU,CAACE,SAAS,GAAGL,GAAG;QAC1BG,UAAU,CAACG,SAAS,GAAGR,QAAQ;QAC/BK,UAAU,CAACI,OAAO,GAAGT,QAAQ;MACjC;MAEA,MAAMU,MAAM,GAAG,MAAM,IAAI,CAAClB,WAAW,CAACmB,OAAO,CAAC,IAAI,CAACtB,KAAK,EAAES,EAAE,EAAEO,UAAU,CAAC;MAEzE,IAAIK,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;QACjB,OAAOlC,MAAM,CAACmC,IAAI,CAAC,IAAI5B,0BAA0B,CAACyB,MAAM,CAACI,KAAK,CAAC,CAAC;MACpE;;MAEA;MACA,MAAMC,SAAS,GAAG,MAAM,IAAI,CAACtB,YAAY,CAACkB,OAAO,CAAmB,IAAI,CAACtB,KAAK,EAAES,EAAE,CAAC;MAEnF,IAAIiB,SAAS,CAACH,MAAM,CAAC,CAAC,EAAE;QACpB,OAAOlC,MAAM,CAACmC,IAAI,CAAC,IAAI5B,0BAA0B,CAAC8B,SAAS,CAACD,KAAK,CAAC,CAAC;MACvE;MAEA,MAAME,KAAK,GAAGD,SAAS,CAACE,KAAK;MAC7B,MAAMC,UAAU,GAAG,IAAIlC,UAAU,CAACgC,KAAK,EAAE,IAAI,CAAC1B,MAAM,CAAC6B,OAAO,CAAC;MAE7D,OAAOzC,MAAM,CAAC0C,EAAE,CAACF,UAAU,CAAC;IAChC,CAAC,CAAC,OAAOJ,KAAK,EAAE;MACZ,OAAOpC,MAAM,CAACmC,IAAI,CAAC,IAAI5B,0BAA0B,CAAC6B,KAAc,CAAC,CAAC;IACtE;EACJ;AACJ;AAEA,OAAO,MAAMlC,yBAAyB,GAAGC,qBAAqB,CAACwC,oBAAoB,CAAC;EAChFC,cAAc,EAAEnC,6BAA6B;EAC7CoC,YAAY,EAAE,CACVxC,kBAAkB,EAClBD,mBAAmB,EACnBP,eAAe,EACfC,kBAAkB,EAClBC,mBAAmB;AAE3B,CAAC,CAAC","ignoreList":[]}

package/features/UpdateEntryLock/UpdateEntryLockUseCase.d.ts

@@ -0,0 +1,18 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateEntryLockUseCase as UseCaseAbstraction, UpdateEntryLockRepository, UpdateEntryLockInput } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { LockEntryUseCase } from "../LockEntry/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+declare class UpdateEntryLockUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getLockRecord;
+    private lockEntry;
+    private repository;
+    private identityContext;
+    constructor(getLockRecord: GetLockRecordUseCase.Interface, lockEntry: LockEntryUseCase.Interface, repository: UpdateEntryLockRepository.Interface, identityContext: IdentityContext.Interface);
+    execute(input: UpdateEntryLockInput): Promise<Result<ILockRecord, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateEntryLockUseCase: typeof UpdateEntryLockUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateEntryLockUseCase>;
+};
+export {};

package/features/UpdateEntryLock/UpdateEntryLockUseCase.js

@@ -0,0 +1,62 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateEntryLockUseCase as UseCaseAbstraction, UpdateEntryLockRepository } from "./abstractions.js";
+import { GetLockRecordUseCase } from "../GetLockRecord/abstractions.js";
+import { LockEntryUseCase } from "../LockEntry/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { LockRecordNotFoundError, IdentityMismatchError, 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);
+    }
+    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));
+    }
+    return Result.ok(updateResult.value);
+  }
+}
+export const UpdateEntryLockUseCase = UseCaseAbstraction.createImplementation({
+  implementation: UpdateEntryLockUseCaseImpl,
+  dependencies: [GetLockRecordUseCase, LockEntryUseCase, UpdateEntryLockRepository, IdentityContext]
+});
+
+//# sourceMappingURL=UpdateEntryLockUseCase.js.map

package/features/UpdateEntryLock/UpdateEntryLockUseCase.js.map

@@ -0,0 +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/IdentityContext\";\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":[]}

package/features/UpdateEntryLock/abstractions.d.ts

@@ -0,0 +1,42 @@
+import { Result } from "@webiny/feature/api";
+import type { ILockRecord } from "../../domain/LockRecord.js";
+import type { LockRecordEntryType } from "../../domain/types.js";
+import type { LockRecordNotFoundError, LockRecordPersistenceError, IdentityMismatchError, UpdateEntryLockError } from "../../domain/errors.js";
+export interface UpdateEntryLockInput {
+    id: string;
+    type: LockRecordEntryType;
+}
+/**
+ * UpdateEntryLock Use Case - Updates lock timestamp to keep it alive
+ */
+export interface IUpdateEntryLockUseCase {
+    execute(input: UpdateEntryLockInput): Promise<Result<ILockRecord, UseCaseError>>;
+}
+export interface IUpdateEntryLockUseCaseErrors {
+    notFound: LockRecordNotFoundError;
+    notSameIdentity: IdentityMismatchError;
+    persistence: LockRecordPersistenceError;
+    updateError: UpdateEntryLockError;
+}
+type UseCaseError = IUpdateEntryLockUseCaseErrors[keyof IUpdateEntryLockUseCaseErrors];
+export declare const UpdateEntryLockUseCase: import("@webiny/di").Abstraction<IUpdateEntryLockUseCase>;
+export declare namespace UpdateEntryLockUseCase {
+    type Interface = IUpdateEntryLockUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * UpdateEntryLockRepository - Updates lock record in storage
+ */
+export interface IUpdateEntryLockRepository {
+    update(lockRecordId: string, updateOwner: boolean): Promise<Result<ILockRecord, RepositoryError>>;
+}
+export interface IUpdateEntryLockRepositoryErrors {
+    persistence: LockRecordPersistenceError;
+}
+type RepositoryError = IUpdateEntryLockRepositoryErrors[keyof IUpdateEntryLockRepositoryErrors];
+export declare const UpdateEntryLockRepository: import("@webiny/di").Abstraction<IUpdateEntryLockRepository>;
+export declare namespace UpdateEntryLockRepository {
+    type Interface = IUpdateEntryLockRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/UpdateEntryLock/abstractions.js

@@ -0,0 +1,17 @@
+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");
+
+//# sourceMappingURL=abstractions.js.map

package/features/UpdateEntryLock/abstractions.js.map

@@ -0,0 +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":[]}

package/features/UpdateEntryLock/feature.d.ts

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

package/features/UpdateEntryLock/feature.js

@@ -0,0 +1,12 @@
+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();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/UpdateEntryLock/feature.js.map

@@ -0,0 +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":[]}

package/features/UpdateEntryLock/index.d.ts

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

package/features/UpdateEntryLock/index.js

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

package/features/UpdateEntryLock/index.js.map

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

package/graphql/checkPermissions.d.ts

@@ -0,0 +1,5 @@
+import type { ApiCoreContext } from "@webiny/api-core/types/core.js";
+/**
+ * Simple permission check. Only authenticated users can access the websockets API via GraphQL
+ */
+export declare const checkPermissions: (context: ApiCoreContext) => Promise<void>;

package/graphql/checkPermissions.js

@@ -0,0 +1,14 @@
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+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();
+  }
+};
+
+//# sourceMappingURL=checkPermissions.js.map

package/graphql/checkPermissions.js.map

@@ -0,0 +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/IdentityContext\";\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,2CAA2C;AAC3E,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":[]}

package/{utils → graphql}/resolve.d.ts

@@ -1,8 +1,8 @@
 import { ErrorResponse, Response } from "@webiny/handler-graphql";
-import { IRecordLockingMeta } from "../types";
+import type { IRecordLockingMeta } from "../types.js";
 export declare const resolve: <T>(cb: () => Promise<T>) => Promise<Response<T> | ErrorResponse>;
 export interface IListResponse<T> {
     items: T[];
     meta: IRecordLockingMeta;
 }
-export declare const resolveList: <T>(cb: () => Promise<IListResponse<T>>) => Promise<ErrorResponse | Response<T[]>>;
+export declare const resolveList: <T>(cb: () => Promise<IListResponse<T>>) => Promise<Response<T[]> | ErrorResponse>;

package/graphql/resolve.js

@@ -0,0 +1,22 @@
+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);
+  }
+};
+export const resolveList = async cb => {
+  try {
+    const {
+      items,
+      meta
+    } = await cb();
+    return new ListResponse(items, meta);
+  } catch (ex) {
+    return new ListErrorResponse(ex);
+  }
+};
+
+//# sourceMappingURL=resolve.js.map

package/graphql/resolve.js.map

@@ -0,0 +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":[]}

package/graphql/schema.d.ts

@@ -1,7 +1,11 @@
-import { Context } from "../types";
-import { IGraphQLSchemaPlugin } from "@webiny/handler-graphql";
+import type { IGraphQLSchemaPlugin } from "@webiny/handler-graphql";
+import type { ApiCoreContext } from "@webiny/api-core/types/core.js";
+import { CmsModel } from "@webiny/api-headless-cms/types/model.js";
+import type { CmsFieldTypePlugins } from "@webiny/api-headless-cms/types/index.js";
 interface Params {
-    context: Pick<Context, "plugins" | "recordLocking" | "security" | "cms">;
+    model: CmsModel;
+    models: CmsModel[];
+    fieldTypePlugins: CmsFieldTypePlugins;
 }
-export declare const createGraphQLSchema: (params: Params) => Promise<IGraphQLSchemaPlugin<Context>>;
+export declare const createGraphQLSchema: (params: Params) => Promise<IGraphQLSchemaPlugin<ApiCoreContext>>;
 export {};

package/graphql/schema.js

@@ -1,51 +1,48 @@
-"use strict";
+import { resolve, resolveList } from "./resolve.js";
+import { createGraphQLSchemaPlugin } from "@webiny/handler-graphql";
+import { renderFields } from "@webiny/api-headless-cms/utils/renderFields.js";
+import { renderListFilterFields } from "@webiny/api-headless-cms/utils/renderListFilterFields.js";
+import { renderSortEnum } from "@webiny/api-headless-cms/utils/renderSortEnum.js";
+import { checkPermissions } from "./checkPermissions.js";
+import { IsEntryLockedUseCase } from "../features/IsEntryLocked/abstractions.js";
+import { GetLockRecordUseCase } from "../features/GetLockRecord/abstractions.js";
+import { GetLockedEntryLockRecordUseCase } from "../features/GetLockedEntryLockRecord/abstractions.js";
+import { ListLockRecordsUseCase } from "../features/ListLockRecords/abstractions.js";
+import { ListAllLockRecordsUseCase } from "../features/ListAllLockRecords/abstractions.js";
+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 => {
+  // Record locking model
+  const model = params.model;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createGraphQLSchema = void 0;
-var _resolve = require("../utils/resolve");
-var _handlerGraphql = require("@webiny/handler-graphql");
-var _renderFields = require("@webiny/api-headless-cms/utils/renderFields");
-var _createFieldTypePluginRecords = require("@webiny/api-headless-cms/graphql/schema/createFieldTypePluginRecords");
-var _renderListFilterFields = require("@webiny/api-headless-cms/utils/renderListFilterFields");
-var _renderSortEnum = require("@webiny/api-headless-cms/utils/renderSortEnum");
-var _checkPermissions = require("../utils/checkPermissions");
-const createGraphQLSchema = async params => {
-  const context = params.context;
-  const model = await context.recordLocking.getModel();
-  const models = await context.security.withoutAuthorization(async () => {
-    return (await context.cms.listModels()).filter(model => {
-      if (model.fields.length === 0) {
-        return false;
-      } else if (model.isPrivate) {
-        return false;
-      }
-      return true;
-    });
+  // Other public models that have at least one field
+  const models = params.models.filter(model => {
+    return model.fields.length > 0;
   });
-  const fieldTypePlugins = (0, _createFieldTypePluginRecords.createFieldTypePluginRecords)(context.plugins);
-  const recordLockingFields = (0, _renderFields.renderFields)({
+  const fieldTypePlugins = params.fieldTypePlugins;
+  const recordLockingFields = renderFields({
     models,
     model,
     fields: model.fields,
     type: "manage",
     fieldTypePlugins
   });
-  const listFilterFieldsRender = (0, _renderListFilterFields.renderListFilterFields)({
+  const listFilterFieldsRender = renderListFilterFields({
     model,
     fields: model.fields,
     type: "manage",
     fieldTypePlugins,
     excludeFields: ["entryId"]
   });
-  const sortEnumRender = (0, _renderSortEnum.renderSortEnum)({
+  const sortEnumRender = renderSortEnum({
     model,
     fields: model.fields,
     fieldTypePlugins,
     sorterPlugins: []
   });
-  const plugin = (0, _handlerGraphql.createGraphQLSchemaPlugin)({
+  const plugin = createGraphQLSchemaPlugin({
     typeDefs: /* GraphQL */`
             ${recordLockingFields.map(f => f.typeDefs).join("\n")}
 
@@ -126,7 +123,7 @@ const createGraphQLSchema = async params => {
             }
 
             input RecordLockingListWhereInput {
-                ${listFilterFieldsRender}
+                ${listFilterFieldsRender.allFiltersAsString()}
             }
 
             enum RecordLockingListSorter {
@@ -188,85 +185,127 @@ const createGraphQLSchema = async params => {
       },
       RecordLockingQuery: {
         async isEntryLocked(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return context.recordLocking.isEntryLocked({
+          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 (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            const result = await context.recordLocking.getLockRecord({
+          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) {
-              return result;
+            if (result.isFail()) {
+              throw result.error;
             }
-            throw new _handlerGraphql.NotFoundError("Lock record not found.");
+            return result.value;
           });
         },
         async getLockedEntryLockRecord(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.getLockedEntryLockRecord({
+          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 (0, _resolve.resolveList)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.listLockRecords(args);
+          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 (0, _resolve.resolveList)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.listAllLockRecords(args);
+          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 (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return context.recordLocking.lockEntry({
+          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 (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return context.recordLocking.updateEntryLock({
+          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 (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.unlockEntry({
+          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 (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.unlockEntryRequest({
+          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;
           });
         }
       }
@@ -275,6 +314,5 @@ const createGraphQLSchema = async params => {
   plugin.name = "recordLocking.graphql.schema.locking";
   return plugin;
 };
-exports.createGraphQLSchema = createGraphQLSchema;
 
 //# sourceMappingURL=schema.js.map