Package dependencies updated.

Code refactored
Added express server to run the app in Heroku
Added NodeJs binary as file, Instead of downloading from server ,

Author: patelvimal

src/Procfile

@@ -0,0 +1 @@
+web: node server.js

src/collection.json

@@ -3,8 +3,8 @@
   "schematics": {
     "ng-add": {
       "description": "Add @angular-schule/ngx-deploy-starter deploy schematic",
-      "factory": "./ng-add#ngAdd",
-      "schema": "./ng-add-schema.json",
+      "factory": "./ng-add/ng-add#ngAdd",
+      "schema": "./ng-add/ng-add-schema.json",
       "aliases": ["install"]
     }
   }

src/deploy/actions.spec.ts

@@ -1,9 +1,9 @@
 import { JsonObject, logging } from '@angular-devkit/core';
 import { BuilderContext, BuilderRun, ScheduleOptions, Target } from '@angular-devkit/architect/src/index';
 import deploy from './actions';
+import { SynchronousDelegateExpectedException } from '@angular-devkit/core/src/virtual-fs/host';
 
 let context: BuilderContext;
-const mockEngine = { run: (_: string, __: any, __2: any) => Promise.resolve() }
 
 const PROJECT = 'pirojok-project';
 
@@ -12,7 +12,7 @@ describe('Deploy Angular apps', () => {
 
   it('should invoke the builder', async () => {
     const spy = spyOn(context, 'scheduleTarget').and.callThrough();
-    await deploy(mockEngine, context, 'host', {});
+    await deploy( context, 'host',"app", {});
 
     expect(spy).toHaveBeenCalledWith({
         target: 'build',
@@ -25,7 +25,7 @@ describe('Deploy Angular apps', () => {
 
   it('should invoke the builder with the baseHref', async () => {
     const spy = spyOn(context, 'scheduleTarget').and.callThrough();
-    await deploy(mockEngine, context, 'host', { baseHref: '/folder'});
+    await deploy(context, 'host',"app", { baseHref: '/folder'});
 
     expect(spy).toHaveBeenCalledWith({
         target: 'build',
@@ -36,23 +36,35 @@ describe('Deploy Angular apps', () => {
     );
   });
 
-  it('should invoke engine.run', async () => {
-    const spy = spyOn(mockEngine, 'run').and.callThrough();
-    await deploy(mockEngine, context, 'host', {});
+  // it('should invoke engine.run', async () => {
+  //   const spy = spyOn(mockEngine, 'run').and.callThrough();
+  //   await deploy(mockEngine, context, 'host', {});
 
-    expect(spy).toHaveBeenCalledWith('host', {}, context.logger);
-  });
+  //   expect(spy).toHaveBeenCalledWith('host', {}, context.logger);
+  // });
 
   describe('error handling', () => {
     it('throws if there is no target project', async () => {
       context.target = undefined;
       try {
-        await deploy(mockEngine, context, 'host', {});
+        await deploy(context, 'host', "app", {});
         fail();
       } catch (e) {
         expect(e.message).toMatch(/Cannot execute the build target/);
       }
     });
+
+    it('return false if api Token not present', async () => {
+      var output = await deploy(context, 'host', "app", {});
+      expect(output.success).toEqual(false);
+    });
+    
+    it('return false if app name not present', async () => {
+      var output = await deploy(context, 'host', "app", {
+        herokuApiToken:"asd"
+      });
+      expect(output.success).toEqual(false);
+    });
   });
 });
 

src/deploy/actions.ts

@@ -1,17 +1,17 @@
 import { BuilderContext } from '@angular-devkit/architect';
 import { json, logging } from '@angular-devkit/core';
-
+import * as engine from '../engine/engine';
 import { Schema } from './schema';
 
 
+
 export default async function deploy(
-  engine: { run: (dir: string, options: Schema, outDir: string, logger: logging.LoggerApi) => Promise<void> },
   context: BuilderContext,
   projectRoot: string,
   outDir: string,
   options: Schema
 ) {
-
+  
   if (options.noBuild) {
     context.logger.info(`📦 Skipping build`);
   } else {
@@ -36,7 +36,16 @@ export default async function deploy(
     await build.result;
   }
 
-  await engine.run(
+  if (!options.herokuApiToken) {
+    context.logger.error("🚨 Heroku API Token not found!");
+    return { success: false };
+  }
+  if (!options.appName) {
+    context.logger.error("🚨 Please specify Heroku Application in which you want to deploy!");
+    return { success: false };
+  }
+
+  return await engine.run(
     projectRoot,
     options,
     outDir,

src/deploy/builder.ts

@@ -4,13 +4,12 @@ import { NodeJsSyncHost } from '@angular-devkit/core/node';
 import os from 'os';
 import * as path from 'path';
 
-import * as engine from '../engine/engine';
 import deploy from './actions';
 import { Schema } from './schema';
 
 // Call the createBuilder() function to create a builder. This mirrors
 // createJobHandler() but add typings specific to Architect Builders.
-export default createBuilder<any>(
+export default createBuilder(
   async (
     options: Schema,
     context: BuilderContext
@@ -48,8 +47,7 @@ export default createBuilder<any>(
     // const workspaceRoot =  workspace.root;
 
     try {
-      await deploy(
-        engine,
+      return await deploy(
         context,
         path.join(workspaceRoot),
         targets.build.options.outputPath,
@@ -60,7 +58,5 @@ export default createBuilder<any>(
       console.error(e);
       return { success: false };
     }
-
-    return { success: true };
   }
 );

src/deploy/schema.json

@@ -21,6 +21,14 @@
     "targetDir": {
       "type": "string",
       "description": "This is one of the options you can freely choose according to your needs. --- We will 'deploy' to this folder."
+    },
+    "appName": {
+      "type": "string",
+      "description": "Application Name in which you want to deploy"
+    },
+    "herokuApiToken": {
+      "type": "string",
+      "description": "Heroku API Token for deploying the application"
     }
   }
 }

src/engine/engine.spec.ts

@@ -1,10 +1,23 @@
 import * as engine from './engine';
-import { NullLogger } from '@angular-devkit/core/src/logger';
+import { JsonObject, logging } from '@angular-devkit/core';
+import { Logger, LogLevel } from '@angular-devkit/core/src/logger';
+const Heroku = require('heroku-client');
+const logger: any = {
+  error: (message: string) => { }
+}
+let heroku: any = null;
+jest.mock('heroku-client') // this auto mocks all methods on heroku-client
 
 describe('engine', () => {
-  it('should copy directory', () => {
+  beforeEach(() => {
+    heroku = new Heroku({ token: 'asd' });
+  });
 
-    // TODO: really write test here!
-    expect(1 + 1).toEqual(2);
+  it('should return false if application name not find in Heroku', async () => {
+    const spy = spyOn(logger, 'error').and.callThrough();
+    const result = await engine.run("", { appName: 'test' }, "app", logger);
+    expect(result.success).toEqual(false);
+    expect(spy).toHaveBeenCalledWith("🚨 test application not found in Heroku!");
   });
+
 });

src/engine/engine.ts

@@ -1,44 +1,57 @@
+import { BuilderOutput } from '@angular-devkit/architect';
 import { logging } from '@angular-devkit/core';
+import {
+  copy,
+  copyFileSync, ensureDir, move,
+  readFileSync, remove
+} from 'fs-extra';
+import * as tar from 'tar';
 import { Schema } from '../deploy/schema';
 const Heroku = require('heroku-client');
-import * as tar from 'tar';
 const fetch = require("node-fetch");
-import {
-  ensureDir, copy, remove, move,
-  copyFileSync, readFileSync, createWriteStream
-} from 'fs-extra';
 
+const path = require("path");
 
 // TODO: add your deployment code here!
 export async function run(dir: string,
   options: Schema,
   outDir: string,
-  logger: logging.LoggerApi) {
+  logger: logging.LoggerApi): Promise<BuilderOutput> {
 
   try {
-
-    const heroku = new Heroku({ token: '' });
-
+    const heroku = new Heroku({ token: options.herokuApiToken });
     const result = await heroku.get('/apps');
-    const site = result.find((app => app.name === 'ngx-deploy-demo'))
+    let site: any = null;
+    if (result && result.length > 0) {
+      site = result.find((app => app.name === options.appName));
+    }
+
+    if (!site) {
+      logger.error(`🚨 ${options.appName} application not found in Heroku!`);
+      return { success: false };
+    }
 
     const slugResult = await heroku.post(`/apps/${site.name}/slugs`, {
       body: {
         buildpack_provided_description: "heroku/nodejs",
-        process_types: { "web": `node-v12.12.0-linux-x64/bin/node index.js` }
+        process_types: { "web": `node-v15.6.0-linux-x64/bin/node server.js` }
       }
     });
+
     logger.info('Copying Build Files');
     await remove(`${dir}/app`);
     await remove(`${dir}/tmp`);
     await remove(`${dir}/slug.tgz`);
     await ensureDir(`${dir}/app`);
     await ensureDir(`${dir}/tmp`);
-
-    await download();
+    
     await copy(`${outDir}`, `${dir}/app`);
-    await moveNodeJS('node-v12.12.0-linux-x64', `${dir}/app/node-v12.12.0-linux-x64`)
-    copyFileSync('index.js', `${dir}/app/index.js`);
+    await tar.x({
+      file: path.join(__dirname, "../", 'node-v15.6.0-linux-x64.tar')
+    })
+    await moveNodeJS('node-v15.6.0-linux-x64', `${dir}/app/node-v15.6.0-linux-x64`)
+    copyFileSync(path.join(__dirname, "../", 'server.js'), `${dir}/app/server.js`);
+    copyFileSync(path.join(__dirname, "../", 'Procfile'), `${dir}/app/Procfile`);
 
     const tarResponse = await tar.c(
       {
@@ -68,6 +81,7 @@ export async function run(dir: string,
     });
 
     logger.info('Deployment Success!');
+    return { success: true };
     // await remove(`${dir}/app`);
     // await remove(`${dir}/tmp`);
     // await remove(`${dir}/slug.tgz`);
@@ -79,23 +93,6 @@ export async function run(dir: string,
 };
 
 
-async function download() {
-  const res = await fetch('http://nodejs.org/dist/latest-v12.x/node-v12.12.0-linux-x64.tar.gz');
-  await new Promise((resolve, reject) => {
-    const fileStream = createWriteStream('./tmp/node-v12.12.0-linux-x64.tar.gz');
-    res.body.pipe(fileStream);
-    res.body.on("error", (err) => {
-      reject(err);
-    });
-    fileStream.on("finish", function () {
-      tar.x({
-        file: './tmp/node-v12.12.0-linux-x64.tar.gz'
-      })
-      resolve();
-    });
-  });
-}
-
 async function moveNodeJS(src, dest) {
   try {
     await move(src, dest)

src/interfaces.ts

@@ -0,0 +1,13 @@
+
+export interface WorkspaceProject {
+    projectType?: string;
+    architect?: Record<
+        string,
+        { builder: string; options?: Record<string, any> }
+    >;
+}
+
+export interface Workspace {
+    defaultProject?: string;
+    projects: Record<string, WorkspaceProject>;
+}