@envelop/operation-field-permissions 9.0.1-alpha-20260116145543-f197583d9cd21e690cc9cff89254fcc8e1baa649 → 9.1.0-alpha-20260120163957-b4744604646cfe51bb9485f5a65ddd6bc24c2966

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dotan Simha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cjs/index.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOperationFieldPermissions = void 0;
+const graphql_1 = require("graphql");
+const core_1 = require("@envelop/core");
+const extended_validation_1 = require("@envelop/extended-validation");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+const OPERATION_PERMISSIONS_SYMBOL = Symbol('OPERATION_PERMISSIONS_SYMBOL');
+/**
+ * Returns a set of type names that allow access to all fields in the type.
+ */
+const getWildcardTypes = (scope) => {
+    const wildcardTypes = new Set();
+    for (const item of scope) {
+        if (item.endsWith('*')) {
+            const [typeName] = item.split('.');
+            wildcardTypes.add(typeName);
+        }
+    }
+    return wildcardTypes;
+};
+const toSet = (input) => typeof input === 'string' ? new Set([input]) : input;
+const getContext = (input) => {
+    if (typeof input !== 'object' || !input || !(OPERATION_PERMISSIONS_SYMBOL in input)) {
+        throw new Error('OperationScopeRule was used without context.');
+    }
+    return input[OPERATION_PERMISSIONS_SYMBOL];
+};
+/**
+ * Validate whether a user is allowed to execute a certain GraphQL operation.
+ */
+const OperationScopeRule = (options) => (context, executionArgs) => {
+    const permissionContext = getContext(executionArgs.contextValue);
+    const handleField = (node, objectType) => {
+        const schemaCoordinate = `${objectType.name}.${node.name.value}`;
+        if (!permissionContext.allowAll &&
+            !permissionContext.wildcardTypes.has(objectType.name) &&
+            !permissionContext.schemaCoordinates.has(schemaCoordinate)) {
+            // We should use GraphQLError once the object constructor lands in stable GraphQL.js
+            // and useMaskedErrors supports it.
+            const error = new graphql_1.GraphQLError(options.formatError(schemaCoordinate));
+            error.nodes = [node];
+            context.reportError(error);
+        }
+    };
+    return {
+        Field(node) {
+            const type = context.getType();
+            if (type) {
+                const namedType = (0, graphql_1.getNamedType)(type);
+                if ((0, graphql_1.isIntrospectionType)(namedType)) {
+                    return false;
+                }
+            }
+            const parentType = context.getParentType();
+            if (parentType) {
+                if ((0, graphql_1.isIntrospectionType)(parentType)) {
+                    return false;
+                }
+                // We handle objects, interface and union permissions differently.
+                // When accessing an an object field, we check simply run the check.
+                if ((0, graphql_1.isObjectType)(parentType)) {
+                    handleField(node, parentType);
+                }
+                // To allow a union case, every type in the union has to be allowed/
+                // If one of the types doesn't permit access we should throw a validation error.
+                if ((0, graphql_1.isUnionType)(parentType)) {
+                    for (const objectType of parentType.getTypes()) {
+                        handleField(node, objectType);
+                    }
+                }
+                // Same goes for interfaces. Every implementation should allow the access of the given
+                // field to pass the validation rule.
+                if ((0, graphql_1.isInterfaceType)(parentType)) {
+                    for (const objectType of executionArgs.schema.getImplementations(parentType).objects) {
+                        handleField(node, objectType);
+                    }
+                }
+            }
+            return undefined;
+        },
+    };
+};
+const defaultFormatError = (schemaCoordinate) => `Insufficient permissions for selecting '${schemaCoordinate}'.`;
+const useOperationFieldPermissions = (opts) => {
+    return {
+        onPluginInit({ addPlugin }) {
+            addPlugin((0, extended_validation_1.useExtendedValidation)({
+                rules: [
+                    OperationScopeRule({
+                        formatError: opts.formatError ?? defaultFormatError,
+                    }),
+                ],
+            }));
+            addPlugin((0, core_1.useExtendContext)(context => (0, promise_helpers_1.handleMaybePromise)(() => opts.getPermissions(context), permissions => {
+                // Schema coordinates is a set of type-name field-name strings that
+                // describe the position of a field in the schema.
+                const schemaCoordinates = toSet(permissions);
+                const wildcardTypes = getWildcardTypes(schemaCoordinates);
+                const scopeContext = {
+                    schemaCoordinates,
+                    wildcardTypes,
+                    allowAll: schemaCoordinates.has('*'),
+                };
+                return {
+                    [OPERATION_PERMISSIONS_SYMBOL]: scopeContext,
+                };
+            })));
+        },
+    };
+};
+exports.useOperationFieldPermissions = useOperationFieldPermissions;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/esm/index.js

@@ -0,0 +1,108 @@
+import { getNamedType, GraphQLError, isInterfaceType, isIntrospectionType, isObjectType, isUnionType, } from 'graphql';
+import { useExtendContext } from '@envelop/core';
+import { useExtendedValidation } from '@envelop/extended-validation';
+import { handleMaybePromise } from '@whatwg-node/promise-helpers';
+const OPERATION_PERMISSIONS_SYMBOL = Symbol('OPERATION_PERMISSIONS_SYMBOL');
+/**
+ * Returns a set of type names that allow access to all fields in the type.
+ */
+const getWildcardTypes = (scope) => {
+    const wildcardTypes = new Set();
+    for (const item of scope) {
+        if (item.endsWith('*')) {
+            const [typeName] = item.split('.');
+            wildcardTypes.add(typeName);
+        }
+    }
+    return wildcardTypes;
+};
+const toSet = (input) => typeof input === 'string' ? new Set([input]) : input;
+const getContext = (input) => {
+    if (typeof input !== 'object' || !input || !(OPERATION_PERMISSIONS_SYMBOL in input)) {
+        throw new Error('OperationScopeRule was used without context.');
+    }
+    return input[OPERATION_PERMISSIONS_SYMBOL];
+};
+/**
+ * Validate whether a user is allowed to execute a certain GraphQL operation.
+ */
+const OperationScopeRule = (options) => (context, executionArgs) => {
+    const permissionContext = getContext(executionArgs.contextValue);
+    const handleField = (node, objectType) => {
+        const schemaCoordinate = `${objectType.name}.${node.name.value}`;
+        if (!permissionContext.allowAll &&
+            !permissionContext.wildcardTypes.has(objectType.name) &&
+            !permissionContext.schemaCoordinates.has(schemaCoordinate)) {
+            // We should use GraphQLError once the object constructor lands in stable GraphQL.js
+            // and useMaskedErrors supports it.
+            const error = new GraphQLError(options.formatError(schemaCoordinate));
+            error.nodes = [node];
+            context.reportError(error);
+        }
+    };
+    return {
+        Field(node) {
+            const type = context.getType();
+            if (type) {
+                const namedType = getNamedType(type);
+                if (isIntrospectionType(namedType)) {
+                    return false;
+                }
+            }
+            const parentType = context.getParentType();
+            if (parentType) {
+                if (isIntrospectionType(parentType)) {
+                    return false;
+                }
+                // We handle objects, interface and union permissions differently.
+                // When accessing an an object field, we check simply run the check.
+                if (isObjectType(parentType)) {
+                    handleField(node, parentType);
+                }
+                // To allow a union case, every type in the union has to be allowed/
+                // If one of the types doesn't permit access we should throw a validation error.
+                if (isUnionType(parentType)) {
+                    for (const objectType of parentType.getTypes()) {
+                        handleField(node, objectType);
+                    }
+                }
+                // Same goes for interfaces. Every implementation should allow the access of the given
+                // field to pass the validation rule.
+                if (isInterfaceType(parentType)) {
+                    for (const objectType of executionArgs.schema.getImplementations(parentType).objects) {
+                        handleField(node, objectType);
+                    }
+                }
+            }
+            return undefined;
+        },
+    };
+};
+const defaultFormatError = (schemaCoordinate) => `Insufficient permissions for selecting '${schemaCoordinate}'.`;
+export const useOperationFieldPermissions = (opts) => {
+    return {
+        onPluginInit({ addPlugin }) {
+            addPlugin(useExtendedValidation({
+                rules: [
+                    OperationScopeRule({
+                        formatError: opts.formatError ?? defaultFormatError,
+                    }),
+                ],
+            }));
+            addPlugin(useExtendContext(context => handleMaybePromise(() => opts.getPermissions(context), permissions => {
+                // Schema coordinates is a set of type-name field-name strings that
+                // describe the position of a field in the schema.
+                const schemaCoordinates = toSet(permissions);
+                const wildcardTypes = getWildcardTypes(schemaCoordinates);
+                const scopeContext = {
+                    schemaCoordinates,
+                    wildcardTypes,
+                    allowAll: schemaCoordinates.has('*'),
+                };
+                return {
+                    [OPERATION_PERMISSIONS_SYMBOL]: scopeContext,
+                };
+            })));
+        },
+    };
+};

package/package.json

@@ -1,10 +1,19 @@
 {
   "name": "@envelop/operation-field-permissions",
-  "version": "9.0.1-alpha-20260116145543-f197583d9cd21e690cc9cff89254fcc8e1baa649",
-  "type": "module",
+  "version": "9.1.0-alpha-20260120163957-b4744604646cfe51bb9485f5a65ddd6bc24c2966",
+  "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0",
+    "@envelop/core": "^5.5.0-alpha-20260120163957-b4744604646cfe51bb9485f5a65ddd6bc24c2966"
+  },
+  "dependencies": {
+    "@whatwg-node/promise-helpers": "^1.2.4",
+    "tslib": "^2.5.0",
+    "@envelop/extended-validation": "^7.1.0-alpha-20260120163957-b4744604646cfe51bb9485f5a65ddd6bc24c2966"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/graphql-hive/graphql-yoga",
+    "url": "https://github.com/graphql-hive/envelop.git",
     "directory": "packages/plugins/operation-field-permissions"
   },
   "author": "Laurin Quast <laurinquast@googlemail.com.com>",
@@ -12,71 +21,42 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "main": "dist/index.cjs",
-  "typings": "dist/index.d.mts",
-  "module": "dist/index.mjs",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
   "exports": {
     ".": {
       "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
       },
       "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
       },
       "default": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
       }
     },
     "./*": {
       "require": {
-        "types": "./dist/*.d.cts",
-        "default": "./dist/*.cjs"
+        "types": "./typings/*.d.cts",
+        "default": "./cjs/*.js"
       },
       "import": {
-        "types": "./dist/*.d.mts",
-        "default": "./dist/*.mjs"
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
       },
       "default": {
-        "types": "./dist/*.d.mts",
-        "default": "./dist/*.mjs"
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
       }
     },
     "./package.json": "./package.json"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsdown",
-    "check": "tsc --pretty --noEmit"
-  },
-  "peerDependencies": {
-    "@envelop/core": "workspace:^",
-    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
-  },
-  "dependencies": {
-    "@envelop/extended-validation": "workspace:^",
-    "@whatwg-node/promise-helpers": "^1.2.4",
-    "tslib": "^2.5.0"
-  },
-  "devDependencies": {
-    "@envelop/core": "workspace:^",
-    "@graphql-tools/schema": "10.0.30",
-    "graphql": "16.12.0",
-    "tsdown": "^0.20.0-beta.1",
-    "typescript": "5.9.3"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "sideEffects": false,
-  "buildOptions": {
-    "input": "./src/index.ts"
-  },
-  "typescript": {
-    "definition": "dist/index.d.mts"
   }
-}
+}

package/typings/index.d.cts

@@ -0,0 +1,18 @@
+import { Plugin, PromiseOrValue } from '@envelop/core';
+declare const OPERATION_PERMISSIONS_SYMBOL: unique symbol;
+type ScopeContext = {
+    allowAll: boolean;
+    wildcardTypes: Set<string>;
+    schemaCoordinates: Set<string>;
+};
+type OperationScopeRuleOptions = {
+    formatError: (schemaCoordinate: string) => string;
+};
+type OperationScopeOptions<TContext> = {
+    getPermissions: (context: TContext) => PromiseOrValue<Set<string> | string>;
+    formatError?: OperationScopeRuleOptions['formatError'];
+};
+export declare const useOperationFieldPermissions: <TContext>(opts: OperationScopeOptions<TContext>) => Plugin<{
+    [OPERATION_PERMISSIONS_SYMBOL]: ScopeContext;
+}>;
+export {};

package/typings/index.d.ts

@@ -0,0 +1,18 @@
+import { Plugin, PromiseOrValue } from '@envelop/core';
+declare const OPERATION_PERMISSIONS_SYMBOL: unique symbol;
+type ScopeContext = {
+    allowAll: boolean;
+    wildcardTypes: Set<string>;
+    schemaCoordinates: Set<string>;
+};
+type OperationScopeRuleOptions = {
+    formatError: (schemaCoordinate: string) => string;
+};
+type OperationScopeOptions<TContext> = {
+    getPermissions: (context: TContext) => PromiseOrValue<Set<string> | string>;
+    formatError?: OperationScopeRuleOptions['formatError'];
+};
+export declare const useOperationFieldPermissions: <TContext>(opts: OperationScopeOptions<TContext>) => Plugin<{
+    [OPERATION_PERMISSIONS_SYMBOL]: ScopeContext;
+}>;
+export {};

package/dist/index.cjs

@@ -1,68 +0,0 @@
-let graphql = require("graphql");
-let _envelop_core = require("@envelop/core");
-let _envelop_extended_validation = require("@envelop/extended-validation");
-let _whatwg_node_promise_helpers = require("@whatwg-node/promise-helpers");
-
-//#region src/index.ts
-const OPERATION_PERMISSIONS_SYMBOL = Symbol("OPERATION_PERMISSIONS_SYMBOL");
-/**
-* Returns a set of type names that allow access to all fields in the type.
-*/
-const getWildcardTypes = (scope) => {
-	const wildcardTypes = /* @__PURE__ */ new Set();
-	for (const item of scope) if (item.endsWith("*")) {
-		const typeName = item.split(".")[0];
-		wildcardTypes.add(typeName);
-	}
-	return wildcardTypes;
-};
-const toSet = (input) => typeof input === "string" ? new Set([input]) : input;
-const getContext = (input) => {
-	if (typeof input !== "object" || !input || !(OPERATION_PERMISSIONS_SYMBOL in input)) throw new Error("OperationScopeRule was used without context.");
-	return input[OPERATION_PERMISSIONS_SYMBOL];
-};
-/**
-* Validate whether a user is allowed to execute a certain GraphQL operation.
-*/
-const OperationScopeRule = (options) => (context, executionArgs) => {
-	const permissionContext = getContext(executionArgs.contextValue);
-	const handleField = (node, objectType) => {
-		const schemaCoordinate = `${objectType.name}.${node.name.value}`;
-		if (!permissionContext.allowAll && !permissionContext.wildcardTypes.has(objectType.name) && !permissionContext.schemaCoordinates.has(schemaCoordinate)) {
-			const error = new graphql.GraphQLError(options.formatError(schemaCoordinate));
-			error.nodes = [node];
-			context.reportError(error);
-		}
-	};
-	return { Field(node) {
-		const type = context.getType();
-		if (type) {
-			if ((0, graphql.isIntrospectionType)((0, graphql.getNamedType)(type))) return false;
-		}
-		const parentType = context.getParentType();
-		if (parentType) {
-			if ((0, graphql.isIntrospectionType)(parentType)) return false;
-			if ((0, graphql.isObjectType)(parentType)) handleField(node, parentType);
-			if ((0, graphql.isUnionType)(parentType)) for (const objectType of parentType.getTypes()) handleField(node, objectType);
-			if ((0, graphql.isInterfaceType)(parentType)) for (const objectType of executionArgs.schema.getImplementations(parentType).objects) handleField(node, objectType);
-		}
-	} };
-};
-const defaultFormatError = (schemaCoordinate) => `Insufficient permissions for selecting '${schemaCoordinate}'.`;
-const useOperationFieldPermissions = (opts) => {
-	return { onPluginInit({ addPlugin }) {
-		addPlugin((0, _envelop_extended_validation.useExtendedValidation)({ rules: [OperationScopeRule({ formatError: opts.formatError ?? defaultFormatError })] }));
-		addPlugin((0, _envelop_core.useExtendContext)((context) => (0, _whatwg_node_promise_helpers.handleMaybePromise)(() => opts.getPermissions(context), (permissions) => {
-			const schemaCoordinates = toSet(permissions);
-			const scopeContext = {
-				schemaCoordinates,
-				wildcardTypes: getWildcardTypes(schemaCoordinates),
-				allowAll: schemaCoordinates.has("*")
-			};
-			return { [OPERATION_PERMISSIONS_SYMBOL]: scopeContext };
-		})));
-	} };
-};
-
-//#endregion
-exports.useOperationFieldPermissions = useOperationFieldPermissions;

package/dist/index.d.cts

@@ -1,21 +0,0 @@
-import { Plugin, PromiseOrValue } from "@envelop/core";
-
-//#region src/index.d.ts
-declare const OPERATION_PERMISSIONS_SYMBOL: unique symbol;
-type ScopeContext = {
-  allowAll: boolean;
-  wildcardTypes: Set<string>;
-  schemaCoordinates: Set<string>;
-};
-type OperationScopeRuleOptions = {
-  formatError: (schemaCoordinate: string) => string;
-};
-type OperationScopeOptions<TContext> = {
-  getPermissions: (context: TContext) => PromiseOrValue<Set<string> | string>;
-  formatError?: OperationScopeRuleOptions['formatError'];
-};
-declare const useOperationFieldPermissions: <TContext>(opts: OperationScopeOptions<TContext>) => Plugin<{
-  [OPERATION_PERMISSIONS_SYMBOL]: ScopeContext;
-}>;
-//#endregion
-export { useOperationFieldPermissions };

package/dist/index.d.mts

@@ -1,21 +0,0 @@
-import { Plugin, PromiseOrValue } from "@envelop/core";
-
-//#region src/index.d.ts
-declare const OPERATION_PERMISSIONS_SYMBOL: unique symbol;
-type ScopeContext = {
-  allowAll: boolean;
-  wildcardTypes: Set<string>;
-  schemaCoordinates: Set<string>;
-};
-type OperationScopeRuleOptions = {
-  formatError: (schemaCoordinate: string) => string;
-};
-type OperationScopeOptions<TContext> = {
-  getPermissions: (context: TContext) => PromiseOrValue<Set<string> | string>;
-  formatError?: OperationScopeRuleOptions['formatError'];
-};
-declare const useOperationFieldPermissions: <TContext>(opts: OperationScopeOptions<TContext>) => Plugin<{
-  [OPERATION_PERMISSIONS_SYMBOL]: ScopeContext;
-}>;
-//#endregion
-export { useOperationFieldPermissions };

package/dist/index.mjs

@@ -1,68 +0,0 @@
-import { GraphQLError, getNamedType, isInterfaceType, isIntrospectionType, isObjectType, isUnionType } from "graphql";
-import { useExtendContext } from "@envelop/core";
-import { useExtendedValidation } from "@envelop/extended-validation";
-import { handleMaybePromise } from "@whatwg-node/promise-helpers";
-
-//#region src/index.ts
-const OPERATION_PERMISSIONS_SYMBOL = Symbol("OPERATION_PERMISSIONS_SYMBOL");
-/**
-* Returns a set of type names that allow access to all fields in the type.
-*/
-const getWildcardTypes = (scope) => {
-	const wildcardTypes = /* @__PURE__ */ new Set();
-	for (const item of scope) if (item.endsWith("*")) {
-		const typeName = item.split(".")[0];
-		wildcardTypes.add(typeName);
-	}
-	return wildcardTypes;
-};
-const toSet = (input) => typeof input === "string" ? new Set([input]) : input;
-const getContext = (input) => {
-	if (typeof input !== "object" || !input || !(OPERATION_PERMISSIONS_SYMBOL in input)) throw new Error("OperationScopeRule was used without context.");
-	return input[OPERATION_PERMISSIONS_SYMBOL];
-};
-/**
-* Validate whether a user is allowed to execute a certain GraphQL operation.
-*/
-const OperationScopeRule = (options) => (context, executionArgs) => {
-	const permissionContext = getContext(executionArgs.contextValue);
-	const handleField = (node, objectType) => {
-		const schemaCoordinate = `${objectType.name}.${node.name.value}`;
-		if (!permissionContext.allowAll && !permissionContext.wildcardTypes.has(objectType.name) && !permissionContext.schemaCoordinates.has(schemaCoordinate)) {
-			const error = new GraphQLError(options.formatError(schemaCoordinate));
-			error.nodes = [node];
-			context.reportError(error);
-		}
-	};
-	return { Field(node) {
-		const type = context.getType();
-		if (type) {
-			if (isIntrospectionType(getNamedType(type))) return false;
-		}
-		const parentType = context.getParentType();
-		if (parentType) {
-			if (isIntrospectionType(parentType)) return false;
-			if (isObjectType(parentType)) handleField(node, parentType);
-			if (isUnionType(parentType)) for (const objectType of parentType.getTypes()) handleField(node, objectType);
-			if (isInterfaceType(parentType)) for (const objectType of executionArgs.schema.getImplementations(parentType).objects) handleField(node, objectType);
-		}
-	} };
-};
-const defaultFormatError = (schemaCoordinate) => `Insufficient permissions for selecting '${schemaCoordinate}'.`;
-const useOperationFieldPermissions = (opts) => {
-	return { onPluginInit({ addPlugin }) {
-		addPlugin(useExtendedValidation({ rules: [OperationScopeRule({ formatError: opts.formatError ?? defaultFormatError })] }));
-		addPlugin(useExtendContext((context) => handleMaybePromise(() => opts.getPermissions(context), (permissions) => {
-			const schemaCoordinates = toSet(permissions);
-			const scopeContext = {
-				schemaCoordinates,
-				wildcardTypes: getWildcardTypes(schemaCoordinates),
-				allowAll: schemaCoordinates.has("*")
-			};
-			return { [OPERATION_PERMISSIONS_SYMBOL]: scopeContext };
-		})));
-	} };
-};
-
-//#endregion
-export { useOperationFieldPermissions };