216 lines
7.3 KiB
TypeScript
216 lines
7.3 KiB
TypeScript
import * as plugins from './typedsocket.plugins.js';
|
|
|
|
const publicRoleName = 'publicRoleName';
|
|
const publicRolePass = 'publicRolePass';
|
|
|
|
export type TTypedSocketSide = 'server' | 'client';
|
|
|
|
export class TypedSocket {
|
|
// STATIC
|
|
/**
|
|
* creates a typedsocket server
|
|
* note: this will fail in browser environments as server libs are not bundled.
|
|
*/
|
|
public static async createServer(
|
|
typedrouterArg: plugins.typedrequest.TypedRouter,
|
|
smartexpressServerArg?: any
|
|
): Promise<TypedSocket> {
|
|
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 <T extends plugins.typedrequestInterfaces.ITypedRequest>(
|
|
dataArg: T,
|
|
targetConnectionArg?: plugins.smartsocket.SocketConnection
|
|
): Promise<T> => {
|
|
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: T = (await smartsocketServer.clientCall(
|
|
'processMessage',
|
|
dataArg,
|
|
targetConnectionArg
|
|
)) as any;
|
|
return response;
|
|
},
|
|
smartsocketServer
|
|
);
|
|
await smartsocketServer.start();
|
|
|
|
return typedsocket;
|
|
}
|
|
|
|
public static async createClient(
|
|
typedrouterArg: plugins.typedrequest.TypedRouter,
|
|
serverUrlArg: string,
|
|
aliasArg = 'clientArg'
|
|
): Promise<TypedSocket> {
|
|
const domain = new plugins.smartstring.Domain(serverUrlArg);
|
|
|
|
const socketOptions: plugins.smartsocket.ISmartsocketClientOptions = {
|
|
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 <T extends plugins.typedrequestInterfaces.ITypedRequest>(dataArg: T): Promise<T> => {
|
|
const response: T = smartsocketClient.serverCall('processMessage', dataArg) as any as T;
|
|
return response;
|
|
},
|
|
smartsocketClient
|
|
);
|
|
|
|
await smartsocketClient.connect();
|
|
|
|
return typedsocket;
|
|
}
|
|
|
|
// INSTANCE
|
|
public side: TTypedSocketSide;
|
|
public typedrouter: plugins.typedrequest.TypedRouter;
|
|
private postMethod: plugins.typedrequest.IPostMethod &
|
|
((
|
|
typedRequestPostObject: plugins.typedrequestInterfaces.ITypedRequest,
|
|
socketConnectionArg?: plugins.smartsocket.SocketConnection
|
|
) => Promise<plugins.typedrequestInterfaces.ITypedRequest>);
|
|
private socketServerOrClient:
|
|
| plugins.smartsocket.Smartsocket
|
|
| plugins.smartsocket.SmartsocketClient;
|
|
constructor(
|
|
sideArg: TTypedSocketSide,
|
|
typedrouterArg: plugins.typedrequest.TypedRouter,
|
|
postMethodArg: plugins.typedrequest.IPostMethod,
|
|
socketServerOrClientArg: plugins.smartsocket.Smartsocket | plugins.smartsocket.SmartsocketClient
|
|
) {
|
|
this.side = sideArg;
|
|
this.typedrouter = typedrouterArg;
|
|
this.postMethod = postMethodArg;
|
|
this.socketServerOrClient = socketServerOrClientArg;
|
|
}
|
|
|
|
public addTag(keyArg: string, payloadArg: any) {
|
|
if (
|
|
this.side === 'client' &&
|
|
this.socketServerOrClient instanceof plugins.smartsocket.SmartsocketClient
|
|
) {
|
|
this.socketServerOrClient.socketConnection.addTag({
|
|
id: keyArg,
|
|
payload: payloadArg,
|
|
});
|
|
} else {
|
|
throw new Error('tagging is only supported on clients');
|
|
}
|
|
}
|
|
|
|
public createTypedRequest<T extends plugins.typedrequestInterfaces.ITypedRequest>(
|
|
methodName: T['method'],
|
|
targetConnection?: plugins.smartsocket.SocketConnection
|
|
): plugins.typedrequest.TypedRequest<T> {
|
|
const typedrequest = new plugins.typedrequest.TypedRequest<T>(
|
|
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
|
|
*/
|
|
public async findAllTargetConnections(
|
|
asyncFindFuncArg: (connectionArg: plugins.smartsocket.SocketConnection) => Promise<boolean>
|
|
) {
|
|
if (this.socketServerOrClient instanceof plugins.smartsocket.Smartsocket) {
|
|
const matchingSockets: plugins.smartsocket.SocketConnection[] = [];
|
|
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
|
|
*/
|
|
public async findTargetConnection(
|
|
asyncFindFuncArg: (connectionArg: plugins.smartsocket.SocketConnection) => Promise<boolean>
|
|
) {
|
|
const allMatching = await this.findAllTargetConnections(asyncFindFuncArg);
|
|
return allMatching[0];
|
|
}
|
|
|
|
public async findAllTargetConnectionsByTag<TTag extends plugins.typedrequestInterfaces.ITag = any>(keyArg: TTag['name'], payloadArg?: TTag['payload']) {
|
|
return this.findAllTargetConnections(async (socketConnectionArg) => {
|
|
let result: boolean;
|
|
if (!payloadArg) {
|
|
result = !!(await socketConnectionArg.getTagById(keyArg));
|
|
} else {
|
|
result = !!(
|
|
plugins.smartjson.stringify((await socketConnectionArg.getTagById(keyArg))?.payload) ===
|
|
plugins.smartjson.stringify(payloadArg)
|
|
);
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
|
|
public async findTargetConnectionByTag<TTag extends plugins.typedrequestInterfaces.ITag = any>(keyArg: TTag['name'], payloadArg?: TTag['payload']) {
|
|
const allResults = await this.findAllTargetConnectionsByTag(keyArg, payloadArg);
|
|
return allResults[0];
|
|
}
|
|
|
|
public async stop() {
|
|
await this.socketServerOrClient.stop();
|
|
}
|
|
}
|