bufgix conflict 해결(#2)

.gitignore

-node_modules/
\ No newline at end of file
+node_modules/
+.env/
+config.json/

app.js

-<<<<<<< Updated upstream
-=======
+
 // app.js
 
 require('dotenv').config();
 
->>>>>>> Stashed changes
 const express = require('express');
 const session = require('express-session');
 const passport = require('./passport'); // 변경된 경로
 const flash = require('connect-flash');
 
 const app = express();
-<<<<<<< Updated upstream
-=======
+
 
 // 미들웨어 설정
 app.use(express.json());
@@ -38,10 +35,6 @@ app.use(flash());
 const authRoutes = require('./routes/auth');
 app.use('/auth', authRoutes);
 
-// ... 다른 라우트 및 설정
-
-// 서버 시작
->>>>>>> Stashed changes
 const PORT = process.env.PORT || 3000;
 
 app.get('/', (req, res) => {
@@ -50,4 +43,4 @@ app.get('/', (req, res) => {
 
 app.listen(PORT, () => {
   console.log(`Server is running on http://localhost:${PORT}`);
-});
\ No newline at end of file
+});

config/config.json

-{
-  "development": {
-    "username": "root",
-    "password": null,
-    "database": "database_development",
-    "host": "127.0.0.1",
-    "dialect": "mysql"
-  },
-  "test": {
-    "username": "root",
-    "password": null,
-    "database": "database_test",
-    "host": "127.0.0.1",
-    "dialect": "mysql"
-  },
-  "production": {
-    "username": "root",
-    "password": null,
-    "database": "database_production",
-    "host": "127.0.0.1",
-    "dialect": "mysql"
-  }
-}

config/mongoose.js

+// config/mongoose.js
+
+const mongoose = require('mongoose');
+
+mongoose.connect(process.env.MONGO_URI, {
+  useNewUrlParser: true,
+  useUnifiedTopology: true,
+});
+
+mongoose.connection.on('connected', () => {
+  console.log('Mongoose connected.');
+});
+
+mongoose.connection.on('error', (err) => {
+  console.error('Mongoose connection error:', err);
+});
+
+module.exports = mongoose;

config/sequelize.js

+// config/sequelize.js
+
+const { Sequelize } = require('sequelize');
+
+const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, {
+  host: process.env.DB_HOST,
+  dialect: 'mysql', // 사용하려는 DBMS에 맞게 변경
+  logging: false,
+  define: {
+    //timestamps: true, // createdAt, updatedAt 자동 생성
+    underscored: true, // created_at 형식의 필드명 사용
+  },
+});
+
+module.exports = sequelize;
\ No newline at end of file

models/Friend.js

+// models/Friend.js
+
+const { DataTypes } = require('sequelize');
+const sequelize = require('../config/sequelize');
+const User = require('./User');
+
+const Friend = sequelize.define('Friend', {
+  type: {
+    type: DataTypes.ENUM('NORMAL', 'SPECIAL'),
+    allowNull: false,
+  },
+}, {
+  tableName: 'Friends',
+  timestamps: true,
+});
+
+Friend.belongsTo(User, { foreignKey: 'user_id', as: 'user' });
+Friend.belongsTo(User, { foreignKey: 'friend_id', as: 'friend' });
+
+User.hasMany(Friend, { foreignKey: 'user_id', as: 'friends' });
+User.hasMany(Friend, { foreignKey: 'friend_id', as: 'friendOf' });
+
+module.exports = Friend;

models/Friends.js

-// models/Friend.js
-module.exports = (sequelize, DataTypes) => {
-  const Friend = sequelize.define('Friend', {
-    id: {
-      type: DataTypes.BIGINT,
-      primaryKey: true,
-      autoIncrement: true,
-    },
-    user_id: {
-      type: DataTypes.BIGINT,
-      allowNull: false,
-      references: {
-        model: 'Users',
-        key: 'id',
-      },
-      onDelete: 'CASCADE',
-    },
-    friend_id: {
-      type: DataTypes.BIGINT,
-      allowNull: false,
-      references: {
-        model: 'Users',
-        key: 'id',
-      },
-      onDelete: 'CASCADE',
-    },
-    type: {
-      type: DataTypes.ENUM('NORMAL', 'SPECIAL'),
-      allowNull: false,
-    },
-    created_at: {
-      type: DataTypes.DATE,
-      defaultValue: DataTypes.NOW,
-    },
-  }, {
-    tableName: 'Friends',
-    timestamps: false,
-    indexes: [
-      {
-        unique: true,
-        fields: ['user_id', 'friend_id'],
-      },
-    ],
-  });
-
-  return Friend;
-};

models/index.js

-// models/User.js
-module.exports = (sequelize, DataTypes) => {
-  const User = sequelize.define('User', {
-    id: {
-      type: DataTypes.BIGINT,
-      primaryKey: true,
-      autoIncrement: true,
-    },
-    name: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    email: {
-      type: DataTypes.STRING,
-      allowNull: false,
-      unique: true,
-      validate: {
-        isEmail: true, // 이메일 형식 검증
-      },
-    },
-    invite_code: {
-      type: DataTypes.UUID,
-      defaultValue: DataTypes.UUIDV4, // 자동으로 UUID 생성
-      allowNull: false,
-      unique: true,
-    },
-    created_at: {
-      type: DataTypes.DATE,
-      defaultValue: DataTypes.NOW,
-    },
-    // updated_at 추가 (필요 시)
-    updated_at: {
-      type: DataTypes.DATE,
-      defaultValue: DataTypes.NOW,
-    },
-  }, {
-    tableName: 'Users',
-    timestamps: false, // created_at과 updated_at을 수동으로 관리
-  });
+// models/index.js
 
-  return User;
+const sequelize = require('../config/sequelize');
+
+const User = require('./User');
+const Schedule = require('./Schedule');
+const Meeting = require('./Meeting');
+const MeetingParticipant = require('./MeetingParticipant'); //대소문자수정
+const Friend = require('./Friend');
+
+module.exports = {
+  sequelize,
+  User,
+  Schedule,
+  Meeting,
+  MeetingParticipant,
+  Friend,
 };

models/meeting.js

 // models/Meeting.js
-module.exports = (sequelize, DataTypes) => {
-  const Meeting = sequelize.define('Meeting', {
-    id: {
-      type: DataTypes.BIGINT,
-      primaryKey: true,
-      autoIncrement: true,
-    },
-    title: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    description: {
-      type: DataTypes.TEXT,
-      allowNull: true,
-    },
-    start_time: {
-      type: DataTypes.DATE,
-      allowNull: false,
-    },
-    end_time: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      validate: {
-        isAfterStart(value) {
-          if (value <= this.start_time) {
-            throw new Error('end_time은 start_time 이후여야 합니다.');
-          }
-        },
-      },
-    },
-    location: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-    deadline: {
-      type: DataTypes.DATE,
-      allowNull: true,
-    },
-    type: {
-      type: DataTypes.ENUM('OPEN', 'CLOSE'),
-      allowNull: false,
-    },
-    created_by: {
-      type: DataTypes.BIGINT,
-      allowNull: false,
-      references: {
-        model: 'Users',
-        key: 'id',
-      },
-      onDelete: 'CASCADE',
-    },
-  }, {
-    tableName: 'Meetings',
-    timestamps: false,
-    indexes: [
-      {
-        fields: ['created_by'],
-      },
-    ],
-  });
 
-  return Meeting;
-};
+const { DataTypes } = require('sequelize');
+const sequelize = require('../config/sequelize');
+const User = require('./User');
+
+const Meeting = sequelize.define('Meeting', {
+  title: {
+    type: DataTypes.STRING,
+    allowNull: false,
+  },
+  description: {
+    type: DataTypes.TEXT,
+  },
+  start_time: {
+    type: DataTypes.DATE,
+    allowNull: false,
+  },
+  end_time: {
+    type: DataTypes.DATE,
+    allowNull: false,
+  },
+  location: {
+    type: DataTypes.STRING,
+  },
+  deadline: {
+    type: DataTypes.DATE,
+  },
+  type: {
+    type: DataTypes.ENUM('OPEN', 'CLOSE'),
+    allowNull: false,
+  },
+}, {
+  tableName: 'Meetings',
+  timestamps: false,
+});
+
+Meeting.belongsTo(User, { foreignKey: 'created_by', as: 'creator' });
+User.hasMany(Meeting, { foreignKey: 'created_by', as: 'meetings' });
+
+module.exports = Meeting;

models/meetingParticipant.js

 // models/MeetingParticipant.js
-module.exports = (sequelize, DataTypes) => {
-  const MeetingParticipant = sequelize.define('MeetingParticipant', {
-    id: {
-      type: DataTypes.BIGINT,
-      primaryKey: true,
-      autoIncrement: true,
-    },
-    meeting_id: {
-      type: DataTypes.BIGINT,
-      allowNull: false,
-      references: {
-        model: 'Meetings',
-        key: 'id',
-      },
-      onDelete: 'CASCADE',
-    },
-    user_id: {
-      type: DataTypes.BIGINT,
-      allowNull: false,
-      references: {
-        model: 'Users',
-        key: 'id',
-      },
-      onDelete: 'CASCADE',
-    },
-  }, {
-    tableName: 'MeetingParticipants',
-    timestamps: false,
-    indexes: [
-      {
-        unique: true,
-        fields: ['meeting_id', 'user_id'],
-      },
-    ],
-  });
 
-  return MeetingParticipant;
-};
+const { DataTypes } = require('sequelize');
+const sequelize = require('../config/sequelize');
+const Meeting = require('./Meeting');
+const User = require('./User');
+
+const MeetingParticipant = sequelize.define('MeetingParticipant', {}, {
+  tableName: 'MeetingParticipants',
+  timestamps: false,
+});
+
+MeetingParticipant.belongsTo(Meeting, { foreignKey: 'meeting_id', as: 'meeting' });
+Meeting.hasMany(MeetingParticipant, { foreignKey: 'meeting_id', as: 'participants' });
+
+MeetingParticipant.belongsTo(User, { foreignKey: 'user_id', as: 'user' });
+User.hasMany(MeetingParticipant, { foreignKey: 'user_id', as: 'meetingParticipations' });
+
+module.exports = MeetingParticipant;

models/schedule.js

 // models/Schedule.js
-module.exports = (sequelize, DataTypes) => {
-  const Schedule = sequelize.define('Schedule', {
-    id: {
-      type: DataTypes.BIGINT,
-      primaryKey: true,
-      autoIncrement: true,
-    },
-    user_id: {
-      type: DataTypes.BIGINT,
-      allowNull: false,
-      references: {
-        model: 'Users',
-        key: 'id',
-      },
-      onDelete: 'CASCADE',
-    },
-    title: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    start_time: {
-      type: DataTypes.DATE,
-      allowNull: false,
-    },
-    end_time: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      validate: {
-        isAfterStart(value) {
-          if (value <= this.start_time) {
-            throw new Error('end_time은 start_time 이후여야 합니다.');
-          }
-        },
-      },
-    },
-  }, {
-    tableName: 'Schedules',
-    timestamps: false,
-    indexes: [
-      {
-        fields: ['user_id'],
-      },
-    ],
-  });
 
-  return Schedule;
-};
+const { DataTypes } = require('sequelize');
+const sequelize = require('../config/sequelize');
+const User = require('./User');
+
+const Schedule = sequelize.define('Schedule', {
+  title: {
+    type: DataTypes.STRING,
+    allowNull: false,
+  },
+  start_time: {
+    type: DataTypes.DATE,
+    allowNull: false,
+  },
+  end_time: {
+    type: DataTypes.DATE,
+    allowNull: false,
+  },
+}, {
+  tableName: 'Schedules',
+  timestamps: false,
+});
+
+Schedule.belongsTo(User, { foreignKey: 'user_id', as: 'user' });
+User.hasMany(Schedule, { foreignKey: 'user_id', as: 'schedules' });
+
+module.exports = Schedule;

models/user.js

 // models/User.js
-module.exports = (sequelize, DataTypes) => {
-  const User = sequelize.define('User', {
-    id: {
-      type: DataTypes.BIGINT,
-      primaryKey: true,
-      autoIncrement: true,
-    },
-    name: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    email: {
-      type: DataTypes.STRING,
-      allowNull: false,
-      unique: true,
-      validate: {
-        isEmail: true, // 이메일 형식 검증
-      },
-    },
-    invite_code: {
-      type: DataTypes.UUID,
-      defaultValue: DataTypes.UUIDV4, // 자동으로 UUID 생성
-      allowNull: false,
-      unique: true,
-    },
-    created_at: {
-      type: DataTypes.DATE,
-      defaultValue: DataTypes.NOW,
-    },
-    // updated_at 추가 (필요 시)
-    updated_at: {
-      type: DataTypes.DATE,
-      defaultValue: DataTypes.NOW,
+
+const { DataTypes } = require('sequelize');
+const sequelize = require('../config/sequelize'); // sequelize 인스턴스 경로에 맞게 수정하세요.
+
+const User = sequelize.define('User', {
+  name: {
+    type: DataTypes.STRING, // VARCHAR
+    allowNull: false,
+  },
+  email: {
+    type: DataTypes.STRING, // VARCHAR
+    allowNull: false,
+    unique: true,
+    validate: {
+      isEmail: true,
     },
-  }, {
-    tableName: 'Users',
-    timestamps: false, // created_at과 updated_at을 수동으로 관리
-  });
+  },
+}, {
+  tableName: 'Users',
+  timestamps: true, // createdAt과 updatedAt 자동 관리
+});
 
-  return User;
-};
+module.exports = User;

package.json

 {
   "name": "webback",
   "version": "1.0.0",
-  "main": "index.js",
+  "main": "app.js",
   "scripts": {
+    "start": "nodemon app",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {

schemas/ChatRoomParticipants.js

-const ChatRoomParticipantSchema = new Schema({
+// schemas/ChatRoomParticipant.js
+
+const mongoose = require('mongoose');
+
+const ChatRoomParticipantSchema = new mongoose.Schema({
   chat_room_id: {
-    type: mongoose.Schema.Types.BigInt,
+    type: mongoose.Schema.Types.ObjectId,
     ref: 'ChatRoom',
     required: true,
   },
   user_id: {
-    type: mongoose.Schema.Types.BigInt,
-    ref: 'User',
+    type: Number, // SQL의 Users 테이블 ID 참조
     required: true,
   },
-  joined_at: {
-    type: Date,
-    default: Date.now,
-  },
   left_at: {
     type: Date,
     default: null,
   },
+}, {
+  timestamps: { createdAt: 'joined_at', updatedAt: false },
 });
 
-// 복합 인덱스 생성하여 중복 참여 방지
-ChatRoomParticipantSchema.index({ chat_room_id: 1, user_id: 1 }, { unique: true });
-
 module.exports = mongoose.model('ChatRoomParticipant', ChatRoomParticipantSchema);

schemas/ChatRooms.js

+// schemas/ChatRoom.js
+
 const mongoose = require('mongoose');
-const { Schema } = mongoose;
 
-const ChatRoomSchema = new Schema({
+const ChatRoomSchema = new mongoose.Schema({
   name: {
     type: String,
     required: true,
   },
   meeting_id: {
-    type: mongoose.Schema.Types.BigInt, // 관계형 DB의 Meetings.id와 연동
-    ref: 'Meeting',
+    type: Number, // SQL의 Meetings 테이블 ID 참조
     default: null,
   },
   type: {
@@ -17,18 +17,11 @@ const ChatRoomSchema = new Schema({
     required: true,
   },
   created_by: {
-    type: mongoose.Schema.Types.BigInt, // 관계형 DB의 Users.id와 연동
-    ref: 'User',
+    type: Number, // SQL의 Users 테이블 ID 참조
     required: true,
   },
-  created_at: {
-    type: Date,
-    default: Date.now,
-  },
-  updated_at: {
-    type: Date,
-    default: Date.now,
-  },
+}, {
+  timestamps: true, // createdAt, updatedAt 자동 관리
 });
 
 module.exports = mongoose.model('ChatRoom', ChatRoomSchema);

schemas/Messages.js

-const MessageSchema = new Schema({
+// schemas/Message.js
+
+const mongoose = require('mongoose');
+
+const MessageSchema = new mongoose.Schema({
   chat_room_id: {
-    type: mongoose.Schema.Types.BigInt,
+    type: mongoose.Schema.Types.ObjectId,
     ref: 'ChatRoom',
     required: true,
   },
   sender_id: {
-    type: mongoose.Schema.Types.BigInt,
-    ref: 'User',
+    type: Number, // SQL의 Users 테이블 ID 참조
     required: true,
   },
   message: {
     type: String,
     required: true,
   },
-  sent_at: {
-    type: Date,
-    default: Date.now,
-  },
+}, {
+  timestamps: { createdAt: 'sent_at', updatedAt: false },
 });
 
-// 인덱스 추가하여 조회 성능 향상
-MessageSchema.index({ chat_room_id: 1, sent_at: -1 });
-
 module.exports = mongoose.model('Message', MessageSchema);

schemas/index.js

-const mongoose = require('mongoose');
-
-// MongoDB 연결
-mongoose.connect('mongodb://localhost:27017/chatDB', {
-  useNewUrlParser: true,
-  useUnifiedTopology: true,
-})
-.then(() => console.log('MongoDB 연결 성공'))
-.catch(err => console.error('MongoDB 연결 실패:', err));
-
-// 위에서 정의한 ChatRoom, ChatRoomParticipant, Message 모델을 사용
-const ChatRoom = require('./models/ChatRoom');
-const ChatRoomParticipant = require('./models/ChatRoomParticipant');
-const Message = require('./models/Message');
-
-// 예시: 채팅방 생성
-async function createChatRoom(data) {
-  try {
-    const chatRoom = new ChatRoom(data);
-    await chatRoom.save();
-    console.log('채팅방 생성 완료:', chatRoom);
-  } catch (error) {
-    console.error('채팅방 생성 실패:', error);
-  }
-}
-
-// 예시 함수 호출
-createChatRoom({
-  name: '일반 채팅방',
-  type: 'OPEN',
-  created_by: 1, // 관계형 DB의 Users.id와 일치
-});