initial dockerizing

spooty-be/package.json

@@ -21,9 +21,11 @@
   },
   "dependencies": {
     "@nestjs/common": "^10.0.0",
+    "@nestjs/config": "^3.2.2",
     "@nestjs/core": "^10.0.0",
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/schedule": "^4.0.2",
+    "@nestjs/serve-static": "^4.0.2",
     "@nestjs/typeorm": "^10.0.2",
     "@types/yt-search": "^2.10.3",
     "isomorphic-unfetch": "^4.0.2",

spooty-be/src/app.module.ts

@@ -1,20 +1,36 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { ScheduleModule } from '@nestjs/schedule';
+import { ServeStaticModule } from '@nestjs/serve-static';
+import {ConfigModule, ConfigService} from "@nestjs/config";
 import {TypeOrmModule} from '@nestjs/typeorm';
 import {TrackEntity} from "./track/track.entity";
 import {TrackModule} from "./track/track.module";
 import {PlaylistModule} from "./playlist/playlist.module";
 import {PlaylistEntity} from "./playlist/playlist.entity";
+import { resolve } from 'path';
 
 @Module({
   imports: [
+    ConfigModule.forRoot(),
     ScheduleModule.forRoot(),
-    TypeOrmModule.forRoot({
-      type: 'sqlite',
-      database: 'test.sqlite',
-      entities: [TrackEntity, PlaylistEntity],
-      synchronize: true,
+    TypeOrmModule.forRootAsync({
+      imports:[ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        type: 'sqlite',
+        database: configService.get<string>('DB'),
+        entities: [TrackEntity, PlaylistEntity],
+        synchronize: true,
+      }),
+      inject: [ConfigService]
+    }),
+    ServeStaticModule.forRootAsync({
+      imports:[ConfigModule],
+      useFactory: async (configService: ConfigService) => ([{
+        rootPath: resolve(__dirname, configService.get<string>('FE')),
+        exclude: ['/api/(.*)'],
+      }]),
+      inject: [ConfigService]
     }),
     TrackModule,
     PlaylistModule,

spooty-be/src/main.ts

@@ -1,8 +1,13 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
+import * as fs from 'fs';
+import { resolve } from 'path';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
+  app.setGlobalPrefix('api');
   await app.listen(3000);
 }
 bootstrap();
+const folderName = resolve(__dirname, process.env.DOWNLOADS);
+!fs.existsSync(folderName) && fs.mkdirSync(folderName);

spooty-be/src/track/track.controller.ts

@@ -3,13 +3,15 @@ import {TrackService} from "./track.service";
 import {TrackModel} from "./track.model";
 import {TrackEntity} from "./track.entity";
 import {createReadStream} from "fs";
-import { join } from 'path';
+import { resolve } from 'path';
 import type { Response } from 'express';
+import {ConfigService} from "@nestjs/config";
 
 @Controller('track')
 export class TrackController {
 
-    constructor(private readonly service: TrackService) {
+    constructor(private readonly service: TrackService,
+                private readonly configService: ConfigService) {
     }
 
     @Get()
@@ -40,7 +42,7 @@ export class TrackController {
     @Get('download/:id')
     async getFile(@Res({ passthrough: true }) res: Response, @Param('id') id: number): Promise<StreamableFile> {
         const track = await this.service.findOne(id);
-        const file = createReadStream(join(process.cwd(), 'downloads', `${track.artist} - ${track.song}.mp3`));
+        const file = createReadStream(resolve(__dirname, '..', this.configService.get<string>('DOWNLOADS'), `${track.artist} - ${track.song}.mp3`));
         res.set({'Content-Disposition': `attachment; filename="${track.artist} - ${track.song}.mp3"`,});
         return new StreamableFile(file);
     }

spooty-be/src/track/track.module.ts

@@ -3,9 +3,13 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import {TrackEntity} from "./track.entity";
 import {TrackService} from "./track.service";
 import {TrackController} from "./track.controller";
+import {ConfigModule} from "@nestjs/config";
 
 @Module({
-    imports: [TypeOrmModule.forFeature([TrackEntity])],
+    imports: [
+        TypeOrmModule.forFeature([TrackEntity]),
+        ConfigModule,
+    ],
     providers: [TrackService],
     controllers: [TrackController],
     exports: [TrackService],

spooty-be/src/track/track.service.ts

@@ -8,12 +8,15 @@ import {TrackStatusEnum} from "./track.model";
 import * as yts from 'yt-search';
 import * as ytdl from 'ytdl-core';
 import * as fs from 'fs';
+import {ConfigService} from "@nestjs/config";
+import {resolve} from "path";
 
 @Injectable()
 export class TrackService {
     constructor(
         @InjectRepository(TrackEntity)
         private repository: Repository<TrackEntity>,
+        private readonly configService: ConfigService,
     ) {}
 
     findAll(criteria?: Partial<TrackEntity>): Promise<TrackEntity[]> {
@@ -50,7 +53,12 @@ export class TrackService {
         const queuedTracks = await this.findAll({status: TrackStatusEnum.Queued});
         queuedTracks.forEach(async track => {
             await ytdl(track.youtubeUrl, {quality: "highestaudio", filter: "audioonly"}).pipe(
-                fs.createWriteStream(`downloads/${track.artist} - ${track.song.replace('/', '')}.mp3`)
+                fs.createWriteStream(resolve(
+                    __dirname,
+                    '..',
+                    this.configService.get<string>('DOWNLOADS'),
+                    `${track.artist} - ${track.song.replace('/', '')}.mp3`,
+                ))
             );
             await this.update(track.id, {...track, status: TrackStatusEnum.Completed})
         });