refactor: use strong type in models

export missing

Author: a60814billy

lib/app.ts

@@ -25,6 +25,7 @@ import * as response from "./response";
 import * as models from "./models";
 import * as csp from "./csp";
 import {Environment} from "./config/enum";
+import {checkAllNotesRevision} from "./services/note";
 
 import {checkVersion, versionCheckMiddleware} from "./web/middleware/checkVersion";
 import TooBusyMiddleware from './middleware/tooBusy'
@@ -288,7 +289,7 @@ function startListen() {
 models.sequelize.sync().then(function () {
   // check if realtime is ready
   if (realtime.isReady()) {
-    models.Revision.checkAllNotesRevision(function (err, notes) {
+    checkAllNotesRevision(function (err, notes) {
       if (err) throw new Error(err)
       if (!notes || notes.length <= 0) return startListen()
     })
@@ -327,7 +328,7 @@ function handleTermSignals() {
   })
   const checkCleanTimer = setInterval(function () {
     if (realtime.isReady()) {
-      models.Revision.checkAllNotesRevision(function (err, notes) {
+      checkAllNotesRevision(function (err, notes) {
         if (err) return logger.error(err)
         if (!notes || notes.length <= 0) {
           clearInterval(checkCleanTimer)

lib/models/author.ts

@@ -1,25 +1,40 @@
 // external modules
 
-export = function (sequelize, DataTypes) {
-  const Author = sequelize.define('Author', {
-    id: {
-      type: DataTypes.INTEGER,
-      primaryKey: true,
-      autoIncrement: true
-    },
-    color: {
-      type: DataTypes.STRING
-    }
-  }, {
-    indexes: [
+import {Model, DataTypes} from "sequelize";
+
+export interface AuthorAttributes {
+  id: string
+  color: string
+}
+
+export class Author extends Model<AuthorAttributes> implements AuthorAttributes {
+  color: string;
+  id: string;
+
+  static initialize(sequelize): void {
+    Author.init(
       {
-        unique: true,
-        fields: ['noteId', 'userId']
-      }
-    ]
-  })
+        id: {
+          type: DataTypes.INTEGER,
+          primaryKey: true,
+          autoIncrement: true
+        },
+        color: {
+          type: DataTypes.STRING
+        }
+      },
+      {
+        sequelize,
+        indexes: [
+          {
+            unique: true,
+            fields: ['noteId', 'userId']
+          }
+        ]
+      })
+  }
 
-  Author.associate = function (models) {
+  static associate(models: any): void {
     Author.belongsTo(models.Note, {
       foreignKey: 'noteId',
       as: 'note',
@@ -35,6 +50,4 @@ export = function (sequelize, DataTypes) {
       hooks: true
     })
   }
-
-  return Author
 }

lib/models/baseModel.ts

@@ -0,0 +1,22 @@
+import {Sequelize, Model} from "sequelize";
+
+export type MySequelize = Sequelize & {
+  processData?: any
+  stripNullByte?: any
+}
+
+export type BaseModel<T> = {
+  name: string;
+  initialize(sequelize: Sequelize): void
+  associate(models: any): void
+}
+
+export function StaticImplements<T>(t: T) {
+  return t;
+}
+
+export interface BaseModelStatic extends Model {
+  initialize(sequelize: Sequelize): void
+
+  associate(models: any): void
+}

lib/models/index.ts

@@ -1,13 +1,24 @@
 // external modules
 import * as fs from "fs";
 import * as path from "path";
-import {Sequelize} from "sequelize";
+import {Model, Sequelize} from "sequelize";
 import {cloneDeep} from "lodash";
 
 // core
 import config from "../config";
 import {logger} from "../logger";
 
+
+import {BaseModel} from "./baseModel";
+
+import {Author, AuthorAttributes} from './author'
+import {User, UserAttributes} from './user'
+import {Revision, RevisionAttributes} from "./revision";
+import {Note, NoteAttributes} from './note'
+
+export {Author, User, Revision, Note}
+export {AuthorAttributes, UserAttributes, RevisionAttributes, NoteAttributes}
+
 const dbconfig = cloneDeep(config.db)
 dbconfig.logging = config.debug ? (data) => {
   logger.info(data)
@@ -41,22 +52,16 @@ sequelize.processData = processData
 
 const db: any = {}
 
-fs.readdirSync(__dirname)
-  .filter(function (file) {
-    return (file.indexOf('.') !== 0) && (file !== 'index.js') && file.endsWith('.js')
-  })
-  .forEach(function (file) {
-    const model = sequelize.import(path.join(__dirname, file))
-    db[model.name] = model
-  })
-
-Object.keys(db).forEach(function (modelName) {
-  if ('associate' in db[modelName]) {
-    db[modelName].associate(db)
+const models: BaseModel<Model>[] = [User, Note, Author, Revision]
+
+models.forEach(m => {
+  m.initialize(sequelize)
+  db[m.name] = m
+})
+models.forEach(m => {
+  if ('associate' in m) {
+    m.associate(db)
   }
 })
 
-db.sequelize = sequelize
-db.Sequelize = Sequelize
-
-export = db
+export {sequelize}