fix: flowtype definitions for [email protected]

Author: nodkz

.flowconfig

@@ -2,6 +2,8 @@
 .*/coverage/.*
 .*/resources/.*
 <PROJECT_ROOT>/lib/.*
+<PROJECT_ROOT>/es/.*
+<PROJECT_ROOT>/node8/.*
 <PROJECT_ROOT>/dist/.*
 .*/node_modules/ajv.*
 .*/node_modules/acorn.*

flow-typed/npm/mongoose_v4.x.x.js

@@ -1,6 +1,43 @@
-import mongoose from "mongoose";
+// flow-typed signature: ff3cec7c93541c92294f76bebb0d2ee4
+// flow-typed version: 640b352228/mongoose_v4.x.x/flow_>=v0.50.x
+
+/*** FIX broken globals import 'bson' (((( ***/
+// import 'bson';
+declare class bson$ObjectId {
+  constructor(id?: string | number | bson$ObjectId): this;
+  generationTime: number;
+  static createFromHexString(hexString: string): bson$ObjectId;
+  static createFromTime(time: number): bson$ObjectId;
+  static isValid(id?: string | number | bson$ObjectId | null | void): boolean;
+  equals(otherID: bson$ObjectId): boolean;
+  generate(time?: number): string;
+  getTimestamp(): Date;
+  toHexString(): string;
+  toString(): string;
+  inspect(): string;
+  toJSON(): string;
+}
+declare class bson$Decimal128 {
+  constructor(bytes: Buffer): this;
+  static fromString(string: string): bson$Decimal128;
+  toString(): string;
+  toJSON(): { $numberDecimal: string };
+}
+/*** end FIX broken globals import 'bson' (((( ***/
+
+type MongoId = bson$ObjectId | string | number;
 
-type MongoId = BSONObjectId | string | number;
+type Mongoose$Types = {|
+  ObjectId: Class<bson$ObjectId>,
+  Mixed: Object,
+  Embedded: Object,
+  Document: Object,
+  DocumentArray: Object,
+  Subdocument: Object,
+  Array: Object,
+  Buffer: Object,
+  Decimal128: Class<bson$Decimal128>
+|};
 
 type SchemaFields = {
   [fieldName: string]: any
@@ -34,13 +71,14 @@ type SchemaOpts<Doc> = {
   typeKey?: string,
   useNestedStrict?: boolean,
   validateBeforeSave?: boolean,
-  versionKey?: string,
+  versionKey?: string | false,
   timestamps?:
     | boolean
     | {
         createdAt?: string,
         updatedAt?: string
-      }
+      },
+  discriminatorKey?: string
 };
 
 type IndexFields = {
@@ -57,32 +95,6 @@ type IndexOpts = {|
   weights?: Object
 |};
 
-declare class BSONObjectId {
-  constructor(id?: string | number | BSONObjectId): BSONObjectId;
-  toHexString(): string;
-  toString(): string;
-  toJSON(): string;
-  inspect(): string;
-  equals(otherId: string | number | BSONObjectId): boolean;
-  getTimestamp(): Date;
-
-  static createFromTime(time: number): BSONObjectId;
-  static createFromHexString(str: string): BSONObjectId;
-  static isValid(id: string | number | BSONObjectId): boolean;
-}
-
-type Mongoose$Types = {|
-  ObjectId: Class<BSONObjectId>,
-  Mixed: Object,
-  Embedded: Object,
-  Document: Object,
-  DocumentArray: Object,
-  Subdocument: Object,
-  Array: Object,
-  Buffer: Object,
-  Decimal128: Object
-|};
-
 type Mongoose$SchemaMethods = {
   [name: string]: Function
 };
@@ -170,7 +182,8 @@ type Mongoose$SchemaField<Schema> = {
     description: ?string
   },
   enumValues?: ?(string[]),
-  schema?: Schema
+  schema?: Schema,
+  _index?: ?{ [optionName: string]: mixed }
 };
 
 declare class Mongoose$SchemaVirtualField {
@@ -220,7 +233,7 @@ declare class Mongoose$Document {
     data: Object,
     options?: Object
   ): Mongoose$Query<?this, this>;
-  static count(criteria: Object): Promise<number>;
+  static count(criteria?: Object): Promise<number>;
   static remove(criteria: Object): Promise<mixed>;
   static update(
     criteria: Object,
@@ -253,10 +266,12 @@ declare class Mongoose$Document {
   static modelName: string;
   static schema: Mongoose$Schema<this>;
   static on(type: string, cb: Function): void;
+  static discriminator(name: string, schema: Mongoose$Schema<any>): Class<this>;
 
+  collection: Mongoose$Collection;
   constructor(data?: $Shape<this>): this;
   id: string | number;
-  _id: MongoId;
+  _id: bson$ObjectId | string | number;
   __v?: number;
   save(): Promise<this>;
   update(update: Object, options?: Object): Promise<UpdateResult>;
@@ -346,7 +361,7 @@ declare class Mongoose$Query<Result, Doc> extends Promise<Result> {
   batchSize(n: number): Mongoose$Query<Result, Doc>;
   collation(value: Object): Mongoose$Query<Result, Doc>;
   comment(val: string): Mongoose$Query<Result, Doc>;
-  cursor(opts: Object): Mongoose$QueryCursor<Doc>;
+  cursor(opts?: Object): Mongoose$QueryCursor<Doc>;
   deleteMany(criteria?: Object): Mongoose$Query<any, Doc>;
   deleteOne(criteria?: Object): Mongoose$Query<any, Doc>;
   distinct(field: string, criteria?: Object): Mongoose$Query<Result, Doc>;
@@ -407,7 +422,7 @@ declare class Mongoose$Query<Result, Doc> extends Promise<Result> {
 
 declare class Mongoose$QueryCursor<Doc> {
   on(type: "data" | "end" | string, cb: Function): void;
-  next(cb: (err: Error, doc: Doc) => void): void;
+  next(cb?: (err: Error, doc: Doc) => void): Promise<?Doc>;
 }
 
 declare class Mongoose$QueryStream {
@@ -483,14 +498,15 @@ declare class Mongoose$Connection {
 }
 
 declare module "mongoose" {
-  declare export type MongooseConnection = Mongoose$Connection;
-  declare export type MongoId = MongoId;
-  declare export type BSONObjectId = BSONObjectId;
-  declare export type MongooseQuery<Result, Doc> = Mongoose$Query<Result, Doc>;
-  declare export type MongooseDocument = Mongoose$Document;
-  declare export type MongooseModel = typeof Mongoose$Document;
-  declare export type MongooseSchema<Doc> = Mongoose$Schema<Doc>;
-  declare export type MongooseSchemaField<Schema> = Mongoose$SchemaField<
+  declare type MongooseConnection = Mongoose$Connection;
+  declare type MongoId = MongoId;
+  declare type BSONObjectId = bson$ObjectId;
+  declare type ObjectId = bson$ObjectId;
+  declare type MongooseQuery<Result, Doc> = Mongoose$Query<Result, Doc>;
+  declare type MongooseDocument = Mongoose$Document;
+  declare type MongooseModel = typeof Mongoose$Document;
+  declare type MongooseSchema<Doc> = Mongoose$Schema<Doc>;
+  declare type MongooseSchemaField<Schema> = Mongoose$SchemaField<
     Schema
   >;
 
@@ -499,9 +515,9 @@ declare module "mongoose" {
     Types: Mongoose$Types,
     Promise: any,
     model: $PropertyType<Mongoose$Connection, "model">,
-    createConnection(uri?: string): Mongoose$Connection,
+    createConnection(uri?: string, options?: Object): Mongoose$Connection,
     set: (key: string, value: string | Function | boolean) => void,
-    connect: Function,
+    connect: (uri: string, options?: Object) => void,
     connection: Mongoose$Connection,
     connections: Mongoose$Connection[],
     Query: typeof Mongoose$Query,

package.json

@@ -40,30 +40,30 @@
     "babel-cli": "^6.26.0",
     "babel-core": "^6.26.0",
     "babel-eslint": "^8.2.2",
-    "babel-jest": "^22.4.0",
+    "babel-jest": "^22.4.3",
     "babel-plugin-transform-flow-strip-types": "^6.22.0",
     "babel-plugin-transform-object-rest-spread": "^6.13.0",
     "babel-plugin-transform-runtime": "^6.23.0",
     "babel-preset-env": "^1.6.1",
     "cz-conventional-changelog": "^2.1.0",
-    "eslint": "^4.18.0",
+    "eslint": "^4.19.1",
     "eslint-config-airbnb-base": "^12.1.0",
     "eslint-config-prettier": "^2.9.0",
-    "eslint-plugin-flowtype": "^2.45.0",
-    "eslint-plugin-import": "^2.8.0",
+    "eslint-plugin-flowtype": "^2.46.1",
+    "eslint-plugin-import": "^2.10.0",
     "eslint-plugin-prettier": "^2.6.0",
-    "flow-bin": "^0.65.0",
-    "graphql": "0.13.1",
-    "graphql-compose": "^3.0.5",
+    "flow-bin": "^0.69.0",
+    "graphql": "0.13.2",
+    "graphql-compose": "^3.1.1",
     "graphql-compose-connection": ">=3.0.0",
     "graphql-compose-pagination": ">=3.0.0",
-    "jest": "^22.4.0",
-    "mongodb-memory-server": "^1.7.0",
-    "mongoose": "^5.0.6",
-    "prettier": "^1.10.2",
-    "request": "^2.83.0",
+    "jest": "^22.4.3",
+    "mongodb-memory-server": "^1.7.3",
+    "mongoose": "^5.0.12",
+    "prettier": "^1.11.1",
+    "request": "^2.85.0",
     "rimraf": "^2.6.2",
-    "semantic-release": "^12.4.1"
+    "semantic-release": "^15.1.4"
   },
   "config": {
     "commitizen": {

src/__mocks__/mongooseCommon.js

@@ -9,7 +9,7 @@ mongoose.Promise = Promise;
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000;
 
 const originalConnect = mongoose.connect;
-mongoose.connect = async () => {
+mongoose.connect = (async () => {
   const mongoServer = new MongodbMemoryServer();
 
   const mongoUri = await mongoServer.getConnectionString(true);
@@ -33,6 +33,6 @@ mongoose.connect = async () => {
     // console.log('MongoDB disconnected!');
     mongoServer.stop();
   });
-};
+}: any);
 
 export { mongoose, Schema };

src/__tests__/github-issues-test.js

@@ -1,31 +1,15 @@
 /* @flow */
 
 import mongoose from 'mongoose';
-import MongodbMemoryServer from 'mongodb-memory-server';
 import { schemaComposer, graphql } from 'graphql-compose';
 import { composeWithMongoose } from '../index';
 import { UserModel } from '../__mocks__/userModel';
 
 // May require additional time for downloading MongoDB binaries
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000;
 
-let mongoServer;
-
-// const opts = { useMongoClient: true }; // Mongoose 4
-const opts = {}; // Mongoose 5
-
-beforeAll(async () => {
-  mongoServer = new MongodbMemoryServer();
-  const mongoUri = await mongoServer.getConnectionString();
-  mongoose.connect(mongoUri, opts, err => {
-    if (err) console.error(err);
-  });
-});
-
-afterAll(() => {
-  mongoose.disconnect();
-  mongoServer.stop();
-});
+beforeAll(() => UserModel.base.connect());
+afterAll(() => UserModel.base.disconnect());
 
 const UserTC = composeWithMongoose(UserModel);
 schemaComposer.rootQuery().addFields({

src/fieldsConverter.js

@@ -118,8 +118,9 @@ export function convertModelToGraphQL(
   const schemaComposer = sc || globalSchemaComposer;
 
   // if model already has generated TypeComposer early, then return it
-  if (model.schema && model.schema._gqcTypeComposer) {
-    return (model.schema._gqcTypeComposer: any);
+  const modelSchema: any = model.schema;
+  if (modelSchema && modelSchema._gqcTypeComposer) {
+    return modelSchema._gqcTypeComposer;
   }
 
   if (!typeName) {
@@ -128,8 +129,7 @@ export function convertModelToGraphQL(
 
   const typeComposer = schemaComposer.getOrCreateTC(typeName);
 
-  // $FlowFixMe
-  model.schema._gqcTypeComposer = typeComposer; // eslint-disable-line no-param-reassign
+  modelSchema._gqcTypeComposer = typeComposer; // eslint-disable-line no-param-reassign
 
   const mongooseFields = getFieldsFromModel(model);
   const graphqlFields = {};

src/utils/getIndexesFromModel.js

@@ -4,7 +4,7 @@ import type { MongooseModel } from 'mongoose';
 
 export type getIndexesFromModelOpts = {
   extractCompound?: boolean, // true by default
-  skipSpecificIndeces?: boolean, // eg text, 2d, 2dsphere (true by default)
+  skipSpecificIndexes?: boolean, // eg text, 2d, 2dsphere (true by default)
 };
 
 export type IndexT = { [fieldName: string]: any };