feat(schematics): Super charge the schematics (#2836)

Co-authored-by: Tomek Sułkowski <[email protected]>

Author: jamesdaniels

.github/workflows/test.yml

@@ -155,8 +155,14 @@ jobs:
           yarn config set yarn-offline-mirror ~/.npm-packages-offline-cache
           yarn install --frozen-lockfile --prefer-offline --ignore-engines
       - name: Build
-        id: yarn-pack-dir
         run: yarn build
+      # Seeing some flakes on windows, skip for now
+      # https://github.com/angular/angularfire/runs/3593478229
+      # not just windows
+      # https://github.com/angular/angularfire/runs/3593535123
+      # - name: Test
+      #   if: runner.os != 'windows'
+      #   run: yarn test
 
   headless:
     runs-on: ubuntu-latest

package.json

@@ -52,22 +52,25 @@
     "@angular/platform-browser": "^12.0.0",
     "@angular/platform-browser-dynamic": "^12.0.0",
     "@angular/router": "^12.0.0",
+    "@schematics/angular": "^12.0.0",
     "firebase": "^9.0.0",
-    "firebase-admin": "^8.10.0",
+    "firebase-admin": "^9.11.1",
     "firebase-functions": "^3.6.0",
     "firebase-tools": "^9.0.0",
     "fs-extra": "^8.0.1",
     "fuzzy": "^0.1.3",
     "husky": "^4.2.5",
-    "inquirer": "^6.2.2",
     "inquirer-autocomplete-prompt": "^1.0.1",
     "jsonc-parser": "^3.0.0",
-    "open": "^7.0.3",
+    "open": "^7.0.3 || ^8.0.0",
+    "ora": "^5.3.0",
     "rxfire": "^6.0.0",
     "rxjs": "~6.6.0",
     "semver": "^7.1.3",
+    "triple-beam": "^1.3.0",
     "tslib": "^2.1.0",
     "webpack": "^5.35.0",
+    "winston": "^3.0.0",
     "zone.js": "~0.11.4"
   },
   "devDependencies": {
@@ -84,6 +87,8 @@
     "@types/node": "^12.6.2 < 12.12.42",
     "@types/request": "0.0.30",
     "@types/semver": "^7.1.0",
+    "@types/triple-beam": "^1.3.0",
+    "@types/winston": "^2.4.4",
     "codelyzer": "^6.0.0",
     "concurrently": "^2.2.0",
     "conventional-changelog-cli": "^1.2.0",

samples/advanced/.firebaserc

@@ -32,7 +32,14 @@
     "rxjs": "~6.6.0"
   },
   "dependencies": {
-    "tslib": "^2.0.0"
+    "tslib": "^2.0.0",
+    "fuzzy": "^0.1.3",
+    "inquirer-autocomplete-prompt": "^1.0.1",
+    "open": "^8.0.0",
+    "jsonc-parser": "^3.0.0",
+    "ora": "^5.3.0",
+    "winston": "^3.0.0",
+    "triple-beam": "^1.3.0"
   },
   "ngPackage": {
     "lib": {
@@ -45,7 +52,12 @@
       },
       "entryFile": "public_api.ts"
     },
-    "dest": "../dist/packages-dist"
+    "dest": "../dist/packages-dist",
+    "allowedNonPeerDependencies": [
+      "fuzzy", "inquirer-autocomplete-prompt",
+      "open", "jsonc-parser", "ora", "winston",
+      "triple-beam"
+    ]
   },
   "ng-update": {
     "migrations": "./schematics/migration.json"

samples/advanced/angular.json

@@ -0,0 +1,34 @@
+import { chain, Rule, SchematicContext, TaskId, Tree } from '@angular-devkit/schematics';
+import { DeployOptions } from '../interfaces';
+import { addDependencies } from '../common';
+import { peerDependencies } from '../versions.json';
+import { NodePackageInstallTask, RunSchematicTask } from '@angular-devkit/schematics/tasks';
+
+const addFirebaseHostingDependencies = () => (tree: Tree, context: SchematicContext) => {
+  addDependencies(
+    tree,
+    peerDependencies,
+    context
+  );
+  return tree;
+};
+
+let npmInstallTaskId: TaskId;
+
+const npmInstall = () => (tree: Tree, context: SchematicContext) => {
+  npmInstallTaskId = context.addTask(new NodePackageInstallTask());
+  return tree;
+};
+
+const runSetup = (options: DeployOptions) => (tree: Tree, context: SchematicContext) => {
+  context.addTask(new RunSchematicTask('ng-add-setup-project', options), [npmInstallTaskId]);
+  return tree;
+};
+
+export const ngAdd = (options: DeployOptions): Rule => {
+  return chain([
+    addFirebaseHostingDependencies(),
+    npmInstall(),
+    runSetup(options),
+  ]);
+};

samples/advanced/firebase.json

@@ -0,0 +1,16 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "angular-fire-ng-add",
+    "title": "AngularFire ng-add",
+    "type": "object",
+    "properties": {
+      "project": {
+        "type": "string",
+        "description": "The name of the project.",
+        "$default": {
+          "$source": "projectName"
+        }
+      }
+    },
+    "required": []
+  }

samples/advanced/package.json

@@ -3,11 +3,13 @@
   "schematics": {
     "ng-add": {
       "description": "Add firebase deploy schematic",
-      "factory": "./public_api#ngAdd"
+      "factory": "./add#ngAdd",
+      "schema": "./add/schema.json"
     },
     "ng-add-setup-project": {
       "description": "Setup ng deploy",
-      "factory": "./public_api#ngAddSetupProject"
+      "factory": "./setup#ngAddSetupProject",
+      "schema": "./setup/schema.json"
     }
   }
 }

samples/advanced/yarn.lock

@@ -1,20 +1,7 @@
 import { SchematicsException, Tree, SchematicContext } from '@angular-devkit/schematics';
-import { FirebaseRc } from './interfaces';
+import { FirebaseHostingSite, FirebaseRc } from './interfaces';
 import * as semver from 'semver';
-
-export interface NgAddOptions {
-  firebaseProject: string;
-  project?: string;
-}
-
-export interface NgAddNormalizedOptions {
-  firebaseProject: string;
-  project: string;
-}
-
-export interface DeployOptions {
-  project: string;
-}
+import { shortSiteName } from './utils';
 
 export const stringifyFormatted = (obj: any) => JSON.stringify(obj, null, 2);
 
@@ -36,12 +23,11 @@ function emptyFirebaseRc() {
   };
 }
 
-function generateFirebaseRcTarget(firebaseProject: string, project: string) {
+function generateFirebaseRcTarget(firebaseProject: string, firebaseHostingSite: FirebaseHostingSite|undefined, project: string) {
   return {
     hosting: {
       [project]: [
-        // TODO(kirjs): Generally site name is consistent with the project name, but there are edge cases.
-        firebaseProject
+        shortSiteName(firebaseHostingSite) ?? firebaseProject
       ]
     }
   };
@@ -51,25 +37,20 @@ export function generateFirebaseRc(
   tree: Tree,
   path: string,
   firebaseProject: string,
+  firebaseHostingSite: FirebaseHostingSite|undefined,
   project: string
 ) {
   const firebaseRc: FirebaseRc = tree.exists(path)
     ? safeReadJSON(path, tree)
     : emptyFirebaseRc();
 
   firebaseRc.targets = firebaseRc.targets || {};
-
-  /* TODO do we want to prompt?
-  if (firebaseProject in firebaseRc.targets) {
-    throw new SchematicsException(
-      `Firebase project ${firebaseProject} already defined in .firebaserc`
-    );
-  }*/
-
   firebaseRc.targets[firebaseProject] = generateFirebaseRcTarget(
     firebaseProject,
+    firebaseHostingSite,
     project
   );
+  firebaseRc.projects = { default: firebaseProject };
 
   overwriteIfExists(tree, path, stringifyFormatted(firebaseRc));
 }
@@ -95,28 +76,27 @@ export const addDependencies = (
     throw new SchematicsException('Could not locate package.json');
   }
 
+  packageJson.devDependencies ??= {};
+  packageJson.dependencies ??= {};
+
   Object.keys(deps).forEach(depName => {
     const dep = deps[depName];
-    if (dep.dev) {
-      const existingVersion = packageJson.devDependencies[depName];
-      if (existingVersion) {
+    const existingDeps = dep.dev ? packageJson.devDependencies : packageJson.dependencies;
+    const existingVersion = existingDeps[depName];
+    if (existingVersion) {
+      try {
         if (!semver.intersects(existingVersion, dep.version)) {
           context.logger.warn(`⚠️ The ${depName} devDependency specified in your package.json (${existingVersion}) does not fulfill AngularFire's dependency (${dep.version})`);
           // TODO offer to fix
         }
-      } else {
-        packageJson.devDependencies[depName] = dep.version;
-      }
-    } else {
-      const existingVersion = packageJson.dependencies[depName];
-      if (existingVersion) {
-        if (!semver.intersects(existingVersion, dep.version)) {
-          context.logger.warn(`⚠️ The ${depName} dependency specified in your package.json (${existingVersion}) does not fulfill AngularFire's dependency (${dep.version})`);
+      } catch (e) {
+        if (existingVersion !== dep.version) {
+          context.logger.warn(`⚠️ The ${depName} devDependency specified in your package.json (${existingVersion}) does not fulfill AngularFire's dependency (${dep.version})`);
           // TODO offer to fix
         }
-      } else {
-        packageJson.dependencies[depName] = dep.version;
       }
+    } else {
+      existingDeps[depName] = dep.version;
     }
   });
 

samples/modular/yarn.lock

@@ -1,7 +1,7 @@
 import { JsonObject, logging } from '@angular-devkit/core';
 import { BuilderContext, BuilderRun, ScheduleOptions, Target } from '@angular-devkit/architect';
 import { BuildTarget, FirebaseDeployConfig, FirebaseTools, FSHost } from '../interfaces';
-import deploy, { deployToFunction } from './actions';
+import deploy, { deployToFunction } from '@angular/fire/schematics/deploy/actions';
 import { join } from 'path';
 import 'jasmine';
 
@@ -28,13 +28,29 @@ const initMocks = () => {
     renameSync(_: string, __: string) {
     },
     writeFileSync(_: string, __: string) {
+    },
+    copySync(_: string, __: string) {
+    },
+    removeSync(_: string) {
     }
   };
 
   firebaseMock = {
     login: () => Promise.resolve(),
     projects: {
-      list: () => Promise.resolve([])
+      list: () => Promise.resolve([]),
+      create: () => Promise.reject(),
+    },
+    apps: {
+      list: () => Promise.resolve([]),
+      create: () => Promise.reject(),
+      sdkconfig: () => Promise.resolve({ fileName: '_', fileContents: '', sdkConfig: {}, }),
+    },
+    hosting: {
+      sites: {
+        list: () => Promise.resolve({sites: []}),
+        create: () => Promise.reject(),
+      }
     },
     deploy: (_: FirebaseDeployConfig) => Promise.resolve(),
     use: () => Promise.resolve(),
@@ -86,19 +102,22 @@ describe('Deploy Angular apps', () => {
 
   it('should call login', async () => {
     const spy = spyOn(firebaseMock, 'login');
-    await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined, FIREBASE_PROJECT, { preview: false });
+    await deploy(
+      firebaseMock, context, STATIC_BUILD_TARGET, undefined,
+      undefined, undefined, { projectId: FIREBASE_PROJECT, preview: false }
+    );
     expect(spy).toHaveBeenCalled();
   });
 
   it('should not call login', async () => {
     const spy = spyOn(firebaseMock, 'login');
-    await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined, FIREBASE_PROJECT, { preview: false }, FIREBASE_TOKEN);
+    await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined,  undefined, undefined, { preview: false }, FIREBASE_TOKEN);
     expect(spy).not.toHaveBeenCalled();
   });
 
   it('should invoke the builder', async () => {
     const spy = spyOn(context, 'scheduleTarget').and.callThrough();
-    await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined, FIREBASE_PROJECT, { preview: false });
+    await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined,  undefined, undefined, { preview: false });
     expect(spy).toHaveBeenCalled();
     expect(spy).toHaveBeenCalledWith({
       target: 'build',
@@ -113,26 +132,27 @@ describe('Deploy Angular apps', () => {
       options: {}
     };
     const spy = spyOn(context, 'scheduleTarget').and.callThrough();
-    await deploy(firebaseMock, context, buildTarget, undefined, FIREBASE_PROJECT, { preview: false });
+    await deploy(firebaseMock, context, buildTarget, undefined,  undefined, undefined, { preview: false });
     expect(spy).toHaveBeenCalled();
     expect(spy).toHaveBeenCalledWith({ target: 'prerender', project: PROJECT }, {});
   });
 
   it('should invoke firebase.deploy', async () => {
     const spy = spyOn(firebaseMock, 'deploy').and.callThrough();
-    await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined, FIREBASE_PROJECT, { preview: false }, FIREBASE_TOKEN);
+    await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined,  undefined, undefined, { preview: false }, FIREBASE_TOKEN);
     expect(spy).toHaveBeenCalled();
     expect(spy).toHaveBeenCalledWith({
       cwd: 'cwd',
       only: 'hosting:' + PROJECT,
-      token: FIREBASE_TOKEN
+      token: FIREBASE_TOKEN,
+      nonInteractive: true,
     });
   });
 
   describe('error handling', () => {
     it('throws if there is no firebase project', async () => {
       try {
-        await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined, undefined, { preview: false  });
+        await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined, undefined, undefined, { preview: false  });
       } catch (e) {
         expect(e.message).toMatch(/Cannot find firebase project/);
       }
@@ -141,7 +161,7 @@ describe('Deploy Angular apps', () => {
     it('throws if there is no target project', async () => {
       context.target = undefined;
       try {
-        await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined, FIREBASE_PROJECT, { preview: false });
+        await deploy(firebaseMock, context, STATIC_BUILD_TARGET, undefined, undefined, undefined, { preview: false });
       } catch (e) {
         expect(e.message).toMatch(/Cannot execute the build target/);
       }
@@ -174,6 +194,28 @@ describe('universal deployment', () => {
     expect(functionArgs[0]).toBe(join('dist', 'index.js'));
   });
 
+  it('should create a firebase function (new)', async () => {
+    const spy = spyOn(fsHost, 'writeFileSync');
+    await deployToFunction(
+      firebaseMock,
+      context,
+      '/home/user',
+      STATIC_BUILD_TARGET,
+      SERVER_BUILD_TARGET,
+      { preview: false, outputPath: join('dist', 'functions') },
+      undefined,
+      fsHost
+    );
+
+    expect(spy).toHaveBeenCalledTimes(2);
+
+    const packageArgs = spy.calls.argsFor(0);
+    const functionArgs = spy.calls.argsFor(1);
+
+    expect(packageArgs[0]).toBe(join('dist', 'functions', 'package.json'));
+    expect(functionArgs[0]).toBe(join('dist', 'functions', 'index.js'));
+  });
+
   it('should rename the index.html file in the nested dist', async () => {
     const spy = spyOn(fsHost, 'renameSync');
     await deployToFunction(
@@ -197,6 +239,29 @@ describe('universal deployment', () => {
     ]);
   });
 
+  it('should rename the index.html file in the nested dist (new)', async () => {
+    const spy = spyOn(fsHost, 'renameSync');
+    await deployToFunction(
+      firebaseMock,
+      context,
+      '/home/user',
+      STATIC_BUILD_TARGET,
+      SERVER_BUILD_TARGET,
+      { preview: false, outputPath: join('dist', 'functions') },
+      undefined,
+      fsHost
+    );
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    const packageArgs = spy.calls.argsFor(0);
+
+    expect(packageArgs).toEqual([
+      join('dist', 'functions', 'dist', 'browser', 'index.html'),
+      join('dist', 'functions', 'dist', 'browser', 'index.original.html')
+    ]);
+  });
+
   it('should invoke firebase.deploy', async () => {
     const spy = spyOn(firebaseMock, 'deploy');
     await deployToFunction(

src/package.json

@@ -1,7 +1,8 @@
 import { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';
 import deploy, { DeployBuilderOptions } from './actions';
 import { BuildTarget } from '../interfaces';
-import { getFirebaseProjectName } from '../utils';
+import { getFirebaseProjectNameFromFs } from '../utils';
+import { getFirebaseTools } from '../firebaseTools';
 
 // Call the createBuilder() function to create a builder. This mirrors
 // createJobHandler() but add typings specific to Architect Builders.
@@ -11,31 +12,51 @@ export default createBuilder(
       throw new Error('Cannot deploy the application without a target');
     }
 
-    const firebaseProject = options.firebaseProject || getFirebaseProjectName(
+    const [defaultFirebaseProject, defulatFirebaseHostingSite] = getFirebaseProjectNameFromFs(
       context.workspaceRoot,
       context.target.project
     );
 
+    const firebaseProject = options.firebaseProject || defaultFirebaseProject;
     if (!firebaseProject) {
-      throw new Error('Cannot find firebase project for your app in .firebaserc');
+      throw new Error('Cannot detirmine the Firebase Project from your angular.json or .firebaserc');
+    }
+    if (firebaseProject !== defaultFirebaseProject) {
+      throw new Error('The Firebase Project specified by your angular.json or .firebaserc is in conflict');
+    }
+
+    const firebaseHostingSite = options.firebaseHostingSite || defulatFirebaseHostingSite;
+    if (!firebaseHostingSite) {
+      throw new Error(`Cannot detirmine the Firebase Hosting Site from your angular.json or .firebaserc`);
+    }
+    if (firebaseHostingSite !== defulatFirebaseHostingSite) {
+      throw new Error('The Firebase Hosting Site specified by your angular.json or .firebaserc is in conflict');
     }
 
-    const staticBuildTarget = { name: options.buildTarget || `${context.target.project}:build:production` };
+    const staticBuildTarget = { name: options.browserTarget || options.buildTarget || `${context.target.project}:build:production` };
+
+    let prerenderBuildTarget: BuildTarget | undefined;
+    if (options.prerender) {
+      prerenderBuildTarget = {
+        name: options.prerenderTarget || `${context.target.project}:prerender:production`
+      };
+    }
 
     let serverBuildTarget: BuildTarget | undefined;
     if (options.ssr) {
       serverBuildTarget = {
-        name: options.universalBuildTarget || `${context.target.project}:server:production`
+        name: options.serverTarget || options.universalBuildTarget || `${context.target.project}:server:production`
       };
     }
 
     try {
       process.env.FIREBASE_DEPLOY_AGENT = 'angularfire';
       await deploy(
-        require('firebase-tools'),
+        (await getFirebaseTools()),
         context,
         staticBuildTarget,
         serverBuildTarget,
+        prerenderBuildTarget,
         firebaseProject,
         options,
         process.env.FIREBASE_TOKEN,

src/schematics/add/index.ts

@@ -1,9 +1,10 @@
 import { DeployBuilderOptions } from './actions';
 
-// TODO allow these to be configured
-const DEFAULT_NODE_VERSION = 10;
-const DEFAULT_FUNCTION_NAME = 'ssr';
+export const DEFAULT_NODE_VERSION = 14;
+export const DEFAULT_FUNCTION_NAME = 'ssr';
+
 const DEFAULT_FUNCTION_REGION = 'us-central1';
+
 const DEFAULT_RUNTIME_OPTIONS = {
   timeoutSeconds: 60,
   memory: '1GB'
@@ -13,39 +14,46 @@ export const defaultPackage = (
   dependencies: {[key: string]: string},
   devDependencies: {[key: string]: string},
   options: DeployBuilderOptions,
-) => `{
-  "name": "functions",
-  "description": "Angular Universal Application",
-  "scripts": {
-    "lint": "",
-    "serve": "firebase serve --only functions",
-    "shell": "firebase functions:shell",
-    "start": "npm run shell",
-    "deploy": "firebase deploy --only functions",
-    "logs": "firebase functions:log"
+  main?: string,
+) => ({
+  name: 'functions',
+  description: 'Angular Universal Application',
+  main: main ?? 'index.js',
+  scripts: {
+    start: main ? `node ${main}` : 'firebase functions:shell',
   },
-  "engines": {
-    "node": "${options.functionsNodeVersion || DEFAULT_NODE_VERSION}"
+  engines: {
+    node: (options.functionsNodeVersion || DEFAULT_NODE_VERSION).toString()
   },
-  "dependencies": ${JSON.stringify(dependencies, null, 4)},
-  "devDependencies": ${JSON.stringify(devDependencies, null, 4)},
-  "private": true
-}
-`;
+  dependencies,
+  devDependencies,
+  private: true
+});
 
 export const defaultFunction = (
   path: string,
   options: DeployBuilderOptions,
+  functionName: string|undefined,
 ) => `const functions = require('firebase-functions');
 
 // Increase readability in Cloud Logging
 require("firebase-functions/lib/logger/compat");
 
 const expressApp = require('./${path}/main').app();
 
-exports.${DEFAULT_FUNCTION_NAME} = functions
-  .region('${DEFAULT_FUNCTION_REGION}')
+exports.${functionName || DEFAULT_FUNCTION_NAME} = functions
+  .region('${options.region || DEFAULT_FUNCTION_REGION}')
   .runWith(${JSON.stringify(options.functionsRuntimeOptions || DEFAULT_RUNTIME_OPTIONS)})
   .https
   .onRequest(expressApp);
 `;
+
+export const dockerfile = (
+  options: DeployBuilderOptions,
+) => `FROM node:${options.functionsNodeVersion || DEFAULT_NODE_VERSION}-slim
+WORKDIR /usr/src/app
+COPY package*.json ./
+RUN npm install --only=production
+COPY . ./
+CMD [ "npm", "start" ]
+`;

src/schematics/add/schema.json

@@ -9,21 +9,103 @@
       "description": "Target to build.",
       "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
     },
+    "browserTarget": {
+      "type": "string",
+      "description": "Target to build.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
+    },
+    "prerenderTarget": {
+      "type": "string",
+      "description": "Target to build.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
+    },
+    "serverTarget": {
+      "type": "string",
+      "description": "Target to build.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
+    },
+    "universalBuildTarget": {
+      "type": "string",
+      "description": "Target to build.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
+    },
+    "ssr": {
+      "type": ["boolean", "string"],
+      "description": "Should we attempt to deploy the function to Cloud Functions (true or 'cloud-functions') / Cloud Run ('cloud-run') or just Hosting (false)"
+    },
+    "prerender": {
+      "type": "boolean",
+      "description": "Prerender before deploy?"
+    },
     "firebaseProject": {
       "type": "string",
       "description": "The Firebase project name or project alias to use when deploying"
     },
+    "firebaseHostingSite": {
+      "type": "string",
+      "description": "The Firebase Hosting site to deploy to"
+    },
+    "functionName": {
+      "type": "string",
+      "description": "The name of the Cloud Function or Cloud Run serviceId to deploy SSR to"
+    },
     "functionsNodeVersion": {
-      "type": "number",
-      "description": "Version of Node.js to run Cloud Functions on"
+      "type": ["number", "string"],
+      "description": "Version of Node.js to run Cloud Functions / Run on"
+    },
+    "region": {
+      "type": "string",
+      "description": "The region to deploy Cloud Functions or Cloud Run to"
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "Where to output the deploy artifacts"
     },
     "functionsRuntimeOptions": {
       "type": "object",
-      "description": "Runtime options for Cloud Functions"
+      "description": "Runtime options for Cloud Functions, if deploying to Cloud Functions"
     },
     "preview": {
       "type": "boolean",
       "description": "Do not deploy the application, just set up the Firebase Function in the project output directory. Can be used for testing the Firebase Function with `firebase serve`."
+    },
+    "cloudRunOptions": {
+      "type": "object",
+      "description": "Options passed to Cloud Run, if deploying to Cloud Run.",
+      "properties": {
+        "cpus": {
+          "type": "number",
+          "description": "Set a CPU limit in Kubernetes cpu units."
+        },
+        "maxConcurrency": {
+          "type": ["number", "string"],
+          "pattern": "^(\\d+|default)$",
+          "description": "Set the maximum number of concurrent requests allowed per container instance. If concurrency is unspecified, any number of concurrent requests are allowed. To unset this field, provide the special value default."
+        },
+        "maxInstances": {
+          "type": ["number", "string"],
+          "pattern": "^(\\d+|default)$",
+          "description": "The maximum number of container instances of the Service to run. Use 'default' to unset the limit and use the platform default."
+        },
+        "memory": {
+          "type": "string",
+          "pattern": "^\\d+(G|M)i$",
+          "description": "Set a memory limit. Ex: 1Gi, 512Mi."
+        },
+        "minInstances": {
+          "type": ["number", "string"],
+          "pattern": "^(\\d+|default)$",
+          "description": "The minimum number of container instances of the Service to run or 'default' to remove any minimum."
+        },
+        "timeout": {
+          "type": "number",
+          "description": "Set the maximum request execution time (timeout) in seconds."
+        },
+        "vpcConnector": {
+          "type": "string",
+          "description": "Set a VPC connector for this resource."
+        }
+      }
     }
   }
 }

src/schematics/collection.json

@@ -0,0 +1,49 @@
+import { FirebaseTools } from './interfaces';
+import { spawn, execSync } from 'child_process';
+import ora from 'ora';
+
+declare global {
+    var firebaseTools: FirebaseTools|undefined;
+}
+
+export const getFirebaseTools = () => globalThis.firebaseTools ?
+    Promise.resolve(globalThis.firebaseTools) :
+    new Promise<FirebaseTools>((resolve, reject) => {
+        try {
+            resolve(require('firebase-tools'));
+        } catch (e) {
+            try {
+                const root = execSync('npm root -g').toString().trim();
+                resolve(require(`${root}/firebase-tools`));
+            } catch (e) {
+                const spinner = ora({
+                    text: `Installing firebase-tools...`,
+                    // Workaround for https://github.com/sindresorhus/ora/issues/136.
+                    discardStdin: process.platform !== 'win32',
+                }).start();
+                spawn('npm', ['i', '-g', 'firebase-tools'], {
+                    stdio: 'pipe',
+                    shell: true,
+                }).on('close', (code) => {
+                    if (code === 0) {
+                        spinner.succeed('firebase-tools installed globally.');
+                        spinner.stop();
+                        const root = execSync('npm root -g').toString().trim();
+                        resolve(require(`${root}/firebase-tools`));
+                    } else {
+                        spinner.fail('Package install failed.');
+                        reject();
+                    }
+                });
+            }
+        }
+    }).then(firebaseTools => {
+        globalThis.firebaseTools = firebaseTools;
+        const version = firebaseTools.cli.version();
+        console.log(`Using firebase-tools version ${version}`);
+        if (parseInt(version, 10) !== 9) {
+            console.error('firebase-tools version 9 is required');
+            return Promise.reject();
+        }
+        return firebaseTools;
+    });

src/schematics/ng-add-common.ts renamed to src/schematics/common.ts

@@ -1,22 +1,108 @@
 import { RuntimeOptions } from 'firebase-functions';
 
-export interface Project {
+export const enum FEATURES {
+  Hosting,
+  Authentication,
+  Analytics,
+  Database,
+  Functions,
+  Messaging,
+  Performance,
+  Firestore,
+  Storage,
+  RemoteConfig,
+}
+
+export const featureOptions = [
+  { name: 'ng deploy -- hosting', value: FEATURES.Hosting },
+  { name: 'Authentication', value: FEATURES.Authentication },
+  { name: 'Firestore', value: FEATURES.Firestore },
+  { name: 'Realtime Database', value: FEATURES.Database },
+  { name: 'Analytics', value: FEATURES.Analytics },
+  { name: 'Cloud Functions (callable)', value: FEATURES.Functions },
+  { name: 'Cloud Messaging', value: FEATURES.Messaging },
+  { name: 'Performance Monitoring', value: FEATURES.Performance },
+  { name: 'Cloud Storage', value: FEATURES.Storage },
+  { name: 'Remote Config', value: FEATURES.RemoteConfig },
+];
+
+export const enum PROJECT_TYPE { Static, CloudFunctions, CloudRun }
+
+export interface NgAddOptions {
+  firebaseProject: string;
+  project?: string;
+}
+
+export interface NgAddNormalizedOptions {
+  project: string;
+  firebaseProject: FirebaseProject;
+  firebaseApp: FirebaseApp|undefined;
+  firebaseHostingSite: FirebaseHostingSite|undefined;
+  sdkConfig: Record<string, string>|undefined;
+  prerender: boolean;
+  browserTarget: string|undefined;
+  serverTarget: string|undefined;
+  prerenderTarget: string|undefined;
+}
+
+export interface DeployOptions {
+  project: string;
+}
+
+export interface FirebaseProject {
   projectId: string;
   projectNumber: string;
   displayName: string;
   name: string;
   resources: { [key: string]: string };
+  state: string;
 }
 
 export interface FirebaseDeployConfig {
   cwd: string;
   only?: string;
   token?: string;
+  [key: string]: any;
+}
+
+export interface FirebaseApp {
+  name: string;
+  displayName: string;
+  platform: string;
+  appId: string;
+  namespace: string;
+}
+
+export interface FirebaseHostingSite {
+  name: string;
+  defaultUrl: string;
+  type: string;
+  appId: string|undefined;
+}
+
+export interface FirebaseSDKConfig {
+  fileName: string;
+  fileContents: string;
+  sdkConfig: { [key: string]: string };
 }
 
 export interface FirebaseTools {
   projects: {
-    list(): Promise<Project[]>;
+    list(options: any): Promise<FirebaseProject[]>;
+    create(projectId: string|undefined, options: any): Promise<FirebaseProject>;
+  };
+
+  apps: {
+    list(platform: string|undefined, options: any): Promise<FirebaseApp[]>;
+    create(platform: string, displayName: string|undefined, options: any): Promise<FirebaseApp>;
+    sdkconfig(type: string, projectId: string, options: any): Promise<FirebaseSDKConfig>;
+  };
+
+  hosting: {
+    sites: {
+      list(options: any): Promise<{ sites: FirebaseHostingSite[]}>;
+      create(siteId: string, options: any): Promise<FirebaseHostingSite>;
+    }
   };
 
   logger: {
@@ -67,16 +153,36 @@ export interface FirebaseRcTarget {
 
 export interface FirebaseRc {
   targets?: Record<string, FirebaseRcTarget>;
+  projects?: Record<string, string>;
 }
 
 export interface DeployBuilderSchema {
   buildTarget?: string;
+  browserTarget?: string;
   firebaseProject?: string;
+  firebaseHostingSite?: string;
   preview?: boolean;
   universalBuildTarget?: string;
-  ssr?: boolean;
-  functionsNodeVersion?: number;
+  serverTarget?: string;
+  prerenderTarget?: string;
+  ssr?: boolean | string;
+  region?: string;
+  prerender?: boolean;
+  functionName?: string;
+  functionsNodeVersion?: number|string;
   functionsRuntimeOptions?: RuntimeOptions;
+  cloudRunOptions?: Partial<CloudRunOptions>;
+  outputPath?: string;
+}
+
+export interface CloudRunOptions {
+  cpus: number;
+  maxConcurrency: number | 'default';
+  maxInstances: number | 'default';
+  memory: string;
+  minInstances: number | 'default';
+  timeout: number;
+  vpcConnector: string;
 }
 
 export interface BuildTarget {
@@ -88,11 +194,20 @@ export interface FSHost {
   moveSync(src: string, dest: string): void;
   writeFileSync(src: string, data: string): void;
   renameSync(src: string, dest: string): void;
+  copySync(src: string, dest: string): void;
+  removeSync(src: string): void;
 }
 
 export interface WorkspaceProject {
+  root: string;
+  sourceRoot?: string;
   projectType?: string;
-  architect?: Record<string, { builder: string; options?: Record<string, any> }>;
+  architect?: Record<string, {
+    builder: string;
+    options?: Record<string, any>,
+    configurations?: Record<string, Record<string, any>>,
+    defaultConfiguration?: string,
+  }>;
 }
 
 export interface Workspace {

src/schematics/deploy/actions.jasmine.ts

@@ -4,11 +4,11 @@
         "migration-v7": {
             "version": "7.0.0",
             "description": "Update @angular/fire to v7",
-            "factory": "./public_api#ngUpdateV7"
+            "factory": "./update/v7#ngUpdate"
         },
         "ng-post-upgate": {
             "description": "Print out results after ng-update",
-            "factory": "./public_api#ngPostUpdate",
+            "factory": "./update#ngPostUpdate",
             "private": true
         }
     }

src/schematics/deploy/actions.ts

@@ -0,0 +1,150 @@
+import { SchematicContext, SchematicsException, Tree } from '@angular-devkit/schematics';
+import { getWorkspace, getProject, getFirebaseProjectNameFromHost, addEnvironmentEntry, addToNgModule, addIgnoreFiles } from '../utils';
+import { projectTypePrompt, appPrompt, sitePrompt, projectPrompt, featuresPrompt } from './prompts';
+import { setupUniversalDeployment } from './ssr';
+import { setupStaticDeployment } from './static';
+import {
+  FirebaseApp, FirebaseHostingSite, FirebaseProject, DeployOptions, NgAddNormalizedOptions,
+  FEATURES, PROJECT_TYPE
+} from '../interfaces';
+import { getFirebaseTools } from '../firebaseTools';
+
+export const setupProject =
+  async (tree: Tree, context: SchematicContext, features: FEATURES[], config: DeployOptions & {
+    firebaseProject: FirebaseProject,
+    firebaseApp?: FirebaseApp,
+    firebaseHostingSite?: FirebaseHostingSite,
+    sdkConfig?: Record<string, string>,
+    projectType: PROJECT_TYPE,
+    prerender: boolean,
+    nodeVersion?: string,
+    browserTarget?: string,
+    serverTarget?: string,
+    prerenderTarget?: string,
+    project: string,
+  }) => {
+    const { path: workspacePath, workspace } = getWorkspace(tree);
+
+    const { project, projectName } = getProject(config, tree);
+
+    const sourcePath = [project.root, project.sourceRoot].filter(it => !!it).join('/');
+
+    addIgnoreFiles(tree);
+
+    const featuresToImport = features.filter(it => it !== FEATURES.Hosting);
+    if (featuresToImport.length > 0) {
+      addToNgModule(tree, { features: featuresToImport, sourcePath });
+    }
+
+    if (config.sdkConfig) {
+      const source = `
+  firebase: {
+${Object.entries(config.sdkConfig).reduce(
+    (c, [k, v]) => c.concat(`    ${k}: '${v}'`),
+    [] as string[]
+).join(',\n')},
+  }`;
+
+      const environmentPath = `${sourcePath}/environments/environment.ts`;
+      addEnvironmentEntry(tree, `/${environmentPath}`, source);
+
+      // Iterate over the replacements for the environment file and add the config
+      Object.values(project.architect || {}).forEach(builder => {
+        Object.values(builder.configurations || {}).forEach(configuration => {
+          (configuration.fileReplacements || []).forEach((replacement: any) => {
+            if (replacement.replace === environmentPath) {
+              addEnvironmentEntry(tree, `/${replacement.with}`, source);
+            }
+          });
+        });
+      });
+    }
+
+    const options: NgAddNormalizedOptions = {
+      project: projectName,
+      firebaseProject: config.firebaseProject,
+      firebaseApp: config.firebaseApp,
+      firebaseHostingSite: config.firebaseHostingSite,
+      sdkConfig: config.sdkConfig,
+      prerender: config.prerender,
+      browserTarget: config.browserTarget,
+      serverTarget: config.serverTarget,
+      prerenderTarget: config.prerenderTarget,
+    };
+
+    if (features.includes(FEATURES.Hosting)) {
+      // TODO dry up by always doing the static work
+      switch (config.projectType) {
+        case PROJECT_TYPE.CloudFunctions:
+        case PROJECT_TYPE.CloudRun:
+          return setupUniversalDeployment({
+            workspace,
+            workspacePath,
+            options,
+            tree,
+            context,
+            project,
+            projectType: config.projectType,
+            // tslint:disable-next-line:no-non-null-assertion
+            nodeVersion: config.nodeVersion!,
+          });
+        case PROJECT_TYPE.Static:
+          return setupStaticDeployment({
+            workspace,
+            workspacePath,
+            options,
+            tree,
+            context,
+            project
+          });
+        default: throw(new SchematicsException(`Unimplemented PROJECT_TYPE ${config.projectType}`));
+      }
+    }
+};
+
+export const ngAddSetupProject = (
+  options: DeployOptions
+) => async (host: Tree, context: SchematicContext) => {
+  const features = await featuresPrompt();
+
+  if (features.length > 0) {
+
+    const firebaseTools = await getFirebaseTools();
+
+    await firebaseTools.login();
+
+    const { project: ngProject, projectName: ngProjectName } = getProject(options, host);
+
+    const [ defaultProjectName ] = getFirebaseProjectNameFromHost(host, ngProjectName);
+
+    const firebaseProject = await projectPrompt(defaultProjectName);
+
+    let hosting = { projectType: PROJECT_TYPE.Static, prerender: false };
+    let firebaseHostingSite: FirebaseHostingSite|undefined;
+
+    if (features.includes(FEATURES.Hosting)) {
+      // TODO read existing settings from angular.json, if available
+      const results = await projectTypePrompt(ngProject, ngProjectName);
+      hosting = { ...hosting, ...results };
+      firebaseHostingSite = await sitePrompt(firebaseProject);
+    }
+
+    let firebaseApp: FirebaseApp|undefined;
+    let sdkConfig: Record<string, string>|undefined;
+
+    if (features.find(it => it !== FEATURES.Hosting)) {
+
+      const defaultAppId = firebaseHostingSite?.appId;
+      firebaseApp = await appPrompt(firebaseProject, defaultAppId);
+
+      const result = await firebaseTools.apps.sdkconfig('web', firebaseApp.appId, { nonInteractive: true });
+      sdkConfig = result.sdkConfig;
+
+    }
+
+    await setupProject(host, context, features, {
+      ...options, ...hosting, firebaseProject, firebaseApp, firebaseHostingSite, sdkConfig,
+    });
+
+  }
+};

src/schematics/deploy/builder.ts

@@ -0,0 +1,273 @@
+import * as fuzzy from 'fuzzy';
+import * as inquirer from 'inquirer';
+import { featureOptions, FEATURES, FirebaseApp, FirebaseHostingSite, FirebaseProject, PROJECT_TYPE, WorkspaceProject } from '../interfaces';
+import { hasPrerenderOption, isUniversalApp, shortAppId, shortSiteName } from '../utils';
+import { getFirebaseTools } from '../firebaseTools';
+
+inquirer.registerPrompt('autocomplete', require('inquirer-autocomplete-prompt'));
+
+const NEW_OPTION = '~~angularfire-new~~';
+const DEFAULT_SITE_TYPE = 'DEFAULT_SITE';
+
+// `fuzzy` passes either the original list of projects or an internal object
+// which contains the project as a property.
+const isProject = (elem: FirebaseProject | fuzzy.FilterResult<FirebaseProject>): elem is FirebaseProject => {
+    return (elem as { original: FirebaseProject }).original === undefined;
+};
+
+const isApp = (elem: FirebaseApp | fuzzy.FilterResult<FirebaseApp>): elem is FirebaseApp => {
+    return (elem as { original: FirebaseApp }).original === undefined;
+};
+
+const isSite = (elem: FirebaseHostingSite | fuzzy.FilterResult<FirebaseHostingSite>): elem is FirebaseHostingSite => {
+    return (elem as { original: FirebaseHostingSite }).original === undefined;
+};
+
+export const searchProjects = (promise: Promise<FirebaseProject[]>) =>
+    (_: any, input: string) => promise.then(projects => {
+        projects.unshift({
+            projectId: NEW_OPTION,
+            displayName: '[CREATE NEW PROJECT]'
+        } as any);
+        return fuzzy.filter(input, projects, {
+            extract(el) {
+                return `${el.projectId} ${el.displayName}`;
+            }
+        }).map((result) => {
+            let original: FirebaseProject;
+            if (isProject(result)) {
+                original = result;
+            } else {
+                original = result.original;
+            }
+            return {
+                name: original.displayName,
+                title: original.displayName,
+                value: original.projectId
+            };
+        });
+    });
+
+export const searchApps = (promise: Promise<FirebaseApp[]>) =>
+  (_: any, input: string) => promise.then(apps => {
+    apps.unshift({
+      appId: NEW_OPTION,
+      displayName: '[CREATE NEW APP]',
+    } as any);
+    return fuzzy.filter(input, apps, {
+      extract(el: FirebaseApp) {
+        return el.displayName;
+      }
+    }).map((result) => {
+      let original: FirebaseApp;
+      if (isApp(result)) {
+        original = result;
+      } else {
+        original = result.original;
+      }
+      return {
+        name: original.displayName,
+        title: original.displayName,
+        value: shortAppId(original),
+      };
+    });
+  });
+
+export const searchSites = (promise: Promise<FirebaseHostingSite[]>) =>
+  (_: any, input: string) => promise.then(sites => {
+    sites.unshift({
+      name: NEW_OPTION,
+      defaultUrl: '[CREATE NEW SITE]',
+    } as any);
+    return fuzzy.filter(input, sites, {
+      extract(el) {
+        return el.defaultUrl;
+      }
+    }).map((result) => {
+      let original: FirebaseHostingSite;
+      if (isSite(result)) {
+        original = result;
+      } else {
+        original = result.original;
+      }
+      return {
+        name: original.defaultUrl,
+        title: original.defaultUrl,
+        value: shortSiteName(original),
+      };
+    });
+  });
+
+
+type Prompt = <K extends string, U= unknown>(questions: { name: K, source: (...args) =>
+  Promise<{ value: U }[]>, default?: U | ((o: U[]) => U | Promise<U>), [key: string]: any }) =>
+    Promise<{[T in K]: U }>;
+
+const autocomplete: Prompt = (questions) => inquirer.prompt(questions);
+
+
+export const featuresPrompt = async (): Promise<FEATURES[]> => {
+  const { features } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'features',
+    choices: featureOptions,
+    message: 'What features would you like to setup?',
+    default: [FEATURES.Hosting],
+  });
+  return features;
+};
+
+export const projectPrompt = async (defaultProject?: string) => {
+  const firebaseTools = await getFirebaseTools();
+  const projects = firebaseTools.projects.list({});
+  const { projectId } = await autocomplete({
+    type: 'autocomplete',
+    name: 'projectId',
+    source: searchProjects(projects),
+    message: 'Please select a project:',
+    default: defaultProject,
+  });
+  if (projectId === NEW_OPTION) {
+    const { projectId } = await inquirer.prompt({
+      type: 'input',
+      name: 'projectId',
+      message: `Please specify a unique project id (cannot be modified afterward) [6-30 characters]:`,
+    });
+    const { displayName } = await inquirer.prompt({
+      type: 'input',
+      name: 'displayName',
+      message: 'What would you like to call your project?',
+      default: projectId,
+    });
+    return await firebaseTools.projects.create(projectId, { displayName, nonInteractive: true });
+  }
+  // tslint:disable-next-line:no-non-null-assertion
+  return (await projects).find(it => it.projectId === projectId)!;
+};
+
+export const appPrompt = async ({ projectId: project }: FirebaseProject, defaultAppId: string|undefined) => {
+  const firebaseTools = await getFirebaseTools();
+  const apps = firebaseTools.apps.list('web', { project });
+  const { appId } = await autocomplete({
+    type: 'autocomplete',
+    name: 'appId',
+    source: searchApps(apps),
+    message: 'Please select an app:',
+    default: defaultAppId,
+  });
+  if (appId === NEW_OPTION) {
+    const { displayName } = await inquirer.prompt({
+      type: 'input',
+      name: 'displayName',
+      message: 'What would you like to call your app?',
+    });
+    return await firebaseTools.apps.create('web', displayName, { nonInteractive: true, project });
+  }
+  // tslint:disable-next-line:no-non-null-assertion
+  return (await apps).find(it => shortAppId(it) === appId)!;
+};
+
+export const sitePrompt = async ({ projectId: project }: FirebaseProject) => {
+  const firebaseTools = await getFirebaseTools();
+  if (!firebaseTools.hosting.sites) {
+    return undefined;
+  }
+  const sites = firebaseTools.hosting.sites.list({ project }).then(it => {
+    if (it.sites.length === 0) {
+      // newly created projects don't return their default site, stub one
+      return [{
+        name: project,
+        defaultUrl: `https://${project}.web.app`,
+        type: DEFAULT_SITE_TYPE,
+        appId: undefined,
+      } as FirebaseHostingSite];
+    } else {
+      return it.sites;
+    }
+  });
+  const { siteName } = await autocomplete({
+    type: 'autocomplete',
+    name: 'siteName',
+    source: searchSites(sites),
+    message: 'Please select a hosting site:',
+    default: _ => sites.then(it => shortSiteName(it.find(it => it.type === DEFAULT_SITE_TYPE))),
+  });
+  if (siteName === NEW_OPTION) {
+    const { subdomain } = await inquirer.prompt({
+      type: 'input',
+      name: 'subdomain',
+      message: 'Please provide an unique, URL-friendly id for the site (<id>.web.app):',
+    });
+    return await firebaseTools.hosting.sites.create(subdomain, { nonInteractive: true, project });
+  }
+  // tslint:disable-next-line:no-non-null-assertion
+  return (await sites).find(it => shortSiteName(it) === siteName)!;
+};
+
+export const prerenderPrompt = (project: WorkspaceProject, prerender: boolean): Promise<{ projectType: PROJECT_TYPE }> => {
+  if (isUniversalApp(project)) {
+    return inquirer.prompt({
+      type: 'prompt',
+      name: 'prerender',
+      message: 'We detected an Angular Universal project. How would you like to render server-side content?',
+      default: true
+    });
+  }
+  return Promise.resolve({ projectType: PROJECT_TYPE.Static });
+};
+
+export const projectTypePrompt = async (project: WorkspaceProject, name: string) => {
+  let prerender = false;
+  let nodeVersion: string|undefined;
+  let serverTarget: string|undefined;
+  let browserTarget = `${name}:build:${project.architect?.build?.defaultConfiguration || 'production'}`;
+  let prerenderTarget: string|undefined;
+  if (isUniversalApp(project)) {
+    serverTarget = `${name}:server:${project.architect?.server?.defaultConfiguration || 'production'}`;
+    browserTarget = `${name}:build:${project.architect?.build?.defaultConfiguration || 'production'}`;
+    if (hasPrerenderOption(project)) {
+      prerenderTarget = `${name}:prerender:${project.architect?.prerender?.defaultConfiguration || 'production'}`;
+      const { shouldPrerender } = await inquirer.prompt({
+        type: 'confirm',
+        name: 'shouldPrerender',
+        message: 'Should we prerender before deployment?',
+        default: true
+      });
+      prerender = shouldPrerender;
+    }
+    const choices = [
+      { name: prerender ? 'Pre-render only' : 'Don\'t render universal content', value: PROJECT_TYPE.Static },
+      { name: 'Cloud Functions', value: PROJECT_TYPE.CloudFunctions },
+      { name: 'Cloud Run', value: PROJECT_TYPE.CloudRun },
+    ];
+    const { projectType } = await inquirer.prompt({
+      type: 'list',
+      name: 'projectType',
+      choices,
+      message: 'How would you like to render server-side content?',
+      default: PROJECT_TYPE.CloudFunctions,
+    });
+    if (projectType === PROJECT_TYPE.CloudFunctions) {
+      const { newNodeVersion } = await inquirer.prompt({
+        type: 'list',
+        name: 'newNodeVersion',
+        choices: ['12', '14', '16'],
+        message: 'What version of Node.js would you like to use?',
+        default: parseInt(process.versions.node, 10).toString(),
+      });
+      nodeVersion = newNodeVersion;
+    } else if (projectType === PROJECT_TYPE.CloudRun) {
+      const fetch = require('node-fetch');
+      const { newNodeVersion } = await inquirer.prompt({
+        type: 'input',
+        name: 'newNodeVersion',
+        message: 'What version of Node.js would you like to use?',
+        validate: it => fetch(`https://hub.docker.com/v2/repositories/library/node/tags/${it}-slim`).then(it => it.status === 200 || `Can't find node:${it}-slim docker image.`),
+        default: parseFloat(process.versions.node).toString(),
+      });
+      nodeVersion = newNodeVersion;
+    }
+    return { prerender, projectType, nodeVersion, browserTarget, serverTarget, prerenderTarget };
+  }
+  return { projectType: PROJECT_TYPE.Static, prerender, nodeVersion, browserTarget, serverTarget, prerenderTarget };
+};

src/schematics/deploy/functions-templates.ts

@@ -0,0 +1,16 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "angular-fire-ng-add",
+    "title": "AngularFire ng-add",
+    "type": "object",
+    "properties": {
+      "project": {
+        "type": "string",
+        "description": "The name of the project.",
+        "$default": {
+          "$source": "projectName"
+        }
+      }
+    },
+    "required": []
+  }

src/schematics/deploy/schema.json

@@ -0,0 +1,150 @@
+import { SchematicsException, Tree, SchematicContext } from '@angular-devkit/schematics';
+import {
+  addDependencies,
+  generateFirebaseRc,
+  overwriteIfExists,
+  safeReadJSON,
+  stringifyFormatted
+} from '../common';
+import { FirebaseJSON, Workspace, WorkspaceProject, NgAddNormalizedOptions, PROJECT_TYPE } from '../interfaces';
+import { firebaseFunctionsDependencies } from '../versions.json';
+import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
+import { shortSiteName } from '../utils';
+
+function generateHostingConfig(project: string, dist: string, functionName: string, projectType: PROJECT_TYPE) {
+  return {
+    target: project,
+    public: dist,
+    ignore: ['**/.*'],
+    headers: [{
+      // TODO check the hash style in the angular.json
+      source: '*.[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f].+(css|js)',
+      headers: [{
+        key: 'Cache-Control',
+        value: 'public,max-age=31536000,immutable'
+      }]
+    }],
+    rewrites: [
+      projectType === PROJECT_TYPE.CloudFunctions ? {
+        source: '**',
+        function: functionName
+      } : {
+        source: '**',
+        run: { serviceId: functionName }
+      }
+    ]
+  };
+}
+
+function generateFunctionsConfig(source: string) {
+  return {
+    source
+  };
+}
+
+export function generateFirebaseJson(
+  tree: Tree,
+  path: string,
+  project: string,
+  dist: string,
+  functionsOutput: string,
+  functionName: string,
+  projectType: PROJECT_TYPE,
+) {
+  const firebaseJson: FirebaseJSON = tree.exists(path)
+    ? safeReadJSON(path, tree)
+    : {};
+
+  const newConfig = generateHostingConfig(project, dist, functionName, projectType);
+  if (firebaseJson.hosting === undefined) {
+    firebaseJson.hosting = [newConfig];
+  } else if (Array.isArray(firebaseJson.hosting)) {
+    const existingConfigIndex = firebaseJson.hosting.findIndex(config => config.target === newConfig.target);
+    if (existingConfigIndex > -1) {
+      firebaseJson.hosting.splice(existingConfigIndex, 1, newConfig);
+    } else {
+      firebaseJson.hosting.push(newConfig);
+    }
+  } else {
+    firebaseJson.hosting = [firebaseJson.hosting, newConfig];
+  }
+
+  if (projectType === PROJECT_TYPE.CloudFunctions) {
+    firebaseJson.functions = generateFunctionsConfig(functionsOutput);
+  }
+
+  overwriteIfExists(tree, path, stringifyFormatted(firebaseJson));
+}
+
+export const setupUniversalDeployment = (config: {
+  project: WorkspaceProject;
+  options: NgAddNormalizedOptions;
+  workspacePath: string;
+  workspace: Workspace;
+  tree: Tree;
+  context: SchematicContext;
+  projectType: PROJECT_TYPE;
+  nodeVersion: string;
+}) => {
+  const { tree, workspacePath, workspace, options } = config;
+  const project = workspace.projects[options.project];
+
+  if (!project.architect?.build?.options?.outputPath) {
+    throw new SchematicsException(
+      `Cannot read the output path (architect.build.options.outputPath) of the Angular project "${options.project}" in angular.json`
+    );
+  }
+
+  if (!project.architect?.server?.options?.outputPath) {
+    throw new SchematicsException(
+      `Cannot read the output path (architect.server.options.outputPath) of the Angular project "${options.project}" in angular.json`
+    );
+  }
+
+  const ssrDirectory = config.projectType === PROJECT_TYPE.CloudFunctions ? 'functions' : 'run';
+  const staticOutput = project.architect.build.options.outputPath;
+  const functionsOutput = `dist/${options.project}/${ssrDirectory}`;
+
+  // TODO clean this up a bit
+  const functionName = config.projectType === PROJECT_TYPE.CloudRun ?
+    `ssr-${options.project.replace('_', '-')}` :
+    `ssr_${options.project}`;
+
+  project.architect.deploy = {
+    builder: '@angular/fire:deploy',
+    options: {
+      ssr: config.projectType === PROJECT_TYPE.CloudRun ? 'cloud-run' : 'cloud-functions',
+      prerender: options.prerender,
+      firebaseProject: options.firebaseProject.projectId,
+      firebaseHostingSite: shortSiteName(options.firebaseHostingSite),
+      functionName,
+      functionsNodeVersion: config.nodeVersion,
+      region: 'us-central1',
+      browserTarget: options.browserTarget,
+      ...(options.serverTarget ? {serverTarget: options.serverTarget} : {}),
+      ...(options.prerenderTarget ? {prerenderTarget: options.prerenderTarget} : {}),
+      outputPath: functionsOutput,
+    }
+  };
+
+  tree.overwrite(workspacePath, JSON.stringify(workspace, null, 2));
+
+  addDependencies(
+    tree,
+    firebaseFunctionsDependencies,
+    config.context
+  );
+
+  config.context.addTask(new NodePackageInstallTask());
+
+  generateFirebaseJson(tree, 'firebase.json', options.project, staticOutput, functionsOutput, functionName, config.projectType);
+  generateFirebaseRc(
+    tree,
+    '.firebaserc',
+    options.firebaseProject.projectId,
+    options.firebaseHostingSite,
+    options.project
+  );
+
+  return tree;
+};

src/schematics/firebaseTools.ts

@@ -1,17 +1,13 @@
 import { SchematicsException, Tree, SchematicContext } from '@angular-devkit/schematics';
 import {
-  addDependencies,
-  DeployOptions,
   generateFirebaseRc,
-  NgAddNormalizedOptions,
   overwriteIfExists,
   safeReadJSON,
   stringifyFormatted
-} from './ng-add-common';
-import { FirebaseJSON, Workspace, WorkspaceProject } from './interfaces';
+} from '../common';
+import { NgAddNormalizedOptions, FirebaseJSON, Workspace, WorkspaceProject } from '../interfaces';
 
-import { default as defaultDependencies } from './versions.json';
-import { NodePackageInstallTask, RunSchematicTask } from '@angular-devkit/schematics/tasks';
+import { shortSiteName } from '../utils';
 
 function emptyFirebaseJson() {
   return {
@@ -50,58 +46,35 @@ export function generateFirebaseJson(
     ? safeReadJSON(path, tree)
     : emptyFirebaseJson();
 
-  /* TODO do we want to prompt for override?
-  if (
-    firebaseJson.hosting &&
-    ((Array.isArray(firebaseJson.hosting) &&
-      firebaseJson.hosting.find(config => config.target === project)) ||
-      (firebaseJson.hosting as FirebaseHostingConfig).target === project)
-  ) {
-    throw new SchematicsException(
-      `Target ${project} already exists in firebase.json`
-    );
-  }*/
-
   const newConfig = generateHostingConfig(project, dist);
   if (firebaseJson.hosting === undefined) {
     firebaseJson.hosting = newConfig;
   } else if (Array.isArray(firebaseJson.hosting)) {
-    firebaseJson.hosting.push(newConfig);
+    const targetIndex = firebaseJson.hosting.findIndex(it => it.target === newConfig.target);
+    if (targetIndex > -1) {
+      firebaseJson.hosting[targetIndex] = newConfig;
+    } else {
+      firebaseJson.hosting.push(newConfig);
+    }
   } else {
     firebaseJson.hosting = [firebaseJson.hosting, newConfig];
   }
 
   overwriteIfExists(tree, path, stringifyFormatted(firebaseJson));
 }
 
-export const addFirebaseHostingDependencies = (options: DeployOptions) => (tree: Tree, context: SchematicContext) => {
-  addDependencies(
-    tree,
-    defaultDependencies,
-    context
-  );
-  context.addTask(new RunSchematicTask('ng-add-setup-project', options), [
-    context.addTask(new NodePackageInstallTask())
-  ]);
-  return tree;
-};
-
 export const setupStaticDeployment = (config: {
   project: WorkspaceProject;
   options: NgAddNormalizedOptions;
   workspacePath: string;
   workspace: Workspace;
   tree: Tree;
+  context: SchematicContext;
 }) => {
   const { tree, workspacePath, workspace, options } = config;
   const project = workspace.projects[options.project];
 
-  if (
-    !project.architect ||
-    !project.architect.build ||
-    !project.architect.build.options ||
-    !project.architect.build.options.outputPath
-  ) {
+  if (!project.architect?.build?.options?.outputPath) {
     throw new SchematicsException(
       `Cannot read the output path (architect.build.options.outputPath) of the Angular project "${options.project}" in angular.json`
     );
@@ -111,15 +84,24 @@ export const setupStaticDeployment = (config: {
 
   project.architect.deploy = {
     builder: '@angular/fire:deploy',
-    options: {}
+    options: {
+      prerender: options.prerender,
+      ssr: false,
+      browserTarget: options.browserTarget,
+      firebaseProject: options.firebaseProject.projectId,
+      firebaseHostingSite: shortSiteName(options.firebaseHostingSite),
+      ...(options.serverTarget ? {serverTarget: options.serverTarget} : {}),
+      ...(options.prerenderTarget ? {prerenderTarget: options.prerenderTarget} : {}),
+    }
   };
 
   tree.overwrite(workspacePath, JSON.stringify(workspace, null, 2));
   generateFirebaseJson(tree, 'firebase.json', options.project, outputPath);
   generateFirebaseRc(
     tree,
     '.firebaserc',
-    options.firebaseProject,
+    options.firebaseProject.projectId,
+    options.firebaseHostingSite,
     options.project
   );
 

src/schematics/interfaces.ts

@@ -7,6 +7,7 @@
         "removeComments": true,
         "strictNullChecks": true,
         "resolveJsonModule": true,
+        "esModuleInterop": true,
         "lib": [
             "es2015",
             "dom",
@@ -20,5 +21,12 @@
         "module": "commonjs",
         "outDir": "../../dist/packages-dist/schematics"
     },
-    "files": ["public_api.ts"]
+    "files": [
+        "update/index.ts",
+        "deploy/actions.ts",
+        "deploy/builder.ts",
+        "add/index.ts",
+        "setup/index.ts",
+        "update/v7/index.ts",
+    ]
 }

src/schematics/migration.json

@@ -1,7 +1,7 @@
 import { Rule, SchematicContext, SchematicsException, Tree } from '@angular-devkit/schematics';
 import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
-import { overwriteIfExists, safeReadJSON, stringifyFormatted } from '../../ng-add-common';
-import { default as defaultDependencies, firebaseFunctions } from '../../versions.json';
+import { overwriteIfExists, safeReadJSON, stringifyFormatted } from '../../common';
+import { peerDependencies, firebaseFunctionsDependencies } from '../../versions.json';
 import { join } from 'path';
 
 const IMPORT_REGEX = /(?<key>import|export)\s+(?:(?<alias>[\w,{}\s\*]+)\s+from)?\s*(?:(?<quote>["'])?(?<ref>[@\w\s\\\/.-]+)\3?)\s*(?<term>[;\n])/g;
@@ -23,18 +23,16 @@ export const ngUpdate = (): Rule => (
         throw new SchematicsException('Could not locate package.json');
     }
 
-    Object.keys(defaultDependencies).forEach(depName => {
-        const dep = defaultDependencies[depName];
-        if (dep.dev) {
-            packageJson.devDependencies[depName] = dep.version;
-        } else {
-            packageJson.dependencies[depName] = dep.version;
+    Object.keys(peerDependencies).forEach(depName => {
+        const dep = peerDependencies[depName];
+        if (dep) {
+            packageJson[dep.dev ? 'devDependencies' : 'dependencies'][depName] = dep.version;
         }
     });
 
     // TODO test if it's a SSR project in the JSON
-    Object.keys(firebaseFunctions).forEach(depName => {
-        const dep = firebaseFunctions[depName];
+    Object.keys(firebaseFunctionsDependencies).forEach(depName => {
+        const dep = firebaseFunctionsDependencies[depName];
         if (dep.dev && packageJson.devDependencies[depName]) {
             packageJson.devDependencies[depName] = dep.version;
         } else if (packageJson.dependencies[depName]) {

src/schematics/ng-add-ssr.ts

@@ -1,64 +1,38 @@
 import { readFileSync } from 'fs';
-import { FirebaseRc, Project, Workspace, WorkspaceProject } from './interfaces';
+import { FirebaseRc, Workspace, WorkspaceProject, FirebaseApp, FirebaseHostingSite, DeployOptions, FEATURES } from './interfaces';
 import { join } from 'path';
-import { isUniversalApp } from './ng-add-ssr';
 import { SchematicsException, Tree } from '@angular-devkit/schematics';
-import { DeployOptions } from './ng-add-common';
+import ts from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
+import { findNode, addImportToModule, insertImport } from '@schematics/angular/utility/ast-utils';
+import { InsertChange, ReplaceChange, applyToUpdateRecorder, Change } from '@schematics/angular/utility/change';
+import { findModuleFromOptions, buildRelativePath } from '@schematics/angular/utility/find-module';
+import { overwriteIfExists } from './common';
 
-export async function listProjects() {
-  const firebase = require('firebase-tools');
-  await firebase.login();
-  return firebase.projects.list();
-}
+// We consider a project to be a universal project if it has a `server` architect
+// target. If it does, it knows how to build the application's server.
+export const isUniversalApp = (
+  project: WorkspaceProject
+) => project.architect?.server;
 
-// `fuzzy` passes either the original list of projects or an internal object
-// which contains the project as a property.
-const isProject = (elem: Project | { original: Project }): elem is Project => {
-  return (elem as { original: Project }).original === undefined;
-};
+export const hasPrerenderOption = (
+  project: WorkspaceProject
+) => project.architect?.prerender;
 
-const searchProjects = (projects: Project[]) => {
-  return (_: any, input: string) => {
-    return Promise.resolve(
-      require('fuzzy')
-        .filter(input, projects, {
-          extract(el: Project) {
-            return `${el.projectId} ${el.displayName}`;
-          }
-        })
-        .map((result: Project | { original: Project }) => {
-          let original: Project;
-          if (isProject(result)) {
-            original = result;
-          } else {
-            original = result.original;
-          }
-          return {
-            name: `${original.displayName} (${original.projectId})`,
-            title: original.displayName,
-            value: original.projectId
-          };
-        })
-    );
-  };
-};
+export const shortAppId = (app?: FirebaseApp) => app?.appId && app.appId.split('/').pop();
 
+export const shortSiteName = (site?: FirebaseHostingSite) => site?.name && site.name.split('/').pop();
 
 export function getWorkspace(
   host: Tree
 ): { path: string; workspace: Workspace } {
-  const possibleFiles = ['/angular.json', '/.angular.json'];
-  const path = possibleFiles.filter(p => host.exists(p))[0];
+  const path = '/angular.json';
 
-  const configBuffer = host.read(path);
-  if (configBuffer === null) {
+  const configBuffer = path && host.read(path);
+  if (!configBuffer) {
     throw new SchematicsException(`Could not find angular.json`);
   }
 
-  // We can not depend on this library to have be included in older (or newer) Angular versions.
-  // Require here, since the schematic will add it to the package.json and install it before
-  // continuing.
-  const { parse }: typeof import('jsonc-parser') = require('jsonc-parser');
+  const { parse } = require('jsonc-parser');
 
   const workspace = parse(configBuffer.toString()) as Workspace|undefined;
   if (!workspace) {
@@ -97,41 +71,251 @@ export const getProject = (options: DeployOptions, host: Tree) => {
   return {project, projectName};
 };
 
-export const projectPrompt = (projects: Project[]) => {
-  const inquirer = require('inquirer');
-  inquirer.registerPrompt(
-    'autocomplete',
-    require('inquirer-autocomplete-prompt')
+export function getFirebaseProjectNameFromHost(
+  host: Tree,
+  target: string
+): [string|undefined, string|undefined] {
+  const buffer = host.read('/.firebaserc');
+  if (!buffer) {
+    return [undefined, undefined];
+  }
+  const rc: FirebaseRc = JSON.parse(buffer.toString());
+  return projectFromRc(rc, target);
+}
+
+export function getFirebaseProjectNameFromFs(
+  root: string,
+  target: string
+): [string|undefined, string|undefined] {
+  const path = join(root, '.firebaserc');
+  try {
+    const buffer = readFileSync(path);
+    const rc: FirebaseRc = JSON.parse(buffer.toString());
+    return projectFromRc(rc, target);
+  } catch (e) {
+    return [undefined, undefined];
+  }
+}
+
+const projectFromRc = (rc: FirebaseRc, target: string): [string|undefined, string|undefined] => {
+  const defaultProject = rc.projects?.default;
+  const project = Object.keys(rc.targets || {}).find(
+    project => !!rc.targets?.[project]?.hosting?.[target]
   );
-  return inquirer.prompt({
-    type: 'autocomplete',
-    name: 'firebaseProject',
-    source: searchProjects(projects),
-    message: 'Please select a project:'
-  });
+  const site = project && rc.targets?.[project]?.hosting?.[target]?.[0];
+  return [project || defaultProject, site];
 };
 
-export const projectTypePrompt = (project: WorkspaceProject): Promise<{ universalProject: boolean }> => {
-  if (isUniversalApp(project)) {
-    return require('inquirer').prompt({
-      type: 'confirm',
-      name: 'universalProject',
-      message: 'We detected an Angular Universal project. Do you want to deploy as a Firebase Function?'
-    });
+/**
+ * Adds a package to the package.json
+ */
+export function addEnvironmentEntry(
+  host: Tree,
+  filePath: string,
+  data: string,
+): Tree {
+  if (!host.exists(filePath)) {
+    throw new Error(`File ${filePath} does not exist`);
   }
-  return Promise.resolve({ universalProject: false });
-};
 
-export function getFirebaseProjectName(
-  workspaceRoot: string,
-  target: string
-): string | undefined {
-  const rc: FirebaseRc = JSON.parse(
-    readFileSync(join(workspaceRoot, '.firebaserc'), 'UTF-8')
+  const buffer = host.read(filePath);
+  if (!buffer) {
+    throw new SchematicsException(`Cannot read ${filePath}`);
+  }
+  const sourceFile = ts.createSourceFile(filePath, buffer.toString('utf-8'), ts.ScriptTarget.Latest, true);
+
+  const envIdentifier = findNode(sourceFile as any, ts.SyntaxKind.Identifier, 'environment');
+  if (!envIdentifier || !envIdentifier.parent) {
+    throw new SchematicsException(`Cannot find 'environment' identifier in ${filePath}`);
+  }
+
+  const envObjectLiteral = envIdentifier.parent.getChildren().find(({ kind }) => kind === ts.SyntaxKind.ObjectLiteralExpression);
+  if (!envObjectLiteral) {
+    throw new SchematicsException(`${filePath} is not in the expected format`);
+  }
+  const firebaseIdentifier = findNode(envObjectLiteral, ts.SyntaxKind.Identifier, 'firebase');
+
+  const recorder = host.beginUpdate(filePath);
+  if (firebaseIdentifier && firebaseIdentifier.parent) {
+    const change = new ReplaceChange(filePath, firebaseIdentifier.parent.pos, firebaseIdentifier.parent.getFullText(), data);
+    applyToUpdateRecorder(recorder, [change]);
+  } else {
+    const openBracketToken = envObjectLiteral.getChildren().find(({ kind }) => kind === ts.SyntaxKind.OpenBraceToken);
+    if (openBracketToken) {
+      const change = new InsertChange(filePath, openBracketToken.end, `${data},`);
+      applyToUpdateRecorder(recorder, [change]);
+    } else {
+      throw new SchematicsException(`${filePath} is not in the expected format`);
+    }
+  }
+  host.commitUpdate(recorder);
+
+  return host;
+}
+
+export function addToNgModule(host: Tree, options: { sourcePath: string, features: FEATURES[]}) {
+
+  const modulePath = findModuleFromOptions(host, {
+    name: 'app',
+    path: options.sourcePath,
+  });
+
+  if (!modulePath) {
+    return host;
+  }
+
+  if (!host.exists(modulePath)) {
+    throw new Error(`Specified module path ${modulePath} does not exist`);
+  }
+
+  const text = host.read(modulePath);
+  if (text === null) {
+    throw new SchematicsException(`File ${modulePath} does not exist.`);
+  }
+  const sourceText = text.toString('utf-8');
+
+  const source = ts.createSourceFile(
+    modulePath,
+    sourceText,
+    ts.ScriptTarget.Latest,
+    true
   );
-  const targets = rc.targets || {};
-  const projects = Object.keys(targets || {});
-  return projects.find(
-    project => !!Object.keys(targets[project].hosting).find(t => t === target)
+
+  const environmentsPath = buildRelativePath(
+    modulePath,
+    `/${options.sourcePath}/environments/environment`
   );
+
+  const changes: Array<Change> = [];
+
+  if (!findNode(source, ts.SyntaxKind.Identifier, 'provideFirebaseApp')) {
+    changes.push(
+      insertImport(source, modulePath, ['initializeApp', 'provideFirebaseApp'] as any, '@angular/fire/app'),
+      insertImport(source, modulePath, 'environment', environmentsPath),
+      ...addImportToModule(source, modulePath, `provideFirebaseApp(() => initializeApp(environment.firebase))`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.Analytics) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'provideAnalytics')
+  ) {
+    // TODO add user and screen tracking service
+    changes.push(
+      insertImport(source, modulePath, ['provideAnalytics', 'getAnalytics'] as any, '@angular/fire/analytics'),
+      ...addImportToModule(source, modulePath, `provideAnalytics(() => getAnalytics())`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.Authentication) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'provideAuth')
+  ) {
+    changes.push(
+      insertImport(source, modulePath, ['provideAuth', 'getAuth'] as any, '@angular/fire/auth'),
+      ...addImportToModule(source, modulePath, `provideAuth(() => getAuth())`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.Database) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'provideDatabase')
+  ) {
+    changes.push(
+      insertImport(source, modulePath, ['provideDatabase', 'getDatabase'] as any, '@angular/fire/database'),
+      ...addImportToModule(source, modulePath, `provideDatabase(() => getDatabase())`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.Firestore) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'provideFirestore')
+  ) {
+    changes.push(
+      insertImport(source, modulePath, ['provideFirestore', 'getFirestore'] as any, '@angular/fire/firestore'),
+      ...addImportToModule(source, modulePath, `provideFirestore(() => getFirestore())`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.Functions) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'provideFunctions')
+  ) {
+    changes.push(
+      insertImport(source, modulePath, ['provideFunctions', 'getFunctions'] as any, '@angular/fire/functions'),
+      ...addImportToModule(source, modulePath, `provideFunctions(() => getFunctions())`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.Messaging) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'provideMessaging')
+  ) {
+    // TODO add the service worker
+    changes.push(
+      insertImport(source, modulePath, ['provideMessaging', 'getMessaging'] as any, '@angular/fire/messaging'),
+      ...addImportToModule(source, modulePath, `provideMessaging(() => getMessaging())`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.Performance) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'providePerformance')
+  ) {
+    // TODO performance monitor service
+    changes.push(
+      insertImport(source, modulePath, ['providePerformance', 'getPerformance'] as any, '@angular/fire/performance'),
+      ...addImportToModule(source, modulePath, `providePerformance(() => getPerformance())`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.RemoteConfig) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'provideRemoteConfig')
+  ) {
+    changes.push(
+      insertImport(source, modulePath, ['provideRemoteConfig', 'getRemoteConfig'] as any, '@angular/fire/remote-config'),
+      ...addImportToModule(source, modulePath, `provideRemoteConfig(() => getRemoteConfig())`, null as any),
+    );
+  }
+
+  if (
+    options.features.includes(FEATURES.Storage) &&
+    !findNode(source, ts.SyntaxKind.Identifier, 'provideStorage')
+  ) {
+    changes.push(
+      insertImport(source, modulePath, ['provideStorage', 'getStorage'] as any, '@angular/fire/storage'),
+      ...addImportToModule(source, modulePath, `provideStorage(() => getStorage())`, null as any),
+    );
+  }
+
+  const recorder = host.beginUpdate(modulePath);
+  applyToUpdateRecorder(recorder, changes);
+  host.commitUpdate(recorder);
+
+  return host;
 }
+
+export const addIgnoreFiles = (host: Tree) => {
+  const path = '/.gitignore';
+  if (!host.exists(path)) {
+    return host;
+  }
+
+  const buffer = host.read(path);
+  if (!buffer) {
+    return host;
+  }
+
+  const content = buffer.toString();
+  if (!content.includes('# Firebase')) {
+    overwriteIfExists(host, path, content.concat(`
+# Firebase
+.firebase
+*-debug.log
+.runtimeconfig.json
+`));
+  }
+
+  return host;
+};

src/schematics/ng-add.jasmine.ts

@@ -1,18 +1,10 @@
 {
-    "default": {
-        "firebase": { "version": "0.0.0" },
-        "rxfire": { "version": "0.0.0" },
-        "@angular-devkit/architect": { "dev": true, "version": "0.0.0" },
-        "firebase-tools": { "dev": true, "version": "0.0.0" },
-        "fuzzy": { "dev": true, "version": "0.0.0"},
-        "inquirer": { "dev": true, "version": "0.0.0"},
-        "inquirer-autocomplete-prompt": { "dev": true, "version": "0.0.0"},
-        "open": { "dev": true, "version": "0.0.0"},
-        "jsonc-parser": { "dev": true, "version": "0.0.0" }
+    "peerDependencies": {
+        "firebase": { "dev": false, "version": "0.0.0" },
+        "rxfire": { "dev": false, "version": "0.0.0" }
     },
-    "firebaseFunctions": {
+    "firebaseFunctionsDependencies": {
         "firebase-admin": { "dev": true, "version": "0.0.0" },
-        "firebase-functions": { "dev": true, "version":  "0.0.0" },
-        "firebase-functions-test": { "dev": true, "version": "0.0.0" }
+        "firebase-functions": { "dev": true, "version":  "0.0.0" }
     }
 }

src/schematics/ng-add.ts

@@ -161,11 +161,11 @@ async function replaceSchematicVersions() {
   const root = await rootPackage;
   const path = dest('schematics', 'versions.json');
   const dependencies = await import(path);
-  Object.keys(dependencies.default).forEach(name => {
-    dependencies.default[name].version = root.dependencies[name] || root.devDependencies[name];
+  Object.keys(dependencies.peerDependencies).forEach(name => {
+    dependencies.peerDependencies[name].version = root.dependencies[name] || root.devDependencies[name];
   });
-  Object.keys(dependencies.firebaseFunctions).forEach(name => {
-    dependencies.firebaseFunctions[name].version = root.dependencies[name] || root.devDependencies[name];
+  Object.keys(dependencies.firebaseFunctionsDependencies).forEach(name => {
+    dependencies.firebaseFunctionsDependencies[name].version = root.dependencies[name] || root.devDependencies[name];
   });
   return writeFile(path, JSON.stringify(dependencies, null, 2));
 }
@@ -181,6 +181,8 @@ async function compileSchematics() {
     copy(src('schematics', 'collection.json'), dest('schematics', 'collection.json')),
     copy(src('schematics', 'migration.json'), dest('schematics', 'migration.json')),
     copy(src('schematics', 'deploy', 'schema.json'), dest('schematics', 'deploy', 'schema.json')),
+    copy(src('schematics', 'add', 'schema.json'), dest('schematics', 'add', 'schema.json')),
+    copy(src('schematics', 'setup', 'schema.json'), dest('schematics', 'setup', 'schema.json')),
     replaceSchematicVersions()
   ]);
 }