@openapi-typescript-infra/service 3.0.1 → 3.0.3

package/build/types.d.ts

@@ -10,9 +10,9 @@ import type { middleware } from 'express-openapi-validator';
 import type { Meter } from '@opentelemetry/api';
 import { Confit } from '@sesamecare-oss/confit';
 import { ConfigurationSchema } from './config/schema';
-export interface InternalLocals extends Record<string, unknown> {
+export interface InternalLocals<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>> extends Record<string, unknown> {
     server?: Server;
-    mainApp: ServiceExpress;
+    mainApp: ServiceExpress<SLocals>;
 }
 export type ServiceLogger = pino.BaseLogger & Pick<pino.Logger, 'isLevelEnabled'>;
 export interface ServiceLocals<Config extends ConfigurationSchema = ConfigurationSchema> {
@@ -21,21 +21,21 @@ export interface ServiceLocals<Config extends ConfigurationSchema = Configuratio
     logger: ServiceLogger;
     config: Confit<Config>;
     meter: Meter;
-    internalApp: Application<InternalLocals>;
+    internalApp: Application<InternalLocals<this>>;
 }
 export interface RequestLocals {
     rawBody?: Buffer | true;
     logger: ServiceLogger;
 }
-export type ServiceExpress<Locals extends ServiceLocals = ServiceLocals> = Application<Locals>;
-export type RequestWithApp<Locals extends ServiceLocals = ServiceLocals> = Omit<Request, 'app'> & {
+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 ServiceLocals = ServiceLocals, RLocals extends RequestLocals = RequestLocals> {
+export interface Service<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>, RLocals extends RequestLocals = RequestLocals> {
     name?: string;
     configure?: (startOptions: ServiceStartOptions<SLocals, RLocals>, options: ServiceOptions) => ServiceOptions;
     attach?: (app: ServiceExpress<SLocals>) => void | Promise<void>;
@@ -47,8 +47,8 @@ export interface Service<SLocals extends ServiceLocals = ServiceLocals, RLocals
     getLogFields?(req: RequestWithApp<SLocals>, values: Record<string, string | string[] | number | undefined>): void;
     attachRepl?(app: ServiceExpress<SLocals>, repl: REPLServer): void;
 }
-export type ServiceFactory<SLocals extends ServiceLocals = ServiceLocals, RLocals extends RequestLocals = RequestLocals> = () => Service<SLocals, RLocals>;
-export interface ServiceStartOptions<SLocals extends ServiceLocals = ServiceLocals, RLocals extends RequestLocals = RequestLocals> {
+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;
     rootDirectory: string;
     codepath?: 'build' | 'src' | 'dist';
@@ -62,7 +62,7 @@ export interface ServiceOptions {
     configurationDirectories: string[];
     openApiOptions?: Parameters<typeof middleware>[0];
 }
-export interface ServiceLike<SLocals extends ServiceLocals = ServiceLocals> {
+export interface ServiceLike<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>> {
     locals: SLocals;
 }
 /**
@@ -73,13 +73,13 @@ export interface ServiceLike<SLocals extends ServiceLocals = ServiceLocals> {
  * like query strings or body or similar. Most often, you want the
  * logger.
  */
-export interface RequestLike<SLocals extends ServiceLocals = ServiceLocals, RLocals extends RequestLocals = RequestLocals> {
+export interface RequestLike<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>, RLocals extends RequestLocals = RequestLocals> {
     app: ServiceLike<SLocals>;
     res: {
         locals: RLocals;
     };
 }
-export interface ServiceTypes<SLocals extends ServiceLocals = ServiceLocals, RLocals extends RequestLocals = RequestLocals, ResBody = unknown> {
+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>;
@@ -90,3 +90,5 @@ export interface ServiceTypes<SLocals extends ServiceLocals = ServiceLocals, RLo
     ServiceFactory: ServiceFactory<SLocals, RLocals>;
     ServiceLocals: SLocals;
 }
+export type UnwrapServiceConfig<SLocals extends ServiceLocals> = SLocals extends ServiceLocals<infer C> ? C : never;
+export type AnyServiceLocals = ServiceLocals<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openapi-typescript-infra/service",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "An opinionated framework for building configuration driven services - web, api, or  ob. Uses OpenAPI, pino logging, express, confit, Typescript and vitest.",
   "main": "build/index.js",
   "scripts": {
@@ -80,7 +80,7 @@
     "@opentelemetry/sdk-node": "^0.43.0",
     "@opentelemetry/sdk-trace-base": "^1.17.1",
     "@opentelemetry/semantic-conventions": "^1.17.1",
-    "@sesamecare-oss/confit": "^1.0.6",
+    "@sesamecare-oss/confit": "^1.1.0",
     "@sesamecare-oss/opentelemetry-node-metrics": "^1.0.1",
     "cookie-parser": "^1.4.6",
     "dotenv": "^16.3.1",
@@ -92,8 +92,7 @@
     "minimist": "^1.2.8",
     "opentelemetry-instrumentation-fetch-node": "^1.1.0",
     "pino": "^8.16.0",
-    "read-pkg-up": "^7.0.1",
-    "rest-api-support": "^1.16.3"
+    "read-pkg-up": "^7.0.1"
   },
   "devDependencies": {
     "@commitlint/cli": "^17.8.0",
@@ -104,7 +103,7 @@
     "@semantic-release/exec": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/release-notes-generator": "^12.0.0",
-    "@types/cookie-parser": "^1.4.4",
+    "@types/cookie-parser": "^1.4.5",
     "@types/eventsource": "1.1.12",
     "@types/express": "^4.17.19",
     "@types/glob": "^8.1.0",

package/src/bootstrap.ts

@@ -5,9 +5,10 @@ import dotenv from 'dotenv';
 import readPackageUp from 'read-pkg-up';
 import type { NormalizedPackageJson } from 'read-pkg-up';
 
-import type { RequestLocals, ServiceLocals, ServiceStartOptions } from './types';
+import type { AnyServiceLocals, RequestLocals, ServiceLocals, ServiceStartOptions } from './types';
 import { isDev } from './env';
 import { startWithTelemetry } from './telemetry/index';
+import { ConfigurationSchema } from './config/schema';
 
 interface BootstrapArguments {
   // The name of the service, else discovered via read-pkg-up
@@ -68,7 +69,7 @@ function getBuildDir(main: string): 'build' | 'dist' {
 // for jobs or other scripts that need service infra but are
 // not simply the service
 export async function bootstrap<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 >(argv?: BootstrapArguments) {
   const { main, rootDirectory, name } = await getServiceDetails(argv);

package/src/development/repl.ts

@@ -1,9 +1,13 @@
 import repl from 'repl';
 import path from 'path';
 
-import { ServiceExpress } from '../types';
+import { AnyServiceLocals, ServiceExpress, ServiceLocals } from '../types';
+import { ConfigurationSchema } from '../config/schema';
 
-export function serviceRepl(app: ServiceExpress, onExit: () => void) {
+export function serviceRepl<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>>(
+  app: ServiceExpress<SLocals>,
+  onExit: () => void,
+) {
   const rl = repl.start({
     prompt: '> ',
   });

package/src/error.ts

@@ -1,4 +1,5 @@
-import type { ServiceLike, ServiceLocals } from './types';
+import { ConfigurationSchema } from './config/schema';
+import type { AnyServiceLocals, ServiceLike, ServiceLocals } from './types';
 
 export interface ServiceErrorSpec {
   status?: number;
@@ -16,7 +17,9 @@ export interface ServiceErrorSpec {
  *
  * You can also include a display_message which is intended to be viewed by the end user
  */
-export class ServiceError extends Error {
+export class ServiceError<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+> extends Error {
   public status: number | undefined;
 
   public code?: string;
@@ -32,7 +35,7 @@ export class ServiceError extends Error {
   // take up the valuable mental space of an error log.
   public expected_error?: boolean;
 
-  constructor(app: ServiceLike<ServiceLocals>, message: string, spec?: ServiceErrorSpec) {
+  constructor(app: ServiceLike<SLocals>, message: string, spec?: ServiceErrorSpec) {
     super(message);
     this.domain = app.locals.name;
     Object.assign(this, spec);

package/src/express-app/app.ts

@@ -10,6 +10,7 @@ import { metrics } from '@opentelemetry/api';
 import { setupNodeMetrics } from '@sesamecare-oss/opentelemetry-node-metrics';
 import { createTerminus } from '@godaddy/terminus';
 import type { RequestHandler, Response } from 'express';
+import { Confit } from '@sesamecare-oss/confit';
 
 import { loadConfiguration } from '../config/index';
 import { openApi } from '../openapi';
@@ -19,6 +20,7 @@ import {
   notFoundMiddleware,
 } from '../telemetry/requestLogger';
 import type {
+  AnyServiceLocals,
   RequestLocals,
   RequestWithApp,
   ServiceExpress,
@@ -41,7 +43,7 @@ function isSyncLogging() {
 }
 
 export async function startApp<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 >(startOptions: ServiceStartOptions<SLocals, RLocals>): Promise<ServiceExpress<SLocals>> {
   const { service, rootDirectory, codepath = 'build', name } = startOptions;
@@ -86,12 +88,12 @@ export async function startApp<
     sourceDirectory: path.join(rootDirectory, codepath),
   });
 
-  const logging = config.get('logging') as ConfigurationSchema['logging'];
+  const logging = config.get('logging');
   logger.level = logging?.level || 'info';
 
   // Concentrate the Typescript ugliness...
   const app = express() as unknown as ServiceExpress<SLocals>;
-  const routing = config.get('routing') as ConfigurationSchema['routing'];
+  const routing = config.get('routing');
 
   app.disable('x-powered-by');
   if (routing?.etag !== true) {
@@ -241,11 +243,13 @@ export async function startApp<
 }
 
 export type StartAppFn<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 > = typeof startApp<SLocals, RLocals>;
 
-export async function shutdownApp(app: ServiceExpress) {
+export async function shutdownApp<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+>(app: ServiceExpress<SLocals>) {
   const { logger } = app.locals;
   try {
     await app.locals.service.stop?.(app);
@@ -256,10 +260,10 @@ export async function shutdownApp(app: ServiceExpress) {
   (logger as pino.Logger).flush?.();
 }
 
-function httpServer<SLocals extends ServiceLocals = ServiceLocals>(
-  app: ServiceExpress<SLocals>,
-  config: ConfigurationSchema['server'],
-) {
+function httpServer<
+  Config extends ConfigurationSchema = ConfigurationSchema,
+  SLocals extends ServiceLocals<Config> = ServiceLocals<Config>,
+>(app: ServiceExpress<SLocals>, config: ConfigurationSchema['server']) {
   if (!config.certificate) {
     return http.createServer(app);
   }
@@ -280,11 +284,14 @@ function url(config: ConfigurationSchema['server'], port: number) {
   return `http://${config.hostname}${port === 80 ? '' : `:${port}`}`;
 }
 
-export async function listen<SLocals extends ServiceLocals = ServiceLocals>(
+export async function listen<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>>(
   app: ServiceExpress<SLocals>,
   shutdownHandler?: () => Promise<void>,
 ) {
-  const config = app.locals.config.get('server') as Required<ConfigurationSchema['server']>;
+  // TODO I don't know why this is necessary, but TS can't quite figure this out
+  // otherwise.
+  const typedConfig = app.locals.config as unknown as Confit<ConfigurationSchema>;
+  const config = typedConfig.get('server') as Required<ConfigurationSchema['server']>;
   const { port } = config;
 
   const { service, logger } = app.locals;
@@ -341,7 +348,7 @@ export async function listen<SLocals extends ServiceLocals = ServiceLocals>(
       const { locals } = app;
       locals.logger.info({ url: url(config, port), service: locals.name }, 'express listening');
 
-      const serverConfig = locals.config.get('server') as ConfigurationSchema['server'];
+      const serverConfig = typedConfig.get('server');
       // Ok now start the internal port if we have one.
       if (serverConfig?.internalPort || serverConfig?.internalPort === 0) {
         startInternalApp(app, serverConfig.internalPort)
@@ -372,4 +379,5 @@ export async function listen<SLocals extends ServiceLocals = ServiceLocals>(
   return server;
 }
 
-export type ListenFn<SLocals extends ServiceLocals = ServiceLocals> = typeof listen<SLocals>;
+export type ListenFn<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>> =
+  typeof listen<SLocals>;

package/src/express-app/internal-server.ts

@@ -1,11 +1,14 @@
 import express from 'express';
 import type { Application } from 'express-serve-static-core';
 
-import { InternalLocals, ServiceExpress } from '../types';
+import { AnyServiceLocals, InternalLocals, ServiceExpress, ServiceLocals } from '../types';
 import { findPort } from '../development/port-finder';
+import { ConfigurationSchema } from '../config/schema';
 
-export async function startInternalApp(mainApp: ServiceExpress, port: number) {
-  const app = express() as unknown as Application<InternalLocals>;
+export async function startInternalApp<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+>(mainApp: ServiceExpress<SLocals>, port: number) {
+  const app = express() as unknown as Application<InternalLocals<SLocals>>;
   app.locals.mainApp = mainApp;
 
   const finalPort = port === 0 ? await findPort(3001) : port;

package/src/express-app/route-loader.ts

@@ -2,11 +2,14 @@ import path from 'path';
 
 import express from 'express';
 
-import type { ServiceExpress } from '../types';
+import type { AnyServiceLocals, ServiceExpress, ServiceLocals } from '../types';
+import { ConfigurationSchema } from '../config/schema';
 
 import { getFilesInDir, loadModule } from './modules';
 
-export async function loadRoutes(app: ServiceExpress, routingDir: string, pattern: string) {
+export async function loadRoutes<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+>(app: ServiceExpress<SLocals>, routingDir: string, pattern: string) {
   const files = await getFilesInDir(pattern, routingDir);
 
   await Promise.all(

package/src/express-app/types.ts

@@ -1,9 +1,10 @@
 import type { NextFunction, Response } from 'express';
 
-import type { RequestLocals, RequestWithApp, ServiceLocals } from '../types';
+import type { AnyServiceLocals, RequestLocals, RequestWithApp, ServiceLocals } from '../types';
+import { ConfigurationSchema } from '../config/schema';
 
 export type ServiceHandler<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
   ResBody = unknown,
   RetType = unknown,
@@ -16,7 +17,7 @@ export type ServiceHandler<
 // Make it easier to declare route files. This is not an exhaustive list
 // of supported router methods, but it has the most common ones.
 export interface ServiceRouter<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 > {
   all(path: string, ...handlers: ServiceHandler<SLocals, RLocals>[]): void;

package/src/hook.ts

@@ -1,4 +1,5 @@
-import type { RequestLocals, Service, ServiceLocals } from './types';
+import { ConfigurationSchema } from './config/schema';
+import type { AnyServiceLocals, RequestLocals, Service, ServiceLocals } from './types';
 
 /**
  * Your service should call this function and then "inherit"
@@ -19,10 +20,10 @@ import type { RequestLocals, Service, ServiceLocals } from './types';
  *   }
  * }
  *
- * @returns Service<SLocals, RLocals>
+ * @returns Service<Config, SLocals, RLocals>
  */
 export function useService<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 >(baseService?: Service<SLocals, RLocals>): Service<SLocals, RLocals> {
   return {

package/src/index.ts

@@ -1,5 +1,4 @@
 export * from './telemetry';
-export * from './service-calls';
 export * from './express-app';
 export * from './types';
 export * from './env';

package/src/openapi.ts

@@ -4,8 +4,9 @@ import _ from 'lodash';
 import * as OpenApiValidator from 'express-openapi-validator';
 import type { Handler } from 'express';
 
-import type { ServiceExpress } from './types';
+import type { AnyServiceLocals, ServiceExpress, ServiceLocals } from './types';
 import { getFilesInDir, loadModule } from './express-app/modules';
+import { ConfigurationSchema } from './config/schema';
 
 const notImplementedHandler: Handler = (req, res) => {
   res.status(501).json({
@@ -21,8 +22,10 @@ function stripExtension(filename: string) {
   return filename.slice(0, filename.lastIndexOf('.'));
 }
 
-export async function openApi(
-  app: ServiceExpress,
+export async function openApi<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+>(
+  app: ServiceExpress<SLocals>,
   rootDirectory: string,
   codepath: string,
   pattern: string,

package/src/telemetry/index.ts

@@ -4,12 +4,14 @@ import * as opentelemetry from '@opentelemetry/sdk-node';
 import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
 
 import type {
+  AnyServiceLocals,
   DelayLoadServiceStartOptions,
   RequestLocals,
   ServiceLocals,
   ServiceStartOptions,
 } from '../types';
 import type { ListenFn, StartAppFn } from '../express-app/index';
+import type { ConfigurationSchema } from '../config/schema';
 
 import { getAutoInstrumentations, getResourceDetectors } from './instrumentations';
 import { DummySpanExporter } from './DummyExporter';
@@ -70,7 +72,7 @@ export async function shutdownGlobalTelemetry() {
 }
 
 export async function startWithTelemetry<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 >(options: DelayLoadServiceStartOptions) {
   startGlobalTelemetry(options.name);

package/src/telemetry/requestLogger.ts

@@ -1,8 +1,9 @@
 import type { RequestHandler, Request, Response, ErrorRequestHandler } from 'express';
 
 import { ServiceError } from '../error';
-import type { RequestWithApp, ServiceExpress, ServiceLocals } from '../types';
+import type { AnyServiceLocals, RequestWithApp, ServiceExpress, ServiceLocals } from '../types';
 import type { ServiceHandler } from '../express-app/types';
+import { ConfigurationSchema } from '../config/schema';
 
 const LOG_PREFS = Symbol('Logging information');
 
@@ -38,7 +39,7 @@ function getBasicInfo(req: Request) {
   return preInfo;
 }
 
-function finishLog<SLocals extends ServiceLocals = ServiceLocals>(
+function finishLog<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>>(
   app: ServiceExpress<SLocals>,
   error: Error | undefined,
   req: Request,
@@ -92,11 +93,9 @@ function finishLog<SLocals extends ServiceLocals = ServiceLocals>(
   logger.info(endLog, 'req');
 }
 
-export function loggerMiddleware<SLocals extends ServiceLocals = ServiceLocals>(
-  app: ServiceExpress<SLocals>,
-  logRequests?: boolean,
-  logResponses?: boolean,
-): RequestHandler {
+export function loggerMiddleware<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+>(app: ServiceExpress<SLocals>, logRequests?: boolean, logResponses?: boolean): RequestHandler {
   const { logger, service } = app.locals;
   return function gblogger(req, res, next) {
     const prefs: LogPrefs = {
@@ -142,11 +141,9 @@ export function loggerMiddleware<SLocals extends ServiceLocals = ServiceLocals>(
   };
 }
 
-export function errorHandlerMiddleware<SLocals extends ServiceLocals = ServiceLocals>(
-  app: ServiceExpress<SLocals>,
-  unnest?: boolean,
-  returnError?: boolean,
-) {
+export function errorHandlerMiddleware<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+>(app: ServiceExpress<SLocals>, unnest?: boolean, returnError?: boolean) {
   const gbErrorHandler: ErrorRequestHandler = (error, req, res, next) => {
     let loggable: Partial<ServiceError> = error;
     const body = error.response?.body || error.body;

package/src/types.ts

@@ -10,9 +10,11 @@ import { Confit } from '@sesamecare-oss/confit';
 
 import { ConfigurationSchema } from './config/schema';
 
-export interface InternalLocals extends Record<string, unknown> {
+export interface InternalLocals<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+> extends Record<string, unknown> {
   server?: Server;
-  mainApp: ServiceExpress;
+  mainApp: ServiceExpress<SLocals>;
 }
 
 export type ServiceLogger = pino.BaseLogger & Pick<pino.Logger, 'isLevelEnabled'>;
@@ -26,7 +28,7 @@ export interface ServiceLocals<Config extends ConfigurationSchema = Configuratio
   logger: ServiceLogger;
   config: Confit<Config>;
   meter: Meter;
-  internalApp: Application<InternalLocals>;
+  internalApp: Application<InternalLocals<this>>;
 }
 
 export interface RequestLocals {
@@ -36,10 +38,14 @@ export interface RequestLocals {
   logger: ServiceLogger;
 }
 
-export type ServiceExpress<Locals extends ServiceLocals = ServiceLocals> = Application<Locals>;
-export type RequestWithApp<Locals extends ServiceLocals = ServiceLocals> = Omit<Request, 'app'> & {
-  app: Application<Locals>;
-};
+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,
@@ -49,7 +55,7 @@ export type ResponseFromApp<
  * This is the core type you need to implement to provide a service
  */
 export interface Service<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 > {
   name?: string;
@@ -97,12 +103,12 @@ export interface Service<
 }
 
 export type ServiceFactory<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 > = () => Service<SLocals, RLocals>;
 
 export interface ServiceStartOptions<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 > {
   name: string;
@@ -134,7 +140,9 @@ export interface ServiceOptions {
   openApiOptions?: Parameters<typeof middleware>[0];
 }
 
-export interface ServiceLike<SLocals extends ServiceLocals = ServiceLocals> {
+export interface ServiceLike<
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
+> {
   locals: SLocals;
 }
 
@@ -147,7 +155,7 @@ export interface ServiceLike<SLocals extends ServiceLocals = ServiceLocals> {
  * logger.
  */
 export interface RequestLike<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
 > {
   app: ServiceLike<SLocals>;
@@ -161,7 +169,7 @@ export interface RequestLike<
 // Typically you should export an interface that extends this one
 // and then access all your types through that.
 export interface ServiceTypes<
-  SLocals extends ServiceLocals = ServiceLocals,
+  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
   RLocals extends RequestLocals = RequestLocals,
   ResBody = unknown,
 > {
@@ -178,3 +186,14 @@ export interface ServiceTypes<
   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>;

package/build/service-calls/index.d.ts

@@ -1,16 +0,0 @@
-import type { FetchConfig, RestApiResponse } from 'rest-api-support';
-import { ServiceErrorSpec } from '../error';
-import type { ServiceExpress, ServiceLike, ServiceLocals } from '../types';
-/**
- * Return a factory that will make instances of an OpenAPI/Swagger client for each request
- */
-export declare function createServiceInterface<ServiceType>(service: ServiceExpress, name: string, Implementation: {
-    new (c: FetchConfig): ServiceType;
-}): ServiceType;
-interface SpecWithMessage extends ServiceErrorSpec {
-    message?: string;
-}
-export declare function throwOrGetResponse<SLocals extends ServiceLocals, AppType extends ServiceLike<SLocals>, ResType extends RestApiResponse<number, SuccessResponseType>, SuccessResponseType>(app: AppType, exec: () => Promise<ResType>, errorSpec?: SpecWithMessage): Promise<Extract<ResType, {
-    responseType: 'response';
-}>>;
-export {};