feat: add model $delete method

Author: kiaking

src/model/Model.ts

@@ -1,6 +1,7 @@
 import { Store } from 'vuex'
 import { isNullish, isArray, assert } from '../support/Utils'
 import { Element, Item, Collection } from '../data/Data'
+import { Query } from '../query/Query'
 import { NonEnumerable } from './decorators/NonEnumerable'
 import { Attribute } from './attributes/Attribute'
 import { Attr } from './attributes/types/Attr'
@@ -253,12 +254,10 @@ export class Model {
   }
 
   /**
-   * Set the store instance.
+   * Get the model fields for this model.
    */
-  $setStore(store: Store<any>): this {
-    this._store = store
-
-    return this
+  get $fields(): ModelFields {
+    return this.$self.schemas[this.$entity]
   }
 
   /**
@@ -275,10 +274,19 @@ export class Model {
   }
 
   /**
-   * Get the model fields for this model.
+   * Create a new query instance.
    */
-  get $fields(): ModelFields {
-    return this.$self.schemas[this.$entity]
+  $query(): Query<this> {
+    return new Query(this.$store, this)
+  }
+
+  /**
+   * Set the store instance.
+   */
+  $setStore(store: Store<any>): this {
+    this._store = store
+
+    return this
   }
 
   /**
@@ -450,6 +458,37 @@ export class Model {
     return this.$toJson(this, { relations: false })
   }
 
+  /**
+   * Delete the model from the database.
+   */
+  async $delete(): Promise<boolean> {
+    const key = this.$getKeyName()
+
+    return isArray(key)
+      ? this.$deleteByCompositeKeyName(key)
+      : this.$deleteByKeyName(key)
+  }
+
+  /**
+   * Delete the model from the database by ID.
+   */
+  protected async $deleteByKeyName(key: string): Promise<boolean> {
+    return !!(await this.$query().destroy(this[key]))
+  }
+
+  /**
+   * Delete the model from the database by composite key.
+   */
+  protected async $deleteByCompositeKeyName(keys: string[]): Promise<boolean> {
+    const query = this.$query()
+
+    keys.forEach((key) => {
+      query.where(key, this[key])
+    })
+
+    return (await query.delete()).length > 0
+  }
+
   /**
    * Serialize this model, or the given model, as POJO.
    */

src/query/Options.ts

@@ -1,4 +1,3 @@
-import { Model } from '../model/Model'
 import { Query } from './Query'
 
 export interface Where {
@@ -16,12 +15,12 @@ export interface WhereGroup {
   or?: Where[]
 }
 
-export interface Order<M extends Model> {
-  field: OrderBy<M>
+export interface Order {
+  field: OrderBy
   direction: OrderDirection
 }
 
-export type OrderBy<M extends Model> = string | ((model: M) => any)
+export type OrderBy = string | ((model: any) => any)
 
 export type OrderDirection = 'asc' | 'desc'
 

src/query/Query.ts

@@ -65,7 +65,7 @@ export class Query<M extends Model = Model> {
   /**
    * The orderings for the query.
    */
-  protected orders: Order<M>[] = []
+  protected orders: Order[] = []
 
   /**
    * The maximum number of records to return.
@@ -150,7 +150,7 @@ export class Query<M extends Model = Model> {
   /**
    * Add an "order by" clause to the query.
    */
-  orderBy(field: OrderBy<M>, direction: OrderDirection = 'asc'): Query<M> {
+  orderBy(field: OrderBy, direction: OrderDirection = 'asc'): Query<M> {
     this.orders.push({ field, direction })
 
     return this
@@ -286,7 +286,7 @@ export class Query<M extends Model = Model> {
   /**
    * Get comparator for the where clause.
    */
-  protected getWhereComparator(): (model: M) => boolean {
+  protected getWhereComparator(): (model: any) => boolean {
     const { and, or } = groupBy(this.wheres, (where) => where.boolean)
 
     return (model) => {

src/repository/Repository.ts

@@ -122,7 +122,7 @@ export class Repository<M extends Model = Model> {
   /**
    * Add an "order by" clause to the query.
    */
-  orderBy(field: OrderBy<M>, direction?: OrderDirection): Query<M> {
+  orderBy(field: OrderBy, direction?: OrderDirection): Query<M> {
     return this.query().orderBy(field, direction)
   }
 

src/support/Utils.ts

@@ -4,11 +4,18 @@ interface SortableArray<T> {
   value: T
 }
 
+/**
+ * Check if the given value is the type of null.
+ */
+export function isNull(value: any): value is null {
+  return value === null
+}
+
 /**
  * Check if the given value is the type of undefined or null.
  */
 export function isNullish(value: any): value is undefined | null {
-  return value === undefined || value === null
+  return value === undefined || isNull(value)
 }
 
 /**

test/feature/model/deletes_delete.spec.ts

@@ -0,0 +1,31 @@
+import { createStore, fillState, assertState } from 'test/Helpers'
+import { Model, Attr, Str } from '@/index'
+
+describe('feature/model/deletes_delete', () => {
+  class User extends Model {
+    static entity = 'users'
+
+    @Attr() id!: any
+    @Str('') name!: string
+  }
+
+  it('deletes a record', async () => {
+    const store = createStore()
+
+    fillState(store, {
+      users: {
+        1: { id: 1, name: 'John Doe' }
+      }
+    })
+
+    const user = store.$repo(User).find(1)!
+
+    const result = await user.$delete()
+
+    expect(result).toBe(true)
+
+    assertState(store, {
+      users: {}
+    })
+  })
+})

test/feature/model/deletes_delete_composite_key.spec.ts

@@ -0,0 +1,34 @@
+import { createStore, fillState, assertState } from 'test/Helpers'
+import { Model, Attr, Str } from '@/index'
+
+describe('feature/model/deletes_delete_composite_key', () => {
+  class User extends Model {
+    static entity = 'users'
+
+    static primaryKey = ['idA', 'idB']
+
+    @Attr() idA!: any
+    @Attr() idB!: any
+    @Str('') name!: string
+  }
+
+  it('deletes a record', async () => {
+    const store = createStore()
+
+    fillState(store, {
+      users: {
+        '[1,2]': { idA: 1, idB: 2, name: 'John Doe' }
+      }
+    })
+
+    const user = store.$repo(User).where('idA', 1).where('idB', 2).first()!
+
+    const result = await user.$delete()
+
+    expect(result).toBe(true)
+
+    assertState(store, {
+      users: {}
+    })
+  })
+})