fix: add support for AngularV11

Author: dianjuar

src/deploy/actions.spec.ts

@@ -5,15 +5,42 @@ import {
   ScheduleOptions,
   Target
 } from '@angular-devkit/architect/src/index';
+
 import deploy from './actions';
+import { BuildTarget } from 'interfaces';
+import * as path from 'path';
 
-let context: BuilderContext;
-const mockEngine = { run: (_: string, __: any, __2: any) => Promise.resolve() };
+import { readFileAsync } from '../utils';
+jest.mock('../utils');
 
+const mockEngine = {
+  run: (_: string, __: any, __2: any) => Promise.resolve()
+};
 const PROJECT = 'pirojok-project';
 
+let context: BuilderContext;
+let mockedReadFileAsync: jest.Mock<ReturnType<typeof readFileAsync>>;
+let ngPackageContent: JsonObject;
+
 describe('Deploy Angular apps', () => {
-  beforeEach(() => initMocks());
+  beforeEach(() => {
+    ngPackageContent = {
+      dest: `../../dist/randomness/${PROJECT}`
+    };
+
+    mockedReadFileAsync = readFileAsync as jest.Mock<
+      ReturnType<typeof readFileAsync>
+    >;
+    mockedReadFileAsync.mockImplementation(() =>
+      Promise.resolve(JSON.stringify(ngPackageContent, null, 2))
+    );
+
+    initMocks();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
 
   describe('Builder', () => {
     let spy: jest.SpyInstance;
@@ -23,7 +50,7 @@ describe('Deploy Angular apps', () => {
     });
 
     it('should invoke the builder', async () => {
-      await deploy(mockEngine, context, 'host', {});
+      await deploy(mockEngine, context, getBuildTarget(), {});
 
       expect(spy).toHaveBeenCalledWith({
         target: 'build',
@@ -34,7 +61,7 @@ describe('Deploy Angular apps', () => {
     it('should invoke the builder with the right configuration', async () => {
       const customConf = 'my-custom-conf';
 
-      await deploy(mockEngine, context, 'host', {
+      await deploy(mockEngine, context, getBuildTarget(), {
         configuration: customConf
       });
 
@@ -47,27 +74,45 @@ describe('Deploy Angular apps', () => {
   });
 
   it('should invoke engine.run', async () => {
-    const spy = spyOn(mockEngine, 'run').and.callThrough();
-    await deploy(mockEngine, context, 'host', {});
+    const expectedOutputDir = path.join(
+      context.workspaceRoot,
+      `dist/randomness/${PROJECT}`
+    );
+    const runSpy = spyOn(mockEngine, 'run').and.callThrough();
+
+    await deploy(mockEngine, context, getBuildTarget(), {});
 
-    expect(spy).toHaveBeenCalledWith('host', {}, context.logger);
+    expect(runSpy).toHaveBeenCalledWith(expectedOutputDir, {}, context.logger);
   });
 
   describe('error handling', () => {
-    it('throws if there is no target project', async () => {
+    it('should throw if there is no target project', async () => {
       context.target = undefined;
       try {
-        await deploy(mockEngine, context, 'host', {});
+        await deploy(mockEngine, context, getBuildTarget(), {});
         fail();
       } catch (e) {
         expect(e.message).toMatch(/Cannot execute the build target/);
       }
     });
+
+    it('should throw if there is not project on build options', async () => {
+      context.getTargetOptions = () => Promise.resolve({});
+
+      try {
+        await deploy(mockEngine, context, getBuildTarget(), {});
+        fail();
+      } catch (e) {
+        expect(e.message).toMatch(
+          /Cannot read the project path option of the Angular library '.*' in angular.json/
+        );
+      }
+    });
   });
 });
 
 const initMocks = () => {
-  context = {
+  context = ({
     target: {
       configuration: 'production',
       project: PROJECT,
@@ -78,21 +123,18 @@ const initMocks = () => {
       description: 'mock',
       optionSchema: false
     },
-    currentDirectory: 'cwd',
-    id: 1,
+    workspaceRoot: 'my/workspace/root',
     logger: new logging.NullLogger() as any,
-    workspaceRoot: 'cwd',
-    addTeardown: _ => {},
-    validateOptions: _ => Promise.resolve({} as any),
-    getBuilderNameForTarget: () => Promise.resolve(''),
-    analytics: null as any,
-    getTargetOptions: (_: Target) => Promise.resolve({}),
-    reportProgress: (_: number, __?: number, ___?: string) => {},
-    reportStatus: (_: string) => {},
-    reportRunning: () => {},
-    scheduleBuilder: (_: string, __?: JsonObject, ___?: ScheduleOptions) =>
-      Promise.resolve({} as BuilderRun),
     scheduleTarget: (_: Target, __?: JsonObject, ___?: ScheduleOptions) =>
-      Promise.resolve({} as BuilderRun)
-  };
+      Promise.resolve({} as BuilderRun),
+    getTargetOptions: (t: Target) =>
+      Promise.resolve({
+        project: `projects/${t.project}/some-file.json`,
+        target: t.target
+      })
+  } as unknown) as BuilderContext;
 };
+
+const getBuildTarget = (): BuildTarget => ({
+  name: `${PROJECT}:build:production`
+});

src/deploy/actions.ts

@@ -1,7 +1,15 @@
-import { BuilderContext, Target } from '@angular-devkit/architect';
+import {
+  BuilderContext,
+  Target,
+  targetFromTargetString
+} from '@angular-devkit/architect';
 import { logging } from '@angular-devkit/core';
 
+import * as path from 'path';
+
 import { Schema } from './schema';
+import { readFileAsync } from '../utils';
+import { BuildTarget } from 'interfaces';
 
 export default async function deploy(
   engine: {
@@ -12,7 +20,7 @@ export default async function deploy(
     ) => Promise<void>;
   },
   context: BuilderContext,
-  projectRoot: string,
+  buildTarget: BuildTarget,
   options: Schema
 ) {
   if (options.noBuild) {
@@ -44,9 +52,55 @@ export default async function deploy(
     await build.result;
   }
 
+  const targetFromStr = targetFromTargetString(buildTarget.name);
+  const buildOptions = await context.getTargetOptions(targetFromStr);
+
+  if (!buildOptions.project || typeof buildOptions.project !== 'string') {
+    throw new Error(
+      `Cannot read the project path option of the Angular library '${buildTarget.name}' in angular.json`
+    );
+  }
+
+  const outputPath = await getOutPutPath(
+    context.workspaceRoot,
+    buildOptions.project
+  );
+
   await engine.run(
-    projectRoot,
+    outputPath,
     options,
     (context.logger as unknown) as logging.LoggerApi
   );
 }
+
+async function getOutPutPath(
+  projectRoot: string,
+  relativeNgPackagePath: string
+): Promise<string> {
+  const ngPackagePath = path.join(projectRoot, relativeNgPackagePath);
+
+  let ngPackageContentStr: string;
+
+  try {
+    ngPackageContentStr = await readFileAsync(ngPackagePath, {
+      encoding: 'utf8'
+    });
+  } catch (error) {
+    throw new Error(`Error reading the ng-package.json`);
+  }
+
+  const ngPackageContent = JSON.parse(ngPackageContentStr);
+
+  if (!ngPackageContent.dest || typeof ngPackageContent.dest !== 'string') {
+    throw new Error(
+      `Cannot read the project 'dest' option of the ng-package.json`
+    );
+  }
+
+  const outputPath = path.join(
+    path.dirname(ngPackagePath),
+    ngPackageContent.dest
+  );
+
+  return outputPath;
+}

src/deploy/builder.ts

@@ -3,53 +3,28 @@ import {
   BuilderOutput,
   createBuilder
 } from '@angular-devkit/architect';
-import { asWindowsPath, experimental, normalize } from '@angular-devkit/core';
-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): Promise<BuilderOutput> => {
-    // The project root is added to a BuilderContext.
-    const root = normalize(context.workspaceRoot);
-    const workspace = new experimental.workspace.Workspace(
-      root,
-      new NodeJsSyncHost()
-    );
-    await workspace
-      .loadWorkspaceFromHost(normalize('angular.json'))
-      .toPromise();
-
     if (!context.target) {
       throw new Error('Cannot deploy the application without a target');
     }
 
-    const targets = workspace.getProjectTargets(context.target.project);
-
-    const outputPath = await getLibraryOutputPath(targets);
-
-    // normalizes pathes don't work with all native functions
-    // as a workaround, you can use the following 2 lines
-    const isWin = os.platform() === 'win32';
-    const workspaceRoot = !isWin
-      ? workspace.root
-      : asWindowsPath(workspace.root);
-    // if this is not necessary, use this:
-    // const workspaceRoot =  workspace.root;
+    const configuration = options.configuration
+      ? `:${options.configuration}`
+      : '';
+    const buildTarget = {
+      name: `${context.target.project}:build${configuration}`
+    };
 
     try {
-      await deploy(
-        engine,
-        context,
-        path.join(workspaceRoot, outputPath),
-        options
-      );
+      await deploy(engine, context, buildTarget, options);
     } catch (e) {
       context.logger.error('Error when trying to deploy:', e);
       console.error(e);
@@ -59,31 +34,3 @@ export default createBuilder<any>(
     return { success: true };
   }
 );
-
-const fs = require('fs');
-function readFileAsync<T>(path: string): Promise<T> {
-  return new Promise((res, rej) => {
-    fs.readFile(path, 'utf8', function(err, contents) {
-      if (err) rej(err);
-
-      res(contents);
-    });
-  });
-}
-
-async function getLibraryOutputPath(
-  targets: experimental.workspace.WorkspaceTool
-) {
-  const ngPackagePath = targets.build.options.project;
-
-  try {
-    const dataStr = await readFileAsync<string>(ngPackagePath);
-    const data = JSON.parse(dataStr);
-
-    const fullPath = (data.dest as string).replace(/\.\.\//g, '');
-
-    return fullPath;
-  } catch (err) {
-    throw new Error('An error occurs reading the ng-package.json');
-  }
-}

src/engine/engine.spec.ts

@@ -5,9 +5,9 @@ import * as engine from './engine';
 import { Schema } from '../deploy/schema';
 import { npmAccess } from './defaults';
 
-import * as exec from './utils/exec-async';
+import * as exec from '../utils/exec-async';
 
-import * as fs from './utils/fs-async';
+import * as fs from '../utils/fs-async';
 import { PromiseWithChild } from 'child_process';
 
 describe('engine', () => {

src/engine/engine.ts

@@ -1,8 +1,8 @@
-import { logging } from '@angular-devkit/core';
+import { JsonObject, logging } from '@angular-devkit/core';
 import * as path from 'path';
 
-import * as fs from './utils/fs-async';
-import { execAsync } from './utils/exec-async';
+import * as fs from '../utils/fs-async';
+import { execAsync } from '../utils/exec-async';
 
 import { Schema } from '../deploy/schema';
 import { defaults } from './defaults';
@@ -17,7 +17,7 @@ export async function run(
 
     // If we are not on dry run
     if (options.packageVersion && !options.dryRun) {
-      await setPackageVersion(dir, options);
+      await setPackageVersion(dir, options.packageVersion);
     }
 
     const npmOptions = extractOnlyNPMOptions(options);
@@ -44,15 +44,15 @@ export async function run(
   }
 }
 
-async function setPackageVersion(dir: string, options: Schema) {
-  let packageContent: string = await fs.readFileAsync(
+async function setPackageVersion(dir: string, packageVersion: string) {
+  const packageContent: string = await fs.readFileAsync(
     path.join(dir, 'package.json'),
     { encoding: 'utf8' }
   );
 
-  let packageObj: any = JSON.parse(packageContent);
+  const packageObj: JsonObject = JSON.parse(packageContent);
 
-  packageObj.version = options.packageVersion;
+  packageObj.version = packageVersion;
 
   await fs.writeFileAsync(
     path.join(dir, 'package.json'),

src/interfaces.ts

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