feat(core): add dependencies manager

Author: Ovidiu Barabula

src/dependencies-manager/index.spec.ts

@@ -0,0 +1,97 @@
+import { assert, expect } from 'chai';
+import 'mocha';
+
+import * as path from 'path';
+import { DependenceisManifests, DependenciesManager, DependenciesSubscriber } from '.';
+import FileReader from '../util/file-reader';
+
+
+describe('DependenciesManager', () => {
+  let fileReader: FileReader;
+  let depsManager: DependenciesManager;
+  let subscriber: DependenciesSubscriber;
+  const manifestName = 'my-manifest';
+  const manifest: DependenceisManifests = {
+    dependencies: { 'my-package': '^2.2.2' },
+    devDependencies: { 'my-dev-package': '^1.1.1' },
+  };
+
+  before(() => {
+    depsManager = DependenciesManager();
+  });
+
+  beforeEach(() => {
+    subscriber = depsManager.getSubscriber();
+  });
+
+
+  describe('getSubscriber()', () => {
+    it('returns a function', () => {
+      expect(subscriber).to.be.a('function');
+    });
+
+
+    it('returns a limited function', () => {
+      subscriber(manifest, manifestName);
+      expect(subscriber(manifest, manifestName)).to.be.an('undefined');
+    });
+
+
+    describe('Subscriber function', () => {
+      it('subscribes a dependency manifest', () => {
+        subscriber(manifest, manifestName);
+        expect(depsManager.isRegistered(manifestName)).to.be.true;
+      });
+
+
+      it('doesn\'t subscribe an already registered dependency manifest', () => {
+        // Use the sub fn once
+        subscriber(manifest, manifestName);
+        // Get new subscriber
+        subscriber = depsManager.getSubscriber();
+        // Subscribe again
+        subscriber(manifest, manifestName);
+        expect(depsManager.isRegistered(manifestName)).to.be.true;
+      });
+    });
+  });
+
+
+  describe('install()', () => {
+    it('registers the dependencies and starts the installation', async () => {
+      subscriber(manifest, manifestName);
+      await depsManager.install();
+      const {
+        dependencies,
+        devDependencies,
+      } = await FileReader(path.join(process.cwd(), 'test.package.json')).read();
+
+      expect(dependencies).to.contain.keys('my-package');
+      expect(devDependencies).to.contain.keys('my-dev-package');
+    }).timeout(12000);
+  });
+
+
+  describe('private method registerDependencies()', () => {
+    it('registeres dependencies manifests with DependenciesInstaller', async () => {
+      subscriber(manifest, manifestName);
+      await depsManager.install();
+      const {
+        dependencies,
+        devDependencies,
+      } = await FileReader(path.join(process.cwd(), 'test.package.json')).read();
+
+      expect(dependencies).to.contain.keys('my-package');
+      expect(devDependencies).to.contain.keys('my-dev-package');
+    }).timeout(12000);
+  });
+
+
+  after(async () => {
+    fileReader = FileReader(path.join(process.cwd(), 'test.package.json'));
+    const fileContents = await fileReader.read();
+    delete fileContents.dependencies;
+    delete fileContents.devDependencies;
+    await fileReader.write(fileContents);
+  });
+});

src/dependencies-manager/index.ts

@@ -0,0 +1,143 @@
+/**
+ * Name: index.ts
+ * Description: Plugin dependencies manager
+ * Author: Ovidiu Barabula <lectii2008@gmail.com>
+ * @since 1.1.0
+ */
+
+import chalk from 'chalk';
+import Logger from '../util/logger';
+import { limitFn, pluginName } from '../util/utility-functions';
+import InstallerSingleton, {
+  DependenciesInstaller,
+  DependenciesManifest,
+} from './dependencies-installer';
+
+
+export type DependenciesSubscriber = (manifest: DependenciesManifest, name: string) => void;
+
+export interface DependenceisManifests {
+  [key: string]: DependenciesManifest;
+}
+
+export interface DependenciesManager {
+  getSubscriber(): DependenciesSubscriber;
+  install(): Promise<void>;
+  /* test:start */
+  instantiateInstaller?(): Promise<void>;
+  isRegistered?(name: string): boolean;
+  registerDependencies?(): Promise<void>;
+  /* test:end */
+}
+
+
+// Custom messages
+const MESSAGES = {
+  REGISTERING_PLUGIN_DEPS: 'Registering dependencies',
+};
+
+
+// Custom error messages
+const ERRORS = {
+  ALREADY_REGISTERED: 'Sorry, there are dependencies already registered under this name',
+};
+
+
+/**
+ * DependenciesManager constructor
+ * The manager will act as a middle-man to delay the (taxing) Dependencies Installer instatiation
+ */
+export function DependenciesManager(): DependenciesManager {
+  const logger = Logger.getInstance()('DependenciesManager');
+  const depsManifests: DependenceisManifests = {};
+  let depsInstaller: DependenciesInstaller;
+
+
+  /**
+   * Instantiate Dependencies Installer
+   */
+  async function instantiateInstaller(): Promise<void> {
+    if (typeof depsInstaller === 'undefined') {
+      depsInstaller = await InstallerSingleton.getInstance(process.cwd());
+    }
+  }
+
+
+  /**
+   * Register subscribed dependencies to Dependencies Installer
+   */
+  async function registerDependencies(): Promise<void> {
+    for (const name of Object.keys(depsManifests)) {
+      await depsInstaller.add(depsManifests[name]);
+    }
+  }
+
+
+  /**
+   * Instantiate, register dependencies and start the Dependencies Installer .run() method
+   */
+  async function install(): Promise<void> {
+    // Get the Dependencies Installer instance
+    await instantiateInstaller();
+    // Register the dependencies with the Dependencies Installer
+    await registerDependencies();
+    // Start the installation process
+    await depsInstaller.run();
+  }
+
+
+  /**
+   * Check if manifest is registered
+   * @param name Manifest name (task or plugin name)
+   */
+  function isRegistered(name: string): boolean {
+    return Object.keys(depsManifests).includes(name);
+  }
+
+
+  /**
+   * Create the dependencies subscriber function
+   * This function will be provided to all plugins to allow dependencies registration
+   * The manager will then register each plugin's dependencies to the Dependencies Installer instance
+   */
+  function getSubscriber(): DependenciesSubscriber {
+    // Return a limited function (1 maximum call) to register plugin dependencies
+    return limitFn(function (manifest: DependenciesManifest, name: string) {
+      /* istanbul ignore else */
+      if (typeof name !== 'undefined') {
+        logger.debug(`${MESSAGES.REGISTERING_PLUGIN_DEPS} for ${chalk.cyan.bold(pluginName(name))}`);
+      }
+
+      // Check if name is already used
+      if (isRegistered(name)) {
+        // Output an error and return
+        logger.error(`${ERRORS.ALREADY_REGISTERED} ${chalk.cyan.bold(name)}`);
+      }
+
+      // Add the dependencies to the manifests object, if it's not registered already
+      depsManifests[name] = manifest;
+    });
+  }
+
+
+  // Public API object
+  let publicApi = {
+    getSubscriber,
+    install,
+  };
+
+
+  /* test:start */
+  // Add private methods for test environment
+  publicApi = {...publicApi,
+    instantiateInstaller,
+    isRegistered,
+    registerDependencies,
+  };
+  /* test:end */
+
+  // Return the read-only public API object
+  return Object.freeze(publicApi);
+}
+
+export default DependenciesManager();