Refact some infer-doc-type import lines

lib/schema.js

@@ -108,7 +108,7 @@ function Schema(obj, options) {
   this._indexes = [];
   this.methods = {};
   this.methodOptions = {};
-  this.statics = options?.statics || {};
+  this.statics = (options && options.statics) || {};
   this.tree = {};
   this.query = {};
   this.childSchemas = [];

test/model.test.js

@@ -8117,8 +8117,8 @@ function pick(obj, keys) {
   return newObj;
 }
 
-describe('Check if statics functions that is supplied in schema option is availabe', function() {
-  it('should give an array back rather than undefined m0_0aAutoTyped', function M0_0aModelJS() {
+describe('Check if statics functions that is supplied in schema option is availabe (m0_0a)', function() {
+  it('should give an 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/schema.test.ts

@@ -1,6 +1,5 @@
-import { Schema, Document, SchemaDefinition, Model } from 'mongoose';
+import { Schema, Document, SchemaDefinition, Model, InferSchemaType } from 'mongoose';
 import { expectError, expectType } from 'tsd';
-import { InferSchemaType } from '../../types/infer-doc-type';
 
 enum Genre {
   Action,

types/index.d.ts

@@ -2,12 +2,12 @@
 /// <reference path="./error.d.ts" />
 /// <reference path="./pipelinestage.d.ts" />
 /// <reference path="./schemaoptions.d.ts" />
+/// <reference path="./inferschematype.d.ts" />
 
 import events = require('events');
 import mongodb = require('mongodb');
 import mongoose = require('mongoose');
 import stream = require('stream');
-import { InferSchemaType, ObtainDocumentType, ObtainSchemaGeneric } from './infer-doc-type';
 
 declare module 'mongoose' {
 

types/inferschematype.d.ts

@@ -0,0 +1,49 @@
+import { Schema, InferSchemaType } from 'mongoose';
+
+declare module 'mongoose' {
+  type ObtainDocumentType<DocDefinition, DocType = any> =
+    DoesDocTypeExist<DocType> extends true ? DocType : {
+      [K in keyof (RequiredProperties<DocDefinition> &
+        OptionalProperties<DocDefinition>)]: ObtainDocumentPropertyType<DocDefinition[K]>;
+    };
+
+  type InferSchemaType<SchemaType> = SchemaType extends Schema<infer DocType, any, any, any, infer DocDefinition>
+    ? DoesDocTypeExist<DocType> extends true ? DocType : DocDefinition
+    : unknown;
+
+  type ObtainSchemaGeneric<TSchema, name extends 'DocType' | 'M' | 'TInstanceMethods' | 'TQueryHelpers' | 'DocDefinition' | 'StaticsMethods'> =
+    TSchema extends Schema<infer DocType, infer M, infer TInstanceMethods, infer TQueryHelpers, infer DocDefinition, infer StaticsMethods>
+    ? { DocType: DocType, M: M, TInstanceMethods: TInstanceMethods, TQueryHelpers: TQueryHelpers, DocDefinition: DocDefinition, StaticsMethods: StaticsMethods }[name]
+    : never;
+}
+
+type RequiredPropertyKeys<T> = {
+  [K in keyof T]: T[K] extends { required: true | [true, string | undefined] } ? K : never;
+}[keyof T];
+
+type RequiredProperties<T> = {
+  [K in RequiredPropertyKeys<T>]: T[K];
+};
+
+type OptionalPropertyKeys<T> = {
+  [K in keyof T]: T[K] extends { required: true | [true, string | undefined] } ? never : K;
+}[keyof T];
+
+type OptionalProperties<T> = {
+  [K in OptionalPropertyKeys<T>]?: T[K];
+};
+
+type ResolvePropertyType<PropertyValue> = PropertyValue extends (
+  ...args: any
+) => any
+  ? ReturnType<PropertyValue>
+  : PropertyValue;
+
+type ObtainDocumentPropertyType<PropertyValue> = PropertyValue extends Schema<any>
+  ? InferSchemaType<PropertyValue>
+  : ResolvePropertyType<PropertyValue extends { type: any }
+    ? ResolvePropertyType<PropertyValue['type']>
+    : PropertyValue
+>;
+
+type DoesDocTypeExist<DocType> = keyof DocType extends string ? true : false;