Ufdjrw

I aspire to assign Websockets and net.Sockets with unique identifiers, so when a message is received, the client is identified by the identifier attached to the socket.

Previous research:

For Websocket:

According to this and this, the following is requires:

const app = express();
const server = http.createServer(app);
const wss = new WebSocket.Server( server );
wss.on('connection', (ws) => 
 ws.id = uuid.v4(); // This is the relevant line of code
 ws.on('message', (msg: string) => 
 ...
 
);

For net.Socket:

Quite the same - according to this, the following is required:

var server = net.createServer();

server.on('connection', function(conn) 
 conn.id = uuid.v4(); // This is the relevant line of code
 conn.on('data', function(data) 
 ...
 );
);

The problem

The error "Property 'id' does not exist on type 'WebSocket' [or 'Socket' accordingly]" during compilation. This explains why.

Optional Solution #1: Cast to any

The update net.Socket code will be:

var server = net.createServer();

server.on('connection', function(conn) 
 (conn as any).id = uuid.v4();
 conn.on('data', function(data) 
 console.log('Session id:' + (conn as any).id);
 );
);

The problem: It doesn't seem like good practice to me. I don't have references for why except for a hunch for now.

Optional Solution #2: Use a local variable [seems like a better option]

The update net.Socket code will be:

var server = net.createServer();

server.on('connection', function(conn) 
 const id: string = uuid.v4();
 conn.on('data', function(data) 
 console.log('Session id:' + id);
 );
);

After some experiencing, it seems to work properly.

So - the questions:

1. 
   In optional solution #2: is it guaranteed that the id variable will always be available in this scope? In other words: is this solution valid? for both net.Socket & Websocket? Or is there something that I'm missing?


2. 
   In general: Is there additional identifiers (perhaps built in identifiers in WebSocket and net.Socket) that can be used instead?

[Typescript version: 3.2.4].

I'm not aware of a field that already exists for that.

If you can keep the socket id in a local variable like you do in option 2, that's what I'd do. I generally prefer to avoid adding arbitrary fields to objects. However, sometimes you want the entirety of your application to be able to access the additional piece of data, and in those cases using a local variable won't work.

Adding a custom field

Instead of using a type assertion to any, you could add a file to your project that contains this:

declare module "net" 
 interface Socket 
 id: string;
 

This is augmenting the net.Socket interface to add an id field which is a string. This is a bit neater than a type assertion because the type assertion would let typos go through (e.g. (conn as any).ids). I used your code, removed the type assertion and added the above in a file named externals.d.ts that I put next to the .ts file that contains your code. tsc stopped complaining about the field. Note that you don't need to import this file or refer to it in any way. You must just have a tsconfig.json that picks it up along with the rest of your source. By default, it would be picked up due to the .d.ts extension.

In the past I've used type assertions and interface augmentation to add arbitrary fields to DOM nodes, and it worked just fine. However, when I did that, I used field names that were very singular, meaning that there was a very low chance of a clash with other libraries that might want to add their own fields. Your field name is id. I'd be worried about name clashes with other libraries that decide they want to keep track of sockets and add their own id field to a socket.

Using WeakMap

There's another method you can use. You could setup a WeakMap that associates the socket with the id. Here's an illustration. You could have a module socket-map that just exports a map that maps sockets to strings:

import * as net from "net";

export const socketMap = new WeakMap<net.Socket, string>();

And then you'd store the socket with the id when you obtain the socket:

import * as net from "net";
import * as uuid from "uuid";
import socketMap from "./socket-map";

var server = net.createServer();

server.on('connection', function(conn) 
 const id = uuid.v4();
 socketMap.set(conn, id); // You store the socket into the map.
 conn.on('data', function(data) 
 console.log('Session id:' + (conn as any).id);
 );
);

Then later, in another module, you could get the id back with:

import * as net from "net";
import socketMap from "./socket-map";

export function foo(conn: net.Socket) 
 const id = socketMap.get(conn);

Here I've just associated the socket with an id string, but you could have any structure you want in the values of the WeakMap. It could be an object that contains a whole slew of information besides an id.

The reason to use WeakMap is while the keys of a WeakMap object contain references to objects, these references do not count as far as garbage collection goes. So if your application is done with a socket and no longer references it anywhere than a WeakMap, the reference present in the WeakMap will still allow the socket to be collected by the garbage collector.