@api.global/typedsocket
Version:
A library for creating typed WebSocket connections, supporting bi-directional communication with type safety.
150 lines • 13.3 kB
JavaScript
import * as plugins from './typedsocket.plugins.js';
const publicRoleName = 'publicRoleName';
const publicRolePass = 'publicRolePass';
export class TypedSocket {
// STATIC
/**
* creates a typedsocket server
* note: this will fail in browser environments as server libs are not bundled.
*/
static async createServer(typedrouterArg, smartexpressServerArg) {
const smartsocketServer = new plugins.smartsocket.Smartsocket({
alias: 'typedsocketServer',
port: 3000,
});
if (smartexpressServerArg) {
smartsocketServer.setExternalServer('smartexpress', smartexpressServerArg);
}
smartsocketServer.socketFunctions.add(new plugins.smartsocket.SocketFunction({
funcName: 'processMessage',
funcDef: async (dataArg, socketConnectionArg) => {
return typedrouterArg.routeAndAddResponse(dataArg);
},
}));
const typedsocket = new TypedSocket('server', typedrouterArg, async (dataArg, targetConnectionArg) => {
if (!targetConnectionArg) {
if ((smartsocketServer.socketConnections.getArray().length = 1)) {
console.log('Since no targetConnection was supplied and there is only one active one present, choosing that one automatically');
targetConnectionArg = smartsocketServer.socketConnections.getArray()[0];
}
else {
throw new Error('you need to specify the wanted targetConnection. Currently no target is selectable automatically.');
}
}
const response = (await smartsocketServer.clientCall('processMessage', dataArg, targetConnectionArg));
return response;
}, smartsocketServer);
await smartsocketServer.start();
return typedsocket;
}
static async createClient(typedrouterArg, serverUrlArg, aliasArg = 'clientArg') {
const domain = new plugins.smartstring.Domain(serverUrlArg);
const socketOptions = {
alias: aliasArg,
port: domain.port || 3000,
url: `${domain.nodeParsedUrl.protocol}//${domain.nodeParsedUrl.hostname}`,
autoReconnect: true,
};
console.log(`starting typedsocket with the following settings:`);
console.log(socketOptions);
const smartsocketClient = new plugins.smartsocket.SmartsocketClient(socketOptions);
smartsocketClient.addSocketFunction(new plugins.smartsocket.SocketFunction({
funcName: 'processMessage',
funcDef: async (dataArg, socketConnectionArg) => {
return typedrouterArg.routeAndAddResponse(dataArg);
},
}));
const typedsocket = new TypedSocket('client', typedrouterArg, async (dataArg) => {
const response = smartsocketClient.serverCall('processMessage', dataArg);
return response;
}, smartsocketClient);
console.log(`typedsocket triggering smartsocket to connect...`);
const before = Date.now();
await smartsocketClient.connect();
console.log(`typedsocket triggered smartsocket connected in ${Date.now() - before}ms!!!`);
return typedsocket;
}
static { this.useWindowLocationOriginUrl = () => {
const windowLocationResult = plugins.smarturl.Smarturl.createFromUrl(globalThis.location.origin).toString();
return windowLocationResult;
}; }
get eventSubject() {
return this.socketServerOrClient.eventSubject;
}
constructor(sideArg, typedrouterArg, postMethodArg, socketServerOrClientArg) {
this.side = sideArg;
this.typedrouter = typedrouterArg;
this.postMethod = postMethodArg;
this.socketServerOrClient = socketServerOrClientArg;
}
addTag(nameArg, payloadArg) {
if (this.side === 'client' &&
this.socketServerOrClient instanceof plugins.smartsocket.SmartsocketClient) {
this.socketServerOrClient.socketConnection.addTag({
id: nameArg,
payload: payloadArg,
});
}
else {
throw new Error('tagging is only supported on clients');
}
}
createTypedRequest(methodName, targetConnection) {
const typedrequest = new plugins.typedrequest.TypedRequest(new plugins.typedrequest.TypedTarget({
postMethod: async (requestDataArg) => {
const result = await this.postMethod(requestDataArg, targetConnection);
return result;
},
}), methodName);
return typedrequest;
}
/**
* returns all matching target connection
* @param asyncFindFuncArg
* @returns
*/
async findAllTargetConnections(asyncFindFuncArg) {
if (this.socketServerOrClient instanceof plugins.smartsocket.Smartsocket) {
const matchingSockets = [];
for (const socketConnection of this.socketServerOrClient.socketConnections.getArray()) {
if (await asyncFindFuncArg(socketConnection)) {
matchingSockets.push(socketConnection);
}
}
return matchingSockets;
}
else {
throw new Error('this method >>findTargetConnection<< is only available from the server');
}
}
/**
* returns a single target connection by returning the first one of all matching ones
* @param asyncFindFuncArg
* @returns
*/
async findTargetConnection(asyncFindFuncArg) {
const allMatching = await this.findAllTargetConnections(asyncFindFuncArg);
return allMatching[0];
}
async findAllTargetConnectionsByTag(keyArg, payloadArg) {
return this.findAllTargetConnections(async (socketConnectionArg) => {
let result;
if (!payloadArg) {
result = !!(await socketConnectionArg.getTagById(keyArg));
}
else {
result = !!(plugins.smartjson.stringify((await socketConnectionArg.getTagById(keyArg))?.payload) ===
plugins.smartjson.stringify(payloadArg));
}
return result;
});
}
async findTargetConnectionByTag(keyArg, payloadArg) {
const allResults = await this.findAllTargetConnectionsByTag(keyArg, payloadArg);
return allResults[0];
}
async stop() {
await this.socketServerOrClient.stop();
}
}
//# sourceMappingURL=data:application/json;base64,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