beavuck-time 2.3.6 → 2.3.7

package/api-tests/bruno/now/ok/ok_same_origin.bru

@@ -1,23 +0,0 @@
-meta {
-  name: ok_same_origin
-  type: http
-  seq: 2
-}
-
-get {
-  url: {{BASE_URL}}/now
-  body: none
-  auth: inherit
-}
-
-headers {
-  Origin: {{BASE_URL}}
-}
-
-assert {
-  res.status: eq 200
-  res.body: isDefined
-  res.body.now: isDefined
-  res.body.now: matches {{RFC_3339_REGEX}}
-  res.responseTime: lt 200
-}

package/api-tests/bruno/now/ok/ok_same_referrer.bru

@@ -1,23 +0,0 @@
-meta {
-  name: ok_same_referrer
-  type: http
-  seq: 3
-}
-
-get {
-  url: {{BASE_URL}}/now
-  body: none
-  auth: inherit
-}
-
-headers {
-  Referrer: {{BASE_URL}}
-}
-
-assert {
-  res.status: eq 200
-  res.body: isDefined
-  res.body.now: isDefined
-  res.body.now: matches {{RFC_3339_REGEX}}
-  res.responseTime: lt 200
-}

package/api-tests/bruno/now/ok/ok_trusted_origin.bru

@@ -1,23 +0,0 @@
-meta {
-  name: ok_trusted_origin
-  type: http
-  seq: 1
-}
-
-get {
-  url: {{BASE_URL}}/now
-  body: none
-  auth: inherit
-}
-
-headers {
-  Origin: {{TRUSTED_ORIGIN}}
-}
-
-assert {
-  res.status: eq 200
-  res.body: isDefined
-  res.body.now: isDefined
-  res.body.now: matches {{RFC_3339_REGEX}}
-  res.responseTime: lt 200
-}

package/eslint.config.mjs

@@ -1,28 +0,0 @@
-// eslint.config.mjs
-
-import globals from 'globals'
-import pluginJs from '@eslint/js'
-import tseslint from 'typescript-eslint'
-
-/** @type {import('eslint').Linter.Config[]} */
-export default [
-    {files: ['**/*.{js,mjs,cjs,ts}']},
-    {languageOptions: {globals: globals.browser}},
-    pluginJs.configs.recommended,
-    ...tseslint.configs.recommended,
-    {
-        rules: {
-            '@typescript-eslint/no-explicit-any': 'off',
-            'no-restricted-syntax': [
-                'error', {
-                    selector: 'CallExpression[callee.object.name="console"]',
-                    message: 'Don\'t use console -- use the configured logger instead',
-                },
-                'error', {
-                    selector: ':not(BinaryExpression:matches([operator="!=="], [operator="==="])) > Literal[value="null"]',
-                    message: 'Usage of "null" is deprecated except when received from legacy APIs. Use "undefined" instead',
-                },
-            ],
-        },
-    },
-]

package/sonar-project.properties

@@ -1,9 +0,0 @@
-sonar.projectKey=beavuck-services_time
-sonar.organization=beavuck-services
-sonar.sources=.
-sonar.exclusions=**/node_modules/**, **/coverage/**, **/build/**, **/build/**, **/api-tests/**, *package*.json, src/routes/routes.ts
-sonar.coverage.exclusions=src/__tests__/utils/urlUtil.test.ts, src/__tests__/middlewares/errorHandler.test.ts, src/__tests__/config/corsOptions.test.ts, src/__tests__/api.test.ts, src/config/logger.ts, src/server.ts, src/middlewares/rateLimiter.ts, src/routes/routes.ts
-sonar.sourceEncoding=UTF-8
-sonar.typescript.tsconfigPaths=tsconfig.json
-sonar.coverage.inclusions=src/**/*.*
-sonar.javascript.lcov.reportPaths=coverage/lcov.info

package/src/__tests__/api.test.ts

@@ -1,98 +0,0 @@
-import request from 'supertest'
-import {api} from '../api'
-import {StatusCodes} from 'http-status-codes'
-import {RFC_3339_FORMAT} from '../types/isoTimestamp'
-
-let callsMadeSoFar = 0
-
-function getSomeTrustedOrigin(): string {
-  return process.env.BEAVUCK_TIME_TRUSTED_ORIGINS?.split(',')[0] ?? ''
-}
-
-/**
- * Increments the callsMadeSoFar counter and returns the response and trusted origin
- */
-async function makeSuccessfulCallToNowEndpoint() {
-  const trustedOrigin = getSomeTrustedOrigin()
-  const res = await request(api).get('/now').set('Origin', trustedOrigin)
-  callsMadeSoFar++
-  return {res, trustedOrigin}
-}
-
-describe('App Initialization', () => {
-  it('should disable x-powered-by header', async () => {
-    const res = await request(api).get('/now')
-    expect(res.header['x-powered-by']).toBeUndefined()
-  })
-
-  it('should allow requests from trusted origins', async () => {
-    const {res, trustedOrigin} = await makeSuccessfulCallToNowEndpoint()
-    expect(res.header['access-control-allow-origin']).toBe(trustedOrigin)
-    expect(res.status).toBe(StatusCodes.OK)
-  })
-
-  it('should block requests from non-trusted origins', async () => {
-    const res = await request(api).get('/now').set('Origin', 'https://non-trusted.com')
-    expect(res.header['access-control-allow-origin']).toBeUndefined()
-    expect(res.status).toBe(StatusCodes.FORBIDDEN)
-  })
-
-  it('should block requests with no origin header', async () => {
-    const res = await request(api).get('/now')
-    expect(res.header['access-control-allow-origin']).toBeUndefined()
-    expect(res.status).toBe(StatusCodes.FORBIDDEN)
-  })
-
-  it('should allow requests with no origin header but a referrer header identical to server url', async () => {
-    const REFERRER: string = process.env.BEAVUCK_TIME_HOST_URL!
-    const res = await request(api).get('/now').set('Referrer', REFERRER)
-    expect(res.header['access-control-allow-origin']).toBeUndefined()
-    expect(res.status).toBe(StatusCodes.OK)
-    callsMadeSoFar++
-  })
-
-  it('should allow requests with no origin header but a referer (sic) header identical to server url', async () => {
-    const REFERER: string = process.env.BEAVUCK_TIME_HOST_URL!
-    const res = await request(api).get('/now').set('Referer', REFERER)
-    expect(res.header['access-control-allow-origin']).toBeUndefined()
-    expect(res.status).toBe(StatusCodes.OK)
-    callsMadeSoFar++
-  })
-
-  it('should handle errors using errorHandler middleware', async () => {
-    const res = await request(api).get('/nope').set('Origin', getSomeTrustedOrigin())
-    expect(res.status).toBe(StatusCodes.NOT_FOUND)
-  })
-
-  it('should return the current time in ISO format', async () => {
-    const {res} = await makeSuccessfulCallToNowEndpoint()
-    expect(res.status).toBe(StatusCodes.OK)
-    expect(res.body).toHaveProperty('now')
-    expect(res.body.now).toMatch(RFC_3339_FORMAT)
-  })
-
-  it('should return 500 if HOST_URL is not set', async () => {
-    const originalHostUrl = process.env.BEAVUCK_TIME_HOST_URL
-    delete process.env.BEAVUCK_TIME_HOST_URL
-
-    const res = await request(api).get('/now')
-    expect(res.status).toBe(StatusCodes.INTERNAL_SERVER_ERROR)
-
-    process.env.BEAVUCK_TIME_HOST_URL = originalHostUrl
-  })
-
-  it('should block requests with non-trusted referrer header if origin is not OK', async () => {
-    const res = await request(api).get('/now').set('Referrer', 'https://non-trusted.com')
-    expect(res.status).toBe(StatusCodes.FORBIDDEN)
-  })
-
-  it('should block requests that exceed the rate limit', async () => {
-    const RATE_LIMIT = parseInt(process.env.BEAVUCK_TIME_RATE_LIMIT!, 10)
-    while (callsMadeSoFar <= RATE_LIMIT) {
-      const {res} = await makeSuccessfulCallToNowEndpoint()
-      if (callsMadeSoFar > RATE_LIMIT) {
-        expect(res.status).toBe(StatusCodes.TOO_MANY_REQUESTS)
-      }
-    }
-  })
-})

package/src/__tests__/middlewares/errorHandler.test.ts

@@ -1,93 +0,0 @@
-// src/__tests__/middlewares/errorHandler.test.ts
-
-import express from 'express'
-import {errorHandler} from '../../middlewares/errorHandler'
-import {BeavuckTimeClientError} from '../../errors/BeavuckTimeClientError'
-import {BeavuckTimeServerError} from '../../errors/BeavuckTimeServerError'
-import {CorsError} from '../../errors/CorsError'
-import {StatusCodes} from 'http-status-codes'
-import {logger} from '../../config/logger'
-import {ValidateError} from 'tsoa'
-
-jest.mock('../../config/logger')
-
-describe('errorHandler', () => {
-  let req: express.Request
-  let res: express.Response
-  let next: express.NextFunction
-
-  beforeEach(() => {
-    req = {} as express.Request
-    res = {
-      status: jest.fn().mockReturnThis(),
-      json: jest.fn().mockReturnThis(),
-    } as unknown as express.Response
-    next = jest.fn() as express.NextFunction
-  })
-
-  it('should handle BeavuckTimeClientError', () => {
-    const err = new BeavuckTimeClientError('Some message')
-    errorHandler(err, req, res, next)
-    expect(logger.warn).toHaveBeenCalledWith(err)
-    expect(res.status).toHaveBeenCalledWith(err.code)
-    expect(res.json).toHaveBeenCalledWith({message: `${err.message}`})
-  })
-
-  it('should handle CorsError', () => {
-    const err = new CorsError('Some message')
-    errorHandler(err, req, res, next)
-    expect(logger.warn).toHaveBeenCalledWith(err)
-    expect(res.status).toHaveBeenCalledWith(err.code)
-    expect(res.json).toHaveBeenCalledWith({message: `${err.message}`})
-  })
-
-  it('should handle BeavuckTimeServerError', () => {
-    const err = new BeavuckTimeServerError('Some message')
-    errorHandler(err, req, res, next)
-    expect(logger.error).toHaveBeenCalledWith(err)
-    expect(res.status).toHaveBeenCalledWith(err.code)
-    expect(res.json).toHaveBeenCalledWith({message: `${err.message}`})
-  })
-
-  it('should handle non-specific error', () => {
-    const err = new Error('Some message')
-    errorHandler(err, req, res, next)
-    const beavuckError = BeavuckTimeServerError.fromError(err)
-    expect(logger.error).toHaveBeenCalledWith(beavuckError)
-    expect(res.status).toHaveBeenCalledWith(StatusCodes.INTERNAL_SERVER_ERROR)
-    expect(res.json).toHaveBeenCalledWith({
-      message: `${beavuckError.message}`,
-    })
-  })
-
-  it('should call next if no error', () => {
-    errorHandler(undefined, req, res, next)
-    expect(next).toHaveBeenCalled()
-  })
-
-  it('should handle ValidateError', () => {
-    const err = new ValidateError({}, 'Some message')
-    errorHandler(err, req, res, next)
-    expect(logger.error).toHaveBeenCalled()
-    expect(res.status).toHaveBeenCalledWith(StatusCodes.UNPROCESSABLE_ENTITY)
-    expect(res.json).toHaveBeenCalledWith({
-      message: 'Validation Error',
-      details: err.fields,
-    })
-  })
-
-  it('should handle unknown error type', () => {
-    const err = {some: 'unknown error'}
-    errorHandler(err, req, res, next)
-    expect(logger.error).toHaveBeenCalled()
-    expect(res.status).toHaveBeenCalledWith(StatusCodes.INTERNAL_SERVER_ERROR)
-    expect(res.json).toHaveBeenCalledWith({
-      message: 'Internal Server Error',
-    })
-  })
-
-  it('should handle null error', () => {
-    errorHandler(undefined, req, res, next)
-    expect(next).toHaveBeenCalled()
-  })
-})

package/src/__tests__/utils/urlUtil.test.ts

@@ -1,53 +0,0 @@
-// src/__tests__/utils/urlUtil.test.ts
-
-import {isSameOrigin, tryParseUrl} from '../../utils/urlUtil'
-import {URL} from 'url'
-
-const A_VALID_URL_STRING = 'https://example.com:1234'
-const SAME_VALID_URL_DIFFERENT_PORT = 'https://example.com:81'
-const SOME_OTHER_VALID_URL_STRING = 'https://different.com:1234'
-const AN_INVALID_URL_STRING = 'invalid'
-
-describe('urlUtil', () => {
-  describe('isSameOrigin', () => {
-    it('returns false when either URL is undefined', () => {
-      const url = new URL(A_VALID_URL_STRING)
-      expect(isSameOrigin(url)).toBe(false)
-      expect(isSameOrigin(undefined, url)).toBe(false)
-    })
-
-    it('returns true when URLs have the same origin', () => {
-      const url1 = new URL(A_VALID_URL_STRING)
-      const url2 = new URL(A_VALID_URL_STRING)
-      expect(isSameOrigin(url1, url2)).toBe(true)
-    })
-
-    it('returns false when URLs have the same origin but different ports', () => {
-      const url1 = new URL(A_VALID_URL_STRING)
-      const url2 = new URL(SAME_VALID_URL_DIFFERENT_PORT)
-      expect(isSameOrigin(url1, url2)).toBe(false)
-    })
-
-    it('returns false when URLs have different origins', () => {
-      const url1 = new URL(A_VALID_URL_STRING)
-      const url2 = new URL(SOME_OTHER_VALID_URL_STRING)
-      expect(isSameOrigin(url1, url2)).toBe(false)
-    })
-  })
-
-  describe('tryParseUrl', () => {
-    it('returns undefined when URL string is undefined', () => {
-      expect(tryParseUrl()).toBeUndefined()
-    })
-
-    it('returns a URL object when URL string is valid', () => {
-      const url = tryParseUrl(A_VALID_URL_STRING)
-      expect(url).toBeInstanceOf(URL)
-      expect(url?.origin).toBe(A_VALID_URL_STRING)
-    })
-
-    it('returns undefined when URL string is invalid', () => {
-      expect(tryParseUrl(AN_INVALID_URL_STRING)).toBeUndefined()
-    })
-  })
-})

package/src/api.ts

@@ -1,19 +0,0 @@
-// src/api.ts
-
-import express from 'express'
-import {corsMiddleware} from './middlewares/corsMiddleware'
-import {errorHandler} from './middlewares/errorHandler'
-import {rateLimiter} from './middlewares/rateLimiter'
-import {notFoundHandler} from './middlewares/notFoundHandler'
-import {RegisterRoutes} from './routes/routes'
-
-export const api = express()
-api.disable('x-powered-by')
-
-api.use(corsMiddleware)
-api.use(errorHandler)
-api.use(rateLimiter)
-
-RegisterRoutes(api)
-
-api.use(notFoundHandler)

package/src/config/corsOptions.ts

@@ -1,63 +0,0 @@
-// src/config/corsOptions.ts
-
-import {CorsOptions} from 'cors'
-import {CorsError} from '../errors/CorsError'
-import {isSameOrigin, tryParseUrl} from '../utils/urlUtil'
-import {StatusCodes} from 'http-status-codes'
-import dotenvx from '@dotenvx/dotenvx'
-
-dotenvx.config()
-
-export const corsOptions: CorsOptions = {
-  methods: ['GET', 'OPTIONS'],
-  optionsSuccessStatus: StatusCodes.OK,
-  origin: (
-    origin: string | undefined,
-    callback: (err: Error | null, allow?: boolean) => void,
-  ): void => {
-    if (
-      isAllTrusted() ||
-      isSameOrigin(getHostUrl(), tryParseUrl(origin)) ||
-      isOriginAbsentOrTrusted(origin)
-    ) {
-      // eslint-disable-next-line no-restricted-syntax
-      callback(null, true)
-    } else {
-      callback(new CorsError(origin), false)
-    }
-  },
-}
-
-let HOST_URL: URL
-let TRUSTED_ORIGINS: string[]
-
-export function getHostUrl(): URL | undefined {
-  if (!HOST_URL) {
-    initHostUrl()
-  }
-  return HOST_URL
-}
-
-export function initHostUrl(): void {
-  HOST_URL = new URL(process.env.BEAVUCK_TIME_HOST_URL!)
-}
-
-export function getTrustedOrigins(): string[] {
-  if (!TRUSTED_ORIGINS || TRUSTED_ORIGINS.length === 0) {
-    initTrustedOrigins()
-  }
-  return TRUSTED_ORIGINS
-}
-
-export function initTrustedOrigins(): void {
-  const trustedOrigins: string = process.env.BEAVUCK_TIME_TRUSTED_ORIGINS!
-  TRUSTED_ORIGINS = trustedOrigins.split(',')
-}
-
-export function isAllTrusted(): boolean {
-  return getTrustedOrigins().includes('*')
-}
-
-export function isOriginAbsentOrTrusted(origin?: string): boolean {
-  return !origin || getTrustedOrigins().includes(origin)
-}

package/src/config/logger.ts

@@ -1,38 +0,0 @@
-// src/config/logger.ts
-
-import {createLogger, format, transports} from 'winston'
-import 'winston-daily-rotate-file'
-import dotenvx from '@dotenvx/dotenvx'
-
-dotenvx.config()
-
-const LOGS_DIR = 'logs'
-const LOG_LEVEL: string = process.env.BEAVUCK_TIME_LOG_LEVEL ?? 'info'
-const MAX_LOG_FILES: string | number = process.env.BEAVUCK_TIME_MAX_LOG_FILES ?? 64
-const MAX_SIZE_LOG_FILES: string = process.env.BEAVUCK_TIME_MAX_SIZE_LOG_FILES ?? '1m'
-
-const dailyRotateFileTransport = new transports.DailyRotateFile({
-  filename: `${LOGS_DIR}/%DATE%-combined.log`,
-  datePattern: 'YYYY-MM-DD',
-  zippedArchive: true,
-  maxSize: MAX_SIZE_LOG_FILES,
-  maxFiles: MAX_LOG_FILES,
-})
-
-export const logger = createLogger({
-  level: LOG_LEVEL,
-  format: format.combine(
-    format.timestamp(),
-    format.printf(({timestamp, level, message}) => {
-      return `${timestamp} [${level.toUpperCase()}]: ${message}`
-    }),
-  ),
-  transports: [
-    new transports.Console(),
-    new transports.File({
-      filename: `${LOGS_DIR}/error.log`,
-      level: 'error',
-    }),
-    dailyRotateFileTransport,
-  ],
-})

package/src/controllers/nowController.ts

@@ -1,19 +0,0 @@
-// src/controllers/nowController.ts
-
-import {Controller, Get, OperationId, Route, Tags} from 'tsoa'
-import {Now} from '../models/now'
-import {NowService} from '../services/nowService'
-
-@Route('now')
-export class NowController extends Controller {
-  /**
-   * Get the current time in ISO format, in UTC timezone
-   * @summary Get current time
-   */
-  @Tags('now')
-  @Get()
-  @OperationId('getNow')
-  public async getNow(): Promise<Now> {
-    return new NowService().get()
-  }
-}

package/src/errors/BeavuckTimeClientError.ts

@@ -1,12 +0,0 @@
-// src/errors/BeavuckTimeClientError.ts
-
-import {BeavuckTimeError} from './base/BeavuckTimeError'
-import {StatusCodes} from 'http-status-codes'
-
-export class BeavuckTimeClientError extends BeavuckTimeError {
-  static readonly baseMessage: string = 'Client Error'
-
-  constructor(message: string, code: number = StatusCodes.BAD_REQUEST) {
-    super(`${BeavuckTimeClientError.baseMessage}: ${message}`, code)
-  }
-}

package/src/errors/BeavuckTimeServerError.ts

@@ -1,18 +0,0 @@
-// src/errors/BeavuckTimeServerError.ts
-
-import {BeavuckTimeError} from './base/BeavuckTimeError'
-import {StatusCodes} from 'http-status-codes'
-
-export class BeavuckTimeServerError extends BeavuckTimeError {
-  static readonly baseMessage: string = 'Internal Server Error'
-
-  constructor(message: string, code: number = StatusCodes.INTERNAL_SERVER_ERROR) {
-    super(`${BeavuckTimeServerError.baseMessage}: ${message}`, code)
-  }
-
-  static fromError(error: Error): BeavuckTimeServerError {
-    return error instanceof BeavuckTimeServerError ? error : (
-        new BeavuckTimeServerError(error.message)
-      )
-  }
-}

package/src/errors/CorsError.ts

@@ -1,12 +0,0 @@
-// src/errors/CorsError.ts
-
-import {StatusCodes} from 'http-status-codes'
-import {BeavuckTimeClientError} from './BeavuckTimeClientError'
-
-export class CorsError extends BeavuckTimeClientError {
-  static readonly baseMessage: string = 'Origin forbidden by CORS'
-
-  constructor(origin?: string) {
-    super(`${CorsError.baseMessage}: ${origin}`, StatusCodes.FORBIDDEN)
-  }
-}

package/src/errors/base/BeavuckTimeError.ts

@@ -1,12 +0,0 @@
-// src/errors/base/BeavuckTimeError.ts
-
-export abstract class BeavuckTimeError extends Error {
-  code: number
-
-  protected constructor(message: string, code: number) {
-    super(message)
-    this.name = this.constructor.name
-    this.code = code
-    Error.captureStackTrace(this, this.constructor)
-  }
-}

package/src/middlewares/corsMiddleware.ts

@@ -1,32 +0,0 @@
-// src/middlewares/corsMiddleware.ts
-
-import cors from 'cors'
-import {isSameOrigin, tryParseUrl} from '../utils/urlUtil'
-import {CorsError} from '../errors/CorsError'
-import express from 'express'
-import {logger} from '../config/logger'
-import {BeavuckTimeServerError} from '../errors/BeavuckTimeServerError'
-import {corsOptions} from '../config/corsOptions'
-
-export const corsMiddleware = (
-  req: express.Request,
-  res: express.Response,
-  next: express.NextFunction,
-) => {
-  const HOST_URL = tryParseUrl(process.env.BEAVUCK_TIME_HOST_URL ?? '')
-  // 'referer' is a misspelling that was kept for compatibility: https://en.wikipedia.org/wiki/HTTP_referer
-  const referrerHeader: string | undefined =
-    (req.headers.referrer as string) || req.headers.referer
-  if (req.headers.origin) {
-    logger.debug(`CORS request from ${req.headers.origin}`)
-    cors(corsOptions)(req, res, next)
-  } else if (!HOST_URL) {
-    const noHostUrl = 'Host URL not set'
-    next(new BeavuckTimeServerError(noHostUrl))
-  } else if (isSameOrigin(HOST_URL, tryParseUrl(referrerHeader ?? ''))) {
-    next()
-  } else {
-    const badOriginAndOrReferrer = `origin: ${req.headers.origin}, referrer: ${referrerHeader}`
-    next(new CorsError(badOriginAndOrReferrer))
-  }
-}

package/src/middlewares/errorHandler.ts

@@ -1,57 +0,0 @@
-// src/middlewares/errorHandler.ts
-
-import express from 'express'
-import {logger} from '../config/logger'
-import {BeavuckTimeClientError} from '../errors/BeavuckTimeClientError'
-import {BeavuckTimeServerError} from '../errors/BeavuckTimeServerError'
-import {StatusCodes} from 'http-status-codes'
-import {ValidateError} from 'tsoa'
-import {BeavuckTimeError} from '../errors/base/BeavuckTimeError'
-
-export const errorHandler = (
-  err: unknown,
-  req: express.Request,
-  res: express.Response,
-  next: express.NextFunction,
-) => {
-  if (err instanceof ValidateError) {
-    const logMsg = `Validation error on ${req.path}: ${err.fields}`
-    const resStatus = StatusCodes.UNPROCESSABLE_ENTITY
-    const resMsgObj = {message: 'Validation Error', details: err.fields}
-    handleOtherError(res, logMsg, resStatus, resMsgObj)
-  } else if (err instanceof BeavuckTimeClientError) {
-    handleBeavuckClientError(res, err)
-  } else if (err instanceof BeavuckTimeServerError || err instanceof Error) {
-    handleBeavuckServerError(res, BeavuckTimeServerError.fromError(err))
-  } else if (err) {
-    handleOtherError(res)
-  } else {
-    next()
-  }
-}
-
-function sendErrorResponse(res: express.Response, err: BeavuckTimeError) {
-  res.status(err.code).json({message: err.message})
-}
-
-function handleBeavuckClientError(res: express.Response, err: BeavuckTimeClientError) {
-  logger.warn(err)
-  sendErrorResponse(res, err)
-}
-
-function handleBeavuckServerError(res: express.Response, err: BeavuckTimeServerError) {
-  logger.error(err)
-  sendErrorResponse(res, err)
-}
-
-function handleOtherError(
-  res: express.Response,
-  logMsg: string = `Unknown error`,
-  resStatus: StatusCodes = StatusCodes.INTERNAL_SERVER_ERROR,
-  resMsg: {message: string; details?: unknown} = {
-    message: BeavuckTimeServerError.baseMessage,
-  },
-) {
-  logger.error(`${logMsg}: ${JSON.stringify(resMsg)}`)
-  res.status(resStatus).json(resMsg)
-}

package/src/middlewares/notFoundHandler.ts

@@ -1,8 +0,0 @@
-// src/middlewares/notFoundHandler.ts
-
-import {Request as ExpressRequest, Response as ExpressResponse} from 'express'
-import {StatusCodes} from 'http-status-codes'
-
-export const notFoundHandler = (_req: ExpressRequest, res: ExpressResponse) => {
-  res.status(StatusCodes.NOT_FOUND).send({message: 'Not Found'})
-}

package/src/middlewares/rateLimiter.ts

@@ -1,15 +0,0 @@
-// src/middlewares/rateLimiter.ts
-
-import rateLimit from 'express-rate-limit'
-
-const NO_RATE_LIMIT = '-1'
-const RATE_LIMIT = parseInt(process.env.BEAVUCK_TIME_RATE_LIMIT ?? NO_RATE_LIMIT, 10)
-
-const SECONDS_IN_ONE_MINUTE = 60
-const MILLISECONDS_IN_ONE_SECOND = 1000
-const ONE_MINUTE = SECONDS_IN_ONE_MINUTE * MILLISECONDS_IN_ONE_SECOND
-
-export const rateLimiter =
-  RATE_LIMIT > 0 ?
-    rateLimit({windowMs: ONE_MINUTE, limit: RATE_LIMIT})
-  : (_req: any, _res: any, next: any) => next()