@stryke/trpc-next 0.5.48 → 0.5.50

package/dist/shield/constructors.cjs

@@ -1 +1,86 @@
-const e=require(`./rules.cjs`),t=(t,n)=>r=>(typeof t==`object`?(n=t,t=Math.random().toString()):typeof t==`string`?n??={}:(t=Math.random().toString(),n={}),new e.Rule(t,r,{})),n=(...t)=>new e.RuleAnd(t),r=(...t)=>new e.RuleChain(t),i=(...t)=>new e.RuleRace(t),a=(...t)=>new e.RuleOr(t),o=(t,n)=>typeof n==`string`?new e.RuleNot(t,Error(n)):new e.RuleNot(t,n),s=new e.RuleTrue,c=new e.RuleFalse;exports.allow=s,exports.and=n,exports.chain=r,exports.deny=c,exports.not=o,exports.or=a,exports.race=i,exports.rule=t;
+const require_shield_rules = require('./rules.cjs');
+
+//#region src/shield/constructors.ts
+/**
+* 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 (ctx, type, path, input, rawInput, options) => {
+*  return true
+* })
+*
+* // 2.
+* const auth = rule('name')(async (ctx, type, path, input, rawInput, options) => {
+*  return true
+* })
+*
+* // 3.
+* const auth = rule({
+*  name: 'name',
+* })(async (ctx, type, path, input, rawInput, options) => {
+*  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 require_shield_rules.Rule(name, func, {});
+};
+/**
+* Logical operator and serves as a wrapper for and operation.
+*/
+const and = (...rules) => {
+	return new require_shield_rules.RuleAnd(rules);
+};
+/**
+* Logical operator and serves as a wrapper for and operation.
+*/
+const chain = (...rules) => {
+	return new require_shield_rules.RuleChain(rules);
+};
+/**
+* Logical operator and serves as a wrapper for and operation.
+*/
+const race = (...rules) => {
+	return new require_shield_rules.RuleRace(rules);
+};
+/**
+* Logical operator or serves as a wrapper for or operation.
+*/
+const or = (...rules) => {
+	return new require_shield_rules.RuleOr(rules);
+};
+/**
+* Logical operator not serves as a wrapper for not operation.
+*/
+const not = (rule$1, error) => {
+	if (typeof error === "string") return new require_shield_rules.RuleNot(rule$1, new Error(error));
+	return new require_shield_rules.RuleNot(rule$1, error);
+};
+/**
+* Allow queries.
+*/
+const allow = new require_shield_rules.RuleTrue();
+/**
+* Deny queries.
+*/
+const deny = new require_shield_rules.RuleFalse();
+
+//#endregion
+exports.allow = allow;
+exports.and = and;
+exports.chain = chain;
+exports.deny = deny;
+exports.not = not;
+exports.or = or;
+exports.race = race;
+exports.rule = rule;

package/dist/shield/constructors.mjs

@@ -1,2 +1,80 @@
-import{Rule as e,RuleAnd as t,RuleChain as n,RuleFalse as r,RuleNot as i,RuleOr as a,RuleRace as o,RuleTrue as s}from"./rules.mjs";const c=(t,n)=>r=>(typeof t==`object`?(n=t,t=Math.random().toString()):typeof t==`string`?n??={}:(t=Math.random().toString(),n={}),new e(t,r,{})),l=(...e)=>new t(e),u=(...e)=>new n(e),d=(...e)=>new o(e),f=(...e)=>new a(e),p=(e,t)=>typeof t==`string`?new i(e,Error(t)):new i(e,t),m=new s,h=new r;export{m as allow,l as and,u as chain,h as deny,p as not,f as or,d as race,c as rule};
+import { Rule, RuleAnd, RuleChain, RuleFalse, RuleNot, RuleOr, RuleRace, RuleTrue } from "./rules.mjs";
+
+//#region src/shield/constructors.ts
+/**
+* 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 (ctx, type, path, input, rawInput, options) => {
+*  return true
+* })
+*
+* // 2.
+* const auth = rule('name')(async (ctx, type, path, input, rawInput, options) => {
+*  return true
+* })
+*
+* // 3.
+* const auth = rule({
+*  name: 'name',
+* })(async (ctx, type, path, input, rawInput, options) => {
+*  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 Rule(name, func, {});
+};
+/**
+* Logical operator and serves as a wrapper for and operation.
+*/
+const and = (...rules) => {
+	return new RuleAnd(rules);
+};
+/**
+* Logical operator and serves as a wrapper for and operation.
+*/
+const chain = (...rules) => {
+	return new RuleChain(rules);
+};
+/**
+* Logical operator and serves as a wrapper for and operation.
+*/
+const race = (...rules) => {
+	return new RuleRace(rules);
+};
+/**
+* Logical operator or serves as a wrapper for or operation.
+*/
+const or = (...rules) => {
+	return new RuleOr(rules);
+};
+/**
+* Logical operator not serves as a wrapper for not operation.
+*/
+const not = (rule$1, error) => {
+	if (typeof error === "string") return new RuleNot(rule$1, new Error(error));
+	return new RuleNot(rule$1, error);
+};
+/**
+* Allow queries.
+*/
+const allow = new RuleTrue();
+/**
+* Deny queries.
+*/
+const deny = new RuleFalse();
+
+//#endregion
+export { allow, and, chain, deny, not, or, race, rule };
 //# sourceMappingURL=constructors.mjs.map

package/dist/shield/constructors.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constructors.mjs","names":["rule"],"sources":["../../src/shield/constructors.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport {\n  Rule,\n  RuleAnd,\n  RuleChain,\n  RuleFalse,\n  RuleNot,\n  RuleOr,\n  RuleRace,\n  RuleTrue\n} from \"./rules\";\nimport type {\n  RuleConstructorOptionsInterface,\n  RuleFunctionInterface,\n  ShieldRule\n} from \"./types\";\n\n/**\n * Wraps a function into a Rule class. This way we can identify rules\n * once we start generating middleware from our ruleTree.\n *\n * ```\n * // 1.\n * const auth = rule()(async (ctx, type, path, input, rawInput, options) => {\n *  return true\n * })\n *\n * // 2.\n * const auth = rule('name')(async (ctx, type, path, input, rawInput, options) => {\n *  return true\n * })\n *\n * // 3.\n * const auth = rule({\n *  name: 'name',\n * })(async (ctx, type, path, input, rawInput, options) => {\n *  return true\n * })\n * ```\n */\nexport const rule =\n  <TContext extends Record<string, any>>(\n    name?: string,\n    options?: RuleConstructorOptionsInterface\n  ) =>\n  (func: RuleFunctionInterface<TContext>): Rule<TContext> => {\n    if (typeof name === \"object\") {\n      options = name;\n      name = Math.random().toString();\n    } else if (typeof name === \"string\") {\n      options = options ?? {};\n    } else {\n      name = Math.random().toString();\n      options = {};\n    }\n\n    // @ts-ignore\n    return new Rule(name, func, {});\n  };\n\n/**\n * Logical operator and serves as a wrapper for and operation.\n */\nexport const and = <TContext extends Record<string, any>>(\n  ...rules: ShieldRule<TContext>[]\n): RuleAnd<TContext> => {\n  return new RuleAnd(rules);\n};\n\n/**\n * Logical operator and serves as a wrapper for and operation.\n */\nexport const chain = <TContext extends Record<string, any>>(\n  ...rules: ShieldRule<TContext>[]\n): RuleChain<TContext> => {\n  return new RuleChain(rules);\n};\n\n/**\n * Logical operator and serves as a wrapper for and operation.\n */\nexport const race = <TContext extends Record<string, any>>(\n  ...rules: ShieldRule<TContext>[]\n): RuleRace<TContext> => {\n  return new RuleRace(rules);\n};\n\n/**\n * Logical operator or serves as a wrapper for or operation.\n */\nexport const or = <TContext extends Record<string, any>>(\n  ...rules: ShieldRule<TContext>[]\n): RuleOr<TContext> => {\n  return new RuleOr(rules);\n};\n\n/**\n * Logical operator not serves as a wrapper for not operation.\n */\nexport const not = <TContext extends Record<string, any>>(\n  rule: ShieldRule<TContext>,\n  error?: string | Error\n): RuleNot<TContext> => {\n  if (typeof error === \"string\") return new RuleNot(rule, new Error(error));\n  return new RuleNot(rule, error);\n};\n\n/**\n * Allow queries.\n */\nexport const allow = new RuleTrue();\n\n/**\n * Deny queries.\n */\nexport const deny = new RuleFalse();\n"],"mappings":"mIAyDA,MAAa,GAET,EACA,IAED,IACK,OAAO,GAAS,UAClB,EAAU,EACV,EAAO,KAAK,QAAQ,CAAC,UAAU,EACtB,OAAO,GAAS,SACzB,IAAqB,EAAE,EAEvB,EAAO,KAAK,QAAQ,CAAC,UAAU,CAC/B,EAAU,EAAE,EAIP,IAAI,EAAK,EAAM,EAAM,EAAE,CAAC,EAMtB,GACX,GAAG,IAEI,IAAI,EAAQ,EAAM,CAMd,GACX,GAAG,IAEI,IAAI,EAAU,EAAM,CAMhB,GACX,GAAG,IAEI,IAAI,EAAS,EAAM,CAMf,GACX,GAAG,IAEI,IAAI,EAAO,EAAM,CAMb,GACX,EACA,IAEI,OAAO,GAAU,SAAiB,IAAI,EAAQA,EAAU,MAAM,EAAM,CAAC,CAClE,IAAI,EAAQA,EAAM,EAAM,CAMpB,EAAQ,IAAI,EAKZ,EAAO,IAAI"}
+{"version":3,"file":"constructors.mjs","names":["rule"],"sources":["../../src/shield/constructors.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport {\n  Rule,\n  RuleAnd,\n  RuleChain,\n  RuleFalse,\n  RuleNot,\n  RuleOr,\n  RuleRace,\n  RuleTrue\n} from \"./rules\";\nimport type {\n  RuleConstructorOptionsInterface,\n  RuleFunctionInterface,\n  ShieldRule\n} from \"./types\";\n\n/**\n * Wraps a function into a Rule class. This way we can identify rules\n * once we start generating middleware from our ruleTree.\n *\n * ```\n * // 1.\n * const auth = rule()(async (ctx, type, path, input, rawInput, options) => {\n *  return true\n * })\n *\n * // 2.\n * const auth = rule('name')(async (ctx, type, path, input, rawInput, options) => {\n *  return true\n * })\n *\n * // 3.\n * const auth = rule({\n *  name: 'name',\n * })(async (ctx, type, path, input, rawInput, options) => {\n *  return true\n * })\n * ```\n */\nexport const rule =\n  <TContext extends Record<string, any>>(\n    name?: string,\n    options?: RuleConstructorOptionsInterface\n  ) =>\n  (func: RuleFunctionInterface<TContext>): Rule<TContext> => {\n    if (typeof name === \"object\") {\n      options = name;\n      name = Math.random().toString();\n    } else if (typeof name === \"string\") {\n      options = options ?? {};\n    } else {\n      name = Math.random().toString();\n      options = {};\n    }\n\n    // @ts-ignore\n    return new Rule(name, func, {});\n  };\n\n/**\n * Logical operator and serves as a wrapper for and operation.\n */\nexport const and = <TContext extends Record<string, any>>(\n  ...rules: ShieldRule<TContext>[]\n): RuleAnd<TContext> => {\n  return new RuleAnd(rules);\n};\n\n/**\n * Logical operator and serves as a wrapper for and operation.\n */\nexport const chain = <TContext extends Record<string, any>>(\n  ...rules: ShieldRule<TContext>[]\n): RuleChain<TContext> => {\n  return new RuleChain(rules);\n};\n\n/**\n * Logical operator and serves as a wrapper for and operation.\n */\nexport const race = <TContext extends Record<string, any>>(\n  ...rules: ShieldRule<TContext>[]\n): RuleRace<TContext> => {\n  return new RuleRace(rules);\n};\n\n/**\n * Logical operator or serves as a wrapper for or operation.\n */\nexport const or = <TContext extends Record<string, any>>(\n  ...rules: ShieldRule<TContext>[]\n): RuleOr<TContext> => {\n  return new RuleOr(rules);\n};\n\n/**\n * Logical operator not serves as a wrapper for not operation.\n */\nexport const not = <TContext extends Record<string, any>>(\n  rule: ShieldRule<TContext>,\n  error?: string | Error\n): RuleNot<TContext> => {\n  if (typeof error === \"string\") return new RuleNot(rule, new Error(error));\n  return new RuleNot(rule, error);\n};\n\n/**\n * Allow queries.\n */\nexport const allow = new RuleTrue();\n\n/**\n * Deny queries.\n */\nexport const deny = new RuleFalse();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,MAAa,QAET,MACA,aAED,SAA0D;AACzD,KAAI,OAAO,SAAS,UAAU;AAC5B,YAAU;AACV,SAAO,KAAK,QAAQ,CAAC,UAAU;YACtB,OAAO,SAAS,SACzB,WAAU,WAAW,EAAE;MAClB;AACL,SAAO,KAAK,QAAQ,CAAC,UAAU;AAC/B,YAAU,EAAE;;AAId,QAAO,IAAI,KAAK,MAAM,MAAM,EAAE,CAAC;;;;;AAMnC,MAAa,OACX,GAAG,UACmB;AACtB,QAAO,IAAI,QAAQ,MAAM;;;;;AAM3B,MAAa,SACX,GAAG,UACqB;AACxB,QAAO,IAAI,UAAU,MAAM;;;;;AAM7B,MAAa,QACX,GAAG,UACoB;AACvB,QAAO,IAAI,SAAS,MAAM;;;;;AAM5B,MAAa,MACX,GAAG,UACkB;AACrB,QAAO,IAAI,OAAO,MAAM;;;;;AAM1B,MAAa,OACX,QACA,UACsB;AACtB,KAAI,OAAO,UAAU,SAAU,QAAO,IAAI,QAAQA,QAAM,IAAI,MAAM,MAAM,CAAC;AACzE,QAAO,IAAI,QAAQA,QAAM,MAAM;;;;;AAMjC,MAAa,QAAQ,IAAI,UAAU;;;;AAKnC,MAAa,OAAO,IAAI,WAAW"}

package/dist/shield/generator.cjs

@@ -1 +1,28 @@
-function e(e,t){return async({next:n,ctx:r,type:i,path:a,input:o,rawInput:s})=>{let c=a.split(`.`),l=c[c.length-1],u=Object.keys(e),d;if(u.includes(`query`)||u.includes(`mutation`))d=e?.[i]?.[l];else{let t=e[c[0]];t?.[i]?.[l]&&(d=t?.[i]?.[l])}return d??=t.fallbackRule,d?d?.resolve(r,i,a,o,s,t).then(async e=>{if(e instanceof Error)throw e;if(!e)throw t.fallbackError;return n()}):n()}}exports.generateMiddlewareFromRuleTree=e;
+
+//#region src/shield/generator.ts
+/**
+* Generates middleware from given rules.
+*/
+function generateMiddlewareFromRuleTree(ruleTree, options) {
+	return async ({ next, ctx, type, path, input, rawInput }) => {
+		const opWithPath = path.split(".");
+		const opName = opWithPath[opWithPath.length - 1];
+		const keys = Object.keys(ruleTree);
+		let rule;
+		if (keys.includes("query") || keys.includes("mutation")) rule = ruleTree?.[type]?.[opName];
+		else {
+			const tree = ruleTree[opWithPath[0]];
+			if (tree?.[type]?.[opName]) rule = tree?.[type]?.[opName];
+		}
+		rule = rule ?? options.fallbackRule;
+		if (rule) return rule?.resolve(ctx, type, path, input, rawInput, options).then(async (result) => {
+			if (result instanceof Error) throw result;
+			if (!result) throw options.fallbackError;
+			return next();
+		});
+		return next();
+	};
+}
+
+//#endregion
+exports.generateMiddlewareFromRuleTree = generateMiddlewareFromRuleTree;

package/dist/shield/generator.mjs

@@ -1,2 +1,28 @@
-function e(e,t){return async({next:n,ctx:r,type:i,path:a,input:o,rawInput:s})=>{let c=a.split(`.`),l=c[c.length-1],u=Object.keys(e),d;if(u.includes(`query`)||u.includes(`mutation`))d=e?.[i]?.[l];else{let t=e[c[0]];t?.[i]?.[l]&&(d=t?.[i]?.[l])}return d??=t.fallbackRule,d?d?.resolve(r,i,a,o,s,t).then(async e=>{if(e instanceof Error)throw e;if(!e)throw t.fallbackError;return n()}):n()}}export{e as generateMiddlewareFromRuleTree};
+//#region src/shield/generator.ts
+/**
+* Generates middleware from given rules.
+*/
+function generateMiddlewareFromRuleTree(ruleTree, options) {
+	return async ({ next, ctx, type, path, input, rawInput }) => {
+		const opWithPath = path.split(".");
+		const opName = opWithPath[opWithPath.length - 1];
+		const keys = Object.keys(ruleTree);
+		let rule;
+		if (keys.includes("query") || keys.includes("mutation")) rule = ruleTree?.[type]?.[opName];
+		else {
+			const tree = ruleTree[opWithPath[0]];
+			if (tree?.[type]?.[opName]) rule = tree?.[type]?.[opName];
+		}
+		rule = rule ?? options.fallbackRule;
+		if (rule) return rule?.resolve(ctx, type, path, input, rawInput, options).then(async (result) => {
+			if (result instanceof Error) throw result;
+			if (!result) throw options.fallbackError;
+			return next();
+		});
+		return next();
+	};
+}
+
+//#endregion
+export { generateMiddlewareFromRuleTree };
 //# sourceMappingURL=generator.mjs.map

package/dist/shield/generator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"generator.mjs","names":["opWithPath: Array<string>","opName: string","rule: ShieldRule<TContext> | undefined"],"sources":["../../src/shield/generator.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { IRules, OptionsInterface, ShieldRule } from \"./types\";\n\n/**\n * Generates middleware from given rules.\n */\nexport function generateMiddlewareFromRuleTree<\n  TContext extends Record<string, unknown>\n>(ruleTree: IRules<TContext>, options: OptionsInterface<TContext>) {\n  return async ({\n    next,\n    ctx,\n    type,\n    path,\n    input,\n    rawInput\n  }: {\n    next: () => Promise<any>;\n    ctx: TContext;\n    type: string;\n    path: string;\n    input: { [name: string]: any };\n    rawInput: unknown;\n  }) => {\n    const opWithPath: Array<string> = path.split(\".\");\n    const opName: string = opWithPath[opWithPath.length - 1]!;\n    const keys = Object.keys(ruleTree);\n    let rule: ShieldRule<TContext> | undefined;\n    if (keys.includes(\"query\") || keys.includes(\"mutation\")) {\n      // @ts-ignore\n      rule = ruleTree?.[type]?.[opName];\n    } else {\n      const namespace = opWithPath[0];\n\n      const tree = (ruleTree as Record<string, any>)[namespace!];\n      if (tree?.[type]?.[opName]) {\n        rule = tree?.[type]?.[opName];\n      }\n    }\n    rule = rule ?? options.fallbackRule;\n\n    if (rule) {\n      return rule\n        ?.resolve(ctx, type, path, input, rawInput, options)\n        .then(async result => {\n          if (result instanceof Error) {\n            throw result;\n          }\n          if (!result) {\n            throw options.fallbackError;\n          }\n\n          return next();\n        });\n    }\n\n    return next();\n  };\n}\n"],"mappings":"AAuBA,SAAgB,EAEd,EAA4B,EAAqC,CACjE,OAAO,MAAO,CACZ,OACA,MACA,OACA,OACA,QACA,cAQI,CACJ,IAAMA,EAA4B,EAAK,MAAM,IAAI,CAC3CC,EAAiB,EAAW,EAAW,OAAS,GAChD,EAAO,OAAO,KAAK,EAAS,CAC9BC,EACJ,GAAI,EAAK,SAAS,QAAQ,EAAI,EAAK,SAAS,WAAW,CAErD,EAAO,IAAW,KAAQ,OACrB,CAGL,IAAM,EAAQ,EAFI,EAAW,IAGzB,IAAO,KAAQ,KACjB,EAAO,IAAO,KAAQ,IAoB1B,MAjBA,KAAe,EAAQ,aAEnB,EACK,GACH,QAAQ,EAAK,EAAM,EAAM,EAAO,EAAU,EAAQ,CACnD,KAAK,KAAM,IAAU,CACpB,GAAI,aAAkB,MACpB,MAAM,EAER,GAAI,CAAC,EACH,MAAM,EAAQ,cAGhB,OAAO,GAAM,EACb,CAGC,GAAM"}
+{"version":3,"file":"generator.mjs","names":["opWithPath: Array<string>","opName: string","rule: ShieldRule<TContext> | undefined"],"sources":["../../src/shield/generator.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { IRules, OptionsInterface, ShieldRule } from \"./types\";\n\n/**\n * Generates middleware from given rules.\n */\nexport function generateMiddlewareFromRuleTree<\n  TContext extends Record<string, unknown>\n>(ruleTree: IRules<TContext>, options: OptionsInterface<TContext>) {\n  return async ({\n    next,\n    ctx,\n    type,\n    path,\n    input,\n    rawInput\n  }: {\n    next: () => Promise<any>;\n    ctx: TContext;\n    type: string;\n    path: string;\n    input: { [name: string]: any };\n    rawInput: unknown;\n  }) => {\n    const opWithPath: Array<string> = path.split(\".\");\n    const opName: string = opWithPath[opWithPath.length - 1]!;\n    const keys = Object.keys(ruleTree);\n    let rule: ShieldRule<TContext> | undefined;\n    if (keys.includes(\"query\") || keys.includes(\"mutation\")) {\n      // @ts-ignore\n      rule = ruleTree?.[type]?.[opName];\n    } else {\n      const namespace = opWithPath[0];\n\n      const tree = (ruleTree as Record<string, any>)[namespace!];\n      if (tree?.[type]?.[opName]) {\n        rule = tree?.[type]?.[opName];\n      }\n    }\n    rule = rule ?? options.fallbackRule;\n\n    if (rule) {\n      return rule\n        ?.resolve(ctx, type, path, input, rawInput, options)\n        .then(async result => {\n          if (result instanceof Error) {\n            throw result;\n          }\n          if (!result) {\n            throw options.fallbackError;\n          }\n\n          return next();\n        });\n    }\n\n    return next();\n  };\n}\n"],"mappings":";;;;AAuBA,SAAgB,+BAEd,UAA4B,SAAqC;AACjE,QAAO,OAAO,EACZ,MACA,KACA,MACA,MACA,OACA,eAQI;EACJ,MAAMA,aAA4B,KAAK,MAAM,IAAI;EACjD,MAAMC,SAAiB,WAAW,WAAW,SAAS;EACtD,MAAM,OAAO,OAAO,KAAK,SAAS;EAClC,IAAIC;AACJ,MAAI,KAAK,SAAS,QAAQ,IAAI,KAAK,SAAS,WAAW,CAErD,QAAO,WAAW,QAAQ;OACrB;GAGL,MAAM,OAAQ,SAFI,WAAW;AAG7B,OAAI,OAAO,QAAQ,QACjB,QAAO,OAAO,QAAQ;;AAG1B,SAAO,QAAQ,QAAQ;AAEvB,MAAI,KACF,QAAO,MACH,QAAQ,KAAK,MAAM,MAAM,OAAO,UAAU,QAAQ,CACnD,KAAK,OAAM,WAAU;AACpB,OAAI,kBAAkB,MACpB,OAAM;AAER,OAAI,CAAC,OACH,OAAM,QAAQ;AAGhB,UAAO,MAAM;IACb;AAGN,SAAO,MAAM"}

package/dist/shield/index.cjs

@@ -1 +1,12 @@
-const e=require(`./constructors.cjs`),t=require(`./shield.cjs`);exports.allow=e.allow,exports.and=e.and,exports.chain=e.chain,exports.deny=e.deny,exports.not=e.not,exports.or=e.or,exports.race=e.race,exports.rule=e.rule,exports.shield=t.shield;
+const require_shield_constructors = require('./constructors.cjs');
+const require_shield_shield = require('./shield.cjs');
+
+exports.allow = require_shield_constructors.allow;
+exports.and = require_shield_constructors.and;
+exports.chain = require_shield_constructors.chain;
+exports.deny = require_shield_constructors.deny;
+exports.not = require_shield_constructors.not;
+exports.or = require_shield_constructors.or;
+exports.race = require_shield_constructors.race;
+exports.rule = require_shield_constructors.rule;
+exports.shield = require_shield_shield.shield;

package/dist/shield/index.mjs

@@ -1 +1,4 @@
-import{allow as e,and as t,chain as n,deny as r,not as i,or as a,race as o,rule as s}from"./constructors.mjs";import{shield as c}from"./shield.mjs";export{e as allow,t as and,n as chain,r as deny,i as not,a as or,o as race,s as rule,c as shield};
+import { allow, and, chain, deny, not, or, race, rule } from "./constructors.mjs";
+import { shield } from "./shield.mjs";
+
+export { allow, and, chain, deny, not, or, race, rule, shield };

package/dist/shield/rules.cjs

@@ -1 +1,200 @@
-var e=class{name;func;constructor(e,t){this.name=e,this.func=t}async resolve(e,t,n,r,i,a){try{let o=await this.executeRule(e,t,n,r,i,a);return o instanceof Error?o:typeof o==`string`?Error(o):o===!0}catch(e){if(a.debug)throw e;return!1}}equals(e){return this.func===e.func}executeRule(e,t,n,r,i,a){return this.func(e,t,n,r,i,a)}},t=class extends e{rules;constructor(e){super(`LogicRule`),this.rules=e}async resolve(e,t,n,r,i,a){return!1}async evaluate(e,t,n,r,i,a){let o=this.getRules().map(async o=>o.resolve(e,t,n,r,i,a));return Promise.all(o)}getRules(){return this.rules}},n=class extends t{constructor(e){super(e)}async resolve(e,t,n,r,i,a){let o=await this.evaluate(e,t,n,r,i,a);return o.every(e=>e!==!0)?o.find(e=>e instanceof Error)??!1:!0}},r=class extends t{constructor(e){super(e)}async resolve(e,t,n,r,i,a){let o=await this.evaluate(e,t,n,r,i,a);return o.some(e=>e!==!0)?o.find(e=>e instanceof Error)??!1:!0}},i=class extends t{constructor(e){super(e)}async resolve(e,t,n,r,i,a){let o=await this.evaluate(e,t,n,r,i,a);return o.some(e=>e!==!0)?o.find(e=>e instanceof Error)??!1:!0}async evaluate(e,t,n,r,i,a){return o(this.getRules());async function o([s,...c]){return s===void 0?[]:s.resolve(e,t,n,r,i,a).then(async e=>e===!0?o(c).then(t=>t.concat(e)):[e])}}},a=class extends t{constructor(e){super(e)}async resolve(e,t,n,r,i,a){let o=await this.evaluate(e,t,n,r,i,a);return o.includes(!0)?!0:o.find(e=>e instanceof Error)??!1}async evaluate(e,t,n,r,i,a){return o(this.getRules());async function o([s,...c]){return s===void 0?[]:s.resolve(e,t,n,r,i,a).then(async e=>e===!0?[e]:o(c).then(t=>t.concat(e)))}}},o=class extends t{error;name=`RuleNot`;equals;constructor(e,t){super([e]),this.error=t}async resolve(e,t,n,r,i,a){let[o]=await this.evaluate(e,t,n,r,i,a);return o instanceof Error?!0:o===!0?this.error?this.error:!1:!0}},s=class extends t{name=`RuleTrue`;equals;constructor(){super([])}async resolve(){return!0}},c=class extends t{name=`RuleTrue`;equals;constructor(){super([])}async resolve(){return!1}};exports.LogicRule=t,exports.Rule=e,exports.RuleAnd=r,exports.RuleChain=i,exports.RuleFalse=c,exports.RuleNot=o,exports.RuleOr=n,exports.RuleRace=a,exports.RuleTrue=s;
+
+//#region src/shield/rules.ts
+var Rule = class {
+	name;
+	func;
+	constructor(name, func) {
+		this.name = name;
+		this.func = func;
+	}
+	async resolve(ctx, type, path, input, rawInput, options) {
+		try {
+			const res = await this.executeRule(ctx, type, path, input, rawInput, options);
+			if (res instanceof Error) return res;
+			else if (typeof res === "string") return new Error(res);
+			else if (res === true) return true;
+			else return false;
+		} catch (err) {
+			if (options.debug) throw err;
+			else return false;
+		}
+	}
+	/**
+	*
+	* Compares a given rule with the current one
+	* and checks whether their functions are equal.
+	*
+	*/
+	equals(rule) {
+		return this.func === rule.func;
+	}
+	executeRule(ctx, type, path, input, rawInput, options) {
+		return this.func(ctx, type, path, input, rawInput, options);
+	}
+};
+var LogicRule = class extends Rule {
+	rules;
+	constructor(rules) {
+		super("LogicRule");
+		this.rules = rules;
+	}
+	/**
+	* By default logic rule resolves to false.
+	*/
+	async resolve(_ctx, _type, _path, _input, _rawInput, _options) {
+		return false;
+	}
+	/**
+	* Evaluates all the rules.
+	*/
+	async evaluate(ctx, type, path, input, rawInput, options) {
+		const tasks = this.getRules().map(async (rule) => rule.resolve(ctx, type, path, input, rawInput, options));
+		return Promise.all(tasks);
+	}
+	/**
+	* Returns rules in a logic rule.
+	*/
+	getRules() {
+		return this.rules;
+	}
+};
+var RuleOr = class extends LogicRule {
+	constructor(rules) {
+		super(rules);
+	}
+	/**
+	* Makes sure that at least one of them has evaluated to true.
+	*/
+	async resolve(ctx, type, path, input, rawInput, options) {
+		const result = await this.evaluate(ctx, type, path, input, rawInput, options);
+		if (result.every((res) => res !== true)) return result.find((res) => res instanceof Error) ?? false;
+		else return true;
+	}
+};
+var RuleAnd = class extends LogicRule {
+	constructor(rules) {
+		super(rules);
+	}
+	/**
+	* Makes sure that all of them have resolved to true.
+	*/
+	async resolve(ctx, type, path, input, rawInput, options) {
+		const result = await this.evaluate(ctx, type, path, input, rawInput, options);
+		if (result.some((res) => res !== true)) return result.find((res) => res instanceof Error) ?? false;
+		else return true;
+	}
+};
+var RuleChain = class extends LogicRule {
+	constructor(rules) {
+		super(rules);
+	}
+	/**
+	* Makes sure that all of them have resolved to true.
+	*/
+	async resolve(ctx, type, path, input, rawInput, options) {
+		const result = await this.evaluate(ctx, type, path, input, rawInput, options);
+		if (result.some((res) => res !== true)) return result.find((res) => res instanceof Error) ?? false;
+		else return true;
+	}
+	/**
+	* Evaluates all the rules.
+	*/
+	async evaluate(ctx, type, path, input, rawInput, options) {
+		return iterate(this.getRules());
+		async function iterate([rule, ...otherRules]) {
+			if (rule === void 0) return [];
+			return rule.resolve(ctx, type, path, input, rawInput, options).then(async (res) => {
+				if (res !== true) return [res];
+				else return iterate(otherRules).then((ress) => ress.concat(res));
+			});
+		}
+	}
+};
+var RuleRace = class extends LogicRule {
+	constructor(rules) {
+		super(rules);
+	}
+	/**
+	* Makes sure that at least one of them resolved to true.
+	*/
+	async resolve(ctx, type, path, input, rawInput, options) {
+		const result = await this.evaluate(ctx, type, path, input, rawInput, options);
+		if (result.includes(true)) return true;
+		else return result.find((res) => res instanceof Error) ?? false;
+	}
+	/**
+	* Evaluates all the rules.
+	*/
+	async evaluate(ctx, type, path, input, rawInput, options) {
+		return iterate(this.getRules());
+		async function iterate([rule, ...otherRules]) {
+			if (rule === void 0) return [];
+			return rule.resolve(ctx, type, path, input, rawInput, options).then(async (res) => {
+				if (res === true) return [res];
+				else return iterate(otherRules).then((ress) => ress.concat(res));
+			});
+		}
+	}
+};
+var RuleNot = class extends LogicRule {
+	error;
+	name = "RuleNot";
+	equals;
+	constructor(rule, error) {
+		super([rule]);
+		this.error = error;
+	}
+	/**
+	* Negates the result.
+	*/
+	async resolve(ctx, type, path, input, rawInput, options) {
+		const [res] = await this.evaluate(ctx, type, path, input, rawInput, options);
+		if (res instanceof Error) return true;
+		else if (res !== true) return true;
+		else {
+			if (this.error) return this.error;
+			return false;
+		}
+	}
+};
+var RuleTrue = class extends LogicRule {
+	name = "RuleTrue";
+	equals;
+	constructor() {
+		super([]);
+	}
+	/**
+	*
+	* Always true.
+	*
+	*/
+	async resolve() {
+		return true;
+	}
+};
+var RuleFalse = class extends LogicRule {
+	name = "RuleTrue";
+	equals;
+	constructor() {
+		super([]);
+	}
+	/**
+	*
+	* Always false.
+	*
+	*/
+	async resolve() {
+		return false;
+	}
+};
+
+//#endregion
+exports.LogicRule = LogicRule;
+exports.Rule = Rule;
+exports.RuleAnd = RuleAnd;
+exports.RuleChain = RuleChain;
+exports.RuleFalse = RuleFalse;
+exports.RuleNot = RuleNot;
+exports.RuleOr = RuleOr;
+exports.RuleRace = RuleRace;
+exports.RuleTrue = RuleTrue;