mongoose 7.0.1 → 7.0.3

package/scripts/loadSponsorData.js

@@ -0,0 +1,115 @@
+'use strict';
+
+let config;
+try {
+  config = require('../.config.js');
+} finally {
+  if (!config || !config.uri) {
+    console.error('No Config or config.URI given, please create a .config.js file with those values in the root of the repository');
+    process.exit(-1);
+  }
+}
+const axios = require('axios');
+const fs = require('fs');
+const mongoose = require('../');
+
+run().catch(err => {
+  console.error(err);
+  process.exit(-1);
+});
+
+// only "." because fs resolves relative to the CWD instead of relative to __dirname
+const docsDir = './docs';
+
+async function run() {
+  await mongoose.connect(config.uri);
+
+  const Subscriber = mongoose.model('Subscriber', mongoose.Schema({
+    companyName: String,
+    description: String,
+    url: String,
+    logo: String
+  }), 'Subscriber');
+
+  const Job = mongoose.model('Job', mongoose.Schema({
+    logo: String,
+    company: String,
+    title: String,
+    location: {
+      type: String,
+      required: true
+    },
+    description: {
+      type: String,
+      required: true
+    },
+    url: {
+      type: String,
+      required: true
+    }
+  }), 'Job');
+
+  const OpenCollectiveSponsor = mongoose.model('OpenCollectiveSponsor', mongoose.Schema({
+    openCollectiveId: {
+      type: Number,
+      required: true
+    },
+    website: {
+      type: String,
+      required: true
+    },
+    image: {
+      type: String,
+      required: true
+    },
+    alt: {
+      type: String
+    }
+  }), 'OpenCollectiveSponsor');
+
+  try {
+    fs.mkdirSync(`${docsDir}/data`);
+  } catch (err) {}
+
+  const subscribers = await Subscriber.
+    find({ companyName: { $exists: true }, description: { $exists: true }, logo: { $exists: true } }).
+    sort({ createdAt: 1 }).
+    select({ companyName: 1, description: 1, url: 1, logo: 1 });
+  fs.writeFileSync(`${docsDir}/data/sponsors.json`, JSON.stringify(subscribers, null, '  '));
+
+  const jobs = await Job.find().select({ logo: 1, company: 1, title: 1, location: 1, description: 1, url: 1 });
+  fs.writeFileSync(`${docsDir}/data/jobs.json`, JSON.stringify(jobs, null, '  '));
+
+  const opencollectiveSponsors = await axios.get('https://opencollective.com/mongoose/members.json').
+    then(res => res.data).
+    then(sponsors => {
+      return sponsors.filter(result => result.tier == 'sponsor' && result.isActive);
+    }).
+    catch(() => null);
+
+  for (const sponsor of opencollectiveSponsors) {
+    const override = await OpenCollectiveSponsor.findOne({ openCollectiveId: sponsor['MemberId'] });
+    if (override == null) {
+      continue;
+    }
+
+    sponsor.website = override.website;
+    sponsor.image = override.image;
+    if (override.alt != null) {
+      sponsor.alt = override.alt;
+    }
+  }
+
+  const additionalSponsors = await OpenCollectiveSponsor.find({}).
+    then(docs => docs.filter(doc => doc.openCollectiveId == null));
+  for (const sponsor of additionalSponsors) {
+    opencollectiveSponsors.push(sponsor);
+  }
+
+  if (opencollectiveSponsors != null) {
+    fs.writeFileSync(`${docsDir}/data/opencollective.json`, JSON.stringify(opencollectiveSponsors, null, '  '));
+  }
+
+  console.log('Done');
+  process.exit(0);
+}

package/types/cursor.d.ts

@@ -38,8 +38,8 @@ declare module 'mongoose' {
      * will wait for the promise to resolve before iterating on to the next one.
      * Returns a promise that resolves when done.
      */
-    eachAsync(fn: (doc: DocType[]) => any, options: EachAsyncOptions & { batchSize: number }): Promise<void>;
-    eachAsync(fn: (doc: DocType) => any, options?: EachAsyncOptions): Promise<void>;
+    eachAsync(fn: (doc: DocType[], i: number) => any, options: EachAsyncOptions & { batchSize: number }): Promise<void>;
+    eachAsync(fn: (doc: DocType, i: number) => any, options?: EachAsyncOptions): Promise<void>;
 
     /**
      * Registers a transform function which subsequently maps documents retrieved

package/types/models.d.ts

@@ -316,6 +316,24 @@ declare module 'mongoose' {
       docs: Array<DocContents | TRawDocType>,
       options: InsertManyOptions & { lean: true; }
     ): Promise<Array<MergeType<MergeType<TRawDocType, DocContents>, Require_id<TRawDocType>>>>;
+    insertMany<DocContents = TRawDocType>(
+      doc: DocContents,
+      options: InsertManyOptions & { ordered: false; rawResult: true; }
+    ): Promise<mongodb.InsertManyResult<TRawDocType> & {
+      mongoose: {
+        validationErrors: Error[];
+        results: Array<
+          Error |
+          Object |
+          HydratedDocument<
+            MergeType<
+              MergeType<TRawDocType, DocContents>,
+              Require_id<TRawDocType>
+            >
+          >
+        >
+      }
+    }>;
     insertMany<DocContents = TRawDocType>(
       docs: Array<DocContents | TRawDocType>,
       options: InsertManyOptions & { rawResult: true; }

package/types/query.d.ts

@@ -109,7 +109,7 @@ declare module 'mongoose' {
     /**
      * If truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document.
      */
-    lean?: boolean | any;
+    lean?: boolean | Record<string, any>;
     limit?: number;
     maxTimeMS?: number;
     multi?: boolean;
@@ -430,7 +430,7 @@ declare module 'mongoose' {
     j(val: boolean | null): this;
 
     /** Sets the lean option. */
-    lean<LeanResultType = ResultType extends any[] ? Require_id<RawDocType>[] : Require_id<RawDocType>>(val?: boolean | any): QueryWithHelpers<LeanResultType, DocType, THelpers, RawDocType>;
+    lean<LeanResultType = ResultType extends any[] ? Require_id<RawDocType>[] : Require_id<RawDocType>>(val?: boolean | any): QueryWithHelpers<ResultType extends null ? LeanResultType | null : LeanResultType, DocType, THelpers, RawDocType>;
 
     /** Specifies the maximum number of documents the query will return. */
     limit(val: number): this;
@@ -532,7 +532,7 @@ declare module 'mongoose' {
     replaceOne(filter?: FilterQuery<DocType>, replacement?: DocType | AnyObject, options?: QueryOptions<DocType> | null): QueryWithHelpers<any, DocType, THelpers, RawDocType>;
 
     /** Specifies which document fields to include or exclude (also known as the query "projection") */
-    select(arg: string | any): this;
+    select(arg: string | string[] | Record<string, number | boolean | object>): this;
 
     /** Determines if field selection has been made. */
     selected(): boolean;

package/types/types.d.ts

@@ -61,7 +61,7 @@ declare module 'mongoose' {
 
     class DocumentArray<T> extends Types.Array<T extends Types.Subdocument ? T : Types.Subdocument<InferId<T>> & T> {
       /** DocumentArray constructor */
-      constructor(values: any[]);
+      constructor(values: AnyObject[]);
 
       isMongooseDocumentArray: true;
 

package/.eslintrc.json

@@ -1,195 +0,0 @@
-{
-  "extends": [
-    "eslint:recommended"
-  ],
-  "ignorePatterns": [
-    "docs",
-    "tools",
-    "dist",
-    "website.js",
-    "test/files/*",
-    "benchmarks"
-  ],
-  "overrides": [
-    {
-      "files": [
-        "**/*.{ts,tsx}"
-      ],
-      "extends": [
-        "plugin:@typescript-eslint/eslint-recommended",
-        "plugin:@typescript-eslint/recommended"
-      ],
-      "plugins": [
-        "@typescript-eslint"
-      ],
-      "rules": {
-        "@typescript-eslint/triple-slash-reference": "off",
-        "@typescript-eslint/no-non-null-assertion": "off",
-        "@typescript-eslint/no-empty-function": "off",
-        "spaced-comment": [
-          "error",
-          "always",
-          {
-            "block": {
-              "markers": [
-                "!"
-              ],
-              "balanced": true
-            },
-            "markers": [
-              "/"
-            ]
-          }
-        ],
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/ban-types": "off",
-        "@typescript-eslint/no-unused-vars": "off",
-        "@typescript-eslint/explicit-module-boundary-types": "off",
-        "@typescript-eslint/indent": [
-          "warn",
-          2,
-          {
-            "SwitchCase": 1,
-            "ignoredNodes": ["TSTypeParameterInstantiation"]
-          }
-        ],
-        "@typescript-eslint/prefer-optional-chain": "error",
-        "@typescript-eslint/brace-style": "error",
-        "@typescript-eslint/no-dupe-class-members": "error",
-        "@typescript-eslint/no-redeclare": "error",
-        "@typescript-eslint/type-annotation-spacing": "error",
-        "@typescript-eslint/object-curly-spacing": [
-          "error",
-          "always"
-        ],
-        "@typescript-eslint/semi": "error",
-        "@typescript-eslint/space-before-function-paren": [
-          "error",
-          "never"
-        ],
-        "@typescript-eslint/space-infix-ops": "off"
-      }
-    }
-  ],
-  "plugins": [
-    "mocha-no-only"
-  ],
-  "parserOptions": {
-    "ecmaVersion": 2020
-  },
-  "env": {
-    "node": true,
-    "es6": true
-  },
-  "rules": {
-    "comma-style": "error",
-    "indent": [
-      "error",
-      2,
-      {
-        "SwitchCase": 1,
-        "VariableDeclarator": 2
-      }
-    ],
-    "keyword-spacing": "error",
-    "no-whitespace-before-property": "error",
-    "no-buffer-constructor": "warn",
-    "no-console": "off",
-    "no-constant-condition": "off",
-    "no-multi-spaces": "error",
-    "func-call-spacing": "error",
-    "no-trailing-spaces": "error",
-    "no-undef": "error",
-    "no-unneeded-ternary": "error",
-    "no-const-assign": "error",
-    "no-useless-rename": "error",
-    "no-dupe-keys": "error",
-    "space-in-parens": [
-      "error",
-      "never"
-    ],
-    "spaced-comment": [
-      "error",
-      "always",
-      {
-        "block": {
-          "markers": [
-            "!"
-          ],
-          "balanced": true
-        }
-      }
-    ],
-    "key-spacing": [
-      "error",
-      {
-        "beforeColon": false,
-        "afterColon": true
-      }
-    ],
-    "comma-spacing": [
-      "error",
-      {
-        "before": false,
-        "after": true
-      }
-    ],
-    "array-bracket-spacing": 1,
-    "arrow-spacing": [
-      "error",
-      {
-        "before": true,
-        "after": true
-      }
-    ],
-    "object-curly-spacing": [
-      "error",
-      "always"
-    ],
-    "comma-dangle": [
-      "error",
-      "never"
-    ],
-    "no-unreachable": "error",
-    "quotes": [
-      "error",
-      "single"
-    ],
-    "quote-props": [
-      "error",
-      "as-needed"
-    ],
-    "semi": "error",
-    "no-extra-semi": "error",
-    "semi-spacing": "error",
-    "no-spaced-func": "error",
-    "no-throw-literal": "error",
-    "space-before-blocks": "error",
-    "space-before-function-paren": [
-      "error",
-      "never"
-    ],
-    "space-infix-ops": "error",
-    "space-unary-ops": "error",
-    "no-var": "warn",
-    "prefer-const": "warn",
-    "strict": [
-      "error",
-      "global"
-    ],
-    "no-restricted-globals": [
-      "error",
-      {
-        "name": "context",
-        "message": "Don't use Mocha's global context"
-      }
-    ],
-    "no-prototype-builtins": "off",
-    "mocha-no-only/mocha-no-only": [
-      "error"
-    ],
-    "no-empty": "off",
-    "eol-last": "warn",
-    "no-multiple-empty-lines": ["warn", { "max": 2 }]
-  }
-}