@feathersjs/transport-commons 5.0.0-pre.6 → 5.0.0

package/src/channels/channel/combined.ts

@@ -1,56 +1,57 @@
-import { Channel, RealTimeConnection } from './base';
+import { RealTimeConnection } from '@feathersjs/feathers'
+import { Channel } from './base'
 
-function collectConnections (children: Channel[]) {
-  const mappings = new WeakMap<RealTimeConnection, any>();
-  const connections: RealTimeConnection[] = [];
+function collectConnections(children: Channel[]) {
+  const mappings = new WeakMap<RealTimeConnection, any>()
+  const connections: RealTimeConnection[] = []
 
-  children.forEach(channel => {
-    channel.connections.forEach(connection => {
+  children.forEach((channel) => {
+    channel.connections.forEach((connection) => {
       if (!mappings.has(connection)) {
-        connections.push(connection);
-        mappings.set(connection, channel.data);
+        connections.push(connection)
+        mappings.set(connection, channel.data)
       }
-    });
-  });
+    })
+  })
 
-  return { connections, mappings };
+  return { connections, mappings }
 }
 
 export class CombinedChannel extends Channel {
-  children: Channel[];
-  mappings: WeakMap<RealTimeConnection, any>;
+  children: Channel[]
+  mappings: WeakMap<RealTimeConnection, any>
 
-  constructor (children: Channel[], data: any = null) {
-    const { mappings, connections } = collectConnections(children);
+  constructor(children: Channel[], data: any = null) {
+    const { mappings, connections } = collectConnections(children)
 
-    super(connections, data);
+    super(connections, data)
 
-    this.children = children;
-    this.mappings = mappings;
+    this.children = children
+    this.mappings = mappings
   }
 
-  refresh () {
-    const collected = collectConnections(this.children);
+  refresh() {
+    const collected = collectConnections(this.children)
 
-    return Object.assign(this, collected);
+    return Object.assign(this, collected)
   }
 
-  leave (...connections: RealTimeConnection[]) {
-    return this.callChildren('leave', connections);
+  leave(...connections: RealTimeConnection[]) {
+    return this.callChildren('leave', connections)
   }
 
-  join (...connections: RealTimeConnection[]) {
-    return this.callChildren('join', connections);
+  join(...connections: RealTimeConnection[]) {
+    return this.callChildren('join', connections)
   }
 
-  dataFor (connection: RealTimeConnection) {
-    return this.mappings.get(connection);
+  dataFor(connection: RealTimeConnection) {
+    return this.mappings.get(connection)
   }
 
-  private callChildren (method: string, connections: RealTimeConnection[]) {
-    this.children.forEach((child: any) => child[method](...connections));
-    this.refresh();
+  private callChildren(method: string, connections: RealTimeConnection[]) {
+    this.children.forEach((child: any) => child[method](...connections))
+    this.refresh()
 
-    return this;
+    return this
   }
 }

package/src/channels/index.ts

@@ -1,80 +1,83 @@
-import { Application, FeathersService, getServiceOptions } from '@feathersjs/feathers';
-import { createDebug } from '@feathersjs/commons';
-import { compact, flattenDeep, noop } from 'lodash';
-import { Channel, RealTimeConnection } from './channel/base';
-import { CombinedChannel } from './channel/combined';
-import { channelMixin, publishMixin, keys, PublishMixin, Event, Publisher } from './mixins';
-import EventEmitter from 'events';
+import { Application, FeathersService, RealTimeConnection, getServiceOptions } from '@feathersjs/feathers'
+import { createDebug } from '@feathersjs/commons'
+import { compact, flattenDeep, noop } from 'lodash'
+import { Channel } from './channel/base'
+import { CombinedChannel } from './channel/combined'
+import { channelMixin, publishMixin, keys, PublishMixin, Event, Publisher } from './mixins'
+import EventEmitter from 'events'
 
-const debug = createDebug('@feathersjs/transport-commons/channels');
-const { CHANNELS } = keys;
+const debug = createDebug('@feathersjs/transport-commons/channels')
+const { CHANNELS } = keys
 
 declare module '@feathersjs/feathers/lib/declarations' {
-  interface ServiceAddons<A, S> extends EventEmitter { // eslint-disable-line
-    publish (publisher: Publisher<ServiceGenericType<S>>): this;
-    publish (event: Event, publisher: Publisher<ServiceGenericType<S>>): this;
+  interface ServiceAddons<A, S> extends EventEmitter {
+    // eslint-disable-line
+    publish(publisher: Publisher<ServiceGenericType<S>, A, this>): this
+    publish(event: Event, publisher: Publisher<ServiceGenericType<S>, A, this>): this
 
-    registerPublisher (publisher: Publisher<ServiceGenericType<S>>): this;
-    registerPublisher (event: Event, publisher: Publisher<ServiceGenericType<S>>): this;
+    registerPublisher(publisher: Publisher<ServiceGenericType<S>, A, this>): this
+    registerPublisher(event: Event, publisher: Publisher<ServiceGenericType<S>, A, this>): this
   }
 
-  interface Application<ServiceTypes, AppSettings> { // eslint-disable-line
-    channels: string[];
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface Application<Services, Settings> {
+    // eslint-disable-line
+    channels: string[]
 
-    channel (name: string[]): Channel;
-    channel (...names: string[]): Channel;
+    channel(name: string | string[]): Channel
+    channel(...names: string[]): Channel
 
-    publish<T> (publisher: Publisher<T>): this;
-    publish<T> (event: Event, publisher: Publisher<T>): this;
+    publish<T>(publisher: Publisher<T, this>): this
+    publish<T>(event: Event, publisher: Publisher<T, this>): this
 
-    registerPublisher<T> (publisher: Publisher<T>): this;
-    registerPublisher<T> (event: Event, publisher: Publisher<T>): this;
+    registerPublisher<T>(publisher: Publisher<T, this>): this
+    registerPublisher<T>(event: Event, publisher: Publisher<T, this>): this
   }
 
   interface Params {
-    connection?: RealTimeConnection;
+    connection?: RealTimeConnection
   }
 }
 
-export { keys };
+export { keys }
 
-export function channels () {
+export function channels() {
   return (app: Application) => {
     if (typeof app.channel === 'function' && typeof app.publish === 'function') {
-      return;
+      return
     }
 
-    Object.assign(app, channelMixin(), publishMixin());
+    Object.assign(app, channelMixin(), publishMixin())
     Object.defineProperty(app, 'channels', {
-      get () {
-        return Object.keys(this[CHANNELS]);
+      get() {
+        return Object.keys(this[CHANNELS])
       }
-    });
+    })
 
-    app.mixins.push((service: FeathersService<any>, path: string) => {
-      const { serviceEvents } = getServiceOptions(service);
+    app.mixins.push((service: FeathersService, path: string) => {
+      const { serviceEvents } = getServiceOptions(service)
 
       if (typeof service.publish === 'function') {
-        return;
+        return
       }
 
-      Object.assign(service, publishMixin());
+      Object.assign(service, publishMixin())
 
       serviceEvents.forEach((event: string) => {
         service.on(event, function (data, hook) {
           if (!hook) {
             // Fake hook for custom events
-            hook = { path, service, app, result: data };
+            hook = { path, service, app, result: data }
           }
 
-          debug('Publishing event', event, hook.path);
+          debug('Publishing event', event, hook.path)
 
-          const logError = (error: any) => debug(`Error in '${hook.path} ${event}' publisher`, error);
-          const servicePublishers = (service as unknown as PublishMixin)[keys.PUBLISHERS];
-          const appPublishers = (app as unknown as PublishMixin)[keys.PUBLISHERS];
+          const logError = (error: any) => debug(`Error in '${hook.path} ${event}' publisher`, error)
+          const servicePublishers = (service as unknown as PublishMixin)[keys.PUBLISHERS]
+          const appPublishers = (app as unknown as PublishMixin)[keys.PUBLISHERS]
           // This will return the first publisher list that is not empty
           // In the following precedence
-          const publisher = (
+          const publisher =
             // 1. Service publisher for a specific event
             servicePublishers[event] ||
             // 2. Service publisher for all events
@@ -85,28 +88,31 @@ export function channels () {
             appPublishers[keys.ALL_EVENTS] ||
             // 5. No publisher
             noop
-          );
 
           try {
-            Promise.resolve(publisher(data, hook)).then((result: any) => {
-              if (!result) {
-                return;
-              }
-
-              const results = (Array.isArray(result) ? compact(flattenDeep(result)) : [result] as Channel[]);
-              const channel = new CombinedChannel(results);
-
-              if (channel && channel.length > 0) {
-                app.emit('publish', event, channel, hook, data);
-              } else {
-                debug('No connections to publish to');
-              }
-            }).catch(logError);
-          } catch (error) {
-            logError(error);
+            Promise.resolve(publisher(data, hook))
+              .then((result: any) => {
+                if (!result) {
+                  return
+                }
+
+                const results = Array.isArray(result) ? compact(flattenDeep(result)) : ([result] as Channel[])
+                const channel = new CombinedChannel(results)
+
+                if (channel && channel.length > 0) {
+                  app.emit('publish', event, channel, hook, data)
+                } else {
+                  debug('No connections to publish to')
+                }
+              })
+              .catch(logError)
+          } catch (error: any) {
+            logError(error)
           }
-        });
-      });
-    });
-  };
+        })
+      })
+    })
+  }
 }
+
+export { Channel, CombinedChannel, RealTimeConnection }

package/src/channels/mixins.ts

@@ -1,105 +1,108 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-import { HookContext, getServiceOptions } from '@feathersjs/feathers';
-import { createDebug } from '@feathersjs/commons';
-import { Channel } from './channel/base';
-import { CombinedChannel } from './channel/combined';
+import { Application, HookContext, getServiceOptions, defaultServiceEvents } from '@feathersjs/feathers'
+import { createDebug } from '@feathersjs/commons'
+import { Channel } from './channel/base'
+import { CombinedChannel } from './channel/combined'
 
-const debug = createDebug('@feathersjs/transport-commons:channels/mixins');
-const PUBLISHERS = Symbol('@feathersjs/transport-commons/publishers');
-const CHANNELS = Symbol('@feathersjs/transport-commons/channels');
-const ALL_EVENTS = Symbol('@feathersjs/transport-commons/all-events');
+const debug = createDebug('@feathersjs/transport-commons/channels/mixins')
+const PUBLISHERS = Symbol('@feathersjs/transport-commons/publishers')
+const CHANNELS = Symbol('@feathersjs/transport-commons/channels')
+const ALL_EVENTS = Symbol('@feathersjs/transport-commons/all-events')
 
 export const keys = {
   PUBLISHERS: PUBLISHERS as typeof PUBLISHERS,
   CHANNELS: CHANNELS as typeof CHANNELS,
   ALL_EVENTS: ALL_EVENTS as typeof ALL_EVENTS
-};
+}
 
 export interface ChannelMixin {
-  [CHANNELS]: { [key: string]: Channel };
-  channel (...names: string[]): Channel;
+  [CHANNELS]: { [key: string]: Channel }
+  channel(...names: string[]): Channel
 }
 
-export function channelMixin () {
+export function channelMixin() {
   const mixin: ChannelMixin = {
     [CHANNELS]: {},
 
-    channel (...names: string[]): Channel {
-      debug('Returning channels', names);
+    channel(...names: string[]): Channel {
+      debug('Returning channels', names)
 
       if (names.length === 0) {
-        throw new Error('app.channel needs at least one channel name');
+        throw new Error('app.channel needs at least one channel name')
       }
 
       if (names.length === 1) {
-        const [ name ] = names;
+        const [name] = names
 
         if (Array.isArray(name)) {
-          return this.channel(...name);
+          return this.channel(...name)
         }
 
         if (!this[CHANNELS][name]) {
-          const channel = new Channel();
+          const channel = new Channel()
 
           channel.once('empty', () => {
-            channel.removeAllListeners();
-            delete this[CHANNELS][name];
-          });
+            channel.removeAllListeners()
+            delete this[CHANNELS][name]
+          })
 
-          this[CHANNELS][name] = channel;
+          this[CHANNELS][name] = channel
         }
 
-        return this[CHANNELS][name];
+        return this[CHANNELS][name]
       }
 
-      const channels = names.map(name => this.channel(name));
+      const channels = names.map((name) => this.channel(name))
 
-      return new CombinedChannel(channels);
+      return new CombinedChannel(channels)
     }
-  };
+  }
 
-  return mixin;
+  return mixin
 }
 
-export type Event = string|(typeof ALL_EVENTS);
+export type Event = string | typeof ALL_EVENTS
 
-export type Publisher<T = any> = (data: T, context: HookContext<T>) => Channel | Channel[] | void | Promise<Channel | Channel[] | void>;
+export type Publisher<T = any, A = Application, S = any> = (
+  data: T,
+  context: HookContext<A, S>
+) => Channel | Channel[] | void | Promise<Channel | Channel[] | void>
 
 export interface PublishMixin<T = any> {
-  [PUBLISHERS]: { [ALL_EVENTS]?: Publisher<T>, [key: string]: Publisher<T> };
-  publish (event: Event, publisher: Publisher<T>): this;
-  registerPublisher (event: Event, publisher: Publisher<T>): this;
+  [PUBLISHERS]: { [ALL_EVENTS]?: Publisher<T>; [key: string]: Publisher<T> }
+  publish(event: Event, publisher: Publisher<T>): this
+  registerPublisher(event: Event, publisher: Publisher<T>): this
 }
 
-export function publishMixin () {
+export function publishMixin() {
   const result: PublishMixin = {
     [PUBLISHERS]: {},
 
-    publish (...args) {
-      return this.registerPublisher(...args);
+    publish(...args) {
+      return this.registerPublisher(...args)
     },
 
-    registerPublisher (event, publisher) {
-      debug('Registering publisher', event);
+    registerPublisher(event, publisher) {
+      debug('Registering publisher', event)
 
       if (!publisher && typeof event === 'function') {
-        publisher = event;
-        event = ALL_EVENTS;
+        publisher = event
+        event = ALL_EVENTS
       }
 
-      const { serviceEvents } = getServiceOptions(this);
+      const { serviceEvents = defaultServiceEvents } = getServiceOptions(this) || {}
 
       if (event !== ALL_EVENTS && !serviceEvents.includes(event)) {
-        throw new Error(`'${event.toString()}' is not a valid service event`);
+        throw new Error(`'${event.toString()}' is not a valid service event`)
       }
 
-      const publishers = this[PUBLISHERS];
+      const publishers = this[PUBLISHERS]
 
-      publishers[event] = publisher;
+      publishers[event] = publisher
 
-      return this;
+      return this
     }
-  };
+  }
 
-  return result;
+  return result
 }

package/src/client.ts

@@ -1,11 +1,13 @@
-import { convert } from '@feathersjs/errors';
-import { createDebug } from '@feathersjs/commons';
-import { Id, NullableId, Params, ServiceInterface } from '@feathersjs/feathers';
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { convert } from '@feathersjs/errors'
+import { createDebug } from '@feathersjs/commons'
+import { Id, NullableId, Params, ServiceInterface } from '@feathersjs/feathers'
 
-const debug = createDebug('@feathersjs/transport-commons/client');
+const debug = createDebug('@feathersjs/transport-commons/client')
 
 const namespacedEmitterMethods = [
   'addListener',
+  'addEventListener',
   'emit',
   'listenerCount',
   'listeners',
@@ -14,128 +16,126 @@ const namespacedEmitterMethods = [
   'prependListener',
   'prependOnceListener',
   'removeAllListeners',
+  'removeEventListener',
   'removeListener'
-];
-const otherEmitterMethods = [
-  'eventNames',
-  'getMaxListeners',
-  'setMaxListeners'
-];
+]
+const otherEmitterMethods = ['eventNames', 'getMaxListeners', 'setMaxListeners']
 
 const addEmitterMethods = (service: any) => {
-  otherEmitterMethods.forEach(method => {
+  otherEmitterMethods.forEach((method) => {
     service[method] = function (...args: any[]) {
       if (typeof this.connection[method] !== 'function') {
-        throw new Error(`Can not call '${method}' on the client service connection`);
+        throw new Error(`Can not call '${method}' on the client service connection`)
       }
 
-      return this.connection[method](...args);
-    };
-  });
+      return this.connection[method](...args)
+    }
+  })
 
   // Methods that should add the namespace (service path)
-  namespacedEmitterMethods.forEach(method => {
+  namespacedEmitterMethods.forEach((method) => {
     service[method] = function (name: string, ...args: any[]) {
       if (typeof this.connection[method] !== 'function') {
-        throw new Error(`Can not call '${method}' on the client service connection`);
+        throw new Error(`Can not call '${method}' on the client service connection`)
       }
 
-      const eventName = `${this.path} ${name}`;
+      const eventName = `${this.path} ${name}`
 
-      debug(`Calling emitter method ${method} with ` +
-        `namespaced event '${eventName}'`);
+      debug(`Calling emitter method ${method} with ` + `namespaced event '${eventName}'`)
 
-      const result = this.connection[method](eventName, ...args);
+      const result = this.connection[method](eventName, ...args)
 
-      return result === this.connection ? this : result;
-    };
-  });
-};
+      return result === this.connection ? this : result
+    }
+  })
+}
 
 interface ServiceOptions {
-  name: string;
-  connection: any;
-  method: string;
-  events?: string[];
+  name: string
+  connection: any
+  method: string
+  events?: string[]
 }
 
-export type SocketService<T = any, D = Partial<any>> = Service<T, D>;
+export type SocketService<T = any, D = Partial<any>, P extends Params = Params> = Service<T, D, P>
 
-export class Service<T = any, D = Partial<T>> implements ServiceInterface<T, D> {
-  events: string[];
-  path: string;
-  connection: any;
-  method: string;
+export class Service<T = any, D = Partial<T>, P extends Params = Params>
+  implements ServiceInterface<T, D, P>
+{
+  events: string[]
+  path: string
+  connection: any
+  method: string
 
-  constructor (options: ServiceOptions) {
-    this.events = options.events;
-    this.path = options.name;
-    this.connection = options.connection;
-    this.method = options.method;
+  constructor(options: ServiceOptions) {
+    this.events = options.events
+    this.path = options.name
+    this.connection = options.connection
+    this.method = options.method
 
-    addEmitterMethods(this);
+    addEmitterMethods(this)
   }
 
-  send<X = any> (method: string, ...args: any[]) {
+  send<X = any>(method: string, ...args: any[]) {
     return new Promise<X>((resolve, reject) => {
-      args.unshift(method, this.path);
+      args.unshift(method, this.path)
       args.push(function (error: any, data: any) {
-        return error ? reject(convert(error)) : resolve(data);
-      });
+        return error ? reject(convert(error)) : resolve(data)
+      })
 
-      debug(`Sending socket.${this.method}`, args);
+      debug(`Sending socket.${this.method}`, args)
 
-      this.connection[this.method](...args);
-    });
+      this.connection[this.method](...args)
+    })
   }
 
-  methods (this: any, ...names: string[]) {
-    names.forEach(name => {
+  methods(this: any, ...names: string[]) {
+    names.forEach((name) => {
       this[name] = function (data: any, params: Params = {}) {
-        return this.send(name, data, params.query || {});
+        return this.send(name, data, params.query || {})
       }
-    });
-    return this;
+    })
+    return this
   }
 
-  find (params: Params = {}) {
-    return this.send<T|T[]>('find', params.query || {});
+  find(params: Params = {}) {
+    return this.send<T | T[]>('find', params.query || {})
   }
 
-  get (id: Id, params: Params = {}) {
-    return this.send<T>('get', id, params.query || {});
+  get(id: Id, params: Params = {}) {
+    return this.send<T>('get', id, params.query || {})
   }
 
-  create (data: any, params: Params = {}) {
-    return this.send<T>('create', data, params.query || {});
+  create(data: any, params: Params = {}) {
+    return this.send<T>('create', data, params.query || {})
   }
 
-  update (id: Id, data: any, params: Params = {}) {
-    return this.send<T> ('update', id, data, params.query || {});
+  update(id: Id, data: any, params: Params = {}) {
+    return this.send<T>('update', id, data, params.query || {})
   }
 
-  patch (id: NullableId, data: any, params: Params = {}) {
-    return this.send<T|T[]> ('patch', id, data, params.query || {});
+  patch(id: NullableId, data: any, params: Params = {}) {
+    return this.send<T | T[]>('patch', id, data, params.query || {})
   }
 
-  remove (id: NullableId, params: Params = {}) {
-    return this.send<T|T[]> ('remove', id, params.query || {});
+  remove(id: NullableId, params: Params = {}) {
+    return this.send<T | T[]>('remove', id, params.query || {})
   }
 
   // `off` is actually not part of the Node event emitter spec
   // but we are adding it since everybody is expecting it because
   // of the emitter-component Socket.io is using
-  off (name: string, ...args: any[]) {
+  off(name: string, ...args: any[]) {
     if (typeof this.connection.off === 'function') {
-      const result = this.connection.off(`${this.path} ${name}`, ...args);
+      const result = this.connection.off(`${this.path} ${name}`, ...args)
 
-      return result === this.connection ? this : result;
+      return result === this.connection ? this : result
     } else if (args.length === 0) {
       // @ts-ignore
-      return this.removeAllListeners(name);
+      return this.removeAllListeners(name)
     }
 
     // @ts-ignore
-    return this.removeListener(name, ...args);
+    return this.removeListener(name, ...args)
   }
 }