@api.global/typedrequest
Version:
A TypeScript library for making typed requests towards APIs, including facilities for handling requests, routing, and virtual stream handling.
369 lines • 30.8 kB
JavaScript
import * as plugins from './plugins.js';
import { TypedRouter } from './classes.typedrouter.js';
const closingBit = '#############CLOSING BIT#############';
/**
* 1. A VirtualStream connects over the network
* 2. It is always paired to one other VirtualStream
* on the other side with the same streamId.
* 3. It has a Readable and Writable side.
* 4. The Writable side is Readable on the other side and vice versa.
*/
export class VirtualStream {
// STATIC
static encodePayloadForNetwork(objectPayload, commFunctions, originalPayload, path = []) {
if (!objectPayload) {
return objectPayload;
}
if (plugins.smartbuffer.isBufferLike(objectPayload)) {
return objectPayload;
}
if (objectPayload instanceof VirtualStream) {
if (!objectPayload.side && commFunctions.sendMethod) {
objectPayload.side = 'requesting';
objectPayload.sendMethod = commFunctions.sendMethod;
}
if (!objectPayload.side && commFunctions.typedrouter) {
objectPayload.side = 'responding';
objectPayload.typedrouter = commFunctions.typedrouter;
commFunctions.typedrouter.registeredVirtualStreams.add(objectPayload);
}
if (!originalPayload.response || path.includes('response')) {
objectPayload.startKeepAliveLoop();
return {
_isVirtualStream: true,
streamId: objectPayload.streamId,
};
}
else {
return {
_OBMITTED_VIRTUAL_STREAM: true,
reason: 'path is under .request: obmitted for deduplication reasons in response cycle.',
};
}
}
else if (Array.isArray(objectPayload)) {
// For arrays, we recurse over each item.
return objectPayload.map((item, index) => VirtualStream.encodePayloadForNetwork(item, commFunctions, originalPayload || objectPayload, path.concat(String(index)) // Convert index to string and concatenate to path
));
}
else if (objectPayload !== null && typeof objectPayload === 'object') {
// For objects, we recurse over each key-value pair.
return Object.entries(objectPayload).reduce((acc, [key, value]) => {
const newPath = path.concat(key); // Concatenate the new key to the path
acc[key] = VirtualStream.encodePayloadForNetwork(value, commFunctions, originalPayload || objectPayload, newPath);
return acc;
}, {});
}
else {
return objectPayload;
}
}
static decodePayloadFromNetwork(objectPayload, commFunctions) {
if (plugins.smartbuffer.isBufferLike(objectPayload)
|| objectPayload instanceof TypedRouter) {
return objectPayload;
}
if (objectPayload !== null && typeof objectPayload === 'object') {
if (objectPayload._isVirtualStream) {
const virtualStream = new VirtualStream();
virtualStream.streamId = objectPayload.streamId;
if (!virtualStream.side && commFunctions.sendMethod) {
virtualStream.side = 'requesting';
virtualStream.sendMethod = commFunctions.sendMethod;
}
if (!virtualStream.side && commFunctions.typedrouter) {
virtualStream.side = 'responding';
virtualStream.typedrouter = commFunctions.typedrouter;
commFunctions.typedrouter.registeredVirtualStreams.add(virtualStream);
}
virtualStream.startKeepAliveLoop();
return virtualStream;
}
else if (Array.isArray(objectPayload)) {
const returnArray = [];
for (const item of objectPayload) {
returnArray.push(VirtualStream.decodePayloadFromNetwork(item, commFunctions));
}
return returnArray;
}
else {
return Object.keys(objectPayload).reduce((acc, key) => {
acc[key] = VirtualStream.decodePayloadFromNetwork(objectPayload[key], commFunctions);
return acc;
}, {});
}
}
else {
return objectPayload;
}
}
constructor() {
this.streamId = plugins.isounique.uni();
// wether to keep the stream alive
this.keepAlive = true;
// backpressured arrays
this.sendBackpressuredArray = new plugins.lik.BackpressuredArray(16);
this.receiveBackpressuredArray = new plugins.lik.BackpressuredArray(16);
}
/**
* takes care of sending
*/
async workOnQueue() {
if (this.workingDeferred) {
return this.workingDeferred.promise;
}
else {
this.workingDeferred = plugins.smartpromise.defer();
}
if (this.side === 'requesting') {
let thisSideIsBackpressured = !this.receiveBackpressuredArray.checkSpaceAvailable();
let otherSideHasNext = false;
let otherSideIsBackpressured = false;
// helper functions
const getFeedback = async () => {
const streamTr = await this.sendMethod({
method: '##VirtualStream##',
request: {
streamId: this.streamId,
cycleId: plugins.isounique.uni(),
cycle: 'request',
mainPurpose: 'feedback',
next: this.sendBackpressuredArray.data.length > 0,
backpressure: !this.receiveBackpressuredArray.checkSpaceAvailable(),
},
response: null,
}).catch(() => {
console.log('stream ended immaturely');
this.keepAlive = false;
});
if (streamTr && streamTr.response) {
otherSideIsBackpressured = streamTr.response.backpressure;
otherSideHasNext = streamTr.response.next;
}
};
await getFeedback();
// do work loop
while (this.sendBackpressuredArray.data.length > 0 || otherSideHasNext) {
if (otherSideIsBackpressured) {
while (otherSideIsBackpressured) {
console.log('waiting for feedback because of backpressure...');
await plugins.smartdelay.delayFor(50);
await getFeedback();
}
}
let dataArg;
if (this.sendBackpressuredArray.data.length > 0) {
dataArg = this.sendBackpressuredArray.shift();
}
let streamTr;
streamTr = await this.sendMethod({
method: '##VirtualStream##',
request: {
streamId: this.streamId,
cycleId: plugins.isounique.uni(),
cycle: 'request',
mainPurpose: dataArg ? 'chunk' : 'read',
backpressure: thisSideIsBackpressured,
next: this.sendBackpressuredArray.data.length > 0,
...dataArg ? { chunkData: dataArg } : {},
},
response: null,
}).catch(() => {
console.log('stream ended immaturely');
this.keepAlive = false;
return null;
});
if (streamTr && streamTr.response && streamTr.response.chunkData) {
this.receiveBackpressuredArray.push(streamTr.response.chunkData);
}
otherSideIsBackpressured = streamTr && streamTr.response && streamTr.response.backpressure;
thisSideIsBackpressured = !this.receiveBackpressuredArray.checkSpaceAvailable();
// lets care about looping
otherSideHasNext = streamTr && streamTr.response && streamTr.response.next;
}
}
this.workingDeferred.resolve();
this.workingDeferred = null;
}
/**
* This method handles the stream only on the responding side
* @param streamTrArg
* @returns
*/
async handleStreamTr(streamTrArg) {
if (streamTrArg.request.keepAlive === true && this.keepAlive === true) {
this.lastKeepAliveEvent = Date.now();
}
else if (streamTrArg.request.keepAlive === false) {
this.keepAlive = false;
}
// keepAlive handling
if (streamTrArg.request.mainPurpose === 'keepAlive') {
// if the main purpose is keepAlive, we answer with a keepAlive
streamTrArg.response = {
streamId: this.streamId,
cycleId: streamTrArg.request.cycleId,
cycle: 'response',
mainPurpose: 'keepAlive',
keepAlive: this.keepAlive,
next: this.sendBackpressuredArray.data.length > 0,
backpressure: !this.receiveBackpressuredArray.checkSpaceAvailable(),
};
}
// feedback handling
if (streamTrArg.request.mainPurpose === 'feedback') {
streamTrArg.response = {
streamId: this.streamId,
cycleId: streamTrArg.request.cycleId,
cycle: 'response',
mainPurpose: 'feedback',
next: this.sendBackpressuredArray.data.length > 0,
backpressure: !this.receiveBackpressuredArray.checkSpaceAvailable(),
};
}
// chunk handling
if (streamTrArg.request.mainPurpose === 'chunk') {
this.receiveBackpressuredArray.push(streamTrArg.request.chunkData);
if (this.sendBackpressuredArray.data.length > 0 && streamTrArg.response.backpressure === false) {
const dataArg = this.sendBackpressuredArray.shift();
streamTrArg.response = {
streamId: this.streamId,
cycleId: streamTrArg.request.cycleId,
cycle: 'response',
mainPurpose: 'chunk',
next: this.sendBackpressuredArray.data.length > 1, // 1 and not 0 because we call shift a few lines down
backpressure: !this.receiveBackpressuredArray.checkSpaceAvailable(),
chunkData: this.sendBackpressuredArray.shift(),
};
}
else {
streamTrArg.response = {
streamId: this.streamId,
cycleId: streamTrArg.request.cycleId,
cycle: 'response',
mainPurpose: 'feedback',
next: this.sendBackpressuredArray.data.length > 0,
backpressure: !this.receiveBackpressuredArray.checkSpaceAvailable(),
};
}
streamTrArg.request = null;
}
return streamTrArg;
}
// lifecycle methods
/**
* closes the virtual stream
*/
async cleanup() {
if (this.typedrouter) {
this.typedrouter.registeredVirtualStreams.remove(this);
}
}
/**
* a keepAlive loop that works across technologies
*/
async startKeepAliveLoop() {
// initially wait for a second
if (this.side === 'responding') {
return;
}
await plugins.smartdelay.delayFor(0);
console.log(`starting keepalive loop on side ${this.side}`);
let counter = 0;
keepAliveLoop: while (this.keepAlive) {
await this.triggerKeepAlive();
await plugins.smartdelay.delayFor(1000);
}
await plugins.smartdelay.delayFor(1000);
await this.cleanup();
console.log(`cleaned up for stream ${this.streamId}`);
}
async triggerKeepAlive() {
if (this.side === 'requesting') {
console.log(`keepalive sent.`);
const streamTr = await this.sendMethod({
method: '##VirtualStream##',
request: {
streamId: this.streamId,
cycleId: plugins.isounique.uni(),
cycle: 'request',
mainPurpose: 'keepAlive',
keepAlive: this.keepAlive,
},
response: null,
}).catch(() => {
this.keepAlive = false;
});
// lets handle keepAlive
if (streamTr && streamTr.response && streamTr.response.keepAlive === false) {
this.keepAlive = false;
}
else {
this.lastKeepAliveEvent = Date.now();
}
if (streamTr && streamTr.response && streamTr.response.next) {
this.workOnQueue();
}
}
if (Date.now() - this.lastKeepAliveEvent > 10000) {
console.log(`closing stream for ${this.streamId}`);
this.keepAlive = false;
}
}
// Data sending and receiving
async sendData(dataArg) {
this.sendBackpressuredArray.push(dataArg);
this.workOnQueue();
await this.sendBackpressuredArray.waitForSpace();
}
async fetchData() {
if (this.receiveBackpressuredArray.hasSpace) {
// do something maybe?
}
await this.receiveBackpressuredArray.waitForItems();
const dataPackage = this.receiveBackpressuredArray.shift();
return dataPackage;
}
/**
* reads from a Readable and sends it to the other side
* @param readableStreamArg
*/
async readFromWebstream(readableStreamArg, closeAfterReading = true) {
const reader = readableStreamArg.getReader();
let streamIsDone = false;
while (!streamIsDone) {
const { value, done } = await reader.read();
if (value) {
await this.sendData(value);
}
streamIsDone = done;
}
if (closeAfterReading) {
await this.close(true);
}
}
async writeToWebstream(writableStreamArg) {
const writer = writableStreamArg.getWriter();
while (this.keepAlive || this.receiveBackpressuredArray.checkHasItems()) {
const value = await this.fetchData();
if (value === closingBit) {
writer.releaseLock();
await writableStreamArg.close();
break;
}
await writer.write(value);
}
}
/**
* closes the stream
* if sendClosingBitArg is true, the stream will send a closing bit
* @param sendClosingBitArg
*/
async close(sendClosingBitArg = false) {
if (sendClosingBitArg) {
this.sendData(closingBit);
}
this.keepAlive = false;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.virtualstream.js","sourceRoot":"","sources":["../ts/classes.virtualstream.ts"],"names":[],"mappings":"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"}