@openapi-typescript-infra/service 6.10.1 → 6.10.2

package/src/config/shortstops.ts

@@ -1,155 +0,0 @@
-import os from 'os';
-import path from 'path';
-
-import {
-  base64Handler,
-  envHandler,
-  fileHandler,
-  pathHandler,
-  requireHandler,
-  yamlHandler,
-  type ShortstopHandler,
-} from '@sesamecare-oss/confit';
-
-/**
- * Default shortstop handlers for GasBuddy service configuration
- */
-
-/**
- * A require: shortstop that will dig and find a named function
- * with a url-like hash pattern
- */
-function betterRequire(basepath: string) {
-  const baseRequire = requireHandler(basepath);
-  return function hashRequire(v: string) {
-    const [moduleName, func] = v.split('#');
-    const module = baseRequire(moduleName);
-    if (func) {
-      if (module[func]) {
-        return module[func];
-      }
-      return baseRequire(v);
-    }
-    return module;
-  };
-}
-
-/**
- * Just like path, but resolve ~/ to the home directory
- */
-function betterPath(basepath: string) {
-  const basePath = pathHandler(basepath);
-  return function pathWithHomeDir(v: string) {
-    if (v.startsWith('~/')) {
-      return basePath(path.join(os.homedir(), v.slice(2)));
-    }
-    return basePath(v);
-  };
-}
-
-/**
- * Just like file, but resolve ~/ to the home directory
- */
-function betterFile(basepath: string) {
-  const baseFile = fileHandler(basepath);
-  return function fileWithHomeDir(v: string) {
-    if (v.startsWith('~/')) {
-      return baseFile(path.join(os.homedir(), v.slice(2)));
-    }
-    return baseFile(v);
-  };
-}
-
-function canonicalizeServiceSuffix(suffix?: string) {
-  if (!suffix) {
-    return 'internal';
-  }
-  return { serv: 'internal' }[suffix] || suffix;
-}
-
-/**
- * Our convention is that service names end with:
- *  -serv or -internal - a back end service not callable by the outside world and where no authorization occurs (canonicalized to internal)
- *  -api - a non-UI front end service that exposes swagger and sometimes non-swagger APIs
- *  -web - a UI front end service
- *  -worker - a scheduled job or queue processor
- *
- * This shortstop will take a CSV of service types and tell you if this service is
- * of that type, or if the first character after serviceType: is an exclamation point,
- * whether it's NOT of any of the specified types
- */
-function serviceTypeFactory(name: string) {
-  const type = canonicalizeServiceSuffix(name.split('-').pop());
-
-  return function serviceType(v: string) {
-    let checkValue = v;
-    let matchIsGood = true;
-    if (checkValue.startsWith('!')) {
-      matchIsGood = false;
-      checkValue = checkValue.substring(1);
-    }
-    const values = checkValue.split(',').map(canonicalizeServiceSuffix);
-    // Welp, there's no XOR so here we are.
-    return type && values.includes(type) ? matchIsGood : !matchIsGood;
-  };
-}
-
-const osMethods = {
-  hostname: os.hostname,
-  platform: os.platform,
-  type: os.type,
-  version: os.version,
-};
-
-export function shortstops(service: { name: string }, sourcedir: string) {
-  /**
-   * Since we use transpiled sources a lot,
-   * basedir and sourcedir are meaningfully different reference points.
-   */
-  const basedir = path.join(sourcedir, '..');
-
-  const env = envHandler();
-
-  return {
-    env,
-    // A version of env that can default to false
-    env_switch(v: string) {
-      if (v && v.startsWith('!')) {
-        const bval = env(`${v.substring(1)}|b`);
-        return !bval;
-      }
-      return !!env(v);
-    },
-    base64: base64Handler(),
-    regex(v: string) {
-      const [, pattern, flags] = /^\/(.*)\/([a-z]*)$/.exec(v) || [];
-      if (pattern === undefined) {
-        throw new Error(`Invalid regular expression in configuration ${v}`);
-      }
-      return new RegExp(pattern, flags);
-    },
-
-    // handle source and base directory intelligently
-    path: betterPath(basedir),
-    sourcepath: pathHandler(sourcedir),
-    file: betterFile(basedir),
-    sourcefile: fileHandler(sourcedir),
-    require: betterRequire(basedir),
-    sourcerequire: betterRequire(sourcedir),
-
-    // Sometimes yaml is more pleasant for configuration
-    yaml: yamlHandler(basedir),
-
-    // Switch on service type
-    servicetype: serviceTypeFactory(service.name),
-    servicename: (v: string) => v.replace(/\$\{name\}/g, service.name),
-
-    os(p: string) {
-      return osMethods[p as keyof typeof osMethods]();
-    },
-    // No-op in case you have values that start with a shortstop handler name (and colon)
-    literal(v: string) {
-      return v;
-    },
-  } satisfies Record<string, ShortstopHandler<string, unknown>>;
-}

package/src/config/validation.ts

@@ -1,23 +0,0 @@
-import type { ConfigurationSchema } from './schema.js';
-
-export interface ConfigValidationError {
-  path: string;
-  message: string;
-}
-
-export type ConfigurationValidator<Config extends ConfigurationSchema> = (config: Config) => {
-  success: boolean;
-  errors: ConfigValidationError[];
-};
-
-export function validateConfiguration<Config extends ConfigurationSchema>(
-  config: Config,
-  validator: ConfigurationValidator<Config>,
-) {
-  const result = validator(config);
-  if (!result.success) {
-    const errorMessages = result.errors.map((e) => `  - ${e.path}: ${e.message}`).join('\n');
-    throw new Error(`Configuration validation failed:
-${errorMessages}`);
-  }
-}

package/src/development/port-finder.ts

@@ -1,67 +0,0 @@
-import net from 'net';
-
-import { isTest } from '../env.js';
-
-// Inspired by https://github.com/kessler/find-port/blob/master/lib/findPort.js
-async function isAvailable(port: number) {
-  return new Promise((accept, reject) => {
-    const server = net.createServer().listen(port);
-
-    const timeoutRef = setTimeout(() => {
-      accept(false);
-    }, 2000);
-
-    timeoutRef.unref();
-
-    server.once('listening', () => {
-      clearTimeout(timeoutRef);
-      server.close();
-      accept(true);
-    });
-    server.once('error', (err) => {
-      clearTimeout(timeoutRef);
-
-      if ((err as { code?: string }).code === 'EADDRINUSE') {
-        accept(false);
-        return;
-      }
-
-      reject(err);
-    });
-  });
-}
-
-async function findPort(start: number) {
-  for (let p = start; p < start + 1000; p += 1) {
-    if (await isAvailable(p)) {
-      return p;
-    }
-  }
-  return 0;
-}
-
-async function getEphemeralPort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-
-    server.listen(0, () => {
-      const address = server.address();
-      if (typeof address === 'string' || !address) {
-        reject(new Error('Invalid address'));
-        return;
-      }
-      const port = address.port; // Retrieve the ephemeral port
-      server.close((err) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(port);
-        }
-      });
-    });
-  });
-}
-
-export async function getAvailablePort(basePort: number): Promise<number> {
-  return isTest() || process.env.TEST_RUNNER ? getEphemeralPort() : findPort(basePort);
-}

package/src/development/repl.ts

@@ -1,131 +0,0 @@
-import type { REPLServer } from 'node:repl';
-import repl from 'node:repl';
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { glob } from 'glob';
-import { set } from 'moderndash';
-
-import type { AnyServiceLocals, ServiceExpress, ServiceLocals } from '../types.js';
-import type { ConfigurationSchema } from '../config/schema.js';
-
-const REPL_PROP = '$$repl$$';
-
-interface WithReplProp {
-  [REPL_PROP]?: string;
-}
-
-export function serviceRepl<SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>>(
-  app: ServiceExpress<SLocals>,
-  codepath: string | undefined,
-  onExit: () => void,
-) {
-  class FakeReq {
-    locals: { app: ServiceExpress<SLocals> } = { app };
-    headers: Record<string, string | string[] | undefined> = {};
-    query = new URLSearchParams();
-    body: unknown = {};
-
-    constructor(public path: string) {
-      this.locals.app = app;
-    }
-  }
-
-  const rl = repl.start({
-    prompt: '> ',
-  });
-  Object.assign(rl.context, app.locals, {
-    app,
-    req: new FakeReq('/'),
-    dump(o: unknown) {
-      console.log(JSON.stringify(o, null, '\t'));
-    },
-    // Use iTerm2's escape code to copy to clipboard
-    pbcopy(str: string) {
-      const encoded = Buffer.from(str.toString(), 'utf8').toString('base64');
-      process.stdout.write(`\x1b]52;c;${encoded}\x07`);
-    },
-  });
-  rl.setupHistory(path.resolve('.node_repl_history'), (err) => {
-    if (err) {
-      // eslint-disable-next-line no-console
-      console.error('History setup failed', err);
-    }
-  });
-  app.locals.service.attachRepl?.(app, rl);
-
-  loadReplFunctions(app, codepath, rl).catch((error) => {
-    // eslint-disable-next-line no-console
-    console.error('Failed to load REPL functions', error);
-  });
-
-  rl.on('exit', onExit);
-}
-
-async function loadReplFunctions<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
->(app: ServiceExpress<SLocals>, codepath: string | undefined, rl: REPLServer) {
-  if (!codepath) {
-    return;
-  }
-
-  const files = glob.sync(path.join(codepath, '**/*.{js,ts}'));
-
-  for (const file of files) {
-    try {
-      // Read the file content as text
-      const fileContent = fs.readFileSync(file, 'utf-8');
-
-      // Check if repl$ is present, in a very rudimentary way (note built JS has close paren not open)
-      if (/repl\$[()]/.test(fileContent)) {
-        const module = await import(path.resolve(file));
-
-        // Look for functions with the REPL_PROP marker
-        for (const exported of Object.values(module as Record<string, unknown>)) {
-          if (!exported) {
-            continue;
-          }
-          if (typeof exported === 'function') {
-            const replName = (exported as WithReplProp)[REPL_PROP];
-            if (replName) {
-              set(rl.context, replName, exported.bind(null, app));
-            }
-          }
-        }
-      }
-    } catch (err) {
-      // eslint-disable-next-line no-console
-      console.error(`Failed to load REPL functions from ${file}:`, err);
-    }
-  }
-}
-
-// Can't seem to sort out proper generics here, so we'll just use any since it's dev only
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type ReplAny = any;
-
-/**
- * This decorator-like function can be applied to functions and the service will load and expose
- * the function when the repl is engaged.
- *
- * async function myFunction(app: MyService['App'], arg1: string, arg2: number) {
- * }
- * repl$(myFunction);
- *
- * or
- *
- * repl(myFunction, 'some.func.name');
- */
-export function repl$<
-  S extends ServiceExpress<ReplAny>,
-  T extends (app: S, ...args: ReplAny[]) => ReplAny,
->(fn: T, name?: string) {
-  const functionName = name || fn.name;
-  if (!functionName) {
-    throw new Error('Function must have a name or a name must be provided.');
-  }
-  Object.defineProperty(fn, REPL_PROP, {
-    enumerable: false,
-    value: functionName,
-  });
-}

package/src/env.ts

@@ -1,29 +0,0 @@
-type ValidEnv = 'development' | 'production' | 'staging' | 'test';
-
-export function getNodeEnv(): ValidEnv {
-  switch (process.env.APP_ENV || process.env.NODE_ENV) {
-    case 'production':
-    case 'staging':
-    case 'test':
-      return (process.env.APP_ENV || process.env.NODE_ENV) as ValidEnv;
-    case undefined:
-    default:
-      return 'development';
-  }
-}
-
-export function isDev() {
-  return getNodeEnv() === 'development';
-}
-
-export function isProd() {
-  return getNodeEnv() === 'production';
-}
-
-export function isStaging() {
-  return getNodeEnv() === 'staging';
-}
-
-export function isTest() {
-  return getNodeEnv() === 'test';
-}

package/src/error.ts

@@ -1,47 +0,0 @@
-import type { ConfigurationSchema } from './config/schema.js';
-import type { AnyServiceLocals, ServiceLike, ServiceLocals } from './types.js';
-
-export interface ServiceErrorSpec {
-  status?: number;
-  code?: string;
-  domain?: string;
-  display_message?: string;
-  log_stack?: boolean;
-  expected_error?: boolean;
-  client_metadata?: Record<string, unknown>;
-}
-
-/**
- * An error that gives more structured information to callers. Throw inside a handler as
- *
- *   throw new Error(req, 'Something broke', { code: 'SomethingBroke', status: 400 });
- *
- * You can also include a display_message which is intended to be viewed by the end user
- */
-export class ServiceError<
-  SLocals extends AnyServiceLocals = ServiceLocals<ConfigurationSchema>,
-> extends Error {
-  public status: number | undefined;
-
-  public code?: string;
-
-  public domain: string;
-
-  public display_message?: string;
-
-  public log_stack?: boolean;
-
-  // Additional data TO BE RETURNED TO THE CLIENT
-  public client_metadata?: Record<string, unknown>;
-
-  // If true, this shouldn't be logged as an error, but as an info log.
-  // This is common when the error needs to go to the client, but should not
-  // take up the valuable mental space of an error log.
-  public expected_error?: boolean;
-
-  constructor(app: ServiceLike<SLocals>, message: string, spec?: ServiceErrorSpec) {
-    super(message);
-    this.domain = app.locals.name;
-    Object.assign(this, spec);
-  }
-}