graphql-shield-node23 7.6.5

package/src/utils.ts

@@ -0,0 +1,101 @@
+import { ShieldRule, ILogicRule, IRuleFieldMap, IRule } from './types.js'
+import { Rule, LogicRule } from './rules.js'
+
+/**
+ *
+ * @param x
+ *
+ * Makes sure that a certain field is a rule.
+ *
+ */
+export function isRule(x: any): x is IRule {
+  return (
+    x instanceof Rule || (x && x.constructor && x.constructor.name === 'Rule')
+  )
+}
+
+/**
+ *
+ * @param x
+ *
+ * Makes sure that a certain field is a logic rule.
+ *
+ */
+export function isLogicRule(x: any): x is ILogicRule {
+  return (
+    x instanceof LogicRule ||
+    (x &&
+      x.constructor &&
+      (x.constructor.name === 'RuleOr' ||
+        x.constructor.name === 'RuleAnd' ||
+        x.constructor.name === 'RuleChain' ||
+        x.constructor.name === 'RuleRace' ||
+        x.constructor.name === 'RuleNot' ||
+        x.constructor.name === 'RuleTrue' ||
+        x.constructor.name === 'RuleFalse'))
+  )
+}
+
+/**
+ *
+ * @param x
+ *
+ * Makes sure that a certain field is a rule or a logic rule.
+ *
+ */
+export function isRuleFunction(x: any): x is ShieldRule {
+  return isRule(x) || isLogicRule(x)
+}
+
+/**
+ *
+ * @param x
+ *
+ * Determines whether a certain field is rule field map or not.
+ *
+ */
+export function isRuleFieldMap(x: any): x is IRuleFieldMap {
+  return (
+    typeof x === 'object' &&
+    Object.values(x).every((rule) => isRuleFunction(rule))
+  )
+}
+
+/**
+ *
+ * @param obj
+ * @param func
+ *
+ * Flattens object of particular type by checking if the leaf
+ * evaluates to true from particular function.
+ *
+ */
+export function flattenObjectOf<T>(
+  obj: { [key: string]: any },
+  f: (x: any) => boolean,
+): T[] {
+  const values = Object.keys(obj).reduce<T[]>((acc, key) => {
+    const val = obj[key]
+    if (f(val)) {
+      return [...acc, val]
+    } else if (typeof val === 'object' && !f(val)) {
+      return [...acc, ...flattenObjectOf(val, f)]
+    } else {
+      return acc
+    }
+  }, [])
+  return values
+}
+
+/**
+ *
+ * Returns fallback is provided value is undefined
+ *
+ * @param fallback
+ */
+export function withDefault<T>(fallback: T): (value: T | undefined) => T {
+  return (value) => {
+    if (value === undefined) return fallback
+    return value
+  }
+}

package/src/validation.ts

@@ -0,0 +1,90 @@
+import { IRules, ShieldRule, ILogicRule, IRule } from './types.js'
+import { isRuleFunction, flattenObjectOf, isLogicRule } from './utils.js'
+
+/**
+ *
+ * @param ruleTree
+ *
+ * Validates the rule tree declaration by checking references of rule
+ * functions. We deem rule tree valid if no two rules with the same name point
+ * to different rules.
+ *
+ */
+export function validateRuleTree(
+  ruleTree: IRules,
+): { status: 'ok' } | { status: 'err'; message: string } {
+  const rules = extractRules(ruleTree)
+
+  const valid = rules.reduce<{ map: Map<string, IRule>; duplicates: string[] }>(
+    ({ map, duplicates }, rule) => {
+      if (!map.has(rule.name)) {
+        return { map: map.set(rule.name, rule), duplicates }
+      } else if (
+        !map.get(rule.name)!.equals(rule) &&
+        !duplicates.includes(rule.name)
+      ) {
+        return {
+          map: map.set(rule.name, rule),
+          duplicates: [...duplicates, rule.name],
+        }
+      } else {
+        return { map, duplicates }
+      }
+    },
+    { map: new Map<string, IRule>(), duplicates: [] },
+  )
+
+  if (valid.duplicates.length === 0) {
+    return { status: 'ok' }
+  } else {
+    const duplicates = valid.duplicates.join(', ')
+    return {
+      status: 'err',
+      message: `There seem to be multiple definitions of these rules: ${duplicates}`,
+    }
+  }
+
+  /* Helper functions */
+  /**
+   *
+   * @param ruleTree
+   *
+   * Extracts rules from rule tree.
+   *
+   */
+  function extractRules(ruleTree: IRules): IRule[] {
+    const resolvers = flattenObjectOf<ShieldRule>(ruleTree, isRuleFunction)
+
+    const rules = resolvers.reduce<IRule[]>((rules, rule) => {
+      if (isLogicRule(rule)) {
+        return [...rules, ...extractLogicRules(rule)]
+      } else {
+        return [...rules, rule]
+      }
+    }, [])
+
+    return rules
+  }
+
+  /**
+   *
+   * Recursively extracts Rules from LogicRule
+   *
+   * @param rule
+   */
+  function extractLogicRules(rule: ILogicRule): IRule[] {
+    return rule.getRules().reduce<IRule[]>((acc, shieldRule) => {
+      if (isLogicRule(shieldRule)) {
+        return [...acc, ...extractLogicRules(shieldRule)]
+      } else {
+        return [...acc, shieldRule]
+      }
+    }, [])
+  }
+}
+
+export class ValidationError extends Error {
+  constructor(message: string) {
+    super(message)
+  }
+}

package/tests/__snapshots__/input.test.ts.snap

@@ -0,0 +1,7 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`input rule schema validation works as expected 1`] = `
+Array [
+  [GraphQLError: It has to be an email!],
+]
+`;