feat(server,web): libraries (#3124)

* feat: libraries

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

server/src/infra/entities/asset.entity.ts

@@ -10,19 +10,25 @@ import {
   OneToMany,
   OneToOne,
   PrimaryGeneratedColumn,
-  Unique,
   UpdateDateColumn,
 } from 'typeorm';
 import { AlbumEntity } from './album.entity';
 import { AssetFaceEntity } from './asset-face.entity';
 import { ExifEntity } from './exif.entity';
+import { LibraryEntity } from './library.entity';
 import { SharedLinkEntity } from './shared-link.entity';
 import { SmartInfoEntity } from './smart-info.entity';
 import { TagEntity } from './tag.entity';
 import { UserEntity } from './user.entity';
 
+export const ASSET_CHECKSUM_CONSTRAINT = 'UQ_assets_owner_library_checksum';
+
 @Entity('assets')
-@Unique('UQ_userid_checksum', ['owner', 'checksum'])
+// Checksums must be unique per user and library
+@Index(ASSET_CHECKSUM_CONSTRAINT, ['owner', 'library', 'checksum'], {
+  unique: true,
+})
+// For all assets, each originalpath must be unique per user and library
 export class AssetEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string;
@@ -36,13 +42,19 @@ export class AssetEntity {
   @Column()
   ownerId!: string;
 
+  @ManyToOne(() => LibraryEntity, { onDelete: 'CASCADE', onUpdate: 'CASCADE', nullable: false })
+  library!: LibraryEntity;
+
+  @Column()
+  libraryId!: string;
+
   @Column()
   deviceId!: string;
 
   @Column()
   type!: AssetType;
 
-  @Column({ unique: true })
+  @Column()
   originalPath!: string;
 
   @Column({ type: 'varchar', nullable: true })
@@ -75,9 +87,15 @@ export class AssetEntity {
   @Column({ type: 'boolean', default: false })
   isArchived!: boolean;
 
+  @Column({ type: 'boolean', default: false })
+  isExternal!: boolean;
+
   @Column({ type: 'boolean', default: false })
   isReadOnly!: boolean;
 
+  @Column({ type: 'boolean', default: false })
+  isOffline!: boolean;
+
   @Column({ type: 'bytea' })
   @Index()
   checksum!: Buffer; // sha1 checksum

server/src/infra/entities/index.ts

@@ -4,6 +4,7 @@ import { AssetFaceEntity } from './asset-face.entity';
 import { AssetEntity } from './asset.entity';
 import { AuditEntity } from './audit.entity';
 import { ExifEntity } from './exif.entity';
+import { LibraryEntity } from './library.entity';
 import { PartnerEntity } from './partner.entity';
 import { PersonEntity } from './person.entity';
 import { SharedLinkEntity } from './shared-link.entity';
@@ -19,6 +20,7 @@ export * from './asset-face.entity';
 export * from './asset.entity';
 export * from './audit.entity';
 export * from './exif.entity';
+export * from './library.entity';
 export * from './partner.entity';
 export * from './person.entity';
 export * from './shared-link.entity';
@@ -43,4 +45,5 @@ export const databaseEntities = [
   TagEntity,
   UserEntity,
   UserTokenEntity,
+  LibraryEntity,
 ];

server/src/infra/entities/library.entity.ts

@@ -0,0 +1,61 @@
+import {
+  Column,
+  CreateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  JoinTable,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+import { AssetEntity } from './asset.entity';
+import { UserEntity } from './user.entity';
+
+@Entity('libraries')
+export class LibraryEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column()
+  name!: string;
+
+  @OneToMany(() => AssetEntity, (asset) => asset.library)
+  @JoinTable()
+  assets!: AssetEntity[];
+
+  @ManyToOne(() => UserEntity, { onDelete: 'CASCADE', onUpdate: 'CASCADE', nullable: false })
+  owner!: UserEntity;
+
+  @Column()
+  ownerId!: string;
+
+  @Column()
+  type!: LibraryType;
+
+  @Column('text', { array: true })
+  importPaths!: string[];
+
+  @Column('text', { array: true })
+  exclusionPatterns!: string[];
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+
+  @DeleteDateColumn({ type: 'timestamptz' })
+  deletedAt?: Date;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  refreshedAt!: Date | null;
+
+  @Column({ type: 'boolean', default: true })
+  isVisible!: boolean;
+}
+
+export enum LibraryType {
+  UPLOAD = 'UPLOAD',
+  EXTERNAL = 'EXTERNAL',
+}

server/src/infra/entities/system-config.entity.ts

@@ -42,6 +42,7 @@ export enum SystemConfigKey {
   JOB_STORAGE_TEMPLATE_MIGRATION_CONCURRENCY = 'job.storageTemplateMigration.concurrency',
   JOB_SEARCH_CONCURRENCY = 'job.search.concurrency',
   JOB_SIDECAR_CONCURRENCY = 'job.sidecar.concurrency',
+  JOB_LIBRARY_CONCURRENCY = 'job.library.concurrency',
 
   MACHINE_LEARNING_ENABLED = 'machineLearning.enabled',
   MACHINE_LEARNING_URL = 'machineLearning.url',

server/src/infra/infra.module.ts

@@ -9,6 +9,7 @@ import {
   IGeocodingRepository,
   IJobRepository,
   IKeyRepository,
+  ILibraryRepository,
   IMachineLearningRepository,
   IMediaRepository,
   immichAppConfig,
@@ -43,6 +44,7 @@ import {
   FilesystemProvider,
   GeocodingRepository,
   JobRepository,
+  LibraryRepository,
   MachineLearningRepository,
   MediaRepository,
   PartnerRepository,
@@ -66,6 +68,7 @@ const providers: Provider[] = [
   { provide: IFaceRepository, useClass: FaceRepository },
   { provide: IGeocodingRepository, useClass: GeocodingRepository },
   { provide: IJobRepository, useClass: JobRepository },
+  { provide: ILibraryRepository, useClass: LibraryRepository },
   { provide: IKeyRepository, useClass: APIKeyRepository },
   { provide: IMachineLearningRepository, useClass: MachineLearningRepository },
   { provide: IPartnerRepository, useClass: PartnerRepository },

server/src/infra/migrations/1688392120838-AddLibraryTable.ts

@@ -0,0 +1,57 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddLibraries1688392120838 implements MigrationInterface {
+  name = 'AddLibraryTable1688392120838';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "assets" DROP CONSTRAINT "UQ_userid_checksum"`);
+    await queryRunner.query(
+      `CREATE TABLE "libraries" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" character varying NOT NULL, "ownerId" uuid NOT NULL, "type" character varying NOT NULL, "importPaths" text array NOT NULL, "exclusionPatterns" text array NOT NULL, "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "refreshedAt" TIMESTAMP WITH TIME ZONE, "isVisible" boolean NOT NULL DEFAULT true, CONSTRAINT "PK_505fedfcad00a09b3734b4223de" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(`ALTER TABLE "assets" ADD "isOffline" boolean NOT NULL DEFAULT false`);
+    await queryRunner.query(`ALTER TABLE "assets" ADD "libraryId" uuid`);
+    await queryRunner.query(`ALTER TABLE "assets" DROP CONSTRAINT "UQ_4ed4f8052685ff5b1e7ca1058ba"`);
+    await queryRunner.query(`ALTER TABLE "assets" ADD "isExternal" boolean NOT NULL DEFAULT false`);
+
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "UQ_assets_owner_library_checksum" on "assets" ("ownerId", "libraryId", checksum)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "libraries" ADD CONSTRAINT "FK_0f6fc2fb195f24d19b0fb0d57c1" FOREIGN KEY ("ownerId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "assets" ADD CONSTRAINT "FK_9977c3c1de01c3d848039a6b90c" FOREIGN KEY ("libraryId") REFERENCES "libraries"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+
+    // Create default library for each user and assign all assets to it
+    const userIds: string[] = (await queryRunner.query(`SELECT id FROM "users"`)).map((user: any) => user.id);
+
+    for (const userId of userIds) {
+      await queryRunner.query(
+        `INSERT INTO "libraries" ("name", "ownerId", "type", "importPaths", "exclusionPatterns") VALUES ('Default Library', '${userId}', 'UPLOAD', '{}', '{}')`,
+      );
+
+      await queryRunner.query(
+        `UPDATE "assets" SET "libraryId" = (SELECT id FROM "libraries" WHERE "ownerId" = '${userId}' LIMIT 1) WHERE "ownerId" = '${userId}'`,
+      );
+    }
+
+    await queryRunner.query(`ALTER TABLE "assets" ALTER COLUMN "libraryId" SET NOT NULL`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "assets" ALTER COLUMN "libraryId" DROP NOT NULL`);
+    await queryRunner.query(`ALTER TABLE "assets" DROP CONSTRAINT "FK_9977c3c1de01c3d848039a6b90c"`);
+    await queryRunner.query(`ALTER TABLE "libraries" DROP CONSTRAINT "FK_0f6fc2fb195f24d19b0fb0d57c1"`);
+    await queryRunner.query(`DROP INDEX "UQ_assets_owner_library_checksum"`);
+    await queryRunner.query(`ALTER TABLE "assets" DROP CONSTRAINT "UQ_owner_library_originalpath"`);
+    await queryRunner.query(
+      `ALTER TABLE "assets" ADD CONSTRAINT "UQ_4ed4f8052685ff5b1e7ca1058ba" UNIQUE ("originalPath")`,
+    );
+    await queryRunner.query(`ALTER TABLE "assets" DROP COLUMN "libraryId"`);
+    await queryRunner.query(`ALTER TABLE "assets" DROP COLUMN "isOffline"`);
+    await queryRunner.query(`ALTER TABLE "assets" DROP COLUMN "isExternal"`);
+    await queryRunner.query(`DROP TABLE "libraries"`);
+    await queryRunner.query(`ALTER TABLE "assets" ADD CONSTRAINT "UQ_userid_checksum" UNIQUE ("ownerId", "checksum")`);
+  }
+}

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

@@ -1,7 +1,7 @@
 import { IAccessRepository } from '@app/domain';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
-import { AlbumEntity, AssetEntity, PartnerEntity, PersonEntity, SharedLinkEntity } from '../entities';
+import { AlbumEntity, AssetEntity, LibraryEntity, PartnerEntity, PersonEntity, SharedLinkEntity } from '../entities';
 
 export class AccessRepository implements IAccessRepository {
   constructor(
@@ -10,9 +10,29 @@ export class AccessRepository implements IAccessRepository {
     @InjectRepository(PartnerEntity) private partnerRepository: Repository<PartnerEntity>,
     @InjectRepository(PersonEntity) private personRepository: Repository<PersonEntity>,
     @InjectRepository(SharedLinkEntity) private sharedLinkRepository: Repository<SharedLinkEntity>,
+    @InjectRepository(LibraryEntity) private libraryRepository: Repository<LibraryEntity>,
   ) {}
 
   library = {
+    hasOwnerAccess: (userId: string, libraryId: string): Promise<boolean> => {
+      return this.libraryRepository.exist({
+        where: {
+          id: libraryId,
+          ownerId: userId,
+        },
+      });
+    },
+    hasPartnerAccess: (userId: string, partnerId: string): Promise<boolean> => {
+      return this.partnerRepository.exist({
+        where: {
+          sharedWithId: userId,
+          sharedById: partnerId,
+        },
+      });
+    },
+  };
+
+  timeline = {
     hasPartnerAccess: (userId: string, partnerId: string): Promise<boolean> => {
       return this.partnerRepository.exist({
         where: {

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

@@ -38,6 +38,12 @@ export class AssetRepository implements IAssetRepository {
     await this.exifRepository.upsert(exif, { conflictPaths: ['assetId'] });
   }
 
+  create(
+    asset: Omit<AssetEntity, 'id' | 'createdAt' | 'updatedAt' | 'ownerId' | 'livePhotoVideoId'>,
+  ): Promise<AssetEntity> {
+    return this.repository.save(asset);
+  }
+
   getByDate(ownerId: string, date: Date): Promise<AssetEntity[]> {
     // For reference of a correct approach although slower
 
@@ -85,6 +91,7 @@ export class AssetRepository implements IAssetRepository {
       },
     });
   }
+
   async deleteAll(ownerId: string): Promise<void> {
     await this.repository.delete({ ownerId });
   }
@@ -115,6 +122,39 @@ export class AssetRepository implements IAssetRepository {
     });
   }
 
+  getByLibraryId(libraryIds: string[]): Promise<AssetEntity[]> {
+    return this.repository.find({
+      where: { library: { id: In(libraryIds) } },
+    });
+  }
+
+  getByLibraryIdAndOriginalPath(libraryId: string, originalPath: string): Promise<AssetEntity | null> {
+    return this.repository.findOne({
+      where: { library: { id: libraryId }, originalPath: originalPath },
+    });
+  }
+
+  getById(assetId: string): Promise<AssetEntity> {
+    return this.repository.findOneOrFail({
+      where: {
+        id: assetId,
+      },
+      relations: {
+        exifInfo: true,
+        tags: true,
+        sharedLinks: true,
+        smartInfo: true,
+        faces: {
+          person: true,
+        },
+      },
+    });
+  }
+
+  remove(asset: AssetEntity): Promise<AssetEntity> {
+    return this.repository.remove(asset);
+  }
+
   getAll(pagination: PaginationOptions, options: AssetSearchOptions = {}): Paginated<AssetEntity> {
     return paginate(this.repository, pagination, {
       where: {
@@ -273,13 +313,19 @@ export class AssetRepository implements IAssetRepository {
     });
   }
 
-  getWith(pagination: PaginationOptions, property: WithProperty): Paginated<AssetEntity> {
+  getWith(pagination: PaginationOptions, property: WithProperty, libraryId?: string): Paginated<AssetEntity> {
     let where: FindOptionsWhere<AssetEntity> | FindOptionsWhere<AssetEntity>[] = {};
 
     switch (property) {
       case WithProperty.SIDECAR:
         where = [{ sidecarPath: Not(IsNull()), isVisible: true }];
         break;
+      case WithProperty.IS_OFFLINE:
+        if (!libraryId) {
+          throw new Error('Library id is required when finding offline assets');
+        }
+        where = [{ isOffline: true, libraryId: libraryId }];
+        break;
 
       default:
         throw new Error(`Invalid getWith property: ${property}`);

server/src/infra/repositories/filesystem.provider.spec.ts

@@ -0,0 +1,209 @@
+import { CrawlOptionsDto } from '@app/domain';
+import mockfs from 'mock-fs';
+import { FilesystemProvider } from './filesystem.provider';
+
+describe(FilesystemProvider.name, () => {
+  const sut: FilesystemProvider = new FilesystemProvider();
+
+  describe('crawl', () => {
+    it('should return empty wnen crawling an empty path list', async () => {
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = [];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths).toHaveLength(0);
+    });
+
+    it('should crawl a single path', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+      });
+
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(['/photos/image.jpg'].sort());
+    });
+
+    it('should exclude by file extension', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+        '/photos/image.tif': '',
+      });
+
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/'];
+      options.exclusionPatterns = ['**/*.tif'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(['/photos/image.jpg'].sort());
+    });
+
+    it('should exclude by file extension without case sensitivity', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+        '/photos/image.tif': '',
+      });
+
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/'];
+      options.exclusionPatterns = ['**/*.TIF'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(['/photos/image.jpg'].sort());
+    });
+
+    it('should exclude by folder', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+        '/photos/raw/image.jpg': '',
+        '/photos/raw2/image.jpg': '',
+        '/photos/folder/raw/image.jpg': '',
+        '/photos/crawl/image.jpg': '',
+      });
+
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/'];
+      options.exclusionPatterns = ['**/raw/**'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(['/photos/image.jpg', '/photos/raw2/image.jpg', '/photos/crawl/image.jpg'].sort());
+    });
+
+    it('should crawl multiple paths', async () => {
+      mockfs({
+        '/photos/image1.jpg': '',
+        '/images/image2.jpg': '',
+        '/albums/image3.jpg': '',
+      });
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/', '/images/', '/albums/'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(['/photos/image1.jpg', '/images/image2.jpg', '/albums/image3.jpg'].sort());
+    });
+
+    it('should support globbing paths', async () => {
+      mockfs({
+        '/photos1/image1.jpg': '',
+        '/photos2/image2.jpg': '',
+        '/images/image3.jpg': '',
+      });
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos*'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(['/photos1/image1.jpg', '/photos2/image2.jpg'].sort());
+    });
+
+    it('should crawl a single path without trailing slash', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+      });
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(['/photos/image.jpg'].sort());
+    });
+
+    // TODO: test for hidden paths (not yet implemented)
+
+    it('should crawl a single path', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+        '/photos/subfolder/image1.jpg': '',
+        '/photos/subfolder/image2.jpg': '',
+        '/image1.jpg': '',
+      });
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(
+        ['/photos/image.jpg', '/photos/subfolder/image1.jpg', '/photos/subfolder/image2.jpg'].sort(),
+      );
+    });
+
+    it('should filter file extensions', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+        '/photos/image.txt': '',
+        '/photos/1': '',
+      });
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(['/photos/image.jpg'].sort());
+    });
+
+    it('should include photo and video extensions', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+        '/photos/image.jpeg': '',
+        '/photos/image.heic': '',
+        '/photos/image.heif': '',
+        '/photos/image.png': '',
+        '/photos/image.gif': '',
+        '/photos/image.tif': '',
+        '/photos/image.tiff': '',
+        '/photos/image.webp': '',
+        '/photos/image.dng': '',
+        '/photos/image.nef': '',
+        '/videos/video.mp4': '',
+        '/videos/video.mov': '',
+        '/videos/video.webm': '',
+      });
+
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/', '/videos/'];
+      const paths: string[] = await sut.crawl(options);
+
+      expect(paths.sort()).toEqual(
+        [
+          '/photos/image.jpg',
+          '/photos/image.jpeg',
+          '/photos/image.heic',
+          '/photos/image.heif',
+          '/photos/image.png',
+          '/photos/image.gif',
+          '/photos/image.tif',
+          '/photos/image.tiff',
+          '/photos/image.webp',
+          '/photos/image.dng',
+          '/photos/image.nef',
+          '/videos/video.mp4',
+          '/videos/video.mov',
+          '/videos/video.webm',
+        ].sort(),
+      );
+    });
+
+    it('should check file extensions without case sensitivity', async () => {
+      mockfs({
+        '/photos/image.jpg': '',
+        '/photos/image.Jpg': '',
+        '/photos/image.jpG': '',
+        '/photos/image.JPG': '',
+        '/photos/image.jpEg': '',
+        '/photos/image.TIFF': '',
+        '/photos/image.tif': '',
+        '/photos/image.dng': '',
+        '/photos/image.NEF': '',
+      });
+
+      const options = new CrawlOptionsDto();
+      options.pathsToCrawl = ['/photos/'];
+      const paths: string[] = await sut.crawl(options);
+      expect(paths.sort()).toEqual(
+        [
+          '/photos/image.jpg',
+          '/photos/image.Jpg',
+          '/photos/image.jpG',
+          '/photos/image.JPG',
+          '/photos/image.jpEg',
+          '/photos/image.TIFF',
+          '/photos/image.tif',
+          '/photos/image.dng',
+          '/photos/image.NEF',
+        ].sort(),
+      );
+    });
+
+    afterEach(() => {
+      mockfs.restore();
+    });
+  });
+});

server/src/infra/repositories/filesystem.provider.ts

@@ -1,7 +1,15 @@
-import { DiskUsage, ImmichReadStream, ImmichZipStream, IStorageRepository } from '@app/domain';
+import {
+  CrawlOptionsDto,
+  DiskUsage,
+  ImmichReadStream,
+  ImmichZipStream,
+  IStorageRepository,
+  mimeTypes,
+} from '@app/domain';
 import archiver from 'archiver';
 import { constants, createReadStream, existsSync, mkdirSync } from 'fs';
 import fs, { readdir } from 'fs/promises';
+import { glob } from 'glob';
 import mv from 'mv';
 import { promisify } from 'node:util';
 import path from 'path';
@@ -52,6 +60,8 @@ export class FilesystemProvider implements IStorageRepository {
     await fs.unlink(file);
   }
 
+  stat = fs.stat;
+
   async unlinkDir(folder: string, options: { recursive?: boolean; force?: boolean }) {
     await fs.rm(folder, options);
   }
@@ -93,5 +103,25 @@ export class FilesystemProvider implements IStorageRepository {
     };
   }
 
+  async crawl(crawlOptions: CrawlOptionsDto): Promise<string[]> {
+    const pathsToCrawl = crawlOptions.pathsToCrawl;
+
+    let paths: string;
+    if (!pathsToCrawl) {
+      // No paths to crawl, return empty list
+      return [];
+    } else if (pathsToCrawl.length === 1) {
+      paths = pathsToCrawl[0];
+    } else {
+      paths = '{' + pathsToCrawl.join(',') + '}';
+    }
+
+    paths = paths + '/**/*{' + mimeTypes.getSupportedFileExtensions().join(',') + '}';
+
+    return (await glob(paths, { nocase: true, nodir: true, ignore: crawlOptions.exclusionPatterns })).map((assetPath) =>
+      path.normalize(assetPath),
+    );
+  }
+
   readdir = readdir;
 }

server/src/infra/repositories/index.ts

@@ -9,6 +9,7 @@ export * from './face.repository';
 export * from './filesystem.provider';
 export * from './geocoding.repository';
 export * from './job.repository';
+export * from './library.repository';
 export * from './machine-learning.repository';
 export * from './media.repository';
 export * from './partner.repository';

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

@@ -78,7 +78,7 @@ export class JobRepository implements IJobRepository {
     }
   }
 
-  private getQueue(queue: QueueName) {
+  private getQueue(queue: QueueName): Queue {
     return this.moduleRef.get<Queue>(getQueueToken(queue), { strict: false });
   }
 }

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

@@ -0,0 +1,183 @@
+import { ILibraryRepository, LibraryStatsResponseDto } from '@app/domain';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { IsNull, Not } from 'typeorm';
+import { Repository } from 'typeorm/repository/Repository';
+import { LibraryEntity, LibraryType } from '../entities';
+
+@Injectable()
+export class LibraryRepository implements ILibraryRepository {
+  constructor(@InjectRepository(LibraryEntity) private repository: Repository<LibraryEntity>) {}
+
+  get(id: string, withDeleted = false): Promise<LibraryEntity | null> {
+    return this.repository.findOneOrFail({
+      where: {
+        id,
+      },
+      relations: { owner: true },
+      withDeleted,
+    });
+  }
+
+  existsByName(name: string, withDeleted = false): Promise<boolean> {
+    return this.repository.exist({
+      where: {
+        name,
+      },
+      withDeleted,
+    });
+  }
+
+  getCountForUser(ownerId: string): Promise<number> {
+    return this.repository.countBy({ ownerId });
+  }
+
+  getDefaultUploadLibrary(ownerId: string): Promise<LibraryEntity | null> {
+    return this.repository.findOne({
+      where: {
+        ownerId: ownerId,
+        type: LibraryType.UPLOAD,
+      },
+      order: {
+        createdAt: 'ASC',
+      },
+    });
+  }
+
+  getUploadLibraryCount(ownerId: string): Promise<number> {
+    return this.repository.count({
+      where: {
+        ownerId: ownerId,
+        type: LibraryType.UPLOAD,
+      },
+    });
+  }
+
+  getAllByUserId(ownerId: string, type?: LibraryType): Promise<LibraryEntity[]> {
+    return this.repository.find({
+      where: {
+        ownerId,
+        isVisible: true,
+        type,
+      },
+      relations: {
+        owner: true,
+      },
+      order: {
+        createdAt: 'ASC',
+      },
+    });
+  }
+
+  getAll(withDeleted = false, type?: LibraryType): Promise<LibraryEntity[]> {
+    return this.repository.find({
+      where: { type },
+      relations: {
+        owner: true,
+      },
+      order: {
+        createdAt: 'ASC',
+      },
+      withDeleted,
+    });
+  }
+
+  getAllDeleted(): Promise<LibraryEntity[]> {
+    return this.repository.find({
+      where: {
+        isVisible: true,
+        deletedAt: Not(IsNull()),
+      },
+      relations: {
+        owner: true,
+      },
+      order: {
+        createdAt: 'ASC',
+      },
+      withDeleted: true,
+    });
+  }
+
+  create(library: Omit<LibraryEntity, 'id' | 'createdAt' | 'updatedAt' | 'ownerId'>): Promise<LibraryEntity> {
+    return this.repository.save(library);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.repository.delete({ id });
+  }
+
+  async softDelete(id: string): Promise<void> {
+    await this.repository.softDelete({ id });
+  }
+
+  async update(library: Partial<LibraryEntity>): Promise<LibraryEntity> {
+    return this.save(library);
+  }
+
+  async getStatistics(id: string): Promise<LibraryStatsResponseDto> {
+    const stats = await this.repository
+      .createQueryBuilder('libraries')
+      .addSelect(`COUNT(assets.id) FILTER (WHERE assets.type = 'IMAGE' AND assets.isVisible)`, 'photos')
+      .addSelect(`COUNT(assets.id) FILTER (WHERE assets.type = 'VIDEO' AND assets.isVisible)`, 'videos')
+      .addSelect('COALESCE(SUM(exif.fileSizeInByte), 0)', 'usage')
+      .leftJoin('libraries.assets', 'assets')
+      .leftJoin('assets.exifInfo', 'exif')
+      .groupBy('libraries.id')
+      .where('libraries.id = :id', { id })
+      .getRawOne();
+
+    return {
+      photos: Number(stats.photos),
+      videos: Number(stats.videos),
+      usage: Number(stats.usage),
+      total: Number(stats.photos) + Number(stats.videos),
+    };
+  }
+
+  async getOnlineAssetPaths(libraryId: string): Promise<string[]> {
+    // Return all non-offline asset paths for a given library
+    const rawResults = await this.repository
+      .createQueryBuilder('library')
+      .innerJoinAndSelect('library.assets', 'assets')
+      .where('library.id = :id', { id: libraryId })
+      .andWhere('assets.isOffline = false')
+      .select('assets.originalPath')
+      .getRawMany();
+
+    const results: string[] = [];
+
+    for (const rawPath of rawResults) {
+      results.push(rawPath.assets_originalPath);
+    }
+
+    return results;
+  }
+
+  async getAssetIds(libraryId: string, withDeleted = false): Promise<string[]> {
+    let query = await this.repository
+      .createQueryBuilder('library')
+      .innerJoinAndSelect('library.assets', 'assets')
+      .where('library.id = :id', { id: libraryId })
+      .select('assets.id');
+
+    if (withDeleted) {
+      query = query.withDeleted();
+    }
+
+    // Return all asset paths for a given library
+    const rawResults = await query.getRawMany();
+
+    const results: string[] = [];
+
+    for (const rawPath of rawResults) {
+      results.push(rawPath.assets_id);
+    }
+
+    return results;
+  }
+
+  private async save(library: Partial<LibraryEntity>) {
+    const { id } = await this.repository.save(library);
+    return this.repository.findOneByOrFail({ id });
+  }
+}