WIP: experiment with switching Schema -> AutoInferredSchema re: #14962 #14954

vkarpov15 · vkarpov15 · commit 5b8a93a1b89a · 2025-05-20T15:51:22.000-04:00
diff --git a/test/types/connection.test.ts b/test/types/connection.test.ts
@@ -9,7 +9,7 @@ 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 +132,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: {
diff --git a/test/types/docArray.test.ts b/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
diff --git a/test/types/inferrawdoctype.test.ts b/test/types/inferrawdoctype.test.ts
@@ -1,4 +1,4 @@
-import { InferRawDocType, Schema, AutoInferredSchema } from 'mongoose';
+import { InferRawDocType, Schema } from 'mongoose';
 import { expectType, expectError } from 'tsd';
 
 function gh14839() {
@@ -18,10 +18,10 @@ function gh14839() {
       type: Date,
       required: true
     },
-    subdoc: new AutoInferredSchema({
+    subdoc: new Schema({
       name: { type: String, required: true }
     }),
-    docArr: [new AutoInferredSchema({ test: { type: String, required: true } })]
+    docArr: [new Schema({ test: { type: String, required: true } })]
   };
 
   type UserType = InferRawDocType<typeof schemaDefinition>;
@@ -51,13 +51,13 @@ function gh14954() {
       type: Date,
       required: true
     },
-    subdoc: new AutoInferredSchema({
+    subdoc: new Schema({
       name: { type: String, required: true },
-      l2: new AutoInferredSchema({
+      l2: new Schema({
         myProp: { type: Number, required: true }
       })
     }),
-    docArr: [new AutoInferredSchema({ test: { type: String, required: true } })]
+    docArr: [new Schema({ test: { type: String, required: true } })]
   };
 
   type UserType = InferRawDocType<typeof schemaDefinition>;
diff --git a/test/types/maps.test.ts b/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<any, ITest>({
   map1: {
     type: Map,
     of: Number
@@ -50,7 +50,7 @@ function gh10575() {
     property3: string;
   }
 
-  const BaseSchema: Schema<IBase> = new Schema({ prop1: String, prop2: String });
+  const BaseSchema: Schema<any, IBase> = new Schema<any, IBase>({ prop1: String, prop2: String });
 
   const Model1Schema: Schema<IModel1> = BaseSchema.clone() as any;
   Model1Schema.add({ property1: Number, property2: Number });
diff --git a/test/types/methods.test.ts b/test/types/methods.test.ts
@@ -10,7 +10,7 @@ interface ITestMethods {
 
 type ITestModel = Model<ITest, {}, ITestMethods>;
 
-const TestSchema = new Schema<ITest, ITestModel, ITestMethods>({
+const TestSchema = new Schema<any, ITest, ITestModel, ITestMethods>({
   foo: { type: String, required: true }
 });
 
diff --git a/test/types/middleware.test.ts b/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<any, 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<any, 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<any, 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,
diff --git a/test/types/plugin.test.ts b/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,7 +54,7 @@ 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 }
 });
diff --git a/test/types/querycursor.test.ts b/test/types/querycursor.test.ts
@@ -1,7 +1,7 @@
-import { Schema, model, Model, Types } from 'mongoose';
+import { Schema, model, Model, Types, InferRawDocTypeFromSchema, InferRawDocType } from 'mongoose';
 import { expectType } from 'tsd';
 
-const schema = new Schema({ name: { type: 'String' } });
+const schema = new Schema({ name: { type: String } });
 
 const Test = model('Test', schema);
 
diff --git a/test/types/queryhelpers.test.ts b/test/types/queryhelpers.test.ts
@@ -13,7 +13,7 @@ interface ProjectQueryHelpers {
   byName(this: ProjectModelQuery, name: string): ProjectModelQuery;
 }
 
-const schema = new Schema<Project, ProjectModelType, {}, ProjectQueryHelpers>({
+const schema = new Schema<any, Project, ProjectModelType, {}, ProjectQueryHelpers>({
   name: { type: String, required: true },
   stars: { type: Number, required: true }
 });
diff --git a/test/types/subdocuments.test.ts b/test/types/subdocuments.test.ts
@@ -47,7 +47,7 @@ async function gh10597(): Promise<void> {
     name: string;
     events: IGameEventDocument[]
   }
-  const schema = new Schema<IGameDocument>({ name: String, events: [{ description: String }] });
+  const schema = new Schema<any, IGameDocument>({ name: String, events: [{ description: String }] });
 
   const GameModel = model<IGameDocument>('Game', schema);
 
@@ -66,7 +66,7 @@ function gh10674() {
 
   type FooModel = Model<Foo>;
 
-  const FooSchema = new Schema<Foo, FooModel, Foo>(
+  const FooSchema = new Schema<any, Foo, FooModel, Foo>(
     {
       bar: { type: String },
       schedule: {
diff --git a/test/types/virtuals.test.ts b/test/types/virtuals.test.ts
@@ -21,13 +21,13 @@ interface PetVirtuals {
   owner: IPerson;
 }
 
-const personSchema = new Schema<IPerson & Document, Model<IPerson & Document>, IPerson>({
+const personSchema = new Schema<unknown, IPerson & Document, Model<IPerson & Document>, IPerson>({
   _id: { type: Number, required: true },
   firstName: { type: String, required: true },
   lastName: { type: String, required: true }
 });
 
-const petSchema = new Schema<IPet & Document, Model<IPet & Document>, IPet>({
+const petSchema = new Schema<unknown, IPet & Document, Model<IPet & Document>, IPet>({
   name: { type: String, required: true },
   ownerId: { type: Number, required: true },
   isDeleted: { type: Boolean, default: false }
@@ -78,7 +78,7 @@ const Pet = model<IPet>('Pet', petSchema);
 })();
 
 function gh11543() {
-  const personSchema = new Schema<IPerson, Model<IPerson, {}, {}, PetVirtuals>, {}, {}, PetVirtuals>({
+  const personSchema = new Schema<unknown, IPerson, Model<IPerson, {}, {}, PetVirtuals>, {}, {}, PetVirtuals>({
     _id: { type: Number, required: true },
     firstName: { type: String, required: true },
     lastName: { type: String, required: true }
diff --git a/types/connection.d.ts b/types/connection.d.ts
@@ -194,11 +194,11 @@ declare module 'mongoose' {
     TSchema> & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
     model<T, U, TQueryHelpers = {}>(
       name: string,
-      schema?: Schema<T, any, any, TQueryHelpers, any, any, any>,
+      schema?: Schema<any, T, any, any, TQueryHelpers, any, any, any>,
       collection?: string,
       options?: CompileModelOptions
     ): U;
-    model<T>(name: string, schema?: Schema<T, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
+    model<T>(name: string, schema?: Schema<any, T, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
 
     /** Returns an array of model names created on this connection. */
     modelNames(): Array<string>;
diff --git a/types/index.d.ts b/types/index.d.ts
@@ -97,11 +97,11 @@ declare module 'mongoose' {
   TSchema
   > & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
 
-  export function model<T>(name: string, schema?: Schema<T, any, any> | Schema<T & Document, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
+  export function model<T>(name: string, schema?: Schema<any, T, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
 
   export function model<T, U, TQueryHelpers = {}>(
     name: string,
-    schema?: Schema<T, any, any, TQueryHelpers, any, any, any>,
+    schema?: Schema<any, T, U, any, TQueryHelpers, any, any, any>,
     collection?: string,
     options?: CompileModelOptions
   ): U;
@@ -256,9 +256,9 @@ declare module 'mongoose' {
     TInstanceMethods,
     TQueryHelpers,
     TVirtuals,
-    TStaticMethods> = (schema: Schema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>, opts?: any) => void;
+    TStaticMethods> = (schema: Schema<any, DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>, opts?: any) => void;
 
-  export class AutoInferredSchema<
+  export class Schema<
     SchemaDef = unknown,
     RawDocType = InferRawDocType<SchemaDef>,
     TModelType = Model<RawDocType, any, any, any>,
@@ -275,35 +275,15 @@ declare module 'mongoose' {
       ResolveSchemaOptions<TSchemaOptions>
     >,
     THydratedDocumentType = HydratedDocument<FlatRecord<DocType>, TVirtuals & TInstanceMethods>
-  > extends Schema<RawDocType, TModelType, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods, TSchemaOptions, DocType, THydratedDocumentType> {
-    constructor(definition: SchemaDef, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
-  }
-
-  export class Schema<
-    RawDocType = any,
-    TModelType = Model<RawDocType, any, any, any>,
-    TInstanceMethods = {},
-    TQueryHelpers = {},
-    TVirtuals = {},
-    TStaticMethods = {},
-    TSchemaOptions = DefaultSchemaOptions,
-    DocType extends ApplySchemaOptions<
-      ObtainDocumentType<DocType, RawDocType, ResolveSchemaOptions<TSchemaOptions>>,
-      ResolveSchemaOptions<TSchemaOptions>
-    > = ApplySchemaOptions<
-      ObtainDocumentType<any, RawDocType, ResolveSchemaOptions<TSchemaOptions>>,
-      ResolveSchemaOptions<TSchemaOptions>
-    >,
-    THydratedDocumentType = HydratedDocument<FlatRecord<DocType>, TVirtuals & TInstanceMethods, {}, TVirtuals>
   >
     extends events.EventEmitter {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType, THydratedDocumentType> | DocType, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
+    constructor(definition: SchemaDef, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
 
     /** Adds key path / schema type pairs to this schema. */
-    add(obj: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType> | Schema, prefix?: string): this;
+    add(obj: AnyObject, prefix?: string): this;
 
     /**
      * Add an alias for `path`. This means getting or setting the `alias`
@@ -371,7 +351,7 @@ declare module 'mongoose' {
     methods: AddThisParameter<TInstanceMethods, THydratedDocumentType> & AnyObject;
 
     /** The original object passed to the schema constructor */
-    obj: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType>;
+    obj: SchemaDef;
 
     /** Returns a new schema that has the `paths` from the original schema, minus the omitted ones. */
     omit<T = this>(paths: string[], options?: SchemaOptions): T;
diff --git a/types/inferrawdoctype.d.ts b/types/inferrawdoctype.d.ts
diff --git a/types/inferschematype.d.ts b/types/inferschematype.d.ts
diff --git a/types/utility.d.ts b/types/utility.d.ts

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ async function gh10293() {`
`7`	`7`	`arrayOfArray: string[][]; // <-- Array of Array`
`8`	`8`	`}`
`9`	`9`
`10`		`- const testSchema = new Schema<ITest>({`
	`10`	`+ const testSchema = new Schema<unknown, ITest>({`
`11`	`11`	`name: {`
`12`	`12`	`type: String,`
`13`	`13`	`required: true`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ interface ITest {`
`7`	`7`	`map3: Map<string, number>`
`8`	`8`	`}`
`9`	`9`
`10`		`-const schema: Schema = new Schema<ITest>({`
	`10`	`+const schema = new Schema<any, ITest>({`
`11`	`11`	`map1: {`
`12`	`12`	`type: Map,`
`13`	`13`	`of: Number`
`@@ -50,7 +50,7 @@ function gh10575() {`
`50`	`50`	`property3: string;`
`51`	`51`	`}`
`52`	`52`
`53`		`- const BaseSchema: Schema<IBase> = new Schema({ prop1: String, prop2: String });`
	`53`	`+ const BaseSchema: Schema<any, IBase> = new Schema<any, IBase>({ prop1: String, prop2: String });`
`54`	`54`
`55`	`55`	`const Model1Schema: Schema<IModel1> = BaseSchema.clone() as any;`
`56`	`56`	`Model1Schema.add({ property1: Number, property2: Number });`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ interface ProjectQueryHelpers {`
`13`	`13`	`byName(this: ProjectModelQuery, name: string): ProjectModelQuery;`
`14`	`14`	`}`
`15`	`15`
`16`		`-const schema = new Schema<Project, ProjectModelType, {}, ProjectQueryHelpers>({`
	`16`	`+const schema = new Schema<any, Project, ProjectModelType, {}, ProjectQueryHelpers>({`
`17`	`17`	`name: { type: String, required: true },`
`18`	`18`	`stars: { type: Number, required: true }`
`19`	`19`	`});`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ async function gh10597(): Promise<void> {`
`47`	`47`	`name: string;`
`48`	`48`	`events: IGameEventDocument[]`
`49`	`49`	`}`
`50`		`- const schema = new Schema<IGameDocument>({ name: String, events: [{ description: String }] });`
	`50`	`+ const schema = new Schema<any, IGameDocument>({ name: String, events: [{ description: String }] });`
`51`	`51`
`52`	`52`	`const GameModel = model<IGameDocument>('Game', schema);`
`53`	`53`
`@@ -66,7 +66,7 @@ function gh10674() {`
`66`	`66`
`67`	`67`	`type FooModel = Model<Foo>;`
`68`	`68`
`69`		`- const FooSchema = new Schema<Foo, FooModel, Foo>(`
	`69`	`+ const FooSchema = new Schema<any, Foo, FooModel, Foo>(`
`70`	`70`	`{`
`71`	`71`	`bar: { type: String },`
`72`	`72`	`schedule: {`