old.cms.fellies.org/packages/db/src/media-foundation.ts

import {
  attachArtworkRenditionInputSchema,
  createArtworkInputSchema,
  createGroupingInputSchema,
  createMediaAssetInputSchema,
  linkArtworkGroupingInputSchema,
  updateMediaAssetInputSchema,
} from "@cms/content"

import { db } from "./client"

type PublicArtworkGroupType = "gallery" | "album" | "category" | "tag"

type ListPublishedArtworksInput = {
  groupType?: PublicArtworkGroupType
  groupSlug?: string
  limit?: number
}

export async function listMediaAssets(limit = 24) {
  return db.mediaAsset.findMany({
    orderBy: { updatedAt: "desc" },
    take: limit,
  })
}

export async function listArtworks(limit = 24) {
  return db.artwork.findMany({
    orderBy: { updatedAt: "desc" },
    take: limit,
    include: {
      renditions: {
        select: {
          id: true,
          slot: true,
          mediaAssetId: true,
        },
      },
      galleryLinks: {
        include: {
          gallery: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      albumLinks: {
        include: {
          album: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      categoryLinks: {
        include: {
          category: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      tagLinks: {
        include: {
          tag: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
    },
  })
}

export async function listMediaFoundationGroups() {
  const [galleries, albums, categories, tags] = await Promise.all([
    db.gallery.findMany({
      orderBy: [{ sortOrder: "asc" }, { name: "asc" }],
    }),
    db.album.findMany({
      orderBy: [{ sortOrder: "asc" }, { name: "asc" }],
    }),
    db.category.findMany({
      orderBy: [{ sortOrder: "asc" }, { name: "asc" }],
    }),
    db.tag.findMany({
      orderBy: { name: "asc" },
    }),
  ])

  return {
    galleries,
    albums,
    categories,
    tags,
  }
}

export async function createMediaAsset(input: unknown) {
  const payload = createMediaAssetInputSchema.parse(input)

  return db.mediaAsset.create({
    data: payload,
  })
}

export async function getMediaAssetById(id: string) {
  return db.mediaAsset.findUnique({
    where: { id },
  })
}

export async function updateMediaAsset(input: unknown) {
  const payload = updateMediaAssetInputSchema.parse(input)
  const { id, ...data } = payload

  return db.mediaAsset.update({
    where: { id },
    data,
  })
}

export async function deleteMediaAsset(id: string) {
  return db.mediaAsset.delete({
    where: { id },
  })
}

export async function createArtwork(input: unknown) {
  const payload = createArtworkInputSchema.parse(input)

  return db.artwork.create({
    data: payload,
  })
}

export async function createGallery(input: unknown) {
  const payload = createGroupingInputSchema.parse(input)

  return db.gallery.create({
    data: payload,
  })
}

export async function createAlbum(input: unknown) {
  const payload = createGroupingInputSchema.parse(input)

  return db.album.create({
    data: payload,
  })
}

export async function createCategory(input: unknown) {
  const payload = createGroupingInputSchema.parse(input)

  return db.category.create({
    data: payload,
  })
}

export async function createTag(input: unknown) {
  const payload = createGroupingInputSchema
    .pick({
      name: true,
      slug: true,
    })
    .parse(input)

  return db.tag.create({
    data: payload,
  })
}

export async function linkArtworkToGrouping(input: unknown) {
  const payload = linkArtworkGroupingInputSchema.parse(input)

  if (payload.groupType === "gallery") {
    return db.artworkGallery.upsert({
      where: {
        artworkId_galleryId: {
          artworkId: payload.artworkId,
          galleryId: payload.groupId,
        },
      },
      create: {
        artworkId: payload.artworkId,
        galleryId: payload.groupId,
      },
      update: {},
    })
  }

  if (payload.groupType === "album") {
    return db.artworkAlbum.upsert({
      where: {
        artworkId_albumId: {
          artworkId: payload.artworkId,
          albumId: payload.groupId,
        },
      },
      create: {
        artworkId: payload.artworkId,
        albumId: payload.groupId,
      },
      update: {},
    })
  }

  if (payload.groupType === "category") {
    return db.artworkCategory.upsert({
      where: {
        artworkId_categoryId: {
          artworkId: payload.artworkId,
          categoryId: payload.groupId,
        },
      },
      create: {
        artworkId: payload.artworkId,
        categoryId: payload.groupId,
      },
      update: {},
    })
  }

  return db.artworkTag.upsert({
    where: {
      artworkId_tagId: {
        artworkId: payload.artworkId,
        tagId: payload.groupId,
      },
    },
    create: {
      artworkId: payload.artworkId,
      tagId: payload.groupId,
    },
    update: {},
  })
}

export async function attachArtworkRendition(input: unknown) {
  const payload = attachArtworkRenditionInputSchema.parse(input)

  return db.artworkRendition.upsert({
    where: {
      artworkId_slot: {
        artworkId: payload.artworkId,
        slot: payload.slot,
      },
    },
    create: payload,
    update: {
      mediaAssetId: payload.mediaAssetId,
      width: payload.width,
      height: payload.height,
      isPrimary: payload.isPrimary,
    },
  })
}

export async function getMediaFoundationSummary() {
  const [mediaAssets, artworks, galleries, albums, categories, tags] = await Promise.all([
    db.mediaAsset.count(),
    db.artwork.count(),
    db.gallery.count(),
    db.album.count(),
    db.category.count(),
    db.tag.count(),
  ])

  return {
    mediaAssets,
    artworks,
    galleries,
    albums,
    categories,
    tags,
  }
}

export async function listPublishedPortfolioGroups() {
  const [galleries, albums, categories, tags] = await Promise.all([
    db.gallery.findMany({
      where: {
        isVisible: true,
      },
      orderBy: [{ sortOrder: "asc" }, { name: "asc" }],
      select: {
        id: true,
        name: true,
        slug: true,
      },
    }),
    db.album.findMany({
      where: {
        isVisible: true,
      },
      orderBy: [{ sortOrder: "asc" }, { name: "asc" }],
      select: {
        id: true,
        name: true,
        slug: true,
      },
    }),
    db.category.findMany({
      where: {
        isVisible: true,
      },
      orderBy: [{ sortOrder: "asc" }, { name: "asc" }],
      select: {
        id: true,
        name: true,
        slug: true,
      },
    }),
    db.tag.findMany({
      orderBy: [{ name: "asc" }],
      select: {
        id: true,
        name: true,
        slug: true,
      },
    }),
  ])

  return {
    galleries,
    albums,
    categories,
    tags,
  }
}

export async function listPublishedArtworks(input: ListPublishedArtworksInput = {}) {
  const take = input.limit ?? 36
  const where: Record<string, unknown> = {
    isPublished: true,
  }

  if (input.groupType && input.groupSlug) {
    if (input.groupType === "gallery") {
      where.galleryLinks = {
        some: {
          gallery: {
            slug: input.groupSlug,
            isVisible: true,
          },
        },
      }
    } else if (input.groupType === "album") {
      where.albumLinks = {
        some: {
          album: {
            slug: input.groupSlug,
            isVisible: true,
          },
        },
      }
    } else if (input.groupType === "category") {
      where.categoryLinks = {
        some: {
          category: {
            slug: input.groupSlug,
            isVisible: true,
          },
        },
      }
    } else if (input.groupType === "tag") {
      where.tagLinks = {
        some: {
          tag: {
            slug: input.groupSlug,
          },
        },
      }
    }
  }

  return db.artwork.findMany({
    where,
    orderBy: [{ updatedAt: "desc" }],
    take,
    include: {
      renditions: {
        where: {
          mediaAsset: {
            isPublished: true,
          },
        },
        include: {
          mediaAsset: {
            select: {
              id: true,
              title: true,
              altText: true,
              mimeType: true,
              width: true,
              height: true,
            },
          },
        },
      },
      galleryLinks: {
        include: {
          gallery: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      albumLinks: {
        include: {
          album: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      categoryLinks: {
        include: {
          category: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      tagLinks: {
        include: {
          tag: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
    },
  })
}

export async function getPublishedArtworkBySlug(slug: string) {
  return db.artwork.findFirst({
    where: {
      slug,
      isPublished: true,
    },
    include: {
      renditions: {
        where: {
          mediaAsset: {
            isPublished: true,
          },
        },
        include: {
          mediaAsset: {
            select: {
              id: true,
              title: true,
              altText: true,
              mimeType: true,
              width: true,
              height: true,
              source: true,
              author: true,
              copyright: true,
              tags: true,
            },
          },
        },
      },
      galleryLinks: {
        include: {
          gallery: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      albumLinks: {
        include: {
          album: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      categoryLinks: {
        include: {
          category: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
      tagLinks: {
        include: {
          tag: {
            select: {
              id: true,
              name: true,
              slug: true,
            },
          },
        },
      },
    },
  })
}