refactor: repositories (#16036)

server/src/repositories/album.repository.ts

@@ -6,7 +6,17 @@ import { Albums, DB } from 'src/db';
 import { Chunked, ChunkedArray, ChunkedSet, DummyValue, GenerateSql } from 'src/decorators';
 import { AlbumUserCreateDto } from 'src/dtos/album.dto';
 import { AlbumEntity } from 'src/entities/album.entity';
-import { AlbumAssetCount, AlbumInfoOptions, IAlbumRepository } from 'src/interfaces/album.interface';
+
+export interface AlbumAssetCount {
+  albumId: string;
+  assetCount: number;
+  startDate: Date | null;
+  endDate: Date | null;
+}
+
+export interface AlbumInfoOptions {
+  withAssets: boolean;
+}
 
 const userColumns = [
   'id',
@@ -71,7 +81,7 @@ const withAssets = (eb: ExpressionBuilder<DB, 'albums'>) => {
 };
 
 @Injectable()
-export class AlbumRepository implements IAlbumRepository {
+export class AlbumRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [DummyValue.UUID, { withAssets: true }] })

server/src/repositories/asset.repository.ts

@@ -21,34 +21,138 @@ import {
   withTagId,
   withTags,
 } from 'src/entities/asset.entity';
-import { AssetFileType, AssetStatus, AssetType } from 'src/enum';
-import {
-  AssetDeltaSyncOptions,
-  AssetExploreFieldOptions,
-  AssetFullSyncOptions,
-  AssetGetByChecksumOptions,
-  AssetStats,
-  AssetStatsOptions,
-  AssetUpdateDuplicateOptions,
-  DayOfYearAssets,
-  DuplicateGroup,
-  GetByIdsRelations,
-  IAssetRepository,
-  LivePhotoSearchOptions,
-  MonthDay,
-  TimeBucketItem,
-  TimeBucketOptions,
-  TimeBucketSize,
-  WithProperty,
-  WithoutProperty,
-} from 'src/interfaces/asset.interface';
-import { AssetSearchOptions, SearchExploreItem, SearchExploreItemSet } from 'src/interfaces/search.interface';
+import { AssetFileType, AssetOrder, AssetStatus, AssetType } from 'src/enum';
 import { MapMarker, MapMarkerSearchOptions } from 'src/repositories/map.repository';
+import { AssetSearchOptions, SearchExploreItem, SearchExploreItemSet } from 'src/repositories/search.repository';
 import { anyUuid, asUuid, mapUpsertColumns } from 'src/utils/database';
 import { Paginated, PaginationOptions, paginationHelper } from 'src/utils/pagination';
 
+export type AssetStats = Record<AssetType, number>;
+
+export interface AssetStatsOptions {
+  isFavorite?: boolean;
+  isArchived?: boolean;
+  isTrashed?: boolean;
+}
+
+export interface LivePhotoSearchOptions {
+  ownerId: string;
+  libraryId?: string | null;
+  livePhotoCID: string;
+  otherAssetId: string;
+  type: AssetType;
+}
+
+export enum WithoutProperty {
+  THUMBNAIL = 'thumbnail',
+  ENCODED_VIDEO = 'encoded-video',
+  EXIF = 'exif',
+  SMART_SEARCH = 'smart-search',
+  DUPLICATE = 'duplicate',
+  FACES = 'faces',
+  SIDECAR = 'sidecar',
+}
+
+export enum WithProperty {
+  SIDECAR = 'sidecar',
+}
+
+export enum TimeBucketSize {
+  DAY = 'DAY',
+  MONTH = 'MONTH',
+}
+
+export interface AssetBuilderOptions {
+  isArchived?: boolean;
+  isFavorite?: boolean;
+  isTrashed?: boolean;
+  isDuplicate?: boolean;
+  albumId?: string;
+  tagId?: string;
+  personId?: string;
+  userIds?: string[];
+  withStacked?: boolean;
+  exifInfo?: boolean;
+  status?: AssetStatus;
+  assetType?: AssetType;
+}
+
+export interface TimeBucketOptions extends AssetBuilderOptions {
+  size: TimeBucketSize;
+  order?: AssetOrder;
+}
+
+export interface TimeBucketItem {
+  timeBucket: string;
+  count: number;
+}
+
+export interface MonthDay {
+  day: number;
+  month: number;
+}
+
+export interface AssetExploreFieldOptions {
+  maxFields: number;
+  minAssetsPerField: number;
+}
+
+export interface AssetFullSyncOptions {
+  ownerId: string;
+  lastId?: string;
+  updatedUntil: Date;
+  limit: number;
+}
+
+export interface AssetDeltaSyncOptions {
+  userIds: string[];
+  updatedAfter: Date;
+  limit: number;
+}
+
+export interface AssetUpdateDuplicateOptions {
+  targetDuplicateId: string | null;
+  assetIds: string[];
+  duplicateIds: string[];
+}
+
+export interface UpsertFileOptions {
+  assetId: string;
+  type: AssetFileType;
+  path: string;
+}
+
+export interface AssetGetByChecksumOptions {
+  ownerId: string;
+  checksum: Buffer;
+  libraryId?: string;
+}
+
+export type AssetPathEntity = Pick<AssetEntity, 'id' | 'originalPath' | 'isOffline'>;
+
+export interface GetByIdsRelations {
+  exifInfo?: boolean;
+  faces?: { person?: boolean };
+  files?: boolean;
+  library?: boolean;
+  owner?: boolean;
+  smartSearch?: boolean;
+  stack?: { assets?: boolean };
+  tags?: boolean;
+}
+
+export interface DuplicateGroup {
+  duplicateId: string;
+  assets: AssetEntity[];
+}
+
+export interface DayOfYearAssets {
+  yearsAgo: number;
+  assets: AssetEntity[];
+}
+
 @Injectable()
-export class AssetRepository implements IAssetRepository {
+export class AssetRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   async upsertExif(exif: Insertable<Exif>): Promise<void> {

server/src/repositories/config.repository.ts

@@ -13,9 +13,9 @@ import { Notice } from 'postgres';
 import { citiesFile, excludePaths, IWorker } from 'src/constants';
 import { Telemetry } from 'src/decorators';
 import { EnvDto } from 'src/dtos/env.dto';
-import { ImmichEnvironment, ImmichHeader, ImmichTelemetry, ImmichWorker, LogLevel } from 'src/enum';
-import { DatabaseConnectionParams, DatabaseExtension, VectorExtension } from 'src/interfaces/database.interface';
+import { DatabaseExtension, ImmichEnvironment, ImmichHeader, ImmichTelemetry, ImmichWorker, LogLevel } from 'src/enum';
 import { QueueName } from 'src/interfaces/job.interface';
+import { DatabaseConnectionParams, VectorExtension } from 'src/repositories/database.repository';
 import { setDifference } from 'src/utils/set';
 import { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions.js';
 

server/src/repositories/crypto.repository.ts

@@ -2,11 +2,10 @@ import { Injectable } from '@nestjs/common';
 import { compareSync, hash } from 'bcrypt';
 import { createHash, createPublicKey, createVerify, randomBytes, randomUUID } from 'node:crypto';
 import { createReadStream } from 'node:fs';
-import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 
 @Injectable()
-export class CryptoRepository implements ICryptoRepository {
-  randomUUID() {
+export class CryptoRepository {
+  randomUUID(): string {
     return randomUUID();
   }
 

server/src/repositories/database.repository.ts

@@ -6,24 +6,66 @@ import { InjectKysely } from 'nestjs-kysely';
 import semver from 'semver';
 import { POSTGRES_VERSION_RANGE, VECTOR_VERSION_RANGE, VECTORS_VERSION_RANGE } from 'src/constants';
 import { DB } from 'src/db';
-import {
-  DatabaseExtension,
-  DatabaseLock,
-  EXTENSION_NAMES,
-  ExtensionVersion,
-  IDatabaseRepository,
-  VectorExtension,
-  VectorIndex,
-  VectorUpdateResult,
-} from 'src/interfaces/database.interface';
+import { DatabaseExtension } from 'src/enum';
 import { ConfigRepository } from 'src/repositories/config.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { UPSERT_COLUMNS } from 'src/utils/database';
 import { isValidInteger } from 'src/validation';
 import { DataSource, EntityManager, EntityMetadata, QueryRunner } from 'typeorm';
 
+export type VectorExtension = DatabaseExtension.VECTOR | DatabaseExtension.VECTORS;
+
+export type DatabaseConnectionURL = {
+  connectionType: 'url';
+  url: string;
+};
+
+export type DatabaseConnectionParts = {
+  connectionType: 'parts';
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+  database: string;
+};
+
+export type DatabaseConnectionParams = DatabaseConnectionURL | DatabaseConnectionParts;
+
+export enum VectorIndex {
+  CLIP = 'clip_index',
+  FACE = 'face_index',
+}
+
+export enum DatabaseLock {
+  GeodataImport = 100,
+  Migrations = 200,
+  SystemFileMounts = 300,
+  StorageTemplateMigration = 420,
+  VersionHistory = 500,
+  CLIPDimSize = 512,
+  Library = 1337,
+  GetSystemConfig = 69,
+  BackupDatabase = 42,
+}
+
+export const EXTENSION_NAMES: Record<DatabaseExtension, string> = {
+  cube: 'cube',
+  earthdistance: 'earthdistance',
+  vector: 'pgvector',
+  vectors: 'pgvecto.rs',
+} as const;
+
+export interface ExtensionVersion {
+  availableVersion: string | null;
+  installedVersion: string | null;
+}
+
+export interface VectorUpdateResult {
+  restartRequired: boolean;
+}
+
 @Injectable()
-export class DatabaseRepository implements IDatabaseRepository {
+export class DatabaseRepository {
   private vectorExtension: VectorExtension;
   private readonly asyncLock = new AsyncLock();
 

server/src/repositories/index.ts

@@ -1,20 +1,6 @@
-import { IAlbumRepository } from 'src/interfaces/album.interface';
-import { IAssetRepository } from 'src/interfaces/asset.interface';
-import { ICryptoRepository } from 'src/interfaces/crypto.interface';
-import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { IEventRepository } from 'src/interfaces/event.interface';
 import { IJobRepository } from 'src/interfaces/job.interface';
-import { ILibraryRepository } from 'src/interfaces/library.interface';
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
-import { IMoveRepository } from 'src/interfaces/move.interface';
-import { IPartnerRepository } from 'src/interfaces/partner.interface';
-import { IPersonRepository } from 'src/interfaces/person.interface';
-import { ISearchRepository } from 'src/interfaces/search.interface';
-import { ISharedLinkRepository } from 'src/interfaces/shared-link.interface';
-import { IStackRepository } from 'src/interfaces/stack.interface';
-import { IStorageRepository } from 'src/interfaces/storage.interface';
-import { ITagRepository } from 'src/interfaces/tag.interface';
-import { IUserRepository } from 'src/interfaces/user.interface';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
 import { AlbumUserRepository } from 'src/repositories/album-user.repository';
@@ -58,44 +44,44 @@ import { ViewRepository } from 'src/repositories/view-repository';
 export const repositories = [
   AccessRepository,
   ActivityRepository,
+  AlbumRepository,
   AlbumUserRepository,
   AuditRepository,
   ApiKeyRepository,
+  AssetRepository,
   ConfigRepository,
   CronRepository,
+  CryptoRepository,
+  DatabaseRepository,
+  LibraryRepository,
   LoggingRepository,
   MapRepository,
   MediaRepository,
   MemoryRepository,
   MetadataRepository,
+  MoveRepository,
   NotificationRepository,
   OAuthRepository,
+  PartnerRepository,
+  PersonRepository,
   ProcessRepository,
+  SearchRepository,
   SessionRepository,
   ServerInfoRepository,
+  SharedLinkRepository,
+  StackRepository,
+  StorageRepository,
   SystemMetadataRepository,
+  TagRepository,
   TelemetryRepository,
   TrashRepository,
+  UserRepository,
   ViewRepository,
   VersionHistoryRepository,
 ];
 
 export const providers = [
-  { provide: IAlbumRepository, useClass: AlbumRepository },
-  { provide: IAssetRepository, useClass: AssetRepository },
-  { provide: ICryptoRepository, useClass: CryptoRepository },
-  { provide: IDatabaseRepository, useClass: DatabaseRepository },
   { provide: IEventRepository, useClass: EventRepository },
   { provide: IJobRepository, useClass: JobRepository },
-  { provide: ILibraryRepository, useClass: LibraryRepository },
   { provide: IMachineLearningRepository, useClass: MachineLearningRepository },
-  { provide: IMoveRepository, useClass: MoveRepository },
-  { provide: IPartnerRepository, useClass: PartnerRepository },
-  { provide: IPersonRepository, useClass: PersonRepository },
-  { provide: ISearchRepository, useClass: SearchRepository },
-  { provide: ISharedLinkRepository, useClass: SharedLinkRepository },
-  { provide: IStackRepository, useClass: StackRepository },
-  { provide: IStorageRepository, useClass: StorageRepository },
-  { provide: ITagRepository, useClass: TagRepository },
-  { provide: IUserRepository, useClass: UserRepository },
 ];

server/src/repositories/library.repository.ts

@@ -7,7 +7,6 @@ import { DummyValue, GenerateSql } from 'src/decorators';
 import { LibraryStatsResponseDto } from 'src/dtos/library.dto';
 import { LibraryEntity } from 'src/entities/library.entity';
 import { AssetType } from 'src/enum';
-import { ILibraryRepository } from 'src/interfaces/library.interface';
 
 const userColumns = [
   'users.id',
@@ -34,7 +33,7 @@ const withOwner = (eb: ExpressionBuilder<DB, 'libraries'>) => {
 };
 
 @Injectable()
-export class LibraryRepository implements ILibraryRepository {
+export class LibraryRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [DummyValue.UUID] })

server/src/repositories/move.repository.ts

@@ -5,10 +5,11 @@ import { DB, MoveHistory } from 'src/db';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { MoveEntity } from 'src/entities/move.entity';
 import { PathType } from 'src/enum';
-import { IMoveRepository } from 'src/interfaces/move.interface';
+
+export type MoveCreate = Pick<MoveEntity, 'oldPath' | 'newPath' | 'entityId' | 'pathType'> & Partial<MoveEntity>;
 
 @Injectable()
-export class MoveRepository implements IMoveRepository {
+export class MoveRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   create(entity: Insertable<MoveHistory>): Promise<MoveEntity> {

server/src/repositories/partner.repository.ts

@@ -5,7 +5,16 @@ import { InjectKysely } from 'nestjs-kysely';
 import { DB, Partners, Users } from 'src/db';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { PartnerEntity } from 'src/entities/partner.entity';
-import { IPartnerRepository, PartnerIds } from 'src/interfaces/partner.interface';
+
+export interface PartnerIds {
+  sharedById: string;
+  sharedWithId: string;
+}
+
+export enum PartnerDirection {
+  SharedBy = 'shared-by',
+  SharedWith = 'shared-with',
+}
 
 const columns = ['id', 'name', 'email', 'profileImagePath', 'profileChangedAt'] as const;
 
@@ -28,7 +37,7 @@ const withSharedWith = (eb: ExpressionBuilder<DB, 'partners'>) => {
 };
 
 @Injectable()
-export class PartnerRepository implements IPartnerRepository {
+export class PartnerRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [DummyValue.UUID] })

server/src/repositories/person.repository.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { ExpressionBuilder, Insertable, Kysely, sql } from 'kysely';
+import { ExpressionBuilder, Insertable, Kysely, Selectable, sql } from 'kysely';
 import { jsonObjectFrom } from 'kysely/helpers/postgres';
 import { InjectKysely } from 'nestjs-kysely';
 import { AssetFaces, DB, FaceSearch, Person } from 'src/db';
@@ -7,23 +7,53 @@ import { ChunkedArray, DummyValue, GenerateSql } from 'src/decorators';
 import { AssetFaceEntity } from 'src/entities/asset-face.entity';
 import { PersonEntity } from 'src/entities/person.entity';
 import { SourceType } from 'src/enum';
-import {
-  AssetFaceId,
-  DeleteFacesOptions,
-  IPersonRepository,
-  PeopleStatistics,
-  PersonNameResponse,
-  PersonNameSearchOptions,
-  PersonSearchOptions,
-  PersonStatistics,
-  SelectFaceOptions,
-  UnassignFacesOptions,
-  UpdateFacesData,
-} from 'src/interfaces/person.interface';
 import { mapUpsertColumns } from 'src/utils/database';
 import { Paginated, PaginationOptions } from 'src/utils/pagination';
 import { FindOptionsRelations } from 'typeorm';
 
+export interface PersonSearchOptions {
+  minimumFaceCount: number;
+  withHidden: boolean;
+  closestFaceAssetId?: string;
+}
+
+export interface PersonNameSearchOptions {
+  withHidden?: boolean;
+}
+
+export interface PersonNameResponse {
+  id: string;
+  name: string;
+}
+
+export interface AssetFaceId {
+  assetId: string;
+  personId: string;
+}
+
+export interface UpdateFacesData {
+  oldPersonId?: string;
+  faceIds?: string[];
+  newPersonId: string;
+}
+
+export interface PersonStatistics {
+  assets: number;
+}
+
+export interface PeopleStatistics {
+  total: number;
+  hidden: number;
+}
+
+export interface DeleteFacesOptions {
+  sourceType: SourceType;
+}
+
+export type UnassignFacesOptions = DeleteFacesOptions;
+
+export type SelectFaceOptions = (keyof Selectable<AssetFaces>)[];
+
 const withPerson = (eb: ExpressionBuilder<DB, 'asset_faces'>) => {
   return jsonObjectFrom(
     eb.selectFrom('person').selectAll('person').whereRef('person.id', '=', 'asset_faces.personId'),
@@ -43,7 +73,7 @@ const withFaceSearch = (eb: ExpressionBuilder<DB, 'asset_faces'>) => {
 };
 
 @Injectable()
-export class PersonRepository implements IPersonRepository {
+export class PersonRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [{ oldPersonId: DummyValue.UUID, newPersonId: DummyValue.UUID }] })

server/src/repositories/search.repository.ts

@@ -6,26 +6,202 @@ import { DB } from 'src/db';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { AssetEntity, searchAssetBuilder } from 'src/entities/asset.entity';
 import { GeodataPlacesEntity } from 'src/entities/geodata-places.entity';
-import { AssetType } from 'src/enum';
-import {
-  AssetDuplicateSearch,
-  AssetSearchOptions,
-  FaceEmbeddingSearch,
-  GetCameraMakesOptions,
-  GetCameraModelsOptions,
-  GetCitiesOptions,
-  GetStatesOptions,
-  ISearchRepository,
-  SearchPaginationOptions,
-  SmartSearchOptions,
-} from 'src/interfaces/search.interface';
+import { AssetStatus, AssetType } from 'src/enum';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { anyUuid, asUuid } from 'src/utils/database';
 import { Paginated } from 'src/utils/pagination';
 import { isValidInteger } from 'src/validation';
 
+export interface SearchResult<T> {
+  /** total matches */
+  total: number;
+  /** collection size */
+  count: number;
+  /** current page */
+  page: number;
+  /** items for page */
+  items: T[];
+  /** score */
+  distances: number[];
+  facets: SearchFacet[];
+}
+
+export interface SearchFacet {
+  fieldName: string;
+  counts: Array<{
+    count: number;
+    value: string;
+  }>;
+}
+
+export type SearchExploreItemSet<T> = Array<{
+  value: string;
+  data: T;
+}>;
+
+export interface SearchExploreItem<T> {
+  fieldName: string;
+  items: SearchExploreItemSet<T>;
+}
+
+export interface SearchAssetIDOptions {
+  checksum?: Buffer;
+  deviceAssetId?: string;
+  id?: string;
+}
+
+export interface SearchUserIdOptions {
+  deviceId?: string;
+  libraryId?: string | null;
+  userIds?: string[];
+}
+
+export type SearchIdOptions = SearchAssetIDOptions & SearchUserIdOptions;
+
+export interface SearchStatusOptions {
+  isArchived?: boolean;
+  isEncoded?: boolean;
+  isFavorite?: boolean;
+  isMotion?: boolean;
+  isOffline?: boolean;
+  isVisible?: boolean;
+  isNotInAlbum?: boolean;
+  type?: AssetType;
+  status?: AssetStatus;
+  withArchived?: boolean;
+  withDeleted?: boolean;
+}
+
+export interface SearchOneToOneRelationOptions {
+  withExif?: boolean;
+  withStacked?: boolean;
+}
+
+export interface SearchRelationOptions extends SearchOneToOneRelationOptions {
+  withFaces?: boolean;
+  withPeople?: boolean;
+}
+
+export interface SearchDateOptions {
+  createdBefore?: Date;
+  createdAfter?: Date;
+  takenBefore?: Date;
+  takenAfter?: Date;
+  trashedBefore?: Date;
+  trashedAfter?: Date;
+  updatedBefore?: Date;
+  updatedAfter?: Date;
+}
+
+export interface SearchPathOptions {
+  encodedVideoPath?: string;
+  originalFileName?: string;
+  originalPath?: string;
+  previewPath?: string;
+  thumbnailPath?: string;
+}
+
+export interface SearchExifOptions {
+  city?: string | null;
+  country?: string | null;
+  lensModel?: string | null;
+  make?: string | null;
+  model?: string | null;
+  state?: string | null;
+  description?: string | null;
+}
+
+export interface SearchEmbeddingOptions {
+  embedding: string;
+  userIds: string[];
+}
+
+export interface SearchPeopleOptions {
+  personIds?: string[];
+}
+
+export interface SearchTagOptions {
+  tagIds?: string[];
+}
+
+export interface SearchOrderOptions {
+  orderDirection?: 'asc' | 'desc';
+}
+
+export interface SearchPaginationOptions {
+  page: number;
+  size: number;
+}
+
+type BaseAssetSearchOptions = SearchDateOptions &
+  SearchIdOptions &
+  SearchExifOptions &
+  SearchOrderOptions &
+  SearchPathOptions &
+  SearchStatusOptions &
+  SearchUserIdOptions &
+  SearchPeopleOptions &
+  SearchTagOptions;
+
+export type AssetSearchOptions = BaseAssetSearchOptions & SearchRelationOptions;
+
+export type AssetSearchOneToOneRelationOptions = BaseAssetSearchOptions & SearchOneToOneRelationOptions;
+
+export type AssetSearchBuilderOptions = Omit<AssetSearchOptions, 'orderDirection'>;
+
+export type SmartSearchOptions = SearchDateOptions &
+  SearchEmbeddingOptions &
+  SearchExifOptions &
+  SearchOneToOneRelationOptions &
+  SearchStatusOptions &
+  SearchUserIdOptions &
+  SearchPeopleOptions &
+  SearchTagOptions;
+
+export interface FaceEmbeddingSearch extends SearchEmbeddingOptions {
+  hasPerson?: boolean;
+  numResults: number;
+  maxDistance: number;
+}
+
+export interface AssetDuplicateSearch {
+  assetId: string;
+  embedding: string;
+  maxDistance: number;
+  type: AssetType;
+  userIds: string[];
+}
+
+export interface FaceSearchResult {
+  distance: number;
+  id: string;
+  personId: string | null;
+}
+
+export interface AssetDuplicateResult {
+  assetId: string;
+  duplicateId: string | null;
+  distance: number;
+}
+
+export interface GetStatesOptions {
+  country?: string;
+}
+
+export interface GetCitiesOptions extends GetStatesOptions {
+  state?: string;
+}
+
+export interface GetCameraModelsOptions {
+  make?: string;
+}
+
+export interface GetCameraMakesOptions {
+  model?: string;
+}
+
 @Injectable()
-export class SearchRepository implements ISearchRepository {
+export class SearchRepository {
   constructor(
     private logger: LoggingRepository,
     @InjectKysely() private db: Kysely<DB>,

server/src/repositories/shared-link.repository.ts

@@ -7,10 +7,14 @@ import { DB, SharedLinks } from 'src/db';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { SharedLinkEntity } from 'src/entities/shared-link.entity';
 import { SharedLinkType } from 'src/enum';
-import { ISharedLinkRepository, SharedLinkSearchOptions } from 'src/interfaces/shared-link.interface';
+
+export type SharedLinkSearchOptions = {
+  userId: string;
+  albumId?: string;
+};
 
 @Injectable()
-export class SharedLinkRepository implements ISharedLinkRepository {
+export class SharedLinkRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID] })

server/src/repositories/stack.repository.ts

@@ -5,9 +5,13 @@ import { InjectKysely } from 'nestjs-kysely';
 import { DB } from 'src/db';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { StackEntity } from 'src/entities/stack.entity';
-import { IStackRepository, StackSearch } from 'src/interfaces/stack.interface';
 import { asUuid } from 'src/utils/database';
 
+export interface StackSearch {
+  ownerId: string;
+  primaryAssetId?: string;
+}
+
 const withAssets = (eb: ExpressionBuilder<DB, 'asset_stack'>, withTags = false) => {
   return jsonArrayFrom(
     eb
@@ -35,7 +39,7 @@ const withAssets = (eb: ExpressionBuilder<DB, 'asset_stack'>, withTags = false)
 };
 
 @Injectable()
-export class StackRepository implements IStackRepository {
+export class StackRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [{ ownerId: DummyValue.UUID }] })

server/src/repositories/storage.repository.ts

@@ -5,20 +5,38 @@ import { escapePath, glob, globStream } from 'fast-glob';
 import { constants, createReadStream, createWriteStream, existsSync, mkdirSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { Writable } from 'node:stream';
+import { Readable, Writable } from 'node:stream';
 import { CrawlOptionsDto, WalkOptionsDto } from 'src/dtos/library.dto';
-import {
-  DiskUsage,
-  IStorageRepository,
-  ImmichReadStream,
-  ImmichZipStream,
-  WatchEvents,
-} from 'src/interfaces/storage.interface';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { mimeTypes } from 'src/utils/mime-types';
 
+export interface WatchEvents {
+  onReady(): void;
+  onAdd(path: string): void;
+  onChange(path: string): void;
+  onUnlink(path: string): void;
+  onError(error: Error): void;
+}
+
+export interface ImmichReadStream {
+  stream: Readable;
+  type?: string;
+  length?: number;
+}
+
+export interface ImmichZipStream extends ImmichReadStream {
+  addFile: (inputPath: string, filename: string) => void;
+  finalize: () => Promise<void>;
+}
+
+export interface DiskUsage {
+  available: number;
+  free: number;
+  total: number;
+}
+
 @Injectable()
-export class StorageRepository implements IStorageRepository {
+export class StorageRepository {
   constructor(private logger: LoggingRepository) {
     this.logger.setContext(StorageRepository.name);
   }

server/src/repositories/tag.repository.ts

@@ -2,12 +2,13 @@ import { Injectable } from '@nestjs/common';
 import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { Chunked, ChunkedSet, DummyValue, GenerateSql } from 'src/decorators';
 import { TagEntity } from 'src/entities/tag.entity';
-import { AssetTagItem, ITagRepository } from 'src/interfaces/tag.interface';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { DataSource, In, Repository } from 'typeorm';
 
+export type AssetTagItem = { assetId: string; tagId: string };
+
 @Injectable()
-export class TagRepository implements ITagRepository {
+export class TagRepository {
   constructor(
     @InjectDataSource() private dataSource: DataSource,
     @InjectRepository(TagEntity) private repository: Repository<TagEntity>,

server/src/repositories/user.repository.ts

@@ -6,12 +6,6 @@ import { DummyValue, GenerateSql } from 'src/decorators';
 import { UserMetadata } from 'src/entities/user-metadata.entity';
 import { UserEntity, withMetadata } from 'src/entities/user.entity';
 import { UserStatus } from 'src/enum';
-import {
-  IUserRepository,
-  UserFindOptions,
-  UserListFilter,
-  UserStatsQueryResponse,
-} from 'src/interfaces/user.interface';
 import { asUuid } from 'src/utils/database';
 
 const columns = [
@@ -34,8 +28,27 @@ const columns = [
 
 type Upsert = Insertable<DbUserMetadata>;
 
+export interface UserListFilter {
+  withDeleted?: boolean;
+}
+
+export interface UserStatsQueryResponse {
+  userId: string;
+  userName: string;
+  photos: number;
+  videos: number;
+  usage: number;
+  usagePhotos: number;
+  usageVideos: number;
+  quotaSizeInBytes: number | null;
+}
+
+export interface UserFindOptions {
+  withDeleted?: boolean;
+}
+
 @Injectable()
-export class UserRepository implements IUserRepository {
+export class UserRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [DummyValue.UUID, DummyValue.BOOLEAN] })