test commit

2026-05-21 14:22:03 +05:00
parent 058fa26e12
commit 47124a01a7
21 changed files with 535 additions and 527 deletions
@@ -6,116 +6,136 @@ import {
 import { prisma } from '../../lib/prisma.js'

 export async function registerAdminCategoryRoutes(fastify) {
-  fastify.get('/api/admin/categories', { preHandler: [fastify.verifyAdmin] }, async () => {
-    const items = await prisma.category.findMany({
-      orderBy: [{ sort: 'asc' }, { name: 'asc' }],
-    })
-    return { items }
+  fastify.get('/api/admin/categories', { preHandler: [fastify.verifyAdmin] }, async (request, reply) => {
+    try {
+      const items = await prisma.category.findMany({
+        orderBy: [{ sort: 'asc' }, { name: 'asc' }],
+      })
+      return { items }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось загрузить категории' })
+    }
  })

  fastify.post('/api/admin/categories', { preHandler: [fastify.verifyAdmin] }, async (request, reply) => {
-    const body = request.body ?? {}
-    const name = String(body.name ?? '').trim()
-    if (!name) {
-      reply.code(400).send({ error: 'Укажите название категории' })
-      return
+    try {
+      const body = request.body ?? {}
+      const name = String(body.name ?? '').trim()
+      if (!name) {
+        reply.code(400).send({ error: 'Укажите название категории' })
+        return
+      }
+      const slug = String(body.slug ?? '').trim() || request.server.slugify(name) || `cat-${Date.now()}`
+      if (isUnspecifiedCategorySlug(slug)) {
+        reply.code(400).send({ error: `Slug «${UNSPECIFIED_CATEGORY_SLUG}» зарезервирован` })
+        return
+      }
+      const sort = body.sort !== undefined && body.sort !== null && body.sort !== '' ? Number(body.sort) : undefined
+      const exists = await prisma.category.findUnique({ where: { slug } })
+      if (exists) {
+        reply.code(409).send({ error: 'Такой slug уже занят' })
+        return
+      }
+      const category = await prisma.category.create({
+        data: {
+          name,
+          slug,
+          sort: Number.isFinite(sort) ? Math.round(sort) : 0,
+        },
+      })
+      reply.code(201).send(category)
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось создать категорию' })
    }
-    const slug = String(body.slug ?? '').trim() || request.server.slugify(name) || `cat-${Date.now()}`
-    if (isUnspecifiedCategorySlug(slug)) {
-      reply.code(400).send({ error: `Slug «${UNSPECIFIED_CATEGORY_SLUG}» зарезервирован` })
-      return
-    }
-    const sort = body.sort !== undefined && body.sort !== null && body.sort !== '' ? Number(body.sort) : undefined
-    const exists = await prisma.category.findUnique({ where: { slug } })
-    if (exists) {
-      reply.code(409).send({ error: 'Такой slug уже занят' })
-      return
-    }
-    const category = await prisma.category.create({
-      data: {
-        name,
-        slug,
-        sort: Number.isFinite(sort) ? Math.round(sort) : 0,
-      },
-    })
-    reply.code(201).send(category)
  })

  fastify.patch('/api/admin/categories/:id', { preHandler: [fastify.verifyAdmin] }, async (request, reply) => {
-    const { id } = request.params
-    const body = request.body ?? {}
-    const existing = await prisma.category.findUnique({ where: { id } })
-    if (!existing) {
-      reply.code(404).send({ error: 'Категория не найдена' })
-      return
-    }
+    try {
+      const { id } = request.params
+      const body = request.body ?? {}
+      const existing = await prisma.category.findUnique({ where: { id } })
+      if (!existing) {
+        reply.code(404).send({ error: 'Категория не найдена' })
+        return
+      }

-    const data = {}
-    if (body.name !== undefined) data.name = String(body.name ?? '').trim()
-    if (body.sort !== undefined) {
-      const s = Number(body.sort)
-      if (!Number.isFinite(s)) {
-        reply.code(400).send({ error: 'Некорректный sort' })
-        return
-      }
-      data.sort = Math.round(s)
-    }
-    if (body.slug !== undefined) {
-      const s = String(body.slug ?? '').trim()
-      if (isUnspecifiedCategorySlug(existing.slug) && s !== UNSPECIFIED_CATEGORY_SLUG) {
-        reply.code(400).send({ error: 'Нельзя сменить slug служебной категории «Не указано»' })
-        return
-      }
-      if (!s) {
-        reply.code(400).send({ error: 'Slug не может быть пустым' })
-        return
-      }
-      if (s !== existing.slug) {
-        if (isUnspecifiedCategorySlug(s)) {
-          reply.code(400).send({ error: `Slug «${UNSPECIFIED_CATEGORY_SLUG}» зарезервирован` })
+      const data = {}
+      if (body.name !== undefined) data.name = String(body.name ?? '').trim()
+      if (body.sort !== undefined) {
+        const s = Number(body.sort)
+        if (!Number.isFinite(s)) {
+          reply.code(400).send({ error: 'Некорректный sort' })
          return
        }
-        const clash = await prisma.category.findFirst({ where: { slug: s, NOT: { id } } })
-        if (clash) {
-          reply.code(409).send({ error: 'Такой slug уже занят' })
+        data.sort = Math.round(s)
+      }
+      if (body.slug !== undefined) {
+        const s = String(body.slug ?? '').trim()
+        if (isUnspecifiedCategorySlug(existing.slug) && s !== UNSPECIFIED_CATEGORY_SLUG) {
+          reply.code(400).send({ error: 'Нельзя сменить slug служебной категории «Не указано»' })
          return
        }
+        if (!s) {
+          reply.code(400).send({ error: 'Slug не может быть пустым' })
+          return
+        }
+        if (s !== existing.slug) {
+          if (isUnspecifiedCategorySlug(s)) {
+            reply.code(400).send({ error: `Slug «${UNSPECIFIED_CATEGORY_SLUG}» зарезервирован` })
+            return
+          }
+          const clash = await prisma.category.findFirst({ where: { slug: s, NOT: { id } } })
+          if (clash) {
+            reply.code(409).send({ error: 'Такой slug уже занят' })
+            return
+          }
+        }
+        data.slug = s
      }
-      data.slug = s
-    }

-    if (Object.keys(data).length === 0) {
-      return existing
-    }
-    if (data.name !== undefined && !data.name) {
-      reply.code(400).send({ error: 'Укажите название' })
-      return
-    }
+      if (Object.keys(data).length === 0) {
+        return existing
+      }
+      if (data.name !== undefined && !data.name) {
+        reply.code(400).send({ error: 'Укажите название' })
+        return
+      }

-    const updated = await prisma.category.update({ where: { id }, data })
-    return updated
+      const updated = await prisma.category.update({ where: { id }, data })
+      return updated
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось обновить категорию' })
+    }
  })

  fastify.delete('/api/admin/categories/:id', { preHandler: [fastify.verifyAdmin] }, async (request, reply) => {
-    const { id } = request.params
-    const existing = await prisma.category.findUnique({ where: { id } })
-    if (!existing) {
-      reply.code(404).send({ error: 'Категория не найдена' })
-      return
-    }
-    if (isUnspecifiedCategorySlug(existing.slug)) {
-      reply.code(409).send({ error: 'Служебную категорию «Не указано» нельзя удалить' })
-      return
-    }
+    try {
+      const { id } = request.params
+      const existing = await prisma.category.findUnique({ where: { id } })
+      if (!existing) {
+        reply.code(404).send({ error: 'Категория не найдена' })
+        return
+      }
+      if (isUnspecifiedCategorySlug(existing.slug)) {
+        reply.code(409).send({ error: 'Служебную категорию «Не указано» нельзя удалить' })
+        return
+      }

-    const fallback = await getOrCreateUnspecifiedCategory()
-    await prisma.$transaction([
-      prisma.product.updateMany({
-        where: { categoryId: id },
-        data: { categoryId: fallback.id },
-      }),
-      prisma.category.delete({ where: { id } }),
-    ])
-    return reply.code(204).send()
+      const fallback = await getOrCreateUnspecifiedCategory()
+      await prisma.$transaction([
+        prisma.product.updateMany({
+          where: { categoryId: id },
+          data: { categoryId: fallback.id },
+        }),
+        prisma.category.delete({ where: { id } }),
+      ])
+      return reply.code(204).send()
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось удалить категорию' })
+    }
  })
 }
@@ -3,89 +3,104 @@ import { prisma } from '../../lib/prisma.js'
 const MAX_SLIDES = 20

 export async function registerCatalogSliderRoutes(fastify) {
-  fastify.get('/api/catalog-slider', async () => {
-    const slides = await prisma.catalogSliderSlide.findMany({
-      orderBy: { sortOrder: 'asc' },
-      include: { galleryImage: true },
-    })
-    return {
-      slides: slides.map((s) => ({
-        id: s.id,
-        url: s.galleryImage.url,
-        caption: s.caption,
-      })),
+  fastify.get('/api/catalog-slider', async (request, reply) => {
+    try {
+      const slides = await prisma.catalogSliderSlide.findMany({
+        orderBy: { sortOrder: 'asc' },
+        include: { galleryImage: true },
+      })
+      return {
+        slides: slides.map((s) => ({
+          id: s.id,
+          url: s.galleryImage.url,
+          caption: s.caption,
+        })),
+      }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось загрузить слайдер' })
    }
  })

-  fastify.get('/api/admin/catalog-slider', { preHandler: [fastify.verifyAdmin] }, async () => {
-    const slides = await prisma.catalogSliderSlide.findMany({
-      orderBy: { sortOrder: 'asc' },
-      include: { galleryImage: true },
-    })
-    return {
-      slides: slides.map((s) => ({
-        id: s.id,
-        galleryImageId: s.galleryImageId,
-        url: s.galleryImage.url,
-        caption: s.caption,
-      })),
+  fastify.get('/api/admin/catalog-slider', { preHandler: [fastify.verifyAdmin] }, async (request, reply) => {
+    try {
+      const slides = await prisma.catalogSliderSlide.findMany({
+        orderBy: { sortOrder: 'asc' },
+        include: { galleryImage: true },
+      })
+      return {
+        slides: slides.map((s) => ({
+          id: s.id,
+          galleryImageId: s.galleryImageId,
+          url: s.galleryImage.url,
+          caption: s.caption,
+        })),
+      }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось загрузить слайдер' })
    }
  })

  fastify.put('/api/admin/catalog-slider', { preHandler: [fastify.verifyAdmin] }, async (request, reply) => {
-    const body = request.body ?? {}
-    const rawSlides = body.slides
-    if (!Array.isArray(rawSlides)) {
-      return reply.code(400).send({ error: 'Ожидается slides: массив' })
-    }
-    if (rawSlides.length > MAX_SLIDES) {
-      return reply.code(400).send({ error: `Не более ${MAX_SLIDES} слайдов` })
-    }
+    try {
+      const body = request.body ?? {}
+      const rawSlides = body.slides
+      if (!Array.isArray(rawSlides)) {
+        return reply.code(400).send({ error: 'Ожидается slides: массив' })
+      }
+      if (rawSlides.length > MAX_SLIDES) {
+        return reply.code(400).send({ error: `Не более ${MAX_SLIDES} слайдов` })
+      }

-    const seenGalleryIds = new Set()
-    const normalized = []
-    for (let i = 0; i < rawSlides.length; i++) {
-      const row = rawSlides[i]
-      const galleryImageId = String(row?.galleryImageId ?? '').trim()
-      if (!galleryImageId) {
-        return reply.code(400).send({ error: `Слайд ${i + 1}: укажите galleryImageId` })
+      const seenGalleryIds = new Set()
+      const normalized = []
+      for (let i = 0; i < rawSlides.length; i++) {
+        const row = rawSlides[i]
+        const galleryImageId = String(row?.galleryImageId ?? '').trim()
+        if (!galleryImageId) {
+          return reply.code(400).send({ error: `Слайд ${i + 1}: укажите galleryImageId` })
+        }
+        if (seenGalleryIds.has(galleryImageId)) {
+          return reply.code(400).send({ error: 'Одно изображение нельзя добавить дважды' })
+        }
+        seenGalleryIds.add(galleryImageId)
+        const img = await prisma.galleryImage.findUnique({ where: { id: galleryImageId } })
+        if (!img) {
+          return reply.code(400).send({ error: `Изображение не найдено: ${galleryImageId}` })
+        }
+        const caption = row?.caption == null ? '' : String(row.caption).slice(0, 500)
+        normalized.push({ galleryImageId, caption, sortOrder: i })
      }
-      if (seenGalleryIds.has(galleryImageId)) {
-        return reply.code(400).send({ error: 'Одно изображение нельзя добавить дважды' })
-      }
-      seenGalleryIds.add(galleryImageId)
-      const img = await prisma.galleryImage.findUnique({ where: { id: galleryImageId } })
-      if (!img) {
-        return reply.code(400).send({ error: `Изображение не найдено: ${galleryImageId}` })
-      }
-      const caption = row?.caption == null ? '' : String(row.caption).slice(0, 500)
-      normalized.push({ galleryImageId, caption, sortOrder: i })
-    }

-    await prisma.$transaction(async (tx) => {
-      await tx.catalogSliderSlide.deleteMany({})
-      for (const n of normalized) {
-        await tx.catalogSliderSlide.create({
-          data: {
-            sortOrder: n.sortOrder,
-            caption: n.caption,
-            galleryImageId: n.galleryImageId,
-          },
-        })
-      }
-    })
+      await prisma.$transaction(async (tx) => {
+        await tx.catalogSliderSlide.deleteMany({})
+        for (const n of normalized) {
+          await tx.catalogSliderSlide.create({
+            data: {
+              sortOrder: n.sortOrder,
+              caption: n.caption,
+              galleryImageId: n.galleryImageId,
+            },
+          })
+        }
+      })

-    const slides = await prisma.catalogSliderSlide.findMany({
-      orderBy: { sortOrder: 'asc' },
-      include: { galleryImage: true },
-    })
-    return {
-      slides: slides.map((s) => ({
-        id: s.id,
-        galleryImageId: s.galleryImageId,
-        url: s.galleryImage.url,
-        caption: s.caption,
-      })),
+      const slides = await prisma.catalogSliderSlide.findMany({
+        orderBy: { sortOrder: 'asc' },
+        include: { galleryImage: true },
+      })
+      return {
+        slides: slides.map((s) => ({
+          id: s.id,
+          galleryImageId: s.galleryImageId,
+          url: s.galleryImage.url,
+          caption: s.caption,
+        })),
+      }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось обновить слайдер' })
    }
  })
 }
@@ -123,8 +123,7 @@ export async function registerAuthRoutes(fastify) {
    const avatarRaw = request.body?.avatar
    const avatar = avatarRaw === null || avatarRaw === undefined ? undefined : String(avatarRaw).trim()
    const avatarTypeRaw = request.body?.avatarType
-    const avatarType =
-      avatarTypeRaw === null || avatarTypeRaw === undefined ? undefined : String(avatarTypeRaw).trim()
+    const avatarType = avatarTypeRaw === null || avatarTypeRaw === undefined ? undefined : String(avatarTypeRaw).trim()
    const avatarStyleRaw = request.body?.avatarStyle
    const avatarStyle =
      avatarStyleRaw === null || avatarStyleRaw === undefined ? undefined : String(avatarStyleRaw).trim()
@@ -45,133 +45,159 @@ function validateAddressPayload(body, reply) {
 }

 export async function registerUserAddressRoutes(fastify) {
-  fastify.get('/api/me/addresses', { preHandler: [fastify.authenticate] }, async (request) => {
-    const userId = request.user.sub
-    const items = await prisma.shippingAddress.findMany({
-      where: { userId },
-      orderBy: [{ isDefault: 'desc' }, { updatedAt: 'desc' }],
-    })
-    return { items }
+  fastify.get('/api/me/addresses', { preHandler: [fastify.authenticate] }, async (request, reply) => {
+    try {
+      const userId = request.user.sub
+      const items = await prisma.shippingAddress.findMany({
+        where: { userId },
+        orderBy: [{ isDefault: 'desc' }, { updatedAt: 'desc' }],
+      })
+      return { items }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось загрузить адреса' })
+    }
  })

  fastify.post('/api/me/addresses', { preHandler: [fastify.authenticate] }, async (request, reply) => {
-    const userId = request.user.sub
-    const validated = validateAddressPayload(request.body, reply)
-    if (!validated) return
+    try {
+      const userId = request.user.sub
+      const validated = validateAddressPayload(request.body, reply)
+      if (!validated) return

-    const isDefault = Boolean(request.body?.isDefault)
-    const created = await prisma.$transaction(async (tx) => {
-      if (isDefault) {
-        await tx.shippingAddress.updateMany({ where: { userId, isDefault: true }, data: { isDefault: false } })
-      }
-      return tx.shippingAddress.create({
-        data: {
-          userId,
-          ...validated,
-          isDefault,
-        },
+      const isDefault = Boolean(request.body?.isDefault)
+      const created = await prisma.$transaction(async (tx) => {
+        if (isDefault) {
+          await tx.shippingAddress.updateMany({ where: { userId, isDefault: true }, data: { isDefault: false } })
+        }
+        return tx.shippingAddress.create({
+          data: {
+            userId,
+            ...validated,
+            isDefault,
+          },
+        })
      })
-    })
-    return reply.code(201).send({ item: created })
+      return reply.code(201).send({ item: created })
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось создать адрес' })
+    }
  })

  fastify.patch('/api/me/addresses/:id', { preHandler: [fastify.authenticate] }, async (request, reply) => {
-    const userId = request.user.sub
-    const { id } = request.params
-    const existing = await prisma.shippingAddress.findFirst({ where: { id, userId } })
-    if (!existing) return reply.code(404).send({ error: 'Адрес не найден' })
+    try {
+      const userId = request.user.sub
+      const { id } = request.params
+      const existing = await prisma.shippingAddress.findFirst({ where: { id, userId } })
+      if (!existing) return reply.code(404).send({ error: 'Адрес не найден' })

-    const body = request.body ?? {}
-    const data = {}
+      const body = request.body ?? {}
+      const data = {}

-    if (body.label !== undefined) {
-      const labelRaw = body.label
-      const label = labelRaw === null || labelRaw === undefined ? null : String(labelRaw).trim()
-      if (label !== null && label.length > 40)
-        return reply.code(400).send({ error: 'Метка адреса максимум 40 символов' })
-      data.label = label && label.length ? label : null
-    }
-
-    if (body.recipientName !== undefined) {
-      const v = String(body.recipientName || '').trim()
-      if (!v) return reply.code(400).send({ error: 'Укажите ФИО получателя' })
-      if (v.length > 80) return reply.code(400).send({ error: 'ФИО получателя максимум 80 символов' })
-      data.recipientName = v
-    }
-
-    if (body.recipientPhone !== undefined) {
-      const v = normalizePhoneLite(body.recipientPhone)
-      if (!v) return reply.code(400).send({ error: 'Укажите телефон получателя' })
-      if (!/^\+?\d{7,20}$/.test(v)) return reply.code(400).send({ error: 'Некорректный телефон получателя' })
-      data.recipientPhone = v
-    }
-
-    if (body.addressLine !== undefined) {
-      const v = String(body.addressLine || '').trim()
-      if (!v) return reply.code(400).send({ error: 'Укажите адрес' })
-      if (v.length > 200) return reply.code(400).send({ error: 'Адрес максимум 200 символов' })
-      data.addressLine = v
-    }
-
-    if (body.comment !== undefined) {
-      const commentRaw = body.comment
-      const comment = commentRaw === null || commentRaw === undefined ? null : String(commentRaw).trim()
-      if (comment !== null && comment.length > 200)
-        return reply.code(400).send({ error: 'Комментарий максимум 200 символов' })
-      data.comment = comment && comment.length ? comment : null
-    }
-
-    if (body.lat !== undefined) {
-      const lat = Number(body.lat)
-      if (!Number.isFinite(lat) || lat < -90 || lat > 90) return reply.code(400).send({ error: 'Некорректная широта' })
-      data.lat = lat
-    }
-
-    if (body.lng !== undefined) {
-      const lng = Number(body.lng)
-      if (!Number.isFinite(lng) || lng < -180 || lng > 180)
-        return reply.code(400).send({ error: 'Некорректная долгота' })
-      data.lng = lng
-    }
-
-    const setDefault = body.isDefault === true
-    const updated = await prisma.$transaction(async (tx) => {
-      if (setDefault) {
-        await tx.shippingAddress.updateMany({ where: { userId, isDefault: true }, data: { isDefault: false } })
+      if (body.label !== undefined) {
+        const labelRaw = body.label
+        const label = labelRaw === null || labelRaw === undefined ? null : String(labelRaw).trim()
+        if (label !== null && label.length > 40)
+          return reply.code(400).send({ error: 'Метка адреса максимум 40 символов' })
+        data.label = label && label.length ? label : null
      }
-      return tx.shippingAddress.update({
-        where: { id },
-        data: {
-          ...data,
-          ...(setDefault ? { isDefault: true } : {}),
-        },
-      })
-    })

-    return { item: updated }
+      if (body.recipientName !== undefined) {
+        const v = String(body.recipientName || '').trim()
+        if (!v) return reply.code(400).send({ error: 'Укажите ФИО получателя' })
+        if (v.length > 80) return reply.code(400).send({ error: 'ФИО получателя максимум 80 символов' })
+        data.recipientName = v
+      }
+
+      if (body.recipientPhone !== undefined) {
+        const v = normalizePhoneLite(body.recipientPhone)
+        if (!v) return reply.code(400).send({ error: 'Укажите телефон получателя' })
+        if (!/^\+?\d{7,20}$/.test(v)) return reply.code(400).send({ error: 'Некорректный телефон получателя' })
+        data.recipientPhone = v
+      }
+
+      if (body.addressLine !== undefined) {
+        const v = String(body.addressLine || '').trim()
+        if (!v) return reply.code(400).send({ error: 'Укажите адрес' })
+        if (v.length > 200) return reply.code(400).send({ error: 'Адрес максимум 200 символов' })
+        data.addressLine = v
+      }
+
+      if (body.comment !== undefined) {
+        const commentRaw = body.comment
+        const comment = commentRaw === null || commentRaw === undefined ? null : String(commentRaw).trim()
+        if (comment !== null && comment.length > 200)
+          return reply.code(400).send({ error: 'Комментарий максимум 200 символов' })
+        data.comment = comment && comment.length ? comment : null
+      }
+
+      if (body.lat !== undefined) {
+        const lat = Number(body.lat)
+        if (!Number.isFinite(lat) || lat < -90 || lat > 90)
+          return reply.code(400).send({ error: 'Некорректная широта' })
+        data.lat = lat
+      }
+
+      if (body.lng !== undefined) {
+        const lng = Number(body.lng)
+        if (!Number.isFinite(lng) || lng < -180 || lng > 180)
+          return reply.code(400).send({ error: 'Некорректная долгота' })
+        data.lng = lng
+      }
+
+      const setDefault = body.isDefault === true
+      const updated = await prisma.$transaction(async (tx) => {
+        if (setDefault) {
+          await tx.shippingAddress.updateMany({ where: { userId, isDefault: true }, data: { isDefault: false } })
+        }
+        return tx.shippingAddress.update({
+          where: { id },
+          data: {
+            ...data,
+            ...(setDefault ? { isDefault: true } : {}),
+          },
+        })
+      })
+
+      return { item: updated }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось обновить адрес' })
+    }
  })

  fastify.delete('/api/me/addresses/:id', { preHandler: [fastify.authenticate] }, async (request, reply) => {
-    const userId = request.user.sub
-    const { id } = request.params
-    const existing = await prisma.shippingAddress.findFirst({ where: { id, userId } })
-    if (!existing) return reply.code(404).send({ error: 'Адрес не найден' })
+    try {
+      const userId = request.user.sub
+      const { id } = request.params
+      const existing = await prisma.shippingAddress.findFirst({ where: { id, userId } })
+      if (!existing) return reply.code(404).send({ error: 'Адрес не найден' })

-    await prisma.shippingAddress.delete({ where: { id } })
-    return reply.code(204).send()
+      await prisma.shippingAddress.delete({ where: { id } })
+      return reply.code(204).send()
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось удалить адрес' })
+    }
  })

  fastify.post('/api/me/addresses/:id/default', { preHandler: [fastify.authenticate] }, async (request, reply) => {
-    const userId = request.user.sub
-    const { id } = request.params
-    const existing = await prisma.shippingAddress.findFirst({ where: { id, userId } })
-    if (!existing) return reply.code(404).send({ error: 'Адрес не найден' })
+    try {
+      const userId = request.user.sub
+      const { id } = request.params
+      const existing = await prisma.shippingAddress.findFirst({ where: { id, userId } })
+      if (!existing) return reply.code(404).send({ error: 'Адрес не найден' })

-    const updated = await prisma.$transaction(async (tx) => {
-      await tx.shippingAddress.updateMany({ where: { userId, isDefault: true }, data: { isDefault: false } })
-      return tx.shippingAddress.update({ where: { id }, data: { isDefault: true } })
-    })
+      const updated = await prisma.$transaction(async (tx) => {
+        await tx.shippingAddress.updateMany({ where: { userId, isDefault: true }, data: { isDefault: false } })
+        return tx.shippingAddress.update({ where: { id }, data: { isDefault: true } })
+      })

-    return { item: updated }
+      return { item: updated }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось установить адрес по умолчанию' })
+    }
  })
 }
@@ -1,76 +1,96 @@
 import { prisma } from '../lib/prisma.js'

 export async function registerUserCartRoutes(fastify) {
-  fastify.get('/api/me/cart', { preHandler: [fastify.authenticate] }, async (request) => {
-    const userId = request.user.sub
-    const items = await prisma.cartItem.findMany({
-      where: { userId },
-      include: { product: { include: { category: true, images: { orderBy: { sort: 'asc' } } } } },
-      orderBy: { createdAt: 'asc' },
-    })
-    return {
-      items: items.map((x) => ({
-        id: x.id,
-        qty: x.qty,
-        product: x.product,
-      })),
+  fastify.get('/api/me/cart', { preHandler: [fastify.authenticate] }, async (request, reply) => {
+    try {
+      const userId = request.user.sub
+      const items = await prisma.cartItem.findMany({
+        where: { userId },
+        include: { product: { include: { category: true, images: { orderBy: { sort: 'asc' } } } } },
+        orderBy: { createdAt: 'asc' },
+      })
+      return {
+        items: items.map((x) => ({
+          id: x.id,
+          qty: x.qty,
+          product: x.product,
+        })),
+      }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось загрузить корзину' })
    }
  })

  fastify.post('/api/me/cart/items', { preHandler: [fastify.authenticate] }, async (request, reply) => {
-    const userId = request.user.sub
-    const productId = String(request.body?.productId || '').trim()
-    const qtyRaw = request.body?.qty
-    const qty = qtyRaw === undefined || qtyRaw === null || qtyRaw === '' ? 1 : Number(qtyRaw)
+    try {
+      const userId = request.user.sub
+      const productId = String(request.body?.productId || '').trim()
+      const qtyRaw = request.body?.qty
+      const qty = qtyRaw === undefined || qtyRaw === null || qtyRaw === '' ? 1 : Number(qtyRaw)

-    if (!productId) return reply.code(400).send({ error: 'productId обязателен' })
-    if (!Number.isFinite(qty) || qty <= 0) return reply.code(400).send({ error: 'qty должен быть > 0' })
+      if (!productId) return reply.code(400).send({ error: 'productId обязателен' })
+      if (!Number.isFinite(qty) || qty <= 0) return reply.code(400).send({ error: 'qty должен быть > 0' })

-    const product = await prisma.product.findFirst({ where: { id: productId, published: true } })
-    if (!product) return reply.code(404).send({ error: 'Товар не найден' })
+      const product = await prisma.product.findFirst({ where: { id: productId, published: true } })
+      if (!product) return reply.code(404).send({ error: 'Товар не найден' })

-    const available = product.quantity
-    const existing = await prisma.cartItem.findUnique({ where: { userId_productId: { userId, productId } } })
-    const nextQty = (existing?.qty ?? 0) + Math.floor(qty)
-    if (nextQty > available) return reply.code(409).send({ error: `Доступно: ${available} шт.` })
+      const available = product.quantity
+      const existing = await prisma.cartItem.findUnique({ where: { userId_productId: { userId, productId } } })
+      const nextQty = (existing?.qty ?? 0) + Math.floor(qty)
+      if (nextQty > available) return reply.code(409).send({ error: `Доступно: ${available} шт.` })

-    const item = await prisma.cartItem.upsert({
-      where: { userId_productId: { userId, productId } },
-      update: { qty: nextQty },
-      create: { userId, productId, qty: nextQty },
-    })
-    return reply.code(201).send({ item })
+      const item = await prisma.cartItem.upsert({
+        where: { userId_productId: { userId, productId } },
+        update: { qty: nextQty },
+        create: { userId, productId, qty: nextQty },
+      })
+      return reply.code(201).send({ item })
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось добавить в корзину' })
+    }
  })

  fastify.patch('/api/me/cart/items/:id', { preHandler: [fastify.authenticate] }, async (request, reply) => {
-    const userId = request.user.sub
-    const { id } = request.params
-    const qtyRaw = request.body?.qty
-    const qty = Number(qtyRaw)
-    if (!Number.isFinite(qty) || qty < 0) return reply.code(400).send({ error: 'qty должен быть ≥ 0' })
+    try {
+      const userId = request.user.sub
+      const { id } = request.params
+      const qtyRaw = request.body?.qty
+      const qty = Number(qtyRaw)
+      if (!Number.isFinite(qty) || qty < 0) return reply.code(400).send({ error: 'qty должен быть ≥ 0' })

-    const existing = await prisma.cartItem.findFirst({ where: { id, userId }, include: { product: true } })
-    if (!existing) return reply.code(404).send({ error: 'Позиция корзины не найдена' })
+      const existing = await prisma.cartItem.findFirst({ where: { id, userId }, include: { product: true } })
+      if (!existing) return reply.code(404).send({ error: 'Позиция корзины не найдена' })

-    if (qty === 0) {
-      await prisma.cartItem.delete({ where: { id } })
-      return reply.code(204).send()
+      if (qty === 0) {
+        await prisma.cartItem.delete({ where: { id } })
+        return reply.code(204).send()
+      }
+
+      const available = existing.product.quantity
+      const nextQty = Math.floor(qty)
+      if (nextQty > available) return reply.code(409).send({ error: `Доступно: ${available} шт.` })
+
+      const updated = await prisma.cartItem.update({ where: { id }, data: { qty: nextQty } })
+      return { item: updated }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось обновить количество' })
    }
-
-    const available = existing.product.quantity
-    const nextQty = Math.floor(qty)
-    if (nextQty > available) return reply.code(409).send({ error: `Доступно: ${available} шт.` })
-
-    const updated = await prisma.cartItem.update({ where: { id }, data: { qty: nextQty } })
-    return { item: updated }
  })

  fastify.delete('/api/me/cart/items/:id', { preHandler: [fastify.authenticate] }, async (request, reply) => {
-    const userId = request.user.sub
-    const { id } = request.params
-    const existing = await prisma.cartItem.findFirst({ where: { id, userId } })
-    if (!existing) return reply.code(404).send({ error: 'Позиция корзины не найдена' })
-    await prisma.cartItem.delete({ where: { id } })
-    return reply.code(204).send()
+    try {
+      const userId = request.user.sub
+      const { id } = request.params
+      const existing = await prisma.cartItem.findFirst({ where: { id, userId } })
+      if (!existing) return reply.code(404).send({ error: 'Позиция корзины не найдена' })
+      await prisma.cartItem.delete({ where: { id } })
+      return reply.code(204).send()
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось удалить из корзины' })
+    }
  })
 }
@@ -44,22 +44,21 @@ export async function registerUserMessageRoutes(fastify) {
    })
    if (orders.length === 0) return { count: 0 }

+    const orderIds = orders.map((o) => o.id)
    const readStates = await prisma.userOrderMessageReadState.findMany({
      where: { userId },
    })
    const lastReadByOrder = new Map(readStates.map((r) => [r.orderId, r.lastReadAt]))

+    const adminMessages = await prisma.orderMessage.findMany({
+      where: { orderId: { in: orderIds }, authorType: 'admin' },
+      select: { orderId: true, createdAt: true },
+    })
+
    let count = 0
-    for (const o of orders) {
-      const lastRead = lastReadByOrder.get(o.id) ?? new Date(0)
-      const n = await prisma.orderMessage.count({
-        where: {
-          orderId: o.id,
-          authorType: 'admin',
-          createdAt: { gt: lastRead },
-        },
-      })
-      count += n
+    for (const msg of adminMessages) {
+      const lastRead = lastReadByOrder.get(msg.orderId) ?? new Date(0)
+      if (msg.createdAt > lastRead) count++
    }
    return { count }
  })
@@ -86,25 +85,32 @@ export async function registerUserMessageRoutes(fastify) {
    })
    const lastReadByOrder = new Map(readStates.map((r) => [r.orderId, r.lastReadAt]))

+    const orderIds = orders.map((o) => o.id)
+    const unreadCounts = new Map()
+    if (orderIds.length > 0) {
+      const adminMessages = await prisma.orderMessage.findMany({
+        where: { orderId: { in: orderIds }, authorType: 'admin' },
+        select: { orderId: true, createdAt: true },
+      })
+      for (const msg of adminMessages) {
+        const lastRead = lastReadByOrder.get(msg.orderId) ?? new Date(0)
+        if (msg.createdAt > lastRead) {
+          unreadCounts.set(msg.orderId, (unreadCounts.get(msg.orderId) ?? 0) + 1)
+        }
+      }
+    }
+
    const items = []
    for (const o of orders) {
      const lastMsg = o.messages[0]
      if (!lastMsg) continue
-      const lastRead = lastReadByOrder.get(o.id) ?? new Date(0)
-      const unreadCount = await prisma.orderMessage.count({
-        where: {
-          orderId: o.id,
-          authorType: 'admin',
-          createdAt: { gt: lastRead },
-        },
-      })
      items.push({
        orderId: o.id,
        status: o.status,
        deliveryType: o.deliveryType,
        lastMessageAt: lastMsg.createdAt,
        preview: lastMsg.text.length > 280 ? `${lastMsg.text.slice(0, 277)}…` : lastMsg.text,
-        unreadCount,
+        unreadCount: unreadCounts.get(o.id) ?? 0,
      })
    }
    return { items }
@@ -176,35 +176,45 @@ export async function registerUserOrderRoutes(fastify) {
    return reply.code(201).send({ orderId: created.id })
  })

-  fastify.get('/api/me/orders', { preHandler: [fastify.authenticate] }, async (request) => {
-    const userId = request.user.sub
-    const orders = await prisma.order.findMany({
-      where: { userId },
-      include: { items: true },
-      orderBy: { createdAt: 'desc' },
-    })
-    return {
-      items: orders.map((o) => ({
-        id: o.id,
-        status: o.status,
-        totalCents: o.totalCents,
-        currency: o.currency,
-        createdAt: o.createdAt,
-        updatedAt: o.updatedAt,
-        itemsCount: o.items.reduce((s, i) => s + i.qty, 0),
-      })),
+  fastify.get('/api/me/orders', { preHandler: [fastify.authenticate] }, async (request, reply) => {
+    try {
+      const userId = request.user.sub
+      const orders = await prisma.order.findMany({
+        where: { userId },
+        include: { items: { select: { qty: true } } },
+        orderBy: { createdAt: 'desc' },
+      })
+      return {
+        items: orders.map((o) => ({
+          id: o.id,
+          status: o.status,
+          totalCents: o.totalCents,
+          currency: o.currency,
+          createdAt: o.createdAt,
+          updatedAt: o.updatedAt,
+          itemsCount: o.items.reduce((s, i) => s + i.qty, 0),
+        })),
+      }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось загрузить заказы' })
    }
  })

  fastify.get('/api/me/orders/:id', { preHandler: [fastify.authenticate] }, async (request, reply) => {
-    const userId = request.user.sub
-    const { id } = request.params
-    const order = await prisma.order.findFirst({
-      where: { id, userId },
-      include: { items: true, messages: { orderBy: { createdAt: 'asc' } } },
-    })
-    if (!order) return reply.code(404).send({ error: 'Заказ не найден' })
-    return { item: order }
+    try {
+      const userId = request.user.sub
+      const { id } = request.params
+      const order = await prisma.order.findFirst({
+        where: { id, userId },
+        include: { items: true, messages: { orderBy: { createdAt: 'asc' } } },
+      })
+      if (!order) return reply.code(404).send({ error: 'Заказ не найден' })
+      return { item: order }
+    } catch (err) {
+      request.log.error(err)
+      return reply.code(500).send({ error: 'Не удалось загрузить заказ' })
+    }
  })

  fastify.get(
@@ -251,19 +261,24 @@ export async function registerUserOrderRoutes(fastify) {
    '/api/me/orders/:id/confirm-received',
    { preHandler: [fastify.authenticate] },
    async (request, reply) => {
-      const userId = request.user.sub
-      const { id } = request.params
-      const order = await prisma.order.findFirst({ where: { id, userId } })
-      if (!order) return reply.code(404).send({ error: 'Заказ не найден' })
+      try {
+        const userId = request.user.sub
+        const { id } = request.params
+        const order = await prisma.order.findFirst({ where: { id, userId } })
+        if (!order) return reply.code(404).send({ error: 'Заказ не найден' })

-      const okDelivery = order.deliveryType === 'delivery' && order.status === 'SHIPPED'
-      const okPickup = order.deliveryType === 'pickup' && order.status === 'READY_FOR_PICKUP'
-      if (!okDelivery && !okPickup) {
-        return reply.code(409).send({ error: 'Сейчас нельзя подтвердить получение заказа' })
+        const okDelivery = order.deliveryType === 'delivery' && order.status === 'SHIPPED'
+        const okPickup = order.deliveryType === 'pickup' && order.status === 'READY_FOR_PICKUP'
+        if (!okDelivery && !okPickup) {
+          return reply.code(409).send({ error: 'Сейчас нельзя подтвердить получение заказа' })
+        }
+
+        await prisma.order.update({ where: { id }, data: { status: 'DONE' } })
+        return { ok: true, status: 'DONE' }
+      } catch (err) {
+        request.log.error(err)
+        return reply.code(500).send({ error: 'Не удалось подтвердить получение' })
      }
-
-      await prisma.order.update({ where: { id }, data: { status: 'DONE' } })
-      return { ok: true, status: 'DONE' }
    },
  )
 }