@maioradv/nestjs-core 1.0.1

package/README.md

@@ -0,0 +1 @@
+

package/index.ts

@@ -0,0 +1 @@
+export * from './dist';

package/lib/decorators/api-response-with-rels.decorator.ts

@@ -0,0 +1,75 @@
+import { Type, applyDecorators } from "@nestjs/common";
+import { ApiExtraModels, ApiResponse, ApiResponseMetadata, getSchemaPath } from "@nestjs/swagger";
+import { WithRequired } from "../utils/types.helper";
+import { ReferenceObject, SchemaObject } from "@nestjs/swagger/dist/interfaces/open-api-spec.interface";
+
+export type TModel = Type<any> | [string,Type<any>]
+export type RelationDefs = {
+  oneToOne?: TModel[],
+  oneToMany?: TModel[],
+  manyToMany?: [TModel,TModel|TModel[]][],
+}
+
+export type ApiReponseWithRelsOptions = WithRequired<ApiResponseMetadata,'type'>
+
+export const ApiResponseWithRels = (
+  options: ApiReponseWithRelsOptions,
+  relations: RelationDefs
+) => {
+  const {type, ...rest} = options
+  const Model = type as Type<any> 
+  const {properties,extraModels} = handleRelationsForSwagger(relations)
+  return applyDecorators(
+    ApiExtraModels(...extraModels),
+    ApiResponse({
+      ...rest,
+      schema:{
+        title: `${Model.name}`,
+        allOf: [
+          { $ref: getSchemaPath(Model) },
+          {
+            properties:properties
+          }
+        ],
+      }
+    }),
+  );
+};
+
+export function handleRelationsForSwagger(relations: RelationDefs): {
+  properties:Record<string,SchemaObject | ReferenceObject>,
+  extraModels:Type<any>[]
+} {
+  let properties:Record<string,SchemaObject | ReferenceObject> = {}
+  let extraModels:Type<any>[] = []
+  relations.oneToMany?.forEach((T) => {
+    const [name,schema] = Array.isArray(T) ? T : [T.name,T]
+    properties[`${name}`] = {
+      type:'array',
+      items: { $ref: getSchemaPath(schema) }
+    }
+    extraModels.push(schema)
+  })
+  relations.oneToOne?.forEach((T) => {
+    const [name,schema] = Array.isArray(T) ? T : [T.name,T]
+    properties[`${name}`] = { $ref: getSchemaPath(schema) }
+    extraModels.push(schema)
+  })
+  relations.manyToMany?.forEach((TCouple) => {
+    const [T,S] = TCouple
+    const [name,schema] = Array.isArray(T) ? T : [T.name,T]
+    const models = Array.isArray(S) ? S : [S]
+    let rels:Record<string,SchemaObject | ReferenceObject> = {}
+    models.forEach(M => {
+      const [name,schema] = Array.isArray(M) ? M : [M.name,M]
+      rels[`${name}`] = { $ref: getSchemaPath(schema) }
+      extraModels.push(schema)
+    })
+    properties[`${name}`] = {
+      type:'array',
+      items: { $ref: getSchemaPath(schema), properties:rels }
+    }
+    extraModels.push(schema)
+  })
+  return {properties,extraModels}
+}

package/lib/decorators/index.ts

@@ -0,0 +1 @@
+export * from './api-response-with-rels.decorator'

package/lib/dto/clauses/index.ts

@@ -0,0 +1,2 @@
+export * from './standard-clauses.decorator'
+export * from './model'

package/lib/dto/clauses/model.ts

@@ -0,0 +1,15 @@
+//export type WhereClause = number | number[] | string | string[] | Date | boolean;
+
+export interface DefaultClausesI {
+  id?:number[];
+  createdAt?:Date;
+  updatedAt?:Date;
+  minCreatedAt?:Date;
+  maxCreatedAt?:Date;
+  minUpdatedAt?:Date;
+  maxUpdatedAt?:Date;
+}
+
+export type WhereClausesOf<T, P extends keyof T = Exclude<keyof T,keyof DefaultClausesI | 'metafields' | 'translations'>> = {
+  [K in P]?: T[K] | T[K][]
+}

package/lib/dto/clauses/standard-clauses.decorator.ts

@@ -0,0 +1,80 @@
+import { applyDecorators, Type as TypeI } from "@nestjs/common";
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { Transform, Type } from "class-transformer";
+import { IsArray, IsBoolean, IsDate, IsEnum, IsNumber, IsOptional, IsString } from "class-validator";
+
+export const IsStringClause = (
+
+) => {
+  return applyDecorators(
+    ApiPropertyOptional({
+      type:String,
+      description:'Check if field contains the string'
+    }),
+    IsOptional(),
+    IsString()
+  );
+};
+
+export const IsEnumClause = (
+  model: object,
+) => {
+  return applyDecorators(
+    ApiPropertyOptional({
+      enum:model,
+      description:'A string or a comma-separated list of strings'
+    }),
+    Transform(({value}:{value:string}) => value.split(',')),
+    IsOptional(),
+    IsEnum(model,{each:true}),
+    IsArray()
+  );
+};
+
+export const IsNumberClause = (
+
+) => {
+  return applyDecorators(
+    ApiPropertyOptional({
+      type:Number,
+      description:'A number or a comma-separated list of numbers'
+    }),
+    Transform(({value}:{value:string}) => value.split(',').map(str => +str)),
+    IsOptional(),
+    IsNumber({allowNaN:false},{each: true}),
+    IsArray()
+  );
+};
+
+export const IsBooleanClause = (
+
+  ) => {
+    return applyDecorators(
+      ApiPropertyOptional({
+        type:Boolean,
+      }),
+      Transform(({value}:{value:string}) => {
+        return value === 'true' ? true : 
+          value === 'false' ? false : 
+          value === '1' ? true :
+          value === '0' ? false :
+          value ? true : false
+      }),
+      IsOptional(),
+      IsBoolean()
+    );
+  };
+
+export const IsDateStringClause = (
+  
+) => {
+  return applyDecorators(
+    ApiPropertyOptional({
+      type:Date,
+      description:'A date string in ISO8601 format',
+    }),
+    Type(() => Date),
+    IsOptional(),
+    IsDate()
+  );
+};

package/lib/dto/index.ts

@@ -0,0 +1,3 @@
+export * from './clauses'
+export * from './sorting'
+export * from './pagination'

package/lib/dto/pagination/cursor-meta.dto.ts

@@ -0,0 +1,38 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Field, ObjectType, Int } from '@nestjs/graphql'
+
+@ObjectType()
+export default class CursorMetaDto {
+  @ApiProperty()
+  @Field(() => Int,{ nullable: true })
+  readonly startCursor: number;
+
+  @ApiProperty()
+  @Field(() => Int,{ nullable: true })
+  readonly endCursor: number; 
+
+  @ApiProperty()
+  @Field()
+  readonly hasPreviousPage: boolean;
+
+  @ApiProperty()
+  @Field()
+  readonly hasNextPage: boolean;
+
+  constructor({ 
+    first,
+    last,
+    start,
+    end 
+  }:{ 
+    first: number|undefined,
+    last: number|undefined,
+    start: number|undefined,
+    end: number|undefined,
+  }) {
+    if(start) this.startCursor = start;
+    if(end) this.endCursor = end;
+    this.hasPreviousPage = start ? (start !== first) : false
+    this.hasNextPage = end ? (end !== last) : false
+  }
+}

package/lib/dto/pagination/cursor-paginated.dto.ts

@@ -0,0 +1,68 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { Type } from '@nestjs/common';
+import CursorMetaDto from './cursor-meta.dto'
+
+interface IEdgeType<T> {
+  cursor: string;
+  node: T;
+}
+
+export interface IPaginatedType<T> {
+  edges: IEdgeType<T>[];
+  nodes: T[];
+  meta: CursorMetaDto;
+}
+
+export function PaginatedGQL<T>(classRef: Type<T>): Type<IPaginatedType<T>> {
+  @ObjectType(`${classRef.name}Edge`)
+  abstract class EdgeType {
+    @Field(() => String)
+    cursor: string;
+
+    @Field(() => classRef)
+    node: T;
+  }
+
+  @ObjectType({ isAbstract: true })
+  abstract class PaginatedType implements IPaginatedType<T> {
+    @Field(() => [EdgeType], { nullable: true })
+    edges: EdgeType[];
+
+    @Field(() => [classRef], { nullable: true })
+    nodes: T[];
+
+    @Field(() => CursorMetaDto, { nullable: true })
+    meta: CursorMetaDto;
+  }
+  return PaginatedType as Type<IPaginatedType<T>>;
+}
+
+export type CursorMeta = {
+  first:number|undefined
+  last:number|undefined
+}
+
+export class PaginatedGQLDto<T> implements IPaginatedType<T>{
+  readonly edges: IEdgeType<T>[];
+  readonly nodes: T[];
+  readonly meta: CursorMetaDto;
+
+  constructor(data: T[], meta: CursorMeta) {
+    this.edges = this.getEdges(data)
+    this.nodes = data
+    this.meta = new CursorMetaDto({
+      ...meta,
+      start: +this.edges[0]?.cursor,
+      end: +this.edges[this.edges.length-1]?.cursor
+    })
+  }
+
+  private getEdges(data: T[]) {
+    return data.map((value) => {
+      return {
+        node: value,
+        cursor: (value as any).id,
+      };
+    });
+  }
+}

package/lib/dto/pagination/cursor-query.dto.ts

@@ -0,0 +1,64 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsInt, IsNumber, IsOptional, Max, Min } from "class-validator";
+import { Int, Field, ArgsType } from '@nestjs/graphql';
+
+@ArgsType()
+export default class CursorQueryDto {
+  @ApiProperty({
+    required:false,
+  })
+  @Field(() => Int,{nullable:true})
+  @IsNumber()
+  @IsOptional()
+  @IsInt()
+  @Type(() => Number)
+  readonly after?:number;
+
+  @ApiProperty({
+    required:false,
+  })
+  @Field(() => Int,{nullable:true})
+  @IsNumber()
+  @IsOptional()
+  @IsInt()
+  @Type(() => Number)
+  readonly before?:number;
+
+  @ApiProperty({
+    required:false,
+    minimum: 1,
+    maximum: 250,
+    default: 50,
+  })
+  @Field(() => Int,{nullable:true})
+  @IsNumber()
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(250)
+  @Type(() => Number)
+  readonly limit?:number = 50;
+
+  get skip(): number {
+    if(this.after || this.before) return 1;
+    return 0;
+  }
+
+  get take(): number {
+    if(this.before) return -this.limit;
+    return this.limit;
+  }
+
+  get order():Record<string,any> {
+    return {
+      id: 'asc'
+    }
+  }
+
+  get cursor() {
+    return this.after || this.before ? {
+      id: this.after ?? this.before
+    } : undefined
+  }
+}

package/lib/dto/pagination/index.ts

@@ -0,0 +1,16 @@
+import ApiPaginatedResponse from "./paginated-response.decorator";
+import PaginatedMetaDto from "./paginated-meta.dto";
+import PaginatedQueryDto from "./paginated-query.dto";
+import PaginatedDto from "./paginated.dto";
+import CursorQueryDto from "./cursor-query.dto";
+export * from './cursor-paginated.dto'
+
+export * from './model'
+
+export {
+  ApiPaginatedResponse,
+  PaginatedMetaDto,
+  PaginatedQueryDto,
+  CursorQueryDto,
+  PaginatedDto
+}

package/lib/dto/pagination/model.ts

@@ -0,0 +1,7 @@
+export interface PaginatedQueryI {
+  readonly page?:number;
+  readonly limit?:number;
+
+  get skip(): number;
+  get take(): number;
+} 

package/lib/dto/pagination/paginated-meta.dto.ts

@@ -0,0 +1,37 @@
+import { ApiProperty } from "@nestjs/swagger";
+import PaginatedQueryDto from "./paginated-query.dto";
+
+export default class PaginatedMetaDto {
+  @ApiProperty()
+  readonly page: number;
+
+  @ApiProperty()
+  readonly take: number;
+
+  @ApiProperty()
+  readonly itemCount: number;
+
+  @ApiProperty()
+  readonly pageCount: number;
+
+  @ApiProperty()
+  readonly hasPreviousPage: boolean;
+
+  @ApiProperty()
+  readonly hasNextPage: boolean;
+
+  constructor({ 
+    paginatedQueryDto, 
+    itemCount 
+  }:{ 
+    paginatedQueryDto: PaginatedQueryDto,
+    itemCount: number
+  }) {
+    this.page = paginatedQueryDto.page;
+    this.take = paginatedQueryDto.take;
+    this.itemCount = itemCount;
+    this.pageCount = Math.ceil(this.itemCount / this.take);
+    this.hasPreviousPage = this.page > 1;
+    this.hasNextPage = this.page < this.pageCount;
+  }
+}

package/lib/dto/pagination/paginated-query.dto.ts

@@ -0,0 +1,40 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsInt, IsNumber, IsOptional, Max, Min } from "class-validator";
+import { PaginatedQueryI } from "./model";
+
+export default class PaginatedQueryDto implements PaginatedQueryI {
+  @ApiProperty({
+    required:false,
+    minimum: 1,
+    default: 1,
+  })
+  @IsNumber()
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Type(() => Number)
+  readonly page?:number = 1;
+
+  @ApiProperty({
+    required:false,
+    minimum: 1,
+    maximum: 250,
+    default: 50,
+  })
+  @IsNumber()
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(250)
+  @Type(() => Number)
+  readonly limit?:number = 50;
+
+  get skip(): number {
+    return (this.page - 1) * this.limit;
+  }
+
+  get take(): number {
+    return this.limit;
+  }
+}

package/lib/dto/pagination/paginated-response.decorator.ts

@@ -0,0 +1,49 @@
+import { HttpStatus, Type, applyDecorators } from "@nestjs/common";
+import { ApiExtraModels, ApiOkResponse, ApiResponseOptions, getSchemaPath } from "@nestjs/swagger";
+import PaginatedMetaDto from "./paginated-meta.dto";
+import PaginatedDto from "./paginated.dto";
+import { RelationDefs, handleRelationsForSwagger } from "@/decorators";
+
+const ApiPaginatedResponse = <TModel extends Type<any>>(
+  model: TModel,
+  relations?:RelationDefs,
+  options?: ApiResponseOptions,
+) => {
+  const {properties,extraModels} = relations ? handleRelationsForSwagger(relations) : {properties:undefined,extraModels:[]}
+  return applyDecorators(
+    ApiExtraModels(PaginatedMetaDto, PaginatedDto, model, ...extraModels),
+    ApiOkResponse({
+      status:HttpStatus.OK,
+      description:`${model.name}s`,
+      schema: {
+        title: `Paginated${model.name}Dto`,
+        allOf: [
+          { $ref: getSchemaPath(PaginatedDto) },
+          {
+            properties: {
+              data: {
+                
+                type: 'array',
+                items: { 
+                  title:`${model.name}s`,
+                  allOf:[
+                    { $ref: getSchemaPath(model) },
+                    {
+                      properties:properties
+                    }
+                  ]
+                },          
+              },
+              meta: {
+                $ref: getSchemaPath(PaginatedMetaDto)
+              },
+            },
+          },
+        ],
+      },
+      ...options
+    }),
+  );
+};
+
+export default ApiPaginatedResponse

package/lib/dto/pagination/paginated.dto.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from "@nestjs/swagger";
+import PaginatedMetaDto from "./paginated-meta.dto";
+
+export default class PaginatedDto<T> {
+  @ApiProperty()
+  readonly data: T[];
+
+  @ApiProperty()
+  readonly meta: PaginatedMetaDto;
+
+  constructor(data: T[], meta: PaginatedMetaDto) {
+    this.data = data
+    this.meta = meta
+  }
+}

package/lib/dto/pagination/pagination-params.decorator.ts

@@ -0,0 +1,21 @@
+import { Type, applyDecorators } from "@nestjs/common";
+import { ApiExtraModels, ApiQuery, getSchemaPath } from "@nestjs/swagger";
+import PaginatedQueryDto from "./paginated-query.dto";
+
+const ApiPaginationParams = <TModel extends Type<any>>() => {
+  return applyDecorators(
+    ApiExtraModels(PaginatedQueryDto),
+    ApiQuery({
+      required: false,
+      name: 'pagination',
+      style: 'deepObject',
+      explode: true,
+      type: 'object',
+      schema: {
+        $ref: getSchemaPath(PaginatedQueryDto),
+      },
+    })
+  );
+};
+
+export default ApiPaginationParams

package/lib/dto/sorting/enums.ts

@@ -0,0 +1,4 @@
+export enum Sorting {
+  asc = 'asc',
+  desc = 'desc'
+}

package/lib/dto/sorting/index.ts

@@ -0,0 +1,3 @@
+export * from './enums'
+export * from './sorting-params.decorator'
+export * from './models'

package/lib/dto/sorting/models.ts

@@ -0,0 +1,47 @@
+import { IsEnum, IsOptional } from 'class-validator';
+import { Sorting } from '@/dto/sorting';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class SortingDto implements DefaultSortingI {
+  @ApiPropertyOptional({enum: Sorting})
+  @IsEnum(Sorting)
+  @IsOptional()
+  id?: Sorting;
+
+  @ApiPropertyOptional({enum: Sorting})
+  @IsEnum(Sorting)
+  @IsOptional()
+  createdAt?: Sorting;
+
+  @ApiPropertyOptional({enum: Sorting})
+  @IsEnum(Sorting)
+  @IsOptional()
+  updatedAt?: Sorting;
+
+  get orderBy() {
+    return Object.entries(this).map(entry => {
+      return {[entry[0]]: entry[1]};
+    });
+  }
+
+  get orderByRDB() {
+    return Object.entries(this).map(entry => {
+      return {column:entry[0], order:entry[1]};
+    });
+  }
+}
+
+export interface DefaultSortingI {
+  id?: Sorting;
+  createdAt?: Sorting;
+  updatedAt?: Sorting;
+  get orderBy();
+}
+
+export interface SortingQueryI<T extends SortingDto> {
+  sorting?:T
+}
+
+export type SortingFieldsOf<T, P extends keyof T = Exclude<keyof T,keyof DefaultSortingI | 'metafields' | 'translations'>> = {
+  [K in P]?: Sorting
+}

package/lib/dto/sorting/sorting-params.decorator.ts

@@ -0,0 +1,35 @@
+import { Type as TypeI, applyDecorators } from "@nestjs/common";
+import { ApiExtraModels, ApiPropertyOptional, ApiQuery, getSchemaPath } from "@nestjs/swagger";
+import { Transform, Type, plainToClass } from "class-transformer";
+import { IsOptional, ValidateNested } from "class-validator";
+
+export const ApiSortingParams = <TModel extends TypeI<any>>(
+  model: TModel,
+) => {
+  return applyDecorators(
+    ApiExtraModels(model),
+    ApiQuery({
+      required: false,
+      name: 'sorting',
+      style: 'deepObject',
+      explode: true,
+      type: 'object',
+      example:'',
+      schema: {
+        $ref: getSchemaPath(model),
+      },
+    })
+  );
+};
+
+export const IsSortingObject = <TModel extends TypeI<any>>(
+  model: TModel,
+) => {
+  return applyDecorators(
+    ApiPropertyOptional({type:model}),
+    ValidateNested(),
+    Transform(({value}) => plainToClass(model, JSON.parse(value))),
+    Type(() => model),
+    IsOptional()
+  );
+};

package/lib/errors/index.ts

@@ -0,0 +1 @@
+export * from './validation.error'

package/lib/errors/validation.error.ts

@@ -0,0 +1,9 @@
+import { BadRequestException } from "@nestjs/common";
+
+export const VALIDATION_EXCEPTION_CODE = 'VALIDATION_ERROR'
+
+export class ValidationException extends BadRequestException {
+  constructor(objectOrError?: any) {
+    super(objectOrError,VALIDATION_EXCEPTION_CODE);
+  }
+}

package/lib/filters/all-exception.filter.ts

@@ -0,0 +1,33 @@
+import { ExceptionFilter, Catch, ArgumentsHost, HttpStatus } from '@nestjs/common';
+import { GqlContextType } from '@nestjs/graphql';
+import { Request, Response } from 'express';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  catch(exception: any, host: ArgumentsHost): void {
+    if(host.getType<GqlContextType>() === 'graphql') {
+      return exception;
+    }
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+    const status = HttpStatus.INTERNAL_SERVER_ERROR;
+
+    const data = process.env.NODE_ENV == 'development' ? {
+      statusCode: status,
+      method: request.method,
+      path: request.url,
+      type: exception.name,
+      code: exception.code,
+      message: exception.message ?? 'Internal Server Error',
+      stack: exception.stack?.split('\n')
+    } : {
+      statusCode: status,
+      message: 'Internal Server Error',
+    }
+    
+    response
+      .status(status)
+      .send(data);
+  }
+}

package/lib/filters/http-exception.filter.ts

@@ -0,0 +1,32 @@
+import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
+import { GqlContextType } from '@nestjs/graphql';
+import { Request, Response } from 'express';
+
+@Catch(HttpException)
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception: HttpException, host: ArgumentsHost) {
+    if(host.getType<GqlContextType>() === 'graphql') {
+      return exception;
+    }
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+    const status = exception.getStatus();
+
+    const data = process.env.NODE_ENV == 'development' ? {
+      statusCode: status,
+      method: request.method,
+      path: request.url,
+      type: exception.name,
+      message: exception.message,
+      stack: exception.stack?.split('\n')
+    } : {
+      statusCode: status,
+      message: exception.message,
+    }
+   
+    response
+      .status(status)
+      .send(data);
+  }
+}

package/lib/filters/index.ts

@@ -0,0 +1,3 @@
+export * from './all-exception.filter'
+export * from './http-exception.filter'
+export * from './validation-exception.filter'

package/lib/filters/validation-exception.filter.ts

@@ -0,0 +1,21 @@
+import { ExceptionFilter, Catch, ArgumentsHost, HttpException, BadRequestException } from '@nestjs/common';
+import { GqlContextType } from '@nestjs/graphql';
+import { Request, Response } from 'express';
+import { ValidationException } from '../errors/validation.error';
+
+@Catch(BadRequestException)
+export class ValidationExceptionFilter implements ExceptionFilter {
+  catch(exception: BadRequestException, host: ArgumentsHost) {
+    if(host.getType<GqlContextType>() === 'graphql') {
+      return exception;
+    }
+    
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const status = exception.getStatus();
+   
+    response
+      .status(status)
+      .send(exception['response']);
+  }
+}

package/lib/index.ts

@@ -0,0 +1,6 @@
+export * from './utils'
+export * from './decorators'
+export * from './dto'
+export * from './errors'
+export * from './filters'
+export * from './logger'

package/lib/logger/index.ts

@@ -0,0 +1 @@
+export * from './logger-factory'

package/lib/logger/logger-factory.ts

@@ -0,0 +1,42 @@
+import { LoggerService } from '@nestjs/common';
+import { WinstonModule, WinstonModuleOptions, utilities } from 'nest-winston';
+import { format, transports } from 'winston';
+import DailyRotateFile from "winston-daily-rotate-file";
+import { joinFromRoot } from '../utils';
+
+export const LoggerFactory = (appName: string): LoggerService => {
+  return WinstonModule.createLogger(LoggerFactoryOptions(appName))
+}
+
+export const LoggerFactoryOptions = (appName:string): WinstonModuleOptions => {
+  const relativePath = `../logs/${appName}`
+  return {
+    transports: [
+      new DailyRotateFile({
+        filename: joinFromRoot(relativePath,`%DATE%-error.log`), 
+        level: 'error',
+        format: format.combine(format.timestamp({format:'YYYY-MM-DDTHH:mm:ssZZ'}), format.ms(), format.json()),
+        datePattern: 'YYYY-MM-DD',
+        zippedArchive: true,
+        maxFiles: '30d',
+      }),
+      new DailyRotateFile({
+        filename: joinFromRoot(relativePath,`%DATE%-combined.log`),
+        format: format.combine(format.timestamp({format:'YYYY-MM-DDTHH:mm:ssZZ'}), format.ms(), format.json()),
+        datePattern: 'YYYY-MM-DD',
+        zippedArchive: true,
+        maxFiles: '30d',
+      }),
+      new transports.Console({
+        format: format.combine(
+          format.timestamp(),
+          format.ms(),
+          utilities.format.nestLike(appName, {
+            colors: true,
+            prettyPrint: true,
+          }),
+        ),
+      }),
+    ],
+  }
+}

package/lib/utils/chunk.helper.ts

@@ -0,0 +1,4 @@
+export const chunk = <T>(arr:T[], size:number): (T[])[] =>
+  Array.from({ length: Math.ceil(arr.length / size) }, (v, i) =>
+    arr.slice(i * size, i * size + size)
+  );

package/lib/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './chunk.helper'
+export * from './path.helper'
+export * from './slug.helper'
+export * from './storage.helper'
+export * from './types.helper'

package/lib/utils/path.helper.ts

@@ -0,0 +1,5 @@
+import { join } from 'path';
+
+export const ROOT_PATH = join(__dirname,'..','../../')
+
+export const joinFromRoot = (...paths:string[]):string => join(ROOT_PATH,...paths)

package/lib/utils/slug.helper.ts

@@ -0,0 +1,22 @@
+export default class Slugger {
+  private unique;
+  constructor(private readonly word: string) {}
+
+  public get(): string {
+    return this.word.trim().normalize("NFD").replace(/[\u0300-\u036f]/g, '').replace(/[^a-z0-9\s]/gi, '').replaceAll(' ','-').toLowerCase() + (this.unique ? '-'+this.randomString(5) : '')
+  }
+
+  public makeUnique() {
+    this.unique = true
+  }
+
+  private randomString(length:number) {
+    let result = '';
+    const characters = 'abcdefghijklmnopqrstuvwxyz';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+  }
+}

package/lib/utils/storage.helper.ts

@@ -0,0 +1,39 @@
+import * as fs from 'fs';
+import { promisify } from 'util';
+import { join, dirname } from 'path';
+import { EOL } from 'os';
+
+export default class StorageHelper {
+  public rootPath = join(__dirname,'..','../../public')
+
+  public async read(path:string): Promise<string | Buffer> {
+    const realPath = join(this.rootPath,path)
+    const readFile = promisify(fs.readFile);
+    return await readFile(realPath, {});
+  }
+
+  public async write(path:string,data:string): Promise<void> {
+    const realPath = join(this.rootPath,path)
+    this.safeDirectory(realPath)
+    const writeFile = promisify(fs.writeFile);
+    return await writeFile(realPath, data, 'utf8');
+  }
+
+  public async append(path:string,data:string): Promise<void> {
+    const realPath = join(this.rootPath,path)
+    this.safeDirectory(realPath)
+    const appendFile = promisify(fs.appendFile);
+    return await appendFile(realPath, data + EOL);
+  }
+
+  public async delete(path:string): Promise<void> {
+    const realPath = join(this.rootPath,path)
+    const unlink = promisify(fs.unlink);
+    return fs.existsSync(realPath) ? await unlink(realPath) : null;
+  }
+
+  private safeDirectory(path:string) {
+    const dirPath = dirname(path)
+    if(!fs.existsSync(dirPath)) fs.mkdirSync(dirPath,{recursive:true});
+  }
+}

package/lib/utils/types.helper.ts

@@ -0,0 +1,3 @@
+export type ExcludeMethods<T> = { [K in keyof T as (T[K] extends Function ? never : K)]: T[K] }
+export type WithRelations<T,R extends object> = T & R
+export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] }

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@maioradv/nestjs-core",
+  "version": "1.0.1",
+  "description": "NestJS helpers by MaiorADV",
+  "repository": "https://github.com/maioradv/nestjs-core.git",
+  "author": "Maior ADV Srl",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "build": "tsc",
+    "prepublish:npm": "npm run build",
+    "publish:npm": "npm publish --access public",
+    "prepublish:next": "npm run build",
+    "publish:next": "npm publish --access public --tag next"
+  },
+  "dependencies": {
+    "@nestjs/common": "^10.3.8",
+    "@nestjs/graphql": "^12.1.1",
+    "@nestjs/swagger": "^7.3.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "express": "^4.19.2",
+    "nest-winston": "^1.10.0",
+    "ts-node": "^10.9.2",
+    "winston": "^3.13.0",
+    "winston-daily-rotate-file": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.13",
+    "typescript": "^5.4.5"
+  },
+  "peerDependencies": {}
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "noLib": false,
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "target": "ES2021",
+    "sourceMap": false,
+    "outDir": "./dist",
+    "rootDir": "./lib",
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["./lib/*"],
+    }
+  },
+  "include": ["lib/**/*"],
+  "exclude": ["node_modules", "**/*.spec.ts", "tests"]
+}