@hedhog/admin 0.0.107 → 0.0.109

package/src/locale/locale.middleware.ts

@@ -1,34 +0,0 @@
-import { PrismaService } from '@hedhog/prisma';
-import { Injectable, NestMiddleware } from '@nestjs/common';
-import { NextFunction, Request, Response } from 'express';
-
-@Injectable()
-export class LocaleMiddleware implements NestMiddleware {
-  private languages = [];
-
-  constructor(private prisma: PrismaService) {}
-
-  async use(req: Request, _res: Response, next: NextFunction) {
-    const locale = req.headers['accept-language'] || 'en-US';
-    let code = locale.split(',')[0].split('-')[0];
-
-    if (!this.languages.length) {
-      const locale = await this.prisma.locale.findMany({
-        select: {
-          code: true,
-        },
-      });
-
-      for (const l of locale) {
-        this.languages.push(l.code);
-      }
-    }
-
-    if (!this.languages.includes(code)) {
-      code = 'en';
-    }
-
-    req['locale'] = code;
-    next();
-  }
-}

package/src/locale/locale.module.ts

@@ -1,23 +0,0 @@
-import { PaginationModule } from '@hedhog/pagination';
-import { PrismaModule } from '@hedhog/prisma';
-import { forwardRef, MiddlewareConsumer, Module } from '@nestjs/common';
-import { LocaleService } from './locale.service';
-import { LocaleController } from './locale.controller';
-import { LocaleMiddleware } from './locale.middleware';
-import { AuthModule } from '../auth/auth.module';
-
-@Module({
-  imports: [
-    forwardRef(() => AuthModule),
-    forwardRef(() => PrismaModule),
-    forwardRef(() => PaginationModule),
-  ],
-  controllers: [LocaleController],
-  providers: [LocaleService],
-  exports: [LocaleService],
-})
-export class LocaleModule {
-  configure(consumer: MiddlewareConsumer) {
-    consumer.apply(LocaleMiddleware).forRoutes('*');
-  }
-}

package/src/locale/locale.service.spec.ts

@@ -1,193 +0,0 @@
-import { PaginationService } from '@hedhog/pagination';
-import { PrismaService } from '@hedhog/prisma';
-import { BadRequestException } from '@nestjs/common';
-import { Test, TestingModule } from '@nestjs/testing';
-import { CreateDTO } from './dto/create.dto';
-import { DeleteDTO } from './dto/delete.dto';
-import { UpdateDTO } from './dto/update.dto';
-import { LocaleService } from './locale.service';
-
-describe('LocaleService', () => {
-  let service: LocaleService;
-  let prismaService: PrismaService;
-  let paginationService: PaginationService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        LocaleService,
-        {
-          provide: PrismaService,
-          useValue: {
-            translation: {
-              findMany: jest.fn(),
-            },
-            locale: {
-              findUnique: jest.fn(),
-              create: jest.fn(),
-              update: jest.fn(),
-              deleteMany: jest.fn(),
-            },
-          },
-        },
-        {
-          provide: PaginationService,
-          useValue: {
-            paginate: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    service = module.get<LocaleService>(LocaleService);
-    prismaService = module.get<PrismaService>(PrismaService);
-    paginationService = module.get<PaginationService>(PaginationService);
-  });
-
-  it('should be defined', () => {
-    expect(service).toBeDefined();
-  });
-
-  describe('getTranslations', () => {
-    it('should throw BadRequestException when localeCode is not provided', async () => {
-      await expect(service.getTranslations('', 'namespace')).rejects.toThrow(
-        BadRequestException,
-      );
-    });
-
-    it('should return translation for a given localeCode and namespace', async () => {
-      const mockTranslations = [
-        {
-          id: 1,
-          locale_id: 1,
-          namespace_id: 1,
-          name: 'hello',
-          value: 'Hello',
-          created_at: new Date(),
-          updated_at: new Date(),
-        },
-      ];
-      jest
-        .spyOn(prismaService.translation, 'findMany')
-        .mockResolvedValue(mockTranslations);
-
-      const result = await service.getTranslations('en-US', 'namespace');
-      expect(result).toEqual({ hello: 'Hello' });
-    });
-  });
-  /*
-  describe('get', () => {
-    it('should paginate locale', async () => {
-      const mockPaginationResult = {
-        data: [],
-        total: 10,
-        lastPage: 1,
-        page: 1,
-        prev: 0,
-        next: 2,
-        pageSize: 10,
-      };
-      jest
-        .spyOn(paginationService, 'paginate')
-        .mockResolvedValue(mockPaginationResult);
-
-      const paginationParams: PaginationDTO = {
-        page: 1,
-        pageSize: 20,
-        sortField: '',
-        sortOrder: PageOrderDirection.Asc,
-        fields: '',
-        search: '',
-      };
-      const result = await service.get(paginationParams );
-
-      expect(paginationService.paginate).toHaveBeenCalledWith(
-        prismaService.locale,
-        paginationParams,
-        expect.anything(),
-      );
-      expect(result).toBe(mockPaginationResult);
-    });
-  });
-*/
-  describe('getById', () => {
-    it('should return a locale by ID', async () => {
-      const mockLocale = {
-        id: 1,
-        name: 'English',
-        code: 'en',
-        region: 'us',
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest
-        .spyOn(prismaService.locale, 'findUnique')
-        .mockResolvedValue(mockLocale);
-
-      const result = await service.getById(1);
-      expect(result).toBe(mockLocale);
-    });
-  });
-
-  describe('create', () => {
-    it('should create a new locale', async () => {
-      const mockCreateDTO: CreateDTO = {
-        name: 'English',
-        code: 'en',
-        region: 'us',
-      };
-      const mockLocale = {
-        id: 1,
-        name: 'English',
-        code: 'en',
-        region: 'us',
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(prismaService.locale, 'create').mockResolvedValue(mockLocale);
-
-      const result = await service.create(mockCreateDTO);
-      expect(result).toBe(mockLocale);
-    });
-  });
-
-  describe('update', () => {
-    it('should update a locale', async () => {
-      const mockUpdateDTO: UpdateDTO = {
-        name: 'English Updated',
-        code: 'en',
-        region: 'us',
-      };
-      const mockLocale = {
-        id: 1,
-        name: 'English Updated',
-        code: 'en',
-        region: 'us',
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(prismaService.locale, 'update').mockResolvedValue(mockLocale);
-
-      const result = await service.update({ id: 1, data: mockUpdateDTO });
-      expect(result).toBe(mockLocale);
-    });
-  });
-
-  describe('delete', () => {
-    it('should throw BadRequestException if no IDs are provided', async () => {
-      await expect(service.delete({ ids: null })).rejects.toThrow(
-        BadRequestException,
-      );
-    });
-
-    it('should delete locale by IDs', async () => {
-      const mockDeleteDTO: DeleteDTO = { ids: [1, 2, 3] };
-      jest
-        .spyOn(prismaService.locale, 'deleteMany')
-        .mockResolvedValue({ count: 3 });
-
-      const result = await service.delete(mockDeleteDTO);
-      expect(result.count).toBe(3);
-    });
-  });
-});

package/src/locale/locale.service.ts

@@ -1,370 +0,0 @@
-import { PaginationDTO, PaginationService } from '@hedhog/pagination';
-import { PrismaService } from '@hedhog/prisma';
-import {
-  BadRequestException,
-  Inject,
-  Injectable,
-  forwardRef,
-} from '@nestjs/common';
-import { CreateDTO } from './dto/create.dto';
-import { DeleteDTO } from './dto/delete.dto';
-import { UpdateDTO } from './dto/update.dto';
-
-@Injectable()
-export class LocaleService {
-  private codes: any = {};
-
-  constructor(
-    @Inject(forwardRef(() => PrismaService))
-    private readonly prismaService: PrismaService,
-    @Inject(forwardRef(() => PaginationService))
-    private readonly paginationService: PaginationService,
-  ) {}
-
-  async setEnabled(codes: string[]) {
-    if (!codes || codes.length < 1) {
-      throw new BadRequestException('You must select at least one item code.');
-    }
-
-    await this.prismaService.locale.updateMany({
-      where: {
-        enabled: true,
-      },
-      data: {
-        enabled: false,
-      },
-    });
-
-    return this.prismaService.locale.updateMany({
-      where: {
-        code: {
-          in: codes,
-        },
-      },
-      data: {
-        enabled: true,
-      },
-    });
-  }
-
-  async getEnables(currentLocale: string, paginationParams: PaginationDTO) {
-    const fields = ['code', 'region'];
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
-      fields,
-      paginationParams,
-    );
-
-    const result = await this.paginationService.paginate(
-      this.prismaService.locale,
-      paginationParams,
-      {
-        where: {
-          AND: [
-            {
-              enabled: true,
-            },
-            {
-              OR,
-            },
-          ],
-        },
-      },
-    );
-
-    const codes = [];
-
-    for (const item of result.data) {
-      codes.push((item as any).code);
-    }
-
-    const { code, region, locale } = this.parseLocale(currentLocale);
-
-    const where: any = {
-      locale: {
-        code,
-      },
-      translation_namespace: {
-        name: 'translation',
-      },
-    };
-
-    if (locale.length > 1) {
-      where.locale.region = region;
-    }
-
-    const values = await this.prismaService.translation.findMany({
-      where,
-      select: {
-        name: true,
-        value: true,
-      },
-    });
-
-    for (let i = 0; i < result.data.length; i++) {
-      for (const value of values) {
-        if (value.name === (result.data[i] as any).code) {
-          (result.data[i] as any).name = value.value;
-          break;
-        }
-      }
-    }
-
-    return result;
-  }
-
-  parseLocale(locale: string) {
-    const localeCodes = locale.toLowerCase().split('-');
-    const code = localeCodes[0];
-    const region = localeCodes[1];
-    return {
-      code,
-      region,
-      locale: localeCodes,
-    };
-  }
-
-  async getTranslations(localeCode: string, namespace: string) {
-    if (!localeCode) {
-      throw new BadRequestException('Locale code is required.');
-    }
-
-    if (!namespace) {
-      namespace = 'translation';
-    }
-
-    const { code, region, locale } = this.parseLocale(localeCode);
-    const where: any = {
-      locale: {
-        code,
-      },
-      translation_namespace: {
-        name: namespace,
-      },
-    };
-
-    if (locale.length > 1) {
-      where.locale.region = region;
-    }
-
-    const values = await this.prismaService.translation.findMany({
-      where,
-      select: {
-        name: true,
-        value: true,
-      },
-    });
-
-    const translation = {};
-
-    for (const value of values) {
-      translation[value.name] = value.value;
-    }
-
-    return translation;
-  }
-
-  async get(currentLocale: string, paginationParams: PaginationDTO) {
-    const fields = ['code', 'region'];
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
-      fields,
-      paginationParams,
-    );
-
-    const result = await this.paginationService.paginate(
-      this.prismaService.locale,
-      paginationParams,
-      {
-        where: {
-          OR,
-        },
-      },
-    );
-
-    const codes = [];
-
-    for (const item of result.data) {
-      codes.push((item as any).code);
-    }
-
-    const { code, region, locale } = this.parseLocale(currentLocale);
-
-    const where: any = {
-      locale: {
-        code,
-      },
-      translation_namespace: {
-        name: 'translation',
-      },
-    };
-
-    if (locale.length > 1) {
-      where.locale.region = region;
-    }
-
-    const values = await this.prismaService.translation.findMany({
-      where,
-      select: {
-        name: true,
-        value: true,
-      },
-    });
-
-    for (let i = 0; i < result.data.length; i++) {
-      for (const value of values) {
-        if (value.name === (result.data[i] as any).code) {
-          (result.data[i] as any).name = value.value;
-          break;
-        }
-      }
-    }
-
-    return result;
-  }
-
-  async getByCode(code: string) {
-    if (this.codes[code]) {
-      return this.codes[code];
-    }
-    return (this.codes[code] = await this.prismaService.locale.findFirst({
-      where: { code },
-    }));
-  }
-
-  async getById(localeId: number) {
-    return this.prismaService.locale.findUnique({
-      where: { id: localeId },
-    });
-  }
-
-  async create(data: CreateDTO) {
-    return this.prismaService.locale.create({
-      data,
-    });
-  }
-
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.prismaService.locale.update({
-      where: { id },
-      data,
-    });
-  }
-
-  async delete({ ids }: DeleteDTO) {
-    if (ids == undefined || ids == null) {
-      throw new BadRequestException(
-        'You must select at least one item to delete.',
-      );
-    }
-
-    return this.prismaService.locale.deleteMany({
-      where: {
-        id: {
-          in: ids,
-        },
-      },
-    });
-  }
-
-  private getTableNameTranslations(modelName: string) {
-    const modelNames = modelName.split('_');
-    modelNames.push('locale');
-    return modelNames.join('_');
-  }
-
-  async createModelWithLocale<T>(
-    modelName: string,
-    foreginKeyName: string,
-    data: T,
-    locale: Record<string, string>,
-  ) {
-    const model = await this.prismaService[modelName].create({
-      data,
-    });
-
-    if (locale) {
-      for (const localeCode of Object.keys(locale)) {
-        const locale = await this.getByCode(localeCode);
-
-        const data: any = {};
-
-        for (const key of Object.keys(locale[localeCode])) {
-          data[key] = locale[localeCode][key];
-        }
-
-        await this.prismaService[
-          this.getTableNameTranslations(modelName)
-        ].create({
-          data: {
-            [foreginKeyName]: model.id,
-            locale_id: locale.id,
-            ...data,
-          },
-        });
-      }
-    }
-
-    return this.prismaService[modelName].findUnique({
-      where: { id: model.id },
-      include: {
-        [this.getTableNameTranslations(modelName)]: {
-          where: {
-            locale: {
-              enabled: true,
-            },
-          },
-          include: {
-            locale: {
-              select: {
-                code: true,
-              },
-            },
-          },
-        },
-      },
-    });
-  }
-
-  async updateModelWithLocale<T extends any>(
-    modelName: string,
-    foreginKeyName: string,
-    id: number,
-    data: T,
-    locale: Record<string, string>,
-  ) {
-    if (locale) {
-      for (const localeCode of Object.keys(locale)) {
-        const locale = await this.getByCode(localeCode);
-
-        const data: any = {};
-
-        for (const key of Object.keys(locale[localeCode])) {
-          data[key] = locale[localeCode][key];
-        }
-
-        await this.prismaService[
-          this.getTableNameTranslations(modelName)
-        ].upsert({
-          where: {
-            [`${foreginKeyName}_locale_id`]: {
-              [foreginKeyName]: id,
-              locale_id: locale.id,
-            },
-          },
-          create: {
-            [foreginKeyName]: id,
-            locale_id: locale.id,
-            ...data,
-          },
-          update: {
-            ...data,
-          },
-        });
-      }
-    }
-
-    return this.prismaService[modelName].update({
-      where: { id },
-      data,
-    });
-  }
-}

package/src/role/decorators/role.decorator.ts

@@ -1,4 +0,0 @@
-import { SetMetadata } from '@nestjs/common';
-
-export const WITH_ROLE = 'withRole';
-export const Role = () => SetMetadata(WITH_ROLE, true);