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

package/src/common/callMetaReports.ts

@@ -12,6 +12,7 @@ import {
 	Platform,
 } from '@observertc/sample-schemas-js';
 
+// eslint-disable-next-line no-shadow
 export enum CallMetaType {
 	CERTIFICATE = 'CERTIFICATE',
 	CODEC = 'CODEC',
@@ -32,47 +33,47 @@ export enum CallMetaType {
 
 export type CallMetaReportType =
 	| {
-			type: CallMetaType.CERTIFICATE;
-			payload: Certificate;
+		type: CallMetaType.CERTIFICATE;
+		payload: Certificate;
 	} | {
-			type: CallMetaType.CODEC;
-			payload: MediaCodecStats;
+		type: CallMetaType.CODEC;
+		payload: MediaCodecStats;
 	} | {
-			type: CallMetaType.ICE_LOCAL_CANDIDATE;
-			payload: IceLocalCandidate;
+		type: CallMetaType.ICE_LOCAL_CANDIDATE;
+		payload: IceLocalCandidate;
 	} | {
-			type: CallMetaType.ICE_REMOTE_CANDIDATE;
-			payload: IceRemoteCandidate;
+		type: CallMetaType.ICE_REMOTE_CANDIDATE;
+		payload: IceRemoteCandidate;
 	} | {
-			type: CallMetaType.ICE_SERVER;
-			payload: string;
+		type: CallMetaType.ICE_SERVER;
+		payload: string;
 	} | {
-			type: CallMetaType.MEDIA_CONSTRAINT;
-			payload: string;
+		type: CallMetaType.MEDIA_CONSTRAINT;
+		payload: string;
 	} | {
-			type: CallMetaType.MEDIA_DEVICE;
-			payload: MediaDevice;
+		type: CallMetaType.MEDIA_DEVICE;
+		payload: MediaDevice;
 	} | {
-			type: CallMetaType.MEDIA_SOURCE;
-			payload: MediaSourceStat;
+		type: CallMetaType.MEDIA_SOURCE;
+		payload: MediaSourceStat;
 	} | {
-			type: CallMetaType.USER_MEDIA_ERROR;
-			payload: string;
+		type: CallMetaType.USER_MEDIA_ERROR;
+		payload: string;
 	} | {
-			type: CallMetaType.OPERATION_SYSTEM;
-			payload: OperationSystem;
+		type: CallMetaType.OPERATION_SYSTEM;
+		payload: OperationSystem;
 	} | {
-			type: CallMetaType.PLATFORM;
-			payload: Platform;
+		type: CallMetaType.PLATFORM;
+		payload: Platform;
 	} | {
-			type: CallMetaType.ENGINE;
-			payload: Engine;
+		type: CallMetaType.ENGINE;
+		payload: Engine;
 	} | {
-			type: CallMetaType.LOCAL_SDP;
-			payload: string;
+		type: CallMetaType.LOCAL_SDP;
+		payload: string;
 	} | {
-			type: CallMetaType.BROWSER;
-			payload: Browser;
+		type: CallMetaType.BROWSER;
+		payload: Browser;
 	};
 
 export function createCallMetaReport(
@@ -96,5 +97,6 @@ export function createCallMetaReport(
 		payload: JSON.stringify(reportType.payload),
 		timestamp: timestamp ?? Date.now(),
 	};
+	
 	return report;
 }

package/src/common/logger.ts

@@ -1,186 +1,194 @@
 export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
 
 export interface Logger {
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    trace(...args: any[]): void;
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    debug(...args: any[]): void;
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    info(...args: any[]): void;
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    warn(...args: any[]): void;
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    error(...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	trace(...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	debug(...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	info(...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	warn(...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	error(...args: any[]): void;
 }
 
 export interface WrappedLogger extends Logger {
-    init(): void;
-    level: LogLevel | undefined,
+	init(): void;
+	level: LogLevel | undefined,
 	logger: Logger;
 }
 
 export type LoggerFactory = () => Logger;
 
 const COLORS = {
-    black: "\x1b[30m",
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    magenta: "\x1b[35m",
-    cyan: "\x1b[36m",
-    white: "\x1b[37m",
-    default: "\x1b[39m",
+	black: '\x1b[30m',
+	red: '\x1b[31m',
+	green: '\x1b[32m',
+	yellow: '\x1b[33m',
+	blue: '\x1b[34m',
+	magenta: '\x1b[35m',
+	cyan: '\x1b[36m',
+	white: '\x1b[37m',
+	default: '\x1b[39m',
 };
 
-let defaultLevel: LogLevel = "error";
+let defaultLevel: LogLevel = 'error';
 const created = Date.now();
 
 function createDefaultLoggerFactory(): LoggerFactory {
-    return () => {
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        const trace = (...args: any[]) => {
-            /* eslint-disable no-debugger, no-console */
-            console.trace(...args);
-        };
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        const debug = (...args: any[]) => {
-            /* eslint-disable no-debugger, no-console */
-            console.debug(...args);
-        };
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        const info = (...args: any[]) => {
-            /* eslint-disable no-debugger, no-console */
-            console.info(...args);
-        };
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        const warn = (...args: any[]) => {
-            /* eslint-disable no-debugger, no-console */
-            console.warn(...args);
-        };
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        const error = (...args: any[]) => {
-            /* eslint-disable no-debugger, no-console */
-            console.error(...args);
-        };
-        return {
-            trace,
-            debug,
-            info,
-            warn,
-            error,
-        }
-    }
+	return () => {
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		const trace = (...args: any[]) => {
+			/* eslint-disable no-debugger, no-console */
+			console.trace(...args);
+		};
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		const debug = (...args: any[]) => {
+			/* eslint-disable no-debugger, no-console */
+			console.debug(...args);
+		};
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		const info = (...args: any[]) => {
+			/* eslint-disable no-debugger, no-console */
+			console.info(...args);
+		};
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		const warn = (...args: any[]) => {
+			/* eslint-disable no-debugger, no-console */
+			console.warn(...args);
+		};
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		const error = (...args: any[]) => {
+			/* eslint-disable no-debugger, no-console */
+			console.error(...args);
+		};
+		
+		return {
+			trace,
+			debug,
+			info,
+			warn,
+			error,
+		};
+	};
 }
 
 const wrapLogger = (logger: Logger, moduleName: string, logLevel?: LogLevel) => {
 
-    let isTrace = false;
-    let isDebug = false
-    let isInfo = false
-    let isWarning = false;
-    let isError = false;
+	let isTrace = false;
+	let isDebug = false;
+	let isInfo = false;
+	let isWarning = false;
+	let isError = false;
 
-    let _level = logLevel;
-    let _logger = logger;
+	let _level = logLevel;
+	let _logger = logger;
 	const tracePrefix = `${COLORS.magenta}[TRACE]${COLORS.default} ${moduleName}`;
 	const debugPrefix = `${COLORS.cyan}[DEBUG]${COLORS.default} ${moduleName}`;
 	const infoPrefix = `${COLORS.green}[INFO]${COLORS.default} ${moduleName}`;
 	const warnPrefix = `${COLORS.yellow}[WARN]${COLORS.default} ${moduleName}`;
 	const errorPrefix = `${COLORS.red}[ERROR]${COLORS.default} ${moduleName}`;
 
-    const result = new class implements WrappedLogger {
-        public init() {
-            isTrace = ["trace"].includes(_level ?? defaultLevel);
-            isDebug = ["trace", "debug"].includes(_level ?? defaultLevel);
-            isInfo = ["trace", "debug", "info"].includes(_level ?? defaultLevel);
-            isWarning = ["trace", "debug", "info", "warn"].includes(_level ?? defaultLevel);
-            isError = ["trace", "debug", "info", "warn", "error"].includes(_level ?? defaultLevel);
-        }
+	const result = new class implements WrappedLogger {
+		public init() {
+			isTrace = [ 'trace' ].includes(_level ?? defaultLevel);
+			isDebug = [ 'trace', 'debug' ].includes(_level ?? defaultLevel);
+			isInfo = [ 'trace', 'debug', 'info' ].includes(_level ?? defaultLevel);
+			isWarning = [ 'trace', 'debug', 'info', 'warn' ].includes(_level ?? defaultLevel);
+			isError = [ 'trace', 'debug', 'info', 'warn', 'error' ].includes(_level ?? defaultLevel);
+		}
 		public get logger() {
 			return _logger;
 		}
 		public set logger(value: Logger) {
 			_logger = value;
 		}
-        public get level(): LogLevel | undefined {
-            return _level;
-        }
-        public set level(value: LogLevel | undefined) {
-            _level = value;
-        }
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        trace(...args: any[]): void {
-            if (isTrace) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`
-                logger.trace(tracePrefix, ...args, elapsedInMs);
-            }
-        }
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        debug(...args: any[]): void {
-            if (isDebug) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`
-                logger.debug(debugPrefix, ...args, elapsedInMs);
-            }
-        }
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        info(...args: any[]): void {
-            if (isInfo) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`
-                logger.info(infoPrefix, ...args, elapsedInMs);
-            }
-        }
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        warn(...args: any[]): void {
-            if (isWarning) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`
-                logger.warn(warnPrefix, ...args, elapsedInMs);
-            }
-        }
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        error(...args: any[]): void {
-            if (isError) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`
-                logger.error(errorPrefix, ...args, elapsedInMs);
-            }
-            
-        }
-    }
-    return result;
-}
+		public get level(): LogLevel | undefined {
+			return _level;
+		}
+		public set level(value: LogLevel | undefined) {
+			_level = value;
+		}
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		trace(...args: any[]): void {
+			if (isTrace) {
+				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
+
+				logger.trace(tracePrefix, ...args, elapsedInMs);
+			}
+		}
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		debug(...args: any[]): void {
+			if (isDebug) {
+				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
+
+				logger.debug(debugPrefix, ...args, elapsedInMs);
+			}
+		}
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		info(...args: any[]): void {
+			if (isInfo) {
+				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
 
+				logger.info(infoPrefix, ...args, elapsedInMs);
+			}
+		}
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		warn(...args: any[]): void {
+			if (isWarning) {
+				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
+
+				logger.warn(warnPrefix, ...args, elapsedInMs);
+			}
+		}
+		/* eslint-disable @typescript-eslint/no-explicit-any */
+		error(...args: any[]): void {
+			if (isError) {
+				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
+
+				logger.error(errorPrefix, ...args, elapsedInMs);
+			}
+            
+		}
+	};
+	
+	return result;
+};
 
 let actualLoggerFactory: LoggerFactory = createDefaultLoggerFactory();
 const loggers = new Map<string, WrappedLogger>();
 
 export const createLogger = (moduleName: string, logLevel?: LogLevel) => {
 	let wrappedLogger = loggers.get(moduleName);
+
 	if (!wrappedLogger) {
-        const logger = actualLoggerFactory();
+		const logger = actualLoggerFactory();
+
 		wrappedLogger = wrapLogger(logger, moduleName, logLevel ?? defaultLevel);
 		loggers.set(moduleName, wrappedLogger);
 	} else {
 		wrappedLogger.level = logLevel ?? defaultLevel;
-    }
-    wrappedLogger.init();
-    return wrappedLogger;
-}
+	}
+	wrappedLogger.init();
+	
+	return wrappedLogger;
+};
 
 export const setLogLevel = (level: LogLevel) => {
-    defaultLevel = level;
-    for (const [moduleName] of Array.from(loggers.entries())) {
-        loggers.set(moduleName, createLogger(moduleName, level));
-    }
+	defaultLevel = level;
+	for (const [ moduleName ] of Array.from(loggers.entries())) {
+		loggers.set(moduleName, createLogger(moduleName, level));
+	}
 };
 
 export const setLoggerFactory = (loggerFactory: LoggerFactory) => {
-    actualLoggerFactory = loggerFactory;
-    for (const [moduleName, logger] of Array.from(loggers.entries())) {
-        loggers.set(moduleName, createLogger(moduleName, logger.level));
-    }
+	actualLoggerFactory = loggerFactory;
+	for (const [ moduleName, logger ] of Array.from(loggers.entries())) {
+		loggers.set(moduleName, createLogger(moduleName, logger.level));
+	}
 };
 
 export const getLogLevel = () => {
-    return defaultLevel;
-}
-
+	return defaultLevel;
+};

package/src/common/types.ts

@@ -131,4 +131,4 @@ export interface ObserverSinkContext {
 	readonly sfuMetaReports: SfuMetaReport[];
 }
 
-export type ObserverSinkMiddleware = Middleware<ObserverSinkContext>;
+export type ObserverSinkMiddleware = Middleware<ObserverSinkContext>;

package/src/common/utils.ts

@@ -10,5 +10,16 @@ export function iteratorConverter<T>(generator: Generator<T, void, undefined>):
 		next(): IteratorResult<T> {
 			return generator.next();
 		},
-	}
+	};
+}
+
+export function asyncIteratorConverter<T>(generator: AsyncGenerator<T, void, undefined>): AsyncIterableIterator<T> {
+	return {
+		[Symbol.asyncIterator](): AsyncIterableIterator<T> {
+			return this;
+		},
+		next(): Promise<IteratorResult<T>> {
+			return generator.next();
+		},
+	};
 }

package/src/entries/CallEntry.ts

@@ -0,0 +1,62 @@
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { createLogger } from '../common/logger';
+import { asyncIteratorConverter } from '../common/utils';
+import { ClientEntry, createClientEntry } from './ClientEntry';
+
+export const logger = createLogger('CallWrapper');
+
+export type CallEntry = ReturnType<typeof createCallEntry>;
+
+export function createCallEntry(storageProvider: StorageProvider, model?: Models.Call) {
+	if (!model) return;
+	const { 
+		callId,
+		roomId,
+		serviceId,
+		started,
+	} = model;
+
+	if (!callId) return logger.warn(`Call model without callId: ${JSON.stringify(model)}`);
+	if (!roomId) return logger.warn(`Call model without roomId: ${JSON.stringify(model)}`);
+	if (!serviceId) return logger.warn(`Call model without serviceId: ${JSON.stringify(model)}`);
+	if (!started) return logger.warn(`Call model without started: ${JSON.stringify(model)}`);
+
+	const getClient = async (clientId: string) => {
+		return model.clientIds.includes(clientId) ? createClientEntry(storageProvider, await storageProvider.clientStorage.get(clientId)) : undefined;
+	};
+
+	const asyncClientsGenerator = async function *(providedClientIds?: string[]) {
+		const { clientStorage } = storageProvider;
+		const clientModels = await Promise.all(
+			(providedClientIds ?? model.clientIds).map((clientId) => clientStorage.get(clientId))
+		);
+
+		for (const clientModel of clientModels) {
+			if (!clientModel) continue;
+			yield createClientEntry(storageProvider, clientModel);
+		}
+	};
+	
+	return {
+		callId,
+		roomId, 
+		serviceId,
+		started,
+		get clientIds(): ReadonlyArray<string> {
+			return model.clientIds;
+		},
+		getClient,
+		get clients(): AsyncIterableIterator<ClientEntry> {
+			return asyncIteratorConverter<ClientEntry>(asyncClientsGenerator());
+		},
+
+		refresh: async () => {
+			const refreshedModel = await storageProvider.callStorage.get(callId);
+
+			if (!refreshedModel) return;
+
+			model.clientIds = refreshedModel.clientIds;
+		}
+	};
+}

package/src/entries/ClientEntry.ts

@@ -0,0 +1,90 @@
+import * as Models from '../models/Models';
+import { StorageProvider } from '../storages/StorageProvider';
+import { logger, createCallEntry } from './CallEntry';
+import { asyncIteratorConverter } from '../common/utils';
+import { PeerConnectionEntry, createPeerConnectionEntry } from './PeerConnectionEntry';
+
+export type ClientEntry = ReturnType<typeof createClientEntry>;
+
+export function createClientEntry(storageProvider: StorageProvider, model?: Models.Client) {
+	if (!model) return;
+
+	const {
+		clientId, 
+		roomId, 
+		serviceId, 
+		mediaUnitId, 
+		callId, 
+		joined, 
+		timeZoneId, 
+	} = model;
+
+	if (!callId) return logger.warn(`Client model without callId: ${JSON.stringify(model)}`);
+	if (!roomId) return logger.warn(`Client model without roomId: ${JSON.stringify(model)}`);
+	if (!clientId) return logger.warn(`Client model without clientId: ${JSON.stringify(model)}`);
+	if (!serviceId) return logger.warn(`Client model without serviceId: ${JSON.stringify(model)}`);
+	if (!mediaUnitId) return logger.warn(`Client model without mediaUnitId: ${JSON.stringify(model)}`);
+
+	const getCall = async () => {
+		return createCallEntry(storageProvider, await storageProvider.callStorage.get(callId));
+	};
+
+	const asyncPeerConnectionGenerator = async function *(providedPeerConnectionIds?: string[]) {
+		const peerConnectionModels = await Promise.all(
+			(providedPeerConnectionIds ?? model.peerConnectionIds).map((peerConnectionId) => storageProvider.peerConnectionStorage.get(peerConnectionId))
+		);
+
+		for (const peerConnectionModel of peerConnectionModels) {
+			if (!peerConnectionModel) continue;
+			yield createPeerConnectionEntry(storageProvider, peerConnectionModel);
+		}
+	};
+
+	return {
+		clientId,
+		roomId,
+		serviceId,
+		mediaUnitId,
+		callId,
+		joined,
+		timeZoneId,
+		get browser() {
+			return model.browser;
+		},
+		get engine() {
+			return model.engine;
+		},
+		get operationSystem() {
+			return model.operationSystem;
+		},
+		get platform() {
+			return model.platform;
+		},
+		get peerConnectionIds(): ReadonlyArray<string> {
+			return model.peerConnectionIds;
+		},
+		get marker() {
+			return model.marker;
+		},
+		getCall,
+		get peerConnections(): AsyncIterableIterator<PeerConnectionEntry> {
+			return asyncIteratorConverter<PeerConnectionEntry>(asyncPeerConnectionGenerator());
+		},
+		getPeerConnection: async (peerConnectionId: string) => {
+			return model.peerConnectionIds.includes(peerConnectionId) ? createPeerConnectionEntry(storageProvider, await storageProvider.peerConnectionStorage.get(peerConnectionId)) : undefined;
+		},
+
+		refresh: async () => {
+			const refreshedModel = await storageProvider.clientStorage.get(clientId);
+
+			if (!refreshedModel) return;
+
+			model.browser = refreshedModel.browser;
+			model.engine = refreshedModel.engine;
+			model.operationSystem = refreshedModel.operationSystem;
+			model.platform = refreshedModel.platform;
+			model.peerConnectionIds = refreshedModel.peerConnectionIds;
+			model.marker = refreshedModel.marker;
+		}
+	};
+}

package/src/entries/InboundTrackEntry.ts

@@ -0,0 +1,74 @@
+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('InboundTrackWrapper');
+
+export type InboundTrackEntry = ReturnType<typeof createInboundTrackEntry>;
+
+export function createInboundTrackEntry(storageProvider: StorageProvider, model?: Models.InboundTrack) {
+	if (!model) return;
+	const {
+		callId,
+		clientId,
+		peerConnectionId,
+		trackId,
+		kind,
+	} = model;
+
+	if (!callId) return logger.warn(`InboundTrack model without callId: ${JSON.stringify(model)}`);
+	if (!clientId) return logger.warn(`InboundTrack model without clientId: ${JSON.stringify(model)}`);
+	if (!peerConnectionId) return logger.warn(`InboundTrack model without peerConnectionId: ${JSON.stringify(model)}`);
+	if (!trackId) return logger.warn(`InboundTrack model without trackId: ${JSON.stringify(model)}`);
+	if (!kind) return logger.warn(`InboundTrack model without kind: ${JSON.stringify(model)}`);
+
+	const direction = 'inbound' 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,
+
+		async refresh() {
+			const refreshedModel = await storageProvider.inboundTrackStorage.get(trackId);
+
+			if (!refreshedModel) return;
+
+			model.audioStats = refreshedModel.audioStats;
+			model.videoStats = refreshedModel.videoStats;
+			model.marker = refreshedModel.marker;
+			model.ssrc = refreshedModel.ssrc;
+		}
+
+	};
+}