Added index stored + getIndices to retrieve all indexed classes

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## [Unreleased]
 
+- Added index stored + getIndices to retrieve all indexed classes
 
 ## [1.1.0] 2018-04-30
 

README.md

@@ -182,7 +182,7 @@ Extended options provided by IConfigOptions:
 |     Name    |                                                    Type                                                   | Optional | Description                     |
 |:-----------:|:---------------------------------------------------------------------------------------------------------:|:--------:|---------------------------------|
 | client      | [elasticsearch.Client](https://github.com/elastic/elasticsearch-js/blob/14.x/docs/configuration.asciidoc) |     X    | Official client instance to use |
-| indexPrefix |                                                   string                                                  |     X    | Prefix to set to all indexes    |
+| indexPrefix |                                                   string                                                  |     X    | Prefix to set to all indices    |
 
 #### Core functions
 
@@ -193,6 +193,7 @@ The main class provides the main part of the [document API](https://www.elastic.
 - create: Add a new document to the index [create api](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html#api-create))
 - delete: Delete a document from the index [delete api](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html#api-delete))
 - get: Retrieve a document by its id [get api](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html#api-get))
+- getIndices: Return all Indexed classes
 - index: Add or update a document in the index [index api](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html#api-index))
 - search: Search documents in the index [search api](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html#api-search))
 - update: Update a document [update api](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html#api-update))

src/decorators/index.decorator.test.ts

@@ -1,4 +1,5 @@
 import { DECORATORS } from '../constants';
+import { IndexStore } from '../lib/index-store';
 import { Index } from './index.decorator';
 
 describe('pathOrOptions as string', () => {
@@ -101,11 +102,28 @@ describe('only options object', () => {
   });
 });
 
-describe('requires index', () => {
+describe('@index', () => {
   it('throw if index is missing', () => {
     expect(() => {
       @Index('/type')
       class Tweet {}
     }).toThrow('Index undefined');
   });
+
+  it('store the class in the IndexStore', () => {
+    const spy = jest.spyOn(IndexStore, 'add');
+
+    const define = () => {
+      @Index()
+      class Tweet {}
+      return Tweet;
+    };
+
+    const cls = define();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith(cls);
+
+    spy.mockRestore();
+  });
 });

src/decorators/index.decorator.ts

@@ -1,4 +1,6 @@
 import { DECORATORS } from '../constants';
+import { IndexStore } from '../lib/index-store';
+import { AnyClass } from '../types';
 
 export interface IIndexOptions {
   index?: string;
@@ -9,14 +11,14 @@ export interface IIndexOptions {
 /**
  * Index decorator factory
  */
-export function Index(pathOrOptions?: IIndexOptions): any;
-export function Index(pathOrOptions: string, indexOptions?: IIndexOptions): any;
-export function Index(pathOrOptions?: string | IIndexOptions, indexOptions?: IIndexOptions): any {
+export function Index(pathOrOptions?: IIndexOptions): <T extends AnyClass>(target: T) => T;
+export function Index(pathOrOptions: string, indexOptions?: IIndexOptions): <T extends AnyClass>(target: T) => T;
+export function Index(pathOrOptions?: string | IIndexOptions, indexOptions?: IIndexOptions): <T extends AnyClass>(target: T) => T {
   /**
    * Index decorator
    * Store class description into class metadata using DECORATORS.INDEX key
    */
-  return <T extends new (...args: any[]) => any>(target: T): T => {
+  return <T extends AnyClass>(target: T): T => {
     const options: IIndexOptions = (pathOrOptions && typeof pathOrOptions === 'object' ? pathOrOptions : indexOptions) || {};
     const name: string = (typeof pathOrOptions === 'string' ? pathOrOptions : options.index) || target.name;
     const parts = name.split('/');
@@ -27,6 +29,7 @@ export function Index(pathOrOptions?: string | IIndexOptions, indexOptions?: IIn
       throw new Error('Index undefined');
     }
     Reflect.defineMetadata(DECORATORS.INDEX, { ...meta, index: index.toLowerCase(), type: type.toLowerCase(), settings: options.settings }, target);
+    IndexStore.add(target);
     return target;
   };
 }

src/lib/core.test.ts

@@ -4,6 +4,7 @@ import Mock = jest.Mock;
 
 import { Field, Index, Primary } from '../';
 import { BULK_ITEMS_COUNT_MAX, Core, ICoreOptions } from './core';
+import { IndexStore } from './index-store';
 import { deepFreeze } from './testing-tools.test';
 
 import * as tools from './tools';
@@ -300,6 +301,19 @@ describe('get', () => {
   });
 });
 
+describe('getIndices', () => {
+  it('return stored indices', () => {
+    const indices: any = [{}, {}];
+    const spy = jest.spyOn(IndexStore, 'getAll');
+    spy.mockReturnValue(indices);
+
+    expect(core.getIndices()).toBe(indices);
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    spy.mockRestore();
+  });
+});
+
 describe('index', () => {
   beforeEach(() => (client.index = jest.fn()));
 

src/lib/core.ts

@@ -1,7 +1,9 @@
 import { Client, CountParams, CountResponse, GetParams, GetResponse, ScrollParams, SearchParams, SearchResponse } from 'elasticsearch';
 import { Readable } from 'stream';
-import { Indexed, IndexedClass } from '../types';
+
+import { AnyClass, Indexed, IndexedClass } from '../types';
 import { ArrayStream } from './array-stream';
+import { IndexStore } from './index-store';
 import { getIndexMetadata } from './metadata-handler';
 import { buildBulkQuery, getQueryStructure, instantiateResult } from './tools';
 
@@ -156,6 +158,13 @@ export class Core {
     return { response, document };
   }
 
+  /**
+   * Return all Indexed classes
+   */
+  getIndices(): AnyClass[] {
+    return IndexStore.getAll();
+  }
+
   /**
    * Index a document or a literal
    * When not providing an id, ES will generate it

src/lib/index-store.test.ts

@@ -0,0 +1,62 @@
+import { IndexStore } from './index-store';
+
+class User {}
+
+class Twitter {}
+
+const store = (IndexStore as any).store;
+
+beforeEach(() => {
+  // flush internal store
+  store.length = 0;
+});
+
+describe('add', () => {
+  it('stores classes', () => {
+    IndexStore.add(User);
+    IndexStore.add(Twitter);
+    expect(store).toEqual([User, Twitter]);
+  });
+
+  it('throw if push a non function', () => {
+    expect.assertions(1);
+    try {
+      IndexStore.add(new User() as any);
+    } catch (err) {
+      expect(err).toEqual(new Error('Function expected'));
+    }
+  });
+});
+
+describe('flush', () => {
+  beforeEach(() => {
+    store.push(User, Twitter);
+  });
+
+  it('empty internal store', () => {
+    IndexStore.flush();
+    expect(store).toEqual([]);
+  });
+
+  it('does not change store reference', () => {
+    IndexStore.flush();
+    expect(store).toBe((IndexStore as any).store);
+  });
+});
+
+describe('getAll', () => {
+  beforeEach(() => {
+    store.push(User, Twitter);
+  });
+
+  it('returns store content', () => {
+    expect(IndexStore.getAll()).toEqual([User, Twitter]);
+  });
+
+  it('isolate internal array from the one returned', () => {
+    const copy1 = IndexStore.getAll();
+    const copy2 = IndexStore.getAll();
+    expect(copy1).toEqual(copy2);
+    expect(copy1).not.toBe(copy2);
+  });
+});

src/lib/index-store.ts

@@ -0,0 +1,20 @@
+import { AnyClass, IndexedClass } from '../types';
+
+export class IndexStore {
+  private static store: AnyClass[] = [];
+
+  public static add<T>(cls: IndexedClass<T>) {
+    if (typeof cls !== 'function') {
+      throw new Error('Function expected');
+    }
+    IndexStore.store.push(cls);
+  }
+
+  public static flush(): void {
+    IndexStore.store.length = 0;
+  }
+
+  public static getAll(): AnyClass[] {
+    return IndexStore.store.slice();
+  }
+}

src/types.ts

@@ -13,3 +13,5 @@ export type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
 export type Indexed<T> = Omit<T, 'index' | 'type'>;
 
 export type IndexedClass<T> = new (...args: any[]) => T;
+
+export type AnyClass = new (...args: any[]) => any;