chore: move apps and test utils (#8129)

server/src/apps/api.main.ts

@@ -0,0 +1,57 @@
+import { NestFactory } from '@nestjs/core';
+import { NestExpressApplication } from '@nestjs/platform-express';
+import { json } from 'body-parser';
+import cookieParser from 'cookie-parser';
+import { existsSync } from 'node:fs';
+import sirv from 'sirv';
+import { ApiModule } from 'src/apps/api.module';
+import { ApiService } from 'src/apps/api.service';
+import { excludePaths } from 'src/config';
+import { WEB_ROOT, envName, isDev, serverVersion } from 'src/domain/domain.constant';
+import { useSwagger } from 'src/immich/app.utils';
+import { otelSDK } from 'src/infra/instrumentation';
+import { ImmichLogger } from 'src/infra/logger';
+import { WebSocketAdapter } from 'src/infra/websocket.adapter';
+
+const logger = new ImmichLogger('ImmichServer');
+const port = Number(process.env.SERVER_PORT) || 3001;
+
+export async function bootstrapApi() {
+  otelSDK.start();
+  const app = await NestFactory.create<NestExpressApplication>(ApiModule, { bufferLogs: true });
+
+  app.useLogger(app.get(ImmichLogger));
+  app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']);
+  app.set('etag', 'strong');
+  app.use(cookieParser());
+  app.use(json({ limit: '10mb' }));
+  if (isDev) {
+    app.enableCors();
+  }
+  app.useWebSocketAdapter(new WebSocketAdapter(app));
+  useSwagger(app, isDev);
+
+  app.setGlobalPrefix('api', { exclude: excludePaths });
+  if (existsSync(WEB_ROOT)) {
+    // copied from https://github.com/sveltejs/kit/blob/679b5989fe62e3964b9a73b712d7b41831aa1f07/packages/adapter-node/src/handler.js#L46
+    // provides serving of precompressed assets and caching of immutable assets
+    app.use(
+      sirv(WEB_ROOT, {
+        etag: true,
+        gzip: true,
+        brotli: true,
+        setHeaders: (res, pathname) => {
+          if (pathname.startsWith(`/_app/immutable`) && res.statusCode === 200) {
+            res.setHeader('cache-control', 'public,max-age=31536000,immutable');
+          }
+        },
+      }),
+    );
+  }
+  app.use(app.get(ApiService).ssr(excludePaths));
+
+  const server = await app.listen(port);
+  server.requestTimeout = 30 * 60 * 1000;
+
+  logger.log(`Immich Server is listening on ${await app.getUrl()} [v${serverVersion}] [${envName}] `);
+}

server/src/apps/api.module.ts

@@ -0,0 +1,87 @@
+import { Module, OnModuleInit, ValidationPipe } from '@nestjs/common';
+import { APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core';
+import { ScheduleModule } from '@nestjs/schedule';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ApiService } from 'src/apps/api.service';
+import { ActivityController } from 'src/controllers/activity.controller';
+import { AlbumController } from 'src/controllers/album.controller';
+import { APIKeyController } from 'src/controllers/api-key.controller';
+import { AppController } from 'src/controllers/app.controller';
+import { AssetController, AssetsController } from 'src/controllers/asset.controller';
+import { AuditController } from 'src/controllers/audit.controller';
+import { AuthController } from 'src/controllers/auth.controller';
+import { DownloadController } from 'src/controllers/download.controller';
+import { FaceController } from 'src/controllers/face.controller';
+import { JobController } from 'src/controllers/job.controller';
+import { LibraryController } from 'src/controllers/library.controller';
+import { OAuthController } from 'src/controllers/oauth.controller';
+import { PartnerController } from 'src/controllers/partner.controller';
+import { PersonController } from 'src/controllers/person.controller';
+import { SearchController } from 'src/controllers/search.controller';
+import { ServerInfoController } from 'src/controllers/server-info.controller';
+import { SharedLinkController } from 'src/controllers/shared-link.controller';
+import { SystemConfigController } from 'src/controllers/system-config.controller';
+import { TagController } from 'src/controllers/tag.controller';
+import { TrashController } from 'src/controllers/trash.controller';
+import { UserController } from 'src/controllers/user.controller';
+import { DomainModule } from 'src/domain/domain.module';
+import { AssetEntity } from 'src/entities/asset.entity';
+import { ExifEntity } from 'src/entities/exif.entity';
+import { AssetRepositoryV1, IAssetRepositoryV1 } from 'src/immich/api-v1/asset/asset-repository';
+import { AssetController as AssetControllerV1 } from 'src/immich/api-v1/asset/asset.controller';
+import { AssetService as AssetServiceV1 } from 'src/immich/api-v1/asset/asset.service';
+import { InfraModule } from 'src/infra/infra.module';
+import { AuthGuard } from 'src/middleware/auth.guard';
+import { ErrorInterceptor } from 'src/middleware/error.interceptor';
+import { FileUploadInterceptor } from 'src/middleware/file-upload.interceptor';
+
+@Module({
+  imports: [
+    //
+    InfraModule,
+    DomainModule,
+    ScheduleModule.forRoot(),
+    TypeOrmModule.forFeature([AssetEntity, ExifEntity]),
+  ],
+  controllers: [
+    ActivityController,
+    AssetsController,
+    AssetControllerV1,
+    AssetController,
+    AppController,
+    AlbumController,
+    APIKeyController,
+    AuditController,
+    AuthController,
+    DownloadController,
+    FaceController,
+    JobController,
+    LibraryController,
+    OAuthController,
+    PartnerController,
+    SearchController,
+    ServerInfoController,
+    SharedLinkController,
+    SystemConfigController,
+    TagController,
+    TrashController,
+    UserController,
+    PersonController,
+  ],
+  providers: [
+    { provide: APP_PIPE, useValue: new ValidationPipe({ transform: true, whitelist: true }) },
+    { provide: APP_INTERCEPTOR, useClass: ErrorInterceptor },
+    { provide: APP_GUARD, useClass: AuthGuard },
+    { provide: IAssetRepositoryV1, useClass: AssetRepositoryV1 },
+    ApiService,
+    AssetServiceV1,
+    FileUploadInterceptor,
+  ],
+})
+export class ApiModule implements OnModuleInit {
+  constructor(private appService: ApiService) {}
+
+  async onModuleInit() {
+    await this.appService.init();
+  }
+}

server/src/apps/api.service.ts

@@ -0,0 +1,116 @@
+import { Injectable } from '@nestjs/common';
+import { Cron, CronExpression, Interval } from '@nestjs/schedule';
+import { NextFunction, Request, Response } from 'express';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { AuthService } from 'src/domain/auth/auth.service';
+import { DatabaseService } from 'src/domain/database/database.service';
+import { ONE_HOUR, WEB_ROOT } from 'src/domain/domain.constant';
+import { JobService } from 'src/domain/job/job.service';
+import { ServerInfoService } from 'src/domain/server-info/server-info.service';
+import { SharedLinkService } from 'src/domain/shared-link/shared-link.service';
+import { StorageService } from 'src/domain/storage/storage.service';
+import { SystemConfigService } from 'src/domain/system-config/system-config.service';
+import { ImmichLogger } from 'src/infra/logger';
+import { OpenGraphTags } from 'src/utils';
+
+const render = (index: string, meta: OpenGraphTags) => {
+  const tags = `
+    <meta name="description" content="${meta.description}" />
+
+    <!-- Facebook Meta Tags -->
+    <meta property="og:type" content="website" />
+    <meta property="og:title" content="${meta.title}" />
+    <meta property="og:description" content="${meta.description}" />
+    ${meta.imageUrl ? `<meta property="og:image" content="${meta.imageUrl}" />` : ''}
+
+    <!-- Twitter Meta Tags -->
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta name="twitter:title" content="${meta.title}" />
+    <meta name="twitter:description" content="${meta.description}" />
+
+    ${meta.imageUrl ? `<meta name="twitter:image" content="${meta.imageUrl}" />` : ''}`;
+
+  return index.replace('<!-- metadata:tags -->', tags);
+};
+
+@Injectable()
+export class ApiService {
+  private logger = new ImmichLogger(ApiService.name);
+
+  constructor(
+    private authService: AuthService,
+    private configService: SystemConfigService,
+    private jobService: JobService,
+    private serverService: ServerInfoService,
+    private sharedLinkService: SharedLinkService,
+    private storageService: StorageService,
+    private databaseService: DatabaseService,
+  ) {}
+
+  @Interval(ONE_HOUR.as('milliseconds'))
+  async onVersionCheck() {
+    await this.serverService.handleVersionCheck();
+  }
+
+  @Cron(CronExpression.EVERY_DAY_AT_MIDNIGHT)
+  async onNightlyJob() {
+    await this.jobService.handleNightlyJobs();
+  }
+
+  async init() {
+    await this.databaseService.init();
+    await this.configService.init();
+    this.storageService.init();
+    await this.serverService.init();
+    this.logger.log(`Feature Flags: ${JSON.stringify(await this.serverService.getFeatures(), null, 2)}`);
+  }
+
+  ssr(excludePaths: string[]) {
+    let index = '';
+    try {
+      index = readFileSync(join(WEB_ROOT, 'index.html')).toString();
+    } catch {
+      this.logger.warn('Unable to open `www/index.html, skipping SSR.');
+    }
+
+    return async (request: Request, res: Response, next: NextFunction) => {
+      if (
+        request.url.startsWith('/api') ||
+        request.method.toLowerCase() !== 'get' ||
+        excludePaths.some((item) => request.url.startsWith(item))
+      ) {
+        return next();
+      }
+
+      const targets = [
+        {
+          regex: /^\/share\/(.+)$/,
+          onMatch: async (matches: RegExpMatchArray) => {
+            const key = matches[1];
+            const auth = await this.authService.validateSharedLink(key);
+            return this.sharedLinkService.getMetadataTags(auth);
+          },
+        },
+      ];
+
+      let html = index;
+
+      try {
+        for (const { regex, onMatch } of targets) {
+          const matches = request.url.match(regex);
+          if (matches) {
+            const meta = await onMatch(matches);
+            if (meta) {
+              html = render(index, meta);
+            }
+
+            break;
+          }
+        }
+      } catch {}
+
+      res.type('text/html').header('Cache-Control', 'no-store').send(html);
+    };
+  }
+}

server/src/apps/immich-admin.main.ts

@@ -0,0 +1,8 @@
+import { CommandFactory } from 'nest-commander';
+import { ImmichAdminModule } from 'src/apps/immich-admin.module';
+import { LogLevel } from 'src/entities/system-config.entity';
+
+export async function bootstrapImmichAdmin() {
+  process.env.LOG_LEVEL = LogLevel.WARN;
+  await CommandFactory.run(ImmichAdminModule);
+}

server/src/apps/immich-admin.module.ts

@@ -0,0 +1,21 @@
+import { Module } from '@nestjs/common';
+import { ListUsersCommand } from 'src/commands/list-users.command';
+import { DisableOAuthLogin, EnableOAuthLogin } from 'src/commands/oauth-login';
+import { DisablePasswordLoginCommand, EnablePasswordLoginCommand } from 'src/commands/password-login';
+import { PromptPasswordQuestions, ResetAdminPasswordCommand } from 'src/commands/reset-admin-password.command';
+import { DomainModule } from 'src/domain/domain.module';
+import { InfraModule } from 'src/infra/infra.module';
+
+@Module({
+  imports: [InfraModule, DomainModule],
+  providers: [
+    ResetAdminPasswordCommand,
+    PromptPasswordQuestions,
+    EnablePasswordLoginCommand,
+    DisablePasswordLoginCommand,
+    EnableOAuthLogin,
+    DisableOAuthLogin,
+    ListUsersCommand,
+  ],
+})
+export class ImmichAdminModule {}

server/src/apps/microservices.main.ts

@@ -0,0 +1,20 @@
+import { NestFactory } from '@nestjs/core';
+import { MicroservicesModule } from 'src/apps/microservices.module';
+import { envName, serverVersion } from 'src/domain/domain.constant';
+import { otelSDK } from 'src/infra/instrumentation';
+import { ImmichLogger } from 'src/infra/logger';
+import { WebSocketAdapter } from 'src/infra/websocket.adapter';
+
+const logger = new ImmichLogger('ImmichMicroservice');
+const port = Number(process.env.MICROSERVICES_PORT) || 3002;
+
+export async function bootstrapMicroservices() {
+  otelSDK.start();
+  const app = await NestFactory.create(MicroservicesModule, { bufferLogs: true });
+  app.useLogger(app.get(ImmichLogger));
+  app.useWebSocketAdapter(new WebSocketAdapter(app));
+
+  await app.listen(port);
+
+  logger.log(`Immich Microservices is listening on ${await app.getUrl()} [v${serverVersion}] [${envName}] `);
+}

server/src/apps/microservices.module.ts

@@ -0,0 +1,16 @@
+import { Module, OnModuleInit } from '@nestjs/common';
+import { MicroservicesService } from 'src/apps/microservices.service';
+import { DomainModule } from 'src/domain/domain.module';
+import { InfraModule } from 'src/infra/infra.module';
+
+@Module({
+  imports: [InfraModule, DomainModule],
+  providers: [MicroservicesService],
+})
+export class MicroservicesModule implements OnModuleInit {
+  constructor(private appService: MicroservicesService) {}
+
+  async onModuleInit() {
+    await this.appService.init();
+  }
+}

server/src/apps/microservices.service.ts

@@ -0,0 +1,91 @@
+import { Injectable } from '@nestjs/common';
+import { AssetService } from 'src/domain/asset/asset.service';
+import { AuditService } from 'src/domain/audit/audit.service';
+import { DatabaseService } from 'src/domain/database/database.service';
+import { JobName } from 'src/domain/job/job.constants';
+import { IDeleteFilesJob } from 'src/domain/job/job.interface';
+import { JobService } from 'src/domain/job/job.service';
+import { LibraryService } from 'src/domain/library/library.service';
+import { MediaService } from 'src/domain/media/media.service';
+import { MetadataService } from 'src/domain/metadata/metadata.service';
+import { PersonService } from 'src/domain/person/person.service';
+import { SmartInfoService } from 'src/domain/smart-info/smart-info.service';
+import { StorageTemplateService } from 'src/domain/storage-template/storage-template.service';
+import { StorageService } from 'src/domain/storage/storage.service';
+import { SystemConfigService } from 'src/domain/system-config/system-config.service';
+import { UserService } from 'src/domain/user/user.service';
+import { otelSDK } from 'src/infra/instrumentation';
+
+@Injectable()
+export class MicroservicesService {
+  constructor(
+    private auditService: AuditService,
+    private assetService: AssetService,
+    private configService: SystemConfigService,
+    private jobService: JobService,
+    private libraryService: LibraryService,
+    private mediaService: MediaService,
+    private metadataService: MetadataService,
+    private personService: PersonService,
+    private smartInfoService: SmartInfoService,
+    private storageTemplateService: StorageTemplateService,
+    private storageService: StorageService,
+    private userService: UserService,
+    private databaseService: DatabaseService,
+  ) {}
+
+  async init() {
+    await this.databaseService.init();
+    await this.configService.init();
+    await this.libraryService.init();
+    await this.jobService.init({
+      [JobName.ASSET_DELETION]: (data) => this.assetService.handleAssetDeletion(data),
+      [JobName.ASSET_DELETION_CHECK]: () => this.assetService.handleAssetDeletionCheck(),
+      [JobName.DELETE_FILES]: (data: IDeleteFilesJob) => this.storageService.handleDeleteFiles(data),
+      [JobName.CLEAN_OLD_AUDIT_LOGS]: () => this.auditService.handleCleanup(),
+      [JobName.USER_DELETE_CHECK]: () => this.userService.handleUserDeleteCheck(),
+      [JobName.USER_DELETION]: (data) => this.userService.handleUserDelete(data),
+      [JobName.USER_SYNC_USAGE]: () => this.userService.handleUserSyncUsage(),
+      [JobName.QUEUE_SMART_SEARCH]: (data) => this.smartInfoService.handleQueueEncodeClip(data),
+      [JobName.SMART_SEARCH]: (data) => this.smartInfoService.handleEncodeClip(data),
+      [JobName.STORAGE_TEMPLATE_MIGRATION]: () => this.storageTemplateService.handleMigration(),
+      [JobName.STORAGE_TEMPLATE_MIGRATION_SINGLE]: (data) => this.storageTemplateService.handleMigrationSingle(data),
+      [JobName.QUEUE_MIGRATION]: () => this.mediaService.handleQueueMigration(),
+      [JobName.MIGRATE_ASSET]: (data) => this.mediaService.handleAssetMigration(data),
+      [JobName.MIGRATE_PERSON]: (data) => this.personService.handlePersonMigration(data),
+      [JobName.QUEUE_GENERATE_THUMBNAILS]: (data) => this.mediaService.handleQueueGenerateThumbnails(data),
+      [JobName.GENERATE_JPEG_THUMBNAIL]: (data) => this.mediaService.handleGenerateJpegThumbnail(data),
+      [JobName.GENERATE_WEBP_THUMBNAIL]: (data) => this.mediaService.handleGenerateWebpThumbnail(data),
+      [JobName.GENERATE_THUMBHASH_THUMBNAIL]: (data) => this.mediaService.handleGenerateThumbhashThumbnail(data),
+      [JobName.QUEUE_VIDEO_CONVERSION]: (data) => this.mediaService.handleQueueVideoConversion(data),
+      [JobName.VIDEO_CONVERSION]: (data) => this.mediaService.handleVideoConversion(data),
+      [JobName.QUEUE_METADATA_EXTRACTION]: (data) => this.metadataService.handleQueueMetadataExtraction(data),
+      [JobName.METADATA_EXTRACTION]: (data) => this.metadataService.handleMetadataExtraction(data),
+      [JobName.LINK_LIVE_PHOTOS]: (data) => this.metadataService.handleLivePhotoLinking(data),
+      [JobName.QUEUE_FACE_DETECTION]: (data) => this.personService.handleQueueDetectFaces(data),
+      [JobName.FACE_DETECTION]: (data) => this.personService.handleDetectFaces(data),
+      [JobName.QUEUE_FACIAL_RECOGNITION]: (data) => this.personService.handleQueueRecognizeFaces(data),
+      [JobName.FACIAL_RECOGNITION]: (data) => this.personService.handleRecognizeFaces(data),
+      [JobName.GENERATE_PERSON_THUMBNAIL]: (data) => this.personService.handleGeneratePersonThumbnail(data),
+      [JobName.PERSON_CLEANUP]: () => this.personService.handlePersonCleanup(),
+      [JobName.QUEUE_SIDECAR]: (data) => this.metadataService.handleQueueSidecar(data),
+      [JobName.SIDECAR_DISCOVERY]: (data) => this.metadataService.handleSidecarDiscovery(data),
+      [JobName.SIDECAR_SYNC]: (data) => this.metadataService.handleSidecarSync(data),
+      [JobName.SIDECAR_WRITE]: (data) => this.metadataService.handleSidecarWrite(data),
+      [JobName.LIBRARY_SCAN_ASSET]: (data) => this.libraryService.handleAssetRefresh(data),
+      [JobName.LIBRARY_SCAN]: (data) => this.libraryService.handleQueueAssetRefresh(data),
+      [JobName.LIBRARY_DELETE]: (data) => this.libraryService.handleDeleteLibrary(data),
+      [JobName.LIBRARY_REMOVE_OFFLINE]: (data) => this.libraryService.handleOfflineRemoval(data),
+      [JobName.LIBRARY_QUEUE_SCAN_ALL]: (data) => this.libraryService.handleQueueAllScan(data),
+      [JobName.LIBRARY_QUEUE_CLEANUP]: () => this.libraryService.handleQueueCleanup(),
+    });
+
+    await this.metadataService.init();
+  }
+
+  async teardown() {
+    await this.libraryService.teardown();
+    await this.metadataService.teardown();
+    await otelSDK.shutdown();
+  }
+}