2016-11-07 12:59:39 +09:00
|
|
|
/*
|
|
|
|
|
|
|
|
Mutations have four steps:
|
|
|
|
|
|
|
|
1. Validation
|
|
|
|
|
2017-02-06 21:47:27 +08:00
|
|
|
If the mutation call is not trusted (i.e. it comes from a GraphQL mutation),
|
2016-11-14 17:17:44 +09:00
|
|
|
we'll run all validate steps:
|
|
|
|
|
|
|
|
- Check that the current user has permission to insert/edit each field.
|
|
|
|
- Add userId to document (insert only).
|
|
|
|
- Run validation callbacks.
|
2016-11-07 12:59:39 +09:00
|
|
|
|
|
|
|
2. Sync Callbacks
|
|
|
|
|
2017-02-06 21:47:27 +08:00
|
|
|
The second step is to run the mutation argument through all the sync callbacks.
|
2016-11-07 12:59:39 +09:00
|
|
|
|
|
|
|
3. Operation
|
|
|
|
|
|
|
|
We then perform the insert/update/remove operation.
|
|
|
|
|
|
|
|
4. Async Callbacks
|
|
|
|
|
2017-02-06 21:47:27 +08:00
|
|
|
Finally, *after* the operation is performed, we execute any async callbacks.
|
2016-11-07 12:59:39 +09:00
|
|
|
Being async, they won't hold up the mutation and slow down its response time
|
2017-02-06 21:47:27 +08:00
|
|
|
to the client.
|
2016-11-07 12:59:39 +09:00
|
|
|
|
|
|
|
*/
|
|
|
|
|
2017-08-17 10:48:20 +09:00
|
|
|
import { runCallbacks, runCallbacksAsync } from '../modules/index.js';
|
2017-08-16 16:18:40 +09:00
|
|
|
import { createError } from 'apollo-errors';
|
2017-08-17 10:48:20 +09:00
|
|
|
import { validateDocument, validateModifier } from '../modules/validation.js';
|
2018-03-03 11:39:56 +09:00
|
|
|
import { registerSetting } from '../modules/settings.js';
|
2017-09-14 19:47:35 +02:00
|
|
|
import { debug } from '../modules/debug.js';
|
2018-02-11 12:57:51 +09:00
|
|
|
import { Connectors } from './connectors.js';
|
2018-06-05 16:39:03 +09:00
|
|
|
import pickBy from 'lodash/pickBy';
|
2018-02-11 12:57:51 +09:00
|
|
|
|
|
|
|
registerSetting('database', 'mongo', 'Which database to use for your back-end');
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2018-06-05 16:39:03 +09:00
|
|
|
export const createMutator = async ({ collection, document, data, currentUser, validate, context }) => {
|
2017-02-06 21:47:27 +08:00
|
|
|
|
2017-09-14 19:47:35 +02:00
|
|
|
debug('//------------------------------------//');
|
2018-06-02 18:49:53 +09:00
|
|
|
debug('// createMutator');
|
2017-09-14 19:47:35 +02:00
|
|
|
debug(collection._name);
|
2017-09-15 11:14:09 +02:00
|
|
|
debug(`validate: ${validate}`);
|
2018-06-06 07:36:25 +09:00
|
|
|
debug(document || data);
|
2017-02-06 21:47:27 +08:00
|
|
|
|
2017-01-11 18:02:12 +01:00
|
|
|
// we don't want to modify the original document
|
2018-06-05 16:39:03 +09:00
|
|
|
let newDocument = Object.assign({}, document || data);
|
2017-08-16 16:18:40 +09:00
|
|
|
|
2016-11-07 11:47:33 +09:00
|
|
|
const collectionName = collection._name;
|
2016-11-14 17:17:44 +09:00
|
|
|
const schema = collection.simpleSchema()._schema;
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2016-11-07 12:11:02 +09:00
|
|
|
if (validate) {
|
2016-11-14 17:17:44 +09:00
|
|
|
|
2017-08-17 10:48:20 +09:00
|
|
|
const validationErrors = validateDocument(newDocument, collection, context);
|
2016-11-14 17:17:44 +09:00
|
|
|
|
|
|
|
// run validation callbacks
|
2018-06-02 18:49:53 +09:00
|
|
|
newDocument = runCallbacks(`${collectionName}.create.validate`, newDocument, currentUser, validationErrors);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-08-16 16:18:40 +09:00
|
|
|
newDocument = runCallbacks(`${collectionName}.new.validate`, newDocument, currentUser, validationErrors);
|
2018-06-02 18:49:53 +09:00
|
|
|
|
2017-08-16 16:18:40 +09:00
|
|
|
if (validationErrors.length) {
|
|
|
|
const NewDocumentValidationError = createError('app.validation_error', {message: 'app.new_document_validation_error'});
|
|
|
|
throw new NewDocumentValidationError({data: {break: true, errors: validationErrors}});
|
|
|
|
}
|
|
|
|
|
2016-11-07 12:11:02 +09:00
|
|
|
}
|
2017-04-03 16:24:19 +09:00
|
|
|
|
2017-12-25 15:39:22 +09:00
|
|
|
// if user is logged in, check if userId field is in the schema and add it to document if needed
|
|
|
|
if (currentUser) {
|
|
|
|
const userIdInSchema = Object.keys(schema).find(key => key === 'userId');
|
|
|
|
if (!!userIdInSchema && !newDocument.userId) newDocument.userId = currentUser._id;
|
|
|
|
}
|
|
|
|
|
2017-04-28 09:24:28 +09:00
|
|
|
// run onInsert step
|
2017-08-30 09:38:05 +09:00
|
|
|
// note: cannot use forEach with async/await.
|
|
|
|
// See https://stackoverflow.com/a/37576787/649299
|
|
|
|
for(let fieldName of _.keys(schema)) {
|
2018-06-04 17:59:18 +09:00
|
|
|
const onCreate = schema[fieldName].onCreate || schema[fieldName].onInsert; // OpenCRUD backwards compatibility
|
|
|
|
if (onCreate) {
|
|
|
|
const autoValue = await onCreate(newDocument, currentUser);
|
2017-09-23 08:10:58 +02:00
|
|
|
if (typeof autoValue !== 'undefined') {
|
2017-04-03 16:24:19 +09:00
|
|
|
newDocument[fieldName] = autoValue;
|
|
|
|
}
|
|
|
|
}
|
2017-08-30 09:38:05 +09:00
|
|
|
}
|
2017-04-03 16:24:19 +09:00
|
|
|
|
2016-11-07 11:47:33 +09:00
|
|
|
// TODO: find that info in GraphQL mutations
|
|
|
|
// if (Meteor.isServer && this.connection) {
|
|
|
|
// post.userIP = this.connection.clientAddress;
|
2017-09-14 19:47:35 +02:00
|
|
|
// post.userAgent = this.connection.httpHeaders['user-agent'];
|
2016-11-07 11:47:33 +09:00
|
|
|
// }
|
|
|
|
|
|
|
|
// run sync callbacks
|
2018-06-02 18:49:53 +09:00
|
|
|
newDocument = await runCallbacks(`${collectionName}.create.before`, newDocument, currentUser);
|
|
|
|
newDocument = await runCallbacks(`${collectionName}.create.sync`, newDocument, currentUser);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-10-21 12:47:58 +09:00
|
|
|
newDocument = await runCallbacks(`${collectionName}.new.before`, newDocument, currentUser);
|
2017-08-16 16:18:40 +09:00
|
|
|
newDocument = await runCallbacks(`${collectionName}.new.sync`, newDocument, currentUser);
|
2016-11-07 11:47:33 +09:00
|
|
|
|
|
|
|
// add _id to document
|
2018-03-03 11:39:56 +09:00
|
|
|
newDocument._id = await Connectors.create(collection, newDocument);
|
2016-11-07 12:59:39 +09:00
|
|
|
|
2017-10-21 12:47:58 +09:00
|
|
|
// run any post-operation sync callbacks
|
2018-06-02 18:49:53 +09:00
|
|
|
newDocument = await runCallbacks(`${collectionName}.create.after`, newDocument, currentUser);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-10-21 12:47:58 +09:00
|
|
|
newDocument = await runCallbacks(`${collectionName}.new.after`, newDocument, currentUser);
|
|
|
|
|
2016-11-07 12:59:39 +09:00
|
|
|
// get fresh copy of document from db
|
2017-10-21 12:47:58 +09:00
|
|
|
// TODO: not needed?
|
2018-03-03 11:39:56 +09:00
|
|
|
const insertedDocument = await Connectors.get(collection, newDocument._id);
|
2016-11-07 11:47:33 +09:00
|
|
|
|
|
|
|
// run async callbacks
|
|
|
|
// note: query for document to get fresh document with collection-hooks effects applied
|
2018-06-02 18:49:53 +09:00
|
|
|
await runCallbacksAsync(`${collectionName}.create.async`, insertedDocument, currentUser, collection);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-12-18 09:57:17 +09:00
|
|
|
await runCallbacksAsync(`${collectionName}.new.async`, insertedDocument, currentUser, collection);
|
2017-02-06 21:47:27 +08:00
|
|
|
|
2018-06-02 18:49:53 +09:00
|
|
|
debug('// createMutator finished:');
|
2017-09-14 19:47:35 +02:00
|
|
|
debug(newDocument);
|
|
|
|
debug('//------------------------------------//');
|
2017-02-06 21:47:27 +08:00
|
|
|
|
2018-06-05 16:39:03 +09:00
|
|
|
return { data: newDocument };
|
2016-11-07 11:47:33 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-06-05 16:39:03 +09:00
|
|
|
export const updateMutator = async ({ collection, documentId, data, set = {}, unset = {}, currentUser, validate, context }) => {
|
2017-02-06 21:47:27 +08:00
|
|
|
|
2016-11-07 11:47:33 +09:00
|
|
|
const collectionName = collection._name;
|
2016-11-14 17:17:44 +09:00
|
|
|
const schema = collection.simpleSchema()._schema;
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2016-11-07 12:11:02 +09:00
|
|
|
// build mongo modifier from arguments
|
2018-06-05 16:39:03 +09:00
|
|
|
let modifier = {};
|
|
|
|
if (data) {
|
|
|
|
modifier = { $set: pickBy(data, f => f !== null), $unset: Object.keys(pickBy(data, f => f === null)).map(f => ({[f]: true})) };
|
|
|
|
} else {
|
|
|
|
modifier = { $set: set, $unset: unset }
|
|
|
|
}
|
2016-11-07 11:47:33 +09:00
|
|
|
// get original document from database
|
2018-01-20 11:02:11 +09:00
|
|
|
// TODO: avoid fetching document a second time if possible
|
2018-03-03 11:39:56 +09:00
|
|
|
let document = await Connectors.get(collection, documentId);
|
2017-08-16 16:18:40 +09:00
|
|
|
|
2017-10-05 09:14:42 +09:00
|
|
|
debug('//------------------------------------//');
|
2018-06-02 18:49:53 +09:00
|
|
|
debug('// updateMutator');
|
2017-10-05 09:14:42 +09:00
|
|
|
debug('// collectionName: ', collection._name);
|
|
|
|
debug('// documentId: ', documentId);
|
2018-06-05 16:39:03 +09:00
|
|
|
debug('// modifier: ', modifier);
|
2018-03-25 10:54:45 +09:00
|
|
|
debug('// document: ', document);
|
2016-11-07 12:11:02 +09:00
|
|
|
|
|
|
|
if (validate) {
|
2016-11-14 17:17:44 +09:00
|
|
|
|
2017-08-19 16:18:18 +09:00
|
|
|
const validationErrors = validateModifier(modifier, document, collection, context);
|
2017-04-03 16:24:19 +09:00
|
|
|
|
2018-06-02 18:49:53 +09:00
|
|
|
modifier = runCallbacks(`${collectionName}.update.validate`, modifier, document, currentUser, validationErrors);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-08-16 16:18:40 +09:00
|
|
|
modifier = runCallbacks(`${collectionName}.edit.validate`, modifier, document, currentUser, validationErrors);
|
|
|
|
|
|
|
|
if (validationErrors.length) {
|
2018-01-25 15:03:03 -06:00
|
|
|
// eslint-disable-next-line no-console
|
|
|
|
console.log('// validationErrors');
|
|
|
|
// eslint-disable-next-line no-console
|
|
|
|
console.log(validationErrors);
|
2017-08-16 16:18:40 +09:00
|
|
|
const EditDocumentValidationError = createError('app.validation_error', {message: 'app.edit_document_validation_error'});
|
|
|
|
throw new EditDocumentValidationError({data: {break: true, errors: validationErrors}});
|
|
|
|
}
|
2016-11-14 17:17:44 +09:00
|
|
|
|
2016-11-07 12:11:02 +09:00
|
|
|
}
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2018-03-19 14:58:31 +09:00
|
|
|
// get a "preview" of the new document
|
|
|
|
let newDocument = { ...document, ...modifier.$set};
|
|
|
|
Object.keys(modifier.$unset).forEach(fieldName => {
|
|
|
|
delete newDocument[fieldName];
|
|
|
|
});
|
|
|
|
|
2017-04-28 09:24:28 +09:00
|
|
|
// run onEdit step
|
2017-08-30 09:38:05 +09:00
|
|
|
for(let fieldName of _.keys(schema)) {
|
2018-06-04 17:59:18 +09:00
|
|
|
const onUpdate = schema[fieldName].onUpdate || schema[fieldName].onEdit; // OpenCRUD backwards compatibility
|
|
|
|
if (onUpdate) {
|
|
|
|
const autoValue = await onUpdate(modifier, document, currentUser, newDocument);
|
2017-05-23 09:48:31 +09:00
|
|
|
if (typeof autoValue !== 'undefined') {
|
|
|
|
if (autoValue === null) {
|
|
|
|
// if any autoValue returns null, then unset the field
|
|
|
|
modifier.$unset[fieldName] = true;
|
|
|
|
} else {
|
|
|
|
modifier.$set[fieldName] = autoValue;
|
2017-09-05 15:45:14 +02:00
|
|
|
// make sure we don't try to unset the same field at the same time
|
|
|
|
delete modifier.$unset[fieldName];
|
2017-05-23 09:48:31 +09:00
|
|
|
}
|
2017-04-03 16:24:19 +09:00
|
|
|
}
|
|
|
|
}
|
2017-08-30 09:38:05 +09:00
|
|
|
}
|
2017-04-03 16:24:19 +09:00
|
|
|
|
2016-11-07 11:47:33 +09:00
|
|
|
// run sync callbacks (on mongo modifier)
|
2018-03-19 14:58:31 +09:00
|
|
|
modifier = await runCallbacks(`${collectionName}.edit.before`, modifier, document, currentUser, newDocument);
|
|
|
|
modifier = await runCallbacks(`${collectionName}.edit.sync`, modifier, document, currentUser, newDocument);
|
2018-06-02 18:49:53 +09:00
|
|
|
// OpenCRUD backwards compatibility
|
|
|
|
modifier = await runCallbacks(`${collectionName}.update.before`, modifier, document, currentUser, newDocument);
|
|
|
|
modifier = await runCallbacks(`${collectionName}.update.sync`, modifier, document, currentUser, newDocument);
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2017-04-03 16:24:19 +09:00
|
|
|
// remove empty modifiers
|
|
|
|
if (_.isEmpty(modifier.$set)) {
|
|
|
|
delete modifier.$set;
|
|
|
|
}
|
|
|
|
if (_.isEmpty(modifier.$unset)) {
|
|
|
|
delete modifier.$unset;
|
|
|
|
}
|
|
|
|
|
2018-05-17 09:53:16 +09:00
|
|
|
if (!_.isEmpty(modifier)) {
|
|
|
|
// update document
|
|
|
|
await Connectors.update(collection, documentId, modifier, {removeEmptyStrings: false});
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2018-05-17 09:53:16 +09:00
|
|
|
// get fresh copy of document from db
|
|
|
|
newDocument = await Connectors.get(collection, documentId);
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2018-05-17 09:53:16 +09:00
|
|
|
// clear cache if needed
|
|
|
|
if (collection.loader) {
|
|
|
|
collection.loader.clear(documentId);
|
|
|
|
}
|
2017-04-25 12:57:08 +09:00
|
|
|
}
|
2017-04-15 21:39:36 +09:00
|
|
|
|
2017-10-21 12:47:58 +09:00
|
|
|
// run any post-operation sync callbacks
|
2018-06-02 18:49:53 +09:00
|
|
|
newDocument = await runCallbacks(`${collectionName}.update.after`, newDocument, document, currentUser);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-10-21 12:47:58 +09:00
|
|
|
newDocument = await runCallbacks(`${collectionName}.edit.after`, newDocument, document, currentUser);
|
|
|
|
|
2016-11-07 11:47:33 +09:00
|
|
|
// run async callbacks
|
2018-06-02 18:49:53 +09:00
|
|
|
await runCallbacksAsync(`${collectionName}.update.async`, newDocument, document, currentUser, collection);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-12-18 09:57:17 +09:00
|
|
|
await runCallbacksAsync(`${collectionName}.edit.async`, newDocument, document, currentUser, collection);
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2018-06-02 18:49:53 +09:00
|
|
|
debug('// updateMutator finished')
|
2017-10-05 09:14:42 +09:00
|
|
|
debug('// modifier: ', modifier)
|
2018-06-02 18:49:53 +09:00
|
|
|
debug('// updated document: ', newDocument)
|
2017-09-14 19:47:35 +02:00
|
|
|
debug('//------------------------------------//');
|
2016-11-14 17:17:44 +09:00
|
|
|
|
2018-06-05 16:39:03 +09:00
|
|
|
return { data: newDocument };
|
2016-11-07 11:47:33 +09:00
|
|
|
}
|
|
|
|
|
2018-06-02 18:49:53 +09:00
|
|
|
export const deleteMutator = async ({ collection, documentId, currentUser, validate, context }) => {
|
2016-11-07 11:47:33 +09:00
|
|
|
|
2017-09-14 19:47:35 +02:00
|
|
|
debug('//------------------------------------//');
|
2018-06-02 18:49:53 +09:00
|
|
|
debug('// deleteMutator')
|
2017-09-14 19:47:35 +02:00
|
|
|
debug(collection._name)
|
|
|
|
debug(documentId)
|
|
|
|
debug('//------------------------------------//');
|
|
|
|
|
2016-11-07 12:59:39 +09:00
|
|
|
const collectionName = collection._name;
|
2017-04-28 09:24:28 +09:00
|
|
|
const schema = collection.simpleSchema()._schema;
|
2016-11-07 12:59:39 +09:00
|
|
|
|
2018-03-03 11:39:56 +09:00
|
|
|
let document = await Connectors.get(collection, documentId);
|
2016-11-07 12:59:39 +09:00
|
|
|
|
|
|
|
// if document is not trusted, run validation callbacks
|
|
|
|
if (validate) {
|
2018-06-02 18:49:53 +09:00
|
|
|
document = runCallbacks(`${collectionName}.delete.validate`, document, currentUser);
|
|
|
|
// OpenCRUD backwards compatibility
|
2016-12-13 11:40:24 +09:00
|
|
|
document = runCallbacks(`${collectionName}.remove.validate`, document, currentUser);
|
2016-11-07 12:59:39 +09:00
|
|
|
}
|
|
|
|
|
2017-04-28 09:24:28 +09:00
|
|
|
// run onRemove step
|
2017-08-30 09:38:05 +09:00
|
|
|
for(let fieldName of _.keys(schema)) {
|
2018-06-04 17:59:18 +09:00
|
|
|
const onDelete = schema[fieldName].onDelete || schema[fieldName].onRemove; // OpenCRUD backwards compatibility
|
|
|
|
if (onDelete) {
|
|
|
|
await onDelete(document, currentUser);
|
2017-04-28 09:24:28 +09:00
|
|
|
}
|
2017-08-30 09:38:05 +09:00
|
|
|
}
|
2017-04-28 09:24:28 +09:00
|
|
|
|
2018-06-02 18:49:53 +09:00
|
|
|
await runCallbacks(`${collectionName}.delete.before`, document, currentUser);
|
|
|
|
await runCallbacks(`${collectionName}.delete.sync`, document, currentUser);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-10-21 15:58:02 +09:00
|
|
|
await runCallbacks(`${collectionName}.remove.before`, document, currentUser);
|
2017-08-16 16:18:40 +09:00
|
|
|
await runCallbacks(`${collectionName}.remove.sync`, document, currentUser);
|
2016-11-07 12:59:39 +09:00
|
|
|
|
2018-03-03 11:39:56 +09:00
|
|
|
await Connectors.delete(collection, documentId);
|
2016-11-07 12:59:39 +09:00
|
|
|
|
2017-04-25 12:57:08 +09:00
|
|
|
// clear cache if needed
|
|
|
|
if (collection.loader) {
|
|
|
|
collection.loader.clear(documentId);
|
|
|
|
}
|
|
|
|
|
2018-06-02 18:49:53 +09:00
|
|
|
await runCallbacksAsync(`${collectionName}.delete.async`, document, currentUser, collection);
|
|
|
|
// OpenCRUD backwards compatibility
|
2017-12-18 09:57:17 +09:00
|
|
|
await runCallbacksAsync(`${collectionName}.remove.async`, document, currentUser, collection);
|
2016-12-05 09:29:49 +09:00
|
|
|
|
2018-06-05 16:39:03 +09:00
|
|
|
return { data: document };
|
2016-11-07 11:47:33 +09:00
|
|
|
}
|
2017-12-25 15:39:22 +09:00
|
|
|
|
2018-06-02 18:49:53 +09:00
|
|
|
// OpenCRUD backwards compatibility
|
|
|
|
export const newMutation = createMutator;
|
|
|
|
export const editMutation = updateMutator;
|
|
|
|
export const removeMutation = deleteMutator;
|
|
|
|
export const newMutator = createMutator;
|
|
|
|
export const editMutator = updateMutator;
|
|
|
|
export const removeMutator = deleteMutator;
|