feat: add custom repository support (#4)

Author: kiaking

src/repository/Repository.ts

@@ -1,4 +1,5 @@
 import { Store } from 'vuex'
+import { error } from '../support/Utils'
 import { Constructor } from '../types'
 import { Element, Item, Collection, Collections } from '../data/Data'
 import { Model } from '../model/Model'
@@ -9,7 +10,14 @@ import {
   OrderDirection
 } from '../query/Options'
 
-export class Repository<M extends Model> {
+export class Repository<M extends Model = Model> {
+  /**
+   * A special flag to indicate if this is the repository class or not. It's
+   * used when retrieving repository instance from `store.$repo()` method to
+   * determine whether the passed in class is either a repository or a model.
+   */
+  static _isRepository: boolean = true
+
   /**
    * The store instance.
    */
@@ -18,21 +26,78 @@ export class Repository<M extends Model> {
   /**
    * The model instance.
    */
-  protected model: M
+  protected model!: M
+
+  /**
+   * The model object to be used for the custom repository.
+   */
+  use?: typeof Model
 
   /**
    * Create a new Repository instance.
    */
-  constructor(store: Store<any>, model: Constructor<M>) {
+  constructor(store: Store<any>) {
     this.store = store
-    this.model = new model().$setStore(store)
+  }
+
+  /**
+   * Initialize the repository by setting the model instance.
+   */
+  initialize(model?: Constructor<M>): this {
+    // If there's a model passed in, just use that and return immediately.
+    if (model) {
+      this.model = new model().$setStore(this.store)
+
+      return this
+    }
+
+    // If no model was passed to the initializer, that means the user has
+    // passed repository to the `store.$repo` method instead of a model.
+    // In this case, we'll check if the user has set model to the `use`
+    // property and instantiate that.
+    if (this.use) {
+      this.model = (new this.use() as M).$setStore(this.store)
+
+      return this
+    }
+
+    // Else just return for now. If the user tries to call methods that require
+    // a model, the error will be thrown at that time.
+    return this
+  }
+
+  /**
+   * Get the model instance. If the model is not registered to the repository,
+   * it will throw an error. It happens when users use a custom repository
+   * without setting `use` property.
+   */
+  getModel(): M {
+    if (!this.model) {
+      error([
+        'The model is not registered. Please define the model to be used at',
+        '`use` property of the repository class.'
+      ])
+    }
+
+    return this.model
+  }
+
+  /**
+   * Create a new repository with the given model.
+   */
+  repo<M extends Model>(model: Constructor<M>): Repository<M>
+  repo<R extends Repository<any>>(repository: Constructor<R>): R
+  repo(modelOrRepository: any): any {
+    return modelOrRepository._isRepository
+      ? new modelOrRepository(this.store).initialize()
+      : new Repository(this.store).initialize(modelOrRepository)
   }
 
   /**
    * Create a new Query instance.
    */
   query(): Query<M> {
-    return new Query(this.store, this.model)
+    return new Query(this.store, this.getModel())
   }
 
   /**
@@ -91,7 +156,7 @@ export class Repository<M extends Model> {
    * the store instance to support model instance methods in SSR environment.
    */
   make(attributes?: Element): M {
-    return this.model.$newInstance(attributes, {
+    return this.getModel().$newInstance(attributes, {
       relations: false
     })
   }

src/store/Store.ts

@@ -1,7 +1,5 @@
-import { Constructor } from '../types'
 import { Store, Plugin } from 'vuex'
 import { Database } from '../database/Database'
-import { Model } from '../model/Model'
 import { Repository } from '../repository/Repository'
 import { plugins, components } from '../plugin/Plugin'
 
@@ -84,9 +82,9 @@ function startDatabase(store: Store<any>): void {
  * Mixin repo function to the store.
  */
 function mixinRepoFunction(store: Store<any>): void {
-  store.$repo = function <M extends Model>(
-    model: Constructor<M>
-  ): Repository<M> {
-    return new Repository(this, model)
+  store.$repo = function (modelOrRepository: any): any {
+    return modelOrRepository._isRepository
+      ? new modelOrRepository(this).initialize()
+      : new Repository(this).initialize(modelOrRepository)
   }
 }

src/support/Utils.ts

@@ -199,12 +199,19 @@ export function cloneDeep<T extends object>(target: T): T {
   return target
 }
 
+/**
+ * Throw a new error with the given message.
+ */
+export function error(message: string[]): never {
+  throw new Error(['[Vuex ORM]'].concat(message).join(' '))
+}
+
 /**
  * Check for the given condition, and if it's `false`, it will throw a new
  * error with the given message.
  */
 export function assert(condition: boolean, message: string[]): void {
   if (!condition) {
-    throw new Error(['[Vuex ORM]'].concat(message).join(' '))
+    error(message)
   }
 }

src/types/vuex.ts

@@ -14,5 +14,6 @@ declare module 'vuex' {
      * Get a new Repository instance for the given model.
      */
     $repo<M extends Model>(model: Constructor<M>): Repository<M>
+    $repo<R extends Repository<any>>(repository: Constructor<R>): R
   }
 }

test/feature/repository_custom/custom_repository.spec.ts

@@ -0,0 +1,57 @@
+import { createStore } from 'test/Helpers'
+import { Model, Attr, Str, Repository } from '@/index'
+
+describe('feature/repository_custom/custom_repository', () => {
+  it('can define a custom repository', async () => {
+    class User extends Model {
+      static entity = 'users'
+
+      @Attr() id!: any
+      @Str('') name!: string
+    }
+
+    class UserRepository extends Repository<User> {
+      use: typeof User = User
+
+      custom(): number {
+        return 1
+      }
+    }
+
+    const store = createStore([User])
+
+    const userRepo = store.$repo(UserRepository)
+
+    expect(userRepo.custom()).toBe(1)
+  })
+
+  it('can define an abstract custom repository', async () => {
+    class ARepository extends Repository {
+      custom(): number {
+        return 1
+      }
+    }
+
+    const store = createStore([])
+
+    const userRepo = store.$repo(ARepository)
+
+    expect(userRepo.custom()).toBe(1)
+  })
+
+  it('throws if the user tries to access the model in abstract custom repository', async () => {
+    class ARepository extends Repository {
+      custom(): any {
+        this.getModel()
+      }
+    }
+
+    const store = createStore([])
+
+    const userRepo = store.$repo(ARepository)
+
+    expect(() => {
+      userRepo.custom()
+    }).toThrow()
+  })
+})

test/unit/repository/Repository.spec.ts

@@ -1,5 +1,5 @@
 import { createStore, assertModel } from 'test/Helpers'
-import { Model, Attr, Str } from '@/index'
+import { Model, Attr, Str, Repository } from '@/index'
 
 describe('unit/repository/Repository', () => {
   class User extends Model {
@@ -9,6 +9,13 @@ describe('unit/repository/Repository', () => {
     @Str('John Doe') name!: string
   }
 
+  class Post extends Model {
+    static entity = 'posts'
+
+    @Attr() id!: any
+    @Str('Title 001') title!: string
+  }
+
   it('creates a new model instance', () => {
     const store = createStore([User])
 
@@ -31,4 +38,28 @@ describe('unit/repository/Repository', () => {
     expect(user.$store).toBe(store)
     assertModel(user, { id: 1, name: 'Jane Doe' })
   })
+
+  it('can create a new repository from the model', () => {
+    const store = createStore([User, Post])
+
+    const userRepo = store.$repo(User)
+
+    const postRepo = userRepo.repo(Post)
+
+    expect(postRepo.getModel()).toBeInstanceOf(Post)
+  })
+
+  it('can create a new repository from the custom repository', () => {
+    class PostRepository extends Repository<Post> {
+      use: typeof Post = Post
+    }
+
+    const store = createStore([User, Post])
+
+    const userRepo = store.$repo(User)
+
+    const postRepo = userRepo.repo(PostRepository)
+
+    expect(postRepo.getModel()).toBeInstanceOf(Post)
+  })
 })