@stryke/trpc-next 0.5.48 → 0.5.49

package/dist/shield/rules.mjs

@@ -1,2 +1,192 @@
-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}};export{t as LogicRule,e as Rule,r as RuleAnd,i as RuleChain,c as RuleFalse,o as RuleNot,n as RuleOr,a as RuleRace,s as RuleTrue};
+//#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
+export { LogicRule, Rule, RuleAnd, RuleChain, RuleFalse, RuleNot, RuleOr, RuleRace, RuleTrue };
 //# sourceMappingURL=rules.mjs.map

package/dist/shield/rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rules.mjs","names":[],"sources":["../../src/shield/rules.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 {\n  LogicRuleInterface,\n  OptionsInterface,\n  RuleFunctionInterface,\n  RuleInterface,\n  RuleResultInterface,\n  ShieldRule\n} from \"./types\";\n\nexport class Rule<\n  TContext extends Record<string, any>\n> implements RuleInterface<TContext> {\n  readonly name: string;\n\n  func?: RuleFunctionInterface<TContext>;\n\n  constructor(name: string, func?: RuleFunctionInterface<TContext>) {\n    this.name = name;\n    this.func = func;\n  }\n\n  async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    try {\n      /* Resolve */\n      const res = await this.executeRule(\n        ctx,\n        type,\n        path,\n        input,\n        rawInput,\n        options\n      );\n\n      if (res instanceof Error) {\n        return res;\n      } else if (typeof res === \"string\") {\n        return new Error(res);\n      } else if (res === true) {\n        return true;\n      } else {\n        return false;\n      }\n    } catch (err) {\n      if (options.debug) {\n        throw err;\n      } else {\n        return false;\n      }\n    }\n  }\n\n  /**\n   *\n   * Compares a given rule with the current one\n   * and checks whether their functions are equal.\n   *\n   */\n  equals(rule: Rule<TContext>): boolean {\n    return this.func === rule.func;\n  }\n\n  executeRule<TContext extends Record<string, any>>(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): string | boolean | Error | Promise<RuleResultInterface> {\n    // @ts-ignore\n    return this.func(ctx, type, path, input, rawInput, options);\n  }\n}\n\nexport class LogicRule<TContext extends Record<string, any>>\n  extends Rule<TContext>\n  implements LogicRuleInterface<TContext>\n{\n  private rules: ShieldRule<TContext>[];\n\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(\"LogicRule\");\n\n    this.rules = rules;\n  }\n\n  /**\n   * By default logic rule resolves to false.\n   */\n  override async resolve(\n    _ctx: TContext,\n    _type: string,\n    _path: string,\n    _input: { [name: string]: any },\n    _rawInput: unknown,\n    _options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    return false;\n  }\n\n  /**\n   * Evaluates all the rules.\n   */\n  async evaluate(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface[]> {\n    const rules = this.getRules();\n    const tasks = rules.map(async rule =>\n      rule.resolve(ctx, type, path, input, rawInput, options)\n    );\n\n    return Promise.all(tasks);\n  }\n\n  /**\n   * Returns rules in a logic rule.\n   */\n  getRules() {\n    return this.rules;\n  }\n}\n\n// Extended Types\n\nexport class RuleOr<\n  TContext extends Record<string, any>\n> extends LogicRule<TContext> {\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(rules);\n  }\n\n  /**\n   * Makes sure that at least one of them has evaluated to true.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const result = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (result.every(res => res !== true)) {\n      const customError = result.find(res => res instanceof Error);\n\n      return customError ?? false;\n    } else {\n      return true;\n    }\n  }\n}\n\nexport class RuleAnd<\n  TContext extends Record<string, any>\n> extends LogicRule<TContext> {\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(rules);\n  }\n\n  /**\n   * Makes sure that all of them have resolved to true.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const result = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (result.some(res => res !== true)) {\n      const customError = result.find(res => res instanceof Error);\n\n      return customError ?? false;\n    } else {\n      return true;\n    }\n  }\n}\n\nexport class RuleChain<\n  TContext extends Record<string, any>\n> extends LogicRule<TContext> {\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(rules);\n  }\n\n  /**\n   * Makes sure that all of them have resolved to true.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const result = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (result.some(res => res !== true)) {\n      const customError = result.find(res => res instanceof Error);\n\n      return customError ?? false;\n    } else {\n      return true;\n    }\n  }\n\n  /**\n   * Evaluates all the rules.\n   */\n  override async evaluate(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface[]> {\n    const rules = this.getRules();\n\n    return iterate(rules);\n\n    async function iterate([\n      rule,\n      ...otherRules\n    ]: ShieldRule<TContext>[]): Promise<RuleResultInterface[]> {\n      if (rule === undefined) return [];\n      return rule\n        .resolve(ctx, type, path, input, rawInput, options)\n        .then(async res => {\n          if (res !== true) {\n            return [res];\n          } else {\n            return iterate(otherRules).then(ress => ress.concat(res));\n          }\n        });\n    }\n  }\n}\n\nexport class RuleRace<\n  TContext extends Record<string, any>\n> extends LogicRule<TContext> {\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(rules);\n  }\n\n  /**\n   * Makes sure that at least one of them resolved to true.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const result = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (result.includes(true)) {\n      return true;\n    } else {\n      const customError = result.find(res => res instanceof Error);\n\n      return customError ?? false;\n    }\n  }\n\n  /**\n   * Evaluates all the rules.\n   */\n  override async evaluate(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface[]> {\n    const rules = this.getRules();\n\n    return iterate(rules);\n\n    async function iterate([\n      rule,\n      ...otherRules\n    ]: ShieldRule<TContext>[]): Promise<RuleResultInterface[]> {\n      if (rule === undefined) return [];\n      return rule\n        .resolve(ctx, type, path, input, rawInput, options)\n        .then(async res => {\n          if (res === true) {\n            return [res];\n          } else {\n            return iterate(otherRules).then(ress => ress.concat(res));\n          }\n        });\n    }\n  }\n}\n\nexport class RuleNot<TContext extends Record<string, any>>\n  extends LogicRule<TContext>\n  implements LogicRuleInterface<TContext>\n{\n  error?: Error;\n\n  override name: string = \"RuleNot\";\n\n  override equals!: (rule: RuleInterface<TContext>) => boolean;\n\n  constructor(rule: ShieldRule<TContext>, error?: Error) {\n    super([rule]);\n    this.error = error;\n  }\n\n  /**\n   * Negates the result.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const [res] = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (res instanceof Error) {\n      return true;\n    } else if (res !== true) {\n      return true;\n    } else {\n      if (this.error) return this.error;\n      return false;\n    }\n  }\n}\n\nexport class RuleTrue<TContext extends Record<string, any>>\n  extends LogicRule<TContext>\n  implements LogicRuleInterface<TContext>\n{\n  override name: string = \"RuleTrue\";\n\n  override equals!: (rule: RuleInterface<TContext>) => boolean;\n\n  constructor() {\n    super([]);\n  }\n\n  /**\n   *\n   * Always true.\n   *\n   */\n  override async resolve(): Promise<RuleResultInterface> {\n    return true;\n  }\n}\n\nexport class RuleFalse<TContext extends Record<string, any>>\n  extends LogicRule<TContext>\n  implements LogicRuleInterface<TContext>\n{\n  override name: string = \"RuleTrue\";\n\n  override equals!: (rule: RuleInterface<TContext>) => boolean;\n\n  constructor() {\n    super([]);\n  }\n\n  /**\n   *\n   * Always false.\n   *\n   */\n  override async resolve(): Promise<RuleResultInterface> {\n    return false;\n  }\n}\n"],"mappings":"AA2BA,IAAa,EAAb,KAEqC,CACnC,KAEA,KAEA,YAAY,EAAc,EAAwC,CAChE,KAAK,KAAO,EACZ,KAAK,KAAO,EAGd,MAAM,QACJ,EACA,EACA,EACA,EACA,EACA,EAC8B,CAC9B,GAAI,CAEF,IAAM,EAAM,MAAM,KAAK,YACrB,EACA,EACA,EACA,EACA,EACA,EACD,CASC,OAPE,aAAe,MACV,EACE,OAAO,GAAQ,SACb,MAAM,EAAI,CACZ,IAAQ,SAKZ,EAAK,CACZ,GAAI,EAAQ,MACV,MAAM,EAEN,MAAO,IAWb,OAAO,EAA+B,CACpC,OAAO,KAAK,OAAS,EAAK,KAG5B,YACE,EACA,EACA,EACA,EACA,EACA,EACyD,CAEzD,OAAO,KAAK,KAAK,EAAK,EAAM,EAAM,EAAO,EAAU,EAAQ,GAIlD,EAAb,cACU,CAEV,CACE,MAEA,YAAY,EAA+B,CACzC,MAAM,YAAY,CAElB,KAAK,MAAQ,EAMf,MAAe,QACb,EACA,EACA,EACA,EACA,EACA,EAC8B,CAC9B,MAAO,GAMT,MAAM,SACJ,EACA,EACA,EACA,EACA,EACA,EACgC,CAEhC,IAAM,EADQ,KAAK,UAAU,CACT,IAAI,KAAM,IAC5B,EAAK,QAAQ,EAAK,EAAM,EAAM,EAAO,EAAU,EAAQ,CACxD,CAED,OAAO,QAAQ,IAAI,EAAM,CAM3B,UAAW,CACT,OAAO,KAAK,QAMH,EAAb,cAEU,CAAoB,CAC5B,YAAY,EAA+B,CACzC,MAAM,EAAM,CAMd,MAAe,QACb,EACA,EACA,EACA,EACA,EACA,EAC8B,CAC9B,IAAM,EAAS,MAAM,KAAK,SACxB,EACA,EACA,EACA,EACA,EACA,EACD,CAOC,OALE,EAAO,MAAM,GAAO,IAAQ,GAAK,CACf,EAAO,KAAK,GAAO,aAAe,MAAM,EAEtC,GAEf,KAKA,EAAb,cAEU,CAAoB,CAC5B,YAAY,EAA+B,CACzC,MAAM,EAAM,CAMd,MAAe,QACb,EACA,EACA,EACA,EACA,EACA,EAC8B,CAC9B,IAAM,EAAS,MAAM,KAAK,SACxB,EACA,EACA,EACA,EACA,EACA,EACD,CAOC,OALE,EAAO,KAAK,GAAO,IAAQ,GAAK,CACd,EAAO,KAAK,GAAO,aAAe,MAAM,EAEtC,GAEf,KAKA,EAAb,cAEU,CAAoB,CAC5B,YAAY,EAA+B,CACzC,MAAM,EAAM,CAMd,MAAe,QACb,EACA,EACA,EACA,EACA,EACA,EAC8B,CAC9B,IAAM,EAAS,MAAM,KAAK,SACxB,EACA,EACA,EACA,EACA,EACA,EACD,CAOC,OALE,EAAO,KAAK,GAAO,IAAQ,GAAK,CACd,EAAO,KAAK,GAAO,aAAe,MAAM,EAEtC,GAEf,GAOX,MAAe,SACb,EACA,EACA,EACA,EACA,EACA,EACgC,CAGhC,OAAO,EAFO,KAAK,UAAU,CAER,CAErB,eAAe,EAAQ,CACrB,EACA,GAAG,GACsD,CAEzD,OADI,IAAS,IAAA,GAAkB,EAAE,CAC1B,EACJ,QAAQ,EAAK,EAAM,EAAM,EAAO,EAAU,EAAQ,CAClD,KAAK,KAAM,IACN,IAAQ,GAGH,EAAQ,EAAW,CAAC,KAAK,GAAQ,EAAK,OAAO,EAAI,CAAC,CAFlD,CAAC,EAAI,CAId,IAKG,EAAb,cAEU,CAAoB,CAC5B,YAAY,EAA+B,CACzC,MAAM,EAAM,CAMd,MAAe,QACb,EACA,EACA,EACA,EACA,EACA,EAC8B,CAC9B,IAAM,EAAS,MAAM,KAAK,SACxB,EACA,EACA,EACA,EACA,EACA,EACD,CAOC,OALE,EAAO,SAAS,GAAK,CAChB,GAEa,EAAO,KAAK,GAAO,aAAe,MAAM,EAEtC,GAO1B,MAAe,SACb,EACA,EACA,EACA,EACA,EACA,EACgC,CAGhC,OAAO,EAFO,KAAK,UAAU,CAER,CAErB,eAAe,EAAQ,CACrB,EACA,GAAG,GACsD,CAEzD,OADI,IAAS,IAAA,GAAkB,EAAE,CAC1B,EACJ,QAAQ,EAAK,EAAM,EAAM,EAAO,EAAU,EAAQ,CAClD,KAAK,KAAM,IACN,IAAQ,GACH,CAAC,EAAI,CAEL,EAAQ,EAAW,CAAC,KAAK,GAAQ,EAAK,OAAO,EAAI,CAAC,CAE3D,IAKG,EAAb,cACU,CAEV,CACE,MAEA,KAAwB,UAExB,OAEA,YAAY,EAA4B,EAAe,CACrD,MAAM,CAAC,EAAK,CAAC,CACb,KAAK,MAAQ,EAMf,MAAe,QACb,EACA,EACA,EACA,EACA,EACA,EAC8B,CAC9B,GAAM,CAAC,GAAO,MAAM,KAAK,SACvB,EACA,EACA,EACA,EACA,EACA,EACD,CAQC,OANE,aAAe,MACV,GACE,IAAQ,GAGb,KAAK,MAAc,KAAK,MACrB,GAHA,KAQA,EAAb,cACU,CAEV,CACE,KAAwB,WAExB,OAEA,aAAc,CACZ,MAAM,EAAE,CAAC,CAQX,MAAe,SAAwC,CACrD,MAAO,KAIE,EAAb,cACU,CAEV,CACE,KAAwB,WAExB,OAEA,aAAc,CACZ,MAAM,EAAE,CAAC,CAQX,MAAe,SAAwC,CACrD,MAAO"}
+{"version":3,"file":"rules.mjs","names":[],"sources":["../../src/shield/rules.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 {\n  LogicRuleInterface,\n  OptionsInterface,\n  RuleFunctionInterface,\n  RuleInterface,\n  RuleResultInterface,\n  ShieldRule\n} from \"./types\";\n\nexport class Rule<\n  TContext extends Record<string, any>\n> implements RuleInterface<TContext> {\n  readonly name: string;\n\n  func?: RuleFunctionInterface<TContext>;\n\n  constructor(name: string, func?: RuleFunctionInterface<TContext>) {\n    this.name = name;\n    this.func = func;\n  }\n\n  async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    try {\n      /* Resolve */\n      const res = await this.executeRule(\n        ctx,\n        type,\n        path,\n        input,\n        rawInput,\n        options\n      );\n\n      if (res instanceof Error) {\n        return res;\n      } else if (typeof res === \"string\") {\n        return new Error(res);\n      } else if (res === true) {\n        return true;\n      } else {\n        return false;\n      }\n    } catch (err) {\n      if (options.debug) {\n        throw err;\n      } else {\n        return false;\n      }\n    }\n  }\n\n  /**\n   *\n   * Compares a given rule with the current one\n   * and checks whether their functions are equal.\n   *\n   */\n  equals(rule: Rule<TContext>): boolean {\n    return this.func === rule.func;\n  }\n\n  executeRule<TContext extends Record<string, any>>(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): string | boolean | Error | Promise<RuleResultInterface> {\n    // @ts-ignore\n    return this.func(ctx, type, path, input, rawInput, options);\n  }\n}\n\nexport class LogicRule<TContext extends Record<string, any>>\n  extends Rule<TContext>\n  implements LogicRuleInterface<TContext>\n{\n  private rules: ShieldRule<TContext>[];\n\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(\"LogicRule\");\n\n    this.rules = rules;\n  }\n\n  /**\n   * By default logic rule resolves to false.\n   */\n  override async resolve(\n    _ctx: TContext,\n    _type: string,\n    _path: string,\n    _input: { [name: string]: any },\n    _rawInput: unknown,\n    _options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    return false;\n  }\n\n  /**\n   * Evaluates all the rules.\n   */\n  async evaluate(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface[]> {\n    const rules = this.getRules();\n    const tasks = rules.map(async rule =>\n      rule.resolve(ctx, type, path, input, rawInput, options)\n    );\n\n    return Promise.all(tasks);\n  }\n\n  /**\n   * Returns rules in a logic rule.\n   */\n  getRules() {\n    return this.rules;\n  }\n}\n\n// Extended Types\n\nexport class RuleOr<\n  TContext extends Record<string, any>\n> extends LogicRule<TContext> {\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(rules);\n  }\n\n  /**\n   * Makes sure that at least one of them has evaluated to true.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const result = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (result.every(res => res !== true)) {\n      const customError = result.find(res => res instanceof Error);\n\n      return customError ?? false;\n    } else {\n      return true;\n    }\n  }\n}\n\nexport class RuleAnd<\n  TContext extends Record<string, any>\n> extends LogicRule<TContext> {\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(rules);\n  }\n\n  /**\n   * Makes sure that all of them have resolved to true.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const result = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (result.some(res => res !== true)) {\n      const customError = result.find(res => res instanceof Error);\n\n      return customError ?? false;\n    } else {\n      return true;\n    }\n  }\n}\n\nexport class RuleChain<\n  TContext extends Record<string, any>\n> extends LogicRule<TContext> {\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(rules);\n  }\n\n  /**\n   * Makes sure that all of them have resolved to true.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const result = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (result.some(res => res !== true)) {\n      const customError = result.find(res => res instanceof Error);\n\n      return customError ?? false;\n    } else {\n      return true;\n    }\n  }\n\n  /**\n   * Evaluates all the rules.\n   */\n  override async evaluate(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface[]> {\n    const rules = this.getRules();\n\n    return iterate(rules);\n\n    async function iterate([\n      rule,\n      ...otherRules\n    ]: ShieldRule<TContext>[]): Promise<RuleResultInterface[]> {\n      if (rule === undefined) return [];\n      return rule\n        .resolve(ctx, type, path, input, rawInput, options)\n        .then(async res => {\n          if (res !== true) {\n            return [res];\n          } else {\n            return iterate(otherRules).then(ress => ress.concat(res));\n          }\n        });\n    }\n  }\n}\n\nexport class RuleRace<\n  TContext extends Record<string, any>\n> extends LogicRule<TContext> {\n  constructor(rules: ShieldRule<TContext>[]) {\n    super(rules);\n  }\n\n  /**\n   * Makes sure that at least one of them resolved to true.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const result = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (result.includes(true)) {\n      return true;\n    } else {\n      const customError = result.find(res => res instanceof Error);\n\n      return customError ?? false;\n    }\n  }\n\n  /**\n   * Evaluates all the rules.\n   */\n  override async evaluate(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface[]> {\n    const rules = this.getRules();\n\n    return iterate(rules);\n\n    async function iterate([\n      rule,\n      ...otherRules\n    ]: ShieldRule<TContext>[]): Promise<RuleResultInterface[]> {\n      if (rule === undefined) return [];\n      return rule\n        .resolve(ctx, type, path, input, rawInput, options)\n        .then(async res => {\n          if (res === true) {\n            return [res];\n          } else {\n            return iterate(otherRules).then(ress => ress.concat(res));\n          }\n        });\n    }\n  }\n}\n\nexport class RuleNot<TContext extends Record<string, any>>\n  extends LogicRule<TContext>\n  implements LogicRuleInterface<TContext>\n{\n  error?: Error;\n\n  override name: string = \"RuleNot\";\n\n  override equals!: (rule: RuleInterface<TContext>) => boolean;\n\n  constructor(rule: ShieldRule<TContext>, error?: Error) {\n    super([rule]);\n    this.error = error;\n  }\n\n  /**\n   * Negates the result.\n   */\n  override async resolve(\n    ctx: TContext,\n    type: string,\n    path: string,\n    input: { [name: string]: any },\n    rawInput: unknown,\n    options: OptionsInterface<TContext>\n  ): Promise<RuleResultInterface> {\n    const [res] = await this.evaluate(\n      ctx,\n      type,\n      path,\n      input,\n      rawInput,\n      options\n    );\n\n    if (res instanceof Error) {\n      return true;\n    } else if (res !== true) {\n      return true;\n    } else {\n      if (this.error) return this.error;\n      return false;\n    }\n  }\n}\n\nexport class RuleTrue<TContext extends Record<string, any>>\n  extends LogicRule<TContext>\n  implements LogicRuleInterface<TContext>\n{\n  override name: string = \"RuleTrue\";\n\n  override equals!: (rule: RuleInterface<TContext>) => boolean;\n\n  constructor() {\n    super([]);\n  }\n\n  /**\n   *\n   * Always true.\n   *\n   */\n  override async resolve(): Promise<RuleResultInterface> {\n    return true;\n  }\n}\n\nexport class RuleFalse<TContext extends Record<string, any>>\n  extends LogicRule<TContext>\n  implements LogicRuleInterface<TContext>\n{\n  override name: string = \"RuleTrue\";\n\n  override equals!: (rule: RuleInterface<TContext>) => boolean;\n\n  constructor() {\n    super([]);\n  }\n\n  /**\n   *\n   * Always false.\n   *\n   */\n  override async resolve(): Promise<RuleResultInterface> {\n    return false;\n  }\n}\n"],"mappings":"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"}

package/dist/shield/shield.cjs

@@ -1 +1,31 @@
-const e=require(`./constructors.cjs`),t=require(`./generator.cjs`),n=require(`./utils.cjs`),r=require(`./validation.cjs`);function i(t){return typeof t.fallbackError==`string`&&(t.fallbackError=Error(t.fallbackError)),{debug:t.debug??!1,allowExternalErrors:n.withDefault(!1)(t.allowExternalErrors),fallbackRule:n.withDefault(e.allow)(t.fallbackRule),fallbackError:n.withDefault(Error(`Authorization error`))(t.fallbackError)}}function a(e,n={}){let a=i(n),o=r.validateRuleTree(e);if(o.status===`ok`)return t.generateMiddlewareFromRuleTree(e,a);throw new r.ValidationError(o.message)}exports.shield=a;
+const require_shield_constructors = require('./constructors.cjs');
+const require_shield_generator = require('./generator.cjs');
+const require_shield_utils = require('./utils.cjs');
+const require_shield_validation = require('./validation.cjs');
+
+//#region src/shield/shield.ts
+/**
+* Makes sure all of defined rules are in accord with the options
+* shield can process.
+*/
+function normalizeOptions(options) {
+	if (typeof options.fallbackError === "string") options.fallbackError = new Error(options.fallbackError);
+	return {
+		debug: options.debug ?? false,
+		allowExternalErrors: require_shield_utils.withDefault(false)(options.allowExternalErrors),
+		fallbackRule: require_shield_utils.withDefault(require_shield_constructors.allow)(options.fallbackRule),
+		fallbackError: require_shield_utils.withDefault(/* @__PURE__ */ new Error("Authorization error"))(options.fallbackError)
+	};
+}
+/**
+* Validates rules and generates middleware from defined rule tree.
+*/
+function shield(ruleTree, options = {}) {
+	const normalizedOptions = normalizeOptions(options);
+	const ruleTreeValidity = require_shield_validation.validateRuleTree(ruleTree);
+	if (ruleTreeValidity.status === "ok") return require_shield_generator.generateMiddlewareFromRuleTree(ruleTree, normalizedOptions);
+	else throw new require_shield_validation.ValidationError(ruleTreeValidity.message);
+}
+
+//#endregion
+exports.shield = shield;

package/dist/shield/shield.mjs

@@ -1,2 +1,32 @@
-import{allow as e}from"./constructors.mjs";import{generateMiddlewareFromRuleTree as t}from"./generator.mjs";import{withDefault as n}from"./utils.mjs";import{ValidationError as r,validateRuleTree as i}from"./validation.mjs";function a(t){return typeof t.fallbackError==`string`&&(t.fallbackError=Error(t.fallbackError)),{debug:t.debug??!1,allowExternalErrors:n(!1)(t.allowExternalErrors),fallbackRule:n(e)(t.fallbackRule),fallbackError:n(Error(`Authorization error`))(t.fallbackError)}}function o(e,n={}){let o=a(n),s=i(e);if(s.status===`ok`)return t(e,o);throw new r(s.message)}export{o as shield};
+import { allow } from "./constructors.mjs";
+import { generateMiddlewareFromRuleTree } from "./generator.mjs";
+import { withDefault } from "./utils.mjs";
+import { ValidationError, validateRuleTree } from "./validation.mjs";
+
+//#region src/shield/shield.ts
+/**
+* Makes sure all of defined rules are in accord with the options
+* shield can process.
+*/
+function normalizeOptions(options) {
+	if (typeof options.fallbackError === "string") options.fallbackError = new Error(options.fallbackError);
+	return {
+		debug: options.debug ?? false,
+		allowExternalErrors: withDefault(false)(options.allowExternalErrors),
+		fallbackRule: withDefault(allow)(options.fallbackRule),
+		fallbackError: withDefault(/* @__PURE__ */ new Error("Authorization error"))(options.fallbackError)
+	};
+}
+/**
+* Validates rules and generates middleware from defined rule tree.
+*/
+function shield(ruleTree, options = {}) {
+	const normalizedOptions = normalizeOptions(options);
+	const ruleTreeValidity = validateRuleTree(ruleTree);
+	if (ruleTreeValidity.status === "ok") return generateMiddlewareFromRuleTree(ruleTree, normalizedOptions);
+	else throw new ValidationError(ruleTreeValidity.message);
+}
+
+//#endregion
+export { shield };
 //# sourceMappingURL=shield.mjs.map

package/dist/shield/shield.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"shield.mjs","names":[],"sources":["../../src/shield/shield.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 { MiddlewareFunction } from \"@trpc/server/unstable-core-do-not-import\";\nimport { allow } from \"./constructors\";\nimport { generateMiddlewareFromRuleTree } from \"./generator\";\nimport type {\n  IFallbackErrorType,\n  IRules,\n  OptionsConstructorInterface,\n  OptionsInterface,\n  ShieldRule\n} from \"./types\";\nimport { withDefault } from \"./utils\";\nimport { ValidationError, validateRuleTree } from \"./validation\";\n\n/**\n * Makes sure all of defined rules are in accord with the options\n * shield can process.\n */\nfunction normalizeOptions<TContext extends Record<string, any>>(\n  options: OptionsConstructorInterface<TContext>\n): OptionsInterface<TContext> {\n  if (typeof options.fallbackError === \"string\") {\n    options.fallbackError = new Error(options.fallbackError);\n  }\n\n  return {\n    debug: options.debug ?? false,\n    allowExternalErrors: withDefault(false)(options.allowExternalErrors),\n    fallbackRule: withDefault<ShieldRule<TContext>>(\n      allow as ShieldRule<TContext>\n    )(options.fallbackRule),\n    fallbackError: withDefault<IFallbackErrorType<TContext>>(\n      new Error(\"Authorization error\")\n    )(options.fallbackError)\n  };\n}\n\n/**\n * Validates rules and generates middleware from defined rule tree.\n */\nexport function shield<\n  TContext extends Record<string, any>,\n  TMeta extends object = object\n>(\n  ruleTree: IRules<TContext>,\n  options: OptionsConstructorInterface<TContext> = {}\n): MiddlewareFunction<TContext, TMeta, TContext, TContext, unknown> {\n  const normalizedOptions = normalizeOptions<TContext>(options);\n  const ruleTreeValidity = validateRuleTree<TContext>(ruleTree);\n\n  if (ruleTreeValidity.status === \"ok\") {\n    return generateMiddlewareFromRuleTree<TContext>(\n      ruleTree,\n      normalizedOptions\n    ) as any;\n  } else {\n    throw new ValidationError(ruleTreeValidity.message);\n  }\n}\n"],"mappings":"+NAmCA,SAAS,EACP,EAC4B,CAK5B,OAJI,OAAO,EAAQ,eAAkB,WACnC,EAAQ,cAAoB,MAAM,EAAQ,cAAc,EAGnD,CACL,MAAO,EAAQ,OAAS,GACxB,oBAAqB,EAAY,GAAM,CAAC,EAAQ,oBAAoB,CACpE,aAAc,EACZ,EACD,CAAC,EAAQ,aAAa,CACvB,cAAe,EACT,MAAM,sBAAsB,CACjC,CAAC,EAAQ,cAAc,CACzB,CAMH,SAAgB,EAId,EACA,EAAiD,EAAE,CACe,CAClE,IAAM,EAAoB,EAA2B,EAAQ,CACvD,EAAmB,EAA2B,EAAS,CAE7D,GAAI,EAAiB,SAAW,KAC9B,OAAO,EACL,EACA,EACD,CAED,MAAM,IAAI,EAAgB,EAAiB,QAAQ"}
+{"version":3,"file":"shield.mjs","names":[],"sources":["../../src/shield/shield.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 { MiddlewareFunction } from \"@trpc/server/unstable-core-do-not-import\";\nimport { allow } from \"./constructors\";\nimport { generateMiddlewareFromRuleTree } from \"./generator\";\nimport type {\n  IFallbackErrorType,\n  IRules,\n  OptionsConstructorInterface,\n  OptionsInterface,\n  ShieldRule\n} from \"./types\";\nimport { withDefault } from \"./utils\";\nimport { ValidationError, validateRuleTree } from \"./validation\";\n\n/**\n * Makes sure all of defined rules are in accord with the options\n * shield can process.\n */\nfunction normalizeOptions<TContext extends Record<string, any>>(\n  options: OptionsConstructorInterface<TContext>\n): OptionsInterface<TContext> {\n  if (typeof options.fallbackError === \"string\") {\n    options.fallbackError = new Error(options.fallbackError);\n  }\n\n  return {\n    debug: options.debug ?? false,\n    allowExternalErrors: withDefault(false)(options.allowExternalErrors),\n    fallbackRule: withDefault<ShieldRule<TContext>>(\n      allow as ShieldRule<TContext>\n    )(options.fallbackRule),\n    fallbackError: withDefault<IFallbackErrorType<TContext>>(\n      new Error(\"Authorization error\")\n    )(options.fallbackError)\n  };\n}\n\n/**\n * Validates rules and generates middleware from defined rule tree.\n */\nexport function shield<\n  TContext extends Record<string, any>,\n  TMeta extends object = object\n>(\n  ruleTree: IRules<TContext>,\n  options: OptionsConstructorInterface<TContext> = {}\n): MiddlewareFunction<TContext, TMeta, TContext, TContext, unknown> {\n  const normalizedOptions = normalizeOptions<TContext>(options);\n  const ruleTreeValidity = validateRuleTree<TContext>(ruleTree);\n\n  if (ruleTreeValidity.status === \"ok\") {\n    return generateMiddlewareFromRuleTree<TContext>(\n      ruleTree,\n      normalizedOptions\n    ) as any;\n  } else {\n    throw new ValidationError(ruleTreeValidity.message);\n  }\n}\n"],"mappings":";;;;;;;;;;AAmCA,SAAS,iBACP,SAC4B;AAC5B,KAAI,OAAO,QAAQ,kBAAkB,SACnC,SAAQ,gBAAgB,IAAI,MAAM,QAAQ,cAAc;AAG1D,QAAO;EACL,OAAO,QAAQ,SAAS;EACxB,qBAAqB,YAAY,MAAM,CAAC,QAAQ,oBAAoB;EACpE,cAAc,YACZ,MACD,CAAC,QAAQ,aAAa;EACvB,eAAe,4BACb,IAAI,MAAM,sBAAsB,CACjC,CAAC,QAAQ,cAAc;EACzB;;;;;AAMH,SAAgB,OAId,UACA,UAAiD,EAAE,EACe;CAClE,MAAM,oBAAoB,iBAA2B,QAAQ;CAC7D,MAAM,mBAAmB,iBAA2B,SAAS;AAE7D,KAAI,iBAAiB,WAAW,KAC9B,QAAO,+BACL,UACA,kBACD;KAED,OAAM,IAAI,gBAAgB,iBAAiB,QAAQ"}

package/dist/shield/utils.cjs

@@ -1 +1,56 @@
-const e=require(`./rules.cjs`);function t(t){return t instanceof e.Rule||t&&t.constructor&&t.constructor.name===`Rule`}function n(t){return t instanceof e.LogicRule||t&&t.constructor&&(t.constructor.name===`RuleOr`||t.constructor.name===`RuleAnd`||t.constructor.name===`RuleChain`||t.constructor.name===`RuleRace`||t.constructor.name===`RuleNot`||t.constructor.name===`RuleTrue`||t.constructor.name===`RuleFalse`)}function r(e){return t(e)||n(e)}function i(e){return typeof e==`object`&&Object.values(e).every(e=>r(e))}function a(e,t){return Object.keys(e).reduce((n,r)=>{let i=e[r];return t(i)?[...n,i]:typeof i==`object`&&!t(i)?[...n,...a(i,t)]:n},[])}function o(e){return t=>t===void 0?e:t}exports.flattenObjectOf=a,exports.isLogicRule=n,exports.isRule=t,exports.isRuleFieldMap=i,exports.isRuleFunction=r,exports.withDefault=o;
+const require_shield_rules = require('./rules.cjs');
+
+//#region src/shield/utils.ts
+/**
+* Makes sure that a certain field is a rule.
+*/
+function isRule(x) {
+	return x instanceof require_shield_rules.Rule || x && x.constructor && x.constructor.name === "Rule";
+}
+/**
+* Makes sure that a certain field is a logic rule.
+*/
+function isLogicRule(x) {
+	return x instanceof require_shield_rules.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");
+}
+/**
+* Makes sure that a certain field is a rule or a logic rule.
+*/
+function isRuleFunction(x) {
+	return isRule(x) || isLogicRule(x);
+}
+/**
+* Determines whether a certain field is rule field map or not.
+*/
+function isRuleFieldMap(x) {
+	return typeof x === "object" && Object.values(x).every((rule) => isRuleFunction(rule));
+}
+/**
+* Flattens object of particular type by checking if the leaf
+* evaluates to true from particular function.
+*/
+function flattenObjectOf(obj, f) {
+	return Object.keys(obj).reduce((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;
+	}, []);
+}
+/**
+* Returns fallback is provided value is undefined
+*/
+function withDefault(fallback) {
+	return (value) => {
+		if (value === void 0) return fallback;
+		return value;
+	};
+}
+
+//#endregion
+exports.flattenObjectOf = flattenObjectOf;
+exports.isLogicRule = isLogicRule;
+exports.isRule = isRule;
+exports.isRuleFieldMap = isRuleFieldMap;
+exports.isRuleFunction = isRuleFunction;
+exports.withDefault = withDefault;

package/dist/shield/utils.mjs

@@ -1,2 +1,52 @@
-import{LogicRule as e,Rule as t}from"./rules.mjs";function n(e){return e instanceof t||e&&e.constructor&&e.constructor.name===`Rule`}function r(t){return t instanceof e||t&&t.constructor&&(t.constructor.name===`RuleOr`||t.constructor.name===`RuleAnd`||t.constructor.name===`RuleChain`||t.constructor.name===`RuleRace`||t.constructor.name===`RuleNot`||t.constructor.name===`RuleTrue`||t.constructor.name===`RuleFalse`)}function i(e){return n(e)||r(e)}function a(e){return typeof e==`object`&&Object.values(e).every(e=>i(e))}function o(e,t){return Object.keys(e).reduce((n,r)=>{let i=e[r];return t(i)?[...n,i]:typeof i==`object`&&!t(i)?[...n,...o(i,t)]:n},[])}function s(e){return t=>t===void 0?e:t}export{o as flattenObjectOf,r as isLogicRule,n as isRule,a as isRuleFieldMap,i as isRuleFunction,s as withDefault};
+import { LogicRule, Rule } from "./rules.mjs";
+
+//#region src/shield/utils.ts
+/**
+* Makes sure that a certain field is a rule.
+*/
+function isRule(x) {
+	return x instanceof Rule || x && x.constructor && x.constructor.name === "Rule";
+}
+/**
+* Makes sure that a certain field is a logic rule.
+*/
+function isLogicRule(x) {
+	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");
+}
+/**
+* Makes sure that a certain field is a rule or a logic rule.
+*/
+function isRuleFunction(x) {
+	return isRule(x) || isLogicRule(x);
+}
+/**
+* Determines whether a certain field is rule field map or not.
+*/
+function isRuleFieldMap(x) {
+	return typeof x === "object" && Object.values(x).every((rule) => isRuleFunction(rule));
+}
+/**
+* Flattens object of particular type by checking if the leaf
+* evaluates to true from particular function.
+*/
+function flattenObjectOf(obj, f) {
+	return Object.keys(obj).reduce((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;
+	}, []);
+}
+/**
+* Returns fallback is provided value is undefined
+*/
+function withDefault(fallback) {
+	return (value) => {
+		if (value === void 0) return fallback;
+		return value;
+	};
+}
+
+//#endregion
+export { flattenObjectOf, isLogicRule, isRule, isRuleFieldMap, isRuleFunction, withDefault };
 //# sourceMappingURL=utils.mjs.map

package/dist/shield/utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.mjs","names":[],"sources":["../../src/shield/utils.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 { LogicRule, Rule } from \"./rules\";\nimport type {\n  LogicRuleInterface,\n  RuleFieldMapInterface,\n  RuleInterface,\n  ShieldRule\n} from \"./types\";\n\n/**\n * Makes sure that a certain field is a rule.\n */\nexport function isRule<TContext extends Record<string, any>>(\n  x: any\n): x is RuleInterface<TContext> {\n  return (\n    x instanceof Rule || (x && x.constructor && x.constructor.name === \"Rule\")\n  );\n}\n\n/**\n * Makes sure that a certain field is a logic rule.\n */\nexport function isLogicRule<TContext extends Record<string, any>>(\n  x: any\n): x is LogicRuleInterface<TContext> {\n  return (\n    x instanceof LogicRule ||\n    (x &&\n      x.constructor &&\n      (x.constructor.name === \"RuleOr\" ||\n        x.constructor.name === \"RuleAnd\" ||\n        x.constructor.name === \"RuleChain\" ||\n        x.constructor.name === \"RuleRace\" ||\n        x.constructor.name === \"RuleNot\" ||\n        x.constructor.name === \"RuleTrue\" ||\n        x.constructor.name === \"RuleFalse\"))\n  );\n}\n\n/**\n * Makes sure that a certain field is a rule or a logic rule.\n */\nexport function isRuleFunction<TContext extends Record<string, any>>(\n  x: any\n): x is ShieldRule<TContext> {\n  return isRule(x) || isLogicRule(x);\n}\n\n/**\n * Determines whether a certain field is rule field map or not.\n */\nexport function isRuleFieldMap<TContext extends Record<string, any>>(\n  x: any\n): x is RuleFieldMapInterface<TContext> {\n  return (\n    typeof x === \"object\" &&\n    Object.values(x).every(rule => isRuleFunction(rule))\n  );\n}\n\n/**\n * Flattens object of particular type by checking if the leaf\n * evaluates to true from particular function.\n */\nexport function flattenObjectOf<T>(\n  obj: { [key: string]: any },\n  f: (x: any) => boolean\n): T[] {\n  const values = Object.keys(obj).reduce<T[]>((acc, key) => {\n    const val = obj[key];\n    if (f(val)) {\n      return [...acc, val];\n    } else if (typeof val === \"object\" && !f(val)) {\n      return [...acc, ...flattenObjectOf(val, f)];\n    } else {\n      return acc;\n    }\n  }, []);\n\n  return values;\n}\n\n/**\n * Returns fallback is provided value is undefined\n */\nexport function withDefault<T>(fallback: T): (value: T | undefined) => T {\n  return value => {\n    if (value === undefined) return fallback;\n    return value;\n  };\n}\n"],"mappings":"kDA6BA,SAAgB,EACd,EAC8B,CAC9B,OACE,aAAa,GAAS,GAAK,EAAE,aAAe,EAAE,YAAY,OAAS,OAOvE,SAAgB,EACd,EACmC,CACnC,OACE,aAAa,GACZ,GACC,EAAE,cACD,EAAE,YAAY,OAAS,UACtB,EAAE,YAAY,OAAS,WACvB,EAAE,YAAY,OAAS,aACvB,EAAE,YAAY,OAAS,YACvB,EAAE,YAAY,OAAS,WACvB,EAAE,YAAY,OAAS,YACvB,EAAE,YAAY,OAAS,aAO/B,SAAgB,EACd,EAC2B,CAC3B,OAAO,EAAO,EAAE,EAAI,EAAY,EAAE,CAMpC,SAAgB,EACd,EACsC,CACtC,OACE,OAAO,GAAM,UACb,OAAO,OAAO,EAAE,CAAC,MAAM,GAAQ,EAAe,EAAK,CAAC,CAQxD,SAAgB,EACd,EACA,EACK,CAYL,OAXe,OAAO,KAAK,EAAI,CAAC,QAAa,EAAK,IAAQ,CACxD,IAAM,EAAM,EAAI,GAMd,OALE,EAAE,EAAI,CACD,CAAC,GAAG,EAAK,EAAI,CACX,OAAO,GAAQ,UAAY,CAAC,EAAE,EAAI,CACpC,CAAC,GAAG,EAAK,GAAG,EAAgB,EAAK,EAAE,CAAC,CAEpC,GAER,EAAE,CAAC,CAQR,SAAgB,EAAe,EAA0C,CACvE,MAAO,IACD,IAAU,IAAA,GAAkB,EACzB"}
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../src/shield/utils.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 { LogicRule, Rule } from \"./rules\";\nimport type {\n  LogicRuleInterface,\n  RuleFieldMapInterface,\n  RuleInterface,\n  ShieldRule\n} from \"./types\";\n\n/**\n * Makes sure that a certain field is a rule.\n */\nexport function isRule<TContext extends Record<string, any>>(\n  x: any\n): x is RuleInterface<TContext> {\n  return (\n    x instanceof Rule || (x && x.constructor && x.constructor.name === \"Rule\")\n  );\n}\n\n/**\n * Makes sure that a certain field is a logic rule.\n */\nexport function isLogicRule<TContext extends Record<string, any>>(\n  x: any\n): x is LogicRuleInterface<TContext> {\n  return (\n    x instanceof LogicRule ||\n    (x &&\n      x.constructor &&\n      (x.constructor.name === \"RuleOr\" ||\n        x.constructor.name === \"RuleAnd\" ||\n        x.constructor.name === \"RuleChain\" ||\n        x.constructor.name === \"RuleRace\" ||\n        x.constructor.name === \"RuleNot\" ||\n        x.constructor.name === \"RuleTrue\" ||\n        x.constructor.name === \"RuleFalse\"))\n  );\n}\n\n/**\n * Makes sure that a certain field is a rule or a logic rule.\n */\nexport function isRuleFunction<TContext extends Record<string, any>>(\n  x: any\n): x is ShieldRule<TContext> {\n  return isRule(x) || isLogicRule(x);\n}\n\n/**\n * Determines whether a certain field is rule field map or not.\n */\nexport function isRuleFieldMap<TContext extends Record<string, any>>(\n  x: any\n): x is RuleFieldMapInterface<TContext> {\n  return (\n    typeof x === \"object\" &&\n    Object.values(x).every(rule => isRuleFunction(rule))\n  );\n}\n\n/**\n * Flattens object of particular type by checking if the leaf\n * evaluates to true from particular function.\n */\nexport function flattenObjectOf<T>(\n  obj: { [key: string]: any },\n  f: (x: any) => boolean\n): T[] {\n  const values = Object.keys(obj).reduce<T[]>((acc, key) => {\n    const val = obj[key];\n    if (f(val)) {\n      return [...acc, val];\n    } else if (typeof val === \"object\" && !f(val)) {\n      return [...acc, ...flattenObjectOf(val, f)];\n    } else {\n      return acc;\n    }\n  }, []);\n\n  return values;\n}\n\n/**\n * Returns fallback is provided value is undefined\n */\nexport function withDefault<T>(fallback: T): (value: T | undefined) => T {\n  return value => {\n    if (value === undefined) return fallback;\n    return value;\n  };\n}\n"],"mappings":";;;;;;AA6BA,SAAgB,OACd,GAC8B;AAC9B,QACE,aAAa,QAAS,KAAK,EAAE,eAAe,EAAE,YAAY,SAAS;;;;;AAOvE,SAAgB,YACd,GACmC;AACnC,QACE,aAAa,aACZ,KACC,EAAE,gBACD,EAAE,YAAY,SAAS,YACtB,EAAE,YAAY,SAAS,aACvB,EAAE,YAAY,SAAS,eACvB,EAAE,YAAY,SAAS,cACvB,EAAE,YAAY,SAAS,aACvB,EAAE,YAAY,SAAS,cACvB,EAAE,YAAY,SAAS;;;;;AAO/B,SAAgB,eACd,GAC2B;AAC3B,QAAO,OAAO,EAAE,IAAI,YAAY,EAAE;;;;;AAMpC,SAAgB,eACd,GACsC;AACtC,QACE,OAAO,MAAM,YACb,OAAO,OAAO,EAAE,CAAC,OAAM,SAAQ,eAAe,KAAK,CAAC;;;;;;AAQxD,SAAgB,gBACd,KACA,GACK;AAYL,QAXe,OAAO,KAAK,IAAI,CAAC,QAAa,KAAK,QAAQ;EACxD,MAAM,MAAM,IAAI;AAChB,MAAI,EAAE,IAAI,CACR,QAAO,CAAC,GAAG,KAAK,IAAI;WACX,OAAO,QAAQ,YAAY,CAAC,EAAE,IAAI,CAC3C,QAAO,CAAC,GAAG,KAAK,GAAG,gBAAgB,KAAK,EAAE,CAAC;MAE3C,QAAO;IAER,EAAE,CAAC;;;;;AAQR,SAAgB,YAAe,UAA0C;AACvE,SAAO,UAAS;AACd,MAAI,UAAU,OAAW,QAAO;AAChC,SAAO"}

package/dist/shield/validation.cjs

@@ -1 +1,59 @@
-const e=require(`./utils.cjs`);function t(t){let n=r(t).reduce(({map:e,duplicates:t},n)=>e.has(n.name)?!e.get(n.name).equals(n)&&!t.includes(n.name)?{map:e.set(n.name,n),duplicates:[...t,n.name]}:{map:e,duplicates:t}:{map:e.set(n.name,n),duplicates:t},{map:new Map,duplicates:[]});if(n.duplicates.length===0)return{status:`ok`};return{status:`err`,message:`There seem to be multiple definitions of these rules: ${n.duplicates.join(`, `)}`};function r(t){return e.flattenObjectOf(t,e.isRuleFunction).reduce((t,n)=>e.isLogicRule(n)?[...t,...i(n)]:[...t,n],[])}function i(t){return t.getRules().reduce((t,n)=>e.isLogicRule(n)?[...t,...i(n)]:[...t,n],[])}}var n=class extends Error{constructor(e){super(e)}};exports.ValidationError=n,exports.validateRuleTree=t;
+const require_shield_utils = require('./utils.cjs');
+
+//#region src/shield/validation.ts
+/**
+* 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.
+*/
+function validateRuleTree(ruleTree) {
+	const valid = extractRules(ruleTree).reduce(({ 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: /* @__PURE__ */ new Map(),
+		duplicates: []
+	});
+	if (valid.duplicates.length === 0) return { status: "ok" };
+	else return {
+		status: "err",
+		message: `There seem to be multiple definitions of these rules: ${valid.duplicates.join(", ")}`
+	};
+	/**
+	* Extracts rules from rule tree.
+	*/
+	function extractRules(ruleTree$1) {
+		return require_shield_utils.flattenObjectOf(ruleTree$1, require_shield_utils.isRuleFunction).reduce((rules, rule) => {
+			if (require_shield_utils.isLogicRule(rule)) return [...rules, ...extractLogicRules(rule)];
+			else return [...rules, rule];
+		}, []);
+	}
+	/**
+	* Recursively extracts Rules from LogicRule
+	*/
+	function extractLogicRules(rule) {
+		return rule.getRules().reduce((acc, shieldRule) => {
+			if (require_shield_utils.isLogicRule(shieldRule)) return [...acc, ...extractLogicRules(shieldRule)];
+			else return [...acc, shieldRule];
+		}, []);
+	}
+}
+var ValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+};
+
+//#endregion
+exports.ValidationError = ValidationError;
+exports.validateRuleTree = validateRuleTree;

package/dist/shield/validation.mjs

@@ -1,2 +1,59 @@
-import{flattenObjectOf as e,isLogicRule as t,isRuleFunction as n}from"./utils.mjs";function r(r){let i=a(r).reduce(({map:e,duplicates:t},n)=>e.has(n.name)?!e.get(n.name).equals(n)&&!t.includes(n.name)?{map:e.set(n.name,n),duplicates:[...t,n.name]}:{map:e,duplicates:t}:{map:e.set(n.name,n),duplicates:t},{map:new Map,duplicates:[]});if(i.duplicates.length===0)return{status:`ok`};return{status:`err`,message:`There seem to be multiple definitions of these rules: ${i.duplicates.join(`, `)}`};function a(r){return e(r,n).reduce((e,n)=>t(n)?[...e,...o(n)]:[...e,n],[])}function o(e){return e.getRules().reduce((e,n)=>t(n)?[...e,...o(n)]:[...e,n],[])}}var i=class extends Error{constructor(e){super(e)}};export{i as ValidationError,r as validateRuleTree};
+import { flattenObjectOf, isLogicRule, isRuleFunction } from "./utils.mjs";
+
+//#region src/shield/validation.ts
+/**
+* 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.
+*/
+function validateRuleTree(ruleTree) {
+	const valid = extractRules(ruleTree).reduce(({ 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: /* @__PURE__ */ new Map(),
+		duplicates: []
+	});
+	if (valid.duplicates.length === 0) return { status: "ok" };
+	else return {
+		status: "err",
+		message: `There seem to be multiple definitions of these rules: ${valid.duplicates.join(", ")}`
+	};
+	/**
+	* Extracts rules from rule tree.
+	*/
+	function extractRules(ruleTree$1) {
+		return flattenObjectOf(ruleTree$1, isRuleFunction).reduce((rules, rule) => {
+			if (isLogicRule(rule)) return [...rules, ...extractLogicRules(rule)];
+			else return [...rules, rule];
+		}, []);
+	}
+	/**
+	* Recursively extracts Rules from LogicRule
+	*/
+	function extractLogicRules(rule) {
+		return rule.getRules().reduce((acc, shieldRule) => {
+			if (isLogicRule(shieldRule)) return [...acc, ...extractLogicRules(shieldRule)];
+			else return [...acc, shieldRule];
+		}, []);
+	}
+}
+var ValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+};
+
+//#endregion
+export { ValidationError, validateRuleTree };
 //# sourceMappingURL=validation.mjs.map

package/dist/shield/validation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"validation.mjs","names":["ruleTree"],"sources":["../../src/shield/validation.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 {\n  IRules,\n  LogicRuleInterface,\n  RuleInterface,\n  ShieldRule\n} from \"./types\";\nimport { flattenObjectOf, isLogicRule, isRuleFunction } from \"./utils\";\n\n/**\n * Validates the rule tree declaration by checking references of rule\n * functions. We deem rule tree valid if no two rules with the same name point\n * to different rules.\n */\nexport function validateRuleTree<TContext extends Record<string, any>>(\n  ruleTree: IRules<TContext>\n): { status: \"ok\" } | { status: \"err\"; message: string } {\n  const rules = extractRules(ruleTree);\n\n  const valid = rules.reduce<{\n    map: Map<string, RuleInterface<TContext>>;\n    duplicates: string[];\n  }>(\n    ({ map, duplicates }, rule) => {\n      if (!map.has(rule.name)) {\n        return { map: map.set(rule.name, rule), duplicates };\n      } else if (\n        !map.get(rule.name)!.equals(rule) &&\n        !duplicates.includes(rule.name)\n      ) {\n        return {\n          map: map.set(rule.name, rule),\n          duplicates: [...duplicates, rule.name]\n        };\n      } else {\n        return { map, duplicates };\n      }\n    },\n    { map: new Map<string, RuleInterface<TContext>>(), duplicates: [] }\n  );\n\n  if (valid.duplicates.length === 0) {\n    return { status: \"ok\" };\n  } else {\n    const duplicates = valid.duplicates.join(\", \");\n\n    return {\n      status: \"err\",\n      message: `There seem to be multiple definitions of these rules: ${duplicates}`\n    };\n  }\n\n  /**\n   * Extracts rules from rule tree.\n   */\n  function extractRules<TContext extends Record<string, any>>(\n    ruleTree: IRules<TContext>\n  ): RuleInterface<TContext>[] {\n    const resolvers = flattenObjectOf<ShieldRule<TContext>>(\n      ruleTree,\n      isRuleFunction\n    );\n\n    const rules = resolvers.reduce<RuleInterface<TContext>[]>((rules, rule) => {\n      if (isLogicRule(rule)) {\n        return [\n          ...rules,\n          ...extractLogicRules(rule)\n        ] as RuleInterface<TContext>[];\n      } else {\n        return [...rules, rule] as RuleInterface<TContext>[];\n      }\n    }, []);\n\n    return rules;\n  }\n\n  /**\n   * Recursively extracts Rules from LogicRule\n   */\n  function extractLogicRules<TContext extends Record<string, any>>(\n    rule: LogicRuleInterface<TContext>\n  ): RuleInterface<TContext>[] {\n    return rule\n      .getRules()\n      .reduce<RuleInterface<TContext>[]>((acc, shieldRule) => {\n        if (isLogicRule(shieldRule)) {\n          return [\n            ...acc,\n            ...extractLogicRules(shieldRule)\n          ] as RuleInterface<TContext>[];\n        } else {\n          return [...acc, shieldRule] as RuleInterface<TContext>[];\n        }\n      }, []);\n  }\n}\n\nexport class ValidationError extends Error {\n  constructor(message: string) {\n    super(message);\n  }\n}\n"],"mappings":"mFA+BA,SAAgB,EACd,EACuD,CAGvD,IAAM,EAFQ,EAAa,EAAS,CAEhB,QAIjB,CAAE,MAAK,cAAc,IACf,EAAI,IAAI,EAAK,KAAK,CAGrB,CAAC,EAAI,IAAI,EAAK,KAAK,CAAE,OAAO,EAAK,EACjC,CAAC,EAAW,SAAS,EAAK,KAAK,CAExB,CACL,IAAK,EAAI,IAAI,EAAK,KAAM,EAAK,CAC7B,WAAY,CAAC,GAAG,EAAY,EAAK,KAAK,CACvC,CAEM,CAAE,MAAK,aAAY,CAVnB,CAAE,IAAK,EAAI,IAAI,EAAK,KAAM,EAAK,CAAE,aAAY,CAaxD,CAAE,IAAK,IAAI,IAAwC,WAAY,EAAE,CAAE,CACpE,CAED,GAAI,EAAM,WAAW,SAAW,EAC9B,MAAO,CAAE,OAAQ,KAAM,CAIvB,MAAO,CACL,OAAQ,MACR,QAAS,yDAJQ,EAAM,WAAW,KAAK,KAAK,GAK7C,CAMH,SAAS,EACP,EAC2B,CAiB3B,OAhBkB,EAChBA,EACA,EACD,CAEuB,QAAmC,EAAO,IAC5D,EAAY,EAAK,CACZ,CACL,GAAG,EACH,GAAG,EAAkB,EAAK,CAC3B,CAEM,CAAC,GAAG,EAAO,EAAK,CAExB,EAAE,CAAC,CAQR,SAAS,EACP,EAC2B,CAC3B,OAAO,EACJ,UAAU,CACV,QAAmC,EAAK,IACnC,EAAY,EAAW,CAClB,CACL,GAAG,EACH,GAAG,EAAkB,EAAW,CACjC,CAEM,CAAC,GAAG,EAAK,EAAW,CAE5B,EAAE,CAAC,EAIZ,IAAa,EAAb,cAAqC,KAAM,CACzC,YAAY,EAAiB,CAC3B,MAAM,EAAQ"}
+{"version":3,"file":"validation.mjs","names":["ruleTree"],"sources":["../../src/shield/validation.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 {\n  IRules,\n  LogicRuleInterface,\n  RuleInterface,\n  ShieldRule\n} from \"./types\";\nimport { flattenObjectOf, isLogicRule, isRuleFunction } from \"./utils\";\n\n/**\n * Validates the rule tree declaration by checking references of rule\n * functions. We deem rule tree valid if no two rules with the same name point\n * to different rules.\n */\nexport function validateRuleTree<TContext extends Record<string, any>>(\n  ruleTree: IRules<TContext>\n): { status: \"ok\" } | { status: \"err\"; message: string } {\n  const rules = extractRules(ruleTree);\n\n  const valid = rules.reduce<{\n    map: Map<string, RuleInterface<TContext>>;\n    duplicates: string[];\n  }>(\n    ({ map, duplicates }, rule) => {\n      if (!map.has(rule.name)) {\n        return { map: map.set(rule.name, rule), duplicates };\n      } else if (\n        !map.get(rule.name)!.equals(rule) &&\n        !duplicates.includes(rule.name)\n      ) {\n        return {\n          map: map.set(rule.name, rule),\n          duplicates: [...duplicates, rule.name]\n        };\n      } else {\n        return { map, duplicates };\n      }\n    },\n    { map: new Map<string, RuleInterface<TContext>>(), duplicates: [] }\n  );\n\n  if (valid.duplicates.length === 0) {\n    return { status: \"ok\" };\n  } else {\n    const duplicates = valid.duplicates.join(\", \");\n\n    return {\n      status: \"err\",\n      message: `There seem to be multiple definitions of these rules: ${duplicates}`\n    };\n  }\n\n  /**\n   * Extracts rules from rule tree.\n   */\n  function extractRules<TContext extends Record<string, any>>(\n    ruleTree: IRules<TContext>\n  ): RuleInterface<TContext>[] {\n    const resolvers = flattenObjectOf<ShieldRule<TContext>>(\n      ruleTree,\n      isRuleFunction\n    );\n\n    const rules = resolvers.reduce<RuleInterface<TContext>[]>((rules, rule) => {\n      if (isLogicRule(rule)) {\n        return [\n          ...rules,\n          ...extractLogicRules(rule)\n        ] as RuleInterface<TContext>[];\n      } else {\n        return [...rules, rule] as RuleInterface<TContext>[];\n      }\n    }, []);\n\n    return rules;\n  }\n\n  /**\n   * Recursively extracts Rules from LogicRule\n   */\n  function extractLogicRules<TContext extends Record<string, any>>(\n    rule: LogicRuleInterface<TContext>\n  ): RuleInterface<TContext>[] {\n    return rule\n      .getRules()\n      .reduce<RuleInterface<TContext>[]>((acc, shieldRule) => {\n        if (isLogicRule(shieldRule)) {\n          return [\n            ...acc,\n            ...extractLogicRules(shieldRule)\n          ] as RuleInterface<TContext>[];\n        } else {\n          return [...acc, shieldRule] as RuleInterface<TContext>[];\n        }\n      }, []);\n  }\n}\n\nexport class ValidationError extends Error {\n  constructor(message: string) {\n    super(message);\n  }\n}\n"],"mappings":";;;;;;;;AA+BA,SAAgB,iBACd,UACuD;CAGvD,MAAM,QAFQ,aAAa,SAAS,CAEhB,QAIjB,EAAE,KAAK,cAAc,SAAS;AAC7B,MAAI,CAAC,IAAI,IAAI,KAAK,KAAK,CACrB,QAAO;GAAE,KAAK,IAAI,IAAI,KAAK,MAAM,KAAK;GAAE;GAAY;WAEpD,CAAC,IAAI,IAAI,KAAK,KAAK,CAAE,OAAO,KAAK,IACjC,CAAC,WAAW,SAAS,KAAK,KAAK,CAE/B,QAAO;GACL,KAAK,IAAI,IAAI,KAAK,MAAM,KAAK;GAC7B,YAAY,CAAC,GAAG,YAAY,KAAK,KAAK;GACvC;MAED,QAAO;GAAE;GAAK;GAAY;IAG9B;EAAE,qBAAK,IAAI,KAAsC;EAAE,YAAY,EAAE;EAAE,CACpE;AAED,KAAI,MAAM,WAAW,WAAW,EAC9B,QAAO,EAAE,QAAQ,MAAM;KAIvB,QAAO;EACL,QAAQ;EACR,SAAS,yDAJQ,MAAM,WAAW,KAAK,KAAK;EAK7C;;;;CAMH,SAAS,aACP,YAC2B;AAiB3B,SAhBkB,gBAChBA,YACA,eACD,CAEuB,QAAmC,OAAO,SAAS;AACzE,OAAI,YAAY,KAAK,CACnB,QAAO,CACL,GAAG,OACH,GAAG,kBAAkB,KAAK,CAC3B;OAED,QAAO,CAAC,GAAG,OAAO,KAAK;KAExB,EAAE,CAAC;;;;;CAQR,SAAS,kBACP,MAC2B;AAC3B,SAAO,KACJ,UAAU,CACV,QAAmC,KAAK,eAAe;AACtD,OAAI,YAAY,WAAW,CACzB,QAAO,CACL,GAAG,KACH,GAAG,kBAAkB,WAAW,CACjC;OAED,QAAO,CAAC,GAAG,KAAK,WAAW;KAE5B,EAAE,CAAC;;;AAIZ,IAAa,kBAAb,cAAqC,MAAM;CACzC,YAAY,SAAiB;AAC3B,QAAM,QAAQ"}