refactor(server): stacks (#11453)

* refactor: stacks

* mobile: get it built

* chore: feedback

* fix: sync and duplicates

* mobile: remove old stack reference

* chore: add primary asset id

* revert change to asset entity

* mobile: refactor mobile api

* mobile: sync stack info after creating stack

* mobile: update timeline after deleting stack

* server: update asset updatedAt when stack is deleted

* mobile: simplify action

* mobile: rename to match dto property

* fix: web test

---------

Co-authored-by: Alex <alex.tran1502@gmail.com>

server/src/repositories/access.repository.ts

@@ -11,6 +11,7 @@ import { PartnerEntity } from 'src/entities/partner.entity';
 import { PersonEntity } from 'src/entities/person.entity';
 import { SessionEntity } from 'src/entities/session.entity';
 import { SharedLinkEntity } from 'src/entities/shared-link.entity';
+import { StackEntity } from 'src/entities/stack.entity';
 import { AlbumUserRole } from 'src/enum';
 import { IAccessRepository } from 'src/interfaces/access.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
@@ -20,10 +21,11 @@ type IActivityAccess = IAccessRepository['activity'];
 type IAlbumAccess = IAccessRepository['album'];
 type IAssetAccess = IAccessRepository['asset'];
 type IAuthDeviceAccess = IAccessRepository['authDevice'];
-type ITimelineAccess = IAccessRepository['timeline'];
 type IMemoryAccess = IAccessRepository['memory'];
 type IPersonAccess = IAccessRepository['person'];
 type IPartnerAccess = IAccessRepository['partner'];
+type IStackAccess = IAccessRepository['stack'];
+type ITimelineAccess = IAccessRepository['timeline'];
 
 @Instrumentation()
 @Injectable()
@@ -313,6 +315,28 @@ class AuthDeviceAccess implements IAuthDeviceAccess {
   }
 }
 
+class StackAccess implements IStackAccess {
+  constructor(private stackRepository: Repository<StackEntity>) {}
+
+  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID_SET] })
+  @ChunkedSet({ paramIndex: 1 })
+  async checkOwnerAccess(userId: string, stackIds: Set<string>): Promise<Set<string>> {
+    if (stackIds.size === 0) {
+      return new Set();
+    }
+
+    return this.stackRepository
+      .find({
+        select: { id: true },
+        where: {
+          id: In([...stackIds]),
+          ownerId: userId,
+        },
+      })
+      .then((stacks) => new Set(stacks.map((stack) => stack.id)));
+  }
+}
+
 class TimelineAccess implements ITimelineAccess {
   constructor(private partnerRepository: Repository<PartnerEntity>) {}
 
@@ -428,6 +452,7 @@ export class AccessRepository implements IAccessRepository {
   memory: IMemoryAccess;
   person: IPersonAccess;
   partner: IPartnerAccess;
+  stack: IStackAccess;
   timeline: ITimelineAccess;
 
   constructor(
@@ -441,6 +466,7 @@ export class AccessRepository implements IAccessRepository {
     @InjectRepository(AssetFaceEntity) assetFaceRepository: Repository<AssetFaceEntity>,
     @InjectRepository(SharedLinkEntity) sharedLinkRepository: Repository<SharedLinkEntity>,
     @InjectRepository(SessionEntity) sessionRepository: Repository<SessionEntity>,
+    @InjectRepository(StackEntity) stackRepository: Repository<StackEntity>,
   ) {
     this.activity = new ActivityAccess(activityRepository, albumRepository);
     this.album = new AlbumAccess(albumRepository, sharedLinkRepository);
@@ -449,6 +475,7 @@ export class AccessRepository implements IAccessRepository {
     this.memory = new MemoryAccess(memoryRepository);
     this.person = new PersonAccess(assetFaceRepository, personRepository);
     this.partner = new PartnerAccess(partnerRepository);
+    this.stack = new StackAccess(stackRepository);
     this.timeline = new TimelineAccess(partnerRepository);
   }
 }

server/src/repositories/stack.repository.ts

@@ -1,21 +1,120 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
+import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
+import { AssetEntity } from 'src/entities/asset.entity';
 import { StackEntity } from 'src/entities/stack.entity';
-import { IStackRepository } from 'src/interfaces/stack.interface';
+import { IStackRepository, StackSearch } from 'src/interfaces/stack.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { Repository } from 'typeorm';
+import { DataSource, In, Repository } from 'typeorm';
 
 @Instrumentation()
 @Injectable()
 export class StackRepository implements IStackRepository {
-  constructor(@InjectRepository(StackEntity) private repository: Repository<StackEntity>) {}
+  constructor(
+    @InjectDataSource() private dataSource: DataSource,
+    @InjectRepository(StackEntity) private repository: Repository<StackEntity>,
+  ) {}
 
-  create(entity: Partial<StackEntity>) {
-    return this.save(entity);
+  search(query: StackSearch): Promise<StackEntity[]> {
+    return this.repository.find({
+      where: {
+        ownerId: query.ownerId,
+        primaryAssetId: query.primaryAssetId,
+      },
+      relations: {
+        assets: {
+          exifInfo: true,
+        },
+      },
+    });
+  }
+
+  async create(entity: { ownerId: string; assetIds: string[] }): Promise<StackEntity> {
+    return this.dataSource.manager.transaction(async (manager) => {
+      const stackRepository = manager.getRepository(StackEntity);
+
+      const stacks = await stackRepository.find({
+        where: {
+          ownerId: entity.ownerId,
+          primaryAssetId: In(entity.assetIds),
+        },
+        select: {
+          id: true,
+          assets: {
+            id: true,
+          },
+        },
+        relations: {
+          assets: {
+            exifInfo: true,
+          },
+        },
+      });
+
+      const assetIds = new Set<string>(entity.assetIds);
+
+      // children
+      for (const stack of stacks) {
+        for (const asset of stack.assets) {
+          assetIds.add(asset.id);
+        }
+      }
+
+      if (stacks.length > 0) {
+        await stackRepository.delete({ id: In(stacks.map((stack) => stack.id)) });
+      }
+
+      const { id } = await stackRepository.save({
+        ownerId: entity.ownerId,
+        primaryAssetId: entity.assetIds[0],
+        assets: [...assetIds].map((id) => ({ id }) as AssetEntity),
+      });
+
+      return stackRepository.findOneOrFail({
+        where: {
+          id,
+        },
+        relations: {
+          assets: {
+            exifInfo: true,
+          },
+        },
+      });
+    });
   }
 
   async delete(id: string): Promise<void> {
+    const stack = await this.getById(id);
+    if (!stack) {
+      return;
+    }
+
+    const assetIds = stack.assets.map(({ id }) => id);
+
     await this.repository.delete(id);
+
+    // Update assets updatedAt
+    await this.dataSource.manager.update(AssetEntity, assetIds, {
+      updatedAt: new Date(),
+    });
+  }
+
+  async deleteAll(ids: string[]): Promise<void> {
+    const assetIds = [];
+    for (const id of ids) {
+      const stack = await this.getById(id);
+      if (!stack) {
+        continue;
+      }
+
+      assetIds.push(...stack.assets.map(({ id }) => id));
+    }
+
+    await this.repository.delete(ids);
+
+    // Update assets updatedAt
+    await this.dataSource.manager.update(AssetEntity, assetIds, {
+      updatedAt: new Date(),
+    });
   }
 
   update(entity: Partial<StackEntity>) {
@@ -28,8 +127,14 @@ export class StackRepository implements IStackRepository {
         id,
       },
       relations: {
-        primaryAsset: true,
-        assets: true,
+        assets: {
+          exifInfo: true,
+        },
+      },
+      order: {
+        assets: {
+          fileCreatedAt: 'ASC',
+        },
       },
     });
   }
@@ -41,8 +146,14 @@ export class StackRepository implements IStackRepository {
         id,
       },
       relations: {
-        primaryAsset: true,
-        assets: true,
+        assets: {
+          exifInfo: true,
+        },
+      },
+      order: {
+        assets: {
+          fileCreatedAt: 'ASC',
+        },
       },
     });
   }