refactor: domain repositories (#4403)

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

@@ -0,0 +1,29 @@
+export const IAccessRepository = 'IAccessRepository';
+
+export interface IAccessRepository {
+  asset: {
+    hasOwnerAccess(userId: string, assetId: string): Promise<boolean>;
+    hasAlbumAccess(userId: string, assetId: string): Promise<boolean>;
+    hasPartnerAccess(userId: string, assetId: string): Promise<boolean>;
+    hasSharedLinkAccess(sharedLinkId: string, assetId: string): Promise<boolean>;
+  };
+
+  album: {
+    hasOwnerAccess(userId: string, albumId: string): Promise<boolean>;
+    hasSharedAlbumAccess(userId: string, albumId: string): Promise<boolean>;
+    hasSharedLinkAccess(sharedLinkId: string, albumId: string): Promise<boolean>;
+  };
+
+  library: {
+    hasOwnerAccess(userId: string, libraryId: string): Promise<boolean>;
+    hasPartnerAccess(userId: string, partnerId: string): Promise<boolean>;
+  };
+
+  timeline: {
+    hasPartnerAccess(userId: string, partnerId: string): Promise<boolean>;
+  };
+
+  person: {
+    hasOwnerAccess(userId: string, personId: string): Promise<boolean>;
+  };
+}

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

@@ -0,0 +1,34 @@
+import { AlbumEntity } from '@app/infra/entities';
+
+export const IAlbumRepository = 'IAlbumRepository';
+
+export interface AlbumAssetCount {
+  albumId: string;
+  assetCount: number;
+}
+
+export interface AlbumInfoOptions {
+  withAssets: boolean;
+}
+
+export interface IAlbumRepository {
+  getById(id: string, options: AlbumInfoOptions): Promise<AlbumEntity | null>;
+  getByIds(ids: string[]): Promise<AlbumEntity[]>;
+  getByAssetId(ownerId: string, assetId: string): Promise<AlbumEntity[]>;
+  hasAsset(id: string, assetId: string): Promise<boolean>;
+  /** Remove an asset from _all_ albums */
+  removeAsset(id: string): Promise<void>;
+  getAssetCountForIds(ids: string[]): Promise<AlbumAssetCount[]>;
+  getInvalidThumbnail(): Promise<string[]>;
+  getOwned(ownerId: string): Promise<AlbumEntity[]>;
+  getShared(ownerId: string): Promise<AlbumEntity[]>;
+  getNotShared(ownerId: string): Promise<AlbumEntity[]>;
+  restoreAll(userId: string): Promise<void>;
+  softDeleteAll(userId: string): Promise<void>;
+  deleteAll(userId: string): Promise<void>;
+  getAll(): Promise<AlbumEntity[]>;
+  create(album: Partial<AlbumEntity>): Promise<AlbumEntity>;
+  update(album: Partial<AlbumEntity>): Promise<AlbumEntity>;
+  delete(album: AlbumEntity): Promise<void>;
+  updateThumbnails(): Promise<number | undefined>;
+}

server/src/domain/repositories/api-key.repository.ts

@@ -0,0 +1,16 @@
+import { APIKeyEntity } from '@app/infra/entities';
+
+export const IKeyRepository = 'IKeyRepository';
+
+export interface IKeyRepository {
+  create(dto: Partial<APIKeyEntity>): Promise<APIKeyEntity>;
+  update(userId: string, id: string, dto: Partial<APIKeyEntity>): Promise<APIKeyEntity>;
+  delete(userId: string, id: string): Promise<void>;
+  /**
+   * Includes the hashed `key` for verification
+   * @param id
+   */
+  getKey(hashedToken: string): Promise<APIKeyEntity | null>;
+  getById(userId: string, id: string): Promise<APIKeyEntity | null>;
+  getByUserId(userId: string): Promise<APIKeyEntity[]>;
+}

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

@@ -0,0 +1,126 @@
+import { AssetEntity, AssetType, ExifEntity } from '@app/infra/entities';
+import { Paginated, PaginationOptions } from '../domain.util';
+
+export type AssetStats = Record<AssetType, number>;
+
+export interface AssetStatsOptions {
+  isFavorite?: boolean;
+  isArchived?: boolean;
+  isTrashed?: boolean;
+}
+
+export interface AssetSearchOptions {
+  isVisible?: boolean;
+  trashedBefore?: Date;
+  type?: AssetType;
+  order?: 'ASC' | 'DESC';
+}
+
+export interface LivePhotoSearchOptions {
+  ownerId: string;
+  livePhotoCID: string;
+  otherAssetId: string;
+  type: AssetType;
+}
+
+export interface MapMarkerSearchOptions {
+  isArchived?: boolean;
+  isFavorite?: boolean;
+  fileCreatedBefore?: Date;
+  fileCreatedAfter?: Date;
+}
+
+export interface MapMarker {
+  id: string;
+  lat: number;
+  lon: number;
+}
+
+export enum WithoutProperty {
+  THUMBNAIL = 'thumbnail',
+  ENCODED_VIDEO = 'encoded-video',
+  EXIF = 'exif',
+  CLIP_ENCODING = 'clip-embedding',
+  OBJECT_TAGS = 'object-tags',
+  FACES = 'faces',
+  SIDECAR = 'sidecar',
+}
+
+export enum WithProperty {
+  SIDECAR = 'sidecar',
+  IS_OFFLINE = 'isOffline',
+}
+
+export enum TimeBucketSize {
+  DAY = 'DAY',
+  MONTH = 'MONTH',
+}
+
+export interface TimeBucketOptions {
+  size: TimeBucketSize;
+  isArchived?: boolean;
+  isFavorite?: boolean;
+  isTrashed?: boolean;
+  albumId?: string;
+  personId?: string;
+  userId?: string;
+}
+
+export interface TimeBucketItem {
+  timeBucket: string;
+  count: number;
+}
+
+export type AssetCreate = Pick<
+  AssetEntity,
+  | 'deviceAssetId'
+  | 'ownerId'
+  | 'libraryId'
+  | 'deviceId'
+  | 'type'
+  | 'originalPath'
+  | 'fileCreatedAt'
+  | 'localDateTime'
+  | 'fileModifiedAt'
+  | 'checksum'
+  | 'originalFileName'
+> &
+  Partial<AssetEntity>;
+
+export interface MonthDay {
+  day: number;
+  month: number;
+}
+
+export const IAssetRepository = 'IAssetRepository';
+
+export interface IAssetRepository {
+  create(asset: AssetCreate): Promise<AssetEntity>;
+  getByDate(ownerId: string, date: Date): Promise<AssetEntity[]>;
+  getByIds(ids: string[]): Promise<AssetEntity[]>;
+  getByDayOfYear(ownerId: string, monthDay: MonthDay): Promise<AssetEntity[]>;
+  getByChecksum(userId: string, checksum: Buffer): Promise<AssetEntity | null>;
+  getByAlbumId(pagination: PaginationOptions, albumId: string): Paginated<AssetEntity>;
+  getByUserId(pagination: PaginationOptions, userId: string, options?: AssetSearchOptions): Paginated<AssetEntity>;
+  getById(id: string): Promise<AssetEntity | null>;
+  getWithout(pagination: PaginationOptions, property: WithoutProperty): Paginated<AssetEntity>;
+  getWith(pagination: PaginationOptions, property: WithProperty, libraryId?: string): Paginated<AssetEntity>;
+  getRandom(userId: string, count: number): Promise<AssetEntity[]>;
+  getFirstAssetForAlbumId(albumId: string): Promise<AssetEntity | null>;
+  getLastUpdatedAssetForAlbumId(albumId: string): Promise<AssetEntity | null>;
+  getByLibraryId(libraryIds: string[]): Promise<AssetEntity[]>;
+  getByLibraryIdAndOriginalPath(libraryId: string, originalPath: string): Promise<AssetEntity | null>;
+  deleteAll(ownerId: string): Promise<void>;
+  getAll(pagination: PaginationOptions, options?: AssetSearchOptions): Paginated<AssetEntity>;
+  updateAll(ids: string[], options: Partial<AssetEntity>): Promise<void>;
+  save(asset: Pick<AssetEntity, 'id'> & Partial<AssetEntity>): Promise<AssetEntity>;
+  remove(asset: AssetEntity): Promise<void>;
+  softDeleteAll(ids: string[]): Promise<void>;
+  restoreAll(ids: string[]): Promise<void>;
+  findLivePhotoMatch(options: LivePhotoSearchOptions): Promise<AssetEntity | null>;
+  getMapMarkers(ownerId: string, options?: MapMarkerSearchOptions): Promise<MapMarker[]>;
+  getStatistics(ownerId: string, options: AssetStatsOptions): Promise<AssetStats>;
+  getTimeBuckets(options: TimeBucketOptions): Promise<TimeBucketItem[]>;
+  getByTimeBucket(timeBucket: string, options: TimeBucketOptions): Promise<AssetEntity[]>;
+  upsertExif(exif: Partial<ExifEntity>): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+import { AuditEntity, DatabaseAction, EntityType } from '@app/infra/entities';
+
+export const IAuditRepository = 'IAuditRepository';
+
+export interface AuditSearch {
+  action?: DatabaseAction;
+  entityType?: EntityType;
+  ownerId?: string;
+}
+
+export interface IAuditRepository {
+  getAfter(since: Date, options: AuditSearch): Promise<AuditEntity[]>;
+  removeBefore(before: Date): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+export const ICommunicationRepository = 'ICommunicationRepository';
+
+export enum CommunicationEvent {
+  UPLOAD_SUCCESS = 'on_upload_success',
+  ASSET_DELETE = 'on_asset_delete',
+  ASSET_TRASH = 'on_asset_trash',
+  PERSON_THUMBNAIL = 'on_person_thumbnail',
+  SERVER_VERSION = 'on_server_version',
+  CONFIG_UPDATE = 'on_config_update',
+}
+
+export interface ICommunicationRepository {
+  send(event: CommunicationEvent, userId: string, data: any): void;
+  broadcast(event: CommunicationEvent, data: any): void;
+}

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

@@ -0,0 +1,11 @@
+export const ICryptoRepository = 'ICryptoRepository';
+
+export interface ICryptoRepository {
+  randomBytes(size: number): Buffer;
+  randomUUID(): string;
+  hashFile(filePath: string | Buffer): Promise<Buffer>;
+  hashSha256(data: string): string;
+  hashSha1(data: string | Buffer): Buffer;
+  hashBcrypt(data: string | Buffer, saltOrRounds: string | number): Promise<string>;
+  compareBcrypt(data: string | Buffer, encrypted: string): boolean;
+}

server/src/domain/repositories/index.ts

@@ -0,0 +1,22 @@
+export * from './access.repository';
+export * from './album.repository';
+export * from './api-key.repository';
+export * from './asset.repository';
+export * from './audit.repository';
+export * from './communication.repository';
+export * from './crypto.repository';
+export * from './job.repository';
+export * from './library.repository';
+export * from './machine-learning.repository';
+export * from './media.repository';
+export * from './metadata.repository';
+export * from './partner.repository';
+export * from './person.repository';
+export * from './search.repository';
+export * from './shared-link.repository';
+export * from './smart-info.repository';
+export * from './storage.repository';
+export * from './system-config.repository';
+export * from './tag.repository';
+export * from './user-token.repository';
+export * from './user.repository';

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

@@ -0,0 +1,123 @@
+import { JobName, QueueName } from '../job/job.constants';
+
+import {
+  IAssetDeletionJob,
+  IAssetFaceJob,
+  IBaseJob,
+  IBulkEntityJob,
+  IDeleteFilesJob,
+  IEntityJob,
+  ILibraryFileJob,
+  ILibraryRefreshJob,
+  IOfflineLibraryFileJob,
+} from '../job/job.interface';
+
+export interface JobCounts {
+  active: number;
+  completed: number;
+  failed: number;
+  delayed: number;
+  waiting: number;
+  paused: number;
+}
+
+export interface QueueStatus {
+  isActive: boolean;
+  isPaused: boolean;
+}
+
+export type JobItem =
+  // Transcoding
+  | { name: JobName.QUEUE_VIDEO_CONVERSION; data: IBaseJob }
+  | { name: JobName.VIDEO_CONVERSION; data: IEntityJob }
+
+  // Thumbnails
+  | { name: JobName.QUEUE_GENERATE_THUMBNAILS; data: IBaseJob }
+  | { name: JobName.GENERATE_JPEG_THUMBNAIL; data: IEntityJob }
+  | { name: JobName.GENERATE_WEBP_THUMBNAIL; data: IEntityJob }
+  | { name: JobName.GENERATE_THUMBHASH_THUMBNAIL; data: IEntityJob }
+
+  // User Deletion
+  | { name: JobName.USER_DELETE_CHECK; data?: IBaseJob }
+  | { name: JobName.USER_DELETION; data: IEntityJob }
+
+  // Storage Template
+  | { name: JobName.STORAGE_TEMPLATE_MIGRATION; data?: IBaseJob }
+  | { name: JobName.STORAGE_TEMPLATE_MIGRATION_SINGLE; data: IEntityJob }
+  | { name: JobName.SYSTEM_CONFIG_CHANGE; data?: IBaseJob }
+
+  // Migration
+  | { name: JobName.QUEUE_MIGRATION; data?: IBaseJob }
+  | { name: JobName.MIGRATE_ASSET; data?: IEntityJob }
+  | { name: JobName.MIGRATE_PERSON; data?: IEntityJob }
+
+  // Metadata Extraction
+  | { name: JobName.QUEUE_METADATA_EXTRACTION; data: IBaseJob }
+  | { name: JobName.METADATA_EXTRACTION; data: IEntityJob }
+  | { name: JobName.LINK_LIVE_PHOTOS; data: IEntityJob }
+
+  // Sidecar Scanning
+  | { name: JobName.QUEUE_SIDECAR; data: IBaseJob }
+  | { name: JobName.SIDECAR_DISCOVERY; data: IEntityJob }
+  | { name: JobName.SIDECAR_SYNC; data: IEntityJob }
+
+  // Object Tagging
+  | { name: JobName.QUEUE_OBJECT_TAGGING; data: IBaseJob }
+  | { name: JobName.CLASSIFY_IMAGE; data: IEntityJob }
+
+  // Recognize Faces
+  | { name: JobName.QUEUE_RECOGNIZE_FACES; data: IBaseJob }
+  | { name: JobName.RECOGNIZE_FACES; data: IEntityJob }
+  | { name: JobName.GENERATE_PERSON_THUMBNAIL; data: IEntityJob }
+  | { name: JobName.PERSON_DELETE; data: IEntityJob }
+
+  // Clip Embedding
+  | { name: JobName.QUEUE_ENCODE_CLIP; data: IBaseJob }
+  | { name: JobName.ENCODE_CLIP; data: IEntityJob }
+
+  // Filesystem
+  | { name: JobName.DELETE_FILES; data: IDeleteFilesJob }
+
+  // Audit log cleanup
+  | { name: JobName.CLEAN_OLD_AUDIT_LOGS; data?: IBaseJob }
+
+  // Asset Deletion
+  | { name: JobName.PERSON_CLEANUP; data?: IBaseJob }
+  | { name: JobName.ASSET_DELETION; data: IAssetDeletionJob }
+  | { name: JobName.ASSET_DELETION_CHECK; data?: IBaseJob }
+
+  // Library Managment
+  | { name: JobName.LIBRARY_SCAN_ASSET; data: ILibraryFileJob }
+  | { name: JobName.LIBRARY_MARK_ASSET_OFFLINE; data: IOfflineLibraryFileJob }
+  | { name: JobName.LIBRARY_SCAN; data: ILibraryRefreshJob }
+  | { name: JobName.LIBRARY_REMOVE_OFFLINE; data: IEntityJob }
+  | { name: JobName.LIBRARY_DELETE; data: IEntityJob }
+  | { name: JobName.LIBRARY_QUEUE_SCAN_ALL; data: IBaseJob }
+  | { name: JobName.LIBRARY_QUEUE_CLEANUP; data: IBaseJob }
+
+  // Search
+  | { name: JobName.SEARCH_INDEX_ASSETS; data?: IBaseJob }
+  | { name: JobName.SEARCH_INDEX_ASSET; data: IBulkEntityJob }
+  | { name: JobName.SEARCH_INDEX_FACES; data?: IBaseJob }
+  | { name: JobName.SEARCH_INDEX_FACE; data: IAssetFaceJob }
+  | { name: JobName.SEARCH_INDEX_ALBUMS; data?: IBaseJob }
+  | { name: JobName.SEARCH_INDEX_ALBUM; data: IBulkEntityJob }
+  | { name: JobName.SEARCH_REMOVE_ASSET; data: IBulkEntityJob }
+  | { name: JobName.SEARCH_REMOVE_ALBUM; data: IBulkEntityJob }
+  | { name: JobName.SEARCH_REMOVE_FACE; data: IAssetFaceJob };
+
+export type JobHandler<T = any> = (data: T) => boolean | Promise<boolean>;
+export type JobItemHandler = (item: JobItem) => Promise<void>;
+
+export const IJobRepository = 'IJobRepository';
+
+export interface IJobRepository {
+  addHandler(queueName: QueueName, concurrency: number, handler: JobItemHandler): void;
+  setConcurrency(queueName: QueueName, concurrency: number): void;
+  queue(item: JobItem): Promise<void>;
+  pause(name: QueueName): Promise<void>;
+  resume(name: QueueName): Promise<void>;
+  empty(name: QueueName): Promise<void>;
+  getQueueStatus(name: QueueName): Promise<QueueStatus>;
+  getJobCounts(name: QueueName): Promise<JobCounts>;
+}

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

@@ -0,0 +1,22 @@
+import { LibraryEntity, LibraryType } from '@app/infra/entities';
+import { LibraryStatsResponseDto } from '../library/library.dto';
+
+export const ILibraryRepository = 'ILibraryRepository';
+
+export interface ILibraryRepository {
+  getCountForUser(ownerId: string): Promise<number>;
+  getAllByUserId(userId: string, type?: LibraryType): Promise<LibraryEntity[]>;
+  getAll(withDeleted?: boolean, type?: LibraryType): Promise<LibraryEntity[]>;
+  getAllDeleted(): Promise<LibraryEntity[]>;
+  get(id: string, withDeleted?: boolean): Promise<LibraryEntity | null>;
+  create(library: Partial<LibraryEntity>): Promise<LibraryEntity>;
+  delete(id: string): Promise<void>;
+  softDelete(id: string): Promise<void>;
+  getDefaultUploadLibrary(ownerId: string): Promise<LibraryEntity | null>;
+  getUploadLibraryCount(ownerId: string): Promise<number>;
+  update(library: Partial<LibraryEntity>): Promise<LibraryEntity>;
+  getStatistics(id: string): Promise<LibraryStatsResponseDto>;
+  getOnlineAssetPaths(id: string): Promise<string[]>;
+  getAssetIds(id: string, withDeleted?: boolean): Promise<string[]>;
+  existsByName(name: string, withDeleted?: boolean): Promise<boolean>;
+}

server/src/domain/repositories/machine-learning.repository.ts

@@ -0,0 +1,44 @@
+import { ClassificationConfig, CLIPConfig, RecognitionConfig } from '../smart-info/dto';
+
+export const IMachineLearningRepository = 'IMachineLearningRepository';
+
+export interface VisionModelInput {
+  imagePath: string;
+}
+
+export interface TextModelInput {
+  text: string;
+}
+
+export interface BoundingBox {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+
+export interface DetectFaceResult {
+  imageWidth: number;
+  imageHeight: number;
+  boundingBox: BoundingBox;
+  score: number;
+  embedding: number[];
+}
+
+export enum ModelType {
+  IMAGE_CLASSIFICATION = 'image-classification',
+  FACIAL_RECOGNITION = 'facial-recognition',
+  CLIP = 'clip',
+}
+
+export enum CLIPMode {
+  VISION = 'vision',
+  TEXT = 'text',
+}
+
+export interface IMachineLearningRepository {
+  classifyImage(url: string, input: VisionModelInput, config: ClassificationConfig): Promise<string[]>;
+  encodeImage(url: string, input: VisionModelInput, config: CLIPConfig): Promise<number[]>;
+  encodeText(url: string, input: TextModelInput, config: CLIPConfig): Promise<number[]>;
+  detectFaces(url: string, input: VisionModelInput, config: RecognitionConfig): Promise<DetectFaceResult[]>;
+}

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

@@ -0,0 +1,80 @@
+import { VideoCodec } from '@app/infra/entities';
+import { Writable } from 'stream';
+
+export const IMediaRepository = 'IMediaRepository';
+
+export interface ResizeOptions {
+  size: number;
+  format: 'webp' | 'jpeg';
+  colorspace: string;
+  quality: number;
+}
+
+export interface VideoStreamInfo {
+  index: number;
+  height: number;
+  width: number;
+  rotation: number;
+  codecName?: string;
+  codecType?: string;
+  frameCount: number;
+  isHDR: boolean;
+}
+
+export interface AudioStreamInfo {
+  index: number;
+  codecName?: string;
+  codecType?: string;
+  frameCount: number;
+}
+
+export interface VideoFormat {
+  formatName?: string;
+  formatLongName?: string;
+  duration: number;
+}
+
+export interface VideoInfo {
+  format: VideoFormat;
+  videoStreams: VideoStreamInfo[];
+  audioStreams: AudioStreamInfo[];
+}
+
+export interface CropOptions {
+  top: number;
+  left: number;
+  width: number;
+  height: number;
+}
+
+export interface TranscodeOptions {
+  inputOptions: string[];
+  outputOptions: string[];
+  twoPass: boolean;
+}
+
+export interface BitrateDistribution {
+  max: number;
+  target: number;
+  min: number;
+  unit: string;
+}
+
+export interface VideoCodecSWConfig {
+  getOptions(videoStream: VideoStreamInfo, audioStream: AudioStreamInfo): TranscodeOptions;
+}
+
+export interface VideoCodecHWConfig extends VideoCodecSWConfig {
+  getSupportedCodecs(): Array<VideoCodec>;
+}
+
+export interface IMediaRepository {
+  // image
+  resize(input: string | Buffer, output: string, options: ResizeOptions): Promise<void>;
+  crop(input: string, options: CropOptions): Promise<Buffer>;
+  generateThumbhash(imagePath: string): Promise<Buffer>;
+
+  // video
+  probe(input: string): Promise<VideoInfo>;
+  transcode(input: string, output: string | Writable, options: TranscodeOptions): Promise<void>;
+}

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

@@ -0,0 +1,32 @@
+import { Tags } from 'exiftool-vendored';
+import { InitOptions } from 'local-reverse-geocoder';
+
+export const IMetadataRepository = 'IMetadataRepository';
+
+export interface GeoPoint {
+  latitude: number;
+  longitude: number;
+}
+
+export interface ReverseGeocodeResult {
+  country: string | null;
+  state: string | null;
+  city: string | null;
+}
+
+export interface ImmichTags extends Omit<Tags, 'FocalLength'> {
+  ContentIdentifier?: string;
+  MotionPhoto?: number;
+  MotionPhotoVersion?: number;
+  MotionPhotoPresentationTimestampUs?: number;
+  MediaGroupUUID?: string;
+  ImagePixelDepth?: string;
+  FocalLength?: number;
+}
+
+export interface IMetadataRepository {
+  init(options: Partial<InitOptions>): Promise<void>;
+  reverseGeocode(point: GeoPoint): Promise<ReverseGeocodeResult>;
+  deleteCache(): Promise<void>;
+  getExifTags(path: string): Promise<ImmichTags | null>;
+}

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

@@ -0,0 +1,20 @@
+import { PartnerEntity } from '@app/infra/entities';
+
+export interface PartnerIds {
+  sharedById: string;
+  sharedWithId: string;
+}
+
+export enum PartnerDirection {
+  SharedBy = 'shared-by',
+  SharedWith = 'shared-with',
+}
+
+export const IPartnerRepository = 'IPartnerRepository';
+
+export interface IPartnerRepository {
+  getAll(userId: string): Promise<PartnerEntity[]>;
+  get(partner: PartnerIds): Promise<PartnerEntity | null>;
+  create(partner: PartnerIds): Promise<PartnerEntity>;
+  remove(entity: PartnerEntity): Promise<void>;
+}

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

@@ -0,0 +1,39 @@
+import { AssetEntity, AssetFaceEntity, PersonEntity } from '@app/infra/entities';
+export const IPersonRepository = 'IPersonRepository';
+
+export interface PersonSearchOptions {
+  minimumFaceCount: number;
+  withHidden: boolean;
+}
+
+export interface AssetFaceId {
+  assetId: string;
+  personId: string;
+}
+
+export interface UpdateFacesData {
+  oldPersonId: string;
+  newPersonId: string;
+}
+
+export interface IPersonRepository {
+  getAll(): Promise<PersonEntity[]>;
+  getAllWithoutThumbnail(): Promise<PersonEntity[]>;
+  getAllForUser(userId: string, options: PersonSearchOptions): Promise<PersonEntity[]>;
+  getAllWithoutFaces(): Promise<PersonEntity[]>;
+  getById(personId: string): Promise<PersonEntity | null>;
+
+  getAssets(personId: string): Promise<AssetEntity[]>;
+  prepareReassignFaces(data: UpdateFacesData): Promise<string[]>;
+  reassignFaces(data: UpdateFacesData): Promise<number>;
+
+  create(entity: Partial<PersonEntity>): Promise<PersonEntity>;
+  update(entity: Partial<PersonEntity>): Promise<PersonEntity>;
+  delete(entity: PersonEntity): Promise<PersonEntity | null>;
+  deleteAll(): Promise<number>;
+
+  getAllFaces(): Promise<AssetFaceEntity[]>;
+  getFacesByIds(ids: AssetFaceId[]): Promise<AssetFaceEntity[]>;
+  getRandomFace(personId: string): Promise<AssetFaceEntity | null>;
+  createFace(entity: Partial<AssetFaceEntity>): Promise<AssetFaceEntity>;
+}

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

@@ -0,0 +1,97 @@
+import { AlbumEntity, AssetEntity, AssetFaceEntity, AssetType } from '@app/infra/entities';
+
+export enum SearchCollection {
+  ASSETS = 'assets',
+  ALBUMS = 'albums',
+  FACES = 'faces',
+}
+
+export enum SearchStrategy {
+  CLIP = 'CLIP',
+  TEXT = 'TEXT',
+}
+
+export interface SearchFaceFilter {
+  ownerId: string;
+}
+
+export interface SearchFilter {
+  id?: string;
+  userId: string;
+  type?: AssetType;
+  isFavorite?: boolean;
+  isArchived?: boolean;
+  city?: string;
+  state?: string;
+  country?: string;
+  make?: string;
+  model?: string;
+  objects?: string[];
+  tags?: string[];
+  recent?: boolean;
+  motion?: boolean;
+  debug?: boolean;
+}
+
+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 interface SearchExploreItem<T> {
+  fieldName: string;
+  items: Array<{
+    value: string;
+    data: T;
+  }>;
+}
+
+export type OwnedFaceEntity = Pick<AssetFaceEntity, 'assetId' | 'personId' | 'embedding'> & {
+  /** computed as assetId|personId */
+  id: string;
+  /** copied from asset.id */
+  ownerId: string;
+};
+
+export type SearchCollectionIndexStatus = Record<SearchCollection, boolean>;
+
+export const ISearchRepository = 'ISearchRepository';
+
+export interface ISearchRepository {
+  setup(): Promise<void>;
+  checkMigrationStatus(): Promise<SearchCollectionIndexStatus>;
+
+  importAlbums(items: AlbumEntity[], done: boolean): Promise<void>;
+  importAssets(items: AssetEntity[], done: boolean): Promise<void>;
+  importFaces(items: OwnedFaceEntity[], done: boolean): Promise<void>;
+
+  deleteAlbums(ids: string[]): Promise<void>;
+  deleteAssets(ids: string[]): Promise<void>;
+  deleteFaces(ids: string[]): Promise<void>;
+  deleteAllFaces(): Promise<number>;
+  updateCLIPField(num_dim: number): Promise<void>;
+
+  searchAlbums(query: string, filters: SearchFilter): Promise<SearchResult<AlbumEntity>>;
+  searchAssets(query: string, filters: SearchFilter): Promise<SearchResult<AssetEntity>>;
+  vectorSearch(query: number[], filters: SearchFilter): Promise<SearchResult<AssetEntity>>;
+  searchFaces(query: number[], filters: SearchFaceFilter): Promise<SearchResult<AssetFaceEntity>>;
+
+  explore(userId: string): Promise<SearchExploreItem<AssetEntity>[]>;
+}

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

@@ -0,0 +1,12 @@
+import { SharedLinkEntity } from '@app/infra/entities';
+
+export const ISharedLinkRepository = 'ISharedLinkRepository';
+
+export interface ISharedLinkRepository {
+  getAll(userId: string): Promise<SharedLinkEntity[]>;
+  get(userId: string, id: string): Promise<SharedLinkEntity | null>;
+  getByKey(key: Buffer): Promise<SharedLinkEntity | null>;
+  create(entity: Partial<SharedLinkEntity>): Promise<SharedLinkEntity>;
+  update(entity: Partial<SharedLinkEntity>): Promise<SharedLinkEntity>;
+  remove(entity: SharedLinkEntity): Promise<void>;
+}

server/src/domain/repositories/smart-info.repository.ts

@@ -0,0 +1,7 @@
+import { SmartInfoEntity } from '@app/infra/entities';
+
+export const ISmartInfoRepository = 'ISmartInfoRepository';
+
+export interface ISmartInfoRepository {
+  upsert(info: Partial<SmartInfoEntity>): Promise<void>;
+}

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

@@ -0,0 +1,40 @@
+import { Stats } from 'fs';
+import { FileReadOptions } from 'fs/promises';
+import { Readable } from 'stream';
+import { CrawlOptionsDto } from '../library';
+
+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;
+}
+
+export const IStorageRepository = 'IStorageRepository';
+
+export interface IStorageRepository {
+  createZipStream(): ImmichZipStream;
+  createReadStream(filepath: string, mimeType?: string | null): Promise<ImmichReadStream>;
+  readFile(filepath: string, options?: FileReadOptions<Buffer>): Promise<Buffer>;
+  writeFile(filepath: string, buffer: Buffer): Promise<void>;
+  unlink(filepath: string): Promise<void>;
+  unlinkDir(folder: string, options?: { recursive?: boolean; force?: boolean }): Promise<void>;
+  removeEmptyDirs(folder: string, self?: boolean): Promise<void>;
+  moveFile(source: string, target: string): Promise<void>;
+  checkFileExists(filepath: string, mode?: number): Promise<boolean>;
+  mkdirSync(filepath: string): void;
+  checkDiskUsage(folder: string): Promise<DiskUsage>;
+  readdir(folder: string): Promise<string[]>;
+  stat(filepath: string): Promise<Stats>;
+  crawl(crawlOptions: CrawlOptionsDto): Promise<string[]>;
+}

server/src/domain/repositories/system-config.repository.ts

@@ -0,0 +1,10 @@
+import { SystemConfigEntity } from '@app/infra/entities';
+
+export const ISystemConfigRepository = 'ISystemConfigRepository';
+
+export interface ISystemConfigRepository {
+  load(): Promise<SystemConfigEntity[]>;
+  readFile(filename: string): Promise<Buffer>;
+  saveAll(items: SystemConfigEntity[]): Promise<SystemConfigEntity[]>;
+  deleteKeys(keys: string[]): Promise<void>;
+}

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

@@ -0,0 +1,16 @@
+import { AssetEntity, TagEntity } from '@app/infra/entities';
+
+export const ITagRepository = 'ITagRepository';
+
+export interface ITagRepository {
+  getById(userId: string, tagId: string): Promise<TagEntity | null>;
+  getAll(userId: string): Promise<TagEntity[]>;
+  create(tag: Partial<TagEntity>): Promise<TagEntity>;
+  update(tag: Partial<TagEntity>): Promise<TagEntity>;
+  remove(tag: TagEntity): Promise<void>;
+  hasName(userId: string, name: string): Promise<boolean>;
+  hasAsset(userId: string, tagId: string, assetId: string): Promise<boolean>;
+  getAssets(userId: string, tagId: string): Promise<AssetEntity[]>;
+  addAssets(userId: string, tagId: string, assetIds: string[]): Promise<void>;
+  removeAssets(userId: string, tagId: string, assetIds: string[]): Promise<void>;
+}

server/src/domain/repositories/user-token.repository.ts

@@ -0,0 +1,11 @@
+import { UserTokenEntity } from '@app/infra/entities';
+
+export const IUserTokenRepository = 'IUserTokenRepository';
+
+export interface IUserTokenRepository {
+  create(dto: Partial<UserTokenEntity>): Promise<UserTokenEntity>;
+  save(dto: Partial<UserTokenEntity>): Promise<UserTokenEntity>;
+  delete(userId: string, id: string): Promise<void>;
+  getByToken(token: string): Promise<UserTokenEntity | null>;
+  getAll(userId: string): Promise<UserTokenEntity[]>;
+}

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

@@ -0,0 +1,31 @@
+import { UserEntity } from '@app/infra/entities';
+
+export interface UserListFilter {
+  withDeleted?: boolean;
+}
+
+export interface UserStatsQueryResponse {
+  userId: string;
+  userFirstName: string;
+  userLastName: string;
+  photos: number;
+  videos: number;
+  usage: number;
+}
+
+export const IUserRepository = 'IUserRepository';
+
+export interface IUserRepository {
+  get(id: string, withDeleted?: boolean): Promise<UserEntity | null>;
+  getAdmin(): Promise<UserEntity | null>;
+  getByEmail(email: string, withPassword?: boolean): Promise<UserEntity | null>;
+  getByStorageLabel(storageLabel: string): Promise<UserEntity | null>;
+  getByOAuthId(oauthId: string): Promise<UserEntity | null>;
+  getDeletedUsers(): Promise<UserEntity[]>;
+  getList(filter?: UserListFilter): Promise<UserEntity[]>;
+  getUserStats(): Promise<UserStatsQueryResponse[]>;
+  create(user: Partial<UserEntity>): Promise<UserEntity>;
+  update(id: string, user: Partial<UserEntity>): Promise<UserEntity>;
+  delete(user: UserEntity, hard?: boolean): Promise<UserEntity>;
+  restore(user: UserEntity): Promise<UserEntity>;
+}