@webiny/api-record-locking 0.0.0-unstable.c27f4d8a31 → 0.0.0-unstable.d0f34a8194

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.d.ts

@@ -1 +1,4 @@
-export declare const UpdateEntryLockFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;
+export declare const UpdateEntryLockFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

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/RecordLockingGraphQLSchema.d.ts

@@ -0,0 +1,25 @@
+import { GraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { RecordLockingModelProvider } from "../domain/abstractions.js";
+/**
+ * The record locking GraphQL schema. The lock record type is rendered from the lock record model,
+ * which is loaded when the schema is composed.
+ */
+declare class RecordLockingGraphQLSchemaImpl implements GraphQLSchemaFactory.Interface {
+    private readonly tenantContext;
+    private readonly identityContext;
+    private readonly modelProvider;
+    private readonly listModelsUseCase;
+    private readonly fieldRegistry;
+    constructor(tenantContext: TenantContext.Interface, identityContext: IdentityContext.Interface, modelProvider: RecordLockingModelProvider.Interface, listModelsUseCase: ListModelsUseCase.Interface, fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface);
+    getSchemaKey(): Promise<string>;
+    execute(builder: GraphQLSchemaFactory.SchemaBuilder): Promise<GraphQLSchemaFactory.SchemaBuilder>;
+    private loadInputs;
+}
+export declare const RecordLockingGraphQLSchema: typeof RecordLockingGraphQLSchemaImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-graphql/graphql/abstractions.public.js").IGraphQLSchemaFactory>;
+};
+export {};

package/graphql/RecordLockingGraphQLSchema.js

@@ -0,0 +1,390 @@
+import { GraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { createModelSchemaKey } from "@webiny/api-headless-cms/utils/createModelSchemaKey.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+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 { RecordLockingModelProvider } from "../domain/abstractions.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";
+import { resolve, resolveList } from "./resolve.js";
+import { checkPermissions } from "./checkPermissions.js";
+function renderTypeDefs(params) {
+    const { model, fieldRegistry } = params;
+    const models = params.models.filter((model)=>model.fields.length > 0);
+    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: []
+    });
+    return `
+        ${recordLockingFields.map((f)=>f.typeDefs).join("\n")}
+
+        type RecordLockingError {
+            message: String
+            code: String
+            data: JSON
+            stack: String
+        }
+
+        enum RecordLockingRecordActionType {
+            requested
+            approved
+            denied
+        }
+
+        type RecordLockingIdentity {
+            id: String!
+            displayName: String
+            type: String
+        }
+
+        type RecordLockingRecordAction {
+            id: ID!
+            type: RecordLockingRecordActionType!
+            message: String
+            createdBy: RecordLockingIdentity!
+            createdOn: DateTime!
+        }
+
+        type RecordLockingRecord {
+            id: ID!
+            lockedBy: RecordLockingIdentity!
+            lockedOn: DateTime!
+            updatedOn: DateTime!
+            expiresOn: DateTime!
+            ${recordLockingFields.map((f)=>f.fields).join("\n")}
+        }
+
+        type RecordLockingIsEntryLockedResponse {
+            data: Boolean
+            error: RecordLockingError
+        }
+
+        type RecordLockingGetLockRecordResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingGetLockedEntryLockRecordResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingListLockRecordsResponse {
+            data: [RecordLockingRecord!]
+            error: RecordLockingError
+        }
+
+        type RecordLockingLockEntryResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingUpdateLockResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingUnlockEntryResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        type RecordLockingUnlockEntryRequestResponse {
+            data: RecordLockingRecord
+            error: RecordLockingError
+        }
+
+        input RecordLockingListWhereInput {
+            ${listFilterFieldsRender.allFiltersAsString()}
+        }
+
+        enum RecordLockingListSorter {
+            ${sortEnumRender}
+        }
+
+        type RecordLockingQuery {
+            _empty: String
+        }
+
+        type RecordLockingMutation {
+            _empty: String
+        }
+
+        extend type RecordLockingQuery {
+            isEntryLocked(id: ID!, type: String!): RecordLockingIsEntryLockedResponse!
+            getLockRecord(id: ID!, type: String!): RecordLockingGetLockRecordResponse!
+            # Returns lock record or null - if entry is locked in context of the current user, does not throw an error like getLockRecord if no record in the DB
+            getLockedEntryLockRecord(id: ID!, type: String!): RecordLockingGetLockedEntryLockRecordResponse!
+            listAllLockRecords(
+                where: RecordLockingListWhereInput
+                sort: [RecordLockingListSorter!]
+                limit: Int
+                after: String
+            ): RecordLockingListLockRecordsResponse!
+            # Basically same as listAllLockRecords except this one will filter out records with expired lock.
+            listLockRecords(
+                where: RecordLockingListWhereInput
+                sort: [RecordLockingListSorter!]
+                limit: Int
+                after: String
+            ): RecordLockingListLockRecordsResponse!
+        }
+
+        extend type RecordLockingMutation {
+            lockEntry(id: ID!, type: String!): RecordLockingLockEntryResponse!
+            updateEntryLock(id: ID!, type: String!): RecordLockingUpdateLockResponse!
+            unlockEntry(id: ID!, type: String!, force: Boolean): RecordLockingUnlockEntryResponse!
+            unlockEntryRequest(
+                id: ID!
+                type: String!
+            ): RecordLockingUnlockEntryRequestResponse!
+        }
+
+        extend type Query {
+            recordLocking: RecordLockingQuery
+        }
+
+        extend type Mutation {
+            recordLocking: RecordLockingMutation
+        }
+    `;
+}
+function addQueryResolvers(builder) {
+    builder.addResolver({
+        path: "Query.recordLocking",
+        resolver: ()=>async ()=>({})
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.isEntryLocked",
+        dependencies: [
+            IdentityContext,
+            IsEntryLockedUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.getLockRecord",
+        dependencies: [
+            IdentityContext,
+            GetLockRecordUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.getLockedEntryLockRecord",
+        dependencies: [
+            IdentityContext,
+            GetLockedEntryLockRecordUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) return null;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.listLockRecords",
+        dependencies: [
+            IdentityContext,
+            ListLockRecordsUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolveList(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute(args);
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingQuery.listAllLockRecords",
+        dependencies: [
+            IdentityContext,
+            ListAllLockRecordsUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolveList(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute(args);
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+}
+function addMutationResolvers(builder) {
+    builder.addResolver({
+        path: "Mutation.recordLocking",
+        resolver: ()=>async ()=>({})
+    });
+    builder.addResolver({
+        path: "RecordLockingMutation.lockEntry",
+        dependencies: [
+            IdentityContext,
+            LockEntryUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingMutation.updateEntryLock",
+        dependencies: [
+            IdentityContext,
+            UpdateEntryLockUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingMutation.unlockEntry",
+        dependencies: [
+            IdentityContext,
+            UnlockEntryUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type,
+                        force: args.force
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+    builder.addResolver({
+        path: "RecordLockingMutation.unlockEntryRequest",
+        dependencies: [
+            IdentityContext,
+            UnlockEntryRequestUseCase
+        ],
+        resolver: (identityContext, useCase)=>({ args })=>resolve(async ()=>{
+                    checkPermissions(identityContext);
+                    const result = await useCase.execute({
+                        id: args.id,
+                        type: args.type
+                    });
+                    if (result.isFail()) throw result.error;
+                    return result.value;
+                })
+    });
+}
+class RecordLockingGraphQLSchemaImpl {
+    constructor(tenantContext, identityContext, modelProvider, listModelsUseCase, fieldRegistry){
+        this.tenantContext = tenantContext;
+        this.identityContext = identityContext;
+        this.modelProvider = modelProvider;
+        this.listModelsUseCase = listModelsUseCase;
+        this.fieldRegistry = fieldRegistry;
+    }
+    async getSchemaKey() {
+        const inputs = await this.loadInputs();
+        if (!inputs) return "RecordLocking:no-tenant";
+        const modelKey = createModelSchemaKey([
+            inputs.model
+        ], inputs.models);
+        return `RecordLocking:${modelKey}`;
+    }
+    async execute(builder) {
+        const inputs = await this.loadInputs();
+        if (!inputs) return builder;
+        const { model, models } = inputs;
+        const typeDefs = renderTypeDefs({
+            model,
+            models,
+            fieldRegistry: this.fieldRegistry
+        });
+        builder.addTypeDefs(typeDefs);
+        addQueryResolvers(builder);
+        addMutationResolvers(builder);
+        return builder;
+    }
+    async loadInputs() {
+        if (!this.tenantContext.getTenant()) return null;
+        const model = await this.modelProvider.get();
+        const models = await this.identityContext.withoutAuthorization(async ()=>{
+            const result = await this.listModelsUseCase.execute({
+                includePrivate: false
+            });
+            if (result.isFail()) throw result.error;
+            return result.value;
+        });
+        return {
+            model,
+            models
+        };
+    }
+}
+const RecordLockingGraphQLSchema = GraphQLSchemaFactory.createImplementation({
+    implementation: RecordLockingGraphQLSchemaImpl,
+    dependencies: [
+        TenantContext,
+        IdentityContext,
+        RecordLockingModelProvider,
+        ListModelsUseCase,
+        CmsModelFieldToGraphQLRegistry
+    ]
+});
+export { RecordLockingGraphQLSchema };
+
+//# sourceMappingURL=RecordLockingGraphQLSchema.js.map

package/graphql/RecordLockingGraphQLSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql/RecordLockingGraphQLSchema.js","sources":["../../src/graphql/RecordLockingGraphQLSchema.ts"],"sourcesContent":["import { GraphQLSchemaFactory } from \"@webiny/api-graphql/graphql/abstractions.js\";\nimport { createModelSchemaKey } from \"@webiny/api-headless-cms/utils/createModelSchemaKey.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { ListModelsUseCase } from \"@webiny/api-headless-cms/features/contentModel/ListModels/index.js\";\nimport { CmsModelFieldToGraphQLRegistry } from \"@webiny/api-headless-cms/exports/api/cms/graphql.js\";\nimport { renderFields } from \"@webiny/api-headless-cms/utils/renderFields.js\";\nimport { renderListFilterFields } from \"@webiny/api-headless-cms/utils/renderListFilterFields.js\";\nimport { renderSortEnum } from \"@webiny/api-headless-cms/utils/renderSortEnum.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/model.js\";\nimport { RecordLockingModelProvider } from \"~/domain/abstractions.js\";\nimport { IsEntryLockedUseCase } from \"~/features/IsEntryLocked/abstractions.js\";\nimport { GetLockRecordUseCase } from \"~/features/GetLockRecord/abstractions.js\";\nimport { GetLockedEntryLockRecordUseCase } from \"~/features/GetLockedEntryLockRecord/abstractions.js\";\nimport { ListLockRecordsUseCase } from \"~/features/ListLockRecords/abstractions.js\";\nimport type { ListLockRecordsInput } from \"~/features/ListLockRecords/abstractions.js\";\nimport { ListAllLockRecordsUseCase } from \"~/features/ListAllLockRecords/abstractions.js\";\nimport type { ListAllLockRecordsInput } from \"~/features/ListAllLockRecords/abstractions.js\";\nimport { LockEntryUseCase } from \"~/features/LockEntry/abstractions.js\";\nimport { UpdateEntryLockUseCase } from \"~/features/UpdateEntryLock/abstractions.js\";\nimport { UnlockEntryUseCase } from \"~/features/UnlockEntry/abstractions.js\";\nimport { UnlockEntryRequestUseCase } from \"~/features/UnlockEntryRequest/abstractions.js\";\nimport { resolve } from \"./resolve.js\";\nimport { resolveList } from \"./resolve.js\";\nimport { checkPermissions } from \"./checkPermissions.js\";\n\ninterface IEntryArgs {\n    id: string;\n    type: string;\n}\n\ninterface IUnlockEntryArgs extends IEntryArgs {\n    force?: boolean;\n}\n\ninterface IResolverParams<TArgs = unknown> {\n    args: TArgs;\n}\n\ninterface IRenderTypeDefsParams {\n    model: CmsModel;\n    models: CmsModel[];\n    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;\n}\n\nfunction renderTypeDefs(params: IRenderTypeDefsParams): string {\n    const { model, fieldRegistry } = params;\n\n    const models = params.models.filter(model => {\n        return model.fields.length > 0;\n    });\n\n    const recordLockingFields = renderFields({\n        models,\n        model,\n        fields: model.fields,\n        type: \"manage\",\n        fieldRegistry\n    });\n\n    const listFilterFieldsRender = renderListFilterFields({\n        model,\n        fields: model.fields,\n        type: \"manage\",\n        fieldRegistry,\n        excludeFields: [\"entryId\"]\n    });\n\n    const sortEnumRender = renderSortEnum({\n        model,\n        fields: model.fields,\n        fieldRegistry,\n        sorters: []\n    });\n\n    return /* GraphQL */ `\n        ${recordLockingFields.map(f => f.typeDefs).join(\"\\n\")}\n\n        type RecordLockingError {\n            message: String\n            code: String\n            data: JSON\n            stack: String\n        }\n\n        enum RecordLockingRecordActionType {\n            requested\n            approved\n            denied\n        }\n\n        type RecordLockingIdentity {\n            id: String!\n            displayName: String\n            type: String\n        }\n\n        type RecordLockingRecordAction {\n            id: ID!\n            type: RecordLockingRecordActionType!\n            message: String\n            createdBy: RecordLockingIdentity!\n            createdOn: DateTime!\n        }\n\n        type RecordLockingRecord {\n            id: ID!\n            lockedBy: RecordLockingIdentity!\n            lockedOn: DateTime!\n            updatedOn: DateTime!\n            expiresOn: DateTime!\n            ${recordLockingFields.map(f => f.fields).join(\"\\n\")}\n        }\n\n        type RecordLockingIsEntryLockedResponse {\n            data: Boolean\n            error: RecordLockingError\n        }\n\n        type RecordLockingGetLockRecordResponse {\n            data: RecordLockingRecord\n            error: RecordLockingError\n        }\n\n        type RecordLockingGetLockedEntryLockRecordResponse {\n            data: RecordLockingRecord\n            error: RecordLockingError\n        }\n\n        type RecordLockingListLockRecordsResponse {\n            data: [RecordLockingRecord!]\n            error: RecordLockingError\n        }\n\n        type RecordLockingLockEntryResponse {\n            data: RecordLockingRecord\n            error: RecordLockingError\n        }\n\n        type RecordLockingUpdateLockResponse {\n            data: RecordLockingRecord\n            error: RecordLockingError\n        }\n\n        type RecordLockingUnlockEntryResponse {\n            data: RecordLockingRecord\n            error: RecordLockingError\n        }\n\n        type RecordLockingUnlockEntryRequestResponse {\n            data: RecordLockingRecord\n            error: RecordLockingError\n        }\n\n        input RecordLockingListWhereInput {\n            ${listFilterFieldsRender.allFiltersAsString()}\n        }\n\n        enum RecordLockingListSorter {\n            ${sortEnumRender}\n        }\n\n        type RecordLockingQuery {\n            _empty: String\n        }\n\n        type RecordLockingMutation {\n            _empty: String\n        }\n\n        extend type RecordLockingQuery {\n            isEntryLocked(id: ID!, type: String!): RecordLockingIsEntryLockedResponse!\n            getLockRecord(id: ID!, type: String!): RecordLockingGetLockRecordResponse!\n            # Returns lock record or null - if entry is locked in context of the current user, does not throw an error like getLockRecord if no record in the DB\n            getLockedEntryLockRecord(id: ID!, type: String!): RecordLockingGetLockedEntryLockRecordResponse!\n            listAllLockRecords(\n                where: RecordLockingListWhereInput\n                sort: [RecordLockingListSorter!]\n                limit: Int\n                after: String\n            ): RecordLockingListLockRecordsResponse!\n            # Basically same as listAllLockRecords except this one will filter out records with expired lock.\n            listLockRecords(\n                where: RecordLockingListWhereInput\n                sort: [RecordLockingListSorter!]\n                limit: Int\n                after: String\n            ): RecordLockingListLockRecordsResponse!\n        }\n\n        extend type RecordLockingMutation {\n            lockEntry(id: ID!, type: String!): RecordLockingLockEntryResponse!\n            updateEntryLock(id: ID!, type: String!): RecordLockingUpdateLockResponse!\n            unlockEntry(id: ID!, type: String!, force: Boolean): RecordLockingUnlockEntryResponse!\n            unlockEntryRequest(\n                id: ID!\n                type: String!\n            ): RecordLockingUnlockEntryRequestResponse!\n        }\n\n        extend type Query {\n            recordLocking: RecordLockingQuery\n        }\n\n        extend type Mutation {\n            recordLocking: RecordLockingMutation\n        }\n    `;\n}\n\nfunction addQueryResolvers(builder: GraphQLSchemaFactory.SchemaBuilder): void {\n    builder.addResolver({\n        path: \"Query.recordLocking\",\n        resolver: () => async () => ({})\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingQuery.isEntryLocked\",\n        dependencies: [IdentityContext, IsEntryLockedUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: IsEntryLockedUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<IEntryArgs>) => {\n                return resolve(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute({\n                        id: args.id,\n                        type: args.type\n                    });\n                    if (result.isFail()) {\n                        throw result.error;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingQuery.getLockRecord\",\n        dependencies: [IdentityContext, GetLockRecordUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: GetLockRecordUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<IEntryArgs>) => {\n                return resolve(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute({\n                        id: args.id,\n                        type: args.type\n                    });\n                    if (result.isFail()) {\n                        throw result.error;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingQuery.getLockedEntryLockRecord\",\n        dependencies: [IdentityContext, GetLockedEntryLockRecordUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: GetLockedEntryLockRecordUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<IEntryArgs>) => {\n                return resolve(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute({\n                        id: args.id,\n                        type: args.type\n                    });\n                    // Returns null if not found/expired/locked by current user.\n                    if (result.isFail()) {\n                        return null;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingQuery.listLockRecords\",\n        dependencies: [IdentityContext, ListLockRecordsUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: ListLockRecordsUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<ListLockRecordsInput>) => {\n                return resolveList(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute(args);\n                    if (result.isFail()) {\n                        throw result.error;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingQuery.listAllLockRecords\",\n        dependencies: [IdentityContext, ListAllLockRecordsUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: ListAllLockRecordsUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<ListAllLockRecordsInput>) => {\n                return resolveList(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute(args);\n                    if (result.isFail()) {\n                        throw result.error;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n}\n\nfunction addMutationResolvers(builder: GraphQLSchemaFactory.SchemaBuilder): void {\n    builder.addResolver({\n        path: \"Mutation.recordLocking\",\n        resolver: () => async () => ({})\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingMutation.lockEntry\",\n        dependencies: [IdentityContext, LockEntryUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: LockEntryUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<IEntryArgs>) => {\n                return resolve(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute({\n                        id: args.id,\n                        type: args.type\n                    });\n                    if (result.isFail()) {\n                        throw result.error;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingMutation.updateEntryLock\",\n        dependencies: [IdentityContext, UpdateEntryLockUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: UpdateEntryLockUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<IEntryArgs>) => {\n                return resolve(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute({\n                        id: args.id,\n                        type: args.type\n                    });\n                    if (result.isFail()) {\n                        throw result.error;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingMutation.unlockEntry\",\n        dependencies: [IdentityContext, UnlockEntryUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: UnlockEntryUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<IUnlockEntryArgs>) => {\n                return resolve(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute({\n                        id: args.id,\n                        type: args.type,\n                        force: args.force\n                    });\n                    if (result.isFail()) {\n                        throw result.error;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n\n    builder.addResolver({\n        path: \"RecordLockingMutation.unlockEntryRequest\",\n        dependencies: [IdentityContext, UnlockEntryRequestUseCase],\n        resolver: (\n            identityContext: IdentityContext.Interface,\n            useCase: UnlockEntryRequestUseCase.Interface\n        ) => {\n            return ({ args }: IResolverParams<IEntryArgs>) => {\n                return resolve(async () => {\n                    checkPermissions(identityContext);\n                    const result = await useCase.execute({\n                        id: args.id,\n                        type: args.type\n                    });\n                    if (result.isFail()) {\n                        throw result.error;\n                    }\n                    return result.value;\n                });\n            };\n        }\n    });\n}\n\n/**\n * The record locking GraphQL schema. The lock record type is rendered from the lock record model,\n * which is loaded when the schema is composed.\n */\nclass RecordLockingGraphQLSchemaImpl implements GraphQLSchemaFactory.Interface {\n    public constructor(\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly modelProvider: RecordLockingModelProvider.Interface,\n        private readonly listModelsUseCase: ListModelsUseCase.Interface,\n        private readonly fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface\n    ) {}\n\n    public async getSchemaKey(): Promise<string> {\n        const inputs = await this.loadInputs();\n        if (!inputs) {\n            return \"RecordLocking:no-tenant\";\n        }\n\n        const modelKey = createModelSchemaKey([inputs.model], inputs.models);\n        return `RecordLocking:${modelKey}`;\n    }\n\n    public async execute(\n        builder: GraphQLSchemaFactory.SchemaBuilder\n    ): Promise<GraphQLSchemaFactory.SchemaBuilder> {\n        const inputs = await this.loadInputs();\n        if (!inputs) {\n            return builder;\n        }\n\n        const { model, models } = inputs;\n        const typeDefs = renderTypeDefs({\n            model,\n            models,\n            fieldRegistry: this.fieldRegistry\n        });\n\n        builder.addTypeDefs(typeDefs);\n        addQueryResolvers(builder);\n        addMutationResolvers(builder);\n\n        return builder;\n    }\n\n    private async loadInputs() {\n        // There is no tenant until installation completes, and no model to render a schema from.\n        if (!this.tenantContext.getTenant()) {\n            return null;\n        }\n\n        const model = await this.modelProvider.get();\n\n        // The model list feeds `ref` field rendering. ListModels is filtered by permission, so it\n        // is read without authorization to keep the schema the same for every identity.\n        const models = await this.identityContext.withoutAuthorization(async () => {\n            const result = await this.listModelsUseCase.execute({ includePrivate: false });\n            if (result.isFail()) {\n                throw result.error;\n            }\n            return result.value;\n        });\n\n        return { model, models };\n    }\n}\n\nexport const RecordLockingGraphQLSchema = GraphQLSchemaFactory.createImplementation({\n    implementation: RecordLockingGraphQLSchemaImpl,\n    dependencies: [\n        TenantContext,\n        IdentityContext,\n        RecordLockingModelProvider,\n        ListModelsUseCase,\n        CmsModelFieldToGraphQLRegistry\n    ]\n});\n"],"names":["renderTypeDefs","params","model","fieldRegistry","models","recordLockingFields","renderFields","listFilterFieldsRender","renderListFilterFields","sortEnumRender","renderSortEnum","f","addQueryResolvers","builder","IdentityContext","IsEntryLockedUseCase","identityContext","useCase","args","resolve","checkPermissions","result","GetLockRecordUseCase","GetLockedEntryLockRecordUseCase","ListLockRecordsUseCase","resolveList","ListAllLockRecordsUseCase","addMutationResolvers","LockEntryUseCase","UpdateEntryLockUseCase","UnlockEntryUseCase","UnlockEntryRequestUseCase","RecordLockingGraphQLSchemaImpl","tenantContext","modelProvider","listModelsUseCase","inputs","modelKey","createModelSchemaKey","typeDefs","RecordLockingGraphQLSchema","GraphQLSchemaFactory","TenantContext","RecordLockingModelProvider","ListModelsUseCase","CmsModelFieldToGraphQLRegistry"],"mappings":"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"}

package/graphql/checkPermissions.d.ts

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

package/graphql/checkPermissions.js

@@ -1,14 +1,8 @@
-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();
-  }
+const checkPermissions = (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/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":[]}
+{"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\";\n\n/**\n * Simple permission check. Only authenticated users can access the record locking API via GraphQL.\n */\nexport const checkPermissions = (identityContext: IdentityContext.Interface): void => {\n    const identity = identityContext.getIdentity();\n\n    if (identity.isAnonymous()) {\n        throw new NotAuthorizedError();\n    }\n};\n"],"names":["checkPermissions","identityContext","identity","NotAuthorizedError"],"mappings":";AAMO,MAAMA,mBAAmB,CAACC;IAC7B,MAAMC,WAAWD,gBAAgB,WAAW;IAE5C,IAAIC,SAAS,WAAW,IACpB,MAAM,IAAIC;AAElB"}

package/graphql/resolve.d.ts

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

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);
-  }
+import { ErrorResponse, ListErrorResponse, ListResponse, Response } from "@webiny/api-graphql";
+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/api-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/index.d.ts

@@ -1,9 +1,2 @@
-import type { ApiCoreContext } from "@webiny/api-core/types/core.js";
-import { ContextPlugin } from "@webiny/api";
-export interface ICreateContextPluginParams {
-    /**
-     * A number of seconds after the last activity to wait before the record is automatically unlocked.
-     */
-    timeout?: number;
-}
-export declare const createRecordLocking: (params?: ICreateContextPluginParams) => ContextPlugin<ApiCoreContext>[];
+export { RecordLockingAppFeature } from "./RecordLockingAppFeature.js";
+export type { IRecordLockingAppFeatureParams } from "./RecordLockingAppFeature.js";