fix tests

Author: fratzinger

README.md

@@ -16,7 +16,8 @@
 - removed several checks that are handled by typescript
 - removed check for `preventChanges(true, ...fieldNames)`
 
-  - switch `true` to second argument
+  - switch `true` to second argument options
+  - async
 
 - renamed 'keepQuery' to 'pickQuery', added alias
 - renamed 'required' to 'checkRequired', added alias
@@ -40,6 +41,10 @@
 
 - rm 'actOnDispatch' & 'actOnDefault'
 
+- rm 'validate', 'validateSchema', 'setNow', 'sequelizeConvert', 'serialize', 'required', 'runHook', 'populate', 'pick', 'omit', 'mongoKeys', 'lowercase', 'lowerCase', 'keepQuery', 'keepQueryInArray', 'isNot', fgraphql', 'fastJoin', 'discard...', 'dePopulate', 'actOnDefault', 'actOnDispatch', 'sifter'
+
+- softDelete: need to pass 'deletedQuery' and 'removeData'
+
 #### predicates
 
 - renamed 'isNot' to 'not' (added alias for 'isNot')

src/hooks/index.ts

@@ -35,7 +35,6 @@ export * from './set-now/set-now-data.js'
 export * from './set-now/set-now-result.js'
 
 export * from './set-slug/set-slug.js'
-export * from './sifter/sifter.js'
 export * from './soft-delete/soft-delete.js'
 export * from './stash-before/stash-before.js'
 export * from './traverse/traverse.js'

src/hooks/lowercase/lowercase-data.test.ts

@@ -36,11 +36,11 @@ describe('lowercaseData', () => {
       assert.deepEqual(hook.data, { first: null, last: 'doe' })
     })
 
-    it('throws if field is not a string', () => {
+    it('throws if field is not a string', async () => {
       const hook: any = { type: 'before', method: 'create', data: { first: 1, last: 'Doe' } }
-      assert.throws(() => {
-        lowercaseData(['first', 'last'])(hook)
-      })
+      await expect(async () => {
+        await lowercaseData(['first', 'last'])(hook)
+      }).rejects.toThrow('Expected string data. (lowercase first)')
     })
   })
 

src/hooks/lowercase/lowercase-data.ts

@@ -11,6 +11,7 @@ import { toArray } from '../../internal.utils.js'
  */
 export const lowercaseData = (fieldNames: MaybeArray<string>) => {
   const fieldNamesArr = toArray(fieldNames)
+
   return transformData(item => {
     for (let i = 0; i < fieldNamesArr.length; i++) {
       const fieldName = fieldNamesArr[i]

src/hooks/prevent-changes/prevent-changes.test.ts

@@ -1,4 +1,4 @@
-import { assert } from 'vitest'
+import { assert, expect } from 'vitest'
 import { preventChanges } from './prevent-changes.js'
 import { clone } from '../../common/index.js'
 
@@ -15,17 +15,27 @@ describe('preventChanges', () => {
       }
     })
 
-    it('does not throw if props not found', () => {
-      preventChanges(['name', 'address'], { error: true })(hookBefore)
-      preventChanges(['name.x', 'x.y.z'], { error: true })(hookBefore)
+    it('does not throw if props not found', async () => {
+      await preventChanges(['name', 'address'], { error: true })(hookBefore)
+      await preventChanges(['name.x', 'x.y.z'], { error: true })(hookBefore)
     })
 
-    it('throw if props found', () => {
-      assert.throw(() => preventChanges(['name', 'first'], { error: true })(hookBefore))
-      assert.throw(() => preventChanges(['name', 'a'], { error: true })(hookBefore))
-      assert.throw(() => preventChanges(['name', 'a.b'], { error: true })(hookBefore))
-      assert.throw(() => preventChanges(['name', 'a.c'], { error: true })(hookBefore))
-      assert.throw(() => preventChanges(['name', 'a.c.d.e'], { error: true })(hookBefore))
+    it('throw if props found', async () => {
+      await expect(() =>
+        preventChanges(['name', 'first'], { error: true })(hookBefore),
+      ).rejects.toThrow()
+      await expect(() =>
+        preventChanges(['name', 'a'], { error: true })(hookBefore),
+      ).rejects.toThrow()
+      await expect(() =>
+        preventChanges(['name', 'a.b'], { error: true })(hookBefore),
+      ).rejects.toThrow()
+      await expect(() =>
+        preventChanges(['name', 'a.c'], { error: true })(hookBefore),
+      ).rejects.toThrow()
+      await expect(() =>
+        preventChanges(['name', 'a.c.d.e'], { error: true })(hookBefore),
+      ).rejects.toThrow()
     })
   })
 
@@ -39,38 +49,44 @@ describe('preventChanges', () => {
       }
     })
 
-    it('does not delete if props not found', () => {
-      let context: any = preventChanges(['name', 'address'], { error: false })(clone(hookBefore))
+    it('does not delete if props not found', async () => {
+      let context: any = await preventChanges(['name', 'address'], { error: false })(
+        clone(hookBefore),
+      )
       assert.deepEqual(context, hookBefore)
 
-      context = preventChanges(['name.x', 'x.y.z'], { error: false })(clone(hookBefore))
+      context = await preventChanges(['name.x', 'x.y.z'], { error: false })(clone(hookBefore))
       assert.deepEqual(context, hookBefore)
     })
 
-    it('deletes if props found', () => {
-      let context: any = preventChanges(['name', 'first'], { error: false })(clone(hookBefore))
+    it('deletes if props found', async () => {
+      let context: any = await preventChanges(['name', 'first'], { error: false })(
+        clone(hookBefore),
+      )
       assert.deepEqual(context.data, { last: 'Doe', a: { b: 'john', c: { d: { e: 1 } } } }, '1')
 
-      context = preventChanges(['name', 'a'], { error: false })(clone(hookBefore))
+      context = await preventChanges(['name', 'a'], { error: false })(clone(hookBefore))
       assert.deepEqual(context.data, { first: 'John', last: 'Doe' }, '2')
 
-      context = preventChanges(['name', 'a.b'], { error: false })(clone(hookBefore))
+      context = await preventChanges(['name', 'a.b'], { error: false })(clone(hookBefore))
       assert.deepEqual(context.data, { first: 'John', last: 'Doe', a: { c: { d: { e: 1 } } } }, '3')
 
-      context = preventChanges(['name', 'a.c'], { error: false })(clone(hookBefore))
+      context = await preventChanges(['name', 'a.c'], { error: false })(clone(hookBefore))
       assert.deepEqual(context.data, { first: 'John', last: 'Doe', a: { b: 'john' } }, '4')
 
-      context = preventChanges(['name', 'a.c.d.e'], { error: false })(clone(hookBefore))
+      context = await preventChanges(['name', 'a.c.d.e'], { error: false })(clone(hookBefore))
       assert.deepEqual(
         context.data,
         { first: 'John', last: 'Doe', a: { b: 'john', c: { d: {} } } },
         '5',
       )
 
-      context = preventChanges(['first', 'last'], { error: false })(clone(hookBefore))
+      context = await preventChanges(['first', 'last'], { error: false })(clone(hookBefore))
       assert.deepEqual(context.data, { a: { b: 'john', c: { d: { e: 1 } } } })
 
-      context = preventChanges(['first', 'a.b', 'a.c.d.e'], { error: false })(clone(hookBefore))
+      context = await preventChanges(['first', 'a.b', 'a.c.d.e'], { error: false })(
+        clone(hookBefore),
+      )
       assert.deepEqual(context.data, { last: 'Doe', a: { c: { d: {} } } })
     })
   })

src/hooks/prevent-changes/prevent-changes.ts

@@ -31,7 +31,7 @@ export const preventChanges = (fieldNames: MaybeArray<string>, options?: Prevent
           throw error
         }
       }
-
+    } else {
       item = _omit(item, fieldNamesArr)
     }
 

src/hooks/set-field/set-field.ts

@@ -34,7 +34,7 @@ export const setField =
 
     context = _setWith(context, as, value, _clone)
 
-    if (next) return next().then(() => context)
+    if (next) return next()
 
     return context
   }

src/hooks/set-now/set-now-data.test.ts

@@ -21,7 +21,7 @@ describe('setNowData', () => {
     })
 
     it('supports multiple field names', () => {
-      setNowData('createdAt1', 'createdAt2')(hookBefore)
+      setNowData(['createdAt1', 'createdAt2'])(hookBefore)
       checkHook(hookBefore.data, { first: 'John', last: 'Doe' }, ['createdAt1', 'createdAt2'])
     })
   })
@@ -54,7 +54,7 @@ describe('setNowData', () => {
     })
 
     it('props with no dots', () => {
-      setNowData('madeAt', 'builtAt')(hookBefore)
+      setNowData(['madeAt', 'builtAt'])(hookBefore)
       checkHook(
         hookBefore.data,
         { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },

src/hooks/set-now/set-now-data.ts

@@ -1,3 +1,5 @@
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
 import { transformData } from '../transform/transform-data.js'
 import _set from 'lodash/set.js'
 
@@ -6,11 +8,14 @@ import _set from 'lodash/set.js'
  *
  * @see https://hooks-common.feathersjs.com/hooks.html#setnow
  */
-export const setNowData = (...fieldNames: string[]) =>
-  transformData(data => {
-    for (let i = 0; i < fieldNames.length; i++) {
-      const key = fieldNames[i]
+export const setNowData = (fieldNames: MaybeArray<string>) => {
+  const fieldNamesArr = toArray(fieldNames)
+
+  return transformData(data => {
+    for (let i = 0; i < fieldNamesArr.length; i++) {
+      const key = fieldNamesArr[i]
 
       _set(data, key, new Date())
     }
   })
+}

src/hooks/set-slug/set-slug.ts

@@ -6,21 +6,21 @@ import type { HookContext, NextFunction } from '@feathersjs/feathers'
  *
  * @see https://hooks-common.feathersjs.com/hooks.html#setslug
  */
-export const setSlug =
-  <H extends HookContext = HookContext>(slug: string, fieldName?: string) =>
-  (context: H, next?: NextFunction) => {
-    if (typeof fieldName !== 'string') {
-      fieldName = `query.${slug}`
-    }
+export const setSlug = <H extends HookContext = HookContext>(slug: string, fieldName?: string) => {
+  if (typeof fieldName !== 'string') {
+    fieldName = `query.${slug}`
+  }
 
+  return (context: H, next?: NextFunction) => {
     if (context.params && context.params.provider === 'rest') {
       const value = context.params.route[slug]
       if (typeof value === 'string' && value[0] !== ':') {
         _set(context.params, fieldName, value)
       }
     }
 
-    if (next) return next().then(() => context)
+    if (next) return next()
 
     return context
   }
+}