feat: can create albums

cli/package.json

@@ -67,6 +67,9 @@
     "collectCoverageFrom": [
       "<rootDir>/src/**/*.(t|j)s"
     ],
+    "moduleNameMapper": {
+      "^@api(|/.*)$": "<rootDir>/src/api/$1"
+    },
     "coverageDirectory": "./coverage",
     "testEnvironment": "node"
   }

cli/src/api/album-api.ts

@@ -0,0 +1,11 @@
+import axios from 'axios';
+
+import { AlbumResponseDto, CreateAlbumDto } from './open-api';
+import { auth } from './auth';
+
+export const albumApi = {
+  createAlbum: async (server: any, accessToken: string, dto: CreateAlbumDto) => {
+    const res = await axios.post(`${server}/album`, dto, auth(accessToken));
+    return res.data as AlbumResponseDto;
+  },
+};

cli/src/api/auth.ts

@@ -0,0 +1,3 @@
+export const auth = (accessToken: string) => ({
+  headers: { Authorization: `Bearer ${accessToken}` },
+});

cli/src/api/index.ts

@@ -0,0 +1,7 @@
+import { albumApi } from './album-api';
+import { auth } from './auth';
+
+export const api = {
+  albumApi,
+  auth,
+};

cli/src/commands/upload.ts

@@ -1,4 +1,4 @@
-import { CrawledAsset } from '../cores/models/crawled-asset';
+import { Asset } from '../cores/models/asset';
 import { CrawlService, UploadService } from '../services';
 import * as si from 'systeminformation';
 import FormData from 'form-data';
@@ -8,13 +8,13 @@ import { CrawlOptionsDto } from '../cores/dto/crawl-options-dto';
 import cliProgress from 'cli-progress';
 import byteSize from 'byte-size';
 import { BaseCommand } from '../cli/base-command';
+import { api } from 'src/api';
 
 export default class Upload extends BaseCommand {
   private crawlService = new CrawlService();
   private uploadService!: UploadService;
   deviceId!: string;
   uploadLength!: number;
-  dryRun = false;
 
   public async run(paths: string[], options: UploadOptionsDto): Promise<void> {
     await this.connect();
@@ -23,8 +23,6 @@ export default class Upload extends BaseCommand {
     this.deviceId = uuid.os || 'CLI';
     this.uploadService = new UploadService(this.immichApi.apiConfiguration);
 
-    this.dryRun = options.dryRun;
-
     const crawlOptions = new CrawlOptionsDto();
     crawlOptions.pathsToCrawl = paths;
     crawlOptions.recursive = options.recursive;
@@ -37,7 +35,7 @@ export default class Upload extends BaseCommand {
       return;
     }
 
-    const assetsToUpload = crawledFiles.map((path) => new CrawledAsset(path));
+    const assetsToUpload = crawledFiles.map((path) => new Asset(path));
 
     const uploadProgress = new cliProgress.SingleBar(
       {
@@ -58,71 +56,21 @@ export default class Upload extends BaseCommand {
       totalSize += asset.fileSize;
     }
 
+    const existingAlbums = (await this.immichApi.albumApi.getAllAlbums()).data;
+
     uploadProgress.start(totalSize, 0);
     uploadProgress.update({ value_formatted: 0, total_formatted: byteSize(totalSize) });
 
+    try {
       for (const asset of assetsToUpload) {
         uploadProgress.update({
           filename: asset.path,
         });
 
-      try {
-        await this.uploadAsset(asset, options.skipHash);
-      } catch (error) {
-        // Immediately halt on an upload error
-        // TODO: In the future, we might retry and do exponential backoff for certain errors
-        uploadProgress.stop();
-        throw error;
-      }
-
-      sizeSoFar += asset.fileSize;
-      if (!asset.skipped) {
-        totalSizeUploaded += asset.fileSize;
-        uploadCounter++;
-      }
-
-      uploadProgress.update(sizeSoFar, { value_formatted: byteSize(sizeSoFar) });
-    }
-
-    uploadProgress.stop();
-
-    let messageStart;
-    if (this.dryRun) {
-      messageStart = 'Would have';
-    } else {
-      messageStart = 'Successfully';
-    }
-
-    if (uploadCounter === 0) {
-      console.log('All assets were already uploaded, nothing to do.');
-    } else {
-      console.log(`${messageStart} uploaded ${uploadCounter} assets (${byteSize(totalSizeUploaded)})`);
-    }
-    if (options.delete) {
-      if (this.dryRun) {
-        console.log(`Would now have deleted assets, but skipped due to dry run`);
-      } else {
-        console.log('Deleting assets that have been uploaded...');
-        const deletionProgress = new cliProgress.SingleBar(cliProgress.Presets.shades_classic);
-        deletionProgress.start(crawledFiles.length, 0);
-
-        for (const asset of assetsToUpload) {
-          if (!this.dryRun) {
-            await asset.delete();
-          }
-          deletionProgress.increment();
-        }
-        deletionProgress.stop();
-        console.log('Deletion complete');
-      }
-    }
-  }
-
-  private async uploadAsset(asset: CrawledAsset, skipHash = false) {
         await asset.readData();
 
         let skipUpload = false;
-    if (!skipHash) {
+        if (!options.skipHash) {
           const checksum = await asset.hash();
 
           const checkResponse = await this.uploadService.checkIfAssetAlreadyExists(asset.path, checksum);
@@ -148,8 +96,64 @@ export default class Upload extends BaseCommand {
             });
           }
 
-      if (!this.dryRun) {
+          if (!options.dryRun) {
-        await this.uploadService.upload(uploadFormData);
+            const res = await this.uploadService.upload(uploadFormData);
+
+            if (options.album && asset.albumName) {
+              let album = existingAlbums.find((album) => album.albumName === asset.albumName);
+              if (!album) {
+                const res = await this.immichApi.albumApi.createAlbum({
+                  createAlbumDto: { albumName: asset.albumName },
+                });
+                album = res.data;
+                existingAlbums.push(album);
+              }
+
+              await this.immichApi.albumApi.addAssetsToAlbum({ id: album.id, bulkIdsDto: { ids: [res.data.id] } });
+            }
+          }
+        }
+
+        sizeSoFar += asset.fileSize;
+        if (!asset.skipped) {
+          totalSizeUploaded += asset.fileSize;
+          uploadCounter++;
+        }
+
+        uploadProgress.update(sizeSoFar, { value_formatted: byteSize(sizeSoFar) });
+      }
+    } finally {
+      uploadProgress.stop();
+    }
+
+    let messageStart;
+    if (options.dryRun) {
+      messageStart = 'Would have';
+    } else {
+      messageStart = 'Successfully';
+    }
+
+    if (uploadCounter === 0) {
+      console.log('All assets were already uploaded, nothing to do.');
+    } else {
+      console.log(`${messageStart} uploaded ${uploadCounter} assets (${byteSize(totalSizeUploaded)})`);
+    }
+    if (options.delete) {
+      if (options.dryRun) {
+        console.log(`Would now have deleted assets, but skipped due to dry run`);
+      } else {
+        console.log('Deleting assets that have been uploaded...');
+        const deletionProgress = new cliProgress.SingleBar(cliProgress.Presets.shades_classic);
+        deletionProgress.start(crawledFiles.length, 0);
+
+        for (const asset of assetsToUpload) {
+          if (!options.dryRun) {
+            await asset.delete();
+          }
+          deletionProgress.increment();
+        }
+        deletionProgress.stop();
+        console.log('Deletion complete');
       }
     }
   }

cli/src/cores/dto/upload-options-dto.ts

@@ -5,4 +5,5 @@ export class UploadOptionsDto {
   skipHash = false;
   delete = false;
   readOnly = true;
+  album = false;
 }

cli/src/cores/models/asset.ts

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import { basename } from 'node:path';
 import crypto from 'crypto';
 
-export class CrawledAsset {
+export class Asset {
   public path: string;
 
   public assetData?: fs.ReadStream;
@@ -13,6 +13,7 @@ export class CrawledAsset {
   public sidecarPath?: string;
   public fileSize!: number;
   public skipped = false;
+  public albumName?: string;
 
   constructor(path: string) {
     this.path = path;
@@ -28,6 +29,7 @@ export class CrawledAsset {
     this.fileCreatedAt = stats.mtime.toISOString();
     this.fileModifiedAt = stats.mtime.toISOString();
     this.fileSize = stats.size;
+    this.albumName = this.extractAlbumName();
 
     // TODO: doesn't xmp replace the file extension? Will need investigation
     const sideCarPath = `${this.path}.xmp`;
@@ -55,4 +57,8 @@ export class CrawledAsset {
 
     return await sha1(this.path);
   }
+
+  private extractAlbumName(): string {
+    return this.path.split('/').slice(-2)[0];
+  }
 }

cli/src/cores/models/index.ts

@@ -1 +1 @@
-export * from './crawled-asset';
+export * from './asset';

cli/src/index.ts

@@ -15,6 +15,11 @@ program
   .addOption(new Option('-r, --recursive', 'Recursive').env('IMMICH_RECURSIVE').default(false))
   .addOption(new Option('-i, --ignore [paths...]', 'Paths to ignore').env('IMMICH_IGNORE_PATHS'))
   .addOption(new Option('-h, --skip-hash', "Don't hash files before upload").env('IMMICH_SKIP_HASH').default(false))
+  .addOption(
+    new Option('-a, --album', 'Automatically create albums based on folder name')
+      .env('IMMICH_AUTO_CREATE_ALBUM')
+      .default(false),
+  )
   .addOption(
     new Option('-n, --dry-run', "Don't perform any actions, just show what will be done")
       .env('IMMICH_DRY_RUN')

cli/src/services/upload.service.ts

@@ -1,6 +1,7 @@
-import axios, { AxiosRequestConfig } from 'axios';
+import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
 import FormData from 'form-data';
 import { ApiConfiguration } from '../cores/api-configuration';
+import { AssetFileUploadResponseDto } from 'src/api/open-api';
 
 export class UploadService {
   private readonly uploadConfig: AxiosRequestConfig<any>;
@@ -36,7 +37,7 @@ export class UploadService {
     return axios(this.checkAssetExistenceConfig);
   }
 
-  public upload(data: FormData) {
+  public upload(data: FormData): Promise<AxiosResponse<AssetFileUploadResponseDto>> {
     this.uploadConfig.data = data;
 
     // TODO: retry on 500 errors?

server/src/domain/album/album.service.ts

@@ -87,7 +87,7 @@ export class AlbumService {
     );
   }
 
-  async get(authUser: AuthUserDto, id: string, dto: AlbumInfoDto) {
+  async get(authUser: AuthUserDto, id: string, dto: AlbumInfoDto): Promise<AlbumResponseDto> {
     await this.access.requirePermission(authUser, Permission.ALBUM_READ, id);
     await this.albumRepository.updateThumbnails();
     return mapAlbum(await this.findOrFail(id, { withAssets: true }), !dto.withoutAssets);

server/src/immich/controllers/album.controller.ts

@@ -31,23 +31,31 @@ export class AlbumController {
   }
 
   @Get()
-  getAllAlbums(@AuthUser() authUser: AuthUserDto, @Query() query: GetAlbumsDto) {
+  getAllAlbums(@AuthUser() authUser: AuthUserDto, @Query() query: GetAlbumsDto): Promise<AlbumResponseDto[]> {
     return this.service.getAll(authUser, query);
   }
 
   @Post()
-  createAlbum(@AuthUser() authUser: AuthUserDto, @Body() dto: CreateDto) {
+  createAlbum(@AuthUser() authUser: AuthUserDto, @Body() dto: CreateDto): Promise<AlbumResponseDto> {
     return this.service.create(authUser, dto);
   }
 
   @SharedLinkRoute()
   @Get(':id')
-  getAlbumInfo(@AuthUser() authUser: AuthUserDto, @Param() { id }: UUIDParamDto, @Query() dto: AlbumInfoDto) {
+  getAlbumInfo(
+    @AuthUser() authUser: AuthUserDto,
+    @Param() { id }: UUIDParamDto,
+    @Query() dto: AlbumInfoDto,
+  ): Promise<AlbumResponseDto> {
     return this.service.get(authUser, id, dto);
   }
 
   @Patch(':id')
-  updateAlbumInfo(@AuthUser() authUser: AuthUserDto, @Param() { id }: UUIDParamDto, @Body() dto: UpdateDto) {
+  updateAlbumInfo(
+    @AuthUser() authUser: AuthUserDto,
+    @Param() { id }: UUIDParamDto,
+    @Body() dto: UpdateDto,
+  ): Promise<AlbumResponseDto> {
     return this.service.update(authUser, id, dto);
   }