@webiny/api-record-locking 0.0.0-unstable.06b2ede40f → 0.0.0-unstable.0d717d18dd

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

package/features/UpdateEntryLock/abstractions.js.map

@@ -0,0 +1 @@
+{"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

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

package/features/UpdateEntryLock/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateEntryLockUseCase } from "./UpdateEntryLockUseCase.js";
+import { UpdateEntryLockRepository } from "./UpdateEntryLockRepository.js";
+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

@@ -0,0 +1 @@
+{"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.d.ts

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

package/features/UpdateEntryLock/index.js

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

package/graphql/RecordLockingContextualSchema.d.ts

@@ -0,0 +1,18 @@
+import type { GraphQLSchema } from "graphql";
+import type { IGraphQLContextualSchema } from "@webiny/api-graphql";
+import { WcpContext } from "@webiny/api-core/features/wcp/WcpContext/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { type IRecordLockingAppConfig } from "../domain/RecordLockingAppConfig.js";
+declare class RecordLockingContextualSchemaImpl implements IGraphQLContextualSchema {
+    private wcp;
+    private tenantCtx;
+    private identityCtx;
+    private config;
+    constructor(wcp: WcpContext.Interface, tenantCtx: TenantContext.Interface, identityCtx: IdentityContext.Interface, config: IRecordLockingAppConfig);
+    build(ctx: Record<string, any>): Promise<GraphQLSchema>;
+}
+export declare const RecordLockingContextualSchema: typeof RecordLockingContextualSchemaImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IGraphQLContextualSchema>;
+};
+export {};

package/graphql/RecordLockingContextualSchema.js

@@ -0,0 +1,77 @@
+import { makeExecutableSchema } from "@graphql-tools/schema";
+import { mergeResolvers } from "@graphql-tools/merge";
+import { GraphQLContextualSchema } from "@webiny/api-graphql";
+import { WcpContext } from "@webiny/api-core/features/wcp/WcpContext/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { createBaseContentSchema } from "@webiny/api-headless-cms/graphql/schema/baseContentSchema.js";
+import { RECORD_LOCKING_MODEL_ID } from "../domain/RecordLockingModel.js";
+import { RecordLockingAppConfig } from "../domain/RecordLockingAppConfig.js";
+import { RecordLockingFeature } from "../features/RecordLockingFeature.js";
+import { createGraphQLSchema } from "./schema.js";
+class RecordLockingContextualSchemaImpl {
+    constructor(wcp, tenantCtx, identityCtx, config){
+        this.wcp = wcp;
+        this.tenantCtx = tenantCtx;
+        this.identityCtx = identityCtx;
+        this.config = config;
+    }
+    async build(ctx) {
+        if (!this.wcp.canUseRecordLocking() || !this.tenantCtx.getTenant()) return makeExecutableSchema({
+            typeDefs: "type Query\ntype Mutation",
+            assumeValidSDL: true
+        });
+        const container = ctx.container;
+        const getModel = container.resolve(GetModelUseCase);
+        const listModels = container.resolve(ListModelsUseCase);
+        const fieldRegistry = container.resolve(CmsModelFieldToGraphQLRegistry);
+        const [model, publicModels] = await this.identityCtx.withoutAuthorization(async ()=>{
+            const [modelResult, publicModelsResult] = await Promise.all([
+                getModel.execute(RECORD_LOCKING_MODEL_ID),
+                listModels.execute({
+                    includePrivate: false
+                })
+            ]);
+            return [
+                modelResult.value,
+                publicModelsResult.value
+            ];
+        });
+        RecordLockingFeature.register(container, {
+            timeout: this.config.timeout,
+            model
+        });
+        const plugin = await createGraphQLSchema({
+            model,
+            models: publicModels,
+            fieldRegistry
+        });
+        const baseContent = createBaseContentSchema();
+        return makeExecutableSchema({
+            typeDefs: [
+                baseContent.schema.typeDefs,
+                plugin.schema.typeDefs
+            ],
+            resolvers: mergeResolvers([
+                baseContent.schema.resolvers,
+                plugin.schema.resolvers
+            ]),
+            inheritResolversFromInterfaces: true
+        });
+    }
+}
+const RecordLockingContextualSchema = GraphQLContextualSchema.createImplementation({
+    implementation: RecordLockingContextualSchemaImpl,
+    dependencies: [
+        WcpContext,
+        TenantContext,
+        IdentityContext,
+        RecordLockingAppConfig
+    ]
+});
+export { RecordLockingContextualSchema };
+
+//# sourceMappingURL=RecordLockingContextualSchema.js.map

package/graphql/RecordLockingContextualSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql/RecordLockingContextualSchema.js","sources":["../../src/graphql/RecordLockingContextualSchema.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport type { GraphQLSchema } from \"graphql\";\nimport { makeExecutableSchema } from \"@graphql-tools/schema\";\nimport { mergeResolvers } from \"@graphql-tools/merge\";\nimport { GraphQLContextualSchema } from \"@webiny/api-graphql\";\nimport type { IGraphQLContextualSchema } from \"@webiny/api-graphql\";\nimport { WcpContext } from \"@webiny/api-core/features/wcp/WcpContext/index.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel\";\nimport { ListModelsUseCase } from \"@webiny/api-headless-cms/features/contentModel/ListModels\";\nimport { CmsModelFieldToGraphQLRegistry } from \"@webiny/api-headless-cms/exports/api/cms/graphql.js\";\nimport { createBaseContentSchema } from \"@webiny/api-headless-cms/graphql/schema/baseContentSchema.js\";\nimport { RECORD_LOCKING_MODEL_ID } from \"~/domain/RecordLockingModel.js\";\nimport {\n    RecordLockingAppConfig,\n    type IRecordLockingAppConfig\n} from \"~/domain/RecordLockingAppConfig.js\";\nimport { RecordLockingFeature } from \"~/features/RecordLockingFeature.js\";\nimport { createGraphQLSchema } from \"~/graphql/schema.js\";\n\nclass RecordLockingContextualSchemaImpl implements IGraphQLContextualSchema {\n    constructor(\n        private wcp: WcpContext.Interface,\n        private tenantCtx: TenantContext.Interface,\n        private identityCtx: IdentityContext.Interface,\n        private config: IRecordLockingAppConfig\n    ) {}\n\n    async build(ctx: Record<string, any>): Promise<GraphQLSchema> {\n        if (!this.wcp.canUseRecordLocking() || !this.tenantCtx.getTenant()) {\n            return makeExecutableSchema({\n                typeDefs: \"type Query\\ntype Mutation\",\n                assumeValidSDL: true\n            });\n        }\n\n        const container = ctx.container as Container;\n\n        // Resolve the CMS use-cases lazily here (at build/request time) rather than as\n        // constructor dependencies. They depend on AccessControl/CmsContext, which the CMS\n        // initializer only registers during its own build() — so injecting them eagerly would\n        // fail when the engine constructs all contextual schemas before any build() has run.\n        const getModel = container.resolve(GetModelUseCase);\n        const listModels = container.resolve(ListModelsUseCase);\n        const fieldRegistry = container.resolve(CmsModelFieldToGraphQLRegistry);\n\n        const [model, publicModels] = await this.identityCtx.withoutAuthorization(async () => {\n            const [modelResult, publicModelsResult] = await Promise.all([\n                getModel.execute(RECORD_LOCKING_MODEL_ID),\n                listModels.execute({ includePrivate: false })\n            ]);\n\n            return [modelResult.value, publicModelsResult.value];\n        });\n\n        RecordLockingFeature.register(container, {\n            timeout: this.config.timeout,\n            model\n        });\n\n        const plugin = await createGraphQLSchema({\n            model,\n            models: publicModels,\n            fieldRegistry\n        });\n\n        // The generated record-locking model schema references CMS base scalars (DateTime, JSON,\n        // etc.). Include createBaseContentSchema() — which declares those scalars and their\n        // resolvers — exactly as the normal CMS schema build (buildSchemaPlugins) does, so this\n        // standalone schema is self-contained and valid before it is merged by the engine.\n        const baseContent = createBaseContentSchema();\n\n        return makeExecutableSchema({\n            typeDefs: [baseContent.schema.typeDefs as string, plugin.schema.typeDefs as string],\n            resolvers: mergeResolvers([\n                baseContent.schema.resolvers as any,\n                plugin.schema.resolvers as any\n            ]),\n            inheritResolversFromInterfaces: true\n        });\n    }\n}\n\nexport const RecordLockingContextualSchema = GraphQLContextualSchema.createImplementation({\n    implementation: RecordLockingContextualSchemaImpl,\n    dependencies: [WcpContext, TenantContext, IdentityContext, RecordLockingAppConfig]\n});\n"],"names":["RecordLockingContextualSchemaImpl","wcp","tenantCtx","identityCtx","config","ctx","makeExecutableSchema","container","getModel","GetModelUseCase","listModels","ListModelsUseCase","fieldRegistry","CmsModelFieldToGraphQLRegistry","model","publicModels","modelResult","publicModelsResult","Promise","RECORD_LOCKING_MODEL_ID","RecordLockingFeature","plugin","createGraphQLSchema","baseContent","createBaseContentSchema","mergeResolvers","RecordLockingContextualSchema","GraphQLContextualSchema","WcpContext","TenantContext","IdentityContext","RecordLockingAppConfig"],"mappings":";;;;;;;;;;;;;;AAqBA,MAAMA;IACF,YACYC,GAAyB,EACzBC,SAAkC,EAClCC,WAAsC,EACtCC,MAA+B,CACzC;aAJUH,GAAG,GAAHA;aACAC,SAAS,GAATA;aACAC,WAAW,GAAXA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,MAAMC,GAAwB,EAA0B;QAC1D,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,mBAAmB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,IAC5D,OAAOC,qBAAqB;YACxB,UAAU;YACV,gBAAgB;QACpB;QAGJ,MAAMC,YAAYF,IAAI,SAAS;QAM/B,MAAMG,WAAWD,UAAU,OAAO,CAACE;QACnC,MAAMC,aAAaH,UAAU,OAAO,CAACI;QACrC,MAAMC,gBAAgBL,UAAU,OAAO,CAACM;QAExC,MAAM,CAACC,OAAOC,aAAa,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,oBAAoB,CAAC;YACtE,MAAM,CAACC,aAAaC,mBAAmB,GAAG,MAAMC,QAAQ,GAAG,CAAC;gBACxDV,SAAS,OAAO,CAACW;gBACjBT,WAAW,OAAO,CAAC;oBAAE,gBAAgB;gBAAM;aAC9C;YAED,OAAO;gBAACM,YAAY,KAAK;gBAAEC,mBAAmB,KAAK;aAAC;QACxD;QAEAG,qBAAqB,QAAQ,CAACb,WAAW;YACrC,SAAS,IAAI,CAAC,MAAM,CAAC,OAAO;YAC5BO;QACJ;QAEA,MAAMO,SAAS,MAAMC,oBAAoB;YACrCR;YACA,QAAQC;YACRH;QACJ;QAMA,MAAMW,cAAcC;QAEpB,OAAOlB,qBAAqB;YACxB,UAAU;gBAACiB,YAAY,MAAM,CAAC,QAAQ;gBAAYF,OAAO,MAAM,CAAC,QAAQ;aAAW;YACnF,WAAWI,eAAe;gBACtBF,YAAY,MAAM,CAAC,SAAS;gBAC5BF,OAAO,MAAM,CAAC,SAAS;aAC1B;YACD,gCAAgC;QACpC;IACJ;AACJ;AAEO,MAAMK,gCAAgCC,wBAAwB,oBAAoB,CAAC;IACtF,gBAAgB3B;IAChB,cAAc;QAAC4B;QAAYC;QAAeC;QAAiBC;KAAuB;AACtF"}

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,10 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared";
+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

@@ -0,0 +1 @@
+{"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/{utils → graphql}/resolve.d.ts

@@ -1,8 +1,8 @@
-import { ErrorResponse, Response } from "@webiny/handler-graphql";
-import type { IRecordLockingMeta } from "../types";
-export declare const resolve: <T>(cb: () => Promise<T>) => Promise<ErrorResponse | Response<T>>;
+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> {
     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,20 @@
+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);
+    }
+};
+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

@@ -0,0 +1 @@
+{"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/graphql/schema.d.ts

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

package/graphql/schema.js

@@ -1,53 +1,47 @@
-"use strict";
-
-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;
+import { resolve, resolveList } from "./resolve.js";
+import { createGraphQLSchemaPlugin } from "@webiny/api-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";
+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 fieldTypePlugins = (0, _createFieldTypePluginRecords.createFieldTypePluginRecords)(context.plugins);
-  const recordLockingFields = (0, _renderFields.renderFields)({
-    models,
-    model,
-    fields: model.fields,
-    type: "manage",
-    fieldTypePlugins
-  });
-  const listFilterFieldsRender = (0, _renderListFilterFields.renderListFilterFields)({
-    model,
-    fields: model.fields,
-    type: "manage",
-    fieldTypePlugins,
-    excludeFields: ["entryId"]
-  });
-  const sortEnumRender = (0, _renderSortEnum.renderSortEnum)({
-    model,
-    fields: model.fields,
-    fieldTypePlugins,
-    sorterPlugins: []
-  });
-  const plugin = (0, _handlerGraphql.createGraphQLSchemaPlugin)({
-    typeDefs: /* GraphQL */`
-            ${recordLockingFields.map(f => f.typeDefs).join("\n")}
+    const plugin = createGraphQLSchemaPlugin({
+        typeDefs: `
+            ${recordLockingFields.map((f)=>f.typeDefs).join("\n")}
 
             type RecordLockingError {
                 message: String
@@ -82,7 +76,7 @@ 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 {
@@ -126,7 +120,7 @@ const createGraphQLSchema = async params => {
             }
 
             input RecordLockingListWhereInput {
-                ${listFilterFieldsRender}
+                ${listFilterFieldsRender.allFiltersAsString()}
             }
 
             enum RecordLockingListSorter {
@@ -179,102 +173,125 @@ const createGraphQLSchema = async params => {
                 recordLocking: RecordLockingMutation
             }
         `,
-    resolvers: {
-      Query: {
-        recordLocking: async () => ({})
-      },
-      Mutation: {
-        recordLocking: async () => ({})
-      },
-      RecordLockingQuery: {
-        async isEntryLocked(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return context.recordLocking.isEntryLocked({
-              id: args.id,
-              type: args.type
-            });
-          });
-        },
-        async getLockRecord(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            const result = await context.recordLocking.getLockRecord({
-              id: args.id,
-              type: args.type
-            });
-            if (result) {
-              return result;
+        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;
+                    });
+                }
             }
-            throw new _handlerGraphql.NotFoundError("Lock record not found.");
-          });
-        },
-        async getLockedEntryLockRecord(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.getLockedEntryLockRecord({
-              id: args.id,
-              type: args.type
-            });
-          });
-        },
-        async listLockRecords(_, args, context) {
-          return (0, _resolve.resolveList)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.listLockRecords(args);
-          });
-        },
-        listAllLockRecords(_, args, context) {
-          return (0, _resolve.resolveList)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.listAllLockRecords(args);
-          });
         }
-      },
-      RecordLockingMutation: {
-        async lockEntry(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return context.recordLocking.lockEntry({
-              id: args.id,
-              type: args.type
-            });
-          });
-        },
-        async updateEntryLock(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return context.recordLocking.updateEntryLock({
-              id: args.id,
-              type: args.type
-            });
-          });
-        },
-        async unlockEntry(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.unlockEntry({
-              id: args.id,
-              type: args.type,
-              force: args.force
-            });
-          });
-        },
-        async unlockEntryRequest(_, args, context) {
-          return (0, _resolve.resolve)(async () => {
-            await (0, _checkPermissions.checkPermissions)(context);
-            return await context.recordLocking.unlockEntryRequest({
-              id: args.id,
-              type: args.type
-            });
-          });
-        }
-      }
-    }
-  });
-  plugin.name = "recordLocking.graphql.schema.locking";
-  return plugin;
+    });
+    plugin.name = "recordLocking.graphql.schema.locking";
+    return plugin;
 };
-exports.createGraphQLSchema = createGraphQLSchema;
+export { createGraphQLSchema };
 
 //# sourceMappingURL=schema.js.map