Pass errors swallow by promise to the observable + Fix loader type + minor fixes

index.d.ts

@@ -35,7 +35,7 @@ interface Class0 {
 
   servicesConfig: ServicesConfig;
   build(): Microservices;
-  serviceLoaders(...services: Array<{loader: () => {promise: Promise<any>}, serviceClass: any}>): Class0;
+  serviceLoaders(...services: Array<{loader: () => Promise<any>, serviceClass: any}>): Class0;
   services(...services: Array<any>): Class0;
 }
 export class DispatcherContext {
@@ -115,7 +115,7 @@ export class ServicesConfig {
   servicesConfig: Array<ServicesConfig>;
   constructor(service: any, builder?:Class0);
 }
-declare var utils: {getServiceInterface: (o: Object) => any, getServiceName: (o: Object) => any | any | any | any | any, isLoader: (inst: Object | null) => null | any | any | boolean, makeLoader: (loadFunction: {promise: Promise<any>}, Class: any) => {meta: any, promise: {promise: Promise<any>}}};
+declare var utils: {getServiceInterface: (o: Object) => any, getServiceName: (o: Object) => any | any | any | any | any, isLoader: (inst: Object | null) => null | any | any | boolean, makeLoader: (loadFunction: Promise<any>, Class: any) => {meta: any, promise: Promise<any>}};
 
 
 

index.js.flow

@@ -29,7 +29,7 @@ declare class Class0 {
 
   servicesConfig: ServicesConfig;
   build(): Microservices;
-  serviceLoaders(...services: Array<{loader: () => {promise: Promise<any>}, serviceClass: any}>): Class0;
+  serviceLoaders(...services: Array<{loader: () => Promise<any>, serviceClass: any}>): Class0;
   services(...services: Array<any>): Class0;
 }
 declare export class DispatcherContext {
@@ -109,4 +109,4 @@ declare export class ServicesConfig {
   servicesConfig: Array<ServicesConfig>;
   constructor(service: any, builder: ?Class0): ServicesConfig | ServicesConfig;
 }
-declare export var utils: {getServiceInterface: (o: Object) => any, getServiceName: (o: Object) => any | any | any | any | any, isLoader: (inst: Object | null) => null | any | any | boolean, makeLoader: (loadFunction: {promise: Promise<any>}, Class: any) => {meta: any, promise: {promise: Promise<any>}}};
+declare export var utils: {getServiceInterface: (o: Object) => any, getServiceName: (o: Object) => any | any | any | any | any, isLoader: (inst: Object | null) => null | any | any | boolean, makeLoader: (loadFunction: Promise<any>, Class: any) => {meta: any, promise: Promise<any>}};

src/scalecube-services/services/Microservices.js

@@ -1,38 +1,52 @@
 // @flow
-import { ServicesConfig, ServiceRegistery, ProxyContext, DispatcherContext, utils } from 'src/scalecube-services/services'
+import {
+  ServicesConfig,
+  ServiceRegistery,
+  ProxyContext,
+  DispatcherContext,
+  utils
+} from 'src/scalecube-services/services'
 
 class Builder {
   servicesConfig: ServicesConfig;
-  constructor(){
+
+  constructor() {
     this.servicesConfig = new ServicesConfig([]);
   }
-  services(...services:any[]){
+
+  services(...services: any[]) {
     this.servicesConfig = ServicesConfig.builder(this)
       .services(services)
       .create();
     return this;
   }
-  serviceLoaders(...services:{loader:()=>{promise:Promise<any>}, serviceClass:any}[]){
-    services.map((s)=>this.services(utils.makeLoader(s.loader(), s.serviceClass)));
+
+  serviceLoaders(...services: { loader: () => Promise<any>, serviceClass: any }[]) {
+    services.map((s) => this.services(utils.makeLoader(s.loader(), s.serviceClass)));
     return this;
   }
+
   build(): Microservices {
     return new Microservices(this.servicesConfig);
   }
 }
 export class Microservices {
   static Builder: Builder;
   serviceRegistery: ServiceRegistery;
-  constructor(serviceConfig: ServicesConfig){
+
+  constructor(serviceConfig: ServicesConfig) {
     this.serviceRegistery = new ServiceRegistery(serviceConfig);
     return this;
   }
+
   static builder() {
     return new Builder();
   };
+
   proxy() {
     return new ProxyContext(this);
   }
+
   dispatcher() {
     return new DispatcherContext(this);
   }

src/scalecube-services/services/ServiceCall.js

@@ -2,6 +2,9 @@
 
 import { Router, Message, utils } from 'src/scalecube-services/services';
 import { Observable } from 'rxjs/Observable';
+// $FlowFixMe
+import 'rxjs/add/operator/catch';
+
 
 const isObservable = (obj: any): boolean => {
   if (obj.constructor.name === 'Observable') {
@@ -36,10 +39,12 @@ export class ServiceCall {
       if (!Array.isArray(message.data)) {
         return reject(new Error(`Message format error: data must be Array`));
       }
+
       const inst = this.router.route(message);
+
       if (inst && inst.service && utils.isLoader(inst)) {
         return inst.service.promise.then((myservice) => {
-          return resolve(myservice[ message.method ](...message.data))
+          return resolve(myservice[ message.method ](...message.data));
         });
       } else if (inst) {
         return resolve(inst.service[ message.method ](...message.data));
@@ -58,12 +63,14 @@ export class ServiceCall {
         observer.error(new Error(`Service not found error: ${message.serviceName}.${message.method}`));
       } else if (utils.isLoader(inst)) {
         let unsubscribe;
-        const promise = inst.service.promise;
-        promise.then((service) => {
-          unsubscribe = createServiceObserver(message, service, observer);
+        const promise = new Promise(resolve=>{
+          inst.service.promise.then((service) => {
+            resolve(createServiceObserver(message, service, observer));
+          }).catch(e=>observer.error(e));
+
         });
         return () => {
-          promise.then(() => unsubscribe())
+          promise.then(unsubscribe => unsubscribe());
         };
       } else {
         return createServiceObserver(message, inst.service, observer);

src/scalecube-services/services/ServiceDefinition.js

@@ -26,29 +26,11 @@ export class ServiceDefinition {
   }
   static from(service: Object) {
     const methods = {};
-    //const x = new service();
-    /*Object.getOwnPropertyNames(Object.getPrototypeOf(service)).map((method) => {
-      if (method !== 'constructor' && typeof service[ method ] === 'function') {
-        methods[ method ] = service[ method ];
-      }
-    });*/
+
     const meta = service.constructor.meta || service.meta;
     Object.keys(meta.methods).map((key)=>{
         methods[ key ] = ServiceDefinition.getMethod(meta, service, key);
     });
     return new ServiceDefinition(service, utils.getServiceName(service), methods);
   }
-  /*static fromPromise(service: ServicePromise<Object>){
-    const methods = {};
-
-
-
-    Object.getOwnPropertyNames(Object.getPrototypeOf(service)).map((method) => {
-      if (method !== 'constructor' && typeof service[ method ] === 'function') {
-        methods[ method ] = service[ method ];
-      }
-    });
-
-    return new ServiceDefinition(service, utils.getServiceName(service), methods);
-  }*/
 }

src/scalecube-services/services/utils.js

@@ -1,7 +1,6 @@
 // @flow
 
 
-
 export const getServiceInterface = (o: Object) => {
   // we`ll have to think about this one... right new just a name
   return o.constructor.name;
@@ -12,7 +11,7 @@ export const getServiceName = (o: Object) => {
 export const isLoader = (inst: Object | null) => {
   return inst && inst.service && inst.service.meta && inst.service.meta.type === 'Loader';
 }
-export const makeLoader = (loadFunction: {promise:Promise<any>}, Class:any) => {
+export const makeLoader = (loadFunction: Promise<any>, Class: any) => {
   return {
     promise: loadFunction,
     meta: Object.assign(Class.meta, {

test/scalecube-services/services/greeting.test.js

@@ -34,7 +34,7 @@ describe('Greeting suite', () => {
       .create();
 
     expect.assertions(1);
-    return expect().rejects.toEqual(new Error("please provide user to greet"));
+    return expect(greetingService.hello()).rejects.toEqual(new Error("please provide user to greet"));
 
   });
   it('Greeting.repeatToStream should return observable of greetings ', () => {
@@ -95,7 +95,7 @@ describe('Greeting suite', () => {
       .api(GreetingService)
       .create();
 
-    expect.assertions(1);
+      expect.assertions(1);
     greetingService.repeatToStream('hey', 'hello').subscribe().unsubscribe();
     expect(window['repeatToStreamUnsubscribe']).toBe(true);
   });