refactor: refactor types

src/database.ts

@@ -118,7 +118,7 @@ class Database {
    * @param {Schema|object} [schema]
    * @return {Model}
    */
-  model(name: string, schema?: Schema | Record<string, AddSchemaTypeOptions>): Model<any> {
+  model<T>(name: string, schema?: Schema<T> | Record<string, AddSchemaTypeOptions>): Model<any> {
     if (this._models[name]) {
       return this._models[name];
     }

src/document.ts

@@ -7,7 +7,7 @@ const cloneDeep = rfdc();
 abstract class Document<T> {
   abstract _model: Model<T>;
   _id!: string | number | undefined;
-  abstract _schema: Schema;
+  abstract _schema: Schema<T>;
   [key : string]: any;
 
   /**

src/model.ts

@@ -16,7 +16,7 @@ import type { AddSchemaTypeOptions, NodeJSLikeCallback, Options, PopulateResult
 class Model<T> extends EventEmitter {
   _mutex = new Mutex();
   data: Record<PropertyKey, T> = {};
-  schema: Schema;
+  schema: Schema<T>;
   length = 0;
   Document;
   Query;
@@ -28,10 +28,10 @@ class Model<T> extends EventEmitter {
    * @param {string} name Model name
    * @param {Schema|object} [schema_] Schema
    */
-  constructor(public name: string, schema_: Schema | Record<string, AddSchemaTypeOptions>) {
+  constructor(public name: string, schema_: Schema<T> | Record<string, AddSchemaTypeOptions>) {
     super();
 
-    let schema: Schema;
+    let schema: Schema<T>;
 
     // Define schema
     if (schema_ instanceof Schema) {
@@ -51,7 +51,7 @@ class Model<T> extends EventEmitter {
 
     class _Document<T> extends Document<T> {
       _model!: Model<T>;
-      _schema!: Schema;
+      _schema!: Schema<T>;
       constructor(data: T) {
         super(data);
 
@@ -67,7 +67,7 @@ class Model<T> extends EventEmitter {
 
     class _Query<T> extends Query<T> {
       _model!: Model<T>;
-      _schema!: Schema;
+      _schema!: Schema<T>;
     }
 
     this.Query = _Query;
@@ -963,7 +963,7 @@ class Model<T> extends EventEmitter {
 
 Model.prototype.get = Model.prototype.findById;
 
-function execHooks(schema: Schema, type: string, event: string, data: any): Promise<any> {
+function execHooks(schema: Schema<any>, type: string, event: string, data: any): Promise<any> {
   const hooks = schema.hooks[type][event] as ((data: any) => Promise<void> | void)[];
   if (!hooks.length) return Promise.resolve(data);
 

src/query.ts

@@ -9,7 +9,7 @@ abstract class Query<T> {
   data: Document<T>[];
   length: number;
   abstract _model: Model<T>;
-  abstract _schema: Schema;
+  abstract _schema: Schema<T>;
 
   /**
    * Query constructor.

src/schema.ts

@@ -6,6 +6,7 @@ import PopulationError from './error/population';
 import SchemaTypeVirtual from './types/virtual';
 import { isPlainObject } from 'is-plain-object';
 import type { AddSchemaTypeLoopOptions, AddSchemaTypeOptions, PopulateResult, SchemaTypeOptions } from './types';
+import type Model from './model';
 
 /**
  * @callback queryFilterCallback
@@ -379,7 +380,7 @@ class QueryParser {
 }
 
 
-class Schema {
+class Schema<T> {
   paths: Record<string, SchemaType<any>> = {};
   statics: Record<string, (...args: any[]) => any> = {};
   methods: Record<string, (...args: any[]) => any> = {};
@@ -557,7 +558,7 @@ class Schema {
    * @param {Function} [getter]
    * @return {SchemaType.Virtual}
    */
-  virtual(name: string, getter?: () => any): SchemaTypeVirtual {
+  virtual(name: string, getter?: (this: T) => any): SchemaTypeVirtual<T> {
     const virtual = new Types.Virtual(name, {});
     if (getter) virtual.get(getter);
 
@@ -614,7 +615,7 @@ class Schema {
    * @param {String} name
    * @param {Function} fn
    */
-  static(name: string, fn: (...args: any[]) => any) {
+  static(name: string, fn: (this: Model<T>, ...args: any[]) => any) {
     if (!name) throw new TypeError('Method name is required!');
 
     if (typeof fn !== 'function') {

src/types/virtual.ts

@@ -4,8 +4,8 @@ import { setGetter } from '../util';
 /**
  * Virtual schema type.
  */
-class SchemaTypeVirtual extends SchemaType<any> {
-  getter: (() => any) | undefined;
+class SchemaTypeVirtual<T> extends SchemaType<any> {
+  getter: ((this: T) => any) | undefined;
   setter: ((value: any) => void) | undefined;
 
   /**
@@ -14,7 +14,7 @@ class SchemaTypeVirtual extends SchemaType<any> {
    * @param {Function} fn
    * @chainable
    */
-  get(fn: () => any): SchemaTypeVirtual {
+  get(fn: (this: T) => any): SchemaTypeVirtual<T> {
     if (typeof fn !== 'function') {
       throw new TypeError('Getter must be a function!');
     }
@@ -30,7 +30,7 @@ class SchemaTypeVirtual extends SchemaType<any> {
    * @param {Function} fn
    * @chainable
    */
-  set(fn: (value: any) => void): SchemaTypeVirtual {
+  set(fn: (this: T, value: any) => void): SchemaTypeVirtual<T> {
     if (typeof fn !== 'function') {
       throw new TypeError('Setter must be a function!');
     }

test/scripts/model.ts

@@ -37,7 +37,15 @@
 
   const db = new Database();
 
-  const userSchema = new Schema({
+  const userSchema = new Schema<{
+    name: {
+      first: string;
+      last: string;
+    }
+    email: string;
+    age: number;
+    posts: string[];
+  }>({
     name: {
       first: String,
       last: String
@@ -68,7 +76,7 @@
       age: 20
     });
 
     user._id!.should.exist;
     user.name.first.should.eql('John');
     user.name.last.should.eql('Doe');
     user.name.full.should.eql('John Doe');
@@ -688,7 +696,7 @@
     {age: 30},
     {age: 40}
   ]).then(data => {
     (User.findOne({age: {$gt: 20}}, {lean: true}) as Document<UserType>)._id!.should.eql(data[2]._id);
     return data;
   }).map<unknown, any>(item => User.removeById(item._id)));
 

test/scripts/types/virtual.ts

@@ -3,7 +3,7 @@ const should = chai.should(); // eslint-disable-line
 import SchemaTypeVirtual from '../../../dist/types/virtual';
 
 describe('SchemaTypeVirtual', () => {
-  const type = new SchemaTypeVirtual('test');
+  const type = new SchemaTypeVirtual<any>('test');
 
   it('get()', () => {
     const getter = () => 'foo';