WIP: alternative changes to clean up type inference re: #14954

Author: vkarpov15

test/types/aggregate.test.ts

@@ -1,7 +1,7 @@
 import { Schema, model, Document, Expression, PipelineStage, Types, Model, Aggregate } from 'mongoose';
 import { expectType } from 'tsd';
 
-const schema: Schema = new Schema({ name: { type: 'String' } });
+const schema = new Schema({ name: { type: 'String' } });
 
 interface ITest {
   name?: string;

test/types/collection.test.ts

@@ -1,6 +1,6 @@
 import { Schema, model, Document, connection, Collection } from 'mongoose';
 
-const schema: Schema = new Schema({ name: { type: 'String' } });
+const schema = new Schema({ name: { type: 'String' } });
 
 interface ITest {
   name?: string;

test/types/connection.test.ts

@@ -9,7 +9,9 @@ expectType<Connection>(createConnection('mongodb://127.0.0.1:27017/test', { appN
 
 const conn = createConnection();
 
-expectAssignable<Model<{ name: string }, any, any, any>>(conn.model('Test', new Schema<{ name: string }>({ name: { type: String } })));
+expectAssignable<Model<{ name: string }, any, any, any>>(
+  conn.model('Test', new Schema<unknown, { name: string }>({ name: { type: String } }))
+);
 expectType<Model<{ name: string }>>(conn.model<{ name: string }>('Test', new Schema({ name: { type: String } })));
 
 expectType<Promise<Connection>>(conn.openUri('mongodb://127.0.0.1:27017/test'));
@@ -132,7 +134,7 @@ function schemaInstanceMethodsAndQueryHelpersOnConnection() {
   }
   type UserModel = Model<User, UserQueryHelpers, UserInstanceMethods> & UserStaticMethods;
 
-  const userSchema = new Schema<User, UserModel, UserInstanceMethods, UserQueryHelpers, any, UserStaticMethods>({
+  const userSchema = new Schema<unknown, User, UserModel, UserInstanceMethods, UserQueryHelpers, any, UserStaticMethods>({
     name: String
   }, {
     statics: {

test/types/discriminator.test.ts

@@ -1,6 +1,6 @@
 import mongoose, { Document, Model, Schema, SchemaDefinition, SchemaOptions, Types, model } from 'mongoose';
 
-const schema: Schema = new Schema({ name: { type: 'String' } });
+const schema = new Schema({ name: { type: 'String' } });
 
 interface IBaseTest {
   name?: string;
@@ -47,7 +47,7 @@ function test(): void {
 
   const cardDbSchemaOptions: SchemaOptions = { discriminatorKey: 'type' };
 
-  const cardDbSchema: Schema = new Schema(
+  const cardDbSchema = new Schema(
     cardDbBaseSchemaDefinition,
     cardDbSchemaOptions
   );
@@ -60,7 +60,7 @@ function test(): void {
 
   const landDbAdditionalPropertiesSchemaDefinition: SchemaDefinition = {};
 
-  const landDbSchema: Schema = new Schema(
+  const landDbSchema = new Schema(
     landDbAdditionalPropertiesSchemaDefinition
   );
 

test/types/docArray.test.ts

@@ -7,7 +7,7 @@ async function gh10293() {
     arrayOfArray: string[][]; // <-- Array of Array
   }
 
-  const testSchema = new Schema<ITest>({
+  const testSchema = new Schema<unknown, ITest>({
     name: {
       type: String,
       required: true
@@ -144,9 +144,9 @@ function gh14469() {
   };
   type UserModelType = Model<User, {}, UserDocumentProps>;
 
-  const userSchema = new Schema<User, UserModelType>(
+  const userSchema = new Schema<unknown, User, UserModelType>(
     {
-      names: [new Schema<Names>({ firstName: String })]
+      names: [new Schema<unknown, Names>({ firstName: String })]
     },
     { timestamps: true }
   );

test/types/lean.test.ts

@@ -34,7 +34,7 @@ function gh10345() {
 }
 
 async function gh11761() {
-  const thingSchema = new Schema<{ name: string }>({
+  const thingSchema = new Schema<unknown, { name: string }>({
     name: Schema.Types.String
   });
 
@@ -66,7 +66,7 @@ async function gh11118(): Promise<void> {
     avatar?: string;
   }
 
-  const schema = new Schema<User>({
+  const schema = new Schema<unknown, User>({
     name: { type: String, required: true },
     email: { type: String, required: true },
     avatar: String
@@ -87,7 +87,7 @@ async function _11767() {
     answers: string[];
     correct: number;
   }
-  const QuestionSchema = new Schema<Question>({
+  const QuestionSchema = new Schema<unknown, Question>({
     text: String,
     answers: [String],
     correct: Number
@@ -97,7 +97,7 @@ async function _11767() {
     dateTaken: Date;
     questions: Question[];
   }
-  const ExamSchema = new Schema<Exam>({
+  const ExamSchema = new Schema<unknown, Exam>({
     element: String,
     dateTaken: Date,
     questions: [QuestionSchema]
@@ -218,7 +218,7 @@ async function gh15057() {
         value?: string;
       };
 
-  const TestSchema = new Schema<Attachment>({
+  const TestSchema = new Schema<unknown, Attachment>({
     type: { type: String, required: true },
     value: { type: String }
   });
@@ -291,7 +291,7 @@ async function gh15122() {
     ParentInstance
   >;
 
-  const parentSchema = new Schema<IParent, ParentModelType>(
+  const parentSchema = new Schema<unknown, IParent, ParentModelType>(
     {
       name: {
         type: String,
@@ -330,7 +330,7 @@ async function gh15158() {
   };
 
   const createSomeModelAndDoSomething = async <T extends FooBar>() => {
-    const TestSchema = new Schema<T>({
+    const TestSchema = new Schema<unknown, T>({
       value: { type: String }
     });
 

test/types/maps.test.ts

@@ -7,7 +7,7 @@ interface ITest {
   map3: Map<string, number>
 }
 
-const schema: Schema = new Schema<ITest>({
+const schema = new Schema<unknown, ITest>({
   map1: {
     type: Map,
     of: Number
@@ -50,12 +50,12 @@ function gh10575() {
     property3: string;
   }
 
-  const BaseSchema: Schema<IBase> = new Schema({ prop1: String, prop2: String });
+  const BaseSchema: Schema<unknown, IBase> = new Schema({ prop1: String, prop2: String });
 
-  const Model1Schema: Schema<IModel1> = BaseSchema.clone() as any;
+  const Model1Schema: Schema<unknown, IModel1> = BaseSchema.clone() as any;
   Model1Schema.add({ property1: Number, property2: Number });
 
-  const Model2Schema: Schema<IModel2> = BaseSchema.clone() as any;
+  const Model2Schema: Schema<unknown, IModel2> = BaseSchema.clone() as any;
   Model2Schema.add({ property3: String });
 
   const Model1 = model<IModel1, Model<IModel1>>('m1', Model1Schema);

test/types/methods.test.ts

@@ -1,4 +1,5 @@
-import { Schema, Model, connection } from 'mongoose';
+import { Schema, Model, connection, ObtainSchemaGeneric } from 'mongoose';
+import { expectType } from 'tsd';
 
 interface ITest {
   foo: string;
@@ -10,7 +11,7 @@ interface ITestMethods {
 
 type ITestModel = Model<ITest, {}, ITestMethods>;
 
-const TestSchema = new Schema<ITest, ITestModel, ITestMethods>({
+const TestSchema = new Schema<unknown, ITest, ITestModel, ITestMethods>({
   foo: { type: String, required: true }
 });
 
@@ -26,3 +27,26 @@ Test.create({ foo: 'test' });
 const doc = new Test({ foo: 'test' });
 
 Math.floor(doc.getAnswer());
+
+function autoInferred() {
+  const TestSchema = new Schema({
+    foo: { type: String, required: true }
+  }, {
+    methods: {
+      getAnswer() {
+        console.log(this.foo.trim());
+        return 42;
+      }
+    }
+  });
+
+  const Test = connection.model<typeof TestSchema>('Test', TestSchema);
+  type Methods = ObtainSchemaGeneric<typeof TestSchema, 'TInstanceMethods'>;
+  type Hydrated = ObtainSchemaGeneric<typeof TestSchema, 'THydratedDocumentType'>;
+
+  Test.create({ foo: 'test' });
+
+  const doc = new Test({ foo: 'test' });
+
+  Math.floor(doc.getAnswer());
+}

test/types/middleware.test.ts

@@ -137,7 +137,7 @@ function gh11480(): void {
     name: string;
   };
 
-  const UserSchema = new Schema<IUserSchema>({ name: { type: String } });
+  const UserSchema = new Schema<unknown, IUserSchema>({ name: { type: String } });
 
   UserSchema.pre('save', function(next) {
     expectNotType<any>(this);
@@ -152,7 +152,7 @@ function gh12583() {
     avatar?: string;
   }
 
-  const userSchema = new Schema<IUser>({
+  const userSchema = new Schema<unknown, IUser>({
     name: { type: String, required: true },
     email: { type: String, required: true },
     avatar: String
@@ -172,7 +172,7 @@ function gh11257() {
     avatar?: string;
   }
 
-  const schema = new Schema<User>({
+  const schema = new Schema<unknown, User>({
     name: { type: String, required: true },
     email: { type: String, required: true },
     avatar: String
@@ -211,7 +211,7 @@ function gh15242() {
   type DocumentValidatorThis = HydratedDocument<PostPersisted>;
   type QueryValidatorThis = Query<unknown, PostRecord>;
 
-  const PostSchema = new Schema<PostPersisted>({
+  const PostSchema = new Schema<unknown, PostPersisted>({
     title: { type: String, required: true },
     postTime: {
       type: Date,

test/types/plugin.test.ts

@@ -1,6 +1,6 @@
 import { connection, HydratedDocument, Model, Query, Schema } from 'mongoose';
 
-function pluginVirtuals(schema: Schema<Test, any, any, any, TestVirtuals>): void {
+function pluginVirtuals(schema: Schema<any, Test, any, any, any, TestVirtuals>): void {
   schema.virtual('fullName').get(function(this: TestDocument) {
     return `${this.firstName} ${this.lastName}`;
   });
@@ -9,19 +9,19 @@ function pluginVirtuals(schema: Schema<Test, any, any, any, TestVirtuals>): void
   });
 }
 
-function pluginQueryHelpers(schema: Schema<Test, any, any, TestQueryHelpers>): void {
+function pluginQueryHelpers(schema: Schema<any, Test, any, any, TestQueryHelpers>): void {
   schema.query.whereSomething = function() {
     return this.where({ name: 'something' });
   };
 }
 
-function pluginMethods(schema: Schema<Test, any, TestInstanceMethods>): void {
+function pluginMethods(schema: Schema<any, Test, any, TestInstanceMethods>): void {
   schema.methods.doSomething = function() {
     return 'test';
   };
 }
 
-function pluginStatics(schema: Schema<Test, TestModel, any, TestQueryHelpers, any, TestStaticMethods>): void {
+function pluginStatics(schema: Schema<any, Test, TestModel, any, TestQueryHelpers, any, TestStaticMethods>): void {
   schema.statics.findSomething = function() {
     return this.findOne().orFail().exec();
   };
@@ -54,12 +54,12 @@ interface TestQueryHelpers {
   whereSomething(this: TestQuery): this
 }
 type TestModel = Model<Test, TestQueryHelpers, TestInstanceMethods, TestVirtuals> & TestStaticMethods;
-const testSchema = new Schema<Test, TestModel, TestInstanceMethods, TestQueryHelpers, TestVirtuals, TestStaticMethods>({
+const testSchema = new Schema<any, Test, TestModel, TestInstanceMethods, TestQueryHelpers, TestVirtuals, TestStaticMethods>({
   firstName: { type: String, required: true },
   lastName: { type: String, required: true }
 });
 
-function pluginGeneric(schema: Schema): void {
+function pluginGeneric(schema: Schema<any>): void {
   schema.static('test', function() {
     return 0;
   });