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

package/lib/Observer.js

@@ -1,6 +1,42 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Observer = void 0;
@@ -9,8 +45,19 @@ const Sources_1 = require("./sources/Sources");
 const StorageProvider_1 = require("./storages/StorageProvider");
 const Evaluator_1 = require("./Evaluator");
 const Semaphore_1 = require("./common/Semaphore");
+const utils_1 = require("./common/utils");
 const logger_1 = require("./common/logger");
-const events_1 = __importDefault(require("events"));
+const events_1 = require("events");
+const CallEntry_1 = require("./entries/CallEntry");
+const ClientEntry_1 = require("./entries/ClientEntry");
+const PeerConnectionEntry_1 = require("./entries/PeerConnectionEntry");
+const InboundTrackEntry_1 = require("./entries/InboundTrackEntry");
+const OutboundTrackEntry_1 = require("./entries/OutboundTrackEntry");
+const SfuEntry_1 = require("./entries/SfuEntry");
+const SfuTransportEntry_1 = require("./entries/SfuTransportEntry");
+const SfuInboundRtpPadEntry_1 = require("./entries/SfuInboundRtpPadEntry");
+const SfuOutboundRtpPadEntry_1 = require("./entries/SfuOutboundRtpPadEntry");
+const SfuSctpChannelEntry_1 = require("./entries/SfuSctpChannelEntry");
 const logger = (0, logger_1.createLogger)('Observer');
 class Observer {
     static create(providedConfig) {
@@ -37,24 +84,31 @@ class Observer {
         this.config = config;
         this._storages = _storages;
         this._semaphores = _semaphores;
-        this._emitter = new events_1.default();
+        this._emitter = new events_1.EventEmitter();
         this._closed = false;
         this._sources = new Sources_1.Sources(config.sources);
         this._sink = new ObserverSink_1.SinkImpl(config.sink);
         this._evaluator = new Evaluator_1.Evaluator(this.config.evaluator, this._semaphores.callSemaphore, this._storages, this._sink);
         this._sources.on('observed-samples', (event) => {
+            this._emitter.emit('processing-started');
             this._evaluator.addObservedSamples(event);
         });
         this._sources.on('added-client-source', (event) => {
             this._evaluator.addCreatedClientSource(event);
+            this._emitter.emit('client-added', event.clientId);
         });
         this._sources.on('removed-client-source', (event) => {
             this._evaluator.addClosedClientSource(event);
+            this._emitter.emit('client-added', event.clientId);
         });
         this._evaluator.on('ready', () => {
             this._sink.emit();
+            this._emitter.emit('processing-ended');
         });
-        logger.debug(`Observer is created with config`, this.config);
+        logger.debug('Observer is created with config', this.config);
+    }
+    get sources() {
+        return this._sources;
     }
     on(event, listener) {
         this._emitter.on(event, listener);
@@ -69,86 +123,35 @@ class Observer {
         return this;
     }
     createCallSource(config) {
-        var _a, _b;
         if (this._closed) {
-            throw new Error(`Attempted to create a call source on a closed observer`);
+            throw new Error('Attempted to create a call source on a closed observer');
         }
-        let closed = false;
-        const serviceId = (_a = config.serviceId) !== null && _a !== void 0 ? _a : this.config.defaultServiceId;
-        const mediaUnitId = (_b = config.mediaUnitId) !== null && _b !== void 0 ? _b : this.config.defaultMediaUnitId;
-        const clientSources = new Map();
-        const callSource = {
-            ...config,
-            serviceId,
+        const { serviceId = this.config.defaultServiceId, mediaUnitId = this.config.defaultMediaUnitId, appData = {} } = config, callConfig = __rest(config, ["serviceId", "mediaUnitId", "appData"]);
+        return this._sources.createCallSource(Object.assign(Object.assign({}, callConfig), { appData,
             mediaUnitId,
-            createClientSource: (context) => {
-                const clientSource = this._sources.createClientSource({
-                    ...config,
-                    ...context,
-                    serviceId,
-                    mediaUnitId,
-                });
-                const closeClientSource = clientSource.close;
-                clientSource.close = () => {
-                    closeClientSource();
-                    clientSources.delete(context.clientId);
-                };
-                clientSources.set(context.clientId, clientSource);
-                return clientSource;
-            },
-            close: () => {
-                if (closed) {
-                    return;
-                }
-                for (const clientSource of clientSources.values()) {
-                    clientSource.close();
-                }
-                clientSources.clear();
-                closed = true;
-            },
-            closed,
-        };
-        return callSource;
-    }
-    createClientSource(config) {
-        var _a, _b, _c;
-        if (this._closed) {
-            throw new Error(`Attempted to create a client source on a closed observer`);
-        }
-        const serviceId = (_a = config.serviceId) !== null && _a !== void 0 ? _a : this.config.defaultServiceId;
-        const mediaUnitId = (_b = config.mediaUnitId) !== null && _b !== void 0 ? _b : this.config.defaultMediaUnitId;
-        const joined = (_c = config.joined) !== null && _c !== void 0 ? _c : Date.now();
-        return this._sources.createClientSource({
-            ...config,
-            serviceId,
-            mediaUnitId,
-            joined,
-        });
+            serviceId }));
     }
     createSfuSource(config) {
-        var _a, _b, _c;
         if (this._closed) {
-            throw new Error(`Attempted to create a sfu source on a closed observer`);
+            throw new Error('Attempted to create a sfu source on a closed observer');
         }
-        const serviceId = (_a = config.serviceId) !== null && _a !== void 0 ? _a : this.config.defaultServiceId;
-        const mediaUnitId = (_b = config.mediaUnitId) !== null && _b !== void 0 ? _b : this.config.defaultMediaUnitId;
-        const joined = (_c = config.joined) !== null && _c !== void 0 ? _c : Date.now();
-        return this._sources.createSfuSource({
-            ...config,
+        const { appData = {}, serviceId = this.config.defaultServiceId, mediaUnitId = this.config.defaultMediaUnitId, joined = Date.now() } = config, sfuConfig = __rest(config, ["appData", "serviceId", "mediaUnitId", "joined"]);
+        return this._sources.createSfuSource(Object.assign(Object.assign({}, sfuConfig), { appData,
             serviceId,
             mediaUnitId,
-            joined,
-        });
-    }
-    async evaluate() {
-        return new Promise((resolve, reject) => {
-            this._evaluator.once('ready', err => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
+            joined }));
+    }
+    evaluate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this._evaluator.once('ready', (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+                this._sources.emitSamples();
             });
-            this._sources.emitSamples();
         });
     }
     get reports() {
@@ -156,7 +159,7 @@ class Observer {
     }
     addEvaluators(...processes) {
         if (this._closed) {
-            throw new Error(`Attempted to add an evaluator to a closed observer`);
+            throw new Error('Attempted to add an evaluator to a closed observer');
         }
         for (const process of processes) {
             this._evaluator.addProcess(process);
@@ -164,7 +167,7 @@ class Observer {
     }
     removeEvaluators(...processes) {
         if (this._closed) {
-            throw new Error(`Attempted to remove an evaluator from a closed observer`);
+            throw new Error('Attempted to remove an evaluator from a closed observer');
         }
         for (const process of processes) {
             this._evaluator.removeProcess(process);
@@ -172,7 +175,7 @@ class Observer {
     }
     addSinks(...processes) {
         if (this._closed) {
-            throw new Error(`Attempted to add an evaluator to a closed observer`);
+            throw new Error('Attempted to add an evaluator to a closed observer');
         }
         for (const process of processes) {
             this._sink.addProcess(process);
@@ -180,158 +183,459 @@ class Observer {
     }
     removeSinks(...processes) {
         if (this._closed) {
-            throw new Error(`Attempted to remove an evaluator from a closed observer`);
+            throw new Error('Attempted to remove an evaluator from a closed observer');
         }
         for (const process of processes) {
             this._sink.removeProcess(process);
         }
     }
     calls() {
-        const { callStorage } = this._storages;
-        return callStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_1, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.callStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, callModel] = _c;
+                            if (!callModel)
+                                continue;
+                            yield yield __await((0, CallEntry_1.createCallEntry)(storageProvider, callModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            });
+        })());
     }
     sfus() {
-        const { sfuStorage } = this._storages;
-        return sfuStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_2, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.sfuStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, sfuModel] = _c;
+                            if (!sfuModel)
+                                continue;
+                            yield yield __await((0, SfuEntry_1.createSfuEntry)(storageProvider, sfuModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            });
+        })());
     }
     sfuTransports() {
-        const { sfuTransportStorage } = this._storages;
-        return sfuTransportStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_3, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.sfuTransportStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, sfuTransportModel] = _c;
+                            if (!sfuTransportModel)
+                                continue;
+                            yield yield __await((0, SfuTransportEntry_1.createSfuTransportEntry)(storageProvider, sfuTransportModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            });
+        })());
     }
     sfuInboundRtpPads() {
-        const { sfuInboundRtpPadStorage } = this._storages;
-        return sfuInboundRtpPadStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_4, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.sfuInboundRtpPadStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, sfuInboundRtpPadModel] = _c;
+                            if (!sfuInboundRtpPadModel)
+                                continue;
+                            yield yield __await((0, SfuInboundRtpPadEntry_1.createSfuInboundRtpPadEntry)(storageProvider, sfuInboundRtpPadModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            });
+        })());
     }
     sfuOutboundRtpPads() {
-        const { sfuOutboundRtpPadStorage } = this._storages;
-        return sfuOutboundRtpPadStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_5, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.sfuOutboundRtpPadStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, sfuOutboundRtpPadModel] = _c;
+                            if (!sfuOutboundRtpPadModel)
+                                continue;
+                            yield yield __await((0, SfuOutboundRtpPadEntry_1.createSfuOutboundRtpPadEntry)(storageProvider, sfuOutboundRtpPadModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+            });
+        })());
     }
     clients() {
-        const { clientStorage } = this._storages;
-        return clientStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_6, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.clientStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, callModel] = _c;
+                            if (!callModel)
+                                continue;
+                            yield yield __await((0, ClientEntry_1.createClientEntry)(storageProvider, callModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+            });
+        })());
     }
     peerConnections() {
-        const { peerConnectionStorage } = this._storages;
-        return peerConnectionStorage[Symbol.asyncIterator]();
-    }
-    async getTrack(trackId) {
-        const { inboundTrackStorage, outboundTrackStorage } = this._storages;
-        const [inbTrack, outbTrack] = await Promise.all([
-            inboundTrackStorage.get(trackId),
-            outboundTrackStorage.get(trackId),
-        ]);
-        if (inbTrack)
-            return inbTrack;
-        else if (outbTrack)
-            return outbTrack;
-    }
-    async getAllTracks(trackIds) {
-        const { inboundTrackStorage, outboundTrackStorage } = this._storages;
-        const [inbTracks, outbTracks] = await Promise.all([
-            inboundTrackStorage.getAll(trackIds),
-            outboundTrackStorage.getAll(trackIds),
-        ]);
-        return new Map([...inbTracks, ...outbTracks]);
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_7, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.peerConnectionStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, peerConnectionModel] = _c;
+                            if (!peerConnectionModel)
+                                continue;
+                            yield yield __await((0, PeerConnectionEntry_1.createPeerConnectionEntry)(storageProvider, peerConnectionModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+            });
+        })());
+    }
+    getTrack(trackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { inboundTrackStorage, outboundTrackStorage } = this._storages;
+            const [inbTrackModel, outbTrackModel] = yield Promise.all([
+                inboundTrackStorage.get(trackId),
+                outboundTrackStorage.get(trackId),
+            ]);
+            if (inbTrackModel)
+                return (0, InboundTrackEntry_1.createInboundTrackEntry)(this._storages, inbTrackModel);
+            else if (outbTrackModel)
+                return (0, OutboundTrackEntry_1.createOutboundTrackEntry)(this._storages, outbTrackModel);
+        });
+    }
+    getAllTracks(trackIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storageProvider = this._storages;
+            const { inboundTrackStorage, outboundTrackStorage } = this._storages;
+            const [inbTrackModels, outbTrackModels] = yield Promise.all([
+                inboundTrackStorage.getAll(trackIds),
+                outboundTrackStorage.getAll(trackIds),
+            ]);
+            const result = new Map();
+            for (const [trackId, model] of inbTrackModels) {
+                result.set(trackId, (0, InboundTrackEntry_1.createInboundTrackEntry)(storageProvider, model));
+            }
+            for (const [trackId, model] of outbTrackModels) {
+                result.set(trackId, (0, OutboundTrackEntry_1.createOutboundTrackEntry)(storageProvider, model));
+            }
+            return result;
+        });
     }
     inboundTracks() {
-        const { inboundTrackStorage } = this._storages;
-        return inboundTrackStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_8, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.inboundTrackStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, inboundTrackModel] = _c;
+                            if (!inboundTrackModel)
+                                continue;
+                            yield yield __await((0, InboundTrackEntry_1.createInboundTrackEntry)(storageProvider, inboundTrackModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            });
+        })());
     }
     outboundTracks() {
-        const { outboundTrackStorage } = this._storages;
-        return outboundTrackStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_9, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.outboundTrackStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, outboundTrackModel] = _c;
+                            if (!outboundTrackModel)
+                                continue;
+                            yield yield __await((0, OutboundTrackEntry_1.createOutboundTrackEntry)(storageProvider, outboundTrackModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                }
+            });
+        })());
     }
     sfuSctpChannels() {
-        const { sfuSctpChannelStorage } = this._storages;
-        return sfuSctpChannelStorage[Symbol.asyncIterator]();
+        const storageProvider = this._storages;
+        return (0, utils_1.asyncIteratorConverter)((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                var _a, e_10, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(storageProvider.sfuSctpChannelStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const [, sfuSctpChannelModel] = _c;
+                            if (!sfuSctpChannelModel)
+                                continue;
+                            yield yield __await((0, SfuSctpChannelEntry_1.createSfuSctpChannelEntry)(storageProvider, sfuSctpChannelModel));
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+            });
+        })());
     }
-    async getCall(callId) {
-        const { callStorage } = this._storages;
-        return callStorage.get(callId);
+    getCall(callId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, CallEntry_1.createCallEntry)(this._storages, yield this._storages.callStorage.get(callId));
+        });
     }
-    async getAllCalls(callIds) {
-        const { callStorage } = this._storages;
-        return callStorage.getAll(callIds);
+    getAllCalls(callIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.callStorage.getAll(callIds);
+            return new Map(Array.from(models).map(([callId, model]) => [callId, (0, CallEntry_1.createCallEntry)(this._storages, model)]));
+        });
     }
-    async getSfu(sfuId) {
-        const { sfuStorage } = this._storages;
-        return sfuStorage.get(sfuId);
+    getSfu(sfuId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, SfuEntry_1.createSfuEntry)(this._storages, yield this._storages.sfuStorage.get(sfuId));
+        });
     }
-    async getAllSfus(sfuIds) {
-        const { sfuStorage } = this._storages;
-        return sfuStorage.getAll(sfuIds);
+    getAllSfus(sfuIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.sfuStorage.getAll(sfuIds);
+            return new Map(Array.from(models).map(([sfuId, model]) => [sfuId, (0, SfuEntry_1.createSfuEntry)(this._storages, model)]));
+        });
     }
-    async getSfuTransport(sfuTransportId) {
-        const { sfuTransportStorage } = this._storages;
-        return sfuTransportStorage.get(sfuTransportId);
+    getSfuTransport(sfuTransportId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, SfuTransportEntry_1.createSfuTransportEntry)(this._storages, yield this._storages.sfuTransportStorage.get(sfuTransportId));
+        });
     }
-    async getAllSfuTransports(sfuTransportIds) {
-        const { sfuTransportStorage } = this._storages;
-        return sfuTransportStorage.getAll(sfuTransportIds);
+    getAllSfuTransports(sfuTransportIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.sfuTransportStorage.getAll(sfuTransportIds);
+            return new Map(Array.from(models).map(([sfuTransportId, model]) => [sfuTransportId, (0, SfuTransportEntry_1.createSfuTransportEntry)(this._storages, model)]));
+        });
     }
-    async getSfuInboundRtpPad(sfuInboundRtpPadId) {
-        const { sfuInboundRtpPadStorage } = this._storages;
-        return sfuInboundRtpPadStorage.get(sfuInboundRtpPadId);
+    getSfuInboundRtpPad(sfuInboundRtpPadId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, SfuInboundRtpPadEntry_1.createSfuInboundRtpPadEntry)(this._storages, yield this._storages.sfuInboundRtpPadStorage.get(sfuInboundRtpPadId));
+        });
     }
-    async getAllSfuInboundRtpPads(sfuInboundRtpPadIds) {
-        const { sfuInboundRtpPadStorage } = this._storages;
-        return sfuInboundRtpPadStorage.getAll(sfuInboundRtpPadIds);
+    getAllSfuInboundRtpPads(sfuInboundRtpPadIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.sfuInboundRtpPadStorage.getAll(sfuInboundRtpPadIds);
+            return new Map(Array.from(models).map(([sfuInboundRtpPadId, model]) => [sfuInboundRtpPadId, (0, SfuInboundRtpPadEntry_1.createSfuInboundRtpPadEntry)(this._storages, model)]));
+        });
     }
-    async getSfuOutboundRtpPad(sfuOutboundRtpPadId) {
-        const { sfuOutboundRtpPadStorage } = this._storages;
-        return sfuOutboundRtpPadStorage.get(sfuOutboundRtpPadId);
+    getSfuOutboundRtpPad(sfuOutboundRtpPadId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, SfuOutboundRtpPadEntry_1.createSfuOutboundRtpPadEntry)(this._storages, yield this._storages.sfuOutboundRtpPadStorage.get(sfuOutboundRtpPadId));
+        });
     }
-    async getAllSfuOutboundRtpPads(sfuOutboundRtpPadIds) {
-        const { sfuOutboundRtpPadStorage } = this._storages;
-        return sfuOutboundRtpPadStorage.getAll(sfuOutboundRtpPadIds);
+    getAllSfuOutboundRtpPads(sfuOutboundRtpPadIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.sfuOutboundRtpPadStorage.getAll(sfuOutboundRtpPadIds);
+            return new Map(Array.from(models).map(([sfuOutboundRtpPadId, model]) => [sfuOutboundRtpPadId, (0, SfuOutboundRtpPadEntry_1.createSfuOutboundRtpPadEntry)(this._storages, model)]));
+        });
     }
-    async getClient(clientId) {
-        const { clientStorage } = this._storages;
-        return clientStorage.get(clientId);
+    getClient(clientId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, ClientEntry_1.createClientEntry)(this._storages, yield this._storages.clientStorage.get(clientId));
+        });
     }
-    async getAllClient(clientIds) {
-        const { clientStorage } = this._storages;
-        return clientStorage.getAll(clientIds);
+    getAllClient(clientIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.clientStorage.getAll(clientIds);
+            return new Map(Array.from(models).map(([clientId, model]) => [clientId, (0, ClientEntry_1.createClientEntry)(this._storages, model)]));
+        });
     }
-    async getPeerConnection(peerConnectionId) {
-        const { peerConnectionStorage } = this._storages;
-        return peerConnectionStorage.get(peerConnectionId);
+    getPeerConnection(peerConnectionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, PeerConnectionEntry_1.createPeerConnectionEntry)(this._storages, yield this._storages.peerConnectionStorage.get(peerConnectionId));
+        });
     }
-    async getAllPeerConnections(peerConnectionIds) {
-        const { peerConnectionStorage } = this._storages;
-        return peerConnectionStorage.getAll(peerConnectionIds);
+    getAllPeerConnections(peerConnectionIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.peerConnectionStorage.getAll(peerConnectionIds);
+            return new Map(Array.from(models).map(([peerConnectionId, model]) => [peerConnectionId, (0, PeerConnectionEntry_1.createPeerConnectionEntry)(this._storages, model)]));
+        });
     }
-    async getInboundTrack(inboundTrackId) {
-        const { inboundTrackStorage } = this._storages;
-        return inboundTrackStorage.get(inboundTrackId);
+    getInboundTrack(inboundTrackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, InboundTrackEntry_1.createInboundTrackEntry)(this._storages, yield this._storages.inboundTrackStorage.get(inboundTrackId));
+        });
     }
-    async getAllInboundTracks(inboundTrackIds) {
-        const { inboundTrackStorage } = this._storages;
-        return inboundTrackStorage.getAll(inboundTrackIds);
+    getAllInboundTracks(inboundTrackIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.inboundTrackStorage.getAll(inboundTrackIds);
+            return new Map(Array.from(models).map(([inboundTrackId, model]) => [inboundTrackId, (0, InboundTrackEntry_1.createInboundTrackEntry)(this._storages, model)]));
+        });
     }
-    async getOutboundTrack(outboundTrackId) {
-        const { outboundTrackStorage } = this._storages;
-        return outboundTrackStorage.get(outboundTrackId);
+    getOutboundTrack(outboundTrackId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, OutboundTrackEntry_1.createOutboundTrackEntry)(this._storages, yield this._storages.outboundTrackStorage.get(outboundTrackId));
+        });
     }
-    async getAllOutboundTracks(outboundTrackIds) {
-        const { outboundTrackStorage } = this._storages;
-        return outboundTrackStorage.getAll(outboundTrackIds);
+    getAllOutboundTracks(outboundTrackIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.outboundTrackStorage.getAll(outboundTrackIds);
+            return new Map(Array.from(models).map(([outboundTrackId, model]) => [outboundTrackId, (0, OutboundTrackEntry_1.createOutboundTrackEntry)(this._storages, model)]));
+        });
     }
-    async getSfuSctpChannel(sctpChannelId) {
-        const { sfuSctpChannelStorage } = this._storages;
-        return sfuSctpChannelStorage.get(sctpChannelId);
+    getSfuSctpChannel(sctpChannelId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, SfuSctpChannelEntry_1.createSfuSctpChannelEntry)(this._storages, yield this._storages.sfuSctpChannelStorage.get(sctpChannelId));
+        });
     }
-    async getAllSfuSctpChannel(sctpChannelIds) {
-        const { sfuSctpChannelStorage } = this._storages;
-        return sfuSctpChannelStorage.getAll(sctpChannelIds);
+    getAllSfuSctpChannel(sctpChannelIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const models = yield this._storages.sfuSctpChannelStorage.getAll(sctpChannelIds);
+            return new Map(Array.from(models).map(([sctpChannelId, model]) => [sctpChannelId, (0, SfuSctpChannelEntry_1.createSfuSctpChannelEntry)(this._storages, model)]));
+        });
     }
     get closed() {
         return this._closed;
     }
     close() {
         if (this._closed) {
-            logger.debug(`Attempted to close twice`);
-            return;
+            return logger.debug('Attempted to close twice');
         }
         this._closed = true;
         this._sources.close();