feat: add speech to text

Author: minhnq

backend/.env.example

@@ -9,5 +9,8 @@ S3_ACCESS_KEY=
 S3_SECRET_KEY=
 S3_BUCKET=
 
+# Deepgram Speech-to-Text
+DEEPGRAM_API_KEY=
+
 # Server Port
 PORT=3001

backend/bun.lock

@@ -15,6 +15,7 @@
     },
     "dependencies": {
         "@aws-sdk/client-s3": "^3.700.0",
+        "@deepgram/sdk": "^4.11.3",
         "@nestjs/common": "^10.0.0",
         "@nestjs/config": "^3.0.0",
         "@nestjs/core": "^10.0.0",
@@ -30,6 +31,7 @@
     "devDependencies": {
         "@nestjs/cli": "^10.0.0",
         "@nestjs/schematics": "^10.0.0",
+        "@types/express": "^5.0.6",
         "@types/node": "^20.3.1",
         "prettier": "^3.0.0",
         "typescript": "^5.1.3"

backend/package.json

@@ -5,6 +5,7 @@ import { DatabaseModule } from './database/database.module';
 import { StorageModule } from './storage/storage.module';
 import { CleanupModule } from './cleanup/cleanup.module';
 import { ChatModule } from './chat/chat.module';
+import { SpeechModule } from './speech/speech.module';
 
 @Module({
     imports: [
@@ -17,6 +18,8 @@ import { ChatModule } from './chat/chat.module';
         StorageModule,
         CleanupModule,
         ChatModule,
+        SpeechModule,
     ],
 })
 export class AppModule { }
+

backend/src/app.module.ts

@@ -82,4 +82,40 @@ export class CleanupService {
             this.logger.error('❌ JSON bin cleanup failed:', error);
         }
     }
+
+    /**
+     * Cleanup expired speech transcriptions - runs every hour
+     */
+    @Cron(CronExpression.EVERY_HOUR)
+    async handleSpeechCleanup() {
+        this.logger.log('🧹 Starting speech transcription cleanup...');
+
+        try {
+            const expiredSpeech = await this.databaseService.getExpiredSpeechTranscriptions();
+
+            if (expiredSpeech.length === 0) {
+                this.logger.log('✅ No expired speech transcriptions found');
+                return;
+            }
+
+            let deleted = 0;
+            let failed = 0;
+
+            for (const speech of expiredSpeech) {
+                try {
+                    await this.r2Service.deleteObject(speech.object_key);
+                    await this.databaseService.deleteSpeechTranscription(speech.id);
+                    deleted++;
+                } catch (error) {
+                    this.logger.error(`Failed to delete speech ${speech.id}:`, error);
+                    failed++;
+                }
+            }
+
+            this.logger.log(`✅ Speech cleanup complete: ${deleted} deleted, ${failed} failed`);
+        } catch (error) {
+            this.logger.error('❌ Speech cleanup failed:', error);
+        }
+    }
 }
+

backend/src/cleanup/cleanup.service.ts

@@ -146,4 +146,61 @@ export class DatabaseService implements OnModuleInit {
         `;
         return result.length;
     }
+
+    // ============ Speech Transcriptions ============
+
+    /**
+     * Initialize speech_transcriptions table
+     */
+    async initSpeechTranscriptionsTable() {
+        await this.sql`
+            CREATE TABLE IF NOT EXISTS speech_transcriptions (
+                id VARCHAR(32) PRIMARY KEY,
+                object_key VARCHAR(255) NOT NULL,
+                filename VARCHAR(255) NOT NULL,
+                file_size BIGINT NOT NULL,
+                duration_seconds FLOAT,
+                status VARCHAR(20) DEFAULT 'pending',
+                transcript TEXT,
+                words JSONB,
+                language VARCHAR(10),
+                created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                expires_at TIMESTAMP WITH TIME ZONE NOT NULL
+            )
+        `;
+        // Add words column if it doesn't exist (for existing tables)
+        await this.sql`
+            ALTER TABLE speech_transcriptions 
+            ADD COLUMN IF NOT EXISTS words JSONB
+        `;
+        // Add paragraphs column if it doesn't exist
+        await this.sql`
+            ALTER TABLE speech_transcriptions 
+            ADD COLUMN IF NOT EXISTS paragraphs JSONB
+        `;
+        await this.sql`
+            CREATE INDEX IF NOT EXISTS idx_speech_expires 
+            ON speech_transcriptions(expires_at)
+        `;
+        this.logger.log('✅ Speech transcriptions table initialized');
+    }
+
+    /**
+     * Get expired speech transcriptions
+     */
+    async getExpiredSpeechTranscriptions() {
+        return this.sql`
+            SELECT id, object_key, filename 
+            FROM speech_transcriptions 
+            WHERE expires_at < NOW()
+        `;
+    }
+
+    /**
+     * Delete a speech transcription by ID
+     */
+    async deleteSpeechTranscription(id: string) {
+        return this.sql`DELETE FROM speech_transcriptions WHERE id = ${id}`;
+    }
 }
+

backend/src/database/database.service.ts

@@ -6,6 +6,13 @@ async function bootstrap() {
     const logger = new Logger('Bootstrap');
     const app = await NestFactory.create(AppModule);
 
+    // Enable CORS
+    app.enableCors({
+        origin: '*',
+        methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Authorization'],
+    });
+
     const port = process.env.PORT || 3001;
     await app.listen(port);
 

backend/src/main.ts

@@ -0,0 +1,109 @@
+import {
+    Controller,
+    Post,
+    Get,
+    Param,
+    Query,
+    UseInterceptors,
+    UploadedFile,
+    BadRequestException,
+    Res,
+    Headers,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { Response } from 'express';
+import { SpeechService, SpeechTranscription } from './speech.service';
+
+@Controller('speech')
+export class SpeechController {
+    constructor(private readonly speechService: SpeechService) { }
+
+    /**
+     * Upload audio file
+     */
+    @Post('upload')
+    @UseInterceptors(FileInterceptor('file', {
+        limits: { fileSize: 50 * 1024 * 1024 }, // 50MB limit
+        fileFilter: (req, file, cb) => {
+            const allowedMimes = [
+                'audio/mpeg',
+                'audio/mp3',
+                'audio/wav',
+                'audio/wave',
+                'audio/ogg',
+                'audio/webm',
+                'audio/mp4',
+                'audio/m4a',
+                'audio/flac',
+                'audio/x-m4a',
+            ];
+            if (allowedMimes.includes(file.mimetype) || file.originalname.match(/\.(mp3|wav|ogg|webm|m4a|flac)$/i)) {
+                cb(null, true);
+            } else {
+                cb(new BadRequestException('Only audio files are allowed'), false);
+            }
+        },
+    }))
+    async uploadAudio(@UploadedFile() file: { originalname: string; buffer: Buffer; mimetype: string; size: number }): Promise<SpeechTranscription> {
+        if (!file) {
+            throw new BadRequestException('No file uploaded');
+        }
+        return this.speechService.uploadAudio(file);
+    }
+
+    /**
+     * Start transcription
+     */
+    @Post(':id/transcribe')
+    async transcribe(@Param('id') id: string, @Query('language') language?: string): Promise<SpeechTranscription> {
+        return this.speechService.transcribe(id, language || 'vi');
+    }
+
+    /**
+     * Get transcription result
+     */
+    @Get(':id')
+    async getTranscription(@Param('id') id: string): Promise<SpeechTranscription> {
+        return this.speechService.getTranscription(id);
+    }
+
+    /**
+     * Stream audio file with Range request support for seeking
+     */
+    @Get(':id/audio')
+    async streamAudio(
+        @Param('id') id: string,
+        @Headers('range') range: string | undefined,
+        @Res() res: Response,
+    ): Promise<void> {
+        const { buffer, contentType } = await this.speechService.getAudioFile(id);
+        const fileSize = buffer.length;
+
+        // Handle Range requests for seeking
+        if (range) {
+            const parts = range.replace(/bytes=/, '').split('-');
+            const start = parseInt(parts[0], 10);
+            const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
+            const chunkSize = end - start + 1;
+
+            res.status(206);
+            res.set({
+                'Content-Range': `bytes ${start}-${end}/${fileSize}`,
+                'Accept-Ranges': 'bytes',
+                'Content-Length': chunkSize,
+                'Content-Type': contentType,
+            });
+            res.end(buffer.subarray(start, end + 1));
+        } else {
+            // No range - return full file
+            res.set({
+                'Accept-Ranges': 'bytes',
+                'Content-Length': fileSize,
+                'Content-Type': contentType,
+                'Content-Disposition': 'inline',
+            });
+            res.end(buffer);
+        }
+    }
+}
+

backend/src/speech/speech.controller.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { DatabaseModule } from '../database/database.module';
+import { StorageModule } from '../storage/storage.module';
+import { SpeechController } from './speech.controller';
+import { SpeechService } from './speech.service';
+
+@Module({
+    imports: [DatabaseModule, StorageModule],
+    controllers: [SpeechController],
+    providers: [SpeechService],
+})
+export class SpeechModule { }