fix(core): update

ts/smartnpm.classes.npmpackage.ts

@@ -1,13 +1,35 @@
 import * as plugins from './smartnpm.plugins';
 import { NpmRegistry } from './smartnpm.classes.npmregistry';
+import { PackageDisttag } from './smartnpm.classes.packagedisttag';
+import { PackageVersion, IVersionData } from './smartnpm.classes.packageversion';
 
 export class NpmPackage {
-  public static async createFromFullMetadata(
+  public static async createFromFullMetadataAndVersionData(
     npmRegistryArg: NpmRegistry,
-    fullMetadata: plugins.packageJson.FullMetadata
+    fullMetadataArg: plugins.packageJson.FullMetadata,
+    versionsDataArg: {
+      name: string;
+      'dist-tags': { [key: string]: string };
+      versions: { [key: string]: IVersionData };
+    }
   ) {
     const npmPackage = new NpmPackage(npmRegistryArg);
-    Object.assign(npmPackage, fullMetadata);
+    Object.assign(npmPackage, fullMetadataArg);
+    npmPackage.allVersions = [];
+    npmPackage.allDistTags = [];
+    for (const versionArg of Object.keys(versionsDataArg.versions)) {
+      const packageVersion = PackageVersion.createFromVersionData(
+        versionsDataArg.versions[versionArg]
+      );
+      npmPackage.allVersions.push(packageVersion);
+    }
+    for (const distTagArg of Object.keys(versionsDataArg['dist-tags'])) {
+      const packageDistTag = new PackageDisttag(
+        distTagArg,
+        versionsDataArg['dist-tags'][distTagArg]
+      );
+      npmPackage.allDistTags.push(packageDistTag);
+    }
     return npmPackage;
   }
 
@@ -15,6 +37,8 @@ export class NpmPackage {
   public name: string = null;
   public scope: string = null;
   public version: string = null;
+  public allVersions: PackageVersion[];
+  public allDistTags: PackageDisttag[];
   public description: string = null;
   public keywords: string[] = null;
   public date: string;
@@ -62,23 +86,54 @@ export class NpmPackage {
   }
 
   /**
-   * saves the package to memory
+   * saves the complete package to cache
    */
-  public async saveToMemory() {}
+  public async saveToCache() {}
 
   /**
    * get file from package
    */
-  public async getFileFromPackage(filePath: string): Promise<plugins.smartfile.Smartfile> {
+  public async getFileFromPackage(
+    filePath: string,
+    optionsArg?: {
+      distTag?: string;
+      version?: string;
+    }
+  ): Promise<plugins.smartfile.Smartfile> {
     const done = plugins.smartpromise.defer<plugins.smartfile.Smartfile>();
     const smartarchiveInstance = new plugins.smartarchive.SmartArchive();
-    const fileObservable = await smartarchiveInstance.extractArchiveFromUrlToObservable(
-      this.dist.tarball
-    );
+    let tarballUrl = this.dist.tarball;
+    if (optionsArg && (optionsArg.version || optionsArg.distTag)) {
+      if (optionsArg.distTag && optionsArg.version) {
+        throw new Error('Please either sepcify version OR disttag, not both.');
+      }
+      let targetVersion: plugins.smartversion.SmartVersion;
+      if (optionsArg.distTag) {
+        const targetDistTag = this.allDistTags.find((distTag) => {
+          return distTag.name === optionsArg.distTag;
+        });
+        if (targetDistTag) {
+          targetVersion = new plugins.smartversion.SmartVersion(targetDistTag.targetVersion);
+        }
+      } else {
+        const smartversion = plugins.smartversion.SmartVersion.fromFuzzyString(optionsArg.version);
+      }
+
+      // lets find the best matching release
+      const versionStrings = this.allVersions.map((packageVersion) => packageVersion.version);
+      const bestMatchingVersion = targetVersion.getBestMatch(versionStrings);
+      tarballUrl = this.allVersions.find(
+        (packageVersion) => packageVersion.version === bestMatchingVersion
+      ).dist.tarball;
+    }
+    const fileObservable = await smartarchiveInstance.extractArchiveFromUrlToObservable(tarballUrl);
     const wantedFilePath = plugins.path.join('package', filePath);
     const subscription = fileObservable.subscribe(
       (fileArg) => {
         if (fileArg.path === wantedFilePath) {
+          // lets care about caching
+
+          // lets resolve with the wanted file
           done.resolve(fileArg);
           subscription.unsubscribe();
         }
@@ -92,4 +147,9 @@ export class NpmPackage {
     );
     return done.promise;
   }
+
+  /**
+   * updates the package with information from the registry
+   */
+  update() {}
 }

ts/smartnpm.classes.npmregistry.ts

@@ -6,6 +6,7 @@ import { ISearchObject } from './smartnpm.interfaces';
 
 // classes
 import { NpmPackage } from './smartnpm.classes.npmpackage';
+import { RegistryCache } from './smartnpm.classes.registrycache';
 
 export interface INpmRegistryConstructorOptions {
   npmRegistryUrl?: string;
@@ -13,6 +14,7 @@ export interface INpmRegistryConstructorOptions {
 
 export class NpmRegistry {
   public options: INpmRegistryConstructorOptions;
+  public registryCache: RegistryCache;
   private searchDomain = 'https://api.npms.io/v2/search?q=';
 
   constructor(optionsArg: INpmRegistryConstructorOptions = {}) {
@@ -23,6 +25,7 @@ export class NpmRegistry {
       ...defaultOptions,
       ...optionsArg,
     };
+    this.registryCache = new RegistryCache(this);
   }
 
   /**
@@ -34,7 +37,11 @@ export class NpmRegistry {
       registryUrl: this.options.npmRegistryUrl,
       fullMetadata: true,
     });
-    const npmPackage = await NpmPackage.createFromFullMetadata(this, fullMetadata);
+    const versionData = await plugins.packageJson(packageName, {
+      registryUrl: this.options.npmRegistryUrl,
+      allVersions: true
+    });
+    const npmPackage = await NpmPackage.createFromFullMetadataAndVersionData(this, fullMetadata, versionData as any);
     return npmPackage;
   }
 
@@ -52,12 +59,26 @@ export class NpmRegistry {
   /**
    * gets a file from a package as Smartfile
    */
-  public async getFileFromPackage(packageNameArg: string, filePath: string): Promise<plugins.smartfile.Smartfile> {
-    const npmPackage = await this.getPackageInfo(packageNameArg);
-    return npmPackage.getFileFromPackage(filePath);
+  public async getFileFromPackage(packageNameArg: string, filePath: string, optionsArg?: {
+    distTag?: string;
+    version?: string;
+  }): Promise<plugins.smartfile.Smartfile> {
+    const fileId = `${this.options.npmRegistryUrl}//+//${packageNameArg}//+//${filePath}//+//${optionsArg?.distTag || optionsArg?.version}`;
+    const cachedFile: plugins.smartfile.Smartfile = await this.registryCache.getCachedFile(fileId);
+    if (!cachedFile) {
+      const npmPackage = await this.getPackageInfo(packageNameArg);
+      const fileResult = await npmPackage.getFileFromPackage(filePath, optionsArg);
+      this.registryCache.cacheSmartFile(fileId, fileResult);
+      return fileResult;
+    } else {
+      return cachedFile;
+    }
   }
 
   public async getPackageAsSmartfileVirtualDir(packageNameArg: string): Promise<plugins.smartfile.VirtualDirectory> {
+    /**
+     * TODO: rewrite as memory only
+     */
     const baseDir = plugins.path.join(paths.nogitDir, packageNameArg.replace('/', '__'));
     await plugins.smartfile.fs.ensureDir(baseDir);
     await this.savePackageToDisk(packageNameArg, baseDir);

ts/smartnpm.classes.packagedisttag.ts

@@ -0,0 +1,11 @@
+import * as plugins from './smartnpm.plugins';
+
+export class PackageDisttag {
+  name: string;
+  targetVersion: string;
+
+  constructor(nameArg: string, targetVersionArg: string) {
+    this.name = nameArg;
+    this.targetVersion = targetVersionArg;
+  }
+}

ts/smartnpm.classes.packageversion.ts

@@ -0,0 +1,31 @@
+import * as plugins from './smartnpm.plugins';
+
+export interface IVersionData {
+  name: string;
+  version: string;
+  dependencies: { [key: string]: string };
+  devDependencies: { [key: string]: string };
+  dist: {
+    integrity: string;
+    shasum: string;
+    tarball: string;
+  };
+}
+
+export class PackageVersion implements IVersionData {
+  public static createFromVersionData(versionDataArg: IVersionData) {
+    const packageVersion = new PackageVersion();
+    Object.assign(packageVersion, versionDataArg);
+    return packageVersion;
+  }
+
+  name: string;
+  version: string;
+  dependencies: { [key: string]: string };
+  devDependencies: { [key: string]: string };
+  dist: {
+    integrity: string;
+    shasum: string;
+    tarball: string;
+  };
+}

ts/smartnpm.classes.registrycache.ts

@@ -0,0 +1,30 @@
+import { NpmRegistry } from './smartnpm.classes.npmregistry';
+import * as plugins from './smartnpm.plugins';
+
+export class RegistryCache {
+  npmregistryRef: NpmRegistry;
+  public levelCache: plugins.levelcache.LevelCache;
+
+  constructor(npmRegistryRefArg: NpmRegistry) {
+    this.npmregistryRef = npmRegistryRefArg;
+    this.levelCache = new plugins.levelcache.LevelCache({
+      cacheId: encodeURIComponent(this.npmregistryRef.options.npmRegistryUrl),
+      
+    });
+  }
+
+  public async getCachedFile (fileId: string): Promise<plugins.smartfile.Smartfile> {
+    const cacheEntry = await this.levelCache.retrieveCacheEntryByKey(fileId);
+    if (cacheEntry) {
+      return plugins.smartfile.Smartfile.fromFoldedJson(cacheEntry.contents.toString());
+    }
+    return null;
+  }
+
+  public async cacheSmartFile (fileIdArg: string, smartfileArg: plugins.smartfile.Smartfile) {
+    await this.levelCache.storeCacheEntryByKey(fileIdArg, new plugins.levelcache.CacheEntry({
+      contents: Buffer.from(smartfileArg.foldToJson()),
+      ttl: 60000
+    }));
+  }
+}

ts/smartnpm.plugins.ts

@@ -5,12 +5,14 @@ export { path };
 
 // @pushrocks scope
 import * as consolecolor from '@pushrocks/consolecolor';
+import * as levelcache from '@pushrocks/levelcache';
 import * as smartarchive from '@pushrocks/smartarchive';
 import * as smartfile from '@pushrocks/smartfile';
 import * as smartpromise from '@pushrocks/smartpromise';
 import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartversion from '@pushrocks/smartversion';
 
-export { consolecolor, smartarchive, smartfile, smartpromise, smartrequest };
+export { consolecolor, levelcache, smartarchive, smartfile, smartpromise, smartrequest, smartversion };
 
 // third party scope
 import packageJson from 'package-json';