JavaScript承诺使用Mongoose

JavaScript Promises with Mongoose

本文关键字：Mongoose 承诺 JavaScript      更新时间：2024-05-24

我在使用promise和mongoose来注册一个尚未在数据库中的新用户时遇到了一些困难。这是我的代码：

exports.signup = (req) => {
  const newUser = {
    email: req.body.email,
    password: req.body.password
  };
  let result = {};
  return new Promise((resolve, reject) => {
    UserModel.findOne({email: newUser.email}, (err, existingUser) => {
      if (err) {
        return reject(err)
      } else {
        if (existingUser) {
          return reject()
        } else {
          result = newUser;
          UserModel.create(result);
          return resolve(result)
        }
      }
    })
  })
};

传入的请求值正在传入，但应用程序在finOne集合中中断。

有人能发现错误吗？

非常感谢。

更新：

如果我省略猫鼬方法：

exports.signup = (req) => {
  const newUser = {
    email: req.body.email,
    password: req.body.password
  };
  return Promise.resolve(newUser);
};

一切都正常，但当然不会向数据库中添加任何内容。所以，据我所知，这与我的猫鼬方法有关。

最终更新：

我知道我的错误是什么，但pandres95以正确的答案击败了我，所以我给了他分数。但我也会在下面提供我的解决方案，详细解释我在哪里搞砸了，以防其他人也走同样的路。

令人惊讶的是，得分低于1公里的人总是来拯救他们。）

可能存在一些问题：

  1. 我注意到你没有使用回复（即res）。您正在使用哪个Web服务器库/框架
  2. 然后，我更喜欢使用return作为退出语句来管理控制流，而不是使用一系列内联条件。它们可能会导致意想不到的结果
  3. 在这种情况下，不建议使用result变量，因为：
    1. 作为范围变量，范围的变化可能是问题的一部分
    2. 我认为没有必要，因为你用过一次

以下是我如何从mongoose模式中解决同样的情况。

var userSchema = new Schema({
    email: String,
    password: String
});
userSchema.statics.signup = function (data) {
    return new Promise((resolve, reject) => {
        this.findOne({
            email: data.email
        }, (err, existingUser) => {
            if(err) return reject(err);
            if(existingUser) return reject();
            return this.create(data, (err) => {
                if(err) return reject(err);
                return resolve(data);
            });
        });
    });
};
return userSchema;

完整的解决方案（包括一些单元测试）可以在这里找到

解决方案：

犯同样的错误足够多次，最终你就会学会。最初我有这个：

从".."导入UserModel/models/security/user.api.model'；

虽然是正确的，但我的模型实际上明确地声明UserModel为导出常量，这意味着我应该改为：

从".."导入｛UserModel｝/models/security/user.api.model'；

尽管很有挑战性，但我有一个球可以改进入门项目react redux通用热门示例

我将我的网站拆分为静态网页端口和api端口

不幸的是，不管是否如此，前面提到的github项目都没有提供数据库示例，所以我不得不自己解决。

以下是使用JavaScript承诺的模式、api操作（服务器控制器）的示例解决方案：

user.api.model.js:

'use strict';
import mongoose from 'mongoose';
const UserSchema = new mongoose.Schema({
  email: {type: String, required: '{PATH} is required!', index: {unique: true}},
  password: {type: String, min: 7, max: 15}, required: '{PATH} is required!',
  active: {type: Boolean, default: false},
  .....
  createdAt: { type: Date, default: Date.now() },
  updatedAt: { type: Date, default: Date.now() }
});

export const UserModel = mongoose.model('User', UserSchema);

security.api.actions.js（控制器），带有承诺：

 'use strict';
import { UserModel } from '../../models/user/user.api.model';
.....
exports.signup = (req) => {
  let result = {};
  return new Promise((resolve, reject) => {
    UserModel.findOne({ email: req.body.email}, (err, existingUser) => {
      if (!existingUser) {
        const newUser = new UserModel({
           email: req.body.email,
           password: req.body.password
           ......
          });
        newUser.save((err) => {
            if (err) { 
              reject(err)
            } else {
              result = newUser;
            }
          });
      }
      if (err) reject(err);
      else resolve(result);
    })
  });
};

auth.shared.reducer.js:

const LOAD = 'security/LOAD';
const LOAD_SUCCESS = 'security/LOAD_SUCCESS';
const LOAD_FAIL = 'security/LOAD_FAIL';
const LOGIN = 'security/LOGIN';
const LOGIN_SUCCESS = 'security/LOGIN_SUCCESS';
const LOGIN_FAIL = 'security/LOGIN_FAIL';
const LOGOUT = 'security/LOGOUT';
const LOGOUT_SUCCESS = 'security/LOGOUT_SUCCESS';
const LOGOUT_FAIL = 'security/LOGOUT_FAIL';
const SIGNUP = 'security/SIGNUP';
const SIGNUP_SUCCESS = 'security/SIGNUP_SUCCESS';
const SIGNUP_FAIL = 'security/SIGNUP_FAIL';

const initialState = {
  loaded: false
};
export default function reducer(state = initialState, action = {}) {
  switch (action.type) {
    case LOAD:
      return {
        ...state,
        loading: true
      };
    case LOAD_SUCCESS:
      return {
        ...state,
        loading: false,
        loaded: true,
        user: action.result
      };
    case LOAD_FAIL:
      return {
        ...state,
        loading: false,
        loaded: false,
        error: action.error
      };
    case LOGIN:
      return {
        ...state,
        loggingIn: true
      };
    case LOGIN_SUCCESS:
      return {
        ...state,
        loggingIn: false,
        user: action.result
      };
    case LOGIN_FAIL:
      return {
        ...state,
        loggingIn: false,
        user: null,
        loginError: action.error
      };
    case LOGOUT:
      return {
        ...state,
        loggingOut: true
      };
    case LOGOUT_SUCCESS:
      return {
        ...state,
        loggingOut: false,
        user: null
      };
    case LOGOUT_FAIL:
      return {
        ...state,
        loggingOut: false,
        logoutError: action.error
      };
    case SIGNUP:
      return {
        ...state,
        signingUp: true
      };
    case SIGNUP_SUCCESS:
      return {
        ...state,
        signingUp: false,
        user: action.result
      };
    case SIGNUP_FAIL:
      return {
        ...state,
        signingUp: false,
        user: null,
        signUpError: action.error
      };
    default:
      return state;
  }
}

export function isLoaded(globalState) {
  return globalState.auth && globalState.auth.loaded;
}
export function load() {
  return {
    types: [LOAD, LOAD_SUCCESS, LOAD_FAIL],
    promise: (client) => client.get('/security/createUserSession')
  };
}
export function login(name) {
  return {
    types: [LOGIN, LOGIN_SUCCESS, LOGIN_FAIL],
    promise: (client) => client.post('/security/login', {
      data: {
        name
      }
    })
  };
}
export function logout() {
  return {
    types: [LOGOUT, LOGOUT_SUCCESS, LOGOUT_FAIL],
    promise: (client) => client.get('/security/logout')
  };
}
export function signup(email, password) {
  return {
    types: [SIGNUP, SIGNUP_SUCCESS, SIGNUP_FAIL],
    promise: (client) => client.post('/security/signup', {
      data: {
        email: email,
        password: password
      }
    })
  };
}

如果你是一个React程序员或爱好者，我建议你看看入门套件，如果你还没有。这是一种前沿技术，但我相信在不久的将来，所采用的技术将成为标准技术。

相关文章：