graphql-shield-node23 7.6.5

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# graphql-shield
+
+## 7.6.5
+
+### Patch Changes
+
+- [#1493](https://github.com/dimatill/graphql-shield/pull/1493) [`00d3c47`](https://github.com/dimatill/graphql-shield/commit/00d3c4764900e8835ae7c586ebe6a2e7f25fd688) Thanks [@dimatill](https://github.com/dimatill)! - ESM build fix
+
+## 7.6.4
+
+### Patch Changes
+
+- [#1470](https://github.com/dimatill/graphql-shield/pull/1470) [`ddf293e`](https://github.com/dimatill/graphql-shield/commit/ddf293e2554e31bf0de8eee00d07bdf58e4f8a8b) Thanks [@mhassan1](https://github.com/mhassan1)! - fix(deps): add missing `tslib` dependency
+
+## 7.6.3
+
+### Patch Changes
+
+- [#1461](https://github.com/dimatill/graphql-shield/pull/1461) [`9b35bb7`](https://github.com/dimatill/graphql-shield/commit/9b35bb7184f8da7111c8524f01a33411e4693b79) Thanks [@dimatill](https://github.com/dimatill)! - fix wildcard rules are not reusable
+
+## 7.6.1
+
+### Patch Changes
+
+- 0da0a61: fix corrupted release
+
+## 7.6.0
+
+### Minor Changes
+
+- 32b91fe: Bump Package Dependencies

package/dist/cjs/constructors.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deny = exports.allow = exports.not = exports.or = exports.race = exports.chain = exports.and = exports.inputRule = exports.rule = void 0;
+const rules_js_1 = require("./rules.js");
+/**
+ *
+ * @param name
+ * @param options
+ *
+ * Wraps a function into a Rule class. This way we can identify rules
+ * once we start generating middleware from our ruleTree.
+ *
+ * 1.
+ * const auth = rule()(async (parent, args, ctx, info) => {
+ *  return true
+ * })
+ *
+ * 2.
+ * const auth = rule('name')(async (parent, args, ctx, info) => {
+ *  return true
+ * })
+ *
+ * 3.
+ * const auth = rule({
+ *  name: 'name',
+ *  fragment: 'string',
+ *  cache: 'cache',
+ * })(async (parent, args, ctx, info) => {
+ *  return true
+ * })
+ *
+ */
+const rule = (name, options) => (func) => {
+    if (typeof name === 'object') {
+        options = name;
+        name = Math.random().toString();
+    }
+    else if (typeof name === 'string') {
+        options = options || {};
+    }
+    else {
+        name = Math.random().toString();
+        options = {};
+    }
+    return new rules_js_1.Rule(name, func, {
+        fragment: options.fragment,
+        cache: options.cache,
+    });
+};
+exports.rule = rule;
+/**
+ *
+ * Constructs a new InputRule based on the schema.
+ *
+ * @param schema
+ */
+const inputRule = (name) => (schema, options) => {
+    if (typeof name === 'string') {
+        return new rules_js_1.InputRule(name, schema, options);
+    }
+    else {
+        return new rules_js_1.InputRule(Math.random().toString(), schema, options);
+    }
+};
+exports.inputRule = inputRule;
+/**
+ *
+ * @param rules
+ *
+ * Logical operator and serves as a wrapper for and operation.
+ *
+ */
+const and = (...rules) => {
+    return new rules_js_1.RuleAnd(rules);
+};
+exports.and = and;
+/**
+ *
+ * @param rules
+ *
+ * Logical operator and serves as a wrapper for and operation.
+ *
+ */
+const chain = (...rules) => {
+    return new rules_js_1.RuleChain(rules);
+};
+exports.chain = chain;
+/**
+ *
+ * @param rules
+ *
+ * Logical operator and serves as a wrapper for and operation.
+ *
+ */
+const race = (...rules) => {
+    return new rules_js_1.RuleRace(rules);
+};
+exports.race = race;
+/**
+ *
+ * @param rules
+ *
+ * Logical operator or serves as a wrapper for or operation.
+ *
+ */
+const or = (...rules) => {
+    return new rules_js_1.RuleOr(rules);
+};
+exports.or = or;
+/**
+ *
+ * @param rule
+ *
+ * Logical operator not serves as a wrapper for not operation.
+ *
+ */
+const not = (rule, error) => {
+    if (typeof error === 'string')
+        return new rules_js_1.RuleNot(rule, new Error(error));
+    return new rules_js_1.RuleNot(rule, error);
+};
+exports.not = not;
+/**
+ *
+ * Allow queries.
+ *
+ */
+exports.allow = new rules_js_1.RuleTrue();
+/**
+ *
+ * Deny queries.
+ *
+ */
+exports.deny = new rules_js_1.RuleFalse();

package/dist/cjs/generator.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMiddlewareGeneratorFromRuleTree = void 0;
+const graphql_1 = require("graphql");
+const utils_js_1 = require("./utils.js");
+const validation_js_1 = require("./validation.js");
+/**
+ *
+ * @param options
+ *
+ * Generates a middleware function from a given rule and
+ * initializes the cache object in context.
+ *
+ */
+function generateFieldMiddlewareFromRule(rule, options) {
+    async function middleware(resolve, parent, args, ctx, info) {
+        // Cache
+        if (!ctx) {
+            ctx = {};
+        }
+        if (!ctx._shield) {
+            ctx._shield = {
+                cache: {},
+            };
+        }
+        // Execution
+        try {
+            const res = await rule.resolve(parent, args, ctx, info, options);
+            if (res === true) {
+                return await resolve(parent, args, ctx, info);
+            }
+            else if (res === false) {
+                if (typeof options.fallbackError === 'function') {
+                    return await options.fallbackError(null, parent, args, ctx, info);
+                }
+                return options.fallbackError;
+            }
+            else {
+                return res;
+            }
+        }
+        catch (err) {
+            if (options.debug) {
+                throw err;
+            }
+            else if (options.allowExternalErrors) {
+                return err;
+            }
+            else {
+                if (typeof options.fallbackError === 'function') {
+                    return await options.fallbackError(err, parent, args, ctx, info);
+                }
+                return options.fallbackError;
+            }
+        }
+    }
+    if ((0, utils_js_1.isRule)(rule) && rule.extractFragment()) {
+        return {
+            fragment: rule.extractFragment(),
+            resolve: middleware,
+        };
+    }
+    if ((0, utils_js_1.isLogicRule)(rule)) {
+        return {
+            fragments: rule.extractFragments(),
+            resolve: middleware,
+        };
+    }
+    return middleware;
+}
+/**
+ *
+ * @param type
+ * @param rules
+ * @param options
+ *
+ * Generates middleware from rule for a particular type.
+ *
+ */
+function applyRuleToType(type, rules, options) {
+    if ((0, utils_js_1.isRuleFunction)(rules)) {
+        /* Apply defined rule function to every field */
+        const fieldMap = type.getFields();
+        const middleware = Object.keys(fieldMap).reduce((middleware, field) => {
+            return {
+                ...middleware,
+                [field]: generateFieldMiddlewareFromRule(rules, options),
+            };
+        }, {});
+        return middleware;
+    }
+    else if ((0, utils_js_1.isRuleFieldMap)(rules)) {
+        /* Apply rules assigned to each field to each field */
+        const fieldMap = type.getFields();
+        /* Extract default type wildcard if any and remove it for validation */
+        const defaultTypeRule = rules['*'];
+        const { '*': _, ...rulesWithoutWildcard } = rules;
+        /* Validation */
+        const fieldErrors = Object.keys(rulesWithoutWildcard)
+            .filter((type) => !Object.prototype.hasOwnProperty.call(fieldMap, type))
+            .map((field) => `${type.name}.${field}`)
+            .join(', ');
+        if (fieldErrors.length > 0) {
+            throw new validation_js_1.ValidationError(`It seems like you have applied rules to ${fieldErrors} fields but Shield cannot find them in your schema.`);
+        }
+        /* Generation */
+        const middleware = Object.keys(fieldMap).reduce((middleware, field) => ({
+            ...middleware,
+            [field]: generateFieldMiddlewareFromRule((0, utils_js_1.withDefault)(defaultTypeRule || options.fallbackRule)(rules[field]), options),
+        }), {});
+        return middleware;
+    }
+    else {
+        /* Apply fallbackRule to type with no defined rule */
+        const fieldMap = type.getFields();
+        const middleware = Object.keys(fieldMap).reduce((middleware, field) => ({
+            ...middleware,
+            [field]: generateFieldMiddlewareFromRule(options.fallbackRule, options),
+        }), {});
+        return middleware;
+    }
+}
+/**
+ *
+ * @param schema
+ * @param rule
+ * @param options
+ *
+ * Applies the same rule over entire schema.
+ *
+ */
+function applyRuleToSchema(schema, rule, options) {
+    const typeMap = schema.getTypeMap();
+    const middleware = Object.keys(typeMap)
+        .filter((type) => !(0, graphql_1.isIntrospectionType)(typeMap[type]))
+        .reduce((middleware, typeName) => {
+        const type = typeMap[typeName];
+        if ((0, graphql_1.isObjectType)(type)) {
+            return {
+                ...middleware,
+                [typeName]: applyRuleToType(type, rule, options),
+            };
+        }
+        else {
+            return middleware;
+        }
+    }, {});
+    return middleware;
+}
+/**
+ *
+ * @param rules
+ * @param wrapper
+ *
+ * Converts rule tree to middleware.
+ *
+ */
+function generateMiddlewareFromSchemaAndRuleTree(schema, rules, options) {
+    if ((0, utils_js_1.isRuleFunction)(rules)) {
+        /* Applies rule to entire schema. */
+        return applyRuleToSchema(schema, rules, options);
+    }
+    else {
+        /**
+         * Checks type map and field map and applies rules
+         * to particular fields.
+         */
+        const typeMap = schema.getTypeMap();
+        /* Validation */
+        const typeErrors = Object.keys(rules)
+            .filter((type) => !Object.prototype.hasOwnProperty.call(typeMap, type))
+            .join(', ');
+        if (typeErrors.length > 0) {
+            throw new validation_js_1.ValidationError(`It seems like you have applied rules to ${typeErrors} types but Shield cannot find them in your schema.`);
+        }
+        // Generation
+        const middleware = Object.keys(typeMap)
+            .filter((type) => !(0, graphql_1.isIntrospectionType)(typeMap[type]))
+            .reduce((middleware, typeName) => {
+            const type = typeMap[typeName];
+            if ((0, graphql_1.isObjectType)(type)) {
+                return {
+                    ...middleware,
+                    [typeName]: applyRuleToType(type, rules[typeName], options),
+                };
+            }
+            else {
+                return middleware;
+            }
+        }, {});
+        return middleware;
+    }
+}
+/**
+ *
+ * @param ruleTree
+ * @param options
+ *
+ * Generates middleware from given rules.
+ *
+ */
+function generateMiddlewareGeneratorFromRuleTree(ruleTree, options) {
+    return (schema) => generateMiddlewareFromSchemaAndRuleTree(schema, ruleTree, options);
+}
+exports.generateMiddlewareGeneratorFromRuleTree = generateMiddlewareGeneratorFromRuleTree;

package/dist/cjs/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.not = exports.or = exports.race = exports.chain = exports.and = exports.deny = exports.allow = exports.inputRule = exports.rule = exports.shield = void 0;
+var shield_js_1 = require("./shield.js");
+Object.defineProperty(exports, "shield", { enumerable: true, get: function () { return shield_js_1.shield; } });
+var constructors_js_1 = require("./constructors.js");
+Object.defineProperty(exports, "rule", { enumerable: true, get: function () { return constructors_js_1.rule; } });
+Object.defineProperty(exports, "inputRule", { enumerable: true, get: function () { return constructors_js_1.inputRule; } });
+Object.defineProperty(exports, "allow", { enumerable: true, get: function () { return constructors_js_1.allow; } });
+Object.defineProperty(exports, "deny", { enumerable: true, get: function () { return constructors_js_1.deny; } });
+Object.defineProperty(exports, "and", { enumerable: true, get: function () { return constructors_js_1.and; } });
+Object.defineProperty(exports, "chain", { enumerable: true, get: function () { return constructors_js_1.chain; } });
+Object.defineProperty(exports, "race", { enumerable: true, get: function () { return constructors_js_1.race; } });
+Object.defineProperty(exports, "or", { enumerable: true, get: function () { return constructors_js_1.or; } });
+Object.defineProperty(exports, "not", { enumerable: true, get: function () { return constructors_js_1.not; } });

package/dist/cjs/package.json

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