Javascript 在使用Mongoose创建对象之前，请检查唯一字段

我正在构建一个GraphQL服务器，在将数据提交到数据库（MongoDB和Mongoose）之前，我需要在其中进行某种验证

其中一个检查与唯一字段相关。所以，一个模型可能有一个或多个唯一字段，我需要能够在保存到数据库之前检查这些字段

因此，我构建了一些帮助函数来完成此操作，代码如下：

助手代码：

import mongoose from "mongoose";

const isFieldUnique = (modelName, fieldName, fieldValue) => {

    let model = mongoose.model(modelName);
    let query = {};
    query[fieldName] = fieldValue;
    return model.findOne(query).exec();
};

const executeUniquePromises = (uniques, modelName, data) => {

    let promises = [];
    uniques.map(name => {

        let value = data[name];
        if (!value)
            throw new Error("Cannot test uniqueness for a null field.");

        promises.push(
            isFieldUnique(modelName, name, value)
            .then(value => {
                if (value) {
                    let error = name + ' is not unique';
                    console.log(error);
                    return error;
                }

                console.log(name + ' is unique');
                return null;
            })
            .catch(error => {
                throw new Error(error);
            })
        )
    });

    return Promise.all(promises);
};

export const checkUniqueness = (uniques, modelName, data) => {

    return new Promise((resolve, reject) => {

        executeUniquePromises(uniques, modelName, data).then(result => {

            let errors = [];

            // Check for errors
            result.map((error) =>  {
                if (error)
                    errors.push(error);
            });

            if (errors.length > 0)
                return reject(errors);
            else
                resolve();
        });
    });
}

import * as helper from './helper';

schema.statics.create = function (data) {

    let uniques = ['name', 'email'];
    helper.checkUniqueness(uniques,'Company', data)
    .then(result => {
            let user = new this(data);
            return company.save();
    })
    .catch(error => {
            throw new Error(error);
    });
}

const createUser = {
    type: UserType,
    description: "Create a user",
    args: {
        data: {
            name: "user",
            type: new GraphQLNonNull(UserInputType)
        }
    },
    resolve(root, args) {
        return UserModel.create(args.data);
    }
};

猫鼬静态创建功能：

import mongoose from "mongoose";

const isFieldUnique = (modelName, fieldName, fieldValue) => {

    let model = mongoose.model(modelName);
    let query = {};
    query[fieldName] = fieldValue;
    return model.findOne(query).exec();
};

const executeUniquePromises = (uniques, modelName, data) => {

    let promises = [];
    uniques.map(name => {

        let value = data[name];
        if (!value)
            throw new Error("Cannot test uniqueness for a null field.");

        promises.push(
            isFieldUnique(modelName, name, value)
            .then(value => {
                if (value) {
                    let error = name + ' is not unique';
                    console.log(error);
                    return error;
                }

                console.log(name + ' is unique');
                return null;
            })
            .catch(error => {
                throw new Error(error);
            })
        )
    });

    return Promise.all(promises);
};

export const checkUniqueness = (uniques, modelName, data) => {

    return new Promise((resolve, reject) => {

        executeUniquePromises(uniques, modelName, data).then(result => {

            let errors = [];

            // Check for errors
            result.map((error) =>  {
                if (error)
                    errors.push(error);
            });

            if (errors.length > 0)
                return reject(errors);
            else
                resolve();
        });
    });
}

import * as helper from './helper';

schema.statics.create = function (data) {

    let uniques = ['name', 'email'];
    helper.checkUniqueness(uniques,'Company', data)
    .then(result => {
            let user = new this(data);
            return company.save();
    })
    .catch(error => {
            throw new Error(error);
    });
}

const createUser = {
    type: UserType,
    description: "Create a user",
    args: {
        data: {
            name: "user",
            type: new GraphQLNonNull(UserInputType)
        }
    },
    resolve(root, args) {
        return UserModel.create(args.data);
    }
};

图形SQL代码：

import mongoose from "mongoose";

const isFieldUnique = (modelName, fieldName, fieldValue) => {

    let model = mongoose.model(modelName);
    let query = {};
    query[fieldName] = fieldValue;
    return model.findOne(query).exec();
};

const executeUniquePromises = (uniques, modelName, data) => {

    let promises = [];
    uniques.map(name => {

        let value = data[name];
        if (!value)
            throw new Error("Cannot test uniqueness for a null field.");

        promises.push(
            isFieldUnique(modelName, name, value)
            .then(value => {
                if (value) {
                    let error = name + ' is not unique';
                    console.log(error);
                    return error;
                }

                console.log(name + ' is unique');
                return null;
            })
            .catch(error => {
                throw new Error(error);
            })
        )
    });

    return Promise.all(promises);
};

export const checkUniqueness = (uniques, modelName, data) => {

    return new Promise((resolve, reject) => {

        executeUniquePromises(uniques, modelName, data).then(result => {

            let errors = [];

            // Check for errors
            result.map((error) =>  {
                if (error)
                    errors.push(error);
            });

            if (errors.length > 0)
                return reject(errors);
            else
                resolve();
        });
    });
}

import * as helper from './helper';

schema.statics.create = function (data) {

    let uniques = ['name', 'email'];
    helper.checkUniqueness(uniques,'Company', data)
    .then(result => {
            let user = new this(data);
            return company.save();
    })
    .catch(error => {
            throw new Error(error);
    });
}

const createUser = {
    type: UserType,
    description: "Create a user",
    args: {
        data: {
            name: "user",
            type: new GraphQLNonNull(UserInputType)
        }
    },
    resolve(root, args) {
        return UserModel.create(args.data);
    }
};

助手代码看起来很混乱，我没有将我对承诺的用法与其他承诺一起使用，这是正确的做法

请记住，我可能需要检查几个字段的唯一性，这就是我创建promise数组的原因

一个问题是，当我在没有唯一性匹配的地方插入数据时，我在GraphQL服务器中没有得到任何返回

---

我想找到一种更好的方法，并找出为什么我无法取回保存的对象。

MongoDB已经可以处理现成的对象了。在Mongoose模式中将字段设置为

unique:true

。您可以使用使错误消息与验证错误消息类似。最后，当您无法让

unique:true

正常工作时，请阅读。

MongoDB已经可以进行开箱即用的处理。在Mongoose模式中将字段设置为

unique:true

。您可以使用使错误消息与验证错误消息类似。最后，当您无法使

unique:true

正常工作时，请阅读。

我知道这一点，但这对我的GraphQL服务器没有用处，因为错误消息将不是应用程序标准。您可以在几行代码中获得与普通验证错误完全相同的消息。唯一的缺点是，普通验证在发送到DB之前运行，而唯一约束由DB本身检查。因此，普通验证消息永远不会与唯一验证消息同时显示。我知道这一点，但这对我的GraphQL服务器没有用处，因为错误消息不是应用程序标准消息。您可以在几行代码中获得与普通验证错误完全相同的消息。唯一的缺点是，普通验证在发送到DB之前运行，而唯一约束由DB本身检查。因此，普通验证消息永远不会与唯一验证消息同时显示。