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

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

import { db } from "./client"

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 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,
  }
}