nongo-driver 2.12.6 → 3.1.0

package/src/atlas-api.ts

@@ -1,16 +1,12 @@
 import deepEqual from 'deep-equal';
 import rp from 'request-promise';
 import Logger from 'wbb-logger';
-import {
-  Analyzer,
-  AtlasParams,
-  AtlasSearchIndex,
-  CreateSearchIndex,
-} from './interface/atlas';
+import {Analyzer, AtlasParams, AtlasSearchIndex, CreateSearchIndex} from './interface/atlas';
 
 const logger = new Logger('atlas-api.ts');
 
 export default class AtlasApi {
+
   private readonly ftsUrl: string;
   private readonly defaultOptions;
 
@@ -38,10 +34,7 @@ export default class AtlasApi {
     });
   }
 
-  public async getSearchIndexes(
-    db: string,
-    collection: string,
-  ): Promise<AtlasSearchIndex[]> {
+  public async getSearchIndexes(db: string, collection: string): Promise<AtlasSearchIndex[]> {
     const url = `${this.ftsUrl}/indexes/${db}/${collection}`;
     return rp({
       ...this.defaultOptions,
@@ -49,11 +42,7 @@ export default class AtlasApi {
     });
   }
 
-  public async createSearchIndex(
-    db: string,
-    collection: string,
-    index: CreateSearchIndex,
-  ): Promise<any> {
+  public async createSearchIndex(db: string, collection: string, index: CreateSearchIndex): Promise<any> {
     this.logIndexChange(db, collection, 'Creating', index.name);
     const url = `${this.ftsUrl}/indexes`;
     return rp({
@@ -68,11 +57,7 @@ export default class AtlasApi {
     });
   }
 
-  public async ensureSearchIndexes(
-    db: string,
-    collection: string,
-    createParams: CreateSearchIndex[],
-  ): Promise<AtlasSearchIndex[]> {
+  public async ensureSearchIndexes(db: string, collection: string, createParams: CreateSearchIndex[]): Promise<AtlasSearchIndex[]> {
     const existingIndexes = await this.getSearchIndexes(db, collection);
     const toRemove = new Map<string, AtlasSearchIndex>();
     existingIndexes.forEach((e) => toRemove.set(e.name, e));
@@ -87,6 +72,7 @@ export default class AtlasApi {
       } else {
         await this.createSearchIndex(db, collection, cParams);
       }
+
     }
 
     for (const index of toRemove.values()) {
@@ -96,12 +82,7 @@ export default class AtlasApi {
     return await this.getSearchIndexes(db, collection);
   }
 
-  public async updateSearchIndex(
-    db: string,
-    collection: string,
-    existingIndex: AtlasSearchIndex,
-    createParams: CreateSearchIndex,
-  ): Promise<any> {
+  public async updateSearchIndex(db: string, collection: string, existingIndex: AtlasSearchIndex, createParams: CreateSearchIndex): Promise<any> {
     if (deepEqual(existingIndex.mappings, createParams.mappings)) {
       return;
     }
@@ -122,11 +103,7 @@ export default class AtlasApi {
     });
   }
 
-  public async deleteSearchIndex(
-    db: string,
-    collection: string,
-    existingIndex: AtlasSearchIndex,
-  ): Promise<any> {
+  public async deleteSearchIndex(db: string, collection: string, existingIndex: AtlasSearchIndex): Promise<any> {
     this.logIndexChange(db, collection, 'Deleting', existingIndex.name);
     const url = `${this.ftsUrl}/indexes/${existingIndex.indexID}`;
     return rp({
@@ -136,14 +113,8 @@ export default class AtlasApi {
     });
   }
 
-  private logIndexChange(
-    db: string,
-    collection: string,
-    action: string,
-    indexName: string,
-  ) {
-    logger.info(
-      `${action} search index "${indexName}" for collection ${db}.${collection}`,
-    );
+  private logIndexChange(db: string, collection: string, action: string, indexName: string) {
+    logger.info(`${action} search index "${indexName}" for collection ${db}.${collection}`);
   }
+
 }

package/src/cursor-iterator.ts

@@ -1,8 +1,6 @@
-import {Cursor} from 'mongodb';
-
 export default class CursorIterator<T = any> implements AsyncIterator<T> {
 
-  constructor(private cursor: Cursor, private map = (next) => next) {
+  constructor(private cursor, private map = (next) => next) {
   }
 
   public [Symbol.asyncIterator] = () => this;

package/src/index.ts

@@ -11,4 +11,4 @@ export {default as generateInterfaces} from './generate-interfaces';
 export {default as NongoMap} from './nongo-map';
 export * from './interface';
 export {default as AtlasApi} from './atlas-api';
-export {ObjectId, MongoClient} from 'mongodb';
+export {ObjectId, MongoClient, SortDirection, CollectionInfo, Db, DeleteResult, FindOptions, Filter, Document, UpdateFilter, UpdateOptions} from 'mongodb';

package/src/interface/index.ts

@@ -4,14 +4,3 @@ export * from './atlas';
  * Defines an object that can be created via the 'new' keyword
  */
 export type Newable<T = any> = new(...args: any[]) => T;
-
-export interface NongoWriteResult {
-  nModified: number;
-  ok: number;
-  n: number;
-}
-
-export interface NongoDeleteResult {
-  ok?: number;
-  n?: number;
-}

package/src/model.ts

@@ -1,17 +1,30 @@
 import clone from 'clone-deep';
-import cmd from 'cmd-promise';
-import {BulkWriteOpResultObject, CollectionBulkWriteOptions, Db, ObjectId} from 'mongodb';
-import Logger from 'wbb-logger';
+import {AggregateOptions, AnyBulkWriteOperation, BulkWriteOptions, BulkWriteResult, CountDocumentsOptions, Db, DeleteOptions, DeleteResult, Document, Filter, FindOptions, ObjectId, UpdateFilter, UpdateOptions, UpdateResult} from 'mongodb';
+import {diff} from 'just-diff';
 
 import CursorIterator from './cursor-iterator';
-import {CreateSearchIndex, NongoDeleteResult, NongoWriteResult} from './interface';
+import {CreateSearchIndex} from './interface';
 import MongoIndex from './mongo-index';
 import Nongo from './nongo';
 import Validator from './validator';
 
-const logger = new Logger('schema-parser.ts');
+const DEFAULT_PATHS = ['_id', 'revision', 'history', 'diffs']
 
-export default abstract class Model<T extends {_id?: ObjectId} = any> {
+function excludePathsFromDiff(diff, excludedPaths = DEFAULT_PATHS) {
+  return diff.filter((d) => {
+    if (!excludedPaths.includes(d.path[0])) {
+      return true;
+    }
+  })
+}
+
+export interface RevisionHistory {
+  id: string;
+  revision: string;
+  created: Date;
+}
+
+export default abstract class Model<T extends {_id?: ObjectId, revision?: string, history?: RevisionHistory[], diffs?: any} = any> {
   // {@code instanceof} can be a bit funny when importing classes across
   // modules so this is an explicit type guard we can use
   public isNongoModel: true = true;
@@ -19,6 +32,7 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
   public db: Db;
   public name: string;
   public dynamic: boolean;
+  private collectionRevision: string | null;
 
   constructor(public nongo: Nongo, public obj: T) {
     // Set this.db if nongo given
@@ -32,11 +46,21 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
     }
 
     this.collection = this.defineCollection();
+    this.collectionRevision = 
+      this.schemaVersioningEnabled() ? `${this.defineCollection()}${Nongo.REVISION}` : null;
     this.name = this.constructor.name;
     this.dynamic = false;
     this.initStructure();
   }
 
+  public getCollectionRevision (): string {
+    return this.collectionRevision;
+  }
+
+  protected schemaVersioningEnabled(): boolean {
+    return false;
+  }
+
   public getMongoIndexes(): MongoIndex[] {
     return [];
   }
@@ -47,18 +71,7 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
 
   public async validate() {
     const schema = this.nongo.schema[this.name];
-    return await new Validator(schema, this).validate();
-  }
-
-  public async dumpCollection(dir: string, gzip = false): Promise<void> {
-    logger.info(`Taking dump of ${this.name}...`);
-
-    const script =
-      `mkdir -p ${dir};` +
-      `mongodump --uri "${this.nongo.uri()}" -c ${this.name} ${gzip ? '--gzip' : ''} --out ${dir};`;
-
-    await cmd(script);
-    logger.info(`Dump written to ${dir}...`);
+    return new Validator(schema, this).validate();
   }
 
   public idString(): string {
@@ -85,11 +98,30 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
       }
     }
 
+    let revisionObj;
+    const revisionObjId = new ObjectId();
+    if (this.collectionRevision) {
+      revisionObj = await this.db.collection(this.collection).findOne({_id: this.obj._id});
+      this.obj.revision = Nongo.revisionNumber(revisionObj?.revision);
+      this.obj.history = Nongo.revisionHistory(revisionObj, revisionObjId);
+
+      // get diffs
+      if (revisionObj) {
+        delete this.obj.diffs;
+        const diffs = diff(revisionObj, this.obj);
+        this.obj.diffs = excludePathsFromDiff(diffs);
+      }
+    }
     // Upsert
-    await this.db
+    const UpsertResult = await this.db
       .collection(this.collection)
       .replaceOne({_id: this.obj._id}, this.obj, {upsert: true});
 
+    if (UpsertResult.modifiedCount === 1 && this.collectionRevision) {
+      revisionObj._id = revisionObjId;
+      await this.db.collection(this.collectionRevision).insertOne(revisionObj);
+    }
+
     // Return the saved model
     return this;
   }
@@ -160,7 +192,24 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
   }
 
   public async byId(id) {
-    return await this.findOne({_id: id});
+    return this.findOne({_id: id});
+  }
+
+  public async getRevisions () {
+    return this.toArray(await this.findIterator({}, {sort: {revision: 'descending'}}, this.collectionRevision));
+  }
+
+  public async getRevision (query: Filter<Document>) {
+    const doc = await this.db.collection(this.collectionRevision).findOne(query);
+
+    // Return null if no doc was found
+    if (doc == null) {
+      return null;
+    }
+
+    // Otherwise return the doc as a model
+    // @ts-ignore
+    return new this.constructor(this.nongo, doc);
   }
 
   /*
@@ -168,7 +217,7 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
    * @param options: the query options e.g. sorting, limiting results etc.
    * @return the results of the query as an array of models.
    */
-  public async find(query: any = {}, options?: any): Promise<this[]> {
+  public async find(query: Filter<Document> = {}, options?: FindOptions<Document>): Promise<this[]> {
     return this.toArray(await this.findIterator(query, options));
   }
 
@@ -177,9 +226,9 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
    * @param options?: CollectionBulkWriteOptions
    */
   public async bulkWrite(
-    operations: object[],
-    options?: CollectionBulkWriteOptions,
-  ): Promise<BulkWriteOpResultObject> {
+    operations: AnyBulkWriteOperation<Document>[],
+    options?: BulkWriteOptions,
+  ): Promise<BulkWriteResult> {
     return this.db.collection(this.collection).bulkWrite(operations, options);
   }
 
@@ -188,12 +237,13 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
    * @param options: the query options e.g. sorting, limiting results etc.
    * @return the results of the query as an {@link AsyncIterator}.
    */
-  public async findIterator(
-    query: any = {},
-    options?: any,
+  public async  findIterator(
+    query: Filter<Document> = {},
+    options?: FindOptions<Document>,
+    collection = this.collection,
   ): Promise<CursorIterator<this>> {
     query = this.prepareQuery(query);
-    const cursor = this.db.collection(this.collection).find(query, options);
+    const cursor = this.db.collection(collection).find(query, options);
     return new CursorIterator<this>(
       cursor,
     // @ts-ignore
@@ -205,7 +255,7 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
    * @param query: A mongo db query.
    * @return the result of the query as a model.
    */
-  public async findOne(query: any = {}): Promise<this> {
+  public async findOne(query: Filter<Document> = {}): Promise<this> {
     query = this.prepareQuery(query);
     const doc = await this.db.collection(this.collection).findOne(query);
 
@@ -219,19 +269,18 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
     return new this.constructor(this.nongo, doc);
   }
 
-  public async remove(query: any): Promise<NongoDeleteResult> {
+  public async remove(query: Filter<Document>, options?: DeleteOptions): Promise<DeleteResult> {
     query = this.prepareQuery(query);
-    const res = await this.db.collection(this.collection).deleteMany(query);
-    return res.result;
+    return this.db.collection(this.collection).deleteMany(query, options);
   }
 
-  public async aggregate(pipeline: any, options?: any): Promise<any[]> {
-    return await this.toArray(await this.aggregateIterator(pipeline, options));
+  public async aggregate(pipeline: Document[], options?: AggregateOptions): Promise<any[]> {
+    return this.toArray(await this.aggregateIterator(pipeline, options));
   }
 
   public async aggregateIterator(
-    pipeline: any,
-    options?: any,
+    pipeline: Document[],
+    options?: AggregateOptions,
   ): Promise<CursorIterator<any>> {
     options = options || {};
     if (options.allowDiskUse == null) {
@@ -244,20 +293,19 @@ export default abstract class Model<T extends {_id?: ObjectId} = any> {
     return new CursorIterator(cursor);
   }
 
-  public async distinct(field: string) {
-    return await this.db.collection(this.collection).distinct(field, {});
+  public async distinct(field: string, filter: Filter<Document> = {}) {
+    return this.db.collection(this.collection).distinct(field, filter);
   }
 
-  public async update(query: any, updates: any): Promise<NongoWriteResult> {
+  public async update(query: Filter<Document>, updates: UpdateFilter<Document>, options?: UpdateOptions): Promise<UpdateResult<Document>> {
     query = this.prepareQuery(query);
-    const res = await this.db
+    return this.db
       .collection(this.collection)
-      .updateMany(query, updates);
-    return res.result;
+      .updateMany(query, updates, options);
   }
 
-  public async count(query = {}): Promise<number> {
-    return await this.db.collection(this.collection).countDocuments(query);
+  public async count(query: Document = {}, options?: CountDocumentsOptions): Promise<number> {
+    return this.db.collection(this.collection).countDocuments(query, options);
   }
 
   /*

package/src/mongo-index.ts

@@ -1,5 +1,3 @@
-import {IndexOptions} from 'mongodb';
-
 /**
  * Very basic model used to hold information on a mongo index.
  */
@@ -13,7 +11,7 @@ export default class MongoIndex {
    * @param options IndexOptions - options for the index these match the options defined here:
    *                       https://mongodb.github.io/node-mongodb-native/api-generated/collection.html#ensureindex
    */
-  constructor(index: {[key: string]: 1 | -1 | 'text'}, public readonly options: IndexOptions = {}, validateName = true) {
+  constructor(index: {[key: string]: 1 | -1 | 'text'}, public readonly options: any = {}, validateName = true) {
     // Delete any keys from options that have an undefined value. We do this to standardise the options so they can
     // easily be compared
     for (const key of Object.keys(options)) {

package/src/nongo.ts

@@ -1,9 +1,10 @@
 import deepEqual from 'deep-equal';
 import {Collection, Db, MongoClient, ObjectId} from 'mongodb';
 import Logger from 'wbb-logger';
+import incVersion from 'semver/functions/inc';
 import AtlasApi from './atlas-api';
 import {Newable} from './interface';
-import Model from './model';
+import Model, { RevisionHistory } from './model';
 import MongoIndex from './mongo-index';
 import MongoIndexSet from './mongo-index-set';
 import NongoParams from './nongo-params';
@@ -28,11 +29,36 @@ export default class Nongo {
     return id;
   }
 
+  public static revisionNumber(revision: string): string {
+    if (!revision) {
+      return '0.0.1';
+    }
+    return incVersion(revision, 'patch');
+  }
+
+  public static revisionHistory(model, revisionId): RevisionHistory[] {
+    if (!model?.history) {
+      return [];
+    } else {
+      // we don't want to mutate the original array
+      const array = [...model.history];
+      array.push(
+        {
+          id: revisionId.toString(),
+          revision: model.revision,
+          created: new Date(),
+        }
+      )
+      return array;
+    }
+  }
+
   public schema: any = {};
   public validKeys: any = {};
   public noStripKeys: any = {};
   public db: Db;
   public dbName: string;
+  public static REVISION = "Revision";
 
   // Parallel to {@code this.modelClasses} and {@code this.schemaParsers}
   private instances: Model[];
@@ -60,11 +86,7 @@ export default class Nongo {
 
   public async connect() {
     // Connect to the database
-    this.mongoClient = this.mongoClient ?? await MongoClient.connect(this.uri(), {
-      useNewUrlParser: true,
-      useUnifiedTopology: true,
-      poolSize: this.poolSize,
-    });
+    this.mongoClient = this.mongoClient ?? await new MongoClient(this.uri(), {minPoolSize: this.poolSize}).connect();
     this.db = this.mongoClient.db(this.params.db);
     this.dbName = this.params.db;
 
@@ -106,6 +128,12 @@ export default class Nongo {
         await this.db.createCollection(collName);
       }
 
+      // Create the revision collection if it doesn't exist
+      const revisionCollName = instance.getCollectionRevision();
+      if (revisionCollName && !collectionNames.includes(revisionCollName)) {
+        await this.db.createCollection(revisionCollName);
+      }
+
       // Add field to {@code this.newGenerator} with a function as a value that can be
       // used to init a new model
       this.newGeneratorMap[instance.name] = (obj) => {

package/src/revision-model.ts

@@ -0,0 +1,22 @@
+import { Model } from ".";
+
+export default abstract class RevisionModel<T = any> extends Model<T> {
+  public defineSchema(): any {
+    return {
+      revision: {
+        type: "string",
+      },
+      history: {
+        type: [{
+          id: {type: "string"},
+          revision: {type: "string"},
+          created: {type: "date"},
+        }]
+      }
+    };
+  }
+
+  public schemaVersioningEnabled(): boolean {
+    return true;
+  }
+}

package/test/database-helper.ts

@@ -2,9 +2,22 @@ import {MongoClient} from 'mongodb';
 import {MongoMemoryServer} from 'mongodb-memory-server';
 import {Newable, NongoParams} from '../src';
 import Nongo from '../src/nongo';
+import Logger from 'wbb-logger';
+
+const logger = new Logger("database-helper.ts");
+
+let mongoMemoryServer: MongoMemoryServer;
+
+const getInMemoryServer = async () => {
+  if (!mongoMemoryServer) {
+    logger.info("Using in memory server.");
+    mongoMemoryServer = await MongoMemoryServer.create();
+  }
+  return mongoMemoryServer;
+};
 
-const mongoMemoryServer = new MongoMemoryServer();
 export default class DatabaseHelper {
+  public static DB_NAME = 'testing';
   public static async getNongoInstance(models: Newable[]): Promise<Nongo> {
     return await new Nongo(
       await DatabaseHelper.getNongoParams(),
@@ -13,27 +26,27 @@ export default class DatabaseHelper {
   }
 
   public static async getNongoParams(): Promise<NongoParams> {
-    return {
-      host: 'localhost',
-      port: await mongoMemoryServer.getPort(),
-      db: await mongoMemoryServer.getDbName(),
-    };
+    logger.info("Fetching in memory server.");
+      const mongod = await getInMemoryServer();
+      return {
+        protocol: null,
+        uri: mongod.getUri(),
+        db: DatabaseHelper.DB_NAME,
+      };
   }
 
   public static async getClient(): Promise<MongoClient> {
-    return MongoClient.connect(await mongoMemoryServer.getUri(), {
-      useNewUrlParser: true,
-      useUnifiedTopology: true,
-    });
+    const mongod = await getInMemoryServer();
+    return MongoClient.connect(await mongod.getUri());
   }
 
-  public static async getDbName(): Promise<string> {
-    return await mongoMemoryServer.getDbName();
+  public static getDbName(): string {
+    return DatabaseHelper.DB_NAME;
   }
 
   public static async drop(): Promise<void> {
     const client = await DatabaseHelper.getClient();
-    const db = client.db(await DatabaseHelper.getDbName());
+    const db = client.db(DatabaseHelper.getDbName());
     await db.dropDatabase();
     await client.close();
   }

package/test/model-versioning.test.ts

@@ -0,0 +1,83 @@
+import Logger from 'wbb-logger';
+import { Nongo } from '../src';
+import DatabaseHelper from './database-helper';
+import DummyModelWithRevisionObj from './models/dummy-model-with-revision-obj';
+import DummyModelWithRevision from './models/dummy-model-with-revision.nongo';
+import DummyModel from './models/dummy-model.nongo';
+
+const logger = new Logger('model-versioning.test.ts');
+
+const models = [DummyModel, DummyModelWithRevision];
+
+let nongo: Nongo;
+
+const print = (model) => {
+  model.forEach((m) => console.log(JSON.stringify(m.obj, null, 2)))
+}
+
+// Catch unhanded promise rejections and log them
+process.on('unhandledRejection', (reason) => {
+  logger.error(reason);
+});
+
+describe('Testing nongo revisioning', () => {
+
+  beforeAll(async () => {
+    nongo = await DatabaseHelper.getNongoInstance(models);
+  })
+
+  afterAll(async () => {
+    // remove everything
+  })
+  
+  it('Should create revision collection on DummyModelWithRevision', async () => {
+    const collections = await nongo.db.collections();
+    const collectionsNames = collections.map(coll => coll.collectionName);
+    expect(collectionsNames.length).toEqual(3);
+    expect(collectionsNames.includes('DummyModelWithRevisionRevision')).toEqual(true)
+    expect(collectionsNames.includes('DummyModelRevision')).toEqual(false)
+  })
+
+  it('Should have revision 0.0.1', async () => {
+    const obj: DummyModelWithRevisionObj = {
+      name: 'John',
+      created: new Date(),
+    };
+    const obj2: DummyModelWithRevisionObj = {
+      name: 'Leo',
+      age: 35,
+      created: new Date(),
+    };
+    const model = await nongo.new(DummyModelWithRevision, obj).save();
+    const model2 = await nongo.new(DummyModelWithRevision, obj2).save();
+    expect(model.obj.revision).toEqual('0.0.1');
+    expect(model2.obj.revision).toEqual('0.0.1');
+  })
+
+  it('Should save revision doc in revision collection', async () => {
+    const model = await nongo.col(DummyModelWithRevision).findOne({name: 'John'})
+    model.obj.age = 30;
+    await model.save();
+    expect(model.obj.revision).toEqual('0.0.2');
+    const revisions = await nongo.col(DummyModelWithRevision).getRevisions();
+    expect(revisions.length).toEqual(1);
+  })
+
+  it('Should save 2 revision docs in revision collection', async () => {
+    const model = await nongo.col(DummyModelWithRevision).findOne({name: 'John'});
+    model.obj.name = 'Nick';
+    await model.save();
+    const revisions = await nongo.col(DummyModelWithRevision).getRevisions();
+    // print(revisions);
+    console.log("MODEKS")
+    expect(revisions.length).toEqual(2);
+    const models = await nongo.col(DummyModelWithRevision).find();
+    // print(models);
+    expect(models.length).toEqual(2);
+  })
+
+  it('Should return revision doc', async () => {
+    const revision = await nongo.col(DummyModelWithRevision).getRevision({name: "John", revision: "0.0.1"});
+    expect(revision.obj.revision).toEqual("0.0.1");
+  })
+})

package/test/models/dummy-model-changed-obj.ts

@@ -0,0 +1,12 @@
+// This file was generated using nongo-driver's TsInterfaceGenerator.
+export default interface DummyModelChangedObj {
+  'name': string;
+  'pets': Array<{
+    'species'?: string;
+    'likes'?: {
+      'food'?: string[];
+      'drink'?: string[];
+    };
+  }>;
+  '_id'?: any;
+}