feat 엔티티모델 정의 및 DB연결 테스트완료 (#3)

.env

+DB_HOST=localhost
+DB_USER=root
+DB_PASSWORD=0000
+DB_NAME=meeting
+MONGO_URI=mongodb://localhost:27017/your_mongo_db
+PORT=3306
\ No newline at end of file

.gitignore

 node_modules/
+.env/
+config.json/

app.js

+// app.js
+
+require('dotenv').config(); // 환경 변수 로드
+
 const express = require('express');
 const app = express();
-const PORT = process.env.PORT || 3000;
+const sequelize = require('./config/sequelize');
+//const mongoose = require('./config/mongoose');
+//const userRoutes = require('./routes/userRoutes');
+//const passport = require('./passport');
 
-app.get('/', (req, res) => {
-  res.send('Hello, World!');
+// 미들웨어 설정
+app.use(express.json());
+//app.use(passport.initialize());
+
+// 라우팅
+//app.use('/users', userRoutes);
+
+// Sequelize 데이터베이스 연결 및 동기화
+sequelize.sync()
+  .then(() => {
+    console.log('Sequelize synchronized.');
+  })
+  .catch(err => {
+    console.error('Sequelize synchronization error:', err);
   });
 
+// 서버 시작
+const PORT = process.env.PORT || 3000;
 app.listen(PORT, () => {
-  console.log(`Server is running on http://localhost:${PORT}`);
+  console.log(`Server running on port ${PORT}`);
 });

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: false,
+});
+
+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 { DataTypes } = require('sequelize');
+const sequelize = require('../config/sequelize');
+const User = require('./User');
+
 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,
@@ -21,44 +19,23 @@ module.exports = (sequelize, DataTypes) => {
   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;
-};
+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',
-    },
-  }, {
+
+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,
-    indexes: [
-      {
-        unique: true,
-        fields: ['meeting_id', 'user_id'],
-      },
-    ],
+  timestamps: true,
 });
 
-  return MeetingParticipant;
-};
+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 { DataTypes } = require('sequelize');
+const sequelize = require('../config/sequelize');
+const User = require('./User');
+
 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,
@@ -26,23 +16,13 @@ module.exports = (sequelize, DataTypes) => {
   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'],
-      },
-    ],
+  timestamps: true,
 });
 
-  return Schedule;
-};
+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 { DataTypes } = require('sequelize');
+const sequelize = require('../config/sequelize'); // sequelize 인스턴스 경로에 맞게 수정하세요.
+
 const User = sequelize.define('User', {
-    id: {
-      type: DataTypes.BIGINT,
-      primaryKey: true,
-      autoIncrement: true,
-    },
   name: {
-      type: DataTypes.STRING,
+    type: DataTypes.STRING, // VARCHAR
     allowNull: false,
   },
   email: {
-      type: DataTypes.STRING,
+    type: DataTypes.STRING, // VARCHAR
     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,
+      isEmail: true,
     },
-    // updated_at 추가 (필요 시)
-    updated_at: {
-      type: DataTypes.DATE,
-      defaultValue: DataTypes.NOW,
   },
 }, {
   tableName: 'Users',
-    timestamps: false, // created_at과 updated_at을 수동으로 관리
+  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);