chore(server): remove deprecated endpoints (#6984)

* chore: remove deprecated endpoints * chore: open api
2024-02-08 16:57:54 -05:00
parent 198e8517e5
commit 90a7f16817
36 changed files with 168 additions and 2905 deletions
@@ -14,7 +14,7 @@ import { AssetEntity, AssetStackEntity, AssetType, SharedLinkType } from '@app/i
 import { AssetRepository } from '@app/infra/repositories';
 import { INestApplication } from '@nestjs/common';
 import { errorStub, userDto, uuidStub } from '@test/fixtures';
-import { randomBytes } from 'crypto';
+import { randomBytes } from 'node:crypto';
 import request from 'supertest';
 import { api } from '../../client';
 import { generateAsset, testApp, today, yesterday } from '../utils';
@@ -517,91 +517,6 @@ describe(`${AssetController.name} (e2e)`, () => {
    }
  });

-  // TODO remove with deprecated endpoint
-  describe('GET /asset/assetById/:id', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server).get(`/asset/assetById/${uuidStub.notFound}`);
-      expect(body).toEqual(errorStub.unauthorized);
-      expect(status).toBe(401);
-    });
-
-    it('should require a valid id', async () => {
-      const { status, body } = await request(server)
-        .get(`/asset/assetById/${uuidStub.invalid}`)
-        .set('Authorization', `Bearer ${user1.accessToken}`);
-      expect(status).toBe(400);
-      expect(body).toEqual(errorStub.badRequest(['id must be a UUID']));
-    });
-
-    it('should require access', async () => {
-      const { status, body } = await request(server)
-        .get(`/asset/assetById/${asset4.id}`)
-        .set('Authorization', `Bearer ${user1.accessToken}`);
-      expect(status).toBe(400);
-      expect(body).toEqual(errorStub.noPermission);
-    });
-
-    it('should get the asset info', async () => {
-      const { status, body } = await request(server)
-        .get(`/asset/assetById/${asset1.id}`)
-        .set('Authorization', `Bearer ${user1.accessToken}`);
-      expect(status).toBe(200);
-      expect(body).toMatchObject({ id: asset1.id });
-    });
-
-    it('should work with a shared link', async () => {
-      const sharedLink = await api.sharedLinkApi.create(server, user1.accessToken, {
-        type: SharedLinkType.INDIVIDUAL,
-        assetIds: [asset1.id],
-      });
-
-      const { status, body } = await request(server).get(`/asset/assetById/${asset1.id}?key=${sharedLink.key}`);
-      expect(status).toBe(200);
-      expect(body).toMatchObject({ id: asset1.id });
-    });
-
-    it('should not send people data for shared links for un-authenticated users', async () => {
-      const personRepository = app.get<IPersonRepository>(IPersonRepository);
-      const person = await personRepository.create({ ownerId: asset1.ownerId, name: 'Test Person' });
-
-      await personRepository.createFaces([
-        {
-          assetId: asset1.id,
-          personId: person.id,
-          embedding: Array.from({ length: 512 }, Math.random),
-        },
-      ]);
-
-      const { status, body } = await request(server)
-        .put(`/asset/${asset1.id}`)
-        .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ isFavorite: true });
-      expect(status).toEqual(200);
-      expect(body).toMatchObject({
-        id: asset1.id,
-        isFavorite: true,
-        people: [
-          {
-            birthDate: null,
-            id: expect.any(String),
-            isHidden: false,
-            name: 'Test Person',
-            thumbnailPath: '',
-          },
-        ],
-      });
-
-      const sharedLink = await api.sharedLinkApi.create(server, user1.accessToken, {
-        type: SharedLinkType.INDIVIDUAL,
-        assetIds: [asset1.id],
-      });
-
-      const data = await request(server).get(`/asset/assetById/${asset1.id}?key=${sharedLink.key}`);
-      expect(data.status).toBe(200);
-      expect(data.body).toMatchObject({ people: [] });
-    });
-  });
-
  describe('GET /asset/:id', () => {
    it('should require authentication', async () => {
      const { status, body } = await request(server).get(`/asset/${uuidStub.notFound}`);
@@ -643,6 +558,47 @@ describe(`${AssetController.name} (e2e)`, () => {
      expect(status).toBe(200);
      expect(body).toMatchObject({ id: asset1.id });
    });
+
+    it('should not send people data for shared links for un-authenticated users', async () => {
+      const personRepository = app.get<IPersonRepository>(IPersonRepository);
+      const person = await personRepository.create({ ownerId: asset1.ownerId, name: 'Test Person' });
+
+      await personRepository.createFaces([
+        {
+          assetId: asset1.id,
+          personId: person.id,
+          embedding: Array.from({ length: 512 }, Math.random),
+        },
+      ]);
+
+      const { status, body } = await request(server)
+        .put(`/asset/${asset1.id}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ isFavorite: true });
+      expect(status).toEqual(200);
+      expect(body).toMatchObject({
+        id: asset1.id,
+        isFavorite: true,
+        people: [
+          {
+            birthDate: null,
+            id: expect.any(String),
+            isHidden: false,
+            name: 'Test Person',
+            thumbnailPath: '',
+          },
+        ],
+      });
+
+      const sharedLink = await api.sharedLinkApi.create(server, user1.accessToken, {
+        type: SharedLinkType.INDIVIDUAL,
+        assetIds: [asset1.id],
+      });
+
+      const data = await request(server).get(`/asset/${asset1.id}?key=${sharedLink.key}`);
+      expect(data.status).toBe(200);
+      expect(data.body).toMatchObject({ people: [] });
+    });
  });

  describe('POST /asset/upload', () => {
@@ -920,46 +876,6 @@ describe(`${AssetController.name} (e2e)`, () => {
    });
  });

-  describe('POST /asset/download/info', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server)
-        .post(`/asset/download/info`)
-        .send({ assetIds: [asset1.id] });
-
-      expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
-    });
-
-    it('should download info', async () => {
-      const { status, body } = await request(server)
-        .post('/asset/download/info')
-        .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ assetIds: [asset1.id] });
-
-      expect(status).toBe(201);
-      expect(body).toEqual(expect.objectContaining({ archives: [expect.objectContaining({ assetIds: [asset1.id] })] }));
-    });
-  });
-
-  describe('POST /asset/download/:id', () => {
-    it('should require authentication', async () => {
-      const { status, body } = await request(server).post(`/asset/download/${asset1.id}`);
-
-      expect(status).toBe(401);
-      expect(body).toEqual(errorStub.unauthorized);
-    });
-
-    it('should download file', async () => {
-      const asset = await api.assetApi.upload(server, user1.accessToken, 'example');
-      const response = await request(server)
-        .post(`/asset/download/${asset.id}`)
-        .set('Authorization', `Bearer ${user1.accessToken}`);
-
-      expect(response.status).toBe(200);
-      expect(response.headers['content-type']).toEqual('image/jpeg');
-    });
-  });
-
  describe('GET /asset/statistics', () => {
    beforeEach(async () => {
      await api.assetApi.upload(server, user1.accessToken, 'favored_asset', { isFavorite: true });
@@ -1459,20 +1375,20 @@ describe(`${AssetController.name} (e2e)`, () => {
    });
  });

+  const getAssetIdsWithoutFaces = async () => {
+    const assetPagination = usePagination(10, (pagination) =>
+      assetRepository.getWithout(pagination, WithoutProperty.FACES),
+    );
+    let assets: AssetEntity[] = [];
+    for await (const assetsPage of assetPagination) {
+      assets = [...assets, ...assetsPage];
+    }
+    return assets.map((a) => a.id);
+  };
+
  describe(AssetRepository.name, () => {
    describe('getWithout', () => {
      describe('WithoutProperty.FACES', () => {
-        const getAssetIdsWithoutFaces = async () => {
-          const assetPagination = usePagination(10, (pagination) =>
-            assetRepository.getWithout(pagination, WithoutProperty.FACES),
-          );
-          let assets: AssetEntity[] = [];
-          for await (const assetsPage of assetPagination) {
-            assets = [...assets, ...assetsPage];
-          }
-          return assets.map((a) => a.id);
-        };
-
        beforeEach(async () => {
          await assetRepository.save({ id: asset1.id, resizePath: '/path/to/resize' });
          expect(await getAssetIdsWithoutFaces()).toContain(asset1.id);
@@ -0,0 +1,89 @@
+import { AssetResponseDto, IAssetRepository, LibraryResponseDto, LoginResponseDto, mapAsset } from '@app/domain';
+import { AssetController } from '@app/immich';
+import { AssetEntity } from '@app/infra/entities';
+import { INestApplication } from '@nestjs/common';
+import { errorStub, userDto } from '@test/fixtures';
+import request from 'supertest';
+import { api } from '../../client';
+import { generateAsset, testApp } from '../utils';
+
+describe(`${AssetController.name} (e2e)`, () => {
+  let app: INestApplication;
+  let server: any;
+  let assetRepository: IAssetRepository;
+  let user1: LoginResponseDto;
+  let libraries: LibraryResponseDto[];
+  let asset1: AssetResponseDto;
+
+  const createAsset = async (
+    loginResponse: LoginResponseDto,
+    fileCreatedAt: Date,
+    other: Partial<AssetEntity> = {},
+  ) => {
+    const asset = await assetRepository.create(
+      generateAsset(loginResponse.userId, libraries, { fileCreatedAt, ...other }),
+    );
+
+    return mapAsset(asset);
+  };
+
+  beforeAll(async () => {
+    app = await testApp.create();
+    server = app.getHttpServer();
+    assetRepository = app.get<IAssetRepository>(IAssetRepository);
+
+    await testApp.reset();
+
+    await api.authApi.adminSignUp(server);
+    const admin = await api.authApi.adminLogin(server);
+
+    await api.userApi.create(server, admin.accessToken, userDto.user1);
+    user1 = await api.authApi.login(server, userDto.user1);
+    libraries = await api.libraryApi.getAll(server, user1.accessToken);
+    asset1 = await createAsset(user1, new Date('1970-01-01'));
+  });
+
+  afterAll(async () => {
+    await testApp.teardown();
+  });
+
+  describe('POST /download/info', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server)
+        .post(`/download/info`)
+        .send({ assetIds: [asset1.id] });
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should download info', async () => {
+      const { status, body } = await request(server)
+        .post('/download/info')
+        .set('Authorization', `Bearer ${user1.accessToken}`)
+        .send({ assetIds: [asset1.id] });
+
+      expect(status).toBe(201);
+      expect(body).toEqual(expect.objectContaining({ archives: [expect.objectContaining({ assetIds: [asset1.id] })] }));
+    });
+  });
+
+  describe('POST /download/asset/:id', () => {
+    it('should require authentication', async () => {
+      const { status, body } = await request(server).post(`/download/asset/${asset1.id}`);
+
+      expect(status).toBe(401);
+      expect(body).toEqual(errorStub.unauthorized);
+    });
+
+    it('should download file', async () => {
+      const asset = await api.assetApi.upload(server, user1.accessToken, 'example');
+      const response = await request(server)
+        .post(`/download/asset/${asset.id}`)
+        .set('Authorization', `Bearer ${user1.accessToken}`);
+
+      expect(response.status).toBe(200);
+      expect(response.headers['content-type']).toEqual('image/jpeg');
+    });
+  });
+});