@stryke/trpc-next 0.5.8 → 0.5.10

package/dist/action-handler.d.ts

@@ -10,8 +10,8 @@ import type { BaseContext } from "./types";
  */
 export declare function createTRPCServerActionHandler<TInstance extends {
     _config: RootConfig<AnyRootTypes>;
-}, TContext extends BaseContext = BaseContext>(cookies: () => Promise<ReadonlyRequestCookies>, t: TInstance, createContext?: () => MaybePromise<TContext>): <TProc extends import("@trpc/server/unstable-core-do-not-import").AnyProcedure>(proc: TProc) => import("@trpc/next/app-dir/server").TRPCActionHandler<{
-    input: import("@trpc/server/unstable-core-do-not-import").inferProcedureInput<TProc>;
-    output: import("@trpc/server/unstable-core-do-not-import").inferProcedureOutput<TProc>;
-    errorShape: import("@trpc/server/unstable-core-do-not-import").inferClientTypes<TInstance>["errorShape"];
+}, TContext extends BaseContext = BaseContext>(cookies: () => Promise<ReadonlyRequestCookies>, t: TInstance, createContext?: () => MaybePromise<TContext>): <TProc extends import("@trpc/server/dist/unstable-core-do-not-import.d-BJCeJk5P.d.cts").AnyProcedure>(proc: TProc) => import("@trpc/next/dist/server.d-DLnegS7F.d.cts").TRPCActionHandler<{
+    input: import("@trpc/server/dist/unstable-core-do-not-import.d-BJCeJk5P.d.cts").inferProcedureInput<TProc>;
+    output: import("@trpc/server/dist/unstable-core-do-not-import.d-BJCeJk5P.d.cts").inferProcedureOutput<TProc>;
+    errorShape: import("@trpc/server/dist/unstable-core-do-not-import.d-BJCeJk5P.d.cts").inferClientTypes<TInstance>["errorShape"];
 }>;

package/dist/server.d.ts

@@ -2,7 +2,7 @@ import type { MaybePromise } from "@stryke/types";
 import type { Resolver } from "@trpc/client";
 import type { AnyTRPCRouter, inferRouterContext } from "@trpc/server";
 import type { AnyProcedure, AnyRootTypes, inferProcedureInput, inferTransformedProcedureOutput, ProcedureType, RouterRecord } from "@trpc/server/unstable-core-do-not-import";
-import type { ResolverDef } from "@trpc/tanstack-react-query";
+import type { FeatureFlags, ResolverDef } from "@trpc/tanstack-react-query";
 import type { ReadonlyRequestCookies } from "next/dist/server/web/spec-extension/adapters/request-cookies";
 export type DecorateProcedureServer<TType extends ProcedureType, TDef extends ResolverDef> = TType extends "query" ? {
     query: Resolver<TDef>;
@@ -23,6 +23,7 @@ export type NextAppDirDecorateRouterRecord<TRoot extends AnyRootTypes, TRecord e
         output: inferTransformedProcedureOutput<TRoot, $Value>;
         errorShape: TRoot["errorShape"];
         transformer: TRoot["transformer"];
+        featureFlags: FeatureFlags;
     }> : $Value extends RouterRecord ? NextAppDirDecorateRouterRecord<TRoot, $Value> : never : never;
 };
 /**

package/dist/server.mjs

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

package/dist/shared.cjs

@@ -12,8 +12,8 @@ var _reactQuery = require("@tanstack/react-query");
 var _defu = _interopRequireDefault(require("defu"));
 var _superjson = _interopRequireDefault(require("superjson"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function getTRPCServerUrl(e, t = 1) {
-  return (0, _joinPaths.joinPaths)(typeof e == "string" ? e : e.host || "", "api", t ? `v${t}` : "", "trpc");
+function getTRPCServerUrl(e, r = 1) {
+  return (0, _joinPaths.joinPaths)(typeof e == "string" ? e : e.host || "", "api", r ? `v${r}` : "", "trpc");
 }
 _superjson.default.registerCustom({
   isApplicable: e => e instanceof _polyfill.Temporal.PlainDate,
@@ -31,7 +31,7 @@ const transformer = exports.transformer = _superjson.default,
         staleTime: 1e3 * 30
       },
       dehydrate: {
-        shouldDehydrateQuery: t => (0, _reactQuery.defaultShouldDehydrateQuery)(t) || t.state.status === "pending",
+        shouldDehydrateQuery: r => (0, _reactQuery.defaultShouldDehydrateQuery)(r) || r.state.status === "pending",
         serializeData: transformer.serialize
       },
       hydrate: {

package/dist/shared.d.ts

@@ -1,8 +1,8 @@
-import type { StormURL } from "@stryke/http/types";
+import type { StormURLInterface } from "@stryke/url/types";
 import type { QueryClientConfig } from "@tanstack/react-query";
 import { QueryClient } from "@tanstack/react-query";
 import type { DataTransformer } from "@trpc/server/unstable-core-do-not-import";
-export declare function getTRPCServerUrl(baseUrl: string | StormURL, version?: number | null): any;
+export declare function getTRPCServerUrl(baseUrl: string | StormURLInterface, version?: number | null): any;
 export declare const transformer: DataTransformer;
 /**
  * Create a TRPC Tanstack Query client.

package/dist/shared.mjs

@@ -1 +1 @@
-import{Temporal as r}from"@js-temporal/polyfill";import{joinPaths as i}from"@stryke/path/join-paths";import{defaultShouldDehydrateQuery as o,QueryClient as n}from"@tanstack/react-query";import s from"defu";import a from"superjson";export function getTRPCServerUrl(e,t=1){return i(typeof e=="string"?e:e.host||"","api",t?`v${t}`:"","trpc")}a.registerCustom({isApplicable:e=>e instanceof r.PlainDate,serialize:e=>e.toJSON(),deserialize:e=>r.PlainDate.from(e)},"Temporal.PlainDate"),a.registerCustom({isApplicable:e=>e instanceof r.PlainDateTime,serialize:e=>e.toJSON(),deserialize:e=>r.PlainDateTime.from(e)},"Temporal.PlainDateTime");export const transformer=a,createQueryClient=(e={})=>new n(s(e,{defaultOptions:{queries:{staleTime:1e3*30},dehydrate:{shouldDehydrateQuery:t=>o(t)||t.state.status==="pending",serializeData:transformer.serialize},hydrate:{deserializeData:transformer.deserialize}}}));
+import{Temporal as t}from"@js-temporal/polyfill";import{joinPaths as i}from"@stryke/path/join-paths";import{defaultShouldDehydrateQuery as o,QueryClient as n}from"@tanstack/react-query";import s from"defu";import a from"superjson";export function getTRPCServerUrl(e,r=1){return i(typeof e=="string"?e:e.host||"","api",r?`v${r}`:"","trpc")}a.registerCustom({isApplicable:e=>e instanceof t.PlainDate,serialize:e=>e.toJSON(),deserialize:e=>t.PlainDate.from(e)},"Temporal.PlainDate"),a.registerCustom({isApplicable:e=>e instanceof t.PlainDateTime,serialize:e=>e.toJSON(),deserialize:e=>t.PlainDateTime.from(e)},"Temporal.PlainDateTime");export const transformer=a,createQueryClient=(e={})=>new n(s(e,{defaultOptions:{queries:{staleTime:1e3*30},dehydrate:{shouldDehydrateQuery:r=>o(r)||r.state.status==="pending",serializeData:transformer.serialize},hydrate:{deserializeData:transformer.deserialize}}}));

package/dist/shield/constructors.d.ts

@@ -1,5 +1,5 @@
 import { Rule, RuleAnd, RuleChain, RuleFalse, RuleNot, RuleOr, RuleRace, RuleTrue } from "./rules";
-import type { IRuleConstructorOptions, IRuleFunction, ShieldRule } from "./types";
+import type { RuleConstructorOptionsInterface, RuleFunctionInterface, ShieldRule } from "./types";
 /**
  * Wraps a function into a Rule class. This way we can identify rules
  * once we start generating middleware from our ruleTree.
@@ -23,7 +23,7 @@ import type { IRuleConstructorOptions, IRuleFunction, ShieldRule } from "./types
  * })
  * ```
  */
-export declare const rule: <TContext extends Record<string, any>>(name?: string, options?: IRuleConstructorOptions) => (func: IRuleFunction<TContext>) => Rule<TContext>;
+export declare const rule: <TContext extends Record<string, any>>(name?: string, options?: RuleConstructorOptionsInterface) => (func: RuleFunctionInterface<TContext>) => Rule<TContext>;
 /**
  * Logical operator and serves as a wrapper for and operation.
  */

package/dist/shield/constructors.mjs

@@ -1 +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;
+import{Rule as r,RuleAnd as u,RuleChain as l,RuleFalse as x,RuleNot as n,RuleOr as R,RuleRace as s,RuleTrue as c}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 c,deny=new x;

package/dist/shield/generator.cjs

@@ -7,10 +7,10 @@ exports.generateMiddlewareFromRuleTree = generateMiddlewareFromRuleTree;
 function generateMiddlewareFromRuleTree(r, o) {
   return async ({
     next: a,
-    ctx: d,
+    ctx: f,
     type: t,
     path: c,
-    input: f,
+    input: d,
     rawInput: g
   }) => {
     const s = c.split("."),
@@ -22,7 +22,7 @@ function generateMiddlewareFromRuleTree(r, o) {
         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 => {
+    return n = n ?? o.fallbackRule, n ? n?.resolve(f, t, c, d, g, o).then(async e => {
       if (e instanceof Error) throw e;
       if (!e) throw o.fallbackError;
       return a();

package/dist/shield/generator.d.ts

@@ -1,8 +1,8 @@
-import type { IOptions, IRules } from "./types";
+import type { IRules, OptionsInterface } 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 }: {
+export declare function generateMiddlewareFromRuleTree<TContext extends Record<string, unknown>>(ruleTree: IRules<TContext>, options: OptionsInterface<TContext>): ({ next, ctx, type, path, input, rawInput }: {
     next: () => Promise<any>;
     ctx: TContext;
     type: string;

package/dist/shield/generator.mjs

@@ -1 +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()}}
+export function generateMiddlewareFromRuleTree(r,o){return async({next:a,ctx:f,type:t,path:c,input:d,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(f,t,c,d,g,o).then(async e=>{if(e instanceof Error)throw e;if(!e)throw o.fallbackError;return a()}):a()}}

package/dist/shield/index.d.ts

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

package/dist/shield/rules.cjs

@@ -36,7 +36,7 @@ class LogicRule extends Rule {
     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));
+    const i = this.getRules().map(async a => a.resolve(e, n, s, o, u, r));
     return Promise.all(i);
   }
   getRules() {
@@ -50,7 +50,7 @@ class RuleOr extends LogicRule {
   }
   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;
+    return t.every(i => i !== !0) ? t.find(a => a instanceof Error) ?? !1 : !0;
   }
 }
 exports.RuleOr = RuleOr;
@@ -60,7 +60,7 @@ class RuleAnd extends LogicRule {
   }
   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;
+    return t.some(i => i !== !0) ? t.find(a => a instanceof Error) ?? !1 : !0;
   }
 }
 exports.RuleAnd = RuleAnd;
@@ -70,13 +70,13 @@ class RuleChain extends LogicRule {
   }
   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;
+    return t.some(i => i !== !0) ? t.find(a => a 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)));
+    async function i([a, ...x]) {
+      return a === void 0 ? [] : a.resolve(e, n, s, o, u, r).then(async c => c !== !0 ? [c] : i(x).then(f => f.concat(c)));
     }
   }
 }
@@ -87,13 +87,13 @@ class RuleRace extends LogicRule {
   }
   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;
+    return t.includes(!0) ? !0 : t.find(a => a 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)));
+    async function i([a, ...x]) {
+      return a === void 0 ? [] : a.resolve(e, n, s, o, u, r).then(async c => c === !0 ? [c] : i(x).then(f => f.concat(c)));
     }
   }
 }

package/dist/shield/rules.d.ts

@@ -1,11 +1,11 @@
-import type { ILogicRule, IOptions, IRule, IRuleFunction, IRuleResult, ShieldRule } from "./types";
-export declare class Rule<TContext extends Record<string, any>> implements IRule<TContext> {
+import type { LogicRuleInterface, OptionsInterface, RuleFunctionInterface, RuleInterface, RuleResultInterface, ShieldRule } from "./types";
+export declare class Rule<TContext extends Record<string, any>> implements RuleInterface<TContext> {
     readonly name: string;
-    func?: IRuleFunction<TContext>;
-    constructor(name: string, func?: IRuleFunction<TContext>);
+    func?: RuleFunctionInterface<TContext>;
+    constructor(name: string, func?: RuleFunctionInterface<TContext>);
     resolve(ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface>;
     /**
      *
      * Compares a given rule with the current one
@@ -15,9 +15,9 @@ export declare class Rule<TContext extends Record<string, any>> implements IRule
     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>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): string | boolean | Error | Promise<RuleResultInterface>;
 }
-export declare class LogicRule<TContext extends Record<string, any>> extends Rule<TContext> implements ILogicRule<TContext> {
+export declare class LogicRule<TContext extends Record<string, any>> extends Rule<TContext> implements LogicRuleInterface<TContext> {
     private rules;
     constructor(rules: ShieldRule<TContext>[]);
     /**
@@ -25,13 +25,13 @@ export declare class LogicRule<TContext extends Record<string, any>> extends Rul
      */
     resolve(_ctx: TContext, _type: string, _path: string, _input: {
         [name: string]: any;
-    }, _rawInput: unknown, _options: IOptions<TContext>): Promise<IRuleResult>;
+    }, _rawInput: unknown, _options: OptionsInterface<TContext>): Promise<RuleResultInterface>;
     /**
      * Evaluates all the rules.
      */
     evaluate(ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult[]>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface[]>;
     /**
      * Returns rules in a logic rule.
      */
@@ -44,7 +44,7 @@ export declare class RuleOr<TContext extends Record<string, any>> extends LogicR
      */
     resolve(ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface>;
 }
 export declare class RuleAnd<TContext extends Record<string, any>> extends LogicRule<TContext> {
     constructor(rules: ShieldRule<TContext>[]);
@@ -53,7 +53,7 @@ export declare class RuleAnd<TContext extends Record<string, any>> extends Logic
      */
     resolve(ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface>;
 }
 export declare class RuleChain<TContext extends Record<string, any>> extends LogicRule<TContext> {
     constructor(rules: ShieldRule<TContext>[]);
@@ -62,13 +62,13 @@ export declare class RuleChain<TContext extends Record<string, any>> extends Log
      */
     resolve(ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface>;
     /**
      * Evaluates all the rules.
      */
     evaluate(ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult[]>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface[]>;
 }
 export declare class RuleRace<TContext extends Record<string, any>> extends LogicRule<TContext> {
     constructor(rules: ShieldRule<TContext>[]);
@@ -77,45 +77,45 @@ export declare class RuleRace<TContext extends Record<string, any>> extends Logi
      */
     resolve(ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface>;
     /**
      * Evaluates all the rules.
      */
     evaluate(ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>): Promise<IRuleResult[]>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface[]>;
 }
-export declare class RuleNot<TContext extends Record<string, any>> extends LogicRule<TContext> implements ILogicRule<TContext> {
+export declare class RuleNot<TContext extends Record<string, any>> extends LogicRule<TContext> implements LogicRuleInterface<TContext> {
     error?: Error;
     name: string;
-    equals: (rule: IRule<TContext>) => boolean;
+    equals: (rule: RuleInterface<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>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>): Promise<RuleResultInterface>;
 }
-export declare class RuleTrue<TContext extends Record<string, any>> extends LogicRule<TContext> implements ILogicRule<TContext> {
+export declare class RuleTrue<TContext extends Record<string, any>> extends LogicRule<TContext> implements LogicRuleInterface<TContext> {
     name: string;
-    equals: (rule: IRule<TContext>) => boolean;
+    equals: (rule: RuleInterface<TContext>) => boolean;
     constructor();
     /**
      *
      * Always true.
      *
      */
-    resolve(): Promise<IRuleResult>;
+    resolve(): Promise<RuleResultInterface>;
 }
-export declare class RuleFalse<TContext extends Record<string, any>> extends LogicRule<TContext> implements ILogicRule<TContext> {
+export declare class RuleFalse<TContext extends Record<string, any>> extends LogicRule<TContext> implements LogicRuleInterface<TContext> {
     name: string;
-    equals: (rule: IRule<TContext>) => boolean;
+    equals: (rule: RuleInterface<TContext>) => boolean;
     constructor();
     /**
      *
      * Always false.
      *
      */
-    resolve(): Promise<IRuleResult>;
+    resolve(): Promise<RuleResultInterface>;
 }

package/dist/shield/rules.mjs

@@ -1 +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}}
+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 a=>a.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(a=>a 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(a=>a 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(a=>a instanceof Error)??!1:!0}async evaluate(e,n,s,o,u,r){const t=this.getRules();return i(t);async function i([a,...x]){return a===void 0?[]:a.resolve(e,n,s,o,u,r).then(async c=>c!==!0?[c]:i(x).then(f=>f.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(a=>a instanceof Error)??!1}async evaluate(e,n,s,o,u,r){const t=this.getRules();return i(t);async function i([a,...x]){return a===void 0?[]:a.resolve(e,n,s,o,u,r).then(async c=>c===!0?[c]:i(x).then(f=>f.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

@@ -8,17 +8,17 @@ var _constructors = require("./constructors.cjs");
 var _generator = require("./generator.cjs");
 var _utils = require("./utils.cjs");
 var _validation = require("./validation.cjs");
-function u(r) {
-  return typeof r.fallbackError == "string" && (r.fallbackError = new Error(r.fallbackError)), {
-    debug: r.debug ?? !1,
-    allowExternalErrors: (0, _utils.withDefault)(!1)(r.allowExternalErrors),
-    fallbackRule: (0, _utils.withDefault)(_constructors.allow)(r.fallbackRule),
-    fallbackError: (0, _utils.withDefault)(new Error("Authorization error"))(r.fallbackError)
+function s(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("Authorization error"))(e.fallbackError)
   };
 }
-function shield(r, o = {}) {
-  const n = u(o),
-    t = (0, _validation.validateRuleTree)(r);
-  if (t.status === "ok") return (0, _generator.generateMiddlewareFromRuleTree)(r, n);
+function shield(e, o = {}) {
+  const n = s(o),
+    t = (0, _validation.validateRuleTree)(e);
+  if (t.status === "ok") return (0, _generator.generateMiddlewareFromRuleTree)(e, n);
   throw new _validation.ValidationError(t.message);
 }

package/dist/shield/shield.d.ts

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

package/dist/shield/shield.mjs

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

package/dist/shield/types.d.ts

@@ -1,52 +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>> {
+export type ShieldRule<TContext extends Record<string, any> = Record<string, any>> = RuleInterface<TContext> | LogicRuleInterface<TContext>;
+export interface RuleInterface<TContext extends Record<string, any> = Record<string, any>> {
     name: string;
-    equals: (rule: IRule<TContext>) => boolean;
+    equals: (rule: RuleInterface<TContext>) => boolean;
     resolve: (ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>) => Promise<IRuleResult>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>) => Promise<RuleResultInterface>;
     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>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>) => string | boolean | Error | Promise<RuleResultInterface>;
 }
-export interface IRuleOptions {
+export interface RuleOptionsInterface {
 }
-export interface ILogicRule<TContext extends Record<string, any> = Record<string, any>> extends IRule<TContext> {
+export interface LogicRuleInterface<TContext extends Record<string, any> = Record<string, any>> extends RuleInterface<TContext> {
     getRules: () => ShieldRule<TContext>[];
     evaluate: (ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>) => Promise<IRuleResult[]>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>) => Promise<RuleResultInterface[]>;
     resolve: (ctx: TContext, type: string, path: string, input: {
         [name: string]: any;
-    }, rawInput: unknown, options: IOptions<TContext>) => Promise<IRuleResult>;
+    }, rawInput: unknown, options: OptionsInterface<TContext>) => Promise<RuleResultInterface>;
 }
-export type IRuleResult = boolean | string | Error;
-export type IRuleFunction<TContext extends Record<string, any> = Record<string, any>> = (ctx: TContext, type: string, path: string, input: {
+export type RuleResultInterface = boolean | string | Error;
+export type RuleFunctionInterface<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 {
+}, rawInput: unknown, options: OptionsInterface<TContext>) => RuleResultInterface | Promise<RuleResultInterface>;
+export interface RuleConstructorOptionsInterface {
 }
-export interface IRuleTypeMap<TContext extends Record<string, any> = Record<string, any>> {
-    [key: string]: ShieldRule<TContext> | IRuleFieldMap<TContext> | IRuleTypeMap<TContext>;
+export interface RuleTypeMapInterface<TContext extends Record<string, any> = Record<string, any>> {
+    [key: string]: ShieldRule<TContext> | RuleFieldMapInterface<TContext> | RuleTypeMapInterface<TContext>;
 }
-export interface IRuleFieldMap<TContext extends Record<string, any> = Record<string, any>> {
+export interface RuleFieldMapInterface<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 IRules<TContext extends Record<string, any> = Record<string, any>> = ShieldRule<TContext> | RuleTypeMapInterface<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>> {
+export interface OptionsInterface<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>> {
+export interface OptionsConstructorInterface<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;
+export declare function shield<TContext extends Record<string, any> = Record<string, any>>(ruleTree: IRules<TContext>, options: OptionsInterface<TContext>): any;

package/dist/shield/utils.d.ts

@@ -1,12 +1,12 @@
-import type { ILogicRule, IRule, IRuleFieldMap, ShieldRule } from "./types";
+import type { LogicRuleInterface, RuleFieldMapInterface, RuleInterface, 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>;
+export declare function isRule<TContext extends Record<string, any>>(x: any): x is RuleInterface<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>;
+export declare function isLogicRule<TContext extends Record<string, any>>(x: any): x is LogicRuleInterface<TContext>;
 /**
  * Makes sure that a certain field is a rule or a logic rule.
  */
@@ -14,7 +14,7 @@ export declare function isRuleFunction<TContext extends Record<string, any>>(x:
 /**
  * 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>;
+export declare function isRuleFieldMap<TContext extends Record<string, any>>(x: any): x is RuleFieldMapInterface<TContext>;
 /**
  * Flattens object of particular type by checking if the leaf
  * evaluates to true from particular function.

package/dist/shield/validation.cjs

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.ValidationError = void 0;
 exports.validateRuleTree = validateRuleTree;
 var _utils = require("./utils.cjs");
-function validateRuleTree(r) {
-  const u = c(r).reduce(({
+function validateRuleTree(s) {
+  const a = l(s).reduce(({
     map: t,
     duplicates: n
   }, e) => t.has(e.name) ? !t.get(e.name).equals(e) && !n.includes(e.name) ? {
@@ -23,18 +23,18 @@ function validateRuleTree(r) {
     map: new Map(),
     duplicates: []
   });
-  if (u.duplicates.length === 0) return {
+  if (a.duplicates.length === 0) return {
     status: "ok"
   };
   return {
     status: "err",
-    message: `There seem to be multiple definitions of these rules: ${u.duplicates.join(", ")}`
+    message: `There seem to be multiple definitions of these rules: ${a.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 l(t) {
+    return (0, _utils.flattenObjectOf)(t, _utils.isRuleFunction).reduce((c, r) => (0, _utils.isLogicRule)(r) ? [...c, ...u(r)] : [...c, r], []);
   }
-  function i(t) {
-    return t.getRules().reduce((n, e) => (0, _utils.isLogicRule)(e) ? [...n, ...i(e)] : [...n, e], []);
+  function u(t) {
+    return t.getRules().reduce((n, e) => (0, _utils.isLogicRule)(e) ? [...n, ...u(e)] : [...n, e], []);
   }
 }
 class ValidationError extends Error {

package/dist/shield/validation.mjs

@@ -1 +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)}}
+import{flattenObjectOf as f,isLogicRule as i,isRuleFunction as x}from"./utils";export function validateRuleTree(s){const a=l(s).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(a.duplicates.length===0)return{status:"ok"};return{status:"err",message:`There seem to be multiple definitions of these rules: ${a.duplicates.join(", ")}`};function l(t){return f(t,x).reduce((c,r)=>i(r)?[...c,...u(r)]:[...c,r],[])}function u(t){return t.getRules().reduce((n,e)=>i(e)?[...n,...u(e)]:[...n,e],[])}}export class ValidationError extends Error{constructor(o){super(o)}}

package/dist/tanstack-query/client.cjs

@@ -11,7 +11,7 @@ var _client = require("@trpc/client");
 var _tanstackReactQuery = require("@trpc/tanstack-react-query");
 var _react = require("react");
 var _shared = require("../shared.cjs");
-function createTRPCTanstackQueryClient(t, r) {
+function createTRPCTanstackQueryClient(t, e) {
   const {
     TRPCProvider: o,
     useTRPC: n
@@ -24,7 +24,7 @@ function createTRPCTanstackQueryClient(t, r) {
         } = i,
         [u] = (0, _react.useState)(() => (0, _client.createTRPCClient)({
           links: [(0, _client.loggerLink)({
-            enabled: e => _environmentChecks.isDevelopment || e.direction === "down" && e.result instanceof Error
+            enabled: r => _environmentChecks.isDevelopment || r.direction === "down" && r.result instanceof Error
           }), (0, _client.httpBatchStreamLink)({
             transformer: _shared.transformer,
             url: (0, _shared.getTRPCServerUrl)(t),
@@ -35,9 +35,9 @@ function createTRPCTanstackQueryClient(t, r) {
         }));
       return React.createElement(o, {
         trpcClient: u,
-        queryClient: r
+        queryClient: e
       }, React.createElement(_reactQuery.QueryClientProvider, {
-        client: r
+        client: e
       }, c));
     }
   };

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

@@ -1,4 +1,4 @@
-import type { StormURL } from "@stryke/http/types";
+import type { StormURLInterface } from "@stryke/url/types";
 import type { QueryClient } from "@tanstack/react-query";
 import type { AnyTRPCRouter } from "@trpc/server";
 /**
@@ -6,8 +6,10 @@ import type { AnyTRPCRouter } from "@trpc/server";
  *
  * @returns The TRPC Tanstack Query client
  */
-export declare function createTRPCTanstackQueryClient<TRouter extends AnyTRPCRouter>(baseUrl: string | StormURL, queryClient: QueryClient): {
-    useTRPCTanstackQuery: () => import("@trpc/tanstack-react-query").TRPCOptionsProxy<TRouter>;
+export declare function createTRPCTanstackQueryClient<TRouter extends AnyTRPCRouter>(baseUrl: string | StormURLInterface, queryClient: QueryClient): {
+    useTRPCTanstackQuery: () => import("@trpc/tanstack-react-query").TRPCOptionsProxy<TRouter, {
+        keyPrefix: false;
+    }>;
     TRPCTanstackQueryProvider: (props: {
         children: React.ReactNode;
     }) => import("react").JSX.Element;

package/dist/tanstack-query/client.mjs

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

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

@@ -13,7 +13,9 @@ import "server-only";
  * @returns The TRPC Tanstack Query server
  */
 export declare function createTRPCTanstackQueryServer<TRouter extends AnyTRPCRouter, TContext extends inferRouterContext<TRouter> = inferRouterContext<TRouter>>(headers: () => Promise<Headers>, router: TRouter, createContext?: () => MaybePromise<TContext>, queryClientConfig?: Partial<QueryClientConfig>): {
-    trpc: import("@trpc/tanstack-react-query").TRPCOptionsProxy<TRouter>;
+    trpc: import("@trpc/tanstack-react-query").TRPCOptionsProxy<TRouter, {
+        keyPrefix: false;
+    }>;
     HydrateClient: (props: {
         children: React.ReactNode;
     }) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stryke/trpc-next",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "type": "module",
   "description": "A package to help in using tRPC in modern NextJs applications.",
   "repository": {
@@ -10,9 +10,9 @@
   },
   "private": false,
   "peerDependencies": {
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
-    "react-native": "^0.77.0"
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-native": "^0.77.3"
   },
   "peerDependenciesMeta": {
     "react": { "optional": false },
@@ -20,23 +20,23 @@
     "react-native": { "optional": true }
   },
   "dependencies": {
-    "@js-temporal/polyfill": "^0.5.0",
-    "@tanstack/react-query": "^5.70.0",
-    "@trpc/client": "next",
-    "@trpc/next": "next",
-    "@trpc/server": "next",
-    "@trpc/tanstack-react-query": "next",
+    "@js-temporal/polyfill": "^0.5.1",
+    "@tanstack/react-query": "^5.90.5",
+    "@trpc/client": "^11.7.1",
+    "@trpc/next": "^11.7.1",
+    "@trpc/server": "^11.7.1",
+    "@trpc/tanstack-react-query": "^11.7.1",
     "defu": "^6.1.4",
     "server-only": "^0.0.1",
     "superjson": "2.2.2",
-    "@stryke/env": "^0.15.0",
-    "@stryke/http": "^0.8.2",
-    "@stryke/path": "^0.8.0",
-    "@stryke/types": "^0.8.4"
+    "@stryke/env": "^0.20.5",
+    "@stryke/path": "^0.18.0",
+    "@stryke/types": "^0.10.0",
+    "@stryke/url": "^0.2.4"
   },
   "devDependencies": {
-    "@types/react": "^19.0.12",
-    "@types/react-dom": "^19.0.4",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
     "@types/react-native": "0.72.8"
   },
   "publishConfig": { "access": "public" },
@@ -321,5 +321,6 @@
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts"
+  "types": "./dist/index.d.ts",
+  "gitHead": "1764a8373c1db0b1c11bed7439292236edfd9e4e"
 }