@observertc/observer-js 0.9.21-beta → 0.9.23-beta

package/src/entries/OutboundTrackEntry.ts

@@ -0,0 +1,72 @@
+import { createLogger } from '../common/logger';
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { createCallEntry } from './CallEntry';
+import { createClientEntry } from './ClientEntry';
+import { createPeerConnectionEntry } from './PeerConnectionEntry';
+
+const logger = createLogger('OutboundTrackWrapper');
+
+export type OutboundTrackEntry = ReturnType<typeof createOutboundTrackEntry>;
+
+export function createOutboundTrackEntry(storageProvider: StorageProvider, model?: Models.OutboundTrack) {
+	if (!model) return;
+	const {
+		callId,
+		clientId,
+		peerConnectionId,
+		trackId,
+		kind,
+	} = model;
+
+	if (!callId) return logger.warn(`OutboundTrack model without callId: ${JSON.stringify(model)}`);
+	if (!clientId) return logger.warn(`OutboundTrack model without clientId: ${JSON.stringify(model)}`);
+	if (!peerConnectionId) return logger.warn(`OutboundTrack model without peerConnectionId: ${JSON.stringify(model)}`);
+	if (!trackId) return logger.warn(`OutboundTrack model without trackId: ${JSON.stringify(model)}`);
+	if (!kind) return logger.warn(`OutboundTrack model without kind: ${JSON.stringify(model)}`);
+	
+	const direction = 'outbound' as const;
+	const getCall = async () => {
+		return createCallEntry(storageProvider, await storageProvider.callStorage.get(callId));
+	};
+	const getClient = async () => {
+		return createClientEntry(storageProvider, await storageProvider.clientStorage.get(clientId));
+	};
+	const getPeerConnection = async () => {
+		return createPeerConnectionEntry(storageProvider, await storageProvider.peerConnectionStorage.get(peerConnectionId));
+	};
+	
+	return {
+		callId,
+		clientId,
+		peerConnectionId,
+		trackId,
+		direction,
+		get kind(): 'audio' | 'video' {
+			return kind.toLocaleLowerCase() as 'audio' | 'video';
+		},
+		get stats() {
+			return 0 < model.audioStats.length ? model.audioStats : 0 < model.videoStats.length ? model.videoStats : undefined;
+		},
+		get marker() {
+			return model.marker;
+		},
+		get ssrc() {
+			return model.ssrc;
+		},
+
+		getCall,
+		getClient,
+		getPeerConnection,
+
+		refresh: async () => {
+			const refreshedModel = await storageProvider.outboundTrackStorage.get(trackId);
+
+			if (!refreshedModel) return;
+
+			model.audioStats = refreshedModel.audioStats;
+			model.videoStats = refreshedModel.videoStats;
+			model.marker = refreshedModel.marker;
+		}
+	};
+}

package/src/entries/PeerConnectionEntry.ts

@@ -0,0 +1,133 @@
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { logger, createCallEntry } from './CallEntry';
+import { asyncIteratorConverter } from '../common/utils';
+import { createClientEntry } from './ClientEntry';
+import { InboundTrackEntry, createInboundTrackEntry } from './InboundTrackEntry';
+import { OutboundTrackEntry, createOutboundTrackEntry } from './OutboundTrackEntry';
+
+export type PeerConnectionEntry = ReturnType<typeof createPeerConnectionEntry>;
+
+export function createPeerConnectionEntry(storageProvider: StorageProvider, model?: Models.PeerConnection) {
+	if (!model) return;
+
+	const {
+		callId, 
+		clientId, 
+		peerConnectionId, 
+		label,
+		mediaUnitId, 
+		opened, 
+		serviceId, 
+		roomId, 
+		userId, 
+		marker
+	} = model;
+
+	if (!peerConnectionId) return logger.warn(`PeerConnection model without peerConnectionId: ${JSON.stringify(model)}`);
+	if (!callId) return logger.warn(`PeerConnection model without callId: ${JSON.stringify(model)}`);
+	if (!clientId) return logger.warn(`PeerConnection model without clientId: ${JSON.stringify(model)}`);
+
+	const getClient = async () => {
+		return createClientEntry(storageProvider, await storageProvider.clientStorage.get(clientId));
+	};
+
+	const getCall = async () => {
+		return createCallEntry(storageProvider, await storageProvider.callStorage.get(callId));
+	};
+
+	const asyncInboundTrackGenerator = async function *(providedInboundTrackIds?: string[], kind?: string) {
+		const inboundTrackModels = await Promise.all(
+			(providedInboundTrackIds ?? model.inboundTrackIds).map((inboundTrackId) => storageProvider.inboundTrackStorage.get(inboundTrackId))
+		);
+
+		for (const inboundTrackModel of inboundTrackModels) {
+			if (!inboundTrackModel) continue;
+			if (kind && inboundTrackModel.kind !== kind) continue;
+			yield createInboundTrackEntry(storageProvider, inboundTrackModel);
+		}
+	};
+	const asyncOutboundTrackGenerator = async function *(providedOutboundTrackIds?: string[], kind?: string) {
+		const outboundTrackModels = await Promise.all(
+			(providedOutboundTrackIds ?? model.outboundTrackIds).map((outboundTrackId) => storageProvider.outboundTrackStorage.get(outboundTrackId))
+		);
+
+		for (const outboundTrackModel of outboundTrackModels) {
+			if (!outboundTrackModel) continue;
+			if (kind && outboundTrackModel.kind !== kind) continue;
+			yield createOutboundTrackEntry(storageProvider, outboundTrackModel);
+		}
+	};
+
+	return {
+		callId,
+		clientId,
+		peerConnectionId,
+		marker,
+		label,
+		mediaUnitId,
+		opened,
+		serviceId,
+		roomId,
+		userId,
+
+		getClient,
+		getCall,
+		
+		get iceCandidatePairs() {
+			return model.iceCandidatePairs;
+		},
+		get iceRemoteCandidates() {
+			return model.iceRemoteCandidates;
+		},
+		get iceLocalCandidates() {
+			return model.icelocalCandidates;
+		},
+		get transports() {
+			return model.transports;
+		},
+		get inboundTrackIds(): ReadonlyArray<string> {
+			return model.inboundTrackIds;
+		},
+		get outboundTrackIds(): ReadonlyArray<string> {
+			return model.outboundTrackIds;
+		},
+		get inboundTracks(): AsyncIterableIterator<InboundTrackEntry> {
+			return asyncIteratorConverter<InboundTrackEntry>(asyncInboundTrackGenerator());
+		},
+		get outboundTracks(): AsyncIterableIterator<OutboundTrackEntry> {
+			return asyncIteratorConverter<OutboundTrackEntry>(asyncOutboundTrackGenerator());
+		},
+		get inboundAudioTracks(): AsyncIterableIterator<InboundTrackEntry> {
+			return asyncIteratorConverter<InboundTrackEntry>(asyncInboundTrackGenerator(undefined, 'audio'));
+		},
+		get outboundAudioTracks(): AsyncIterableIterator<OutboundTrackEntry> {
+			return asyncIteratorConverter<OutboundTrackEntry>(asyncOutboundTrackGenerator(undefined, 'audio'));
+		},
+		get inboundVideoTracks(): AsyncIterableIterator<InboundTrackEntry> {
+			return asyncIteratorConverter<InboundTrackEntry>(asyncInboundTrackGenerator(undefined, 'video'));
+		},
+		get outboundVideoTracks(): AsyncIterableIterator<OutboundTrackEntry> {
+			return asyncIteratorConverter<OutboundTrackEntry>(asyncOutboundTrackGenerator(undefined, 'video'));
+		},
+		async getInboundTrack(inboundTrackId: string) {
+			return model.inboundTrackIds.includes(inboundTrackId) ? createInboundTrackEntry(storageProvider, await storageProvider.inboundTrackStorage.get(inboundTrackId)) : undefined;
+		},
+		async getOutboundTrack(outboundTrackId: string) {
+			return model.outboundTrackIds.includes(outboundTrackId) ? createOutboundTrackEntry(storageProvider, await storageProvider.outboundTrackStorage.get(outboundTrackId)) : undefined;
+		},
+
+		async refresh() {
+			const refreshedModel = await storageProvider.peerConnectionStorage.get(peerConnectionId);
+
+			if (!refreshedModel) return;
+
+			model.iceCandidatePairs = refreshedModel.iceCandidatePairs;
+			model.iceRemoteCandidates = refreshedModel.iceRemoteCandidates;
+			model.icelocalCandidates = refreshedModel.icelocalCandidates;
+			model.transports = refreshedModel.transports;
+			model.inboundTrackIds = refreshedModel.inboundTrackIds;
+			model.outboundTrackIds = refreshedModel.outboundTrackIds;
+		}
+	};
+}

package/src/entries/SfuEntry.ts

@@ -0,0 +1,62 @@
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { createLogger } from '../common/logger';
+import { SfuTransportEntry, createSfuTransportEntry } from './SfuTransportEntry';
+import { asyncIteratorConverter } from '../common/utils';
+
+export const logger = createLogger('CallWrapper');
+
+export type SfuEntry = ReturnType<typeof createSfuEntry>;
+
+export function createSfuEntry(storageProvider: StorageProvider, model?: Models.Sfu) {
+	if (!model) return;
+	const { 
+		sfuId,
+		serviceId,
+		mediaUnitId,
+		joined,
+	} = model;
+
+	if (!sfuId) return logger.warn(`Sfu model without sfuId: ${JSON.stringify(model)}`);
+	if (!serviceId) return logger.warn(`Sfu model without serviceId: ${JSON.stringify(model)}`);
+	if (!mediaUnitId) return logger.warn(`Sfu model without mediaUnitId: ${JSON.stringify(model)}`);
+	if (!joined) return logger.warn(`Sfu model without joined: ${JSON.stringify(model)}`);
+
+	const getSfuTransport = async (sfuTransportId: string) => {
+		return createSfuTransportEntry(storageProvider, await storageProvider.sfuTransportStorage.get(sfuTransportId));
+	};
+	const asyncSfuTransportGenerator = async function *() {
+		const sfuTransportModels = await Promise.all(
+			model.sfuTransportIds.map((sfuTransportId) => storageProvider.sfuTransportStorage.get(sfuTransportId))
+		);
+
+		for (const sfuTransportModel of sfuTransportModels) {
+			if (!sfuTransportModel) continue;
+			yield createSfuTransportEntry(storageProvider, sfuTransportModel);
+		}
+	};
+	
+	return {
+		sfuId,
+		serviceId,
+		mediaUnitId,
+		joined,
+		get marker() {
+			return model.marker;
+		},
+		get sfuTransportIds(): ReadonlyArray<string> {
+			return model.sfuTransportIds;
+		},
+		get sfuTransports(): AsyncIterableIterator<SfuTransportEntry> {
+			return asyncIteratorConverter<SfuTransportEntry>(asyncSfuTransportGenerator());
+		},
+		getSfuTransport,
+		refresh: async () => {
+			const refreshedModel = await storageProvider.sfuStorage.get(sfuId);
+
+			if (!refreshedModel) return;
+
+			model.marker = refreshedModel.marker;
+		}
+	};
+}

package/src/entries/SfuInboundRtpPadEntry.ts

@@ -0,0 +1,46 @@
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { logger } from './SfuEntry';
+
+export type SfuInboundRtpPadEntry = ReturnType<typeof createSfuInboundRtpPadEntry>;
+
+export function createSfuInboundRtpPadEntry(storageProvider: StorageProvider, model?: Models.SfuInboundRtpPad) {
+	if (!model) return;
+	const {
+		sfuId, 
+		sfuTransportId,
+		added,
+		internal,
+		rtpPadId,
+		mediaUnitId,
+	} = model;
+
+	if (!sfuId) return logger.warn(`SfuInboundRtpPad model without sfuId: ${JSON.stringify(model)}`);
+	if (!sfuTransportId) return logger.warn(`SfuInboundRtpPad model without sfuTransportId: ${JSON.stringify(model)}`);
+	if (!added) return logger.warn(`SfuInboundRtpPad model without added: ${JSON.stringify(model)}`);
+	if (!rtpPadId) return logger.warn(`SfuInboundRtpPad model without rtpPadId: ${JSON.stringify(model)}`);
+	if (!mediaUnitId) return logger.warn(`SfuInboundRtpPad model without mediaUnitId: ${JSON.stringify(model)}`);
+
+	const direction = 'inbound' as const;
+
+	return {
+		sfuId,
+		sfuTransportId,
+		rtpPadId,
+		direction,
+		added,
+		get internal() {
+			return internal === true;
+		},
+		get marker() {
+			return model.marker;
+		},
+		refresh: async () => {
+			const refreshedModel = await storageProvider.sfuInboundRtpPadStorage.get(sfuTransportId);
+
+			if (!refreshedModel) return;
+
+			model.marker = refreshedModel.marker;
+		}
+	};
+}

package/src/entries/SfuOutboundRtpPadEntry.ts

@@ -0,0 +1,44 @@
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { logger } from './SfuEntry';
+
+export type SfuOutboundRtpPadEntry = ReturnType<typeof createSfuOutboundRtpPadEntry>;
+
+export function createSfuOutboundRtpPadEntry(storageProvider: StorageProvider, model?: Models.SfuOutboundRtpPad) {
+	if (!model) return;
+	const {
+		sfuId, 
+		sfuTransportId,
+		rtpPadId,
+		added,
+		internal,
+	} = model;
+
+	if (!sfuId) return logger.warn(`SfuTransport model without sfuId: ${JSON.stringify(model)}`);
+	if (!sfuTransportId) return logger.warn(`SfuTransport model without sfuTransportId: ${JSON.stringify(model)}`);
+	if (!rtpPadId) return logger.warn(`SfuTransport model without rtpPadId: ${JSON.stringify(model)}`);
+	if (!added) return logger.warn(`SfuTransport model without added: ${JSON.stringify(model)}`);
+	
+	const direction = 'outbound' as const;
+
+	return {
+		sfuTransportId,
+		sfuId,
+		rtpPadId,
+		added,
+		direction,
+		get internal() {
+			return internal === true;
+		},
+		get marker() {
+			return model.marker;
+		},
+		refresh: async () => {
+			const refreshedModel = await storageProvider.sfuTransportStorage.get(sfuTransportId);
+
+			if (!refreshedModel) return;
+
+			model.marker = refreshedModel.marker;
+		}
+	};
+}

package/src/entries/SfuSctpChannelEntry.ts

@@ -0,0 +1,39 @@
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { logger } from './SfuEntry';
+
+export type SfuSctpChannelEntry = ReturnType<typeof createSfuSctpChannelEntry>;
+
+export function createSfuSctpChannelEntry(storageProvider: StorageProvider, model?: Models.SfuSctpChannel) {
+	if (!model) return;
+	const {
+		sfuId,
+		sfuTransportId,
+		sfuSctpChannelId,
+		opened,
+	} = model;
+
+	model.sfuTransportId;
+
+	if (!sfuId) return logger.warn(`SfuSctpChannel model without sfuId: ${JSON.stringify(model)}`);
+	if (!sfuTransportId) return logger.warn(`SfuSctpChannel model without sfuTransportId: ${JSON.stringify(model)}`);
+	if (!sfuSctpChannelId) return logger.warn(`SfuSctpChannel model without sfuSctpChannelId: ${JSON.stringify(model)}`);
+	if (!opened) return logger.warn(`SfuSctpChannel model without opened: ${JSON.stringify(model)}`);
+
+	return {
+		sfuId,
+		sfuTransportId,
+		sfuSctpChannelId,
+		opened,
+		get marker() {
+			return model.marker;
+		},
+		refresh: async () => {
+			const refreshedModel = await storageProvider.sfuSctpChannelStorage.get(sfuSctpChannelId);
+
+			if (!refreshedModel) return;
+
+			model.marker = refreshedModel.marker;
+		}
+	};
+}

package/src/entries/SfuTransportEntry.ts

@@ -0,0 +1,109 @@
+import { asyncIteratorConverter } from '../common/utils';
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { createSfuEntry, logger } from './SfuEntry';
+import { createSfuInboundRtpPadEntry } from './SfuInboundRtpPadEntry';
+import { createSfuOutboundRtpPadEntry } from './SfuOutboundRtpPadEntry';
+import { createSfuSctpChannelEntry } from './SfuSctpChannelEntry';
+
+export type SfuTransportEntry = ReturnType<typeof createSfuTransportEntry>;
+
+export function createSfuTransportEntry(storageProvider: StorageProvider, model?: Models.SfuTransport) {
+	if (!model) return;
+	const {
+		sfuId,
+		transportId: sfuTransportId,
+		opened,
+		internal,
+	} = model;
+
+	if (!sfuId) return logger.warn(`SfuTransport model without sfuId: ${JSON.stringify(model)}`);
+	if (!sfuTransportId) return logger.warn(`SfuTransport model without sfuTransportId: ${JSON.stringify(model)}`);
+	if (!opened) return logger.warn(`SfuTransport model without opened: ${JSON.stringify(model)}`);
+	
+	const getSfu = async () => {
+		return createSfuEntry(storageProvider, await storageProvider.sfuStorage.get(sfuId));
+	};
+	const getSfuInboundRtpPad = async (sfuInboundRtpPadId: string) => {
+		return createSfuInboundRtpPadEntry(storageProvider, await storageProvider.sfuInboundRtpPadStorage.get(sfuInboundRtpPadId));
+	};
+	const getSfuOutboundRtpPad = async (sfuOutboundRtpPadId: string) => {
+		return createSfuOutboundRtpPadEntry(storageProvider, await storageProvider.sfuOutboundRtpPadStorage.get(sfuOutboundRtpPadId));
+	};
+	const getSfuSctpChannel = async (sfuSctpChannelId: string) => {
+		return createSfuSctpChannelEntry(storageProvider, await storageProvider.sfuSctpChannelStorage.get(sfuSctpChannelId));
+	};
+	const asyncSfuInboundRtpPadGenerator = async function *() {
+		const sfuInboundRtpPadModels = await Promise.all(
+			model.inboundRtpPadIds.map((sfuInboundRtpPadId) => storageProvider.sfuInboundRtpPadStorage.get(sfuInboundRtpPadId))
+		);
+
+		for (const sfuInboundRtpPadModel of sfuInboundRtpPadModels) {
+			if (!sfuInboundRtpPadModel) continue;
+			yield createSfuInboundRtpPadEntry(storageProvider, sfuInboundRtpPadModel);
+		}
+	};
+
+	const asyncSfuOutboundRtpPadGenerator = async function *() {
+		const sfuOutboundRtpPadModels = await Promise.all(
+			model.outboundRtpPadIds.map((sfuOutboundRtpPadId) => storageProvider.sfuOutboundRtpPadStorage.get(sfuOutboundRtpPadId))
+		);
+
+		for (const sfuOutboundRtpPadModel of sfuOutboundRtpPadModels) {
+			if (!sfuOutboundRtpPadModel) continue;
+			yield createSfuOutboundRtpPadEntry(storageProvider, sfuOutboundRtpPadModel);
+		}
+	};
+
+	const asyncSfuSctpChannelGenerator = async function *() {
+		const sfuSctpChannelModels = await Promise.all(
+			model.sctpChannelIds.map((sfuSctpChannelId) => storageProvider.sfuSctpChannelStorage.get(sfuSctpChannelId))
+		);
+
+		for (const sfuSctpChannelModel of sfuSctpChannelModels) {
+			if (!sfuSctpChannelModel) continue;
+			yield createSfuSctpChannelEntry(storageProvider, sfuSctpChannelModel);
+		}
+	};
+
+	return {
+		sfuTransportId,
+		sfuId,
+		opened,
+		get internal() {
+			return internal === true;
+		},
+		get marker() {
+			return model.marker;
+		},
+		get inboundRtpPadIds(): ReadonlyArray<string> {
+			return model.inboundRtpPadIds;
+		},
+		get outboundRtpPadIds(): ReadonlyArray<string> {
+			return model.outboundRtpPadIds;
+		},
+		get sctpChannelIds(): ReadonlyArray<string> {
+			return model.sctpChannelIds;
+		},
+		get inboundRtpPads(): AsyncIterableIterator<ReturnType<typeof createSfuInboundRtpPadEntry>> {
+			return asyncIteratorConverter<ReturnType<typeof createSfuInboundRtpPadEntry>>(asyncSfuInboundRtpPadGenerator());
+		},
+		get outboundRtpPads(): AsyncIterableIterator<ReturnType<typeof createSfuOutboundRtpPadEntry>> {
+			return asyncIteratorConverter<ReturnType<typeof createSfuOutboundRtpPadEntry>>(asyncSfuOutboundRtpPadGenerator());
+		},
+		get sctpChannels(): AsyncIterableIterator<ReturnType<typeof createSfuSctpChannelEntry>> {
+			return asyncIteratorConverter<ReturnType<typeof createSfuSctpChannelEntry>>(asyncSfuSctpChannelGenerator());
+		},
+		getSfu,
+		getSfuInboundRtpPad,
+		getSfuOutboundRtpPad,
+		getSfuSctpChannel,
+		refresh: async () => {
+			const refreshedModel = await storageProvider.sfuTransportStorage.get(sfuTransportId);
+
+			if (!refreshedModel) return;
+
+			model.marker = refreshedModel.marker;
+		}
+	};
+}

package/src/index.ts

@@ -13,6 +13,17 @@ export * as Models from './models/Models';
 export * as SampleSchema from '@observertc/sample-schemas-js';
 export * as ReportSchema from '@observertc/report-schemas-js';
 
+export type { CallEntry } from './entries/CallEntry';
+export type { ClientEntry } from './entries/ClientEntry';
+export type { PeerConnectionEntry } from './entries/PeerConnectionEntry';
+export type { InboundTrackEntry } from './entries/InboundTrackEntry';
+export type { OutboundTrackEntry } from './entries/OutboundTrackEntry';
+export type { SfuEntry } from './entries/SfuEntry';
+export type { SfuTransportEntry } from './entries/SfuTransportEntry';
+export type { SfuInboundRtpPadEntry } from './entries/SfuInboundRtpPadEntry';
+export type { SfuOutboundRtpPadEntry } from './entries/SfuOutboundRtpPadEntry';
+export type { SfuSctpChannelEntry } from './entries/SfuSctpChannelEntry';
+
 export type {
 	Samples,
 	ClientSample,

package/src/middlewares/CallOperationsContext.ts

@@ -13,11 +13,11 @@ export type CallOperationsContext = {
 
 export type CallOperation =
 	| (ObservedClientSourceConfig & {
-        type: 'join';
-    }) | (ObservedClientSourceConfig & {
-        type: 'detach';
-        detached: number;
-    });
+		type: 'join';
+	}) | (ObservedClientSourceConfig & {
+		type: 'detach';
+		detached: number;
+	});
 
 export function createCallOperationContext(
 	clientOperations: Map<string, CallOperation>,
@@ -25,12 +25,14 @@ export function createCallOperationContext(
 ): CallOperationsContext {
 	const joinedClients: CallOperationsContext['joinedClients'] = [];
 	const detachedClients: CallOperationsContext['detachedClients'] = [];
+
 	for (const clientOperation of clientOperations.values()) {
 		switch (clientOperation.type) {
 			case 'join': {
 				const joinedClient: CallOperationsContext['joinedClients'][number] = {
 					...clientOperation,
 				};
+
 				joinedClients.push(joinedClient);
 				break;
 			}
@@ -38,11 +40,13 @@ export function createCallOperationContext(
 				const detachedClient: CallOperationsContext['detachedClients'][number] = {
 					...clientOperation,
 				};
+
 				detachedClients.push(detachedClient);
 				break;
 			}
 		}
 	}
+	
 	return {
 		joinedClients,
 		detachedClients,

package/src/middlewares/CallProcessor.ts

@@ -19,7 +19,8 @@ export function createCallProcessor(
 
 			evaluatorContext: context.evaluatorContext,
 		};
-		await Promise.all([joinClientProcess(input), next ? next(context) : Promise.resolve()]);
+
+		await Promise.all([ joinClientProcess(input), next ? next(context) : Promise.resolve() ]);
 	};
 
 	const detachClientMiddleware: Middleware<CallOperationsContext> = async (context, next) => {
@@ -29,7 +30,8 @@ export function createCallProcessor(
 			evaluatorContext: context.evaluatorContext,
 			recursive: true,
 		};
-		await Promise.all([detachClientProcess(input), next ? next(context) : Promise.resolve()]);
+
+		await Promise.all([ detachClientProcess(input), next ? next(context) : Promise.resolve() ]);
 	};
 
 	return createProcessor(joinClientMiddleware, detachClientMiddleware);

package/src/middlewares/CommitTransactionMiddleware.ts

@@ -160,6 +160,7 @@ export function createCommitTransactionMiddleware(
 
 		const [
 			[
+				// eslint-disable-next-line @typescript-eslint/no-unused-vars
 				oldClientModels,
 				oldPeerConnectionModels,
 				oldInboundAudioTrackModels,
@@ -233,6 +234,7 @@ export function createCommitTransactionMiddleware(
 		};
 		const addedUnits = <K, V>(oldItems: ReadonlyMap<K, V>, updatedItems: ReadonlyMap<K, V>) => {
 			const oldSet = new Set<K>(oldItems.keys());
+			
 			return Array.from(updatedItems.keys()).filter((updatedKey) => !oldSet.has(updatedKey));
 		};
 
@@ -312,14 +314,15 @@ export function createCommitTransactionMiddleware(
 			})
 		);
 
-		evaluatorContext.callEvents = [...reports.getCallEventReports()];
-		evaluatorContext.clientExtensionStats = [...reports.getClientExtensionReports()];
-		evaluatorContext.sfuEvents = [...reports.getSfuEventReports()];
-		evaluatorContext.sfuExtensionStats = [...reports.getSfuExtensionReports()];
+		evaluatorContext.callEvents = [ ...reports.getCallEventReports() ];
+		evaluatorContext.clientExtensionStats = [ ...reports.getClientExtensionReports() ];
+		evaluatorContext.sfuEvents = [ ...reports.getSfuEventReports() ];
+		evaluatorContext.sfuExtensionStats = [ ...reports.getSfuExtensionReports() ];
 	};
 
 	const result = async (context: TransactionContext, next?: Middleware<TransactionContext>) => {
-		await Promise.all([process(context), next ? next(context) : Promise.resolve()]);
+		await Promise.all([ process(context), next ? next(context) : Promise.resolve() ]);
 	};
+	
 	return result;
 }