Merge pull request #415 from feathersjs-ecosystem/useFindParams

Use find params

Author: marshallswain

package.json

@@ -102,6 +102,9 @@
   "directories": {
     "lib": "lib"
   },
+  "peerDependencies": {
+    "@vue/composition-api": "^0.3.4"
+  },
   "dependencies": {
     "@feathersjs/adapter-commons": "^4.4.3",
     "@feathersjs/commons": "^4.4.3",
@@ -110,7 +113,6 @@
     "@types/inflection": "^1.5.28",
     "@types/lodash": "^4.14.149",
     "@types/npm": "^2.0.31",
-    "@vue/composition-api": "^0.3.4",
     "bson-objectid": "^1.3.0",
     "debug": "^4.1.1",
     "events": "^3.1.0",
@@ -141,6 +143,7 @@
     "@types/mocha": "^5.2.7",
     "@typescript-eslint/eslint-plugin": "^2.16.0",
     "@typescript-eslint/parser": "^2.16.0",
+    "@vue/composition-api": "^0.3.4",
     "@vue/eslint-config-prettier": "^6.0.0",
     "@vue/eslint-config-typescript": "^5.0.1",
     "@vue/test-utils": "^1.0.0-beta.30",

src/useFind.ts

@@ -3,15 +3,15 @@ eslint
 @typescript-eslint/no-explicit-any: 0
 */
 import {
-  reactive,
   computed,
-  toRefs,
   isRef,
-  watch,
-  Ref
+  reactive,
+  Ref,
+  toRefs,
+  watch
 } from '@vue/composition-api'
-import { getQueryInfo, getItemsFromQueryInfo, Params } from './utils'
 import debounce from 'lodash/debounce'
+import { getItemsFromQueryInfo, getQueryInfo, Params } from './utils'
 
 interface UseFindOptions {
   model: Function
@@ -47,6 +47,9 @@ interface UseFindData {
   find: Function
 }
 
+const unwrapParams = (params: Params | Ref<Params>): Params =>
+  isRef(params) ? params.value : params
+
 export default function find(options: UseFindOptions): UseFindData {
   const defaults = {
     model: null,
@@ -62,24 +65,21 @@ export default function find(options: UseFindOptions): UseFindData {
     options
   )
 
-  const getFetchParams = (providedParams?: object): Params => {
-    const provided = isRef(providedParams)
-      ? providedParams.value
-      : providedParams
+  const getFetchParams = (providedParams?: Params | Ref<Params>): Params => {
+    const provided = unwrapParams(providedParams)
 
     if (provided) {
       return provided
-    } else {
-      const fetchParams = isRef(options.fetchParams)
-        ? options.fetchParams.value
-        : options.fetchParams
-      const params = isRef(options.params)
-        ? options.params.value
-        : options.params
-
-      // Returning null fetchParams allows the query to be skipped.
-      return fetchParams || fetchParams === null ? fetchParams : params
     }
+
+    const fetchParams = unwrapParams(options.fetchParams)
+    // Returning null fetchParams allows the query to be skipped.
+    if (fetchParams || fetchParams === null) {
+      return fetchParams
+    }
+
+    const params = unwrapParams(options.params)
+    return params
   }
 
   const state = reactive<UseFindState>({
@@ -95,9 +95,8 @@ export default function find(options: UseFindOptions): UseFindData {
   const computes = {
     // The find getter
     items: computed<any[]>(() => {
-      const getterParams: Params = isRef(params)
-        ? Object.assign({}, params.value)
-        : { params }
+      const getterParams = unwrapParams(params)
+
       if (getterParams.paginate) {
         const serviceState = model.store.state[model.servicePath]
         const { defaultSkip, defaultLimit } = serviceState.pagination
@@ -125,8 +124,8 @@ export default function find(options: UseFindOptions): UseFindData {
     servicePath: computed<string>(() => model.servicePath)
   }
 
-  function find<T>(params: Params): T {
-    params = isRef(params) ? params.value : params
+  function find<T>(params: Params | Ref<Params>): T {
+    params = unwrapParams(params)
     if (queryWhen.value && !state.isLocal) {
       state.isPending = true
       state.haveBeenRequested = true
@@ -151,7 +150,7 @@ export default function find(options: UseFindOptions): UseFindData {
       return find(params)
     }
   }
-  function findProxy<T>(params?: Params): T {
+  function findProxy<T>(params?: Params | Ref<Params>): T {
     const paramsToUse = getFetchParams(params)
 
     if (paramsToUse && paramsToUse.debounce) {

test/use/find.test.ts

@@ -106,6 +106,65 @@ describe('use/find', function() {
     assert(qid.value === 'default')
   })
 
+  it('returns correct default data even when params is not reactive', function() {
+    const { Instrument } = makeContext()
+
+    const instrumentsData = useFind({
+      model: Instrument,
+      params: {
+        query: {},
+        paginate: false
+      }
+    })
+
+    const {
+      debounceTime,
+      error,
+      haveBeenRequested,
+      haveLoaded,
+      isPending,
+      isLocal,
+      items,
+      latestQuery,
+      paginationData,
+      qid
+    } = instrumentsData
+
+    assert(isRef(debounceTime))
+    assert(debounceTime.value === null)
+
+    assert(isRef(error))
+    assert(error.value === null)
+
+    assert(isRef(haveBeenRequested))
+    assert(haveBeenRequested.value === true)
+
+    assert(isRef(haveLoaded))
+    assert(haveLoaded.value === false)
+
+    assert(isRef(isPending))
+    assert(isPending.value === true)
+
+    assert(isRef(isLocal))
+    assert(isLocal.value === false)
+
+    assert(isRef(items))
+    assert(Array.isArray(items.value))
+    assert(items.value.length === 0)
+
+    assert(isRef(latestQuery))
+    assert(latestQuery.value === null)
+
+    assert(isRef(paginationData))
+    assert.deepStrictEqual(paginationData.value, {
+      defaultLimit: null,
+      defaultSkip: null
+    })
+
+    assert(isRef(qid))
+    assert(qid.value === 'default')
+  })
+
   it('allows passing {lazy:true} to not query immediately', function() {
     const { Instrument } = makeContext()