@openapi-typescript-infra/service 6.10.1 → 6.10.2

package/__tests__/fake-serv/src/index.ts

@@ -1,36 +0,0 @@
-import type { Service, ServiceLocals } from '../../../src/types.js';
-import { useService } from '../../../src/index.js';
-
-export interface FakeServLocals extends ServiceLocals {
-  services: {
-    fakeServ: {
-      get_something(): Promise<{ things: string[] } | Error>;
-    };
-  };
-}
-
-export function service(): Service<FakeServLocals> {
-  const base = useService<FakeServLocals>();
-  return {
-    ...base,
-    async start(app) {
-      await base.start(app);
-      app.locals.services = app.locals.services || {};
-      app.locals.services.fakeServ = {
-        async get_something() {
-          throw new Error('Should not be called.');
-        },
-      };
-    },
-    async onRequest(req, res) {
-      await base.onRequest?.(req, res);
-      res.locals.rawBody = true;
-    },
-    async healthy(app) {
-      await base.healthy?.(app);
-      return new Promise((accept) => {
-        setTimeout(accept, 1000);
-      });
-    },
-  };
-}

package/__tests__/fake-serv/src/routes/error.ts

@@ -1,16 +0,0 @@
-import type { ServiceRouter } from '../../../../src/index';
-import { ServiceError } from '../../../../src/error';
-
-export function route(router: ServiceRouter) {
-  router.get('/sync', (req) => {
-    throw new ServiceError(req.app, 'Synchronous error', { code: 'SyncError' });
-  });
-
-  router.get('/async', async (req) => {
-    await new Promise((accept) => {
-      setTimeout(accept, 100);
-    }).then(() => {
-      throw new ServiceError(req.app, 'Async error', { code: 'AsyncError' });
-    });
-  });
-}

package/__tests__/fake-serv/src/routes/index.ts

@@ -1,19 +0,0 @@
-import type { ServiceExpress, ServiceRouter } from '../../../../src/index';
-import type { FakeServLocals } from '../index';
-
-export function route(router: ServiceRouter<FakeServLocals>, app: ServiceExpress<FakeServLocals>) {
-  const worldRequests = app.locals.meter.createCounter('world_requests', {
-    description: 'Metrics about requests to world',
-  });
-
-  router.get('/world', (req, res) => {
-    worldRequests.add(1, { method: 'get' });
-    res.json({ hello: 'world' });
-  });
-
-  router.post('/world', async (req, res) => {
-    await app.locals.services.fakeServ.get_something();
-    worldRequests.add(1);
-    res.sendStatus(204);
-  });
-}

package/__tests__/fake-serv/src/routes/other/world.ts

@@ -1,7 +0,0 @@
-import type { Router } from 'express';
-
-export function route(router: Router) {
-  router.get('/', (req, res) => {
-    res.json({ hello: 'jupiter' });
-  });
-}

package/__tests__/fake-serv.test.ts

@@ -1,119 +0,0 @@
-import http from 'http';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { describe, expect, test } from 'vitest';
-import request from 'supertest';
-
-import type {
-  ServiceStartOptions} from '../src/index.js';
-import {
-  listen,
-  startApp,
-} from '../src/index.js';
-
-import { type FakeServLocals, service } from './fake-serv/src/index.js';
-
-function httpRequest(options: http.RequestOptions) {
-  return new Promise((resolve, reject) => {
-    const req = http.request(options, (res) => {
-      let responseData = '';
-      res.on('data', (chunk) => {
-        responseData += chunk;
-      });
-      res.on('end', () => {
-        resolve(responseData);
-      });
-    });
-    req.on('error', (e) => {
-      reject(e);
-    });
-    req.end();
-  });
-}
-
-describe('fake-serv', () => {
-  test('basic service functionality', async () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-
-    const options: ServiceStartOptions<FakeServLocals> = {
-      service,
-      name: 'fake-serv',
-      rootDirectory: path.resolve(__dirname, './fake-serv'),
-      codepath: 'src',
-      version: '1.0.0',
-    };
-
-    const app = await startApp(options).catch((error) => {
-      // eslint-disable-next-line no-console
-      console.error(error);
-      throw error;
-    });
-    expect(app.locals.config.server.port).not.toEqual(0);
-    expect(app).toBeTruthy();
-
-    let { body } = await request(app).get('/world').timeout(500).expect(200);
-    expect(body.hello).toEqual('world');
-
-    ({ body } = await request(app).get('/other/world').timeout(500).expect(200));
-    expect(body.hello).toEqual('jupiter');
-
-    ({ body } = await request(app)
-      .get('/hello')
-      .query({ greeting: 'Hello Pluto!', number: '6', break_things: true })
-      .expect(200));
-    expect(body.greeting).toEqual('Hello Pluto!');
-
-    // Can't convert green to a number
-    await request(app)
-      .get('/hello')
-      .query({ greeting: 'Hello Pluto!', number: 'green' })
-      .expect(400);
-
-    // Make sure body paramater conversion works
-    await request(app).post('/hello').send({ number: 'green' }).expect(400);
-    await request(app).post('/hello').send({ number: '6' }).expect(204);
-    await request(app).post('/hello').send({ number: 6 }).expect(204);
-
-    ({ body } = await request(app).get('/error/sync').timeout(1000).expect(500));
-    expect(body.code).toEqual('SyncError');
-
-    ({ body } = await request(app).get('/error/async').timeout(1000).expect(500));
-    expect(body.code).toEqual('AsyncError');
-
-    // Mocking
-    await request(app).post('/world').expect(500);
-
-    const server = await listen(app);
-    // Exercise the http module
-    await httpRequest({
-      hostname: 'localhost',
-      port: app.locals.config.server.port,
-      path: '/hello?greeting=Hello&number=6',
-      method: 'GET',
-    });
-    await request(app.locals.internalApp)
-      .get('/metrics')
-      .expect(200)
-      .expect((res) => {
-        expect(res.text).toMatch(/nodejs_version_info{version/);
-        expect(res.text).toMatch(/# UNIT http_server_duration ms/);
-        expect(res.text).toMatch(/world_requests_total{method="get".*} 1/);
-        expect(res.text).toContain(
-          'http_request_duration_seconds_bucket{status_code="200",method="GET",path="/world",service="fake-serv"',
-        );
-      });
-
-    // Clean shutdown
-    await new Promise<void>((accept, reject) => {
-      server.close((e) => {
-        if (e) {
-          reject(e);
-        } else {
-          accept();
-        }
-      });
-    });
-  });
-});

package/__tests__/vitest.test-setup.ts

@@ -1,15 +0,0 @@
-import { afterAll, beforeAll } from 'vitest';
-
-import { shutdownGlobalTelemetry, startGlobalTelemetry } from '../src/telemetry/index.js';
-
-// Even in testing, this needs to run first so that the instrumentation
-// is loaded BEFORE express is loaded.
-const startPromise = startGlobalTelemetry('fake-serv');
-
-beforeAll(async () => {
-  await startPromise;
-});
-
-afterAll(async () => {
-  await shutdownGlobalTelemetry().catch(() => undefined);
-});

package/src/bin/start-service.ts

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-import minimist from 'minimist';
-
-import { serviceRepl } from '../development/repl.js';
-import { isDev } from '../env.js';
-import { bootstrap } from '../bootstrap.js';
-
-/**
- * built - forces the use of the build directory. Defaults to true in stage/prod, not in dev
- * repl - launch the REPL (defaults to disabling telemetry)
- * telemetry - whether to use OpenTelemetry. Defaults to false in dev or with repl
- * nobind - do not listen on http port or expose metrics
- */
-const argv = minimist(process.argv.slice(2), {
-  boolean: ['built', 'repl', 'telemetry', 'nobind'],
-});
-
-if (argv.telemetry) {
-  await import('../telemetry/hook-modules.js');
-}
-
-const noTelemetry = (argv.repl || isDev()) && !argv.telemetry;
-void bootstrap({
-  ...argv,
-  telemetry: !noTelemetry,
-}).then(({ app, codepath, server }) => {
-  if (argv.repl) {
-    serviceRepl(app, codepath, () => {
-      server?.close();
-    });
-  }
-});

package/src/bootstrap.ts

@@ -1,160 +0,0 @@
-import path from 'node:path';
-import assert from 'node:assert';
-
-import { config } from 'dotenv';
-import { readPackageUp } from 'read-package-up';
-import type { NormalizedPackageJson } from 'read-package-up';
-import type { NodeSDKConfiguration } from '@opentelemetry/sdk-node';
-
-import type {
-  AnyServiceLocals,
-  RequestLocals,
-  ServiceLocals,
-  ServiceStartOptions,
-} from './types.js';
-import { isDev } from './env.js';
-import { startWithTelemetry } from './telemetry/index.js';
-import type { ConfigurationSchema } from './config/schema.js';
-
-interface BootstrapArguments {
-  // The name of the service, else discovered via read-package-up
-  name?: string;
-  // The name of the file with the service function, relative to root
-  main?: string;
-  // Root directory of the app, else discovered via read-package-up
-  root?: string;
-  // Use built directory. Omitting lets us determine a sensible default
-  built?: boolean;
-  // The location of the package.json used for discovery (defaults to cwd)
-  packageDir?: string;
-  // Whether to engage telemetry
-  telemetry?: boolean;
-  // Don't bind to http port or expose metrics
-  nobind?: boolean;
-  // The version of the app, else discovered via read-package-up
-  version?: string;
-}
-
-function resolveMain(packageJson: NormalizedPackageJson) {
-  if (typeof packageJson.main === 'string') {
-    return packageJson.main;
-  }
-  return undefined;
-}
-
-async function getServiceDetails(argv: BootstrapArguments = {}) {
-  if (argv.name && argv.root) {
-    return {
-      rootDirectory: argv.root,
-      name: argv.name,
-      version: argv.version || '0.0.0',
-      main: argv.main || (isDev() && !argv.built ? 'src/index.ts' : 'build/index.js'),
-    };
-  }
-  const cwd = argv.packageDir ? path.resolve(argv.packageDir) : process.cwd();
-  const pkg = await readPackageUp({ cwd });
-  if (!pkg) {
-    throw new Error(
-      `Unable to find package.json in ${cwd} to get main module. Make sure you are running from the package root directory.`,
-    );
-  }
-  const main = resolveMain(pkg.packageJson);
-  const parts = pkg.packageJson.name.split('/');
-  return {
-    main,
-    rootDirectory: path.dirname(pkg.path),
-    name: parts[parts.length - 1],
-    version: pkg.packageJson.version,
-    customizer: (pkg.packageJson.config?.telemetry as { customizer?: string })?.customizer,
-  };
-}
-
-function getBuildDir(main: string): 'build' | 'dist' {
-  const dir = /^(?:\.?\/?)(build|dist)\//.exec(main);
-  assert(dir, 'Could not determine build directory - should be dist or build');
-  return dir[1] as 'build' | 'dist';
-}
-
-// Automagically start your app by using common patterns
-// to find your implementation and settings. This is most useful
-// for jobs or other scripts that need service infra but are
-// not simply the service
-export async function bootstrap<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-  RLocals extends RequestLocals = RequestLocals,
->(argv?: BootstrapArguments) {
-  const { main, rootDirectory, name, version, customizer } = await getServiceDetails(argv);
-
-  let entrypoint: string;
-  let codepath: 'build' | 'dist' | 'src' = 'build';
-  if (isDev() && argv?.built !== true) {
-    const handlesTs = parseInt(process.versions.node.split('.')[0], 10) >= 24;
-    if (!handlesTs) {
-      await import('tsx/esm');
-    }
-    if (main) {
-      entrypoint = handlesTs
-        ? main
-        : main.replace(/^(\.?\/?)(build|dist)\//, '$1src/').replace(/\.js$/, '.ts');
-    } else {
-      entrypoint = './src/index.ts';
-    }
-    codepath = 'src';
-  } else if (main) {
-    codepath = getBuildDir(main);
-    entrypoint = main;
-  } else {
-    entrypoint = './build/index.js';
-  }
-
-  config({ quiet: true });
-
-  const absoluteEntrypoint = path.resolve(rootDirectory, entrypoint);
-  if (argv?.telemetry) {
-    let otelCustomizer:
-      | ((options: Partial<NodeSDKConfiguration>) => Partial<NodeSDKConfiguration>)
-      | undefined = undefined;
-    if (customizer) {
-      // Customize OTEL with a dynamic import based on the codePath (so put it in src, generally)
-      otelCustomizer = (await import(path.resolve(`${codepath}/${customizer}`)))
-        .NodeSDKConfiguration;
-      if (typeof otelCustomizer === 'object') {
-        otelCustomizer = (v) => ({ ...v, ...(otelCustomizer as Partial<NodeSDKConfiguration>) });
-      }
-    }
-    return startWithTelemetry<SLocals, RLocals>({
-      name,
-      rootDirectory,
-      service: absoluteEntrypoint,
-      codepath,
-      version,
-      customizer: otelCustomizer,
-    });
-  }
-
-  // This needs to be required for TS on-the-fly to work
-
-  const impl = await import(absoluteEntrypoint);
-  const opts: ServiceStartOptions<SLocals, RLocals> = {
-    name,
-    version,
-    rootDirectory,
-    service: impl.default || impl.service,
-    codepath,
-  };
-
-  const { startApp, listen } = await import('./express-app/app.js');
-  const app = await startApp<SLocals, RLocals>(opts);
-  const server = argv?.nobind ? undefined : await listen(app);
-  return { server, app, codepath };
-}
-
-export function bootstrapCli<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-  RLocals extends RequestLocals = RequestLocals,
->(argv?: BootstrapArguments) {
-  return bootstrap<SLocals, RLocals>({
-    nobind: true,
-    ...argv,
-  });
-}

package/src/config/index.ts

@@ -1,124 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import type { BaseConfitSchema, Confit, Factory, ShortstopHandler } from '@sesamecare-oss/confit';
-import { confit } from '@sesamecare-oss/confit';
-
-import { getAvailablePort } from '../development/port-finder.js';
-
-import type { ConfigurationSchema } from './schema.js';
-
-// Order matters here.
-const ENVIRONMENTS = ['production', 'staging', 'test', 'development'] as const;
-
-async function pathExists(f: string) {
-  return new Promise((accept, reject) => {
-    fs.stat(f, (err) => {
-      if (!err) {
-        accept(true);
-      } else if (err.code === 'ENOENT') {
-        accept(false);
-      } else {
-        reject(err);
-      }
-    });
-  });
-}
-
-async function addDefaultConfiguration<Config extends ConfigurationSchema = ConfigurationSchema>(
-  configFactory: Factory<Config>,
-  directory: string,
-  envConfit: Confit<BaseConfitSchema>,
-) {
-  const addIfEnv = async (e: (typeof ENVIRONMENTS)[number]) => {
-    const c = path.join(directory, `${e}.json`);
-    if (envConfit.get().env[e] && (await pathExists(c))) {
-      configFactory.addDefault(c);
-      return true;
-    }
-    return false;
-  };
-
-  await ENVIRONMENTS.reduce(
-    (runningPromise, environment) => runningPromise.then((prev) => prev || addIfEnv(environment)),
-    Promise.resolve(false),
-  );
-
-  const baseConfig = path.join(directory, 'config.json');
-  if (await pathExists(baseConfig)) {
-    configFactory.addDefault(baseConfig);
-  }
-}
-
-export interface ServiceConfigurationSpec {
-  // The LAST configuration is the most "specific" - if a configuration value
-  // exists in all directories, the last one wins
-  configurationDirectories: string[];
-  shortstopHandlers: Record<string, ShortstopHandler<string, unknown>>;
-}
-
-export async function loadConfiguration<Config extends ConfigurationSchema>({
-  configurationDirectories: dirs,
-  shortstopHandlers,
-}: ServiceConfigurationSpec): Promise<Config> {
-  const specificConfig = dirs[dirs.length - 1];
-
-  // This confit version just gets us environment info
-  const envConfit = await confit({ basedir: specificConfig }).create();
-  const configFactory = confit<Config>({
-    basedir: specificConfig,
-    protocols: shortstopHandlers,
-  });
-
-  /**
-   * Note that in confit, when using addDefault,
-   * the FIRST addDefault takes precendence over the next (and so on), so
-   * if you override this method, you should register your defaults first.
-   */
-  const defaultOrder = dirs.slice(0, dirs.length - 1).reverse();
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path.dirname(__filename);
-
-  defaultOrder.push(path.join(__dirname, '../..', 'config'));
-  await defaultOrder.reduce(
-    (promise, dir) => promise.then(() => addDefaultConfiguration(configFactory, dir, envConfit)),
-    Promise.resolve(),
-  );
-
-  const loaded = await configFactory.create();
-
-  // Because other things need to know the port we choose, we pick it here if it's
-  // configured to auto-select
-  const serverConfig = loaded.get().server;
-  if (serverConfig.port === 0) {
-    const port = await getAvailablePort(8001);
-    const store = loaded.get();
-    store.server = store.server || {};
-    store.server.port = port;
-  }
-
-  // TODO init other stuff based on config here, such as key management or
-  // other cloud-aware shortstop handlers
-
-  // Not sure why this is necessary, but it is
-  return loaded.get();
-}
-
-export function insertConfigurationBefore(
-  configDirs: string[] | undefined,
-  insert: string,
-  before: string,
-) {
-  const copy = [...(configDirs || [])];
-  const index = copy.indexOf(before);
-  if (index === -1) {
-    copy.push(insert, before);
-  } else {
-    copy.splice(index, 0, insert);
-  }
-  return copy;
-}
-
-export * from './schema.js';
-export * from './validation.js';

package/src/config/schema.ts

@@ -1,70 +0,0 @@
-import type { BaseConfitSchema } from '@sesamecare-oss/confit';
-import type { middleware } from 'express-openapi-validator';
-import type { Level } from 'pino';
-import type bodyParser from 'body-parser';
-
-export interface ConfigurationItemEnabled {
-  enabled?: boolean;
-}
-
-export interface ConfigurationSchema extends BaseConfitSchema {
-  trustProxy?: string[] | boolean;
-  logging?: {
-    level?: Level;
-    logRequestBody?: boolean;
-    logResponseBody?: boolean;
-    // Whether to log a "pre" message when request processing starts. Most useful in
-    // situations where there is some problem causing requests to hang
-    preLog?: boolean;
-  };
-  routing?: {
-    openapi?: boolean | Partial<Parameters<typeof middleware>[0]>;
-    // Relative to the *root directory* of the app
-    routes?: string;
-    // Whether to add middleware that "freezes" the query string
-    // rather than preserving the new Express@5 behavior of reparsing
-    // every time (which causes problems for OpenAPI validation)
-    freezeQuery?: boolean;
-    // Whether to compute etag headers. http://expressjs.com/en/api.html#etag.options.table
-    etag?: boolean;
-    cookieParser?: boolean;
-    bodyParsers?: {
-      json?: boolean | Parameters<typeof bodyParser.json>[0];
-      form?: boolean | Parameters<typeof bodyParser.urlencoded>[0];
-    };
-    // Set static.enabled to true to enable static assets to be served
-    static?: ConfigurationItemEnabled & {
-      // The path relative to the root directory of the app
-      path?: string;
-      // The path on which to mount the static assets (defaults to /)
-      mountPath?: string;
-    };
-    finalHandlers: {
-      // Whether to create and return errors for unhandled routes
-      notFound?: boolean;
-      // Whether to handle errors and return them to clients
-      // (currently means we will return JSON errors)
-      errors?: ConfigurationItemEnabled & {
-        render?: boolean;
-        // Check to see if we got an error from an upstream
-        // service that has code/domain/message, and if so return
-        // that as is. Otherwise we will sanitize it to avoid leaking
-        // information.
-        unnest: boolean;
-      };
-    };
-  };
-  server: {
-    internalPort?: number;
-    port?: number;
-    // To enable HTTPS on the main service, set the key and cert to the
-    // actual key material (not the path). Use shortstop file: handler.
-    // Note that generally it's better to offload tls termination,
-    // but this is useful for dev.
-    key?: string | Uint8Array;
-    certificate?: string | Uint8Array;
-    // If you have an alternate host name (other than localhost) that
-    // should be used when referring to this service, set it here.
-    hostname?: string;
-  };
-}