nongo-driver 3.3.5 → 3.3.7

package/src/model.ts

@@ -1,5 +1,21 @@
 import clone from 'clone-deep';
-import {AggregateOptions, AnyBulkWriteOperation, BulkWriteOptions, BulkWriteResult, CountDocumentsOptions, Db, DeleteOptions, DeleteResult, Document, Filter, FindOptions, ObjectId, UpdateFilter, UpdateOptions, UpdateResult} from 'mongodb';
+import {
+  AggregateOptions,
+  AnyBulkWriteOperation,
+  BulkWriteOptions,
+  BulkWriteResult,
+  CountDocumentsOptions,
+  Db,
+  DeleteOptions,
+  DeleteResult,
+  Document,
+  Filter,
+  FindOptions,
+  ObjectId,
+  UpdateFilter,
+  UpdateOptions,
+  UpdateResult,
+} from 'mongodb';
 import {diff} from 'just-diff';
 import semverGt from 'semver/functions/gt';
 import incVersion from 'semver/functions/inc';
@@ -10,14 +26,14 @@ import MongoIndex from './mongo-index';
 import Nongo from './nongo';
 import Validator from './validator';
 
-const DEFAULT_PATHS = ['_id', 'revision', 'history', 'diffs']
+const DEFAULT_PATHS = ['_id', 'revision', 'history', 'diffs'];
 
 function excludePathsFromDiff(diff, excludedPaths = DEFAULT_PATHS) {
   return diff.filter((d) => {
     if (!excludedPaths.includes(d.path[0])) {
       return true;
     }
-  })
+  });
 }
 
 export interface RevisionHistory {
@@ -26,7 +42,18 @@ export interface RevisionHistory {
   created?: Date;
 }
 
-export default abstract class Model<T extends {_id?: ObjectId, revision?: string, history?: RevisionHistory[], diffs?: any, name?: string, environment?: string, deleted?:true} = any> {
+export default abstract class Model<
+  T extends {
+    _id?: ObjectId;
+    revision?: string;
+    history?: RevisionHistory[];
+    diffs?: any;
+    name?: string;
+    key?: string;
+    environment?: string;
+    deleted?: true;
+  } = 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;
@@ -50,15 +77,19 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
 
     this.collection = this.defineCollection();
     this.collectionRevision = // e.g. BlockRevision
-      this.schemaVersioningEnabled() ? `${this.defineCollection()}${Nongo.REVISION}` : null;
+      this.schemaVersioningEnabled()
+        ? `${this.defineCollection()}${Nongo.REVISION}`
+        : null;
     this.collectionEnvironmentMapping = // e.g. BlockEnvironmentMapping
-      this.schemaVersioningEnabled() ? `${this.defineCollection()}${Nongo.ENVIRONMENT_MAPPING}` : null;
+      this.schemaVersioningEnabled()
+        ? `${this.defineCollection()}${Nongo.ENVIRONMENT_MAPPING}`
+        : null;
     this.name = this.constructor.name;
     this.dynamic = false;
     this.initStructure();
   }
 
-  public getCollectionRevision (): string {
+  public getCollectionRevision(): string {
     return this.collectionRevision;
   }
 
@@ -84,17 +115,22 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
   }
 
   private async getLatestRevisionNumber(name: string): Promise<string> {
-    const liveObj = await this.db.collection(this.collection).findOne({name}, {sort:{revision: -1}});
-    const revObj = await this.db.collection(this.collectionRevision).findOne({name}, {sort:{revision: -1}});
-    let version = "0.0.1";
+    const query = this.collection === 'FormModel' ? {key: name} : {name};
+    const liveObj = await this.db
+      .collection(this.collection)
+      .findOne(query, {sort: {revision: -1}});
+    const revObj = await this.db
+      .collection(this.collectionRevision)
+      .findOne(query, {sort: {revision: -1}});
+    let version = '0.0.1';
     if (liveObj && revObj) {
-      semverGt(liveObj.revision, revObj.revision) ? 
-        version = incVersion(liveObj.revision, 'patch') :
-        version = incVersion(revObj.revision, 'patch');
+      semverGt(liveObj.revision, revObj.revision)
+        ? (version = incVersion(liveObj.revision, 'patch'))
+        : (version = incVersion(revObj.revision, 'patch'));
     } else if (liveObj) {
-      version = incVersion(liveObj.revision, 'patch')
+      version = incVersion(liveObj.revision, 'patch');
     } else if (revObj) {
-      version = incVersion(revObj.revision, 'patch')
+      version = incVersion(revObj.revision, 'patch');
     }
     return version;
   }
@@ -118,51 +154,72 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
         this.throwValidationError(err);
       }
     }
-    
+
     if (this.collectionRevision) {
-      const query = ObjectId.isValid(this.obj.environment) ? {_id: new ObjectId(this.obj.environment)} : {isLive:true}
+      const query = ObjectId.isValid(this.obj.environment)
+        ? {_id: new ObjectId(this.obj.environment)}
+        : {isLive: true};
       const clientEnv = await this.db.collection('Environment').findOne(query);
       const environmentId = clientEnv._id.toHexString();
 
-      const {name} = this.obj;
-      this.obj.revision = await this.getLatestRevisionNumber(name);
+      const {name, key} = this.obj;
+      this.obj.revision = await this.getLatestRevisionNumber(name || key);
 
       if (clientEnv.isLive) {
         const revisionObjId = new ObjectId();
-        const liveRevisionObject = await this.db.collection(this.collection).findOne({_id: this.obj._id});
-        this.obj.history = Nongo.revisionHistory(liveRevisionObject, revisionObjId);
+        const liveRevisionObject = await this.db
+          .collection(this.collection)
+          .findOne({_id: this.obj._id});
+        this.obj.history = Nongo.revisionHistory(
+          liveRevisionObject,
+          revisionObjId,
+        );
         await this.db
           .collection(this.collection)
           .replaceOne({_id: this.obj._id}, this.obj, {upsert: true});
         if (liveRevisionObject) {
           liveRevisionObject._id = revisionObjId;
-          await this.db.collection(this.collectionRevision).insertOne(liveRevisionObject);
+          await this.db
+            .collection(this.collectionRevision)
+            .insertOne(liveRevisionObject);
         }
       } else {
-        const revisionObj = await this.db.collection(this.collectionRevision).findOne({_id: this.obj._id});
-        
+        const revisionObj = await this.db
+          .collection(this.collectionRevision)
+          .findOne({_id: this.obj._id});
+
         this.obj.history = Nongo.revisionHistory(revisionObj, this.idString());
         this.obj._id = new ObjectId();
-        const r = await this.db.collection(this.collectionRevision).insertOne(this.obj);
-        if (this.obj.revision !== "0.0.1") {
+        const r = await this.db
+          .collection(this.collectionRevision)
+          .insertOne(this.obj);
+        if (this.obj.revision !== '0.0.1') {
           // update relevant mappings
           const revisionId = revisionObj._id.toHexString();
           const insertedId = r.insertedId.toHexString();
-          await this.updateEnvironmentMapping(revisionId, insertedId, environmentId);
-          await this.updateIntentEntityBlockMapping(revisionId, insertedId, environmentId);
+          await this.updateEnvironmentMapping(
+            revisionId,
+            insertedId,
+            environmentId,
+          );
+          await this.updateIntentEntityBlockMapping(
+            revisionId,
+            insertedId,
+            environmentId,
+          );
         }
       }
-      if (this.obj.revision === "0.0.1") {
+      if (this.obj.revision === '0.0.1') {
         await this.createEnvironmentMapping(environmentId);
       }
       if (this.obj.deleted) {
-        await this.removeEnvironmentMapping(environmentId)
+        await this.removeEnvironmentMapping(environmentId);
       }
     } else {
       // Upsert non revision models
       await this.db
-      .collection(this.collection)
-      .replaceOne({_id: this.obj._id}, this.obj, {upsert: true});
+        .collection(this.collection)
+        .replaceOne({_id: this.obj._id}, this.obj, {upsert: true});
     }
 
     // Return the saved model
@@ -171,45 +228,53 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
 
   private async removeEnvironmentMapping(environmentId: string): Promise<void> {
     const path = `environments.${environmentId}`;
-        await this.db.collection(this.collectionEnvironmentMapping).updateOne(
-          {originalId: this.idString()},
-          {$unset: {[path]: ""}}
-          )
+    await this.db
+      .collection(this.collectionEnvironmentMapping)
+      .updateOne({originalId: this.idString()}, {$unset: {[path]: ''}});
   }
 
   private async createEnvironmentMapping(environmentId: string): Promise<void> {
     await this.db.collection(this.collectionEnvironmentMapping).insertOne({
       originalId: this.idString(),
-      environments: {[environmentId]: this.idString()}
-    })
+      environments: {[environmentId]: this.idString()},
+    });
   }
 
-  private async updateEnvironmentMapping(revisionId: string, insertedId: string, environmentId: string): Promise<void> {
-    const path = `environments.${environmentId}`
-    await this.db.collection(this.collectionEnvironmentMapping).updateOne(
-      {[path]: revisionId},
-      { $set: {[path]: insertedId}}
-    )
+  private async updateEnvironmentMapping(
+    revisionId: string,
+    insertedId: string,
+    environmentId: string,
+  ): Promise<void> {
+    const path = `environments.${environmentId}`;
+    await this.db
+      .collection(this.collectionEnvironmentMapping)
+      .updateOne({[path]: revisionId}, {$set: {[path]: insertedId}});
   }
 
-  private async updateIntentEntityBlockMapping(oldId: string, newId: string, environment: string): Promise<void> {
-    if (this.collection === "Block") {
+  private async updateIntentEntityBlockMapping(
+    oldId: string,
+    newId: string,
+    environment: string,
+  ): Promise<void> {
+    if (this.collection === 'Block') {
       // update intent and entity mappings
-      const filter = {block_id: oldId, environment}
-      const update = {$set: {'block_id': newId}}
+      const filter = {block_id: oldId, environment};
+      const update = {$set: {block_id: newId}};
       await this.db.collection('IntentBlockMapping').updateMany(filter, update);
       await this.db.collection('EntityBlockMapping').updateMany(filter, update);
-    } else if (this.collection === "Intent") {
+    } else if (this.collection === 'Intent') {
       // update intent mapping
-      const filter = {intent_id: oldId, environment}
-      const update = {$set: {'intent_id': newId}}
+      const filter = {intent_id: oldId, environment};
+      const update = {$set: {intent_id: newId}};
       await this.db.collection('IntentBlockMapping').updateMany(filter, update);
-    } else if (this.collection === "Entity") {
+    } else if (this.collection === 'Entity') {
       // update entity mapping
-      const filter = {entity_id: oldId, environment}
-      const update = {$set: {'entity_id': newId}}
+      const filter = {entity_id: oldId, environment};
+      const update = {$set: {entity_id: newId}};
       await this.db.collection('EntityBlockMapping').updateMany(filter, update);
-    } else { 
+    } else if (this.collection === 'FormModel') {
+      return;
+    } else {
       throw Error(`${this.collection} is unsupported revision type.`);
     }
   }
@@ -217,12 +282,16 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
   public async revertVersion(id: string, revisionId: string): Promise<this> {
     const revisionObjId = new ObjectId();
     // get the actuall object
-    const obj = await this.db.collection(this.collection).findOne({_id: new ObjectId(id)});
-    
+    const obj = await this.db
+      .collection(this.collection)
+      .findOne({_id: new ObjectId(id)});
+
     // get revision
-    const objToRevert = await this.db.collection(this.collectionRevision).findOne({_id: new ObjectId(revisionId)});
+    const objToRevert = await this.db
+      .collection(this.collectionRevision)
+      .findOne({_id: new ObjectId(revisionId)});
 
-    // update revision object 
+    // update revision object
     objToRevert.revision = Nongo.revisionNumber(obj.revision);
     objToRevert.history = Nongo.revisionHistory(obj, revisionObjId);
     delete objToRevert.diffs;
@@ -234,7 +303,6 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
       .collection(this.collection)
       .replaceOne({_id: obj._id}, objToRevert);
 
-
     // make actuall object as revision object and save it to the revision collection
     obj._id = revisionObjId;
     await this.db.collection(this.collectionRevision).insertOne(obj);
@@ -244,7 +312,10 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
     return new this.constructor(this.nongo, objToRevert);
   }
 
-  public async getRevisionObjForEnvironment(isLive: boolean, id: string): Promise<this> {
+  public async getRevisionObjForEnvironment(
+    isLive: boolean,
+    id: string,
+  ): Promise<this> {
     let doc;
     const _id = new ObjectId(id);
 
@@ -264,8 +335,13 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
     return new this.constructor(this.nongo, doc);
   }
 
-  public async saveEnvironmentRevision(id: string, environmentId: string): Promise<this> {
-    const obj = await this.db.collection(this.collection).findOne({_id: new ObjectId(id)});
+  public async saveEnvironmentRevision(
+    id: string,
+    environmentId: string,
+  ): Promise<this> {
+    const obj = await this.db
+      .collection(this.collection)
+      .findOne({_id: new ObjectId(id)});
 
     const revisionObj = clone(obj);
     revisionObj._id = new ObjectId();
@@ -277,8 +353,12 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
     return new this.constructor(this.nongo, revisionObj);
   }
 
-  public async removeEnvironmentRevisions(environmentId: string): Promise<DeleteResult> {
-    const result = await this.db.collection(this.collectionRevision).deleteMany({environment: environmentId})
+  public async removeEnvironmentRevisions(
+    environmentId: string,
+  ): Promise<DeleteResult> {
+    const result = await this.db
+      .collection(this.collectionRevision)
+      .deleteMany({environment: environmentId});
     return result;
   }
 
@@ -351,17 +431,30 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
     return this.findOne({_id: id});
   }
 
-  public async getRevisionHistory (history: RevisionHistory[]) {
-    const revisionIds = history.map(i => new ObjectId(i.id));
-    return this.toArray(await this.findIterator({_id: {$in: revisionIds}}, {sort: {revision: 'descending'}}, this.collectionRevision));
+  public async getRevisionHistory(history: RevisionHistory[]) {
+    const revisionIds = history.map((i) => new ObjectId(i.id));
+    return this.toArray(
+      await this.findIterator(
+        {_id: {$in: revisionIds}},
+        {sort: {revision: 'descending'}},
+        this.collectionRevision,
+      ),
+    );
   }
 
-  public async getRevisions(query: Filter<Document>, options?: FindOptions<Document>): Promise<this[]> {
-    return this.toArray(await this.findIterator(query, options, this.collectionRevision));
+  public async getRevisions(
+    query: Filter<Document>,
+    options?: FindOptions<Document>,
+  ): Promise<this[]> {
+    return this.toArray(
+      await this.findIterator(query, options, this.collectionRevision),
+    );
   }
 
-  public async getRevision (query: Filter<Document>): Promise<this> {
-    const doc = await this.db.collection(this.collectionRevision).findOne(query);
+  public async getRevision(query: Filter<Document>): Promise<this> {
+    const doc = await this.db
+      .collection(this.collectionRevision)
+      .findOne(query);
 
     // Return null if no doc was found
     if (doc == null) {
@@ -378,7 +471,10 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
    * @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: Filter<Document> = {}, options?: FindOptions<Document>): Promise<this[]> {
+  public async find(
+    query: Filter<Document> = {},
+    options?: FindOptions<Document>,
+  ): Promise<this[]> {
     return this.toArray(await this.findIterator(query, options));
   }
 
@@ -398,7 +494,7 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
    * @param options: the query options e.g. sorting, limiting results etc.
    * @return the results of the query as an {@link AsyncIterator}.
    */
-  public async  findIterator(
+  public async findIterator(
     query: Filter<Document> = {},
     options?: FindOptions<Document>,
     collection = this.collection,
@@ -407,7 +503,7 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
     const cursor = this.db.collection(collection).find(query, options);
     return new CursorIterator<this>(
       cursor,
-    // @ts-ignore
+      // @ts-ignore
       (obj) => new this.constructor(this.nongo, obj),
     );
   }
@@ -430,12 +526,18 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
     return new this.constructor(this.nongo, doc);
   }
 
-  public async remove(query: Filter<Document>, options?: DeleteOptions): Promise<DeleteResult> {
+  public async remove(
+    query: Filter<Document>,
+    options?: DeleteOptions,
+  ): Promise<DeleteResult> {
     query = this.prepareQuery(query);
     return this.db.collection(this.collection).deleteMany(query, options);
   }
 
-  public async aggregate(pipeline: Document[], options?: AggregateOptions): Promise<any[]> {
+  public async aggregate(
+    pipeline: Document[],
+    options?: AggregateOptions,
+  ): Promise<any[]> {
     return this.toArray(await this.aggregateIterator(pipeline, options));
   }
 
@@ -458,14 +560,21 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
     return this.db.collection(this.collection).distinct(field, filter);
   }
 
-  public async update(query: Filter<Document>, updates: UpdateFilter<Document>, options?: UpdateOptions): Promise<UpdateResult<Document>> {
+  public async update(
+    query: Filter<Document>,
+    updates: UpdateFilter<Document>,
+    options?: UpdateOptions,
+  ): Promise<UpdateResult<Document>> {
     query = this.prepareQuery(query);
     return this.db
       .collection(this.collection)
       .updateMany(query, updates, options);
   }
 
-  public async count(query: Document = {}, options?: CountDocumentsOptions): Promise<number> {
+  public async count(
+    query: Document = {},
+    options?: CountDocumentsOptions,
+  ): Promise<number> {
     return this.db.collection(this.collection).countDocuments(query, options);
   }
 
@@ -494,7 +603,9 @@ export default abstract class Model<T extends {_id?: ObjectId, revision?: string
     if (typeof _id === 'string') {
       query._id = Nongo.toObjectId(query._id);
     } else if (_id.$in) {
-      _id.$in = _id.$in.map((el) => typeof el === 'string' ? Nongo.toObjectId(el) : el);
+      _id.$in = _id.$in.map((el) =>
+        typeof el === 'string' ? Nongo.toObjectId(el) : el,
+      );
     }
 
     return query;

package/src/nongo.ts

@@ -4,7 +4,7 @@ import Logger from 'wbb-logger';
 import incVersion from 'semver/functions/inc';
 import AtlasApi from './atlas-api';
 import {Newable} from './interface';
-import Model, { RevisionHistory } from './model';
+import Model, {RevisionHistory} from './model';
 import MongoIndex from './mongo-index';
 import MongoIndexSet from './mongo-index-set';
 import NongoParams from './nongo-params';
@@ -42,13 +42,11 @@ export default class Nongo {
     } 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(),
-        }
-      )
+      array.push({
+        id: revisionId.toString(),
+        revision: model.revision,
+        created: new Date(),
+      });
       return array;
     }
   }
@@ -58,8 +56,8 @@ export default class Nongo {
   public noStripKeys: any = {};
   public db: Db;
   public dbName: string;
-  public static REVISION = "Revision";
-  public static ENVIRONMENT_MAPPING = "EnvironmentMapping";
+  public static REVISION = 'Revision';
+  public static ENVIRONMENT_MAPPING = 'EnvironmentMapping';
 
   // Parallel to {@code this.modelClasses} and {@code this.schemaParsers}
   private instances: Model[];
@@ -82,12 +80,15 @@ export default class Nongo {
     public schemaParsers?: SchemaParser[],
     public mongoClient?: MongoClient,
     private readonly poolSize?: number,
-  ) {
-  }
+  ) {}
 
   public async connect() {
     // Connect to the database
-    this.mongoClient = this.mongoClient ?? await new MongoClient(this.uri(), {minPoolSize: this.poolSize}).connect();
+    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;
 
@@ -146,9 +147,9 @@ export default class Nongo {
   }
 
   public async ensureIndexes(): Promise<void> {
-
+    // collections in Mongo
     const collectionNames = await this.getCollectionNames();
-
+    const indexedCollections: string[] = [];
     // Iterate over each of the model instances we have so we can ensure their indexes
     for (let i = 0; i < this.instances.length; i++) {
       const instance = this.instances[i];
@@ -159,7 +160,12 @@ export default class Nongo {
       const explicitIndexes = instance.getMongoIndexes();
       const collName = instance.collection;
       try {
-        await this.ensureCollectionIndexes(schema, collName, explicitIndexes, collectionNames);
+        await this.ensureCollectionIndexes(
+          schema,
+          collName,
+          explicitIndexes,
+          collectionNames,
+        );
       } catch (err) {
         logger.error(`Failed to ensure indexes for ${collName}`);
         logger.error(err);
@@ -170,12 +176,34 @@ export default class Nongo {
       const atlasParams = this.params.atlas;
       const atlasEnabled = atlasParams && !atlasParams.disabled;
       if (atlasEnabled && searchIndexes.length) {
-        await new AtlasApi(atlasParams).ensureSearchIndexes(this.dbName, instance.name, searchIndexes);
+        await new AtlasApi(atlasParams).ensureSearchIndexes(
+          this.dbName,
+          instance.name,
+          searchIndexes,
+        );
+      }
+      // If the instance we've just indexed has a revision,
+      // add to list, so we don't drop it
+      indexedCollections.push(collName);
+      const revision = instance.getCollectionRevision();
+      if (revision) {
+        indexedCollections.push(revision);
       }
+    }
 
+    const dropCollections = collectionNames.filter(
+      (c) => !indexedCollections.includes(c),
+    );
+    for (const coll of dropCollections) {
+      logger.info(`Dropping ${this.dbName}.${coll}`);
+      await this.dropCollection(coll);
     }
   }
 
+  private async dropCollection(collName) {
+    await this.db.dropCollection(collName);
+  }
+
   public async dropDatabase() {
     await this.db.dropDatabase();
   }
@@ -258,7 +286,7 @@ export default class Nongo {
   }
 
   private async getCollectionNames(): Promise<string[]> {
-    const collections = await (this.db.listCollections().toArray());
+    const collections = await this.db.listCollections().toArray();
     return collections.map((col) => col.name);
   }
 
@@ -271,7 +299,10 @@ export default class Nongo {
     const context = this.dbName + '.' + collName;
 
     // Get the existing set of indexes, we will remove the ones we want to keep
-    const existingIndexes = await this.existingIndexes(collName, collectionNames);
+    const existingIndexes = await this.existingIndexes(
+      collName,
+      collectionNames,
+    );
 
     // Ensure all the required indexes have been applied
     const indexSet = await this.getSchemaIndexes(schema);

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

@@ -1,12 +0,0 @@
-// 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;
-}

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

@@ -1,40 +0,0 @@
-// This file was generated using nongo-driver's TsInterfaceGenerator.
-export default interface DummyModelObj {
-  'dontStripChildren'?: any;
-  'dontStripChildren2'?: any;
-  'exampleMap'?: {[key: string]: {
-    'mapValueField': string;
-  }};
-  'created'?: Date;
-  'arrayOfObject'?: object[];
-  'name': string;
-  'age': number;
-  'pets': Array<{
-    'species'?: string;
-    'likes'?: {
-      'food'?: string[];
-      'drink'?: string[];
-    };
-  }>;
-  'job': {
-    'role': string;
-    'at'?: string;
-  };
-  'location'?: {
-    'address1'?: string;
-  };
-  'autoInit': {
-    'initArray': Array<{
-      'nestedObj': any;
-    }>;
-    'initNestedObj'?: {
-      'hello'?: string;
-    };
-    'initNestedNative'?: any;
-  };
-  'notEmptyFields'?: {
-    'aString': string;
-    'anArray': string[];
-  };
-  '_id'?: any;
-}