Feature: Infer schema type automatically.

lib/schema.js

@@ -106,9 +106,9 @@ function Schema(obj, options) {
   this.inherits = {};
   this.callQueue = [];
   this._indexes = [];
-  this.methods = {};
+  this.methods = (options && options.methods) || {};
   this.methodOptions = {};
-  this.statics = {};
+  this.statics = (options && options.statics) || {};
   this.tree = {};
   this.query = {};
   this.childSchemas = [];

test/document.test.js

@@ -11198,4 +11198,12 @@ describe('document', function() {
 
     await doc.validate();
   });
+
+  it('should give an instance function back rather than undefined (m0_0a)', function M0_0aModelJS() {
+    const testSchema = new mongoose.Schema({}, { methods: { instanceFn() { return 'Returned from DocumentInstanceFn'; } } });
+    const TestModel = mongoose.model('TestModel', testSchema);
+    const TestDocument = new TestModel({});
+    assert.equal(TestDocument.instanceFn(), 'Returned from DocumentInstanceFn');
+  });
+
 });

test/model.test.js

@@ -8485,4 +8485,12 @@ function pick(obj, keys) {
     }
   }
   return newObj;
-}
+}
+
+describe('Check if statics functions that is supplied in schema option is availabe (m0_0a)', function() {
+  it('should give a static function back rather than undefined', function M0_0aModelJS() {
+    const testSchema = new mongoose.Schema({}, { statics: { staticFn() { return 'Returned from staticFn'; } } });
+    const TestModel = mongoose.model('TestModel', testSchema);
+    assert.equal(TestModel.staticFn(), 'Returned from staticFn');
+  });
+});

test/types/create.test.ts

@@ -3,7 +3,7 @@ import { Schema, model, Document, Types } from 'mongoose';
 const schema: Schema = new Schema({ name: { type: 'String' } });
 
 interface ITest extends Document {
-  _id?: Types.ObjectId;
+  _id?: Types.ObjectId | string;
   name?: string;
 }
 

test/types/document.test.ts

@@ -162,6 +162,12 @@ function gh11435() {
   const ItemSchema = new Schema<Item>({ name: String });
 
   ItemSchema.pre('validate', function preValidate() {
-    expectType<Model<unknown>>(this.model('Item1'));
+    expectType<Model<Item>>(this.model('Item1'));
+  });
+
+  const AutoTypedItemSchema = new Schema({ name: String });
+
+  AutoTypedItemSchema.pre('validate', function preValidate() {
+    expectType<Model<Item>>(this.model('Item1'));
   });
 }

test/types/middleware.test.ts

@@ -1,5 +1,5 @@
 import { Schema, model, Model, Document, SaveOptions, Query, Aggregate, HydratedDocument, PreSaveMiddlewareFunction } from 'mongoose';
-import { expectError, expectType } from 'tsd';
+import { expectAssignable, expectError } from 'tsd';
 
 interface ITest extends Document {
   name?: string;
@@ -81,6 +81,6 @@ const Test = model<ITest>('Test', schema);
 
 function gh11257(): void {
   schema.pre('save', { document: true }, function() {
-    expectType<HydratedDocument<ITest>>(this);
+    expectAssignable<HydratedDocument<ITest>>(this);
   });
 }

test/types/models.test.ts

@@ -1,5 +1,6 @@
 import { Schema, Document, Model, Types, connection, model } from 'mongoose';
-import { expectError } from 'tsd';
+import { expectAssignable, expectError, expectType } from 'tsd';
+import { M0_0aAutoTypedSchemaType, m0_0aSchema } from './schema.test';
 
 function conventionalSyntax(): void {
   interface ITest extends Document {
@@ -209,4 +210,50 @@ function inheritance() {
 
 Project.createCollection({ expires: '5 seconds' });
 Project.createCollection({ expireAfterSeconds: 5 });
-expectError(Project.createCollection({ expireAfterSeconds: '5 seconds' }));
+expectError(Project.createCollection({ expireAfterSeconds: '5 seconds' }));
+
+export async function m0_0aModel() {
+  const AutoTypeSchema = m0_0aSchema();
+  const AutoTypeModel = model('AutoTypeModel', AutoTypeSchema);
+
+  /* -------------------------------------------------------------------------- */
+  /*                            Model-functions-test                            */
+  /* -------------------------------------------------------------------------- */
+  // Create should works with arbitrary objects.
+  const randomObject = await AutoTypeModel.create({ unExistKey: 'unExistKey', description: 'st' });
+  expectType<string>(randomObject.unExistKey);
+  expectType<M0_0aAutoTypedSchemaType['schema']['userName']>(randomObject.userName);
+
+  const testDoc1 = await AutoTypeModel.create({ userName: 'M0_0a' });
+  expectType<M0_0aAutoTypedSchemaType['schema']['userName']>(testDoc1.userName);
+  expectType<M0_0aAutoTypedSchemaType['schema']['description']>(testDoc1.description);
+
+  const testDoc2 = await AutoTypeModel.findOne({ userName: 'M0_0a' });
+  expectType<M0_0aAutoTypedSchemaType['schema']['userName'] | undefined>(testDoc2?.userName);
+  expectType<M0_0aAutoTypedSchemaType['schema']['description'] | undefined>(testDoc2?.description);
+
+  /* -------------------------------------------------------------------------- */
+  /*                        Model-statics-functions-test                        */
+  /* -------------------------------------------------------------------------- */
+
+  expectType<ReturnType<M0_0aAutoTypedSchemaType['statics']['staticFn']>>(AutoTypeModel.staticFn());
+
+  /* -------------------------------------------------------------------------- */
+  /*                                Instance-Test                               */
+  /* -------------------------------------------------------------------------- */
+
+  const AutoTypeModelInstance = new AutoTypeModel({});
+
+  expectType<M0_0aAutoTypedSchemaType['schema']['userName']>(AutoTypeModelInstance.userName);
+  expectType<M0_0aAutoTypedSchemaType['schema']['favoritDrink']>(AutoTypeModelInstance.favoritDrink);
+  expectType<M0_0aAutoTypedSchemaType['schema']['favoritColorMode']>(AutoTypeModelInstance.favoritColorMode);
+
+  /* -------------------------------------------------------------------------- */
+  /*                          Document-Instance-Methods                         */
+  /* -------------------------------------------------------------------------- */
+
+  expectType<ReturnType<M0_0aAutoTypedSchemaType['methods']['instanceFn']>>(AutoTypeModelInstance.instanceFn());
+
+
+  return AutoTypeModel;
+}

test/types/schema.test.ts

@@ -1,5 +1,5 @@
-import { Schema, Document, SchemaDefinition, Model, Types } from 'mongoose';
-import { expectType, expectNotType, expectError } from 'tsd';
+import { Schema, Document, SchemaDefinition, Model, Types, SchemaType, InferSchemaType } from 'mongoose';
+import { expectType, expectError } from 'tsd';
 
 enum Genre {
   Action,
@@ -305,3 +305,168 @@ function gh11435(): void {
 new Schema({}, { expires: '5 seconds' });
 expectError(new Schema({}, { expireAfterSeconds: '5 seconds' }));
 new Schema({}, { expireAfterSeconds: 5 });
+
+export type M0_0aAutoTypedSchemaType = {
+  schema: {
+  userName: string;
+  description?: string;
+  nested?: {
+    age: number;
+    hobby?: string
+    },
+    favoritDrink?: 'Tea' | 'Coffee',
+    favoritColorMode:'dark' | 'light'
+  }
+  , statics: {
+    staticFn:()=>'Returned from staticFn'
+  },
+  methods: {
+    instanceFn : ()=> 'Returned from DocumentInstanceFn'
+  }
+}
+
+export function m0_0aSchema() {
+  const AutoTypedSchema = new Schema({
+    userName: {
+      type: String,
+      required: [true, 'userName is required']
+    },
+    description: String,
+    nested: new Schema({
+      age: {
+        type: Number,
+        required: true
+      },
+      hobby: {
+        type: String,
+        required: false
+      }
+    }),
+    favoritDrink: {
+      type: String,
+      enum: ['Coffee', 'Tea']
+    },
+    favoritColorMode: {
+      type: String,
+      enum: {
+        values: ['dark', 'light'],
+        message: '{VALUE} is not supported'
+      },
+      required: true
+    }
+  }, {
+    statics: {
+      staticFn() { return 'Returned from staticFn'; }
+    },
+    methods: {
+      instanceFn() { return 'Returned from DocumentInstanceFn'; }
+    }
+  });
+
+  type InferredSchemaType = InferSchemaType<typeof AutoTypedSchema>
+
+  expectType<M0_0aAutoTypedSchemaType['schema']>({} as InferredSchemaType);
+
+  expectError<M0_0aAutoTypedSchemaType['schema'] & { doesNotExist: boolean; }>({} as InferredSchemaType);
+
+  // Test auto schema type obtaining with all possible path types.
+
+  class Int8 extends SchemaType {
+    constructor(key, options) {
+      super(key, options, 'Int8');
+    }
+    cast(val) {
+      let _val = Number(val);
+      if (isNaN(_val)) {
+        throw new Error('Int8: ' + val + ' is not a number');
+      }
+      _val = Math.round(_val);
+      if (_val < -0x80 || _val > 0x7F) {
+        throw new Error('Int8: ' + val +
+          ' is outside of the range of valid 8-bit ints');
+      }
+      return _val;
+    }
+  }
+
+  type TestSchemaType = {
+    string1?: string;
+    string2?: string;
+    string3?: string;
+    string4?: string;
+    number1?: number;
+    number2?: number;
+    number3?: number;
+    number4?: number;
+    date1?: Date;
+    date2?: Date;
+    date3?: Date;
+    date4?: Date;
+    buffer1?: Buffer;
+    buffer2?: Buffer;
+    buffer3?: Buffer;
+    buffer4?: Buffer;
+    boolean1?: boolean;
+    boolean2?: boolean;
+    boolean3?: boolean;
+    boolean4?: boolean;
+    mixed1?: Schema.Types.Mixed;
+    mixed2?: Schema.Types.Mixed;
+    mixed3?: Schema.Types.Mixed;
+    objectId1?: Schema.Types.ObjectId;
+    objectId2?: Schema.Types.ObjectId;
+    objectId3?: Schema.Types.ObjectId;
+    customSchema?:Int8;
+    map1?: Map<string, string>;
+    map2?: Map<string, number>;
+  }
+
+  const TestSchema = new Schema({
+    string1: String,
+    string2: 'String',
+    string3: 'string',
+    string4: Schema.Types.String,
+    number1: Number,
+    number2: 'Number',
+    number3: 'number',
+    number4: Schema.Types.Number,
+    date1: Date,
+    date2: 'Date',
+    date3: 'date',
+    date4: Schema.Types.Date,
+    buffer1: Buffer,
+    buffer2: 'Buffer',
+    buffer3: 'buffer',
+    buffer4: Schema.Types.Buffer,
+    boolean1: Boolean,
+    boolean2: 'Boolean',
+    boolean3: 'boolean',
+    boolean4: Schema.Types.Boolean,
+    mixed1: Object,
+    mixed2: {},
+    mixed3: Schema.Types.Mixed,
+    objectId1: Schema.Types.ObjectId,
+    objectId2: 'ObjectId',
+    objectId3: 'objectId',
+    customSchema: Int8,
+    map1: { type: Map, of: String },
+    map2: { type: Map, of: Number }
+  });
+
+  type InferredTestSchemaType = InferSchemaType<typeof TestSchema>
+
+  expectType<TestSchemaType>({} as InferredTestSchemaType);
+
+  const SchemaWithCustomTypeKey = new Schema({
+    name: {
+      customKTypeKey: String,
+      required: true
+    }
+  }, {
+    typeKey: 'customKTypeKey'
+  });
+
+  expectType<string>({} as InferSchemaType<typeof SchemaWithCustomTypeKey>['name']);
+
+  return AutoTypedSchema;
+}

types/document.d.ts

@@ -170,7 +170,7 @@ declare module 'mongoose' {
     modelName: string;
 
     /** Returns the model with the given name on this document's associated connection. */
-    model<ModelType = Model<unknown>>(name: string): ModelType;
+    model<ModelType = Model<DocType>>(name: string): ModelType;
 
     /**
      * Overwrite all values in this document with the values of `obj`, except