@stryke/trpc-next 0.4.1 → 0.5.0

package/dist/shield/constructors.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rule = exports.race = exports.or = exports.not = exports.deny = exports.chain = exports.and = exports.allow = void 0;
+var _rules = require("./rules.cjs");
+const rule = (e, t) => o => (typeof e == "object" ? (t = e, e = Math.random().toString()) : typeof e == "string" ? t = t ?? {} : (e = Math.random().toString(), t = {}), new _rules.Rule(e, o, {})),
+  and = (...e) => new _rules.RuleAnd(e),
+  chain = (...e) => new _rules.RuleChain(e),
+  race = (...e) => new _rules.RuleRace(e),
+  or = (...e) => new _rules.RuleOr(e),
+  not = (e, t) => typeof t == "string" ? new _rules.RuleNot(e, new Error(t)) : new _rules.RuleNot(e, t),
+  allow = exports.allow = new _rules.RuleTrue(),
+  deny = exports.deny = new _rules.RuleFalse();
+exports.not = not;
+exports.or = or;
+exports.race = race;
+exports.chain = chain;
+exports.and = and;
+exports.rule = rule;

package/dist/shield/constructors.d.ts

@@ -0,0 +1,54 @@
+import { Rule, RuleAnd, RuleChain, RuleFalse, RuleNot, RuleOr, RuleRace, RuleTrue } from "./rules";
+import type { IRuleConstructorOptions, IRuleFunction, ShieldRule } from "./types";
+/**
+ * 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
+ * })
+ * ```
+ */
+export declare const rule: <TContext extends Record<string, any>>(name?: string, options?: IRuleConstructorOptions) => (func: IRuleFunction<TContext>) => Rule<TContext>;
+/**
+ * Logical operator and serves as a wrapper for and operation.
+ */
+export declare const and: <TContext extends Record<string, any>>(...rules: ShieldRule<TContext>[]) => RuleAnd<TContext>;
+/**
+ * Logical operator and serves as a wrapper for and operation.
+ */
+export declare const chain: <TContext extends Record<string, any>>(...rules: ShieldRule<TContext>[]) => RuleChain<TContext>;
+/**
+ * Logical operator and serves as a wrapper for and operation.
+ */
+export declare const race: <TContext extends Record<string, any>>(...rules: ShieldRule<TContext>[]) => RuleRace<TContext>;
+/**
+ * Logical operator or serves as a wrapper for or operation.
+ */
+export declare const or: <TContext extends Record<string, any>>(...rules: ShieldRule<TContext>[]) => RuleOr<TContext>;
+/**
+ * Logical operator not serves as a wrapper for not operation.
+ */
+export declare const not: <TContext extends Record<string, any>>(rule: ShieldRule<TContext>, error?: string | Error) => RuleNot<TContext>;
+/**
+ * Allow queries.
+ */
+export declare const allow: RuleTrue<Record<string, any>>;
+/**
+ * Deny queries.
+ */
+export declare const deny: RuleFalse<Record<string, any>>;

package/dist/shield/constructors.mjs

@@ -0,0 +1 @@
+import{Rule as r,RuleAnd as u,RuleChain as l,RuleFalse as x,RuleNot as n,RuleOr as R,RuleRace as s,RuleTrue as i}from"./rules";export const rule=(e,t)=>o=>(typeof e=="object"?(t=e,e=Math.random().toString()):typeof e=="string"?t=t??{}:(e=Math.random().toString(),t={}),new r(e,o,{})),and=(...e)=>new u(e),chain=(...e)=>new l(e),race=(...e)=>new s(e),or=(...e)=>new R(e),not=(e,t)=>typeof t=="string"?new n(e,new Error(t)):new n(e,t),allow=new i,deny=new x;

package/dist/shield/generator.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateMiddlewareFromRuleTree = generateMiddlewareFromRuleTree;
+function generateMiddlewareFromRuleTree(r, o) {
+  return async ({
+    next: a,
+    ctx: d,
+    type: t,
+    path: c,
+    input: f,
+    rawInput: g
+  }) => {
+    const s = c.split("."),
+      i = s[s.length - 1],
+      l = Object.keys(r);
+    let n;
+    if (l.includes("query") || l.includes("mutation")) n = r?.[t]?.[i];else {
+      const e = s[0],
+        u = r[e];
+      u?.[t]?.[i] && (n = u?.[t]?.[i]);
+    }
+    return n = n ?? o.fallbackRule, n ? n?.resolve(d, t, c, f, g, o).then(async e => {
+      if (e instanceof Error) throw e;
+      if (!e) throw o.fallbackError;
+      return a();
+    }) : a();
+  };
+}

package/dist/shield/generator.d.ts

@@ -0,0 +1,14 @@
+import type { IOptions, IRules } from "./types";
+/**
+ * Generates middleware from given rules.
+ */
+export declare function generateMiddlewareFromRuleTree<TContext extends Record<string, unknown>>(ruleTree: IRules<TContext>, options: IOptions<TContext>): ({ next, ctx, type, path, input, rawInput }: {
+    next: () => Promise<any>;
+    ctx: TContext;
+    type: string;
+    path: string;
+    input: {
+        [name: string]: any;
+    };
+    rawInput: unknown;
+}) => Promise<any>;

package/dist/shield/generator.mjs

@@ -0,0 +1 @@
+export function generateMiddlewareFromRuleTree(r,o){return async({next:a,ctx:d,type:t,path:c,input:f,rawInput:g})=>{const s=c.split("."),i=s[s.length-1],l=Object.keys(r);let n;if(l.includes("query")||l.includes("mutation"))n=r?.[t]?.[i];else{const e=s[0],u=r[e];u?.[t]?.[i]&&(n=u?.[t]?.[i])}return n=n??o.fallbackRule,n?n?.resolve(d,t,c,f,g,o).then(async e=>{if(e instanceof Error)throw e;if(!e)throw o.fallbackError;return a()}):a()}}

package/dist/shield/index.cjs

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

package/dist/shield/index.d.ts

@@ -0,0 +1,3 @@
+export { allow, and, chain, deny, not, or, race, rule } from "./constructors";
+export { shield } from "./shield";
+export type { IRule, IRules } from "./types";

package/dist/shield/index.mjs

@@ -0,0 +1 @@
+export{allow,and,chain,deny,not,or,race,rule}from"./constructors";export{shield}from"./shield";

package/dist/shield/rules.cjs

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RuleTrue = exports.RuleRace = exports.RuleOr = exports.RuleNot = exports.RuleFalse = exports.RuleChain = exports.RuleAnd = exports.Rule = exports.LogicRule = void 0;
+class Rule {
+  name;
+  func;
+  constructor(e, n) {
+    this.name = e, this.func = n;
+  }
+  async resolve(e, n, s, o, u, r) {
+    try {
+      const t = await this.executeRule(e, n, s, o, u, r);
+      return t instanceof Error ? t : typeof t == "string" ? new Error(t) : t === !0;
+    } catch (t) {
+      if (r.debug) throw t;
+      return !1;
+    }
+  }
+  equals(e) {
+    return this.func === e.func;
+  }
+  executeRule(e, n, s, o, u, r) {
+    return this.func(e, n, s, o, u, r);
+  }
+}
+exports.Rule = Rule;
+class LogicRule extends Rule {
+  rules;
+  constructor(e) {
+    super("LogicRule"), this.rules = e;
+  }
+  async resolve(e, n, s, o, u, r) {
+    return !1;
+  }
+  async evaluate(e, n, s, o, u, r) {
+    const i = this.getRules().map(async l => l.resolve(e, n, s, o, u, r));
+    return Promise.all(i);
+  }
+  getRules() {
+    return this.rules;
+  }
+}
+exports.LogicRule = LogicRule;
+class RuleOr extends LogicRule {
+  constructor(e) {
+    super(e);
+  }
+  async resolve(e, n, s, o, u, r) {
+    const t = await this.evaluate(e, n, s, o, u, r);
+    return t.every(i => i !== !0) ? t.find(l => l instanceof Error) ?? !1 : !0;
+  }
+}
+exports.RuleOr = RuleOr;
+class RuleAnd extends LogicRule {
+  constructor(e) {
+    super(e);
+  }
+  async resolve(e, n, s, o, u, r) {
+    const t = await this.evaluate(e, n, s, o, u, r);
+    return t.some(i => i !== !0) ? t.find(l => l instanceof Error) ?? !1 : !0;
+  }
+}
+exports.RuleAnd = RuleAnd;
+class RuleChain extends LogicRule {
+  constructor(e) {
+    super(e);
+  }
+  async resolve(e, n, s, o, u, r) {
+    const t = await this.evaluate(e, n, s, o, u, r);
+    return t.some(i => i !== !0) ? t.find(l => l instanceof Error) ?? !1 : !0;
+  }
+  async evaluate(e, n, s, o, u, r) {
+    const t = this.getRules();
+    return i(t);
+    async function i([l, ...x]) {
+      return l === void 0 ? [] : l.resolve(e, n, s, o, u, r).then(async c => c !== !0 ? [c] : i(x).then(R => R.concat(c)));
+    }
+  }
+}
+exports.RuleChain = RuleChain;
+class RuleRace extends LogicRule {
+  constructor(e) {
+    super(e);
+  }
+  async resolve(e, n, s, o, u, r) {
+    const t = await this.evaluate(e, n, s, o, u, r);
+    return t.includes(!0) ? !0 : t.find(l => l instanceof Error) ?? !1;
+  }
+  async evaluate(e, n, s, o, u, r) {
+    const t = this.getRules();
+    return i(t);
+    async function i([l, ...x]) {
+      return l === void 0 ? [] : l.resolve(e, n, s, o, u, r).then(async c => c === !0 ? [c] : i(x).then(R => R.concat(c)));
+    }
+  }
+}
+exports.RuleRace = RuleRace;
+class RuleNot extends LogicRule {
+  error;
+  name = "RuleNot";
+  equals;
+  constructor(e, n) {
+    super([e]), this.error = n;
+  }
+  async resolve(e, n, s, o, u, r) {
+    const [t] = await this.evaluate(e, n, s, o, u, r);
+    return t instanceof Error || t !== !0 ? !0 : this.error ? this.error : !1;
+  }
+}
+exports.RuleNot = RuleNot;
+class RuleTrue extends LogicRule {
+  name = "RuleTrue";
+  equals;
+  constructor() {
+    super([]);
+  }
+  async resolve() {
+    return !0;
+  }
+}
+exports.RuleTrue = RuleTrue;
+class RuleFalse extends LogicRule {
+  name = "RuleTrue";
+  equals;
+  constructor() {
+    super([]);
+  }
+  async resolve() {
+    return !1;
+  }
+}
+exports.RuleFalse = RuleFalse;

package/dist/shield/rules.d.ts

@@ -0,0 +1,121 @@
+import type { ILogicRule, IOptions, IRule, IRuleFunction, IRuleResult, ShieldRule } from "./types";
+export declare class Rule<TContext extends Record<string, any>> implements IRule<TContext> {
+    readonly name: string;
+    func?: IRuleFunction<TContext>;
+    constructor(name: string, func?: IRuleFunction<TContext>);
+    resolve(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+    /**
+     *
+     * Compares a given rule with the current one
+     * and checks whether their functions are equal.
+     *
+     */
+    equals(rule: Rule<TContext>): boolean;
+    executeRule<TContext extends Record<string, any>>(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): string | boolean | Error | Promise<IRuleResult>;
+}
+export declare class LogicRule<TContext extends Record<string, any>> extends Rule<TContext> implements ILogicRule<TContext> {
+    private rules;
+    constructor(rules: ShieldRule<TContext>[]);
+    /**
+     * By default logic rule resolves to false.
+     */
+    resolve(_ctx: TContext, _type: string, _path: string, _input: {
+        [name: string]: any;
+    }, _rawInput: unknown, _options: IOptions<TContext>): Promise<IRuleResult>;
+    /**
+     * Evaluates all the rules.
+     */
+    evaluate(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult[]>;
+    /**
+     * Returns rules in a logic rule.
+     */
+    getRules(): ShieldRule<TContext>[];
+}
+export declare class RuleOr<TContext extends Record<string, any>> extends LogicRule<TContext> {
+    constructor(rules: ShieldRule<TContext>[]);
+    /**
+     * Makes sure that at least one of them has evaluated to true.
+     */
+    resolve(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+}
+export declare class RuleAnd<TContext extends Record<string, any>> extends LogicRule<TContext> {
+    constructor(rules: ShieldRule<TContext>[]);
+    /**
+     * Makes sure that all of them have resolved to true.
+     */
+    resolve(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+}
+export declare class RuleChain<TContext extends Record<string, any>> extends LogicRule<TContext> {
+    constructor(rules: ShieldRule<TContext>[]);
+    /**
+     * Makes sure that all of them have resolved to true.
+     */
+    resolve(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+    /**
+     * Evaluates all the rules.
+     */
+    evaluate(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult[]>;
+}
+export declare class RuleRace<TContext extends Record<string, any>> extends LogicRule<TContext> {
+    constructor(rules: ShieldRule<TContext>[]);
+    /**
+     * Makes sure that at least one of them resolved to true.
+     */
+    resolve(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+    /**
+     * Evaluates all the rules.
+     */
+    evaluate(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult[]>;
+}
+export declare class RuleNot<TContext extends Record<string, any>> extends LogicRule<TContext> implements ILogicRule<TContext> {
+    error?: Error;
+    name: string;
+    equals: (rule: IRule<TContext>) => boolean;
+    constructor(rule: ShieldRule<TContext>, error?: Error);
+    /**
+     * Negates the result.
+     */
+    resolve(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+}
+export declare class RuleTrue<TContext extends Record<string, any>> extends LogicRule<TContext> implements ILogicRule<TContext> {
+    name: string;
+    equals: (rule: IRule<TContext>) => boolean;
+    constructor();
+    /**
+     *
+     * Always true.
+     *
+     */
+    resolve(): Promise<IRuleResult>;
+}
+export declare class RuleFalse<TContext extends Record<string, any>> extends LogicRule<TContext> implements ILogicRule<TContext> {
+    name: string;
+    equals: (rule: IRule<TContext>) => boolean;
+    constructor();
+    /**
+     *
+     * Always false.
+     *
+     */
+    resolve(): Promise<IRuleResult>;
+}

package/dist/shield/rules.mjs

@@ -0,0 +1 @@
+export class Rule{name;func;constructor(e,n){this.name=e,this.func=n}async resolve(e,n,s,o,u,r){try{const t=await this.executeRule(e,n,s,o,u,r);return t instanceof Error?t:typeof t=="string"?new Error(t):t===!0}catch(t){if(r.debug)throw t;return!1}}equals(e){return this.func===e.func}executeRule(e,n,s,o,u,r){return this.func(e,n,s,o,u,r)}}export class LogicRule extends Rule{rules;constructor(e){super("LogicRule"),this.rules=e}async resolve(e,n,s,o,u,r){return!1}async evaluate(e,n,s,o,u,r){const i=this.getRules().map(async l=>l.resolve(e,n,s,o,u,r));return Promise.all(i)}getRules(){return this.rules}}export class RuleOr extends LogicRule{constructor(e){super(e)}async resolve(e,n,s,o,u,r){const t=await this.evaluate(e,n,s,o,u,r);return t.every(i=>i!==!0)?t.find(l=>l instanceof Error)??!1:!0}}export class RuleAnd extends LogicRule{constructor(e){super(e)}async resolve(e,n,s,o,u,r){const t=await this.evaluate(e,n,s,o,u,r);return t.some(i=>i!==!0)?t.find(l=>l instanceof Error)??!1:!0}}export class RuleChain extends LogicRule{constructor(e){super(e)}async resolve(e,n,s,o,u,r){const t=await this.evaluate(e,n,s,o,u,r);return t.some(i=>i!==!0)?t.find(l=>l instanceof Error)??!1:!0}async evaluate(e,n,s,o,u,r){const t=this.getRules();return i(t);async function i([l,...x]){return l===void 0?[]:l.resolve(e,n,s,o,u,r).then(async c=>c!==!0?[c]:i(x).then(R=>R.concat(c)))}}}export class RuleRace extends LogicRule{constructor(e){super(e)}async resolve(e,n,s,o,u,r){const t=await this.evaluate(e,n,s,o,u,r);return t.includes(!0)?!0:t.find(l=>l instanceof Error)??!1}async evaluate(e,n,s,o,u,r){const t=this.getRules();return i(t);async function i([l,...x]){return l===void 0?[]:l.resolve(e,n,s,o,u,r).then(async c=>c===!0?[c]:i(x).then(R=>R.concat(c)))}}}export class RuleNot extends LogicRule{error;name="RuleNot";equals;constructor(e,n){super([e]),this.error=n}async resolve(e,n,s,o,u,r){const[t]=await this.evaluate(e,n,s,o,u,r);return t instanceof Error||t!==!0?!0:this.error?this.error:!1}}export class RuleTrue extends LogicRule{name="RuleTrue";equals;constructor(){super([])}async resolve(){return!0}}export class RuleFalse extends LogicRule{name="RuleTrue";equals;constructor(){super([])}async resolve(){return!1}}

package/dist/shield/shield.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shield = shield;
+var _constructors = require("./constructors.cjs");
+var _generator = require("./generator.cjs");
+var _utils = require("./utils.cjs");
+var _validation = require("./validation.cjs");
+function u(e) {
+  return typeof e.fallbackError == "string" && (e.fallbackError = new Error(e.fallbackError)), {
+    debug: e.debug ?? !1,
+    allowExternalErrors: (0, _utils.withDefault)(!1)(e.allowExternalErrors),
+    fallbackRule: (0, _utils.withDefault)(_constructors.allow)(e.fallbackRule),
+    fallbackError: (0, _utils.withDefault)(new Error("Not Authorised!"))(e.fallbackError)
+  };
+}
+function shield(e, o = {}) {
+  const n = u(o),
+    r = (0, _validation.validateRuleTree)(e);
+  if (r.status === "ok") return (0, _generator.generateMiddlewareFromRuleTree)(e, n);
+  throw new _validation.ValidationError(r.message);
+}

package/dist/shield/shield.d.ts

@@ -0,0 +1,6 @@
+import type { MiddlewareFunction } from "@trpc/server/unstable-core-do-not-import";
+import type { IOptionsConstructor, IRules } from "./types";
+/**
+ * Validates rules and generates middleware from defined rule tree.
+ */
+export declare function shield<TContext extends Record<string, any>, TMeta extends object = object, TContextOverridesIn = TContext, $ContextOverridesOut = TContext, TInputOut = unknown>(ruleTree: IRules<TContext>, options?: IOptionsConstructor<TContext>): MiddlewareFunction<TContext, TMeta, TContextOverridesIn, $ContextOverridesOut, TInputOut>;

package/dist/shield/shield.mjs

@@ -0,0 +1 @@
+import{allow as l}from"./constructors";import{generateMiddlewareFromRuleTree as a}from"./generator";import{withDefault as t}from"./utils";import{ValidationError as i,validateRuleTree as s}from"./validation";function u(e){return typeof e.fallbackError=="string"&&(e.fallbackError=new Error(e.fallbackError)),{debug:e.debug??!1,allowExternalErrors:t(!1)(e.allowExternalErrors),fallbackRule:t(l)(e.fallbackRule),fallbackError:t(new Error("Not Authorised!"))(e.fallbackError)}}export function shield(e,o={}){const n=u(o),r=s(e);if(r.status==="ok")return a(e,n);throw new i(r.message)}

package/dist/shield/types.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/shield/types.d.ts

@@ -0,0 +1,52 @@
+export type ShieldRule<TContext extends Record<string, any> = Record<string, any>> = IRule<TContext> | ILogicRule<TContext>;
+export interface IRule<TContext extends Record<string, any> = Record<string, any>> {
+    name: string;
+    equals: (rule: IRule<TContext>) => boolean;
+    resolve: (ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>) => Promise<IRuleResult>;
+    executeRule: <TContext extends Record<string, any>>(ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>) => string | boolean | Error | Promise<IRuleResult>;
+}
+export interface IRuleOptions {
+}
+export interface ILogicRule<TContext extends Record<string, any> = Record<string, any>> extends IRule<TContext> {
+    getRules: () => ShieldRule<TContext>[];
+    evaluate: (ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>) => Promise<IRuleResult[]>;
+    resolve: (ctx: TContext, type: string, path: string, input: {
+        [name: string]: any;
+    }, rawInput: unknown, options: IOptions<TContext>) => Promise<IRuleResult>;
+}
+export type IRuleResult = boolean | string | Error;
+export type IRuleFunction<TContext extends Record<string, any> = Record<string, any>> = (ctx: TContext, type: string, path: string, input: {
+    [name: string]: any;
+}, rawInput: unknown, options: IOptions<TContext>) => IRuleResult | Promise<IRuleResult>;
+export interface IRuleConstructorOptions {
+}
+export interface IRuleTypeMap<TContext extends Record<string, any> = Record<string, any>> {
+    [key: string]: ShieldRule<TContext> | IRuleFieldMap<TContext> | IRuleTypeMap<TContext>;
+}
+export interface IRuleFieldMap<TContext extends Record<string, any> = Record<string, any>> {
+    [key: string]: ShieldRule<TContext>;
+}
+export type IRules<TContext extends Record<string, any> = Record<string, any>> = ShieldRule<TContext> | IRuleTypeMap<TContext>;
+export type IFallbackErrorMapperType<TContext extends Record<string, any> = Record<string, any>> = (err: unknown, ctx: TContext, type: string, path: string, input: {
+    [name: string]: any;
+}, rawInput: unknown) => Promise<Error> | Error;
+export type IFallbackErrorType<TContext extends Record<string, any> = Record<string, any>> = Error | IFallbackErrorMapperType<TContext>;
+export interface IOptions<TContext extends Record<string, any> = Record<string, any>> {
+    debug: boolean;
+    allowExternalErrors: boolean;
+    fallbackRule: ShieldRule<TContext>;
+    fallbackError?: IFallbackErrorType<TContext>;
+}
+export interface IOptionsConstructor<TContext extends Record<string, any> = Record<string, any>> {
+    debug?: boolean;
+    allowExternalErrors?: boolean;
+    fallbackRule?: ShieldRule<TContext>;
+    fallbackError?: string | IFallbackErrorType<TContext>;
+}
+export declare function shield<TContext extends Record<string, any> = Record<string, any>>(ruleTree: IRules<TContext>, options: IOptions<TContext>): any;

package/dist/shield/utils.cjs

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flattenObjectOf = flattenObjectOf;
+exports.isLogicRule = isLogicRule;
+exports.isRule = isRule;
+exports.isRuleFieldMap = isRuleFieldMap;
+exports.isRuleFunction = isRuleFunction;
+exports.withDefault = withDefault;
+var _rules = require("./rules.cjs");
+function isRule(e) {
+  return e instanceof _rules.Rule || e && e.constructor && e.constructor.name === "Rule";
+}
+function isLogicRule(e) {
+  return e instanceof _rules.LogicRule || e && e.constructor && (e.constructor.name === "RuleOr" || e.constructor.name === "RuleAnd" || e.constructor.name === "RuleChain" || e.constructor.name === "RuleRace" || e.constructor.name === "RuleNot" || e.constructor.name === "RuleTrue" || e.constructor.name === "RuleFalse");
+}
+function isRuleFunction(e) {
+  return isRule(e) || isLogicRule(e);
+}
+function isRuleFieldMap(e) {
+  return typeof e == "object" && Object.values(e).every(t => isRuleFunction(t));
+}
+function flattenObjectOf(e, t) {
+  return Object.keys(e).reduce((r, o) => {
+    const n = e[o];
+    return t(n) ? [...r, n] : typeof n == "object" && !t(n) ? [...r, ...flattenObjectOf(n, t)] : r;
+  }, []);
+}
+function withDefault(e) {
+  return t => t === void 0 ? e : t;
+}

package/dist/shield/utils.d.ts

@@ -0,0 +1,28 @@
+import type { ILogicRule, IRule, IRuleFieldMap, ShieldRule } from "./types";
+/**
+ * Makes sure that a certain field is a rule.
+ */
+export declare function isRule<TContext extends Record<string, any>>(x: any): x is IRule<TContext>;
+/**
+ * Makes sure that a certain field is a logic rule.
+ */
+export declare function isLogicRule<TContext extends Record<string, any>>(x: any): x is ILogicRule<TContext>;
+/**
+ * Makes sure that a certain field is a rule or a logic rule.
+ */
+export declare function isRuleFunction<TContext extends Record<string, any>>(x: any): x is ShieldRule<TContext>;
+/**
+ * Determines whether a certain field is rule field map or not.
+ */
+export declare function isRuleFieldMap<TContext extends Record<string, any>>(x: any): x is IRuleFieldMap<TContext>;
+/**
+ * Flattens object of particular type by checking if the leaf
+ * evaluates to true from particular function.
+ */
+export declare function flattenObjectOf<T>(obj: {
+    [key: string]: any;
+}, f: (x: any) => boolean): T[];
+/**
+ * Returns fallback is provided value is undefined
+ */
+export declare function withDefault<T>(fallback: T): (value: T | undefined) => T;

package/dist/shield/utils.mjs

@@ -0,0 +1 @@
+import{LogicRule as u,Rule as c}from"./rules";export function isRule(e){return e instanceof c||e&&e.constructor&&e.constructor.name==="Rule"}export function isLogicRule(e){return e instanceof u||e&&e.constructor&&(e.constructor.name==="RuleOr"||e.constructor.name==="RuleAnd"||e.constructor.name==="RuleChain"||e.constructor.name==="RuleRace"||e.constructor.name==="RuleNot"||e.constructor.name==="RuleTrue"||e.constructor.name==="RuleFalse")}export function isRuleFunction(e){return isRule(e)||isLogicRule(e)}export function isRuleFieldMap(e){return typeof e=="object"&&Object.values(e).every(t=>isRuleFunction(t))}export function flattenObjectOf(e,t){return Object.keys(e).reduce((r,o)=>{const n=e[o];return t(n)?[...r,n]:typeof n=="object"&&!t(n)?[...r,...flattenObjectOf(n,t)]:r},[])}export function withDefault(e){return t=>t===void 0?e:t}

package/dist/shield/validation.cjs

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidationError = void 0;
+exports.validateRuleTree = validateRuleTree;
+var _utils = require("./utils.cjs");
+function validateRuleTree(r) {
+  const u = c(r).reduce(({
+    map: t,
+    duplicates: n
+  }, e) => t.has(e.name) ? !t.get(e.name).equals(e) && !n.includes(e.name) ? {
+    map: t.set(e.name, e),
+    duplicates: [...n, e.name]
+  } : {
+    map: t,
+    duplicates: n
+  } : {
+    map: t.set(e.name, e),
+    duplicates: n
+  }, {
+    map: new Map(),
+    duplicates: []
+  });
+  if (u.duplicates.length === 0) return {
+    status: "ok"
+  };
+  return {
+    status: "err",
+    message: `There seem to be multiple definitions of these rules: ${u.duplicates.join(", ")}`
+  };
+  function c(t) {
+    return (0, _utils.flattenObjectOf)(t, _utils.isRuleFunction).reduce((l, s) => (0, _utils.isLogicRule)(s) ? [...l, ...i(s)] : [...l, s], []);
+  }
+  function i(t) {
+    return t.getRules().reduce((n, e) => (0, _utils.isLogicRule)(e) ? [...n, ...i(e)] : [...n, e], []);
+  }
+}
+class ValidationError extends Error {
+  constructor(o) {
+    super(o);
+  }
+}
+exports.ValidationError = ValidationError;

package/dist/shield/validation.d.ts

@@ -0,0 +1,15 @@
+import type { IRules } from "./types";
+/**
+ * Validates the rule tree declaration by checking references of rule
+ * functions. We deem rule tree valid if no two rules with the same name point
+ * to different rules.
+ */
+export declare function validateRuleTree<TContext extends Record<string, any>>(ruleTree: IRules<TContext>): {
+    status: "ok";
+} | {
+    status: "err";
+    message: string;
+};
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}

package/dist/shield/validation.mjs

@@ -0,0 +1 @@
+import{flattenObjectOf as x,isLogicRule as a,isRuleFunction as R}from"./utils";export function validateRuleTree(r){const u=c(r).reduce(({map:t,duplicates:n},e)=>t.has(e.name)?!t.get(e.name).equals(e)&&!n.includes(e.name)?{map:t.set(e.name,e),duplicates:[...n,e.name]}:{map:t,duplicates:n}:{map:t.set(e.name,e),duplicates:n},{map:new Map,duplicates:[]});if(u.duplicates.length===0)return{status:"ok"};return{status:"err",message:`There seem to be multiple definitions of these rules: ${u.duplicates.join(", ")}`};function c(t){return x(t,R).reduce((l,s)=>a(s)?[...l,...i(s)]:[...l,s],[])}function i(t){return t.getRules().reduce((n,e)=>a(e)?[...n,...i(e)]:[...n,e],[])}}export class ValidationError extends Error{constructor(o){super(o)}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stryke/trpc-next",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "type": "module",
   "description": "A package to help in using tRPC in modern NextJs applications.",
   "repository": {
@@ -183,6 +183,118 @@
         "default": "./dist/tanstack-query/client.mjs"
       }
     },
+    "./shield/validation": {
+      "import": {
+        "types": "./dist/shield/validation.d.ts",
+        "default": "./dist/shield/validation.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/validation.d.ts",
+        "default": "./dist/shield/validation.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/validation.d.ts",
+        "default": "./dist/shield/validation.mjs"
+      }
+    },
+    "./shield/utils": {
+      "import": {
+        "types": "./dist/shield/utils.d.ts",
+        "default": "./dist/shield/utils.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/utils.d.ts",
+        "default": "./dist/shield/utils.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/utils.d.ts",
+        "default": "./dist/shield/utils.mjs"
+      }
+    },
+    "./shield/types": {
+      "import": {
+        "types": "./dist/shield/types.d.ts",
+        "default": "./dist/shield/types.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/types.d.ts",
+        "default": "./dist/shield/types.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/types.d.ts",
+        "default": "./dist/shield/types.mjs"
+      }
+    },
+    "./shield/shield": {
+      "import": {
+        "types": "./dist/shield/shield.d.ts",
+        "default": "./dist/shield/shield.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/shield.d.ts",
+        "default": "./dist/shield/shield.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/shield.d.ts",
+        "default": "./dist/shield/shield.mjs"
+      }
+    },
+    "./shield/rules": {
+      "import": {
+        "types": "./dist/shield/rules.d.ts",
+        "default": "./dist/shield/rules.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/rules.d.ts",
+        "default": "./dist/shield/rules.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/rules.d.ts",
+        "default": "./dist/shield/rules.mjs"
+      }
+    },
+    "./shield/index": {
+      "import": {
+        "types": "./dist/shield/index.d.ts",
+        "default": "./dist/shield/index.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/index.d.ts",
+        "default": "./dist/shield/index.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/index.d.ts",
+        "default": "./dist/shield/index.mjs"
+      }
+    },
+    "./shield/generator": {
+      "import": {
+        "types": "./dist/shield/generator.d.ts",
+        "default": "./dist/shield/generator.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/generator.d.ts",
+        "default": "./dist/shield/generator.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/generator.d.ts",
+        "default": "./dist/shield/generator.mjs"
+      }
+    },
+    "./shield/constructors": {
+      "import": {
+        "types": "./dist/shield/constructors.d.ts",
+        "default": "./dist/shield/constructors.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/constructors.d.ts",
+        "default": "./dist/shield/constructors.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/constructors.d.ts",
+        "default": "./dist/shield/constructors.mjs"
+      }
+    },
     ".": {
       "import": { "types": "./dist/index.d.ts", "default": "./dist/index.mjs" },
       "require": {
@@ -191,6 +303,20 @@
       },
       "default": { "types": "./dist/index.d.ts", "default": "./dist/index.mjs" }
     },
+    "./shield": {
+      "import": {
+        "types": "./dist/shield/index.d.ts",
+        "default": "./dist/shield/index.mjs"
+      },
+      "require": {
+        "types": "./dist/shield/index.d.ts",
+        "default": "./dist/shield/index.cjs"
+      },
+      "default": {
+        "types": "./dist/shield/index.d.ts",
+        "default": "./dist/shield/index.mjs"
+      }
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.cjs",