Use delegation

Author: schmidt-sebastian

packages/storage-types/index.d.ts

@@ -47,7 +47,7 @@ export interface Reference {
     metadata?: UploadMetadata
   ): UploadTask;
   root: Reference;
-  storage: Storage;
+  storage: FirebaseStorage;
   toString(): string;
   updateMetadata(metadata: SettableMetadata): Promise<FullMetadata>;
   listAll(): Promise<ListResult>;
@@ -85,7 +85,7 @@ export interface UploadMetadata extends SettableMetadata {
 }
 
 export type NextFn<T> = (value: T) => void;
-export type ErrorFn = (error: Error | FirebaseStorageError) => void;
+export type ErrorFn = (error: Error | Error) => void;
 export type CompleteFn = () => void;
 export type Unsubscribe = () => void;
 export interface StorageObserver<T> {

packages/storage/compat/list.ts

@@ -25,8 +25,8 @@ export class ListResultCompat implements types.ListResult {
   constructor(private readonly  delegate: ListResult) {
   }
 
-  prefixes = this.delegate.prefixes.map(v => ReferenceCompat.fromReference(v));
-  items = this.delegate.items.map(v => ReferenceCompat.fromReference(v));
+  prefixes = this.delegate.prefixes.map(v => new ReferenceCompat(v));
+  items = this.delegate.items.map(v => new ReferenceCompat(v));
   nextPageToken = this.delegate.nextPageToken;
 
 }

packages/storage/compat/reference.ts

@@ -43,24 +43,22 @@ import { UploadTaskCompat } from './task';
 import {ListResultCompat} from "./list";
 import {Location} from "../src/implementation/location";
 import {StorageServiceCompat} from "./service";
+import * as errorsExports from "../src/implementation/error";
 
-export class ReferenceCompat extends Reference implements types.Reference {
-  static fromReference(ref: Reference): types.Reference {
-    return new ReferenceCompat(ref.service, ref.location);
-  }
+export class ReferenceCompat implements types.Reference {
 
-  get root() :  any {
-    const location = new Location(this.location.bucket, '');
-    return new ReferenceCompat(this.service, location);
-  }
-
-  get storage(): any {
-    return StorageServiceCompat.fromService(this.service);
+  constructor(private readonly delegate: Reference) {
   }
 
+  root = new ReferenceCompat(this.delegate.root);
+  storage = new StorageServiceCompat(this.delegate.storage);
+  name = this.delegate.name;
+  bucket = this.delegate.bucket;
+  fullPath = this.delegate.fullPath;
+
   toString(): string {
     validate('toString', [], arguments);
-    return super.toString();
+    return this.delegate.toString();
   }
 
   /**
@@ -70,8 +68,8 @@ export class ReferenceCompat extends Reference implements types.Reference {
    */
   child(childPath: string): types.Reference {
     validate('child', [stringSpec()], arguments);
-    const reference = getChild(this, childPath);
-    return ReferenceCompat.fromReference(reference);
+    const reference = getChild(this.delegate, childPath);
+    return new ReferenceCompat(reference);
   }
 
   /**
@@ -80,11 +78,11 @@ export class ReferenceCompat extends Reference implements types.Reference {
    */
   get parent(): types.Reference | null {
     validate('parent', [], arguments);
-    const reference = getParent(this);
+    const reference = getParent(this.delegate);
     if (reference == null) {
       return null;
     }
-    return ReferenceCompat.fromReference(reference);
+    return new ReferenceCompat(reference);
   }
 
   /**
@@ -96,10 +94,10 @@ export class ReferenceCompat extends Reference implements types.Reference {
   put(
     data: Blob | Uint8Array | ArrayBuffer,
     metadata?: Metadata
-  ): any {
+  ): types.UploadTask {
     validate('put', [uploadDataSpec(), metadataSpec(true)], arguments);
     this.throwIfRoot_('put');
-    return uploadBytes(this, data, metadata) as UploadTaskCompat;
+    return new UploadTaskCompat(uploadBytes(this.delegate, data, metadata));
   }
   /**
    * Uploads a string to this object's location.
@@ -112,15 +110,16 @@ export class ReferenceCompat extends Reference implements types.Reference {
     value: string,
     format: StringFormat = StringFormat.RAW,
     metadata?: Metadata
-  ): any {
+  ): types.UploadTask {
     validate(
       'putString',
       [stringSpec(), stringSpec(formatValidator, true), metadataSpec(true)],
       arguments
     );
     this.throwIfRoot_('putString');
-    return uploadString(this, value, format, metadata);
+    return new UploadTaskCompat(uploadString(this.delegate, value, format, metadata));
   }
+  
   /**
    * List all items (files) and prefixes (folders) under this storage reference.
    *
@@ -140,8 +139,9 @@ export class ReferenceCompat extends Reference implements types.Reference {
    */
   listAll(): Promise<types.ListResult> {
     validate('listAll', [], arguments);
-    return listAll(this).then(r => new ListResultCompat(r));
+    return listAll(this.delegate).then(r => new ListResultCompat(r));
   }
+  
   /**
    * List items (files) and prefixes (folders) under this storage reference.
    *
@@ -164,7 +164,7 @@ export class ReferenceCompat extends Reference implements types.Reference {
    */
   list(options?: ListOptions | null): Promise<types.ListResult> {
     validate('list', [listOptionSpec(true)], arguments);
-    return list(this, options).then(r => new ListResultCompat(r));
+    return list(this.delegate, options).then(r => new ListResultCompat(r));
   }
 
   /**
@@ -174,7 +174,7 @@ export class ReferenceCompat extends Reference implements types.Reference {
    */
   getMetadata(): Promise<Metadata> {
     validate('getMetadata', [], arguments);
-    return getMetadata(this);
+    return getMetadata(this.delegate);
   }
 
   /**
@@ -188,7 +188,7 @@ export class ReferenceCompat extends Reference implements types.Reference {
    */
   updateMetadata(metadata: Metadata): Promise<Metadata> {
     validate('updateMetadata', [metadataSpec()], arguments);
-    return updateMetadata(this, metadata);
+    return updateMetadata(this.delegate, metadata);
   }
 
   /**
@@ -197,7 +197,7 @@ export class ReferenceCompat extends Reference implements types.Reference {
    */
   getDownloadURL(): Promise<string> {
     validate('getDownloadURL', [], arguments);
-    return getDownloadURL(this);
+    return getDownloadURL(this.delegate);
   }
 
   /**
@@ -207,6 +207,12 @@ export class ReferenceCompat extends Reference implements types.Reference {
   delete(): Promise<void> {
     validate('delete', [], arguments);
     this.throwIfRoot_('delete');
-    return deleteObject(this);
+    return deleteObject(this.delegate);
+  }
+
+  private throwIfRoot_(name: string): void {
+    if (this.delegate.location.path === '') {
+      throw errorsExports.invalidRootOperation(name);
+    }
   }
 }

packages/storage/compat/service.ts

@@ -16,12 +16,8 @@
  */
 
 import * as types from '@firebase/storage-types';
-import { StorageService, isUrl } from '../src/service';
+import { StorageService, isUrl, ref } from '../src/service';
 import { Location } from '../src/implementation/location';
-import { FirebaseApp } from '@firebase/app-types';
-import { Provider } from '@firebase/component';
-import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
-import { XhrIoPool } from '../src/implementation/xhriopool';
 import * as args from '../src/implementation/args';
 import { ReferenceCompat } from './reference';
 
@@ -54,37 +50,22 @@ export function pathValidator(path: unknown): void {
  *
  * @struct
  */
-export class StorageServiceCompat extends StorageService implements types.FirebaseStorage {
-  private readonly internals_: ServiceInternals;
+export class StorageServiceCompat implements types.FirebaseStorage {
 
-  constructor(
-    app: FirebaseApp,
-    authProvider: Provider<FirebaseAuthInternalName>,
-  pool: XhrIoPool,
-    url?: string
-  ) {
-    super(app, authProvider, pool, url);
-    this.internals_ = new ServiceInternals(this);
+  constructor(readonly delegate: StorageService) {
   }
 
-
-  static fromService(service: StorageService) : StorageServiceCompat  {
-    return new StorageServiceCompat(service.app, service.authProvider_, service.pool_, service.url_);
-  }
+  app = this.delegate.app;
+  maxOperationRetryTime = this.delegate.maxOperationRetryTime;
+  maxUploadRetryTime = this.delegate.maxUploadRetryTime
 
   /**
    * Returns a firebaseStorage.Reference for the given path in the default
    * bucket.
    */
-  ref(path?: string): types.Reference  {
+  ref(path?: string): types.Reference {
     args.validate('ref', [args.stringSpec(pathValidator, true)], arguments);
-
-    const reference = new ReferenceCompat(this, this.bucket_!);
-    if (path != null) {
-      return reference.child(path);
-    } else {
-      return reference;
-    }
+    return new ReferenceCompat(ref(this.delegate, path));
   }
 
   /**
@@ -97,7 +78,7 @@ export class StorageServiceCompat extends StorageService implements types.Fireba
       [args.stringSpec(urlValidator, false)],
       arguments
     );
-    return new ReferenceCompat(this, url);
+    return new ReferenceCompat(ref(this.delegate, url)) as  types.Reference;
   }
 
   setMaxUploadRetryTime(time: number): void {
@@ -106,8 +87,7 @@ export class StorageServiceCompat extends StorageService implements types.Fireba
       [args.nonNegativeNumberSpec()],
       arguments
     );
-    // Can't call get/set on super class.
-    this.maxUploadRetryTime_ = time;
+    this.delegate.maxUploadRetryTime = time;
   }
 
   setMaxOperationRetryTime(time: number): void {
@@ -116,14 +96,8 @@ export class StorageServiceCompat extends StorageService implements types.Fireba
       [args.nonNegativeNumberSpec()],
       arguments
     );
-    // Can't call get/set on super class.
-    this.maxOperationRetryTime_ = time;
+    this.delegate.maxOperationRetryTime = time;
   }
-
-  get INTERNAL(): ServiceInternals {
-    return this.internals_;
-  }
-
 }
 
 /**

packages/storage/compat/task.ts

@@ -28,29 +28,32 @@ import { Metadata } from '../src/metadata';
 import { ErrorFn, CompleteFn, Unsubscribe, Subscribe } from '@firebase/util';
 import * as types from '@firebase/storage-types';
 import { StorageObserver } from '../src/implementation/observer';
+import * as typeUtils from "../src/implementation/type";
 
-export class UploadTaskCompat extends UploadTask<UploadTaskSnapshotCompat>
-  implements types.UploadTask {
+export class UploadTaskCompat implements types.UploadTask {
   constructor(
-    private refCompat_: ReferenceCompat,
-    blob: FbsBlob,
-    metadata: Metadata | null = null
+    private readonly delegate : UploadTask
   ) {
-    super(refCompat_, blob, metadata);
   }
 
-  get snapshot(): UploadTaskSnapshotCompat {
-    const externalState = taskStateFromInternalTaskState(this.state_);
-    return new UploadTaskSnapshotCompat(
-      this.transferred_,
-      this.blob_.size(),
-      externalState,
-      this.metadata_!, // VERIFY
-      this,
-      this.refCompat_
-    );
+  snapshot = new UploadTaskSnapshotCompat(this.delegate.snapshot);
+
+  cancel = this.delegate.cancel;
+  catch = this.delegate.catch;
+  pause = this.delegate.pause;
+  resume = this.delegate.pause;
+
+  then(
+    onFulfilled?: ((a: UploadTaskSnapshotCompat) => any) | null,
+    onRejected?: ((a: Error) => any) | null
+  ): Promise<any> {
+    return this.delegate.then((snapshot) => {
+      if (onFulfilled) {
+        return onFulfilled(new UploadTaskSnapshotCompat(snapshot));
+      }
+    }, onRejected)
   }
-  
+
   on(
     type: TaskEvent,
     nextOrObserver?:
@@ -60,12 +63,7 @@ export class UploadTaskCompat extends UploadTask<UploadTaskSnapshotCompat>
     error?: ErrorFn | null,
     completed?: CompleteFn | null
   ): Unsubscribe | Subscribe<UploadTaskSnapshotCompat> {
-    const castNextOrObserver = nextOrObserver as
-      | Partial<StorageObserver<UploadTaskSnapshot>>
-      | null
-      | ((a: UploadTaskSnapshot) => unknown);
-    return super.on(type, castNextOrObserver, error, completed) as
-      | Unsubscribe
-      | Subscribe<types.UploadTaskSnapshot>;
+    // TODO: Wrap all returned values in new snapshot
+    return this.delegate.on(type, nextOrObserver as any, error, completed);
   }
 }

packages/storage/compat/tasksnapshot.ts

@@ -21,14 +21,16 @@ import { TaskState } from '../src/implementation/taskenums';
 import { Metadata } from '../src/metadata';
 import { ReferenceCompat } from './reference';
 import { UploadTaskCompat } from './task';
+import {UploadTaskSnapshot} from "../src/tasksnapshot";
 
 export class UploadTaskSnapshotCompat implements types.UploadTaskSnapshot{
-  constructor(
-    readonly bytesTransferred: number,
-    readonly totalBytes: number,
-    readonly state: TaskState,
-    readonly metadata: Metadata,
-    readonly task: UploadTaskCompat,
-    readonly ref: ReferenceCompat
-  ) {}
+  
+  constructor(readonly delegate: UploadTaskSnapshot) {}
+
+  bytesTransferred = this.delegate.bytesTransferred;
+  metadata = this.delegate.metadata;
+  ref = new ReferenceCompat(this.delegate.ref);
+  state = this.delegate.state;
+  task = new UploadTaskCompat(this.delegate.task);
+  totalBytes = this.delegate.bytesTransferred;
 }