Added ListModels functionality for Firebase ML (#795)

* Added ListModels functionality for Firebase ML

Author: ifielker

src/index.d.ts

@@ -5207,8 +5207,8 @@ declare namespace admin.machineLearning {
   /**
    * Interface representing options for listing Models.
    */
-  interface ListModelOptions {
-    listFilter?: string;
+  interface ListModelsOptions {
+    filter?: string;
     pageSize?: number;
     pageToken?: string;
   }
@@ -5322,7 +5322,7 @@ declare namespace admin.machineLearning {
      *     token. For the last page, an empty list of models and no page token
      * are returned.
      */
-    listModels(options: ListModelOptions): Promise<ListModelsResult>;
+    listModels(options?: ListModelsOptions): Promise<ListModelsResult>;
 
     /**
      * Deletes a model from Firebase ML.

src/machine-learning/machine-learning-api-client.ts

@@ -45,6 +45,13 @@ export interface ModelUpdateOptions extends ModelOptions {
   state?: { published?: boolean; };
 }
 
+/** Interface representing listModels options. */
+export interface ListModelsOptions {
+  filter?: string;
+  pageSize?: number;
+  pageToken?: string;
+}
+
 export interface ModelContent {
   readonly displayName?: string;
   readonly tags?: string[];
@@ -66,6 +73,11 @@ export interface ModelResponse extends ModelContent {
   readonly modelHash?: string;
 }
 
+export interface ListModelsResponse {
+  readonly models?: ModelResponse[];
+  readonly nextPageToken?: string;
+}
+
 export interface OperationResponse {
   readonly name?: string;
   readonly done: boolean;
@@ -140,6 +152,42 @@ export class MachineLearningApiClient {
       });
   }
 
+  public listModels(options: ListModelsOptions = {}): Promise<ListModelsResponse> {
+    if (!validator.isNonNullObject(options)) {
+      const err = new FirebaseMachineLearningError('invalid-argument', 'Invalid ListModelsOptions');
+      return Promise.reject(err);
+    }
+    if (typeof options.filter !== 'undefined' && !validator.isNonEmptyString(options.filter)) {
+      const err = new FirebaseMachineLearningError('invalid-argument', 'Invalid list filter.');
+      return Promise.reject(err);
+    }
+    if (typeof options.pageSize !== 'undefined') {
+      if (!validator.isNumber(options.pageSize)) {
+        const err = new FirebaseMachineLearningError('invalid-argument', 'Invalid page size.');
+        return Promise.reject(err);
+      }
+      if (options.pageSize < 1 || options.pageSize > 100) {
+        const err = new FirebaseMachineLearningError(
+          'invalid-argument', 'Page size must be between 1 and 100.');
+        return Promise.reject(err);
+      }
+    }
+    if (typeof options.pageToken !== 'undefined' && !validator.isNonEmptyString(options.pageToken)) {
+      const err = new FirebaseMachineLearningError(
+        'invalid-argument', 'Next page token must be a non-empty string.');
+      return Promise.reject(err);
+    }
+    return this.getUrl()
+      .then((url) => {
+        const request: HttpRequestConfig = {
+          method: 'GET',
+          url: `${url}/models`,
+          data: options,
+        };
+        return this.sendRequest<ListModelsResponse>(request);
+      });
+  }
+
   public deleteModel(modelId: string): Promise<void> {
     return this.getUrl()
       .then((url) => {

src/machine-learning/machine-learning.ts

@@ -17,7 +17,7 @@
 import {FirebaseApp} from '../firebase-app';
 import {FirebaseServiceInterface, FirebaseServiceInternalsInterface} from '../firebase-service';
 import {MachineLearningApiClient, ModelResponse, OperationResponse,
-  ModelOptions, ModelUpdateOptions} from './machine-learning-api-client';
+  ModelOptions, ModelUpdateOptions, ListModelsOptions} from './machine-learning-api-client';
 import {FirebaseError} from '../utils/error';
 
 import * as validator from '../utils/validator';
@@ -41,13 +41,6 @@ class MachineLearningInternals implements FirebaseServiceInternalsInterface {
   }
 }
 
-/** Interface representing listModels options. */
-export interface ListModelsOptions {
-  listFilter?: string;
-  pageSize?: number;
-  pageToken?: string;
-}
-
 /** Response object for a listModels operation. */
 export interface ListModelsResult {
   models: Model[];
@@ -161,8 +154,24 @@ export class MachineLearning implements FirebaseServiceInterface {
    *     token. For the last page, an empty list of models and no page token are
    *     returned.
    */
-  public listModels(options: ListModelsOptions): Promise<ListModelsResult> {
-    throw new Error('NotImplemented');
+  public listModels(options: ListModelsOptions = {}): Promise<ListModelsResult> {
+    return this.client.listModels(options)
+      .then((resp) => {
+        if (!validator.isNonNullObject(resp)) {
+          throw new FirebaseMachineLearningError(
+            'invalid-argument',
+            `Invalid ListModels response: ${JSON.stringify(resp)}`);
+        }
+        let models: Model[] = [];
+        if (resp.models) {
+          models = resp.models.map((rs) =>  new Model(rs));
+        }
+        const result: ListModelsResult = {models};
+        if (resp.nextPageToken) {
+          result.pageToken = resp.nextPageToken;
+        }
+        return result;
+      });
   }
 
   /**
@@ -268,7 +277,6 @@ export class Model {
         sizeBytes: model.tfliteModel.sizeBytes,
       };
     }
-
   }
 
   public get locked(): boolean {

test/integration/machine-learning.spec.ts

@@ -171,9 +171,7 @@ describe('admin.machineLearning', () => {
     });
 
     it('sets tags for a model', () => {
-      // TODO(ifielker): Uncomment & replace when BE change lands.
-      // const ORIGINAL_TAGS = ['tag-node-update-1'];
-      const ORIGINAL_TAGS: string[] = [];
+      const ORIGINAL_TAGS = ['tag-node-update-1'];
       const NEW_TAGS = ['tag-node-update-2', 'tag-node-update-3'];
 
       return createTemporaryModel({
@@ -192,7 +190,7 @@ describe('admin.machineLearning', () => {
     });
 
     it('updates the tflite file', () => {
-      Promise.all([
+      return Promise.all([
           createTemporaryModel(),
           uploadModelToGcs('model1.tflite', 'valid_model.tflite')])
         .then(([model, fileName]) => {
@@ -324,6 +322,120 @@ describe('admin.machineLearning', () => {
     });
   });
 
+  describe('listModels()', () => {
+    let model1: admin.machineLearning.Model;
+    let model2: admin.machineLearning.Model;
+    let model3: admin.machineLearning.Model;
+
+    before(() => {
+      return Promise.all([
+        admin.machineLearning().createModel({
+          displayName: 'node-integration-list1',
+          tags: ['node-integration-tag-1'],
+        }),
+        admin.machineLearning().createModel({
+          displayName: 'node-integration-list2',
+          tags: ['node-integration-tag-1'],
+        }),
+        admin.machineLearning().createModel({
+          displayName: 'node-integration-list3',
+          tags: ['node-integration-tag-1'],
+        })])
+        .then(([m1, m2, m3]: admin.machineLearning.Model[]) => {
+          model1 = m1;
+          model2 = m2;
+          model3 = m3;
+        });
+    });
+
+    after(() => {
+      return Promise.all([
+        admin.machineLearning().deleteModel(model1.modelId),
+        admin.machineLearning().deleteModel(model2.modelId),
+        admin.machineLearning().deleteModel(model3.modelId),
+      ]);
+    });
+
+    it('resolves with a list of models', () => {
+      return admin.machineLearning().listModels({pageSize: 100})
+        .then((modelList) => {
+          expect(modelList.models.length).to.be.at.least(2);
+          expect(modelList.models).to.deep.include(model1);
+          expect(modelList.models).to.deep.include(model2);
+          expect(modelList.pageToken).to.be.empty;
+        });
+    });
+
+    it('respects page size', () => {
+      return admin.machineLearning().listModels({pageSize: 2})
+        .then((modelList) => {
+          expect(modelList.models.length).to.equal(2);
+          expect(modelList.pageToken).not.to.be.empty;
+        });
+    });
+
+    it('filters by exact displayName', () => {
+      return admin.machineLearning().listModels({filter: 'displayName=node-integration-list1'})
+        .then((modelList) => {
+          expect(modelList.models.length).to.equal(1);
+          expect(modelList.models[0]).to.deep.equal(model1);
+          expect(modelList.pageToken).to.be.empty;
+        });
+    });
+
+    it('filters by displayName prefix', () => {
+      return admin.machineLearning().listModels({filter: 'displayName:node-integration-list*', pageSize: 100})
+        .then((modelList) => {
+          expect(modelList.models.length).to.be.at.least(3);
+          expect(modelList.models).to.deep.include(model1);
+          expect(modelList.models).to.deep.include(model2);
+          expect(modelList.models).to.deep.include(model3);
+          expect(modelList.pageToken).to.be.empty;
+        });
+    });
+
+    it('filters by tag', () => {
+      return admin.machineLearning().listModels({filter: 'tags:node-integration-tag-1', pageSize: 100})
+        .then((modelList) => {
+          expect(modelList.models.length).to.be.at.least(3);
+          expect(modelList.models).to.deep.include(model1);
+          expect(modelList.models).to.deep.include(model2);
+          expect(modelList.models).to.deep.include(model3);
+          expect(modelList.pageToken).to.be.empty;
+        });
+    });
+
+    it('handles pageTokens properly', () => {
+      return admin.machineLearning().listModels({filter: 'displayName:node-integration-list*', pageSize: 2})
+        .then((modelList) => {
+          expect(modelList.models.length).to.equal(2);
+          expect(modelList.pageToken).not.to.be.empty;
+          return admin.machineLearning().listModels({
+            filter: 'displayName:node-integration-list*',
+            pageSize: 2,
+            pageToken: modelList.pageToken})
+            .then((modelList2) => {
+              expect(modelList2.models.length).to.be.at.least(1);
+              expect(modelList2.pageToken).to.be.empty;
+            });
+        });
+    });
+
+    it('successfully returns an empty list of models', () => {
+      return admin.machineLearning().listModels({filter: 'displayName=non-existing-model'})
+        .then((modelList) => {
+          expect(modelList.models.length).to.equal(0);
+          expect(modelList.pageToken).to.be.empty;
+        });
+    });
+
+    it('rejects with invalid argument if the filter is invalid', () => {
+      return admin.machineLearning().listModels({filter: 'invalidFilterItem=foo'})
+        .should.eventually.be.rejected.and.have.property(
+          'code', 'machine-learning/invalid-argument');
+    });
+  });
+
   describe('deleteModel()', () => {
     it('rejects with not-found when the Model does not exist', () => {
       const nonExistingName = '00000000';