Add types to ErrorFactory message parameters

packages/util/src/errors.ts

@@ -54,7 +54,9 @@
  *     }
  *   }
  */
-export type ErrorList<T> = { [code: string]: string };
+export type ErrorList<T extends string = string> = {
+  readonly [K in T]: string
+};
 
 const ERROR_NAME = 'FirebaseError';
 
@@ -87,11 +89,10 @@ export interface FirebaseError {
 }
 
 export class FirebaseError implements FirebaseError {
-  public stack: string;
-  public name: string;
+  stack: string;
+  name: string;
 
   constructor(public code: string, public message: string) {
-    let stack: string;
     // We want the stack value, if implemented by Error
     if (captureStackTrace) {
       // Patches this.stack, omitted calls above ErrorFactory#create
@@ -119,39 +120,46 @@ FirebaseError.prototype = Object.create(Error.prototype) as FirebaseError;
 FirebaseError.prototype.constructor = FirebaseError;
 (FirebaseError.prototype as any).name = ERROR_NAME;
 
-export class ErrorFactory<T extends string> {
+type AnyParams = { readonly [key: string]: StringLike | undefined };
+
+export class ErrorFactory<
+  ErrorCode extends string,
+  ErrorParams extends Partial<{ readonly [K in ErrorCode]: AnyParams }> = {}
+> {
   // Matches {$name}, by default.
-  public pattern = /\{\$([^}]+)}/g;
+  pattern = /\{\$([^}]+)}/g;
 
   constructor(
     private service: string,
     private serviceName: string,
-    private errors: ErrorList<T>
+    private errors: ErrorList<ErrorCode>
   ) {
     // empty
   }
 
-  create(code: T, data?: { [prop: string]: StringLike }): FirebaseError {
-    if (data === undefined) {
-      data = {};
-    }
-
-    let template = this.errors[code as string];
+  create<K extends ErrorCode>(
+    code: K,
+    // For some reason, doesn't work with something like this to make the parameter optional only
+    // if it's not defined in ErrorParams
+    // data: ErrorParams[K] extends undefined ? AnyParams | void : ErrorParams[K]
+    data?: ErrorParams[K] extends undefined ? AnyParams : ErrorParams[K]
+  ): FirebaseError {
+    let template = this.errors[code];
 
-    let fullCode = this.service + '/' + code;
+    let fullCode = `${this.service}/${code}`;
     let message: string;
 
     if (template === undefined) {
       message = 'Error';
     } else {
-      message = template.replace(this.pattern, (match, key) => {
-        let value = data![key];
-        return value !== undefined ? value.toString() : '<' + key + '?>';
+      message = template.replace(this.pattern, (_, key) => {
+        let value = data !== undefined ? data[key] : undefined;
+        return value !== undefined ? value.toString() : `<${key}?>`;
       });
     }
 
     // Service: Error message (service/code).
-    message = this.serviceName + ': ' + message + ' (' + fullCode + ').';
+    message = `${this.serviceName}: ${message} (${fullCode}).`;
     let err = new FirebaseError(fullCode, message);
 
     // Populate the Error object with message parts for programmatic

packages/util/test/errors.test.ts

@@ -19,13 +19,18 @@ import { ErrorFactory, ErrorList, patchCapture } from '../src/errors';
 
 type Err = 'generic-error' | 'file-not-found' | 'anon-replace';
 
-let errors = {
+let errors: ErrorList<Err> = {
   'generic-error': 'Unknown error',
   'file-not-found': "Could not find file: '{$file}'",
   'anon-replace': 'Hello, {$repl_}!'
-} as ErrorList<Err>;
+};
 
-let error = new ErrorFactory<Err>('fake', 'Fake', errors);
+interface ErrorParams {
+  'file-not-found': { file: string };
+  'anon-replace': { repl_: string };
+}
+
+let error = new ErrorFactory<Err, ErrorParams>('fake', 'Fake', errors);
 
 describe('FirebaseError', () => {
   it('create', () => {
@@ -59,7 +64,7 @@ describe('FirebaseError', () => {
   });
 
   it('Missing replacement', () => {
-    let e = error.create('file-not-found', { fileX: 'foo.txt' });
+    let e = error.create('file-not-found', { fileX: 'foo.txt' } as any);
     assert.equal(e.code, 'fake/file-not-found');
     assert.equal(
       e.message,