@stryke/trpc-next 0.4.0 → 0.5.0

package/dist/server.cjs

@@ -4,11 +4,24 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createTRPCServer = createTRPCServer;
+Object.defineProperty(exports, "notFound", {
+  enumerable: true,
+  get: function () {
+    return _nextAppDir.experimental_notFound;
+  }
+});
+Object.defineProperty(exports, "redirect", {
+  enumerable: true,
+  get: function () {
+    return _nextAppDir.experimental_redirect;
+  }
+});
 var _client = require("@trpc/client");
 var _nextCache = require("@trpc/next/app-dir/links/nextCache");
 var _server = require("@trpc/next/app-dir/server");
 var _headers = require("next/headers");
 var _shared = require("./shared.cjs");
+var _nextAppDir = require("@trpc/server/adapters/next-app-dir");
 function createTRPCServer(r, t = () => ({})) {
   return (0, _server.experimental_createTRPCNextAppDirServer)({
     config() {

package/dist/server.d.ts

@@ -31,3 +31,4 @@ export type NextAppDirDecorateRouterRecord<TRoot extends AnyRootTypes, TRecord e
  * @param createContext - An optional function to generate a context
  */
 export declare function createTRPCServer<TRouter extends AnyTRPCRouter, TContext extends inferRouterContext<TRouter>>(router: TRouter, createContext?: () => MaybePromise<TContext>): NextAppDirDecorateRouterRecord<TRouter["_def"]["_config"]["$types"], TRouter["_def"]["record"]>;
+export { experimental_notFound as notFound, experimental_redirect as redirect } from "@trpc/server/adapters/next-app-dir";

package/dist/server.mjs

@@ -1 +1 @@
-import{loggerLink as o}from"@trpc/client";import{experimental_nextCacheLink as n}from"@trpc/next/app-dir/links/nextCache";import{experimental_createTRPCNextAppDirServer as p}from"@trpc/next/app-dir/server";import{cookies as u}from"next/headers";import{transformer as i}from"./shared";export function createTRPCServer(r,t=()=>({})){return p({config(){return{links:[o({enabled:e=>!0}),n({revalidate:5,router:r,transformer:i,createContext:async()=>{const e=await Promise.resolve(t());return e.headers??={},e.headers["x-trpc-source"]="rsc-invoke",e.headers.cookie=(await u()).toString(),e}})]}}})}
+import{loggerLink as o}from"@trpc/client";import{experimental_nextCacheLink as n}from"@trpc/next/app-dir/links/nextCache";import{experimental_createTRPCNextAppDirServer as p}from"@trpc/next/app-dir/server";import{cookies as u}from"next/headers";import{transformer as i}from"./shared";export function createTRPCServer(r,t=()=>({})){return p({config(){return{links:[o({enabled:e=>!0}),n({revalidate:5,router:r,transformer:i,createContext:async()=>{const e=await Promise.resolve(t());return e.headers??={},e.headers["x-trpc-source"]="rsc-invoke",e.headers.cookie=(await u()).toString(),e}})]}}})}export{experimental_notFound as notFound,experimental_redirect as redirect}from"@trpc/server/adapters/next-app-dir";

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/dist/tanstack-query/client.cjs

@@ -7,26 +7,24 @@ Object.defineProperty(exports, "__esModule", {
 exports.createTRPCTanstackQueryClient = createTRPCTanstackQueryClient;
 var _environmentChecks = require("@stryke/env/environment-checks");
 var _reactQuery = require("@tanstack/react-query");
-var _reactQueryDevtools = require("@tanstack/react-query-devtools");
 var _client = require("@trpc/client");
 var _tanstackReactQuery = require("@trpc/tanstack-react-query");
 var _react = require("react");
 var _shared = require("../shared.cjs");
-function createTRPCTanstackQueryClient(t, o) {
+function createTRPCTanstackQueryClient(t, r) {
   const {
-      TRPCProvider: n,
-      useTRPC: i
-    } = (0, _tanstackReactQuery.createTRPCContext)(),
-    e = (0, _shared.createQueryClient)(o);
+    TRPCProvider: o,
+    useTRPC: n
+  } = (0, _tanstackReactQuery.createTRPCContext)();
   return {
-    useTRPCTanstackQuery: i,
-    TRPCTanstackQueryProvider: c => {
+    useTRPCTanstackQuery: n,
+    TRPCTanstackQueryProvider: i => {
       const {
-          children: u
-        } = c,
-        [a] = (0, _react.useState)(() => (0, _client.createTRPCClient)({
+          children: c
+        } = i,
+        [u] = (0, _react.useState)(() => (0, _client.createTRPCClient)({
           links: [(0, _client.loggerLink)({
-            enabled: r => _environmentChecks.isDevelopment || r.direction === "down" && r.result instanceof Error
+            enabled: e => _environmentChecks.isDevelopment || e.direction === "down" && e.result instanceof Error
           }), (0, _client.httpBatchStreamLink)({
             transformer: _shared.transformer,
             url: (0, _shared.getTRPCServerUrl)(t),
@@ -35,12 +33,12 @@ function createTRPCTanstackQueryClient(t, o) {
             }
           })]
         }));
-      return React.createElement(n, {
-        trpcClient: a,
-        queryClient: e
+      return React.createElement(o, {
+        trpcClient: u,
+        queryClient: r
       }, React.createElement(_reactQuery.QueryClientProvider, {
-        client: e
-      }, u, React.createElement(_reactQueryDevtools.ReactQueryDevtools, null)));
+        client: r
+      }, c));
     }
   };
 }

package/dist/tanstack-query/client.d.ts

@@ -1,12 +1,12 @@
 import type { StormURL } from "@stryke/http/types";
-import type { QueryClientConfig } from "@tanstack/react-query";
+import type { QueryClient } from "@tanstack/react-query";
 import type { AnyTRPCRouter } from "@trpc/server";
 /**
  * Create a TRPC Tanstack Query client.
  *
  * @returns The TRPC Tanstack Query client
  */
-export declare function createTRPCTanstackQueryClient<TRouter extends AnyTRPCRouter>(baseUrl: string | StormURL, config?: Partial<QueryClientConfig>): {
+export declare function createTRPCTanstackQueryClient<TRouter extends AnyTRPCRouter>(baseUrl: string | StormURL, queryClient: QueryClient): {
     useTRPCTanstackQuery: () => import("@trpc/tanstack-react-query").TRPCOptionsProxy<TRouter>;
     TRPCTanstackQueryProvider: (props: {
         children: React.ReactNode;

package/dist/tanstack-query/client.mjs

@@ -1 +1 @@
-"use client";import{isDevelopment as s}from"@stryke/env/environment-checks";import{QueryClientProvider as m}from"@tanstack/react-query";import{ReactQueryDevtools as C}from"@tanstack/react-query-devtools";import{createTRPCClient as l,httpBatchStreamLink as R,loggerLink as p}from"@trpc/client";import{createTRPCContext as y}from"@trpc/tanstack-react-query";import{useState as T}from"react";import{createQueryClient as f,getTRPCServerUrl as P,transformer as d}from"../shared";export function createTRPCTanstackQueryClient(t,o){const{TRPCProvider:n,useTRPC:i}=y(),e=f(o);return{useTRPCTanstackQuery:i,TRPCTanstackQueryProvider:c=>{const{children:u}=c,[a]=T(()=>l({links:[p({enabled:r=>s||r.direction==="down"&&r.result instanceof Error}),R({transformer:d,url:P(t),headers:{"x-trpc-source":"react-query"}})]}));return React.createElement(n,{trpcClient:a,queryClient:e},React.createElement(m,{client:e},u,React.createElement(C,null)))}}}
+"use client";import{isDevelopment as s}from"@stryke/env/environment-checks";import{QueryClientProvider as a}from"@tanstack/react-query";import{createTRPCClient as m,httpBatchStreamLink as R,loggerLink as p}from"@trpc/client";import{createTRPCContext as C}from"@trpc/tanstack-react-query";import{useState as l}from"react";import{getTRPCServerUrl as T,transformer as y}from"../shared";export function createTRPCTanstackQueryClient(t,r){const{TRPCProvider:o,useTRPC:n}=C();return{useTRPCTanstackQuery:n,TRPCTanstackQueryProvider:i=>{const{children:c}=i,[u]=l(()=>m({links:[p({enabled:e=>s||e.direction==="down"&&e.result instanceof Error}),R({transformer:y,url:T(t),headers:{"x-trpc-source":"react-query"}})]}));return React.createElement(o,{trpcClient:u,queryClient:r},React.createElement(a,{client:r},c))}}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stryke/trpc-next",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "A package to help in using tRPC in modern NextJs applications.",
   "repository": {
@@ -22,7 +22,6 @@
   "dependencies": {
     "@js-temporal/polyfill": "^0.5.0",
     "@tanstack/react-query": "^5.70.0",
-    "@tanstack/react-query-devtools": "^5.70.0",
     "@trpc/client": "^11.0.1",
     "@trpc/next": "^11.0.1",
     "@trpc/server": "^11.0.1",
@@ -184,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": {
@@ -192,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",