chore(server): move domain interfaces (#8124)

move domain interfaces

server/src/interfaces/access.repository.ts

@@ -0,0 +1,43 @@
+export const IAccessRepository = 'IAccessRepository';
+
+export interface IAccessRepository {
+  activity: {
+    checkOwnerAccess(userId: string, activityIds: Set<string>): Promise<Set<string>>;
+    checkAlbumOwnerAccess(userId: string, activityIds: Set<string>): Promise<Set<string>>;
+    checkCreateAccess(userId: string, albumIds: Set<string>): Promise<Set<string>>;
+  };
+
+  asset: {
+    checkOwnerAccess(userId: string, assetIds: Set<string>): Promise<Set<string>>;
+    checkAlbumAccess(userId: string, assetIds: Set<string>): Promise<Set<string>>;
+    checkPartnerAccess(userId: string, assetIds: Set<string>): Promise<Set<string>>;
+    checkSharedLinkAccess(sharedLinkId: string, assetIds: Set<string>): Promise<Set<string>>;
+  };
+
+  authDevice: {
+    checkOwnerAccess(userId: string, deviceIds: Set<string>): Promise<Set<string>>;
+  };
+
+  album: {
+    checkOwnerAccess(userId: string, albumIds: Set<string>): Promise<Set<string>>;
+    checkSharedAlbumAccess(userId: string, albumIds: Set<string>): Promise<Set<string>>;
+    checkSharedLinkAccess(sharedLinkId: string, albumIds: Set<string>): Promise<Set<string>>;
+  };
+
+  library: {
+    checkOwnerAccess(userId: string, libraryIds: Set<string>): Promise<Set<string>>;
+  };
+
+  timeline: {
+    checkPartnerAccess(userId: string, partnerIds: Set<string>): Promise<Set<string>>;
+  };
+
+  person: {
+    checkFaceOwnerAccess(userId: string, assetFaceId: Set<string>): Promise<Set<string>>;
+    checkOwnerAccess(userId: string, personIds: Set<string>): Promise<Set<string>>;
+  };
+
+  partner: {
+    checkUpdateAccess(userId: string, partnerIds: Set<string>): Promise<Set<string>>;
+  };
+}

server/src/interfaces/activity.repository.ts

@@ -0,0 +1,11 @@
+import { ActivityEntity } from 'src/infra/entities/activity.entity';
+import { ActivitySearch } from 'src/infra/repositories/activity.repository';
+
+export const IActivityRepository = 'IActivityRepository';
+
+export interface IActivityRepository {
+  search(options: ActivitySearch): Promise<ActivityEntity[]>;
+  create(activity: Partial<ActivityEntity>): Promise<ActivityEntity>;
+  delete(id: string): Promise<void>;
+  getStatistics(assetId: string | undefined, albumId: string): Promise<number>;
+}

server/src/interfaces/album.repository.ts

@@ -0,0 +1,48 @@
+import { AlbumEntity } from 'src/infra/entities/album.entity';
+
+export const IAlbumRepository = 'IAlbumRepository';
+
+export interface AlbumAssetCount {
+  albumId: string;
+  assetCount: number;
+  startDate: Date | undefined;
+  endDate: Date | undefined;
+}
+
+export interface AlbumInfoOptions {
+  withAssets: boolean;
+}
+
+export interface AlbumAsset {
+  albumId: string;
+  assetId: string;
+}
+
+export interface AlbumAssets {
+  albumId: string;
+  assetIds: string[];
+}
+
+export interface IAlbumRepository {
+  getById(id: string, options: AlbumInfoOptions): Promise<AlbumEntity | null>;
+  getByIds(ids: string[]): Promise<AlbumEntity[]>;
+  getByAssetId(ownerId: string, assetId: string): Promise<AlbumEntity[]>;
+  addAssets(assets: AlbumAssets): Promise<void>;
+  getAssetIds(albumId: string, assetIds?: string[]): Promise<Set<string>>;
+  hasAsset(asset: AlbumAsset): Promise<boolean>;
+  removeAsset(assetId: string): Promise<void>;
+  removeAssets(albumId: string, assetIds: string[]): Promise<void>;
+  getMetadataForIds(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/interfaces/api-key.repository.ts

@@ -0,0 +1,16 @@
+import { APIKeyEntity } from 'src/infra/entities/api-key.entity';
+
+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/interfaces/asset-stack.repository.ts

@@ -0,0 +1,10 @@
+import { AssetStackEntity } from 'src/infra/entities/asset-stack.entity';
+
+export const IAssetStackRepository = 'IAssetStackRepository';
+
+export interface IAssetStackRepository {
+  create(assetStack: Partial<AssetStackEntity>): Promise<AssetStackEntity>;
+  update(asset: Pick<AssetStackEntity, 'id'> & Partial<AssetStackEntity>): Promise<AssetStackEntity>;
+  delete(id: string): Promise<void>;
+  getById(id: string): Promise<AssetStackEntity | null>;
+}

server/src/interfaces/asset.repository.ts

@@ -0,0 +1,179 @@
+import { AssetOrder } from 'src/infra/entities/album.entity';
+import { AssetJobStatusEntity } from 'src/infra/entities/asset-job-status.entity';
+import { AssetEntity, AssetType } from 'src/infra/entities/asset.entity';
+import { ExifEntity } from 'src/infra/entities/exif.entity';
+import { ReverseGeocodeResult } from 'src/interfaces/metadata.repository';
+import { AssetSearchOptions, SearchExploreItem } from 'src/interfaces/search.repository';
+import { Paginated, PaginationOptions } from 'src/utils';
+import { FindOptionsRelations, FindOptionsSelect } from 'typeorm';
+
+export type AssetStats = Record<AssetType, number>;
+
+export interface AssetStatsOptions {
+  isFavorite?: boolean;
+  isArchived?: boolean;
+  isTrashed?: boolean;
+}
+
+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 extends ReverseGeocodeResult {
+  id: string;
+  lat: number;
+  lon: number;
+}
+
+export enum WithoutProperty {
+  THUMBNAIL = 'thumbnail',
+  ENCODED_VIDEO = 'encoded-video',
+  EXIF = 'exif',
+  SMART_SEARCH = 'smart-search',
+  OBJECT_TAGS = 'object-tags',
+  FACES = 'faces',
+  PERSON = 'person',
+  SIDECAR = 'sidecar',
+}
+
+export enum WithProperty {
+  SIDECAR = 'sidecar',
+  IS_OFFLINE = 'isOffline',
+}
+
+export enum TimeBucketSize {
+  DAY = 'DAY',
+  MONTH = 'MONTH',
+}
+
+export interface AssetBuilderOptions {
+  isArchived?: boolean;
+  isFavorite?: boolean;
+  isTrashed?: boolean;
+  albumId?: string;
+  personId?: string;
+  userIds?: string[];
+  withStacked?: boolean;
+  exifInfo?: boolean;
+  assetType?: AssetType;
+}
+
+export interface TimeBucketOptions extends AssetBuilderOptions {
+  size: TimeBucketSize;
+  order?: AssetOrder;
+}
+
+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 type AssetWithoutRelations = Omit<
+  AssetEntity,
+  | 'livePhotoVideo'
+  | 'stack'
+  | 'albums'
+  | 'faces'
+  | 'owner'
+  | 'library'
+  | 'exifInfo'
+  | 'sharedLinks'
+  | 'smartInfo'
+  | 'smartSearch'
+  | 'tags'
+>;
+
+export type AssetUpdateOptions = Pick<AssetWithoutRelations, 'id'> & Partial<AssetWithoutRelations>;
+
+export type AssetUpdateAllOptions = Omit<Partial<AssetWithoutRelations>, 'id'>;
+
+export interface MonthDay {
+  day: number;
+  month: number;
+}
+
+export interface AssetExploreFieldOptions {
+  maxFields: number;
+  minAssetsPerField: number;
+}
+
+export interface AssetExploreOptions extends AssetExploreFieldOptions {
+  relation: keyof AssetEntity;
+  relatedField: string;
+  unnest?: boolean;
+}
+
+export interface MetadataSearchOptions {
+  numResults: number;
+}
+
+export type AssetPathEntity = Pick<AssetEntity, 'id' | 'originalPath' | 'isOffline'>;
+
+export const IAssetRepository = 'IAssetRepository';
+
+export interface IAssetRepository {
+  create(asset: AssetCreate): Promise<AssetEntity>;
+  getByDate(ownerId: string, date: Date): Promise<AssetEntity[]>;
+  getByIds(
+    ids: string[],
+    relations?: FindOptionsRelations<AssetEntity>,
+    select?: FindOptionsSelect<AssetEntity>,
+  ): Promise<AssetEntity[]>;
+  getByIdsWithAllRelations(ids: string[]): Promise<AssetEntity[]>;
+  getByDayOfYear(ownerIds: 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, relations?: FindOptionsRelations<AssetEntity>): 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>;
+  getLibraryAssetPaths(pagination: PaginationOptions, libraryId: string): Paginated<AssetPathEntity>;
+  getByLibraryIdAndOriginalPath(libraryId: string, originalPath: string): Promise<AssetEntity | null>;
+  deleteAll(ownerId: string): Promise<void>;
+  getAll(pagination: PaginationOptions, options?: AssetSearchOptions): Paginated<AssetEntity>;
+  getAllByDeviceId(userId: string, deviceId: string): Promise<string[]>;
+  updateAll(ids: string[], options: Partial<AssetUpdateAllOptions>): Promise<void>;
+  update(asset: AssetUpdateOptions): Promise<void>;
+  remove(asset: AssetEntity): Promise<void>;
+  softDeleteAll(ids: string[]): Promise<void>;
+  restoreAll(ids: string[]): Promise<void>;
+  findLivePhotoMatch(options: LivePhotoSearchOptions): Promise<AssetEntity | null>;
+  getMapMarkers(ownerIds: string[], options?: MapMarkerSearchOptions): Promise<MapMarker[]>;
+  getStatistics(ownerId: string, options: AssetStatsOptions): Promise<AssetStats>;
+  getTimeBuckets(options: TimeBucketOptions): Promise<TimeBucketItem[]>;
+  getTimeBucket(timeBucket: string, options: TimeBucketOptions): Promise<AssetEntity[]>;
+  upsertExif(exif: Partial<ExifEntity>): Promise<void>;
+  upsertJobStatus(jobStatus: Partial<AssetJobStatusEntity>): Promise<void>;
+  getAssetIdByCity(userId: string, options: AssetExploreFieldOptions): Promise<SearchExploreItem<string>>;
+  getAssetIdByTag(userId: string, options: AssetExploreFieldOptions): Promise<SearchExploreItem<string>>;
+  searchMetadata(query: string, userIds: string[], options: MetadataSearchOptions): Promise<AssetEntity[]>;
+}

server/src/interfaces/audit.repository.ts

@@ -0,0 +1,14 @@
+import { AuditEntity, DatabaseAction, EntityType } from 'src/infra/entities/audit.entity';
+
+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/interfaces/communication.repository.ts

@@ -0,0 +1,60 @@
+import { AssetResponseDto } from 'src/domain/asset/response-dto/asset-response.dto';
+import { ReleaseNotification, ServerVersionResponseDto } from 'src/domain/server-info/server-info.dto';
+import { SystemConfig } from 'src/infra/entities/system-config.entity';
+
+export const ICommunicationRepository = 'ICommunicationRepository';
+
+export enum ClientEvent {
+  UPLOAD_SUCCESS = 'on_upload_success',
+  USER_DELETE = 'on_user_delete',
+  ASSET_DELETE = 'on_asset_delete',
+  ASSET_TRASH = 'on_asset_trash',
+  ASSET_UPDATE = 'on_asset_update',
+  ASSET_HIDDEN = 'on_asset_hidden',
+  ASSET_RESTORE = 'on_asset_restore',
+  ASSET_STACK_UPDATE = 'on_asset_stack_update',
+  PERSON_THUMBNAIL = 'on_person_thumbnail',
+  SERVER_VERSION = 'on_server_version',
+  CONFIG_UPDATE = 'on_config_update',
+  NEW_RELEASE = 'on_new_release',
+}
+
+export enum ServerEvent {
+  CONFIG_UPDATE = 'config:update',
+}
+
+export enum InternalEvent {
+  VALIDATE_CONFIG = 'validate_config',
+}
+
+export interface InternalEventMap {
+  [InternalEvent.VALIDATE_CONFIG]: { newConfig: SystemConfig; oldConfig: SystemConfig };
+}
+
+export interface ClientEventMap {
+  [ClientEvent.UPLOAD_SUCCESS]: AssetResponseDto;
+  [ClientEvent.USER_DELETE]: string;
+  [ClientEvent.ASSET_DELETE]: string;
+  [ClientEvent.ASSET_TRASH]: string[];
+  [ClientEvent.ASSET_UPDATE]: AssetResponseDto;
+  [ClientEvent.ASSET_HIDDEN]: string;
+  [ClientEvent.ASSET_RESTORE]: string[];
+  [ClientEvent.ASSET_STACK_UPDATE]: string[];
+  [ClientEvent.PERSON_THUMBNAIL]: string;
+  [ClientEvent.SERVER_VERSION]: ServerVersionResponseDto;
+  [ClientEvent.CONFIG_UPDATE]: Record<string, never>;
+  [ClientEvent.NEW_RELEASE]: ReleaseNotification;
+}
+
+export type OnConnectCallback = (userId: string) => void | Promise<void>;
+export type OnServerEventCallback = () => Promise<void>;
+
+export interface ICommunicationRepository {
+  send<E extends keyof ClientEventMap>(event: E, userId: string, data: ClientEventMap[E]): void;
+  broadcast<E extends keyof ClientEventMap>(event: E, data: ClientEventMap[E]): void;
+  on(event: 'connect', callback: OnConnectCallback): void;
+  on(event: ServerEvent, callback: OnServerEventCallback): void;
+  sendServerEvent(event: ServerEvent): void;
+  emit<E extends keyof InternalEventMap>(event: E, data: InternalEventMap[E]): boolean;
+  emitAsync<E extends keyof InternalEventMap>(event: E, data: InternalEventMap[E]): Promise<any>;
+}

server/src/interfaces/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/interfaces/database.repository.ts

@@ -0,0 +1,53 @@
+import { Version } from 'src/domain/domain.constant';
+
+export enum DatabaseExtension {
+  CUBE = 'cube',
+  EARTH_DISTANCE = 'earthdistance',
+  VECTOR = 'vector',
+  VECTORS = 'vectors',
+}
+
+export type VectorExtension = DatabaseExtension.VECTOR | DatabaseExtension.VECTORS;
+
+export enum VectorIndex {
+  CLIP = 'clip_index',
+  FACE = 'face_index',
+}
+
+export enum DatabaseLock {
+  GeodataImport = 100,
+  Migrations = 200,
+  StorageTemplateMigration = 420,
+  CLIPDimSize = 512,
+  LibraryWatch = 1337,
+}
+
+export const extName: Record<DatabaseExtension, string> = {
+  cube: 'cube',
+  earthdistance: 'earthdistance',
+  vector: 'pgvector',
+  vectors: 'pgvecto.rs',
+} as const;
+
+export interface VectorUpdateResult {
+  restartRequired: boolean;
+}
+
+export const IDatabaseRepository = 'IDatabaseRepository';
+
+export interface IDatabaseRepository {
+  getExtensionVersion(extensionName: string): Promise<Version | null>;
+  getAvailableExtensionVersion(extension: DatabaseExtension): Promise<Version | null>;
+  getPreferredVectorExtension(): VectorExtension;
+  getPostgresVersion(): Promise<Version>;
+  createExtension(extension: DatabaseExtension): Promise<void>;
+  updateExtension(extension: DatabaseExtension, version?: Version): Promise<void>;
+  updateVectorExtension(extension: VectorExtension, version?: Version): Promise<VectorUpdateResult>;
+  reindex(index: VectorIndex): Promise<void>;
+  shouldReindex(name: VectorIndex): Promise<boolean>;
+  runMigrations(options?: { transaction?: 'all' | 'none' | 'each' }): Promise<void>;
+  withLock<R>(lock: DatabaseLock, callback: () => Promise<R>): Promise<R>;
+  tryLock(lock: DatabaseLock): Promise<boolean>;
+  isBusy(lock: DatabaseLock): boolean;
+  wait(lock: DatabaseLock): Promise<void>;
+}

server/src/interfaces/job.repository.ts

@@ -0,0 +1,122 @@
+import { JobName, QueueName } from 'src/domain/job/job.constants';
+import {
+  IAssetDeletionJob,
+  IBaseJob,
+  IDeferrableJob,
+  IDeleteFilesJob,
+  IEntityJob,
+  ILibraryFileJob,
+  ILibraryRefreshJob,
+  ISidecarWriteJob,
+} from 'src/domain/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 enum QueueCleanType {
+  FAILED = 'failed',
+}
+
+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
+  | { name: JobName.USER_DELETE_CHECK; data?: IBaseJob }
+  | { name: JobName.USER_DELETION; data: IEntityJob }
+  | { name: JobName.USER_SYNC_USAGE; data?: IBaseJob }
+
+  // Storage Template
+  | { name: JobName.STORAGE_TEMPLATE_MIGRATION; data?: IBaseJob }
+  | { name: JobName.STORAGE_TEMPLATE_MIGRATION_SINGLE; data: IEntityJob }
+
+  // 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 }
+  | { name: JobName.SIDECAR_WRITE; data: ISidecarWriteJob }
+
+  // Facial Recognition
+  | { name: JobName.QUEUE_FACE_DETECTION; data: IBaseJob }
+  | { name: JobName.FACE_DETECTION; data: IEntityJob }
+  | { name: JobName.QUEUE_FACIAL_RECOGNITION; data: IBaseJob }
+  | { name: JobName.FACIAL_RECOGNITION; data: IDeferrableJob }
+  | { name: JobName.GENERATE_PERSON_THUMBNAIL; data: IEntityJob }
+
+  // Smart Search
+  | { name: JobName.QUEUE_SMART_SEARCH; data: IBaseJob }
+  | { name: JobName.SMART_SEARCH; 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 Management
+  | { name: JobName.LIBRARY_SCAN_ASSET; data: ILibraryFileJob }
+  | { 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 };
+
+export enum JobStatus {
+  SUCCESS = 'success',
+  FAILED = 'failed',
+  SKIPPED = 'skipped',
+}
+
+export type JobHandler<T = any> = (data: T) => Promise<JobStatus>;
+export type JobItemHandler = (item: JobItem) => Promise<void>;
+
+export const IJobRepository = 'IJobRepository';
+
+export interface IJobRepository {
+  addHandler(queueName: QueueName, concurrency: number, handler: JobItemHandler): void;
+  addCronJob(name: string, expression: string, onTick: () => void, start?: boolean): void;
+  updateCronJob(name: string, expression?: string, start?: boolean): void;
+  deleteCronJob(name: string): void;
+  setConcurrency(queueName: QueueName, concurrency: number): void;
+  queue(item: JobItem): Promise<void>;
+  queueAll(items: JobItem[]): Promise<void>;
+  pause(name: QueueName): Promise<void>;
+  resume(name: QueueName): Promise<void>;
+  empty(name: QueueName): Promise<void>;
+  clear(name: QueueName, type: QueueCleanType): Promise<string[]>;
+  getQueueStatus(name: QueueName): Promise<QueueStatus>;
+  getJobCounts(name: QueueName): Promise<JobCounts>;
+  waitForQueueCompletion(...queues: QueueName[]): Promise<void>;
+}

server/src/interfaces/library.repository.ts

@@ -0,0 +1,19 @@
+import { LibraryStatsResponseDto } from 'src/domain/library/library.dto';
+import { LibraryEntity, LibraryType } from 'src/infra/entities/library.entity';
+
+export const ILibraryRepository = 'ILibraryRepository';
+
+export interface ILibraryRepository {
+  getCountForUser(ownerId: string): Promise<number>;
+  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>;
+  getAssetIds(id: string, withDeleted?: boolean): Promise<string[]>;
+}

server/src/interfaces/machine-learning.repository.ts

@@ -0,0 +1,42 @@
+import { CLIPConfig, RecognitionConfig } from 'src/domain/smart-info/dto/model-config.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 {
+  FACIAL_RECOGNITION = 'facial-recognition',
+  CLIP = 'clip',
+}
+
+export enum CLIPMode {
+  VISION = 'vision',
+  TEXT = 'text',
+}
+
+export interface IMachineLearningRepository {
+  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/interfaces/media.repository.ts

@@ -0,0 +1,80 @@
+import { Writable } from 'node:stream';
+import { TranscodeTarget, VideoCodec } from 'src/infra/entities/system-config.entity';
+
+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;
+  frameCount: number;
+  isHDR: boolean;
+  bitrate: number;
+}
+
+export interface AudioStreamInfo {
+  index: number;
+  codecName?: string;
+  frameCount: number;
+}
+
+export interface VideoFormat {
+  formatName?: string;
+  formatLongName?: string;
+  duration: number;
+  bitrate: 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(target: TranscodeTarget, 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/interfaces/metadata.repository.ts

@@ -0,0 +1,47 @@
+import { BinaryField, Tags } from 'exiftool-vendored';
+
+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 ExifDuration {
+  Value: number;
+  Scale?: number;
+}
+
+export interface ImmichTags extends Omit<Tags, 'FocalLength' | 'Duration'> {
+  ContentIdentifier?: string;
+  MotionPhoto?: number;
+  MotionPhotoVersion?: number;
+  MotionPhotoPresentationTimestampUs?: number;
+  MediaGroupUUID?: string;
+  ImagePixelDepth?: string;
+  FocalLength?: number;
+  Duration?: number | string | ExifDuration;
+  EmbeddedVideoType?: string;
+  EmbeddedVideoFile?: BinaryField;
+  MotionPhotoVideo?: BinaryField;
+}
+
+export interface IMetadataRepository {
+  init(): Promise<void>;
+  teardown(): Promise<void>;
+  reverseGeocode(point: GeoPoint): Promise<ReverseGeocodeResult | null>;
+  readTags(path: string): Promise<ImmichTags | null>;
+  writeTags(path: string, tags: Partial<Tags>): Promise<void>;
+  extractBinaryTag(tagName: string, path: string): Promise<Buffer>;
+  getCountries(userId: string): Promise<string[]>;
+  getStates(userId: string, country?: string): Promise<string[]>;
+  getCities(userId: string, country?: string, state?: string): Promise<string[]>;
+  getCameraMakes(userId: string, model?: string): Promise<string[]>;
+  getCameraModels(userId: string, make?: string): Promise<string[]>;
+}

server/src/interfaces/move.repository.ts

@@ -0,0 +1,12 @@
+import { MoveEntity, PathType } from 'src/infra/entities/move.entity';
+
+export const IMoveRepository = 'IMoveRepository';
+
+export type MoveCreate = Pick<MoveEntity, 'oldPath' | 'newPath' | 'entityId' | 'pathType'> & Partial<MoveEntity>;
+
+export interface IMoveRepository {
+  create(entity: MoveCreate): Promise<MoveEntity>;
+  getByEntity(entityId: string, pathType: PathType): Promise<MoveEntity | null>;
+  update(entity: Partial<MoveEntity>): Promise<MoveEntity>;
+  delete(move: MoveEntity): Promise<MoveEntity>;
+}

server/src/interfaces/partner.repository.ts

@@ -0,0 +1,21 @@
+import { PartnerEntity } from 'src/infra/entities/partner.entity';
+
+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>;
+  update(entity: Partial<PartnerEntity>): Promise<PartnerEntity>;
+}

server/src/interfaces/person.repository.ts

@@ -0,0 +1,67 @@
+import { AssetFaceEntity } from 'src/infra/entities/asset-face.entity';
+import { AssetEntity } from 'src/infra/entities/asset.entity';
+import { PersonEntity } from 'src/infra/entities/person.entity';
+import { Paginated, PaginationOptions } from 'src/utils';
+import { FindManyOptions, FindOptionsRelations, FindOptionsSelect } from 'typeorm';
+
+export const IPersonRepository = 'IPersonRepository';
+
+export interface PersonSearchOptions {
+  minimumFaceCount: number;
+  withHidden: boolean;
+}
+
+export interface PersonNameSearchOptions {
+  withHidden?: boolean;
+}
+
+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 IPersonRepository {
+  getAll(pagination: PaginationOptions, options?: FindManyOptions<PersonEntity>): Paginated<PersonEntity>;
+  getAllForUser(userId: string, options: PersonSearchOptions): Promise<PersonEntity[]>;
+  getAllWithoutFaces(): Promise<PersonEntity[]>;
+  getById(personId: string): Promise<PersonEntity | null>;
+  getByName(userId: string, personName: string, options: PersonNameSearchOptions): Promise<PersonEntity[]>;
+
+  getAssets(personId: string): Promise<AssetEntity[]>;
+
+  create(entity: Partial<PersonEntity>): Promise<PersonEntity>;
+  createFaces(entities: Partial<AssetFaceEntity>[]): Promise<string[]>;
+  delete(entities: PersonEntity[]): Promise<void>;
+  deleteAll(): Promise<void>;
+  deleteAllFaces(): Promise<void>;
+  getAllFaces(pagination: PaginationOptions, options?: FindManyOptions<AssetFaceEntity>): Paginated<AssetFaceEntity>;
+  getFaceById(id: string): Promise<AssetFaceEntity>;
+  getFaceByIdWithAssets(
+    id: string,
+    relations?: FindOptionsRelations<AssetFaceEntity>,
+    select?: FindOptionsSelect<AssetFaceEntity>,
+  ): Promise<AssetFaceEntity | null>;
+  getFaces(assetId: string): Promise<AssetFaceEntity[]>;
+  getFacesByIds(ids: AssetFaceId[]): Promise<AssetFaceEntity[]>;
+  getRandomFace(personId: string): Promise<AssetFaceEntity | null>;
+  getStatistics(personId: string): Promise<PersonStatistics>;
+  reassignFace(assetFaceId: string, newPersonId: string): Promise<number>;
+  getNumberOfPeople(userId: string): Promise<PeopleStatistics>;
+  reassignFaces(data: UpdateFacesData): Promise<number>;
+  update(entity: Partial<PersonEntity>): Promise<PersonEntity>;
+}

server/src/interfaces/search.repository.ts

@@ -0,0 +1,195 @@
+import { AssetFaceEntity } from 'src/infra/entities/asset-face.entity';
+import { AssetEntity, AssetType } from 'src/infra/entities/asset.entity';
+import { GeodataPlacesEntity } from 'src/infra/entities/geodata-places.entity';
+import { SmartInfoEntity } from 'src/infra/entities/smart-info.entity';
+import { Paginated } from 'src/utils';
+
+export const ISearchRepository = 'ISearchRepository';
+
+export enum SearchStrategy {
+  SMART = 'SMART',
+  TEXT = 'TEXT',
+}
+
+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 type SearchExploreItemSet<T> = Array<{
+  value: string;
+  data: T;
+}>;
+
+export interface SearchExploreItem<T> {
+  fieldName: string;
+  items: SearchExploreItemSet<T>;
+}
+
+export type Embedding = number[];
+
+export interface SearchAssetIDOptions {
+  checksum?: Buffer;
+  deviceAssetId?: string;
+  id?: string;
+}
+
+export interface SearchUserIdOptions {
+  deviceId?: string;
+  libraryId?: string;
+  userIds?: string[];
+}
+
+export type SearchIdOptions = SearchAssetIDOptions & SearchUserIdOptions;
+
+export interface SearchStatusOptions {
+  isArchived?: boolean;
+  isEncoded?: boolean;
+  isExternal?: boolean;
+  isFavorite?: boolean;
+  isMotion?: boolean;
+  isOffline?: boolean;
+  isReadOnly?: boolean;
+  isVisible?: boolean;
+  isNotInAlbum?: boolean;
+  type?: AssetType;
+  withArchived?: boolean;
+  withDeleted?: boolean;
+}
+
+export interface SearchOneToOneRelationOptions {
+  withExif?: boolean;
+  withSmartInfo?: 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;
+  resizePath?: string;
+  webpPath?: string;
+}
+
+export interface SearchExifOptions {
+  city?: string;
+  country?: string;
+  lensModel?: string;
+  make?: string;
+  model?: string;
+  state?: string;
+}
+
+export interface SearchEmbeddingOptions {
+  embedding: Embedding;
+  userIds: string[];
+}
+
+export interface SearchPeopleOptions {
+  personIds?: string[];
+}
+
+export interface SearchOrderOptions {
+  orderDirection?: 'ASC' | 'DESC';
+}
+
+export interface SearchPaginationOptions {
+  page: number;
+  size: number;
+}
+
+type BaseAssetSearchOptions = SearchDateOptions &
+  SearchIdOptions &
+  SearchExifOptions &
+  SearchOrderOptions &
+  SearchPathOptions &
+  SearchStatusOptions &
+  SearchUserIdOptions &
+  SearchPeopleOptions;
+
+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;
+
+export interface FaceEmbeddingSearch extends SearchEmbeddingOptions {
+  hasPerson?: boolean;
+  numResults: number;
+  maxDistance?: number;
+}
+
+export interface FaceSearchResult {
+  distance: number;
+  face: AssetFaceEntity;
+}
+
+export interface ISearchRepository {
+  init(modelName: string): Promise<void>;
+  searchMetadata(pagination: SearchPaginationOptions, options: AssetSearchOptions): Paginated<AssetEntity>;
+  searchSmart(pagination: SearchPaginationOptions, options: SmartSearchOptions): Paginated<AssetEntity>;
+  searchFaces(search: FaceEmbeddingSearch): Promise<FaceSearchResult[]>;
+  upsert(smartInfo: Partial<SmartInfoEntity>, embedding?: Embedding): Promise<void>;
+  searchPlaces(placeName: string): Promise<GeodataPlacesEntity[]>;
+  getAssetsByCity(userIds: string[]): Promise<AssetEntity[]>;
+  deleteAllSearchEmbeddings(): Promise<void>;
+}

server/src/interfaces/server-info.repository.ts

@@ -0,0 +1,15 @@
+export interface GitHubRelease {
+  id: number;
+  url: string;
+  tag_name: string;
+  name: string;
+  created_at: string;
+  published_at: string;
+  body: string;
+}
+
+export const IServerInfoRepository = 'IServerInfoRepository';
+
+export interface IServerInfoRepository {
+  getGitHubRelease(): Promise<GitHubRelease>;
+}

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

@@ -0,0 +1,12 @@
+import { SharedLinkEntity } from 'src/infra/entities/shared-link.entity';
+
+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/interfaces/storage.repository.ts

@@ -0,0 +1,61 @@
+import { WatchOptions } from 'chokidar';
+import { Stats } from 'node:fs';
+import { FileReadOptions } from 'node:fs/promises';
+import { Readable } from 'node:stream';
+import { CrawlOptionsDto } from 'src/domain/library/library.dto';
+
+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 WatchEvents {
+  onReady(): void;
+  onAdd(path: string): void;
+  onChange(path: string): void;
+  onUnlink(path: string): void;
+  onError(error: Error): void;
+}
+
+export enum StorageEventType {
+  READY = 'ready',
+  ADD = 'add',
+  CHANGE = 'change',
+  UNLINK = 'unlink',
+  ERROR = 'error',
+}
+
+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>;
+  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[]>;
+  walk(crawlOptions: CrawlOptionsDto): AsyncGenerator<string>;
+  copyFile(source: string, target: string): Promise<void>;
+  rename(source: string, target: string): Promise<void>;
+  watch(paths: string[], options: WatchOptions, events: Partial<WatchEvents>): () => Promise<void>;
+  utimes(filepath: string, atime: Date, mtime: Date): Promise<void>;
+}

server/src/interfaces/system-config.repository.ts

@@ -0,0 +1,11 @@
+import { SystemConfigEntity } from 'src/infra/entities/system-config.entity';
+
+export const ISystemConfigRepository = 'ISystemConfigRepository';
+
+export interface ISystemConfigRepository {
+  fetchStyle(url: string): Promise<any>;
+  load(): Promise<SystemConfigEntity[]>;
+  readFile(filename: string): Promise<string>;
+  saveAll(items: SystemConfigEntity[]): Promise<SystemConfigEntity[]>;
+  deleteKeys(keys: string[]): Promise<void>;
+}

server/src/interfaces/system-metadata.repository.ts

@@ -0,0 +1,8 @@
+import { SystemMetadata } from 'src/infra/entities/system-metadata.entity';
+
+export const ISystemMetadataRepository = 'ISystemMetadataRepository';
+
+export interface ISystemMetadataRepository {
+  get<T extends keyof SystemMetadata>(key: T): Promise<SystemMetadata[T] | null>;
+  set<T extends keyof SystemMetadata>(key: T, value: SystemMetadata[T]): Promise<void>;
+}

server/src/interfaces/tag.repository.ts

@@ -0,0 +1,17 @@
+import { AssetEntity } from 'src/infra/entities/asset.entity';
+import { TagEntity } from 'src/infra/entities/tag.entity';
+
+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/interfaces/user-token.repository.ts

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

server/src/interfaces/user.repository.ts

@@ -0,0 +1,37 @@
+import { UserEntity } from 'src/infra/entities/user.entity';
+
+export interface UserListFilter {
+  withDeleted?: boolean;
+}
+
+export interface UserStatsQueryResponse {
+  userId: string;
+  userName: string;
+  photos: number;
+  videos: number;
+  usage: number;
+  quotaSizeInBytes: number | null;
+}
+
+export interface UserFindOptions {
+  withDeleted?: boolean;
+}
+
+export const IUserRepository = 'IUserRepository';
+
+export interface IUserRepository {
+  get(id: string, options: UserFindOptions): Promise<UserEntity | null>;
+  getAdmin(): Promise<UserEntity | null>;
+  hasAdmin(): Promise<boolean>;
+  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>;
+  updateUsage(id: string, delta: number): Promise<void>;
+  syncUsage(id?: string): Promise<void>;
+}