feat: opt param for auth.

Author: zhang740

lib/auth/BaseAuth.ts

@@ -11,15 +11,15 @@ export abstract class BaseAuth extends Service {
 
 export interface RoleMetaInfo {
   /** 需要参数名列表 */
-  params: string[];
+  params: { name: string, required: boolean }[];
 }
 
 const infoSymbol = Symbol('InfoSymbol');
 export function getRoleInfo(roleType: typeof BaseAuth): RoleMetaInfo {
   const desc = Object.getOwnPropertyDescriptor(roleType, infoSymbol);
   if (!desc) {
     const info: RoleMetaInfo = {
-      params: getParameterNames(roleType.prototype.has).map(name => name),
+      params: getParameterNames(roleType.prototype.has).map(name => ({ name, required: true })),
     };
     Object.defineProperty(roleType, infoSymbol, {
       value: info,
@@ -28,3 +28,10 @@ export function getRoleInfo(roleType: typeof BaseAuth): RoleMetaInfo {
   }
   return desc.value;
 }
+
+export function opt() {
+  return (target, key, index): any => {
+    const info = getRoleInfo(target.constructor);
+    info.params[index].required = false;
+  };
+}

lib/middleware/auth.ts

@@ -19,10 +19,10 @@ export const authMiddleware = (app: Application, typeInfo: RouteType) => {
       (typeInfo.auth || [])
         .map(async permRole => {
           const params = getRoleInfo(permRole).params.map(p => {
-            if (paramObj[p] === undefined) {
-              throw new BadRequestError(`Permission [${permRole.name}] NEED Param [${p}]`);
+            if (p.required && !(p.name in paramObj)) {
+              throw new BadRequestError(`Permission [${permRole.name}] NEED Param [${p.name}]`);
             }
-            return paramObj[p];
+            return paramObj[p.name];
           });
           if (!(await getInstance<BaseAuth>(permRole, ctx.app, ctx).has(...params))) {
             throw new ForbiddenError(

lib/util.ts

@@ -1,12 +1,12 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
-const generatorFuncPrototype = Object.getPrototypeOf(function*(): any {});
+const generatorFuncPrototype = Object.getPrototypeOf(function* (): any { });
 export function isGeneratorFunction(fn: any) {
   return typeof fn === 'function' && Object.getPrototypeOf(fn) === generatorFuncPrototype;
 }
 
-const asyncFuncPrototype = Object.getPrototypeOf(async function() {});
+const asyncFuncPrototype = Object.getPrototypeOf(async function () { });
 export function isAsyncFunction(fn: any) {
   return typeof fn === 'function' && Object.getPrototypeOf(fn) === asyncFuncPrototype;
 }
@@ -60,6 +60,10 @@ const DEFAULT_PARAMS = /=[^,]*/gm;
 const FAT_ARROWS = /=>.*$/gm;
 
 export function getParameterNames(fn: Function | string) {
+  if (!fn) {
+    console.warn('NO fn for getParameterNames!');
+    return [];
+  }
   let code = typeof fn === 'function' ? fn.toString() : fn;
 
   let right = 0;

test/auth.test.ts

@@ -44,4 +44,22 @@ describe('auth', () => {
       .get('/auth/forbidden')
       .expect(403);
   });
+
+  it('opt param', () => {
+    return request(app.callback())
+      .get('/auth/opt')
+      .expect(204);
+  });
+
+  it('opt param ok', () => {
+    return request(app.callback())
+      .get('/auth/opt?id=opt')
+      .expect(204);
+  });
+
+  it('opt param fail', () => {
+    return request(app.callback())
+      .get('/auth/opt?id=fail')
+      .expect(403);
+  });
 });

test/fixtures/example/app/auth/default.ts

@@ -1,5 +1,6 @@
 import { BaseAuth } from '../../../../../lib';
 import { ForbiddenError } from '../../../../../lib/error';
+import { opt } from '../../../../../lib/auth/BaseAuth';
 
 export class DefaultAuth extends BaseAuth {
   async has(): Promise<boolean> {
@@ -18,3 +19,9 @@ export class ForbiddenAuth extends BaseAuth {
     throw new ForbiddenError();
   }
 }
+
+export class OptParamAuth extends BaseAuth {
+  async has(@opt() id: string): Promise<boolean> {
+    return !id || id === 'opt';
+  }
+}

test/fixtures/example/app/controller/auth.ts

@@ -1,18 +1,21 @@
 import { Controller } from 'egg';
 import { route, controller } from '../../../../../lib';
-import { DefaultAuth, ForbiddenAuth, NeedParamAuth } from '../auth/default';
+import { DefaultAuth, ForbiddenAuth, NeedParamAuth, OptParamAuth } from '../auth/default';
 
 @controller({ prefix: '/auth' })
 export class AuthController extends Controller {
   @route({ auth: [DefaultAuth] })
-  default() {}
+  default() { }
 
   @route({ auth: [NeedParamAuth] })
-  needParam() {}
+  needParam() { }
 
   @route({ auth: [NeedParamAuth] })
-  needParamOk(id: string) {}
+  needParamOk(id: string) { }
 
   @route({ auth: [ForbiddenAuth] })
-  forbidden() {}
+  forbidden() { }
+
+  @route({ auth: [OptParamAuth] })
+  opt(id?: string) { }
 }