TCP sockets support implemented (breaking changes).

ServeMeClient constructor now takes single ServeMeSocket argument.

Future<ServeMeClient> ServeMe.connect() method added allowing to create WebSocket or TCP client connections (with the same functionality as server client connections).

Author: Mad Sheogorath

CHANGELOG.md

@@ -1,3 +1,8 @@
+## v1.1.0
+* TCP sockets support implemented (breaking changes).
+* ServeMeClient constructor now takes single ServeMeSocket argument.
+* Future<ServeMeClient> ServeMe.connect() method added allowing to create WebSocket or TCP client connections (with the same functionality as server client connections).
+
 ## v1.0.2
 * Bugfix: ESC key press caused ServeMe to crash on Linux
 

README.md

@@ -1,6 +1,7 @@
 ## What is ServeMe
 ServeMe is a simple and powerful modular server framework. It allows to easily create backend services for both mobile and web applications. Here are some of the features provided by ServeMe framework:
 * modular architecture allows to easily implement separate parts of the server using ServeMe Modular API;
+* both WebSockets and TCP sockets are supported (TCP sockets support implemented in v1.1.0);
 * MongoDB support out of the box, automatic database integrity validation for easy server deployment;
 * events API allows to dispatch and listen to any built-in or custom events in your application;
 * scheduler API allows to create different tasks and schedule its' execution time and period;
@@ -92,6 +93,21 @@ class AnotherModule extends Module<ServeMeClient> {
 ```
 And don't forget to enable your newly implemented modules in configuration file. 
 
+## WebSockets and TCP sockets
+ServeMe is using WebSockets by default. However it can handle pure TCP sockets as well:
+```dart
+Future<void> main() async {
+    final ServeMe<ServeMeClient> server = ServeMe<ServeMeClient>(
+        type: ServeMeType.tcp,
+        modules: <String, Module<ServeMeClient>>{
+            'mymodule': MyModule(),
+        },
+    );
+    await server.run();
+}
+```
+Keep in mind that String messages you will try to send via TCP sockets will be converted to Uint8List. So in order to receive String via TCP socket you need to use listen<Uint8List>() instead of listen<String>(). 
+
 ## Configuration files
 By default ServeMe uses config.yaml file and ServeMeConfig class for instantiating config object accessible from any module. However it is possible to implement and use custom configuration class.
 ```dart
@@ -154,8 +170,8 @@ You probably already noticed that both classes ServeMe and Module have generic c
 import 'dart:io';
 
 class MyClient extends ServeMeClient {
-    MyClient(WebSocket socket, HttpHeaders headers) : super(socket, headers) {
-        authToken = headers.value('x-auth-token');
+    MyClient(ServeMeSocket socket) : super(socket) {
+        authToken = socket.httpRequest!.headers.value('x-auth-token');
     }
 
     late final String? authToken;

example/example.dart

@@ -1,5 +1,4 @@
 import 'dart:async';
-import 'dart:io';
 import 'dart:math' show Random;
 import 'package:serveme/serveme.dart';
 
@@ -63,8 +62,8 @@ class MehConfig extends Config {
 /// functionality such as user authorization etc.
 
 class MehClient extends ServeMeClient {
-	MehClient(WebSocket socket, HttpHeaders headers) : super(socket, headers) {
-		userIsLocal = headers.host == '127.0.0.1';
+	MehClient(ServeMeSocket socket) : super(socket) {
+		userIsLocal = socket.httpRequest!.headers.host == '127.0.0.1';
 	}
 
 	late final bool userIsLocal;
@@ -211,7 +210,7 @@ Future<void> main() async {
 		/// Tell server to use our own Config class.
 		configFactory: (_) => MehConfig(_),
 		/// Tell server to use our own Client class.
-		clientFactory: (_, __) => MehClient(_, __),
+		clientFactory: (_) => MehClient(_),
 		/// Pass our modules to server (don't forget to enable them in config).
 		modules: <String, Module<MehClient>>{
 			'meh': MehModule()

lib/serveme.dart

@@ -19,17 +19,20 @@ part 'core/scheduler.dart';
 part 'core/utils.dart';
 
 typedef ServeMeClient = ConnectMeClient;
+typedef ServeMeSocket = ConnectMeSocket;
+typedef ServeMeType = ConnectMeType;
 
 final bool _unixSocketsAvailable = Platform.isLinux || Platform.isAndroid || Platform.isMacOS;
 
 class ServeMe<C extends ServeMeClient> {
 	ServeMe({
 		String configFile = 'config.yaml',
+		ServeMeType type = ServeMeType.ws,
 		Config Function(String filename)? configFactory,
-		C Function(WebSocket, HttpHeaders)? clientFactory,
+		C Function(ServeMeSocket)? clientFactory,
 		Map<String, Module<C>>? modules,
 		Map<String, CollectionDescriptor>? dbIntegrityDescriptor,
-	}) : _clientFactory = clientFactory, _dbIntegrityDescriptor = dbIntegrityDescriptor {
+	}) : _type = type, _clientFactory = clientFactory, _dbIntegrityDescriptor = dbIntegrityDescriptor {
 		config = Config._instantiate(configFile, factory: configFactory);
 		console = Console(this);
 		_logger = Logger(this);
@@ -47,6 +50,7 @@ class ServeMe<C extends ServeMeClient> {
 			: InternetAddress(config._host ?? '127.0.0.1', type: InternetAddressType.IPv4);
 		_cmServer = ConnectMe.server(address,
 			port: config._port ?? 0,
+			type: _type,
 			clientFactory: _clientFactory,
 			onLog: log,
 			onError: error,
@@ -63,9 +67,10 @@ class ServeMe<C extends ServeMeClient> {
 	late final Logger _logger;
 	late final Scheduler _scheduler;
 	late final ConnectMeServer<C> _cmServer;
+	final ServeMeType _type;
 	MongoDbConnection? _mongo;
 	final Map<String, Module<C>> _modules = <String, Module<C>>{};
-	final C Function(WebSocket, HttpHeaders)? _clientFactory;
+	final C Function(ServeMeSocket)? _clientFactory;
 	final Map<String, CollectionDescriptor>? _dbIntegrityDescriptor;
 	ProcessSignal? _signalReceived;
 	Timer? _signalTimer;
@@ -148,6 +153,25 @@ class ServeMe<C extends ServeMeClient> {
 		_cmServer.cancel<T>(handler);
 	}
 
+	Future<ServeMeClient> connect(dynamic address, {
+		Map<String, dynamic> headers = const <String, dynamic>{},
+		int port = 0,
+		bool autoReconnect = true,
+		int queryTimeout = 30,
+		Function()? onConnect,
+		Function()? onDisconnect,
+	}) {
+		return ConnectMe.connect(address,
+			port: port,
+			autoReconnect: autoReconnect,
+			queryTimeout: queryTimeout,
+			onLog: log,
+			onError: error,
+			onConnect: onConnect,
+			onDisconnect: onDisconnect,
+		);
+	}
+
 	Future<bool> run() async {
 		if (_running) return false;
 		log('Server start initiated');

pubspec.yaml

@@ -1,6 +1,6 @@
 name: serveme
 description: Backend server framework designed for a quick development of modular WebSocket based server applications with MongoDB integration.
-version: 1.0.2
+version: 1.1.0
 homepage: https://github.com/sourcecaster/serveme
 repository: https://github.com/sourcecaster/serveme
 issue_tracker: https://github.com/sourcecaster/serveme/issues
@@ -10,7 +10,7 @@ environment:
 dependencies:
   mongo_dart: ^0.7.0+2
   yaml: ^3.1.0
-  connectme: ^1.1.1
+  connectme: ^2.0.1
   packme: ^1.1.5
 dev_dependencies:
   test: ^1.17.11

test/serveme_test.dart

@@ -1,12 +1,14 @@
 import 'dart:async';
-import 'dart:io';
+import 'dart:convert';
 import 'dart:typed_data';
 import 'package:connectme/connectme.dart';
 import 'package:serveme/serveme.dart';
 import 'package:test/test.dart';
 import 'generated/test.generated.dart';
 import 'modules/test.dart';
 
+const Utf8Codec _utf8 = Utf8Codec();
+
 void main() {
     late ServeMe<ServeMeClient> server;
     late ConnectMeClient client;
@@ -38,7 +40,7 @@ void main() {
         });
     });
 
-    group('ServeMe data exchange tests', () {
+    group('ServeMe WebSocket data exchange tests', () {
         setUp(() async {
             timer = Timer(const Duration(seconds: 2), () => fail('Operation timed out'));
             server = ServeMe<ServeMeClient>(
@@ -114,6 +116,85 @@ void main() {
         });
     });
 
+    group('ServeMe TCP data exchange tests', () {
+        setUp(() async {
+            timer = Timer(const Duration(seconds: 2), () => fail('Operation timed out'));
+            server = ServeMe<ServeMeClient>(
+                type: ServeMeType.tcp,
+                configFile: 'test/config_test.yaml',
+                modules: <String, Module<ServeMeClient>>{
+                    'test': module = TestModule(),
+                },
+            );
+            await server.run();
+            client = await ConnectMe.connect('127.0.0.1', port: 31337);
+        });
+
+        tearDown(() async {
+            await client.close();
+            await server.stop();
+            timer.cancel();
+        });
+
+        test('Client sends String to server', () async {
+            final Completer<Uint8List> completer = Completer<Uint8List>();
+            server.listen<Uint8List>((Uint8List message, ConnectMeClient client) async {
+                completer.complete(message);
+            });
+            client.send('Test message from client');
+            final List<int> expected = _utf8.encode('Test message from client');
+            expect(await completer.future, expected);
+        });
+
+        test('Server broadcasts String to clients', () async {
+            final Completer<Uint8List> completer = Completer<Uint8List>();
+            client.listen<Uint8List>((Uint8List message) {
+                completer.complete(message);
+            });
+            server.broadcast('Test message from server');
+            final List<int> expected = _utf8.encode('Test message from server');
+            expect(await completer.future, expected);
+        });
+
+        test('Client sends Uint8List to server', () async {
+            final Completer<Uint8List> completer = Completer<Uint8List>();
+            server.listen<Uint8List>((Uint8List message, ConnectMeClient client) async {
+                completer.complete(message);
+            });
+            client.send(Uint8List.fromList(<int>[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]));
+            expect(await completer.future, Uint8List.fromList(<int>[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]));
+        });
+
+        test('Server broadcasts Uint8List to clients', () async {
+            final Completer<Uint8List> completer = Completer<Uint8List>();
+            client.listen<Uint8List>((Uint8List message) {
+                completer.complete(message);
+            });
+            server.broadcast(Uint8List.fromList(<int>[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]));
+            expect(await completer.future, Uint8List.fromList(<int>[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]));
+        });
+
+        test('Client sends TestResponse query to server', () async {
+            server.register(testMessageFactory);
+            server.listen<TestRequest>((TestRequest request, ConnectMeClient client) async {
+                client.send(request.$response(responseParam: request.requestParam));
+            });
+            client.register(testMessageFactory);
+            final TestResponse response = await client.query<TestResponse>(TestRequest(requestParam: 3.1415926535));
+            expect(response.responseParam, 3.1415926535);
+        });
+
+        test('Server sends TestResponse query to client', () async {
+            client.register(testMessageFactory);
+            client.listen<TestRequest>((TestRequest request) {
+                client.send(request.$response(responseParam: request.requestParam));
+            });
+            server.register(testMessageFactory);
+            final TestResponse response = await server.clients.first.query<TestResponse>(TestRequest(requestParam: 3.1415926535));
+            expect(response.responseParam, 3.1415926535);
+        });
+    });
+
     group('ServeMe API tests', () {
         setUp(() async {
             timer = Timer(const Duration(seconds: 2), () => fail('Operation timed out'));