feat(api): fetch listens from spotify

src/music-library/album.entity.ts

@@ -0,0 +1,36 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToMany,
+  JoinTable,
+  OneToMany
+} from "typeorm";
+import { SpotifyLibraryDetails } from "src/sources/spotify/spotify-library-details.entity";
+import { Artist } from "./artist.entity";
+import { Track } from "./track.entity";
+
+@Entity()
+export class Album {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column()
+  name: string;
+
+  @ManyToMany(
+    type => Artist,
+    artist => artist.albums
+  )
+  @JoinTable()
+  artists: Artist[];
+
+  @OneToMany(
+    type => Track,
+    track => track.album
+  )
+  tracks: Track[];
+
+  @Column(type => SpotifyLibraryDetails)
+  spotify: SpotifyLibraryDetails;
+}

src/music-library/album.repository.ts

@@ -0,0 +1,5 @@
+import { EntityRepository, Repository } from "typeorm";
+import { Album } from "./album.entity";
+
+@EntityRepository(Album)
+export class AlbumRepository extends Repository<Album> {}

src/music-library/artist.entity.ts

@@ -0,0 +1,21 @@
+import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from "typeorm";
+import { SpotifyLibraryDetails } from "src/sources/spotify/spotify-library-details.entity";
+import { Album } from "./album.entity";
+
+@Entity()
+export class Artist {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column()
+  name: string;
+
+  @ManyToMany(
+    type => Album,
+    album => album.artists
+  )
+  albums: Album[];
+
+  @Column(type => SpotifyLibraryDetails)
+  spotify: SpotifyLibraryDetails;
+}

src/music-library/artist.repository.ts

@@ -0,0 +1,5 @@
+import { EntityRepository, Repository } from "typeorm";
+import { Artist } from "./artist.entity";
+
+@EntityRepository(Artist)
+export class ArtistRepository extends Repository<Artist> {}

src/music-library/dto/create-album.dto.ts

@@ -0,0 +1,8 @@
+import { SpotifyLibraryDetails } from "../../sources/spotify/spotify-library-details.entity";
+import { Artist } from "../artist.entity";
+
+export class CreateAlbumDto {
+  name: string;
+  artists: Artist[];
+  spotify?: SpotifyLibraryDetails;
+}

src/music-library/dto/create-artist.dto.ts

@@ -0,0 +1,6 @@
+import { SpotifyLibraryDetails } from "../../sources/spotify/spotify-library-details.entity";
+
+export class CreateArtistDto {
+  name: string;
+  spotify?: SpotifyLibraryDetails;
+}

src/music-library/dto/create-track.dto.ts

@@ -0,0 +1,10 @@
+import { SpotifyLibraryDetails } from "../../sources/spotify/spotify-library-details.entity";
+import { Album } from "../album.entity";
+import { Artist } from "../artist.entity";
+
+export class CreateTrackDto {
+  album: Album;
+  artists: Artist[];
+  name: string;
+  spotify?: SpotifyLibraryDetails;
+}

src/music-library/dto/find-album.dto.ts

@@ -0,0 +1,5 @@
+export class FindAlbumDto {
+  spotify: {
+    id: string;
+  };
+}

src/music-library/dto/find-artist.dto.ts

@@ -0,0 +1,5 @@
+export class FindArtistDto {
+  spotify: {
+    id: string;
+  };
+}

src/music-library/dto/find-track.dto.ts

@@ -0,0 +1,5 @@
+export class FindTrackDto {
+  spotify: {
+    id: string;
+  };
+}

src/music-library/music-library.module.ts

@@ -0,0 +1,19 @@
+import { Module } from "@nestjs/common";
+import { TypeOrmModule } from "@nestjs/typeorm";
+import { AlbumRepository } from "./album.repository";
+import { ArtistRepository } from "./artist.repository";
+import { MusicLibraryService } from "./music-library.service";
+import { TrackRepository } from "./track.repository";
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([
+      AlbumRepository,
+      ArtistRepository,
+      TrackRepository
+    ])
+  ],
+  providers: [MusicLibraryService],
+  exports: [MusicLibraryService]
+})
+export class MusicLibraryModule {}

src/music-library/music-library.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { MusicLibraryService } from "./music-library.service";
+
+describe("MusicLibraryService", () => {
+  let service: MusicLibraryService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [MusicLibraryService]
+    }).compile();
+
+    service = module.get<MusicLibraryService>(MusicLibraryService);
+  });
+
+  it("should be defined", () => {
+    expect(service).toBeDefined();
+  });
+});

src/music-library/music-library.service.ts

@@ -0,0 +1,78 @@
+import { Injectable } from "@nestjs/common";
+import { Album } from "./album.entity";
+import { AlbumRepository } from "./album.repository";
+import { Artist } from "./artist.entity";
+import { ArtistRepository } from "./artist.repository";
+import { CreateAlbumDto } from "./dto/create-album.dto";
+import { CreateArtistDto } from "./dto/create-artist.dto";
+import { CreateTrackDto } from "./dto/create-track.dto";
+import { FindAlbumDto } from "./dto/find-album.dto";
+import { FindArtistDto } from "./dto/find-artist.dto";
+import { FindTrackDto } from "./dto/find-track.dto";
+import { Track } from "./track.entity";
+import { TrackRepository } from "./track.repository";
+
+@Injectable()
+export class MusicLibraryService {
+  constructor(
+    private readonly albumRepository: AlbumRepository,
+    private readonly artistRepository: ArtistRepository,
+    private readonly trackRepository: TrackRepository
+  ) {}
+
+  async findArtist(query: FindArtistDto): Promise<Artist | undefined> {
+    return this.artistRepository.findOne({
+      where: { spotify: { id: query.spotify.id } }
+    });
+  }
+
+  async createArtist(data: CreateArtistDto): Promise<Artist> {
+    const artist = this.artistRepository.create();
+
+    artist.name = data.name;
+    artist.spotify = data.spotify;
+
+    console.log("createArtist", { data, artist });
+
+    await this.artistRepository.save(artist);
+
+    return artist;
+  }
+
+  async findAlbum(query: FindAlbumDto): Promise<Album | undefined> {
+    return this.albumRepository.findOne({
+      where: { spotify: { id: query.spotify.id } }
+    });
+  }
+
+  async createAlbum(data: CreateAlbumDto): Promise<Album> {
+    const album = this.albumRepository.create();
+
+    album.name = data.name;
+    album.artists = data.artists;
+    album.spotify = data.spotify;
+
+    await this.albumRepository.save(album);
+
+    return album;
+  }
+
+  async findTrack(query: FindTrackDto): Promise<Track | undefined> {
+    return this.trackRepository.findOne({
+      where: { spotify: { id: query.spotify.id } }
+    });
+  }
+
+  async createTrack(data: CreateTrackDto): Promise<Track> {
+    const track = this.trackRepository.create();
+
+    track.name = data.name;
+    track.artists = data.artists;
+    track.album = data.album;
+    track.spotify = data.spotify;
+
+    await this.trackRepository.save(track);
+
+    return track;
+  }
+}

src/music-library/track.entity.ts

@@ -0,0 +1,33 @@
+import { SpotifyLibraryDetails } from "src/sources/spotify/spotify-library-details.entity";
+import {
+  Column,
+  Entity,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from "typeorm";
+import { Album } from "./album.entity";
+import { Artist } from "./artist.entity";
+
+@Entity()
+export class Track {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column()
+  name: string;
+
+  @ManyToOne(
+    type => Album,
+    album => album.tracks
+  )
+  album: Album;
+
+  @ManyToMany(type => Artist)
+  @JoinTable()
+  artists: Artist[];
+
+  @Column(type => SpotifyLibraryDetails)
+  spotify?: SpotifyLibraryDetails;
+}

src/music-library/track.repository.ts

@@ -0,0 +1,5 @@
+import { EntityRepository, Repository } from "typeorm";
+import { Track } from "./track.entity";
+
+@EntityRepository(Track)
+export class TrackRepository extends Repository<Track> {}