@feathersjs/rest-client 5.0.0-pre.3 → 5.0.0-pre.30

package/src/base.ts

@@ -1,142 +1,178 @@
-import qs  from 'qs';
-import { Params, Id, Query, NullableId, ServiceInterface } from '@feathersjs/feathers';
-import { Unavailable, convert }  from '@feathersjs/errors';
-import { _, stripSlashes } from '@feathersjs/commons';
+import qs from 'qs'
+import { Params, Id, Query, NullableId, ServiceInterface } from '@feathersjs/feathers'
+import { Unavailable, convert } from '@feathersjs/errors'
+import { _, stripSlashes } from '@feathersjs/commons'
 
-function toError (error: Error & { code: string }) {
+function toError(error: Error & { code: string }) {
   if (error.code === 'ECONNREFUSED') {
-    throw new Unavailable(error.message, _.pick(error, 'address', 'port', 'config'));
+    throw new Unavailable(error.message, _.pick(error, 'address', 'port', 'config'))
   }
 
-  throw convert(error);
+  throw convert(error)
+}
+
+export interface RestClientParams extends Params {
+  connection?: any
 }
 
 interface RestClientSettings {
-  name: string;
-  base: string;
-  connection: any;
-  options: any;
+  name: string
+  base: string
+  connection: any
+  options: any
 }
 
-export abstract class Base<T = any, D = Partial<T>> implements ServiceInterface<T, D> {
-  name: string;
-  base: string;
-  connection: any;
-  options: any;
-
-  constructor (settings: RestClientSettings) {
-    this.name = stripSlashes(settings.name);
-    this.options = settings.options;
-    this.connection = settings.connection;
-    this.base = `${settings.base}/${this.name}`;
+export abstract class Base<T = any, D = Partial<T>, P extends Params = RestClientParams>
+  implements ServiceInterface<T, D, P>
+{
+  name: string
+  base: string
+  connection: any
+  options: any
+
+  constructor(settings: RestClientSettings) {
+    this.name = stripSlashes(settings.name)
+    this.options = settings.options
+    this.connection = settings.connection
+    this.base = `${settings.base}/${this.name}`
   }
 
-  makeUrl (query: Query, id?: string|number|null) {
-    let url = this.base;
+  makeUrl(query: Query, id?: string | number | null) {
+    let url = this.base
 
-    query = query || {};
+    query = query || {}
 
     if (typeof id !== 'undefined' && id !== null) {
-      url += `/${encodeURIComponent(id)}`;
+      url += `/${encodeURIComponent(id)}`
     }
 
-    return url + this.getQuery(query);
+    return url + this.getQuery(query)
   }
 
-  getQuery (query: Query) {
+  getQuery(query: Query) {
     if (Object.keys(query).length !== 0) {
-      const queryString = qs.stringify(query);
+      const queryString = qs.stringify(query)
 
-      return `?${queryString}`;
+      return `?${queryString}`
     }
 
-    return '';
+    return ''
   }
 
-  abstract request (options: any, params: Params): any;
+  abstract request(options: any, params: P): any
 
-  methods (this: any, ...names: string[]) {
-    names.forEach(method => {
+  methods(this: any, ...names: string[]) {
+    names.forEach((method) => {
       this[method] = function (body: any, params: Params = {}) {
-        return this.request({
-          body,
-          url: this.makeUrl(params.query),
-          method: 'POST',
-          headers: Object.assign({
-            'Content-Type': 'application/json',
-            'X-Service-Method': method
-          }, params.headers)
-        }, params).catch(toError);
+        return this.request(
+          {
+            body,
+            url: this.makeUrl(params.query),
+            method: 'POST',
+            headers: Object.assign(
+              {
+                'Content-Type': 'application/json',
+                'X-Service-Method': method
+              },
+              params.headers
+            )
+          },
+          params
+        ).catch(toError)
       }
-    });
+    })
 
-    return this;
+    return this
   }
 
-  find (params: Params = {}) {
-    return this.request({
-      url: this.makeUrl(params.query),
-      method: 'GET',
-      headers: Object.assign({}, params.headers)
-    }, params).catch(toError);
+  find(params?: P) {
+    return this.request(
+      {
+        url: this.makeUrl(params.query),
+        method: 'GET',
+        headers: Object.assign({}, params.headers)
+      },
+      params
+    ).catch(toError)
   }
 
-  get (id: Id, params: Params = {}) {
+  get(id: Id, params?: P) {
     if (typeof id === 'undefined') {
-      return Promise.reject(new Error('id for \'get\' can not be undefined'));
+      return Promise.reject(new Error("id for 'get' can not be undefined"))
     }
 
-    return this.request({
-      url: this.makeUrl(params.query, id),
-      method: 'GET',
-      headers: Object.assign({}, params.headers)
-    }, params).catch(toError);
+    return this.request(
+      {
+        url: this.makeUrl(params.query, id),
+        method: 'GET',
+        headers: Object.assign({}, params.headers)
+      },
+      params
+    ).catch(toError)
   }
 
-  create (body: D, params: Params = {}) {
-    return this.request({
-      url: this.makeUrl(params.query),
-      body,
-      method: 'POST',
-      headers: Object.assign({ 'Content-Type': 'application/json' }, params.headers)
-    }, params).catch(toError);
+  create(body: D, params?: P) {
+    return this.request(
+      {
+        url: this.makeUrl(params.query),
+        body,
+        method: 'POST',
+        headers: Object.assign({ 'Content-Type': 'application/json' }, params.headers)
+      },
+      params
+    ).catch(toError)
   }
 
-  update (id: NullableId, body: D, params: Params = {}) {
+  update(id: NullableId, body: D, params?: P) {
     if (typeof id === 'undefined') {
-      return Promise.reject(new Error('id for \'update\' can not be undefined, only \'null\' when updating multiple entries'));
+      return Promise.reject(
+        new Error("id for 'update' can not be undefined, only 'null' when updating multiple entries")
+      )
     }
 
-    return this.request({
-      url: this.makeUrl(params.query, id),
-      body,
-      method: 'PUT',
-      headers: Object.assign({ 'Content-Type': 'application/json' }, params.headers)
-    }, params).catch(toError);
+    return this.request(
+      {
+        url: this.makeUrl(params.query, id),
+        body,
+        method: 'PUT',
+        headers: Object.assign({ 'Content-Type': 'application/json' }, params.headers)
+      },
+      params
+    ).catch(toError)
   }
 
-  patch (id: NullableId, body: D, params: Params = {}) {
+  patch(id: NullableId, body: D, params?: P) {
     if (typeof id === 'undefined') {
-      return Promise.reject(new Error('id for \'patch\' can not be undefined, only \'null\' when updating multiple entries'));
+      return Promise.reject(
+        new Error("id for 'patch' can not be undefined, only 'null' when updating multiple entries")
+      )
     }
 
-    return this.request({
-      url: this.makeUrl(params.query, id),
-      body,
-      method: 'PATCH',
-      headers: Object.assign({ 'Content-Type': 'application/json' }, params.headers)
-    }, params).catch(toError);
+    return this.request(
+      {
+        url: this.makeUrl(params.query, id),
+        body,
+        method: 'PATCH',
+        headers: Object.assign({ 'Content-Type': 'application/json' }, params.headers)
+      },
+      params
+    ).catch(toError)
   }
 
-  remove (id: NullableId, params: Params = {}) {
+  remove(id: NullableId, params?: P) {
     if (typeof id === 'undefined') {
-      return Promise.reject(new Error('id for \'remove\' can not be undefined, only \'null\' when removing multiple entries'));
+      return Promise.reject(
+        new Error("id for 'remove' can not be undefined, only 'null' when removing multiple entries")
+      )
     }
 
-    return this.request({
-      url: this.makeUrl(params.query, id),
-      method: 'DELETE',
-      headers: Object.assign({}, params.headers)
-    }, params).catch(toError);
+    return this.request(
+      {
+        url: this.makeUrl(params.query, id),
+        method: 'DELETE',
+        headers: Object.assign({}, params.headers)
+      },
+      params
+    ).catch(toError)
   }
 }

package/src/fetch.ts

@@ -1,42 +1,49 @@
-import { Params } from '@feathersjs/feathers';
-import { errors } from '@feathersjs/errors';
-import { Base } from './base';
-
-export class FetchClient extends Base {
-  request (options: any, params: Params) {
-    const fetchOptions = Object.assign({}, options, params.connection);
-
-    fetchOptions.headers = Object.assign({
-      Accept: 'application/json'
-    }, this.options.headers, fetchOptions.headers);
+import { errors } from '@feathersjs/errors'
+import { Params } from '@feathersjs/feathers'
+import { Base, RestClientParams } from './base'
+
+export class FetchClient<T = any, D = Partial<T>, P extends Params = RestClientParams> extends Base<T, D, P> {
+  request(options: any, params: RestClientParams) {
+    const fetchOptions = Object.assign({}, options, params.connection)
+
+    fetchOptions.headers = Object.assign(
+      {
+        Accept: 'application/json'
+      },
+      this.options.headers,
+      fetchOptions.headers
+    )
 
     if (options.body) {
-      fetchOptions.body = JSON.stringify(options.body);
+      fetchOptions.body = JSON.stringify(options.body)
     }
 
     return this.connection(options.url, fetchOptions)
       .then(this.checkStatus)
       .then((response: any) => {
         if (response.status === 204) {
-          return null;
+          return null
         }
 
-        return response.json();
-      });
+        return response.json()
+      })
   }
 
-  checkStatus (response: any) {
+  checkStatus(response: any) {
     if (response.ok) {
-      return response;
+      return response
     }
 
-    return response.json().catch(() => {
-      const ErrorClass = (errors as any)[response.status] || Error;
-
-      return new ErrorClass('JSON parsing error');
-    }).then((error: any) => {
-      error.response = response;
-      throw error;
-    });
+    return response
+      .json()
+      .catch(() => {
+        const ErrorClass = (errors as any)[response.status] || Error
+
+        return new ErrorClass('JSON parsing error')
+      })
+      .then((error: any) => {
+        error.response = response
+        throw error
+      })
   }
 }

package/src/index.ts

@@ -1,80 +1,76 @@
-import { Base } from './base';
-import { AxiosClient } from './axios';
-import { FetchClient } from './fetch';
-import { SuperagentClient } from './superagent';
+import { Application, TransportConnection, defaultServiceMethods } from '@feathersjs/feathers'
 
-export { AxiosClient, FetchClient, SuperagentClient };
+import { Base } from './base'
+import { AxiosClient } from './axios'
+import { FetchClient } from './fetch'
+import { SuperagentClient } from './superagent'
+
+export { AxiosClient, FetchClient, SuperagentClient }
 
 const transports = {
   superagent: SuperagentClient,
   fetch: FetchClient,
   axios: AxiosClient
-};
-
-interface HandlerResult extends Function {
-  /**
-   * initialize service
-   */
-  (): void;
-
-  /**
-   * Transport Service
-   */
-  Service: any;
-
-  /**
-   * default Service
-   */
-  service: any;
 }
 
-export type Handler = (connection: any, options?: any, Service?: any) => HandlerResult;
+export type Handler<ServiceTypes> = (
+  connection: any,
+  options?: any,
+  Service?: any
+) => TransportConnection<ServiceTypes>
 
-export interface Transport {
-  superagent: Handler;
-  fetch: Handler;
-  axios: Handler;
+export interface Transport<ServiceTypes> {
+  superagent: Handler<ServiceTypes>
+  fetch: Handler<ServiceTypes>
+  axios: Handler<ServiceTypes>
 }
 
-export type RestService<T = any, D = Partial<any>> = Base<T, D>;
+export type RestService<T = any, D = Partial<any>> = Base<T, D>
 
-export default function restClient (base = '') {
-  const result: any = { Base };
+export default function restClient<ServiceTypes = any>(base = '') {
+  const result: any = { Base }
 
-  Object.keys(transports).forEach(key => {
+  Object.keys(transports).forEach((key) => {
     result[key] = function (connection: any, options: any = {}, Service: Base = (transports as any)[key]) {
       if (!connection) {
-        throw new Error(`${key} has to be provided to feathers-rest`);
+        throw new Error(`${key} has to be provided to feathers-rest`)
       }
 
       if (typeof options === 'function') {
-        Service = options;
-        options = {};
+        Service = options
+        options = {}
       }
 
       const defaultService = function (name: string) {
-        return new (Service as any)({ base, name, connection, options });
-      };
+        return new (Service as any)({ base, name, connection, options })
+      }
 
-      const initialize = (app: any) => {
+      const initialize = (app: Application & { rest: any }) => {
         if (app.rest !== undefined) {
-          throw new Error('Only one default client provider can be configured');
+          throw new Error('Only one default client provider can be configured')
         }
 
-        app.rest = connection;
-        app.defaultService = defaultService;
-      };
+        app.rest = connection
+        app.defaultService = defaultService
+        app.mixins.unshift((service, _location, options) => {
+          if (options && options.methods && service instanceof Base) {
+            const customMethods = options.methods.filter((name) => !defaultServiceMethods.includes(name))
+
+            service.methods(...customMethods)
+          }
+        })
+      }
 
-      initialize.Service = Service;
-      initialize.service = defaultService;
+      initialize.Service = Service
+      initialize.service = defaultService
 
-      return initialize;
-    };
-  });
+      return initialize
+    }
+  })
 
-  return result as Transport;
+  return result as Transport<ServiceTypes>
 }
 
 if (typeof module !== 'undefined') {
-  module.exports = Object.assign(restClient, module.exports);
+  module.exports = Object.assign(restClient, module.exports)
 }

package/src/superagent.ts

@@ -1,35 +1,39 @@
-import { Params } from '@feathersjs/feathers';
-import { Base } from './base';
+import { Params } from '@feathersjs/feathers'
+import { Base, RestClientParams } from './base'
 
-export class SuperagentClient extends Base {
-  request (options: any, params: Params) {
+export class SuperagentClient<T = any, D = Partial<T>, P extends Params = RestClientParams> extends Base<
+  T,
+  D,
+  P
+> {
+  request(options: any, params: RestClientParams) {
     const superagent = this.connection(options.method, options.url)
       .set(this.options.headers || {})
       .set('Accept', 'application/json')
       .set(params.connection || {})
       .set(options.headers || {})
-      .type(options.type || 'json');
+      .type(options.type || 'json')
 
     return new Promise((resolve, reject) => {
-      superagent.set(options.headers);
+      superagent.set(options.headers)
 
       if (options.body) {
-        superagent.send(options.body);
+        superagent.send(options.body)
       }
 
       superagent.end(function (error: any, res: any) {
         if (error) {
           try {
-            const response = error.response;
-            error = JSON.parse(error.response.text);
-            error.response = response;
-          } catch (e) {}
+            const response = error.response
+            error = JSON.parse(error.response.text)
+            error.response = response
+          } catch (e: any) {}
 
-          return reject(error);
+          return reject(error)
         }
 
-        resolve(res && res.body);
-      });
-    });
+        resolve(res && res.body)
+      })
+    })
   }
 }