Remove native clients

Closes codeoverflow-org#91 and removes the whole concept of native clients as disscussed there and on Discord.
Previously simplifications are now added by extending the original client and adding these methods in a subclass.

Other changes in this PR:
- rcon: Remove `sendMessage(msg: string)`, use `send(msg: string)` instead.
- twitch-chat: Rename `TwitchServiceClient` to `TwitchChatServiceClient` because of naming convention
- twitch-pubsub: Rename `PubSubServiceClient` to `TwitchPubSubServiceClient` because of naming convention

Author: hlxid

nodecg-io-ahk/extension/index.ts

@@ -1,13 +1,13 @@
 import { NodeCG } from "nodecg/types/server";
-import { Result, emptySuccess, success, ServiceBundle, ServiceClient } from "nodecg-io-core";
+import { Result, emptySuccess, success, ServiceBundle } from "nodecg-io-core";
 import { AHK } from "./AHK";
 
 interface AHKServiceConfig {
     host: string;
     port: number;
 }
 
-export type AHKServiceClient = ServiceClient<AHK>;
+export type AHKServiceClient = AHK;
 
 module.exports = (nodecg: NodeCG) => {
     new AhkService(nodecg, "ahk", __dirname, "../ahk-schema.json").register();
@@ -22,11 +22,7 @@ class AhkService extends ServiceBundle<AHKServiceConfig, AHKServiceClient> {
 
     async createClient(config: AHKServiceConfig): Promise<Result<AHKServiceClient>> {
         const ahk = new AHK(this.nodecg, config.host, config.port);
-        return success({
-            getNativeClient() {
-                return ahk;
-            },
-        });
+        return success(ahk);
     }
 
     stopClient() {

nodecg-io-android/extension/index.ts

@@ -1,12 +1,12 @@
 import { NodeCG } from "nodecg/types/server";
-import { Result, emptySuccess, success, ServiceBundle, ServiceClient } from "nodecg-io-core";
+import { Result, emptySuccess, success, ServiceBundle } from "nodecg-io-core";
 import { Android } from "./android";
 
 interface AndroidServiceConfig {
     device: string;
 }
 
-export type AndroidServiceClient = ServiceClient<Android>;
+export type AndroidServiceClient = Android;
 
 module.exports = (nodecg: NodeCG) => {
     new AndroidService(nodecg, "android", __dirname, "../android-schema.json").register();
@@ -24,17 +24,12 @@ class AndroidService extends ServiceBundle<AndroidServiceConfig, AndroidServiceC
         const client = new Android(this.nodecg, config.device);
         await client.connect();
         this.nodecg.log.info("Successfully connected to adb.");
-        return success({
-            getNativeClient() {
-                return client;
-            },
-        });
+        return success(client);
     }
 
     async stopClient(client: AndroidServiceClient): Promise<void> {
         try {
-            const rawClient = client.getNativeClient();
-            await rawClient.disconnect();
+            await client.disconnect();
         } catch (err) {
             this.nodecg.log.error(err);
             // Do nothing. If we did not catch it it'd cause an infinite loop.

nodecg-io-core/extension/bundleManager.ts

@@ -1,5 +1,5 @@
 import { NodeCG } from "nodecg/types/server";
-import { ObjectMap, Service, ServiceClient, ServiceDependency, ServiceInstance } from "./types";
+import { ObjectMap, Service, ServiceDependency, ServiceInstance } from "./types";
 import { emptySuccess, error, Result } from "./utils/result";
 import { EventEmitter } from "events";
 
@@ -27,7 +27,7 @@ export class BundleManager extends EventEmitter {
      * @param service the service that the bundle depends upon.
      * @param clientUpdate the callback that should be called if a client becomes available or gets updated.
      */
-    registerServiceDependency<C extends ServiceClient<unknown>>(
+    registerServiceDependency<C>(
         bundleName: string,
         service: Service<unknown, C>,
         clientUpdate: (client?: C) => void,

nodecg-io-core/extension/index.ts

@@ -3,7 +3,7 @@ import { ServiceManager } from "./serviceManager";
 import { BundleManager } from "./bundleManager";
 import { MessageManager } from "./messageManager";
 import { InstanceManager } from "./instanceManager";
-import { Service, ServiceClient } from "./types";
+import { Service } from "./types";
 import { PersistenceManager } from "./persistenceManager";
 import { ServiceClientWrapper } from "./serviceClientWrapper";
 
@@ -12,11 +12,8 @@ import { ServiceClientWrapper } from "./serviceClientWrapper";
  * Contains references to all internal modules.
  */
 export interface NodeCGIOCore {
-    registerService<R, C extends ServiceClient<unknown>>(service: Service<R, C>): void;
-    requireService<C extends ServiceClient<unknown>>(
-        nodecg: NodeCG,
-        serviceType: string,
-    ): ServiceClientWrapper<C> | undefined;
+    registerService<R, C>(service: Service<R, C>): void;
+    requireService<C>(nodecg: NodeCG, serviceType: string): ServiceClientWrapper<C> | undefined;
 }
 
 module.exports = (nodecg: NodeCG): NodeCGIOCore => {
@@ -40,13 +37,10 @@ module.exports = (nodecg: NodeCG): NodeCGIOCore => {
     // We use a extra object instead of returning a object containing all the managers and so on, because
     // any loaded bundle would be able to call any (public or private) of the managers which is not intended.
     return {
-        registerService<R, C extends ServiceClient<unknown>>(service: Service<R, C>): void {
+        registerService<R, C>(service: Service<R, C>): void {
             serviceManager.registerService(service);
         },
-        requireService<C extends ServiceClient<unknown>>(
-            nodecg: NodeCG,
-            serviceType: string,
-        ): ServiceClientWrapper<C> | undefined {
+        requireService<C>(nodecg: NodeCG, serviceType: string): ServiceClientWrapper<C> | undefined {
             const bundleName = nodecg.bundleName;
             const svc = serviceManager.getService(serviceType);
 

nodecg-io-core/extension/instanceManager.ts

@@ -1,5 +1,5 @@
 import { NodeCG } from "nodecg/types/server";
-import { ObjectMap, Service, ServiceClient, ServiceInstance } from "./types";
+import { ObjectMap, Service, ServiceInstance } from "./types";
 import { emptySuccess, error, Result } from "./utils/result";
 import { ServiceManager } from "./serviceManager";
 import { BundleManager } from "./bundleManager";
@@ -179,7 +179,7 @@ export class InstanceManager extends EventEmitter {
      * @param instanceName the name of the service instance, used for letting all bundles know of the new client.
      * @param service the service of the service instance, needed to stop old client
      */
-    private async updateInstanceClient<R, C extends ServiceClient<unknown>>(
+    private async updateInstanceClient<R, C>(
         inst: ServiceInstance<R, C>,
         instanceName: string,
         service: Service<R, C>,

nodecg-io-core/extension/serviceBundle.ts

@@ -1,6 +1,6 @@
 import { NodeCGIOCore } from ".";
 import { NodeCG } from "nodecg/types/server";
-import { Service, ServiceClient } from "./types";
+import { Service } from "./types";
 import { Result } from "./utils/result";
 
 import * as fs from "fs";
@@ -14,7 +14,7 @@ import * as path from "path";
  *              Intended to hold configurations and authentication information that the service needs to provide a client.
  * @typeParam C the type of a client that the service will provide to bundles using {@link createClient}.
  */
-export abstract class ServiceBundle<R, C extends ServiceClient<unknown>> implements Service<R, C> {
+export abstract class ServiceBundle<R, C> implements Service<R, C> {
     public core: NodeCGIOCore | undefined;
     public nodecg: NodeCG;
     public serviceType: string;

nodecg-io-core/extension/serviceClientWrapper.ts

@@ -1,14 +1,13 @@
 import { EventEmitter } from "events";
 import { NodeCGIOCore } from "./index";
 import { NodeCG } from "nodecg/types/server";
-import { ServiceClient } from "./types";
 
 /**
  * A wrapper around a ServiceClient that has helper functions for setting up callbacks and
  * a function which just returns the current ServiceClient.
  * This class gets its client updates through the framework, namely using the {@link ServiceDependency.clientUpdateCallback}.
  */
-export class ServiceClientWrapper<C extends ServiceClient<unknown>> extends EventEmitter {
+export class ServiceClientWrapper<C> extends EventEmitter {
     private currentClient: C | undefined;
 
     constructor() {
@@ -62,10 +61,7 @@ export class ServiceClientWrapper<C extends ServiceClient<unknown>> extends Even
  * @return {ServiceClientWrapper<C> | undefined} a service client wrapper for access to the service client
  *                                               or undefined if the core wasn't loaded or the service type doesn't exist.
  */
-export function requireService<C extends ServiceClient<unknown>>(
-    nodecg: NodeCG,
-    serviceType: string,
-): ServiceClientWrapper<C> | undefined {
+export function requireService<C>(nodecg: NodeCG, serviceType: string): ServiceClientWrapper<C> | undefined {
     const core = (nodecg.extensions["nodecg-io-core"] as unknown) as NodeCGIOCore | undefined;
     if (core === undefined) {
         nodecg.log.error(

nodecg-io-core/extension/serviceManager.ts

@@ -1,4 +1,4 @@
-import { Service, ServiceClient } from "./types";
+import { Service } from "./types";
 import { NodeCG } from "nodecg/types/server";
 import { error, Result, success } from "./utils/result";
 
@@ -16,7 +16,7 @@ export class ServiceManager {
      * Registers the passed service which show it in the GUI and allows it to be instanced using {@link createServiceInstance}.
      * @param service the service you want to register.
      */
-    registerService<R, C extends ServiceClient<unknown>>(service: Service<R, C>): void {
+    registerService<R, C>(service: Service<R, C>): void {
         this.services.push(service);
         this.nodecg.log.info(`Service ${service.serviceType} has been registered.`);
     }

nodecg-io-core/extension/types.d.ts

@@ -129,13 +129,3 @@ export interface ServiceDependency<C> {
      */
     readonly clientUpdateCallback(client?: C): void;
 }
-
-/**
- * A common interface between all service clients.
- * Currently this only ensures that all services allow access to the underlying client
- * by providing a getNativeClient() function.
- * @typeParam T the type of the underlying client.
- */
-export interface ServiceClient<T> {
-    getNativeClient(): T;
-}

nodecg-io-core/index.ts

@@ -2,7 +2,7 @@
 // This can be used by services and bundles to import everything by just using "nodecg-io-core" and they don't need to know paths
 // or where the thing they want to import is located.
 // You can obviously still provide the full path if you wish.
-export type { ObjectMap, Service, ServiceClient, ServiceDependency, ServiceInstance } from "./extension/types";
+export type { ObjectMap, Service, ServiceDependency, ServiceInstance } from "./extension/types";
 export * from "./extension/utils/result";
 export { ServiceBundle } from "./extension/serviceBundle";
 export { requireService } from "./extension/serviceClientWrapper";