requested changes

docs/guide.md

@@ -80,6 +80,7 @@ The permitted SchemaTypes are:
 * [Decimal128](api/mongoose.html#mongoose_Mongoose-Decimal128)
 * [Map](schematypes.html#maps)
 * [UUID](schematypes.html#uuid)
+* [Int32](schematypes.html#int32)
 
 Read more about [SchemaTypes here](schematypes.html).
 

docs/schematypes.md

@@ -55,6 +55,7 @@ Check out [Mongoose's plugins search](http://plugins.mongoosejs.io) to find plug
 * [Schema](#schemas)
 * [UUID](#uuid)
 * [BigInt](#bigint)
+* [Int32](#int32)
 
 ### Example
 
@@ -68,6 +69,7 @@ const schema = new Schema({
   mixed: Schema.Types.Mixed,
   _someId: Schema.Types.ObjectId,
   decimal: Schema.Types.Decimal128,
+  32bitInt: Schema.Types.Int32,
   array: [],
   ofString: [String],
   ofNumber: [Number],
@@ -647,6 +649,21 @@ const question = new Question({ answer: 42n });
 typeof question.answer; // 'bigint'
 ```
 
+### Int32 {#int32}
+
+Mongoose supports 32-bit integers as a SchemaType.
+Int32s are stored as [32-bit integers in MongoDB (BSON type "int")](https://www.mongodb.com/docs/manual/reference/bson-types/).
+
+```javascript
+const studentsSchema = new Schema({
+  id: Int32
+});
+const Student = mongoose.model('Student', schema);
+
+const student = new Student({ id: 1339 });
+typeof student.id; // 'number'
+```
+
 ## Getters {#getters}
 
 Getters are like virtuals for paths defined in your schema. For example,

docs/source/api.js

@@ -40,7 +40,8 @@ const files = [
   'lib/types/subdocument.js',
   'lib/types/arraySubdocument.js',
   'lib/types/buffer.js',
-  'lib/types/.js',
+  'lib/types/decimal128.js',
+  'lib/types/int32.js',
   'lib/types/map.js',
   'lib/types/array/methods/index.js'
 ];

index.js

@@ -46,6 +46,7 @@ module.exports.Decimal128 = mongoose.Decimal128;
 module.exports.Mixed = mongoose.Mixed;
 module.exports.Date = mongoose.Date;
 module.exports.Number = mongoose.Number;
+module.exports.Int32 = mongoose.Int32;
 module.exports.Error = mongoose.Error;
 module.exports.MongooseError = mongoose.MongooseError;
 module.exports.now = mongoose.now;

lib/browser.js

@@ -50,7 +50,7 @@ exports.Schema = require('./schema');
  * - [ObjectId](https://mongoosejs.com/docs/schematypes.html#objectids)
  * - [Map](https://mongoosejs.com/docs/schematypes.html#maps)
  * - [Subdocument](https://mongoosejs.com/docs/schematypes.html#schemas)
- * - Int32
+ * - [Int32](https://mongoosejs.com/docs/schematypes.html#int32)
  *
  * Using this exposed access to the `ObjectId` type, we can construct ids on demand.
  *

lib/cast/int32.js

@@ -27,7 +27,7 @@ module.exports = function castInt32(val) {
 
     const _val = Number(val);
 
-    if (!isNaN(_val) && _val === Math.round(_val) && _val > INT32_MIN && _val < INT32_MAX) {
+    if (_val !== _val | 0 && _val > INT32_MIN && _val < INT32_MAX) {
       return _val;
     }
     assert.ok(false);

lib/drivers/browser/int32.js

@@ -0,0 +1,7 @@
+/*!
+ * ignore
+ */
+
+'use strict';
+
+module.exports = require('bson').Int32;

lib/mongoose.js

@@ -987,7 +987,7 @@ Mongoose.prototype.VirtualType = VirtualType;
  * - [ObjectId](https://mongoosejs.com/docs/schematypes.html#objectids)
  * - [Map](https://mongoosejs.com/docs/schematypes.html#maps)
  * - [Subdocument](https://mongoosejs.com/docs/schematypes.html#schemas)
- * - Int32
+ * - [Int32](https://mongoosejs.com/docs/schematypes.html#int32)
  *
  * Using this exposed access to the `ObjectId` type, we can construct ids on demand.
  *
@@ -1142,15 +1142,15 @@ Mongoose.prototype.Decimal128 = SchemaTypes.Decimal128;
 
 /**
  * The Mongoose Int32 [SchemaType](https://mongoosejs.com/docs/schematypes.html). Used for
- * declaring paths in your schema that should be 32-bit integers floating points.
+ * declaring paths in your schema that should be 32-bit integers.
  * Do not use this to create a new Int32 instance, use `mongoose.Types.Int32`
  * instead.
  *
  * #### Example:
  *
- *     const vehicleSchema = new Schema({ numberOfCows: mongoose.Int32 });
+ *     const vehicleSchema = new Schema({ numTires: mongoose.Int32 });
  *
- * @property Decimal128
+ * @property Int32
  * @api public
  */
 Mongoose.prototype.Int32 = SchemaTypes.Int32;

lib/query.js

@@ -1634,7 +1634,6 @@ Query.prototype.getOptions = function() {
  * - [projection](https://mongoosejs.com/docs/api/query.html#Query.prototype.projection())
  * - sanitizeProjection
  * - useBigInt64
- * - promoteValues
  *
  * The following options are only for all operations **except** `updateOne()`, `updateMany()`, `deleteOne()`, and `deleteMany()`:
  *

lib/schema.js

@@ -1494,6 +1494,8 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     name = 'ObjectId';
   } else if (type === Types.Decimal128) {
     name = 'Decimal128';
+  } else if (type === Types.Int32) {
+    name = 'Int32';
   } else {
     name = type == null ? '' + type : type.toString();
   }

lib/schema/bigint.js

@@ -81,7 +81,7 @@ SchemaBigInt.setters = [];
 SchemaBigInt.get = SchemaType.get;
 
 /**
- * Get/set the function used to cast arbitrary values to booleans.
+ * Get/set the function used to cast arbitrary values to bigints.
  *
  * #### Example:
  *

lib/schema/int32.js

@@ -47,6 +47,10 @@ SchemaInt32._cast = castInt32;
 /**
  * Sets a default option for all Int32 instances.
  *
+ * #### Example:
+ *
+ *     // Make all Int32 fields required by default
+ *     mongoose.Schema.Int32.set('required', true);
  *
  * @param {String} option The option you'd like to set the value for
  * @param {Any} value value for option
@@ -63,6 +67,11 @@ SchemaInt32.setters = [];
 /**
  * Attaches a getter for all Int32 instances
  *
+ * #### Example:
+ *
+ *     // Converts int32 to be a represent milliseconds upon access
+ *     mongoose.Schema.Int32.get(v => v == null ? '0 ms' : v.toString() + ' ms');
+ *
  * @param {Function} getter
  * @return {this}
  * @function get
@@ -73,7 +82,21 @@ SchemaInt32.setters = [];
 SchemaInt32.get = SchemaType.get;
 
 /**
- * Get/set the function used to cast arbitrary values to booleans.
+ * Get/set the function used to cast arbitrary values to 32-bit integers
+ *
+ * #### Example:
+ *
+ *     // Make Mongoose cast NaN to 0
+ *     const defaultCast = mongoose.Schema.Int32.cast();
+ *     mongoose.Schema.Int32.cast(v => {
+ *       if (isNaN(v)) {
+ *         return 0;
+ *       }
+ *       return defaultCast(v);
+ *     });
+ *
+ *     // Or disable casting for Int32s entirely
+ *     mongoose.Schema.Int32.cast(false);
  *
  * @param {Function} caster
  * @return {Function}

lib/types/index.js

@@ -14,6 +14,7 @@ exports.Embedded = require('./arraySubdocument');
 exports.DocumentArray = require('./documentArray');
 exports.Decimal128 = require('./decimal128');
 exports.ObjectId = require('./objectid');
+exports.ObjectId = require('./int32');
 
 exports.Map = require('./map');
 

lib/types/int32.js

@@ -0,0 +1,13 @@
+/**
+ * Int32 type constructor
+ *
+ * #### Example:
+ *
+ *     const id = new mongoose.Types.Int32('-2');
+ *
+ * @constructor Int32
+ */
+
+'use strict';
+
+module.exports = require('bson').Int32;

lib/utils.js

@@ -93,6 +93,10 @@ exports.deepEqual = function deepEqual(a, b) {
     return a.toString() === b.toString();
   }
 
+  if (isBsonType(a, 'Int32') && isBsonType(b, 'In32')) {
+    return a.value === b.value();
+  }
+
   if (a instanceof RegExp && b instanceof RegExp) {
     return a.source === b.source &&
         a.ignoreCase === b.ignoreCase &&

test/helpers/isBsonType.test.js

@@ -5,6 +5,7 @@ const isBsonType = require('../../lib/helpers/isBsonType');
 
 const Decimal128 = require('mongodb').Decimal128;
 const ObjectId = require('mongodb').ObjectId;
+const Int32 = require('mongodb').Int32;
 
 describe('isBsonType', () => {
   it('true for any object with _bsontype property equal typename', () => {
@@ -30,4 +31,8 @@ describe('isBsonType', () => {
   it('true for ObjectId', () => {
     assert.ok(isBsonType(new ObjectId(), 'ObjectId'));
   });
+
+  it('true for Int32', () => {
+    assert.ok(isBsonType(new Int32(), 'Int32'));
+  });
 });

test/int32.test.js

@@ -2,7 +2,6 @@
 
 const assert = require('assert');
 const start = require('./common');
-const BSONInt32 = require('bson').Int32;
 
 const mongoose = start.mongoose;
 const Schema = mongoose.Schema;
@@ -219,42 +218,6 @@ describe('Int32', function() {
       });
     });
 
-    describe('promoteValues', function() {
-      describe('when promoteValues is false', function() {
-        it('find returns BSON Int32', async function() {
-          await Test.create({ myInt: 7 });
-
-          const doc = await Test.findOne({ myInt: 7 })
-            .setOptions({ promoteValues: false });
-          assert.ok(doc);
-          assert.ok(doc.myInt instanceof BSONInt32);
-          assert.equal(doc.myInt.value, 7);
-        });
-      });
-
-      describe('when promoteValues is undefined', function() {
-        it('find returns a JS number', async function() {
-          await Test.create({ myInt: 7 });
-          const doc = await Test.findOne({ myInt: 7 })
-            .setOptions({ promoteValues: undefined });
-          assert.ok(doc);
-          assert.ok(doc);
-          assert.equal(doc.myInt, 7);
-        });
-      });
-
-      describe('when promoteValues is true', function() {
-        it('find returns a JS number', async function() {
-          await Test.create({ myInt: 7 });
-
-          const doc = await Test.findOne({ myInt: 7 })
-            .setOptions({ promoteValues: false });
-          assert.ok(doc);
-          assert.equal(doc.myInt, 7);
-        });
-      });
-    });
-
     it('can query with comparison operators', async function() {
       await Test.create([
         { myInt: 1 },

test/types/schemaTypeOptions.test.ts

@@ -64,6 +64,7 @@ function defaultOptions() {
   expectType<Record<string, any>>(new Schema.Types.Buffer('none').defaultOptions);
   expectType<Record<string, any>>(new Schema.Types.Date('none').defaultOptions);
   expectType<Record<string, any>>(new Schema.Types.Decimal128('none').defaultOptions);
+  expectType<Record<string, any>>(new Schema.Types.Int32('none').defaultOptions);
   expectType<Record<string, any>>(new Schema.Types.DocumentArray('none').defaultOptions);
   expectType<Record<string, any>>(new Schema.Types.Map('none').defaultOptions);
   expectType<Record<string, any>>(new Schema.Types.Mixed('none').defaultOptions);

types/inferrawdoctype.d.ts

@@ -102,18 +102,21 @@ declare module 'mongoose' {
                                   PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
                                     IfEquals<PathValueType, Schema.Types.Decimal128> extends true ? Types.Decimal128 :
                                       IfEquals<PathValueType, Types.Decimal128> extends true ? Types.Decimal128 :
-                                        IfEquals<PathValueType, Schema.Types.BigInt> extends true ? bigint :
-                                          IfEquals<PathValueType, BigInt> extends true ? bigint :
-                                            PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | typeof BigInt ? bigint :
-                                              PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
-                                                IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
-                                                  PathValueType extends MapConstructor | 'Map' ? Map<string, ResolveRawPathType<Options['of']>> :
-                                                    IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolveRawPathType<Options['of']>> :
-                                                      PathValueType extends ArrayConstructor ? any[] :
-                                                        PathValueType extends typeof Schema.Types.Mixed ? any:
-                                                          IfEquals<PathValueType, ObjectConstructor> extends true ? any:
-                                                            IfEquals<PathValueType, {}> extends true ? any:
-                                                              PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                                PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
-                                                                  unknown;
+                                        PathValueType extends 'int32' | 'Int32' | typeof Schema.Types.Int32 ? Types.Int32 :
+                                          IfEquals<PathValueType, Schema.Types.Int32> extends true ? Types.Int32 :
+                                            IfEquals<PathValueType, Types.Int32> extends true ? Types.Int32 :
+                                              IfEquals<PathValueType, Schema.Types.BigInt> extends true ? bigint :
+                                                IfEquals<PathValueType, BigInt> extends true ? bigint :
+                                                  PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | typeof BigInt ? bigint :
+                                                    PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
+                                                      IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
+                                                        PathValueType extends MapConstructor | 'Map' ? Map<string, ResolveRawPathType<Options['of']>> :
+                                                          IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolveRawPathType<Options['of']>> :
+                                                            PathValueType extends ArrayConstructor ? any[] :
+                                                              PathValueType extends typeof Schema.Types.Mixed ? any:
+                                                                IfEquals<PathValueType, ObjectConstructor> extends true ? any:
+                                                                  IfEquals<PathValueType, {}> extends true ? any:
+                                                                    PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
+                                                                      PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
+                                                                        unknown;
 }