1
datasource db {
2
  provider = "postgresql"
3
  url      = "postgresql://johndoe:mypassword@localhost:5432/mydb?schema=public"
4
}

1
generator client {
2
  provider = 'prisma-client-js'
3
  output   = './generated/prisma-client-js'
4
}

1
model Comment {
2
  id      Int      @id @default(autoincrement())
3
  title   String
4
  content String
5
}
6

7
model Tag {
8
  name String @id
9
}

1
model User {
2
  id    Int     @id @default(autoincrement())
3
  email String  @unique
4
  name  String?
5
  role  Role    @default(USER)
6
}
7

8
enum Role {
9
  USER
10
  ADMIN
11
}

1
model User {
2
  id    Int     @id @default(autoincrement())
3
  name  String
4
  posts Post[]
5
}
6

7
model Post {
8
  id      Int      @id @default(autoincrement())
9
  title   String
10
  userId  Int
11
  user    User     @relation(fields: [userId], references: [id], onDelete: Cascade)
12
}

1
genreator client {
2
  provider = 'prisma-client-js'
3
}

1
$ npm install @prisma/client
2
$ prisma generate

1
const user = await prisma.user.create({
2
  data: {
3
    email: 'admin@codefactory.ai',
4
    name: 'Code Factory',
5
  },
6
})

1
const createMany = await prisma.user.createMany({
2
  data: [
3
    { email: '민지', email: 'minji@codefactory.ai' },
4
    { email: '슬기', email: 'seulgi@codefactory.ai' },
5
    { email: '원영', email: 'minji@codefactory.ai' }, // 중복 키
6
    { email: '다미', email: 'dami@codefactory.ai' },
7
  ],
8
  skipDuplicates: true, // 원영 스킵됨
9
})

1
const user = await prisma.user.findUniquye({
2
  where: { email: 'minji@codefactory.ai' },
3
})

1
const result = await prisma.user.findFirst({
2
  where: {
3
    email: { endsWith: 'codefactory.ai' },
4
  },
5
})

1
const user = await prisma.user.findMany({
2
  where: {
3
    email: { endsWith: 'codefactory.ai' },
4
  },
5
})

1
const users = await prisma.user.findMany({
2
  where: {
3
    OR: [
4
      { name: { startsWith: 'E' } },
5
      {
6
        AND: {
7
          profileViews: { gt: 0 },
8
          role: { equals: 'ADMIN' },
9
        },
10
      },
11
    ],
12
  },
13
})

1
const getUser = await prisma.user.findUnique({
2
  where: { id: 22 },
3
  select: {
4
    email: true,
5
    name: true,
6
  },
7
})

1
const users = await prisma.user.findMany({
2
  include: {
3
    posts: {
4
      select: { title: true },
5
    },
6
  },
7
})

1
const result = await prisma.user.findMany({
2
  where: {
3
    post: {
4
      some: {
5
        content: { contains: 'Code Factory' },
6
      },
7
    },
8
  },
9
})

1
const result = await prisma.user.findMany({
2
  where: {
3
    post: {
4
      every: { published: true },
5
    },
6
  },
7
})

1
const result = await prisma.user.findMany({
2
  where: {
3
    post: {
4
      none: { published: true },
5
    },
6
  },
7
})

1
const result = await prisma.user.findMany({
2
  where: {
3
    user: {
4
      is: { name: 'Code Factory' },
5
    },
6
  },
7
})

1
const result = await prisma.user.findMany({
2
  where: {
3
    user: {
4
      isNot: { name: 'Code Factory' },
5
    },
6
  },
7
})

1
const updateUser = await prisma.user.update({
2
  where: { email: 'test@codefactory.ai' },
3
  data: { name: '민지' },
4
})

1
const deleteUser = await prisma.user.delete({
2
  where: { email: 'test@codefactory.ai' },
3
})

1
model User {
2
  id        Int     @id @default(autoincrement())
3
  profile   Profile @relation(fields: [profileId], references: [id])
4
  profileId Int     @unique // 필수 (1:1이니까ㅣ 당연히)
5
}
6

7
model Profile {
8
  id    Int    @id @default(autoincrement())
9
  user  User?  // nullable만 가능
10
}

1
model User {
2
  id        Int      @id @default(autoincrement())
3
  profile   Profile? @relation(fields: [profileId], references: [id])
4
  profileId Int?     @unique // Optional 생성 가능
5
}
6

7
model Profile {
8
  id    Int    @id @default(autoincrement())
9
  user  User?
10
}

1
model User {
2
  id       Int      @id @default(autoincrement())
3
  posts    Post[]
4
}
5

6
model Post {
7
  id        Int    @id @default(autoincrement())
8
  author    User   @relation(fields: [authorId], references: [id])
9
  authorId  Int
10
}

1
model Post {
2
  id          Int                 @id @default(autoincrement())
3
  title       String
4
  categories  CategoriesOnPosts[]
5
}
6

7
model Category {
8
  id          Int                 @id @default(autoincrement())
9
  name        String
10
  posts       CategoriesOnPosts[]
11
}
12

13
model CategoriesOnPosts {
14
  post        Post      @relation(fields: [postId], references: [id])
15
  postId      Int
16
  category    Category  @relation(fields: [categoryId], references: [id])
17
  categoryId  Int
18
  assignedAt  DateTime   @default(now())
19
  assignedBy  String
20
  @@id([postId, categoryId])
21
}

1
model Post {
2
  id          Int         @id @default(autoincrement())
3
  title       String
4
  categories  Category[]
5
}
6

7
model Category {
8
  id          Int         @id @default(autoincrement())
9
  name        String
10
  posts       Post[]
11
}

1
const aggregations = await prisma.user.aggregate({
2
  _avg: { age: true },
3
})

1
const result = await prisma.$queryRaw('SELECT * FROM User')

1
# prisma migrate dev > 마이그레이션 파일 생성 (자동)
2
prisma migrate dev --name "add-new-field"

1
# prisma migrate deploy > 마이그레이션 진행
2
prisma migrate deploy

1
{
2
  "name": "John Doe",
3
  "age": 30,
4
  "email": "john@example.com",
5
  "interests": ["hiking", "coding"]
6
}

1
const mongoose = require('mongoose')
2

3
async function connectDB() {
4
  try {
5
    await mongoose.connect('mongodb://localhost:27017/mydb')
6
    console.log('MongoDB Connected')
7
  } catch (err) {
8
    console.error('Connection Error:', err)
9
  }
10
}
11

12
connectDB()

1
const userSchema = new mongoose.Schema({
2
  name: String,
3
  age: Number,
4
  email: String,
5
  interests: [String],
6
})
7

8
const User = mongoose.model('User', userSchema)
9

10
const newUser = new User({
11
  name: 'Code Factory',
12
  age: 25,
13
  email: 'admin@codefactory.ai',
14
  interests: ['reading', 'music'],
15
})

1
async function createUser() {
2
  try {
3
    const user = await User.create({
4
      name: '민지',
5
      age: 21,
6
      email: 'minji@codefactory.ai',
7
      interests: ['dancing', 'singing'],
8
    })
9
    console.log('User created:', user)
10
  } catch (err) {
11
    console.error('Error creating user:', err)
12
  }
13
}

1
async function findAllUsers() {
2
  try {
3
    const users = await User.find({})
4
    console.log('User found:', users)
5
  } catch (err) {
6
    console.error('Error finding users:', err)
7
  }
8
}

1
async function updateUser() {
2
  try {
3
    const updateUser = await User.updateOne(
4
      { email: '민지' }, //
5
      { $set: { age: 22 } },
6
    )
7
    console.log('User updated:', updateUser)
8
  } catch (err) {
9
    console.error('Error updating user:', err)
10
  }
11
}

1
async function deleteUser() {
2
  try {
3
    const deleteUser = await User.deleteOne({ name: '민지' })
4
    console.log('User deleted:', deleteUser)
5
  } catch (err) {
6
    console.error('Error deleting user:', err)
7
  }
8
}

1
const userSchema = new mongoose.Schema({
2
  name: String,
3
  age: Number,
4
  email: String,
5
  interests: [String],
6
})
7

8
const postSchema = new mongoose.Schema({
9
  title: String,
10
  author: {
11
    type: mongoose.Schema.Types.ObjectId,
12
    ref: 'User',
13
  },
14
})
15

16
async function findPostsWithAuthors() {
17
  try {
18
    const posts = await Post.find().populate('author').exec()
19
    console.log('Posts & authors:', posts)
20
  } catch (err) {
21
    console.error('Error : ', err)
22
  }
23
}

1
userSchema.pre('save', function (next) {
2
  console.log('Saving user:', this.name)
3
  next()
4
})
5

6
const User = mongoose.model('User', userSchema)

1
const mongoose = require('mongoose')
2

3
const profileSchema = new mongoose.Schema({
4
  bio: String,
5
  website: String,
6
  location: String,
7
})
8

9
const userSchema = new mongoose.Schema({
10
  name: String,
11
  email: String,
12
  profile: {
13
    type: mongoose.Schema.Types.ObjectId,
14
    ref: 'Profile',
15
  },
16
})

1
const userSchema = new mongoose.Schema({
2
  name: String,
3
  email: String,
4
  profile: {
5
    bio: String,
6
    website: String,
7
    location: String,
8
  },
9
})

1
const commentSchema = new mongoose.Schema({
2
  body: String,
3
  date: Date,
4
  postId: {
5
    type: mongoose.Schema.Types.ObjectId,
6
    ref: 'Post',
7
  },
8
})
9

10
const postSchema = new mongoose.Schema({
11
  title: String,
12
  content: String,
13
  comments: [
14
    {
15
      type: mongoose.Schema.Types.ObjectId,
16
      ref: 'Comment',
17
    },
18
  ],
19
})

1
const roleSchema = new mongoose.Schema({
2
  name: String,
3
  users: [
4
    {
5
      type: mongoose.Schema.Types.ObjectId,
6
      ref: 'User',
7
    },
8
  ],
9
})
10

11
const userSchema = new mongoose.Schema({
12
  name: String,
13
  roles: [
14
    {
15
      type: mongoose.Schema.Types.ObjectId,
16
      ref: 'Role',
17
    },
18
  ],
19
})

1
const session = await mongoose.startSession()
2
session.startTransaction()
3

4
try {
5
  const user = new User({ name: '민지', email: 'minji@codefactory.ai' })
6
  await user.save({ session })
7

8
  const post = new Post({ title: "Minji's Post", author: user._id })
9
  await post.save({ session })
10

11
  await session.commitTransaction() // 커밋
12
  session.endSession() // 세션 종료
13
} catch (error) {
14
  await session.abortTransaction() // 롤백
15
  session.endSession()
16
  throw error
17
}