feat(module): WIP Release Candidate API

package.json

@@ -1,6 +1,6 @@
 {
   "name": "angularfire2",
-  "version": "2.0.0-beta.8",
+  "version": "4.0.0-rc0",
   "description": "",
   "main": "bundles/angularfire2.umd.js",
   "module": "index.js",

src/angularfire2.spec.ts

@@ -1,39 +1,25 @@
 import * as firebase from 'firebase/app';
-import {
-  TestBed,
-  inject
-} from '@angular/core/testing';
+import { TestBed, inject } from '@angular/core/testing';
 import { ReflectiveInjector, Provider } from '@angular/core';
-import {
-  AngularFire,
-  FirebaseObjectObservable,
-  FIREBASE_PROVIDERS,
-  FirebaseApp,
-  AngularFireDatabase,
-  FirebaseAppConfig,
-  AngularFireModule,
-  AngularFireAuth
-} from './angularfire2';
+import { FirebaseApp, FirebaseAppConfig, AngularFireModule } from './angularfire2';
 import { Subscription } from 'rxjs/Subscription';
-import { COMMON_CONFIG, ANON_AUTH_CONFIG } from './test-config';
+import { COMMON_CONFIG } from './test-config';
 
 describe('angularfire', () => {
   let subscription:Subscription;
   let app: FirebaseApp;
   let rootRef: firebase.database.Reference;
   let questionsRef: firebase.database.Reference;
   let listOfQuestionsRef: firebase.database.Reference;
-  let angularfire: AngularFire;
   const APP_NAME = 'super-awesome-test-firebase-app-name';
 
   beforeEach(() => {
 
     TestBed.configureTestingModule({
-      imports: [AngularFireModule.initializeApp(COMMON_CONFIG, ANON_AUTH_CONFIG, APP_NAME)]
+      imports: [AngularFireModule.initializeApp(COMMON_CONFIG, APP_NAME)]
     });
 
-    inject([FirebaseApp, AngularFire], (_app: FirebaseApp, _af: AngularFire) => {
-      angularfire = _af;
+    inject([FirebaseApp], (_app: FirebaseApp) => {
       app = _app;
       rootRef = app.database().ref();
       questionsRef = rootRef.child('questions');
@@ -50,23 +36,6 @@ describe('angularfire', () => {
     app.delete().then(done, done.fail);
   });
 
-  it('should be injectable via FIREBASE_PROVIDERS', () => {
-    expect(angularfire instanceof AngularFire).toBe(true);
-  });
-
-  describe('.auth', () => {
-    it('should be an instance of AuthService', inject([AngularFire], (af:AngularFire) => {
-      debugger;
-      expect(af.auth instanceof AngularFireAuth).toBe(true);
-    }));
-  });
-
-  describe('.database', () => {
-    it('should be an instance of Database', inject([AngularFire], (af:AngularFire) => {
-      expect(af.database instanceof AngularFireDatabase).toBe(true);
-    }));
-  });
-
   describe('FirebaseApp', () => {
     it('should provide a FirebaseApp for the FirebaseApp binding', () => {
       expect(typeof app.delete).toBe('function');

src/angularfire2.ts

@@ -2,118 +2,28 @@ import * as firebase from 'firebase/app';
 import * as utils from './utils';
 import { FirebaseAppConfigToken, FirebaseApp, _firebaseAppFactory } from './app/index';
 import { FirebaseListFactoryOpts, FirebaseObjectFactoryOpts, FirebaseAppConfig } from './interfaces';
-import { FirebaseAppName, WindowLocation, FirebaseAuthConfig } from './tokens';
+import { FirebaseAppName } from './tokens';
 import { Injectable, OpaqueToken, NgModule } from '@angular/core';
-import { FirebaseListObservable, FirebaseObjectObservable, FirebaseListFactory, FirebaseObjectFactory, AngularFireDatabase } from './database/index';
-import { FirebaseSdkAuthBackend, AuthBackend, AngularFireAuth, AuthConfiguration } from './auth/index';
-
-@Injectable()
-export class AngularFire {
-  constructor(
-    public auth: AngularFireAuth,
-    public database: AngularFireDatabase) {}
-}
-
-export function _getAngularFire(db: AngularFireDatabase, auth: AngularFireAuth) {
-  return new AngularFire(auth, db);
-}
-
-export function _getAngularFireDatabase(app: FirebaseApp) {
-  return new AngularFireDatabase(app);
-}
-
-export function _getAngularFireAuth(backend: AuthBackend, location: any, config: any) {
-  return new AngularFireAuth(backend, location, config);
-}
-
-export function _getWindowLocation(){
-  return window.location;
-}
-
-export function _getFirebaseAuthBackend(app: FirebaseApp) {
-  return new FirebaseSdkAuthBackend(app);
-}
-
-export const AuthBackendProvder = {
-  provide: AuthBackend,
-  useFactory: _getFirebaseAuthBackend,
-  deps: [ FirebaseApp ]
-};
-
-export const WindowLocationProvider = {
-  provide: WindowLocation,
-  useFactory: _getWindowLocation
-};
 
 export const FirebaseAppProvider = {
   provide: FirebaseApp,
   useFactory: _firebaseAppFactory,
   deps: [ FirebaseAppConfigToken, FirebaseAppName ]
 };
 
-export const AngularFireDatabaseProvider = {
-  provide: AngularFireDatabase,
-  useFactory: _getAngularFireDatabase,
-  deps: [ FirebaseApp ]
-};
-
-export const FirebaseAuthBackendProvider = {
-  provide: FirebaseSdkAuthBackend,
-  useFactory: _getFirebaseAuthBackend,
-  deps: [ FirebaseApp ]
-};
-
-export const AngularFireAuthProvider = {
-  provide: AngularFireAuth,
-  useFactory: _getAngularFireAuth,
-  deps: [ AuthBackend, WindowLocation, FirebaseAuthConfig ]
-};
-
-export const AngularFireProvider = {
-  provide: AngularFire,
-  useFactory: _getAngularFire,
-  deps: [ AngularFireDatabase, AngularFireAuth ]
-};
-
-export const FIREBASE_PROVIDERS:any[] = [
-  FirebaseAppProvider,
-  FirebaseAuthBackendProvider,
-  AuthBackendProvder,
-  WindowLocationProvider,
-  AngularFireDatabaseProvider,
-  AngularFireAuthProvider,
-  AngularFireProvider
-];
-
-export {
-  FirebaseApp,
-  FirebaseAppConfigToken,
-  AngularFireDatabase,
-  AngularFireAuth,
-  FirebaseListObservable,
-  FirebaseObjectObservable,
-  FirebaseListFactory,
-  FirebaseObjectFactory,
-  WindowLocation
-}
-
-export { AuthMethods, firebaseAuthConfig, AuthProviders, FirebaseAuthState } from './auth/index';
-
-export { FirebaseConfig, FirebaseAuthConfig, FirebaseRef, FirebaseUrl, FirebaseUserConfig } from './tokens';
-export { FirebaseAppConfig } from './interfaces';
-
 @NgModule({
-  providers: [FIREBASE_PROVIDERS],
+  providers: [ FirebaseAppProvider ],
 })
 export class AngularFireModule {
-  static initializeApp(config: FirebaseAppConfig, authConfig?: AuthConfiguration, appName?: string) {
+  static initializeApp(config: FirebaseAppConfig, appName?: string) {
     return {
       ngModule: AngularFireModule,
       providers: [
         { provide: FirebaseAppConfigToken, useValue: config },
-        { provide: FirebaseAppName, useValue: appName },
-        { provide: FirebaseAuthConfig, useValue: authConfig }
+        { provide: FirebaseAppName, useValue: appName }
       ]
     }
   }
 }
+
+export { FirebaseApp, FirebaseAppConfigToken, FirebaseAppConfig }

src/auth/auth.module.ts

@@ -0,0 +1,26 @@
+import { NgModule, NgZone } from '@angular/core';
+import * as firebase from 'firebase/app';
+import 'firebase/auth';
+import { FirebaseApp } from '../app/index';
+import { AngularFireModule } from '../angularfire2';
+import { AngularFireAuth } from './index';
+
+export function _getAngularFireAuth(app: FirebaseApp) {
+  return new AngularFireAuth(app);
+}
+
+export const AngularFireAuthProvider = {
+  provide: AngularFireAuth,
+  useFactory: _getAngularFireAuth,
+  deps: [ FirebaseApp ]
+};
+
+export const AUTH_PROVIDERS = [
+  AngularFireAuthProvider,
+];
+
+@NgModule({
+  imports: [ AngularFireModule ],
+  providers: [ AUTH_PROVIDERS ]
+})
+export class AngularFireAuthModule { }