Added CreateModel functionality and tests

src/index.d.ts

@@ -5235,9 +5235,7 @@ declare namespace admin.machineLearning {
     displayName?: string;
     tags?: string[];
 
-    tfLiteModel?: {gcsTFLiteUri: string;};
-
-    toJSON(forUpload?: boolean): object;
+    tfliteModel?: {gcsTfliteUri: string;};
   }
 
   /**
@@ -5247,8 +5245,8 @@ declare namespace admin.machineLearning {
     readonly modelId: string;
     readonly displayName: string;
     readonly tags?: string[];
-    readonly createTime: number;
-    readonly updateTime: number;
+    readonly createTime: string;
+    readonly updateTime: string;
     readonly validationError?: string;
     readonly published: boolean;
     readonly etag: string;

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

@@ -52,6 +52,13 @@ export interface ModelResponse extends ModelContent {
   readonly modelHash?: string;
 }
 
+export interface OperationResponse {
+  readonly name?: string;
+  readonly done: boolean;
+  readonly error?: StatusErrorResponse;
+  readonly response?: ModelResponse;
+}
+
 
 /**
  * Class that facilitates sending requests to the Firebase ML backend API.
@@ -73,6 +80,24 @@ export class MachineLearningApiClient {
     this.httpClient = new AuthorizedHttpClient(app);
   }
 
+  public createModel(model: ModelContent): Promise<OperationResponse> {
+    if (!validator.isNonNullObject(model) ||
+        !validator.isNonEmptyString(model.displayName)) {
+      const err = new FirebaseMachineLearningError('invalid-argument', 'Invalid model content.');
+      return Promise.reject(err);
+    }
+    return this.getUrl()
+        .then((url) => {
+          const request: HttpRequestConfig = {
+            method: 'POST',
+            url: `${url}/models`,
+            data: model,
+          };
+          return this.sendRequest<OperationResponse>(request);
+        });
+  }
+
+
   public getModel(modelId: string): Promise<ModelResponse> {
     return Promise.resolve()
       .then(() => {

src/machine-learning/machine-learning-utils.ts

@@ -25,9 +25,39 @@ export type MachineLearningErrorCode =
   | 'not-found'
   | 'resource-exhausted'
   | 'service-unavailable'
-  | 'unknown-error';
+  | 'unknown-error'
+  | 'cancelled'
+  | 'deadline-exceeded'
+  | 'permission-denied'
+  | 'failed-precondition'
+  | 'aborted'
+  | 'out-of-range'
+  | 'data-loss'
+  | 'unauthenticated';
 
 export class FirebaseMachineLearningError extends PrefixedFirebaseError {
+  public static fromOperationError(code: number, message: string): FirebaseMachineLearningError {
+    switch (code) {
+      case 1: return new FirebaseMachineLearningError('cancelled', message);
+      case 2: return new FirebaseMachineLearningError('unknown-error', message);
+      case 3: return new FirebaseMachineLearningError('invalid-argument', message);
+      case 4: return new FirebaseMachineLearningError('deadline-exceeded', message);
+      case 5: return new FirebaseMachineLearningError('not-found', message);
+      case 6: return new FirebaseMachineLearningError('already-exists', message);
+      case 7: return new FirebaseMachineLearningError('permission-denied', message);
+      case 8: return new FirebaseMachineLearningError('resource-exhausted', message);
+      case 9: return new FirebaseMachineLearningError('failed-precondition', message);
+      case 10: return new FirebaseMachineLearningError('aborted', message);
+      case 11: return new FirebaseMachineLearningError('out-of-range', message);
+      case 13: return new FirebaseMachineLearningError('internal-error', message);
+      case 14: return new FirebaseMachineLearningError('service-unavailable', message);
+      case 15: return new FirebaseMachineLearningError('data-loss', message);
+      case 16: return new FirebaseMachineLearningError('unauthenticated', message);
+      default:
+        return new FirebaseMachineLearningError('unknown-error', message);
+    }
+  }
+
   constructor(code: MachineLearningErrorCode, message: string) {
     super('machine-learning', code, message);
   }

src/machine-learning/machine-learning.ts

@@ -14,16 +14,14 @@
  * limitations under the License.
  */
 
-
 import {FirebaseApp} from '../firebase-app';
 import {FirebaseServiceInterface, FirebaseServiceInternalsInterface} from '../firebase-service';
-import {MachineLearningApiClient, ModelResponse} from './machine-learning-api-client';
+import {MachineLearningApiClient, ModelResponse, OperationResponse, ModelContent} from './machine-learning-api-client';
 import {FirebaseError} from '../utils/error';
 
 import * as validator from '../utils/validator';
 import {FirebaseMachineLearningError} from './machine-learning-utils';
-
-// const ML_HOST = 'mlkit.googleapis.com';
+import { deepCopy } from '../utils/deep-copy';
 
 /**
  * Internals of an ML instance.
@@ -97,7 +95,9 @@ export class MachineLearning implements FirebaseServiceInterface {
    * @return {Promise<Model>} A Promise fulfilled with the created model.
    */
   public createModel(model: ModelOptions): Promise<Model> {
-    throw new Error('NotImplemented');
+    return this.convertOptionstoContent(model, true)
+      .then((modelContent) => this.client.createModel(modelContent))
+      .then((operation) => handleOperation(operation));
   }
 
   /**
@@ -170,10 +170,53 @@ export class MachineLearning implements FirebaseServiceInterface {
   public deleteModel(modelId: string): Promise<void> {
     return this.client.deleteModel(modelId);
   }
+
+  private convertOptionstoContent(options: ModelOptions, forUpload?: boolean): Promise<ModelContent> {
+    const modelContent = deepCopy(options);
+
+    if (forUpload && modelContent.tfliteModel?.gcsTfliteUri) {
+      return this.signUrl(modelContent.tfliteModel.gcsTfliteUri)
+        .then ((uri: string) => {
+          modelContent.tfliteModel!.gcsTfliteUri = uri;
+          return modelContent;
+        })
+        .catch((err: Error) => {
+          throw new FirebaseMachineLearningError(
+            'internal-error',
+            `Error during signing upload url: ${err.message}`);
+        }) as Promise<ModelContent>;
+    }
+
+    return Promise.resolve(modelContent) as Promise<ModelContent>;
+  }
+
+  private signUrl(unsignedUrl: string): Promise<string> {
+    const MINUTES_IN_MILLIS = 60 * 1000;
+    const URL_VALID_DURATION = 10 * MINUTES_IN_MILLIS;
+
+    const gcsRegex = /^gs:\/\/([a-z0-9_.-]{3,63})\/(.+)$/;
+    const matches = gcsRegex.exec(unsignedUrl);
+    if (!matches) {
+      throw new FirebaseMachineLearningError(
+        'invalid-argument',
+        `Invalid unsigned url: ${unsignedUrl}`);
+    }
+    const bucketName = matches[1];
+    const blobName = matches[2];
+    const bucket = this.appInternal.storage().bucket(bucketName);
+    const blob = bucket.file(blobName);
+    return blob.getSignedUrl({
+      action: 'read',
+      expires: Date.now() + URL_VALID_DURATION,
+    }).then((x) => {
+      return x[0];
+    });
+  }
 }
 
+
 /**
- * A Firebase ML Model output object
+ * A Firebase ML Model output object.
  */
 export class Model {
   public readonly modelId: string;
@@ -196,7 +239,7 @@ export class Model {
       !validator.isNonEmptyString(model.displayName) ||
       !validator.isNonEmptyString(model.etag)) {
         throw new FirebaseMachineLearningError(
-          'invalid-argument',
+          'invalid-server-response',
           `Invalid Model response: ${JSON.stringify(model)}`);
     }
 
@@ -252,13 +295,27 @@ export class ModelOptions {
   public displayName?: string;
   public tags?: string[];
 
-  public tfliteModel?: { gcsTFLiteUri: string; };
-
-  protected toJSON(forUpload?: boolean): object {
-    throw new Error('NotImplemented');
-  }
+  public tfliteModel?: { gcsTfliteUri: string; };
 }
 
+
 function extractModelId(resourceName: string): string {
   return resourceName.split('/').pop()!;
 }
+
+
+function handleOperation(op: OperationResponse): Model {
+  // Backend currently does not return operations that are not done.
+  if (op.done) {
+    // Done operations must have either a response or an error.
+    if (op.response) {
+      return new Model(op.response);
+    } else if (op.error) {
+      throw FirebaseMachineLearningError.fromOperationError(
+        op.error.code, op.error.message);
+    }
+  }
+  throw new FirebaseMachineLearningError(
+    'invalid-server-response',
+    `Invalid Operation response: ${JSON.stringify(op)}`);
+}