Javascript 未处理的PromisejectionWarning:TypeError:createUser不是函数

我正在注册一个新用户。 我收到未处理的错误PromisejectionWarning:TypeError:createUser不是函数

auth.js

const express = require("express");
const authrequests = express.Router();
const cors = require("cors");

var createUser = require("./export/authConstants");

// Register User
authrequests.post("/register", async (req, res) => {
  const userData = {
    firstname: req.body.firstname,
    lastname: req.body.lastname,
    email: req.body.email,
    phone: req.body.phone,
    password: req.body.password,
    created: new Date(),
  };
  await createUser(userData)
    .then((res) => {
      console.log(res)
      if (res.status == 200) {
        return res.status(200).json({ msg: 'Registered!' });
      } else if (res.status == 405) {
        return res.status(405).json({ error: 'User already exists' });
      } else {
        return res.status(400).json({ error: err });
      }
    })
    .catch(err => {
      return res.status(400).json({ error: err });
    })
});
module.exports = authrequests;

const customers = require("./../../models/customers");

var hashPassword = require("./util/bcrypt");
var jwtCreate = require("./util/jwt");
var sendMail = require("./util/mail");
var BASE_URL = require("./../constants/constants");

//register
createUser = (userData) => {
    return new Promise(async (resolve, reject) => {
        customers.findOne({ where: { email: userData.email } })
            .then(async (user) => {
                if (!user) {
                    var hashResponse = await hashPassword(userData.password)
                    if (hashResponse.msg) {
                        userData.password = hashResponse.msg
                        customers.create(userData)
                            .then(async (user) => {
                                if (user) {
                                    var jwtResponse = await jwtCreate({ data: user.id, expiry: 172800 })
                                    if (jwtResponse.msg) {
                                        const url = `${BASE_URL}/auth/emailVerified/${jwtResponse.msg}`;
                                        var mailResponse = await sendMail({
                                            to: user.email,
                                            subject: 'Email Verification',
                                            html: `Click on the following link to verify your account: <a href="${url}">click here</a>`
                                        })
                                        if (mailResponse.msg) {
                                            resolve({ status: 200 })
                                        } else {
                                            reject({ error: mailResponse.err })
                                        }
                                    } else {
                                        reject({ error: jwtResponse.err })
                                    }
                                } else {
                                    reject({ error: "oops..! user creation failed" })
                                }
                            })
                            .catch(err => {
                                reject({ error: err })
                            });

                    } else {
                        reject({ error: hashResponse.err })
                    }
                } else {
                    resolve({ status: 405 })
                }
            })
            .catch(err => {
                reject({ error: err })
            })
    })
};

const bcrypt = require("bcrypt");

//hashing password
hashPassword = async (password) => {
    await bcrypt.hash(password, 10, (err, hash) => {
        if (hash) {
            return { msg: hash };
        } else {
            return { error: err };
        }
    })
};

const jwt = require("jsonwebtoken");

var EMAIL_SECRET = require("./../../constants/constants");

//jwt creation
jwtCreate = async (data) => {
    await jwt.sign(data.data, EMAIL_SECRET, { expiresIn: data.expiry }, (err, token) => {
        if (token) {
            return { msg: token };
        } else {
            return { error: err };
        }
    })
};

const nodemailer = require("nodemailer");

var MAIL_HOST = require("./../../constants/constants");
var EMAIL_USER = require("./../../constants/constants");
var EMAIL_PASS = require("./../../constants/constants");

//mail send
sendMail = async (data) => {
    let transporter = nodemailer.createTransport({
        host: MAIL_HOST,
        port: 587,
        secure: false, // true for 465, false for other ports
        auth: {
            user: EMAIL_USER,
            pass: EMAIL_PASS,
        },
        tls: {
            rejectUnauthorized: false,
        },
    });
    await transporter.sendMail({
        from: EMAIL_USER,
        to: data.to,
        subject: data.subject,
        html: data.html
    }, (err, response) => {
        if (token) {
            return { msg: response };
        } else {
            return { error: err };
        }
    });
};

const EMAIL_SECRET = "asdf1093KMnHGcvnkljvasdu09123nlasdasdf";
const MAIL_HOST = "mail.test.com";
const EMAIL_USER = "no_reply_auth@test.com";
const EMAIL_PASS = "JMkC+)*Lv";
const BASE_URL = "http://localhost:3001";

authcontents.js

const express = require("express");
const authrequests = express.Router();
const cors = require("cors");

var createUser = require("./export/authConstants");

// Register User
authrequests.post("/register", async (req, res) => {
  const userData = {
    firstname: req.body.firstname,
    lastname: req.body.lastname,
    email: req.body.email,
    phone: req.body.phone,
    password: req.body.password,
    created: new Date(),
  };
  await createUser(userData)
    .then((res) => {
      console.log(res)
      if (res.status == 200) {
        return res.status(200).json({ msg: 'Registered!' });
      } else if (res.status == 405) {
        return res.status(405).json({ error: 'User already exists' });
      } else {
        return res.status(400).json({ error: err });
      }
    })
    .catch(err => {
      return res.status(400).json({ error: err });
    })
});
module.exports = authrequests;

const customers = require("./../../models/customers");

var hashPassword = require("./util/bcrypt");
var jwtCreate = require("./util/jwt");
var sendMail = require("./util/mail");
var BASE_URL = require("./../constants/constants");

//register
createUser = (userData) => {
    return new Promise(async (resolve, reject) => {
        customers.findOne({ where: { email: userData.email } })
            .then(async (user) => {
                if (!user) {
                    var hashResponse = await hashPassword(userData.password)
                    if (hashResponse.msg) {
                        userData.password = hashResponse.msg
                        customers.create(userData)
                            .then(async (user) => {
                                if (user) {
                                    var jwtResponse = await jwtCreate({ data: user.id, expiry: 172800 })
                                    if (jwtResponse.msg) {
                                        const url = `${BASE_URL}/auth/emailVerified/${jwtResponse.msg}`;
                                        var mailResponse = await sendMail({
                                            to: user.email,
                                            subject: 'Email Verification',
                                            html: `Click on the following link to verify your account: <a href="${url}">click here</a>`
                                        })
                                        if (mailResponse.msg) {
                                            resolve({ status: 200 })
                                        } else {
                                            reject({ error: mailResponse.err })
                                        }
                                    } else {
                                        reject({ error: jwtResponse.err })
                                    }
                                } else {
                                    reject({ error: "oops..! user creation failed" })
                                }
                            })
                            .catch(err => {
                                reject({ error: err })
                            });

                    } else {
                        reject({ error: hashResponse.err })
                    }
                } else {
                    resolve({ status: 405 })
                }
            })
            .catch(err => {
                reject({ error: err })
            })
    })
};

const bcrypt = require("bcrypt");

//hashing password
hashPassword = async (password) => {
    await bcrypt.hash(password, 10, (err, hash) => {
        if (hash) {
            return { msg: hash };
        } else {
            return { error: err };
        }
    })
};

const jwt = require("jsonwebtoken");

var EMAIL_SECRET = require("./../../constants/constants");

//jwt creation
jwtCreate = async (data) => {
    await jwt.sign(data.data, EMAIL_SECRET, { expiresIn: data.expiry }, (err, token) => {
        if (token) {
            return { msg: token };
        } else {
            return { error: err };
        }
    })
};

const nodemailer = require("nodemailer");

var MAIL_HOST = require("./../../constants/constants");
var EMAIL_USER = require("./../../constants/constants");
var EMAIL_PASS = require("./../../constants/constants");

//mail send
sendMail = async (data) => {
    let transporter = nodemailer.createTransport({
        host: MAIL_HOST,
        port: 587,
        secure: false, // true for 465, false for other ports
        auth: {
            user: EMAIL_USER,
            pass: EMAIL_PASS,
        },
        tls: {
            rejectUnauthorized: false,
        },
    });
    await transporter.sendMail({
        from: EMAIL_USER,
        to: data.to,
        subject: data.subject,
        html: data.html
    }, (err, response) => {
        if (token) {
            return { msg: response };
        } else {
            return { error: err };
        }
    });
};

const EMAIL_SECRET = "asdf1093KMnHGcvnkljvasdu09123nlasdasdf";
const MAIL_HOST = "mail.test.com";
const EMAIL_USER = "no_reply_auth@test.com";
const EMAIL_PASS = "JMkC+)*Lv";
const BASE_URL = "http://localhost:3001";

jwt.js

const express = require("express");
const authrequests = express.Router();
const cors = require("cors");

var createUser = require("./export/authConstants");

// Register User
authrequests.post("/register", async (req, res) => {
  const userData = {
    firstname: req.body.firstname,
    lastname: req.body.lastname,
    email: req.body.email,
    phone: req.body.phone,
    password: req.body.password,
    created: new Date(),
  };
  await createUser(userData)
    .then((res) => {
      console.log(res)
      if (res.status == 200) {
        return res.status(200).json({ msg: 'Registered!' });
      } else if (res.status == 405) {
        return res.status(405).json({ error: 'User already exists' });
      } else {
        return res.status(400).json({ error: err });
      }
    })
    .catch(err => {
      return res.status(400).json({ error: err });
    })
});
module.exports = authrequests;

const customers = require("./../../models/customers");

var hashPassword = require("./util/bcrypt");
var jwtCreate = require("./util/jwt");
var sendMail = require("./util/mail");
var BASE_URL = require("./../constants/constants");

//register
createUser = (userData) => {
    return new Promise(async (resolve, reject) => {
        customers.findOne({ where: { email: userData.email } })
            .then(async (user) => {
                if (!user) {
                    var hashResponse = await hashPassword(userData.password)
                    if (hashResponse.msg) {
                        userData.password = hashResponse.msg
                        customers.create(userData)
                            .then(async (user) => {
                                if (user) {
                                    var jwtResponse = await jwtCreate({ data: user.id, expiry: 172800 })
                                    if (jwtResponse.msg) {
                                        const url = `${BASE_URL}/auth/emailVerified/${jwtResponse.msg}`;
                                        var mailResponse = await sendMail({
                                            to: user.email,
                                            subject: 'Email Verification',
                                            html: `Click on the following link to verify your account: <a href="${url}">click here</a>`
                                        })
                                        if (mailResponse.msg) {
                                            resolve({ status: 200 })
                                        } else {
                                            reject({ error: mailResponse.err })
                                        }
                                    } else {
                                        reject({ error: jwtResponse.err })
                                    }
                                } else {
                                    reject({ error: "oops..! user creation failed" })
                                }
                            })
                            .catch(err => {
                                reject({ error: err })
                            });

                    } else {
                        reject({ error: hashResponse.err })
                    }
                } else {
                    resolve({ status: 405 })
                }
            })
            .catch(err => {
                reject({ error: err })
            })
    })
};

const bcrypt = require("bcrypt");

//hashing password
hashPassword = async (password) => {
    await bcrypt.hash(password, 10, (err, hash) => {
        if (hash) {
            return { msg: hash };
        } else {
            return { error: err };
        }
    })
};

const jwt = require("jsonwebtoken");

var EMAIL_SECRET = require("./../../constants/constants");

//jwt creation
jwtCreate = async (data) => {
    await jwt.sign(data.data, EMAIL_SECRET, { expiresIn: data.expiry }, (err, token) => {
        if (token) {
            return { msg: token };
        } else {
            return { error: err };
        }
    })
};

const nodemailer = require("nodemailer");

var MAIL_HOST = require("./../../constants/constants");
var EMAIL_USER = require("./../../constants/constants");
var EMAIL_PASS = require("./../../constants/constants");

//mail send
sendMail = async (data) => {
    let transporter = nodemailer.createTransport({
        host: MAIL_HOST,
        port: 587,
        secure: false, // true for 465, false for other ports
        auth: {
            user: EMAIL_USER,
            pass: EMAIL_PASS,
        },
        tls: {
            rejectUnauthorized: false,
        },
    });
    await transporter.sendMail({
        from: EMAIL_USER,
        to: data.to,
        subject: data.subject,
        html: data.html
    }, (err, response) => {
        if (token) {
            return { msg: response };
        } else {
            return { error: err };
        }
    });
};

const EMAIL_SECRET = "asdf1093KMnHGcvnkljvasdu09123nlasdasdf";
const MAIL_HOST = "mail.test.com";
const EMAIL_USER = "no_reply_auth@test.com";
const EMAIL_PASS = "JMkC+)*Lv";
const BASE_URL = "http://localhost:3001";

mail.js

const express = require("express");
const authrequests = express.Router();
const cors = require("cors");

var createUser = require("./export/authConstants");

// Register User
authrequests.post("/register", async (req, res) => {
  const userData = {
    firstname: req.body.firstname,
    lastname: req.body.lastname,
    email: req.body.email,
    phone: req.body.phone,
    password: req.body.password,
    created: new Date(),
  };
  await createUser(userData)
    .then((res) => {
      console.log(res)
      if (res.status == 200) {
        return res.status(200).json({ msg: 'Registered!' });
      } else if (res.status == 405) {
        return res.status(405).json({ error: 'User already exists' });
      } else {
        return res.status(400).json({ error: err });
      }
    })
    .catch(err => {
      return res.status(400).json({ error: err });
    })
});
module.exports = authrequests;

const customers = require("./../../models/customers");

var hashPassword = require("./util/bcrypt");
var jwtCreate = require("./util/jwt");
var sendMail = require("./util/mail");
var BASE_URL = require("./../constants/constants");

//register
createUser = (userData) => {
    return new Promise(async (resolve, reject) => {
        customers.findOne({ where: { email: userData.email } })
            .then(async (user) => {
                if (!user) {
                    var hashResponse = await hashPassword(userData.password)
                    if (hashResponse.msg) {
                        userData.password = hashResponse.msg
                        customers.create(userData)
                            .then(async (user) => {
                                if (user) {
                                    var jwtResponse = await jwtCreate({ data: user.id, expiry: 172800 })
                                    if (jwtResponse.msg) {
                                        const url = `${BASE_URL}/auth/emailVerified/${jwtResponse.msg}`;
                                        var mailResponse = await sendMail({
                                            to: user.email,
                                            subject: 'Email Verification',
                                            html: `Click on the following link to verify your account: <a href="${url}">click here</a>`
                                        })
                                        if (mailResponse.msg) {
                                            resolve({ status: 200 })
                                        } else {
                                            reject({ error: mailResponse.err })
                                        }
                                    } else {
                                        reject({ error: jwtResponse.err })
                                    }
                                } else {
                                    reject({ error: "oops..! user creation failed" })
                                }
                            })
                            .catch(err => {
                                reject({ error: err })
                            });

                    } else {
                        reject({ error: hashResponse.err })
                    }
                } else {
                    resolve({ status: 405 })
                }
            })
            .catch(err => {
                reject({ error: err })
            })
    })
};

const bcrypt = require("bcrypt");

//hashing password
hashPassword = async (password) => {
    await bcrypt.hash(password, 10, (err, hash) => {
        if (hash) {
            return { msg: hash };
        } else {
            return { error: err };
        }
    })
};

const jwt = require("jsonwebtoken");

var EMAIL_SECRET = require("./../../constants/constants");

//jwt creation
jwtCreate = async (data) => {
    await jwt.sign(data.data, EMAIL_SECRET, { expiresIn: data.expiry }, (err, token) => {
        if (token) {
            return { msg: token };
        } else {
            return { error: err };
        }
    })
};

const nodemailer = require("nodemailer");

var MAIL_HOST = require("./../../constants/constants");
var EMAIL_USER = require("./../../constants/constants");
var EMAIL_PASS = require("./../../constants/constants");

//mail send
sendMail = async (data) => {
    let transporter = nodemailer.createTransport({
        host: MAIL_HOST,
        port: 587,
        secure: false, // true for 465, false for other ports
        auth: {
            user: EMAIL_USER,
            pass: EMAIL_PASS,
        },
        tls: {
            rejectUnauthorized: false,
        },
    });
    await transporter.sendMail({
        from: EMAIL_USER,
        to: data.to,
        subject: data.subject,
        html: data.html
    }, (err, response) => {
        if (token) {
            return { msg: response };
        } else {
            return { error: err };
        }
    });
};

const EMAIL_SECRET = "asdf1093KMnHGcvnkljvasdu09123nlasdasdf";
const MAIL_HOST = "mail.test.com";
const EMAIL_USER = "no_reply_auth@test.com";
const EMAIL_PASS = "JMkC+)*Lv";
const BASE_URL = "http://localhost:3001";

constants.js

const express = require("express");
const authrequests = express.Router();
const cors = require("cors");

var createUser = require("./export/authConstants");

// Register User
authrequests.post("/register", async (req, res) => {
  const userData = {
    firstname: req.body.firstname,
    lastname: req.body.lastname,
    email: req.body.email,
    phone: req.body.phone,
    password: req.body.password,
    created: new Date(),
  };
  await createUser(userData)
    .then((res) => {
      console.log(res)
      if (res.status == 200) {
        return res.status(200).json({ msg: 'Registered!' });
      } else if (res.status == 405) {
        return res.status(405).json({ error: 'User already exists' });
      } else {
        return res.status(400).json({ error: err });
      }
    })
    .catch(err => {
      return res.status(400).json({ error: err });
    })
});
module.exports = authrequests;

const customers = require("./../../models/customers");

var hashPassword = require("./util/bcrypt");
var jwtCreate = require("./util/jwt");
var sendMail = require("./util/mail");
var BASE_URL = require("./../constants/constants");

//register
createUser = (userData) => {
    return new Promise(async (resolve, reject) => {
        customers.findOne({ where: { email: userData.email } })
            .then(async (user) => {
                if (!user) {
                    var hashResponse = await hashPassword(userData.password)
                    if (hashResponse.msg) {
                        userData.password = hashResponse.msg
                        customers.create(userData)
                            .then(async (user) => {
                                if (user) {
                                    var jwtResponse = await jwtCreate({ data: user.id, expiry: 172800 })
                                    if (jwtResponse.msg) {
                                        const url = `${BASE_URL}/auth/emailVerified/${jwtResponse.msg}`;
                                        var mailResponse = await sendMail({
                                            to: user.email,
                                            subject: 'Email Verification',
                                            html: `Click on the following link to verify your account: <a href="${url}">click here</a>`
                                        })
                                        if (mailResponse.msg) {
                                            resolve({ status: 200 })
                                        } else {
                                            reject({ error: mailResponse.err })
                                        }
                                    } else {
                                        reject({ error: jwtResponse.err })
                                    }
                                } else {
                                    reject({ error: "oops..! user creation failed" })
                                }
                            })
                            .catch(err => {
                                reject({ error: err })
                            });

                    } else {
                        reject({ error: hashResponse.err })
                    }
                } else {
                    resolve({ status: 405 })
                }
            })
            .catch(err => {
                reject({ error: err })
            })
    })
};

const bcrypt = require("bcrypt");

//hashing password
hashPassword = async (password) => {
    await bcrypt.hash(password, 10, (err, hash) => {
        if (hash) {
            return { msg: hash };
        } else {
            return { error: err };
        }
    })
};

const jwt = require("jsonwebtoken");

var EMAIL_SECRET = require("./../../constants/constants");

//jwt creation
jwtCreate = async (data) => {
    await jwt.sign(data.data, EMAIL_SECRET, { expiresIn: data.expiry }, (err, token) => {
        if (token) {
            return { msg: token };
        } else {
            return { error: err };
        }
    })
};

const nodemailer = require("nodemailer");

var MAIL_HOST = require("./../../constants/constants");
var EMAIL_USER = require("./../../constants/constants");
var EMAIL_PASS = require("./../../constants/constants");

//mail send
sendMail = async (data) => {
    let transporter = nodemailer.createTransport({
        host: MAIL_HOST,
        port: 587,
        secure: false, // true for 465, false for other ports
        auth: {
            user: EMAIL_USER,
            pass: EMAIL_PASS,
        },
        tls: {
            rejectUnauthorized: false,
        },
    });
    await transporter.sendMail({
        from: EMAIL_USER,
        to: data.to,
        subject: data.subject,
        html: data.html
    }, (err, response) => {
        if (token) {
            return { msg: response };
        } else {
            return { error: err };
        }
    });
};

const EMAIL_SECRET = "asdf1093KMnHGcvnkljvasdu09123nlasdasdf";
const MAIL_HOST = "mail.test.com";
const EMAIL_USER = "no_reply_auth@test.com";
const EMAIL_PASS = "JMkC+)*Lv";
const BASE_URL = "http://localhost:3001";

未处理的PromisejectionWarning:TypeError:createUser不是函数

---

有什么我遗漏的吗。。？或者整个流是错误的？

尝试导出createUser方法以便从其他地方使用。然后```export const createUser=（userData）=>{^^^^^^^^^^^^语法错误：意外标记“导出”``这是错误

exports.createUser=

syntax在postman中运行后，它会被未处理的Promisejection触发警告：类型错误：createUser不是函数