refactor(server)*: tsconfigs (#2689)

* refactor(server): tsconfigs

* chore: dummy commit

* fix: start.sh

* chore: restore original entry scripts

server/src/domain/smart-info/index.ts

@@ -0,0 +1,3 @@
+export * from './machine-learning.interface';
+export * from './smart-info.repository';
+export * from './smart-info.service';

server/src/domain/smart-info/machine-learning.interface.ts

@@ -0,0 +1,27 @@
+export const IMachineLearningRepository = 'IMachineLearningRepository';
+
+export interface MachineLearningInput {
+  imagePath: 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 interface IMachineLearningRepository {
+  classifyImage(input: MachineLearningInput): Promise<string[]>;
+  encodeImage(input: MachineLearningInput): Promise<number[]>;
+  encodeText(input: string): Promise<number[]>;
+  detectFaces(input: MachineLearningInput): Promise<DetectFaceResult[]>;
+}

server/src/domain/smart-info/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/smart-info/smart-info.service.spec.ts

@@ -0,0 +1,153 @@
+import { AssetEntity } from '@app/infra/entities';
+import {
+  assetEntityStub,
+  newAssetRepositoryMock,
+  newJobRepositoryMock,
+  newMachineLearningRepositoryMock,
+  newSmartInfoRepositoryMock,
+} from '@test';
+import { IAssetRepository, WithoutProperty } from '../asset';
+import { IJobRepository, JobName } from '../job';
+import { IMachineLearningRepository } from './machine-learning.interface';
+import { ISmartInfoRepository } from './smart-info.repository';
+import { SmartInfoService } from './smart-info.service';
+
+const asset = {
+  id: 'asset-1',
+  resizePath: 'path/to/resize.ext',
+} as AssetEntity;
+
+describe(SmartInfoService.name, () => {
+  let sut: SmartInfoService;
+  let assetMock: jest.Mocked<IAssetRepository>;
+  let jobMock: jest.Mocked<IJobRepository>;
+  let smartMock: jest.Mocked<ISmartInfoRepository>;
+  let machineMock: jest.Mocked<IMachineLearningRepository>;
+
+  beforeEach(async () => {
+    assetMock = newAssetRepositoryMock();
+    smartMock = newSmartInfoRepositoryMock();
+    jobMock = newJobRepositoryMock();
+    machineMock = newMachineLearningRepositoryMock();
+    sut = new SmartInfoService(assetMock, jobMock, smartMock, machineMock);
+
+    assetMock.getByIds.mockResolvedValue([asset]);
+  });
+
+  it('should work', () => {
+    expect(sut).toBeDefined();
+  });
+
+  describe('handleQueueObjectTagging', () => {
+    it('should queue the assets without tags', async () => {
+      assetMock.getWithout.mockResolvedValue({
+        items: [assetEntityStub.image],
+        hasNextPage: false,
+      });
+
+      await sut.handleQueueObjectTagging({ force: false });
+
+      expect(jobMock.queue.mock.calls).toEqual([
+        [{ name: JobName.CLASSIFY_IMAGE, data: { id: assetEntityStub.image.id } }],
+      ]);
+      expect(assetMock.getWithout).toHaveBeenCalledWith({ skip: 0, take: 1000 }, WithoutProperty.OBJECT_TAGS);
+    });
+
+    it('should queue all the assets', async () => {
+      assetMock.getAll.mockResolvedValue({
+        items: [assetEntityStub.image],
+        hasNextPage: false,
+      });
+
+      await sut.handleQueueObjectTagging({ force: true });
+
+      expect(jobMock.queue.mock.calls).toEqual([
+        [{ name: JobName.CLASSIFY_IMAGE, data: { id: assetEntityStub.image.id } }],
+      ]);
+      expect(assetMock.getAll).toHaveBeenCalled();
+    });
+  });
+
+  describe('handleTagImage', () => {
+    it('should skip assets without a resize path', async () => {
+      const asset = { resizePath: '' } as AssetEntity;
+      assetMock.getByIds.mockResolvedValue([asset]);
+
+      await sut.handleClassifyImage({ id: asset.id });
+
+      expect(smartMock.upsert).not.toHaveBeenCalled();
+      expect(machineMock.classifyImage).not.toHaveBeenCalled();
+    });
+
+    it('should save the returned tags', async () => {
+      machineMock.classifyImage.mockResolvedValue(['tag1', 'tag2', 'tag3']);
+
+      await sut.handleClassifyImage({ id: asset.id });
+
+      expect(machineMock.classifyImage).toHaveBeenCalledWith({ imagePath: 'path/to/resize.ext' });
+      expect(smartMock.upsert).toHaveBeenCalledWith({
+        assetId: 'asset-1',
+        tags: ['tag1', 'tag2', 'tag3'],
+      });
+    });
+
+    it('should no update the smart info if no tags were returned', async () => {
+      machineMock.classifyImage.mockResolvedValue([]);
+
+      await sut.handleClassifyImage({ id: asset.id });
+
+      expect(machineMock.classifyImage).toHaveBeenCalled();
+      expect(smartMock.upsert).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handleQueueEncodeClip', () => {
+    it('should queue the assets without clip embeddings', async () => {
+      assetMock.getWithout.mockResolvedValue({
+        items: [assetEntityStub.image],
+        hasNextPage: false,
+      });
+
+      await sut.handleQueueEncodeClip({ force: false });
+
+      expect(jobMock.queue).toHaveBeenCalledWith({ name: JobName.ENCODE_CLIP, data: { id: assetEntityStub.image.id } });
+      expect(assetMock.getWithout).toHaveBeenCalledWith({ skip: 0, take: 1000 }, WithoutProperty.CLIP_ENCODING);
+    });
+
+    it('should queue all the assets', async () => {
+      assetMock.getAll.mockResolvedValue({
+        items: [assetEntityStub.image],
+        hasNextPage: false,
+      });
+
+      await sut.handleQueueEncodeClip({ force: true });
+
+      expect(jobMock.queue).toHaveBeenCalledWith({ name: JobName.ENCODE_CLIP, data: { id: assetEntityStub.image.id } });
+      expect(assetMock.getAll).toHaveBeenCalled();
+    });
+  });
+
+  describe('handleEncodeClip', () => {
+    it('should skip assets without a resize path', async () => {
+      const asset = { resizePath: '' } as AssetEntity;
+      assetMock.getByIds.mockResolvedValue([asset]);
+
+      await sut.handleEncodeClip({ id: asset.id });
+
+      expect(smartMock.upsert).not.toHaveBeenCalled();
+      expect(machineMock.encodeImage).not.toHaveBeenCalled();
+    });
+
+    it('should save the returned objects', async () => {
+      machineMock.encodeImage.mockResolvedValue([0.01, 0.02, 0.03]);
+
+      await sut.handleEncodeClip({ id: asset.id });
+
+      expect(machineMock.encodeImage).toHaveBeenCalledWith({ imagePath: 'path/to/resize.ext' });
+      expect(smartMock.upsert).toHaveBeenCalledWith({
+        assetId: 'asset-1',
+        clipEmbedding: [0.01, 0.02, 0.03],
+      });
+    });
+  });
+});

server/src/domain/smart-info/smart-info.service.ts

@@ -0,0 +1,81 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { IAssetRepository, WithoutProperty } from '../asset';
+import { MACHINE_LEARNING_ENABLED } from '../domain.constant';
+import { usePagination } from '../domain.util';
+import { IBaseJob, IEntityJob, IJobRepository, JobName, JOBS_ASSET_PAGINATION_SIZE } from '../job';
+import { IMachineLearningRepository } from './machine-learning.interface';
+import { ISmartInfoRepository } from './smart-info.repository';
+
+@Injectable()
+export class SmartInfoService {
+  private logger = new Logger(SmartInfoService.name);
+
+  constructor(
+    @Inject(IAssetRepository) private assetRepository: IAssetRepository,
+    @Inject(IJobRepository) private jobRepository: IJobRepository,
+    @Inject(ISmartInfoRepository) private repository: ISmartInfoRepository,
+    @Inject(IMachineLearningRepository) private machineLearning: IMachineLearningRepository,
+  ) {}
+
+  async handleQueueObjectTagging({ force }: IBaseJob) {
+    const assetPagination = usePagination(JOBS_ASSET_PAGINATION_SIZE, (pagination) => {
+      return force
+        ? this.assetRepository.getAll(pagination)
+        : this.assetRepository.getWithout(pagination, WithoutProperty.OBJECT_TAGS);
+    });
+
+    for await (const assets of assetPagination) {
+      for (const asset of assets) {
+        await this.jobRepository.queue({ name: JobName.CLASSIFY_IMAGE, data: { id: asset.id } });
+      }
+    }
+
+    return true;
+  }
+
+  async handleClassifyImage({ id }: IEntityJob) {
+    const [asset] = await this.assetRepository.getByIds([id]);
+
+    if (!MACHINE_LEARNING_ENABLED || !asset.resizePath) {
+      return false;
+    }
+
+    const tags = await this.machineLearning.classifyImage({ imagePath: asset.resizePath });
+    if (tags.length === 0) {
+      return false;
+    }
+
+    await this.repository.upsert({ assetId: asset.id, tags });
+
+    return true;
+  }
+
+  async handleQueueEncodeClip({ force }: IBaseJob) {
+    const assetPagination = usePagination(JOBS_ASSET_PAGINATION_SIZE, (pagination) => {
+      return force
+        ? this.assetRepository.getAll(pagination)
+        : this.assetRepository.getWithout(pagination, WithoutProperty.CLIP_ENCODING);
+    });
+
+    for await (const assets of assetPagination) {
+      for (const asset of assets) {
+        await this.jobRepository.queue({ name: JobName.ENCODE_CLIP, data: { id: asset.id } });
+      }
+    }
+
+    return true;
+  }
+
+  async handleEncodeClip({ id }: IEntityJob) {
+    const [asset] = await this.assetRepository.getByIds([id]);
+
+    if (!MACHINE_LEARNING_ENABLED || !asset.resizePath) {
+      return false;
+    }
+
+    const clipEmbedding = await this.machineLearning.encodeImage({ imagePath: asset.resizePath });
+    await this.repository.upsert({ assetId: asset.id, clipEmbedding: clipEmbedding });
+
+    return true;
+  }
+}