feat: add limit feature

Author: @jotadeveloper

plugins/memory/README.md

@@ -19,8 +19,8 @@ Complete configuration example:
 ```yaml
 store:
   memory:
-    cache: true
-```    
+    limit: 1000
+```
 
 in `config.yaml`
 
@@ -33,7 +33,7 @@ auth:
     file: ./htpasswd
 store:
   memory:
-    cache: true   
+    limit: 1000
 ```
 
 ## Disclaimer

plugins/memory/src/local-memory.js

@@ -4,23 +4,33 @@ import MemoryHandler from './memory-handler';
 import type { LocalStorage, Logger, Config } from '@verdaccio/types';
 import type { ILocalData } from '@verdaccio/local-storage';
 
+export type ConfigMemory = Config & { limit?: number };
+
+const DEFAULT_LIMIT: number = 1000;
 class LocalMemory implements ILocalData {
   path: string;
+  limit: number;
   logger: Logger;
   data: LocalStorage;
   config: Config;
   locked: boolean;
 
-  constructor(config: Config, logger: Logger) {
+  constructor(config: ConfigMemory, logger: Logger) {
     this.config = config;
+    this.limit = config.limit || DEFAULT_LIMIT;
     this.logger = logger;
     this.data = this._createEmtpyDatabase();
     this.data.secret = config.checkSecretKey(this.data.secret);
   }
 
   add(name: string) {
-    if (this.data.list.indexOf(name) === -1) {
-      this.data.list.push(name);
+    if (this.data.list.length < this.limit) {
+      if (this.data.list.indexOf(name) === -1) {
+        this.data.list.push(name);
+      }
+    } else {
+      this.logger.info({ limit: this.limit }, 'Storage memory has reached limit of @{limit} packages');
+      return new Error('Storage memory has reached limit of limit packages');
     }
   }
 
@@ -40,8 +50,7 @@ class LocalMemory implements ILocalData {
   }
 
   getPackageStorage(packageInfo: string) {
-    // $FlowFixMe
-    return new MemoryHandler(packageInfo, this.data.files, this.logger);
+    return new MemoryHandler(packageInfo, this.logger);
   }
 
   _createEmtpyDatabase(): LocalStorage {

plugins/memory/src/memory-handler.js

@@ -42,13 +42,23 @@ class MemoryHandler implements ILocalPackageManager {
   }
 
   updatePackage(pkgFileName: string, updateHandler: Callback, onWrite: Callback, transformPackage: Function, onEnd: Callback): void {
-    const json = this._getStorage(pkgFileName);
+    let json = this._getStorage(pkgFileName);
+
+    try {
+      json = JSON.parse(json);
+    } catch (err) {
+      return onEnd(err);
+    }
 
     updateHandler(json, err => {
       if (err) {
         return onEnd(err);
       }
-      onWrite(pkgFileName, transformPackage(json), onEnd);
+      try {
+        onWrite(pkgFileName, transformPackage(json), onEnd);
+      } catch (err) {
+        return onEnd(fSError('error on parse', 500));
+      }
     });
   }
 
@@ -81,7 +91,6 @@ class MemoryHandler implements ILocalPackageManager {
     const json = this._getStorage(name);
 
     try {
-      // $FlowFixMe
       cb(typeof json === 'undefined' ? noPackageFoundError() : null, JSON.parse(json));
     } catch (err) {
       cb(fSError('package not found', 404));

plugins/memory/test/memory.spec.js

@@ -1,10 +1,12 @@
 // @flow
 
 import LocalMemory from '../src/index';
-import type { Logger } from '@verdaccio/types';
-import type { ILocalData, IPackageStorage } from '@verdaccio/local-storage';
 import config from './partials/config';
 import pkgExample from './partials/pkg';
+import MemoryHandler from '../src/memory-handler';
+
+import type { Logger } from '@verdaccio/types';
+import type { ILocalData, IPackageStorage } from '@verdaccio/local-storage';
 
 const logger: Logger = {
   error: e => console.warn(e),
@@ -17,47 +19,116 @@ const logger: Logger = {
 };
 
 describe('memory unit test .', () => {
-  test('should create an instance', () => {
-    const localMemory: ILocalData = new LocalMemory(config, logger);
+  describe('LocalMemory', () => {
+    test('should create an LocalMemory instance', () => {
+      const localMemory: ILocalData = new LocalMemory(config, logger);
 
-    expect(localMemory).toBeDefined();
-  });
+      expect(localMemory).toBeDefined();
+    });
 
-  test('should save a package', done => {
-    const localMemory: ILocalData = new LocalMemory(config, logger);
+    test('should create add a package', () => {
+      const localMemory: ILocalData = new LocalMemory(config, logger);
+      localMemory.add('test');
 
-    const handler = localMemory.getPackageStorage('test');
-    expect(handler).toBeDefined();
+      expect(localMemory.get()).toHaveLength(1);
+    });
 
-    if (handler) {
-      handler.savePackage('test', pkgExample, err => {
-        expect(err).toBeNull();
-        handler.readPackage('test', (err, data) => {
-          expect(err).toBeNull();
-          expect(data).toEqual(pkgExample);
-          done();
-        });
-      });
-    }
+    test('should reach max limit', () => {
+      config.limit = 2;
+      const localMemory: ILocalData = new LocalMemory(config, logger);
+      expect(localMemory.add('test1')).toBeUndefined();
+      expect(localMemory.add('test2')).toBeUndefined();
+      expect(localMemory.add('test3')).not.toBeNull();
+    });
+
+    test('should remove a package', () => {
+      const localMemory: ILocalData = new LocalMemory(config, logger);
+      localMemory.add('test');
+      localMemory.remove('test');
+
+      expect(localMemory.get()).toHaveLength(0);
+    });
   });
 
-  test('should delete a package', done => {
-    const localMemory: ILocalData = new LocalMemory(config, logger);
+  describe('MemoryHandler', () => {
+    test('should create an MemoryHandler instance', () => {
+      const memoryHandler: ILocalPackageManager = new MemoryHandler('test', pkgExample, logger);
+
+      expect(memoryHandler).toBeDefined();
+    });
+
+    test('should save a package', done => {
+      const localMemory: ILocalData = new LocalMemory(config, logger);
 
-    const handler: IPackageStorage = localMemory.getPackageStorage('test2');
-    expect(handler).toBeDefined();
-    if (handler) {
-      handler.createPackage('test2', pkgExample, err => {
-        expect(err).toBeNull();
-        handler.deletePackage('test2', (err, data) => {
+      const handler = localMemory.getPackageStorage('test');
+      expect(handler).toBeDefined();
+
+      if (handler) {
+        handler.savePackage('test', pkgExample, err => {
           expect(err).toBeNull();
           handler.readPackage('test', (err, data) => {
-            expect(err).not.toBeNull();
-            expect(err.message).toMatch(/package not found/);
+            expect(err).toBeNull();
+            expect(data).toEqual(pkgExample);
             done();
           });
         });
-      });
-    }
+      }
+    });
+
+    test('should update a package', done => {
+      const localMemory: ILocalData = new LocalMemory(config, logger);
+
+      const handler = localMemory.getPackageStorage('test');
+      expect(handler).toBeDefined();
+      const onEnd = jest.fn();
+
+      if (handler) {
+        handler.savePackage('test', pkgExample, err => {
+          expect(err).toBeNull();
+
+          handler.updatePackage(
+            'test',
+            (json, callback) => {
+              expect(json).toBeDefined();
+              expect(json.name).toBe(pkgExample.name);
+              expect(callback).toBeDefined();
+              callback();
+            },
+            (name, data, onEnd) => {
+              expect(name).toBe('test');
+              expect(data.name).toBe(pkgExample.name);
+              onEnd();
+              expect(onEnd).toBeCalled();
+              done();
+            },
+            data => {
+              expect(data).toBeDefined();
+              return data;
+            },
+            onEnd
+          );
+        });
+      }
+    });
+
+    test('should delete a package', done => {
+      const localMemory: ILocalData = new LocalMemory(config, logger);
+
+      const handler: IPackageStorage = localMemory.getPackageStorage('test2');
+      expect(handler).toBeDefined();
+      if (handler) {
+        handler.createPackage('test2', pkgExample, err => {
+          expect(err).toBeNull();
+          handler.deletePackage('test2', (err, data) => {
+            expect(err).toBeNull();
+            handler.readPackage('test', (err, data) => {
+              expect(err).not.toBeNull();
+              expect(err.message).toMatch(/package not found/);
+              done();
+            });
+          });
+        });
+      }
+    });
   });
 });

plugins/memory/test/partials/config.js

@@ -1,8 +1,8 @@
 // @flow
 
-import type { Config } from '@verdaccio/types';
+import type { ConfigMemory } from '../../src/local-memory';
 
-const config: Config = {
+const config: ConfigMemory = {
   user_agent: 'string',
   server_id: 1234,
   storage: './home',