Using transactions where it needed

backend/src/modules/image/image.service.ts

@@ -1,70 +1,66 @@
 import { HttpException, HttpStatus, Injectable, Logger } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 import { Admin } from 'libs/database/admin.entity';
 import { Image } from 'libs/database/image.entity';
 import { Post } from 'libs/database/post.entity';
-import { Repository } from 'typeorm';
+import { DataSource, EntityManager } from 'typeorm';
 import { IAddImage } from './image.dto';
 @Injectable()
 export class ImageService {
     private readonly logger: Logger = new Logger(ImageService.name);
-    constructor(
-        @InjectRepository(Image) private imageRepository: Repository<Image>,
-        @InjectRepository(Post) private postRepository: Repository<Post>,
-        @InjectRepository(Admin) private adminRepository: Repository<Admin>,
-    ) {}
+    constructor(private dataSource: DataSource) {}
 
     async add(data: IAddImage) {
         try {
-            this.logger.log(`[image.add] data: ${JSON.stringify(data)}`);
             let created_new = false;
-            if (data.media_group_id) {
-                let post = await this.postRepository.findOne({ where: { media_group_id: data.media_group_id } });
-                if (post) {
-                    await this.imageRepository.save({
-                        post: post,
-                        file_id: data.file_id,
-                        has_spoiler: data.has_spoiler,
-                        message_id: data.message_id,
-                    });
-                    if (data.post_text) {
-                        post.text = data.post_text;
-                        post.message_entities = data.message_entities;
-                        post = await this.postRepository.save(post);
+            await this.dataSource.transaction(async (manager: EntityManager) => {
+                this.logger.log(`[image.add] data: ${JSON.stringify(data)}`);
+                if (data.media_group_id) {
+                    let post = await manager.findOne(Post, { where: { media_group_id: data.media_group_id } });
+                    if (post) {
+                        await manager.save(Image, {
+                            post: post,
+                            file_id: data.file_id,
+                            has_spoiler: data.has_spoiler,
+                            message_id: data.message_id,
+                        });
+                        if (data.post_text) {
+                            post.text = data.post_text;
+                            post.message_entities = data.message_entities;
+                            post = await manager.save(Post, post);
+                        }
+                    } else {
+                        const user = await manager.findOne(Admin, { where: { user: { id: data.from_user_id } }, relations: { user: true } });
+                        post = await manager.save(Post, {
+                            media_group_id: data.media_group_id,
+                            text: data.post_text,
+                            message_entities: data.message_entities,
+                            timestamp: new Date(),
+                            from_user: user,
+                        });
+                        created_new = true;
+                        await manager.save(Image, {
+                            post: post,
+                            file_id: data.file_id,
+                            has_spoiler: data.has_spoiler,
+                            message_id: data.message_id,
+                        });
                     }
                 } else {
-                    const user = await this.adminRepository.findOne({ where: { user: { id: data.from_user_id } }, relations: { user: true } });
-                    post = await this.postRepository.save({
-                        media_group_id: data.media_group_id,
+                    const user = await manager.findOne(Admin, { where: { user: { id: data.from_user_id } }, relations: { user: true } });
+                    const post = await manager.save(Post, {
                         text: data.post_text,
                         message_entities: data.message_entities,
                         timestamp: new Date(),
                         from_user: user,
                     });
-                    created_new = true;
-                    await this.imageRepository.save({
+                    await manager.save(Image, {
                         post: post,
                         file_id: data.file_id,
                         has_spoiler: data.has_spoiler,
                         message_id: data.message_id,
                     });
-                    this.logger.log('Created post');
                 }
-            } else {
-                const user = await this.adminRepository.findOne({ where: { user: { id: data.from_user_id } }, relations: { user: true } });
-                const post = await this.postRepository.save({
-                    text: data.post_text,
-                    message_entities: data.message_entities,
-                    timestamp: new Date(),
-                    from_user: user,
-                });
-                await this.imageRepository.save({
-                    post: post,
-                    file_id: data.file_id,
-                    has_spoiler: data.has_spoiler,
-                    message_id: data.message_id,
-                });
-            }
+            });
             return { status: 'ok', created: created_new };
         } catch (error) {
             this.logger.debug(`[image.add] error: ${JSON.stringify(error)}`);

backend/src/modules/post/post.service.ts

@@ -1,9 +1,9 @@
-import { HttpException, HttpStatus, Injectable, Logger } from '@nestjs/common';
+import { HttpException, HttpStatus, Inject, Injectable, Logger } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Admin } from 'libs/database/admin.entity';
 import { Post } from 'libs/database/post.entity';
 import { EGetAll } from 'libs/enums/getAll.enum';
-import { Repository } from 'typeorm';
+import { DataSource, EntityManager, Repository } from 'typeorm';
 import { ICreatePost, IEditPost } from './post.dto';
 
 @Injectable()
@@ -12,18 +12,22 @@ export class PostService {
     constructor(
         @InjectRepository(Post) private postRepository: Repository<Post>,
         @InjectRepository(Admin) private adminRepository: Repository<Admin>,
+        @Inject(DataSource) private dataSource: DataSource,
     ) {}
 
     async newPost(data: ICreatePost) {
         try {
             this.logger.log(`[post.newPost] data: ${JSON.stringify(data)}`);
+            let result: Post = null;
             const user = await this.adminRepository.findOne({ where: { user: { id: data.from_user_id } }, relations: { user: true } });
-            const result = await this.postRepository.save({
-                text: data.text,
-                media_group_id: data.media_group_id,
-                from_user: user,
-                timestamp: new Date(),
-                message_entities: data.message_entities,
+            await this.dataSource.transaction(async (manager: EntityManager) => {
+                result = await manager.save(Post, {
+                    text: data.text,
+                    media_group_id: data.media_group_id,
+                    from_user: user,
+                    timestamp: new Date(),
+                    message_entities: data.message_entities,
+                });
             });
             this.logger.log(`Created new post: ${result.uuid}`);
             return result;
@@ -113,7 +117,10 @@ export class PostService {
     async getByMediaGroup(mediaGroupId: string) {
         try {
             this.logger.log(`[post.getByMediaGroup] data: ${mediaGroupId}`);
-            const post = await this.postRepository.findOne({ where: { media_group_id: mediaGroupId } });
+            let post: Post = null;
+            await this.dataSource.transaction(async (manager: EntityManager) => {
+                post = await manager.findOne(Post, { where: { media_group_id: mediaGroupId } });
+            });
             if (!post) throw new Error("Can't find post");
             return post;
         } catch (error) {