feat: add automatic database registration support

Author: kiaking

src/database/Database.ts

@@ -1,10 +1,8 @@
-import { Store, Module as VuexModule } from 'vuex'
+import { Store } from 'vuex'
 import { schema as Normalizr } from 'normalizr'
-import { Constructor } from '../types'
 import { Schema } from '../schema/Schema'
 import { Model } from '../model/Model'
-import { RootModule } from '../modules/RootModule'
-import { Module } from '../modules/Module'
+import { Relation } from '../model/attributes/relations/Relation'
 import { State } from '../modules/State'
 import { mutations, Mutations } from '../modules/Mutations'
 
@@ -36,15 +34,6 @@ export class Database {
    */
   started: boolean = false
 
-  /**
-   * Register the given model.
-   */
-  register(model: Constructor<Model>): void {
-    const instance = new model()
-
-    this.models[instance.$entity] = instance
-  }
-
   /**
    * Set the store.
    */
@@ -67,101 +56,81 @@ export class Database {
    * Initialize the database before a user can start using it.
    */
   start(): void {
-    this.injectStoreToModels()
-
-    this.createSchemas()
-
-    this.registerModules()
+    this.createRootModule()
 
     this.started = true
   }
 
   /**
-   * Get a model by the specified entity name.
+   * Register the given model.
    */
-  getModel<M extends Model>(name: string): M {
-    return this.models[name] as M
-  }
+  register<M extends Model>(model: M): void {
+    if (!this.models[model.$entity]) {
+      this.models[model.$entity] = model
 
-  /**
-   * Get schema by the specified entity name.
-   */
-  getSchema(name: string): Normalizr.Entity {
-    return this.schemas[name]
-  }
+      this.createModule(model)
 
-  /**
-   * Inject the store instance to all registered models.
-   */
-  private injectStoreToModels(): void {
-    for (const name in this.models) {
-      this.models[name].$setStore(this.store)
-    }
-  }
+      this.createSchema(model)
 
-  /**
-   * Create the schema definition from registered models and set it to the
-   * `schema` property. This schema will be used by the Interpreter to interpret
-   * the data before persisting them to the store.
-   */
-  private createSchemas(): void {
-    for (const name in this.models) {
-      this.schemas[name] = this.createSchema(this.models[name])
+      this.registerRelatedModels(model)
     }
   }
 
   /**
-   * Create schema from the given model.
+   * Register all related models.
    */
-  private createSchema<M extends Model>(model: M): Normalizr.Entity {
-    return new Schema(model).one()
+  private registerRelatedModels<M extends Model>(model: M): void {
+    for (const name in model.$fields) {
+      const attr = model.$fields[name]
+
+      if (attr instanceof Relation) {
+        attr.getRelateds().forEach((m) => {
+          this.register(m.$setStore(this.store))
+        })
+      }
+    }
   }
 
   /**
-   * Generate modules and register them to the store.
+   * Get a model by the specified entity name.
    */
-  private registerModules(): void {
-    this.store.registerModule(this.connection, this.createModule())
+  getModel<M extends Model>(name: string): M {
+    return this.models[name] as M
   }
 
   /**
-   * Create modules from the registered models and modules.
+   * Get schema by the specified entity name.
    */
-  private createModule(): VuexModule<any, any> {
-    const module = this.createRootModule()
-
-    for (const name in this.models) {
-      module.modules[name] = this.createSubModule()
-    }
-
-    return module
+  getSchema(name: string): Normalizr.Entity {
+    return this.schemas[name]
   }
 
   /**
    * Create root module.
    */
-  private createRootModule(): RootModule {
-    return {
-      namespaced: true,
-      modules: {}
-    }
+  private createRootModule(): void {
+    this.store.registerModule(this.connection, {
+      namespaced: true
+    })
   }
 
   /**
    * Create sub module.
    */
-  private createSubModule(): Module<State, any> {
-    return {
+  private createModule<M extends Model>(model: M): void {
+    const preserveState = !!this.store.state[this.connection][model.$entity]
+
+    this.store.registerModule([this.connection, model.$entity], {
       namespaced: true,
-      state: this.createSubState(),
-      mutations: this.createSubMutations()
-    }
+      state: this.createState(),
+      mutations: this.createMutations()
+    }, { preserveState })
   }
 
   /**
    * Create sub state.
    */
-  private createSubState(): State {
+  private createState(): State {
     return {
       data: {}
     }
@@ -170,7 +139,14 @@ export class Database {
   /**
    * Create sub mutations.
    */
-  private createSubMutations(): Mutations<State> {
+  private createMutations(): Mutations<State> {
     return mutations
   }
+
+  /**
+   * Create schema from the given model.
+   */
+  private createSchema<M extends Model>(model: M): Normalizr.Entity {
+    return this.schemas[model.$entity] = new Schema(model).one()
+  }
 }

src/model/attributes/relations/BelongsTo.ts

@@ -40,6 +40,13 @@ export class BelongsTo extends Relation {
     this.child = child
   }
 
+  /**
+   * Get all related models for the relationship.
+   */
+  getRelateds(): Model[] {
+    return [this.child]
+  }
+
   /**
    * Define the normalizr schema for the relation.
    */

src/model/attributes/relations/HasMany.ts

@@ -30,6 +30,13 @@ export class HasMany extends Relation {
     this.localKey = localKey
   }
 
+  /**
+   * Get all related models for the relationship.
+   */
+  getRelateds(): Model[] {
+    return [this.related]
+  }
+
   /**
    * Define the normalizr schema for the relation.
    */

src/model/attributes/relations/HasOne.ts

@@ -30,6 +30,13 @@ export class HasOne extends Relation {
     this.localKey = localKey
   }
 
+  /**
+   * Get all related models for the relationship.
+   */
+  getRelateds(): Model[] {
+    return [this.related]
+  }
+
   /**
    * Define the normalizr schema for the relation.
    */

src/model/attributes/relations/Relation.ts

@@ -29,10 +29,15 @@ export abstract class Relation extends Attribute {
     this.related = related
   }
 
+  /**
+   * Get all related models for the relationship.
+   */
+  abstract getRelateds(): Model[]
+
   /**
    * Get the related model of the relation.
    */
-  public getRelated(): Model {
+  getRelated(): Model {
     return this.related
   }
 

src/modules/Mutations.ts

@@ -3,20 +3,12 @@ import { Elements } from '../data/Data'
 import { State } from './State'
 
 export interface Mutations<S extends State> extends MutationTree<S> {
-  mutate(state: S, callback: (state: S) => void): void
   insert(state: S, records: Elements): void
   update(state: S, records: Elements): void
   delete(state: S, ids: string[]): void
   flush(state: S): void
 }
 
-/**
- * Execute a generic mutation.
- */
-function mutate(state: State, callback: (state: State) => void): void {
-  callback(state)
-}
-
 /**
  * Commit `insert` change to the store.
  */
@@ -54,7 +46,6 @@ function flush(state: State): void {
 }
 
 export const mutations = {
-  mutate,
   insert,
   update,
   delete: destroy,

src/plugin/Plugin.ts

@@ -19,7 +19,6 @@ import { mutations, Mutations } from '../modules/Mutations'
 export interface VuexORMPlugin {
   install(
     store: Store<any>,
-    database: Database,
     components: VuexORMPluginComponents,
     options: any
   ): void

src/store/Store.ts

@@ -12,12 +12,9 @@ type FilledInstallOptions = Required<InstallOptions>
 /**
  * Install Vuex ORM to the store.
  */
-export function install(
-  database: Database,
-  options?: InstallOptions
-): Plugin<any> {
+export function install(options?: InstallOptions): Plugin<any> {
   return (store) => {
-    mixin(store, database, createOptions(options))
+    mixin(store, createOptions(options))
   }
 }
 
@@ -33,42 +30,39 @@ function createOptions(options: InstallOptions = {}): FilledInstallOptions {
 /**
  * Mixin Vuex ORM feature to the store.
  */
-function mixin(
-  store: Store<any>,
-  database: Database,
-  options: FilledInstallOptions
-): void {
-  installPlugins(store, database)
+function mixin(store: Store<any>, options: FilledInstallOptions ): void {
+  createDatabase(store, options)
 
-  connectDatabase(store, database, options)
+  installPlugins(store)
 
   mixinRepoFunction(store)
 
   startDatabase(store)
 }
 
 /**
- * Execute registered plugins.
+ * Create a new database and connect to the store.
  */
-function installPlugins(store: Store<any>, database: Database): void {
-  plugins.forEach((plugin) => {
-    const { func, options } = plugin
+function createDatabase(
+  store: Store<any>,
+  options: FilledInstallOptions
+): void {
+  const database = new Database()
+    .setStore(store)
+    .setConnection(options.namespace)
 
-    func.install(store, database, components, options)
-  })
+  store.$database = database
 }
 
 /**
- * Connect the database to the store.
+ * Execute registered plugins.
  */
-function connectDatabase(
-  store: Store<any>,
-  database: Database,
-  options: FilledInstallOptions
-): void {
-  database.setStore(store).setConnection(options.namespace)
+function installPlugins(store: Store<any>): void {
+  plugins.forEach((plugin) => {
+    const { func, options } = plugin
 
-  store.$database = database
+    func.install(store, components, options)
+  })
 }
 
 /**
@@ -83,8 +77,15 @@ function startDatabase(store: Store<any>): void {
  */
 function mixinRepoFunction(store: Store<any>): void {
   store.$repo = function (modelOrRepository: any): any {
-    return modelOrRepository._isRepository
+    const repository = modelOrRepository._isRepository
       ? new modelOrRepository(this).initialize()
       : new Repository(this).initialize(modelOrRepository)
+
+    try {
+      store.$database.register(repository.getModel())
+    } catch (e) {
+    } finally {
+      return repository
+    }
   }
 }