@jrosadob/ms-sophia-framework-mysql 0.0.2 → 0.0.4

package/libs/ms-sophia-framework-mysql/src/core/common/exceptions/app-badrequest.exception.ts

@@ -1,31 +0,0 @@
-import { BadRequestException, HttpStatus, Logger } from '@nestjs/common';
-// import { nanoid } from 'src/core/tools';
-import { BadRequestResult } from '../result/bad-request.result';
-import { nanoid } from '../../tools';
-
-export class AppBadRequestException extends BadRequestException {
-  constructor(message: string) {
-    super(message);
-  }
-
-  getResponse(): BadRequestResult {
-    const response = super.getResponse();
-    const loggerId = nanoid();
-    if (typeof response === 'string') {
-      Logger.log(`[${loggerId}]: ${response}`, 'AppBadRequestException');
-      return {
-        message: response,
-        error: 'Bad Request',
-        statusCode: HttpStatus.BAD_REQUEST,
-        loggerId: loggerId,
-      } as BadRequestResult;
-    }
-    // @ts-ignore: This line is to ignore the TypeScript error in response.message and response.error
-    const message = response.message ?? response.error;
-    Logger.log(`[${loggerId}]: ${message}`, 'AppBadRequestException');
-    return {
-      ...response,
-      loggerId: loggerId,
-    } as BadRequestResult;
-  }
-}

package/libs/ms-sophia-framework-mysql/src/core/common/exceptions/app-http.exception.ts

@@ -1,35 +0,0 @@
-import { HttpException, HttpStatus, Logger } from '@nestjs/common';
-// import { nanoid } from 'src/core/tools';
-import { Result } from '../base/result';
-import { nanoid } from '../../tools';
-
-export class AppHttpException extends HttpException {
-  constructor(e: any, result: Result<any>) {
-    const loggerId = nanoid();
-    let status: HttpStatus;
-    let loggerMessage: string;
-
-    const errorType = e.constructor.name;
-    switch (errorType) {
-      case 'QueryFailedError':
-        status = HttpStatus.BAD_REQUEST;
-        super(result, status);
-        result.entity = undefined;
-        result.entities = undefined;
-        loggerMessage = `[${loggerId}] SqlState: ${e.driverError.sqlState} | QueryFailedError: ${e.driverError.sqlMessage}`;
-        Logger.log(loggerMessage, 'AppHttpException');
-        result.addError(loggerId, 400, 'Database error (QueryFailedError)');
-        break;
-      default:
-        status = HttpStatus.SERVICE_UNAVAILABLE;
-        super(result, status);
-        result.entity = undefined;
-        result.entities = undefined;
-        loggerMessage = `[${loggerId}] ${e.message}`;
-        Logger.log(loggerMessage, 'AppHttpException');
-        result.addError(loggerId, 503, 'Service unavailable');
-        break;
-    }
-    // super(result, status)
-  }
-}

package/libs/ms-sophia-framework-mysql/src/core/common/exceptions/app-unauthorized.exception.ts

@@ -1,36 +0,0 @@
-import { UnauthorizedException, Logger, HttpStatus } from '@nestjs/common';
-// import { nanoid } from 'src/core/tools';
-import { UnauthorizedResult } from '../result/unauthorized.result';
-import { nanoid } from '../../tools';
-
-const Logging = new Logger('AppUnauthorizedException');
-
-export class AppUnauthorizedException extends UnauthorizedException {
-  constructor(message: string) {
-    super(message);
-  }
-
-  getResponse(): UnauthorizedResult {
-    const response = super.getResponse();
-    const loggerId = nanoid();
-    if (typeof response === 'string') {
-      Logging.log(`[${loggerId}]: ${response}`);
-      return {
-        message: response,
-        error: 'Unauthorized',
-        statusCode: HttpStatus.UNAUTHORIZED,
-        loggerId: loggerId,
-      } as UnauthorizedResult;
-    }
-    // @ts-ignore: This line is to ignore the TypeScript error
-    Logging.log(`[${loggerId}]: ${response.message ?? response.error}`);
-
-    return {
-      error: 'Unauthorized',
-      // @ts-ignore: This line is to ignore the TypeScript error
-      message: response.message,
-      statusCode: HttpStatus.UNAUTHORIZED,
-      loggerId: loggerId,
-    } as UnauthorizedResult;
-  }
-}

package/libs/ms-sophia-framework-mysql/src/core/common/filters/all-exception.filter.ts

@@ -1,42 +0,0 @@
-import {
-  ExceptionFilter,
-  Catch,
-  ArgumentsHost,
-  HttpException,
-  HttpStatus,
-  Logger,
-} from '@nestjs/common';
-import { Response } from 'express';
-import { nanoid } from '../../tools';
-// import { nanoid } from 'src/core/tools';
-
-@Catch()
-export class AllExceptionsFilter implements ExceptionFilter {
-  catch(exception: unknown, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
-
-    const status =
-      exception instanceof HttpException
-        ? exception.getStatus()
-        : HttpStatus.INTERNAL_SERVER_ERROR;
-
-    const message =
-      exception instanceof HttpException ? exception.getResponse() : exception;
-
-    const loggerId = nanoid();
-    const loggerMessage = `[${loggerId}] ${message}`;
-    Logger.error({ message: loggerMessage, context: 'AllExceptionsFilter' });
-
-    response.status(status).json({
-      hasError: true,
-      errors: [
-        {
-          message: message,
-          statusCode: status,
-          loggerId: loggerId,
-        },
-      ],
-    });
-  }
-}

package/libs/ms-sophia-framework-mysql/src/core/common/pipes/app-validation.pipe.ts

@@ -1,35 +0,0 @@
-import {
-  ValidationPipe,
-  ValidationError,
-  BadRequestException,
-  HttpStatus,
-  ValidationPipeOptions,
-} from '@nestjs/common';
-import { BadRequestResult } from '../result/bad-request.result';
-import { PropertyResult } from '../result/property.result';
-import { nanoid } from '../../tools';
-//import { nanoid } from 'src/core/tools';
-
-export class AppValidationPipe extends ValidationPipe {
-  constructor(options?: ValidationPipeOptions) {
-    super(options);
-  }
-
-  createExceptionFactory() {
-    return (validationErrors: ValidationError[] = []) => {
-      const loggerId = nanoid();
-      const customErrors = validationErrors.map((error) => ({
-        property: error.property,
-        message: Object.values(error.constraints || {}).join(', '),
-      }));
-
-      return new BadRequestException({
-        error: 'Bad Request',
-        message: 'Validation failed',
-        statusCode: HttpStatus.BAD_REQUEST,
-        errors: [...customErrors] as PropertyResult[],
-        loggerId: loggerId,
-      } as BadRequestResult);
-    };
-  }
-}

package/libs/ms-sophia-framework-mysql/src/core/common/result/bad-request.result.ts

@@ -1,17 +0,0 @@
-import { ApiProperty } from '@nestjs/swagger'
-import { PropertyResult } from './property.result'
-
-export class BadRequestResult {
-  @ApiProperty({ description: 'Mensaje de error' })
-  message: string
-  @ApiProperty({
-    description: 'Nombre del error según StatusCode, p.e: BAD REQUEST, NOT FOUND, CREATED, etc',
-  })
-  error: string
-  @ApiProperty({ description: 'Código de error HttpStatusCode: 200, 201, 400, 401, etc.' })
-  statusCode: number
-  @ApiProperty({ description: 'loggerId del mensaje de error, para ubicarlo en el Logger' })
-  loggerId: string
-  @ApiProperty({ description: 'Array de errores de validación', type: [PropertyResult] })
-  errors: PropertyResult[] | null
-}

package/libs/ms-sophia-framework-mysql/src/core/common/result/property.result.ts

@@ -1,8 +0,0 @@
-import { ApiProperty } from '@nestjs/swagger'
-
-export class PropertyResult {
-  @ApiProperty({ description: 'Nombre de la property que no cumple con la validación' })
-  property: string
-  @ApiProperty({ description: 'Descripción de la validación que la property no cumple' })
-  message: string
-}

package/libs/ms-sophia-framework-mysql/src/core/common/result/unauthorized.result.ts

@@ -1,14 +0,0 @@
-import { ApiProperty } from '@nestjs/swagger'
-
-export class UnauthorizedResult {
-  @ApiProperty({ description: 'Mensaje de error' })
-  message: string
-  @ApiProperty({
-    description: 'Nombre del error según StatusCode, p.e: BAD REQUEST, NOT FOUND, CREATED, etc',
-  })
-  error: string
-  @ApiProperty({ description: 'Código de error HttpStatusCode: 200, 201, 400, 401, etc.' })
-  statusCode: number
-  @ApiProperty({ description: 'loggerId del mensaje de error, para ubicarlo en el Logger' })
-  loggerId: string
-}

package/libs/ms-sophia-framework-mysql/src/core/config/config.module.ts

@@ -1,22 +0,0 @@
-import { Module, Global } from '@nestjs/common'
-import { ConfigService } from './config.service'
-import * as yaml from 'js-yaml'
-import { readFileSync } from 'node:fs'
-import { replaceEnvVars } from '../tools'
-
-@Global()
-@Module({
-  providers: [
-    {
-      provide: ConfigService,
-      useFactory: () => {
-        const configData = yaml.load(
-          replaceEnvVars(readFileSync('bootstrap.yml', 'utf8')),
-        ) as Record<string, any>
-        return new ConfigService(configData)
-      },
-    },
-  ],
-  exports: [ConfigService],
-})
-export class ConfigModule {}

package/libs/ms-sophia-framework-mysql/src/core/config/config.service.ts

@@ -1,37 +0,0 @@
-import { Injectable } from '@nestjs/common'
-import { Logger } from '../logger/logger'
-
-@Injectable()
-export class ConfigService {
-  private readonly config: Record<string, any>
-
-  constructor(config: Record<string, any>) {
-    this.config = config
-    this.getKey = this.getKey.bind(this)
-    this.get = this.get.bind(this)
-  }
-
-  getKey<T>(key: string): T | undefined {
-    const keys = key.split('.')
-    let current: any = this.config
-
-    for (const k of keys) {
-      if (current && typeof current === 'object' && k in current) {
-        current = current[k]
-      } else {
-        return undefined
-      }
-    }
-
-    return current as T | undefined
-  }
-
-  get<T>(key: string): T | undefined {
-    const value = this.getKey<T>(key)
-    if (value === undefined) {
-      Logger.warn(`[ConfigService] Missing property: ${key}`)
-      return undefined
-    }
-    return value
-  }
-}

package/libs/ms-sophia-framework-mysql/src/core/config/index.ts

@@ -1,2 +0,0 @@
-export * from './config.module'
-export * from './config.service'

package/libs/ms-sophia-framework-mysql/src/core/database/database.module.ts

@@ -1,18 +0,0 @@
-import { Global, Module } from '@nestjs/common'
-import { databaseProviders } from './database.provider'
-import { ConfigService } from '@nestjs/config'
-import { ConfigModule } from '../config/config.module'
-import { Logger } from '../logger/logger'
-// import { ConfigService } from '@nestjs/config'
-// import { LoggerHttpService } from 'src/logger/logger-http.service'
-// import { LoggerModule } from 'src/logger/logger.module'
-// import { LoggerService } from 'src/logger/logger.service'
-// import { LoggerHttpService } from 'src/logger/logger-http.service'
-
-@Global()
-@Module({
-  imports: [ConfigModule],
-  providers: [ConfigService, ...databaseProviders, Logger],
-  exports: [...databaseProviders],
-})
-export class DatabaseModule {}

package/libs/ms-sophia-framework-mysql/src/core/database/database.provider.ts

@@ -1,70 +0,0 @@
-//import { DatabaseType, DataSource, LoggerOptions } from 'typeorm'
-import { DataSource, EntitySchema, MixedList } from 'typeorm';
-import { Providers } from './providers';
-import { ConfigModule } from '../config/config.module';
-import { ConfigService } from '../config/config.service';
-import { Logger } from '../logger/logger';
-import { LoggerModule } from '../logger/logger.module';
-import { TypeOrmLoggerService } from '../logger/typeorm-logger.service';
-import { EntitySubscriber } from '../subscribers/entity.subscriber';
-import { Logs } from '../subscribers/log.entity';
-
-type MySqlDatabaseType = 'mysql' | 'mariadb';
-export const databaseProviders = [
-  {
-    provide: Providers.DATA_SOURCE,
-    imports: [ConfigModule, LoggerModule],
-    inject: [ConfigService, Logger],
-    useFactory: async (configService: ConfigService, logger: Logger) => {
-      const includeLogs: boolean = getIncludeLogs(configService);
-      logger.log('Value process.cwd(): ' + process.cwd(), 'DatabaseProvider');
-
-      const entities: MixedList<string | Function | EntitySchema<any>> | undefined = [
-        process.cwd() + configService.get<string>('typeorm.mysql.entities'),
-      ];
-      if (includeLogs) {
-        entities.push(Logs);
-      }
-      const subscribers = includeLogs ? [EntitySubscriber] : undefined;
-      const synchronize = configService.get<boolean>('typeorm.mysql.synchronize');
-      const logging = configService.get<boolean>('typeorm.mysql.logging') as boolean;
-      const typeOrmLogger = logging ? new TypeOrmLoggerService(logger, logging) : undefined;
-
-      const dataSource = new DataSource({
-        type: configService.get<string>(
-          'typeorm.mysql.type',
-        ) as MySqlDatabaseType,
-        host: configService.get<string>('typeorm.mysql.host'),
-        port: configService.get<number>('typeorm.mysql.port'),
-        database: configService.get<string>('typeorm.mysql.database'),
-        username: configService.get<string>('typeorm.mysql.username'),
-        password: configService.get<string>('typeorm.mysql.password'),
-        // Se define las entities, subscribers, synchronize, logging, logger dinámicamente, mas arriba, según la configuración
-        // entities: [
-        //   process.cwd() + configService.get<string>('typeorm.mysql.entities'),
-        //   Logs
-        // ],
-        // subscribers: [EntitySubscriber],
-        // NOT USE. La sincronización elimina todas las columnas y las crea nuevas
-        // synchronize: configService.get<boolean>('typeorm.mysql.synchronize'),
-        entities,
-        subscribers,
-        synchronize,
-        logging,
-        logger: typeOrmLogger,
-      });
-      const data = await dataSource.initialize();
-      logger.log('Database connection established', 'DatabaseProvider');
-      //return dataSource.initialize()
-      return data;
-    },
-  },
-];
-
-function getIncludeLogs(configService: ConfigService): boolean {
-  const includeLogs = configService.get<boolean>('entityLogs.insertEnabled') || 
-  configService.get<boolean>('entityLogs.updateEnabled') || 
-  configService.get<boolean>('entityLogs.removeEnabled') || 
-  false;
-  return includeLogs
-}

package/libs/ms-sophia-framework-mysql/src/core/database/index.ts

@@ -1,3 +0,0 @@
-export * from './database.module'
-export * from './database.provider'
-export * from './providers'

package/libs/ms-sophia-framework-mysql/src/core/database/providers.ts

@@ -1,3 +0,0 @@
-export enum Providers {
-  DATA_SOURCE = 'DATA_SOURCE',
-}

package/libs/ms-sophia-framework-mysql/src/core/health/health.controller.ts

@@ -1,36 +0,0 @@
-import { Controller, Get, HttpException, HttpStatus, Inject } from '@nestjs/common'
-import { ApiOperation, ApiResponse } from '@nestjs/swagger'
-import { DataSource } from 'typeorm'
-import { Providers } from '../database'
-
-@Controller('health')
-export class HealthController {
-  constructor(
-    @Inject(Providers.DATA_SOURCE)
-    private readonly dataSource: DataSource,
-  ) {}
-
-  @Get('liveness')
-  @ApiOperation({ summary: 'Enpoint liveness for Kubernetes' })
-  @ApiResponse({ status: 200, description: 'Ok' })
-  @ApiResponse({ status: 500, description: 'Internal server error' })
-  liveness() {
-    return { status: 'ok' }
-  }
-
-  @Get('readiness')
-  @ApiOperation({ summary: 'Enpoint readiness for Kubernetes' })
-  @ApiResponse({ status: 200, description: 'Ok' })
-  @ApiResponse({ status: 503, description: 'Service unaivalable' })
-  async readiness() {
-    try {
-      await this.dataSource.query('SELECT 1')
-      return { status: 'ok' }
-    } catch (error) {
-      throw new HttpException(
-        { status: 'error', message: 'Database connection failed' },
-        HttpStatus.SERVICE_UNAVAILABLE,
-      )
-    }
-  }
-}

package/libs/ms-sophia-framework-mysql/src/core/health/health.module.ts

@@ -1,16 +0,0 @@
-import { Module } from '@nestjs/common'
-import { HealthController } from './health.controller'
-import { Logger } from '../logger'
-// import { ConfigModule } from './core/config/config.module'
-// import { DatabaseModule } from './core/database/database.module'
-// import { LoggerModule } from './core/logger/logger.module'
-// import { Logger } from './core/logger/logger'
-// import { HealthController } from './core/health/HealthController'
-
-@Module({
-  imports: [],
-  controllers: [HealthController],
-  providers: [Logger],
-  exports: [Logger],
-})
-export class HealthModule {}

package/libs/ms-sophia-framework-mysql/src/core/interceptors/headers.interceptor.ts

@@ -1,16 +0,0 @@
-import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
-import { Observable } from 'rxjs'
-
-@Injectable()
-export class HeadersInterceptor implements NestInterceptor {
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
-    const request = context.switchToHttp().getRequest()
-    request.startTime = Date.now()
-    request.appName = request.headers['app-name'] ?? ''
-    request.scopes = request.headers['scopes'] ?? ''
-
-    return next.handle()
-  }
-}
-
-//Pasar todo esto al Loggin interceptor

package/libs/ms-sophia-framework-mysql/src/core/interceptors/index.ts

@@ -1,2 +0,0 @@
-export * from './headers.interceptor'
-export * from './logging.interceptor'

package/libs/ms-sophia-framework-mysql/src/core/interceptors/logging.interceptor.ts

@@ -1,43 +0,0 @@
-import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
-import { Observable } from 'rxjs'
-import { tap } from 'rxjs/operators'
-import { LoggerRequest } from '../logger/logger.request'
-import { ConfigService } from '../config'
-import { nanoid } from '../tools/nanoid'
-
-@Injectable()
-export class LoggingInterceptor implements NestInterceptor {
-  //private readonly configService: ConfigService
-  constructor(private readonly configService: ConfigService) {
-    this.configService = configService
-  }
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
-    const request = context.switchToHttp().getRequest()
-    const response = context.switchToHttp().getResponse()
-    const { method, url } = request
-    const startTime = Date.now()
-
-    request.requestId = request.headers['request-id'] ?? nanoid()
-
-    response.setHeader('Request-ID', request.requestId)
-    response['responseTime'] = Date.now() - startTime
-    request.response = response
-
-    LoggerRequest.setConfigService(this.configService)
-    LoggerRequest.setResponse(response)
-    LoggerRequest.setRequest(request)
-    LoggerRequest.log(
-      `[${request.requestId}] Incoming Request: ${method} ${url}`,
-      'LoggingInterceptor',
-    )
-
-    return next.handle().pipe(
-      tap((resp) => {
-        LoggerRequest.log(
-          `[${request.requestId}] Outgoing Response: ${method} ${url} - ${response['responseTime']}ms`,
-          'LoggingInterceptor',
-        )
-      }),
-    )
-  }
-}

package/libs/ms-sophia-framework-mysql/src/core/logger/index.ts

@@ -1,4 +0,0 @@
-export * from './logger.module'
-export * from './logger'
-export * from './logger.request'
-export * from './typeorm-logger.service'

package/libs/ms-sophia-framework-mysql/src/core/logger/logger.module.ts

@@ -1,10 +0,0 @@
-import { Module } from '@nestjs/common'
-import { ConfigModule } from '../config/config.module'
-import { Logger, TypeOrmLoggerService } from '.'
-
-@Module({
-  imports: [ConfigModule],
-  providers: [Logger, TypeOrmLoggerService],
-  exports: [Logger, TypeOrmLoggerService],
-})
-export class LoggerModule {}

package/libs/ms-sophia-framework-mysql/src/core/logger/logger.request.ts

@@ -1,137 +0,0 @@
-import {
-  ConsoleLogger,
-  Injectable,
-  Logger,
-  Logger as NestLogger,
-  LoggerService as NestLoggerService,
-  Scope,
-} from '@nestjs/common'
-import { ConfigService } from '../config/config.service'
-import { sendToLogstash } from '../tools/send-to-logstash'
-import { Request, Response } from 'express'
-
-@Injectable({ scope: Scope.REQUEST })
-export class LoggerRequest extends ConsoleLogger implements NestLoggerService {
-  private static logstashUrl: string | undefined
-  private static configService: ConfigService
-  private static request: Request
-  private static response: Response
-
-  constructor(private readonly configService: ConfigService) {
-    super()
-    LoggerRequest.configService = this.configService
-    LoggerRequest.logstashUrl = this.configService.get<string>('logger.http.host')
-  }
-
-  static setConfigService(configService: ConfigService) {
-    this.configService = configService
-    this.logstashUrl = this.configService.get<string>('logger.http.host')
-  }
-
-  static async setRequest(request: any): Promise<void> {
-    this.request = request
-  }
-
-  static async setResponse(response: any): Promise<void> {
-    this.response = response
-  }
-
-  private static async sendToLogstash(level: string, message: string, meta?: any): Promise<void> {
-    await sendToLogstash(
-      this.configService,
-      this.logstashUrl,
-      level,
-      message,
-      meta,
-      this.request,
-      this.response,
-    )
-  }
-
-  // _log(message: string): void
-  // _log(message: any, context: string): void
-  // _log(message: any, context?: string): void {
-  //   if (context) {
-  //     super.log('- ' + message, context)
-  //     LoggerRequest.sendToLogstash('log', message, { context: context })
-  //   } else {
-  //     super.log('- ' + message)
-  //     LoggerRequest.sendToLogstash('log', message)
-  //   }
-  // }
-
-  warn(message: any)
-  warn(message: any, context: string)
-  warn(message: any, context?: string) {
-    if (context) {
-      super.warn('- ' + message, context)
-      LoggerRequest.sendToLogstash('warn', message, { context: context })
-    } else {
-      super.warn('- ' + message)
-      LoggerRequest.sendToLogstash('warn', message)
-    }
-  }
-
-  error(message: string)
-  error(message: string, trace: string)
-  error(message: string, trace: string, meta: any)
-  error(message: string, trace?: string, meta?: any) {
-    if (meta) {
-      super.error('- ' + message, trace, meta)
-      LoggerRequest.sendToLogstash('error', message, { trace, meta })
-    } else if (trace) {
-      super.error('- ' + message, trace)
-      LoggerRequest.sendToLogstash('error', message, { trace })
-    } else {
-      super.error('- ' + message)
-      LoggerRequest.sendToLogstash('error', message)
-    }
-  }
-
-  debug(message: string)
-  debug(message: any, context: string)
-  debug(message: any, context?: string) {
-    if (context) {
-      super.debug('- ' + message, context)
-      LoggerRequest.sendToLogstash('warn', message, { context: context })
-    } else {
-      super.debug('- ' + message)
-      LoggerRequest.sendToLogstash('warn', message)
-    }
-  }
-  //#endregion
-
-  //#region Static methods
-  static async log(message: string, meta?: any) {
-    const logger = new Logger()
-    logger.log(message, meta)
-    await LoggerRequest.sendToLogstash('log', message, { meta: meta })
-  }
-
-  static async warn(message: string, meta?: any) {
-    NestLogger.warn(message, meta)
-    await LoggerRequest.sendToLogstash('warn', message, { meta: meta })
-  }
-
-  static async error(message: string)
-  static async error(message: string, trace: string)
-  static async error(message: string, trace: string, meta: any)
-  static async error(message: string, trace?: string, meta?: any) {
-    if (meta) {
-      NestLogger.error(message, trace, meta)
-      // await LoggerRequest.sendToLogstash('error', message, { trace, meta })
-    } else if (trace) {
-      NestLogger.error(message, trace)
-      // await LoggerRequest.sendToLogstash('error', message, { trace })
-    } else {
-      NestLogger.error(message)
-      // await LoggerRequest.sendToLogstash('error', message)
-    }
-  }
-
-  static async debug(message: string, meta?: any) {
-    NestLogger.debug(message, meta)
-    await LoggerRequest.sendToLogstash('debug', message, { meta: meta })
-  }
-  //#endregion
-}