feat(api): import listens after first sign in

Previously it took a minute until the import was started within the normal
loop. This way, we create an import job right after the user logs
in for the first time.

src/users/users.module.ts

@@ -1,11 +1,16 @@
+import { PGBossModule } from "@apricote/nest-pg-boss";
 import { Module } from "@nestjs/common";
+import { TypeOrmRepositoryModule } from "../database/entity-repository/typeorm-repository.module";
+import { ImportSpotifyJob } from "../sources/jobs";
 import { UserRepository } from "./user.repository";
-import { UsersService } from "./users.service";
 import { UsersController } from "./users.controller";
-import { TypeOrmRepositoryModule } from "../database/entity-repository/typeorm-repository.module";
+import { UsersService } from "./users.service";
 
 @Module({
-  imports: [TypeOrmRepositoryModule.for([UserRepository])],
+  imports: [
+    TypeOrmRepositoryModule.for([UserRepository]),
+    PGBossModule.forJobs([ImportSpotifyJob]),
+  ],
   providers: [UsersService],
   exports: [UsersService],
   controllers: [UsersController],

src/users/users.service.spec.ts

@@ -1,25 +1,36 @@
+import { JobService } from "@apricote/nest-pg-boss";
 import { Test, TestingModule } from "@nestjs/testing";
+import { IImportSpotifyJob, ImportSpotifyJob } from "../sources/jobs";
 import { UserRepository } from "./user.repository";
 import { UsersService } from "./users.service";
 
 describe("UsersService", () => {
   let service: UsersService;
   let userRepository: UserRepository;
+  let importSpotifyJobService: JobService<IImportSpotifyJob>;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         UsersService,
         { provide: UserRepository, useFactory: () => ({}) },
+        {
+          provide: ImportSpotifyJob.ServiceProvider.provide,
+          useFactory: () => ({}),
+        },
       ],
     }).compile();
 
     service = module.get<UsersService>(UsersService);
     userRepository = module.get<UserRepository>(UserRepository);
+    importSpotifyJobService = module.get<JobService<IImportSpotifyJob>>(
+      ImportSpotifyJob.ServiceProvider.provide
+    );
   });
 
   it("should be defined", () => {
     expect(service).toBeDefined();
     expect(userRepository).toBeDefined();
+    expect(importSpotifyJobService).toBeDefined();
   });
 });

src/users/users.service.ts

@@ -1,12 +1,18 @@
+import { JobService } from "@apricote/nest-pg-boss";
 import { Injectable, NotFoundException } from "@nestjs/common";
+import { IImportSpotifyJob, ImportSpotifyJob } from "../sources/jobs";
 import { SpotifyConnection } from "../sources/spotify/spotify-connection.entity";
 import { CreateOrUpdateDto } from "./dto/create-or-update.dto";
 import { User } from "./user.entity";
 import { UserRepository } from "./user.repository";
 
 @Injectable()
 export class UsersService {
-  constructor(private readonly userRepository: UserRepository) {}
+  constructor(
+    private readonly userRepository: UserRepository,
+    @ImportSpotifyJob.Inject()
+    private readonly importSpotifyJobService: JobService<IImportSpotifyJob>
+  ) {}
 
   async findById(id: string): Promise<User> {
     const user = await this.userRepository.findOneBy({ id });
@@ -27,7 +33,8 @@ export class UsersService {
       spotify: { id: data.spotify.id },
     });
 
-    if (!user) {
+    const isNew = !user;
+    if (isNew) {
       user = this.userRepository.create({
         spotify: {
           id: data.spotify.id,
@@ -42,6 +49,11 @@ export class UsersService {
 
     await this.userRepository.save(user);
 
+    if (isNew) {
+      // Make sure that existing listens are crawled immediately
+      this.importSpotifyJobService.sendOnce({ userID: user.id }, {}, user.id);
+    }
+
     return user;
   }