()
+let utilitiesList: Utility[] = []
+
+export async function discoverUtilities() {
+ const { srcDir = 'src', pattern = '**/*.md', exclude = ['**/node_modules/**', '**/dist/**'] } = {}
+
+ const markdownFiles = await glob(`${srcDir}/${pattern}`, { ignore: exclude })
+ utilities.clear()
+ utilitiesList = []
+
+ for (const filePath of markdownFiles) {
+ try {
+ const content = await fs.readFile(filePath, 'utf-8')
+ const { data: frontmatter, content: body } = matter(content)
+
+ const { title = '', description = '', category, hook } = frontmatter
+
+ if (!title || ['hooks', 'utils', 'resolvers', 'predicates'].indexOf(category) === -1) {
+ console.warn(
+ `Skipping ${filePath}: Missing title or invalid category`,
+ title,
+ category,
+ frontmatter,
+ )
+ continue
+ }
+
+ const slug = kebabCase(title)
+
+ const utility: Utility = {
+ name: title,
+ title,
+ description,
+ category,
+ slug,
+ path: `/${category}/${slug}`,
+ pathMd: `/${category}/${slug}.md`,
+ frontmatter,
+ content: body,
+ hook,
+ lastModified: (await fs.stat(filePath)).mtime,
+ sourceUrl: `https://github.com/${repository}/blob/${mainBranch}/src/${category}/${slug}/${slug}.ts`,
+ }
+
+ utilities.set(slug, utility)
+ utilitiesList.push(utility)
+ } catch (error) {
+ console.warn(`Failed to process ${filePath}:`, error.message)
+ }
+ }
+
+ utilitiesList.sort((a, b) => a.title.localeCompare(b.title))
+
+ return utilitiesList
+}
diff --git a/docs/components/HookTable.vue b/docs/components/HookTable.vue
deleted file mode 100644
index 5361db48..00000000
--- a/docs/components/HookTable.vue
+++ /dev/null
@@ -1,37 +0,0 @@
-
-
-
-
- before
- after
- methods
- multi
- details
-
-
-
-
- {{ before ? 'yes' : 'no' }}
- {{ after ? 'yes' : 'no' }}
- {{ methods.join(", ") }}
- {{ typeof multi === 'boolean' ? multi ? 'yes' : 'no' : multi }}
- source
-
-
-
-
-
-
-
diff --git a/docs/guides.md b/docs/guides.md
index d9b6527c..926637a7 100755
--- a/docs/guides.md
+++ b/docs/guides.md
@@ -9,11 +9,7 @@ function disallowWhat() {
return someVariableCircumstance() ? 'rest' : 'external';
}
// ...
-module.exports = {
- before: {
- all: disallow(disallowWhat())
- }
-};
+module.exports = { before: { all: disallow(disallowWhat()) } };
```
This code will also **not do**, as most parameters do not permit functions, and `disallowWhat` will not be called for each service call.
@@ -23,11 +19,7 @@ function disallowWhat() {
return someVariableCircumstance() ? 'rest' : 'external';
}
// ...
-module.exports = {
- before: {
- all: disallow(disallowWhat)
- }
-};
+module.exports = { before: { all: disallow(disallowWhat) } };
```
You are able to call `disallowWhat` for each service call as follows.
@@ -37,11 +29,7 @@ function disallowWhat() {
return someVariableCircumstance() ? 'rest' : 'external';
}
// ...
-module.exports = {
- before: {
- all: context => disallow(disallowWhat())(context)
- }
-};
+module.exports = { before: { all: context => disallow(disallowWhat())(context) } };
```
`disallowWhat` is called each time the hook is run. `disallow(disallowWhat())` creates a new hook with the value returned by `disallowWhat()`, and then that hook is invoked with `(context)`.
@@ -49,11 +37,7 @@ module.exports = {
Let's look at another example. The `user` record identifies information the user permits to be public, in its `public` field. We can write a hook retaining only the fields allowed to be exposed.
```js
-module.exports = {
- after: {
- get: context => keep(...context.params.user.public)(context)
- }
-};
+module.exports = { after: { get: context => keep(...context.params.user.public)(context) } };
```
## fastJoin
@@ -101,40 +85,27 @@ It also takes an optional query with which you can customise the current operati
```js
// project/src/services/posts/posts.hooks.js
-const { fastJoin } = require('feathers-hooks-common');
+const { fastJoin } = require('feathers-hooks-common/index.js');
const postResolvers = {
joins: {
author:
(...args) =>
async (post, { app }) => {
- post.author = (
- await app.service('users').find({
- query: {
- id: post.userId
- }
- })
- )[0];
+ post.author = (await app.service('users').find({ query: { id: post.userId } }))[0];
},
starers:
$select =>
async (post, { app }) => {
- post.starers = await app.service('users').find({
- query: {
- id: { $in: post.starIds },
- $select: $select || ['name']
- }
- });
- }
- }
+ post.starers = await app
+ .service('users')
+ .find({ query: { id: { $in: post.starIds }, $select: $select || ['name'] } });
+ },
+ },
};
-module.exports = {
- after: {
- all: [fastJoin(postResolvers)]
- }
-};
+module.exports = { after: { all: [fastJoin(postResolvers)] } };
```
The above example has two resolvers. Let's focus on `author`.
@@ -161,7 +132,7 @@ The result would look like:
userId: 101,
starIds: [102, 103, 104],
author: { id: 101, name: 'John' },
- starers: [{ name: 'Marshall' }, { name: 'Barbara' }, { name: 'Aubree' }]
+ starers: [{ name: 'Marshall' }, { name: 'Barbara' }, { name: 'Aubree' }],
}
];
```
@@ -169,15 +140,9 @@ The result would look like:
### Shaping the Result
```js
-const query = {
- author: true
-};
+const query = { author: true };
-module.exports = {
- after: {
- all: [fastJoin(postResolvers, query)]
- }
-};
+module.exports = { after: { all: [fastJoin(postResolvers, query)] } };
```
The above query requests the author resolver be run, but not the starers resolver. This is a GraphQL concept which _shapes_ the result. The result will not contain the `starers` field which the starers resolver would have otherwise added.
@@ -192,8 +157,8 @@ The above query requests the author resolver be run, but not the starers resolve
body: 'John post',
userId: 101,
starIds: [102, 103, 104],
- author: { id: 101, name: 'John' }
- }
+ author: { id: 101, name: 'John' },
+ },
];
```
@@ -241,9 +206,9 @@ The `paginate:false` suppress pagination for this call, ensuring all the matchin
starers: [
{ id: 102, name: 'Marshall' },
{ id: 103, name: 'Barbara' },
- { id: 104, name: 'Aubree' }
- ]
- }
+ { id: 104, name: 'Aubree' },
+ ],
+ },
];
```
@@ -272,8 +237,8 @@ Here, the starerCount resolver adds the field `starerCount` containing a count o
starIds: [102, 103, 104],
starerCount: 3,
author: { id: 101, name: 'John' },
- starers: [{ name: 'Marshall' }, { name: 'Barbara' }, { name: 'Aubree' }]
- }
+ starers: [{ name: 'Marshall' }, { name: 'Barbara' }, { name: 'Aubree' }],
+ },
];
```
@@ -348,23 +313,23 @@ const query = {
text: 'John post Marshall comment 11',
postId: 1,
userId: 102,
- author: { id: 102, name: 'Marshall' }
+ author: { id: 102, name: 'Marshall' },
},
{
id: 12,
text: 'John post Marshall comment 12',
postId: 1,
userId: 102,
- author: { id: 102, name: 'Marshall' }
+ author: { id: 102, name: 'Marshall' },
},
{
id: 13,
text: 'John post Marshall comment 13',
postId: 1,
userId: 102,
- author: { id: 102, name: 'Marshall' }
- }
- ]
+ author: { id: 102, name: 'Marshall' },
+ },
+ ],
}
];
```
@@ -382,11 +347,11 @@ const commentResolvers = {
comment.author = (
await users.find({
query: { id: comment.userId, $select: $select || ['name'] },
- paginate: false
+ paginate: false,
})
)[0];
- }
- }
+ },
+ },
};
const postResolvers = {
@@ -398,16 +363,16 @@ const postResolvers = {
postId: post.id,
$select: $select,
$limit: $limit || 5,
- [$sort]: { createdAt: -1 }
+ [$sort]: { createdAt: -1 },
},
- paginate: false
+ paginate: false,
});
return post.comments;
},
- joins: commentResolvers
- }
- }
+ joins: commentResolvers,
+ },
+ },
};
```
@@ -424,16 +389,14 @@ You need to understand batch-loaders before we proceed, so [read about them now.
### Using a Simple Batch-Loader
```js
-const { fastJoin } = require('feathers-hooks-common');
+const { fastJoin } = require('feathers-hooks-common/index.js');
const BatchLoader = require('@feathers-plus/batch-loader');
const { loaderFactory } = BatchLoader;
const postResolvers = {
before: context => {
context._loaders = { user: {} };
- context._loaders.user.id = loaderFactory(users, 'id', false, {
- paginate: false
- })(context);
+ context._loaders.user.id = loaderFactory(users, 'id', false, { paginate: false })(context);
},
joins: {
@@ -441,8 +404,8 @@ const postResolvers = {
(post.author = await context._loaders.user.id.load(post.userId)),
starers: () => async (post, context) =>
- !post.starIds ? null : (post.starers = await context._loaders.user.id.loadMany(post.starIds))
- }
+ !post.starIds ? null : (post.starers = await context._loaders.user.id.loadMany(post.starIds)),
+ },
};
```
@@ -471,8 +434,8 @@ Let's look at the code in this example:
starers: [
{ id: 102, name: 'Marshall' },
{ id: 103, name: 'Barbara' },
- { id: 104, name: 'Aubree' }
- ]
+ { id: 104, name: 'Aubree' },
+ ],
}
];
```
@@ -484,7 +447,7 @@ Let's look at the code in this example:
The `loaderFactory(users, 'id', false)` above is just a convenience wrapper for building a BatchLoader. We can create our batch loaders directly should we need them to do more.
```js
-const { fastJoin, makeCallingParams } = require('feathers-hooks-common');
+const { fastJoin, makeCallingParams } = require('feathers-hooks-common/index.js');
const BatchLoader = require('@feathers-plus/batch-loader');
const { getResultsByKey, getUniqueKeys } = BatchLoader;
@@ -496,12 +459,12 @@ const postResolvers = {
async (keys, context) => {
const result = await users.find(
makeCallingParams(context, { id: { $in: getUniqueKeys(keys) } }, undefined, {
- paginate: false
- })
+ paginate: false,
+ }),
);
return getResultsByKey(keys, result, user => user.id, '!');
},
- { context }
+ { context },
);
},
@@ -510,8 +473,8 @@ const postResolvers = {
(post.author = await context._loaders.user.id.load(post.userId)),
starers: () => async (post, context) =>
- !post.starIds ? null : (post.starers = await context._loaders.user.id.loadMany(post.starIds))
- }
+ !post.starIds ? null : (post.starers = await context._loaders.user.id.loadMany(post.starIds)),
+ },
};
```
@@ -525,7 +488,7 @@ Let's also add a `reputation` array of objects to `posts`. This will show the in
```js
// project/src/services/posts/posts.hooks.js
-const { fastJoin, makeCallingParams } = require('feathers-hooks-common');
+const { fastJoin, makeCallingParams } = require('feathers-hooks-common/index.js');
const BatchLoader = require('@feathers-plus/batch-loader');
const { getResultsByKey, getUniqueKeys } = BatchLoader;
@@ -534,8 +497,8 @@ const commentResolvers = {
author: () => async (comment, context) =>
!comment.userId
? null
- : (comment.userRecord = await context._loaders.user.id.load(comment.userId))
- }
+ : (comment.userRecord = await context._loaders.user.id.load(comment.userId)),
+ },
};
const postResolvers = {
@@ -546,24 +509,24 @@ const postResolvers = {
async (keys, context) => {
const result = await users.find(
makeCallingParams(context, { id: { $in: getUniqueKeys(keys) } }, undefined, {
- paginate: false
- })
+ paginate: false,
+ }),
);
return getResultsByKey(keys, result, user => user.id, '!');
},
- { context }
+ { context },
);
context._loaders.comments.postId = new BatchLoader(
async (keys, context) => {
const result = await comments.find(
makeCallingParams(context, { postId: { $in: getUniqueKeys(keys) } }, undefined, {
- paginate: false
- })
+ paginate: false,
+ }),
);
return getResultsByKey(keys, result, comment => comment.postId, '[!]');
},
- { context }
+ { context },
);
},
@@ -579,7 +542,7 @@ const postResolvers = {
reputation_author: () => async (post, context) => {
if (!post.reputation) return null;
const authors = await context._loaders.user.id.loadMany(
- post.reputation.map(rep => rep.userId)
+ post.reputation.map(rep => rep.userId),
);
post.reputation.forEach((rep, i) => {
rep.author = authors[i].name;
@@ -591,25 +554,18 @@ const postResolvers = {
(...args) =>
async (post, context) =>
(post.commentRecords = await context._loaders.comments.postId.load(post.id)),
- joins: commentResolvers
- }
- }
+ joins: commentResolvers,
+ },
+ },
};
const query = {
author: true,
starers: [['id', 'name']],
- comments: {
- args: null,
- author: [['id', 'name']]
- }
+ comments: { args: null, author: [['id', 'name']] },
};
-module.exports = {
- after: {
- all: [fastJoin(postResolvers, context => query)]
- }
-};
+module.exports = { after: { all: [fastJoin(postResolvers, context => query)] } };
```
We are using 2 batch-loaders, one for single user records, the other for arrays of comment records.
@@ -721,7 +677,7 @@ We can improve the situation by using persistent caches with the BatchLoaders. A
Let's see how we can use the [cache hook](./index.html#cache) as it maintains a persistent cache for the service its registered on.
```js
-const { cache, fastJoin, makeCallingParams } = require('feathers-hooks-common');
+const { cache, fastJoin, makeCallingParams } = require('feathers-hooks-common/index.js');
const BatchLoader = require('@feathers-plus/batch-loader');
const CacheMap = require('@feathers-plus/cache');
const { getResultsByKey, getUniqueKeys } = BatchLoader;
@@ -733,13 +689,11 @@ const cacheMapUsers = CacheMap({ max: 100 });
const userBatchLoader = new BatchLoader(
async keys => {
const result = await users.find(
- makeCallingParams({}, { id: { $in: getUniqueKeys(keys) } }, undefined, {
- paginate: false
- })
+ makeCallingParams({}, { id: { $in: getUniqueKeys(keys) } }, undefined, { paginate: false }),
);
return getResultsByKey(keys, result, user => user.id, '!');
},
- { cacheMap: cacheMapUsers }
+ { cacheMap: cacheMapUsers },
);
const postResolvers = {
@@ -753,26 +707,19 @@ const postResolvers = {
(post.author = await context._loaders.user.id.load(post.userId)),
starers: () => async (post, context) =>
- !post.starIds ? null : (post.starers = await context._loaders.user.id.loadMany(post.starIds))
- }
+ !post.starIds ? null : (post.starers = await context._loaders.user.id.loadMany(post.starIds)),
+ },
};
const query = {
author: true,
starers: [['id', 'name']],
- comments: {
- args: null,
- author: [['id', 'name']]
- }
+ comments: { args: null, author: [['id', 'name']] },
};
module.exports = {
- before: {
- all: cache(cacheMapUsers)
- },
- after: {
- all: [cache(cacheMapUsers), fastJoin(postResolvers, () => query)]
- }
+ before: { all: cache(cacheMapUsers) },
+ after: { all: [cache(cacheMapUsers), fastJoin(postResolvers, () => query)] },
};
```
@@ -807,22 +754,13 @@ Populates items _recursively_ to any depth. Supports 1:1, 1:n and n:1 relationsh
```javascript
// users like { _id: '111', name: 'John', roleId: '555' }
// roles like { _id: '555', permissions: ['foo', bar'] }
-import { populate } from 'feathers-hooks-common';
+import { populate } from 'feathers-hooks-common/index.js';
const userRoleSchema = {
- include: {
- service: 'roles',
- nameAs: 'role',
- parentField: 'roleId',
- childField: '_id'
- }
+ include: { service: 'roles', nameAs: 'role', parentField: 'roleId', childField: '_id' },
};
-app.service('users').hooks({
- after: {
- all: populate({ schema: userRoleSchema })
- }
-});
+app.service('users').hooks({ after: { all: populate({ schema: userRoleSchema }) } });
// result like
// { _id: '111', name: 'John', roleId: '555',
@@ -835,19 +773,10 @@ app.service('users').hooks({
// users like { _id: '111', name: 'John', roleIds: ['555', '666'] }
// roles like { _id: '555', permissions: ['foo', 'bar'] }
const userRolesSchema = {
- include: {
- service: 'roles',
- nameAs: 'roles',
- parentField: 'roleIds',
- childField: '_id'
- }
+ include: { service: 'roles', nameAs: 'roles', parentField: 'roleIds', childField: '_id' },
};
-usersService.hooks({
- after: {
- all: populate({ schema: userRolesSchema })
- }
-});
+usersService.hooks({ after: { all: populate({ schema: userRolesSchema }) } });
// result like
// { _id: '111', name: 'John', roleIds: ['555', '666'], roles: [
@@ -862,19 +791,10 @@ usersService.hooks({
// posts like { _id: '111', body: '...' }
// comments like { _id: '555', text: '...', postId: '111' }
const postCommentsSchema = {
- include: {
- service: 'comments',
- nameAs: 'comments',
- parentField: '_id',
- childField: 'postId'
- }
+ include: { service: 'comments', nameAs: 'comments', parentField: '_id', childField: 'postId' },
};
-postService.hooks({
- after: {
- all: populate({ schema: postCommentsSchema })
- }
-});
+postService.hooks({ after: { all: populate({ schema: postCommentsSchema }) } });
// result like
// { _id: '111', body: '...' }, comments: [
@@ -934,15 +854,11 @@ const postCommentsSchema = {
include: {
service: 'comments',
nameAs: 'comments',
- select: (hook, parentItem) => ({ postId: parentItem._id })
- }
+ select: (hook, parentItem) => ({ postId: parentItem._id }),
+ },
};
-postService.hooks({
- after: {
- all: populate({ schema: postCommentsSchema })
- }
-});
+postService.hooks({ after: { all: populate({ schema: postCommentsSchema }) } });
// result like
// { _id: '111', body: '...' }, comments: [
@@ -1109,7 +1025,7 @@ The following example shows how the client can ask for the type of schema it nee
```javascript
// on client
-import { paramsForServer } from 'feathers-hooks-common';
+import { paramsForServer } from 'feathers-hooks-common/index.js';
purchaseOrders.get(id, paramsForServer({ schema: 'po-acct' })); // pass schema name to server
// or
purchaseOrders.get(id, paramsForServer({ schema: 'po-rec' }));
@@ -1117,7 +1033,7 @@ purchaseOrders.get(id, paramsForServer({ schema: 'po-rec' }));
```javascript
// on server
-import { paramsFromClient } from 'feathers-hooks-common';
+import { paramsFromClient } from 'feathers-hooks-common/index.js';
const poSchemas = {
'po-acct': /* populate schema for Accounting oriented PO e.g. { include: ... } */,
'po-rec': /* populate schema for Receiving oriented PO */
@@ -1181,7 +1097,7 @@ A full featured example of such a process appears below. It validates and saniti
```javascript
// file /server/services/users/users.hooks.js
const auth = require('feathers-authentication').hooks;
-const { callbackToPromise, remove, validate } = require('feathers-hooks-common');
+const { callbackToPromise, remove, validate } = require('feathers-hooks-common/index.js');
const validateSchema = require('feathers-hooks-validate-joi');
const clientValidations = require('/common/usersClientValidations');
@@ -1197,8 +1113,8 @@ exports.before = {
validate(values => clientValidations.signupAsync(values, 'someMoreParams')), // re-run form async
validate(serverValidationsSignup), // run server validation
remove('confirmPassword'),
- auth.hashPassword()
- ]
+ auth.hashPassword(),
+ ],
};
```
@@ -1263,19 +1179,14 @@ const password = Joi.string()
const email = Joi.string().trim().email().required();
module.exports = {
- options: {
- abortEarly: false,
- convert: true,
- allowUnknown: false,
- stripUnknown: true
- },
+ options: { abortEarly: false, convert: true, allowUnknown: false, stripUnknown: true },
signup: Joi.object().keys({
name: Joi.string().trim().min(8).max(30).required(),
username,
password,
confirmPassword: password.label('Confirm password'),
- email
- })
+ email,
+ }),
};
```
@@ -1294,7 +1205,7 @@ module.exports = {
});
cb(Object.keys(formErrors).length > 0 ? formErrors : null, sanitized);
- }
+ },
};
```
diff --git a/docs/hooks.md b/docs/hooks.md
deleted file mode 100644
index b6f34ffe..00000000
--- a/docs/hooks.md
+++ /dev/null
@@ -1,2157 +0,0 @@
-
-
-# Hooks
-
-## actOnDefault
-
-Runs a series of hooks which mutate context.data or content.result (the Feathers default).
-
-context.dispatch is a writeable, optional property and contains a "safe" version of the data that should be sent to any client. If context.dispatch has not been set context.result will be sent to the client instead.
-
-## alterItems
-
-Make changes to data or result items. Very flexible.
-
-The cache will grow without limit when `Map` is used and the resulting memory pressure may adversely affect your performance. `Map` should only be used when you know or can control its size.
-
-- **Details**
-
- The `cache` hook maintain a persistent cache for the service it is registerd on. A persistent cache stores records so future requests for those records can be served faster; the records stored in the cache are duplicates of records stored in the database.
-
- The `get` service method retrieves records from the cache and updates `context.result` `[.data]`. The other methods remove their `context.data` entries from the cache in the `before` hook, and add entries in the `after` hook. All the records returned by a `find` call are added to the cache.
-
- The `cache` hook may be provided a custom Map instance to use as its memoization cache. Any object that implements the methods get(), set(), delete() and clear() can be provided. This allows for custom Maps which implement various [cache algorithms](https://en.wikipedia.org/wiki/Cache_replacement_policies) to be provided.
-
- The companion `@feathers-plus/cache` provides a least recently-used cache which discards the least recently used items first. It is compatible with `cache` as well as the BatchLoaders used with the `fastJoin` hook.
-
- > The `cache` hook can make [fastJoin](#fastjoin) hooks run more efficiently.
-
- MongoDB and Mongoose store record keys as bson objects rather than as scalars. The safest way to use the cache is in conjunction with the `makeCacheKey` option.
-
-- **options.clone**
-
- The clone function has a single parameter.
-
- - `{Object} item`
-
- It returns
-
- - `{Object} clonedItem`
-
-| Argument | Type | Default | Description |
-| ------------ | :------: | ------- | ------------------ |
-| `item` | `Object` | | The record. |
-| `clonedItem` | `Object` | | A clone of `item`. |
-
-## debug
-
-Display the current hook context for debugging.
-
-The services in all these examples are assumed, for simplicity, to have pagination disabled. You will have to decide when to use `paginate: false` in your code.
-
- ```js
- // project/src/services/posts/posts.hooks.js
- const { fastJoin } = require('feathers-hooks-common');
-
- const postResolvers = {
- joins: {
- author:
- (...args) =>
- async post =>
- (post.author = (
- await users.find({
- query: { id: post.userId },
- paginate: false
- })
- )[0]),
-
- starers: $select => async post =>
- (post.starers = await users.find({
- query: { id: { $in: post.starIds }, $select: $select || ['name'] },
- paginate: false
- }))
- }
- };
-
- const query = {
- author: true,
- starers: [['id', 'name']]
- };
-
- module.exports = {
- after: {
- all: [fastJoin(postResolvers, query)]
- }
- };
-
- // Original record
- [{ id: 1, body: 'John post', userId: 101, starIds: [102, 103, 104] }][
- // Result
- {
- id: 1,
- body: 'John post',
- userId: 101,
- starIds: [102, 103, 104],
- author: { id: 101, name: 'John' },
- starers: [{ name: 'Marshall' }, { name: 'Barbara' }, { name: 'Aubree' }]
- }
- ];
- ```
-
-- **Example with recursive operations**
-
- ```js
- // project/src/services/posts/posts.hooks.js
- const { fastJoin } = require('feathers-hooks-common');
-
- const postResolvers = {
- joins: {
- comments: {
- resolver: ($select, $limit, $sort) => async post => post.comments = await comments.find({
- query: { postId: post.id, $select: $select, $limit: $limit || 5, [$sort]: { createdAt: -1 } },
- paginate: false
- }),
-
- joins: {
- author: $select => async comment => comment.author = (await users.find({
- query: { id: comment.userId, $select: $select },
- paginate: false
- }))[0],
- },
- },
- }
- };
-
- const query = {
- comments: {
- args: [...],
- author: [['id', 'name']]
- },
- };
-
- module.exports = { after: {
- all: [ fastJoin(postResolvers, query) ],
- } };
-
- // Original record
- [ { id: 1, body: 'John post', userId: 101, starIds: [102, 103, 104] } ]
-
- // Result
- [ { id: 1,
- body: 'John post',
- userId: 101,
- starIds: [ 102, 103, 104 ],
- comments:
- [ { id: 11,
- text: 'John post Marshall comment 11',
- postId: 1,
- userId: 102,
- author: { id: 102, name: 'Marshall' } },
- { id: 12,
- text: 'John post Marshall comment 12',
- postId: 1,
- userId: 102,
- author: { id: 102, name: 'Marshall' } },
- { id: 13,
- text: 'John post Marshall comment 13',
- postId: 1,
- userId: 102,
- author: { id: 102, name: 'Marshall' } } ]
- } ]
- ```
-
-- **Example with a simple batch-loader**
-
- ```js
- // project/src/services/posts/posts.hooks.js
- const { fastJoin } = require('feathers-hooks-common');
- const BatchLoader = require('@feathers-plus/batch-loader');
- const { loaderFactory } = BatchLoader;
-
- const postResolvers = {
- before: context => {
- context._loaders = { user: {} };
- context._loaders.user.id = loaderFactory(users, 'id', false, {
- paginate: false
- })(context);
- },
- joins: {
- author: () => async (post, context) =>
- (post.author = await context._loaders.user.id.load(post.userId)),
-
- starers: () => async (post, context) =>
- !post.starIds
- ? null
- : (post.starers = await context._loaders.user.id.loadMany(post.starIds))
- }
- };
-
- module.exports = {
- after: {
- all: [fastJoin(postResolvers)]
- }
- };
-
- // Original record
- [{ id: 1, body: 'John post', userId: 101, starIds: [102, 103, 104] }][
- // Result
- {
- id: 1,
- body: 'John post',
- userId: 101,
- starIds: [102, 103, 104],
- author: { id: 101, name: 'John' },
- starers: [
- { id: 102, name: 'Marshall' },
- { id: 103, name: 'Barbara' },
- { id: 104, name: 'Aubree' }
- ]
- }
- ];
- ```
-
-- **Comprehensive example**
-
- ```js
- // project/src/services/posts/posts.hooks.js
- const { fastJoin, makeCallingParams } = require('feathers-hooks-common');
- const BatchLoader = require('@feathers-plus/batch-loader');
- const { getResultsByKey, getUniqueKeys } = BatchLoader;
-
- const commentResolvers = {
- joins: {
- author: () => async (comment, context) => !comment.userId ? null :
- comment.userRecord = await context._loaders.user.id.load(comment.userId)
- },
- };
-
- const postResolvers = {
- before: context => {
- context._loaders = { user: {}, comments: {} };
-
- context._loaders.user.id = new BatchLoader(async (keys, context) => {
- const result = await users.find(makeCallingParams(
- context, { id: { $in: getUniqueKeys(keys) } }, undefined, { paginate: false }
- ));
- return getResultsByKey(keys, result, user => user.id, '!');
- },
- { context }
- );
-
- context._loaders.comments.postId = new BatchLoader(async (keys, context) => {
- const result = await comments.find(makeCallingParams(
- context, { postId: { $in: getUniqueKeys(keys) } }, undefined, { paginate: false }
- ));
- return getResultsByKey(keys, result, comment => comment.postId, '[!]');
- },
- { context }
- );
- },
- joins: {
- author: () => async (post, context) =>
- post.userRecord = await context._loaders.user.id.load(post.userId),
-
- starers: () => async (post, context) => !post.starIds ? null :
- post.starIdsRecords = await context._loaders.user.id.loadMany(post.starIds),
-
- comments: {
- resolver: (...args) => async (post, context) =>
- post.commentRecords = await context._loaders.comments.postId.load(post.id),
-
- joins: commentResolvers,
- },
- }
- };
-
- const query = {
- author: true,
- starers: [['id', 'name']],
- comments: {
- args: null,
- author: [['id', 'name']]
- },
- };
-
- module.exports = { after: {
- all: [ fastJoin(postResolvers, context => query) ],
- } };
-
- // Original record
- [ { id: 1,
- body: 'John post',
- userId: 101,
- starIds: [102, 103, 104],
- reputation: [ // The `populate` hook cannot handle this structure.
- { userId: 102, points: 1 },
- { userId: 103, points: 1 },
- { userId: 104, points: 1 }
- ]},
- ]
-
- // Results
- [ { id: 1,
- body: 'John post',
- userId: 101,
- starIds: [ 102, 103, 104 ],
- reputation:
- [ { userId: 102, points: 1, author: 'Marshall' },
- { userId: 103, points: 1, author: 'Barbara' },
- { userId: 104, points: 1, author: 'Aubree' } ],
- author: { id: 101, name: 'John' },
- comments:
- [ { id: 11,
- text: 'John post Marshall comment 11',
- postId: 1,
- userId: 102,
- author: { id: 102, name: 'Marshall' } },
- { id: 12,
- text: 'John post Marshall comment 12',
- postId: 1,
- userId: 102,
- author: { id: 102, name: 'Marshall' } },
- { id: 13,
- text: 'John post Marshall comment 13',
- postId: 1,
- userId: 102,
- author: { id: 102, name: 'Marshall' } } ],
- starers:
- [ { id: 102, name: 'Marshall' },
- { id: 103, name: 'Barbara' },
- { id: 104, name: 'Aubree' } ] },
- ]
- ```
-
-- **Example Using a Persistent Cache**
-
- ```js
- const { cache, fastJoin, makeCallingParams } = require('feathers-hooks-common');
- const BatchLoader = require('@feathers-plus/batch-loader');
- const CacheMap = require('@feathers-plus/cache');
- const { getResultsByKey, getUniqueKeys } = BatchLoader;
-
- // Create a cache for a maximum of 100 users
- const cacheMapUsers = CacheMap({ max: 100 });
-
- // Create a batchLoader using the persistent cache
- const userBatchLoader = new BatchLoader(
- async keys => {
- const result = await users.find(
- makeCallingParams({}, { id: { $in: getUniqueKeys(keys) } }, undefined, {
- paginate: false
- })
- );
- return getResultsByKey(keys, result, user => user.id, '!');
- },
- { cacheMap: cacheMapUsers }
- );
-
- const postResolvers = {
- before: context => {
- context._loaders = { user: {} };
- context._loaders.user.id = userBatchLoader;
- },
-
- joins: {
- author: () => async (post, context) =>
- (post.author = await context._loaders.user.id.load(post.userId)),
-
- starers: () => async (post, context) =>
- !post.starIds
- ? null
- : (post.starers = await context._loaders.user.id.loadMany(post.starIds))
- }
- };
-
- const query = {
- author: true,
- starers: [['id', 'name']],
- comments: {
- args: null,
- author: [['id', 'name']]
- }
- };
-
- module.exports = {
- before: {
- all: cache(cacheMapUsers)
- },
- after: {
- all: [cache(cacheMapUsers), fastJoin(postResolvers, () => query)]
- }
- };
- ```
-
- The number of service calls needed to run the `query` above **the second time**:
-
-| Using | number of service calls |
-| ---------------------: | :---------------------: |
-| `populate` | **22** |
-| `fastJoin` alone | **2** |
-| `fastJoin` and `cache` | **0** |
-
-The `cache` hook also makes `get` service calls more efficient.
-
-> The `cache` hook **must** be registered in both `before` and `after`.
-
-- **Details**
-
- We often want to combine rows from two or more tables based on a relationship between them. The `fastJoin` hook will select records that have matching values in both tables. It can batch service calls and cache records, thereby needing roughly an order of magnitude fewer database calls than the `populate` hook, e.g. _2_ calls instead of _20_.
-
- Relationships such as `1:1`, `1:m`, `n:1`, and `n:m` relationships can be handled.
-
- `fastJoin` uses a GraphQL-like imperative API, and it is not restricted to using data from Feathers services. Resources for which there are no Feathers adapters can [be used.](https://github.com/feathersjs-ecosystem/batch-loader)
-
- The companion `@feathers-plus/cache` implements a least recently-used cache which discards the least recently used items first. When used in conjunction with the `cache` hook, it can be used to implement persistent caches for BatchLoaders. BatchLoaders configured this way would retain their cache between requests, eliminating the need to _prime_ the cache at the start of each request.
-
-## iff
-
-Execute one or another series of hooks depending on a sync or async predicate.
-
-fastJoin and populate.
-
-## setField
-
-The `setField` hook allows to set a field on the hook context based on the value of another field on the hook context.
-
-
+
+
+
+
\ No newline at end of file
diff --git a/docs/hooks/[slug].md b/docs/hooks/[slug].md
new file mode 100644
index 00000000..d9dc0004
--- /dev/null
+++ b/docs/hooks/[slug].md
@@ -0,0 +1,4 @@
+---
+---
+
+
diff --git a/docs/hooks/[slug].paths.ts b/docs/hooks/[slug].paths.ts
new file mode 100644
index 00000000..5e2b9bb3
--- /dev/null
+++ b/docs/hooks/[slug].paths.ts
@@ -0,0 +1,15 @@
+import path from 'node:path'
+import { discoverUtilities } from '../.vitepress/utilities'
+import { defineRoutes } from 'vitepress'
+
+export default defineRoutes({
+ async paths() {
+ const utilities = (await discoverUtilities()).filter(utility => utility.category === 'hooks')
+
+ return utilities.map(utility => ({
+ params: { slug: utility.slug },
+ content: utility.content,
+ }))
+ },
+ watch: [path.resolve(import.meta.dirname, '../../src/hooks/**/*.md')],
+})
diff --git a/docs/hooks/index.data.ts b/docs/hooks/index.data.ts
new file mode 100644
index 00000000..37a1f563
--- /dev/null
+++ b/docs/hooks/index.data.ts
@@ -0,0 +1,8 @@
+import { defineLoader } from 'vitepress'
+import { discoverUtilities } from '../.vitepress/utilities'
+
+export default defineLoader({
+ async load() {
+ return (await discoverUtilities()).filter(utility => utility.category === 'hooks')
+ },
+})
diff --git a/docs/hooks/index.md b/docs/hooks/index.md
new file mode 100644
index 00000000..d5f97f60
--- /dev/null
+++ b/docs/hooks/index.md
@@ -0,0 +1,11 @@
+---
+---
+
+
+
+# Hooks
+
+
+
+
+
+
\ No newline at end of file
diff --git a/docs/predicates/[slug].md b/docs/predicates/[slug].md
new file mode 100644
index 00000000..d9dc0004
--- /dev/null
+++ b/docs/predicates/[slug].md
@@ -0,0 +1,4 @@
+---
+---
+
+
diff --git a/docs/predicates/[slug].paths.ts b/docs/predicates/[slug].paths.ts
new file mode 100644
index 00000000..557d2fe8
--- /dev/null
+++ b/docs/predicates/[slug].paths.ts
@@ -0,0 +1,16 @@
+import { discoverUtilities } from '../.vitepress/utilities'
+import { defineRoutes } from 'vitepress'
+
+export default defineRoutes({
+ async paths() {
+ const utilities = (await discoverUtilities()).filter(
+ utility => utility.category === 'predicates',
+ )
+
+ return utilities.map(utility => ({
+ params: { slug: utility.slug },
+ content: utility.content,
+ }))
+ },
+ watch: ['../src/predicates/**/*.md'],
+})
diff --git a/docs/predicates/index.data.ts b/docs/predicates/index.data.ts
new file mode 100644
index 00000000..97a368b4
--- /dev/null
+++ b/docs/predicates/index.data.ts
@@ -0,0 +1,8 @@
+import { defineLoader } from 'vitepress'
+import { discoverUtilities } from '../.vitepress/utilities'
+
+export default defineLoader({
+ async load() {
+ return (await discoverUtilities()).filter(utility => utility.category === 'predicates')
+ },
+})
diff --git a/docs/predicates/index.md b/docs/predicates/index.md
new file mode 100644
index 00000000..25748d77
--- /dev/null
+++ b/docs/predicates/index.md
@@ -0,0 +1,11 @@
+---
+---
+
+
+
+# Predicates
+
+` | | Hooks, used the same way as when you register them. |
-
-- **Example**
-
- ```js
- const { combine, createdAt, updatedAt } = require('feathers-hooks-common');
-
- async function myCustomHook(context) {
- const newContext = await combine(setNow('createdAt'), setNow('updatedAt')).call(this, context);
- return newContext;
- }
- ```
-
-- **Details**
-
- `combine` has the signature of a hook, but is primarily intended to be used within your custom hooks, not when registering hooks.
-
-The following is a better technique to use when registering hooks.
+## Example
```js
-const workflow = [createdAt(), updatedAt(), ...];
-
-module.exports = { before: {
- update: [...workflow],
- patch: [...workflow],
-} };
+const { callingParams, callingParamsDefaults } = require('feathers-hooks-common/index.js');
+// Authentication props to always copy. Suitable for feathers-authentication-management.
+// Only hooks will be calling `callingParams`. Set a flag so other hooks recognize such a call.
+callingParamsDefaults(['provider', 'authenticated', 'user', 'isVerified'], { _calledByHook: true });
+
+async function myCustomHook(context) {
+ // ...
+ const result = await service.find(callingParams({
+ query: { { id: { $in: [1, 2, 3] } } },
+ propNames: ['customProp'],
+ newProps: { mongoose: ... },
+ hooksToDisable: 'populate'
+ }), context);
+ // ...
+}
```
-## every
-
-Return the and of a series of sync or async predicate functions.
-
-The data is transfered using `context.params.query.$client`. If that field already exists, it must be an Object.
@@ -459,164 +210,118 @@ Pass an explicit context.params from client to server. Client-side.
Replace the records in context.data or context.result[.data].
-- **Arguments**
+## Arguments
- - `{Object} context`
- - `{Array< Object > | Object} records`
+- `{Object} context`
+- `{Array< Object > | Object} records`
| Argument | Type | Default | Description |
| --------- | :------------------------: | ------- | ----------------- |
| `context` | `Object` | | The hook context. |
| `records` | `Array< Object >` `Object` | | The new records. |
-- **Example**
-
- ```js
- const { getItems, replaceItems } = require('feathers-hooks-common');
+## Example
- const insertCode = code => context {
- const items = getItems(context);
- if (Array.isArray(items)) {
- items.forEach(item => { item.code = code; });
- } else {
- items.code = code;
- }
- replaceItems(context, items);
- };
+```js
+const { getItems, replaceItems } = require('feathers-hooks-common/index.js');
+
+const insertCode = code => context {
+ const items = getItems(context);
+ if (Array.isArray(items)) {
+ items.forEach(item => { item.code = code; });
+ } else {
+ items.code = code;
+ }
+ replaceItems(context, items);
+};
- module.exports = { before: {
- create: insertCode('a')
- } };
- ```
+module.exports = { before: {
+ create: insertCode('a')
+} };
+```
-- **Details**
+## Details
- `replaceItems` replaces the records in the hook context: `context.data` (before hook) or `context.result[.data]` (after hook).
+`replaceItems` replaces the records in the hook context: `context.data` (before hook) or `context.result[.data]` (after hook).
## runHook
Let's you call a hook right after the service call.
-- **Arguments**
- - `{Object} [ hookContext ]`
- - `{Function} hookFunc`
+## Arguments
+
+- `{Object} [ hookContext ]`
+- `{Function} hookFunc`
| Argument | Type | Default | Description |
| ------------- | :--------: | ------- | ----------------------------- |
| `hookContext` | `Object` | `{}` | The `context` for `hookFunc`. |
| `hookFunc` | `Function` | | The hook to run. |
-- **Example**
-
- ```js
- const { keep, runHook } = require('feathers-hooks-common');
-
- user.get(...)
- .then( runHook()(keep('name', 'address.state')) )
- .then(data => ...); // [{ name: 'Marshall', address: { state: 'UT' }}]
-
- const data = await user.get(...);
- const result = await runHook()(data)(keep('name', 'address.state'));
- ```
-
- ```js
- const { fastJoin, runHook } = require('feathers-hooks-common');
- const runHookFinds = runHook({ app: app, method: 'find' });
-
- const paymentsRecords = [
- { _id: 101, amount: 100, patientId: 1 },
- { _id: 102, amount: 105, patientId: 1 },
- { _id: 103, amount: 110, patientId: 1 },
- { _id: 104, amount: 115, patientId: 2 },
- { _id: 105, amount: 120, patientId: 3 },
- { _id: 106, amount: 125, patientId: 3 }
- ];
- await payments.create(paymentsRecords);
-
- const patientsRecords = [
- { _id: 1, name: 'John' },
- { _id: 2, name: 'Marshall' },
- { _id: 3, name: 'David' }
- ];
- await patients.create(patientsRecords);
-
- const paymentResolvers = {
- joins: {
- patient: () => async payment => {
- payment.patient = (
- await patients.find({
- query: {
- id: payment.patientId
- }
- })
- )[0];
- }
- }
- };
-
- await payments
- .find()
- .then(runHookFinds(fastJoin(paymentResolvers)))
- .then(data => console.log(data));
-
- // log
- [
- { _id: 101, amount: 100, patientId: 1, patient: { _id: 1, name: 'John' } },
- { _id: 102, amount: 105, patientId: 1, patient: { _id: 1, name: 'John' } },
- { _id: 103, amount: 110, patientId: 1, patient: { _id: 1, name: 'John' } },
- {
- _id: 104,
- amount: 115,
- patientId: 2,
- patient: { _id: 2, name: 'Marshall' }
- },
- { _id: 105, amount: 120, patientId: 3, patient: { _id: 3, name: 'David' } },
- { _id: 106, amount: 125, patientId: 3, patient: { _id: 3, name: 'David' } }
- ];
- ```
-
-- **Details**
-
- Hooks are normally registered for a service, e.g. in `project/src/services` `/posts/posts.hooks.js`. This is nice and simple when, for example, all the `find` hooks have to run for every `find` call.
-
- The [conditional hooks](#tag-Conditionals) can be used when hooks have to be conditionally run based on the current environment. For example, we can discard the `password` field when the call is made by a client.
-
- However things are not always so straightforward. There can be that one call for which we want to join specific records. We could add a conditional hook that runs just for that one call, however we may soon find ourselves with a second and a third special case.
-
- `runHook` is designed for such cases. Instead of having to register a conditioned hook, it allows us to run the hook in a `.then()` right after the service call.
-
-## some
-
-Return the or of a series of sync or async predicate functions.
-
-
+
+
+
+
\ No newline at end of file
diff --git a/docs/utils/[slug].md b/docs/utils/[slug].md
new file mode 100644
index 00000000..d9dc0004
--- /dev/null
+++ b/docs/utils/[slug].md
@@ -0,0 +1,4 @@
+---
+---
+
+
diff --git a/docs/utils/[slug].paths.ts b/docs/utils/[slug].paths.ts
new file mode 100644
index 00000000..bfef7467
--- /dev/null
+++ b/docs/utils/[slug].paths.ts
@@ -0,0 +1,15 @@
+import path from 'node:path'
+import { discoverUtilities } from '../.vitepress/utilities'
+import { defineRoutes } from 'vitepress'
+
+export default defineRoutes({
+ async paths() {
+ const utilities = (await discoverUtilities()).filter(utility => utility.category === 'utils')
+
+ return utilities.map(utility => ({
+ params: { slug: utility.slug },
+ content: utility.content,
+ }))
+ },
+ watch: [path.resolve(import.meta.dirname, '../../src/utils/**/*.md')],
+})
diff --git a/docs/utils/index.data.ts b/docs/utils/index.data.ts
new file mode 100644
index 00000000..97a368b4
--- /dev/null
+++ b/docs/utils/index.data.ts
@@ -0,0 +1,8 @@
+import { defineLoader } from 'vitepress'
+import { discoverUtilities } from '../.vitepress/utilities'
+
+export default defineLoader({
+ async load() {
+ return (await discoverUtilities()).filter(utility => utility.category === 'predicates')
+ },
+})
diff --git a/docs/utils/index.md b/docs/utils/index.md
new file mode 100644
index 00000000..a76a8cf4
--- /dev/null
+++ b/docs/utils/index.md
@@ -0,0 +1,11 @@
+---
+---
+
+
+
+# Utils
+
+ {
- return !!p && (typeof p === 'object' || typeof p === 'function') && typeof p.then === 'function';
+ return p instanceof Promise
}
-export { pluck } from './pluck';
-export { setFields } from './set-fields';
-export { transformItems } from './transform-items';
-export { traverse } from './traverse';
-export { clone } from './clone';
+export { traverse } from './traverse.js'
+export { clone } from './clone.js'
diff --git a/src/common/pluck.ts b/src/common/pluck.ts
deleted file mode 100755
index ecd91d9f..00000000
--- a/src/common/pluck.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import _pick from 'lodash/pick.js';
-
-export function pluck>(
- items: T,
- fieldNames: string[],
-): Record;
-export function pluck>(
- items: T[],
- fieldNames: string[],
-): Record[];
-export function pluck>(
- items: T | T[],
- fieldNames: string[],
-): Record | Record[] {
- if (!Array.isArray(items)) {
- return _pick(items, fieldNames);
- }
-
- const pluckedItems = (Array.isArray(items) ? items : [items]).map(item =>
- _pick(item, fieldNames),
- );
-
- return pluckedItems;
-}
diff --git a/src/common/set-fields.ts b/src/common/set-fields.ts
deleted file mode 100755
index 8ae66905..00000000
--- a/src/common/set-fields.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import _set from 'lodash/set.js';
-
-export function setFields>(
- items: T | T[],
- fieldValue: any,
- fieldNames: string[],
- defaultFieldName: string,
-): void {
- const value = typeof fieldValue === 'function' ? fieldValue() : fieldValue;
-
- if (!fieldNames.length) fieldNames = [defaultFieldName];
-
- (Array.isArray(items) ? items : [items]).forEach(item => {
- fieldNames.forEach((fieldName: any) => {
- _set(item, fieldName, value);
- });
- });
-}
diff --git a/src/common/transform-items.ts b/src/common/transform-items.ts
deleted file mode 100755
index 091e94ce..00000000
--- a/src/common/transform-items.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import _get from 'lodash/get.js';
-
-export function transformItems>(
- items: T | T[],
- fieldNames: string[],
- transformer: (item: T, fieldName: string, val: any) => void,
-): void {
- (Array.isArray(items) ? items : [items]).forEach(item => {
- fieldNames.forEach((fieldName: any) => {
- transformer(item, fieldName, _get(item, fieldName));
- });
- });
-}
diff --git a/src/common/traverse.ts b/src/common/traverse.ts
index 58212a04..b8337f1d 100755
--- a/src/common/traverse.ts
+++ b/src/common/traverse.ts
@@ -1,10 +1,10 @@
-import traverser from 'neotraverse/legacy';
+import traverser from 'neotraverse/legacy'
export function traverse>(
items: T | T[],
converter: (item: T) => void,
) {
- (Array.isArray(items) ? items : [items]).forEach(item => {
- traverser(item).forEach(converter); // replacement is in place
- });
+ ;(Array.isArray(items) ? items : [items]).forEach(item => {
+ traverser(item).forEach(converter) // replacement is in place
+ })
}
diff --git a/src/hooks/act-on-dispatch.ts b/src/hooks/act-on-dispatch.ts
deleted file mode 100755
index 893ffe07..00000000
--- a/src/hooks/act-on-dispatch.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-import type { HookFunction } from '../types';
-import { combine } from '../utils/combine';
-
-/**
- * Runs a series of hooks which mutate context.data or context.result (the Feathers default).
- * @see https://hooks-common.feathersjs.com/hooks.html#actondefault
- */
-export const actOnDefault = (...hooks: HookFunction[]) =>
- actOn(undefined, ...hooks);
-
-/**
- * Runs a series of hooks which mutate context.dispatch.
- * @see https://hooks-common.feathersjs.com/hooks.html#actondispatch
- */
-export const actOnDispatch = (...hooks: HookFunction[]) =>
- actOn('dispatch', ...hooks);
-
-function actOn(what: any, ...hooks: HookFunction[]) {
- return async (context: H) => {
- // @ts-ignore
- const currActOn = context.params._actOn;
- // @ts-ignore
- context.params._actOn = what;
-
- const newContext = await combine(...hooks)(context);
- newContext.params._actOn = currActOn;
- return newContext;
- };
-}
diff --git a/src/hooks/alter-items.ts b/src/hooks/alter-items.ts
deleted file mode 100755
index 4e6863dc..00000000
--- a/src/hooks/alter-items.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { BadRequest } from '@feathersjs/errors';
-
-import type { HookContext } from '@feathersjs/feathers';
-import { isPromise } from '../common';
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-
-/**
- * Make changes to data or result items. Very flexible.
- * @see https://hooks-common.feathersjs.com/hooks.html#alteritems
- */
-export function alterItems(
- cb: (record: T, context: H) => any,
-) {
- if (!cb) {
- cb = () => {};
- }
-
- if (typeof cb !== 'function') {
- throw new BadRequest('Function required. (alter)');
- }
-
- return (context: H) => {
- let items = getItems(context);
- const isArray = Array.isArray(items);
-
- const results: any[] = (isArray ? items : [items]).map((item: any) => cb(item, context));
-
- const hasPromises = results.some((result: any) => isPromise(result));
-
- const setItem = (value: any, index: any) => {
- if (typeof value === 'object' && value !== null) {
- if (isArray) {
- items[index] = value;
- } else {
- items = value;
- }
- }
- };
-
- if (hasPromises) {
- return Promise.all(results).then(values => {
- values.forEach(setItem);
-
- replaceItems(context, items);
- return context;
- });
- } else {
- results.forEach(setItem);
-
- replaceItems(context, items);
- return context;
- }
- };
-}
diff --git a/src/hooks/cache.ts b/src/hooks/cache.ts
deleted file mode 100755
index fe9c94d2..00000000
--- a/src/hooks/cache.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import type { HookContext, Id } from '@feathersjs/feathers';
-import { getItems } from '../utils/get-items';
-import { clone as defaultClone } from '../common/clone';
-
-export type CacheMap = Map;
-
-export interface CacheOptions {
- clone?(item: T): T;
- makeCacheKey?(id: Id): string;
-}
-
-const defaultMakeCacheKey = (key: any) => key;
-
-/**
- * Persistent, most-recently-used record cache for services.
- *
- * @see https://hooks-common.feathersjs.com/hooks.html#cache
- */
-export function cache(
- cacheMap: CacheMap,
- keyField?: string,
- options?: CacheOptions,
-) {
- const clone = options?.clone || defaultClone;
- const makeCacheKey = options?.makeCacheKey || defaultMakeCacheKey;
-
- return (context: H) => {
- keyField = keyField || context.service?.id; // Will be undefined on client
-
- let items = getItems(context);
- items = Array.isArray(items) ? items : [items];
-
- const query = context.params.query || {};
-
- if (context.type === 'after') {
- if (context.method === 'remove') {
- items.forEach((item: any) => {
- const idName = getIdName(keyField, item);
- const key = makeCacheKey(item[idName]);
- cacheMap.delete(key);
- });
- return context;
- }
-
- if (query.$select) return context;
-
- items.forEach((item: any) => {
- const idName = getIdName(keyField, item);
- const key = makeCacheKey(item[idName]);
- cacheMap.set(key, clone(item));
- });
-
- return context;
- }
-
- switch (context.method) {
- case 'find': // fall through
- case 'remove': // skip remove in before remove
- case 'create':
- return context;
- case 'get': {
- if (!Object.keys(query).length) {
- const key = makeCacheKey(context.id!);
- const value = cacheMap.get(key);
- if (value) context.result = value;
- }
- return context;
- }
- default: // update, patch, remove
- if (context.id) {
- cacheMap.delete(context.id);
- return context;
- }
-
- items.forEach((item: any) => {
- const idName = getIdName(keyField, item);
- const key = makeCacheKey(item[idName]);
- cacheMap.delete(key);
- });
- }
-
- return context;
- };
-}
-
-function getIdName(keyField: any, item: any) {
- if (keyField) return keyField;
- return '_id' in item ? '_id' : 'id';
-}
diff --git a/src/hooks/cache/cache.md b/src/hooks/cache/cache.md
new file mode 100644
index 00000000..ad7ba63e
--- /dev/null
+++ b/src/hooks/cache/cache.md
@@ -0,0 +1,94 @@
+---
+title: cache
+description: Persistent, least-recently-used record cache for services.
+category: hooks
+hook:
+ type: ['before', 'after']
+ method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+ multi: true
+---
+
+## Arguments
+
+- `{Object | Map} cacheMap`
+- `{String} [ keyField ]`
+- `{Object} [ options ]`
+ - `{Function} [ clone ]`
+ - `{Function} [makeCacheKey]`
+
+| Argument | Type | Default | Description |
+| ---------- | :------------: | -------------------------------------------------- | ---------------------------------------------------------------------------- |
+| `cacheMap` | `Object` `Map` | | Instance of `Map`, or an object with a similar API, to be used as the cache. |
+| `keyField` | `String` | `context.service.id` or `item._id ? '_id' !! 'id'` | The name of the record id field. |
+| `option` | `Object` | | Options. |
+
+| `options` | Argument | Type | Default | Description |
+| -------------- | ---------- | :--------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
+| `clone` | `Function` | `item => JSON.parse(` `JSON.stringify(item) )` | Function to perform a deep clone. See below. |
+| `makeCacheKey` | `Function` | `key => key` | Function to convert record key to cache key. Use this to convert MongoDB/Mongoose ObjectId/bson keys to a cache key using `item._id.toString()`. |
+
+## Examples
+
+```ts twoslash
+const CacheMap = require('@feathers-plus/cache');
+const { cache } = require('feathers-hooks-common/index.js');
+
+const cacheMap = CacheMap({ max: 100 }); // Keep the 100 most recently used.
+
+module.exports = { before: { all: cache(cacheMap) }, after: { all: cache(cacheMap) } };
+```
+
+```js
+const { cache } = require('feathers-hooks-common/index.js');
+
+const cacheMap = new Map();
+
+module.exports = { before: { all: cache(cacheMap) }, after: { all: cache(cacheMap) } };
+```
+
+```js
+const CacheMap = require('@feathers-plus/cache');
+const mongoose = require('mongoose');
+const { cache } = require('feathers-hooks-common/index.js');
+
+const cacheMap = CacheMap({ max: 100 });
+const makeCacheKey = key => (key instanceof mongoose.Types.ObjectId ? key.toString() : key);
+
+module.exports = {
+ before: { all: cache(cacheMap, undefined, { makeCacheKey }) },
+ after: { all: cache(cacheMap, undefined, { makeCacheKey }) },
+};
+```
+
+> The `cache` hook **must** be registered in both `before` and `after`.
+
+ The cache will grow without limit when `Map` is used and the resulting memory pressure may adversely affect your performance. `Map` should only be used when you know or can control its size.
+
+## Details
+
+The `cache` hook maintain a persistent cache for the service it is registerd on. A persistent cache stores records so future requests for those records can be served faster; the records stored in the cache are duplicates of records stored in the database.
+
+The `get` service method retrieves records from the cache and updates `context.result` `[.data]`. The other methods remove their `context.data` entries from the cache in the `before` hook, and add entries in the `after` hook. All the records returned by a `find` call are added to the cache.
+
+The `cache` hook may be provided a custom Map instance to use as its memoization cache. Any object that implements the methods get(), set(), delete() and clear() can be provided. This allows for custom Maps which implement various [cache algorithms](https://en.wikipedia.org/wiki/Cache_replacement_policies) to be provided.
+
+The companion `@feathers-plus/cache` provides a least recently-used cache which discards the least recently used items first. It is compatible with `cache` as well as the BatchLoaders used with the `fastJoin` hook.
+
+> The `cache` hook can make [fastJoin](#fastjoin) hooks run more efficiently.
+
+MongoDB and Mongoose store record keys as bson objects rather than as scalars. The safest way to use the cache is in conjunction with the `makeCacheKey` option.
+
+- **options.clone**
+
+ The clone function has a single parameter.
+
+ - `{Object} item`
+
+ It returns
+
+ - `{Object} clonedItem`
+
+| Argument | Type | Default | Description |
+| ------------ | :------: | ------- | ------------------ |
+| `item` | `Object` | | The record. |
+| `clonedItem` | `Object` | | A clone of `item`. |
diff --git a/src/hooks/cache/cache.test.ts b/src/hooks/cache/cache.test.ts
new file mode 100755
index 00000000..b39b8d1f
--- /dev/null
+++ b/src/hooks/cache/cache.test.ts
@@ -0,0 +1,364 @@
+import { assert } from 'vitest'
+import { cache } from './cache.js'
+
+// @ts-expect-error old
+import CacheMap from '@feathers-plus/cache'
+
+let cacheMap: any
+let hookBeforeSingle: any
+let hookBeforeMulti: any
+let hookAfterSingle: any
+let hookAfterSingleNormalize: any
+let hookAfterMulti: any
+let hookAfterPaginated: any
+let hookBeforeUuid: any
+let hookAfterUuid: any
+let hookBeforeMultiMixed: any
+let hookAfterMultiMixed: any
+let map: any
+let cloneCount: any
+
+const makeCacheKey = (key: any) => -key
+
+describe('service cache', () => {
+ beforeEach(() => {
+ cacheMap = CacheMap({ max: 3 })
+ map = new Map()
+ cloneCount = 0
+
+ hookBeforeSingle = {
+ type: 'before',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ data: { id: 1, first: 'John', last: 'Doe' },
+ }
+ hookBeforeMulti = {
+ type: 'before',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ data: [
+ { id: 1, first: 'John', last: 'Doe' },
+ { id: 2, first: 'Jane', last: 'Doe' },
+ ],
+ }
+ hookAfterSingle = {
+ type: 'after',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ result: { id: 1, first: 'Jane', last: 'Doe' },
+ }
+ hookAfterSingleNormalize = {
+ type: 'after',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ result: { id: -1, first: 'Jane', last: 'Doe' },
+ }
+ hookAfterMulti = {
+ type: 'after',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ result: [
+ { id: 1, first: 'John', last: 'Doe' },
+ { id: 2, first: 'Jane', last: 'Doe' },
+ ],
+ }
+ hookAfterPaginated = {
+ type: 'after',
+ method: 'find',
+ params: { provider: 'rest' },
+ result: {
+ total: 2,
+ data: [
+ { id: 1, first: 'John', last: 'Doe' },
+ { id: 2, first: 'Jane', last: 'Doe' },
+ ],
+ },
+ }
+ hookBeforeUuid = {
+ type: 'before',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ data: { uuid: 1, first: 'John', last: 'Doe' },
+ service: { id: 'uuid' },
+ }
+ hookAfterUuid = {
+ type: 'after',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ result: { uuid: 1, first: 'Jane', last: 'Doe' },
+ service: { id: 'uuid' },
+ }
+ hookBeforeMultiMixed = {
+ type: 'before',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ data: [
+ { _id: 1, first: 'John', last: 'Doe' },
+ { id: 2, first: 'Jane', last: 'Doe' },
+ ],
+ }
+ hookAfterMultiMixed = {
+ type: 'after',
+ id: undefined,
+ method: undefined,
+ params: { provider: 'rest' },
+ result: [
+ { id: 1, first: 'John', last: 'Doe' },
+ { _id: 2, first: 'Jane', last: 'Doe' },
+ ],
+ }
+ })
+
+ describe('Can build a cache', () => {
+ it('Can build a cache', () => {
+ cacheMap.set('a', 'aa')
+ assert.equal(cacheMap.get('a'), 'aa', 'bad get after set')
+
+ cacheMap.delete('a')
+ assert.equal(cacheMap.get('a'), undefined, 'bad get after delete')
+
+ cacheMap.set('a', 'aa')
+ cacheMap.clear()
+ assert.equal(cacheMap.get('a'), undefined, 'bad get after clear')
+ })
+ })
+
+ describe('Clears cache', () => {
+ it('Before one-record update', () => {
+ hookBeforeSingle.method = 'update'
+
+ cacheMap.set(1, 123)
+
+ cache(cacheMap, 'id')(hookBeforeSingle)
+ assert.deepEqual(cacheMap.get(1), undefined)
+ })
+
+ it('Before multi-record update', () => {
+ hookBeforeMulti.method = 'update'
+
+ cacheMap.set(1, 123)
+ cacheMap.set(2, 124)
+
+ cache(cacheMap, 'id')(hookBeforeMulti)
+
+ assert.deepEqual(cacheMap.get(1), undefined)
+ assert.deepEqual(cacheMap.get(2), undefined)
+ })
+
+ it('Before one-record patch', () => {
+ hookBeforeSingle.method = 'patch'
+
+ cacheMap.set(1, 123)
+
+ cache(cacheMap, 'id')(hookBeforeSingle)
+
+ assert.deepEqual(cacheMap.get(1), undefined)
+ })
+
+ it('Before multi-record patch', () => {
+ hookBeforeMulti.method = 'patch'
+
+ cacheMap.set(1, 123)
+ cacheMap.set(2, 789)
+
+ cache(cacheMap, 'id')(hookBeforeMulti)
+ assert.deepEqual(cacheMap.get(1), undefined, 'id 1')
+ assert.deepEqual(cacheMap.get(2), undefined, 'id 2')
+ })
+
+ it('NOT before one-record create', () => {
+ hookBeforeSingle.method = 'create'
+
+ cacheMap.set(1, 123)
+
+ cache(cacheMap, 'id')(hookBeforeSingle)
+ assert.deepEqual(cacheMap.get(1), 123)
+ })
+
+ it('NOT before multi-record remove', () => {
+ hookBeforeMulti.method = 'remove'
+
+ cacheMap.set(1, 123)
+ cacheMap.set(2, 321)
+
+ cache(cacheMap, 'id')(hookBeforeMulti)
+ assert.deepEqual(cacheMap.get(1), 123)
+ assert.deepEqual(cacheMap.get(2), 321)
+ })
+
+ it('After multi-record remove', () => {
+ hookAfterMulti.method = 'remove'
+
+ cacheMap.set(1, 123)
+ cacheMap.set(2, 321)
+
+ cache(cacheMap, 'id')(hookAfterMulti)
+
+ assert.deepEqual(cacheMap.get(1), undefined, 'id 1')
+ assert.deepEqual(cacheMap.get(2), undefined, 'id 2')
+ })
+ })
+
+ describe('Loads cache', () => {
+ it('After one-record create', () => {
+ hookAfterSingle.method = 'create'
+
+ cache(cacheMap, 'id')(hookAfterSingle)
+ assert.deepEqual(cacheMap.get(1), { id: 1, first: 'Jane', last: 'Doe' })
+ })
+
+ it('After multi-record patch', () => {
+ hookAfterMulti.method = 'patch'
+
+ cache(cacheMap, 'id')(hookAfterMulti)
+
+ assert.deepEqual(cacheMap.get(1), { id: 1, first: 'John', last: 'Doe' }, 'id 1')
+ assert.deepEqual(cacheMap.get(2), { id: 2, first: 'Jane', last: 'Doe' }, 'id 2')
+ })
+
+ it('After paginated find', () => {
+ cache(cacheMap, 'id')(hookAfterPaginated)
+
+ assert.deepEqual(cacheMap.get(1), { id: 1, first: 'John', last: 'Doe' }, 'id 1')
+ assert.deepEqual(cacheMap.get(2), { id: 2, first: 'Jane', last: 'Doe' }, 'id 2')
+ })
+
+ it('NOT after remove', () => {
+ hookAfterMulti.method = 'remove'
+
+ cache(cacheMap, 'id')(hookAfterMulti)
+
+ assert.deepEqual(cacheMap.get(1), undefined, 'id 1')
+ assert.deepEqual(cacheMap.get(2), undefined, 'id 2')
+ })
+
+ it('Normalizes record', () => {
+ hookAfterSingleNormalize.method = 'create'
+
+ // @ts-expect-error TODO
+ cache(cacheMap, 'id', { makeCacheKey })(hookAfterSingleNormalize)
+ assert.deepEqual(cacheMap.get(1), { id: -1, first: 'Jane', last: 'Doe' })
+ })
+ })
+
+ describe('Gets from cache', () => {
+ it('Before one-record get', () => {
+ hookBeforeSingle.method = 'get'
+ hookBeforeSingle.id = 1
+
+ cacheMap.set(1, { foo: 'bar' })
+
+ cache(cacheMap, 'id')(hookBeforeSingle)
+
+ assert.deepEqual(cacheMap.get(1), { foo: 'bar' }, 'cache')
+ assert.deepEqual(hookBeforeSingle.result, { foo: 'bar' })
+ })
+
+ it('Normalizes record', () => {
+ hookBeforeSingle.method = 'get'
+ hookBeforeSingle.id = -1
+
+ cacheMap.set(1, { id: -1, foo: 'bar' })
+
+ // @ts-expect-error TODO
+ cache(cacheMap, 'id', { makeCacheKey })(hookBeforeSingle)
+
+ assert.deepEqual(cacheMap.get(1), { id: -1, foo: 'bar' }, 'cache')
+ assert.deepEqual(hookBeforeSingle.result, { id: -1, foo: 'bar' })
+ })
+ })
+
+ describe('Uses context.service.id', () => {
+ it('Clears cache before one-record update', () => {
+ hookBeforeUuid.method = 'update'
+
+ cacheMap.set(1, 123)
+
+ cache(cacheMap)(hookBeforeUuid)
+ assert.deepEqual(cacheMap.get(1), undefined)
+ })
+
+ it('Loads cache after one-record create', () => {
+ hookAfterUuid.method = 'create'
+
+ cache(cacheMap)(hookAfterUuid)
+ assert.deepEqual(cacheMap.get(1), { uuid: 1, first: 'Jane', last: 'Doe' })
+ })
+
+ it('Before one-record get', () => {
+ hookBeforeUuid.method = 'get'
+ hookBeforeUuid.id = 1
+
+ cacheMap.set(1, { foo: 'bar' })
+
+ cache(cacheMap)(hookBeforeUuid)
+
+ assert.deepEqual(cacheMap.get(1), { foo: 'bar' }, 'cache')
+ assert.deepEqual(hookBeforeUuid.result, { foo: 'bar' })
+ })
+ })
+
+ describe('Uses item._id || item.id', () => {
+ it('Clears cache before multi-record patch', () => {
+ hookBeforeMultiMixed.method = 'patch'
+
+ cacheMap.set(1, 123)
+ cacheMap.set(2, 789)
+
+ cache(cacheMap)(hookBeforeMultiMixed)
+ assert.deepEqual(cacheMap.get(1), undefined, 'id 1')
+ assert.deepEqual(cacheMap.get(2), undefined, 'id 2')
+ })
+
+ it('Loads cache after multi-record patch', () => {
+ hookAfterMultiMixed.method = 'patch'
+
+ cache(cacheMap)(hookAfterMultiMixed)
+
+ assert.deepEqual(cacheMap.get(1), { id: 1, first: 'John', last: 'Doe' }, 'id 1')
+ assert.deepEqual(cacheMap.get(2), { _id: 2, first: 'Jane', last: 'Doe' }, 'id 2')
+ })
+ })
+
+ describe('Works with an ES6 Map', () => {
+ it('Clears cache before one-record update', () => {
+ hookBeforeUuid.method = 'update'
+
+ map.set(1, 123)
+
+ cache(map)(hookBeforeUuid)
+ assert.deepEqual(map.get(1), undefined)
+ })
+
+ it('Loads cache after one-record create', () => {
+ hookAfterUuid.method = 'create'
+
+ cache(map)(hookAfterUuid)
+ assert.deepEqual(map.get(1), { uuid: 1, first: 'Jane', last: 'Doe' })
+ })
+ })
+
+ describe('Misc', () => {
+ it('Uses option.clone', () => {
+ hookAfterUuid.method = 'create'
+
+ // @ts-expect-error TODO
+ cache(cacheMap, null, { clone })(hookAfterUuid)
+ assert.deepEqual(cacheMap.get(1), { uuid: 1, first: 'Jane', last: 'Doe' }, 'get')
+ assert.equal(cloneCount, 1, 'count')
+ })
+ })
+})
+
+function clone(obj: any) {
+ cloneCount += 1
+ return Object.assign({}, obj)
+}
diff --git a/src/hooks/cache/cache.ts b/src/hooks/cache/cache.ts
new file mode 100755
index 00000000..d575cec6
--- /dev/null
+++ b/src/hooks/cache/cache.ts
@@ -0,0 +1,92 @@
+import type { HookContext, Id } from '@feathersjs/feathers'
+import { getItems } from '../../utils/index.js'
+import { clone as defaultClone } from '../../common/index.js'
+
+export type CacheMap = Map
+
+export interface CacheOptions {
+ clone?(item: T): T
+ makeCacheKey?(id: Id): string
+}
+
+const defaultMakeCacheKey = (key: any) => key
+
+/**
+ * A hook that caches results in a Map.
+ *
+ * @param cacheMap - The Map to use for caching.
+ * @param keyField - Optional field name to use as the cache key.
+ * @param options - Optional configuration for cloning and cache key generation.
+ * @param options.clone - Function to clone items before caching.
+ */
+export function cache(
+ cacheMap: CacheMap,
+ keyField?: string,
+ options?: CacheOptions,
+) {
+ const clone = options?.clone || defaultClone
+ const makeCacheKey = options?.makeCacheKey || defaultMakeCacheKey
+
+ return (context: H) => {
+ keyField = keyField || context.service?.id // Will be undefined on client
+
+ let items = getItems(context)
+ items = Array.isArray(items) ? items : [items]
+
+ const query = context.params.query || {}
+
+ if (context.type === 'after') {
+ if (context.method === 'remove') {
+ items.forEach((item: any) => {
+ const idName = getIdName(keyField, item)
+ const key = makeCacheKey(item[idName])
+ cacheMap.delete(key)
+ })
+ return context
+ }
+
+ if (query.$select) return context
+
+ items.forEach((item: any) => {
+ const idName = getIdName(keyField, item)
+ const key = makeCacheKey(item[idName])
+ cacheMap.set(key, clone(item))
+ })
+
+ return context
+ }
+
+ switch (context.method) {
+ case 'find': // fall through
+ case 'remove': // skip remove in before remove
+ case 'create':
+ return context
+ case 'get': {
+ if (!Object.keys(query).length) {
+ const key = makeCacheKey(context.id!)
+ const value = cacheMap.get(key)
+ if (value) context.result = value
+ }
+ return context
+ }
+ default: // update, patch, remove
+ if (context.id) {
+ cacheMap.delete(context.id)
+ return context
+ }
+
+ items.forEach((item: any) => {
+ const idName = getIdName(keyField, item)
+ const key = makeCacheKey(item[idName])
+ cacheMap.delete(key)
+ })
+ }
+
+ return context
+ }
+}
+
+function getIdName(keyField: any, item: any) {
+ if (keyField) return keyField
+ return '_id' in item ? '_id' : 'id'
+}
diff --git a/src/hooks/check-required/check-required.md b/src/hooks/check-required/check-required.md
new file mode 100644
index 00000000..fc190fb5
--- /dev/null
+++ b/src/hooks/check-required/check-required.md
@@ -0,0 +1,24 @@
+---
+title: checkRequired
+description: Check selected fields exist and are not falsey. Numeric 0 is acceptable.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
+
+- Arguments
+ - `{Array < String >} fieldNames`
+
+| Name | Type | Description |
+| ---------- | ------------ | ------------------------------------------------------------------- |
+| fieldNames | dot notation | These fields must exist and not be falsey. Numeric 0 is acceptable. |
+
+## Example
+
+```js
+const { required } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: { all: required('email', 'password') } };
+```
diff --git a/src/hooks/check-required/check-required.test.ts b/src/hooks/check-required/check-required.test.ts
new file mode 100755
index 00000000..85c6d935
--- /dev/null
+++ b/src/hooks/check-required/check-required.test.ts
@@ -0,0 +1,36 @@
+import { assert } from 'vitest'
+import { checkRequired } from './check-required.js'
+import type { HookContext } from '@feathersjs/feathers'
+
+let hookBefore: HookContext
+
+describe('checkRequired', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
+ } as HookContext
+ })
+
+ it('does 1 prop with no dots', () => {
+ checkRequired('empl')(hookBefore)
+ })
+
+ it('does multi props with 1 dot', () => {
+ checkRequired(['empl.name', 'dept'])(hookBefore)
+ })
+
+ it('does multi props with 2 dots', () => {
+ checkRequired(['empl.name.last', 'empl.status', 'dept'])(hookBefore)
+ })
+
+ it('throws on bad or missing paths', () => {
+ assert.throws(() => checkRequired(['empl.name.first', 'empl.name.surname'])(hookBefore))
+ })
+
+ it('ignores bad or missing no dot path', () => {
+ assert.throws(() => checkRequired('xx')(hookBefore))
+ })
+})
diff --git a/src/hooks/check-required/check-required.ts b/src/hooks/check-required/check-required.ts
new file mode 100755
index 00000000..a872ec12
--- /dev/null
+++ b/src/hooks/check-required/check-required.ts
@@ -0,0 +1,41 @@
+import _get from 'lodash/get.js'
+import _has from 'lodash/has.js'
+import { BadRequest } from '@feathersjs/errors'
+
+import { checkContext, getDataIsArray } from '../../utils/index.js'
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+/**
+ * Check selected fields exist and are not falsey. Numeric 0 is acceptable.
+ * @see https://hooks-common.feathersjs.com/hooks.html#required
+ */
+export function checkRequired(fieldNames: MaybeArray) {
+ const fieldNamesArray = toArray(fieldNames)
+ return (context: H, next?: NextFunction) => {
+ checkContext(context, ['before', 'around'], ['create', 'update', 'patch'], 'checkRequired')
+
+ const { data } = getDataIsArray(context)
+
+ for (let i = 0; i < data.length; i++) {
+ const item = data[i]
+
+ for (let j = 0; j < fieldNamesArray.length; j++) {
+ const name = fieldNamesArray[j]
+
+ if (!_has(item, name)) {
+ throw new BadRequest(`Field ${name} does not exist. (required)`)
+ }
+
+ const value = _get(item, name)
+
+ if (!value && value !== 0 && value !== false) {
+ throw new BadRequest(`Field ${name} is null. (required)`)
+ }
+ }
+ }
+
+ if (next) return next().then(() => context)
+ }
+}
diff --git a/src/hooks/combine/combine.md b/src/hooks/combine/combine.md
new file mode 100644
index 00000000..59e0189a
--- /dev/null
+++ b/src/hooks/combine/combine.md
@@ -0,0 +1,43 @@
+---
+title: combine
+description: Sequentially execute multiple sync or async hooks.
+category: hooks
+hook:
+ type: ['before', 'after']
+ method: ['all']
+ multi: true
+---
+
+## Arguments
+
+- `{Array< Function >} hookFuncs`
+
+| Argument | Type | Default | Description |
+| ----------- | :----------------: | ------- | --------------------------------------------------- |
+| `hookFuncs` | `Array` | | Hooks, used the same way as when you register them. |
+
+## Example
+
+```js
+const { combine, createdAt, updatedAt } = require('feathers-hooks-common/index.js');
+
+async function myCustomHook(context) {
+ const newContext = await combine(setNow('createdAt'), setNow('updatedAt')).call(this, context);
+ return newContext;
+}
+```
+
+## Details
+
+`combine` has the signature of a hook, but is primarily intended to be used within your custom hooks, not when registering hooks.
+
+The following is a better technique to use when registering hooks.
+
+```js
+const workflow = [createdAt(), updatedAt(), ...];
+
+module.exports = { before: {
+ update: [...workflow],
+ patch: [...workflow],
+} };
+```
diff --git a/src/hooks/combine/combine.test.ts b/src/hooks/combine/combine.test.ts
new file mode 100755
index 00000000..b83e38e5
--- /dev/null
+++ b/src/hooks/combine/combine.test.ts
@@ -0,0 +1,152 @@
+/* eslint-disable @typescript-eslint/no-this-alias */
+import { assert } from 'vitest'
+import { feathers } from '@feathersjs/feathers'
+import { MemoryService } from '@feathersjs/memory'
+import { combine } from './combine.js'
+import { clone } from '../../common/index.js'
+
+const startId = 6
+const storeInit = {
+ 0: { name: 'Jane Doe', key: 'a', id: 0 },
+ 1: { name: 'Jack Doe', key: 'a', id: 1 },
+ 2: { name: 'Jack Doe', key: 'a', id: 2, deleted: true },
+ 3: { name: 'Rick Doe', key: 'b', id: 3 },
+ 4: { name: 'Dick Doe', key: 'b', id: 4 },
+ 5: { name: 'Dick Doe', key: 'b', id: 5, deleted: true },
+}
+let store
+
+function services(app: any) {
+ app.configure(user)
+}
+
+function user(app: any) {
+ let service: any
+ let hookId: any
+ let hookData: any
+ let hookParamsQuery: any
+ store = clone(storeInit)
+
+ app.use(
+ '/users',
+ new MemoryService({
+ store,
+ startId,
+ }),
+ )
+
+ app.service('users').hooks({
+ before: {
+ all: [
+ function (this: any, hook: any) {
+ if (hook.app !== app) {
+ throw new Error('App wrong 0.')
+ }
+ service = this
+
+ hook.data = { a: 'a' }
+
+ hookId = hook.id
+ hookData = clone(hook.data)
+ hookParamsQuery = clone(hook.params.query)
+
+ return hook
+ },
+ combine(
+ function (this: any, hook: any) {
+ if (hook.app !== app) {
+ throw new Error('App wrong 1.')
+ }
+ if (service !== this) {
+ throw new Error('Service wrong 1.')
+ }
+ hook.params.trace = ['sync1']
+ return hook
+ },
+ function (this: any, hook: any) {
+ if (hook.app !== app) {
+ throw new Error('App wrong 2.')
+ }
+ if (service !== this) {
+ throw new Error('Service wrong 2.')
+ }
+
+ if (hook.params.query.key === 'b') {
+ throw new Error('Requested throw.')
+ }
+
+ hook.params.trace.push('promise1')
+ return Promise.resolve(hook)
+ },
+ function (this: any, hook: any) {
+ if (hook.app !== app) {
+ throw new Error('App wrong 3.')
+ }
+ if (service !== this) {
+ throw new Error('Service wrong 3.')
+ }
+ hook.params.trace.push('sync2')
+ },
+ function (this: any, hook: any) {
+ if (hook.app !== app) {
+ throw new Error('App wrong 4.')
+ }
+ if (service !== this) {
+ throw new Error('Service wrong 4.')
+ }
+ hook.params.trace.push('cb1')
+
+ return hook
+ },
+ function (this: any, hook: any) {
+ if (hook.app !== app) {
+ throw new Error('App wrong 5.')
+ }
+ if (service !== this) {
+ throw new Error('Service wrong 5.')
+ }
+ hook.params.trace.push('sync3')
+ return hook
+ },
+ ),
+ function (this: any, hook: any) {
+ if (hook.app !== app) {
+ throw new Error('App wrong 9.')
+ }
+ if (service !== this) {
+ throw new Error('Service wrong 9.')
+ }
+
+ assert.equal(hook.id, hookId)
+ assert.deepEqual(hook.data, hookData)
+ assert.deepEqual(hook.params.query, hookParamsQuery)
+
+ assert.deepEqual(hook.params.trace, ['sync1', 'promise1', 'sync2', 'cb1', 'sync3'])
+ },
+ ],
+ },
+ })
+}
+
+describe('util combine', () => {
+ let app
+ let user: any
+
+ beforeEach(() => {
+ app = feathers().configure(services)
+ user = app.service('users')
+ })
+
+ it('runs successful hooks', async () => {
+ await user.find({ query: { key: 'a' } })
+ })
+
+ it('throws on unsuccessful hook', async () => {
+ await user
+ .find({ query: { key: 'b' } })
+ .then((_data: any) => {
+ assert.fail(true, false)
+ })
+ .catch(() => {})
+ })
+})
diff --git a/src/utils/combine.ts b/src/hooks/combine/combine.ts
similarity index 59%
rename from src/utils/combine.ts
rename to src/hooks/combine/combine.ts
index e1e44eca..51a0e036 100755
--- a/src/utils/combine.ts
+++ b/src/hooks/combine/combine.ts
@@ -1,8 +1,8 @@
-import type { HookContext } from '@feathersjs/feathers';
-import type { HookFunction } from '../types';
+import type { HookContext } from '@feathersjs/feathers'
+import type { HookFunction } from '../../types.js'
/**
- * Sequentially execute multiple sync or async hooks.
+ * Sequentially execute multiple hooks.
* @see https://hooks-common.feathersjs.com/utilities.html#combine
*/
export function combine(...serviceHooks: HookFunction[]) {
@@ -11,11 +11,11 @@ export function combine(...serviceHooks: Ho
// }
const isContext = function (ctx: H) {
- return typeof ctx?.method === 'string' && typeof ctx?.type === 'string';
- };
+ return typeof ctx?.method === 'string' && typeof ctx?.type === 'string'
+ }
return async function (context: H) {
- let ctx = context;
+ let ctx = context
const updateCurrentHook = (current: void | H) => {
// Either use the returned hook object or the current
@@ -24,37 +24,36 @@ export function combine(...serviceHooks: Ho
if (!isContext(current)) {
throw new Error(
`${ctx.type} hook for '${ctx.method}' method returned invalid hook object`,
- );
+ )
}
- ctx = current;
+ ctx = current
}
- return ctx;
- };
+ return ctx
+ }
// Go through all hooks and chain them into our promise
- // @ts-ignore
+
+ // @ts-expect-error TODO
const promise = serviceHooks.reduce(async (current, fn) => {
- // @ts-ignore
- const hook = fn.bind(this);
+ // @ts-expect-error TODO
+ const hook = fn.bind(this)
// Use the returned hook object or the old one
- // eslint-disable-next-line @typescript-eslint/await-thenable
- const currentHook = await current;
- const currentCtx = await hook(currentHook);
- // @ts-ignore
- return updateCurrentHook(currentCtx);
- }, Promise.resolve(ctx));
+
+ const currentHook = await current
+ const currentCtx = await hook(currentHook)
+ return updateCurrentHook(currentCtx)
+ }, Promise.resolve(ctx))
try {
- // eslint-disable-next-line @typescript-eslint/await-thenable
- await promise;
- return ctx;
+ await promise
+ return ctx
} catch (error: any) {
// Add the hook information to any errors
- error.hook = ctx;
- throw error;
+ error.hook = ctx
+ throw error
}
- };
+ }
}
diff --git a/src/hooks/create-related/create-related.md b/src/hooks/create-related/create-related.md
new file mode 100644
index 00000000..137a5666
--- /dev/null
+++ b/src/hooks/create-related/create-related.md
@@ -0,0 +1,9 @@
+---
+title: createRelated
+description: Create related records in other services.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['create']
+ multi: true
+---
diff --git a/src/hooks/create-related/create-related.test.ts b/src/hooks/create-related/create-related.test.ts
new file mode 100644
index 00000000..94641c34
--- /dev/null
+++ b/src/hooks/create-related/create-related.test.ts
@@ -0,0 +1,247 @@
+import assert from 'node:assert'
+import { feathers } from '@feathersjs/feathers'
+import { MemoryService } from '@feathersjs/memory'
+import { createRelated } from './create-related.js'
+
+type MockAppOptions = {
+ multi?: boolean
+}
+
+const defaultOptions = {
+ multi: true,
+}
+
+const mockApp = (_options?: MockAppOptions) => {
+ const options = Object.assign({}, defaultOptions, _options)
+ const app = feathers()
+
+ app.use('users', new MemoryService({ startId: 1, multi: true }))
+ app.use('todos', new MemoryService({ startId: 1, multi: options.multi }))
+
+ const usersService = app.service('users')
+ const todosService = app.service('todos')
+
+ return {
+ app,
+ todosService,
+ usersService,
+ }
+}
+
+describe('hook - createRelated', function () {
+ it('creates single item for single item', async function () {
+ const { app, todosService } = mockApp()
+
+ app.service('users').hooks({
+ after: {
+ create: [
+ createRelated({
+ service: 'todos',
+ data: (item, context) => ({
+ title: 'First issue',
+ userId: item.id,
+ }),
+ }),
+ ],
+ },
+ })
+
+ const user = await app.service('users').create({
+ name: 'John Doe',
+ })
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [{ id: 1, title: 'First issue', userId: 1 }])
+ })
+
+ it('can use context in data function', async function () {
+ const { app, todosService } = mockApp()
+
+ app.service('users').hooks({
+ after: {
+ create: [
+ createRelated({
+ service: 'todos',
+ data: (item, context) => ({
+ title: context.path,
+ userId: item.id,
+ }),
+ }),
+ ],
+ },
+ })
+
+ const user = await app.service('users').create({
+ name: 'John Doe',
+ })
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [{ id: 1, title: 'users', userId: 1 }])
+ })
+
+ it('creates multiple items for multiple items', async function () {
+ const { app, todosService } = mockApp()
+
+ app.service('users').hooks({
+ after: {
+ create: [
+ createRelated({
+ service: 'todos',
+ data: (item, context) => ({
+ title: item.name,
+ userId: item.id,
+ }),
+ }),
+ ],
+ },
+ })
+
+ const users = await app
+ .service('users')
+ .create([{ name: 'user1' }, { name: 'user2' }, { name: 'user3' }])
+
+ const todos = await todosService.find({ query: { $sort: { userId: 1 } } })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 'user1', userId: 1 },
+ { id: 2, title: 'user2', userId: 2 },
+ { id: 3, title: 'user3', userId: 3 },
+ ])
+ })
+
+ it('creates multple items for multiple items with multi: false', async function () {
+ const { app, todosService } = mockApp({ multi: false })
+
+ app.service('users').hooks({
+ after: {
+ create: [
+ createRelated({
+ service: 'todos',
+ data: (item, context) => ({
+ title: item.name,
+ userId: item.id,
+ }),
+ multi: false,
+ }),
+ ],
+ },
+ })
+
+ // @ts-expect-error - does not have options
+ assert.strictEqual(todosService.options.multi, false)
+
+ const users = await app
+ .service('users')
+ .create([{ name: 'user1' }, { name: 'user2' }, { name: 'user3' }])
+
+ const todos = await todosService.find({ query: { $sort: { userId: 1 } } })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 'user1', userId: 1 },
+ { id: 2, title: 'user2', userId: 2 },
+ { id: 3, title: 'user3', userId: 3 },
+ ])
+ })
+
+ it('can create multiple data for one record', async function () {
+ const { app, todosService } = mockApp()
+
+ app.service('users').hooks({
+ after: {
+ create: [
+ createRelated({
+ service: 'todos',
+ data: (item, context) => [
+ {
+ title: 1,
+ userId: item.id,
+ },
+ {
+ title: 2,
+ userId: item.id,
+ },
+ ],
+ }),
+ ],
+ },
+ })
+
+ const user = await app.service('users').create({
+ name: 'John Doe',
+ })
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 1, userId: 1 },
+ { id: 2, title: 2, userId: 1 },
+ ])
+ })
+
+ it('can pass an array', async function () {
+ const { app, todosService } = mockApp()
+
+ app.service('users').hooks({
+ after: {
+ create: [
+ createRelated([
+ {
+ service: 'todos',
+ data: (item, context) => [
+ {
+ title: 1,
+ userId: item.id,
+ },
+ ],
+ },
+ {
+ service: 'todos',
+ data: (item, context) => [
+ {
+ title: 2,
+ userId: item.id,
+ },
+ ],
+ },
+ ]),
+ ],
+ },
+ })
+
+ const user = await app.service('users').create({
+ name: 'John Doe',
+ })
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 1, userId: 1 },
+ { id: 2, title: 2, userId: 1 },
+ ])
+ })
+
+ it('does not create items if falsey', async function () {
+ const { app, todosService } = mockApp()
+
+ app.service('users').hooks({
+ after: {
+ create: [
+ createRelated({
+ service: 'todos',
+ data: (item, context) => null as any,
+ }),
+ ],
+ },
+ })
+
+ const user = await app.service('users').create({
+ name: 'John Doe',
+ })
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [])
+ })
+})
diff --git a/src/hooks/create-related/create-related.ts b/src/hooks/create-related/create-related.ts
new file mode 100644
index 00000000..6598780e
--- /dev/null
+++ b/src/hooks/create-related/create-related.ts
@@ -0,0 +1,54 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { checkContext, getResultIsArray } from '../../utils/index.js'
+import type { MaybeArray, Promisable } from '../../internal.utils.js'
+
+export interface CreateRelatedOptions> {
+ service: keyof S
+ multi?: boolean
+ data: (item: any, context: HookContext) => Promisable>
+}
+
+/**
+ * hook to create related items
+ */
+export function createRelated, H extends HookContext = HookContext>(
+ options: MaybeArray>,
+) {
+ return async (context: H, next?: NextFunction) => {
+ checkContext(context, ['after', 'around'], ['create'], 'createRelated')
+
+ if (next) {
+ await next()
+ }
+
+ const { result } = getResultIsArray(context)
+
+ const entries = Array.isArray(options) ? options : [options]
+
+ await Promise.all(
+ entries.map(async entry => {
+ const { data, service, multi } = entry
+
+ const dataToCreate = (
+ await Promise.all(result.map(async item => data(item, context)))
+ ).filter(x => !!x)
+
+ if (!dataToCreate || dataToCreate.length <= 0) {
+ return context
+ }
+
+ if (multi || dataToCreate.length === 1) {
+ await context.app
+ .service(service as string)
+ .create(dataToCreate.length === 1 ? dataToCreate[0] : dataToCreate)
+ } else {
+ await Promise.all(
+ dataToCreate.map(async item => context.app.service(service as string).create(item)),
+ )
+ }
+ }),
+ )
+
+ return context
+ }
+}
diff --git a/src/hooks/de-populate.ts b/src/hooks/de-populate.ts
deleted file mode 100755
index 2a57d308..00000000
--- a/src/hooks/de-populate.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-import _omit from 'lodash/omit.js';
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-
-/**
- * Remove records and properties created by the populate hook.
- * @see https://hooks-common.feathersjs.com/hooks.html#depopulate
- */
-export function dePopulate(func?: (item: any) => void) {
- return (context: H) => {
- const items = getItems(context);
- const converter = (item: any) => {
- if (typeof func === 'function') {
- func(item);
- }
-
- const keys = ['_elapsed', '_computed', '_include'];
- const { _computed = [], _include = [] } = item;
-
- return _omit(item, keys.concat(_computed).concat(_include));
- };
- const converted = Array.isArray(items) ? items.map(converter) : converter(items);
-
- replaceItems(context, converted);
-
- return context;
- };
-}
diff --git a/src/hooks/debug/debug.md b/src/hooks/debug/debug.md
new file mode 100644
index 00000000..fbd53d2d
--- /dev/null
+++ b/src/hooks/debug/debug.md
@@ -0,0 +1,49 @@
+---
+title: debug
+description: Display the current hook context for debugging.
+category: hooks
+hook:
+ type: ['before', 'after']
+ method: ['all']
+ multi: true
+---
+
+## Arguments
+
+- `{String} label`
+- `{Array < String >} [ fieldNames ]`
+
+| Argument | Type | Default | Description |
+| ------------ | :----------: | ------- | ------------------------------------------------ |
+| `label` | `String` | | Label to identify the logged information. |
+| `fieldNames` | dot notation | | The field values in `context.params` to display. |
+
+## Example
+
+```js
+const { debug } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: {
+ all: [ debug('step 1'), setNow('updatedAt'), debug(' step 2') ],
+} };
+
+// Result
+* step 1
+type: before, method: create
+data: { name: 'Joe Doe' }
+query: { sex: 'm' }
+result: { assigned: true }
+params props: [ 'query' ]
+* step 2
+type: before, method: create
+data: { name: 'Joe Doe', createdAt: 1510518511547 }
+query: { sex: 'm' }
+result: { assigned: true }
+params props: [ 'query' ]
+params.query: { sex: 'm' }
+error: ...
+```
+
+## Details
+
+`debug` is great for debugging issues with hooks. Log the hook context before and after a hook to see what the hook started with, and what it changed.
diff --git a/test/hooks/debug.test.ts b/src/hooks/debug/debug.test.ts
similarity index 75%
rename from test/hooks/debug.test.ts
rename to src/hooks/debug/debug.test.ts
index d4ec03f1..7b1ca49f 100755
--- a/test/hooks/debug.test.ts
+++ b/src/hooks/debug/debug.test.ts
@@ -1,4 +1,4 @@
-import { debug } from '../../src';
+import { debug } from './debug.js'
describe('services debug', () => {
it('does not crash', () => {
@@ -8,9 +8,9 @@ describe('services debug', () => {
data: { a: 'a' },
params: { query: { b: 'b' } },
result: { c: 'c' },
- };
- debug('my message')(hook);
- });
+ }
+ debug('my message')(hook)
+ })
it('display params props', () => {
const hook: any = {
@@ -19,7 +19,7 @@ describe('services debug', () => {
data: { a: 'a' },
params: { query: { b: 'b' }, foo: 'bar' },
result: { c: 'c' },
- };
- debug('my message', 'query', 'foo')(hook);
- });
-});
+ }
+ debug('my message', 'query', 'foo')(hook)
+ })
+})
diff --git a/src/hooks/debug.ts b/src/hooks/debug/debug.ts
similarity index 52%
rename from src/hooks/debug.ts
rename to src/hooks/debug/debug.ts
index 6d54e0d9..5e9a79fe 100755
--- a/src/hooks/debug.ts
+++ b/src/hooks/debug/debug.ts
@@ -1,55 +1,57 @@
-/* eslint-disable no-console */
-import type { HookContext } from '@feathersjs/feathers';
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
/**
* Display the current hook context for debugging.
* @see https://hooks-common.feathersjs.com/hooks.html#debug
*/
-export function debug(msg: string, ...fieldNames: string[]) {
- return (context: H) => {
+export const debug =
+ (msg: string, ...fieldNames: string[]) =>
+ async (context: H, next?: NextFunction) => {
+ if (next) {
+ await next()
+ }
+
// display timestamp
- const now = new Date();
+ const now = new Date()
console.log(
`${now.getFullYear()}-${
now.getMonth() + 1
}-${now.getDate()} ${now.getHours()}:${now.getMinutes()}:${now.getSeconds()}`,
- );
+ )
if (msg) {
- console.log(msg);
+ console.log(msg)
}
// display service, method & type of hook (before/after/error)
- console.log(`${context.type} service('${context.path}').${context.method}()`);
+ console.log(`${context.type} service('${context.path}').${context.method}()`)
// display id for get, patch, update & remove
if (!['find', 'create'].includes(context.method) && 'id' in context) {
- console.log('id:', context.id);
+ console.log('id:', context.id)
}
if (context.data) {
- console.log('data:', context.data);
+ console.log('data:', context.data)
}
if (context.params?.query) {
- console.log('query:', context.params.query);
+ console.log('query:', context.params.query)
}
if (context.result) {
- console.log('result:', context.result);
+ console.log('result:', context.result)
}
// display additional params
- const params = context.params || {};
- console.log('params props:', Object.keys(params).sort());
+ const params = context.params || {}
+ console.log('params props:', Object.keys(params).sort())
fieldNames.forEach(name => {
- // @ts-ignore
- console.log(`params.${name}:`, params[name]);
- });
+ console.log(`params.${name}:`, params[name])
+ })
if (context.error) {
- console.log('error', context.error);
+ console.log('error', context.error)
}
- };
-}
+ }
diff --git a/src/hooks/disable-pagination.ts b/src/hooks/disable-pagination.ts
deleted file mode 100755
index 83d5d23c..00000000
--- a/src/hooks/disable-pagination.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-import { checkContext } from '../utils/check-context';
-
-/**
- * Disables pagination when query.$limit is -1 or '-1'.
- * @see https://hooks-common.feathersjs.com/hooks.html#disablepagination
- */
-export function disablePagination() {
- return (context: H) => {
- checkContext(context, 'before', ['find'], 'disablePagination');
- const $limit = (context.params.query || {}).$limit;
-
- if ($limit === '-1' || $limit === -1) {
- // @ts-ignore
- context.params.paginate = false;
- delete context.params.query.$limit;
- }
-
- return context;
- };
-}
diff --git a/src/hooks/disable-pagination/disable-pagination.md b/src/hooks/disable-pagination/disable-pagination.md
new file mode 100644
index 00000000..c7653a54
--- /dev/null
+++ b/src/hooks/disable-pagination/disable-pagination.md
@@ -0,0 +1,21 @@
+---
+title: disablePagination
+description: Disable pagination when query.$limit is -1 or '-1'.
+category: hooks
+hook:
+ type: ['before']
+ method: ['find']
+ multi: true
+---
+
+## Example
+
+```js
+const { disablePagination } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: { find: disablePagination() } };
+```
+
+## Details
+
+Pagination is disabled if `context.query.$limit` is -1 or '-1'. It works for all types of calls including REST.
diff --git a/test/hooks/disable-pagination.test.ts b/src/hooks/disable-pagination/disable-pagination.test.ts
similarity index 50%
rename from test/hooks/disable-pagination.test.ts
rename to src/hooks/disable-pagination/disable-pagination.test.ts
index 9ff8fe9c..d8ba22ae 100755
--- a/test/hooks/disable-pagination.test.ts
+++ b/src/hooks/disable-pagination/disable-pagination.test.ts
@@ -1,7 +1,7 @@
-import { assert } from 'vitest';
-import { disablePagination } from '../../src';
+import { assert } from 'vitest'
+import { disablePagination } from './disable-pagination.js'
-let hookBefore: any;
+let hookBefore: any
describe('services disablePagination', () => {
beforeEach(() => {
@@ -9,36 +9,36 @@ describe('services disablePagination', () => {
type: 'before',
method: 'find',
params: { query: { id: 1, $limit: -1 } },
- };
- });
+ }
+ })
it('disables on $limit = -1', () => {
- hookBefore.params.query.$limit = -1;
+ hookBefore.params.query.$limit = -1
- const result: any = disablePagination()(hookBefore);
- assert.deepEqual(result.params, { paginate: false, query: { id: 1 } });
- });
+ const result: any = disablePagination()(hookBefore)
+ assert.deepEqual(result.params, { paginate: false, query: { id: 1 } })
+ })
it('disables on $limit = "-1"', () => {
- hookBefore.params.query.$limit = '-1';
+ hookBefore.params.query.$limit = '-1'
- const result: any = disablePagination()(hookBefore);
- assert.deepEqual(result.params, { paginate: false, query: { id: 1 } });
- });
+ const result: any = disablePagination()(hookBefore)
+ assert.deepEqual(result.params, { paginate: false, query: { id: 1 } })
+ })
it('throws if after hook', () => {
- hookBefore.type = 'after';
+ hookBefore.type = 'after'
assert.throws(() => {
- disablePagination()(hookBefore);
- });
- });
+ disablePagination()(hookBefore)
+ })
+ })
it('throws if not find', () => {
- hookBefore.method = 'get';
+ hookBefore.method = 'get'
assert.throws(() => {
- disablePagination()(hookBefore);
- });
- });
-});
+ disablePagination()(hookBefore)
+ })
+ })
+})
diff --git a/src/hooks/disable-pagination/disable-pagination.ts b/src/hooks/disable-pagination/disable-pagination.ts
new file mode 100755
index 00000000..2b6ac88a
--- /dev/null
+++ b/src/hooks/disable-pagination/disable-pagination.ts
@@ -0,0 +1,22 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { checkContext } from '../../utils/index.js'
+
+/**
+ * Disables pagination when query.$limit is -1 or '-1'.
+ * @see https://hooks-common.feathersjs.com/hooks.html#disablepagination
+ */
+export const disablePagination =
+ () =>
+ (context: H, next?: NextFunction) => {
+ checkContext(context, 'before', ['find'], 'disablePagination')
+ const $limit = context.params?.query?.$limit
+
+ if ($limit === '-1' || $limit === -1) {
+ context.params.paginate = false
+ delete context.params.query.$limit
+ }
+
+ if (next) return next().then(() => context)
+
+ return context
+ }
diff --git a/src/hooks/disallow.ts b/src/hooks/disallow.ts
deleted file mode 100755
index c46d6e2e..00000000
--- a/src/hooks/disallow.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { MethodNotAllowed } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-import type { TransportName } from '../types';
-
-/**
- * Prevents access to a service method completely or for specific transports.
- * @see https://hooks-common.feathersjs.com/hooks.html#disallow
- */
-export function disallow(...transports: TransportName[]) {
- return (context: H) => {
- const hookProvider = context.params?.provider;
-
- const anyProvider = transports.length === 0;
- const thisProvider = transports.some(
- provider =>
- provider === hookProvider ||
- (provider === 'server' && !hookProvider) ||
- (provider === 'external' && !!hookProvider),
- );
-
- if (anyProvider || thisProvider) {
- throw new MethodNotAllowed(
- `Provider '${context.params.provider}' can not call '${context.method}'. (disallow)`,
- );
- }
- };
-}
diff --git a/src/hooks/disallow/disallow.md b/src/hooks/disallow/disallow.md
new file mode 100644
index 00000000..b0bcc6ad
--- /dev/null
+++ b/src/hooks/disallow/disallow.md
@@ -0,0 +1,48 @@
+---
+title: disallow
+description: Prevents access to a service method completely or for specific transports.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['all']
+ multi: true
+ methods: ['all']
+---
+
+## Arguments
+
+- `{Array< String >} transports`
+
+| Argument | Type | Default | Description |
+| ------------ | :---------------: | ----------------------- | ----------------------------------------- |
+| `transports` | `Array< String >` | disallow all transports | The transports that you want to disallow. |
+
+| `transports` | Value | Description |
+| ------------ | ------------------------------------- | ----------- |
+| `socketio` | disallow calls by Socket.IO transport |
+| `rest` | disallow calls by REST transport |
+| `external` | disallow calls other than from server |
+| `server` | disallow calls from server |
+
+## Example
+
+```js
+const { disallow, iff } = require('feathers-hooks-common/index.js');
+
+module.exports = {
+ before: {
+ // Users can not be created by external access
+ create: disallow('external'),
+ // A user can not be deleted through the REST provider
+ remove: disallow('rest'),
+ // disallow calling `update` completely (e.g. to allow only `patch`)
+ update: disallow(),
+ // disallow the remove hook if the user is not an admin
+ remove: iff(context => !context.params.user.isAdmin, disallow()),
+ },
+};
+```
+
+## Details
+
+Prevents access to a service method completely or just for specific transports. All transports set the `context.params.provider` property, and `disallow` checks this.
diff --git a/src/hooks/disallow/disallow.test.ts b/src/hooks/disallow/disallow.test.ts
new file mode 100755
index 00000000..7a226ed2
--- /dev/null
+++ b/src/hooks/disallow/disallow.test.ts
@@ -0,0 +1,151 @@
+import { assert } from 'vitest'
+import { disallow } from './disallow.js'
+
+describe('services disallow', () => {
+ describe('disallow is compatible with .disable (without predicate)', () => {
+ let hookRest: any
+ let hookSocketio: any
+ let hookServer: any
+
+ beforeEach(() => {
+ hookRest = { method: 'create', params: { provider: 'rest' } }
+ hookSocketio = { method: 'create', params: { provider: 'socketio' } }
+ hookServer = { method: 'create', params: { provider: '' } }
+ })
+
+ it('disables all providers with no param', () => {
+ assert.throws(() => {
+ disallow()(hookSocketio)
+ })
+ assert.throws(() => {
+ disallow()(hookServer)
+ })
+ })
+
+ it('disables a provider', () => {
+ assert.throws(() => {
+ disallow('socketio')(hookSocketio)
+ })
+ })
+
+ it('does not disable the server', () => {
+ disallow('socketio')(hookServer)
+ assert.throws(() => {
+ disallow('socketio')(hookSocketio)
+ })
+ })
+
+ it('does not disable another provider', () => {
+ disallow('socketio')(hookRest)
+ assert.throws(() => {
+ disallow('socketio')(hookSocketio)
+ })
+ })
+
+ it('disables multiple providers', () => {
+ disallow(['socketio', 'rest'])(hookServer)
+ assert.throws(() => {
+ disallow(['socketio', 'rest'])(hookSocketio)
+ })
+ assert.throws(() => {
+ disallow(['socketio', 'rest'])(hookRest)
+ })
+ })
+
+ it('"external" disables all external providers', () => {
+ disallow(['socketio', 'rest'])(hookServer)
+ assert.throws(() => {
+ disallow(['socketio', 'rest'])(hookSocketio)
+ })
+ assert.throws(() => {
+ disallow(['socketio', 'rest'])(hookRest)
+ })
+ })
+ })
+
+ describe('disallow functionality is like isProvider', () => {
+ let hookServer: any
+ let hookSocketio: any
+ let hook: any
+
+ beforeEach(() => {
+ hookServer = { type: 'before', method: 'create', params: { provider: '' } }
+ hookSocketio = { type: 'before', method: 'create', params: { provider: 'socketio' } }
+ })
+
+ it('returns a function', () => {
+ const fcn = disallow('server')
+
+ assert.isFunction(fcn)
+ })
+
+ it('throws on no args', () => {
+ assert.throws(() => disallow()(hook))
+ })
+
+ it('finds provider with 1 arg', () => {
+ const hook = structuredClone(hookSocketio)
+
+ const result = disallow('rest')(hook)
+ assert.equal(result, undefined)
+
+ assert.throws(() => {
+ disallow('socketio')(hook)
+ })
+ })
+
+ it('finds provider with 2 args', () => {
+ const hook = structuredClone(hookSocketio)
+
+ const result = disallow(['rest', 'server'])(hook)
+ assert.equal(result, undefined)
+
+ assert.throws(() => {
+ disallow(['rest', 'socketio'])(hook)
+ })
+ })
+
+ it('finds server', () => {
+ const hook = structuredClone(hookServer)
+
+ const result = disallow(['rest', 'socketio', 'external'])(hook)
+ assert.equal(result, undefined)
+
+ assert.throws(() => {
+ disallow(['rest', 'socketio', 'server'])(hook)
+ })
+ })
+
+ it('finds external', () => {
+ const hook = structuredClone(hookSocketio)
+
+ const result = disallow(['rest', 'server'])(hook)
+ assert.equal(result, undefined)
+
+ assert.throws(() => {
+ disallow(['rest', 'server', 'external'])(hook)
+ })
+ })
+
+ it('succeeds if not provider', () => {
+ const hook = structuredClone(hookServer)
+
+ const result = disallow('socketio')(hook)
+ assert.equal(result, undefined)
+ })
+
+ it('succeeds if not external', () => {
+ const hook = structuredClone(hookServer)
+
+ const result = disallow('external')(hook)
+ assert.equal(result, undefined)
+ })
+
+ it('succeeds if not server', () => {
+ const hook = structuredClone(hookSocketio)
+
+ const result = disallow('server')(hook)
+ assert.equal(result, undefined)
+ })
+ })
+})
diff --git a/src/hooks/disallow/disallow.ts b/src/hooks/disallow/disallow.ts
new file mode 100755
index 00000000..bc353a1e
--- /dev/null
+++ b/src/hooks/disallow/disallow.ts
@@ -0,0 +1,29 @@
+import { MethodNotAllowed } from '@feathersjs/errors'
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import type { TransportName } from '../../types.js'
+import { isProvider } from '../../predicates/index.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+/**
+ * Prevents access to a service method completely or for specific transports.
+ * @see https://hooks-common.feathersjs.com/hooks.html#disallow
+ */
+export const disallow = (
+ transports?: MaybeArray,
+) => {
+ const transportsArr = toArray(transports)
+ return (context: H, next?: NextFunction) => {
+ if (!transports) {
+ throw new MethodNotAllowed('Method not allowed')
+ }
+
+ if (isProvider(...(transportsArr as TransportName[]))(context)) {
+ throw new MethodNotAllowed(
+ `Provider '${context.params.provider}' can not call '${context.method}'. (disallow)`,
+ )
+ }
+
+ if (next) return next().then(() => context)
+ }
+}
diff --git a/src/hooks/discard-query.ts b/src/hooks/discard-query.ts
deleted file mode 100755
index e298680d..00000000
--- a/src/hooks/discard-query.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-import _omit from 'lodash/omit.js';
-import { checkContext } from '../utils/check-context';
-
-/**
- * Delete certain fields from the query object.
- * @see https://hooks-common.feathersjs.com/hooks.html#discardquery
- */
-export function discardQuery(...fieldNames: string[]) {
- return (context: H) => {
- checkContext(context, 'before', null, 'discardQuery');
-
- const query = context.params.query || {};
-
- context.params.query = _omit(query, fieldNames);
-
- return context;
- };
-}
diff --git a/src/hooks/discard.ts b/src/hooks/discard.ts
deleted file mode 100755
index 5ad1c888..00000000
--- a/src/hooks/discard.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import _omit from 'lodash/omit.js';
-import { checkContextIf } from '../utils/check-context-if';
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Delete certain fields from the record(s).
- * @see https://hooks-common.feathersjs.com/hooks.html#discard
- */
-export function discard(...fieldNames: string[]) {
- return (context: H) => {
- checkContextIf(context, 'before', ['create', 'update', 'patch'], 'discard');
-
- const items = getItems(context);
- const convert = (item: any) => _omit(item, fieldNames);
- const converted = Array.isArray(items) ? items.map(convert) : convert(items);
-
- replaceItems(context, converted);
-
- return context;
- };
-}
diff --git a/src/hooks/fast-join.ts b/src/hooks/fast-join.ts
deleted file mode 100755
index 3dd46c50..00000000
--- a/src/hooks/fast-join.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-import type { Application, HookContext, Query, Service } from '@feathersjs/feathers';
-import type { SyncContextFunction } from '../types';
-
-export interface ResolverContext
- extends HookContext {
- _loaders: any;
-}
-
-export type SimpleResolver = (
- ...args: any[]
-) => (item: any, context: H) => Promise;
-
-export interface RecursiveResolver {
- resolver: SimpleResolver;
- joins: ResolverMap;
-}
-
-export interface ResolverMap {
- after?: (context: H) => void | Promise;
- before?: (context: H) => void | Promise;
- joins: {
- [property: string]: SimpleResolver | RecursiveResolver;
- };
-}
-
-/**
- * We often want to combine rows from two or more tables based on a relationship between them. The fastJoin hook
- * will select records that have matching values in both tables. It can batch service calls and cache records,
- * thereby needing roughly an order of magnitude fewer database calls than the populate hook, i.e. 2 calls instead
- * of 20. It uses a GraphQL-like imperative API.
- *
- * fastJoin is not restricted to using data from Feathers services. Resources for which there are no Feathers
- * adapters can also be used.
- *
- *
- * fastJoin(postResolvers)
- * fastJoin(postResolvers, query)
- * fastJoin(context => postResolvers)
- * fastJoin(postResolvers, context => query) // supports queries from client
- * @see https://hooks-common.feathersjs.com/hooks.html#fastjoin
- */
-export function fastJoin(
- resolvers: ResolverMap | SyncContextFunction, H>,
- query?: Query | SyncContextFunction,
-) {
- return (context: H) => {
- const { method, data, result, params } = context;
-
- // @ts-ignore
- if (params._populate || params._graphql) return context; // our service called within another populate
-
- const q = typeof query === 'function' ? query(context) : query;
- const joins2 = typeof resolvers === 'function' ? resolvers(context) : resolvers;
- const { before, joins, after } = joins2;
-
- const temp = result || (Array.isArray(data) ? data : [data]);
- const results = method === 'find' ? result.data || temp : temp;
-
- const prevLoaders = context._loaders;
- context._loaders = {};
-
- return (
- Promise.resolve()
- // @ts-ignore
- .then(() => before && before(context))
- .then(
- () => joins && results && recursive(joinsForQuery(joins2, q, context), results, context),
- )
- // @ts-ignore
- .then(() => after && after(context))
- .then(() => {
- context._loaders = prevLoaders;
- return context;
- })
- );
- };
-}
-
-function joinsForQuery({ joins }: any = {}, query: any = undefined, context = {}) {
- const runtime: any = [];
-
- Object.keys(joins).forEach(outerLabel => {
- if (query && !query[outerLabel]) return;
-
- let join = joins[outerLabel];
- if (typeof join === 'function') {
- join = { resolver: join };
- }
-
- const { resolver } = join;
- let { joins: innerJoins } = join;
- if (innerJoins && !innerJoins.resolver && innerJoins.joins) {
- // support embedded resolvers for other services
- innerJoins = innerJoins.joins;
- }
-
- let args: any = query ? query[outerLabel] : [];
- if (!Array.isArray(args)) {
- args = typeof args === 'object' && args !== null ? args.args : [];
- }
-
- runtime.push({
- args,
- resolver,
- joins: innerJoins
- ? joinsForQuery({ joins: innerJoins }, query ? query[outerLabel] : null, context)
- : null,
- });
- });
-
- return runtime;
-}
-
-function recursive(joins: any, results: any, context: any) {
- return Promise.all(
- (Array.isArray(results) ? results : [results]).map(result =>
- Promise.all(
- joins.map(({ args = [], resolver, joins }: any) => {
- return Promise.resolve(resolver(...args)(result, context)).then(addedResults => {
- if (!addedResults || !joins) return context;
-
- return recursive(joins, addedResults, context);
- });
- }),
- ),
- ),
- );
-}
diff --git a/src/hooks/fgraphql.ts b/src/hooks/fgraphql.ts
deleted file mode 100755
index c68d8135..00000000
--- a/src/hooks/fgraphql.ts
+++ /dev/null
@@ -1,461 +0,0 @@
-import type { Application, HookContext, Query } from '@feathersjs/feathers';
-import makeDebug from 'debug';
-import type { parse, GraphQLFieldResolver } from 'graphql';
-import type { SyncContextFunction } from '../types';
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-
-export type FGraphQLResolverMapFactory = (app: Application, runtime: any) => FGraphQLResolverMap;
-
-export interface FGraphQLResolverMap {
- [i: string]: {
- [i: string]: GraphQLFieldResolver;
- };
- Query: {
- [i: string]: GraphQLFieldResolver;
- };
-}
-
-export interface FGraphQLOptions {
- skipHookWhen?: SyncContextFunction;
- inclAllFieldsServer?: boolean;
- inclAllFieldsClient?: boolean;
- inclAllFields?: boolean;
- inclJoinedNames?: boolean;
- extraAuthProps?: string[];
-}
-
-export interface FGraphQLHookOptions {
- recordType: string;
- schema: string;
- resolvers: FGraphQLResolverMap | FGraphQLResolverMapFactory;
- query: Query | SyncContextFunction;
- options?: FGraphQLOptions;
- runTime: any;
- parse: typeof parse;
-}
-
-const debug = makeDebug('fgraphql');
-const graphqlActions = ['Query', 'Mutation', 'Subscription'];
-
-/**
- * Generate Graphql Resolvers for services
- * @see https://medium.com/@eddyystop/38faee75dd1
- */
-export function fgraphql(options1: FGraphQLHookOptions) {
- debug('init call');
- const { parse, recordType, resolvers, runTime, query } = options1;
- let { schema } = options1;
-
- let ourResolvers: any; // will be initialized when hook is first called
-
- const options = {
- skipHookWhen: (context: any) => !!(context.params || {}).graphql,
- inclAllFieldsServer: true,
- inclAllFieldsClient: true,
- inclAllFields: null, // Will be initialized each hook call.
- inclJoinedNames: true,
- extraAuthProps: [],
- ...(options1.options || {}),
- };
-
- // @ts-ignore
- schema = isFunction(schema) ? schema() : schema;
-
- if (!isObject(schema) && !isString(schema)) {
- throwError(
- `Resolved schema is typeof ${typeof schema} rather than string or object. (fgraphql)`,
- 101,
- );
- }
-
- if (!isObject(runTime)) {
- throwError(`option runTime is typeof ${typeof runTime} rather than an object. (fgraphql)`, 106);
- }
-
- if (!isString(recordType)) {
- throwError(`recordType is typeof ${typeof recordType} rather than string. (fgraphql)`, 103);
- }
-
- // @ts-ignore
- if (!isArray(options.extraAuthProps)) {
- // @ts-ignore
- throwError(
- `option extraAuthProps is typeof ${typeof options.extraAuthProps} rather than array. (fgraphql)`,
- 105,
- );
- }
-
- const feathersSdl = isObject(schema) ? schema : convertSdlToFeathersSchemaObject(schema, parse);
- debug('schema now in internal form');
-
- // Return the hook.
- return (context: H) => {
- const contextParams = context.params;
- // @ts-ignore
- const optSkipHookWhen = options.skipHookWhen;
- const skipHookWhen = isFunction(optSkipHookWhen) ? optSkipHookWhen(context) : optSkipHookWhen;
- debug(
- `\n.....hook called. type ${context.type} method ${context.method} resolved skipHookWhen ${skipHookWhen}`,
- );
-
- if (context.params.$populate) return context; // populate or fastJoin are running
- if (skipHookWhen) return context;
-
- // @ts-ignore
- const q = isFunction(query) ? query(context) : query;
-
- if (!isObject(q)) {
- throwError(`Resolved query is typeof ${typeof q} rather than object. (fgraphql)`, 102);
- }
-
- if (!ourResolvers) {
- // @ts-ignore
- ourResolvers = resolvers(context.app, runTime);
- debug(`ourResolvers has Types ${Object.keys(ourResolvers)}`);
- }
-
- if (!ourResolvers[recordType]) {
- throwError(`recordType ${recordType} not found in resolvers. (fgraphql)`, 104);
- }
-
- // @ts-ignore
- options.inclAllFields = contextParams.provider
- ? // @ts-ignore
- options.inclAllFieldsClient
- : // @ts-ignore
- options.inclAllFieldsServer;
- // @ts-ignore
- debug(`inclAllField ${options.inclAllFields}`);
-
- // Build content parameter passed to resolver functions.
- const resolverContent: Record = {
- app: context.app,
- provider: contextParams.provider,
- user: contextParams.user,
- authenticated: contextParams.authenticated,
- batchLoaders: {},
- cache: {},
- };
-
- // @ts-ignore
- (options.extraAuthProps || []).forEach((name: any) => {
- if (name in contextParams && !(name in resolverContent)) {
- resolverContent[name] = contextParams[name];
- }
- });
-
- // Static values used by fgraphql functions.
- const store = {
- feathersSdl,
- ourResolvers,
- options,
- resolverContent,
- };
-
- // Populate data.
- const recs = getItems(context);
-
- // @ts-ignore
- return processRecords(store, q, recs, recordType).then(() => {
- replaceItems(context, recs);
- return context;
- });
- };
-}
-
-// Process records recursively.
-function processRecords(store: any, query: any, recs: any, type: any, depth = 0): any {
- if (!recs) return; // Catch no data to populate.
-
- recs = isArray(recs) ? recs : [recs];
- debug(`\nvvvvvvvvvv enter ${depth}`);
- debug(`processRecords depth ${depth} #recs ${recs.length} Type ${type}`);
-
- const storeOurResolversType = store.ourResolvers[type];
- if (!isObject(storeOurResolversType)) {
- throwError(
- `Resolvers for Type ${type} are typeof ${typeof storeOurResolversType} not object. (fgraphql)`,
- 201,
- );
- }
-
- if (!isObject(query)) {
- throwError(`query at Type ${type} are typeof ${typeof query} not object. (fgraphql)`, 202);
- }
-
- return Promise.all(
- recs.map((rec: any, j: any) => processRecord(store, query, depth, rec, type, j)),
- ).then(() => {
- debug(`^^^^^^^^^^ exit ${depth}\n`);
- });
-}
-
-// Process the a record.
-function processRecord(store: any, query: any, depth: any, rec: any, type: any, j: any): any {
- debug(`processRecord rec# ${j} typeof ${typeof rec} Type ${type}`);
- if (!rec) return; // Catch any null values from resolvers.
-
- const queryPropNames = Object.keys(query);
- const recFieldNamesInQuery: any = [];
- const joinedNamesInQuery: any = [];
-
- // Process every query item.
- return Promise.all(
- queryPropNames.map((fieldName, i) =>
- processRecordQuery(
- store,
- query,
- depth,
- rec,
- fieldName,
- type,
- recFieldNamesInQuery,
- joinedNamesInQuery,
- j,
- i,
- ),
- ),
- ).then(() => {
- // Retain only record fields selected
- debug(`field names found ${recFieldNamesInQuery} joined names ${joinedNamesInQuery}`);
- if (
- recFieldNamesInQuery.length ||
- !store.options.inclAllFields ||
- queryPropNames.includes('_none')
- ) {
- // recs[0] may have been created by [rec] so can't replace array elem
- Object.keys(rec).forEach(key => {
- if (!recFieldNamesInQuery.includes(key) && !joinedNamesInQuery.includes(key)) {
- delete rec[key];
- }
- });
- }
-
- // Include joined names in record.
- if (store.options.inclJoinedNames && joinedNamesInQuery.length) {
- rec._include = joinedNamesInQuery;
- }
- });
-}
-
-// Process one query field for a record.
-function processRecordQuery(
- store: any,
- query: any,
- depth: any,
- rec: any,
- fieldName: any,
- type: any,
- recFieldNamesInQuery: any,
- joinedNamesInQuery: any,
- j: any,
- i: any,
-): any {
- debug(`\nprocessRecordQuery rec# ${j} Type ${type} field# ${i} name ${fieldName}`);
-
- // One way to include/exclude rec fields is to give their names a falsey value.
- // _args and _none are not record field names but special purpose
- if (query[fieldName] && fieldName !== '_args' && fieldName !== '_none') {
- if (store.ourResolvers[type][fieldName]) {
- joinedNamesInQuery.push(fieldName);
- return processRecordFieldResolver(store, query, depth, rec, fieldName, type);
- } else {
- debug('is not resolver call');
- recFieldNamesInQuery.push(fieldName);
- }
- }
-}
-
-// Process a resolver call.
-function processRecordFieldResolver(
- store: any,
- query: any,
- depth: any,
- rec: any,
- fieldName: any,
- type: any,
-) {
- debug('is resolver call');
- const ourQuery = store.feathersSdl[type][fieldName];
- const ourResolver = store.ourResolvers[type][fieldName];
-
- if (!isFunction(ourResolver)) {
- throwError(
- `Resolver for Type ${type} fieldName ${fieldName} is typeof ${typeof ourResolver} not function. (fgraphql)`,
- 203,
- );
- }
-
- const args = isObject(query[fieldName]) ? query[fieldName]._args : undefined;
- debug(`resolver listType ${ourQuery.listType} args ${JSON.stringify(args)}`);
-
- // Call resolver function.
- return Promise.resolve(ourResolver(rec, args || {}, store.resolverContent)).then(
- async rawResult => {
- debug(
- `resolver returned typeof ${
- isArray(rawResult) ? `array #recs ${rawResult.length}` : typeof rawResult
- }`,
- );
-
- // Convert rawResult to query requirements.
- const result = convertResolverResult(rawResult, ourQuery, fieldName, type);
- if (isArray(rawResult !== isArray(result) || typeof rawResult !== typeof result)) {
- debug(
- `.....resolver result converted to typeof ${
- isArray(result) ? `array #recs ${result.length}` : typeof result
- }`,
- );
- }
- rec[fieldName] = result;
-
- const nextType = ourQuery.typeof;
- debug(`Type ${type} fieldName ${fieldName} next Type ${nextType}`);
-
- // Populate returned records if their query defn has more fields or Types.
- // Ignore resolvers returning base values like string.
- if (store.ourResolvers[nextType] && isObject(query[fieldName])) {
- return processRecords(store, query[fieldName], result, nextType, depth + 1);
- } else {
- debug('no population of results required');
- }
- },
- );
-}
-
-// Convert result of resolver function to match query field requirements.
-function convertResolverResult(result: any, ourQuery: any, fieldName: any, type: any) {
- if (result === null || result === undefined) {
- return ourQuery.listType ? [] : null;
- }
-
- if (ourQuery.listType) {
- if (!isArray(result)) return [result];
- } else if (isArray(result)) {
- if (result.length > 1) {
- throwError(
- `Query listType true. Resolver for Type ${type} fieldName ${fieldName} result is array len ${result.length} (fgraphql)`,
- 204,
- );
- }
-
- return result[0];
- }
-
- return result;
-}
-
-function convertSdlToFeathersSchemaObject(schemaDefinitionLanguage: any, parse: any) {
- const graphQLSchemaObj = parse(schemaDefinitionLanguage);
- return convertDocument(graphQLSchemaObj);
-}
-
-function convertDocument(ast: any) {
- const result: Record = {};
-
- if (ast.kind !== 'Document' || !isArray(ast.definitions)) {
- throw new Error('Not a valid GraphQL Document.');
- }
-
- ast.definitions.forEach((definition: any, definitionIndex: any) => {
- const [objectName, converted] = convertObjectTypeDefinition(definition, definitionIndex);
-
- if (objectName) {
- result[objectName] = converted;
- }
- });
-
- return result;
-}
-
-function convertObjectTypeDefinition(definition: any, definitionIndex: any) {
- const converted: Record = {};
-
- if (definition.kind !== 'ObjectTypeDefinition' || !isArray(definition.fields)) {
- throw new Error(`Type# ${definitionIndex} is not a valid ObjectTypeDefinition`);
- }
-
- const objectTypeName = convertName(definition.name, `Type# ${definitionIndex}`);
- if (graphqlActions.includes(objectTypeName)) return [null, null];
-
- definition.fields.forEach((field: any) => {
- const [fieldName, fieldDefinition] = convertFieldDefinition(field, `Type ${objectTypeName}`);
- converted[fieldName] = fieldDefinition;
- });
-
- return [objectTypeName, converted];
-}
-
-function convertName(nameObj: any, errDesc?: any) {
- if (!isObject(nameObj) || !isString(nameObj.value)) {
- throw new Error(`${errDesc} does not have a valid name prop.`);
- }
-
- return nameObj.value;
-}
-
-function convertFieldDefinition(field: any, errDesc: any) {
- if (field.kind !== 'FieldDefinition' || !isObject(field.type)) {
- throw new Error(`${errDesc} is not a valid ObjectTypeDefinition`);
- }
-
- const fieldName = convertName(field.name, errDesc);
- const converted = convertFieldDefinitionType(field.type, errDesc);
- converted.inputValues = field.arguments && field.arguments.length !== 0;
-
- return [fieldName, converted];
-}
-
-function convertFieldDefinitionType(fieldDefinitionType: any, errDesc: any, converted?: any): any {
- converted = converted || {
- nonNullTypeList: false,
- listType: false,
- nonNullTypeField: false,
- typeof: null,
- };
-
- if (!isObject(fieldDefinitionType)) {
- throw new Error(`${errDesc} is not a valid Fielddefinition "type".`);
- }
-
- switch (fieldDefinitionType.kind) {
- case 'NamedType':
- converted.typeof = convertName(fieldDefinitionType.name);
- return converted;
- case 'NonNullType':
- if (fieldDefinitionType.type.kind === 'NamedType') {
- converted.nonNullTypeField = true;
- } else {
- converted.nonNullTypeList = true;
- }
-
- return convertFieldDefinitionType(fieldDefinitionType.type, errDesc, converted);
- case 'ListType':
- converted.listType = true;
- return convertFieldDefinitionType(fieldDefinitionType.type, errDesc, converted);
- }
-}
-
-function throwError(msg: any, code: any) {
- const err = new Error(msg);
- // @ts-ignore
- err.code = code;
- throw err;
-}
-
-function isObject(obj: any) {
- return typeof obj === 'object' && obj !== null;
-}
-
-function isString(str: any) {
- return typeof str === 'string';
-}
-
-function isFunction(func: any) {
- return typeof func === 'function';
-}
-
-function isArray(array: any) {
- return Array.isArray(array);
-}
diff --git a/src/hooks/iff-else/iff-else.md b/src/hooks/iff-else/iff-else.md
new file mode 100644
index 00000000..2148061a
--- /dev/null
+++ b/src/hooks/iff-else/iff-else.md
@@ -0,0 +1,40 @@
+---
+title: iffElse
+description: Execute one array of hooks or another based on a sync or async predicate.
+category: hooks
+hook:
+ type: ['before', 'after']
+ method: ['all']
+ multi: true
+---
+
+## Arguments
+
+- `{Function} predicate`
+- `{Array< Functions >} hookFuncsTrue`
+- `{Array< Functions >} hookFuncsFalse`
+
+| Argument | Type | Default | Description |
+| ---------------- | :--------------------------------: | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `predicate` | `Boolean`, `Promise` or `Function` | | Determine if `hookFuncsTrue` or `hookFuncsFalse` should be run. If a function, `predicate` is called with the `context` as its param. It returns either a boolean or a Promise that evaluates to a boolean. |
+| `hookFuncsTrue` | `Array<` `Function >` | | Sync or async hook functions to run if `true`. They may include other conditional hooks. |
+| `hookFuncsFalse` | `Array<` `Function >` | | Sync or async hook functions to run if `false`. They may include other conditional hooks. |
+
+## Example
+
+```js
+const { iffElse, populate, serialize } = require('feathers-hooks-common/index.js');
+
+module.exports = { after: {
+ create: iffElse(() => { ... },
+ [populate(poAccting), serialize( ... )],
+ [populate(poReceiving), serialize( ... )]
+ )
+} };
+```
+
+## Details
+
+Resolve the predicate, then run one set of hooks sequentially.
+
+The predicate and hook functions will not be called with `this` set to the service, as is normal for hook functions. Use `hook.service` instead.
diff --git a/src/hooks/iff-else/iff-else.test.ts b/src/hooks/iff-else/iff-else.test.ts
new file mode 100755
index 00000000..74d49c12
--- /dev/null
+++ b/src/hooks/iff-else/iff-else.test.ts
@@ -0,0 +1,206 @@
+/* eslint-disable @typescript-eslint/no-this-alias */
+import type { HookContext } from '@feathersjs/feathers'
+import { assert } from 'vitest'
+import { iffElse } from './iff-else.js'
+import { some } from '../../predicates/some/some.js'
+import { every } from '../../predicates/every/every.js'
+import { clone } from '../../common/index.js'
+
+let hook: any
+let hookBefore: any
+let hookAfter: any
+let hookFcnSyncCalls: any
+let hookFcnAsyncCalls: any
+let hookFcnCalls: any
+let predicateParam1: any
+let predicateParam2: any
+let predicateParam3: any
+let predicateParam4: any
+let context: any
+let predicateTrueContext: any
+let hookFcnSyncContext: any
+let hookFcnAsyncContext: any
+let hookFcnContext: any
+
+const hookFcnSync = function (this: any, hook: any) {
+ hookFcnSyncContext = this
+
+ hookFcnSyncCalls = +1
+ hook.data.first = hook.data.first.toLowerCase()
+
+ return hook
+}
+
+const hookFcnAsync = function (this: any, hook: any) {
+ hookFcnAsyncContext = this
+
+ return new Promise(resolve => {
+ hookFcnAsyncCalls = +1
+ hook.data.first = hook.data.first.toLowerCase()
+
+ resolve(hook)
+ })
+}
+
+const hookFcn = function (this: any, hook: any, _cb: any) {
+ hookFcnContext = this
+
+ hookFcnCalls = +1
+
+ return hook
+}
+
+const predicateTrue = function (this: any, hook: any, more2: any, more3: any, more4: any): true {
+ predicateTrueContext = this
+
+ predicateParam1 = hook
+ predicateParam2 = more2
+ predicateParam3 = more3
+ predicateParam4 = more4
+
+ return true
+}
+
+describe('services iffElse', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ describe('runs single hook', () => {
+ it('when true', () => {
+ return iffElse(
+ true,
+ hookFcnSync,
+ hookFcnAsync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.equal(hookFcnAsyncCalls, 0)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('when false', () => {
+ return iffElse(
+ false,
+ hookFcnSync,
+ hookFcnAsync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+ })
+
+ describe('runs multiple hooks', () => {
+ it('when true', () => {
+ return iffElse(
+ true,
+ // @ts-expect-error TODO
+ [hookFcnSync, hookFcnAsync, hookFcn],
+ null,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.equal(hookFcnCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('when false', () => {
+ return (
+ // @ts-expect-error TODO
+ iffElse(false, null, [hookFcnSync, hookFcnAsync, hookFcn])(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.equal(hookFcnCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ )
+ })
+ })
+
+ describe('predicate gets right params', () => {
+ it('when true', () => {
+ return iffElse(
+ // @ts-expect-error TODO
+ predicateTrue,
+ [hookFcnSync, hookFcnAsync, hookFcn],
+ null,
+ )(hook).then(() => {
+ assert.deepEqual(predicateParam1, hook, 'param1')
+ assert.strictEqual(predicateParam2, undefined, 'param2')
+ assert.strictEqual(predicateParam3, undefined, 'param3')
+ assert.strictEqual(predicateParam4, undefined, 'param4')
+ })
+ })
+
+ it('every passes on correct params', () => {
+ return iffElse(
+ // @ts-expect-error TODO
+ every(predicateTrue),
+ // @ts-expect-error TODO
+ [hookFcnSync, hookFcnAsync, hookFcn],
+ null,
+ )(hook).then(() => {
+ assert.deepEqual(predicateParam1, hook, 'param1')
+ assert.strictEqual(predicateParam2, undefined, 'param2')
+ assert.strictEqual(predicateParam3, undefined, 'param3')
+ assert.strictEqual(predicateParam4, undefined, 'param4')
+ })
+ })
+
+ it('some passes on correct params', () => {
+ return iffElse(
+ // @ts-expect-error TODO
+ some(predicateTrue),
+ // @ts-expect-error TODO
+ [hookFcnSync, hookFcnAsync, hookFcn],
+ null,
+ )(hook).then(() => {
+ assert.deepEqual(predicateParam1, hook, 'param1')
+ assert.strictEqual(predicateParam2, undefined, 'param2')
+ assert.strictEqual(predicateParam3, undefined, 'param3')
+ assert.strictEqual(predicateParam4, undefined, 'param4')
+ })
+ })
+ })
+
+ describe('predicate and hooks get right context', () => {
+ beforeEach(() => {
+ context = { service: 'abc' }
+ predicateTrueContext = undefined
+ hookFcnSyncContext = undefined
+ hookFcnAsyncContext = undefined
+ hookFcnContext = undefined
+ })
+
+ it('services', () => {
+ return (
+ // @ts-expect-error TODO
+ iffElse(predicateTrue, [hookFcnSync, hookFcnAsync, hookFcn], null)
+ .call(context, hook)
+ .then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.equal(hookFcnCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+
+ assert.deepEqual(predicateTrueContext, { service: 'abc' })
+ assert.deepEqual(hookFcnSyncContext, { service: 'abc' })
+ assert.deepEqual(hookFcnAsyncContext, { service: 'abc' })
+ assert.deepEqual(hookFcnContext, { service: 'abc' })
+ })
+ )
+ })
+ })
+})
diff --git a/src/hooks/iff-else.ts b/src/hooks/iff-else/iff-else.ts
similarity index 64%
rename from src/hooks/iff-else.ts
rename to src/hooks/iff-else/iff-else.ts
index 7e35fe07..a9ee48ec 100755
--- a/src/hooks/iff-else.ts
+++ b/src/hooks/iff-else/iff-else.ts
@@ -1,7 +1,7 @@
-import type { HookContext } from '@feathersjs/feathers';
-import { isPromise } from '../common';
-import { combine } from '../utils/combine';
-import type { HookFunction, PredicateFn } from '../types';
+import type { HookContext } from '@feathersjs/feathers'
+import { isPromise } from '../../common/index.js'
+import { combine } from '../combine/combine.js'
+import type { HookFunction, PredicateFn } from '../../types.js'
/**
* Execute one array of hooks or another based on a sync or async predicate.
@@ -18,30 +18,31 @@ export function iffElse(
? trueHook
: typeof trueHook === 'function'
? [trueHook]
- : undefined;
+ : undefined
const falseHooks = Array.isArray(falseHook)
? falseHook
: typeof falseHook === 'function'
? [falseHook]
- : undefined;
+ : undefined
- const that = this;
- const check = typeof predicate === 'function' ? predicate.apply(that, [ctx]) : !!predicate;
+ // eslint-disable-next-line @typescript-eslint/no-this-alias
+ const that = this
+ const check = typeof predicate === 'function' ? predicate.apply(that, [ctx]) : !!predicate
if (!check) {
- return callHooks.call(that, ctx, falseHooks as any);
+ return callHooks.call(that, ctx, falseHooks as any)
}
if (!isPromise(check)) {
- return callHooks.call(that, ctx, trueHooks as any);
+ return callHooks.call(that, ctx, trueHooks as any)
}
return check.then((check1: any) => {
- const hooks = check1 ? trueHooks : falseHooks;
- return callHooks.call(that, ctx, hooks as any);
- });
- };
+ const hooks = check1 ? trueHooks : falseHooks
+ return callHooks.call(that, ctx, hooks as any)
+ })
+ }
}
function callHooks(
@@ -49,5 +50,5 @@ function callHooks(
ctx: H,
serviceHooks: HookFunction[],
) {
- return serviceHooks ? combine(...serviceHooks).call(this, ctx) : ctx;
+ return serviceHooks ? combine(...serviceHooks).call(this, ctx) : ctx
}
diff --git a/src/hooks/iff/iff.md b/src/hooks/iff/iff.md
new file mode 100644
index 00000000..7292f89e
--- /dev/null
+++ b/src/hooks/iff/iff.md
@@ -0,0 +1,54 @@
+---
+title: iff
+description: Execute one or another series of hooks depending on a sync or async predicate.
+category: hooks
+hook:
+ type: ['before', 'after']
+ method: ['all']
+ multi: true
+---
+
+## Arguments
+
+- `{Boolean | Promise | Function} predicate`
+- `{Array< Function >} hookFuncsTrue`
+- `{Array< Function >} hookFuncsFalse`
+
+| Argument | Type | Default | Description |
+| ---------------- | :--------------------------------: | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `predicate` | `Boolean`, `Promise` or `Function` | | Determine if `hookFuncsTrue` or `hookFuncsFalse` should be run. If a function, `predicate` is called with the `context` as its param. It returns either a boolean or a Promise that evaluates to a boolean. |
+| `hookFuncsTrue` | `Array<` `Function >` | | Sync or async hook functions to run if `true`. They may include other conditional hooks. |
+| `hookFuncsFalse` | `Array<` `Function >` | | Sync or async hook functions to run if `false`. They may include other conditional hooks. |
+
+## Example
+
+```js
+const { discard, iff, isProvider, populate } = require('feathers-hooks-common/index.js');
+const isNotAdmin = adminRole => context => context.params.user.roles.indexOf(adminRole || 'admin') === -1;
+
+module.exports = { before: {
+ create: iff(
+ () => new Promise((resolve, reject) => { ... }),
+ populate('user', { field: 'authorisedByUserId', service: 'users' })
+ ),
+
+ get: [ iff(isNotAdmin(), discard('budget')) ]
+
+ update:
+ iff(isProvider('server'),
+ hookA,
+ iff(isProvider('rest'), hook1, hook2, hook3)
+ .else(hook4, hook5),
+ hookB
+ )
+ .else(
+ iff(hook => hook.path === 'users', hook6, hook7)
+ )
+} };
+```
+
+## Details
+
+Resolve the predicate, then run one set of hooks sequentially.
+
+The predicate and hook functions will not be called with `this` set to the service, as is normal for hook functions. Use `hook.service` instead.
diff --git a/src/hooks/iff/iff.test.ts b/src/hooks/iff/iff.test.ts
new file mode 100755
index 00000000..93db8320
--- /dev/null
+++ b/src/hooks/iff/iff.test.ts
@@ -0,0 +1,401 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { assert } from 'vitest'
+import { iff } from './iff.js'
+import { clone, isPromise } from '../../common/index.js'
+
+let hook: any
+let hookBefore: any
+let hookAfter: any
+let hookFcnSyncCalls: any
+let hookFcnAsyncCalls: any
+let hookFcnCbCalls: any
+let predicateHook: any
+let predicateOptions: any
+let predicateValue: any
+
+const predicateSync = (hook: any) => {
+ predicateHook = clone(hook)
+ return true
+}
+
+const predicateSync2 = (options: any) => (hook: any) => {
+ predicateOptions = clone(options)
+ predicateHook = clone(hook)
+ return true
+}
+
+const predicateAsync = (hook: any) => {
+ predicateHook = clone(hook)
+ return new Promise(resolve => resolve(true))
+}
+
+const predicateAsync2 = (options: any) => (hook: any) => {
+ predicateOptions = clone(options)
+ predicateHook = clone(hook)
+ return new Promise(resolve => resolve(true))
+}
+
+const predicateAsyncFunny = (hook: any) => {
+ predicateHook = clone(hook)
+ return new Promise(resolve => {
+ predicateValue = 'abc'
+ return resolve(predicateValue)
+ })
+}
+
+const hookFcnSync = (hook: HookContext): HookContext => {
+ hookFcnSyncCalls = +1
+ hook.data.first = hook.data.first.toLowerCase()
+
+ return hook
+}
+
+const hookFcnAsync = (hook: HookContext) =>
+ new Promise(resolve => {
+ hookFcnAsyncCalls = +1
+ hook.data.first = hook.data.first.toLowerCase()
+
+ resolve(hook)
+ })
+
+const hookFcn = (hook: HookContext): HookContext => {
+ hookFcnCbCalls = +1
+
+ return hook
+}
+
+describe('services iff - sync predicate, sync hook', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('calls sync hook function if truthy non-function', () => {
+ iff(
+ // @ts-expect-error TODO
+ 'a',
+ hookFcnSync,
+ )(hook)
+ // @ts-expect-error TODO
+ .then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('does not call sync hook function if falsey non-function', () => {
+ // @ts-expect-error TODO
+ const result = iff('', hookFcnSync)(hook)
+
+ if (isPromise(result)) {
+ assert.fail('promise unexpectedly returned')
+ } else {
+ assert.deepEqual(result, hookBefore)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ }
+ })
+
+ it('calls sync hook function if sync predicate truthy', () => {
+ iff(
+ // @ts-expect-error TODO
+ () => 'a',
+ hookFcnSync,
+ )(hook)
+ // @ts-expect-error TODO
+ .then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('does not call sync hook function if sync predicate falsey', () => {
+ // @ts-expect-error TODO
+ const result = iff(() => '', hookFcnSync)(hook)
+
+ if (isPromise(result)) {
+ assert.fail('promise unexpectedly returned')
+ } else {
+ assert.deepEqual(result, hookBefore)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ }
+ })
+})
+
+describe('services iff - sync predicate, async hook', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('calls async hook function if sync predicate truthy', async () => {
+ const result = iff(true, hookFcnAsync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('does not call async hook function if sync predicate falsey', () => {
+ const result = iff(false, hookFcnAsync)(hook)
+
+ if (isPromise(result)) {
+ assert.fail('promise unexpectedly returned')
+ }
+
+ assert.deepEqual(result, hookBefore)
+ assert.equal(hookFcnAsyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ })
+
+ it('calls async hook function if sync predicate returns truthy', async () => {
+ const result = iff(() => true, hookFcnAsync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+})
+
+describe('services iff - async predicate, sync hook', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('calls sync hook function if aync predicate truthy', async () => {
+ const result = iff(() => new Promise(resolve => resolve(true)), hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+ })
+ })
+
+ it('does not call sync hook function if async predicate falsey', async () => {
+ const result = iff(() => new Promise(resolve => resolve(false)), hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookBefore)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ })
+ })
+})
+
+describe('services iff - async predicate, async hook', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('calls async hook function if aync predicate truthy', async () => {
+ const result = iff(() => new Promise(resolve => resolve(true)), hookFcnAsync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+ })
+ })
+
+ it('does not call async hook function if async predicate falsey', async () => {
+ const result = iff(() => new Promise(resolve => resolve(false)), hookFcnAsync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookBefore)
+ assert.equal(hookFcnAsyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ })
+ })
+})
+
+describe('services iff - sync predicate', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ predicateHook = null
+ predicateOptions = null
+ })
+
+ it('does not need to access hook', () => {
+ iff(
+ // @ts-expect-error TODO
+ () => 'a',
+ hookFcnSync,
+ )(hook)
+ // @ts-expect-error TODO
+ .then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('is passed hook as param', () => {
+ iff(
+ predicateSync,
+ hookFcnSync,
+ )(hook)
+ // @ts-expect-error TODO
+ .then((hook: any) => {
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('a higher order predicate can pass more options', () => {
+ iff(
+ predicateSync2({ z: 'z' }),
+ hookFcnSync,
+ )(hook)
+ // @ts-expect-error TODO
+ .then((hook: any) => {
+ assert.deepEqual(predicateOptions, { z: 'z' })
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+})
+
+describe('services iff - async predicate', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ predicateHook = null
+ predicateOptions = null
+ predicateValue = null
+ })
+
+ it('is passed hook as param', async () => {
+ // @ts-expect-error TODO
+ const result = iff(predicateAsync, hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+ })
+ })
+
+ it('is resolved', async () => {
+ // @ts-expect-error TODO
+ const result = iff(predicateAsyncFunny, hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+
+ assert.equal(predicateValue, 'abc')
+ })
+ })
+
+ it('a higher order predicate can pass more options', async () => {
+ // @ts-expect-error TODO
+ const result = iff(predicateAsync2({ y: 'y' }), hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(predicateOptions, { y: 'y' })
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+ })
+ })
+})
+
+describe('services iff - runs multiple hooks', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('runs successfully', async () => {
+ await iff(
+ true,
+ hookFcnSync,
+ hookFcnAsync,
+ hookFcn,
+ )(hook)
+ // @ts-expect-error TODO
+ .then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.equal(hookFcnCbCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+})
diff --git a/src/hooks/iff.ts b/src/hooks/iff/iff.ts
similarity index 62%
rename from src/hooks/iff.ts
rename to src/hooks/iff/iff.ts
index 8012d633..2bdba9fc 100755
--- a/src/hooks/iff.ts
+++ b/src/hooks/iff/iff.ts
@@ -1,9 +1,9 @@
-import type { HookContext } from '@feathersjs/feathers';
-import { iffElse } from './iff-else';
-import type { HookFunction, PredicateFn } from '../types';
+import type { HookContext } from '@feathersjs/feathers'
+import { iffElse } from '../iff-else/iff-else.js'
+import type { HookFunction, PredicateFn } from '../../types.js'
export interface IffHook extends HookFunction {
- else(...hooks: HookFunction[]): HookFunction;
+ else(...hooks: HookFunction[]): HookFunction
}
/**
@@ -15,20 +15,19 @@ export function iff(
...hooks: HookFunction[]
): IffHook {
if (hooks.length && Array.isArray(hooks[0])) {
- hooks = hooks[0];
+ hooks = hooks[0]
}
const iffWithoutElse = function (context: H) {
- return iffElse(predicate, hooks.slice())(context);
- };
+ return iffElse(predicate, hooks.slice())(context)
+ }
iffWithoutElse.else =
(...falseHooks: any[]) =>
(context: H) =>
- // @ts-ignore
- iffElse(predicate, hooks.slice(), falseHooks.slice())(context);
+ iffElse(predicate, hooks.slice(), falseHooks.slice())(context)
- return iffWithoutElse as IffHook;
+ return iffWithoutElse as IffHook
}
-export { iff as when };
+export { iff as when }
diff --git a/src/hooks/index.ts b/src/hooks/index.ts
new file mode 100644
index 00000000..8235ba06
--- /dev/null
+++ b/src/hooks/index.ts
@@ -0,0 +1,36 @@
+export * from './cache/cache.js'
+export * from './check-required/check-required.js'
+export * from './combine/combine.js'
+export * from './create-related/create-related.js'
+export * from './debug/debug.js'
+export * from './disable-pagination/disable-pagination.js'
+export * from './disallow/disallow.js'
+export * from './iff-else/iff-else.js'
+export * from './iff/iff.js'
+export * from './lowercase-data/lowercase-data.js'
+export * from './lowercase-result/lowercase-result.js'
+export * from './omit-data/omit-data.js'
+export * from './omit-query/omit-query.js'
+export * from './omit-result/omit-result.js'
+export * from './params-for-server/params-for-server.js'
+export * from './params-from-client/params-from-client.js'
+export * from './pick-data/pick-data.js'
+export * from './pick-query/pick-query.js'
+export * from './pick-result/pick-result.js'
+export * from './prevent-changes/prevent-changes.js'
+export * from './run-parallel/run-parallel.js'
+export * from './set-field/set-field.js'
+export * from './set-now-data/set-now-data.js'
+export * from './set-now-result/set-now-result.js'
+export * from './set-slug/set-slug.js'
+export * from './soft-delete/soft-delete.js'
+export * from './stash-before/stash-before.js'
+export * from './throw-if-is-multi/throw-if-is-multi.js'
+export * from './throw-if-is-provider/throw-if-is-provider.js'
+export * from './throw-if/throw-if.js'
+export * from './trim-data/trim-data.js'
+export * from './trim-result/trim-result.js'
+export * from './transform-data/transform-data.js'
+export * from './transform-result/transform-result.js'
+export * from './traverse/traverse.js'
+export * from './unless/unless.js'
diff --git a/src/hooks/keep-in-array.ts b/src/hooks/keep-in-array.ts
deleted file mode 100755
index 51833bba..00000000
--- a/src/hooks/keep-in-array.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { BadRequest } from '@feathersjs/errors';
-import _get from 'lodash/get.js';
-import _set from 'lodash/set.js';
-import _has from 'lodash/has.js';
-import { getItems } from '../utils/get-items';
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Keep certain fields in a nested array inside the record(s), deleting the rest.
- * @see https://hooks-common.feathersjs.com/hooks.html#keepinarray
- */
-export function keepInArray(
- arrayName: string,
- fieldNames: string[],
-) {
- return (context: H) => {
- const items = getItems(context);
-
- if (Array.isArray(items)) {
- items.forEach(item => replaceIn(item, arrayName, fieldNames));
- } else {
- replaceIn(items, arrayName, fieldNames);
- }
-
- return context;
- };
-}
-
-function replaceIn(item: any, field: any, fieldNames: any) {
- const target = _get(item, field);
- if (target) {
- if (!Array.isArray(target))
- throw new BadRequest(
- `The 'field' param must lead to array. found type '${typeof target}' instead`,
- );
-
- _set(
- item,
- field,
- target.map(item => replaceItem(item, fieldNames)),
- );
- }
-}
-
-function replaceItem(item: any, fields: any) {
- if (typeof item !== 'object' || item === null) return item;
-
- const newItem = {};
- fields.forEach((field: any) => {
- if (!_has(item, field)) return;
-
- const value = _get(item, field);
- _set(newItem, field, value);
- });
- item = newItem;
- return item;
-}
diff --git a/src/hooks/keep-query-in-array.ts b/src/hooks/keep-query-in-array.ts
deleted file mode 100644
index 7b32ab5d..00000000
--- a/src/hooks/keep-query-in-array.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { checkContext } from '../utils/check-context';
-import { BadRequest } from '@feathersjs/errors';
-import _get from 'lodash/get.js';
-import _set from 'lodash/set.js';
-import _has from 'lodash/has.js';
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Keep certain fields in a nested array inside the query object, deleting the rest.
- * @see https://hooks-common.feathersjs.com/hooks.html#keepqueryinarray
- */
-export function keepQueryInArray(
- arrayName: string,
- fieldNames: string[],
-) {
- return (context: H) => {
- checkContext(context, 'before', null, 'keepQueryInArray');
-
- replaceIn(context.query, arrayName, fieldNames);
-
- return context;
- };
-}
-
-function replaceIn(item: any, field: any, fieldNames: any) {
- const target = _get(item, field);
- if (target) {
- if (!Array.isArray(target))
- throw new BadRequest(
- `The 'field' param must lead to array. found type '${typeof target}' instead`,
- );
-
- _set(
- item,
- field,
- target.map(item => replaceItem(item, fieldNames)),
- );
- }
-}
-
-function replaceItem(item: any, fields: any) {
- if (typeof item !== 'object' || item === null) return item;
-
- const newItem = {};
- fields.forEach((field: any) => {
- if (!_has(item, field)) return;
-
- const value = _get(item, field);
- _set(newItem, field, value);
- });
- item = newItem;
- return item;
-}
diff --git a/src/hooks/keep-query.ts b/src/hooks/keep-query.ts
deleted file mode 100755
index aac6d2e0..00000000
--- a/src/hooks/keep-query.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-import { pluck } from '../common';
-import { checkContext } from '../utils/check-context';
-
-/**
- * Keep certain fields in the query object, deleting the rest.
- * @see https://hooks-common.feathersjs.com/hooks.html#keepquery
- */
-export function keepQuery(...fieldNames: string[]) {
- return (context: H) => {
- checkContext(context, 'before', null, 'keepQuery');
-
- const query = context.params.query || {};
- context.params.query = pluck(query, fieldNames);
-
- return context;
- };
-}
diff --git a/src/hooks/keep.ts b/src/hooks/keep.ts
deleted file mode 100755
index 48df0eef..00000000
--- a/src/hooks/keep.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import _get from 'lodash/get.js';
-import _set from 'lodash/set.js';
-import _has from 'lodash/has.js';
-
-import { checkContextIf } from '../utils/check-context-if';
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Keep certain fields in the record(s), deleting the rest.
- * @see https://hooks-common.feathersjs.com/hooks.html#keep
- */
-export function keep(...fieldNames: string[]) {
- return (context: H) => {
- checkContextIf(context, 'before', ['create', 'update', 'patch'], 'keep');
- const items = getItems(context);
-
- if (Array.isArray(items)) {
- replaceItems(
- context,
- items.map(item => replaceItem(item, fieldNames)),
- );
- } else {
- replaceItems(context, replaceItem(items, fieldNames));
- }
-
- return context;
- };
-}
-
-function replaceItem(item: any, fields: any) {
- if (typeof item !== 'object' || item === null) return item;
-
- const newItem = {};
- fields.forEach((field: any) => {
- if (!_has(item, field)) return;
-
- const value = _get(item, field);
- _set(newItem, field, value);
- });
- item = newItem;
- return item;
-}
diff --git a/src/hooks/lower-case.ts b/src/hooks/lower-case.ts
deleted file mode 100755
index f71cb1ae..00000000
--- a/src/hooks/lower-case.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import _set from 'lodash/set.js';
-import { BadRequest } from '@feathersjs/errors';
-
-import { transformItems } from '../common';
-import { checkContextIf } from '../utils/check-context-if';
-import { getItems } from '../utils/get-items';
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Convert certain field values to lower case.
- * @see https://hooks-common.feathersjs.com/hooks.html#lowercase
- */
-export function lowerCase(...fieldNames: string[]) {
- return (context: H) => {
- checkContextIf(context, 'before', ['create', 'update', 'patch'], 'lowercase');
-
- transformItems(getItems(context), fieldNames, (item: any, fieldName: any, value: any) => {
- if (value !== undefined) {
- if (typeof value !== 'string' && value !== null) {
- throw new BadRequest(`Expected string data. (lowercase ${fieldName})`);
- }
-
- _set(item, fieldName, value ? value.toLowerCase() : value);
- }
- });
-
- return context;
- };
-}
diff --git a/src/hooks/lowercase-data/lowercase-data.md b/src/hooks/lowercase-data/lowercase-data.md
new file mode 100644
index 00000000..d849b1ba
--- /dev/null
+++ b/src/hooks/lowercase-data/lowercase-data.md
@@ -0,0 +1,28 @@
+---
+title: lowercaseData
+description: Convert certain field values to lower case.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
+
+- Arguments
+ - `{Array < String >} fieldNames`
+
+| Name | Type | Description |
+| ---------- | ------------ | --------------------------------------------------------------------- |
+| fieldNames | dot notation | The fields in the record(s) whose values are converted to lower case. |
+
+## Example
+
+```js
+const { lowerCase } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: { create: lowerCase('email', 'username', 'div.dept') } };
+```
+
+## Details
+
+Update either `context.data` (before hook) or `context.result[.data]` (after hook).
diff --git a/src/hooks/lowercase-data/lowercase-data.test.ts b/src/hooks/lowercase-data/lowercase-data.test.ts
new file mode 100755
index 00000000..eef82fa3
--- /dev/null
+++ b/src/hooks/lowercase-data/lowercase-data.test.ts
@@ -0,0 +1,96 @@
+import { assert } from 'vitest'
+import { lowercaseData } from './lowercase-data.js'
+
+let hookBefore: any
+
+describe('lowercaseData', () => {
+ describe('updates data', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ })
+
+ it('updates hook before::create', () => {
+ lowercaseData(['first', 'last'])(hookBefore)
+ assert.deepEqual(hookBefore.data, { first: 'john', last: 'doe' })
+ })
+
+ it('does not throw if field is missing', () => {
+ const hook: any = { type: 'before', method: 'create', data: { last: 'Doe' } }
+ lowercaseData(['first', 'last'])(hook)
+ assert.deepEqual(hook.data, { last: 'doe' })
+ })
+
+ it('does not throw if field is undefined', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ data: { first: undefined, last: 'Doe' },
+ }
+ lowercaseData(['first', 'last'])(hook)
+ assert.deepEqual(hook.data, { first: undefined, last: 'doe' })
+ })
+
+ it('does not throw if field is null', () => {
+ const hook: any = { type: 'before', method: 'create', data: { first: null, last: 'Doe' } }
+ lowercaseData(['first', 'last'])(hook)
+ assert.deepEqual(hook.data, { first: null, last: 'doe' })
+ })
+
+ it('throws if field is not a string', async () => {
+ const hook: any = { type: 'before', method: 'create', data: { first: 1, last: 'Doe' } }
+ await expect(async () => {
+ await lowercaseData(['first', 'last'])(hook)
+ }).rejects.toThrow('Expected string data. (lowercase first)')
+ })
+ })
+
+ describe('handles dot notation', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ data: { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
+ }
+ })
+
+ it('prop with no dots', () => {
+ lowercaseData('dept')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'acct',
+ })
+ })
+
+ it('prop with 1 dot', () => {
+ lowercaseData('empl.status')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'aa' },
+ dept: 'Acct',
+ })
+ })
+
+ it('prop with 2 dots', () => {
+ lowercaseData('empl.name.first')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'john', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+
+ it('ignores bad or missing paths', () => {
+ lowercaseData('empl.xx.first')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+
+ it('ignores bad or missing no dot path', () => {
+ lowercaseData('xx')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+ })
+})
diff --git a/src/hooks/lowercase-data/lowercase-data.ts b/src/hooks/lowercase-data/lowercase-data.ts
new file mode 100755
index 00000000..af05d1db
--- /dev/null
+++ b/src/hooks/lowercase-data/lowercase-data.ts
@@ -0,0 +1,31 @@
+import _get from 'lodash/get.js'
+import _set from 'lodash/set.js'
+import { BadRequest } from '@feathersjs/errors'
+import { transformData } from '../transform-data/transform-data.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+/**
+ * Convert certain field values to lower case.
+ * @see https://hooks-common.feathersjs.com/hooks.html#lowercase
+ */
+export const lowercaseData = (fieldNames: MaybeArray) => {
+ const fieldNamesArr = toArray(fieldNames)
+
+ return transformData(item => {
+ for (let i = 0; i < fieldNamesArr.length; i++) {
+ const fieldName = fieldNamesArr[i]
+ const value = _get(item, fieldName)
+
+ if (value == null) {
+ continue
+ }
+
+ if (typeof value !== 'string') {
+ throw new BadRequest(`Expected string data. (lowercase ${fieldName})`)
+ }
+
+ _set(item, fieldName, value.toLowerCase())
+ }
+ })
+}
diff --git a/src/hooks/lowercase-result/lowercase-result.md b/src/hooks/lowercase-result/lowercase-result.md
new file mode 100644
index 00000000..bc30197f
--- /dev/null
+++ b/src/hooks/lowercase-result/lowercase-result.md
@@ -0,0 +1,28 @@
+---
+title: lowercaseResult
+description: Convert certain field values to lower case.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
+
+- Arguments
+ - `{Array < String >} fieldNames`
+
+| Name | Type | Description |
+| ---------- | ------------ | --------------------------------------------------------------------- |
+| fieldNames | dot notation | The fields in the record(s) whose values are converted to lower case. |
+
+## Example
+
+```js
+const { lowerCase } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: { create: lowerCase('email', 'username', 'div.dept') } };
+```
+
+## Details
+
+Update either `context.data` (before hook) or `context.result[.data]` (after hook).
diff --git a/src/hooks/lowercase-result/lowercase-result.test.ts b/src/hooks/lowercase-result/lowercase-result.test.ts
new file mode 100755
index 00000000..7f7361ca
--- /dev/null
+++ b/src/hooks/lowercase-result/lowercase-result.test.ts
@@ -0,0 +1,52 @@
+import { assert } from 'vitest'
+import { lowercaseResult } from './lowercase-result.js'
+import type { HookContext } from '@feathersjs/feathers'
+
+describe('lowercaseResult', () => {
+ it('updates hook after::find with pagination', () => {
+ const context = {
+ type: 'after',
+ method: 'find',
+ result: {
+ total: 2,
+ data: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ },
+ } as HookContext
+
+ lowercaseResult(['first', 'last'])(context)
+ assert.deepEqual(context.result.data, [
+ { first: 'john', last: 'doe' },
+ { first: 'jane', last: 'doe' },
+ ])
+ })
+
+ it('updates hook after::find with no pagination', () => {
+ const context = {
+ type: 'after',
+ method: 'find',
+ result: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ } as HookContext
+ lowercaseResult(['first', 'last'])(context)
+ assert.deepEqual(context.result, [
+ { first: 'john', last: 'doe' },
+ { first: 'jane', last: 'doe' },
+ ])
+ })
+
+ it('updates hook after', () => {
+ const context = {
+ type: 'after',
+ method: 'create',
+ result: { first: 'Jane', last: 'Doe' },
+ } as HookContext
+ lowercaseResult(['first', 'last'])(context)
+
+ assert.deepEqual(context.result, { first: 'jane', last: 'doe' })
+ })
+})
diff --git a/src/hooks/lowercase-result/lowercase-result.ts b/src/hooks/lowercase-result/lowercase-result.ts
new file mode 100755
index 00000000..de7950ce
--- /dev/null
+++ b/src/hooks/lowercase-result/lowercase-result.ts
@@ -0,0 +1,42 @@
+import _get from 'lodash/get.js'
+import _set from 'lodash/set.js'
+import { BadRequest } from '@feathersjs/errors'
+import { transformResult } from '../transform-result/transform-result.js'
+import type { DispatchOption } from '../../types.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+export type LowercaseResultOptions = {
+ dispatch?: DispatchOption
+}
+
+/**
+ * Convert certain field values to lower case.
+ * @see https://hooks-common.feathersjs.com/hooks.html#lowercase
+ */
+export const lowercaseResult = (
+ fieldNames: MaybeArray,
+ options?: LowercaseResultOptions,
+) => {
+ const fieldNamesArray = toArray(fieldNames)
+
+ return transformResult(
+ (item: any) => {
+ for (let i = 0; i < fieldNamesArray.length; i++) {
+ const fieldName = fieldNamesArray[i]
+ const value = _get(item, fieldName)
+
+ if (value == null) {
+ continue
+ }
+
+ if (typeof value !== 'string') {
+ throw new BadRequest(`Expected string data. (lowercase ${fieldName})`)
+ }
+
+ _set(item, fieldName, value.toLowerCase())
+ }
+ },
+ { dispatch: options?.dispatch },
+ )
+}
diff --git a/src/hooks/mongo-keys.ts b/src/hooks/mongo-keys.ts
deleted file mode 100755
index 07f7c71c..00000000
--- a/src/hooks/mongo-keys.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-import traverse from 'neotraverse/legacy';
-import { checkContext } from '../utils/check-context';
-
-/**
- * Wrap MongoDB foreign keys in ObjectId.
- *
- * @see https://hooks-common.feathersjs.com/hooks.html#mongokeys
- */
-export function mongoKeys(
- ObjectId: new (id?: string | number) => any,
- keyFields: string | string[],
-) {
- keyFields = Array.isArray(keyFields) ? keyFields : [keyFields];
- const keyLeaves: any = [];
-
- const keysInfo = keyFields.map((field: any) => {
- const fieldNames = field.split('.');
- const leaf = fieldNames.slice(-1)[0];
- keyLeaves.push(leaf);
-
- return { leaf, len: fieldNames.length, path: JSON.stringify(fieldNames) };
- });
-
- return (context: H) => {
- checkContext(context, 'before', null, 'mongoKeys');
- const query = context.params.query || {};
-
- traverse(query).forEach(function (node: any) {
- const typeofNode = typeof node;
- const key = this.key;
- const path = this.path;
-
- if (keyLeaves.indexOf(key) === -1) return;
- if (path.indexOf('$sort') !== -1) return;
-
- keysInfo.forEach((info: any) => {
- if (info.leaf === key && info.len <= path.length) {
- const endPath = path.slice(-info.len);
- if (JSON.stringify(endPath) === info.path) {
- if (typeofNode === 'object' && node !== null && !Array.isArray(node)) {
- // { keyPath: { ... } }
- const actualProps = Object.keys(node);
- const onlyProp = actualProps[0];
-
- if (actualProps.length === 1 && onlyProp === '$in') {
- // { keyPath: { $in: [...] } }
- const newNode = { $in: wrapValue(node[onlyProp]) };
- this.update(newNode);
- }
- } else if (typeofNode === 'string' || typeofNode === 'number') {
- // { keyPath: '111111111111' }
- const newNode = wrapValue(node);
- this.update(newNode);
- }
- }
- }
- });
- });
-
- return context;
- };
-
- function wrapValue(value: any) {
- return Array.isArray(value) ? value.map(val => new ObjectId(val)) : new ObjectId(value);
- }
-}
diff --git a/test/hooks/discard-1.test.ts b/src/hooks/omit-data/omit-data-1.test.ts
similarity index 57%
rename from test/hooks/discard-1.test.ts
rename to src/hooks/omit-data/omit-data-1.test.ts
index 00c2b946..217cc5c8 100755
--- a/test/hooks/discard-1.test.ts
+++ b/src/hooks/omit-data/omit-data-1.test.ts
@@ -1,84 +1,44 @@
-import { assert } from 'vitest';
-import { discard } from '../../src';
+import { assert } from 'vitest'
+import { omitData } from './omit-data.js'
+import type { HookContext } from '@feathersjs/feathers'
-describe('common hook discard', () => {
+describe('omitData', () => {
describe('removes fields', () => {
- const beforeJohn = (): any => ({ type: 'before', data: { first: 'John', last: 'Doe' } });
- const beforeUndef = (): any => ({ type: 'before', data: { first: undefined, last: 'Doe' } });
- const beforeNull = (): any => ({ type: 'before', data: { first: null, last: 'Doe' } });
- const afterJane = (): any => ({ type: 'after', result: { first: 'Jane', last: 'Doe' } });
- const afterBoth = (): any => ({
- type: 'after',
- result: [
- { first: 'John', last: 'Doe' },
- { first: 'Jane', last: 'Doe' },
- ],
- });
- const afterPage = (): any => ({
- type: 'after',
- result: {
- total: 2,
- skip: 0,
- data: [
- { first: 'John', last: 'Doe' },
- { first: 'Jane', last: 'Doe' },
- ],
- },
- });
+ const beforeJohn = (): any => ({ type: 'before', data: { first: 'John', last: 'Doe' } })
+ const beforeUndef = (): any => ({ type: 'before', data: { first: undefined, last: 'Doe' } })
+ const beforeNull = (): any => ({ type: 'before', data: { first: null, last: 'Doe' } })
const decisionTable = [
['before::create', beforeJohn(), 'create', null, ['first'], { last: 'Doe' }],
- [
- 'after::find with paginate',
- afterPage(),
- 'find',
- null,
- ['last'],
- [{ first: 'John' }, { first: 'Jane' }],
- ],
- [
- 'after::find no paginate',
- afterBoth(),
- 'find',
- null,
- ['last'],
- [{ first: 'John' }, { first: 'Jane' }],
- ],
- ['after', afterJane(), 'create', null, ['last'], { first: 'Jane' }],
- ['call internally on server', afterJane(), 'create', undefined, ['last'], { first: 'Jane' }],
['not throw field missing', beforeJohn(), 'create', 'rest', ['first', 'xx'], { last: 'Doe' }],
['not throw field undefined', beforeUndef(), 'create', 'rest', ['first'], { last: 'Doe' }],
['not throw field null', beforeNull(), 'create', 'rest', ['first'], { last: 'Doe' }],
- ];
+ ] as [string, HookContext, string, string, string[], any][]
decisionTable.forEach(([desc, context, method, provider, args, result]) => {
it(desc, () => {
- context.method = method;
+ // @ts-expect-error readonly
+ context.method = method
if (provider !== null) {
- context.params = context.params || {};
- context.params.provider = provider;
+ context.params = context.params || {}
+ context.params.provider = provider
}
- discard(...args)(context);
+ omitData(args)(context)
assert.deepEqual(
context.data ? context.data : context.result.data || context.result,
result,
- );
- });
- });
- });
+ )
+ })
+ })
+ })
describe('handles dot notation', () => {
const ctx = (): any => ({
type: 'before',
method: 'create',
data: { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
- });
- const ctx2 = (): any => ({
- type: 'after',
- method: 'get',
- result: { property: null, foo: 'bar' },
- });
+ })
const decisionTable = [
// desc, context, args, result
@@ -118,17 +78,16 @@ describe('common hook discard', () => {
['empl.status', 'dept'],
{ empl: { name: { first: 'John', last: 'Doe' } } },
],
- ['path not obj', ctx2(), ['property.secret'], { property: null, foo: 'bar' }],
- ];
+ ] as [string, HookContext, string[], any][]
decisionTable.forEach(([desc, context, args, result]) => {
it(desc, () => {
- discard(...args)(context);
+ omitData(args)(context)
assert.deepEqual(
context.data ? context.data : context.result.data || context.result,
result,
- );
- });
- });
- });
-});
+ )
+ })
+ })
+ })
+})
diff --git a/src/hooks/omit-data/omit-data.md b/src/hooks/omit-data/omit-data.md
new file mode 100644
index 00000000..bb502b37
--- /dev/null
+++ b/src/hooks/omit-data/omit-data.md
@@ -0,0 +1,33 @@
+---
+title: omitData
+description: Delete certain fields from the record(s).
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
+
+> **Note:** The discard hook will remove fields even if the service is being called from the server. You may want to condition the hook to run only for external transports, e.g. `iff(isProvider('external'), discard(...))`.
+
+- Arguments
+ - `{Array < String >} fieldNames`
+
+| Name | Type | Description |
+| ---------- | ------------ | --------------------------------------------------------- |
+| fieldNames | dot notation | One or more fields you want to remove from the record(s). |
+
+## Example
+
+```js
+const { discard, iff, isProvider } = require('feathers-hooks-common/index.js');
+
+module.exports = {
+ after: { all: iff(isProvider('external'), discard('password', 'address.city')) },
+};
+```
+
+## Details
+
+Delete the fields either from `context.data` (before hook) or `context.result[.data]` (after hook).
+They are not modified if they are not an object, so a `null` value is supported.
diff --git a/src/hooks/omit-data/omit-data.test.ts b/src/hooks/omit-data/omit-data.test.ts
new file mode 100755
index 00000000..438fa215
--- /dev/null
+++ b/src/hooks/omit-data/omit-data.test.ts
@@ -0,0 +1,94 @@
+import { assert } from 'vitest'
+import { omitData } from './omit-data.js'
+
+let hookBefore: any
+
+describe('omitData', () => {
+ describe('removes fields', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: 'John', last: 'Doe' },
+ }
+ })
+
+ it('updates hook before::create', () => {
+ omitData('first')(hookBefore)
+ assert.deepEqual(hookBefore.data, { last: 'Doe' })
+ })
+
+ it('does not throw if field is missing', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: 'John', last: 'Doe' },
+ }
+ omitData(['first', 'xx'])(hook)
+ assert.deepEqual(hook.data, { last: 'Doe' })
+ })
+
+ it('does not throw if field is null', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: null, last: 'Doe' },
+ }
+ omitData('first')(hook)
+ assert.deepEqual(hook.data, { last: 'Doe' })
+ })
+ })
+
+ describe('handles dot notation', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
+ }
+ })
+
+ it('prop with no dots', () => {
+ omitData('dept')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ })
+ })
+
+ it('prop with 1 dot', () => {
+ omitData('empl.status')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' } },
+ dept: 'Acct',
+ })
+ })
+
+ it('prop with 2 dots', () => {
+ omitData('empl.name.first')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+
+ it('ignores bad or missing paths', () => {
+ omitData('empl.xx.first')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+
+ it('ignores bad or missing no dot path', () => {
+ omitData('xx')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+ })
+})
diff --git a/src/hooks/omit-data/omit-data.ts b/src/hooks/omit-data/omit-data.ts
new file mode 100755
index 00000000..49c86ebf
--- /dev/null
+++ b/src/hooks/omit-data/omit-data.ts
@@ -0,0 +1,11 @@
+import _omit from 'lodash/omit.js'
+import { transformData } from '../transform-data/transform-data.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+/**
+ * Delete certain fields from the record(s).
+ * @see https://hooks-common.feathersjs.com/hooks.html#discard
+ */
+export const omitData = (fieldNames: MaybeArray) =>
+ transformData((item: any) => _omit(item, toArray(fieldNames)))
diff --git a/src/hooks/omit-query/omit-query.md b/src/hooks/omit-query/omit-query.md
new file mode 100644
index 00000000..fc0916b0
--- /dev/null
+++ b/src/hooks/omit-query/omit-query.md
@@ -0,0 +1,30 @@
+---
+title: omitQuery
+description: Delete certain fields from the query object.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['all']
+ multi: true
+---
+
+> **Note:** The discardQuery hook will remove any fields not specified even if the service is being called from the server. You may want to condition the hook to run only for external transports, e.g. `iff(isProvider('external'), discardQuery(...))`.
+
+- Arguments
+ - `{Array < String >} fieldNames`
+
+| Name | Type | Description |
+| ---------- | ------------ | ----------------------------------------------------- |
+| fieldNames | dot notation | One or more fields you want to remove from the query. |
+
+## Example
+
+```js
+const { discardQuery, iff, isProvider } = require('feathers-hooks-common/index.js');
+
+module.exports = { after: { all: iff(isProvider('external'), discardQuery('secret')) } };
+```
+
+## Details
+
+Delete the fields from `context.params.query`.
diff --git a/test/hooks/discard-query.test.ts b/src/hooks/omit-query/omit-query.test.ts
similarity index 69%
rename from test/hooks/discard-query.test.ts
rename to src/hooks/omit-query/omit-query.test.ts
index e46b96c7..cd391830 100755
--- a/test/hooks/discard-query.test.ts
+++ b/src/hooks/omit-query/omit-query.test.ts
@@ -1,36 +1,36 @@
-import { assert } from 'vitest';
-import { discardQuery } from '../../src';
+import { assert } from 'vitest'
+import { omitQuery } from './omit-query.js'
-let hookBefore: any;
-let hookAfter: any;
+let hookBefore: any
+let hookAfter: any
-describe('services discardQuery', () => {
+describe('omitQuery', () => {
describe('updates query', () => {
beforeEach(() => {
hookBefore = {
type: 'before',
method: 'create',
params: { query: { first: 'John', last: 'Doe' } },
- };
- hookAfter = { type: 'after', method: 'create', result: { first: 'Jane', last: 'Doe' } };
- });
+ }
+ hookAfter = { type: 'after', method: 'create', result: { first: 'Jane', last: 'Doe' } }
+ })
it('updates hook before::create', () => {
- discardQuery('last')(hookBefore);
- assert.deepEqual(hookBefore.params, { query: { first: 'John' } });
- });
+ omitQuery('last')(hookBefore)
+ assert.deepEqual(hookBefore.params, { query: { first: 'John' } })
+ })
it('throws on hook after', () => {
assert.throws(() => {
- discardQuery('last')(hookAfter);
- });
- });
+ omitQuery('last')(hookAfter)
+ })
+ })
it('does not throw if field is missing', () => {
- discardQuery('x', 'first')(hookBefore);
- assert.deepEqual(hookBefore.params.query, { last: 'Doe' });
- });
- });
+ omitQuery(['x', 'first'])(hookBefore)
+ assert.deepEqual(hookBefore.params.query, { last: 'Doe' })
+ })
+ })
describe('handles dot notation', () => {
beforeEach(() => {
@@ -40,46 +40,46 @@ describe('services discardQuery', () => {
params: {
query: { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
},
- };
- });
+ }
+ })
it('prop with no dots', () => {
- discardQuery('dept')(hookBefore);
+ omitQuery('dept')(hookBefore)
assert.deepEqual(hookBefore.params.query, {
empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
- });
- });
+ })
+ })
it('prop with 1 dot', () => {
- discardQuery('empl.status')(hookBefore);
+ omitQuery('empl.status')(hookBefore)
assert.deepEqual(hookBefore.params.query, {
empl: { name: { first: 'John', last: 'Doe' } },
dept: 'Acct',
- });
- });
+ })
+ })
it('prop with 2 dots', () => {
- discardQuery('empl.name.first')(hookBefore);
+ omitQuery('empl.name.first')(hookBefore)
assert.deepEqual(hookBefore.params.query, {
empl: { name: { last: 'Doe' }, status: 'AA' },
dept: 'Acct',
- });
- });
+ })
+ })
it('ignores bad or missing paths', () => {
- discardQuery('empl.xx.first')(hookBefore);
+ omitQuery('empl.xx.first')(hookBefore)
assert.deepEqual(hookBefore.params.query, {
empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
dept: 'Acct',
- });
- });
+ })
+ })
it('ignores bad or missing no dot path', () => {
- discardQuery('xx')(hookBefore);
+ omitQuery('xx')(hookBefore)
assert.deepEqual(hookBefore.params.query, {
empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
dept: 'Acct',
- });
- });
- });
-});
+ })
+ })
+ })
+})
diff --git a/src/hooks/omit-query/omit-query.ts b/src/hooks/omit-query/omit-query.ts
new file mode 100755
index 00000000..061c41b3
--- /dev/null
+++ b/src/hooks/omit-query/omit-query.ts
@@ -0,0 +1,20 @@
+import type { HookContext } from '@feathersjs/feathers'
+import _omit from 'lodash/omit.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+/**
+ * Delete certain fields from the query object.
+ * @see https://hooks-common.feathersjs.com/hooks.html#discardquery
+ */
+export const omitQuery =
+ (fieldNames: MaybeArray) =>
+ (context: H) => {
+ if (!context.params.query) {
+ return context
+ }
+
+ context.params.query = _omit(context.params.query, toArray(fieldNames))
+
+ return context
+ }
diff --git a/src/hooks/omit-result/omit-result-1.test.ts b/src/hooks/omit-result/omit-result-1.test.ts
new file mode 100755
index 00000000..a464253e
--- /dev/null
+++ b/src/hooks/omit-result/omit-result-1.test.ts
@@ -0,0 +1,86 @@
+import { assert } from 'vitest'
+import { omitResult } from './omit-result.js'
+
+describe('omitResult', () => {
+ describe('removes fields', () => {
+ const afterJane = (): any => ({ type: 'after', result: { first: 'Jane', last: 'Doe' } })
+ const afterBoth = (): any => ({
+ type: 'after',
+ result: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ })
+ const afterPage = (): any => ({
+ type: 'after',
+ result: {
+ total: 2,
+ skip: 0,
+ data: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ },
+ })
+
+ const decisionTable = [
+ [
+ 'after::find with paginate',
+ afterPage(),
+ 'find',
+ null,
+ ['last'],
+ [{ first: 'John' }, { first: 'Jane' }],
+ ],
+ [
+ 'after::find no paginate',
+ afterBoth(),
+ 'find',
+ null,
+ ['last'],
+ [{ first: 'John' }, { first: 'Jane' }],
+ ],
+ ['after', afterJane(), 'create', null, ['last'], { first: 'Jane' }],
+ ['call internally on server', afterJane(), 'create', undefined, ['last'], { first: 'Jane' }],
+ ]
+
+ decisionTable.forEach(([desc, context, method, provider, args, result]) => {
+ it(desc, () => {
+ context.method = method
+ if (provider !== null) {
+ context.params = context.params || {}
+ context.params.provider = provider
+ }
+
+ omitResult(args)(context)
+ assert.deepEqual(
+ context.data ? context.data : context.result.data || context.result,
+ result,
+ )
+ })
+ })
+ })
+
+ describe('handles dot notation', () => {
+ const ctx2 = (): any => ({
+ type: 'after',
+ method: 'get',
+ result: { property: null, foo: 'bar' },
+ })
+
+ const decisionTable = [
+ // desc, context, args, result
+ ['path not obj', ctx2(), ['property.secret'], { property: null, foo: 'bar' }],
+ ]
+
+ decisionTable.forEach(([desc, context, args, result]) => {
+ it(desc, () => {
+ omitResult(args)(context)
+ assert.deepEqual(
+ context.data ? context.data : context.result.data || context.result,
+ result,
+ )
+ })
+ })
+ })
+})
diff --git a/src/hooks/omit-result/omit-result-2.test.ts b/src/hooks/omit-result/omit-result-2.test.ts
new file mode 100755
index 00000000..feaa6bd5
--- /dev/null
+++ b/src/hooks/omit-result/omit-result-2.test.ts
@@ -0,0 +1,121 @@
+import { assert } from 'vitest'
+import { omitResult } from './omit-result.js'
+
+describe('omitResult', () => {
+ describe('removes fields', () => {
+ const afterJane = (): any => ({ type: 'after', result: { first: 'Jane', last: 'Doe' } })
+ const afterBoth = (): any => ({
+ type: 'after',
+ result: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ })
+ const afterPage = (): any => ({
+ type: 'after',
+ result: {
+ total: 2,
+ skip: 0,
+ data: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ },
+ })
+
+ const decisionTable = [
+ // desc, context, method, provider, args, result
+ [
+ 'after::find with paginate',
+ afterPage(),
+ 'find',
+ undefined,
+ ['last'],
+ [{ first: 'John' }, { first: 'Jane' }],
+ ],
+ [
+ 'after::find with paginate',
+ afterPage(),
+ 'find',
+ 'rest',
+ ['last'],
+ [{ first: 'John' }, { first: 'Jane' }],
+ ],
+ [
+ 'after::find with paginate',
+ afterPage(),
+ 'find',
+ 'socketio',
+ ['last'],
+ [{ first: 'John' }, { first: 'Jane' }],
+ ],
+ [
+ 'after::find no paginate',
+ afterBoth(),
+ 'find',
+ undefined,
+ ['last'],
+ [{ first: 'John' }, { first: 'Jane' }],
+ ],
+ [
+ 'after::find no paginate',
+ afterBoth(),
+ 'find',
+ 'rest',
+ ['last'],
+ [{ first: 'John' }, { first: 'Jane' }],
+ ],
+ [
+ 'after::find no paginate',
+ afterBoth(),
+ 'find',
+ 'socketio',
+ ['last'],
+ [{ first: 'John' }, { first: 'Jane' }],
+ ],
+ ['after', afterJane(), 'create', undefined, ['last'], { first: 'Jane' }],
+ ['after', afterJane(), 'create', 'rest', ['last'], { first: 'Jane' }],
+ ['after', afterJane(), 'create', 'socketio', ['last'], { first: 'Jane' }],
+ ['call internally on server', afterJane(), 'create', undefined, ['last'], { first: 'Jane' }],
+ ]
+
+ decisionTable.forEach(([desc, context, method, provider, args, result]) => {
+ it(desc, () => {
+ context.method = method
+ if (provider !== null) {
+ context.params = context.params || {}
+ context.params.provider = provider
+ }
+
+ omitResult(args)(context)
+ assert.deepEqual(
+ context.data ? context.data : context.result.data || context.result,
+ result,
+ )
+ })
+ })
+ })
+
+ describe('handles dot notation', () => {
+ const ctx2 = (): any => ({
+ type: 'after',
+ method: 'get',
+ result: { property: null, foo: 'bar' },
+ })
+
+ const decisionTable = [
+ // desc, context, args, result
+ ['path not obj', ctx2(), ['property.secret'], { property: null, foo: 'bar' }],
+ ]
+
+ decisionTable.forEach(([desc, context, args, result]) => {
+ it(desc, () => {
+ omitResult(args)(context)
+ assert.deepEqual(
+ context.data ? context.data : context.result.data || context.result,
+ result,
+ )
+ })
+ })
+ })
+})
diff --git a/src/hooks/omit-result/omit-result.md b/src/hooks/omit-result/omit-result.md
new file mode 100644
index 00000000..900657fc
--- /dev/null
+++ b/src/hooks/omit-result/omit-result.md
@@ -0,0 +1,9 @@
+---
+title: omitResult
+description: Omit certain fields from the result.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+ multi: true
+---
diff --git a/src/hooks/omit-result/omit-result.test.ts b/src/hooks/omit-result/omit-result.test.ts
new file mode 100755
index 00000000..2f101235
--- /dev/null
+++ b/src/hooks/omit-result/omit-result.test.ts
@@ -0,0 +1,109 @@
+import { assert } from 'vitest'
+import { omitResult } from './omit-result.js'
+
+let hookAfter: any
+let hookFindPaginate: any
+let hookFind: any
+
+describe('omitResult', () => {
+ describe('removes fields', () => {
+ beforeEach(() => {
+ hookAfter = {
+ type: 'after',
+ method: 'create',
+ params: { provider: 'rest' },
+ result: { first: 'Jane', last: 'Doe' },
+ }
+ hookFindPaginate = {
+ type: 'after',
+ method: 'find',
+ params: { provider: 'rest' },
+ result: {
+ total: 2,
+ data: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ },
+ }
+ hookFind = {
+ type: 'after',
+ method: 'find',
+ params: { provider: 'rest' },
+ result: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ }
+ })
+
+ it('updates hook after::find with pagination', () => {
+ omitResult('last')(hookFindPaginate)
+ assert.deepEqual(hookFindPaginate.result.data, [{ first: 'John' }, { first: 'Jane' }])
+ })
+
+ it('updates hook after::find with no pagination', () => {
+ omitResult('last')(hookFind)
+ assert.deepEqual(hookFind.result, [{ first: 'John' }, { first: 'Jane' }])
+ })
+
+ it('updates hook after', () => {
+ omitResult('last')(hookAfter)
+ assert.deepEqual(hookAfter.result, { first: 'Jane' })
+ })
+
+ it('updates when called internally on server', () => {
+ hookAfter.params.provider = ''
+ omitResult('last')(hookAfter)
+ assert.deepEqual(hookAfter.result, { first: 'Jane' })
+ })
+ })
+
+ describe('handles dot notation', () => {
+ it('discards multiple fields', () => {
+ const hook: any = {
+ type: 'after',
+ method: 'get',
+ result: {
+ roles: ['super'],
+ _id: 'a',
+ email: 'foo',
+ password: 'bar',
+ name: 'Rafael',
+ id: 'b',
+ },
+ query: {},
+ }
+
+ omitResult(['email', 'password'])(hook)
+
+ assert.deepEqual(hook.result, {
+ roles: ['super'],
+ _id: 'a',
+ // email: 'foo',
+ // password: 'bar',
+ name: 'Rafael',
+ id: 'b',
+ } as any)
+ })
+
+ it('null prop', () => {
+ const hook: any = {
+ type: 'after',
+ method: 'get',
+ result: {
+ property: null,
+ other: 'bar',
+ },
+ query: {},
+ }
+
+ omitResult('property.secret')(hook)
+
+ assert.deepEqual(hook.result, {
+ property: null,
+ other: 'bar',
+ })
+ })
+ })
+})
diff --git a/src/hooks/omit-result/omit-result.ts b/src/hooks/omit-result/omit-result.ts
new file mode 100755
index 00000000..5d24c965
--- /dev/null
+++ b/src/hooks/omit-result/omit-result.ts
@@ -0,0 +1,16 @@
+import _omit from 'lodash/omit.js'
+import { transformResult } from '../transform-result/transform-result.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+import type { DispatchOption } from '../../types.js'
+
+export type OmitResultOptions = {
+ dispatch?: DispatchOption
+}
+
+/**
+ * Delete certain fields from the record(s).
+ * @see https://hooks-common.feathersjs.com/hooks.html#discard
+ */
+export const omitResult = (fieldNames: MaybeArray, options?: OmitResultOptions) =>
+ transformResult((item: any) => _omit(item, toArray(fieldNames)), { dispatch: options?.dispatch })
diff --git a/src/hooks/on-delete/on-delete.test.ts b/src/hooks/on-delete/on-delete.test.ts
new file mode 100644
index 00000000..a12c50ae
--- /dev/null
+++ b/src/hooks/on-delete/on-delete.test.ts
@@ -0,0 +1,558 @@
+import assert from 'node:assert'
+import { feathers } from '@feathersjs/feathers'
+import { MemoryService } from '@feathersjs/memory'
+import { onDelete } from './on-delete.js'
+
+const mockApp = () => {
+ const app = feathers()
+
+ app.use('users', new MemoryService({ startId: 1, multi: true }))
+ app.use('todos', new MemoryService({ startId: 1, multi: true }))
+ app.use('tasks', new MemoryService({ startId: 1, multi: true }))
+
+ const usersService = app.service('users')
+ const todosService = app.service('todos')
+ const tasksService = app.service('tasks')
+
+ return {
+ app,
+ todosService,
+ usersService,
+ tasksService,
+ }
+}
+
+describe('hook - onDelete', function () {
+ describe('cascade', function () {
+ it('removes single item for single item', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'cascade',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ const user = await usersService.create({
+ name: 'John Doe',
+ })
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: user.id,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ await usersService.remove(user.id)
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [{ id: 2, title: 'Buy eggs', userId: 2 }])
+ })
+
+ it('removes multiple items for single item', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'cascade',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ const user = await usersService.create({
+ name: 'John Doe',
+ })
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: user.id,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: user.id,
+ })
+
+ const todo3 = await todosService.create({
+ title: 'Buy bread',
+ userId: 3,
+ })
+
+ await usersService.remove(user.id)
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [{ id: 3, title: 'Buy bread', userId: 3 }])
+ })
+
+ it('removes single item for multiple items', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'cascade',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ await usersService.create([{ name: 'John Doe' }, { name: 'Jane Doe' }, { name: 'Jack Doe' }])
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: 1,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ const todo3 = await todosService.create({
+ title: 'Buy bread',
+ userId: 3,
+ })
+
+ await usersService.remove(1)
+
+ const users = await usersService.find({ query: {} })
+
+ assert.deepStrictEqual(users, [
+ { id: 2, name: 'Jane Doe' },
+ { id: 3, name: 'Jack Doe' },
+ ])
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 2, title: 'Buy eggs', userId: 2 },
+ { id: 3, title: 'Buy bread', userId: 3 },
+ ])
+ })
+
+ it('removes multiple items for multiple items', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'cascade',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ await usersService.create([{ name: 'John Doe' }, { name: 'Jane Doe' }, { name: 'Jack Doe' }])
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: 1,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ const todo3 = await todosService.create({
+ title: 'Buy bread',
+ userId: 3,
+ })
+
+ await usersService.remove(null, { query: { id: { $in: [1, 2] } } })
+
+ const users = await usersService.find({ query: {} })
+
+ assert.deepStrictEqual(users, [{ id: 3, name: 'Jack Doe' }])
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [{ id: 3, title: 'Buy bread', userId: 3 }])
+ })
+
+ it('does not remove items if not found', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'cascade',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ await usersService.create([{ name: 'John Doe' }, { name: 'Jane Doe' }, { name: 'Jack Doe' }])
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: 2,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ const todo3 = await todosService.create({
+ title: 'Buy bread',
+ userId: 3,
+ })
+
+ await usersService.remove(1)
+
+ const users = await usersService.find({ query: {} })
+
+ assert.deepStrictEqual(users, [
+ { id: 2, name: 'Jane Doe' },
+ { id: 3, name: 'Jack Doe' },
+ ])
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 'Buy milk', userId: 2 },
+ { id: 2, title: 'Buy eggs', userId: 2 },
+ { id: 3, title: 'Buy bread', userId: 3 },
+ ])
+ })
+
+ it('can pass an array', async function () {
+ const { app, usersService, todosService, tasksService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete([
+ {
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'cascade',
+ blocking: true,
+ },
+ {
+ service: 'tasks',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'cascade',
+ blocking: true,
+ },
+ ]),
+ ],
+ },
+ })
+
+ const user = await usersService.create({
+ name: 'John Doe',
+ })
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: user.id,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ const task = await tasksService.create({
+ title: 'Buy milk task',
+ userId: user.id,
+ })
+
+ const task2 = await tasksService.create({
+ title: 'Buy eggs task',
+ userId: 2,
+ })
+
+ await usersService.remove(user.id)
+
+ const todos = await todosService.find({ query: {} })
+ assert.deepStrictEqual(todos, [{ id: 2, title: 'Buy eggs', userId: 2 }])
+
+ const tasks = await tasksService.find({ query: {} })
+ assert.deepStrictEqual(tasks, [{ id: 2, title: 'Buy eggs task', userId: 2 }])
+ })
+ })
+
+ describe('set null', function () {
+ it('sets null single item for single item', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'set null',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ const user = await usersService.create({
+ name: 'John Doe',
+ })
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: user.id,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ await usersService.remove(user.id)
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 'Buy milk', userId: null },
+ { id: 2, title: 'Buy eggs', userId: 2 },
+ ])
+ })
+
+ it('sets null multiple items for single item', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'set null',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ const user = await usersService.create({
+ name: 'John Doe',
+ })
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: user.id,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: user.id,
+ })
+
+ const todo3 = await todosService.create({
+ title: 'Buy bread',
+ userId: 3,
+ })
+
+ await usersService.remove(user.id)
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 'Buy milk', userId: null },
+ { id: 2, title: 'Buy eggs', userId: null },
+ { id: 3, title: 'Buy bread', userId: 3 },
+ ])
+ })
+
+ it('sets null single item for multiple items', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'set null',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ await usersService.create([{ name: 'John Doe' }, { name: 'Jane Doe' }, { name: 'Jack Doe' }])
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: 1,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ const todo3 = await todosService.create({
+ title: 'Buy bread',
+ userId: 3,
+ })
+
+ await usersService.remove(1)
+
+ const users = await usersService.find({ query: {} })
+
+ assert.deepStrictEqual(users, [
+ { id: 2, name: 'Jane Doe' },
+ { id: 3, name: 'Jack Doe' },
+ ])
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 'Buy milk', userId: null },
+ { id: 2, title: 'Buy eggs', userId: 2 },
+ { id: 3, title: 'Buy bread', userId: 3 },
+ ])
+ })
+
+ it('sets null multiple items for multiple items', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'set null',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ await usersService.create([{ name: 'John Doe' }, { name: 'Jane Doe' }, { name: 'Jack Doe' }])
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: 1,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ const todo3 = await todosService.create({
+ title: 'Buy bread',
+ userId: 3,
+ })
+
+ await usersService.remove(null, { query: { id: { $in: [1, 2] } } })
+
+ const users = await usersService.find({ query: {} })
+
+ assert.deepStrictEqual(users, [{ id: 3, name: 'Jack Doe' }])
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 'Buy milk', userId: null },
+ { id: 2, title: 'Buy eggs', userId: null },
+ { id: 3, title: 'Buy bread', userId: 3 },
+ ])
+ })
+
+ it('does not set null for items if not found', async function () {
+ const { app, usersService, todosService } = mockApp()
+
+ usersService.hooks({
+ after: {
+ remove: [
+ onDelete({
+ service: 'todos',
+ keyThere: 'userId',
+ keyHere: 'id',
+ onDelete: 'cascade',
+ blocking: true,
+ }),
+ ],
+ },
+ })
+
+ await usersService.create([{ name: 'John Doe' }, { name: 'Jane Doe' }, { name: 'Jack Doe' }])
+
+ const todo = await todosService.create({
+ title: 'Buy milk',
+ userId: 2,
+ })
+
+ const todo2 = await todosService.create({
+ title: 'Buy eggs',
+ userId: 2,
+ })
+
+ const todo3 = await todosService.create({
+ title: 'Buy bread',
+ userId: 3,
+ })
+
+ await usersService.remove(1)
+
+ const users = await usersService.find({ query: {} })
+
+ assert.deepStrictEqual(users, [
+ { id: 2, name: 'Jane Doe' },
+ { id: 3, name: 'Jack Doe' },
+ ])
+
+ const todos = await todosService.find({ query: {} })
+
+ assert.deepStrictEqual(todos, [
+ { id: 1, title: 'Buy milk', userId: 2 },
+ { id: 2, title: 'Buy eggs', userId: 2 },
+ { id: 3, title: 'Buy bread', userId: 3 },
+ ])
+ })
+ })
+})
diff --git a/src/hooks/on-delete/on-delete.ts b/src/hooks/on-delete/on-delete.ts
new file mode 100644
index 00000000..d233087b
--- /dev/null
+++ b/src/hooks/on-delete/on-delete.ts
@@ -0,0 +1,78 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { checkContext, getResultIsArray } from '../../utils/index.js'
+import type { KeyOf, MaybeArray } from '../../internal.utils.js'
+
+export type OnDeleteAction = 'cascade' | 'set null'
+
+export interface OnDeleteOptions {
+ service: Path
+ keyThere: string
+ keyHere: string
+ onDelete: OnDeleteAction
+ /**
+ * If true, the hook will wait for the service to finish before continuing
+ *
+ * @default false
+ */
+ blocking?: boolean
+}
+
+/**
+ * hook to manipulate related items on delete
+ */
+export const onDelete = , H extends HookContext = HookContext>(
+ options: MaybeArray>>,
+) => {
+ const optionsMulti = Array.isArray(options) ? options : [options]
+
+ return async (context: H, next?: NextFunction) => {
+ checkContext(context, ['after', 'around'], 'remove', 'onDelete')
+
+ if (next) {
+ await next()
+ }
+
+ const { result } = getResultIsArray(context)
+
+ if (!result.length) {
+ return context
+ }
+
+ const promises: Promise[] = []
+
+ optionsMulti.forEach(async ({ keyHere, keyThere, onDelete, service, blocking }) => {
+ let ids = result.map(x => x[keyHere]).filter(x => !!x)
+ ids = [...new Set(ids)]
+
+ if (!ids || ids.length <= 0) {
+ return context
+ }
+
+ const params = {
+ query: {
+ ...(ids.length === 1 ? { [keyThere]: ids[0] } : { [keyThere]: { $in: ids } }),
+ },
+ paginate: false,
+ }
+
+ let promise: Promise | undefined = undefined
+
+ if (onDelete === 'cascade') {
+ promise = context.app.service(service as string).remove(null, params)
+ } else if (onDelete === 'set null') {
+ const data = { [keyThere]: null }
+ promise = context.app.service(service as string).patch(null, data, params)
+ }
+
+ if (promise && blocking) {
+ promises.push(promise)
+ }
+ })
+
+ if (promises.length) {
+ await Promise.all(promises)
+ }
+
+ return context
+ }
+}
diff --git a/src/hooks/params-for-server/params-for-from-shared.ts b/src/hooks/params-for-server/params-for-from-shared.ts
new file mode 100644
index 00000000..eae3bfe5
--- /dev/null
+++ b/src/hooks/params-for-server/params-for-from-shared.ts
@@ -0,0 +1 @@
+export const FROM_CLIENT_FOR_SERVER_DEFAULT_KEY = '_$client' as const
diff --git a/src/hooks/params-for-server/params-for-server.md b/src/hooks/params-for-server/params-for-server.md
new file mode 100644
index 00000000..39656020
--- /dev/null
+++ b/src/hooks/params-for-server/params-for-server.md
@@ -0,0 +1,9 @@
+---
+title: paramsForServer
+description: Add or modify parameters for the server.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
diff --git a/src/hooks/params-for-server/params-for-server.test.ts b/src/hooks/params-for-server/params-for-server.test.ts
new file mode 100644
index 00000000..4ee91366
--- /dev/null
+++ b/src/hooks/params-for-server/params-for-server.test.ts
@@ -0,0 +1,46 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { paramsForServer } from './params-for-server.js'
+
+describe('paramsForServer', () => {
+ it('should move params to query._$client', () => {
+ expect(
+ paramsForServer(['a', 'b'])({
+ params: {
+ a: 1,
+ b: 2,
+ query: {},
+ },
+ } as HookContext),
+ ).toEqual({
+ params: {
+ query: {
+ _$client: {
+ a: 1,
+ b: 2,
+ },
+ },
+ },
+ })
+ })
+
+ it('should move params to query._$client and leave remaining', () => {
+ expect(
+ paramsForServer('a')({
+ params: {
+ a: 1,
+ b: 2,
+ query: {},
+ },
+ } as HookContext),
+ ).toEqual({
+ params: {
+ b: 2,
+ query: {
+ _$client: {
+ a: 1,
+ },
+ },
+ },
+ })
+ })
+})
diff --git a/src/hooks/params-for-server/params-for-server.ts b/src/hooks/params-for-server/params-for-server.ts
new file mode 100644
index 00000000..91c6b141
--- /dev/null
+++ b/src/hooks/params-for-server/params-for-server.ts
@@ -0,0 +1,65 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+import { FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } from './params-for-from-shared.js'
+
+export type ParamsForServerOptions = {
+ /**
+ * @default '_$client'
+ */
+ keyToHide?: string
+}
+
+/**
+ * a hook to move params to query._$client
+ * the server only receives 'query' from params. All other params are ignored.
+ * So, to use `$populateParams` on the server, we need to move the params to query._$client
+ * the server will move them back to params
+ */
+export const paramsForServer = (
+ whitelist: MaybeArray,
+ options?: ParamsForServerOptions,
+) => {
+ const whitelistArr = toArray(whitelist)
+
+ const { keyToHide = FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } = options || {}
+
+ return (context: H, next?: NextFunction) => {
+ // clone params on demand
+ let clonedParams: any
+
+ Object.keys(context.params).forEach(key => {
+ if (key === 'query') {
+ return
+ }
+
+ if (whitelistArr.includes(key)) {
+ if (!clonedParams) {
+ clonedParams = {
+ ...context.params,
+ query: {
+ ...context.params.query,
+ },
+ }
+ }
+
+ if (!clonedParams.query[keyToHide]) {
+ clonedParams.query[keyToHide] = {}
+ }
+
+ clonedParams.query[keyToHide][key] = clonedParams[key]
+ delete clonedParams[key]
+ }
+ })
+
+ if (clonedParams) {
+ context.params = clonedParams
+ }
+
+ if (next) {
+ return next()
+ }
+
+ return context
+ }
+}
diff --git a/src/hooks/params-from-client.ts b/src/hooks/params-from-client.ts
deleted file mode 100755
index 9c0a53b7..00000000
--- a/src/hooks/params-from-client.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Pass context.params from client to server. Server hook.
- * @see https://hooks-common.feathersjs.com/hooks.html#paramsfromclient
- */
-export function paramsFromClient(...whitelist: string[]) {
- return (context: H) => {
- const params = context.params;
-
- if (params?.query?.$client && typeof params.query.$client === 'object') {
- const client = params.query.$client;
-
- whitelist.forEach(key => {
- if (key in client) {
- // @ts-ignore
- params[key] = client[key];
- }
- });
-
- params.query = Object.assign({}, params.query);
- delete params.query.$client;
- }
-
- return context;
- };
-}
diff --git a/src/hooks/params-from-client/params-from-client.md b/src/hooks/params-from-client/params-from-client.md
new file mode 100644
index 00000000..43d1c552
--- /dev/null
+++ b/src/hooks/params-from-client/params-from-client.md
@@ -0,0 +1,46 @@
+---
+title: paramsFromClient
+description: Pass `context.params` from client to server. Server hook.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['all']
+ multi: true
+---
+
+## Arguments
+
+- `{Array< String > | String} whitelist`
+
+| Argument | Type | Default | Description |
+| ----------- | :----------: | ------- | ------------------------------------------------------------------------------------------------------------ |
+| `whitelist` | dot notation | | Names of the props permitted to be in `context.params`. Other props are ignored. This is a security feature. |
+
+## Example
+
+```js
+// client
+const { paramsForServer } = require('feathers-hooks-common/index.js');
+
+service.update(
+ id,
+ data,
+ paramsForServer({ query: { dept: 'a' }, populate: 'po-1', serialize: 'po-mgr' }),
+);
+
+// server
+const { paramsFromClient } = require('feathers-hooks-common/index.js');
+
+module.exports = {
+ before: { all: [paramsFromClient('populate', 'serialize', 'otherProp'), myHook] },
+};
+
+// myHook's `context.params` will now be
+// { query: { dept: 'a' }, populate: 'po-1', serialize: 'po-mgr' } }
+```
+
+## Details
+
+By default, only the `context.params.query` object is transferred from a Feathers client to the server, for security among other reasons. However you can explicitly transfer other `context.params` props with the client utility function `paramsForServer` in conjunction with the `paramsFromClient` hook on the server.
+
+This technique also works for service calls made on the server.
diff --git a/src/hooks/params-from-client/params-from-client.test.ts b/src/hooks/params-from-client/params-from-client.test.ts
new file mode 100644
index 00000000..4f0a0252
--- /dev/null
+++ b/src/hooks/params-from-client/params-from-client.test.ts
@@ -0,0 +1,54 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { paramsFromClient } from './params-from-client.js'
+
+describe('paramsFromClient', () => {
+ it('should move params to query._$client', () => {
+ expect(
+ paramsFromClient(['a', 'b'])({
+ params: {
+ query: {
+ _$client: {
+ a: 1,
+ b: 2,
+ },
+ c: 3,
+ },
+ },
+ } as HookContext),
+ ).toEqual({
+ params: {
+ a: 1,
+ b: 2,
+ query: {
+ c: 3,
+ },
+ },
+ })
+ })
+
+ it('should move params to query._$client and leave remaining', () => {
+ expect(
+ paramsFromClient('a')({
+ params: {
+ query: {
+ _$client: {
+ a: 1,
+ b: 2,
+ },
+ c: 3,
+ },
+ },
+ } as HookContext),
+ ).toEqual({
+ params: {
+ a: 1,
+ query: {
+ _$client: {
+ b: 2,
+ },
+ c: 3,
+ },
+ },
+ })
+ })
+})
diff --git a/src/hooks/params-from-client/params-from-client.ts b/src/hooks/params-from-client/params-from-client.ts
new file mode 100644
index 00000000..ce8b44b2
--- /dev/null
+++ b/src/hooks/params-from-client/params-from-client.ts
@@ -0,0 +1,58 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+import { FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } from '../params-for-server/params-for-from-shared.js'
+
+export type paramsFromClientOptions = {
+ /**
+ * @default '_$client'
+ */
+ keyToHide?: string
+}
+
+export const paramsFromClient = (
+ whitelist: MaybeArray,
+ options?: paramsFromClientOptions,
+) => {
+ const whitelistArr = toArray(whitelist)
+ const { keyToHide = FROM_CLIENT_FOR_SERVER_DEFAULT_KEY } = options || {}
+ return (context: HookContext, next?: NextFunction) => {
+ if (
+ !context.params?.query?.[keyToHide] ||
+ typeof context.params.query[keyToHide] !== 'object'
+ ) {
+ return context
+ }
+
+ const params = {
+ ...context.params,
+ query: {
+ ...context.params.query,
+ [keyToHide]: {
+ ...context.params.query[keyToHide],
+ },
+ },
+ }
+
+ const client = params.query[keyToHide]
+
+ whitelistArr.forEach(key => {
+ if (key in client) {
+ params[key] = client[key]
+ delete client[key]
+ }
+ })
+
+ if (Object.keys(client).length === 0) {
+ delete params.query[keyToHide]
+ }
+
+ context.params = params
+
+ if (next) {
+ return next()
+ }
+
+ return context
+ }
+}
diff --git a/src/hooks/pick-data/pick-data.md b/src/hooks/pick-data/pick-data.md
new file mode 100644
index 00000000..2762e38f
--- /dev/null
+++ b/src/hooks/pick-data/pick-data.md
@@ -0,0 +1,31 @@
+---
+title: pickData
+description: Keep certain fields in the record(s), deleting the rest.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
+
+> **Note:** The keep hook will remove any fields not specified even if the service is being called from the server. You may want to condition the hook to run only for external transports, e.g. `iff(isProvider('external'), keep(...))`.
+
+- Arguments
+ - `{Array < String >} fieldNames`
+
+| Name | Type | Description |
+| ---------- | ------------ | -------------------------------------------------- |
+| fieldNames | dot notation | The only fields you want to keep in the record(s). |
+
+## Example
+
+```js
+const { keep } = require('feathers-hooks-common/index.js');
+
+module.exports = { after: { create: keep('name', 'dept', 'address.city') } };
+```
+
+## Details
+
+Update either `context.data` (before hook) or `context.result[.data]` (after hook).
+Their values are returned if they are not an object, so a `null` value is supported.
diff --git a/src/hooks/pick-data/pick-data.test.ts b/src/hooks/pick-data/pick-data.test.ts
new file mode 100755
index 00000000..5757f491
--- /dev/null
+++ b/src/hooks/pick-data/pick-data.test.ts
@@ -0,0 +1,153 @@
+import { assert } from 'vitest'
+import { pickData } from './pick-data.js'
+
+let hookBefore: any
+
+describe('pickData', () => {
+ describe('removes fields', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: 'John', last: 'Doe' },
+ }
+ })
+
+ it('does not throw if field is missing', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: 'John', last: 'Doe' },
+ }
+ pickData(['last', 'xx'])(hook)
+ assert.deepEqual(hook.data, { last: 'Doe' })
+ })
+
+ it('keeps undefined values', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: undefined, last: 'Doe' },
+ }
+ pickData('first')(hook)
+ assert.deepEqual(hook.data, { first: undefined })
+ })
+
+ it('keeps null values', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: null, last: 'Doe' },
+ }
+ pickData('first')(hook)
+ assert.deepEqual(hook.data, { first: null })
+ })
+
+ it('keeps false values', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: false, last: 'Doe' },
+ }
+ pickData('first')(hook)
+ assert.deepEqual(hook.data, { first: false })
+ })
+
+ it('keeps 0 values', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: 0, last: 'Doe' },
+ }
+ pickData('first')(hook)
+ assert.deepEqual(hook.data, { first: 0 })
+ })
+
+ it('keeps empty string values', () => {
+ const hook: any = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: '', last: 'Doe' },
+ }
+ pickData('first')(hook)
+ assert.deepEqual(hook.data, { first: '' })
+ })
+ })
+
+ describe('handles dot notation', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
+ }
+ })
+
+ it('prop with no dots', () => {
+ pickData('empl')(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ })
+ })
+
+ it('prop with 1 dot', () => {
+ pickData(['empl.name', 'dept'])(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' } },
+ dept: 'Acct',
+ })
+ })
+
+ it('prop with 2 dots', () => {
+ pickData(['empl.name.last', 'empl.status', 'dept'])(hookBefore)
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+
+ it('ignores bad or missing paths', () => {
+ pickData(['empl.name.first', 'empl.name.surname'])(hookBefore)
+ assert.deepEqual(hookBefore.data, { empl: { name: { first: 'John' } } })
+ })
+
+ it('ignores bad or missing no dot path', () => {
+ pickData('xx')(hookBefore)
+ assert.deepEqual(hookBefore.data, {})
+ })
+ })
+
+ describe('ignore non-object records', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: [
+ { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
+ null,
+ undefined,
+ Infinity,
+ ],
+ }
+ })
+
+ it('before', () => {
+ pickData('empl')(hookBefore)
+ assert.deepEqual(hookBefore.data, [
+ { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' } },
+ null,
+ undefined,
+ Infinity,
+ ])
+ })
+ })
+})
diff --git a/src/hooks/pick-data/pick-data.ts b/src/hooks/pick-data/pick-data.ts
new file mode 100755
index 00000000..87fd9ce9
--- /dev/null
+++ b/src/hooks/pick-data/pick-data.ts
@@ -0,0 +1,17 @@
+import _pick from 'lodash/pick.js'
+import { transformData } from '../transform-data/transform-data.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+/**
+ * Keep certain fields in the record(s), deleting the rest.
+ * @see https://hooks-common.feathersjs.com/hooks.html#keep
+ */
+export const pickData = (fieldNames: MaybeArray) => {
+ const fieldNamesArr = toArray(fieldNames)
+ return transformData((item: any) => {
+ if (typeof item !== 'object' || item === null) return item
+
+ return _pick(item, fieldNamesArr)
+ })
+}
diff --git a/src/hooks/pick-query/pick-query.md b/src/hooks/pick-query/pick-query.md
new file mode 100644
index 00000000..b77de53c
--- /dev/null
+++ b/src/hooks/pick-query/pick-query.md
@@ -0,0 +1,30 @@
+---
+title: pickQuery
+description: Keep certain fields in the query object, deleting the rest.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
+
+> **Note:** The keepQuery hook will remove any fields not specified even if the service is being called from the server. You may want to condition the hook to run only for external transports, e.g. `iff(isProvider('external'), keepQuery(...))`.
+
+- Arguments
+ - `{Array < String >} fieldNames`
+
+| Name | Type | Description |
+| ---------- | ------------ | ----------------------------------------------------- |
+| fieldNames | dot notation | The only fields you want to keep in the query object. |
+
+## Example
+
+```js
+const { keepQuery } = require('feathers-hooks-common/index.js');
+
+module.exports = { after: { create: keepQuery('name', 'address.city') } };
+```
+
+## Details
+
+Updates `context.params.query`.
diff --git a/test/hooks/keep-query.test.ts b/src/hooks/pick-query/pick-query.test.ts
similarity index 64%
rename from test/hooks/keep-query.test.ts
rename to src/hooks/pick-query/pick-query.test.ts
index 70f3c3aa..b92ec5f9 100755
--- a/test/hooks/keep-query.test.ts
+++ b/src/hooks/pick-query/pick-query.test.ts
@@ -1,41 +1,41 @@
-import { assert } from 'vitest';
-import { keepQuery } from '../../src';
+import { assert } from 'vitest'
+import { pickQuery } from './pick-query.js'
-let hookBefore: any;
-let hookAfter: any;
+let hookBefore: any
+let hookAfter: any
-describe('services keepQuery', () => {
+describe('pickQuery', () => {
describe('updates query', () => {
beforeEach(() => {
hookBefore = {
type: 'before',
method: 'create',
params: { query: { first: 'John', last: 'Doe' } },
- };
- hookAfter = { type: 'after', method: 'create', result: { first: 'Jane', last: 'Doe' } };
- });
+ }
+ hookAfter = { type: 'after', method: 'create', result: { first: 'Jane', last: 'Doe' } }
+ })
it('updates hook before::create', () => {
- keepQuery('first', 'last')(hookBefore);
- assert.deepEqual(hookBefore.params, { query: { first: 'John', last: 'Doe' } });
- });
+ pickQuery(['first', 'last'])(hookBefore)
+ assert.deepEqual(hookBefore.params, { query: { first: 'John', last: 'Doe' } })
+ })
it('updates hook before::create', () => {
- keepQuery('first')(hookBefore);
- assert.deepEqual(hookBefore.params, { query: { first: 'John' } });
- });
+ pickQuery('first')(hookBefore)
+ assert.deepEqual(hookBefore.params, { query: { first: 'John' } })
+ })
it('throws on hook after', () => {
assert.throws(() => {
- keepQuery('last')(hookAfter);
- });
- });
+ pickQuery('last')(hookAfter)
+ })
+ })
it('does not throw if field is missing', () => {
- keepQuery('x', 'last')(hookBefore);
- assert.deepEqual(hookBefore.params.query, { last: 'Doe' });
- });
- });
+ pickQuery(['x', 'last'])(hookBefore)
+ assert.deepEqual(hookBefore.params.query, { last: 'Doe' })
+ })
+ })
describe('handles dot notation', () => {
beforeEach(() => {
@@ -50,42 +50,42 @@ describe('services keepQuery', () => {
'owner.admin': false,
},
},
- };
- });
+ }
+ })
it('prop with no dots', () => {
- keepQuery('empl')(hookBefore);
+ pickQuery('empl')(hookBefore)
assert.deepEqual(hookBefore.params.query, {
empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
- });
- });
+ })
+ })
it('prop with 1 dot', () => {
- keepQuery('empl.name', 'dept', 'owner.id', 'owner.admin')(hookBefore);
+ pickQuery(['empl.name', 'dept', 'owner.id', 'owner.admin'])(hookBefore)
assert.deepEqual(hookBefore.params.query, {
empl: { name: { first: 'John', last: 'Doe' } },
dept: 'Acct',
'owner.id': 1,
'owner.admin': false,
- });
- });
+ })
+ })
it('prop with 2 dots', () => {
- keepQuery('empl.name.last', 'empl.status', 'dept')(hookBefore);
+ pickQuery(['empl.name.last', 'empl.status', 'dept'])(hookBefore)
assert.deepEqual(hookBefore.params.query, {
empl: { name: { last: 'Doe' }, status: 'AA' },
dept: 'Acct',
- });
- });
+ })
+ })
it('ignores bad or missing paths', () => {
- keepQuery('empl.xx.first')(hookBefore);
- assert.deepEqual(hookBefore.params.query, {});
- });
+ pickQuery('empl.xx.first')(hookBefore)
+ assert.deepEqual(hookBefore.params.query, {})
+ })
it('ignores bad or missing no dot path', () => {
- keepQuery('xx')(hookBefore);
- assert.deepEqual(hookBefore.params.query, {});
- });
- });
-});
+ pickQuery('xx')(hookBefore)
+ assert.deepEqual(hookBefore.params.query, {})
+ })
+ })
+})
diff --git a/src/hooks/pick-query/pick-query.ts b/src/hooks/pick-query/pick-query.ts
new file mode 100755
index 00000000..fec27ba9
--- /dev/null
+++ b/src/hooks/pick-query/pick-query.ts
@@ -0,0 +1,23 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import _pick from 'lodash/pick.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+/**
+ * Keep certain fields in the query object, deleting the rest.
+ * @see https://hooks-common.feathersjs.com/hooks.html#keepquery
+ */
+export const pickQuery = (fieldNames: MaybeArray) => {
+ const fieldNamesArr = toArray(fieldNames)
+ return (context: H, next?: NextFunction) => {
+ if (!context.params.query) {
+ return context
+ }
+
+ context.params.query = _pick(context.params.query, fieldNamesArr)
+
+ if (next) return next().then(() => context)
+
+ return context
+ }
+}
diff --git a/src/hooks/pick-result/pick-result.md b/src/hooks/pick-result/pick-result.md
new file mode 100644
index 00000000..ebd11870
--- /dev/null
+++ b/src/hooks/pick-result/pick-result.md
@@ -0,0 +1,9 @@
+---
+title: pickResult
+description: Pick certain fields from the result.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+ multi: true
+---
diff --git a/src/hooks/pick-result/pick-result.test.ts b/src/hooks/pick-result/pick-result.test.ts
new file mode 100755
index 00000000..3ea24504
--- /dev/null
+++ b/src/hooks/pick-result/pick-result.test.ts
@@ -0,0 +1,77 @@
+import { assert } from 'vitest'
+import { pickResult } from './pick-result.js'
+
+let hookAfter: any
+let hookFindPaginate: any
+let hookFind: any
+
+describe('pickResult', () => {
+ describe('removes fields', () => {
+ beforeEach(() => {
+ hookAfter = {
+ type: 'after',
+ method: 'create',
+ params: { provider: 'rest' },
+ result: { first: 'Jane', last: 'Doe' },
+ }
+ hookFindPaginate = {
+ type: 'after',
+ method: 'find',
+ params: { provider: 'rest' },
+ result: {
+ total: 2,
+ data: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ },
+ }
+ hookFind = {
+ type: 'after',
+ method: 'find',
+ params: { provider: 'rest' },
+ result: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ }
+ })
+
+ it('updates hook after::find with pagination', () => {
+ pickResult('first')(hookFindPaginate)
+ assert.deepEqual(hookFindPaginate.result.data, [{ first: 'John' }, { first: 'Jane' }])
+ })
+
+ it('updates hook after::find with no pagination', () => {
+ pickResult('first')(hookFind)
+ assert.deepEqual(hookFind.result, [{ first: 'John' }, { first: 'Jane' }])
+ })
+
+ it('updates hook after', () => {
+ pickResult('first')(hookAfter)
+ assert.deepEqual(hookAfter.result, { first: 'Jane' })
+ })
+
+ it('updates when called internally on server', () => {
+ hookAfter.params.provider = ''
+ pickResult('first')(hookAfter)
+ assert.deepEqual(hookAfter.result, { first: 'Jane' })
+ })
+ })
+
+ describe('ignore non-object records', () => {
+ beforeEach(() => {
+ hookAfter = {
+ type: 'after',
+ method: 'create',
+ params: { provider: 'rest' },
+ result: [{ first: 'Jane', last: 'Doe' }, null, undefined, Infinity],
+ }
+ })
+
+ it('after', () => {
+ pickResult('first')(hookAfter)
+ assert.deepEqual(hookAfter.result, [{ first: 'Jane' }, null, undefined, Infinity])
+ })
+ })
+})
diff --git a/src/hooks/pick-result/pick-result.ts b/src/hooks/pick-result/pick-result.ts
new file mode 100755
index 00000000..8ee0e37a
--- /dev/null
+++ b/src/hooks/pick-result/pick-result.ts
@@ -0,0 +1,26 @@
+import _pick from 'lodash/pick.js'
+
+import { transformResult } from '../transform-result/transform-result.js'
+import type { DispatchOption } from '../../types.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+export type PickResultOptions = {
+ dispatch?: DispatchOption
+}
+
+/**
+ * Keep certain fields in the record(s), deleting the rest.
+ * @see https://hooks-common.feathersjs.com/hooks.html#keep
+ */
+export const pickResult = (fieldNames: MaybeArray, options?: PickResultOptions) => {
+ const fieldNamesArr = toArray(fieldNames)
+ return transformResult(
+ (item: any) => {
+ if (typeof item !== 'object' || item === null) return item
+
+ return _pick(item, fieldNamesArr)
+ },
+ { dispatch: options?.dispatch },
+ )
+}
diff --git a/src/hooks/populate.ts b/src/hooks/populate.ts
deleted file mode 100755
index 65f46350..00000000
--- a/src/hooks/populate.ts
+++ /dev/null
@@ -1,352 +0,0 @@
-import _get from 'lodash/get.js';
-import _set from 'lodash/set.js';
-import { BadRequest } from '@feathersjs/errors';
-
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-import type { HookContext } from '@feathersjs/feathers';
-
-export interface PopulateOptions {
- schema:
- | Partial
- | ((context: H, options: PopulateOptions) => Partial);
- checkPermissions?: (context: H, path: string, permissions: any, depth: number) => boolean;
- profile?: boolean;
-}
-
-export interface PopulateSchema {
- /**
- * The name of the service providing the items, actually its path.
- */
- service: string;
- /**
- * Where to place the items from the join
- * dot notation
- */
- nameAs: string;
- /**
- * The name of the field in the parent item for the relation.
- * dot notation
- */
- parentField: string;
- /**
- * The name of the field in the child item for the relation.
- * Dot notation is allowed and will result in a query like { 'name.first': 'John' } which is not suitable for all DBs.
- * You may use query or select to create a query suitable for your DB.
- */
- childField: string;
-
- /**
- * Who is allowed to perform this join. See checkPermissions above.
- */
- permissions: any;
-
- /**
- * An object to inject into context.params.query.
- */
- query: any;
-
- /**
- * A function whose result is injected into the query.
- */
- select: (context: HookContext, parentItem: any, depth: number) => any;
-
- /**
- * Force a single joined item to be stored as an array.
- */
- asArray: boolean;
-
- /**
- * Controls pagination for this service.
- */
- paginate: boolean | number;
-
- /**
- * Perform any populate or fastJoin registered on this service.
- */
- useInnerPopulate: boolean;
- /**
- * Call the service as the server, not with the client’s transport.
- */
- provider: string;
- include: Partial | Partial[];
-}
-
-export function populate(options: PopulateOptions) {
- // options.schema is like { service: '...', permissions: '...', include: [ ... ] }
-
- const typeofSchema = typeof options.schema;
- if ((typeofSchema !== 'object' || options.schema === null) && typeofSchema !== 'function') {
- throw new Error('Options.schema is not an object. (populate)');
- }
-
- return function (context: H) {
- const optionsDefault: PopulateOptions = {
- schema: {},
- checkPermissions: () => true,
- profile: false,
- };
-
- // @ts-ignore
- if (context.params._populate === 'skip') {
- // this service call made from another populate
- return context;
- }
-
- return Promise.resolve()
- .then(() => {
- // 'options.schema' resolves to { permissions: '...', include: [ ... ] }
-
- const items = getItems(context);
- const options1 = Object.assign({}, optionsDefault, options);
- const { schema, checkPermissions } = options1;
-
- const schema1 = typeof schema === 'function' ? schema(context, options1) : schema;
- const permissions = schema1.permissions || null;
- const baseService = schema1.service;
- const provider = 'provider' in schema1 ? schema1.provider : context.params.provider;
-
- if (typeof checkPermissions !== 'function') {
- throw new BadRequest('Permissions param is not a function. (populate)');
- }
-
- if (baseService && context.path && baseService !== context.path) {
- throw new BadRequest(`Schema is for ${baseService} not ${context.path}. (populate)`);
- }
-
- if (permissions && !checkPermissions(context, context.path, permissions, 0)) {
- throw new BadRequest('Permissions do not allow this populate. (populate)');
- }
-
- if (typeof schema1 !== 'object') {
- throw new BadRequest('Schema does not resolve to an object. (populate)');
- }
-
- const include = [].concat((schema1.include || []) as any).map(schema => {
- if ('provider' in schema) {
- return schema;
- } else {
- return Object.assign({}, schema, { provider });
- }
- });
-
- return !include.length ? items : populateItemArray(options1, context, items, include, 0);
- })
- .then(items => {
- replaceItems(context, items);
- return context;
- });
- };
-}
-
-function populateItemArray(
- options: any,
- context: HookContext,
- items: any,
- includeSchema: any,
- depth: number,
-): any {
- // 'items' is an item or an array of items
- // 'includeSchema' is like [ { nameAs: 'author', ... }, { nameAs: 'readers', ... } ]
-
- if (items.toJSON || items.toObject) {
- throw new BadRequest('Populate requires results to be plain JavaScript objects. (populate)');
- }
-
- if (!Array.isArray(items)) {
- return populateItem(options, context, items, includeSchema, depth + 1);
- }
-
- return Promise.all(
- items.map(item => populateItem(options, context, item, includeSchema, depth + 1)),
- );
-}
-
-function populateItem(
- options: any,
- context: HookContext,
- item: any,
- includeSchema: any,
- depth: number,
-): any {
- // 'item' is one item
- // 'includeSchema' is like [ { nameAs: 'author', ... }, { nameAs: 'readers', ... } ]
-
- const elapsed: any = {};
- const startAtAllIncludes = new Date().getTime();
- const include = [].concat(includeSchema || []) as any;
- if (!Object.prototype.hasOwnProperty.call(item, '_include')) item._include = [];
-
- return Promise.all(
- include.map((childSchema: any) => {
- const { query, select, parentField } = childSchema;
-
- // A related column join is required if neither the query nor select options are provided.
- // That requires item[parentField] exist. (The DB handles child[childField] existence.)
- if (!query && !select && (!parentField || _get(item, parentField) === undefined)) {
- return undefined;
- }
-
- const startAtThisInclude = new Date().getTime();
- return populateAddChild(options, context, item, childSchema, depth).then((result: any) => {
- const nameAs = childSchema.nameAs || childSchema.service;
- elapsed[nameAs] = getElapsed(options, startAtThisInclude, depth);
-
- return result;
- });
- }),
- ).then(children => {
- // 'children' is like
- // [{ nameAs: 'authorInfo', items: {...} }, { nameAs: readersInfo, items: [{...}, {...}] }]
- if (options.profile !== false) {
- elapsed.total = getElapsed(options, startAtAllIncludes, depth);
- item._elapsed = elapsed;
- }
-
- children.forEach(child => {
- if (child) {
- _set(item, child.nameAs, child.items);
- }
- });
-
- return item;
- });
-}
-
-function populateAddChild(
- options: any,
- context: HookContext,
- parentItem: any,
- childSchema: any,
- depth: any,
-): any {
- /*
- @params
- 'parentItem' is the item we are adding children to
- 'childSchema' is like
- { service: 'comments',
- permissions: '...',
- nameAs: 'comments',
- asArray: true,
- parentField: 'id',
- childField: 'postId',
- query: { $limit: 5, $select: ['title', 'content', 'postId'], $sort: { createdAt: -1 } },
- select: (context, parent, depth) => ({ something: { $exists: false }}),
- paginate: false,
- provider: context.provider,
- useInnerPopulate: false,
- include: [ ... ] }
- @returns { nameAs: string, items: array }
- */
-
- const {
- childField,
- paginate,
- parentField,
- permissions,
- query,
- select,
- service,
- useInnerPopulate,
- provider,
- } = childSchema;
-
- if (!service) {
- throw new BadRequest('Child schema is missing the service property. (populate)');
- }
-
- // A related column join is required if neither the query nor select options are provided.
- if (!query && !select && !(parentField && childField)) {
- throw new BadRequest('Child schema is missing parentField or childField property. (populate)');
- }
-
- if (permissions && !options.checkPermissions(context, service, permissions, depth)) {
- throw new BadRequest(`Permissions for ${service} do not allow include. (populate)`);
- }
-
- const nameAs = childSchema.nameAs || service;
- if (parentItem._include.indexOf(nameAs) === -1) parentItem._include.push(nameAs);
-
- return Promise.resolve()
- .then(() => (select ? select(context, parentItem, depth) : {}))
- .then(selectQuery => {
- let sqlQuery = {};
-
- if (parentField) {
- const parentVal = _get(parentItem, parentField); // will not be undefined
- sqlQuery = { [childField]: Array.isArray(parentVal) ? { $in: parentVal } : parentVal };
- }
-
- const queryObj = Object.assign(
- {},
- query,
- sqlQuery,
- selectQuery, // dynamic options override static ones
- );
-
- const serviceHandle = context.app.service(service);
-
- if (!serviceHandle) {
- throw new BadRequest(`Service ${service} is not configured. (populate)`);
- }
-
- let paginateObj: any = { paginate: false };
- const paginateOption = paginate;
- if (paginateOption === true) {
- paginateObj = null;
- }
- if (typeof paginateOption === 'number') {
- paginateObj = { paginate: { default: paginateOption } };
- }
-
- const params = Object.assign(
- {},
- context.params,
- paginateObj,
- { query: queryObj },
- useInnerPopulate ? {} : { _populate: 'skip' },
- 'provider' in childSchema ? { provider: childSchema.provider } : {},
- );
-
- return serviceHandle.find(params);
- })
- .then(result => {
- result = result.data || result;
-
- if (result.length === 0) {
- return childSchema.asArray ? [] : null;
- }
-
- if (result.length === 1 && !childSchema.asArray) {
- result = result[0];
- }
-
- const include = [].concat(childSchema.include || []).map(schema => {
- if ('provider' in schema) {
- return schema;
- } else {
- return Object.assign({}, schema, { provider });
- }
- });
-
- return childSchema.include && result
- ? populateItemArray(options, context, result, include, depth)
- : result;
- })
- .then(items => ({ nameAs, items }));
-}
-
-// Helpers
-
-// used process.hrTime before
-function milliToNano(num: number) {
- return num * 1000000;
-}
-
-function getElapsed(options: PopulateOptions, startTime: number, depth: number) {
- if (options.profile === true) {
- return milliToNano(new Date().getTime() - startTime + 0.001);
- }
-
- return depth; // for testing _elapsed
-}
diff --git a/src/hooks/prevent-changes.ts b/src/hooks/prevent-changes.ts
deleted file mode 100755
index d921a54c..00000000
--- a/src/hooks/prevent-changes.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import _has from 'lodash/has.js';
-import _omit from 'lodash/omit.js';
-
-import { checkContext } from '../utils/check-context';
-import { BadRequest } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Prevent patch service calls from changing certain fields.
- * @see https://hooks-common.feathersjs.com/hooks.html#preventchanges
- */
-export function preventChanges(
- ifThrow: boolean,
- ...fieldNames: string[]
-) {
- if (typeof ifThrow === 'string') {
- // eslint-disable-next-line no-console
- console.warn('**Deprecated** Use the preventChanges(true, ...fieldNames) syntax instead.');
- fieldNames = [ifThrow, ...fieldNames];
- }
-
- return (context: H) => {
- checkContext(context, 'before', ['patch'], 'preventChanges');
- let data = { ...context.data };
-
- fieldNames.forEach(name => {
- if (_has(data, name)) {
- if (ifThrow) {
- throw new BadRequest(`Field ${name} may not be patched. (preventChanges)`);
- }
- // Delete data.contactPerson.name
- // @ts-ignore
- data = _omit(data, name);
- }
- });
-
- context.data = data;
-
- return context;
- };
-}
diff --git a/src/hooks/prevent-changes/prevent-changes.md b/src/hooks/prevent-changes/prevent-changes.md
new file mode 100644
index 00000000..c926ffe2
--- /dev/null
+++ b/src/hooks/prevent-changes/prevent-changes.md
@@ -0,0 +1,31 @@
+---
+title: preventChanges
+description: Prevent patch service calls from changing certain fields.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['patch']
+ multi: true
+---
+
+## Arguments
+
+- `{Boolean} ifThrow`
+- `{Array < String >} fieldNames`
+
+| Argument | Type | Default | Description |
+| ------------ | :----------: | ------- | ------------------------------------------------------ |
+| `ifThrow` | `Boolean` | | Deletes any `fieldNames` if `false`; throws if `true`. |
+| `fieldNames` | dot notation | | The fields names which may not be patched. |
+
+## Example
+
+```js
+const { preventChanges } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: { patch: preventChanges(true, 'security.badge') } };
+```
+
+## Details
+
+Consider using validateSchema if you would rather specify which fields are allowed to change.
diff --git a/src/hooks/prevent-changes/prevent-changes.test.ts b/src/hooks/prevent-changes/prevent-changes.test.ts
new file mode 100755
index 00000000..7e682284
--- /dev/null
+++ b/src/hooks/prevent-changes/prevent-changes.test.ts
@@ -0,0 +1,93 @@
+import { assert, expect } from 'vitest'
+import { preventChanges } from './prevent-changes.js'
+import { clone } from '../../common/index.js'
+
+let hookBefore: any
+
+describe('preventChanges', () => {
+ describe('throws if first param is "true"', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'patch',
+ params: { provider: 'rest' },
+ data: { first: 'John', last: 'Doe', a: { b: undefined, c: { d: { e: 1 } } } },
+ }
+ })
+
+ 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', 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()
+ })
+ })
+
+ describe('deletes if first param is "false"', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'patch',
+ params: { provider: 'rest' },
+ data: { first: 'John', last: 'Doe', a: { b: 'john', c: { d: { e: 1 } } } },
+ }
+ })
+
+ 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 = await preventChanges(['name.x', 'x.y.z'], { error: false })(clone(hookBefore))
+ assert.deepEqual(context, 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 = await preventChanges(['name', 'a'], { error: false })(clone(hookBefore))
+ assert.deepEqual(context.data, { first: 'John', last: 'Doe' }, '2')
+
+ 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 = await preventChanges(['name', 'a.c'], { error: false })(clone(hookBefore))
+ assert.deepEqual(context.data, { first: 'John', last: 'Doe', a: { b: 'john' } }, '4')
+
+ 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 = await preventChanges(['first', 'last'], { error: false })(clone(hookBefore))
+ assert.deepEqual(context.data, { a: { b: 'john', c: { d: { e: 1 } } } })
+
+ context = await preventChanges(['first', 'a.b', 'a.c.d.e'], { error: false })(
+ clone(hookBefore),
+ )
+ assert.deepEqual(context.data, { last: 'Doe', a: { c: { d: {} } } })
+ })
+ })
+})
diff --git a/src/hooks/prevent-changes/prevent-changes.ts b/src/hooks/prevent-changes/prevent-changes.ts
new file mode 100755
index 00000000..fd81d4fe
--- /dev/null
+++ b/src/hooks/prevent-changes/prevent-changes.ts
@@ -0,0 +1,40 @@
+import _has from 'lodash/has.js'
+import _omit from 'lodash/omit.js'
+import type { FeathersError } from '@feathersjs/errors'
+import { BadRequest } from '@feathersjs/errors'
+import { transformData } from '../transform-data/transform-data.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+export type PreventChangesOptions = {
+ error?: boolean | ((item: any, name: string) => FeathersError)
+}
+
+/**
+ * Prevent patch service calls from changing certain fields.
+ * @see https://hooks-common.feathersjs.com/hooks.html#preventchanges
+ */
+export const preventChanges = (fieldNames: MaybeArray, options?: PreventChangesOptions) => {
+ const fieldNamesArr = toArray(fieldNames)
+
+ return transformData(item => {
+ if (options?.error) {
+ for (let i = 0; i < fieldNamesArr.length; i++) {
+ const name = fieldNamesArr[i]
+
+ if (_has(item, name)) {
+ const error =
+ typeof options.error === 'function'
+ ? options.error(item, name)
+ : new BadRequest(`Field ${name} may not be patched. (preventChanges)`)
+
+ throw error
+ }
+ }
+ } else {
+ item = _omit(item, fieldNamesArr)
+ }
+
+ return item
+ })
+}
diff --git a/src/hooks/required.ts b/src/hooks/required.ts
deleted file mode 100755
index 24db02c4..00000000
--- a/src/hooks/required.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import _get from 'lodash/get.js';
-import { BadRequest } from '@feathersjs/errors';
-import _has from 'lodash/has.js';
-
-import { checkContext } from '../utils/check-context';
-import { getItems } from '../utils/get-items';
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Check selected fields exist and are not falsey. Numeric 0 is acceptable.
- * @see https://hooks-common.feathersjs.com/hooks.html#required
- */
-export function required(...fieldNames: string[]) {
- return (context: H) => {
- checkContext(context, 'before', ['create', 'update', 'patch'], 'required');
- const items = getItems(context);
-
- (Array.isArray(items) ? items : [items]).forEach(item => {
- fieldNames.forEach(name => {
- if (!_has(item, name)) throw new BadRequest(`Field ${name} does not exist. (required)`);
- const value = _get(item, name);
- if (!value && value !== 0 && value !== false)
- throw new BadRequest(`Field ${name} is null. (required)`);
- });
- });
- };
-}
diff --git a/src/hooks/run-parallel/run-parallel.md b/src/hooks/run-parallel/run-parallel.md
new file mode 100644
index 00000000..327d2a7a
--- /dev/null
+++ b/src/hooks/run-parallel/run-parallel.md
@@ -0,0 +1,42 @@
+---
+title: runParallel
+description: Run a hook in parallel to the other hooks and the service call.
+category: hooks
+hook:
+ type: ['before', 'after']
+ method: ['all']
+ multi: true
+---
+
+## Arguments
+
+- `{Function} hookFunc`
+- `{Function} clone`
+- `{Number} [ depth ]`
+
+| Argument | Type | Default | Description |
+| ---------- | :--------: | :-----: | ------------------------------------------------------------------------------------------------------------------- |
+| `hookFunc` | `Function` | | The hook function to run in parallel to the rest of the service call. |
+| `clone` | `Function` | | Function to deep clone its only parameter. |
+| `depth` | `Number` | 6 | Depth to which `context` is to be cloned. 0 does not clone. A depth of 5 would clone `context.result.data.[].item`. |
+
+## Example
+
+```js
+const { runParallel } = require('feathers-hooks-common/index.js');
+const clone = require('clone');
+
+function sendEmail(...) {
+ return context => { ... };
+}
+
+module.exports = { after: {
+ create: runParallel(sendEmail(...), clone)
+} };
+```
+
+## Details
+
+`hookFunc` is scheduled with a `setTimeout`. The next hook starts immediately.
+
+The hook was provided by bedeoverend. Thank you.
diff --git a/test/hooks/run-parallel.test.ts b/src/hooks/run-parallel/run-parallel.test.ts
similarity index 51%
rename from test/hooks/run-parallel.test.ts
rename to src/hooks/run-parallel/run-parallel.test.ts
index 719a3fd1..a4640838 100755
--- a/test/hooks/run-parallel.test.ts
+++ b/src/hooks/run-parallel/run-parallel.test.ts
@@ -1,73 +1,74 @@
-import { assert } from 'vitest';
-import { runParallel } from '../../src';
+import { assert } from 'vitest'
+import { runParallel } from './run-parallel.js'
-let contextBefore: any;
-let that: any;
+let contextBefore: any
+let that: any
function test(tester: any) {
return function (this: any, contextCloned: any) {
- that = this;
- tester(contextCloned);
- };
+ // eslint-disable-next-line @typescript-eslint/no-this-alias
+ that = this
+ tester(contextCloned)
+ }
}
describe('services runParallel', () => {
beforeEach(() => {
- that = undefined;
+ that = undefined
contextBefore = {
type: 'before',
method: 'create',
params: { provider: 'rest' },
data: { first: 'John', last: 'Doe' },
- };
- });
+ }
+ })
it('runs the func', () =>
new Promise(resolve => {
- runParallel(test(tester))(contextBefore);
+ runParallel(test(tester))(contextBefore)
function tester() {
- resolve();
+ resolve()
}
- }));
+ }))
it('passes this', () =>
new Promise(resolve => {
- runParallel(test(tester)).call({ bar: true }, contextBefore);
+ runParallel(test(tester)).call({ bar: true }, contextBefore)
function tester() {
- assert.strictEqual(that.bar, true);
- resolve();
+ assert.strictEqual(that.bar, true)
+ resolve()
}
- }));
+ }))
it('defaults to uncloned context', () =>
new Promise(resolve => {
- runParallel(test(tester))(contextBefore);
- contextBefore._foo = true;
+ runParallel(test(tester))(contextBefore)
+ contextBefore._foo = true
function tester(contextCloned: any) {
- assert.property(contextCloned, '_foo');
- resolve();
+ assert.property(contextCloned, '_foo')
+ resolve()
}
- }));
+ }))
it('clones', () =>
new Promise(resolve => {
- runParallel(test(tester), structuredClone)(contextBefore);
- contextBefore._foo = true;
+ runParallel(test(tester), structuredClone)(contextBefore)
+ contextBefore._foo = true
function tester(contextCloned: any) {
- assert.notProperty(contextCloned, '_foo');
- resolve();
+ assert.notProperty(contextCloned, '_foo')
+ resolve()
}
- }));
+ }))
it('Throws if no func', () => {
assert.throws(() => {
- // @ts-expect-error
- runParallel()(contextBefore);
- });
- });
-});
+ // @ts-expect-error TODO
+ runParallel()(contextBefore)
+ })
+ })
+})
diff --git a/src/hooks/run-parallel.ts b/src/hooks/run-parallel/run-parallel.ts
similarity index 62%
rename from src/hooks/run-parallel.ts
rename to src/hooks/run-parallel/run-parallel.ts
index fc837b8a..ca703f74 100755
--- a/src/hooks/run-parallel.ts
+++ b/src/hooks/run-parallel/run-parallel.ts
@@ -1,6 +1,6 @@
-import { BadRequest } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-import type { HookFunction } from '../types';
+import { BadRequest } from '@feathersjs/errors'
+import type { HookContext } from '@feathersjs/feathers'
+import type { HookFunction } from '../../types.js'
/**
* Run a hook in parallel to the other hooks and the service call.
@@ -12,13 +12,13 @@ export function runParallel(
clone?: (item: H) => H,
) {
if (typeof hook !== 'function') {
- throw new BadRequest('Function not provided. (runParallel)');
+ throw new BadRequest('Function not provided. (runParallel)')
}
return function (this: any, context: H) {
// must use function
- const copy = clone ? clone(context) : context;
+ const copy = clone ? clone(context) : context
- setTimeout(() => hook.call(this, copy as any));
- };
+ setTimeout(() => hook.call(this, copy as any))
+ }
}
diff --git a/src/hooks/sequelize-convert.ts b/src/hooks/sequelize-convert.ts
deleted file mode 100755
index 558eeb4c..00000000
--- a/src/hooks/sequelize-convert.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-
-export interface SequelizeConversion {
- js: (sqlValue: any) => any;
- sql: (jsValue: any) => any;
-}
-
-export interface SequelizeConverts {
- [name: string]: keyof C | 'boolean' | 'date' | 'json';
-}
-
-const methodsWithBeforeData = ['create', 'update', 'patch'];
-const defaultConversions = {
- boolean: {
- sql: (boolean: any) => (boolean ? 1 : 0),
- js: (numb: any) => !!numb,
- },
- date: {
- sql: (dateNow: any) => dateNow,
- js: (sqlDate: any) => new Date(sqlDate).valueOf() || null,
- },
- json: {
- sql: (obj: any) => JSON.stringify(obj),
- js: (str: any) => JSON.parse(str),
- },
-};
-
-/**
- * @see https://hooks-common.feathersjs.com/hooks.html#sequelizeconvert
- */
-export function sequelizeConvert<
- C extends { [name: string]: SequelizeConversion },
- H extends HookContext = HookContext,
->(
- converts: SequelizeConverts | null | undefined | false,
- ignores?: string[] | null | undefined | false,
- conversions?: C,
-) {
- const converter = sequelizeConversion(converts, ignores, conversions);
-
- return (context: H) => {
- if (context.type === 'before' && !methodsWithBeforeData.includes(context.method))
- return context;
-
- const items = getItems(context);
- converter(context.type === 'before' ? 'sql' : 'js', items);
- replaceItems(context, items);
-
- return context;
- };
-}
-
-function sequelizeConversion(converts: any, ignores: any, conversions: Record = {}) {
- converts = converts || {};
- ignores = ignores || [];
- conversions.boolean = conversions.boolean || defaultConversions.boolean;
- conversions.date = conversions.date || defaultConversions.date;
- conversions.json = conversions.json || defaultConversions.json;
-
- const props = Object.keys(converts).filter(name => !ignores.includes(name));
-
- return (sqlJs: any, recs: any) => {
- recs = Array.isArray(recs) ? recs : [recs];
-
- recs.forEach((rec: any) => {
- props.forEach(name => {
- if (name in rec) {
- rec[name] = conversions[converts[name].toLowerCase()][sqlJs](rec[name]);
- }
- });
- });
- };
-}
diff --git a/src/hooks/serialize.ts b/src/hooks/serialize.ts
deleted file mode 100755
index e9ef09ab..00000000
--- a/src/hooks/serialize.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import _get from 'lodash/get.js';
-import _set from 'lodash/set.js';
-import _omit from 'lodash/omit.js';
-
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-import type { SyncContextFunction } from '../types';
-import type { HookContext } from '@feathersjs/feathers';
-
-export interface SerializeSchema {
- only?: string | string[];
- exclude?: string | string[];
- computed?: {
- [propName: string]: (record: any, context: H) => any;
- };
-
- [key: string]:
- | SerializeSchema
- | SerializeSchema['computed']
- | string
- | string[]
- | undefined;
-}
-
-/**
- * Prune values from related records. Calculate new values.
- * @see https://hooks-common.feathersjs.com/hooks.html#serialize
- */
-export function serialize(
- schema1: SerializeSchema | SyncContextFunction,
-) {
- return (context: H) => {
- const schema = typeof schema1 === 'function' ? schema1(context) : schema1;
- const schemaDirectives = ['computed', 'exclude', 'only'];
-
- replaceItems(context, serializeItems(getItems(context), schema));
- return context;
-
- function serializeItems(items: any, schema: any) {
- if (!Array.isArray(items)) {
- return serializeItem(items, schema);
- }
-
- return items.map(item => serializeItem(item, schema));
- }
-
- function serializeItem(item: any, schema: any) {
- const computed: Record = {};
- Object.keys(schema.computed || {}).forEach(name => {
- computed[name] = schema.computed[name](item, context); // needs closure
- });
-
- let only = schema.only;
- only = typeof only === 'string' ? [only] : only;
- if (only) {
- const newItem = {};
- only.concat('_include', '_elapsed', item._include || []).forEach((key: any) => {
- const value = _get(item, key);
- if (value !== undefined) {
- _set(newItem, key, value);
- }
- });
- item = newItem;
- }
-
- let exclude = schema.exclude;
- exclude = typeof exclude === 'string' ? [exclude] : exclude;
- if (exclude) {
- item = _omit(item, exclude);
- }
-
- const _computed = Object.keys(computed);
- item = Object.assign({}, item, computed, _computed.length ? { _computed } : {});
-
- Object.keys(schema).forEach(key => {
- if (!schemaDirectives.includes(key) && typeof item[key] === 'object') {
- // needs closure
- item[key] = serializeItems(item[key], schema[key]);
- }
- });
-
- return item;
- }
- };
-}
diff --git a/src/hooks/set-field.ts b/src/hooks/set-field.ts
deleted file mode 100644
index 80d59081..00000000
--- a/src/hooks/set-field.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import _get from 'lodash/get.js';
-import _setWith from 'lodash/setWith.js';
-import _clone from 'lodash/clone.js';
-import _debug from 'debug';
-import { checkContext } from '../utils/check-context';
-import { Forbidden } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-
-export interface SetFieldOptions {
- as: string;
- from: string;
- allowUndefined?: boolean;
-}
-
-const debug = _debug('feathers-hooks-common/setField');
-
-/**
- * The `setField` hook allows to set a field on the hook context based on the value of another field on the hook context.
- * @see https://hooks-common.feathersjs.com/hooks.html#setfield
- */
-export function setField({
- as,
- from,
- allowUndefined = false,
-}: SetFieldOptions) {
- if (!as || !from) {
- throw new Error("'as' and 'from' options have to be set");
- }
-
- return (context: H) => {
- const { params } = context;
-
- checkContext(context, 'before', null, 'setField');
-
- const value = _get(context, from);
-
- if (value === undefined) {
- if (!params.provider || allowUndefined) {
- debug(`Skipping call with value ${from} not set`);
- return context;
- }
-
- throw new Forbidden(`Expected field ${as} not available`);
- }
-
- debug(`Setting value '${value}' from '${from}' as '${as}'`);
-
- return _setWith(context, as, value, _clone);
- };
-}
diff --git a/src/hooks/set-field/set-field.md b/src/hooks/set-field/set-field.md
new file mode 100644
index 00000000..17aac04f
--- /dev/null
+++ b/src/hooks/set-field/set-field.md
@@ -0,0 +1,88 @@
+---
+title: setField
+description: The `setField` hook allows to set a field on the hook context based on the value of another field on the hook context.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['all']
+ multi: true
+---
+
+### Options
+
+- `from` _required_ - The property on the hook context to use. Can be an array (e.g. `[ 'params', 'user', 'id' ]`) or a dot separated string (e.g. `'params.user.id'`).
+- `as` _required_ - The property on the hook context to set. Can be an array (e.g. `[ 'params', 'query', 'userId' ]`) or a dot separated string (e.g. `'params.query.userId'`).
+- `allowUndefined` (default: `false`) - If set to `false`, an error will be thrown if the value of `from` is `undefined` in an external request (`params.provider` is set). On internal calls (or if set to true `true` for external calls) the hook will do nothing.
+
+> **Important:** This hook should be used after the [authenticate hook](https://docs.feathersjs.com/api/authentication/hook.html#authenticate-options) when accessing user fields (from `params.user`).
+
+**Note:** When the service enable `multi:true` and `data` is an array data type, this hook may working to an unexpected result
+
+### Examples
+
+Limit all external access of the `users` service to the authenticated user:
+
+> **Note:** For MongoDB, Mongoose and NeDB `params.user.id` needs to be changed to `params.user._id`. For any other custom id accordingly.
+
+```js
+const { authenticate } = require('@feathersjs/authentication');
+const { setField } = require('feathers-hooks-common/index.js');
+
+app.service('users').hooks({
+ before: {
+ all: [authenticate('jwt'), setField({ from: 'params.user.id', as: 'params.query.id' })],
+ },
+});
+```
+
+Only allow access to invoices for the users organization:
+
+```js
+const { authenticate } = require('@feathersjs/authentication');
+const { setField } = require('feathers-hooks-common/index.js');
+
+app.service('invoices').hooks({
+ before: {
+ all: [
+ authenticate('jwt'),
+ setField({ from: 'params.user.organizationId', as: 'params.query.organizationId' }),
+ ],
+ },
+});
+```
+
+Set the current user id as `userId` when creating a message and only allow users to edit and remove their own messages:
+
+```js
+const { authenticate } = require('@feathersjs/authentication');
+const { setField } = require('feathers-hooks-common/index.js');
+
+const setUserId = setField({
+ from: 'params.user.id',
+ as: 'data.userId'
+});
+const limitToUser = setField({
+ from: 'params.user.id',
+ as: 'params.query.userId'
+});
+
+app.service('messages').hooks({
+ before: {
+ all: [
+ authenticate('jwt')
+ ],
+ create: [
+ setUserId
+ ],
+ patch: [
+ limitToUser
+ ],
+ update: [
+ limitToUser
+ ]
+ remove: [
+ limitToUser
+ ]
+ }
+})
+```
diff --git a/test/hooks/set-field.test.ts b/src/hooks/set-field/set-field.test.ts
similarity index 50%
rename from test/hooks/set-field.test.ts
rename to src/hooks/set-field/set-field.test.ts
index 9c3c6b37..e1a42d7e 100644
--- a/test/hooks/set-field.test.ts
+++ b/src/hooks/set-field/set-field.test.ts
@@ -1,21 +1,21 @@
-import { assert, expect } from 'vitest';
-import { feathers } from '@feathersjs/feathers';
-import { MemoryService } from '@feathersjs/memory';
-import { setField } from '../../src';
+import { assert, expect } from 'vitest'
+import { feathers } from '@feathersjs/feathers'
+import { MemoryService } from '@feathersjs/memory'
+import { setField } from './set-field.js'
-import type { Application } from '@feathersjs/feathers';
+import type { Application } from '@feathersjs/feathers'
describe('setField', () => {
const user = {
id: 1,
name: 'David',
- };
+ }
- let app: Application;
+ let app: Application
beforeEach(async () => {
- app = feathers();
- app.use('/messages', new MemoryService());
+ app = feathers()
+ app.use('/messages', new MemoryService())
app.service('messages').hooks({
before: {
all: [
@@ -25,84 +25,57 @@ describe('setField', () => {
}),
],
},
- });
+ })
await app.service('messages').create({
id: 1,
text: 'Message 1',
userId: 1,
- });
+ })
await app.service('messages').create({
id: 2,
text: 'Message 2',
userId: 2,
- });
- });
-
- it('errors when options not set', () => {
- assert.throws(() =>
- app.service('messages').hooks({
- before: {
- // @ts-expect-error
- get: setField(),
- },
- }),
- );
- assert.throws(() =>
- app.service('messages').hooks({
- before: {
- // @ts-expect-error
- get: setField({ as: 'me' }),
- },
- }),
- );
- assert.throws(() =>
- app.service('messages').hooks({
- before: {
- // @ts-expect-error
- get: setField({ from: 'you' }),
- },
- }),
- );
- });
+ })
+ })
it('find queries with user information, does not modify original objects', async () => {
- const query = {};
- // @ts-ignore
- const results = await app.service('messages').find({ query, user });
+ const query = {}
+ // @ts-expect-error TODO
+ const results = await app.service('messages').find({ query, user })
- assert.equal(results.length, 1);
- assert.deepEqual(query, {});
- });
+ assert.equal(results.length, 1)
+ assert.deepEqual(query, {})
+ })
it('adds user information to get, throws NotFound event if record exists', async () => {
await expect(async () => {
- // @ts-ignore
- await app.service('messages').get(2, { user });
- }).rejects.toThrow();
+ // @ts-expect-error TODO
+ await app.service('messages').get(2, { user })
+ }).rejects.toThrow()
- // @ts-ignore
- const result = await app.service('messages').get(1, { user });
+ // @ts-expect-error TODO
+ const result = await app.service('messages').get(1, { user })
assert.deepEqual(result, {
id: 1,
text: 'Message 1',
userId: 1,
- });
- });
+ } as any)
+ })
it('does nothing on internal calls if value does not exists', async () => {
- const results = await app.service('messages').find();
+ const results = await app.service('messages').find()
- assert.equal(results.length, 2);
- });
+ assert.equal(results.length, 2)
+ })
it('errors on external calls if value does not exists', async () => {
await expect(async () => {
await app.service('messages').find({
provider: 'rest',
- });
- }).rejects.toThrow();
- });
+ })
+ }).rejects.toThrow()
+ })
it('errors when not used as a before hook', async () => {
app.service('messages').hooks({
@@ -112,10 +85,10 @@ describe('setField', () => {
as: 'params.query.userId',
}),
},
- });
+ })
await expect(async () => {
- await app.service('messages').get(1);
- }).rejects.toThrow();
- });
-});
+ await app.service('messages').get(1)
+ }).rejects.toThrow()
+ })
+})
diff --git a/src/hooks/set-field/set-field.ts b/src/hooks/set-field/set-field.ts
new file mode 100644
index 00000000..c68629a9
--- /dev/null
+++ b/src/hooks/set-field/set-field.ts
@@ -0,0 +1,40 @@
+import _get from 'lodash/get.js'
+import _setWith from 'lodash/setWith.js'
+import _clone from 'lodash/clone.js'
+import { checkContext } from '../../utils/index.js'
+import { Forbidden } from '@feathersjs/errors'
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+
+export interface SetFieldOptions {
+ as: string
+ from: string
+ allowUndefined?: boolean
+}
+
+/**
+ * The `setField` hook allows to set a field on the hook context based on the value of another field on the hook context.
+ * @see https://hooks-common.feathersjs.com/hooks.html#setfield
+ */
+export const setField =
+ ({ as, from, allowUndefined = false }: SetFieldOptions) =>
+ (context: H, next?: NextFunction) => {
+ const { params } = context
+
+ checkContext(context, ['before', 'around'], null, 'setField')
+
+ const value = _get(context, from)
+
+ if (value === undefined) {
+ if (!params.provider || allowUndefined) {
+ return context
+ }
+
+ throw new Forbidden(`Expected field ${as} not available`)
+ }
+
+ context = _setWith(context, as, value, _clone)
+
+ if (next) return next()
+
+ return context
+ }
diff --git a/src/hooks/set-now-data/set-now-data.md b/src/hooks/set-now-data/set-now-data.md
new file mode 100644
index 00000000..7ef04fd0
--- /dev/null
+++ b/src/hooks/set-now-data/set-now-data.md
@@ -0,0 +1,28 @@
+---
+title: setNowData
+description: Create/update certain fields to the current date-time.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
+
+- Arguments
+ - `{Array < String >} fieldNames`
+
+| Name | Type | Description |
+| ---------- | ------------ | ---------------------------------------------------------------- |
+| fieldNames | dot notation | The fields that you want to add or set to the current date-time. |
+
+## Example
+
+```js
+const { setNow } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: { create: setNow('createdAt', 'updatedAt') } };
+```
+
+## Details
+
+Update either `context.data` (before hook) or `context.result[.data]` (after hook).
diff --git a/src/hooks/set-now-data/set-now-data.test.ts b/src/hooks/set-now-data/set-now-data.test.ts
new file mode 100755
index 00000000..9a2fe429
--- /dev/null
+++ b/src/hooks/set-now-data/set-now-data.test.ts
@@ -0,0 +1,135 @@
+import { assert } from 'vitest'
+import { setNowData } from './set-now-data.js'
+
+let hookBefore: any
+let hookBefore2: any
+
+describe('setNowData', () => {
+ describe('updated fields', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ })
+
+ it('updates hook before::create', () => {
+ setNowData('createdAt')(hookBefore)
+ checkHook(hookBefore.data, { first: 'John', last: 'Doe' }, 'createdAt')
+ })
+
+ it('supports field name', () => {
+ setNowData('createdAt2')(hookBefore)
+ checkHook(hookBefore.data, { first: 'John', last: 'Doe' }, 'createdAt2')
+ })
+
+ it('supports multiple field names', () => {
+ setNowData(['createdAt1', 'createdAt2'])(hookBefore)
+ checkHook(hookBefore.data, { first: 'John', last: 'Doe' }, ['createdAt1', 'createdAt2'])
+ })
+ })
+
+ describe('handles dot notation', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ data: { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
+ }
+ hookBefore2 = {
+ type: 'before',
+ method: 'create',
+ data: {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ created: { where: 'NYC' },
+ },
+ }
+ })
+
+ it('prop with no dots', () => {
+ setNowData('madeAt')(hookBefore)
+ checkHook(
+ hookBefore.data,
+ { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
+ 'madeAt',
+ )
+ })
+
+ it('props with no dots', () => {
+ setNowData(['madeAt', 'builtAt'])(hookBefore)
+ checkHook(
+ hookBefore.data,
+ { empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' }, dept: 'Acct' },
+ ['madeAt', 'builtAt'],
+ )
+ })
+
+ it('prop with 1 dot', () => {
+ setNowData('created.at')(hookBefore)
+ assert.instanceOf(hookBefore.data.created.at, Date, 'not instance of Date')
+ assert.equal(Object.keys(hookBefore.data.created).length, 1)
+ delete hookBefore.data.created
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+
+ it('prop with 1 dot in existing obj', () => {
+ setNowData('created.at')(hookBefore2)
+ assert.instanceOf(hookBefore2.data.created.at, Date, 'not instance of Date')
+ assert.equal(Object.keys(hookBefore2.data.created).length, 2)
+ delete hookBefore2.data.created.at
+ assert.deepEqual(hookBefore2.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ created: { where: 'NYC' },
+ })
+ })
+
+ it('prop with 2 dots', () => {
+ setNowData('created.at.time')(hookBefore)
+ assert.instanceOf(hookBefore.data.created.at.time, Date, 'not instance of Date')
+ assert.equal(Object.keys(hookBefore.data.created.at).length, 1)
+ assert.equal(Object.keys(hookBefore.data.created).length, 1)
+ delete hookBefore.data.created
+ assert.deepEqual(hookBefore.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: 'Acct',
+ })
+ })
+ })
+
+ describe('time advances', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ })
+
+ it('for 2 hooks', () =>
+ new Promise(resolve => {
+ setNowData('createdAt')(hookBefore)
+ const firstTime = hookBefore.data.createdAt
+
+ setTimeout(() => {
+ setNowData('createdAt')(hookBefore)
+ assert.isAbove(hookBefore.data.createdAt.getTime(), firstTime.getTime())
+ resolve()
+ }, 50)
+ }))
+ })
+})
+
+// Helpers
+
+function checkHook(item: any, template: any, dateFields: any) {
+ const item1 = structuredClone(item)
+ if (typeof dateFields === 'string') {
+ dateFields = [dateFields]
+ }
+
+ dateFields.forEach((dateField: any) => {
+ assert.instanceOf(item[dateField], Date, 'not instance of Date')
+ item1[dateField] = undefined
+ delete item1[dateField]
+ })
+
+ assert.deepEqual(item1, template, 'objects differ')
+}
diff --git a/src/hooks/set-now-data/set-now-data.ts b/src/hooks/set-now-data/set-now-data.ts
new file mode 100755
index 00000000..799a8ce5
--- /dev/null
+++ b/src/hooks/set-now-data/set-now-data.ts
@@ -0,0 +1,21 @@
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+import { transformData } from '../transform-data/transform-data.js'
+import _set from 'lodash/set.js'
+
+/**
+ * Create/update certain fields to the current date-time.
+ *
+ * @see https://hooks-common.feathersjs.com/hooks.html#setnow
+ */
+export const setNowData = (fieldNames: MaybeArray) => {
+ const fieldNamesArr = toArray(fieldNames)
+
+ return transformData(data => {
+ for (let i = 0; i < fieldNamesArr.length; i++) {
+ const key = fieldNamesArr[i]
+
+ _set(data, key, new Date())
+ }
+ })
+}
diff --git a/src/hooks/set-now-result/set-now-result.md b/src/hooks/set-now-result/set-now-result.md
new file mode 100644
index 00000000..3c5b006f
--- /dev/null
+++ b/src/hooks/set-now-result/set-now-result.md
@@ -0,0 +1,9 @@
+---
+
+title: setNowResult
+description: Set the current date/time on certain fields in the result.
+category: hooks
+hook:
+type: ['before', 'after', 'around']
+method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+multi: true
diff --git a/src/hooks/set-now-result/set-now-result.test.ts b/src/hooks/set-now-result/set-now-result.test.ts
new file mode 100755
index 00000000..3dec829a
--- /dev/null
+++ b/src/hooks/set-now-result/set-now-result.test.ts
@@ -0,0 +1,68 @@
+import { assert } from 'vitest'
+import { setNowResult } from './set-now-result.js'
+
+let hookAfter: any
+let hookFindPaginate: any
+let hookFind: any
+
+describe('setNowResult', () => {
+ describe('updated fields', () => {
+ beforeEach(() => {
+ hookAfter = { type: 'after', method: 'create', result: { first: 'Jane', last: 'Doe' } }
+ hookFindPaginate = {
+ type: 'after',
+ method: 'find',
+ result: {
+ total: 2,
+ data: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ },
+ }
+ hookFind = {
+ type: 'after',
+ method: 'find',
+ result: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ }
+ })
+
+ it('updates hook after::find with pagination', () => {
+ setNowResult('createdAt')(hookFindPaginate)
+
+ checkHook(hookFindPaginate.result.data[0], { first: 'John', last: 'Doe' }, 'createdAt')
+ checkHook(hookFindPaginate.result.data[1], { first: 'Jane', last: 'Doe' }, 'createdAt')
+ })
+
+ it('updates hook after::find with no pagination', () => {
+ setNowResult('createdAt')(hookFind)
+ checkHook(hookFind.result[0], { first: 'John', last: 'Doe' }, 'createdAt')
+ checkHook(hookFind.result[1], { first: 'Jane', last: 'Doe' }, 'createdAt')
+ })
+
+ it('updates hook after', () => {
+ setNowResult('createdAt')(hookAfter)
+ checkHook(hookAfter.result, { first: 'Jane', last: 'Doe' }, 'createdAt')
+ })
+ })
+})
+
+// Helpers
+
+function checkHook(item: any, template: any, dateFields: any) {
+ const item1 = structuredClone(item)
+ if (typeof dateFields === 'string') {
+ dateFields = [dateFields]
+ }
+
+ dateFields.forEach((dateField: any) => {
+ assert.instanceOf(item[dateField], Date, 'not instance of Date')
+ item1[dateField] = undefined
+ delete item1[dateField]
+ })
+
+ assert.deepEqual(item1, template, 'objects differ')
+}
diff --git a/src/hooks/set-now-result/set-now-result.ts b/src/hooks/set-now-result/set-now-result.ts
new file mode 100755
index 00000000..602a5165
--- /dev/null
+++ b/src/hooks/set-now-result/set-now-result.ts
@@ -0,0 +1,29 @@
+import _set from 'lodash/set.js'
+import { transformResult } from '../transform-result/transform-result.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+import type { DispatchOption } from '../../types.js'
+
+type SetNowResultOptions = {
+ dispatch?: DispatchOption
+}
+
+/**
+ * Create/update certain fields to the current date-time.
+ *
+ * @see https://hooks-common.feathersjs.com/hooks.html#setnow
+ */
+export const setNowResult = (fieldNames: MaybeArray, options?: SetNowResultOptions) => {
+ const fieldNamesArray = toArray(fieldNames)
+
+ return transformResult(
+ data => {
+ for (let i = 0, n = fieldNamesArray.length; i < n; i++) {
+ const key = fieldNamesArray[i]
+
+ _set(data, key, new Date())
+ }
+ },
+ { dispatch: options?.dispatch },
+ )
+}
diff --git a/src/hooks/set-now.ts b/src/hooks/set-now.ts
deleted file mode 100755
index 90552147..00000000
--- a/src/hooks/set-now.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { BadRequest } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-import { setFields as _setFields } from '../common';
-import { getItems } from '../utils/get-items';
-
-/**
- * Create/update certain fields to the current date-time.
- *
- * @see https://hooks-common.feathersjs.com/hooks.html#setnow
- */
-export function setNow(...fieldNames: string[]) {
- if (!fieldNames.length) {
- throw new BadRequest('Field name is required. (setNow)');
- }
-
- return (context: H) => {
- _setFields(getItems(context), () => new Date(), fieldNames, 'setNow');
- return context;
- };
-}
diff --git a/src/hooks/set-slug.ts b/src/hooks/set-slug.ts
deleted file mode 100755
index d945534c..00000000
--- a/src/hooks/set-slug.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import _set from 'lodash/set.js';
-import { GeneralError } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-
-/**
- * Fix slugs in URL, e.g. /stores/:storeId.
- *
- * @see https://hooks-common.feathersjs.com/hooks.html#setslug
- */
-export function setSlug(slug: string, fieldName?: string) {
- return (context: H) => {
- if (typeof fieldName !== 'string') {
- fieldName = `query.${slug}`;
- }
-
- if (context.type === 'after') {
- throw new GeneralError('Cannot set slug on after hook. (setSlug)');
- }
-
- if (context.params && context.params.provider === 'rest') {
- const value = context.params.route[slug];
- if (typeof value === 'string' && value[0] !== ':') {
- _set(context.params, fieldName, value);
- }
- }
- };
-}
diff --git a/src/hooks/set-slug/set-slug.md b/src/hooks/set-slug/set-slug.md
new file mode 100644
index 00000000..fa6748b7
--- /dev/null
+++ b/src/hooks/set-slug/set-slug.md
@@ -0,0 +1,42 @@
+---
+title: setSlug
+description: Set slugs in URL, e.g. /stores/:storeId.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['all']
+ multi: true
+---
+
+## Arguments
+
+- `{String} slug`
+- `{String} [ fieldName ]`
+
+| Argument | Type | Default | Description |
+| ----------- | :------: | ------------- | ---------------------------------------------------------------------------------- |
+| `slug` | `String` | | The slug as it appears in the route, e.g. `storeId` for`/stores/:storeId/candies`. |
+| `fieldName` | `String` | `query[slug]` | The field to contain the slug value. |
+
+## Example
+
+```js
+const { setSlug } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: { all: [hooks.setSlug('storeId')] } };
+
+// `context.params.query` will always be normalized,
+// e.g. `{ size: 'large', storeId: '123' }`
+```
+
+## Details
+
+A service may have a slug in its URL, e.g. `storeId` in `app.use(` `'/stores/:storeId/candies',` `new Service());`. The service gets slightly different values depending on the transport used by the client.
+
+| transport | `hook.data` `.storeId` | `hook.params` `.query` | code run on client |
+| --------- | ---------------------- | ------------------------------------- | -------------------------------------------------------------------------------------------- |
+| socketio | `undefined` | `{ size: 'large',` `storeId: '123' }` | `candies.create({ name: 'Gummi',qty: 100 },` `{ query: { size: 'large', storeId: '123' } })` |
+| rest | `:storeId` | same as above | same as above |
+| raw HTTP | `123` | `{ size: 'large' }` | `fetch('/stores/123/candies?size=large', ..` |
+
+This hook normalizes the difference between the transports.
diff --git a/src/hooks/set-slug/set-slug.test.ts b/src/hooks/set-slug/set-slug.test.ts
new file mode 100755
index 00000000..95b90643
--- /dev/null
+++ b/src/hooks/set-slug/set-slug.test.ts
@@ -0,0 +1,53 @@
+import { assert } from 'vitest'
+
+import { setSlug } from './set-slug.js'
+
+let hook: any
+
+describe('services setSlug', () => {
+ beforeEach(() => {
+ hook = { type: 'before', method: 'create', params: { provider: 'rest', query: { a: 'a' } } }
+ })
+
+ describe('ignore feathers-socketio & feathers-rest clients', () => {
+ it('ignore feathers-socketio', () => {
+ hook.params.provider = 'socketio'
+ setSlug('stockId')(hook)
+ assert.deepEqual(hook.params.query, { a: 'a' })
+ })
+
+ it('ignore feathers-rest', () => {
+ hook.params.route = {}
+ hook.params.route.storeId = ':storeId'
+ setSlug('stockId')(hook)
+ assert.deepEqual(hook.params.query, { a: 'a' })
+ })
+ })
+
+ describe('handles raw HTTP clients', () => {
+ it('copies slug to query', () => {
+ hook.params.route = {}
+ hook.params.route.storeId = '123'
+ setSlug('storeId')(hook)
+ assert.deepEqual(hook.params.query, { a: 'a', storeId: '123' })
+ })
+ })
+
+ describe('handles field name', () => {
+ it('copies slug to query', () => {
+ hook.params.route = {}
+ hook.params.route.storeId = '123'
+ setSlug('storeId', 'slugger')(hook)
+ assert.equal(hook.params.slugger, '123')
+ })
+ })
+
+ describe('handles field name with dot notation', () => {
+ it('copies slug to query', () => {
+ hook.params.route = {}
+ hook.params.route.storeId = '123'
+ setSlug('storeId', 'query.slugger')(hook)
+ assert.deepEqual(hook.params.query, { a: 'a', slugger: '123' })
+ })
+ })
+})
diff --git a/src/hooks/set-slug/set-slug.ts b/src/hooks/set-slug/set-slug.ts
new file mode 100755
index 00000000..be4cfcf6
--- /dev/null
+++ b/src/hooks/set-slug/set-slug.ts
@@ -0,0 +1,26 @@
+import _set from 'lodash/set.js'
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+
+/**
+ * Fix slugs in URL, e.g. /stores/:storeId.
+ *
+ * @see https://hooks-common.feathersjs.com/hooks.html#setslug
+ */
+export const setSlug = (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()
+
+ return context
+ }
+}
diff --git a/src/hooks/sifter.ts b/src/hooks/sifter.ts
deleted file mode 100755
index ba4f481d..00000000
--- a/src/hooks/sifter.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { BadRequest } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-import type { SyncContextFunction } from '../types';
-import { checkContext } from '../utils/check-context';
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-
-export function sifter(
- siftFunc: SyncContextFunction<(item: any) => boolean, H>,
-) {
- return (context: H) => {
- checkContext(context, 'after', 'find', 'sifter');
-
- if (typeof siftFunc !== 'function') {
- throw new BadRequest('The sifter param must be a function. (sifter)');
- }
-
- const sifter = siftFunc(context);
-
- if (typeof sifter !== 'function') {
- throw new BadRequest('The result of calling the sifter param must be a function. (sifter)');
- }
-
- replaceItems(context, getItems(context).filter(sifter));
-
- return context;
- };
-}
diff --git a/src/hooks/soft-delete.ts b/src/hooks/soft-delete.ts
deleted file mode 100755
index 04551eef..00000000
--- a/src/hooks/soft-delete.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import type { HookContext } from '@feathersjs/feathers';
-import { checkContext } from '../utils/check-context';
-
-export type SoftDeleteOptionFunction = (
- context?: H,
-) => Promise<{ [key: string]: any }>;
-
-export interface SoftDeleteOptions {
- deletedQuery?: { [key: string]: any } | SoftDeleteOptionFunction;
- removeData?: { [key: string]: any } | SoftDeleteOptionFunction;
-}
-
-const defaultQuery = { deleted: { $ne: true } };
-const defaultData = { deleted: true };
-const getValue = (value: any, ...args: any[]) => {
- if (typeof value === 'function') {
- return Promise.resolve(value(...args));
- }
- return Promise.resolve(value);
-};
-
-/**
- * Allow to mark items as deleted instead of removing them.
- */
-export function softDelete({
- deletedQuery = defaultQuery,
- removeData = defaultData,
-}: SoftDeleteOptions = {}) {
- return async (context: H) => {
- const { service, method, params } = context;
- // @ts-ignore
- const { disableSoftDelete, query = {} } = params;
-
- checkContext(context, 'before', null, 'softDelete');
-
- if (disableSoftDelete) {
- return context;
- }
-
- const deleteQuery = await getValue(deletedQuery, context);
-
- context.params.query = Object.assign({}, query, deleteQuery);
-
- if (method === 'remove') {
- const data = await getValue(removeData, context);
- const result = await service.patch(context.id, data, params);
-
- context.result = result;
- }
-
- return context;
- };
-}
diff --git a/src/hooks/soft-delete/soft-delete.md b/src/hooks/soft-delete/soft-delete.md
new file mode 100644
index 00000000..3516e01e
--- /dev/null
+++ b/src/hooks/soft-delete/soft-delete.md
@@ -0,0 +1,66 @@
+---
+title: softDelete
+description: Flag records as logically deleted instead of physically removing them. Requires a Feathers v4 or later database adapter.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+ multi: true
+---
+
+## Arguments
+
+| Argument | Type | Default | Description | |
+| -------------- | --------- | ------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `deletedQuery` | `Function | Object` | `{ deleted: { $ne: true } }` | An object or async function that takes the query which returns the part of the query to exclude deleted entrie |
+| `removeData` | `Function | Object` | `{ deleted: true }` | An object or async function that returns the data used to flag an entry as deleted |
+
+By default, `softDelete` queries for a `deleted` property not set to `true` (meaning it can either exist or be anything else).
+
+Setting `params.disableSoftDelete` to `true` allows to skip the `softDelete` hook.
+
+## Example
+
+Basic usage:
+
+```js
+const { softDelete } = require('feathers-hooks-common/index.js');
+
+// Use standard softDelete which uses `deleted: true`
+app.service('people').hooks({ before: { all: [softDelete()] } });
+
+// will set `deleted: true` for entry with id 1
+app.service('people').remove(1);
+
+// Will find all people where `deleted` is not `true`
+let people = app.service('people').find();
+
+// `get`, `patch`, `update` or `remove` on a deleted entry will throw NotFound
+app.service('people').get(1);
+```
+
+Customizing `deletedQuery` and `removeData` to e.g. use `deletedAt`:
+
+```js
+// Use deletedAt and set when the entry was deleted
+app.service('people').hooks({
+ before: {
+ all: [
+ hooks.softDelete({
+ // context is the normal hook context
+ deletedQuery: async context => {
+ return { deletedAt: null };
+ },
+ removeData: async context => {
+ return { deletedAt: new Date() };
+ },
+ }),
+ ],
+ create: [
+ context => {
+ context.data.deletedAt = null;
+ },
+ ],
+ },
+});
+```
diff --git a/src/hooks/soft-delete/soft-delete.test.ts b/src/hooks/soft-delete/soft-delete.test.ts
new file mode 100755
index 00000000..5a137019
--- /dev/null
+++ b/src/hooks/soft-delete/soft-delete.test.ts
@@ -0,0 +1,179 @@
+import { assert, expect } from 'vitest'
+import { feathers } from '@feathersjs/feathers'
+import { MemoryService } from '@feathersjs/memory'
+import { softDelete } from './soft-delete.js'
+
+const initialUsers = [
+ { name: 'Jane Doe', key: 'a' },
+ { name: 'Jack Doe', key: 'a' },
+ { name: 'Jack Doe', key: 'a', deletedAt: new Date() },
+ { name: 'Rick Doe', key: 'b' },
+ { name: 'Mick Doe', key: 'b' },
+ { name: 'Mick Doe', key: 'b', deletedAt: new Date() },
+]
+
+describe('softDelete', () => {
+ let userService: any
+
+ beforeEach(() => {
+ const app = feathers().use(
+ '/users',
+ new MemoryService({
+ multi: true,
+ }),
+ )
+
+ userService = app.service('users')
+ userService.hooks({
+ before: {
+ all: [
+ softDelete({
+ deletedQuery: { deletedAt: null },
+ removeData: { deletedAt: new Date() },
+ }),
+ ],
+ },
+ })
+
+ userService.create(initialUsers)
+ })
+
+ describe('find', () => {
+ it('does not return deleted items', async () => {
+ const users = await userService.find()
+
+ assert.deepStrictEqual(users, [
+ { name: 'Jane Doe', key: 'a', id: 0 },
+ { name: 'Jack Doe', key: 'a', id: 1 },
+ { name: 'Rick Doe', key: 'b', id: 3 },
+ { name: 'Mick Doe', key: 'b', id: 4 },
+ ])
+ })
+
+ it('returns everything with params.disableSoftDelete', async () => {
+ const users = await userService.find({
+ disableSoftDelete: true,
+ })
+
+ assert.deepStrictEqual(
+ users.map((x: any) => x.id),
+ [0, 1, 2, 3, 4, 5],
+ )
+ })
+ })
+
+ describe('get', () => {
+ it('returns an undeleted item', async () => {
+ const user = await userService.get(0)
+
+ assert.deepStrictEqual(user, {
+ name: 'Jane Doe',
+ key: 'a',
+ id: 0,
+ })
+ })
+
+ it('throws on deleted item', async () => {
+ await expect(async () => {
+ await userService.get(2)
+ }).rejects.toThrow()
+ })
+
+ it('returns deleted when params.disableSoftDelete is set', async () => {
+ const user = await userService.get(2, {
+ disableSoftDelete: true,
+ })
+
+ assert.ok(user.deletedAt)
+ })
+
+ it('throws on missing item', async () => {
+ await expect(async () => {
+ await userService.get(99)
+ }).rejects.toThrow()
+ })
+ })
+
+ describe('update, with id', () => {
+ it('updates an undeleted item', async () => {
+ const user = await userService.update(0, { y: 'y' })
+
+ assert.deepStrictEqual(user, { y: 'y', id: 0 })
+ })
+
+ it.skip('throws on deleted item', async () => {
+ await expect(async () => {
+ await userService.update(2, { y: 'y' })
+ }).rejects.toThrow()
+ })
+ })
+
+ describe('patch', () => {
+ it('patches an undeleted item', async () => {
+ const user = await userService.patch(0, { y: 'y' })
+
+ assert.deepStrictEqual(user, {
+ name: 'Jane Doe',
+ key: 'a',
+ id: 0,
+ y: 'y',
+ })
+ })
+
+ it('throws on deleted item', async () => {
+ await expect(() => userService.patch(2, { y: 'y' })).rejects.toThrow()
+ })
+
+ it('multi updates on undeleted items', async () => {
+ const patched = await userService.patch(null, { x: 'x' })
+
+ assert.deepStrictEqual(patched, [
+ { name: 'Jane Doe', key: 'a', id: 0, x: 'x' },
+ { name: 'Jack Doe', key: 'a', id: 1, x: 'x' },
+ { name: 'Rick Doe', key: 'b', id: 3, x: 'x' },
+ { name: 'Mick Doe', key: 'b', id: 4, x: 'x' },
+ ])
+ })
+ })
+
+ describe('remove, with id', () => {
+ it('marks item as deleted', async () => {
+ const user = await userService.remove(0)
+
+ assert.equal(user.id, 0)
+ assert.equal(!!user.deletedAt, true)
+
+ await expect(() => userService.get(0)).rejects.toThrow()
+ })
+
+ it('throws if item already deleted', async () => {
+ await expect(() => userService.remove(2)).rejects.toThrow()
+ })
+ })
+
+ describe('remove, without id', () => {
+ it('marks filtered items as deleted', async () => {
+ const query = { key: 'a' }
+ const removedUsers = await userService.remove(null, { query })
+
+ assert.strictEqual(removedUsers.length, 2)
+
+ const users = await userService.find({ query })
+
+ assert.strictEqual(users.length, 0)
+
+ const deletedUsers = await userService.find({
+ query,
+ disableSoftDelete: true,
+ })
+
+ assert.strictEqual(deletedUsers.length, 3)
+ })
+
+ it('handles nothing found', async () => {
+ const users = await userService.remove(null, { query: { key: 'z' } })
+
+ assert.strictEqual(users.length, 0)
+ })
+ })
+})
diff --git a/src/hooks/soft-delete/soft-delete.ts b/src/hooks/soft-delete/soft-delete.ts
new file mode 100755
index 00000000..d5d8def0
--- /dev/null
+++ b/src/hooks/soft-delete/soft-delete.ts
@@ -0,0 +1,89 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { checkContext } from '../../utils/index.js'
+import type { TransformParamsFn } from '../../types.js'
+import { transformParams } from '../../utils/transform-params/transform-params.js'
+import type { Promisable } from '../../internal.utils.js'
+
+export type SoftDeleteOptionFunction = (
+ context?: H,
+) => Promisable<{ [key: string]: any }>
+
+export interface SoftDeleteOptions {
+ /**
+ * @example { deletedAt: null }
+ */
+ deletedQuery: { [key: string]: any } | SoftDeleteOptionFunction
+ /**
+ * @example { deletedAt: new Date() }
+ */
+ removeData: { [key: string]: any } | SoftDeleteOptionFunction
+ /**
+ * Transform the params before calling the service method. E.g. remove 'params.provider' or add custom params.
+ */
+ transformParams?: TransformParamsFn
+
+ /**
+ * Key in `params` to disable the soft delete functionality.
+ *
+ * @default 'disableSoftDelete'
+ */
+ disableSoftDeleteKey?: string
+}
+
+/**
+ * Allow to mark items as deleted instead of removing them.
+ */
+export const softDelete = (options: SoftDeleteOptions) => {
+ if (!options?.deletedQuery || !options?.removeData) {
+ throw new Error(
+ 'You must provide `deletedQuery` and `removeData` options to the softDelete hook.',
+ )
+ }
+
+ return async (context: H, next?: NextFunction) => {
+ checkContext(context, ['before', 'around'], null, 'softDelete')
+
+ const { disableSoftDeleteKey = 'disableSoftDelete' } = options
+
+ if (context.params[disableSoftDeleteKey]) {
+ return context
+ }
+
+ const { deletedQuery, removeData } = options
+
+ const deleteQuery = await getValue(deletedQuery, context)
+
+ const params = transformParams(
+ {
+ ...context.params,
+ query: {
+ ...context.params.query,
+ ...deleteQuery,
+ },
+ },
+ options.transformParams,
+ )
+
+ context.params = params
+
+ if (context.method === 'remove') {
+ const data = await getValue(removeData, context)
+ const result = await context.service.patch(context.id, data, params)
+
+ context.result = result
+ }
+
+ if (next) {
+ await next()
+ }
+
+ return context
+ }
+}
+
+const getValue = (value: any, ...args: any[]) => {
+ if (typeof value === 'function') {
+ return value(...args)
+ }
+ return value
+}
diff --git a/src/hooks/stash-before.ts b/src/hooks/stash-before.ts
deleted file mode 100755
index c535c0d6..00000000
--- a/src/hooks/stash-before.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { BadRequest } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-import { checkContext } from '../utils/check-context';
-
-/**
- * Stash current value of record, usually before mutating it. Performs a get call.
- * @see https://hooks-common.feathersjs.com/hooks.html#stashbefore
- */
-export function stashBefore(fieldName?: string) {
- const beforeField = fieldName || 'before';
-
- return (context: H) => {
- checkContext(context, 'before', ['get', 'update', 'patch', 'remove'], 'stashBefore');
-
- // @ts-ignore
- if (context.params.disableStashBefore) {
- return context;
- }
-
- if ((context.id === null || context.id === undefined) && !context.params.query) {
- throw new BadRequest('Id is required. (stashBefore)');
- }
-
- const params =
- context.method === 'get'
- ? context.params
- : {
- provider: context.params.provider,
- // @ts-ignore
- authenticated: context.params.authenticated,
- // @ts-ignore
- user: context.params.user,
- };
-
- return context.service
- .get(context.id, {
- ...params,
- // @ts-ignore
- query: params.query || {},
- // @ts-ignore
- disableStashBefore: true,
- })
- .then((data: any) => {
- // @ts-ignore
- context.params[beforeField] = JSON.parse(JSON.stringify(data));
- return context;
- })
- .catch(() => context);
- };
-}
diff --git a/src/hooks/stash-before/stash-before.md b/src/hooks/stash-before/stash-before.md
new file mode 100644
index 00000000..c230791c
--- /dev/null
+++ b/src/hooks/stash-before/stash-before.md
@@ -0,0 +1,37 @@
+---
+title: stashBefore
+description: Stash current value of record, usually before mutating it. Performs a get call.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['get', 'update', 'patch', 'remove']
+ multi: true
+---
+
+## Arguments
+
+- `{String} fieldName`
+
+| Argument | Type | Default | Description |
+| ----------- | :--: | ---------- | ------------------------------------------------------------------------------ |
+| `fieldName` | | `'before'` | The name of the `context.params` property to contain the current record value. |
+
+## Example
+
+```js
+const { stashBefore } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: { patch: stashBefore() } };
+```
+
+## Details
+
+The hook performs its own preliminary `get` call. If the original service call is also a `get`, its `context.params` is used for the preliminary `get`. The preliminary `get` will be skipped if `params.disableStashBefore` is truthy.
+
+For any other method the calling params are formed from the original calling context:
+
+```js
+{ provider: context.params.provider,
+ authenticated: context.params.authenticated,
+ user: context.params.user }
+```
diff --git a/src/hooks/stash-before/stash-before.test.ts b/src/hooks/stash-before/stash-before.test.ts
new file mode 100755
index 00000000..db788e99
--- /dev/null
+++ b/src/hooks/stash-before/stash-before.test.ts
@@ -0,0 +1,120 @@
+import { assert, expect } from 'vitest'
+import type { Application } from '@feathersjs/feathers'
+import { feathers } from '@feathersjs/feathers'
+import { MemoryService } from '@feathersjs/memory'
+import { stashBefore } from './stash-before.js'
+import { clone } from '../../common/index.js'
+
+const startId = 6
+const storeInit = {
+ 0: { name: 'Jane Doe', key: 'a', id: 0 },
+ 1: { name: 'Jack Doe', key: 'a', id: 1 },
+ 2: { name: 'John Doe', key: 'a', id: 2 },
+ 3: { name: 'Rick Doe', key: 'b', id: 3 },
+ 4: { name: 'Dick Doe', key: 'b', id: 4 },
+ 5: { name: 'Dork Doe', key: 'b', id: 5 },
+}
+
+let store
+let finalParams: any
+let innerCallParams: any
+
+function services(app: Application) {
+ app.configure(users)
+}
+
+function users(app: Application) {
+ store = clone(storeInit)
+
+ app.use(
+ 'users',
+ new MemoryService({
+ store,
+ startId,
+ multi: true,
+ }),
+ )
+
+ app.service('users').hooks({
+ before: {
+ all: [
+ (context: any) => {
+ if (context.params.disableStashBefore === true) {
+ innerCallParams = context.params
+ }
+ },
+ stashBefore(),
+ (context: any) => {
+ finalParams = context.params
+ },
+ ],
+ },
+ })
+}
+
+describe('stash-before', () => {
+ let app: Application<{ users: MemoryService }>
+ let users: any
+
+ beforeEach(() => {
+ innerCallParams = finalParams = null
+
+ app = feathers().configure(services)
+
+ users = app.service('users')
+ })
+
+ it(`stashes on 'update'`, async () => {
+ await users.update(0, {})
+
+ assert.deepEqual(finalParams.before, storeInit[0])
+ })
+
+ it(`stashes on 'patch'`, async () => {
+ await users.patch(0, {})
+
+ assert.deepEqual(finalParams.before, storeInit[0])
+ })
+
+ it(`stashes on 'remove'`, async () => {
+ await users.remove(0)
+
+ assert.deepEqual(finalParams.before, storeInit[0])
+ })
+
+ it("throws on 'create'", async () => {
+ await expect(users.create({})).rejects.toThrow()
+ })
+
+ it("throws on 'find'", async () => {
+ await expect(users.find({})).rejects.toThrow()
+ })
+
+ it("throws on 'get'", async () => {
+ await expect(users.get(0)).rejects.toThrow()
+ })
+
+ it('stashes on patch with custom params', async () => {
+ await users.patch(0, {}, { provider: 'socketio', eyecatcher: -1 })
+
+ assert.equal(finalParams.provider, 'socketio')
+ assert.equal(finalParams.eyecatcher, -1)
+
+ assert.equal(innerCallParams.provider, 'socketio')
+ assert.property(innerCallParams, 'eyecatcher')
+ })
+
+ it('stashes multi patch', async () => {
+ const items = [storeInit[0], storeInit[1], storeInit[2]]
+ await users.patch(null, { key: 'c' }, { query: { id: { $in: items.map(x => x.id) } } })
+
+ assert.deepEqual(finalParams.before, items)
+ })
+
+ it('stashes multi remove', async () => {
+ const items = [storeInit[0], storeInit[1], storeInit[2]]
+ await users.remove(null, { query: { id: { $in: items.map(x => x.id) } } })
+
+ assert.deepEqual(finalParams.before, items)
+ })
+})
diff --git a/src/hooks/stash-before/stash-before.ts b/src/hooks/stash-before/stash-before.ts
new file mode 100755
index 00000000..d3e23eb4
--- /dev/null
+++ b/src/hooks/stash-before/stash-before.ts
@@ -0,0 +1,41 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { checkContext } from '../../utils/index.js'
+
+/**
+ * Stash current value of record, usually before mutating it. Performs a get call.
+ * @see https://hooks-common.feathersjs.com/hooks.html#stashbefore
+ */
+export function stashBefore(fieldName?: string) {
+ const beforeField = fieldName || 'before'
+
+ return async (context: H, next?: NextFunction) => {
+ if (context.params.disableStashBefore) {
+ return context
+ }
+
+ checkContext(context, ['before', 'around'], ['update', 'patch', 'remove'], 'stashBefore')
+
+ const isMulti = context.id == null
+
+ const params = {
+ ...context.params,
+ disableStashBefore: true,
+ ...(isMulti ? { paginate: false } : {}),
+ }
+
+ await (!isMulti ? context.service.get(context.id, params) : context.service.find(params))
+ .then((result: any) => {
+ context.params[beforeField] = result
+ return context
+ })
+ .catch(() => {
+ return context
+ })
+
+ if (next) {
+ return await next()
+ }
+
+ return context
+ }
+}
diff --git a/src/hooks/throw-if-is-multi/throw-if-is-multi.md b/src/hooks/throw-if-is-multi/throw-if-is-multi.md
new file mode 100644
index 00000000..4430acfe
--- /dev/null
+++ b/src/hooks/throw-if-is-multi/throw-if-is-multi.md
@@ -0,0 +1,9 @@
+---
+title: throwIfIsMulti
+description: Throw an error if the hook is called with multiple records.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
diff --git a/src/hooks/throw-if-is-multi/throw-if-is-multi.test.ts b/src/hooks/throw-if-is-multi/throw-if-is-multi.test.ts
new file mode 100644
index 00000000..c1d9812f
--- /dev/null
+++ b/src/hooks/throw-if-is-multi/throw-if-is-multi.test.ts
@@ -0,0 +1,146 @@
+import { BadRequest } from '@feathersjs/errors'
+import { throwIfIsMulti } from './throw-if-is-multi.js'
+import type { HookContext } from '@feathersjs/feathers'
+
+describe('throwIfIsMulti', () => {
+ describe('general', () => {
+ it('does not throw on find', async () => {
+ const context = {
+ method: 'find',
+ params: { query: { name: 'item1' } },
+ } as HookContext
+
+ await throwIfIsMulti()(context)
+ })
+
+ it('does not throw on get', async () => {
+ const context = {
+ method: 'get',
+ id: 'item1',
+ } as HookContext
+ await throwIfIsMulti()(context)
+ })
+
+ it('does not throw on single create', async () => {
+ const context = {
+ method: 'create',
+ data: { name: 'item1' },
+ } as HookContext
+
+ await throwIfIsMulti()(context)
+ })
+
+ it('does not throw on single update', async () => {
+ const context = {
+ method: 'update',
+ id: 'item1',
+ data: { name: 'item1' },
+ } as HookContext
+
+ await throwIfIsMulti()(context)
+ })
+
+ it('does not throw on single patch', async () => {
+ const context = {
+ method: 'patch',
+ id: 'item1',
+ data: { name: 'item1' },
+ } as HookContext
+
+ await throwIfIsMulti()(context)
+ })
+
+ it('does not throw on single remove', async () => {
+ const context = {
+ method: 'remove',
+ id: 'item1',
+ } as HookContext
+
+ await throwIfIsMulti()(context)
+ })
+ })
+
+ it('throws on multi create by default', async () => {
+ const context = {
+ method: 'create',
+ data: [{ name: 'item1' }, { name: 'item2' }],
+ } as HookContext
+
+ await expect(() => throwIfIsMulti()(context)).rejects.toThrow(BadRequest)
+ })
+
+ it('throws on multi patch by default', async () => {
+ const context = {
+ method: 'patch',
+ id: null,
+ data: { name: 'item1' },
+ } as any as HookContext
+
+ await expect(() => throwIfIsMulti()(context)).rejects.toThrow(BadRequest)
+ })
+
+ it('throws on multi remove by default', async () => {
+ const context = {
+ method: 'remove',
+ id: null,
+ } as any as HookContext
+
+ await expect(() => throwIfIsMulti()(context)).rejects.toThrow(BadRequest)
+ })
+
+ describe('with filter', () => {
+ it('filter function has context as argument', async () => {
+ const filterFn = vi.fn(() => true)
+ const context = {
+ method: 'create',
+ data: [{ name: 'item1' }, { name: 'item2' }],
+ } as HookContext
+ await expect(() => throwIfIsMulti({ filter: filterFn })(context)).rejects.toThrow(BadRequest)
+ expect(filterFn).toHaveBeenCalledWith(context)
+ })
+
+ it('does not throw on multi create if filter returns false', async () => {
+ const context = {
+ method: 'create',
+ data: [{ name: 'item1' }, { name: 'item2' }],
+ } as HookContext
+
+ await expect(() => throwIfIsMulti()(context)).rejects.toThrow(BadRequest)
+
+ // sync
+ await expect(
+ throwIfIsMulti({
+ filter: () => false,
+ })(context),
+ ).resolves.not.toThrow()
+
+ // async
+ await expect(
+ throwIfIsMulti({
+ filter: async () => false,
+ })(context),
+ ).resolves.not.toThrow()
+ })
+
+ it('throws on multi create if filter returns true', async () => {
+ const context = {
+ method: 'create',
+ data: [{ name: 'item1' }, { name: 'item2' }],
+ } as HookContext
+
+ // sync
+ await expect(() =>
+ throwIfIsMulti({
+ filter: () => true,
+ })(context),
+ ).rejects.toThrow()
+
+ // async
+ await expect(() =>
+ throwIfIsMulti({
+ filter: async () => true,
+ })(context),
+ ).rejects.toThrow()
+ })
+ })
+})
diff --git a/src/hooks/throw-if-is-multi/throw-if-is-multi.ts b/src/hooks/throw-if-is-multi/throw-if-is-multi.ts
new file mode 100644
index 00000000..eb68c46b
--- /dev/null
+++ b/src/hooks/throw-if-is-multi/throw-if-is-multi.ts
@@ -0,0 +1,23 @@
+import type { HookContext } from '@feathersjs/feathers'
+import type { PredicateFn } from '../../types.js'
+import { type FeathersError } from '@feathersjs/errors'
+import { every, isMulti } from '../../predicates/index.js'
+import { throwIf } from '../throw-if/throw-if.js'
+
+export type ThrowIfIsMultiOptions = {
+ filter?: PredicateFn
+ error?: (context: HookContext) => FeathersError
+}
+
+export const throwIfIsMulti = (
+ options?: ThrowIfIsMultiOptions,
+) =>
+ throwIf(
+ every(
+ every(isMulti, context => context.method !== 'find'),
+ options?.filter,
+ ),
+ {
+ error: options?.error,
+ },
+ )
diff --git a/src/hooks/throw-if-is-provider/throw-if-is-provider.md b/src/hooks/throw-if-is-provider/throw-if-is-provider.md
new file mode 100644
index 00000000..7c0dbfaf
--- /dev/null
+++ b/src/hooks/throw-if-is-provider/throw-if-is-provider.md
@@ -0,0 +1,9 @@
+---
+title: throwIfIsProvider
+description: Throw an error if the hook is called with a specific provider.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
diff --git a/src/hooks/throw-if-is-provider/throw-if-is-provider.test.ts b/src/hooks/throw-if-is-provider/throw-if-is-provider.test.ts
new file mode 100644
index 00000000..c1ef8bf9
--- /dev/null
+++ b/src/hooks/throw-if-is-provider/throw-if-is-provider.test.ts
@@ -0,0 +1,37 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { throwIfIsProvider } from './throw-if-is-provider.js'
+import { MethodNotAllowed } from '@feathersjs/errors'
+
+describe('throwIfIsProvider', () => {
+ it('should throw if provider matches', async () => {
+ const context = {
+ method: 'create',
+ params: { provider: 'rest' },
+ } as HookContext
+
+ await expect(() => throwIfIsProvider(['rest', 'socketio'])(context)).rejects.toThrow(
+ MethodNotAllowed,
+ )
+ })
+
+ it('should not throw on provider mismatch', async () => {
+ const context = {
+ method: 'create',
+ params: { provider: 'rest' },
+ } as HookContext
+ await expect(throwIfIsProvider(['socketio'])(context)).resolves.not.toThrow()
+ })
+
+ it('can use options.filter', async () => {
+ const context = {
+ method: 'create',
+ params: { provider: 'rest' },
+ } as HookContext
+
+ await expect(
+ throwIfIsProvider(['rest', 'socketio'], {
+ filter: ctx => ctx.method === 'find',
+ })(context),
+ ).resolves.not.toThrow("Provider 'rest' can not call 'create'.")
+ })
+})
diff --git a/src/hooks/throw-if-is-provider/throw-if-is-provider.ts b/src/hooks/throw-if-is-provider/throw-if-is-provider.ts
new file mode 100644
index 00000000..4d7f6caa
--- /dev/null
+++ b/src/hooks/throw-if-is-provider/throw-if-is-provider.ts
@@ -0,0 +1,25 @@
+import type { HookContext } from '@feathersjs/feathers'
+import type { PredicateFn, TransportName } from '../../types.js'
+import type { ThrowIfOptions } from '../throw-if/throw-if.js'
+import { throwIf } from '../throw-if/throw-if.js'
+import { toArray } from 'lodash'
+import { every, isProvider } from '../../predicates/index.js'
+import { MethodNotAllowed } from '@feathersjs/errors'
+
+const defaultError = (context: HookContext) =>
+ new MethodNotAllowed(`Provider '${context.params.provider}' can not call '${context.method}'.`)
+
+export type ThrowIfIsIsProviderOptions = ThrowIfOptions & {
+ filter?: PredicateFn
+}
+
+export const throwIfIsProvider = (
+ transports: TransportName | TransportName[],
+ options?: ThrowIfIsIsProviderOptions,
+) => {
+ const disallowTransports = toArray(transports)
+
+ return throwIf(every(isProvider(...(disallowTransports as any)), options?.filter), {
+ error: options?.error ?? defaultError,
+ })
+}
diff --git a/src/hooks/throw-if/throw-if.md b/src/hooks/throw-if/throw-if.md
new file mode 100644
index 00000000..56b35554
--- /dev/null
+++ b/src/hooks/throw-if/throw-if.md
@@ -0,0 +1,9 @@
+---
+title: throwIf
+description: Throw an error if the hook is called with certain conditions.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['create', 'update', 'patch']
+ multi: true
+---
diff --git a/src/hooks/throw-if/throw-if.test.ts b/src/hooks/throw-if/throw-if.test.ts
new file mode 100644
index 00000000..e3c46e97
--- /dev/null
+++ b/src/hooks/throw-if/throw-if.test.ts
@@ -0,0 +1,23 @@
+import { BadRequest, GeneralError } from '@feathersjs/errors'
+import { throwIf } from './throw-if.js'
+import type { HookContext } from '@feathersjs/feathers'
+
+describe('throwIf', () => {
+ it('throws BadRequest if no error function is provided', async () => {
+ await expect(() => throwIf(() => true)({} as HookContext)).rejects.toThrow(BadRequest)
+ })
+
+ it('should throw an error if the predicate returns true', async () => {
+ await expect(() =>
+ throwIf(() => true, { error: () => new GeneralError('Test error') })({} as HookContext),
+ ).rejects.toThrow(GeneralError)
+ })
+
+ it('async predicate should throw an error if it returns true', async () => {
+ await expect(() =>
+ throwIf(async () => true, { error: () => new GeneralError('Async test error') })(
+ {} as HookContext,
+ ),
+ ).rejects.toThrow(GeneralError)
+ })
+})
diff --git a/src/hooks/throw-if/throw-if.ts b/src/hooks/throw-if/throw-if.ts
new file mode 100644
index 00000000..3607ac67
--- /dev/null
+++ b/src/hooks/throw-if/throw-if.ts
@@ -0,0 +1,27 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import type { PredicateFn } from '../../types.js'
+import { BadRequest } from '@feathersjs/errors'
+import type { FeathersError } from '@feathersjs/errors'
+
+export type ThrowIfOptions = {
+ error?: (context: HookContext) => FeathersError
+}
+
+export const throwIf = (
+ predicate: PredicateFn,
+ options?: ThrowIfOptions,
+) => {
+ return async (context: H, next?: NextFunction) => {
+ const result = await predicate(context)
+
+ if (result) {
+ throw options?.error ? options.error(context) : new BadRequest('Invalid operation')
+ }
+
+ if (next) {
+ await next()
+ }
+
+ return context
+ }
+}
diff --git a/src/hooks/transform-data/transform-data.md b/src/hooks/transform-data/transform-data.md
new file mode 100644
index 00000000..163ff5ee
--- /dev/null
+++ b/src/hooks/transform-data/transform-data.md
@@ -0,0 +1,81 @@
+---
+title: transformData
+description: Make changes to data or result items. Very flexible.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['create', 'update', 'patch', 'remove']
+ multi: true
+ source:
+---
+
+## Arguments
+
+- `{Function} func`
+
+| Argument | Type | Default | Description |
+| -------- | :--------: | --------------------------- | --------------------------------------------- |
+| `func` | `Function` | `(item,` `context) =>` `{}` | Function modifies `item` in place. See below. |
+
+- **returns**
+
+The mutated `item`. Returning `undefined` means the `item` in the parameters was mutated in place. returns result `undefined || item`
+
+## Example
+
+```js
+const { alterItems } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: {
+ all: [
+ alterItems(rec => { delete rec.password; }) // Like `discard('password')`.
+ alterItems(rec => rec.email = email.lowerCase()), // Like `lowerCase('email')`.
+ ],
+} };
+```
+
+Async mutations can be handled with async/await:
+
+```js
+alterItems(rec => {
+ rec.userRecord = (async () => await service.get(...) )()
+})
+```
+
+You can also perform async mutations using Promises by returning a Promise that is resolved once all mutations are complete:
+
+```js
+alterItems(rec => new Promise(resolve => {
+ service.get(...).then(result => {
+ rec.userRecord = result;
+ resolve();
+}});
+```
+
+You can also perform async mutations using Promises by returning a Promise that is resolved once all mutations are complete:
+
+```js
+alterItems(async rec => {
+ rec.userRecord = await service.get(...);
+})
+```
+
+## Details
+
+The declarative nature of most of the common hooks, e.g. `discard('password')`, requires you to remember the names of a fair number of hooks, their parameters, and any possible nuances.
+
+The `alterItems` hook offers an imperative alternative where you directly alter the items. It allows you to reduce the number of trivial hooks you have to register, and you are aware of exactly what your `alterItems` hooks do.
+
+`func` is called for each item in `context.data` (before hook) or `context.result[.data]` (after hook). It receives the parameters
+
+- `{Object} item`
+- `{Object} context`
+
+| Argument | Type | Description |
+| --------- | :------: | ---------------------------------------------------------------------- |
+| `item` | `Object` | The item. The function modifies it in place. |
+| `context` | `Object` | The current context. It contains any alterations made to items so far. |
+
+- **Returns**
+
+ `func` may alternatively return a replacement `item` rather than `undefined`. This is a convenience feature which permits, for example, use of functions from the [Lodash](https://lodash.com/) library, as such functions tend to return new objects.
diff --git a/src/hooks/transform-data/transform-data.test.ts b/src/hooks/transform-data/transform-data.test.ts
new file mode 100755
index 00000000..4b4f375d
--- /dev/null
+++ b/src/hooks/transform-data/transform-data.test.ts
@@ -0,0 +1,94 @@
+import { assert } from 'vitest'
+import { transformData } from './transform-data.js'
+
+let hookBefore: any
+let hookCreateMulti: any
+
+describe('transformData', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: { first: 'John', last: 'Doe' },
+ }
+ hookCreateMulti = {
+ type: 'before',
+ method: 'create',
+ params: { provider: 'rest' },
+ data: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ }
+ })
+
+ it('context is 2nd param', () => {
+ let contextParam
+ transformData((_rec: any, context: any) => {
+ contextParam = context
+ })(hookBefore)
+ assert.deepEqual(contextParam, hookBefore)
+ })
+
+ it('updates hook before::create', () => {
+ transformData((rec: any) => {
+ rec.state = 'UT'
+ })(hookBefore)
+ assert.deepEqual(hookBefore.data, { first: 'John', last: 'Doe', state: 'UT' })
+ })
+
+ it('updates hook before::create::multi', () => {
+ transformData((rec: any) => {
+ rec.state = 'UT'
+ })(hookCreateMulti)
+ assert.deepEqual(hookCreateMulti.data, [
+ { first: 'John', last: 'Doe', state: 'UT' },
+ { first: 'Jane', last: 'Doe', state: 'UT' },
+ ])
+ })
+
+ it('updates hook before::create with new item returned', () => {
+ transformData((rec: any) => Object.assign({}, rec, { state: 'UT' }))(hookBefore)
+ assert.deepEqual(hookBefore.data, { first: 'John', last: 'Doe', state: 'UT' })
+ })
+
+ it('returns a promise that contains context', async () => {
+ const promise = transformData((rec: any) => {
+ rec.state = 'UT'
+ return Promise.resolve()
+ })(hookBefore)
+
+ assert.ok(promise instanceof Promise)
+
+ const result = await promise
+
+ assert.deepEqual(result, hookBefore)
+ })
+
+ it('updates hook before::create with new item returned', async () => {
+ await transformData((rec: any) => Promise.resolve(Object.assign({}, rec, { state: 'UT' })))(
+ hookBefore,
+ )
+
+ assert.deepEqual(hookBefore.data, { first: 'John', last: 'Doe', state: 'UT' })
+ })
+
+ it('updates hook before::create async', async () => {
+ const alterFunc = (rec: any) => {
+ rec.state = 'UT'
+ return Promise.resolve()
+ }
+ await transformData(alterFunc)(hookBefore)
+
+ assert.deepEqual(hookBefore.data, { first: 'John', last: 'Doe', state: 'UT' })
+ })
+
+ it('updates hook before::create async with new item returned', async () => {
+ const alterFunc = (rec: any) => Promise.resolve(Object.assign({}, rec, { state: 'UT' }))
+
+ await transformData(alterFunc)(hookBefore)
+
+ assert.deepEqual(hookBefore.data, { first: 'John', last: 'Doe', state: 'UT' })
+ })
+})
diff --git a/src/hooks/transform-data/transform-data.ts b/src/hooks/transform-data/transform-data.ts
new file mode 100755
index 00000000..687b9f74
--- /dev/null
+++ b/src/hooks/transform-data/transform-data.ts
@@ -0,0 +1,27 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { replaceData } from '../../utils/replace-data/replace-data.js'
+import { isPromise } from '../../common/index.js'
+
+/**
+ * Make changes to data items. Very flexible.
+ * @see https://hooks-common.feathersjs.com/hooks.html#alteritems
+ */
+export const transformData =
+ (cb: (record: T, context: H) => any) =>
+ async (context: H, next?: NextFunction) => {
+ await replaceData(context, (item: any) => {
+ const result = cb(item, context)
+
+ if (isPromise(result)) {
+ return result.then((res: any) => res ?? item)
+ } else {
+ return result ?? item
+ }
+ })
+
+ if (next) {
+ return next()
+ }
+
+ return context
+ }
diff --git a/src/hooks/transform-result/transform-result.md b/src/hooks/transform-result/transform-result.md
new file mode 100644
index 00000000..6448ee93
--- /dev/null
+++ b/src/hooks/transform-result/transform-result.md
@@ -0,0 +1,9 @@
+---
+title: transformResult
+description: Transform the result of a service method.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+ multi: true
+---
diff --git a/src/hooks/transform-result/transform-result.test.ts b/src/hooks/transform-result/transform-result.test.ts
new file mode 100755
index 00000000..7988ff99
--- /dev/null
+++ b/src/hooks/transform-result/transform-result.test.ts
@@ -0,0 +1,204 @@
+import { assert } from 'vitest'
+import { transformResult } from './transform-result.js'
+import type { HookContext } from '@feathersjs/feathers'
+
+let hookAfter: any
+let hookFindPaginate: any
+let hookFind: any
+
+describe('transformResult', () => {
+ beforeEach(() => {
+ hookAfter = {
+ type: 'after',
+ method: 'create',
+ params: { provider: 'rest' },
+ result: { first: 'Jane', last: 'Doe' },
+ }
+ hookFindPaginate = {
+ type: 'after',
+ method: 'find',
+ params: { provider: 'rest' },
+ result: {
+ total: 2,
+ data: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ },
+ }
+ hookFind = {
+ type: 'after',
+ method: 'find',
+ params: { provider: 'rest' },
+ result: [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ],
+ }
+ })
+
+ it('updates hook after::find with pagination', () => {
+ transformResult((rec: any) => {
+ delete rec.last
+ })(hookFindPaginate)
+
+ assert.deepEqual(hookFindPaginate.result.data, [{ first: 'John' }, { first: 'Jane' }])
+ })
+
+ it('updates hook after::find with no pagination', () => {
+ transformResult((rec: any) => {
+ rec.new = rec.first
+ })(hookFind)
+
+ assert.deepEqual(hookFind.result, [
+ { first: 'John', last: 'Doe', new: 'John' },
+ { first: 'Jane', last: 'Doe', new: 'Jane' },
+ ])
+ })
+
+ it('updates hook after', () => {
+ transformResult((rec: any) => {
+ rec.new = rec.first
+ })(hookAfter)
+
+ assert.deepEqual(hookAfter.result, { first: 'Jane', last: 'Doe', new: 'Jane' })
+ })
+
+ it('updates hook after::find with pagination with new item returned', () => {
+ transformResult((rec: any) => Object.assign({}, { first: rec.first }))(hookFindPaginate)
+
+ assert.deepEqual(hookFindPaginate.result.data, [{ first: 'John' }, { first: 'Jane' }])
+ })
+
+ it('updates hook after::find with pagination with new item returned', () => {
+ transformResult((rec: any) => Object.assign({}, rec, { new: rec.first }))(hookFind)
+
+ assert.deepEqual(hookFind.result, [
+ { first: 'John', last: 'Doe', new: 'John' },
+ { first: 'Jane', last: 'Doe', new: 'Jane' },
+ ])
+ })
+
+ it('updates hook after with new item returned', () => {
+ transformResult((rec: any) => Object.assign({}, rec, { new: rec.first }))(hookAfter)
+
+ assert.deepEqual(hookAfter.result, { first: 'Jane', last: 'Doe', new: 'Jane' })
+ })
+
+ it('updates hook after::create', async () => {
+ await transformResult((rec: any) => {
+ rec.new = rec.first
+ return Promise.resolve()
+ })(hookAfter)
+
+ assert.deepEqual(hookAfter.result, { first: 'Jane', last: 'Doe', new: 'Jane' })
+ })
+
+ it('updates hook after::create with new item returned', async () => {
+ await transformResult((rec: any) =>
+ Promise.resolve(Object.assign({}, rec, { new: rec.first })),
+ )(hookAfter)
+
+ assert.deepEqual(hookAfter.result, { first: 'Jane', last: 'Doe', new: 'Jane' })
+ })
+
+ it('updates hook after::find with pagination', async () => {
+ await transformResult((rec: any) => {
+ delete rec.last
+ return Promise.resolve()
+ })(hookFindPaginate)
+
+ assert.deepEqual(hookFindPaginate.result.data, [{ first: 'John' }, { first: 'Jane' }])
+ })
+
+ it('updates hook after::find with no pagination', async () => {
+ await transformResult((rec: any) => {
+ rec.new = rec.first
+ return Promise.resolve()
+ })(hookFind)
+
+ assert.deepEqual(hookFind.result, [
+ { first: 'John', last: 'Doe', new: 'John' },
+ { first: 'Jane', last: 'Doe', new: 'Jane' },
+ ])
+ })
+
+ it('updates hook after::find with pagination with new item returned', async () => {
+ await transformResult((rec: any) => Promise.resolve(Object.assign({}, { first: rec.first })))(
+ hookFindPaginate,
+ )
+
+ assert.deepEqual(hookFindPaginate.result.data, [{ first: 'John' }, { first: 'Jane' }])
+ })
+
+ it('updates hook after::find with no pagination with new item returned', async () => {
+ await transformResult((rec: any) =>
+ Promise.resolve(Object.assign({}, rec, { new: rec.first })),
+ )(hookFind)
+
+ assert.deepEqual(hookFind.result, [
+ { first: 'John', last: 'Doe', new: 'John' },
+ { first: 'Jane', last: 'Doe', new: 'Jane' },
+ ])
+ })
+
+ it('updates dispatch', () => {
+ const context = {
+ type: 'after',
+ method: 'create',
+ params: { provider: 'rest' },
+ result: { first: 'Jane', last: 'Doe' },
+ dispatch: { first: 'Jack', last: 'Doe' },
+ } as HookContext
+
+ transformResult(
+ (rec: any) => {
+ rec.new = rec.first
+ },
+ { dispatch: true },
+ )(context)
+
+ assert.deepEqual(context.result, { first: 'Jane', last: 'Doe' })
+ assert.deepEqual(context.dispatch, { first: 'Jack', last: 'Doe', new: 'Jack' })
+ })
+
+ it('updates dispatch even though it is not defined', () => {
+ const context = {
+ type: 'after',
+ method: 'create',
+ params: { provider: 'rest' },
+ result: { first: 'Jane', last: 'Doe' },
+ dispatch: undefined,
+ } as HookContext
+
+ transformResult(
+ (rec: any) => {
+ rec.new = rec.first
+ },
+ { dispatch: true },
+ )(context)
+
+ assert.deepEqual(context.result, { first: 'Jane', last: 'Doe' })
+ assert.deepEqual(context.dispatch, { first: 'Jane', last: 'Doe', new: 'Jane' })
+ })
+
+ it('updates dispatch and result', () => {
+ const context = {
+ type: 'after',
+ method: 'create',
+ params: { provider: 'rest' },
+ result: { first: 'Jane', last: 'Doe' },
+ dispatch: { first: 'Jack', last: 'Doe' },
+ } as HookContext
+
+ transformResult(
+ (rec: any) => {
+ rec.new = rec.first
+ },
+ { dispatch: 'both' },
+ )(context)
+
+ assert.deepEqual(context.result, { first: 'Jane', last: 'Doe', new: 'Jane' })
+ assert.deepEqual(context.dispatch, { first: 'Jack', last: 'Doe', new: 'Jack' })
+ })
+})
diff --git a/src/hooks/transform-result/transform-result.ts b/src/hooks/transform-result/transform-result.ts
new file mode 100755
index 00000000..88b64aeb
--- /dev/null
+++ b/src/hooks/transform-result/transform-result.ts
@@ -0,0 +1,35 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { isPromise } from '../../common/index.js'
+import { replaceResult } from '../../utils/replace-result/replace-result.js'
+import type { DispatchOption } from '../../types.js'
+
+export type TransformResultOptions = {
+ dispatch?: DispatchOption
+}
+
+/**
+ * Make changes to result items. Very flexible.
+ * @see https://hooks-common.feathersjs.com/hooks.html#alteritems
+ */
+export const transformResult =
+ (
+ cb: (record: T, context: H) => any,
+ options?: TransformResultOptions,
+ ) =>
+ (context: H, next?: NextFunction) =>
+ replaceResult(
+ context,
+ (item: any) => {
+ const result = cb(item, context)
+
+ if (isPromise(result)) {
+ return result.then((res: any) => res ?? item)
+ } else {
+ return result ?? item
+ }
+ },
+ {
+ next,
+ dispatch: options?.dispatch,
+ },
+ )
diff --git a/src/hooks/traverse/traverse.md b/src/hooks/traverse/traverse.md
new file mode 100644
index 00000000..0e20fb62
--- /dev/null
+++ b/src/hooks/traverse/traverse.md
@@ -0,0 +1,50 @@
+---
+title: traverse
+description: Transform fields & objects in place in the record(s) using a recursive walk. Powerful.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+ multi: true
+---
+
+## Arguments
+
+- `{Function} transformer`
+- `{Function} [ getObject ]`
+
+| Argument | Type | Default | Description |
+| ------------- | :--------: | ----------------------------------------- | ----------------------------------------------------------------------------- |
+| `transformer` | `Function` | | Called for every node in every record(s). May change the node in place. |
+| `getObject` | `Function` | `context.data` or `context.result[.data]` | Function with signature `context => {}` which returns the object to traverse. |
+
+## Example
+
+```js
+const { traverse } = require('feathers-hooks-common/index.js');
+
+// Trim strings
+const trimmer = function (node) {
+ if (typeof node === 'string') {
+ this.update(node.trim());
+ }
+};
+
+// REST HTTP request may use the string 'null' in its query string.
+// Replace these strings with the value null.
+const nuller = function (node) {
+ if (node === 'null') {
+ this.update(null);
+ }
+};
+
+module.exports = {
+ before: { create: traverse(trimmer), find: traverse(nuller, context => context.params.query) },
+};
+```
+
+## Details
+
+Traverse and transform objects in place by visiting every node on a recursive walk. Any object in the hook may be traversed, including the query object.
+
+> [traverse (NPM)](https://npmjs.com/package/traverse) documents the extensive methods and context available to the transformer function.
diff --git a/src/hooks/traverse/traverse.test.ts b/src/hooks/traverse/traverse.test.ts
new file mode 100755
index 00000000..3d9a689c
--- /dev/null
+++ b/src/hooks/traverse/traverse.test.ts
@@ -0,0 +1,112 @@
+import { assert } from 'vitest'
+import { traverse } from './traverse.js'
+import { clone } from '../../common/index.js'
+
+describe('traverse', () => {
+ let hookBefore: any
+ let hookBeforeArray: any
+ let trimmer: any
+ let hookAfter: any
+ let hookAfterArray: any
+
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ data: { a: ' a b ' },
+ params: { query: { b: ' b b ' } },
+ }
+
+ hookBeforeArray = {
+ type: 'before',
+ method: 'create',
+ data: [{ a: ' a b ' }, { c: ' c ' }],
+ params: { query: { b: ' b b ' }, something: { c: ' c', d: 'd ' } },
+ }
+
+ hookAfter = {
+ type: 'after',
+ method: 'create',
+ data: { q: 1 },
+ params: { query: { b: ' b b ' } },
+ result: { a: ' a b ' },
+ }
+
+ hookAfterArray = {
+ type: 'after',
+ method: 'create',
+ data: { q: 1 },
+ params: { query: { b: ' b b ' } },
+ result: [{ a: ' a b ' }, { c: ' c ' }],
+ }
+
+ trimmer = function (this: any, node: any) {
+ if (typeof node === 'string') {
+ this.update(node.trim())
+ }
+ }
+ })
+
+ it('transforms hook.data single item', () => {
+ const result = clone(hookBefore)
+ result.data = { a: 'a b' }
+
+ traverse(trimmer)(hookBefore)
+
+ assert.deepEqual(hookBefore, result)
+ })
+
+ it('transforms hook.data array of items', () => {
+ const result = clone(hookBeforeArray)
+ result.data = [{ a: 'a b' }, { c: 'c' }]
+
+ traverse(trimmer)(hookBeforeArray)
+
+ assert.deepEqual(hookBeforeArray, result)
+ })
+
+ it('transforms hook.result single item', () => {
+ const result = clone(hookAfter)
+ result.result = { a: 'a b' }
+
+ traverse(trimmer)(hookAfter)
+
+ assert.deepEqual(hookAfter, result)
+ })
+
+ it('transforms hook.result array of items', () => {
+ const result = clone(hookAfterArray)
+ result.result = [{ a: 'a b' }, { c: 'c' }]
+
+ traverse(trimmer)(hookAfterArray)
+
+ assert.deepEqual(hookAfterArray, result)
+ })
+
+ it('transforms hook.params.query', () => {
+ const result = clone(hookBefore)
+ result.params.query = { b: 'b b' }
+
+ traverse(trimmer, (hook: any) => hook.params.query)(hookBefore)
+
+ assert.deepEqual(hookBefore, result)
+ })
+
+ it('transforms multiple objects within a hook', () => {
+ const result = clone(hookBeforeArray)
+ result.params = { query: { b: 'b b' }, something: { c: 'c', d: 'd' } }
+
+ traverse(trimmer, (hook: any) => [hook.params.query, hook.params.something])(hookBeforeArray)
+
+ assert.deepEqual(hookBeforeArray, result)
+ })
+
+ it('transforms objects', () => {
+ const obj: any = { query: { b: 'b b' }, something: { c: 'c', d: 'd' } }
+ const result = clone(obj)
+
+ traverse(trimmer, obj)(hookBeforeArray)
+
+ assert.deepEqual(obj, result)
+ })
+})
diff --git a/src/hooks/traverse.ts b/src/hooks/traverse/traverse.ts
similarity index 54%
rename from src/hooks/traverse.ts
rename to src/hooks/traverse/traverse.ts
index 7666f25c..6571efd9 100755
--- a/src/hooks/traverse.ts
+++ b/src/hooks/traverse/traverse.ts
@@ -1,7 +1,7 @@
-import type { HookContext } from '@feathersjs/feathers';
-import { traverse as _traverse } from '../common';
-import type { SyncContextFunction } from '../types';
-import { getItems } from '../utils/get-items';
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { traverse as _traverse } from '../../common/index.js'
+import type { SyncContextFunction } from '../../types.js'
+import { getItems } from '../../utils/index.js'
/**
* Transform fields & objects in place in the record(s) using a recursive walk. Powerful.
@@ -12,11 +12,16 @@ export function traverse(
transformer: (transformContext: any) => any,
getObject?: SyncContextFunction,
) {
- return (context: H) => {
+ return (context: H, next?: NextFunction) => {
const items =
- typeof getObject === 'function' ? getObject(context) : getObject || getItems(context);
+ typeof getObject === 'function' ? getObject(context) : getObject || getItems(context)
- _traverse(items, transformer);
- return context;
- };
+ _traverse(items, transformer)
+
+ if (next) {
+ return next()
+ }
+
+ return context
+ }
}
diff --git a/src/hooks/trim-data/trim-data.md b/src/hooks/trim-data/trim-data.md
new file mode 100644
index 00000000..7fa9d7d6
--- /dev/null
+++ b/src/hooks/trim-data/trim-data.md
@@ -0,0 +1,9 @@
+---
+title: trimData
+description: Trim whitespace from string fields in the result.
+category: hooks
+hook:
+ type: ['before', 'around']
+ method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+ multi: true
+---
diff --git a/src/hooks/trim-data/trim-data.test.ts b/src/hooks/trim-data/trim-data.test.ts
new file mode 100755
index 00000000..7aa97e7b
--- /dev/null
+++ b/src/hooks/trim-data/trim-data.test.ts
@@ -0,0 +1,76 @@
+import { assert } from 'vitest'
+import type { HookContext } from '@feathersjs/feathers'
+import { trimData } from './trim-data.js'
+
+describe('trimData', () => {
+ it('updates hook before::create', () => {
+ const context = {
+ type: 'before',
+ method: 'create',
+ data: { first: ' John', last: 'Doe ' },
+ } as HookContext
+ trimData(['first', 'last'])(context)
+ assert.deepEqual(context.data, { first: 'John', last: 'Doe' })
+ })
+
+ it('does not throw if field is missing', () => {
+ const context = { type: 'before', method: 'create', data: { last: ' Doe ' } } as HookContext
+ trimData(['first', 'last'])(context)
+ assert.deepEqual(context.data, { last: 'Doe' })
+ })
+
+ it('does not throw if field is undefined', () => {
+ const context = {
+ type: 'before',
+ method: 'create',
+ data: { first: undefined, last: ' Doe' },
+ } as HookContext
+ trimData(['first', 'last'])(context)
+ assert.deepEqual(context.data, { first: undefined, last: 'Doe' })
+ })
+
+ it('does not throw if field is null', () => {
+ const context = {
+ type: 'before',
+ method: 'create',
+ data: { first: null, last: 'Doe ' },
+ } as HookContext
+ trimData(['first', 'last'])(context)
+ assert.deepEqual(context.data, { first: null, last: 'Doe' })
+ })
+
+ it('throws if field is not a string', async () => {
+ const context = {
+ type: 'before',
+ method: 'create',
+ data: { first: 1, last: 'Doe' },
+ } as HookContext
+ await expect(async () => {
+ await trimData(['first', 'last'])(context)
+ }).rejects.toThrow('Expected string data. (trim first)')
+ })
+
+ it('prop with 1 dot', () => {
+ const context = {
+ data: { empl: { name: { first: 'John', last: 'Doe' }, status: ' AA' }, dept: ' Acct' },
+ } as HookContext
+ trimData('empl.status')(context)
+
+ assert.deepEqual(context.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: ' Acct',
+ })
+ })
+
+ it('prop with 2 dots', () => {
+ const context = {
+ data: { empl: { name: { first: ' John', last: 'Doe' }, status: 'AA' }, dept: ' Acct' },
+ } as HookContext
+ trimData('empl.name.first')(context)
+
+ assert.deepEqual(context.data, {
+ empl: { name: { first: 'John', last: 'Doe' }, status: 'AA' },
+ dept: ' Acct',
+ })
+ })
+})
diff --git a/src/hooks/trim-data/trim-data.ts b/src/hooks/trim-data/trim-data.ts
new file mode 100755
index 00000000..ab29f9e1
--- /dev/null
+++ b/src/hooks/trim-data/trim-data.ts
@@ -0,0 +1,31 @@
+import _get from 'lodash/get.js'
+import _set from 'lodash/set.js'
+import { BadRequest } from '@feathersjs/errors'
+import { transformData } from '../transform-data/transform-data.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+/**
+ * Trim certain field values.
+ * @see https://hooks-common.feathersjs.com/hooks.html#trimData
+ */
+export const trimData = (fieldNames: MaybeArray) => {
+ const fieldNamesArr = toArray(fieldNames)
+
+ return transformData(item => {
+ for (let i = 0; i < fieldNamesArr.length; i++) {
+ const fieldName = fieldNamesArr[i]
+ const value = _get(item, fieldName)
+
+ if (value == null) {
+ continue
+ }
+
+ if (typeof value !== 'string') {
+ throw new BadRequest(`Expected string data. (trim ${fieldName})`)
+ }
+
+ _set(item, fieldName, value.trim())
+ }
+ })
+}
diff --git a/src/hooks/trim-result/trim-result.md b/src/hooks/trim-result/trim-result.md
new file mode 100644
index 00000000..c2791993
--- /dev/null
+++ b/src/hooks/trim-result/trim-result.md
@@ -0,0 +1,9 @@
+---
+title: trimResult
+description: Trim string properties in the result.
+category: hooks
+hook:
+ type: ['before', 'after', 'around']
+ method: ['find', 'get', 'create', 'update', 'patch', 'remove']
+ multi: true
+---
diff --git a/src/hooks/trim-result/trim-result.test.ts b/src/hooks/trim-result/trim-result.test.ts
new file mode 100755
index 00000000..6957fda3
--- /dev/null
+++ b/src/hooks/trim-result/trim-result.test.ts
@@ -0,0 +1,63 @@
+import { assert } from 'vitest'
+import { trimResult } from './trim-result.js'
+import type { HookContext } from '@feathersjs/feathers'
+
+describe('lowercaseResult', () => {
+ it('updates hook after::find with pagination', () => {
+ const context = {
+ type: 'after',
+ method: 'find',
+ result: {
+ total: 2,
+ data: [
+ { first: 'John ', last: ' Doe' },
+ { first: ' Jane ', last: 'Doe ' },
+ ],
+ },
+ } as HookContext
+
+ trimResult(['first', 'last'])(context)
+ assert.deepEqual(context.result.data, [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ])
+ })
+
+ it('updates hook after::find with no pagination', () => {
+ const context = {
+ type: 'after',
+ method: 'find',
+ result: [
+ { first: ' John', last: 'Doe ' },
+ { first: ' Jane ', last: ' Doe' },
+ ],
+ } as HookContext
+ trimResult(['first', 'last'])(context)
+ assert.deepEqual(context.result, [
+ { first: 'John', last: 'Doe' },
+ { first: 'Jane', last: 'Doe' },
+ ])
+ })
+
+ it('single result', () => {
+ const context = {
+ type: 'after',
+ method: 'create',
+ result: { first: ' Jane', last: 'Doe ' },
+ } as HookContext
+ trimResult(['first', 'last'])(context)
+
+ assert.deepEqual(context.result, { first: 'Jane', last: 'Doe' })
+ })
+
+ it('single result dot notation', () => {
+ const context = {
+ type: 'after',
+ method: 'create',
+ result: { first: { name: ' Jane' }, last: 'Doe ' },
+ } as HookContext
+ trimResult('first.name')(context)
+
+ assert.deepEqual(context.result, { first: { name: 'Jane' }, last: 'Doe ' })
+ })
+})
diff --git a/src/hooks/trim-result/trim-result.ts b/src/hooks/trim-result/trim-result.ts
new file mode 100755
index 00000000..d13c4bf0
--- /dev/null
+++ b/src/hooks/trim-result/trim-result.ts
@@ -0,0 +1,39 @@
+import _get from 'lodash/get.js'
+import _set from 'lodash/set.js'
+import { BadRequest } from '@feathersjs/errors'
+import { transformResult } from '../transform-result/transform-result.js'
+import type { DispatchOption } from '../../types.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+export type TrimResultOptions = {
+ dispatch?: DispatchOption
+}
+
+/**
+ * Convert certain field values to lower case.
+ * @see https://hooks-common.feathersjs.com/hooks.html#trimResult
+ */
+export const trimResult = (fieldNames: MaybeArray, options?: TrimResultOptions) => {
+ const fieldNamesArray = toArray(fieldNames)
+
+ return transformResult(
+ (item: any) => {
+ for (let i = 0; i < fieldNamesArray.length; i++) {
+ const fieldName = fieldNamesArray[i]
+ const value = _get(item, fieldName)
+
+ if (value == null) {
+ continue
+ }
+
+ if (typeof value !== 'string') {
+ throw new BadRequest(`Expected string data. (lowercase ${fieldName})`)
+ }
+
+ _set(item, fieldName, value.trim())
+ }
+ },
+ { dispatch: options?.dispatch },
+ )
+}
diff --git a/src/hooks/unless/unless.md b/src/hooks/unless/unless.md
new file mode 100644
index 00000000..3bca03fe
--- /dev/null
+++ b/src/hooks/unless/unless.md
@@ -0,0 +1,42 @@
+---
+title: unless
+description: Execute a series of hooks if a sync or async predicate is falsey.
+category: hooks
+hook:
+ type: ['before', 'after']
+ method: ['all']
+ multi: true
+---
+
+## Arguments
+
+- `{Boolean | Promise | Function} predicate`
+- `{Array< Function >} hookFuncs`
+
+| Argument | Type | Default | Description |
+| ----------- | :--------------------------------: | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `predicate` | `Boolean`, `Promise` or `Function` | | Run `hookFunc` if the `predicate` is false. If a function, `predicate` is called with the `context` as its param. It returns either a boolean or a Promise that evaluates to a boolean. |
+| `hookFuncs` | `Array<` `Function >` | | Sync or async hook functions to run if `true`. They may include other conditional hooks. |
+
+## Example
+
+```js
+const { isProvider, unless } = require('feathers-hooks-common/index.js');
+
+module.exports = {
+ before: {
+ create: unless(
+ isProvider('server'),
+ hookA,
+ unless(isProvider('rest'), hook1, hook2, hook3),
+ hookB,
+ ),
+ },
+};
+```
+
+## Details
+
+Resolve the predicate to a boolean. Run the hooks sequentially if the result is falsey.
+
+The predicate and hook functions will not be called with `this` set to the service, as is normal for hook functions. Use `hook.service` instead.
diff --git a/src/hooks/unless/unless.test.ts b/src/hooks/unless/unless.test.ts
new file mode 100755
index 00000000..ea4b8c82
--- /dev/null
+++ b/src/hooks/unless/unless.test.ts
@@ -0,0 +1,382 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { assert } from 'vitest'
+import { unless } from './unless.js'
+import { clone, isPromise } from '../../common/index.js'
+
+let hook: any
+let hookBefore: any
+let hookAfter: any
+let hookFcnSyncCalls: any
+let hookFcnAsyncCalls: any
+let hookFcnCalls: any
+let predicateHook: any
+let predicateOptions: any
+let predicateValue: any
+
+const predicateSync = (hook: any) => {
+ predicateHook = clone(hook)
+ return false
+}
+
+const predicateSync2 = (options: any) => (hook: any) => {
+ predicateOptions = clone(options)
+ predicateHook = clone(hook)
+ return false
+}
+
+const predicateAsync = (hook: any) => {
+ predicateHook = clone(hook)
+ return new Promise(resolve => resolve(false))
+}
+
+const predicateAsync2 = (options: any) => (hook: any) => {
+ predicateOptions = clone(options)
+ predicateHook = clone(hook)
+ return new Promise(resolve => resolve(false))
+}
+
+const predicateAsyncFunny = (hook: HookContext) => {
+ predicateHook = clone(hook)
+ return new Promise(resolve => {
+ predicateValue = null
+ return resolve(predicateValue)
+ })
+}
+
+const hookFcnSync = (hook: HookContext): HookContext => {
+ hookFcnSyncCalls = +1
+ hook.data.first = hook.data.first.toLowerCase()
+
+ return hook
+}
+
+const hookFcnAsync = (hook: HookContext) =>
+ new Promise(resolve => {
+ hookFcnAsyncCalls = +1
+ hook.data.first = hook.data.first.toLowerCase()
+
+ resolve(hook)
+ })
+
+const hookFcn = (hook: HookContext): HookContext => {
+ hookFcnCalls = +1
+
+ return hook
+}
+
+describe('sync predicate, sync hook', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('calls sync hook function if falsey non-function', () => {
+ unless(
+ false,
+ hookFcnSync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('does not call sync hook function if truthy non-function', () => {
+ const result = unless(true, hookFcnSync)(hook)
+
+ if (isPromise(result)) {
+ assert.fail('promise unexpectedly returned')
+ } else {
+ assert.deepEqual(result, hookBefore)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ }
+ })
+
+ it('calls sync hook function if sync predicate falsey', () => {
+ unless(
+ () => false,
+ hookFcnSync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('does not call sync hook function if sync predicate truthy', () => {
+ const result = unless(() => true, hookFcnSync)(hook)
+
+ if (isPromise(result)) {
+ assert.fail('promise unexpectedly returned')
+ } else {
+ assert.deepEqual(result, hookBefore)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ }
+ })
+})
+
+describe('sync predicate, async hook', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('calls async hook function if sync predicate falsey', async () => {
+ const result = unless(false, hookFcnAsync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('does not call async hook function if sync predicate truthy', () => {
+ const result = unless(true, hookFcnAsync)(hook)
+
+ if (isPromise(result)) {
+ assert.fail('promise unexpectedly returned')
+ }
+
+ assert.deepEqual(result, hookBefore)
+ assert.equal(hookFcnAsyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ })
+
+ it('calls async hook function if sync predicate returns falsey', async () => {
+ const result = unless(() => false, hookFcnAsync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+})
+
+describe('async predicate, sync hook', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('calls sync hook function if aync predicate falsey', async () => {
+ const result = unless(() => new Promise(resolve => resolve(false)), hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+ })
+ })
+
+ it('does not call sync hook function if async predicate truthy', async () => {
+ const result = unless(() => new Promise(resolve => resolve(true)), hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookBefore)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ })
+ })
+})
+
+describe('async predicate, async hook', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('calls async hook function if aync predicate falsey', async () => {
+ const result = unless(() => new Promise(resolve => resolve(false)), hookFcnAsync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+ })
+ })
+
+ it('does not call async hook function if async predicate truthy', async () => {
+ const result = unless(() => new Promise(resolve => resolve(true)), hookFcnAsync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ result.then((result1: any) => {
+ assert.deepEqual(result1, hookBefore)
+ assert.equal(hookFcnAsyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ })
+ })
+})
+
+describe('sync predicate', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ predicateHook = null
+ predicateOptions = null
+ })
+
+ it('does not need to access hook', () => {
+ unless(
+ () => false,
+ hookFcnSync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('is passed hook as param', () => {
+ unless(
+ predicateSync,
+ hookFcnSync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('a higher order predicate can pass more options', () => {
+ unless(
+ predicateSync2({ z: 'z' }),
+ hookFcnSync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(predicateOptions, { z: 'z' })
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+})
+
+describe('async predicate', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ predicateHook = null
+ predicateOptions = null
+ predicateValue = null
+ })
+
+ it('is passed hook as param', async () => {
+ const result = unless(predicateAsync, hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+ })
+ })
+
+ it('is resolved', async () => {
+ // @ts-expect-error TODO
+ const result = unless(predicateAsyncFunny, hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+
+ assert.equal(predicateValue, null)
+ })
+ })
+
+ it('a higher order predicate can pass more options', async () => {
+ const result = unless(predicateAsync2({ y: 'y' }), hookFcnSync)(hook)
+
+ if (!isPromise(result)) {
+ assert.fail('promise unexpectedly not returned')
+ }
+
+ await result.then((result1: any) => {
+ assert.deepEqual(predicateOptions, { y: 'y' })
+ assert.deepEqual(predicateHook, hookBefore)
+ assert.deepEqual(result1, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(result1, hookAfter)
+ })
+ })
+})
+
+describe('runs multiple hooks', () => {
+ beforeEach(() => {
+ hookBefore = { type: 'before', method: 'create', data: { first: 'John', last: 'Doe' } }
+ hookAfter = { type: 'before', method: 'create', data: { first: 'john', last: 'Doe' } }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ hookFcnAsyncCalls = 0
+ })
+
+ it('runs successfully', async () => {
+ await unless(
+ false,
+ hookFcnSync,
+ hookFcnAsync,
+ hookFcn,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.equal(hookFcnAsyncCalls, 1)
+ assert.equal(hookFcnCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+})
diff --git a/src/hooks/unless.ts b/src/hooks/unless/unless.ts
similarity index 55%
rename from src/hooks/unless.ts
rename to src/hooks/unless/unless.ts
index 29bdf8f5..cb735a7b 100755
--- a/src/hooks/unless.ts
+++ b/src/hooks/unless/unless.ts
@@ -1,6 +1,6 @@
-import type { HookContext } from '@feathersjs/feathers';
-import { iffElse } from '..';
-import type { PredicateFn, HookFunction } from '../types';
+import type { HookContext } from '@feathersjs/feathers'
+import { iffElse } from '../iff-else/iff-else.js'
+import type { PredicateFn, HookFunction } from '../../types.js'
/**
* Execute a series of hooks if a sync or async predicate is falsey.
@@ -11,6 +11,5 @@ export function unless(
predicate: boolean | PredicateFn,
...hooks: HookFunction[]
) {
- // @ts-ignore
- return iffElse(predicate, undefined, hooks.slice());
+ return iffElse(predicate, undefined, [...hooks])
}
diff --git a/src/hooks/validate-schema.ts b/src/hooks/validate-schema.ts
deleted file mode 100755
index fb89e1c7..00000000
--- a/src/hooks/validate-schema.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { BadRequest } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-import type { AjvOrNewable, ValidateSchemaOptions } from './validate';
-import { getItems } from '../utils/get-items';
-
-/**
- * Validate data using JSON-Schema.
- * @see https://hooks-common.feathersjs.com/hooks.html#validateschema
- */
-export function validateSchema(
- schema: object | string,
- ajvOrAjv: AjvOrNewable,
- // @ts-ignore
- options: ValidateSchemaOptions = { allErrors: true },
-) {
- const addNewError = options?.addNewError || addNewErrorDflt;
- // delete options.addNewError;
- // TODO: Any better way to tell if ajvOrAjv is an instance or a constructor?
- let ajv: any;
- let Ajv;
- // @ts-ignore
- if (typeof ajvOrAjv.addKeyword !== 'function') {
- Ajv = ajvOrAjv;
- // @ts-ignore
- ajv = new Ajv(options);
- } else {
- ajv = ajvOrAjv;
- }
- const validate = typeof schema === 'string' ? ajv.getSchema(schema) : ajv.compile(schema); // for fastest execution
-
- return (context: H) => {
- const items = getItems(context);
- const itemsArray = Array.isArray(items) ? items : [items];
- const itemsLen = itemsArray.length;
- let errorMessages: any = null;
- let invalid = false;
-
- if (validate.schema.$async) {
- return Promise.all(
- itemsArray.map((item, index) => {
- return validate(item).catch((err: any) => {
- if (!(err instanceof ajv.constructor.ValidationError)) throw err;
-
- invalid = true;
-
- addErrors(err.errors, index);
- });
- }),
- ).then(() => {
- if (invalid) {
- throw new BadRequest('Data does not match schema', { errors: errorMessages });
- }
- });
- }
-
- itemsArray.forEach((item, index) => {
- if (!validate(item)) {
- invalid = true;
-
- addErrors(validate.errors, index);
- }
- });
-
- if (invalid) {
- throw new BadRequest('Data does not match schema', { errors: errorMessages });
- }
-
- function addErrors(errors: any, index: any) {
- errors.forEach((ajvError: any) => {
- errorMessages = addNewError(errorMessages, ajvError, itemsLen, index);
- });
- }
-
- return context;
- };
-}
-
-function addNewErrorDflt(errorMessages: any, ajvError: any, itemsLen: any, index: any) {
- const leader = itemsLen === 1 ? '' : `in row ${index + 1} of ${itemsLen}, `;
- let message;
-
- if (ajvError.dataPath) {
- message = `'${leader}${ajvError.dataPath.substring(1)}' ${ajvError.message}`;
- } else {
- message = `${leader}${ajvError.message}`;
- }
-
- if (ajvError.params && ajvError.params.additionalProperty) {
- message += `: '${ajvError.params.additionalProperty}'`;
- }
-
- return (errorMessages || []).concat(message);
-}
diff --git a/src/hooks/validate.ts b/src/hooks/validate.ts
deleted file mode 100755
index 72b07fd3..00000000
--- a/src/hooks/validate.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import { BadRequest } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-import type { Ajv, ErrorObject as ajvErrorObject, Options as AjvOptions } from 'ajv';
-import { isPromise } from '../common';
-import { checkContext } from '../utils/check-context';
-import { getItems } from '../utils/get-items';
-import { replaceItems } from '../utils/replace-items';
-
-export type SyncValidatorFn = (
- values: any,
- context: H,
-) => { [key: string]: string } | null;
-export type AsyncValidatorFn = (
- values: any,
- context: H,
-) => Promise;
-export type ValidatorFn =
- | SyncValidatorFn
- | AsyncValidatorFn;
-
-export type AjvOrNewable = Ajv | (new (options?: AjvOptions) => Ajv);
-
-export interface ValidateSchemaOptions extends AjvOptions {
- /**
- * The hook will throw if the data does not match the JSON-Schema. error.errors will, by default, contain an array
- * of error messages. You may change this with a custom formatting function. Its a reducing function which works
- * similarly to Array.reduce().
- */
- addNewError: (
- currentFormattedMessages: any,
- ajvErrorObject: ajvErrorObject,
- itemsLen: number,
- itemIndex: number,
- ) => any;
-}
-
-/**
- * Validate data using a validation function.
- * @see https://hooks-common.feathersjs.com/hooks.html#validate
- */
-export function validate(validator: ValidatorFn) {
- return (context: H) => {
- checkContext(context, 'before', ['create', 'update', 'patch'], 'validate');
-
- if (typeof validator !== 'function') {
- throw new BadRequest('Expected validator function. (validate)');
- }
-
- const results = validator(getItems(context), context);
-
- if (isPromise(results)) {
- return results.then((convertedValues: any) => {
- if (convertedValues) {
- // if values have been sanitized
- replaceItems(context, convertedValues);
- }
-
- return context;
- });
- }
-
- // Sync function returns errors. It cannot sanitize.
- if (results && Object.keys(results).length) {
- // @ts-ignore
- throw new BadRequest({ errors: results });
- }
-
- return context;
- };
-}
diff --git a/src/index.ts b/src/index.ts
index 4319455c..9ad8afc0 100755
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,51 +1,5 @@
-export * from './hooks/act-on-dispatch';
-export * from './hooks/alter-items';
-export * from './hooks/cache';
-export * from './utils/check-context-if';
-export * from './hooks/debug';
-export * from './hooks/de-populate';
-export * from './hooks/disable-pagination';
-export * from './hooks/disallow';
-export * from './hooks/discard';
-export * from './hooks/discard-query';
-export * from './hooks/fast-join';
-export * from './hooks/fgraphql';
-export * from './hooks/iff';
-export * from './hooks/iff-else';
-export * from './hooks/keep';
-export * from './hooks/keep-in-array';
-export * from './hooks/keep-query';
-export * from './hooks/keep-query-in-array';
-export * from './hooks/lower-case';
-export * from './hooks/mongo-keys';
-export * from './hooks/params-from-client';
-export * from './hooks/populate';
-export * from './hooks/prevent-changes';
-export * from './hooks/required';
-export * from './utils/run-hook';
-export * from './hooks/run-parallel';
-export * from './hooks/sequelize-convert';
-export * from './hooks/serialize';
-export * from './hooks/set-field';
-export * from './hooks/set-now';
-export * from './hooks/set-slug';
-export * from './hooks/sifter';
-export * from './hooks/soft-delete';
-export * from './hooks/stash-before';
-export * from './hooks/traverse';
-export * from './hooks/unless';
-export * from './hooks/validate';
-export * from './hooks/validate-schema';
+export * from './hooks/index.js'
+export * from './utils/index.js'
+export * from './predicates/index.js'
-export * from './utils/calling-params';
-export * from './utils/check-context';
-export * from './utils/combine';
-export * from './utils/every';
-export * from './utils/get-items';
-export * from './utils/is-not';
-export * from './utils/is-provider';
-export * from './utils/params-for-server';
-export * from './utils/replace-items';
-export * from './utils/some';
-
-export * from './types';
+export * from './types.js'
diff --git a/src/internal.utils.ts b/src/internal.utils.ts
new file mode 100644
index 00000000..dedcc085
--- /dev/null
+++ b/src/internal.utils.ts
@@ -0,0 +1,9 @@
+export const hasOwnProperty = (obj: Record, ...keys: string[]): boolean => {
+ return keys.some(x => Object.prototype.hasOwnProperty.call(obj, x))
+}
+
+export type MaybeArray = T | T[]
+export const toArray = (value: T | T[]): T[] => (Array.isArray(value) ? value : [value])
+
+export type Promisable = T | Promise
+export type KeyOf = Extract
diff --git a/src/predicates/every/every.md b/src/predicates/every/every.md
new file mode 100644
index 00000000..78c9ee41
--- /dev/null
+++ b/src/predicates/every/every.md
@@ -0,0 +1,35 @@
+---
+title: every
+description: Return the and of a series of sync or async predicate functions.
+category: predicates
+---
+
+## Arguments
+
+- `{Array< Function >} predicates`
+
+| Argument | Type | Default | Description |
+| ------------ | :-----------------: | ------- | ----------------------------------------------------------------------------- |
+| `predicates` | `Array< Function >` | | Functions which take the current hook as a param and return a boolean result. |
+
+**Returns**
+
+- `{Boolean} result`
+
+| Name | Type | Description |
+| ------ | ------- | ----------------------------- |
+| result | Boolean | The logical and of predicates |
+
+## Example
+
+```js
+const { iff, every } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: {
+ create: iff(every(hook1, hook2, ...), hookA, hookB, ...)
+} };
+```
+
+## Details
+
+`every` is a predicate function for use in conditional hooks. The predicate functions are run in parallel, and `true` is returned if every predicate returns a truthy value.
diff --git a/test/utils/every.test.ts b/src/predicates/every/every.test.ts
similarity index 54%
rename from test/utils/every.test.ts
rename to src/predicates/every/every.test.ts
index 13b5fbcb..399fad87 100755
--- a/test/utils/every.test.ts
+++ b/src/predicates/every/every.test.ts
@@ -1,14 +1,61 @@
-import { assert } from 'vitest';
-import { feathers } from '@feathersjs/feathers';
-import { MemoryService } from '@feathersjs/memory';
-import { iff, every, isNot } from '../../src';
+import { assert } from 'vitest'
+import type { HookContext } from '@feathersjs/feathers'
+import { feathers } from '@feathersjs/feathers'
+import { MemoryService } from '@feathersjs/memory'
+import { iff } from '../../hooks/index.js'
+import { every } from './every.js'
+import { not } from '../not/not.js'
-describe('util every', () => {
- let app: any;
+describe('predicates/every', () => {
+ it('returns true synchronously when empty', () => {
+ assert.equal(every()({} as HookContext), true)
+ })
+
+ it('returns true when all are undefined', () => {
+ expect(every(undefined, undefined, undefined)({} as HookContext)).toBe(true)
+ })
+
+ it('returns false synchronously when at least 1 hook is false', () => {
+ expect(
+ every(
+ () => true,
+ () => Promise.resolve(false),
+ () => Promise.resolve(true),
+ () => false,
+ )({} as HookContext),
+ ).toBe(false)
+ })
+
+ it('returns true when all hooks are truthy', async () => {
+ await expect(
+ every(
+ () => true,
+ () => Promise.resolve(true),
+ () => Promise.resolve(true),
+ )({} as HookContext),
+ ).resolves.toBe(true)
+ })
+
+ it('rejects with the error', async () => {
+ await expect(
+ async () => await every(() => Promise.reject(new Error('errored')))({} as HookContext),
+ ).rejects.toThrow('errored')
+ })
+
+ it('does not run all predicates when one is false', () => {
+ const fn = vi.fn(() => {
+ return false
+ })
+
+ expect(every(fn, fn, fn)({} as HookContext)).toBe(false)
+ expect(fn).toHaveBeenCalledTimes(1)
+ })
+
+ let app: any
beforeEach(() => {
- app = feathers().use('/users', new MemoryService());
- });
+ app = feathers().use('/users', new MemoryService())
+ })
describe('when all hooks are truthy', () => {
beforeEach(() => {
@@ -18,7 +65,7 @@ describe('util every', () => {
iff(
every(
(_hook: any) => true,
- // @ts-ignore
+ // @ts-expect-error TODO
(_hook: any) => 1,
(_hook: any) => {},
(_hook: any) => Promise.resolve(true),
@@ -27,18 +74,18 @@ describe('util every', () => {
),
],
},
- });
- });
+ })
+ })
it('returns true', () => {
return app
.service('users')
.find()
.then((result: any) => {
- assert.deepEqual(result, []);
- });
- });
- });
+ assert.deepEqual(result, [])
+ })
+ })
+ })
describe('when a hook throws an error', () => {
beforeEach(() => {
@@ -49,7 +96,7 @@ describe('util every', () => {
every(
(_hook: any) => true,
(_hook: any) => {
- throw new Error('Hook 2 errored');
+ throw new Error('Hook 2 errored')
},
(_hook: any) => true,
),
@@ -57,18 +104,18 @@ describe('util every', () => {
),
],
},
- });
- });
+ })
+ })
it('rejects with the error', () => {
return app
.service('users')
.find()
.catch((error: any) => {
- assert.equal(error.message, 'Hook 2 errored');
- });
- });
- });
+ assert.equal(error.message, 'Hook 2 errored')
+ })
+ })
+ })
describe('when a hook rejects with an error', () => {
beforeEach(() => {
@@ -85,18 +132,18 @@ describe('util every', () => {
),
],
},
- });
- });
+ })
+ })
it('rejects with the error', () => {
return app
.service('users')
.find()
.catch((error: any) => {
- assert.equal(error.message, 'Hook 2 errored');
- });
- });
- });
+ assert.equal(error.message, 'Hook 2 errored')
+ })
+ })
+ })
describe('when at least one hook is falsey', () => {
beforeEach(() => {
@@ -104,13 +151,13 @@ describe('util every', () => {
before: {
all: [
iff(
- isNot(
+ not(
every(
(_hook: any) => true,
(_hook: any) => Promise.resolve(true),
(_hook: any) => Promise.resolve(false),
(_hook: any) => false,
- // @ts-ignore
+ // @ts-expect-error TODO
(_hook: any) => 0,
(_hook: any) => null,
(_hook: any) => undefined,
@@ -121,16 +168,16 @@ describe('util every', () => {
),
],
},
- });
- });
+ })
+ })
it('returns false', () => {
return app
.service('users')
.find()
.catch((error: any) => {
- assert.equal(error.message, 'A hook returned false');
- });
- });
- });
-});
+ assert.equal(error.message, 'A hook returned false')
+ })
+ })
+ })
+})
diff --git a/src/predicates/every/every.ts b/src/predicates/every/every.ts
new file mode 100755
index 00000000..aebb6a6b
--- /dev/null
+++ b/src/predicates/every/every.ts
@@ -0,0 +1,52 @@
+import type { HookContext } from '@feathersjs/feathers'
+import type { PredicateFn } from '../../types.js'
+import { isPromise } from '../../common/index.js'
+
+/**
+ * Return the and of a series of sync or async predicate functions.
+ * @see https://hooks-common.feathersjs.com/utilities.html#every
+ */
+export const every =
+ (
+ ...predicates: (PredicateFn | undefined)[]
+ ): PredicateFn =>
+ (context: H): boolean | Promise => {
+ if (!predicates.length) {
+ // same as Array.prototype.every
+ // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every#description
+ return true
+ }
+
+ const promises: Promise[] = []
+
+ let everyUndefined = true
+
+ for (const predicate of predicates) {
+ if (!predicate) {
+ // skip undefined predicates
+ continue
+ } else {
+ everyUndefined = false
+ }
+
+ const result = predicate(context)
+ if (result === false) {
+ return false
+ } else if (isPromise(result)) {
+ promises.push(result)
+ }
+ }
+
+ if (everyUndefined) {
+ // all predicates are undefined -> same as Array.prototype.every
+ // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every#description
+ return true
+ }
+
+ if (!promises.length) {
+ // no promises returned -> all predicates are sync and true
+ return true
+ }
+
+ return Promise.all(promises).then(results => results.every(result => !!result))
+ }
diff --git a/src/predicates/index.ts b/src/predicates/index.ts
new file mode 100644
index 00000000..e54ce11d
--- /dev/null
+++ b/src/predicates/index.ts
@@ -0,0 +1,7 @@
+export * from './every/every.js'
+export * from './is-context/is-context.js'
+export * from './is-multi/is-multi.js'
+export * from './is-paginated/is-paginated.js'
+export * from './is-provider/is-provider.js'
+export * from './not/not.js'
+export * from './some/some.js'
diff --git a/src/predicates/is-context/is-context.ts b/src/predicates/is-context/is-context.ts
new file mode 100644
index 00000000..2ddbee50
--- /dev/null
+++ b/src/predicates/is-context/is-context.ts
@@ -0,0 +1,40 @@
+import type { HookType } from '@feathersjs/feathers'
+import type { MethodName } from '../../types.js'
+import type { MaybeArray } from '../../internal.utils.js'
+import { toArray } from '../../internal.utils.js'
+
+export type IsContextOptions = {
+ path?: MaybeArray
+ type?: MaybeArray
+ method?: MaybeArray
+}
+
+export const isContext =
+ (options: IsContextOptions) =>
+ (context: any): boolean => {
+ if (options.path != null) {
+ const path = toArray(options.path)
+
+ if (!path.some(x => context.path.includes(x))) {
+ return false
+ }
+ }
+
+ if (options.type != null) {
+ const type = toArray(options.type)
+
+ if (!type.some(x => context.type === x)) {
+ return false
+ }
+ }
+
+ if (options.method != null) {
+ const method = toArray(options.method)
+
+ if (!method.some(x => context.method === x)) {
+ return false
+ }
+ }
+
+ return true
+ }
diff --git a/src/predicates/is-multi/is-multi.test.ts b/src/predicates/is-multi/is-multi.test.ts
new file mode 100644
index 00000000..c51505aa
--- /dev/null
+++ b/src/predicates/is-multi/is-multi.test.ts
@@ -0,0 +1,49 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { isMulti } from './is-multi.js'
+
+describe('predicates/isMulti', () => {
+ it('returns true', function () {
+ const makeContext = (type: string, method: string) => {
+ const context = {
+ method,
+ type,
+ } as HookContext
+ if (method === 'create') {
+ context.data = []
+ }
+ if (method === 'patch' || method === 'remove') {
+ context.id = null as any
+ }
+ return context
+ }
+ ;['before', 'after', 'around'].forEach(type => {
+ ;['find', 'create', 'patch', 'remove'].forEach(method => {
+ const context = makeContext(type, method)
+ assert.strictEqual(isMulti(context), true, `'${type}:${method}': returns true`)
+ })
+ })
+ })
+
+ it('returns false', function () {
+ const makeContext = (type: string, method: string) => {
+ const context = {
+ method,
+ type,
+ } as HookContext
+ if (method === 'create') {
+ context.data = {}
+ }
+ if (method === 'patch' || method === 'remove' || method === 'update') {
+ context.id = 0
+ }
+
+ return context
+ }
+ ;['before', 'after', 'around'].forEach(type => {
+ ;['get', 'create', 'update', 'patch', 'remove'].forEach(method => {
+ const context = makeContext(type, method)
+ assert.strictEqual(isMulti(context), false, `'${type}:${method}': returns false`)
+ })
+ })
+ })
+})
diff --git a/src/predicates/is-multi/is-multi.ts b/src/predicates/is-multi/is-multi.ts
new file mode 100644
index 00000000..cf9b3cb6
--- /dev/null
+++ b/src/predicates/is-multi/is-multi.ts
@@ -0,0 +1,25 @@
+import type { HookContext } from '@feathersjs/feathers'
+
+/**
+ * util to check if a hook is a multi hook:
+ * - find: true
+ * - get: false
+ * - create: `context.data` is an array
+ * - update: false
+ * - patch: `context.id == null`
+ * - remove: `context.id == null`
+ */
+export const isMulti = (context: H): boolean => {
+ const { method } = context
+ if (method === 'find') {
+ return true
+ } else if (method === 'patch' || method === 'remove') {
+ return context.id == null
+ } else if (method === 'create') {
+ return Array.isArray(context.data)
+ } else if (method === 'get' || method === 'update') {
+ return false
+ }
+
+ return false
+}
diff --git a/src/predicates/is-paginated/is-paginated.test.ts b/src/predicates/is-paginated/is-paginated.test.ts
new file mode 100644
index 00000000..c303cc2f
--- /dev/null
+++ b/src/predicates/is-paginated/is-paginated.test.ts
@@ -0,0 +1,72 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { isPaginated } from './is-paginated.js'
+
+describe('predicates/isPaginated', () => {
+ it('returns true for service.options.paginate', function () {
+ const serviceOptions = {
+ paginate: {
+ default: 10,
+ max: 50,
+ },
+ }
+
+ const paginate = isPaginated({
+ params: {},
+ service: {
+ options: serviceOptions,
+ },
+ method: 'find',
+ } as HookContext)
+
+ assert.deepStrictEqual(paginate, true)
+ })
+
+ it('returns false for params.paginate: false', function () {
+ const serviceOptions = {
+ paginate: {
+ default: 10,
+ max: 50,
+ },
+ }
+
+ const paginate = isPaginated({
+ params: { paginate: false },
+ service: {
+ options: serviceOptions,
+ },
+ } as HookContext)
+
+ assert.deepStrictEqual(paginate, false)
+ })
+
+ it('returns true for context.adapter.paginate', function () {
+ const serviceOptions = {
+ paginate: false,
+ }
+
+ const paginate = isPaginated({
+ params: { adapter: { paginate: { default: 20, max: 100 } } },
+ service: {
+ options: serviceOptions,
+ },
+ method: 'find',
+ } as HookContext)
+
+ assert.deepStrictEqual(paginate, true)
+ })
+
+ it('returns false for no paginate', function () {
+ const serviceOptions = {
+ paginate: false,
+ }
+
+ const paginate = isPaginated({
+ params: {},
+ service: {
+ options: serviceOptions,
+ },
+ } as HookContext)
+
+ assert.deepStrictEqual(paginate, false)
+ })
+})
diff --git a/src/predicates/is-paginated/is-paginated.ts b/src/predicates/is-paginated/is-paginated.ts
new file mode 100644
index 00000000..e10efbd7
--- /dev/null
+++ b/src/predicates/is-paginated/is-paginated.ts
@@ -0,0 +1,15 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { getPaginate } from '../../utils/get-paginate/get-paginate.js'
+
+/**
+ * util to check if a hook is a paginated hook using `getPaginate`
+ */
+export const isPaginated = (context: H): boolean => {
+ if (context.params.paginate === false || context.method !== 'find') {
+ return false
+ }
+
+ const paginate = getPaginate(context)
+
+ return !!paginate
+}
diff --git a/src/predicates/is-provider/is-provider.md b/src/predicates/is-provider/is-provider.md
new file mode 100644
index 00000000..56dbcb6c
--- /dev/null
+++ b/src/predicates/is-provider/is-provider.md
@@ -0,0 +1,40 @@
+---
+title: isProvider
+description: Check which transport provided the service call.
+category: predicates
+---
+
+## Arguments
+
+- `{Array< String >} transports`
+
+| Name | Type | Default | Description |
+| ------------ | :---------------: | ------- | --------------------------------- |
+| `transports` | `Array< String >` | | The transports you want to allow. |
+
+| `transports` | Value | Description |
+| ------------ | :---------------------------------: | ----------- |
+| `socketio` | Allow calls by Socket.IO transport. |
+| `rest` | Allow calls by REST transport. |
+| `external` | Allow calls other than from server. |
+| `server` | Allow calls from server. |
+
+**Returns**
+
+- `{Boolean} result`
+
+| Name | Type | Description |
+| ------ | ------- | ---------------------------------------------- |
+| result | Boolean | If the call was made by one of the transports. |
+
+## Example
+
+```js
+const { iff, isProvider, discard } = require('feathers-hooks-common/index.js');
+
+module.exports = { after: { create: iff(isProvider('external'), discard('password')) } };
+```
+
+## Details
+
+`isProvider` is a predicate function for use in conditional hooks. Its determines which transport provided the service call by checking `context.params.provider`.
diff --git a/src/predicates/is-provider/is-provider.test.ts b/src/predicates/is-provider/is-provider.test.ts
new file mode 100755
index 00000000..a2ae55a4
--- /dev/null
+++ b/src/predicates/is-provider/is-provider.test.ts
@@ -0,0 +1,134 @@
+import { assert } from 'vitest'
+import { isProvider } from './is-provider.js'
+import { iff } from '../../hooks/index.js'
+import { clone, isPromise } from '../../common/index.js'
+
+let hookServer: any
+let hookSocketio: any
+
+let hook: any
+let hookBefore: any
+let hookAfter: any
+let hookFcnSyncCalls: any
+
+const hookFcnSync = (hook: any) => {
+ hookFcnSyncCalls = +1
+ hook.data.first = hook.data.first.toLowerCase()
+
+ return hook
+}
+
+describe('predicates/isProvider', () => {
+ beforeEach(() => {
+ hookServer = { type: 'before', method: 'create', params: { provider: '' } }
+ hookSocketio = { type: 'before', method: 'create', params: { provider: 'socketio' } }
+ })
+
+ it('returns a function', () => {
+ const fcn = isProvider('server')
+
+ assert.isFunction(fcn)
+ })
+
+ it('gets passed the hook', () => {
+ const hook = clone(hookServer)
+ const result = isProvider('server')(hook)
+
+ assert.equal(result, true)
+ })
+
+ it('throws on no args', () => {
+ assert.throws(() => isProvider())
+ })
+
+ it('finds provider with 1 arg', () => {
+ const hook = clone(hookSocketio)
+ const result = isProvider('socketio')(hook)
+
+ assert.equal(result, true)
+ })
+
+ it('finds provider with 2 args', () => {
+ const hook = clone(hookSocketio)
+ const result = isProvider('rest', 'socketio')(hook)
+
+ assert.equal(result, true)
+ })
+
+ it('finds server', () => {
+ const hook = clone(hookServer)
+ const result = isProvider('rest', 'socketio', 'server')(hook)
+
+ assert.equal(result, true)
+ })
+
+ it('finds external', () => {
+ const hook = clone(hookSocketio)
+ const result = isProvider('rest', 'server', 'external')(hook)
+
+ assert.equal(result, true)
+ })
+
+ it('fails properly if not provider', () => {
+ const hook = clone(hookServer)
+ const result = isProvider('socketio')(hook)
+
+ assert.equal(result, false)
+ })
+
+ it('fails properly if not external', () => {
+ const hook = clone(hookServer)
+ const result = isProvider('external')(hook)
+
+ assert.equal(result, false)
+ })
+
+ it('fails properly if not server', () => {
+ const hook = clone(hookSocketio)
+ const result = isProvider('server')(hook)
+
+ assert.equal(result, false)
+ })
+})
+
+describe('services isProvider - works with iff', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ data: { first: 'John' },
+ params: { provider: 'rest' },
+ }
+ hookAfter = {
+ type: 'before',
+ method: 'create',
+ data: { first: 'john' },
+ params: { provider: 'rest' },
+ }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ })
+
+ it('calls sync hook function if truthy', () => {
+ iff(
+ isProvider('rest'),
+ hookFcnSync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('does not call sync hook function if falsey', () => {
+ const result = iff(isProvider('server'), hookFcnSync)(hook)
+
+ if (isPromise(result)) {
+ assert.fail('promise unexpectedly returned')
+ } else {
+ assert.deepEqual(result, hookBefore)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ }
+ })
+})
diff --git a/src/utils/is-provider.ts b/src/predicates/is-provider/is-provider.ts
similarity index 65%
rename from src/utils/is-provider.ts
rename to src/predicates/is-provider/is-provider.ts
index fe695042..723e7e61 100755
--- a/src/utils/is-provider.ts
+++ b/src/predicates/is-provider/is-provider.ts
@@ -1,6 +1,6 @@
-import { MethodNotAllowed } from '@feathersjs/errors';
-import type { HookContext } from '@feathersjs/feathers';
-import type { TransportName } from '../types';
+import { MethodNotAllowed } from '@feathersjs/errors'
+import type { HookContext } from '@feathersjs/feathers'
+import type { TransportName } from '../../types.js'
/**
* Check which transport provided the service call.
@@ -8,17 +8,17 @@ import type { TransportName } from '../types';
*/
export function isProvider(...providers: TransportName[]) {
if (!providers.length) {
- throw new MethodNotAllowed('Calling isProvider predicate incorrectly.');
+ throw new MethodNotAllowed('Calling isProvider predicate incorrectly.')
}
- return (context: H) => {
- const hookProvider = context.params.provider;
+ return (context: H): boolean => {
+ const hookProvider = context.params.provider
return providers.some(
provider =>
provider === hookProvider ||
(provider === 'server' && !hookProvider) ||
(provider === 'external' && !!hookProvider),
- );
- };
+ )
+ }
}
diff --git a/src/predicates/not/not.md b/src/predicates/not/not.md
new file mode 100644
index 00000000..43d04024
--- /dev/null
+++ b/src/predicates/not/not.md
@@ -0,0 +1,36 @@
+---
+title: not
+description: Negate a sync or async predicate function.
+category: predicates
+---
+
+## Arguments
+
+- `{Function | Boolean} predicate`
+
+| Argument | Type | Default | Description |
+| ----------- | :------------------: | ------- | --------------------------------------------------------------------------------------------- |
+| `predicate` | `Function` `Boolean` | | A sync or async function which take the current hook as a param and returns a boolean result. |
+
+**Returns**
+
+- `{Boolean} result`
+
+| Name | Type | Description |
+| ------ | ------- | -------------------- |
+| result | Boolean | The not of predicate |
+
+## Example
+
+```js
+const { iff, isNot, isProvider, discard } = require('feathers-hooks-common/index.js');
+const isRequestor = () => context => new Promise(resolve, reject) => ... );
+
+module.exports = { after: {
+ create: iff(isNot(isRequestor()), discard('password'))
+} };
+```
+
+## Details
+
+`isNot` is a predicate function for use in conditional hooks.
diff --git a/src/predicates/not/not.test.ts b/src/predicates/not/not.test.ts
new file mode 100755
index 00000000..8102f803
--- /dev/null
+++ b/src/predicates/not/not.test.ts
@@ -0,0 +1,124 @@
+import { assert } from 'vitest'
+import { iff } from '../../hooks/index.js'
+import { clone, isPromise } from '../../common/index.js'
+import { not } from './not.js'
+import { isProvider } from '../is-provider/is-provider.js'
+
+let hookServer: any
+let hook: any
+let hookBefore: any
+let hookAfter: any
+let hookFcnSyncCalls: any
+let predicateCalls: any
+
+const predicateSync = (value: any) => () => {
+ predicateCalls = +1
+ return value
+}
+
+const predicateAsync =
+ (value: T) =>
+ () =>
+ new Promise(resolve => {
+ predicateCalls = +1
+ return resolve(value)
+ })
+
+const hookFcnSync = (hook: any) => {
+ hookFcnSyncCalls = +1
+ hook.data.first = hook.data.first.toLowerCase()
+
+ return hook
+}
+
+describe('predicates/not', () => {
+ beforeEach(() => {
+ hookServer = { type: 'before', method: 'create', params: { provider: '' } }
+ predicateCalls = 0
+ })
+
+ it('negates a sync function 1', () => {
+ const hook = clone(hookServer)
+ const result = not(predicateSync(true))(hook)
+
+ assert.equal(predicateCalls, 1)
+ assert.equal(result, false)
+ })
+
+ it('negates a sync function 2', () => {
+ const hook = clone(hookServer)
+ const result = not(predicateSync(false))(hook)
+
+ assert.equal(predicateCalls, 1)
+ assert.equal(result, true)
+ })
+
+ it('negates an async function 1', async () => {
+ const hook = clone(hookServer)
+
+ await not(predicateAsync(true))(hook)
+ // @ts-expect-error TODO
+ .then((result: any) => {
+ assert.equal(predicateCalls, 1)
+ assert.equal(result, false)
+ })
+ .catch(() => {
+ assert.fail('unexpected catch')
+ })
+ })
+
+ it('negates an async function 2', async () => {
+ const hook = clone(hookServer)
+ await not(predicateAsync(false))(hook)
+ // @ts-expect-error TODO
+ .then((result: any) => {
+ assert.equal(predicateCalls, 1)
+ assert.equal(result, true)
+ })
+ .catch(() => {
+ assert.fail('unexpected catch')
+ })
+ })
+})
+
+describe('services not - works with iff and isProvider', () => {
+ beforeEach(() => {
+ hookBefore = {
+ type: 'before',
+ method: 'create',
+ data: { first: 'John' },
+ params: { provider: 'rest' },
+ }
+ hookAfter = {
+ type: 'before',
+ method: 'create',
+ data: { first: 'john' },
+ params: { provider: 'rest' },
+ }
+ hook = clone(hookBefore)
+ hookFcnSyncCalls = 0
+ })
+
+ it('calls sync hook function if truthy', () => {
+ iff(
+ not(isProvider('server')),
+ hookFcnSync,
+ )(hook).then((hook: any) => {
+ assert.deepEqual(hook, hookAfter)
+ assert.equal(hookFcnSyncCalls, 1)
+ assert.deepEqual(hook, hookAfter)
+ })
+ })
+
+ it('does not call sync hook function if falsey', () => {
+ const result = iff(not(isProvider('rest')), hookFcnSync)(hook)
+
+ if (isPromise(result)) {
+ assert.fail('promise unexpectedly returned')
+ } else {
+ assert.deepEqual(result, hookBefore)
+ assert.equal(hookFcnSyncCalls, 0)
+ assert.deepEqual(hook, hookBefore)
+ }
+ })
+})
diff --git a/src/predicates/not/not.ts b/src/predicates/not/not.ts
new file mode 100755
index 00000000..b4889d66
--- /dev/null
+++ b/src/predicates/not/not.ts
@@ -0,0 +1,20 @@
+import type { HookContext } from '@feathersjs/feathers'
+import { isPromise } from '../../common/index.js'
+import type { PredicateFn } from '../../types.js'
+
+/**
+ * Negate a predicate function.
+ *
+ * @see https://hooks-common.feathersjs.com/utilities.html#isnot
+ */
+export const not =
+ (predicate: PredicateFn): PredicateFn =>
+ (context: H) => {
+ const result = predicate(context)
+
+ if (!isPromise(result)) {
+ return !result
+ }
+
+ return result.then(result1 => !result1)
+ }
diff --git a/src/predicates/some/some.md b/src/predicates/some/some.md
new file mode 100644
index 00000000..d4f60ff3
--- /dev/null
+++ b/src/predicates/some/some.md
@@ -0,0 +1,35 @@
+---
+title: some
+description: Return the or of a series of sync or async predicate functions.
+category: predicates
+---
+
+## Arguments
+
+- `{Array< Function >} predicates`
+
+| Argument | Type | Default | Description |
+| ------------ | :-----------------: | ------- | ----------------------------------------------------------------------------- |
+| `predicates` | `Array< Function >` | | Functions which take the current hook as a param and return a boolean result. |
+
+**Returns**
+
+- `{Boolean} result`
+
+| Name | Type | Description |
+| ------ | ------- | ---------------------------- |
+| result | Boolean | The logical or of predicates |
+
+## Example
+
+```js
+const { iff, some } = require('feathers-hooks-common/index.js');
+
+module.exports = { before: {
+ create: iff(some(hook1, hook2, ...), hookA, hookB, ...)
+} };
+```
+
+## Details
+
+`some` is a predicate function for use in conditional hooks. The predicate functions are run in parallel, and `true` is returned if any predicate returns a truthy value.
diff --git a/src/predicates/some/some.test.ts b/src/predicates/some/some.test.ts
new file mode 100755
index 00000000..3e6126c4
--- /dev/null
+++ b/src/predicates/some/some.test.ts
@@ -0,0 +1,63 @@
+import { expect } from 'vitest'
+import type { HookContext } from '@feathersjs/feathers'
+import { some } from './some.js'
+
+describe('predicates/some', () => {
+ it('returns true synchronously when empty', () => {
+ expect(some()({} as HookContext)).toBe(true)
+ })
+
+ it('returns true when all are undefined', () => {
+ expect(some(undefined, undefined, undefined)({} as HookContext)).toBe(true)
+ })
+
+ it('returns true synchronously when at least 1 hook is true', () => {
+ expect(
+ some(
+ () => false,
+ () => false,
+ () => Promise.resolve(false),
+ () => Promise.resolve(true),
+ () => true,
+ )({} as HookContext),
+ ).toBe(true)
+ })
+
+ it('returns true when at least 1 async hook is true', async () => {
+ expect(
+ some(
+ () => false,
+ () => Promise.resolve(false),
+ () => Promise.resolve(true),
+ )({} as HookContext),
+ ).resolves.toBe(true)
+ })
+
+ it('rejects with the error', async () => {
+ await expect(
+ async () => await some(() => Promise.reject(new Error('errored')))({} as HookContext),
+ ).rejects.toThrow('errored')
+ })
+
+ it('does not run all predicates when one is true', () => {
+ const fn = vi.fn(() => {
+ return true
+ })
+
+ expect(some(fn, fn, fn)({} as HookContext)).toBe(true)
+ expect(fn).toHaveBeenCalledTimes(1)
+ })
+
+ it('when all hooks are falsey', async () => {
+ await expect(
+ some(
+ () => false,
+ () => Promise.resolve(false),
+ // @ts-expect-error test case
+ () => null,
+ () => undefined,
+ () => 0,
+ )({} as HookContext),
+ ).resolves.toBe(false)
+ })
+})
diff --git a/src/predicates/some/some.ts b/src/predicates/some/some.ts
new file mode 100755
index 00000000..e829eb63
--- /dev/null
+++ b/src/predicates/some/some.ts
@@ -0,0 +1,55 @@
+import type { HookContext } from '@feathersjs/feathers'
+import type { PredicateFn } from '../../types.js'
+import { isPromise } from '../../common/index.js'
+
+/**
+ * Return the or of a series of sync or async predicate functions.
+ * @see https://hooks-common.feathersjs.com/utilities.html#some
+ */
+export const some =
+ (
+ ...predicates: (PredicateFn | undefined)[]
+ ): PredicateFn =>
+ (context: H): boolean | Promise => {
+ if (!predicates.length) {
+ // same as Array.prototype.some
+ // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some#description
+ return true
+ }
+
+ const promises: Promise[] = []
+
+ let everyUndefined = true
+
+ for (const predicate of predicates) {
+ if (!predicate) {
+ // skip undefined predicates
+ continue
+ } else {
+ everyUndefined = false
+ }
+
+ const result = predicate(context)
+
+ if (result === true) {
+ return true
+ } else if (result === false) {
+ continue
+ } else if (isPromise(result)) {
+ promises.push(result)
+ }
+ }
+
+ if (everyUndefined) {
+ // all predicates are undefined -> same as Array.prototype.some
+ // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some#description
+ return true
+ }
+
+ if (!promises.length) {
+ // no promises returned -> all predicates are sync and false
+ return false
+ }
+
+ return Promise.all(promises).then(results => results.some(result => !!result))
+ }
diff --git a/src/resolvers/hooks/index.ts b/src/resolvers/hooks/index.ts
new file mode 100644
index 00000000..598ef09f
--- /dev/null
+++ b/src/resolvers/hooks/index.ts
@@ -0,0 +1,4 @@
+export * from './resolve-data.js'
+export * from './resolve-query.js'
+export * from './resolve-result.js'
+export * from './resolve.js'
diff --git a/src/resolvers/hooks/resolve-data.test.ts b/src/resolvers/hooks/resolve-data.test.ts
new file mode 100644
index 00000000..162ddbd1
--- /dev/null
+++ b/src/resolvers/hooks/resolve-data.test.ts
@@ -0,0 +1,131 @@
+import assert from 'node:assert'
+import { BadRequest } from '@feathersjs/errors'
+import { resolveData } from './resolve-data.js'
+import type { HookContext } from '@feathersjs/feathers'
+
+type User = {
+ firstName: string
+ lastName: string
+ password: string
+}
+
+describe('resolve-data', () => {
+ it('simple resolver', async () => {
+ const context = {
+ data: {
+ firstName: 'Dave',
+ lastName: 'L.',
+ },
+ } as unknown as HookContext
+
+ const u = await resolveData({
+ password: async (): Promise => undefined,
+
+ name: async (_value, user, ctx, status) => {
+ assert.deepStrictEqual(ctx, context)
+ assert.deepStrictEqual(status.path, ['name'])
+ assert.strictEqual(typeof status.stack[0], 'function')
+
+ return `${user.firstName} ${user.lastName}`
+ },
+ })(context)
+
+ assert.deepStrictEqual(u.data, {
+ firstName: 'Dave',
+ lastName: 'L.',
+ name: 'Dave L.',
+ })
+ })
+
+ it('array resolver', async () => {
+ const context = {
+ data: [
+ {
+ firstName: 'Dave',
+ lastName: 'L.',
+ },
+ {
+ firstName: 'Fred',
+ lastName: 'F.',
+ },
+ ],
+ } as unknown as HookContext
+
+ const u = await resolveData({
+ password: async (): Promise => undefined,
+
+ name: async (_value, user, ctx, status) => {
+ assert.deepStrictEqual(ctx, context)
+ assert.deepStrictEqual(status.path, ['name'])
+ assert.strictEqual(typeof status.stack[0], 'function')
+
+ return `${user.firstName} ${user.lastName}`
+ },
+ })(context)
+
+ assert.deepStrictEqual(u.data, [
+ {
+ firstName: 'Dave',
+ lastName: 'L.',
+ name: 'Dave L.',
+ },
+ {
+ firstName: 'Fred',
+ lastName: 'F.',
+ name: 'Fred F.',
+ },
+ ])
+ })
+
+ it('resolving with errors', async () => {
+ const resolver = resolveData<{ name: string; age: number }>({
+ name: async value => {
+ if (value === 'Dave') {
+ throw new Error(`No ${value}s allowed`)
+ }
+
+ return value
+ },
+ age: async value => {
+ if (value && value < 18) {
+ throw new BadRequest('Invalid age')
+ }
+
+ return value
+ },
+ })
+
+ await assert.rejects(
+ () =>
+ resolver({
+ data: {
+ name: 'Dave',
+ age: 16,
+ },
+ } as HookContext),
+ {
+ name: 'BadRequest',
+ message: 'Error resolving data',
+ code: 400,
+ className: 'bad-request',
+ data: {
+ name: { message: 'No Daves allowed' },
+ age: {
+ name: 'BadRequest',
+ message: 'Invalid age',
+ code: 400,
+ className: 'bad-request',
+ },
+ },
+ },
+ )
+ })
+
+ it('empty resolver returns original data', async () => {
+ const resolver = resolveData({})
+ const data = { message: 'Hello' }
+ const resolved = await resolver({ data } as HookContext)
+
+ assert.strictEqual(data, resolved.data)
+ })
+})
diff --git a/src/resolvers/hooks/resolve-data.ts b/src/resolvers/hooks/resolve-data.ts
new file mode 100644
index 00000000..fbc9ae73
--- /dev/null
+++ b/src/resolvers/hooks/resolve-data.ts
@@ -0,0 +1,18 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import type { ResolverObject } from './resolvers.internal.js'
+import { resolve } from './resolvers.internal.js'
+import { replaceData } from '../../utils/index.js'
+
+export const resolveData =
+ , H extends HookContext = HookContext>(
+ resolverProperties: ResolverObject,
+ ) =>
+ async (context: H, next?: NextFunction) => {
+ await replaceData(context, item => resolve(resolverProperties, item, context))
+
+ if (next) {
+ return next()
+ }
+
+ return context
+ }
diff --git a/src/resolvers/hooks/resolve-query.ts b/src/resolvers/hooks/resolve-query.ts
new file mode 100644
index 00000000..65824b02
--- /dev/null
+++ b/src/resolvers/hooks/resolve-query.ts
@@ -0,0 +1,20 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { type ResolverObject, resolve } from './resolvers.internal.js'
+
+export const resolveQuery =
+ (resolverProperties: ResolverObject) =>
+ async (context: H, next?: NextFunction) => {
+ const queryIngoing = context?.params?.query || {}
+ const query = await resolve(resolverProperties, queryIngoing, context)
+
+ context.params = {
+ ...context.params,
+ query,
+ }
+
+ if (next) {
+ return next()
+ }
+
+ return context
+ }
diff --git a/src/resolvers/hooks/resolve-result.test.ts b/src/resolvers/hooks/resolve-result.test.ts
new file mode 100644
index 00000000..bae835c0
--- /dev/null
+++ b/src/resolvers/hooks/resolve-result.test.ts
@@ -0,0 +1,215 @@
+import assert from 'node:assert'
+import { BadRequest } from '@feathersjs/errors'
+import { resolveResult } from './resolve-result.js'
+import type { HookContext } from '@feathersjs/feathers'
+
+type User = {
+ firstName: string
+ lastName: string
+ password: string
+}
+
+describe('resolve-result', () => {
+ it('simple resolver', async () => {
+ const context = {
+ result: {
+ firstName: 'Dave',
+ lastName: 'L.',
+ },
+ } as unknown as HookContext
+
+ const u = await resolveResult({
+ password: async (): Promise => undefined,
+
+ name: async (_value, user, ctx, status) => {
+ assert.deepStrictEqual(ctx, context)
+ assert.deepStrictEqual(status.path, ['name'])
+ assert.strictEqual(typeof status.stack[0], 'function')
+
+ return `${user.firstName} ${user.lastName}`
+ },
+ })(context)
+
+ assert.deepStrictEqual(u.result, {
+ firstName: 'Dave',
+ lastName: 'L.',
+ name: 'Dave L.',
+ })
+ })
+
+ it('array result on create', async () => {
+ const context = {
+ method: 'create',
+ result: [
+ {
+ firstName: 'Dave',
+ lastName: 'L.',
+ },
+ {
+ firstName: 'Fred',
+ lastName: 'F.',
+ },
+ ],
+ } as unknown as HookContext
+
+ const u = await resolveResult({
+ password: async (): Promise => undefined,
+
+ name: async (_value, user, ctx, status) => {
+ assert.deepStrictEqual(ctx, context)
+ assert.deepStrictEqual(status.path, ['name'])
+ assert.strictEqual(typeof status.stack[0], 'function')
+
+ return `${user.firstName} ${user.lastName}`
+ },
+ })(context)
+
+ assert.deepStrictEqual(u.result, [
+ {
+ firstName: 'Dave',
+ lastName: 'L.',
+ name: 'Dave L.',
+ },
+ {
+ firstName: 'Fred',
+ lastName: 'F.',
+ name: 'Fred F.',
+ },
+ ])
+ })
+
+ it('array result on find', async () => {
+ const context = {
+ method: 'find',
+ result: [
+ {
+ firstName: 'Dave',
+ lastName: 'L.',
+ },
+ {
+ firstName: 'Fred',
+ lastName: 'F.',
+ },
+ ],
+ } as unknown as HookContext
+
+ const u = await resolveResult({
+ password: async (): Promise => undefined,
+
+ name: async (_value, user, ctx, status) => {
+ assert.deepStrictEqual(ctx, context)
+ assert.deepStrictEqual(status.path, ['name'])
+ assert.strictEqual(typeof status.stack[0], 'function')
+
+ return `${user.firstName} ${user.lastName}`
+ },
+ })(context)
+
+ assert.deepStrictEqual(u.result, [
+ {
+ firstName: 'Dave',
+ lastName: 'L.',
+ name: 'Dave L.',
+ },
+ {
+ firstName: 'Fred',
+ lastName: 'F.',
+ name: 'Fred F.',
+ },
+ ])
+ })
+
+ it('paginated result', async () => {
+ const context = {
+ method: 'find',
+ result: {
+ data: [
+ {
+ firstName: 'Dave',
+ lastName: 'L.',
+ },
+ {
+ firstName: 'Fred',
+ lastName: 'F.',
+ },
+ ],
+ },
+ } as unknown as HookContext
+
+ const u = await resolveResult({
+ password: async (): Promise => undefined,
+
+ name: async (_value, user, ctx, status) => {
+ assert.deepStrictEqual(ctx, context)
+ assert.deepStrictEqual(status.path, ['name'])
+ assert.strictEqual(typeof status.stack[0], 'function')
+
+ return `${user.firstName} ${user.lastName}`
+ },
+ })(context)
+
+ assert.deepStrictEqual(u.result.data, [
+ {
+ firstName: 'Dave',
+ lastName: 'L.',
+ name: 'Dave L.',
+ },
+ {
+ firstName: 'Fred',
+ lastName: 'F.',
+ name: 'Fred F.',
+ },
+ ])
+ })
+
+ it('resolving with errors', async () => {
+ const resolver = resolveResult<{ name: string; age: number }>({
+ name: async value => {
+ if (value === 'Dave') {
+ throw new Error(`No ${value}s allowed`)
+ }
+
+ return value
+ },
+ age: async value => {
+ if (value && value < 18) {
+ throw new BadRequest('Invalid age')
+ }
+
+ return value
+ },
+ })
+
+ await assert.rejects(
+ () =>
+ resolver({
+ result: {
+ name: 'Dave',
+ age: 16,
+ },
+ } as HookContext),
+ {
+ name: 'BadRequest',
+ message: 'Error resolving data',
+ code: 400,
+ className: 'bad-request',
+ data: {
+ name: { message: 'No Daves allowed' },
+ age: {
+ name: 'BadRequest',
+ message: 'Invalid age',
+ code: 400,
+ className: 'bad-request',
+ },
+ },
+ },
+ )
+ })
+
+ it('empty resolver returns original data', async () => {
+ const result = { message: 'Hello' }
+ const resolved = await resolveResult({})({ result } as HookContext)
+
+ assert.strictEqual(result, resolved.result)
+ })
+})
diff --git a/src/resolvers/hooks/resolve-result.ts b/src/resolvers/hooks/resolve-result.ts
new file mode 100644
index 00000000..64dc4a66
--- /dev/null
+++ b/src/resolvers/hooks/resolve-result.ts
@@ -0,0 +1,17 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import { resolve, type ResolverObject } from './resolvers.internal.js'
+import { replaceResult } from '../../utils/index.js'
+
+export const resolveResult = , H extends HookContext = HookContext>(
+ resolverProperties: ResolverObject,
+) => {
+ return async (context: H, next?: NextFunction) => {
+ if (next) {
+ await next()
+ }
+
+ await replaceResult(context, item => resolve(resolverProperties, item, context))
+
+ return context
+ }
+}
diff --git a/src/resolvers/hooks/resolve.ts b/src/resolvers/hooks/resolve.ts
new file mode 100644
index 00000000..7942e131
--- /dev/null
+++ b/src/resolvers/hooks/resolve.ts
@@ -0,0 +1,51 @@
+import type { HookContext, NextFunction } from '@feathersjs/feathers'
+import type { ResolverObject } from './resolvers.internal.js'
+import { resolveData } from './resolve-data.js'
+import { resolveQuery } from './resolve-query.js'
+
+export const resolve = <
+ T extends Record,
+ H extends HookContext = HookContext,
+>(resolverProperties: {
+ data?: ResolverObject
+ query?: ResolverObject
+ result?: ResolverObject
+}) => {
+ const dataResolver = resolverProperties.data ? resolveData(resolverProperties.data) : undefined
+ const queryResolver = resolverProperties.query
+ ? resolveQuery(resolverProperties.query)
+ : undefined
+ const resultResolver = resolverProperties.result
+ ? resolveData(resolverProperties.result)
+ : undefined
+
+ if (!dataResolver && !queryResolver && !resultResolver) {
+ throw new Error('At least one resolver must be provided (data, query, or result)')
+ }
+
+ return async (context: H, next?: NextFunction) => {
+ if (queryResolver || dataResolver) {
+ const promisesBefore: Promise[] = []
+
+ if (queryResolver) {
+ promisesBefore.push(queryResolver(context, next))
+ }
+
+ if (dataResolver) {
+ promisesBefore.push(dataResolver(context, next))
+ }
+
+ await Promise.all(promisesBefore)
+ }
+
+ if (next) {
+ await next()
+ }
+
+ if (resultResolver) {
+ await resultResolver(context, next)
+ }
+
+ return context
+ }
+}
diff --git a/src/resolvers/hooks/resolvers.internal.ts b/src/resolvers/hooks/resolvers.internal.ts
new file mode 100644
index 00000000..4d6b4f32
--- /dev/null
+++ b/src/resolvers/hooks/resolvers.internal.ts
@@ -0,0 +1,114 @@
+import { BadRequest } from '@feathersjs/errors'
+import type { Promisable } from '../../internal.utils.js'
+
+export type ResolverProperty = (
+ value: V | undefined,
+ obj: T,
+ context: C,
+ status: ResolverOptions,
+) => Promisable
+
+export type ResolverObject = {
+ [key in string]: ResolverProperty<
+ T,
+ key extends keyof T ? T[key] : undefined,
+ C,
+ key extends keyof T ? T[key] : any
+ >
+}
+
+export interface ResolverOptions 