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/dtos/asset-response.dto.ts

@@ -52,13 +52,19 @@ export class AssetResponseDto extends SanitizedAssetResponseDto {
   unassignedFaces?: AssetFaceWithoutPersonResponseDto[];
   /**base64 encoded sha1 hash */
   checksum!: string;
-  stackParentId?: string | null;
-  stack?: AssetResponseDto[];
-  @ApiProperty({ type: 'integer' })
-  stackCount!: number | null;
+  stack?: AssetStackResponseDto | null;
   duplicateId?: string | null;
 }
 
+export class AssetStackResponseDto {
+  id!: string;
+
+  primaryAssetId!: string;
+
+  @ApiProperty({ type: 'integer' })
+  assetCount!: number;
+}
+
 export type AssetMapOptions = {
   stripMetadata?: boolean;
   withStack?: boolean;
@@ -83,6 +89,18 @@ const peopleWithFaces = (faces: AssetFaceEntity[]): PersonWithFacesResponseDto[]
   return result;
 };
 
+const mapStack = (entity: AssetEntity) => {
+  if (!entity.stack) {
+    return null;
+  }
+
+  return {
+    id: entity.stack.id,
+    primaryAssetId: entity.stack.primaryAssetId,
+    assetCount: entity.stack.assetCount ?? entity.stack.assets.length,
+  };
+};
+
 export function mapAsset(entity: AssetEntity, options: AssetMapOptions = {}): AssetResponseDto {
   const { stripMetadata = false, withStack = false } = options;
 
@@ -129,13 +147,7 @@ export function mapAsset(entity: AssetEntity, options: AssetMapOptions = {}): As
     people: peopleWithFaces(entity.faces),
     unassignedFaces: entity.faces?.filter((face) => !face.person).map((a) => mapFacesWithoutPerson(a)),
     checksum: entity.checksum.toString('base64'),
-    stackParentId: withStack ? entity.stack?.primaryAssetId : undefined,
-    stack: withStack
-      ? entity.stack?.assets
-          ?.filter((a) => a.id !== entity.stack?.primaryAssetId)
-          ?.map((a) => mapAsset(a, { stripMetadata, auth: options.auth }))
-      : undefined,
-    stackCount: entity.stack?.assetCount ?? entity.stack?.assets?.length ?? null,
+    stack: withStack ? mapStack(entity) : undefined,
     isOffline: entity.isOffline,
     hasMetadata: true,
     duplicateId: entity.duplicateId,

server/src/dtos/asset.dto.ts

@@ -60,12 +60,6 @@ export class AssetBulkUpdateDto extends UpdateAssetBase {
   @ValidateUUID({ each: true })
   ids!: string[];
 
-  @ValidateUUID({ optional: true })
-  stackParentId?: string;
-
-  @ValidateBoolean({ optional: true })
-  removeParent?: boolean;
-
   @Optional()
   duplicateId?: string | null;
 }

server/src/dtos/stack.dto.ts

@@ -1,9 +1,38 @@
+import { ArrayMinSize } from 'class-validator';
+import { AssetResponseDto, mapAsset } from 'src/dtos/asset-response.dto';
+import { AuthDto } from 'src/dtos/auth.dto';
+import { StackEntity } from 'src/entities/stack.entity';
 import { ValidateUUID } from 'src/validation';
 
-export class UpdateStackParentDto {
-  @ValidateUUID()
-  oldParentId!: string;
-
-  @ValidateUUID()
-  newParentId!: string;
+export class StackCreateDto {
+  /** first asset becomes the primary */
+  @ValidateUUID({ each: true })
+  @ArrayMinSize(2)
+  assetIds!: string[];
 }
+
+export class StackSearchDto {
+  primaryAssetId?: string;
+}
+
+export class StackUpdateDto {
+  @ValidateUUID({ optional: true })
+  primaryAssetId?: string;
+}
+
+export class StackResponseDto {
+  id!: string;
+  primaryAssetId!: string;
+  assets!: AssetResponseDto[];
+}
+
+export const mapStack = (stack: StackEntity, { auth }: { auth?: AuthDto }) => {
+  const primary = stack.assets.filter((asset) => asset.id === stack.primaryAssetId);
+  const others = stack.assets.filter((asset) => asset.id !== stack.primaryAssetId);
+
+  return {
+    id: stack.id,
+    primaryAssetId: stack.primaryAssetId,
+    assets: [...primary, ...others].map((asset) => mapAsset(asset, { auth })),
+  };
+};