fix(server): "view all" for cities only showing 12 cities

open-api/immich-openapi-specs.json

@@ -1098,6 +1098,41 @@
         ]
       }
     },
+    "/asset/cities": {
+      "get": {
+        "operationId": "getAssetsByCity",
+        "parameters": [],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "items": {
+                    "$ref": "#/components/schemas/AssetResponseDto"
+                  },
+                  "type": "array"
+                }
+              }
+            },
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "bearer": []
+          },
+          {
+            "cookie": []
+          },
+          {
+            "api_key": []
+          }
+        ],
+        "tags": [
+          "Asset"
+        ]
+      }
+    },
     "/asset/curated-locations": {
       "get": {
         "operationId": "getCuratedLocations",
@@ -10689,7 +10724,8 @@
           }
         },
         "required": [
-          "importPath"
+          "importPath",
+          "isValid"
         ],
         "type": "object"
       },

open-api/typescript-sdk/src/fetch-client.ts

@@ -491,7 +491,7 @@ export type ValidateLibraryDto = {
 };
 export type ValidateLibraryImportPathResponseDto = {
     importPath: string;
-    isValid?: boolean;
+    isValid: boolean;
     message?: string;
 };
 export type ValidateLibraryResponseDto = {
@@ -1291,6 +1291,14 @@ export function checkBulkUpload({ assetBulkUploadCheckDto }: {
         body: assetBulkUploadCheckDto
     })));
 }
+export function getAssetsByCity(opts?: Oazapfts.RequestOpts) {
+    return oazapfts.ok(oazapfts.fetchJson<{
+        status: 200;
+        data: AssetResponseDto[];
+    }>("/asset/cities", {
+        ...opts
+    }));
+}
 export function getCuratedLocations(opts?: Oazapfts.RequestOpts) {
     return oazapfts.ok(oazapfts.fetchJson<{
         status: 200;

server/src/domain/asset/asset.service.ts

@@ -269,6 +269,11 @@ export class AssetService {
     return this.assetRepository.getAllByDeviceId(auth.user.id, deviceId);
   }
 
+  async getAssetsByCity(auth: AuthDto): Promise<AssetResponseDto[]> {
+    const items = await this.assetRepository.getAssetsByCity([auth.user.id]);
+    return items.map((a) => mapAsset(a, { auth }));
+  }
+
   async get(auth: AuthDto, id: string): Promise<AssetResponseDto | SanitizedAssetResponseDto> {
     await this.access.requirePermission(auth, Permission.ASSET_READ, id);
 

server/src/domain/repositories/asset.repository.ts

@@ -152,5 +152,6 @@ export interface IAssetRepository {
   upsertJobStatus(jobStatus: Partial<AssetJobStatusEntity>): Promise<void>;
   getAssetIdByCity(userId: string, options: AssetExploreFieldOptions): Promise<SearchExploreItem<string>>;
   getAssetIdByTag(userId: string, options: AssetExploreFieldOptions): Promise<SearchExploreItem<string>>;
+  getAssetsByCity(userIds: string[]): Promise<AssetEntity[]>;
   searchMetadata(query: string, userIds: string[], options: MetadataSearchOptions): Promise<AssetEntity[]>;
 }

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

@@ -89,6 +89,11 @@ export class AssetController {
     return this.service.getTimeBucket(auth, dto) as Promise<AssetResponseDto[]>;
   }
 
+  @Get('cities')
+  getAssetsByCity(@Auth() auth: AuthDto): Promise<AssetResponseDto[]> {
+    return this.service.getAssetsByCity(auth);
+  }
+
   @Post('jobs')
   @HttpCode(HttpStatus.NO_CONTENT)
   runAssetJobs(@Auth() auth: AuthDto, @Body() dto: AssetJobsDto): Promise<void> {

server/src/infra/repositories/asset.repository.ts

@@ -633,6 +633,7 @@ export class AssetRepository implements IAssetRepository {
     const cte = this.exifRepository
       .createQueryBuilder('e')
       .select('city')
+      .addSelect('count(city)', 'count')
       .groupBy('city')
       .having('count(city) >= :minAssetsPerField', { minAssetsPerField });
 
@@ -644,11 +645,12 @@ export class AssetRepository implements IAssetRepository {
     })
       .select('c.city', 'value')
       .addSelect('asset.id', 'data')
-      .distinctOn(['c.city'])
+      .distinctOn(['c.count', 'c.city'])
       .innerJoin('exif', 'e', 'asset.id = e."assetId"')
       .addCommonTableExpression(cte, 'cities')
       .innerJoin('cities', 'c', 'c.city = e.city')
       .limit(maxFields)
+      .orderBy('c.count', 'DESC')
       .getRawMany();
 
     return { fieldName: 'exifInfo.city', items };
@@ -683,6 +685,96 @@ export class AssetRepository implements IAssetRepository {
     return { fieldName: 'smartInfo.tags', items };
   }
 
+  @GenerateSql({ params: [[DummyValue.UUID]] })
+  async getAssetsByCity(userIds: string[]): Promise<AssetEntity[]> {
+    // the performance difference between this and the normal way is too huge to ignore, e.g. 3s vs 4ms
+    const parameters = [userIds.join(', '), true, false, AssetType.IMAGE];
+    const rawRes = await this.repository.query(
+      `
+      WITH RECURSIVE cte AS (
+        (
+          SELECT city, "assetId"
+          FROM exif
+          INNER JOIN assets ON exif."assetId" = assets.id
+          WHERE "ownerId" IN ($1) AND "isVisible" = $2 AND "isArchived" = $3 AND type = $4
+          ORDER BY city
+          LIMIT 1
+        )
+        UNION ALL
+        SELECT l.city, l."assetId"
+        FROM cte c
+          , LATERAL (
+          SELECT city, "assetId"
+          FROM exif
+          WHERE city > c.city
+          ORDER BY city
+          LIMIT 1
+          ) l
+        INNER JOIN assets ON l."assetId" = assets.id
+        WHERE "ownerId" IN ($5) AND "isVisible" = $6 AND "isArchived" = $7 AND type = $8
+      )
+      SELECT assets.*, exif.*
+      FROM assets
+      INNER JOIN cte ON id = "assetId"
+      INNER JOIN exif ON assets.id = exif."assetId"
+    `,
+      [...parameters, ...parameters],
+    );
+
+    const items = rawRes.map(
+      ({
+        country,
+        state,
+        city,
+        description,
+        model,
+        make,
+        dateTimeOriginal,
+        exifImageHeight,
+        exifImageWidth,
+        exposureTime,
+        fNumber,
+        fileSizeInByte,
+        focalLength,
+        iso,
+        latitude,
+        lensModel,
+        longitude,
+        modifyDate,
+        projectionType,
+        timeZone,
+        ...assetInfo
+      }: any) =>
+        ({
+          exifInfo: {
+            city,
+            country,
+            dateTimeOriginal,
+            description,
+            exifImageHeight,
+            exifImageWidth,
+            exposureTime,
+            fNumber,
+            fileSizeInByte,
+            focalLength,
+            iso,
+            latitude,
+            lensModel,
+            longitude,
+            make,
+            model,
+            modifyDate,
+            projectionType,
+            state,
+            timeZone,
+          },
+          ...assetInfo,
+        }) as AssetEntity,
+    );
+
+    return items;
+  }
+
   private getBuilder(options: AssetBuilderOptions) {
     const { isArchived, isFavorite, isTrashed, albumId, personId, userIds, withStacked, exifInfo, assetType } = options;