scanoss 0.7.8 → 0.7.10

package/src/sdk/DataLayer/DataProviders/ComponentDataProvider.ts

@@ -1,195 +0,0 @@
-import {
-  ComponentDataLayer,
-  DataProvider,
-  Health,
-  IDataLayers
-} from '../DataLayerTypes';
-import {
-  ScannerComponent,
-  ScannerResults
-} from '../../scanner/ScannerTypes';
-import { IDependencyResponse } from '../../Dependencies/DependencyTypes';
-
-export class ComponentDataProvider implements DataProvider {
-
-  private scanRawResults: ScannerResults
-
-  private componentList: Array<ScannerComponent>;
-
-  private dependencies: IDependencyResponse;
-
-  constructor(scanRawResults: ScannerResults, dependencies?: IDependencyResponse) {
-    this.scanRawResults=scanRawResults;
-    this.dependencies = dependencies;
-  }
-
-  public getLayerName(): string {
-    return this.constructor.name;
-  }
-
-  public getData(): IDataLayers {
-    const componentLayer = <IDataLayers>{component: null};
-
-    if (!this.scanRawResults && !this.dependencies) return componentLayer;
-
-
-    //Extract all components from scanRawResults, does not matter if there are duplicated
-    //And removes all no match results.
-    this.componentList = Object.values(this.scanRawResults).flat();
-    this.componentList = this.componentList.filter(component => component.id!=='none')
-    const scannerComponentLayer = this.parseComponentsFromScanner(this.componentList);
-    const dependenciesComponentLayer = this.parseComponentsFromDependencies(this.dependencies);
-
-    componentLayer.component =  [...scannerComponentLayer, ...dependenciesComponentLayer].sort(
-      (itemA, itemB) => {
-                  if ( itemA.name < itemB.name) return -1;
-                  else if( itemA.name > itemB.name) return 1;
-                  return 0;
-               });
-
-    if(!componentLayer.component.length) componentLayer.component=null;
-
-    return componentLayer
-
-  }
-
-  private parseComponentsFromDependencies(dependencies: IDependencyResponse): Array<ComponentDataLayer> {
-    const componentLayer: Array<ComponentDataLayer> = [];
-    if (!dependencies) return componentLayer;
-
-    dependencies.filesList.forEach(file => {
-      file.dependenciesList.forEach(dependency => {
-        const newComponent: ComponentDataLayer = <ComponentDataLayer>{};
-        newComponent.key = dependency.purl;
-        newComponent.purls = [dependency.purl];
-        newComponent.name = dependency.component;
-        newComponent.url = null;
-        newComponent.vendor = null;
-        newComponent.health = null;
-        newComponent.versions = [{
-          version: dependency.version,
-          licenses: dependency.licensesList.map(license => license.spdxId),
-          copyrights: null,
-          cryptography: null,
-          quality: null,
-        }];
-
-        const existingComponent = componentLayer.find(component => component.key === newComponent.key);
-        if (existingComponent) {
-          const existingVersion = existingComponent.versions.find(version => version.version === newComponent.versions[0].version);
-          if(!existingVersion) existingComponent.versions.push({
-            version : newComponent.versions[0].version,
-            licenses: newComponent.versions[0].licenses,
-            copyrights: newComponent.versions[0].copyrights,
-            quality: null,
-            cryptography: null,
-          });
-        } else { //Component does not exist, insert as it is.
-          componentLayer.push(newComponent);
-        }
-
-      });
-    });
-    return componentLayer;
-  }
-
-  private parseComponentsFromScanner(scanComponents: Array<ScannerComponent>): Array<ComponentDataLayer> {
-    const componentLayer: Array<ComponentDataLayer> = [];
-    if (!scanComponents) return componentLayer
-
-    for (let i=0 ; i<scanComponents.length ; i++) {
-
-      try {
-
-        // qualityValue would have a number from 0 to 5 or undefined.
-        const qualityValue = Number(scanComponents[i]?.quality?.shift()?.score?.split("/").shift());
-
-
-        //Generates a new component
-        const newComponent: ComponentDataLayer = {
-          key: scanComponents[i].purl[0],
-          purls: scanComponents[i].purl,
-          name: scanComponents[i].component,
-          url: scanComponents[i].url,
-          vendor: scanComponents[i].vendor,
-          health: scanComponents[i].health,
-          versions: [{
-            version: scanComponents[i].version,
-            licenses: scanComponents[i].licenses.map(license => license.name),
-            copyrights: scanComponents[i].copyrights,
-            quality: { sum: 0, scoreAvg: 0, count: 0 },
-            cryptography: scanComponents[i]?.cryptography,
-          }]
-        };
-
-        //Removes duplicated licenses
-        newComponent.versions[0].licenses = [...new Set(newComponent.versions[0].licenses)]
-
-        if(qualityValue) {
-          newComponent.versions[0].quality.count = 1;
-          newComponent.versions[0].quality.sum = qualityValue;
-          newComponent.versions[0].quality.scoreAvg = qualityValue;
-        }
-
-        //Merge new component in componentList
-        const componentTarget = componentLayer.find(component => component.key === newComponent.key);
-        if (componentTarget) {
-          const versionTarget = componentTarget.versions.find(item => item.version === newComponent.versions[0].version);
-          if (versionTarget) {
-
-            //Insert licenses
-            newComponent.versions[0].licenses.forEach(licence => {
-              if (!versionTarget.licenses.includes(licence)) versionTarget.licenses.push(licence);
-            });
-
-            //Insert copyright
-            newComponent.versions[0]?.copyrights?.forEach(newCopyright => {
-              if (versionTarget.copyrights.every(copyright => newCopyright.name != copyright.name)) {
-                versionTarget.copyrights.push(newCopyright);
-              }
-            });
-
-            //Insert cryptography
-            newComponent.versions[0]?.cryptography?.forEach(newCryptoAlgo => {
-              if (versionTarget.cryptography.every(cryptoAlgorithm => cryptoAlgorithm.algorithm != newCryptoAlgo.algorithm)) {
-                versionTarget.cryptography.push(newCryptoAlgo);
-              }
-            });
-
-            //recalculate quality average in case we have a quality value
-            if (qualityValue) {
-              versionTarget.quality.count++;
-              versionTarget.quality.sum += Number(qualityValue);
-              versionTarget.quality.scoreAvg = versionTarget.quality.sum / versionTarget.quality.count
-            }
-
-
-
-          } else {
-            //newComponent version is not included in the component with same purl key
-            componentTarget.versions = componentTarget.versions.concat(newComponent.versions);
-          }
-        } else componentLayer.push(newComponent);
-
-      } catch (e) {
-        console.error(`Problem inserting new component building Component Data Layer - `, e);
-      }
-    }
-
-    //Replace [] for null in versions
-    for (let i=0 ; i<componentLayer.length ; i++) {
-      if(!componentLayer[i].health) componentLayer[i].health = null;
-      componentLayer[i].versions.forEach(version => {
-        if(version.copyrights?.length == 0) version.copyrights = null;
-        if(version.licenses?.length == 0) version.licenses = null;
-        if(version.cryptography?.length === 0) version.cryptography = null;
-        if(version.quality.count === 0 ) version.quality = null;
-      })
-    }
-
-    return componentLayer;
-
-  }
-
-}
-

package/src/sdk/DataLayer/DataProviders/DependencyDataProvider.ts

@@ -1,48 +0,0 @@
-import {
-  DataProvider,
-  IDataLayers,
-  DependencyDataLayer,
-  License, Dependency
-} from '../DataLayerTypes';
-import { IDependencyResponse } from '../../Dependencies/DependencyTypes';
-
-export class DependencyDataProvider implements DataProvider {
-
-  private dependencies: IDependencyResponse;
-
-  constructor(dependencies: IDependencyResponse) {
-    this.dependencies = dependencies;
-  }
-
-  public getLayerName(): string {
-    return this.constructor.name;
-  }
-
-  public getData(): IDataLayers {
-    const dependencyLayer = <IDataLayers>{dependencies: null};
-    if(!this.dependencies) return dependencyLayer;
-    const parsedDepLayer = this.parseDependencyData(this.dependencies);
-    dependencyLayer.dependencies = parsedDepLayer;
-    if (!dependencyLayer.dependencies.length) dependencyLayer.dependencies=null;
-
-    return dependencyLayer;
-  }
-
-  public parseDependencyData(dependencies: IDependencyResponse): DependencyDataLayer[]{
-    const dependencyLayer: Array<DependencyDataLayer> = [];
-
-    dependencies.filesList.forEach(file => {
-      const newDependencies: Array<Dependency> = [];
-      file.dependenciesList.forEach(dependency => {
-        const newLicenses: Array<License> = [];
-        dependency.licensesList.forEach((license) => {
-          newLicenses.push({name: license.name, spdxid: license.spdxId});
-        });
-        newDependencies.push({purl: dependency.purl, licenses: newLicenses, version: dependency.version, component: dependency.component});
-      });
-      dependencyLayer.push({file: file.file, dependencies: newDependencies});
-    });
-
-    return dependencyLayer;
-  }
-}

package/src/sdk/DataLayer/DataProviders/LicenseDataProvider.ts

@@ -1,184 +0,0 @@
-import {
-  DataProvider,
-  IDataLayers,
-  LicenseComponent,
-  LicenseDataLayer
-} from '../DataLayerTypes';
-import {
-  ScannerComponent,
-  ScannerResults
-} from '../../scanner/ScannerTypes';
-import { IDependencyResponse } from '../../Dependencies/DependencyTypes';
-
-export class LicenseDataProvider implements DataProvider {
-
-  private scanResults: ScannerResults
-
-  private componentList: ScannerComponent[];
-
-  private dependencies: IDependencyResponse;
-
-  private licenseStorage: Record<string, LicenseDataLayer>;
-
-  private licenseLayer: Array<LicenseDataLayer>;
-
-  constructor(scanResults: ScannerResults, dependencies?: IDependencyResponse ) {
-    this.scanResults = scanResults;
-    this.dependencies = dependencies;
-
-    //Maps a license name to its own data
-    this.licenseStorage = {};
-    this.licenseLayer = [];
-  }
-
-  public getLayerName(): string {
-    return this.constructor.name;
-  }
-
-  public getData(): IDataLayers {
-
-    this.componentList = Object.values(this.scanResults).flat();
-    this.componentList = this.componentList.filter(component => component.id!=='none')
-
-    if (this.componentList.length >0)
-      this.updateLicenseStorageFromComponentList();
-
-    if (this.dependencies && this.dependencies.filesList.length > 0)
-      this.updateLicenseStorageFromDependencies();
-
-
-    this.licenseLayer = Object.values(this.licenseStorage);
-    if (this.licenseLayer.length > 0)
-      this.updateIncompatibilities();
-
-    this.licenseLayer.sort((itemA, itemB) => {
-      if (itemA.value > itemB.value) return -1
-      else if (itemA.value < itemB.value) return 1
-      return 0;
-    });
-
-    return {licenses: this.licenseLayer} as IDataLayers
-  }
-
-  //Gets all license from the result of scan and stores in this.licenseStorage map
-  private updateLicenseStorageFromComponentList() {
-    this.componentList.forEach(component => {
-      component.licenses.forEach((license) => {
-
-        const newLicenseComponent: LicenseComponent = <LicenseComponent>{};
-        newLicenseComponent.purl = component.purl[0];
-        newLicenseComponent.vendor = component.vendor;
-        newLicenseComponent.versions = [component.version];
-        newLicenseComponent.name = component.component
-        newLicenseComponent.url = component.url;
-
-        const licenseExist = !!this.licenseStorage[license.name];
-        if(!licenseExist){
-          const newLicense: LicenseDataLayer = <LicenseDataLayer>{};
-          newLicense.value = 1;
-          newLicense.label = license.name;
-          newLicense.copyleft = license.copyleft === 'yes' ? true : false;
-          newLicense.hasIncompatibles = [];
-          newLicense.incompatibleWith = license.incompatible_with!== undefined ? license.incompatible_with.split(',').map(il=> il.trim()) : [];
-          newLicense.components = [newLicenseComponent];
-          this.licenseStorage[license.name] = newLicense;
-        } else {
-          this.licenseStorage[license.name] = this.insertComponentIntoLicense(this.licenseStorage[license.name], newLicenseComponent);
-        }
-      });
-    });
-  }
-
-  //Gets all licenses from results of dependency analysis
-  private updateLicenseStorageFromDependencies() {
-    this.dependencies.filesList.forEach(file => {
-      file.dependenciesList.forEach(dependency => {
-        dependency.licensesList.forEach(license => {
-
-
-          const newLicenseComponent = <LicenseComponent>{};
-          newLicenseComponent.purl = dependency.purl;
-          newLicenseComponent.versions = [dependency.version];
-          newLicenseComponent.name = dependency.component;
-          newLicenseComponent.vendor = null;
-          newLicenseComponent.url = null;
-
-          if(license.spdxId !== '') {
-            license.spdxId.split(/;|\//g).forEach(license_name => {
-
-              const licenseExist = !!this.licenseStorage[license_name];
-              if (!licenseExist) {
-                const newLicense: LicenseDataLayer = <LicenseDataLayer>{};
-                newLicense.value = 1;
-                newLicense.label = license_name;
-                newLicense.copyleft = false;
-                newLicense.hasIncompatibles = [];
-                newLicense.incompatibleWith = [];
-                newLicense.components = [newLicenseComponent];
-                this.licenseStorage[license_name] = newLicense;
-              } else {
-                this.licenseStorage[license_name] = this.insertComponentIntoLicense(this.licenseStorage[license_name], newLicenseComponent);
-              }
-            });
-          } else { // Unknown license
-            const licenseExist = !!this.licenseStorage['unknown'];
-            if (!licenseExist) {
-              const newLicense: LicenseDataLayer = <LicenseDataLayer>{};
-              newLicense.value = 1;
-              newLicense.label = 'unknown';
-              newLicense.copyleft = false;
-              newLicense.hasIncompatibles = [];
-              newLicense.incompatibleWith = [];
-              newLicense.components = [newLicenseComponent];
-              this.licenseStorage['unknown'] = newLicense;
-            } else{
-              this.licenseStorage['unknown'] = this.insertComponentIntoLicense(this.licenseStorage['unknown'], newLicenseComponent);
-            }
-          }
-        });
-      });
-    });
-  }
-
-  private updateIncompatibilities() {
-    for (let l = 0; l < this.licenseLayer.length; l += 1) {
-      const license = this.licenseLayer[l];
-      if (license.incompatibleWith !== undefined)
-        for (let i = 0; i < license.incompatibleWith.length; i += 1) {
-          if (this.licenseLayer.some((lic) => lic.label === license.incompatibleWith[i]))
-            license.hasIncompatibles.push(license.incompatibleWith[i]);
-        }
-    }
-  }
-
-
-  private insertComponentIntoLicense(license: LicenseDataLayer, newComponent: LicenseComponent): LicenseDataLayer {
-    const componentIndex = license.components.findIndex((c)=> c.purl === newComponent.purl);
-    if (componentIndex >= 0) {  //if newComponent exist in license
-      const versionExist = !!license.components[componentIndex].versions.find((version)=>version === newComponent.versions[0]);
-      if (!versionExist) {
-        license.components[componentIndex].versions.push(newComponent.versions[0]);
-        license.value++;
-      }
-    } else {
-      license.components.push(newComponent);
-      license.value++;
-    }
-    return license;
-  }
-
-  private unknownLicensesToEnd(){
-    // let unknownLicenses = null;
-    // if(this.licenseMapper['unknown']){
-    //   unknownLicenses =  this.licenseMapper['unknown'];
-    //   delete this.licenseMapper['unknown'];
-    // }
-    //
-    // this.licenses =  Object.values((this.licenseMapper));
-    // if(unknownLicenses){
-    //   this.licenses.push(unknownLicenses);
-    // }
-  }
-
-
-}

package/src/sdk/DataLayer/DataProviders/SummaryDataProvider.ts

@@ -1,47 +0,0 @@
-import { DataProvider, IDataLayers, SummaryDataLayer } from '../DataLayerTypes';
-import {
-  ScannerComponent,
-  ScannerComponentId,
-  ScannerResults
-} from '../../scanner/ScannerTypes';
-
-export class SummaryDataProvider implements DataProvider {
-
-  private scannerResults: ScannerResults;
-
-  private summary: SummaryDataLayer;
-
-  private projectName: string;
-
-  private projectCreateAt: Date;
-
-  constructor(projectName: string, projectCreatedAt: Date, scannerResults: ScannerResults) {
-    this.scannerResults = scannerResults;
-    this.projectName = projectName;
-    this.projectCreateAt = projectCreatedAt
-    this.summary = <SummaryDataLayer>{};
-  }
-
-  public getLayerName(): string {
-    return this.constructor.name;
-  }
-
-  public getData(): IDataLayers {
-    this.summary.projectName = this.projectName;
-    this.summary.timestamp = this.projectCreateAt;
-    this.summary.totalFiles = 0;
-    this.summary.noMatchFiles = 0;
-    this.summary.matchedFiles = 0;
-
-    for (const [file, components] of Object.entries(this.scannerResults)) {
-      components.forEach(component => {
-        if (component.id==ScannerComponentId.NONE) this.summary.noMatchFiles++;
-        else this.summary.matchedFiles++;
-        this.summary.totalFiles++;
-      });
-    }
-
-    return <IDataLayers>{summary: this.summary};
-  }
-
-}

package/src/sdk/Decompress/DecompressionManager.ts

@@ -1,91 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import { Tree } from '../tree/Tree';
-import { DecompressionFilter } from '../tree/Filters/DecompressionFilter';
-import { Decompressor } from './Decompressor/Decompressor';
-import { DecompressZip } from './Decompressor/DecompressZips';
-import { DecompressTgz } from './Decompressor/DecompressTgz';
-
-export class DecompressionManager {
-
-  private decompressorList: Array<Decompressor>
-
-  private decompressionLevel: number;
-
-  private suffix: string;
-
-  private decompressOverride: boolean;  //When true: Decompress files into <zip_name>-<suffix> whether folder exist or not
-                                        //When false: Decompress files into <zip_name>-<suffix>-X where X can be any number until find a free folder name
-
-  constructor(decompressionLevel: number = 1, suffix: string = "-unzipped", decompressOverride: boolean = false) {
-    this.decompressionLevel = decompressionLevel;
-    this.decompressOverride = decompressOverride;
-    this.suffix = suffix;
-    this.decompressorList = [
-      new DecompressTgz(),
-      new DecompressZip()
-    ];
-
-  }
-
-  public addDecompressor(d: Decompressor) {
-    this.decompressorList.push(d);
-  }
-
-  public getSupportedFormats(): Array<string> {
-    const supportedFormats = [];
-    this.decompressorList.forEach((d) => {
-      supportedFormats.push(...d.getSupportedFormats())
-    });
-    return supportedFormats;
-  }
-
-  public async decompress(archivesPaths: Array<string>): Promise<Array<string>> {
-    for (const archivePath of archivesPaths) await this.decompressRecursive(archivePath, 0);
-    const parentFoldersPath = archivesPaths.map(archivePath => `${archivePath}${this.suffix}`);
-    return parentFoldersPath;
-  }
-
-
-  public async decompressRecursive(archivePath: string, level: number): Promise<void> {
-    if(level>=this.decompressionLevel) return
-
-    const archiveRootPath = path.dirname(archivePath);
-    const archiveName = path.basename(archivePath);
-    let newFolderPath = `${archiveRootPath}${path.sep}${archiveName}${this.suffix}`;
-
-    const isSupported = this.decompressorList.some((d) => d.isSupported(archiveName))
-    if(isSupported) {
-
-
-      let i = 0;
-      const r = new RegExp("(?<=" + this.suffix +")-\\d+$")  //Selects last -X where X is a number
-      while( !this.decompressOverride && fs.existsSync(newFolderPath) ) { //Search for a free name
-        newFolderPath = newFolderPath.replace(r, "");
-        newFolderPath += `-${i}`
-        i++;
-      }
-
-      await fs.promises.mkdir(newFolderPath, { recursive: true });
-
-      //Search for decompressor and extract archive
-      for (const d of this.decompressorList) {
-        if (d.isSupported(archiveName)) {
-          await d.run(archivePath, newFolderPath);
-          break;
-        }
-      }
-
-
-      //Search for new archives
-      const tree = new Tree(newFolderPath);
-      tree.build()
-      const newFilesPath = tree.getFileList(new DecompressionFilter(""));
-      for (const newFilePath of newFilesPath) {
-        await this.decompressRecursive(newFilePath, level+1);
-      }
-    }
-
-  }
-
-}

package/src/sdk/Decompress/Decompressor/DecompressTgz.ts

@@ -1,20 +0,0 @@
-import { Decompressor } from './Decompressor';
-import fs from 'fs';
-import tar from 'tar';
-
-export class DecompressTgz extends Decompressor{
-
-  constructor() {
-    super();
-    this.supportedFormats = [
-      ".tar.gz",
-      ".tgz",
-      ".tar",
-    ]
-  }
-
-  public async run(archivePath: string, destPath: string): Promise<void> {
-      return tar.x({C: destPath, file: archivePath});
-  }
-
-}

package/src/sdk/Decompress/Decompressor/DecompressZips.ts

@@ -1,21 +0,0 @@
-import { Decompressor } from './Decompressor';
-import AdmZip from 'adm-zip';
-
-export class DecompressZip extends Decompressor{
-
-  constructor() {
-    super();
-    this.supportedFormats = [
-      ".zip",
-      ".jar",
-      ".ear",
-      ".war"
-    ]
-  }
-
-  public async run(archivePath: string, destPath: string): Promise<void> {
-    const zip = new AdmZip(archivePath);
-    zip.extractAllTo(destPath);
-  }
-
-}

package/src/sdk/Decompress/Decompressor/Decompressor.ts

@@ -1,20 +0,0 @@
-export abstract class Decompressor {
-  protected supportedFormats: Array<string>;
-
-  public abstract async run(archivePath: string, destPath: string): Promise<void>;
-
-  public isSupported(filename: string) {
-    if (this.supportedFormats.some((format) => filename.endsWith(format))) return true;
-    return false;
-  }
-
-
-  /**
-   * Returns the extension supported by this decompressor
-   * Includes the '.' appended
-   */
-  public getSupportedFormats(): Array<string> {
-    return this.supportedFormats;
-  }
-
-}