OnDisconnect Compat (#4727)

schmidt-sebastian · web-flow · commit 84940981d384 · 2021-04-05T18:41:15.000-06:00
diff --git a/packages/database/exp/index.ts b/packages/database/exp/index.ts
@@ -37,9 +37,9 @@ export {
   Reference,
   ListenOptions,
   Unsubscribe,
-  ThenableReference,
-  OnDisconnect
+  ThenableReference
 } from '../src/exp/Reference';
+export { OnDisconnect } from '../src/exp/OnDisconnect';
 export {
   QueryConstraint,
   DataSnapshot,
diff --git a/packages/database/src/api/Reference.ts b/packages/database/src/api/Reference.ts
@@ -33,6 +33,7 @@ import {
 } from '../core/util/validation';
 import { UserCallback } from '../core/view/EventRegistration';
 import { QueryParams } from '../core/view/QueryParams';
+import { OnDisconnect as ExpOnDisconnect } from '../exp/OnDisconnect';
 import {
   DataSnapshot as ExpDataSnapshot,
   off,
@@ -750,7 +751,9 @@ export class Reference extends Query implements Compat<ReferenceImpl> {
 
   onDisconnect(): OnDisconnect {
     validateWritablePath('Reference.onDisconnect', this._delegate._path);
-    return new OnDisconnect(this._delegate._repo, this._delegate._path);
+    return new OnDisconnect(
+      new ExpOnDisconnect(this._delegate._repo, this._delegate._path)
+    );
   }
 
   get key(): string | null {
diff --git a/packages/database/src/api/onDisconnect.ts b/packages/database/src/api/onDisconnect.ts
@@ -15,67 +15,52 @@
  * limitations under the License.
  */
 
-import { Deferred, validateArgCount, validateCallback } from '@firebase/util';
+import { validateArgCount, validateCallback, Compat } from '@firebase/util';
 
-import {
-  Repo,
-  repoOnDisconnectCancel,
-  repoOnDisconnectSet,
-  repoOnDisconnectSetWithPriority,
-  repoOnDisconnectUpdate
-} from '../core/Repo';
 import { Indexable } from '../core/util/misc';
-import { Path } from '../core/util/Path';
 import { warn } from '../core/util/util';
-import {
-  validateWritablePath,
-  validateFirebaseDataArg,
-  validatePriority,
-  validateFirebaseMergeDataArg
-} from '../core/util/validation';
+import { OnDisconnect as ExpOnDisconnect } from '../exp/OnDisconnect';
 
-export class OnDisconnect {
-  constructor(private repo_: Repo, private path_: Path) {}
+export class OnDisconnect implements Compat<ExpOnDisconnect> {
+  constructor(readonly _delegate: ExpOnDisconnect) {}
 
   cancel(onComplete?: (a: Error | null) => void): Promise<void> {
     validateArgCount('OnDisconnect.cancel', 0, 1, arguments.length);
     validateCallback('OnDisconnect.cancel', 1, onComplete, true);
-    const deferred = new Deferred<void>();
-    repoOnDisconnectCancel(
-      this.repo_,
-      this.path_,
-      deferred.wrapCallback(onComplete)
-    );
-    return deferred.promise;
+    const result = this._delegate.cancel();
+    if (onComplete) {
+      result.then(
+        () => onComplete(null),
+        error => onComplete(error)
+      );
+    }
+    return result;
   }
 
   remove(onComplete?: (a: Error | null) => void): Promise<void> {
     validateArgCount('OnDisconnect.remove', 0, 1, arguments.length);
-    validateWritablePath('OnDisconnect.remove', this.path_);
     validateCallback('OnDisconnect.remove', 1, onComplete, true);
-    const deferred = new Deferred<void>();
-    repoOnDisconnectSet(
-      this.repo_,
-      this.path_,
-      null,
-      deferred.wrapCallback(onComplete)
-    );
-    return deferred.promise;
+    const result = this._delegate.remove();
+    if (onComplete) {
+      result.then(
+        () => onComplete(null),
+        error => onComplete(error)
+      );
+    }
+    return result;
   }
 
   set(value: unknown, onComplete?: (a: Error | null) => void): Promise<void> {
     validateArgCount('OnDisconnect.set', 1, 2, arguments.length);
-    validateWritablePath('OnDisconnect.set', this.path_);
-    validateFirebaseDataArg('OnDisconnect.set', 1, value, this.path_, false);
     validateCallback('OnDisconnect.set', 2, onComplete, true);
-    const deferred = new Deferred<void>();
-    repoOnDisconnectSet(
-      this.repo_,
-      this.path_,
-      value,
-      deferred.wrapCallback(onComplete)
-    );
-    return deferred.promise;
+    const result = this._delegate.set(value);
+    if (onComplete) {
+      result.then(
+        () => onComplete(null),
+        error => onComplete(error)
+      );
+    }
+    return result;
   }
 
   setWithPriority(
@@ -84,34 +69,22 @@ export class OnDisconnect {
     onComplete?: (a: Error | null) => void
   ): Promise<void> {
     validateArgCount('OnDisconnect.setWithPriority', 2, 3, arguments.length);
-    validateWritablePath('OnDisconnect.setWithPriority', this.path_);
-    validateFirebaseDataArg(
-      'OnDisconnect.setWithPriority',
-      1,
-      value,
-      this.path_,
-      false
-    );
-    validatePriority('OnDisconnect.setWithPriority', 2, priority, false);
     validateCallback('OnDisconnect.setWithPriority', 3, onComplete, true);
-
-    const deferred = new Deferred<void>();
-    repoOnDisconnectSetWithPriority(
-      this.repo_,
-      this.path_,
-      value,
-      priority,
-      deferred.wrapCallback(onComplete)
-    );
-    return deferred.promise;
+    const result = this._delegate.setWithPriority(value, priority);
+    if (onComplete) {
+      result.then(
+        () => onComplete(null),
+        error => onComplete(error)
+      );
+    }
+    return result;
   }
 
   update(
     objectToMerge: Indexable,
     onComplete?: (a: Error | null) => void
   ): Promise<void> {
     validateArgCount('OnDisconnect.update', 1, 2, arguments.length);
-    validateWritablePath('OnDisconnect.update', this.path_);
     if (Array.isArray(objectToMerge)) {
       const newObjectToMerge: { [k: string]: unknown } = {};
       for (let i = 0; i < objectToMerge.length; ++i) {
@@ -123,21 +96,14 @@ export class OnDisconnect {
           'existing data, or an Object with integer keys if you really do want to only update some of the children.'
       );
     }
-    validateFirebaseMergeDataArg(
-      'OnDisconnect.update',
-      1,
-      objectToMerge,
-      this.path_,
-      false
-    );
     validateCallback('OnDisconnect.update', 2, onComplete, true);
-    const deferred = new Deferred<void>();
-    repoOnDisconnectUpdate(
-      this.repo_,
-      this.path_,
-      objectToMerge,
-      deferred.wrapCallback(onComplete)
-    );
-    return deferred.promise;
+    const result = this._delegate.update(objectToMerge);
+    if (onComplete) {
+      result.then(
+        () => onComplete(null),
+        error => onComplete(error)
+      );
+    }
+    return result;
   }
 }
diff --git a/packages/database/src/exp/OnDisconnect.ts b/packages/database/src/exp/OnDisconnect.ts
@@ -0,0 +1,117 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Deferred } from '@firebase/util';
+
+import {
+  Repo,
+  repoOnDisconnectCancel,
+  repoOnDisconnectSet,
+  repoOnDisconnectSetWithPriority,
+  repoOnDisconnectUpdate
+} from '../core/Repo';
+import { Indexable } from '../core/util/misc';
+import { Path } from '../core/util/Path';
+import {
+  validateFirebaseDataArg,
+  validateFirebaseMergeDataArg,
+  validatePriority,
+  validateWritablePath
+} from '../core/util/validation';
+
+export class OnDisconnect {
+  constructor(private _repo: Repo, private _path: Path) {}
+
+  cancel(): Promise<void> {
+    const deferred = new Deferred<void>();
+    repoOnDisconnectCancel(
+      this._repo,
+      this._path,
+      deferred.wrapCallback(() => {})
+    );
+    return deferred.promise;
+  }
+
+  remove(): Promise<void> {
+    validateWritablePath('OnDisconnect.remove', this._path);
+    const deferred = new Deferred<void>();
+    repoOnDisconnectSet(
+      this._repo,
+      this._path,
+      null,
+      deferred.wrapCallback(() => {})
+    );
+    return deferred.promise;
+  }
+
+  set(value: unknown): Promise<void> {
+    validateWritablePath('OnDisconnect.set', this._path);
+    validateFirebaseDataArg('OnDisconnect.set', 1, value, this._path, false);
+    const deferred = new Deferred<void>();
+    repoOnDisconnectSet(
+      this._repo,
+      this._path,
+      value,
+      deferred.wrapCallback(() => {})
+    );
+    return deferred.promise;
+  }
+
+  setWithPriority(
+    value: unknown,
+    priority: number | string | null
+  ): Promise<void> {
+    validateWritablePath('OnDisconnect.setWithPriority', this._path);
+    validateFirebaseDataArg(
+      'OnDisconnect.setWithPriority',
+      1,
+      value,
+      this._path,
+      false
+    );
+    validatePriority('OnDisconnect.setWithPriority', 2, priority, false);
+
+    const deferred = new Deferred<void>();
+    repoOnDisconnectSetWithPriority(
+      this._repo,
+      this._path,
+      value,
+      priority,
+      deferred.wrapCallback(() => {})
+    );
+    return deferred.promise;
+  }
+
+  update(objectToMerge: Indexable): Promise<void> {
+    validateWritablePath('OnDisconnect.update', this._path);
+    validateFirebaseMergeDataArg(
+      'OnDisconnect.update',
+      1,
+      objectToMerge,
+      this._path,
+      false
+    );
+    const deferred = new Deferred<void>();
+    repoOnDisconnectUpdate(
+      this._repo,
+      this._path,
+      objectToMerge,
+      deferred.wrapCallback(() => {})
+    );
+    return deferred.promise;
+  }
+}
diff --git a/packages/database/src/exp/Reference.ts b/packages/database/src/exp/Reference.ts
@@ -31,17 +31,6 @@ export interface Reference extends Query {
   readonly parent: Reference | null;
 }
 
-export interface OnDisconnect {
-  cancel(): Promise<void>;
-  remove(): Promise<void>;
-  set(value: unknown): Promise<void>;
-  setWithPriority(
-    value: unknown,
-    priority: number | string | null
-  ): Promise<void>;
-  update(values: object): Promise<void>;
-}
-
 export interface ThenableReference
   extends Reference,
     Pick<Promise<Reference>, 'then' | 'catch'> {}
diff --git a/packages/database/src/exp/Reference_impl.ts b/packages/database/src/exp/Reference_impl.ts
@@ -85,9 +85,9 @@ import {
 } from '../core/view/QueryParams';
 
 import { FirebaseDatabase } from './Database';
+import { OnDisconnect } from './OnDisconnect';
 import {
   ListenOptions,
-  OnDisconnect,
   Query as Query,
   Reference as Reference,
   Unsubscribe
@@ -390,8 +390,8 @@ export function child(ref: Reference, path: string): ReferenceImpl {
 }
 
 export function onDisconnect(ref: Reference): OnDisconnect {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return {} as any;
+  ref = getModularInstance(ref) as ReferenceImpl;
+  return new OnDisconnect(ref._repo, ref._path);
 }
 
 export interface ThenableReferenceImpl
