feat: add "fresh" feature (#13)

src/connection/Connection.ts

@@ -68,6 +68,13 @@ export class Connection {
     this.commit('insert', records)
   }
 
+  /**
+   * Commit `fresh` mutation to the store.
+   */
+  fresh(records: Elements): void {
+    this.commit('fresh', records)
+  }
+
   /**
    * Commit `update` mutation to the store.
    */

src/modules/Mutations.ts

@@ -16,6 +16,13 @@ function insert(state: State, records: Elements): void {
   state.data = { ...state.data, ...records }
 }
 
+/**
+ * Commit `fresh` change to the store.
+ */
+function fresh(state: State, records: Elements): void {
+  state.data = records
+}
+
 /**
  * Commit `update` change to the store.
  */
@@ -47,6 +54,7 @@ function flush(state: State): void {
 
 export const mutations = {
   insert,
+  fresh,
   update,
   delete: destroy,
   flush

src/query/Options.ts

@@ -33,4 +33,4 @@ export interface EagerLoad {
 
 export type EagerLoadConstraint = (query: Query) => void
 
-export type PersistMethod = 'insert' | 'update'
+export type PersistMethod = 'insert' | 'fresh' | 'update'

src/query/Query.ts

@@ -401,6 +401,26 @@ export class Query<M extends Model = Model> {
     return models
   }
 
+  /**
+   * Insert the given records to the store by replacing any existing records.
+   */
+  fresh(records: Element | Element[]): Promise<Collections> {
+    return this.persist('fresh', records)
+  }
+
+  /**
+   * Insert the given records to the store by replacing any existing records.
+   */
+  async replace<E extends Element>(records: E[]): Promise<Collection<M>>
+  async replace<E extends Element>(record: E): Promise<M>
+  async replace(records: any): Promise<any> {
+    const models = this.hydrate(records)
+
+    this.connection.fresh(this.compile(models))
+
+    return models
+  }
+
   /**
    * Update the given record to the store.
    */
@@ -483,6 +503,8 @@ export class Query<M extends Model = Model> {
     switch (method) {
       case 'insert':
         return this.add(mappedRecords)
+      case 'fresh':
+        return this.replace(mappedRecords)
       case 'update':
         return this.merge(mappedRecords)
       default:

src/repository/Repository.ts

@@ -165,6 +165,13 @@ export class Repository<M extends Model = Model> {
     return this.query().insert(records)
   }
 
+  /**
+   * Insert the given records to the store by replacing any existing records.
+   */
+  fresh(records: Element | Element[]): Promise<Collections> {
+    return this.query().fresh(records)
+  }
+
   /**
    * Update records in the store.
    */

test/feature/repository/inserts_fresh.spec.ts

@@ -0,0 +1,62 @@
+import { createStore, fillState, assertState } from 'test/Helpers'
+import { Model, Attr, Str } from '@/index'
+
+describe('feature/repository/inserts_fresh', () => {
+  class User extends Model {
+    static entity = 'users'
+
+    @Attr() id!: any
+    @Str('') name!: string
+  }
+
+  it('inserts a new record to the store', async () => {
+    const store = createStore()
+
+    await store.$repo(User).fresh({ id: 1, name: 'John Doe' })
+
+    assertState(store, {
+      users: {
+        1: { id: 1, name: 'John Doe' }
+      }
+    })
+  })
+
+  it('inserts multiple records to the store', async () => {
+    const store = createStore()
+
+    await store.$repo(User).fresh([
+      { id: 1, name: 'John Doe' },
+      { id: 2, name: 'Jane Doe' }
+    ])
+
+    assertState(store, {
+      users: {
+        1: { id: 1, name: 'John Doe' },
+        2: { id: 2, name: 'Jane Doe' }
+      }
+    })
+  })
+
+  it('replaces existing records', async () => {
+    const store = createStore()
+
+    fillState(store, {
+      users: {
+        1: { id: 1, name: 'John Doe' },
+        2: { id: 2, name: 'Jane Doe' }
+      }
+    })
+
+    await store.$repo(User).fresh([
+      { id: 3, name: 'Johnny Doe' },
+      { id: 4, name: 'David Doe' }
+    ])
+
+    assertState(store, {
+      users: {
+        3: { id: 3, name: 'Johnny Doe' },
+        4: { id: 4, name: 'David Doe' }
+      }
+    })
+  })
+})