@xylabs/express 5.0.80 → 5.0.81

package/src/Logger/Transports/Rollbar/RollbarTransport.ts

@@ -1,24 +0,0 @@
-import type Rollbar from 'rollbar'
-import type { TransportStreamOptions } from 'winston-transport'
-import Transport from 'winston-transport'
-
-import { logFormatRollbar } from '../../LogFormats/index.ts'
-
-export class RollbarTransport extends Transport {
-  protected readonly rollbar?: Rollbar
-  constructor(
-    opts: TransportStreamOptions,
-    rollbar?: Rollbar,
-  ) {
-    super({
-      ...opts, format: logFormatRollbar, level: 'error',
-    })
-    this.rollbar = rollbar
-  }
-
-  override log(info: { message?: string }, next: () => void) {
-    this.rollbar?.error(info?.message)
-    this.emit('logged', info?.message)
-    next()
-  }
-}

package/src/Logger/Transports/Rollbar/canGetDefaultRollbarTransport.ts

@@ -1,3 +0,0 @@
-export const canGetDefaultRollbarTransport = (env: { [key: string]: string | undefined }): boolean => {
-  return env.ROLLBAR_ACCESS_TOKEN === undefined ? false : true
-}

package/src/Logger/Transports/Rollbar/getDefaultRollbarTransport.ts

@@ -1,10 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import Rollbar from 'rollbar'
-
-import { RollbarTransport } from './RollbarTransport.ts'
-
-export const getDefaultRollbarTransport = (env: { [key: string]: string | undefined }): RollbarTransport => {
-  const accessToken = assertEx(env.ROLLBAR_ACCESS_TOKEN, () => 'Missing ROLLBAR_ACCESS_TOKEN ENV VAR')
-  const rollbar: Rollbar = new Rollbar({ accessToken })
-  return new RollbarTransport({}, rollbar)
-}

package/src/Logger/Transports/Rollbar/index.ts

@@ -1,3 +0,0 @@
-export * from './canGetDefaultRollbarTransport.ts'
-export * from './getDefaultRollbarTransport.ts'
-export * from './RollbarTransport.ts'

package/src/Logger/Transports/index.ts

@@ -1 +0,0 @@
-export * from './Rollbar/index.ts'

package/src/Logger/WinstonVerbosity.ts

@@ -1,5 +0,0 @@
-/**
- * Follows NPM log levels
- * https://docs.npmjs.com/cli/v8/using-npm/logging#loglevel
- */
-export type WinstonVerbosity = 'error' | 'warn' | 'info' | 'http' | 'verbose' | 'debug' | 'silly'

package/src/Logger/WrappedWinstonLogger.ts

@@ -1,20 +0,0 @@
-import type { LogFunction, Logger } from '@xylabs/logger'
-import type { Logger as Winston } from 'winston'
-
-/**
- * Wrap Winston logger methods to adapt to familiar
- * console logging methods
- */
-export class WrappedWinstonLogger implements Logger {
-  protected readonly winston: Winston
-  constructor(winston: Winston) {
-    this.winston = winston
-  }
-
-  debug: LogFunction = message => this.winston.debug(message)
-  error: LogFunction = message => this.winston.error(message)
-  info: LogFunction = message => this.winston.info(message)
-  log: LogFunction = message => this.winston.info(message)
-  trace: LogFunction = message => this.winston.debug(message)
-  warn: LogFunction = message => this.winston.warn(message)
-}

package/src/Logger/getDefaultLogger.ts

@@ -1,21 +0,0 @@
-import type { Logger } from '@xylabs/logger'
-
-import { getLogger } from './getLogger.ts'
-import type { WrappedWinstonLogger } from './WrappedWinstonLogger.ts'
-
-/**
- * Static instance to prevent multiple instances of the same logger
- * with the same config
- */
-
-declare global {
-  var xy: {
-    defaultLogger?: WrappedWinstonLogger
-  }
-}
-
-export const getDefaultLogger = (): Logger => {
-  if (globalThis.xy === undefined) globalThis.xy = {}
-  if (globalThis.xy.defaultLogger) return globalThis.xy.defaultLogger
-  return getLogger()
-}

package/src/Logger/getLogger.ts

@@ -1,55 +0,0 @@
-import type { Logger } from '@xylabs/logger'
-import { createLogger, transports as winstonTransports } from 'winston'
-import type TransportStream from 'winston-transport'
-
-import { logFormatLocalDev, logFormatStructured } from './LogFormats/index.ts'
-import type { LoggerVerbosity } from './LoggerVerbosity.ts'
-import { toWinstonVerbosity } from './toWinstonVerbosity.ts'
-import { canGetDefaultRollbarTransport, getDefaultRollbarTransport } from './Transports/index.ts'
-import type { WinstonVerbosity } from './WinstonVerbosity.ts'
-import { WrappedWinstonLogger } from './WrappedWinstonLogger.ts'
-
-const exitOnError = false
-const handleRejections = true
-
-const { Console } = winstonTransports
-const consoleTransport = new Console()
-const format = process.env.NODE_ENV === 'development' ? logFormatLocalDev : logFormatStructured
-const transports: TransportStream[] = [consoleTransport]
-if (canGetDefaultRollbarTransport(process.env)) {
-  try {
-    const rollbarTransport = getDefaultRollbarTransport(process.env)
-    transports.push(rollbarTransport)
-  } catch {
-    // NOTE: No error here, just gracefully adding logger if ENV VARs
-    // were preset
-  }
-}
-
-const loggers: Record<WinstonVerbosity, Logger | undefined> = {
-  debug: undefined,
-  error: undefined,
-  http: undefined,
-  info: undefined,
-  silly: undefined,
-  verbose: undefined,
-  warn: undefined,
-}
-
-export const getLogger = (minVerbosity: LoggerVerbosity = 'info'): Logger => {
-  const level = toWinstonVerbosity(minVerbosity)
-  const existing = loggers[level]
-  if (existing) return existing
-  const logger = new WrappedWinstonLogger(
-    createLogger({
-      exitOnError,
-      format,
-      handleRejections,
-      level,
-      rejectionHandlers: transports,
-      transports,
-    }),
-  )
-  loggers[level] = logger
-  return logger
-}

package/src/Logger/index.ts

@@ -1,13 +0,0 @@
-export * from './getDefaultLogger.ts'
-export * from './getLogger.ts'
-export * from './LoggerMeta.ts'
-export * from './LoggerOptions.ts'
-export * from './LoggerVerbosity.ts'
-export * from './WrappedWinstonLogger.ts'
-import type { LogFunction as XyLabsLogFunction, Logger as XyLabsLogger } from '@xylabs/logger'
-
-/** @deprecated use from @xylabs/logger instead */
-export type LogFunction = XyLabsLogFunction
-
-/** @deprecated use from @xylabs/logger instead */
-export type Logger = XyLabsLogger

package/src/Logger/toWinstonVerbosity.ts

@@ -1,6 +0,0 @@
-import type { LoggerVerbosity } from './LoggerVerbosity.ts'
-import type { WinstonVerbosity } from './WinstonVerbosity.ts'
-
-export const toWinstonVerbosity = (loggerVerbosity: LoggerVerbosity): WinstonVerbosity => {
-  return loggerVerbosity === 'all' ? 'silly' : loggerVerbosity
-}

package/src/Model/ExpressError.ts

@@ -1,3 +0,0 @@
-export interface ExpressError extends Error {
-  statusCode?: number
-}

package/src/Model/index.ts

@@ -1 +0,0 @@
-export * from './ExpressError.ts'

package/src/Performance/Counters.ts

@@ -1,36 +0,0 @@
-export class Counters {
-  static counters: Record<string, number> = {}
-
-  static inc(name: string, count = 1) {
-    this.catchError(name, (name: string) => {
-      this.counters[name] = (this.counters[name] ?? 0) + count
-    })
-  }
-
-  static max(name: string, count: number) {
-    this.catchError(name, (name: string) => {
-      const currentValue = this.counters[name]
-      if (currentValue === undefined || count > currentValue) {
-        this.counters[name] = count
-      }
-    })
-  }
-
-  static min(name: string, count: number) {
-    this.catchError(name, (name: string) => {
-      const currentValue = this.counters[name]
-      if (currentValue === undefined || count < currentValue) {
-        this.counters[name] = count
-      }
-    })
-  }
-
-  private static catchError = (name: string, func: (name: string) => void) => {
-    try {
-      func(name)
-    } catch {
-      this.counters[name] = 0
-      this.inc('CountersErrors')
-    }
-  }
-}

package/src/Performance/Profiler.ts

@@ -1,10 +0,0 @@
-export class Profiler {
-  stats: Record<string, number> = {}
-
-  async profile<T>(name: string, promise: Promise<T>) {
-    const start = Date.now()
-    const result = await promise
-    this.stats[name] = Date.now() - start
-    return result
-  }
-}

package/src/Performance/index.ts

@@ -1,2 +0,0 @@
-export * from './Counters.ts'
-export * from './Profiler.ts'

package/src/Util/compactObject.ts

@@ -1,9 +0,0 @@
-export const compactObject = <T extends Record<string, unknown>>(obj: T) => {
-  const result: Record<string, unknown> = {}
-  for (const key in obj) {
-    if (obj[key] !== undefined && obj[key] !== null) {
-      result[key] = obj[key]
-    }
-  }
-  return result as T
-}

package/src/Util/index.ts

@@ -1,2 +0,0 @@
-export * from './compactObject.ts'
-export * from './tryParse.ts'

package/src/Util/tryParse.ts

@@ -1,17 +0,0 @@
-import { isDefined } from '@xylabs/typeof'
-
-export type ParseFunc<T = number> = (value: string) => T
-
-/**
- * @deprecated use zod instead
- */
-export const tryParse = <T = number>(func: ParseFunc<T>, value?: string) => {
-  try {
-    const result = isDefined(value) ? func(value) : null
-    if (!Number.isNaN(result) && result !== null) {
-      return result
-    }
-  } catch {
-    return
-  }
-}

package/src/Validation/index.ts

@@ -1 +0,0 @@
-export * from './requestHandlerValidator.ts'

package/src/Validation/requestHandlerValidator.ts

@@ -1,120 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { isDefined, isPromise } from '@xylabs/typeof'
-import type {
-  NextFunction, Request, RequestHandler, Response,
-} from 'express'
-import { ReasonPhrases, StatusCodes } from 'http-status-codes'
-import * as z from 'zod'
-
-import type { ExpressError } from '../Model/index.ts'
-
-/**
- * Empty Zod schema for requests with no parameters.
- */
-export const EmptyParamsZod = z.object({}).catchall(z.string())
-
-/**
- * Empty Zod schema for requests with no query parameters.
- */
-export const EmptyQueryParamsZod = z.object({}).catchall(z.union([z.string(), z.array(z.string())]))
-
-/**
- * Default validation schemas for request handler validator.
- */
-export const ValidateRequestDefaults = {
-  params: EmptyParamsZod,
-  query: EmptyQueryParamsZod,
-  body: z.json().optional(),
-  response: z.json().optional(),
-}
-
-type ValidatableRequestKey = 'params' | 'query' | 'body'
-
-/**
- * Factory for Express middleware that validates request and response objects using Zod schemas.
- * @param schemas The Zod schemas to use for validation.
- * @returns A middleware function for validating requests and responses.
- */
-export function requestHandlerValidator<
-  TParams extends typeof EmptyQueryParamsZod | z.ZodType<Record<string, string>> = typeof EmptyQueryParamsZod,
-  TQuery extends typeof EmptyQueryParamsZod | z.ZodType<Record<string, string | string[]>> = typeof EmptyQueryParamsZod,
-  TBody extends z.ZodType<unknown> = z.ZodType<unknown>,
-  TResponse extends z.ZodType<unknown> = z.ZodType<unknown>,
->(schemas?: Partial<{
-  body: TBody
-  params: TParams
-  query: TQuery
-  response: TResponse
-}>) {
-  type Params = z.infer<TParams>
-  type Query = z.infer<TQuery>
-  type Body = z.infer<TBody>
-  type Res = z.infer<TResponse>
-  const validators = { ...ValidateRequestDefaults, ...schemas }
-
-  return (handler: (req: Request<Params, Res, Body, Query>, res: Response<Res>, next: NextFunction) => unknown): RequestHandler => {
-    return async (req: Request, res: Response, next: NextFunction) => {
-      const originalJson = res.json.bind(res)
-      try {
-      // Validate incoming request
-        const errors: string[] = []
-        const keys: ValidatableRequestKey[] = ['params', 'query', 'body']
-        for (const key of keys) {
-          const validator = validators[key]
-          const result = validator.safeParse(req[key])
-          if (result.success) {
-            if (isDefined(result.data)) Object.assign(req[key], result.data)
-          } else {
-            errors.push(
-              ...result.error.issues.map(
-                issue => (issue.path.length === 0)
-                  ? `${key}: ${issue.message}`
-                  : `${key}.${issue.path.join('.')}: ${issue.message}`,
-              ),
-            )
-          }
-        }
-
-        // If there were validation errors, short-circuit and return Bad Request
-        if (errors.length > 0) {
-          const message = errors.join('; ')
-          const err: ExpressError = new Error(message)
-          err.name = ReasonPhrases.BAD_REQUEST
-          err.statusCode = StatusCodes.BAD_REQUEST
-          next(err)
-          return false
-        }
-
-        // Wrap res.json to validate outgoing response
-        res.json = (data: any) => {
-          const result = validators.response.safeParse(data)
-          if (result.success) {
-            return originalJson(result.data)
-          } else {
-            const message = result.error.issues.map(
-              issue => (issue.path.length === 0)
-                ? `response: ${issue.message}`
-                : `response.${issue.path.join('.')}: ${issue.message}`,
-            ).join('; ')
-            const err: ExpressError = new Error(message)
-            err.name = ReasonPhrases.INTERNAL_SERVER_ERROR
-            err.statusCode = StatusCodes.INTERNAL_SERVER_ERROR
-
-            // Restore original json function in case the error handler wants to use it
-            res.json = originalJson
-            throw err
-          }
-        }
-
-        // Automatically handle async errors
-        const result = handler(req as any, res as any, next)
-        if (result && isPromise(result)) {
-          await result
-        }
-      } catch (err) {
-        res.json = originalJson
-        next(err)
-      }
-    }
-  }
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from './Handler/index.ts'
-export * from './HttpUtil/index.ts'
-export * from './Logger/index.ts'
-export * from './middleware/index.ts'
-export * from './Model/index.ts'
-export * from './Performance/index.ts'
-export * from './Util/index.ts'
-export * from './Validation/index.ts'

package/src/middleware/caseInsensitiveRouting/caseInsensitiveRouting.ts

@@ -1,21 +0,0 @@
-import type { Express } from 'express'
-
-const setting = 'case sensitive routing'
-
-/**
- * Enable case sensitivity. When enabled, "/Foo" and "/foo" are different
- * routes. When disabled, "/Foo" and "/foo" are treated the same.
- * @param app The Express app to disable the header on.
- */
-export const enableCaseSensitiveRouting = (app: Express) => {
-  app.enable(setting)
-}
-
-/**
- * Disable case sensitivity. When enabled, "/Foo" and "/foo" are different
- * routes. When disabled, "/Foo" and "/foo" are treated the same.
- * @param app The Express app to disable the header on.
- */
-export const disableCaseSensitiveRouting = (app: Express) => {
-  app.disable(setting)
-}

package/src/middleware/caseInsensitiveRouting/index.ts

@@ -1 +0,0 @@
-export * from './caseInsensitiveRouting.ts'

package/src/middleware/customPoweredByHeader/customPoweredByHeader.ts

@@ -1,29 +0,0 @@
-import type {
-  Express, NextFunction, Request, Response,
-} from 'express'
-
-const header = 'X-Powered-By'
-const setting = 'x-powered-by'
-
-/**
- * By default Express appends the `X-Powered-By: Express` header to
- * all responses. Calling this method enables that behavior.
- * @param app The Express app to disable the header on.
- */
-export const enableExpressDefaultPoweredByHeader = (app: Express) => {
-  app.enable(setting)
-}
-
-/**
- * By default Express appends the `X-Powered-By: Express` header to
- * all responses. Calling this method disables that behavior.
- * @param app The Express app to disable the header on.
- */
-export const disableExpressDefaultPoweredByHeader = (app: Express) => {
-  app.disable(setting)
-}
-
-export const customPoweredByHeader = (req: Request, res: Response, next: NextFunction) => {
-  res.setHeader(header, 'XYO')
-  next()
-}

package/src/middleware/customPoweredByHeader/index.ts

@@ -1 +0,0 @@
-export * from './customPoweredByHeader.ts'

package/src/middleware/index.ts

@@ -1,5 +0,0 @@
-export * from './caseInsensitiveRouting/index.ts'
-export * from './customPoweredByHeader/index.ts'
-export * from './jsonBodyParser/index.ts'
-export * from './metrics/index.ts'
-export * from './standardResponses/index.ts'

package/src/middleware/jsonBodyParser/index.ts

@@ -1 +0,0 @@
-export * from './jsonBodyParser.ts'

package/src/middleware/jsonBodyParser/jsonBodyParser.ts

@@ -1,59 +0,0 @@
-import type { OptionsJson } from 'body-parser'
-import bodyParser from 'body-parser'
-import type { NextHandleFunction } from 'connect'
-
-import { getDefaultLogger } from '../../Logger/index.ts'
-
-/**
- * The default maximum request body size for the JSON Body Parser
- */
-export const DefaultJsonBodyParserOptionsLimit = '100kb'
-
-/**
- * The default MIME types for the JSON Body Parser
- */
-export const DefaultJsonBodyParserOptionsTypes = ['application/json', 'text/json']
-
-/**
- * The default options for the JSON Body Parser
- */
-export const DefaultJsonBodyParserOptions: OptionsJson = {
-  limit: DefaultJsonBodyParserOptionsLimit,
-  type: DefaultJsonBodyParserOptionsTypes,
-}
-
-/**
- * Gets the default JSON Body Parser options merged with the supplied options
- * with the supplied options taking precedence
- * @param options The options to override the default JSON Body Parser options with
- * @returns The combined JSON Body Parser options with the supplied values taking
- * precedence over the default
- */
-export const getJsonBodyParserOptions = (options?: Partial<OptionsJson>): OptionsJson => {
-  return options ? { ...DefaultJsonBodyParserOptions, ...options } : DefaultJsonBodyParserOptions
-}
-
-/**
- * Get a JSON Body Parser connect middleware handler
- * @param options The options for the JSON Body Parser
- * @returns A middleware function that parses JSON bodies
- */
-export const getJsonBodyParser = (options: OptionsJson = DefaultJsonBodyParserOptions): NextHandleFunction => {
-  // Create closed instance of bodyParser to prevent instantiation of new instance on every request
-  const parser = bodyParser.json(options)
-
-  return (req, res, next) => {
-    // If we do not trap this error, then it dumps too much to log, usually happens if request aborted
-    try {
-      parser(req, res, next)
-    } catch (ex) {
-      const error = ex as Error
-      getDefaultLogger().log(`bodyParser failed [${error?.name}]: ${error?.message}`)
-    }
-  }
-}
-
-/**
- * A JSON Body Parser middleware handler initialized with the default options
- */
-export const jsonBodyParser = getJsonBodyParser()

package/src/middleware/metrics/counters.ts

@@ -1,25 +0,0 @@
-import type {
-  Application, NextFunction, Request, Response,
-} from 'express'
-
-import { Counters } from '../../Performance/index.ts'
-
-export const useRequestCounters = (app: Application): void => {
-  // Configure Global counters
-  app.use((req: Request, res: Response, next: NextFunction) => {
-    Counters.inc(req.path)
-    Counters.inc('_calls')
-    next()
-  })
-
-  app.get('/stats', (req: Request, res: Response, next: NextFunction) => {
-    /* #swagger.tags = ['Metrics'] */
-    /* #swagger.summary = 'Get the counters for single instance of diviner' */
-    res.json({
-      alive: true,
-      avgTime: `${((Counters.counters._totalTime ?? 0) / (Counters.counters._calls ?? 1)).toFixed(2)}ms`,
-      counters: Counters.counters,
-    })
-    next()
-  })
-}

package/src/middleware/metrics/index.ts

@@ -1,2 +0,0 @@
-export * from './counters.ts'
-export * from './responseProfiler.ts'

package/src/middleware/metrics/responseProfiler.ts

@@ -1,23 +0,0 @@
-import type {
-  NextFunction, Request, Response,
-} from 'express'
-
-/**
- * Connect middleware to enable profiling of response lifecycle timing. To effectively profile
- * the response timing, this middleware needs to be called first when initializing your Express
- * App
- * @example
- * const app = express()
- * app.use(responseProfiler)
- * // other initialization ...
- * @param _req The request
- * @param res The response
- * @param next The next function
- */
-export const responseProfiler = (_req: Request, res: Response, next: NextFunction) => {
-  if (!res.locals?.meta) {
-    res.locals.meta = {}
-  }
-  res.locals.meta.profile = { startTime: Date.now() }
-  next()
-}

package/src/middleware/standardResponses/getResponseMetadata.ts

@@ -1,18 +0,0 @@
-import type { Response } from 'express'
-
-export const getResponseMetadata = (res: Response): Record<string, unknown> => {
-  const meta: Record<string, unknown> = res.locals?.meta || {}
-  // NOTE: We should do this somewhere else to better separate concerns
-  const profile = res.locals.meta?.profile
-  if (profile) {
-    const startTime = profile?.startTime
-    if (startTime) {
-      const endTime = Date.now()
-      const duration = endTime - startTime
-      res.locals.meta.profile = {
-        duration, endTime, startTime,
-      }
-    }
-  }
-  return meta
-}

package/src/middleware/standardResponses/index.ts

@@ -1,4 +0,0 @@
-export * from './getResponseMetadata.ts'
-export * from './jsonApi/index.ts'
-export * from './standardErrors.ts'
-export * from './standardResponses.ts'

package/src/middleware/standardResponses/jsonApi/README.md

@@ -1,4 +0,0 @@
-# JSON API
-
-The following interfaces/types attempt to capture the
-[JSON API 1.0](https://jsonapi.org/) specification as closely as possible