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

package/src/ObservedInboundTrack.ts

@@ -1,14 +1,11 @@
 import { EventEmitter } from 'events';
-import { StorageProvider } from './storages/StorageProvider';
-import * as Models from './models/Models';
 import { ObservedPeerConnection } from './ObservedPeerConnection';
 import { InboundAudioTrack, InboundVideoTrack } from '@observertc/sample-schemas-js';
 import { ObservedOutboundTrack } from './ObservedOutboundTrack';
 import { InboundAudioTrackReport, InboundVideoTrackReport } from '@observertc/report-schemas-js';
 import { MediaKind } from './common/types';
-import { createSingleExecutor } from './common/SingleExecutor';
 
-export type ObservedInboundTrackConfig<K extends MediaKind> = {
+export type ObservedInboundTrackModel<K extends MediaKind> = {
 	trackId: string;
 	kind: K;
 	sfuStreamId?: string;
@@ -51,35 +48,9 @@ export declare interface ObservedInboundTrack<Kind extends MediaKind> {
 }
 
 export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
-	public static async create<K extends MediaKind>(
-		config: ObservedInboundTrackConfig<K>,
-		peerConnection: ObservedPeerConnection,
-		storageProvider: StorageProvider,
-	) {
-		const model = new Models.InboundTrack({
-			serviceId: peerConnection.client.serviceId,
-			roomId: peerConnection.client.roomId,
-			callId: peerConnection.client.callId,
-			clientId: peerConnection.client.clientId,
-			mediaUnitId: peerConnection.client.mediaUnitId,
-			peerConnectionId: peerConnection.peerConnectionId,
-			trackId: config.trackId,
-			kind: config.kind,
-			sfuStreamId: config.sfuStreamId,
-			sfuSinkId: config.sfuSinkId,
-		});
-
-		const alreadyInserted = await storageProvider.inboundTrackStorage.insert(config.trackId, model);
-
-		if (alreadyInserted) throw new Error(`InboundAudioTrack with id ${config.trackId} already exists`);
-
-		return new ObservedInboundTrack<K>(model, peerConnection, storageProvider);
-	}
-	
-	public created = Date.now();
+	public readonly created = Date.now();
 
 	private readonly _stats = new Map<number, ObservedInboundTrackStats<Kind>>();
-	private readonly _execute = createSingleExecutor();
 	
 	private _closed = false;
 	private _updated = Date.now();
@@ -106,52 +77,43 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 	public deltaReceivedSamples = 0;
 	public deltaSilentConcealedSamples = 0;
 	
-	private constructor(
-		private readonly _model: Models.InboundTrack,
+	public constructor(
+		private readonly _model: ObservedInboundTrackModel<Kind>,
 		public readonly peerConnection: ObservedPeerConnection,
-		private readonly _storageProvider: StorageProvider,
 	) {
 		super();
 	}
 
 	public get serviceId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.serviceId!;
+		return this.peerConnection.serviceId;
 	}
 
 	public get roomId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.roomId!;
+		return this.peerConnection.roomId;
 	}
 
 	public get callId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.callId!;
+		return this.peerConnection.callId;
 	}
 
 	public get clientId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.clientId!;
+		return this.peerConnection.clientId;
 	}
 
 	public get mediaUnitId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.mediaUnitId!;
+		return this.peerConnection.mediaUnitId;
 	}
 
 	public get peerConnectionId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.peerConnectionId!;
+		return this.peerConnection.peerConnectionId;
 	}
 
 	public get trackId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.trackId!;
+		return this._model.trackId;
 	}
 
 	public get kind(): Kind {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.kind! as Kind;
+		return this._model.kind as Kind;
 	}
 
 	public get sfuStreamId() {
@@ -202,9 +164,7 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 
 		this._closed = true;
 
-		this._execute(() => this._storageProvider.inboundTrackStorage.remove(this.trackId))
-			.catch(() => void 0)
-			.finally(() => this.emit('close'));
+		this.emit('close');
 	}
 
 	public resetMetrics() {
@@ -220,9 +180,8 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 		this.fractionLoss = 0;
 	}
 
-	public async update(sample: ObservedInboundTrackStatsUpdate<Kind>, timestamp: number) {
+	public update(sample: ObservedInboundTrackStatsUpdate<Kind>, timestamp: number) {
 		if (this._closed) return;
-		let executeSave = false;
 
 		const report: InboundAudioTrackReport | InboundVideoTrackReport = {
 			serviceId: this.peerConnection.client.call.serviceId,
@@ -247,12 +206,10 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 		
 		if (!this._model.sfuStreamId && sample.sfuStreamId) {
 			this._model.sfuStreamId = sample.sfuStreamId;
-			executeSave = true;
 		}
 
 		if (!this._model.sfuSinkId && sample.sfuSinkId) {
 			this._model.sfuSinkId = sample.sfuSinkId;
-			executeSave = true;
 		}
 
 		const elapsedTimeInMs = Math.max(1, timestamp - this._updated);
@@ -318,15 +275,7 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 		this.deltaSilentConcealedSamples = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.silentConcealedSamples ?? 0), 0);
 		this.fractionLoss = 0 < this.deltaReceivedPackets && 0 < this.deltaLostPackets ? (this.deltaLostPackets / (this.deltaReceivedPackets + this.deltaLostPackets)) : 0;
 
-		if (executeSave) await this._save();
-
 		this._updated = timestamp;
 		this.emit('update');
 	}
-
-	private async _save() {
-		if (this._closed) throw new Error(`OutboundTrack ${this.trackId} is closed`);
-		
-		return this._storageProvider.inboundTrackStorage.set(this.trackId, this._model);
-	}
 }

package/src/ObservedOutboundTrack.ts

@@ -1,14 +1,11 @@
 import { EventEmitter } from 'events';
-import { StorageProvider } from './storages/StorageProvider';
-import * as Models from './models/Models';
 import { ObservedPeerConnection } from './ObservedPeerConnection';
 import { OutboundAudioTrack, OutboundVideoTrack } from '@observertc/sample-schemas-js';
 import { ObservedInboundTrack } from './ObservedInboundTrack';
 import { OutboundAudioTrackReport, OutboundVideoTrackReport } from '@observertc/report-schemas-js';
 import { MediaKind } from './common/types';
-import { createSingleExecutor } from './common/SingleExecutor';
 
-export type ObservedOutboundTrackConfig<K extends MediaKind> = {
+export type ObservedOutboundTrackModel<K extends MediaKind> = {
 	trackId: string;
 	kind: K;
 	sfuStreamId?: string;
@@ -46,29 +43,7 @@ export declare interface ObservedOutboundTrack<Kind extends MediaKind> {
 }
 
 export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter	{
-	public static async create<K extends MediaKind>(
-		config: ObservedOutboundTrackConfig<K>,
-		peerConnection: ObservedPeerConnection,
-		storageProvider: StorageProvider,
-	) {
-		const model = new Models.OutboundTrack({
-			serviceId: peerConnection.client.serviceId,
-			roomId: peerConnection.client.roomId,
-			callId: peerConnection.client.callId,
-			clientId: peerConnection.client.clientId,
-			mediaUnitId: peerConnection.client.mediaUnitId,
-			peerConnectionId: peerConnection.peerConnectionId,
-			trackId: config.trackId,
-			kind: config.kind,
-			sfuStreamId: config.sfuStreamId,
-		});
-
-		const alreadyInserted = await storageProvider.outboundTrackStorage.insert(config.trackId, model);
-
-		if (alreadyInserted) throw new Error(`OutboundAudioTrack with id ${config.trackId} already exists`);
-
-		return new ObservedOutboundTrack<K>(model, peerConnection, storageProvider);
-	}
+	public readonly created = Date.now();
 
 	public bitrate = 0;
 	public rttInMs?: number;
@@ -84,31 +59,49 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 	public deltaSentFrames = 0;
 	public deltaEncodedFrames = 0;
 
-	public created = Date.now();
-
 	private readonly _stats = new Map<number, ObservedOutboundTrackStats<Kind>>();
-	private readonly _execute = createSingleExecutor();
 	
 	private _closed = false;
 	private _updated = Date.now();
 	private _remoteInboundTracks = new Map<string, ObservedInboundTrack<Kind>>();
 
-	private constructor(
-		private readonly _model: Models.OutboundTrack,
+	public constructor(
+		private readonly _model: ObservedOutboundTrackModel<Kind>,
 		public readonly peerConnection: ObservedPeerConnection,
-		private readonly _storageProvider: StorageProvider,
 	) {
 		super();
 	}
 
+	public get serviceId() {
+		return this.peerConnection.serviceId;
+	}
+
+	public get roomId() {
+		return this.peerConnection.roomId;
+	}
+
+	public get callId() {
+		return this.peerConnection.callId;
+	}
+
+	public get clientId() {
+		return this.peerConnection.clientId;
+	}
+
+	public get mediaUnitId() {
+		return this.peerConnection.mediaUnitId;
+	}
+
+	public get peerConnectionId() {
+		return this.peerConnection.peerConnectionId;
+	}
+
 	public get kind(): Kind {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.kind! as Kind;
+		return this._model.kind as Kind;
 	}
 	
 	public get trackId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.trackId!;
+		return this._model.trackId;
 	}
 
 	public get sfuStreamId() {
@@ -141,12 +134,9 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 	
 	public close() {
 		if (this._closed) return;
-
 		this._closed = true;
 
-		this._execute(() => this._storageProvider.inboundTrackStorage.remove(this.trackId))
-			.catch(() => void 0)
-			.finally(() => this.emit('close'));
+		this.emit('close');
 	}
 
 	public resetMetrics() {
@@ -160,9 +150,8 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 		this.deltaEncodedFrames = 0;
 	}
 
-	public async update(sample: ObservedOutboundTrackStatsUpdate<Kind>, timestamp: number): Promise<void> {
+	public update(sample: ObservedOutboundTrackStatsUpdate<Kind>, timestamp: number): void {
 		if (this._closed) return;
-		let executeSave = false;
 
 		const report: OutboundAudioTrackReport | OutboundVideoTrackReport = {
 			serviceId: this.peerConnection.client.serviceId,
@@ -237,12 +226,8 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 
 			if (this.kind === 'audio') this.peerConnection.client.call.sfuStreamIdToOutboundAudioTrack.set(this._model.sfuStreamId, this as ObservedOutboundTrack<'audio'>);
 			else if (this.kind === 'video') this.peerConnection.client.call.sfuStreamIdToOutboundVideoTrack.set(this._model.sfuStreamId, this as ObservedOutboundTrack<'video'>);
-
-			executeSave = true;
 		}
 
-		if (executeSave) await this._save();
-
 		this._updated = timestamp;
 		this.emit('update');
 	}
@@ -257,10 +242,4 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 
 		this._remoteInboundTracks.set(track.trackId, track);
 	}
-
-	private async _save() {
-		if (this._closed) throw new Error(`OutboundTrack ${this.trackId} is closed`);
-		
-		return this._storageProvider.outboundTrackStorage.set(this.trackId, this._model);
-	}
 }

package/src/ObservedPeerConnection.ts

@@ -1,12 +1,9 @@
 import { EventEmitter } from 'events';
-import * as Models from './models/Models';
-import { StorageProvider } from './storages/StorageProvider';
 import { PeerConnectionTransport } from '@observertc/sample-schemas-js';
 import { ObservedClient } from './ObservedClient';
-import { ObservedInboundTrack, ObservedInboundTrackConfig } from './ObservedInboundTrack';
-import { ObservedOutboundTrack, ObservedOutboundTrackConfig } from './ObservedOutboundTrack';
+import { ObservedInboundTrack, ObservedInboundTrackModel } from './ObservedInboundTrack';
+import { ObservedOutboundTrack, ObservedOutboundTrackModel } from './ObservedOutboundTrack';
 import { PeerConnectionTransportReport } from '@observertc/report-schemas-js';
-import { createSingleExecutor } from './common/SingleExecutor';
 import { ObservedICE } from './ObservedICE';
 
 export type ObservedPeerConnectionEvents = {
@@ -18,8 +15,9 @@ export type ObservedPeerConnectionEvents = {
 	newoutboundvideotrack: [ObservedOutboundTrack<'video'>],
 };
 
-export type ObservedPeerConnectionConfig = {
+export type ObservedPeerConnectionModel = {
 	peerConnectionId: string;
+	label?: string;
 };
 
 export type ObservedPeerConnectionStats = Omit<PeerConnectionTransport, 'transportId' | 'label'>;
@@ -32,27 +30,7 @@ export declare interface ObservedPeerConnection {
 }
 
 export class ObservedPeerConnection extends EventEmitter {
-	public static async create(
-		config: ObservedPeerConnectionConfig,
-		client: ObservedClient,
-		storageProvider: StorageProvider,
-	): Promise<ObservedPeerConnection> {
-		const model = new Models.PeerConnection({
-			roomId: client.roomId,
-			serviceId: client.serviceId,
-			callId: client.callId,
-			clientId: client.clientId,
-			peerConnectionId: config.peerConnectionId,
-		});
-
-		const alreadyInserted = await storageProvider.peerConnectionStorage.insert(config.peerConnectionId, model);
-
-		if (alreadyInserted) throw new Error(`PeerConnection with id ${config.peerConnectionId} already exists`);
-
-		return new ObservedPeerConnection(model, client, storageProvider);
-	}
-
-	public created = Date.now();
+	public readonly created = Date.now();
 
 	public totalInboundPacketsLost = 0;
 	public totalInboundPacketsReceived = 0;
@@ -99,20 +77,42 @@ export class ObservedPeerConnection extends EventEmitter {
 	private readonly _inboundVideoTracks = new Map<string, ObservedInboundTrack<'video'>>();
 	private readonly _outboundAudioTracks = new Map<string, ObservedOutboundTrack<'audio'>>();
 	private readonly _outboundVideoTracks = new Map<string, ObservedOutboundTrack<'video'>>();
-	private readonly _execute = createSingleExecutor();
 	
-	private constructor(
-		private readonly _model: Models.PeerConnection,
+	public constructor(
+		private readonly _model: ObservedPeerConnectionModel,
 		public readonly client: ObservedClient,
-		private readonly _storageProvider: StorageProvider,
 	) {
 		super();
 	}
 
+	public get serviceId() {
+		return this.client.serviceId;
+	}
+
+	public get roomId() {
+		return this.client.roomId;
+	}
+
+	public get callId() {
+		return this.client.callId;
+	}
+
+	public get clientId() {
+		return this.client.clientId;
+	}
+
+	public get mediaUnitId() {
+		return this.client.mediaUnitId;
+	}
+
 	public get label() {
 		return this._model.label;
 	}
 
+	public set label(value: string | undefined) {
+		this._model.label = value;
+	}
+
 	public get usingTURN() {
 		return this.ICE.selectedRemoteCandidate?.candidateType?.toLowerCase() === 'relay';
 	}
@@ -175,9 +175,7 @@ export class ObservedPeerConnection extends EventEmitter {
 		Array.from(this._outboundAudioTracks.values()).forEach((track) => track.close());
 		Array.from(this._outboundVideoTracks.values()).forEach((track) => track.close());
 
-		this._execute(() => this._storageProvider.peerConnectionStorage.remove(this.peerConnectionId))
-			.catch(() => void 0)
-			.finally(() => this.emit('close')); 
+		this.emit('close');
 	}
 
 	public getTrack(trackId: string): ObservedInboundTrack<'audio'> | ObservedInboundTrack<'video'> | ObservedOutboundTrack<'audio'> | ObservedOutboundTrack<'video'> | undefined {
@@ -297,14 +295,13 @@ export class ObservedPeerConnection extends EventEmitter {
 		this.avgRttInMs = 0 < nrOfBelongings ? sumRttInMs / nrOfBelongings : undefined;
 	}
 
-	public async update(sample: PeerConnectionTransport, timestamp: number) {
+	public update(sample: PeerConnectionTransport, timestamp: number) {
 		if (this._closed) return;
 		if (sample.peerConnectionId !== this._model.peerConnectionId) throw new Error(`TransportId mismatch. PeerConnectionId: ${ this._model.peerConnectionId } TransportId: ${ sample.transportId}`);
 
 		this._sample = sample;
 		if (this._model.label !== sample.label) {
 			this._model.label = sample.label;
-			await this._save().catch(() => void 0);
 		}
 
 		const report: PeerConnectionTransportReport = {
@@ -321,138 +318,79 @@ export class ObservedPeerConnection extends EventEmitter {
 
 		this.reports.addPeerConnectionTransportReports(report);
 		
-		this._updated = timestamp;
+		this._updated = Date.now();
 		this.emit('update');
 	}
 
-	public async createInboundAudioTrack(config: Omit<ObservedInboundTrackConfig<'audio'>, 'kind'>): Promise<ObservedInboundTrack<'audio'>> {
+	public createInboundAudioTrack(config: Omit<ObservedInboundTrackModel<'audio'>, 'kind'>): ObservedInboundTrack<'audio'> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-
-		const result = await ObservedInboundTrack.create<'audio'>({
+		
+		const result = new ObservedInboundTrack<'audio'>({
 			kind: 'audio',
-			trackId: config.trackId,
-		}, this, this._storageProvider);
-
-		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
+			...config,
+		}, this);
 
-		if (pendingTracksTimestamp) {
-			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
-			result.created = pendingTracksTimestamp;
-		}
-		
 		result.on('close', () => {
 			this._inboundAudioTracks.delete(result.trackId);
-			this._model.inboundTrackIds = this._model.inboundTrackIds.filter((id) => id !== result.trackId);
-			!this._closed &&this._save().catch(() => void 0);
 		});
 		this._inboundAudioTracks.set(result.trackId, result);
-		this._model.inboundTrackIds = [ ...(new Set<string>([ ...this._model.inboundTrackIds, result.trackId ])) ];
-		await this._save();
 
 		this.emit('newinboudaudiotrack', result);
 
 		return result;
 	}
 
-	public async createInboundVideoTrack(config: Omit<ObservedInboundTrackConfig<'video'>, 'kind'>): Promise<ObservedInboundTrack<'video'>> {
+	public createInboundVideoTrack(config: Omit<ObservedInboundTrackModel<'video'>, 'kind'>): ObservedInboundTrack<'video'> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-
-		const result = await ObservedInboundTrack.create<'video'>({
-			kind: 'video',
-			trackId: config.trackId,
-		}, this, this._storageProvider);
 		
-		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
-
-		if (pendingTracksTimestamp) {
-			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
-			result.created = pendingTracksTimestamp;
-		}
+		const result = new ObservedInboundTrack<'video'>({
+			kind: 'video',
+			...config,
+		}, this);
 
 		result.on('close', () => {
 			this._inboundVideoTracks.delete(result.trackId);
-			this._model.inboundTrackIds = this._model.inboundTrackIds.filter((id) => id !== result.trackId);
-			!this._closed &&this._save().catch(() => void 0);
 		});
 		this._inboundVideoTracks.set(result.trackId, result);
-		this._model.inboundTrackIds = [ ...(new Set<string>([ ...this._model.inboundTrackIds, result.trackId ])) ];
-		await this._save();
 
-		this.emit('newinboudvideotrack', result);	
-		
+		this.emit('newinboudvideotrack', result);
+
 		return result;
 	}
 
-	public async createOutboundAudioTrack(config: Omit<ObservedOutboundTrackConfig<'audio'>, 'kind'>): Promise<ObservedOutboundTrack<'audio'>> {
+	public createOutboundAudioTrack(config: Omit<ObservedOutboundTrackModel<'audio'>, 'kind'>): ObservedOutboundTrack<'audio'> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
 		
-		const result = await ObservedOutboundTrack.create<'audio'>({
+		const result = new ObservedOutboundTrack<'audio'>({
 			kind: 'audio',
-			trackId: config.trackId,
-		}, this, this._storageProvider);
-
-		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
-
-		if (pendingTracksTimestamp) {
-			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
-			result.created = pendingTracksTimestamp;
-		}
+			...config,
+		}, this);
 
 		result.on('close', () => {
 			this._outboundAudioTracks.delete(result.trackId);
-			this._model.outboundTrackIds = this._model.outboundTrackIds.filter((id) => id !== result.trackId);
-			
-			result.sfuStreamId && this.client.call.sfuStreamIdToOutboundAudioTrack.delete(result.sfuStreamId);
-			!this._closed &&this._save().catch(() => void 0);
 		});
 		this._outboundAudioTracks.set(result.trackId, result);
-		this._model.outboundTrackIds = [ ...(new Set<string>([ ...this._model.outboundTrackIds, result.trackId ])) ];
-		
-		result.sfuStreamId && this.client.call.sfuStreamIdToOutboundAudioTrack.set(result.sfuStreamId, result);
-		await this._save();
 
 		this.emit('newoutboundaudiotrack', result);
 
 		return result;
 	}
 
-	public async createOutboundVideoTrack(config: Omit<ObservedOutboundTrackConfig<'video'>, 'kind'>): Promise<ObservedOutboundTrack<'video'>> {
+	public createOutboundVideoTrack(config: Omit<ObservedOutboundTrackModel<'video'>, 'kind'>): ObservedOutboundTrack<'video'> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
 		
-		const result = await ObservedOutboundTrack.create<'video'>({
+		const result = new ObservedOutboundTrack<'video'>({
 			kind: 'video',
-			trackId: config.trackId,
-		}, this, this._storageProvider);
-
-		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
-
-		if (pendingTracksTimestamp) {
-			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
-			result.created = pendingTracksTimestamp;
-		}
+			...config,
+		}, this);
 
 		result.on('close', () => {
 			this._outboundVideoTracks.delete(result.trackId);
-			result.sfuStreamId && this.client.call.sfuStreamIdToOutboundVideoTrack.set(result.sfuStreamId, result);
-			this._model.outboundTrackIds = this._model.outboundTrackIds.filter((id) => id !== result.trackId);
-			!this._closed && this._save().catch(() => void 0);
 		});
 		this._outboundVideoTracks.set(result.trackId, result);
-		result.sfuStreamId && this.client.call.sfuStreamIdToOutboundVideoTrack.set(result.sfuStreamId, result);
-		this._model.outboundTrackIds = [ ...(new Set<string>([ ...this._model.outboundTrackIds, result.trackId ])) ];
-		await this._save();
 
 		this.emit('newoutboundvideotrack', result);
-		
-		return result;
-	}
 
-	private async _save() {
-		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-		
-		return this._execute(async () => {
-			if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-			await this._storageProvider.peerConnectionStorage.set(this.peerConnectionId, this._model);
-		});
+		return result;
 	}
 }