fix(*): add createChannel() command (#20)

src/channel.spec.ts

@@ -1,13 +1,16 @@
 import { ChannelState, PermissionQuery } from '@proto/Mumble';
 import { Channel } from './channel';
+import { ChannelManager } from './channel-manager';
 import { Client } from './client';
+import { createChannel } from './commands';
 import { MumbleSocket } from './mumble-socket';
 
 jest.mock('./client');
 jest.mock('./commands', () => ({
   fetchChannelPermissions: jest
     .fn()
     .mockResolvedValue(PermissionQuery.create({ permissions: 0x1 | 0x40 })),
+  createChannel: jest.fn().mockResolvedValue(1),
 }));
 
 describe('Channel', () => {
@@ -20,6 +23,12 @@ describe('Channel', () => {
       username: 'FAKE_USERNAME',
     }) as jest.Mocked<Client>;
     client.socket = {} as MumbleSocket;
+    client.channels = {
+      byId: jest.fn().mockResolvedValue({}),
+      byName: jest.fn().mockResolvedValue({}),
+      byPath: jest.fn().mockResolvedValue({}),
+      findAll: jest.fn().mockReturnValue([]),
+    } as unknown as ChannelManager;
   });
 
   it('should assign properties', () => {
@@ -72,7 +81,11 @@ describe('Channel', () => {
 
     it('should attempt to create channel', async () => {
       await channel.createSubChannel('SUBCHANNEL_NAME');
-      expect(client.createChannel).toHaveBeenCalledWith(7, 'SUBCHANNEL_NAME');
+      expect(createChannel).toHaveBeenCalledWith(
+        client.socket,
+        7,
+        'SUBCHANNEL_NAME',
+      );
     });
   });
 

src/channel.ts

@@ -1,6 +1,7 @@
 import { ChannelState, PermissionQuery } from '@proto/Mumble';
 import { Client } from './client';
 import {
+  createChannel,
   fetchChannelPermissions,
   linkChannels,
   unlinkChannels,
@@ -64,12 +65,17 @@ export class Channel {
   }
 
   async createSubChannel(name: string): Promise<Channel> {
+    if (!this.client.socket) {
+      throw new Error('no socket');
+    }
+
     const permissions = await this.getPermissions();
     if (!permissions.canCreateChannel) {
       throw new InsufficientPermissionsError();
     }
 
-    return await this.client.createChannel(this.id, name);
+    const newChannelId = await createChannel(this.client.socket, this.id, name);
+    return this.client.channels.byId(newChannelId) as Channel;
   }
 
   async remove() {

src/client.ts

@@ -14,7 +14,6 @@ import {
 import {
   Authenticate,
   ChannelRemove,
-  ChannelState,
   PermissionDenied,
   Ping,
   Reject,
@@ -26,7 +25,6 @@ import {
 import { User } from './user';
 import { merge } from 'lodash';
 import { ChannelManager } from './channel-manager';
-import { Channel } from './channel';
 import { UserManager } from './user-manager';
 import EventEmitter from 'events';
 import { encodeMumbleVersion } from './encode-mumble-version';
@@ -121,41 +119,6 @@ export class Client extends EventEmitter {
     return this;
   }
 
-  async createChannel(parent: number, name: string): Promise<Channel> {
-    return new Promise((resolve, reject) => {
-      if (!this.socket) {
-        reject(new Error('no socket'));
-        return;
-      }
-
-      race(
-        this.socket.packet.pipe(
-          filterPacket(ChannelState),
-          filter(
-            channelState =>
-              channelState.parent === parent && channelState.name === name,
-          ),
-          take(1),
-        ),
-        this.socket.packet.pipe(filterPacket(PermissionDenied), take(1)),
-      ).subscribe(packet => {
-        if (PermissionDenied.is(packet)) {
-          const reason = packet.reason;
-          reject(new Error(`failed to create channel (${reason})`));
-        } else {
-          if (packet.channelId) {
-            const channel = this.channels.byId(packet.channelId);
-            if (channel) {
-              resolve(channel);
-            }
-          }
-        }
-      });
-
-      this.socket.send(ChannelState, ChannelState.create({ parent, name }));
-    });
-  }
-
   async removeChannel(channelId: number): Promise<void> {
     return new Promise((resolve, reject) => {
       if (!this.socket) {

src/commands/create-channel.ts

@@ -0,0 +1,36 @@
+import { PermissionDeniedError } from '@/errors';
+import { MumbleSocket } from '@/mumble-socket';
+import { filterPacket } from '@/rxjs-operators/filter-packet';
+import { ChannelState, PermissionDenied } from '@proto/Mumble';
+import { filter, race, take } from 'rxjs';
+
+export const createChannel = async (
+  socket: MumbleSocket,
+  parentChannelId: number,
+  channelName: string,
+): Promise<number> =>
+  new Promise((resolve, reject) => {
+    race(
+      socket.packet.pipe(
+        filterPacket(ChannelState),
+        filter(
+          channelState =>
+            channelState.parent === parentChannelId &&
+            channelState.name === channelName,
+        ),
+        take(1),
+      ),
+      socket.packet.pipe(filterPacket(PermissionDenied), take(1)),
+    ).subscribe(packet => {
+      if (PermissionDenied.is(packet)) {
+        reject(new PermissionDeniedError(packet));
+      } else {
+        resolve(packet.channelId as number);
+      }
+    });
+
+    socket.send(
+      ChannelState,
+      ChannelState.create({ parent: parentChannelId, name: channelName }),
+    );
+  });

src/commands/index.ts

@@ -1,3 +1,4 @@
+export { createChannel } from './create-channel';
 export { fetchChannelPermissions } from './fetch-channel-permissions';
 export { linkChannels } from './link-channels';
 export { unlinkChannels } from './unlink-channels';

src/errors/index.ts

@@ -1,3 +1,4 @@
 export { ConnectionRejectedError } from './connection-rejected.error';
 export { InsufficientPermissionsError } from './insufficient-permissions.error';
 export { NoSuchChannelError } from './no-such-channel.error';
+export { PermissionDeniedError } from './permission-denied.error';

src/errors/permission-denied.error.ts

@@ -0,0 +1,11 @@
+import { PermissionDenied } from '@proto/Mumble';
+
+export class PermissionDeniedError extends Error {
+  constructor(public readonly permissionDenied: PermissionDenied) {
+    let reason = 'permission denied';
+    if (permissionDenied.reason) {
+      reason = permissionDenied.reason;
+    }
+    super(reason);
+  }
+}