High performance self-hosted photo and video management solution.
TypeScript backup-toolfluttergoogle-photosgoogle-photos-alternativejavascriptmobile-appnestjsnodejsphoto-galleryphotosphotos-managementself-hostedsveltesveltekittypescriptvideos
import { BadRequestException, Injectable } from '@nestjs/common';
import { Insertable } from 'kysely';
import { OnJob } from 'src/decorators.js';
import { BulkIdResponseDto, BulkIdsDto } from 'src/dtos/asset-ids.response.dto.js';
import { AuthDto } from 'src/dtos/auth.dto.js';
import {
TagBulkAssetsDto,
TagBulkAssetsResponseDto,
TagCreateDto,
TagResponseDto,
TagUpdateDto,
TagUpsertDto,
mapTag,
} from 'src/dtos/tag.dto.js';
import { JobName, JobStatus, Permission, QueueName } from 'src/enum.js';
import { TagAssetTable } from 'src/schema/tables/tag-asset.table.js';
import { BaseService } from 'src/services/base.service.js';
import { addAssets, removeAssets } from 'src/utils/asset.util.js';
import { updateLockedColumns } from 'src/utils/database.js';
import { findOrFail } from 'src/utils/misc.js';
import { upsertTags } from 'src/utils/tag.js';
@Injectable()
export class TagService extends BaseService {
async getAll(auth: AuthDto) {
const tags = await this.tagRepository.getAll(auth.user.id);
return tags.map((tag) => mapTag(tag));
}
async get(auth: AuthDto, id: string): Promise<TagResponseDto> {
await this.requireAccess({ auth, permission: Permission.TagRead, ids: [id] });
const tag = await this.findOrFail(id);
return mapTag(tag);
}
async create(auth: AuthDto, dto: TagCreateDto) {
let parent;
if (dto.parentId) {
await this.requireAccess({ auth, permission: Permission.TagRead, ids: [dto.parentId] });
parent = await this.tagRepository.get(dto.parentId);
if (!parent) {
throw new BadRequestException('Tag not found');
}
}
const userId = auth.user.id;
const value = parent ? `${parent.value}/${dto.name}` : dto.name;
const duplicate = await this.tagRepository.getByValue(userId, value);
if (duplicate) {
throw new BadRequestException(`A tag with that name already exists`);
}
const { color } = dto;
const tag = await this.tagRepository.create({ userId, value, color, parentId: parent?.id });
return mapTag(tag);
}
async update(auth: AuthDto, id: string, dto: TagUpdateDto): Promise<TagResponseDto> {
await this.requireAccess({ auth, permission: Permission.TagUpdate, ids: [id] });
const { name, color } = dto;
const existing = await this.findOrFail(id);
let value;
if (name) {
const parts = existing.value.split('/');
parts[parts.length - 1] = name;
value = parts.join('/');
} else {
value = existing.value;
}
const assetIds = value === existing.value ? [] : await this.tagRepository.getAssetIdsByTagId(id);
const tag = await this.tagRepository.update(id, { value, color });
await this.syncAssetTags(assetIds);
return mapTag(tag);
}
async upsert(auth: AuthDto, dto: TagUpsertDto) {
const tags = await upsertTags(this.tagRepository, { userId: auth.user.id, tags: dto.tags });
return tags.map((tag) => mapTag(tag));
}
async remove(auth: AuthDto, id: string): Promise<void> {
await this.requireAccess({ auth, permission: Permission.TagDelete, ids: [id] });
const assetIds = await this.tagRepository.getAssetIdsByTagId(id);
await this.tagRepository.delete(id);
await this.syncAssetTags(assetIds);
}
async bulkTagAssets(auth: AuthDto, dto: TagBulkAssetsDto): Promise<TagBulkAssetsResponseDto> {
const [tagIds, assetIds] = await Promise.all([
this.checkAccess({ auth, permission: Permission.TagAsset, ids: dto.tagIds }),
this.checkAccess({ auth, permission: Permission.AssetUpdate, ids: dto.assetIds }),
]);
const items: Insertable<TagAssetTable>[] = [];
for (const tagId of tagIds) {
for (const assetId of assetIds) {
items.push({ tagId, assetId });
}
}
const results = await this.tagRepository.upsertAssetIds(items);
for (const assetId of new Set(results.map((item) => item.assetId))) {
await this.updateTags(assetId);
await this.eventRepository.emit('AssetTag', { assetId, userId: auth.user.id });
}
return { count: results.length };
}
async addAssets(auth: AuthDto, id: string, dto: BulkIdsDto): Promise<BulkIdResponseDto[]> {
await this.requireAccess({ auth, permission: Permission.TagAsset, ids: [id] });
const results = await addAssets(
auth,
{ access: this.accessRepository, bulk: this.tagRepository },
{ parentId: id, assetIds: dto.ids, permission: Permission.AssetUpdate },
);
for (const { id: assetId, success } of results) {
if (!success) {
continue;
}
await this.updateTags(assetId);
await this.eventRepository.emit('AssetTag', { assetId, userId: auth.user.id });
}
return results;
}
async removeAssets(auth: AuthDto, id: string, dto: BulkIdsDto): Promise<BulkIdResponseDto[]> {
await this.requireAccess({ auth, permission: Permission.TagAsset, ids: [id] });
const results = await removeAssets(
auth,
{ access: this.accessRepository, bulk: this.tagRepository },
{ parentId: id, assetIds: dto.ids, canAlwaysRemove: Permission.TagDelete },
);
for (const { id: assetId, success } of results) {
if (!success) {
continue;
}
await this.updateTags(assetId);
await this.eventRepository.emit('AssetUntag', { assetId });
}
return results;
}
@OnJob({ name: JobName.TagCleanup, queue: QueueName.BackgroundTask })
async handleTagCleanup() {
await this.tagRepository.deleteEmptyTags();
return JobStatus.Success;
}
private findOrFail(id: string) {
return findOrFail(() => this.tagRepository.get(id), 'Tag');
}
private async updateTags(assetId: string) {
const { tags } = await this.assetRepository.getForUpdateTags(assetId);
await this.assetRepository.upsertExif({
exif: updateLockedColumns({ assetId, tags: tags.map(({ value }) => value) }),
lockedPropertiesBehavior: 'append',
});
}
private async syncAssetTags(assetIds: string[]) {
if (assetIds.length === 0) {
return;
}
for (const assetId of assetIds) {
await this.updateTags(assetId);
}
await this.jobRepository.queueAll(assetIds.map((id) => ({ name: JobName.SidecarWrite, data: { id } })));
}
}