public async getGraphQLConnectionFromMongoCursor<InputNode, OutputNode>(
        mongoCursor: Cursor, // return value of .find() in mongodb
        first: number = 10, // how many to fetch
        after?: string, // base64 encoded string
        transformNodeFunction?: (node: InputNode) => OutputNode,
    ) {
        // default value:
        if (!after) {
            after = this.createCursor();
        }
        // decode cursor:
        const cursor = this.decodeCursor(after);

        // get totalCount and entries for nodes
        const [totalCount, entries] = await Promise.all([
            mongoCursor.count(),
            mongoCursor
                .sort(cursor.sort)
                .skip(cursor.skip)
                .limit(first)
                .toArray(),
        ]);

        // get startCursor and endCursor
        const startCursor: string = this.createCursor({
            skip: cursor.skip,
            sort: cursor.sort,
        });

        const endCursor: string = this.createCursor({
            skip: cursor.skip + entries.length,
            sort: cursor.sort,
        });

        // return graphql connection response
        return {
            edges: entries.map((entry: InputNode, index: number) => {
                return {
                    cursor: this.createCursor({
                        skip: cursor.skip + index + 1,
                        sort: cursor.sort,
                    }),
                    node: transformNodeFunction(entry),
                };
            }),
            items: entries.map(transformNodeFunction),
            pageInfo: {
                endCursor,
                hasNextPage: cursor.skip + first <= totalCount - 1,
                startCursor,
            },
            totalCount,
        };
    }

  close() {
    if (this.cursor) {
      this.cursor.close();
    }

    return Promise.resolve();
  }

 next(): Promise<any> {
   return this.cursor.next().then((value) => {
     this._result = value;
     this.key = value && value._id;
     return this.key;
   });
 }

 toArray(): Promise<Model[]> {
   return this.cursor.toArray();
 }

 count(applyLimit: boolean = false) {
   return this.cursor.count(applyLimit);
 }

 limit(newLimit: number): Promise<this> {
   this.cursor.limit(newLimit);
   return Promise.resolve(this);
 }

 advance(count: number): void {
   this.cursor.skip(count);
 }