implement namespaced routers support

omar-dulaimi · Jan 13, 2023 · 566eacf · 566eacf
1 parent 73397cd
commit 566eacf
Show file tree

Hide file tree

Showing 3 changed files with 55 additions and 18 deletions.
diff --git a/README.md b/README.md
@@ -116,7 +116,7 @@ const permissions = shield<Context>({
   mutation: {
     addFruitToBasket: isAuthenticated,
   },
-})
+});
 
 export const t = trpc.initTRPC.context<Context>().create();
 
@@ -128,7 +128,32 @@ export const shieldedProcedure = t.procedure.use(permissionsMiddleware);
 For a fully working example, [go here](https://github.com/omar-dulaimi/trpc-shield/tree/master/example).
 ## Documentation
 
-### `shield(rules?, options?)`
+### Namespaced routers
+
+```ts
+export const permissions = shield<Context>({
+  user: {
+    query: {
+      aggregateUser: allow,
+      findFirstUser: allow,
+      findManyUser: isAuthenticated,
+      findUniqueUser: allow,
+      groupByUser: allow,
+    },
+    mutation: {
+      createOneUser: isAuthenticated,
+      deleteManyUser: allow,
+      deleteOneUser: allow,
+      updateManyUser: allow,
+      updateOneUser: allow,
+      upsertOneUser: allow,
+    },
+  },
+});
+```
+
+### API
+#### `shield(rules?, options?)`
 
 > Generates tRPC Middleware layer from your rules.
 

diff --git a/src/generator.ts b/src/generator.ts
@@ -1,4 +1,4 @@
-import { IOptions, IRules } from './types'
+import { IOptions, IRules } from './types';
 
 /**
  *
@@ -20,23 +20,35 @@ export function generateMiddlewareFromRuleTree<TContext extends Record<string, u
     input,
     rawInput,
   }: {
-    next: Function
-    ctx: { [name: string]: any }
-    type: string
-    path: string
-    input: { [name: string]: any }
-    rawInput: unknown
+    next: Function;
+    ctx: { [name: string]: any };
+    type: string;
+    path: string;
+    input: { [name: string]: any };
+    rawInput: unknown;
   }) => {
-    const opWithPath: Array<string> = path.split('.')
-    const opName: string = opWithPath[opWithPath.length - 1]
-    const rule = ruleTree?.[type]?.[opName] || options.fallbackRule
+    const opWithPath: Array<string> = path.split('.');
+    const opName: string = opWithPath[opWithPath.length - 1];
+    const keys = Object.keys(ruleTree);
+    let rule;
+    if (keys.includes('query') || keys.includes('mutation')) {
+      rule = ruleTree?.[type]?.[opName] || options.fallbackRule;
+    } else {
+      for (const key of keys) {
+        const namespace = ruleTree[key];
+        if (namespace?.[type]?.[opName]) {
+          rule = namespace?.[type]?.[opName] || options.fallbackRule;
+          break;
+        }
+      }
+    }
 
     if (rule) {
       return rule?.resolve(ctx, type, path, input, rawInput, options).then((result: any) => {
-        if (!result) throw options.fallbackError
-        return next()
-      })
+        if (!result) throw options.fallbackError;
+        return next();
+      });
     }
-    return next()
-  }
+    return next();
+  };
 }
diff --git a/src/types.ts b/src/types.ts
@@ -57,7 +57,7 @@ export interface IRuleConstructorOptions {}
 // Rules Definition Tree
 
 export interface IRuleTypeMap<TContext> {
-  [key: string]: ShieldRule<TContext> | IRuleFieldMap<TContext>
+  [key: string]: ShieldRule<TContext> | IRuleFieldMap<TContext> | IRuleTypeMap<TContext>
 }
 
 export interface IRuleFieldMap<TContext> {