feature: add async function (#7)

Author: Su-Yong

packages/scope-validator/lib/pattern.ts

@@ -18,8 +18,8 @@ export default class Pattern {
     return this.regex.test(compare);
   }
 
-  getParameters(compare: string): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
+  getParameters(compare: string): Record<string, string> {
+    const result: Record<string, string> = {};
 
     let parameterNames = this.str.split(/(?:\${|})/g);
     parameterNames = parameterNames.filter((value, index) => index % 2);
@@ -38,11 +38,11 @@ export default class Pattern {
 
     const regex = new RegExp(`^${regexStr}$`);
 
-    const parameterValues = compare.match(regex);
+    const parameterValues: string[] | null = compare.match(regex);
     parameterValues?.shift();
 
     parameterNames.forEach((name, index) => {
-      result[name] = parameterValues?.[index];
+      result[name] = parameterValues?.[index] ?? '';
     });
 
     return result;

packages/scope-validator/lib/scope-validator-context.ts

@@ -1,5 +1,5 @@
 export default interface ScopeValidatorContext<T> {
-  parameters?: Record<string, unknown>;
+  parameters?: Record<string, string>;
 
   received?: T;
 }

packages/scope-validator/lib/scope-validator-factory.ts

@@ -7,19 +7,51 @@ type ScopeValidatorFunction<T> = (
   context: ScopeValidatorContext<T>
 ) => boolean;
 
+type ScopeValidatorAsyncFunction<T> = (
+  name: string,
+  context: ScopeValidatorContext<T>
+) => Promise<boolean>;
+
 export default class ScopeValidatorFactory<T> {
-  static create<T = Record<string, unknown>>(
+  static create<T = Record<string, string>>(
     pattern: string,
     func: ScopeValidatorFunction<T>
   ): ScopeValidator<T> {
     const CustomScopeValidator = class extends ScopeValidator<T> {
+      private readonly func;
+
       constructor() {
         super(pattern);
+
+        this.func = func;
       }
 
-      // eslint-disable-next-line class-methods-use-this
       validate(name: string, context: ScopeValidatorContext<T>): boolean {
-        return func(name, context);
+        return this.func(name, context);
+      }
+    };
+
+    return new CustomScopeValidator();
+  }
+
+  static createAsync<T = Record<string, string>>(
+    pattern: string,
+    func: ScopeValidatorAsyncFunction<T>
+  ): ScopeValidator<T> {
+    const CustomScopeValidator = class extends ScopeValidator<T> {
+      private readonly func;
+
+      constructor() {
+        super(pattern);
+
+        this.func = func;
+      }
+
+      async validate(
+        name: string,
+        context: ScopeValidatorContext<T>
+      ): Promise<boolean> {
+        return this.func(name, context);
       }
     };
 

packages/scope-validator/lib/scope-validator-manager.ts

@@ -11,6 +11,38 @@ export default class ScopeValidatorManager<T> {
     this.scopeValidators.push(...scopeValidators);
   }
 
+  async validateAsync(scope: string, context?: T): Promise<boolean>;
+  async validateAsync(scopes: string[], context?: T): Promise<boolean[]>;
+
+  async validateAsync(
+    scope: string | string[],
+    context?: T
+  ): Promise<boolean | boolean[]> {
+    if (scope instanceof Array) {
+      return Promise.all(
+        scope.map(async (one) => this.validateAsync(one, context))
+      );
+    }
+
+    const matchValidators = this.scopeValidators.filter((validator) =>
+      validator.canValidate(scope)
+    );
+
+    let result = true;
+    await Promise.all(
+      matchValidators.map(async (validator) => {
+        const isCheck = await validator.validate(scope, {
+          received: context,
+          parameters: validator.pattern.getParameters(scope),
+        });
+
+        if (result && !isCheck) result = false;
+      })
+    );
+
+    return matchValidators.length >= 1 && result;
+  }
+
   validate(scope: string, context?: T): boolean;
   validate(scopes: string[], context?: T): boolean[];
 

packages/scope-validator/lib/scope-validator.ts

@@ -13,5 +13,8 @@ export default abstract class ScopeValidator<T> {
     return this.pattern.test(str);
   }
 
-  abstract validate(name: string, context: ScopeValidatorContext<T>): boolean;
+  abstract validate(
+    name: string,
+    context: ScopeValidatorContext<T>
+  ): boolean | Promise<boolean>;
 }

packages/scope-validator/test/integration/async-function.spec.ts

@@ -0,0 +1,29 @@
+import { ScopeValidatorFactory, ScopeValidatorManager } from '../../lib';
+
+const TestValidator1 = ScopeValidatorFactory.createAsync(
+  // eslint-disable-next-line no-template-curly-in-string
+  '${param1}-${param2}',
+  async (name, { parameters }) => {
+    const { param1, param2 } = parameters ?? {};
+
+    return new Promise((resolve) => {
+      if (param1 === param2) resolve(true);
+      else resolve(false);
+    });
+  }
+);
+
+describe('success', () => {
+  it('validate', async () => {
+    const scopeValidatorManager = new ScopeValidatorManager();
+    scopeValidatorManager.use(TestValidator1);
+
+    const result = await scopeValidatorManager.validateAsync([
+      'test-test',
+      'test-test2',
+      'test-test-test',
+    ]);
+
+    expect(result).toEqual([true, false, false]);
+  });
+});