feat: add way to get all instances of a type of model from dashboard

src/dashboard/dashboard-manager.test.ts

@@ -175,4 +175,19 @@ describe('Dashboard manager', () => {
     expect(mockModelManager.destroy).toHaveBeenCalledWith(mockOriginalDataSource);
     expect(mockDataSourceManager.setRootDataSource).toHaveBeenCalledWith(mockNewDataSource, dashboard.root);
   });
+
+  test('can retrieve model instances', () => {
+    const dashboard = dashboardManager.create({
+      type: 'serialized-model'
+    });
+
+    const mockDataSource = class MockDataSource {
+      public readonly value: number = Math.random();
+    };
+
+    mockModelManager.getModelInstances = jest.fn().mockReturnValue([new mockDataSource()]);
+
+    expect(dashboard.getModelInstances(mockDataSource).length).toBe(1);
+    expect(mockModelManager.getModelInstances).toHaveBeenCalledWith(mockDataSource, {});
+  });
 });

src/dashboard/dashboard.ts

@@ -23,7 +23,7 @@ export interface Dashboard<TRoot extends object = object> {
   setTimeRange(timeRange: TimeRange): this;
 
   /**
-   * Returns a serialized from of this dashboard. Note this does not
+   * Returns a serialized form of this dashboard. Note this does not
    * affect the dashboard in any way, it must be explicitly destroyed
    * if it is no longer in use.
    */
@@ -56,4 +56,10 @@ export interface Dashboard<TRoot extends object = object> {
    */
   // tslint:disable-next-line: no-any
   getRootDataSource<T extends DataSource<any>>(): T | undefined;
+
+  /**
+   * Returns a shallow copy array of model instances within a dashboard that match the
+   * argument model class
+   */
+  getModelInstances<T extends object>(modelClass: Constructable<T>): object[];
 }

src/dashboard/default-dashboard.ts

@@ -86,4 +86,11 @@ export class DefaultDashboard<TRoot extends object> implements Dashboard<TRoot>
   public getRootDataSource<T extends DataSource<any>>(): T | undefined {
     return this.dataSourceManager.getRootDataSource(this.root) as T | undefined;
   }
+
+  /**
+   * @inheritdoc
+   */
+  public getModelInstances<T extends object>(modelClass: Constructable<T>): object[] {
+    return this.modelManager.getModelInstances<T>(modelClass, this.root);
+  }
 }

src/model/manager/model-manager.test.ts

@@ -14,6 +14,14 @@ describe('Model manager', () => {
     // Value used to disambiguate equality between instances
     public readonly value: number = Math.random();
   };
+  const testClass1 = class TestClass1 {
+    // Value used to disambiguate equality between instances
+    public readonly value: number = Math.random();
+  };
+  const testClass2 = class TestClass2 {
+    // Value used to disambiguate equality between instances
+    public readonly value: number = Math.random();
+  };
   let manager: ModelManager;
   let mockLogger: PartialObjectMock<Logger>;
   let mockApiBuilder: PartialObjectMock<ModelApiBuilder<ModelApi>>;
@@ -59,6 +67,16 @@ describe('Model manager', () => {
     manager.registerModelApiBuilder(mockApiBuilder as ModelApiBuilder<ModelApi>);
   });
 
+  test('returns array of instances matching arg', () => {
+    manager.construct(testClass);
+    manager.construct(testClass);
+    manager.construct(testClass1);
+    expect(manager.getModelInstances(testClass).length).toBe(2);
+    expect(manager.getModelInstances(testClass1).length).toBe(1);
+    expect(manager.getModelInstances(testClass2).length).toBe(0);
+    expect(manager.getModelInstances(testClass, {}).length).toBe(0);
+  });
+
   test('allows constructing new models', () => {
     const instance = manager.construct(testClass);
     expect(instance.constructor).toBe(testClass);

src/model/manager/model-manager.ts

@@ -13,7 +13,7 @@ import { ModelOnDestroy, ModelOnInit } from './model-lifecycle-hooks';
  * models.
  */
 export class ModelManager {
-  private readonly modelInstanceMap: WeakMap<object, ModelInstanceData> = new WeakMap();
+  private readonly modelInstanceMap: Map<object, ModelInstanceData> = new Map();
   private readonly apiBuilders: ModelApiBuilder<ModelApi>[] = [];
   private readonly decorators: ModelDecorator[] = [];
 
@@ -24,6 +24,15 @@ export class ModelManager {
     private readonly beforeModelDestroyedEvent: BeforeModelDestroyedEvent
   ) {}
 
+  /**
+   * Returns a shallow copy array of model instances that match the argument model class
+   */
+  public getModelInstances<T extends object>(modelClass: Constructable<T>, root?: object): object[] {
+    return Array.from(this.modelInstanceMap.keys())
+      .filter(modelInstance => root === undefined || this.getRoot(modelInstance) === root)
+      .filter(modelInstance => modelInstance instanceof modelClass);
+  }
+
   /**
    * Constructs (@see `ModelManager.construct`) then initializes (@see `ModelManager.initialize`) it
    *