Merge pull request #4 from lightness/feature/api-support

Feature/api support

Author: lightness

README.md

@@ -72,4 +72,19 @@ Options:
                                                       [boolean] [default: false]
   --json            show output as prettified json    [boolean] [default: false]
   -h, --help        Show help                                          [boolean]
-```
+```
+
+## Use in your app
+
+```js
+const { grt } = require('github-repo-tools');
+
+const response = await grt({ 
+  user: 'lightness',
+  package: 'typescript',
+  yarnLock: false,
+  token: '<GITHUB_TOKEN>',
+});
+```
+
+> TODO: Add more descriptive exmaple

package.json

@@ -1,8 +1,8 @@
 {
   "name": "github-repo-tools",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Useful tool to get versions from all repos of Github user/org",
-  "main": "build/app.js",
+  "main": "build/index.js",
   "bin": {
     "grt": "./build/app.js"
   },

src/app.module.ts

@@ -1,14 +1,15 @@
-import { Module } from '@nestjs/common';
+import { Module, DynamicModule, Global } from '@nestjs/common';
 import { CliModule } from './modules/cli/cli.module';
 import { NodeVersionModule } from './modules/node-version/node.version.module';
 import { AppService } from './app.service';
 import { NpmDependencyVersionModule } from './modules/npm-dependency-version/npm.dependency.version.module';
 import { RateLimitModule } from './modules/rate-limit/rate.limit.module';
 import { PresenterModule } from './modules/presenter/presenter.module';
+import { CumulativeWritable } from './util/cumulative.stream';
 
+@Global()
 @Module({
   imports: [
-    CliModule,
     PresenterModule,
     RateLimitModule,
     NodeVersionModule,
@@ -22,4 +23,30 @@ import { PresenterModule } from './modules/presenter/presenter.module';
   ],
 })
 export class AppModule {
+  static forApi(): DynamicModule {
+    const streamProvider = { 
+      provide: 'STREAM', 
+      useFactory: () => new CumulativeWritable({}) 
+    };
+
+    return {
+      module: AppModule,
+      providers: [streamProvider],
+      exports: [streamProvider],
+    };
+  }
+
+  static forCli(): DynamicModule {
+    const streamProvider = { 
+      provide: 'STREAM', 
+      useValue: process.stdout 
+    };
+
+    return {
+      module: AppModule,
+      imports: [CliModule],
+      providers: [streamProvider],
+      exports: [streamProvider],
+    };
+  }
 }

src/app.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Optional } from '@nestjs/common';
 import { CliService } from './modules/cli/cli.service';
 import { NodeVersionService } from './modules/node-version/node.version.service';
 import { INodeVersion } from './modules/node-version/interfaces';
@@ -13,7 +13,7 @@ import { PresentationMode } from './modules/presenter/interfaces';
 export class AppService {
 
   constructor(
-    private cliService: CliService,
+    @Optional() private cliService: CliService,
     private presenterService: PresenterService,
     private rateLimitService: RateLimitService,
     private nodeVersionService: NodeVersionService,
@@ -24,19 +24,23 @@ export class AppService {
   public async main() {
     const options: IProgramOptions = await this.cliService.getProgramOptions();
 
+    return this.run(options);
+  }
+
+  public async run(options: IProgramOptions) {
     this.setupPresenter(options);
 
     this.presenterService.showFiglet();
     this.presenterService.showGithubTokenInfo(options);
 
-    const { package: packageName, node, rateLimit } = options;
+    const { package: packageName, node, rateLimit, token } = options;
 
     if (node) {
       return this.nodeCase(options);
     } else if (packageName) {
       return this.packageCase(options);
     } else if (rateLimit) {
-      return this.showRateLimit(true);
+      return this.showRateLimit(true, token);
     } else {
       this.presenterService.showError('Wrong input');
     }
@@ -45,17 +49,17 @@ export class AppService {
   private async nodeCase(options: IProgramOptions) {
     const report: INodeVersion[] = await this.nodeVersionService.getReport(options);
     this.presenterService.showData(report, options);
-    this.showRateLimit(false);
+    this.showRateLimit(false, options.token);
   }
 
   private async packageCase(options: IProgramOptions) {
     const report: IPacakgeVersion[] = await this.npmDependencyVersionService.getReport(options);
     this.presenterService.showData(report, options);
-    this.showRateLimit(false);
+    this.showRateLimit(false, options.token);
   }
 
-  private async showRateLimit(isMainInfo: boolean) {
-    const rateLimit = await this.rateLimitService.getRateLimit();
+  private async showRateLimit(isMainInfo: boolean, token?: string) {
+    const rateLimit = await this.rateLimitService.getRateLimit(token);
 
     this.presenterService.showRateLimit(rateLimit, isMainInfo);
   }

src/app.ts

@@ -5,7 +5,10 @@ import { AppService } from './app.service';
 import { AppLogger } from './app.logger';
 
 async function bootstrap() {
-  const app = await NestFactory.createApplicationContext(AppModule, { logger: new AppLogger() });
+  const app = await NestFactory.createApplicationContext(
+    AppModule.forCli(), 
+    { logger: new AppLogger() }
+  );
 
   const appService = app.get(AppService);
   await appService.main();

src/config/default.ts

@@ -0,0 +1,20 @@
+import { IProgramOptions } from "../interfaces";
+
+export const DEFAULT: IProgramOptions = {
+  skipEmpty: true,
+  skipError: [404],
+
+  json: false,
+  rawJson: false,
+
+  engines: true,
+  nvm: true,
+
+  deps: true,
+  devDeps: true,
+  peerDeps: true,
+  packageLock: true,
+  yarnLock: true,
+
+  token: process.env.GITHUB_TOKEN,
+}

src/index.ts

@@ -0,0 +1,20 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+import { AppService } from './app.service';
+import { AppLogger } from './app.logger';
+import { IProgramOptions } from './interfaces';
+import { CumulativeWritable } from './util/cumulative.stream';
+import { DEFAULT } from './config/default';
+
+export async function grt(options: IProgramOptions) {
+  const app = await NestFactory.createApplicationContext(
+    AppModule.forApi(), 
+    { logger: new AppLogger() }
+  );
+
+  const appService = app.get(AppService);
+  await appService.run({ ...DEFAULT, ...options, json: true });
+  const stream: CumulativeWritable = app.get('STREAM');
+
+  return JSON.parse(stream.getAccumulated());
+}

src/interfaces.ts

@@ -24,7 +24,7 @@ export interface INodeOptions {
 }
 
 export interface IPresenterOptions {
-  json?: number;
+  json?: boolean;
   rawJson?: boolean;
 }
 

src/modules/cli/commander.service.ts

@@ -1,6 +1,7 @@
 import * as yargs from 'yargs';
 import { Injectable } from '@nestjs/common';
-import { IProgramOptions } from '../../interfaces.js';
+import { IProgramOptions } from '../../interfaces';
+import { DEFAULT } from '../../config/default';
 
 @Injectable()
 export class CommanderService {
@@ -31,27 +32,27 @@ export class CommanderService {
       })
       .option('deps', {
         describe: 'disable search in "dependencies" package.json field',
-        default: true,
+        default: DEFAULT.deps,
         type: 'boolean',
       })
       .option('dev-deps', {
         describe: 'disable search in "devDependencies" package.json field',
-        default: true,
+        default: DEFAULT.devDeps,
         type: 'boolean',
       })
       .option('peer-deps', {
         describe: 'disable search in "peerDependencies" package.json field',
-        default: true,
+        default: DEFAULT.peerDeps,
         type: 'boolean',
       })
       .option('yarn-lock', {
         describe: 'disable search in yarn.lock',
-        default: true,
+        default: DEFAULT.yarnLock,
         type: 'boolean',
       })
       .option('package-lock', {
         describe: 'disable search in package-lock.json',
-        default: true,
+        default: DEFAULT.packageLock,
         type: 'boolean',
       })
       .option('node', {
@@ -60,12 +61,12 @@ export class CommanderService {
       })
       .options('nvm', {
         describe: 'disable search in .nvmrc',
-        default: true,
+        default: DEFAULT.nvm,
         type: 'boolean',
       })
       .options('engines', {
         describe: 'disable search in package.json engines',
-        default: true,
+        default: DEFAULT.engines,
         type: 'boolean',
       })
       .option('rate-limit', {
@@ -74,28 +75,28 @@ export class CommanderService {
       })
       .option('skip-empty', {
         describe: 'skip repo, if package/node not found',
-        default: true,
+        default: DEFAULT.skipEmpty,
         type: 'boolean',
       })
       .option('skip-error', {
         describe: 'skip repo, if error with such code occured',
-        default: [404],
+        default: DEFAULT.skipError,
         type: 'array'
       })
       .option('raw-json', {
         describe: 'show output as json without whitespaces',
-        default: false,
+        default: DEFAULT.rawJson,
         type: 'boolean',
       })
       .option('json', {
         describe: 'show output as prettified json',
-        default: false,
+        default: DEFAULT.json,
         type: 'boolean',
       })
       .option('token', {
         alias: 't',
         describe: 'token to auth on github. Env var GITHUB_TOKEN strictly prefered',
-        default: process.env.GITHUB_TOKEN,
+        default: DEFAULT.token,
         type: 'string'
       })
       .group(['user', 'org'], 'Owner:')

src/modules/node-version/node.version.service.ts

@@ -14,9 +14,9 @@ export class NodeVersionService {
   }
 
   public async getReport(options: IProgramOptions): Promise<INodeVersion[]> {
-    const { org, user, nvm, engines } = options;
+    const { org, user, nvm, engines, token } = options;
 
-    const repos = await this.octokitService.getRepos({ org, user });
+    const repos = await this.octokitService.getRepos({ org, user, token });
 
     if (!repos) {
       return null;
@@ -28,8 +28,8 @@ export class NodeVersionService {
       repos.map(async repo => {
         try {
           const [nvmVersion, enginesVersion] = await Promise.all([
-            nvm ? this.getNvmrc(org || user, repo).catch(() => null) : null,
-            engines ? this.getEngines(org || user, repo).catch(() => null) : null
+            nvm ? this.getNvmrc(org || user, repo, token).catch(() => null) : null,
+            engines ? this.getEngines(org || user, repo, token).catch(() => null) : null
           ]);
 
           const data: INodeVersion = { repo };
@@ -54,14 +54,14 @@ export class NodeVersionService {
     return result;
   }
 
-  private async getNvmrc(owner, repo): Promise<string> {
-    const content = await this.octokitService.getFileContent(owner, repo, '.nvmrc');
+  private async getNvmrc(owner, repo, token): Promise<string> {
+    const content = await this.octokitService.getFileContent(owner, repo, '.nvmrc', token);
 
     return content.trim();
   }
 
-  private async getEngines(owner, repo): Promise<string> {
-    const packageJson = await this.octokitService.getPackageJson(owner, repo);
+  private async getEngines(owner, repo, token): Promise<string> {
+    const packageJson = await this.octokitService.getPackageJson(owner, repo, token);
     const engines = packageJson.engines;
 
     if (!engines || !engines.node) {