TypeScript shared.utils類代碼示例

 .filter(prop => {
   const descriptor = Object.getOwnPropertyDescriptor(prototype, prop);
   if (descriptor.set || descriptor.get) {
     return false;
   }
   return !isConstructor(prop) && isFunction(prototype[prop]);
 })

 public createConcreteContext<T extends any[], R extends any[]>(
   metadata: T,
 ): R {
   if (isUndefined(metadata) || isEmpty(metadata)) {
     return [] as R;
   }
   return iterate(metadata)
     .filter((guard: any) => guard && (guard.name || guard.canActivate))
     .map(guard => this.getGuardInstance(guard))
     .filter((guard: CanActivate) => guard && isFunction(guard.canActivate))
     .toArray() as R;
 }

 public createConcreteContext<T extends any[], R extends any[]>(
   metadata: T,
 ): R {
   if (isUndefined(metadata) || isEmpty(metadata)) {
     return [] as R;
   }
   return iterate(metadata)
     .filter((pipe: any) => pipe && (pipe.name || pipe.transform))
     .map(pipe => this.getPipeInstance(pipe))
     .filter(pipe => pipe && pipe.transform && isFunction(pipe.transform))
     .map(pipe => pipe.transform.bind(pipe))
     .toArray() as R;
 }

  public async loadInstance<T>(
    wrapper: InstanceWrapper<T>,
    collection: Map<string, InstanceWrapper<any>>,
    module: Module,
  ) {
    if (wrapper.isPending) {
      return wrapper.done$;
    }
    const done = this.applyDoneHook(wrapper);
    const { name, inject } = wrapper;

    const targetWrapper = collection.get(name);
    if (isUndefined(targetWrapper)) {
      throw new RuntimeException();
    }
    if (targetWrapper.isResolved) {
      return;
    }
    const callback = async instances => {
      const properties = await this.resolveProperties(wrapper, module, inject);
      const instance = await this.instantiateClass(
        instances,
        wrapper,
        targetWrapper,
      );
      this.applyProperties(instance, properties);
      done();
    };
    await this.resolveConstructorParams<T>(wrapper, module, inject, callback);
  }

 public mapRouteToRouteInfo(
   route: Type<any> | RouteInfo | string,
 ): RouteInfo[] {
   if (isString(route)) {
     return [
       {
         path: this.validateRoutePath(route),
         method: RequestMethod.ALL,
       },
     ];
   }
   const routePath: string = Reflect.getMetadata(PATH_METADATA, route);
   if (this.isRouteInfo(routePath, route)) {
     return [
       {
         path: this.validateRoutePath(route.path),
         method: route.method,
       },
     ];
   }
   const paths = this.routerExplorer.scanForPaths(
     Object.create(route),
     route.prototype,
   );
   return paths.map(item => ({
     path:
       this.validateGlobalPath(routePath) + this.validateRoutePath(item.path),
     method: item.requestMethod,
   }));
 }

  public async resolveConstructorParams<T>(
    wrapper: InstanceWrapper<T>,
    module: Module,
    inject: any[],
    callback: (args) => void,
  ) {
    let isResolved = true;
    const args = isNil(inject)
      ? this.reflectConstructorParams(wrapper.metatype)
      : inject;

    const instances = await Promise.all(
      args.map(async (param, index) => {
        const paramWrapper = await this.resolveSingleParam<T>(
          wrapper,
          param,
          { index, length: args.length },
          module,
        );
        if (!paramWrapper.isResolved && !paramWrapper.forwardRef) {
          isResolved = false;
        }
        return paramWrapper.instance;
      }),
    );
    isResolved && (await callback(instances));
  }

 public async intercept(
   interceptors: NestInterceptor[],
   args: any[],
   instance: Controller,
   callback: (...args) => any,
   next: () => Promise<any>,
 ): Promise<any> {
   if (!interceptors || isEmpty(interceptors)) {
     return await await next();
   }
   const context = this.createContext(args, instance, callback);
   const start$ = defer(() => this.transformDeffered(next));
   /***
     const nextFn =  (i: number) => async () => {
     if (i <= interceptors.length) {
       return start$;
     }
     return await interceptors[i].intercept(context, nextFn(i + 1) as any);
   };
   */
   const result$ = await interceptors.reduce(
     async (stream$, interceptor) =>
       await interceptor.intercept(context, await stream$),
     Promise.resolve(start$),
   );
   return await result$.toPromise();
 }

 public *scanForServerHooks(instance: NestGateway): IterableIterator<string> {
   for (const propertyKey in instance) {
     if (isFunction(propertyKey)) {
       continue;
     }
     const property = String(propertyKey);
     const isServer = Reflect.getMetadata(
       GATEWAY_SERVER_METADATA,
       instance,
       property,
     );
     if (!isUndefined(isServer)) {
       yield property;
     }
   }
 }

 public async resolveSingleParam<T>(
   wrapper: InstanceWrapper<T>,
   param: Type<any> | string | symbol | any,
   dependencyContext: InjectorDependencyContext,
   module: Module,
 ) {
   if (isUndefined(param)) {
     throw new UndefinedDependencyException(wrapper.name, dependencyContext, module);
   }
   const token = this.resolveParamToken(wrapper, param);
   return this.resolveComponentInstance<T>(
     module,
     isFunction(token) ? (token as Type<any>).name : token,
     dependencyContext,
     wrapper,
   );
 }

 public send<TResult = any, TInput = any>(
   pattern: any,
   data: TInput,
 ): Observable<TResult> {
   if (isNil(pattern) || isNil(data)) {
     return _throw(new InvalidMessageException());
   }
   return defer(async () => await this.connect()).pipe(
     mergeMap(
       () =>
         new Observable((observer: Observer<TResult>) => {
           const callback = this.createObserver(observer);
           return this.publish({ pattern, data }, callback);
         }),
     ),
   );
 }