@observertc/observer-js 0.30.6-beta → 0.40.0-beta

package/src/ObservedSfu.ts

@@ -1,14 +1,11 @@
 import { EventEmitter } from 'events';
-import * as Models from './models/Models';
 import { Observer } from './Observer';
-import { createSingleExecutor } from './common/SingleExecutor';
 import { SfuSample } from '@observertc/sample-schemas-js';
 
-export type ObservedSfuConfig<AppData extends Record<string, unknown> = Record<string, unknown>> = {
+export type ObservedSfuModel= {
 	serviceId: string;
 	sfuId: string;
 	joined?: number;
-	appData: AppData;
 };
 
 export type ObservedSfuEvents = {
@@ -24,36 +21,13 @@ export declare interface ObservedSfu {
 }
 
 export class ObservedSfu<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
-	public static async create<T extends Record<string, unknown> = Record<string, unknown>>(
-		config: ObservedSfuConfig<T>, 
-		observer: Observer,
-		// reportsCollector: ReportsCollector,
-	) {
-		const model = new Models.Sfu({
-			serviceId: config.serviceId,
-			sfuId: config.sfuId,
-			sfuTransportIds: [],
-			joined: BigInt(config.joined ?? Date.now()),
-		});
-		const result = new ObservedSfu(
-			model,
-			observer,
-			config.appData,
-		);
-
-		const alreadyInserted = await observer.storage.sfuStorage.insert(config.sfuId, model);
-
-		if (alreadyInserted) throw new Error(`Sfu with id ${config.sfuId} already exists`);
-
-		return result;
-	}
+	public readonly created = Date.now();
 
 	private _updated = Date.now();
-	private readonly _execute = createSingleExecutor();
 	private _closed = false;
 	
-	private constructor(
-		private readonly _model: Models.Sfu,
+	public constructor(
+		private readonly _model: ObservedSfuModel,
 		public readonly observer: Observer,
 		public readonly appData: AppData,
 	) {
@@ -75,6 +49,10 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 		return Number(this._model.joined!);
 	}
 
+	public get updated() {
+		return this._updated;
+	}
+
 	public get closed() {
 		return this._closed;
 	}
@@ -85,24 +63,11 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 		this.emit('close');
 	}
 
-	public async update(sample: SfuSample) {
+	public update(sample: SfuSample) {
 		if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
 		if (sample.sfuId !== this.sfuId) throw new Error(`Sfu ${this.sfuId} is not the same as sample.sfuId`);
 		
-		return this._execute(async () => {
-			if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
-			await this._save();
-			this.emit('update');
-		});
-	}
-
-	private async _save() {
-		if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
-		
-		return this._execute(async () => {
-			if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
-			await this.observer.storage.sfuStorage.set(this.sfuId, this._model);
-		});		
+		this._updated = Date.now();
+		this.emit('update');
 	}
-	
 }

package/src/Observer.ts

@@ -1,10 +1,9 @@
 import { createLogger } from './common/logger';
-import { StorageProvider, createSimpleStorageProvider } from './storages/StorageProvider';
-import { ObservedCall, ObservedCallConfig } from './ObservedCall';
+import { ObservedCall, ObservedCallModel } from './ObservedCall';
 import { ReportsCollector } from './ReportsCollector';
 import { EventEmitter } from 'events';
 import { PartialBy } from './common/utils';
-import { createCallStartedEventReport } from './common/callEventReports';
+import { createCallEndedEventReport, createCallStartedEventReport } from './common/callEventReports';
 
 const logger = createLogger('Observer');
 
@@ -36,8 +35,6 @@ export type ObserverConfig = {
 	maxCollectingTimeInMs?: number | undefined;
 	
 	maxEntryIdleTimeInMs?: number | undefined;
-
-	storages?: StorageProvider;
 };
 
 export declare interface Observer {
@@ -63,9 +60,7 @@ export class Observer extends EventEmitter {
 			providedConfig
 		);
 
-		const storages = providedConfig.storages ?? createSimpleStorageProvider();
-		
-		return new Observer(config, storages);
+		return new Observer(config);
 	}
 
 	public readonly reports = new ReportsCollector();
@@ -74,7 +69,6 @@ export class Observer extends EventEmitter {
 	private _closed = false;
 	public constructor(
 		public readonly config: ObserverConfig,
-		public readonly storage: StorageProvider,
 	) {
 		super();
 		logger.debug('Observer is created with config', this.config);
@@ -91,25 +85,26 @@ export class Observer extends EventEmitter {
 		this.reports.on('newreport', onNewReport);
 	}
 
-	public async createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(
-		config: PartialBy<ObservedCallConfig<T>, 'serviceId' | 'started'>
-	): Promise<ObservedCall<T>> {
+	public createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(
+		config: PartialBy<ObservedCallModel, 'serviceId' | 'started'> & { appData: T }
+	): ObservedCall<T> {
 		if (this._closed) {
 			throw new Error('Attempted to create a call source on a closed observer');
 		}
 
-		const call = await ObservedCall.create({
+		const { appData, ...model } = config;
+		const call = new ObservedCall({
+			...model,
 			serviceId: this.config.defaultServiceId,
 			started: Date.now(),
-			...config,
-		}, this);
+		}, this, appData);
 
 		if (this._closed) throw new Error('Cannot create an observed call on a closed observer');
 		if (this._observedCalls.has(call.callId)) throw new Error(`Observed Call with id ${call.callId} already exists`);
 
 		call.once('close', () => {
 			this._observedCalls.delete(call.callId);
-			this.reports.addCallEventReport(createCallStartedEventReport(
+			this.reports.addCallEventReport(createCallEndedEventReport(
 				call.serviceId,
 				call.roomId,
 				call.callId,

package/src/common/types.ts

@@ -18,78 +18,9 @@ import {
 	SfuSctpStreamReport,
 	SFUTransportReport,
 } from '@observertc/report-schemas-js';
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { Message } from '@bufbuild/protobuf';
 
 export type MediaKind = 'audio' | 'video';
 
-export interface EvaluatorContext {
-	readonly startedCallIds: string[];
-	readonly endedCalls: (Omit<Models.Call, keyof Message> & {
-		ended: number;
-	})[];
-
-	readonly joinedClientIds: string[];
-	readonly detachedClients: (Omit<Models.Client, keyof Message> & {
-		detached: number;
-	})[];
-
-	readonly openedPeerConnectionIds: string[];
-	readonly closedPeerConnections: (Omit<Models.PeerConnection, keyof Message> & {
-		closed: number;
-	})[];
-
-	readonly addedInboundAudioTrackIds: string[];
-	readonly removedInboundAudioTracks: (Omit<Models.InboundTrack, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly addedInboundVideoTrackIds: string[];
-	readonly removedInboundVideoTracks: (Omit<Models.InboundTrack, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly addedOutboundAudioTrackIds: string[];
-	readonly removedOutboundAudioTracks: (Omit<Models.OutboundTrack, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly addedOutboundVideoTrackIds: string[];
-	readonly removedOutboundVideoTracks: (Omit<Models.OutboundTrack, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly joinedSfuIds: string[];
-	readonly detachedSfus: (Omit<Models.Sfu, keyof Message> & {
-		detached: number;
-	})[];
-
-	readonly openedSfuTransportIds: string[];
-	readonly closedSfuTransports: (Omit<Models.SfuTransport, keyof Message> & {
-		closed: number;
-	})[];
-
-	readonly addedSfuInbounRtpPadIds: string[];
-	readonly removedSfuInbounRtpPadIds: (Omit<Models.SfuInboundRtpPad, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly addedSfuOutbounRtpPadIds: string[];
-	readonly removedSfuOutbounRtpPadIds: (Omit<Models.SfuOutboundRtpPad, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly openedSfuSctpChannelIds: string[];
-	readonly closedSfuSctpChannels: (Omit<Models.SfuSctpChannel, keyof Message> & {
-		closed: number;
-	})[];
-
-	readonly storages: StorageProvider;
-	readonly reports: ObserverSinkContext;
-
-}
-
 // export type EvaluatorMiddleware = Middleware<EvaluatorContext>;
 
 export interface ObserverSinkContext {

package/src/index.ts

@@ -1,8 +1,6 @@
 export type { ObserverConfig, ObserverEvents } from './Observer';
 
 export { Observer } from './Observer';
-export type { ObserverStorage } from './storages/ObserverStorage';
-export type { StorageProvider } from './storages/StorageProvider';
 
 export * as SampleSchema from '@observertc/sample-schemas-js';
 export * as ReportSchema from '@observertc/report-schemas-js';
@@ -54,12 +52,12 @@ export type {
 	SFUTransportReport,
 } from '@observertc/report-schemas-js';
 
-export type { ObservedClient, ObservedClientConfig } from './ObservedClient';
-export type { ObservedPeerConnection, ObservedPeerConnectionConfig, ObservedPeerConnectionEvents } from './ObservedPeerConnection';
-export type { ObservedInboundTrack, ObservedInboundTrackConfig, ObservedInboundTrackEvents } from './ObservedInboundTrack';
-export type { ObservedOutboundTrack, ObservedOutboundTrackConfig, ObservedOutboundTrackEvents } from './ObservedOutboundTrack';
+export type { ObservedClient, ObservedClientModel } from './ObservedClient';
+export type { ObservedPeerConnection, ObservedPeerConnectionModel, ObservedPeerConnectionEvents } from './ObservedPeerConnection';
+export type { ObservedInboundTrack, ObservedInboundTrackModel, ObservedInboundTrackEvents } from './ObservedInboundTrack';
+export type { ObservedOutboundTrack, ObservedOutboundTrackModel, ObservedOutboundTrackEvents } from './ObservedOutboundTrack';
 
-export type { EvaluatorContext, ObserverSinkContext } from './common/types';
+export type { ObserverSinkContext } from './common/types';
 
 import { Observer, ObserverConfig } from './Observer';
 export function createObserver(config?: Partial<ObserverConfig>) {