@openapi-typescript-infra/service 6.10.1 → 6.10.2

package/src/telemetry/requestLogger.ts

@@ -1,267 +0,0 @@
-import type { RequestHandler, Request, Response, ErrorRequestHandler } from 'express';
-import { getClientIp } from 'request-ip';
-import type { Histogram } from '@opentelemetry/api';
-import cleanStack from 'clean-stack';
-
-import { ServiceError } from '../error.js';
-import type { AnyServiceLocals, RequestWithApp, ServiceExpress, ServiceLocals } from '../types.js';
-import type { ServiceHandler } from '../express-app/types.js';
-import type { ConfigurationSchema } from '../config/schema.js';
-import { getNodeEnv } from '../env.js';
-
-const LOG_PREFS = Symbol('Logging information');
-const LOGGED_SEMAPHORE = Symbol('Logged semaphore');
-
-interface LogPrefs {
-  start: [number, number];
-  logRequests?: boolean;
-  chunks?: Buffer[];
-  logged: boolean;
-}
-
-interface WithLogPrefs {
-  [LOG_PREFS]: LogPrefs;
-}
-
-interface WithIdentifiedSession {
-  session?: {
-    id?: string;
-  };
-}
-
-interface ErrorWithStatus extends Error {
-  status?: number;
-  expected_error?: boolean;
-}
-
-function getBasicInfo(req: Request): [string, Record<string, string | number>] {
-  const url = req.originalUrl || req.url;
-
-  const preInfo: Record<string, string> = {
-    ip: getClientIp(req) || '',
-    m: req.method,
-  };
-
-  if (req.headers['user-agent']) {
-    preInfo.ua = req.headers['user-agent'];
-  }
-
-  const sessionReq = req as WithIdentifiedSession;
-  if (sessionReq.session?.id) {
-    preInfo.sid = sessionReq.session.id;
-  }
-
-  return [url, preInfo];
-}
-
-function finishLog<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>>(
-  app: ServiceExpress<SLocals>,
-  error: Error | undefined,
-  req: Request,
-  res: Response & { [LOGGED_SEMAPHORE]?: boolean },
-  histogram: Histogram,
-) {
-  if (res[LOGGED_SEMAPHORE]) {
-    return;
-  }
-
-  const prefs = (res.locals as WithLogPrefs)[LOG_PREFS] || {};
-  if (prefs.logged) {
-    // This happens when error handler runs, but onEnd hasn't fired yet. We only log the first one.
-    return;
-  }
-
-  const { logger, service } = app.locals;
-
-  let dur = 0;
-  if (prefs.start) {
-    const hrdur = process.hrtime(prefs.start);
-    dur = hrdur[0] + hrdur[1] / 1000000000;
-  }
-  const [url, preInfo] = getBasicInfo(req);
-
-  let responseType = 'unknown';
-
-  if (res.writableFinished) {
-    responseType = 'finished';
-  } else if (req.aborted) {
-    responseType = 'aborted';
-  } else if (req.destroyed) {
-    responseType = 'destroyed';
-  } else if (error) {
-    responseType = 'errored';
-  }
-
-  const endLog: Record<string, string | string[] | number | undefined> = {
-    ...preInfo,
-    t: 'req',
-    r: responseType,
-    s: (error as ErrorWithStatus)?.status || res.statusCode || 0,
-    dur,
-  };
-
-  const path = req.route ? { path: req.route.path } : undefined;
-  histogram.record(dur, {
-    status_code: endLog.s,
-    method: endLog.m,
-    ...path,
-    service: app.locals.name,
-  });
-
-  if (res.locals.user?.id) {
-    endLog.u = res.locals.user.id;
-  }
-
-  let unexpectedError = false;
-  if (error) {
-    endLog.e = error.message;
-    if (!(error instanceof ServiceError) || error.log_stack) {
-      endLog.st = cleanStack(error.stack);
-    }
-    if (!(error as ErrorWithStatus).expected_error) {
-      unexpectedError = true;
-    }
-  }
-
-  if (prefs.logRequests) {
-    endLog.h = JSON.stringify(req.headers);
-    if (Buffer.isBuffer(req.body)) {
-      endLog.b = req.body.toString('base64');
-    } else if (typeof req.body !== 'string') {
-      endLog.b = JSON.stringify(req.body);
-    } else if (req.body) {
-      endLog.b = req.body;
-    }
-  }
-
-  if (prefs.chunks?.length) {
-    const bodyString = Buffer.concat(prefs.chunks).toString('utf8');
-    if (bodyString) {
-      endLog.resBody = bodyString;
-    }
-  }
-  const msg = service.getLogFields?.(req as RequestWithApp<SLocals>, endLog);
-  if (msg === false) {
-    res[LOGGED_SEMAPHORE] = true;
-    return;
-  }
-  if (unexpectedError) {
-    logger.error(endLog, msg || url);
-  } else {
-    logger.info(endLog, msg || url);
-  }
-
-  res[LOGGED_SEMAPHORE] = true;
-}
-
-export function loggerMiddleware<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
->(
-  app: ServiceExpress<SLocals>,
-  histogram: Histogram,
-  config?: ConfigurationSchema['logging'],
-): RequestHandler {
-  const nonProd = getNodeEnv() !== 'production';
-  const { logger, service } = app.locals;
-  return function serviceLogger(req, res, next) {
-    const logResponse =
-      config?.logResponseBody || (nonProd && req.headers['x-log']?.includes('res'));
-    const logRequest = config?.logRequestBody || (nonProd && req.headers['x-log']?.includes('req'));
-    const prefs: LogPrefs = {
-      start: process.hrtime(),
-      logRequests: logRequest,
-      chunks: logResponse ? [] : undefined,
-      logged: false,
-    };
-
-    (res.locals as WithLogPrefs)[LOG_PREFS] = prefs;
-
-    if (logResponse) {
-      // res is a read-only stream, so the only way to intercept response
-      // data is to monkey-patch.
-      const oldWrite = res.write;
-      const oldEnd = res.end;
-      res.write = ((...args: Parameters<(typeof res)['write']>) => {
-        if (prefs.chunks) {
-          prefs.chunks.push(Buffer.isBuffer(args[0]) ? args[0] : Buffer.from(args[0] as string));
-        }
-        return (oldWrite as (typeof res)['write']).apply(res, args);
-      }) as (typeof res)['write'];
-      res.end = ((...args: Parameters<(typeof res)['end']>) => {
-        if (args[0] && prefs.chunks) {
-          prefs.chunks.push(Buffer.isBuffer(args[0]) ? args[0] : Buffer.from(args[0] as string));
-        }
-        return oldEnd.apply(res, args);
-      }) as (typeof res)['end'];
-    }
-
-    if (config?.preLog) {
-      const [url, preInfo] = getBasicInfo(req);
-      const preLog: Record<string, string | string[] | number | undefined> = {
-        ...preInfo,
-        t: 'pre',
-        ref: req.headers.referer || undefined,
-        sid: (req as WithIdentifiedSession).session?.id,
-        c: req.headers.correlationid || undefined,
-      };
-      const msg = service.getLogFields?.(req as RequestWithApp<SLocals>, preLog);
-      if (msg !== false) {
-        logger.info(preLog, msg || url);
-      }
-    }
-
-    const logWriter = (err?: Error) => finishLog(app, err, req, res, histogram);
-    res.on('finish', logWriter);
-    res.on('close', logWriter);
-    res.on('error', logWriter);
-    next();
-  };
-}
-
-export function errorHandlerMiddleware<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
->(app: ServiceExpress<SLocals>, histogram: Histogram, unnest?: boolean, returnError?: boolean) {
-  const svcErrorHandler: ErrorRequestHandler = (error, req, res, next) => {
-    let loggable: Partial<ServiceError> = error;
-    const body = error.response?.body || error.body;
-    if (unnest && body?.domain && body?.code && body?.message) {
-      loggable = {
-        status: error.status,
-        message: body.message,
-        domain: body.domain,
-        code: body.code,
-        display_message: body.display_message,
-        ...loggable.client_metadata,
-      };
-    }
-    // Set the status to error, even if we aren't going to render the error.
-    res.status(loggable.status || 500);
-    if (returnError) {
-      finishLog(app, error as Error, req, res, histogram);
-      const prefs = (res.locals as WithLogPrefs)[LOG_PREFS];
-      prefs.logged = true;
-      res.json({
-        code: loggable.code,
-        message: loggable.message,
-        domain: loggable.domain,
-        display_message: loggable.display_message,
-        ...loggable.client_metadata,
-      });
-    } else {
-      next(error);
-    }
-  };
-  return svcErrorHandler;
-}
-
-export function notFoundMiddleware() {
-  const serviceNotFoundHandler: ServiceHandler = (req, res, next) => {
-    const error = new ServiceError(req.app, `Cannot ${req.method} ${req.path}`, {
-      status: 404,
-      code: 'NotFound',
-      domain: 'http',
-    });
-    next(error);
-  };
-  return serviceNotFoundHandler as RequestHandler;
-}

package/src/tsx.d.ts

@@ -1 +0,0 @@
-declare module 'tsx/esm';

package/src/types.ts

@@ -1,223 +0,0 @@
-import type { Server } from 'node:http';
-import type { REPLServer } from 'node:repl';
-
-import type { BaseLogger, Logger } from 'pino';
-import type { Request, Response } from 'express';
-import type { Application } from 'express-serve-static-core';
-import type { middleware } from 'express-openapi-validator';
-import type { Meter } from '@opentelemetry/api';
-import type { NodeSDKConfiguration } from '@opentelemetry/sdk-node';
-import type { ShortstopHandler } from '@sesamecare-oss/confit';
-
-import type { ConfigurationSchema } from './config/schema.js';
-
-export interface InternalLocals<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-> extends Record<string, unknown> {
-  server?: Server;
-  mainApp: ServiceExpress<SLocals>;
-}
-
-export type ServiceLogger = BaseLogger & Pick<Logger, 'isLevelEnabled'>;
-
-// Vanilla express wants this to extend Record<string, any> but this is a mistake
-// because you lose type checking on it, even though I get that underneath it truly
-// is Record<string, any>
-export interface ServiceLocals<Config extends ConfigurationSchema = ConfigurationSchema> {
-  service: Service;
-  name: string;
-  version: string;
-  logger: ServiceLogger;
-  config: Config;
-  meter: Meter;
-  internalApp: Application<InternalLocals<this>>;
-  /**
-   * This is the parsed OpenAPI spec we are hosting (if openapi is enabled)
-   */
-  openApiSpecification?: ReturnType<typeof JSON.parse>;
-}
-
-export interface RequestLocals {
-  // Set this to true during the request "attachment" and if there is a body,
-  // it will be set to the buffer before API and route handlers run.
-  rawBody?: Buffer | true;
-  logger: ServiceLogger;
-}
-
-export type ServiceExpress<Locals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>> =
-  Application<Locals>;
-
-export type RequestWithApp<Locals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>> =
-  Omit<Request, 'app'> & {
-    app: Application<Locals>;
-  };
-
-export type ResponseFromApp<
-  ResBody = unknown,
-  RLocals extends RequestLocals = RequestLocals,
-> = Response<ResBody, RLocals>;
-
-/**
- * This is the core type you need to implement to provide a service
- */
-export interface Service<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-  RLocals extends RequestLocals = RequestLocals,
-> {
-  name?: string;
-
-  // Modify options used for application start
-  configure?: (
-    startOptions: ServiceStartOptions<SLocals, RLocals>,
-    options: ServiceOptions,
-  ) => ServiceOptions;
-
-  // Run after configuration but before routes are loaded,
-  // which is often a good place to add elements to the app locals
-  // that are needed during route setup
-  attach?: (app: ServiceExpress<SLocals>) => void | Promise<void>;
-
-  // Called after a server is created but before the server starts listening
-  attachServer?: (app: ServiceExpress<SLocals>, server: Server) => void | Promise<void>;
-  // Called after the server is listening
-  onListening?: (
-    app: ServiceExpress<SLocals>,
-    info: { port?: number; protocol: 'http' | 'https' },
-  ) => void | Promise<void>;
-
-  start(app: ServiceExpress<SLocals>): void | Promise<void>;
-
-  stop?: (app: ServiceExpress<SLocals>) => void | Promise<void>;
-
-  healthy?: (app: ServiceExpress<SLocals>) => boolean | Promise<boolean>;
-
-  // This runs as middleware right BEFORE the body parsers.
-  // If you want to run AFTER the body parsers, the current
-  // way to do that would be via /routes/index.ts and router.use()
-  // in that file.
-  onRequest?(req: RequestWithApp<SLocals>, res: Response<unknown, RLocals>): void | Promise<void>;
-
-  // This runs after body parsing but before routing
-  authorize?(
-    req: RequestWithApp<SLocals>,
-    res: Response<unknown, RLocals>,
-  ): boolean | Promise<boolean>;
-
-  // Add or redact any fields for logging. Note this will be called twice per request,
-  // once at the start and once at the end. Modify the values directly. Return a
-  // string to control the "msg" field of the logs, or return undefined to leave it
-  // as the default, which is the request URL. Return false to suppress the log entirely.
-  getLogFields?(
-    req: RequestWithApp<SLocals>,
-    values: Record<string, string | string[] | number | undefined>,
-  ): string | false | undefined;
-
-  // The repl is a useful tool for diagnosing issues in non-dev environments.
-  // The attachRepl method provides a way to add custom functionality
-  // (typically with top level variables) to the repl.
-  attachRepl?(app: ServiceExpress<SLocals>, repl: REPLServer): void;
-}
-
-export type ServiceFactory<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-  RLocals extends RequestLocals = RequestLocals,
-> = () => Service<SLocals, RLocals>;
-
-export interface ServiceStartOptions<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-  RLocals extends RequestLocals = RequestLocals,
-> {
-  name: string;
-  version: string;
-  rootDirectory: string;
-
-  // Defaults to "build", but can be set to "src" to run off non-built source
-  codepath?: 'build' | 'src' | 'dist';
-
-  // NOTE: if you use this, you need to cast it because of a Typescript error:
-  // https://github.com/microsoft/TypeScript/issues/22229
-  // locals: { stuff } as Partial<MyLocals>
-  locals?: Partial<SLocals>;
-
-  // And finally, the function that creates the service instance
-  service: () => Service<SLocals, RLocals>;
-}
-
-export interface DelayLoadServiceStartOptions extends Omit<ServiceStartOptions, 'service'> {
-  service: string;
-  customizer?:
-    | ((options: Partial<NodeSDKConfiguration>) => Partial<NodeSDKConfiguration>)
-    | undefined;
-}
-
-// Handled by service.configure
-export interface ServiceOptions {
-  // Used to resolve code paths flexibly during dev/prod
-  codepath?: string;
-  // Will be either .ts or .js depending on the runtime environment
-  codeExtension?: string;
-
-  // If you need multiple configuration directories, pass them here
-  // in the desired order (later trumps earlier)
-  configurationDirectories: string[];
-
-  // Add or control OpenAPI options such as security handlers
-  openApiOptions?: Partial<Parameters<typeof middleware>[0]>;
-
-  shortstopHandlers: Record<string, ShortstopHandler<string, unknown>>;
-}
-
-export interface ServiceLike<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-> {
-  locals: SLocals;
-}
-
-/**
- * This type should be used (or extended) to pass "context"
- * into functions not directly wired into the Express request
- * handling flow. It will allow "synthetic" requests to be
- * easily constructed without depending on things they should not,
- * like query strings or body or similar. Most often, you want the
- * logger.
- */
-export interface RequestLike<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-  RLocals extends RequestLocals = RequestLocals,
-> {
-  app: ServiceLike<SLocals>;
-  res: {
-    locals: RLocals;
-  };
-}
-
-// Define some utility types to make it easier to put them all
-// in one export. This interface never actually is instantiated.
-// Typically you should export an interface that extends this one
-// and then access all your types through that.
-export interface ServiceTypes<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-  RLocals extends RequestLocals = RequestLocals,
-  ResBody = unknown,
-> {
-  App: ServiceExpress<SLocals>;
-  Handler: (
-    req: RequestWithApp<SLocals>,
-    res: ResponseFromApp<ResBody, RLocals>,
-  ) => void | Promise<void>;
-  Request: RequestWithApp<SLocals>;
-  RequestLike: RequestLike<SLocals, RLocals>;
-  RequestLocals: RLocals;
-  Response: ResponseFromApp<ResBody, RLocals>;
-  Service: Service<SLocals, RLocals>;
-  ServiceFactory: ServiceFactory<SLocals, RLocals>;
-  ServiceLocals: SLocals;
-}
-
-export type UnwrapServiceConfig<SLocals extends ServiceLocals> =
-  SLocals extends ServiceLocals<infer C> ? C : never;
-
-// TODO this allows us to clean up the generics by having a loose parameter
-// but using the UnwrapServiceConfig to get the specific type back
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyServiceLocals = ServiceLocals<any>;