permix/dist/trpc/index.d.mts

Permix is a lightweight, framework-agnostic, type-safe permissions management library for JavaScript applications on the client and server sides.

import { A as Definition, C as Rules, D as Action, O as ActionName, _ as PermixHooks, g as Permix, l as CheckArgs, u as CheckContext, v as RulesPaths } from "../index-BYcbfVQ7.mjs";
import { TRPCMiddlewareBuilder } from "@trpc/server";

//#region src/trpc/permix.d.ts
interface PermixOptions<D extends Definition> {
  onForbidden?: (params: CheckContext<D> & {
    ctx: Record<string, any>;
    next: (...args: any[]) => any;
  }) => any;
}
type TrpcContext<D extends Definition, Key extends string> = { [P in Key]: Permix<D> };
type TrpcRootContext<D extends Definition, Key extends string> = TrpcContext<D, Key> extends ((...args: any[]) => infer TReturn) ? Awaited<TReturn> : TrpcContext<D, Key>;
declare function buildPermix<D extends Definition, const Key extends string>(resolveKey: () => string, options?: PermixOptions<D>): {
  setupContext: (rules: Rules<D>) => { [P in Key]: Permix<D> };
  checkMiddleware: (...args: CheckArgs<D>) => TRPCMiddlewareBuilder<TrpcRootContext<D, Key>, object, unknown, unknown>;
  getRules: (ctx: Record<string, Permix<D> | undefined>) => Rules<D> | null;
  template: <T = void>(rules: Rules<D> | ((param: T) => Rules<D>)) => (param: T) => Rules<D>;
  hook: <K extends keyof PermixHooks<D>>(name: K, fn: PermixHooks<D>[K]) => () => void;
  hookOnce: <K extends keyof PermixHooks<D>>(name: K, fn: PermixHooks<D>[K]) => void;
  readonly key: Key;
  $inferDefinition: D;
  $inferPath: RulesPaths<D>;
};
/**
 * Create a middleware factory that wires Permix into tRPC procedures.
 *
 * Use `.contextKey('name')` to set a custom context key (its literal type is
 * inferred automatically). Defaults to `'permix'`.
 *
 * @example
 * ```ts
 * import { initTRPC } from '@trpc/server'
 * import { createPermix } from 'permix/trpc'
 *
 * const permix = createPermix<{
 *   post: ['create', 'read']
 * }>()
 *
 * const t = initTRPC.context<Context>().create()
 *
 * const trpc = t.procedure
 *   .use(({ next }) => {
 *     return next({
 *       ctx: permix.setupContext({
 *         post: { create: true },
 *       }),
 *     })
 *   })
 *
 * export const router = trpc.router({
 *   createPost: trpc
 *     .use(permix.checkMiddleware('post.create'))
 *     .mutation(({ ctx }) => { ... }),
 * })
 * ```
 *
 * @link https://permix.letstri.dev/docs/integrations/trpc
 */
declare function createPermix<D extends Definition>(options?: PermixOptions<D>): {
  setupContext: (rules: Rules<D>) => {
    permix: Permix<D>;
  };
  checkMiddleware: (...args: CheckArgs<D>) => TRPCMiddlewareBuilder<TrpcContext<D, "permix">, object, unknown, unknown>;
  getRules: (ctx: Record<string, Permix<D> | undefined>) => Rules<D> | null;
  template: <T = void>(rules: Rules<D> | ((param: T) => Rules<D>)) => (param: T) => Rules<D>;
  hook: <K extends keyof PermixHooks<D>>(name: K, fn: PermixHooks<D>[K]) => () => void;
  hookOnce: <K extends keyof PermixHooks<D>>(name: K, fn: PermixHooks<D>[K]) => void;
  readonly key: Key;
  $inferDefinition: D;
  $inferPath: D extends readonly Action[] ? `${ActionName<D[number]>}` : { [K in keyof D & string]: D[K] extends Definition ? D[K] extends infer T ? T extends D[K] ? T extends readonly Action[] ? `${K}.${ActionName<T[number]>}` : { [K_2 in keyof T & string]: T[K_2] extends Definition ? T[K_2] extends infer T_1 ? T_1 extends T[K_2] ? T_1 extends readonly Action[] ? `${K}.${K_2}.${ActionName<T_1[number]>}` : { [K_3 in keyof T_1 & string]: T_1[K_3] extends Definition ? T_1[K_3] extends infer T_2 ? T_2 extends T_1[K_3] ? T_2 extends readonly Action[] ? `${K}.${K_2}.${K_3}.${ActionName<T_2[number]>}` : { [K_4 in keyof T_2 & string]: T_2[K_4] extends Definition ? T_2[K_4] extends infer T_3 ? T_3 extends T_2[K_4] ? T_3 extends readonly Action[] ? `${K}.${K_2}.${K_3}.${K_4}.${ActionName<T_3[number]>}` : { [K_5 in keyof T_3 & string]: T_3[K_5] extends Definition ? T_3[K_5] extends infer T_4 ? T_4 extends T_3[K_5] ? T_4 extends readonly Action[] ? `${K}.${K_2}.${K_3}.${K_4}.${K_5}.${ActionName<T_4[number]>}` : { [K_6 in keyof T_4 & string]: T_4[K_6] extends Definition ? T_4[K_6] extends infer T_5 ? T_5 extends T_4[K_6] ? T_5 extends readonly Action[] ? `${K}.${K_2}.${K_3}.${K_4}.${K_5}.${K_6}.${ActionName<T_5[number]>}` : { [K_7 in keyof T_5 & string]: T_5[K_7] extends Definition ? T_5[K_7] extends infer T_6 ? T_6 extends T_5[K_7] ? T_6 extends readonly Action[] ? `${K}.${K_2}.${K_3}.${K_4}.${K_5}.${K_6}.${K_7}.${ActionName<T_6[number]>}` : { [K_8 in keyof T_6 & string]: T_6[K_8] extends Definition ? T_6[K_8] extends infer T_7 ? T_7 extends T_6[K_8] ? T_7 extends readonly Action[] ? `${K}.${K_2}.${K_3}.${K_4}.${K_5}.${K_6}.${K_7}.${K_8}.${ActionName<T_7[number]>}` : { [K_9 in keyof T_7 & string]: T_7[K_9] extends Definition ? T_7[K_9] extends infer T_8 ? T_8 extends T_7[K_9] ? T_8 extends readonly Action[] ? `${K}.${K_2}.${K_3}.${K_4}.${K_5}.${K_6}.${K_7}.${K_8}.${K_9}.${ActionName<T_8[number]>}` : { [K_10 in keyof T_8 & string]: T_8[K_10] extends Definition ? never : never }[keyof T_8 & string] : never : never : never }[keyof T_7 & string] : never : never : never }[keyof T_6 & string] : never : never : never }[keyof T_5 & string] : never : never : never }[keyof T_4 & string] : never : never : never }[keyof T_3 & string] : never : never : never }[keyof T_2 & string] : never : never : never }[keyof T_1 & string] : never : never : never }[keyof T & string] : never : never : never }[keyof D & string];
} & {
  contextKey<const Key extends string>(newKey: Key): ReturnType<typeof buildPermix<D, Key>>;
};
type TrpcPermix<D extends Definition> = ReturnType<typeof createPermix<D>>;
//#endregion
//#region src/trpc/index.d.ts
declare global {
  interface Disposable {}
  interface AsyncDisposable {}
}
//#endregion
export { PermixOptions, TrpcPermix, createPermix };