몽구스 객체값 저장하기

cheerio로 가져온값을 객체로 만든다음 밖으로 보내서 최종적으로 몽구스로 저장하고싶은데

문제가 생겼던게 저상태로 보내면 [object:object] 로 나오므로 JSON.stringfy()작업으로 문자열 형태로 내보내 주었습니다. 하지만 schema부분을 object로 하여도 object가 가장 상위의 데이터 타입으로 string형태로 저장된다고 여겨졌습니다. 그래서 JSON.stringfy()로 빼내고 저장하는 부분에서 JSON.parse로 하여 다시 저장할려 했지만 다시 [object:object]로 나와서 이부분을 어떻게 해결해야할지 잘찾아봐도 모르겠어서 질문 남겼습니다.

// siteInfo.js
import axios from "axios";
import cheerio from "cheerio";

export class SiteInfo {
  siteInfo = async (prefer) => {
    console.log(prefer);
    const siteData = await axios
      .get(prefer)
      .then()
      .catch((err) => {
        console.log("서버 데이터 안받아와짐 오류 : " + err);
      });
    const keys = [];
    const values = [];
    const $ = cheerio.load(siteData.data);
    $("meta").each((index, el) => {
      if (
        $(el).attr("property") &&
        ($(el).attr("property").includes("og:title") ||
          $(el).attr("property").includes("og:description") ||
          $(el).attr("property").includes("og:image"))
      ) {
        const content = $(el).attr("content");
        const title = $(el).attr("property");
        keys.push(title);
        values.push(content);
      }
    });
    const arr = [];

    for (let i = 0; i < keys.length; i++) {
      arr.push({
        [keys[i]]: values[i],
      });
    }
    console.log("여기 테스트 : " + arr);

    return arr;
  };
}


// signup.controller.js

export class SignupController {
  siteInfoService;
  isValueService;
  saveDataService;
  emailService;

  constructor(siteInfoService, isValueService, saveDataService, emailService) {
    this.siteInfoService = siteInfoService;
    this.isValueService = isValueService;
    this.saveDataService = saveDataService;
    this.emailService = emailService;
  }

  singUp = async (req, res) => {
    const name = req.body.name;
    const email = req.body.email;
    const personal = req.body.personal;
    const prefer = req.body.prefer;
    const pwd = req.body.pwd;
    const phone = req.body.phone;
    console.log(req.body);
    const hasValue = this.isValueService.checkToken(phone);

    if (hasValue === false) {
      res.json("isAuth값이 false입니다");
    }
    const siteInfo = await this.siteInfoService.siteInfo(prefer);
    const ttt = JSON.parse(siteInfo);
    console.log("여기 문제 발생 : " + typeof ttt);
    console.dir("여기 문제 발생 22222: " + ttt);

    const dataSave = await this.saveDataService.dataSave({
      name,
      email,
      personal,
      prefer,
      pwd,
      phone,
      siteInfo,
    });
    const isValue = this.emailService.checkMail(email);
    if (isValue === false) {
      res.send("이메일 형식이 잘못되었습니다");
    }
    const template = this.emailService.welcomeMessage({ name, phone, prefer });

    this.emailService.sendTemplateToEmail({
      template,
      email,
    });
    res.send("_id : " + dataSave);
  };

  userSearch = async (req, res) => {
    const searchReault = await this.saveDataService.dataSearch();
    console.log(searchReault);
    res.send(searchReault);
  };
}



// index.js

import express from "express";
import mongoose from "mongoose";
import cors from "cors";
// import { Token, User } from "./mvc/model/schema.model.js";

import { TokenController } from "./mvc/controller/token.controller.js";
import { SignupController } from "./mvc/controller/signup.controller.js";

// 사이트 정보 가져오기
import { SiteInfo } from "./mvc/controller/service/siteInfo.js";
// 핸드폰 정보 맞는지 boolean으로
import { CheckToken } from "./mvc/controller/service/token.js";
// db저장하고 리턴값 가져오기
import { UserDb } from "./mvc/controller/service/userDb.js";
// 이메일 확인하고 보내주기
import { EmailService } from "./mvc/controller/service/email.js";
// 핸드폰 문자 보내기
import { PhoneService } from "./mvc/controller/service/phone.js";

const app = express();
const corsOptions = {
  origin: "http://127.0.0.1:5500",
};
app.use(cors(corsOptions));
const siteInfo = new SiteInfo();
const checkToken = new CheckToken();
const userDb = new UserDb();
const emailService = new EmailService();
const phoneService = new PhoneService();

app.use(express.json());

const signUpController = new SignupController(
  siteInfo,
  checkToken,
  userDb,
  emailService
);

app.post("/users", signUpController.singUp);

app.get("/users", signUpController.userSearch);

const tokenController = new TokenController(phoneService, checkToken);

app.post("/tokens/phone", tokenController.insertdata);

app.patch("/tokens/phone", tokenController.checkToken);

mongoose.set("debug", true);

mongoose
  .connect("mongodb://mongodb-file:27017/dockerconnetor")
  .then(() => {
    console.log("connect success");
  })
  .catch(() => {
    console.log("fail to connect with db");
  });

app.listen(3001, () => {
  console.log("server open");
});

// userDb.js

import { User } from "../../model/schema.model.js";
export class UserDb {
  dataSave = async ({
    name,
    email,
    personal,
    prefer,
    pwd,
    phone,
    siteInfo,
  }) => {
    const siteInforesult = JSON.parse(siteInfo);
    console.log("여기 확인 : " + siteInforesult);
    const data = new User({
      name: name,
      email: email,
      personal: personal,
      prefer: prefer,
      pwd: pwd,
      phone: phone,
      siteInfo: siteInfo,
    });
    await data.save();
    const idData = await User.findOne({ phone: phone }, { _id: 1 }).exec();
    return idData._id;
  };

  dataSearch = async (name) => {
    console.log("start datasearch");
    const result = await User.find().exec();
    return result;
  };
}


// schema.model.js

import mongoose from "mongoose";

const tokenSchema = new mongoose.Schema({
  phone: String,
  token: Number,
  isAuth: Boolean,
});

export const Token = mongoose.model("Token", tokenSchema);

const userSchema = new mongoose.Schema({
  name: String,
  email: String,
  personal: String,
  prefer: String,
  pwd: String,
  phone: String,
  siteInfo: {
    title: String,
    content: String,
    image: String,
  },
});

export const User = mongoose.model("User", userSchema);

console.log("여기테스트: " + arr) 

console.log("여기테스트: ", arr) 

// 변경 전
const arr = []
for (let i = 0; i < keys.length; i++) {
  arr.push({
    [keys[i]]: values[i],
  });
}

// 변경 후
const arr = keys.map((key, i) => ({ [key]: values[i] }));