WIP refactor container and queuing system (#206)

* refactor microservices to machine-learning

* Update tGithub issue template with correct task syntax

* Added microservices container

* Communicate between service based on queue system

* added dependency

* Fixed problem with having to import BullQueue into the individual service

* Added todo

* refactor server into monorepo with microservices

* refactor database and entity to library

* added simple migration

* Move migrations and database config to library

* Migration works in library

* Cosmetic change in logging message

* added user dto

* Fixed issue with testing not able to find the shared library

* Clean up library mapping path

* Added webp generator to microservices

* Update Github Action build latest

* Fixed issue NPM cannot install due to conflict witl Bull Queue

* format project with prettier

* Modified docker-compose file

* Add GH Action for Staging build:

* Fixed GH action job name

* Modified GH Action to only build & push latest when pushing to main

* Added Test 2e2 Github Action

* Added Test 2e2 Github Action

* Implemented microservice to extract exif

* Added cronjob to scan and generate webp thumbnail  at midnight

* Refactor to ireduce hit time to database when running microservices

* Added error handling to asset services that handle read file from disk

* Added video transcoding queue to process one video at a time

* Fixed loading spinner on web while loading covering the info panel

* Add mechanism to show new release announcement to web and mobile app (#209)

* Added changelog page

* Fixed issues based on PR comments

* Fixed issue with video transcoding run on the server

* Change entry point content for backward combatibility when starting up server

* Added announcement box

* Added error handling to failed silently when the app version checking is not able to make the request to GITHUB

* Added new version announcement overlay

* Update message

* Added messages

* Added logic to check and show announcement

* Add method to handle saving new version

* Added button to dimiss the acknowledge message

* Up version for deployment to the app store

server/apps/immich/test/jest-e2e.json

@@ -0,0 +1,13 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  },
+  "moduleNameMapper": {
+    "@app/database/config/(.*)": "<rootDir>../../../libs/database/src/config/$1",
+    "@app/database/entities/(.*)": "<rootDir>../../../libs/database/src/entities/$1"
+  }
+}

server/apps/immich/test/test-utils.ts

@@ -0,0 +1,37 @@
+import { getConnection } from 'typeorm';
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { TestingModuleBuilder } from '@nestjs/testing';
+import { AuthUserDto } from '../src/decorators/auth-user.decorator';
+import { JwtAuthGuard } from '../src/modules/immich-jwt/guards/jwt-auth.guard';
+
+type CustomAuthCallback = () => AuthUserDto;
+
+export async function clearDb() {
+  const entities = getConnection().entityMetadatas;
+  for (const entity of entities) {
+    const repository = getConnection().getRepository(entity.name);
+    await repository.query(`TRUNCATE ${entity.tableName} RESTART IDENTITY CASCADE;`);
+  }
+}
+
+export function getAuthUser(): AuthUserDto {
+  return {
+    id: '3108ac14-8afb-4b7e-87fd-39ebb6b79750',
+    email: 'test@email.com',
+  };
+}
+
+export function auth(builder: TestingModuleBuilder): TestingModuleBuilder {
+  return authCustom(builder, getAuthUser);
+}
+
+export function authCustom(builder: TestingModuleBuilder, callback: CustomAuthCallback): TestingModuleBuilder {
+  const canActivate: CanActivate = {
+    canActivate: (context: ExecutionContext) => {
+      const req = context.switchToHttp().getRequest();
+      req.user = callback();
+      return true;
+    },
+  };
+  return builder.overrideGuard(JwtAuthGuard).useValue(canActivate);
+}

server/apps/immich/test/user.e2e-spec.ts

@@ -0,0 +1,120 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import request from 'supertest';
+import { clearDb, authCustom } from './test-utils';
+import { databaseConfig } from '@app/database/config/database.config';
+import { UserModule } from '../src/api-v1/user/user.module';
+import { ImmichJwtModule } from '../src/modules/immich-jwt/immich-jwt.module';
+import { UserService } from '../src/api-v1/user/user.service';
+import { CreateUserDto } from '../src/api-v1/user/dto/create-user.dto';
+import { User } from '../src/api-v1/user/response-dto/user';
+
+function _createUser(userService: UserService, data: CreateUserDto) {
+  return userService.createUser(data);
+}
+
+describe('User', () => {
+  let app: INestApplication;
+
+  afterAll(async () => {
+    await clearDb();
+    await app.close();
+  });
+
+  describe('without auth', () => {
+    beforeAll(async () => {
+      const moduleFixture: TestingModule = await Test.createTestingModule({
+        imports: [UserModule, ImmichJwtModule, TypeOrmModule.forRoot(databaseConfig)],
+      }).compile();
+
+      app = moduleFixture.createNestApplication();
+      await app.init();
+    });
+
+    afterAll(async () => {
+      await app.close();
+    });
+
+    it('prevents fetching users if not auth', async () => {
+      const { status } = await request(app.getHttpServer()).get('/user');
+      expect(status).toEqual(401);
+    });
+  });
+
+  describe('with auth', () => {
+    let userService: UserService;
+    let authUser: User;
+
+    beforeAll(async () => {
+      const builder = Test.createTestingModule({
+        imports: [UserModule, TypeOrmModule.forRoot(databaseConfig)],
+      });
+      const moduleFixture: TestingModule = await authCustom(builder, () => authUser).compile();
+
+      app = moduleFixture.createNestApplication();
+      userService = app.get(UserService);
+      await app.init();
+    });
+
+    describe('with users in DB', () => {
+      const authUserEmail = 'auth-user@test.com';
+      const userOneEmail = 'one@test.com';
+      const userTwoEmail = 'two@test.com';
+
+      beforeAll(async () => {
+        await Promise.allSettled([
+          _createUser(userService, {
+            firstName: 'auth-user',
+            lastName: 'test',
+            email: authUserEmail,
+            password: '1234',
+          }).then((user) => (authUser = user)),
+          _createUser(userService, {
+            firstName: 'one',
+            lastName: 'test',
+            email: userOneEmail,
+            password: '1234',
+          }),
+          _createUser(userService, {
+            firstName: 'two',
+            lastName: 'test',
+            email: userTwoEmail,
+            password: '1234',
+          }),
+        ]);
+      });
+
+      it('fetches the user collection excluding the auth user', async () => {
+        const { status, body } = await request(app.getHttpServer()).get('/user');
+        expect(status).toEqual(200);
+        expect(body).toHaveLength(2);
+        expect(body).toEqual(
+          expect.arrayContaining([
+            {
+              email: userOneEmail,
+              firstName: 'one',
+              lastName: 'test',
+              id: expect.anything(),
+              createdAt: expect.anything(),
+              isAdmin: false,
+              isFirstLoggedIn: true,
+              profileImagePath: '',
+            },
+            {
+              email: userTwoEmail,
+              firstName: 'two',
+              lastName: 'test',
+              id: expect.anything(),
+              createdAt: expect.anything(),
+              isAdmin: false,
+              isFirstLoggedIn: true,
+              profileImagePath: '',
+            },
+          ]),
+        );
+        expect(body).toEqual(expect.not.arrayContaining([expect.objectContaining({ email: authUserEmail })]));
+      });
+    });
+  });
+});