@terreno/api 0.7.0 → 0.7.2

package/src/__tests__/versionCheck.test.ts

@@ -0,0 +1,132 @@
+import {afterEach, beforeEach, describe, expect, it} from "bun:test";
+import supertest from "supertest";
+import {VersionConfig} from "../models/versionConfig";
+import {TerrenoApp} from "../terrenoApp";
+import {setupDb, UserModel} from "../tests";
+import {VersionCheckPlugin} from "../versionCheckPlugin";
+
+describe("VersionCheckPlugin", () => {
+  let app: ReturnType<typeof supertest>;
+
+  beforeEach(async () => {
+    await setupDb();
+    await VersionConfig.deleteMany({});
+
+    const expressApp = new TerrenoApp({
+      skipListen: true,
+      userModel: UserModel as any,
+    })
+      .register(new VersionCheckPlugin())
+      .build();
+
+    app = supertest(expressApp);
+  });
+
+  afterEach(async () => {
+    await VersionConfig.deleteMany({});
+  });
+
+  it("returns ok when no VersionConfig exists", async () => {
+    const res = await app.get("/version-check").query({platform: "web", version: 100});
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({status: "ok"});
+  });
+
+  it("returns ok when version param is missing", async () => {
+    const res = await app.get("/version-check");
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({status: "ok"});
+  });
+
+  it("returns ok when version param is invalid", async () => {
+    const res = await app.get("/version-check").query({platform: "web", version: "invalid"});
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({status: "ok"});
+  });
+
+  it("returns ok when client version >= warning and required (web)", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 50,
+      webWarningVersion: 100,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 150});
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({status: "ok"});
+  });
+
+  it("returns warning when client version < warning (web)", async () => {
+    await VersionConfig.create({
+      warningMessage: "Please update!",
+      webRequiredVersion: 50,
+      webWarningVersion: 100,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 80});
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe("warning");
+    expect(res.body.message).toBe("Please update!");
+  });
+
+  it("returns required when client version < required (web)", async () => {
+    await VersionConfig.create({
+      requiredMessage: "Update required",
+      updateUrl: "https://example.com/update",
+      webRequiredVersion: 100,
+      webWarningVersion: 150,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 50});
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe("required");
+    expect(res.body.message).toBe("Update required");
+    expect(res.body.updateUrl).toBe("https://example.com/update");
+  });
+
+  it("uses mobile thresholds when platform is mobile", async () => {
+    await VersionConfig.create({
+      mobileRequiredVersion: 200,
+      mobileWarningVersion: 250,
+      webRequiredVersion: 50,
+      webWarningVersion: 80,
+    });
+
+    const webRes = await app.get("/version-check").query({platform: "web", version: 100});
+    expect(webRes.body.status).toBe("ok");
+
+    const mobileRes = await app.get("/version-check").query({platform: "mobile", version: 100});
+    expect(mobileRes.body.status).toBe("required");
+  });
+
+  it("defaults to web when platform is invalid", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 100,
+      webWarningVersion: 150,
+    });
+
+    const res = await app.get("/version-check").query({platform: "invalid", version: 50});
+    expect(res.body.status).toBe("required");
+  });
+
+  it("version equal to threshold returns ok (not warning)", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 50,
+      webWarningVersion: 100,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 100});
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({status: "ok"});
+  });
+
+  it("version equal to required returns warning not required", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 100,
+      webWarningVersion: 150,
+    });
+
+    const res = await app.get("/version-check").query({platform: "web", version: 100});
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe("warning");
+  });
+});

package/src/expressServer.ts

@@ -1,5 +1,4 @@
 import * as Sentry from "@sentry/bun";
-import openapi from "@wesleytodd/openapi";
 import cors from "cors";
 import cron from "cron";
 import express, {type Router} from "express";
@@ -8,7 +7,6 @@ import cloneDeep from "lodash/cloneDeep";
 import onFinished from "on-finished";
 import passport from "passport";
 import qs from "qs";
-
 import type {ModelRouterOptions} from "./api";
 import {addAuthRoutes, addMeRoutes, setupAuth, type UserModel as UserMongooseModel} from "./auth";
 import {apiErrorMiddleware, apiUnauthorizedMiddleware} from "./errors";
@@ -17,6 +15,7 @@ import {type LoggingOptions, logger, setupLogging} from "./logger";
 import {sendToSlack} from "./notifiers";
 import {openApiCompatMiddleware, patchAppUse} from "./openApiCompat";
 import {openApiEtagMiddleware} from "./openApiEtag";
+import openapi from "./vendor/wesleytodd-openapi/index";
 
 const SLOW_READ_MAX = 200;
 const SLOW_WRITE_MAX = 500;

package/src/index.ts

@@ -10,6 +10,7 @@ export * from "./expressServer";
 export * from "./githubAuth";
 export * from "./logger";
 export * from "./middleware";
+export * from "./models/versionConfig";
 export * from "./notifiers";
 export * from "./openApiBuilder";
 export * from "./openApiCompat";
@@ -24,3 +25,4 @@ export * from "./terrenoApp";
 export * from "./terrenoPlugin";
 export * from "./transformers";
 export * from "./utils";
+export * from "./versionCheckPlugin";

package/src/models/versionConfig.ts

@@ -0,0 +1,92 @@
+import mongoose, {type Document} from "mongoose";
+
+import {type APIErrorConstructor} from "../errors";
+import {createdUpdatedPlugin, findOneOrNone} from "../plugins";
+
+export interface VersionConfigDocument extends mongoose.Document {
+  webWarningVersion: number;
+  webRequiredVersion: number;
+  mobileWarningVersion: number;
+  mobileRequiredVersion: number;
+  warningMessage: string;
+  requiredMessage: string;
+  updateUrl?: string;
+  created?: Date;
+  updated?: Date;
+}
+
+export interface VersionConfigModel extends mongoose.Model<VersionConfigDocument> {
+  findOneOrNone(
+    query: Record<string, any>,
+    errorArgs?: Partial<APIErrorConstructor>
+  ): Promise<(Document & VersionConfigDocument) | null>;
+}
+
+const versionConfigSchema = new mongoose.Schema<VersionConfigDocument>(
+  {
+    mobileRequiredVersion: {
+      default: 0,
+      description: "Build number at which mobile users are blocked from using the app",
+      min: 0,
+      type: Number,
+    },
+    mobileWarningVersion: {
+      default: 0,
+      description: "Build number at which mobile users see a warning toast",
+      min: 0,
+      type: Number,
+    },
+    requiredMessage: {
+      default: "This version is no longer supported. Please update to continue.",
+      description: "Message shown on the blocking screen",
+      type: String,
+    },
+    updateUrl: {
+      description:
+        "App store or download URL for mobile updates (optional, falls back to expo-updates)",
+      type: String,
+    },
+    warningMessage: {
+      default: "A new version is available. Please update for the best experience.",
+      description: "Message shown in the warning toast",
+      type: String,
+    },
+    webRequiredVersion: {
+      default: 0,
+      description: "Build number at which web users are blocked from using the app",
+      min: 0,
+      type: Number,
+    },
+    webWarningVersion: {
+      default: 0,
+      description: "Build number at which web users see a warning toast",
+      min: 0,
+      type: Number,
+    },
+  },
+  {strict: "throw", toJSON: {virtuals: true}, toObject: {virtuals: true}}
+);
+
+// Enforce singleton: only one VersionConfig document can exist.
+// The _singleton field is always "config" (required, immutable, enum-constrained)
+// and a unique index guarantees at most one document.
+(versionConfigSchema as mongoose.Schema).add({
+  _singleton: {
+    default: "config",
+    description: "Sentinel field to enforce singleton via unique index",
+    enum: ["config"],
+    immutable: true,
+    required: true,
+    select: false,
+    type: String,
+  },
+});
+versionConfigSchema.index({_singleton: 1}, {unique: true});
+
+versionConfigSchema.plugin(createdUpdatedPlugin);
+versionConfigSchema.plugin(findOneOrNone);
+
+export const VersionConfig = mongoose.model<VersionConfigDocument, VersionConfigModel>(
+  "VersionConfig",
+  versionConfigSchema
+);

package/src/terrenoApp.ts

@@ -1,9 +1,7 @@
 import * as Sentry from "@sentry/bun";
-import openapi from "@wesleytodd/openapi";
 import cors from "cors";
 import express from "express";
 import qs from "qs";
-
 import type {ModelRouterRegistration} from "./api";
 import {addAuthRoutes, addMeRoutes, setupAuth, type UserModel as UserMongooseModel} from "./auth";
 import {ConfigurationApp, type ConfigurationAppOptions} from "./configurationApp";
@@ -14,6 +12,7 @@ import {type LoggingOptions, logger, setupLogging} from "./logger";
 import {openApiCompatMiddleware, patchAppUse} from "./openApiCompat";
 import {openApiEtagMiddleware} from "./openApiEtag";
 import type {TerrenoPlugin} from "./terrenoPlugin";
+import openapi from "./vendor/wesleytodd-openapi/index";
 
 type CorsOrigin =
   | string

package/src/vendor/wesleytodd-openapi/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2018 Wes Todd <wes@wesleytodd.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/src/vendor/wesleytodd-openapi/index.js

@@ -0,0 +1,189 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: express-5)
+// Package: @wesleytodd/openapi v1.1.0
+// License: ISC (see LICENSE)
+// Vendored to allow local modifications and avoid external dependency drift.
+'use strict'
+const httpErrors = require('http-errors')
+const Router = require('router')
+const SwaggerParser = require('swagger-parser')
+const ui = require('./lib/ui')
+const makeValidator = require('./lib/validate')
+const { get: getSchema, set: setSchema } = require('./lib/layer-schema')
+const minimumViableDocument = require('./lib/minimum-doc')
+const generateDocument = require('./lib/generate-doc')
+const defaultRoutePrefix = '/openapi'
+const YAML = require('yaml')
+
+module.exports = function ExpressOpenApi (_routePrefix, _doc, _opts) {
+  // Acceptable arguments:
+  //   oapi()
+  //   oapi('/path')
+  //   oapi('/path', doc)
+  //   oapi('/path', doc, opts)
+  //   oapi(doc)
+  //   oapi(doc, opts)
+  //
+  // The below logic is correct, but very hard to reason about
+  let routePrefix = _routePrefix || defaultRoutePrefix
+  let doc = _doc || minimumViableDocument
+  let opts = _opts || {}
+  if (typeof _routePrefix !== 'string') {
+    routePrefix = defaultRoutePrefix
+    doc = _routePrefix || minimumViableDocument
+    opts = _doc || {}
+  }
+
+  // We need to route a bit, seems a safe addition
+  // to use the express router in an express middleware
+  const router = new Router()
+
+  // Fully generate the doc on the first request
+  let isFirstRequest = true
+
+  // Where the magic happens
+  const middleware = function OpenApiMiddleware (req, res, next) {
+    if (isFirstRequest) {
+      middleware.document = generateDocument(middleware.document, req.app._router || req.app.router, opts.basePath)
+      isFirstRequest = false
+    }
+
+    router.handle(req, res, next)
+  }
+
+  // Expose the current document and prefix
+  middleware.routePrefix = routePrefix
+  middleware.document = generateDocument(doc, undefined, opts.basePath)
+  middleware.generateDocument = generateDocument
+  middleware.options = opts
+
+  // Add a path schema to the document
+  middleware.path = function (schema = {}) {
+    function schemaMiddleware (req, res, next) {
+      next()
+    }
+
+    setSchema(schemaMiddleware, schema)
+    return schemaMiddleware
+  }
+
+  // Validate path middleware
+  middleware.validPath = function (schema = {}, pathOpts = {}) {
+    let validate
+    function validSchemaMiddleware (req, res, next) {
+      if (!validate) {
+        validate = makeValidator(middleware, getSchema(validSchemaMiddleware), { ...pathOpts, ...opts })
+      }
+      return validate(req, res, next)
+    }
+
+    setSchema(validSchemaMiddleware, schema)
+    return validSchemaMiddleware
+  }
+
+  // Component definitions
+  middleware.component = function (type, name, description) {
+    if (!type) {
+      throw new TypeError('Component type is required')
+    }
+
+    // Return whole component type
+    if (!name && !description) {
+      return middleware.document.components && middleware.document.components[type]
+    }
+
+    // Return ref to type
+    if (name && !description) {
+      if (!middleware.document.components || !middleware.document.components[type] || !middleware.document.components[type][name]) {
+        throw new Error(`Unknown ${type} ref: ${name}`)
+      }
+      return { $ref: `#/components/${type}/${name}` }
+    }
+
+    // Set name on parameter if not passed
+    if (type === 'parameters') {
+      description.name = description.name || name
+    }
+
+    // Define a new component
+    middleware.document.components = middleware.document.components || {}
+    middleware.document.components[type] = middleware.document.components[type] || {}
+    middleware.document.components[type][name] = description
+
+    return middleware
+  }
+  middleware.schema = middleware.component.bind(null, 'schemas')
+  middleware.response = middleware.component.bind(null, 'responses')
+  middleware.parameters = middleware.component.bind(null, 'parameters')
+  middleware.examples = middleware.component.bind(null, 'examples')
+  middleware.requestBodies = middleware.component.bind(null, 'requestBodies')
+  middleware.headers = middleware.component.bind(null, 'headers')
+  middleware.securitySchemes = middleware.component.bind(null, 'securitySchemes')
+  middleware.links = middleware.component.bind(null, 'links')
+  middleware.callbacks = middleware.component.bind(null, 'callbacks')
+
+  // Expose ui middleware
+  middleware.swaggerui = (options) => ui.serveSwaggerUI(`${routePrefix}.json`, options)
+
+  // OpenAPI document as json
+  router.get(`${routePrefix}.json`, (req, res) => {
+    middleware.document = generateDocument(middleware.document, req.app._router || req.app.router, opts.basePath)
+    res.json(middleware.document)
+  })
+
+  // OpenAPI document as yaml
+  router.get([`${routePrefix}.yaml`, `${routePrefix}.yml`], (req, res) => {
+    const jsonSpec = generateDocument(middleware.document, req.app._router || req.app.router, opts.basePath)
+    const yamlSpec = YAML.stringify(jsonSpec)
+
+    res.type('yaml')
+    res.send(yamlSpec)
+  })
+
+  router.get(`${routePrefix}/components/:type/:name.json`, (req, res, next) => {
+    const { type, name } = req.params
+    middleware.document = generateDocument(middleware.document, req.app._router || req.app.router, opts.basePath)
+
+    // No component by that identifer
+    if (!middleware.document.components[type] || !middleware.document.components[type][name]) {
+      return next(httpErrors(404, `Component does not exist: ${type}/${name}`))
+    }
+
+    // Return component
+    res.json(middleware.document.components[type][name])
+  })
+
+  // Validate full open api document
+  router.get(`${routePrefix}/validate`, (req, res) => {
+    middleware.document = generateDocument(middleware.document, req.app._router || req.app.router, opts.basePath)
+    SwaggerParser.validate(middleware.document, (err, api) => {
+      if (err) {
+        return res.json({
+          valid: false,
+          details: err.details,
+          document: middleware.document
+        })
+      }
+      res.json({
+        valid: true,
+        document: middleware.document
+      })
+    })
+  })
+
+  // Serve up the for exploring the document
+  if (opts.htmlui) {
+    let ui = opts.htmlui
+    if (!Array.isArray(opts.htmlui)) {
+      ui = [opts.htmlui]
+    }
+    if (ui.includes('swagger-ui')) {
+      router.get(`${routePrefix}`, (req, res) => { res.redirect(`${routePrefix}/swagger-ui`) })
+      router.use(`${routePrefix}/swagger-ui`, middleware.swaggerui)
+    }
+  }
+
+  return middleware
+}
+
+module.exports.minimumViableDocument = minimumViableDocument
+module.exports.defaultRoutePrefix = defaultRoutePrefix

package/src/vendor/wesleytodd-openapi/lib/convert-yaml.js

@@ -0,0 +1,13 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: express-5)
+// License: ISC (see ../LICENSE)
+const YAML = require('yaml')
+
+/**
+ * Converts a json to yaml
+ * @param {object} jsonObject
+ * @returns {string} yamlString
+ */
+module.exports = function (jsonObject) {
+  const doc = YAML.stringify(jsonObject)
+  return doc
+}

package/src/vendor/wesleytodd-openapi/lib/generate-doc.js

@@ -0,0 +1,153 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: main / tag: v1.1.0)
+// NOTE: This file uses the main-branch algorithm (regexp-based route traversal) rather than
+// the express-5 branch version, because the express-5 version requires router.getRoutes()
+// which only exists on the bjohansebas/router fork and not on the Express 5 app router.
+// The main-branch approach works correctly with the openApiCompat.ts regexp shim.
+// License: ISC (see ../LICENSE)
+'use strict'
+const pathToRegexp = require('path-to-regexp')
+const minimumViableDocument = require('./minimum-doc')
+const { get: getSchema, set: setSchema } = require('./layer-schema')
+
+module.exports = function generateDocument (baseDocument, router, basePath) {
+  // Merge document with select minimum defaults
+  const doc = Object.assign({
+    openapi: minimumViableDocument.openapi
+  }, baseDocument, {
+    info: Object.assign({}, minimumViableDocument.info, baseDocument.info),
+    paths: Object.assign({}, minimumViableDocument.paths, baseDocument.paths)
+  })
+
+  // Iterate the middleware stack and add any paths and schemas, etc
+  router && router.stack.forEach((_layer) => {
+    iterateStack('', null, _layer, (path, routeLayer, layer) => {
+      if (basePath && path.startsWith(basePath)) {
+        path = path.replace(basePath, '')
+      }
+      const schema = getSchema(layer.handle)
+      if (!schema || !layer.method) {
+        return
+      }
+
+      const operation = Object.assign({}, schema)
+
+      // Add route params to schema
+      if (routeLayer && routeLayer.keys && routeLayer.keys.length) {
+        const keys = {}
+
+        const params = routeLayer.keys.map((k, i) => {
+          const prev = i > 0 && routeLayer.keys[i - 1]
+          // do not count parameters without a name if they are next to a named parameter
+          if (typeof k.name === 'number' && prev && prev.offset + prev.name.length + 1 >= k.offset) {
+            return null
+          }
+          let param
+          if (schema.parameters) {
+            param = schema.parameters.find((p) => p.name === k.name && p.in === 'path')
+          }
+
+          // Reformat the path
+          keys[k.name] = '{' + k.name + '}'
+
+          return Object.assign({
+            name: k.name,
+            in: 'path',
+            required: !k.optional,
+            schema: k.schema || { type: 'string' }
+          }, param || {})
+        })
+          .filter((e) => e)
+
+        if (schema.parameters) {
+          schema.parameters.forEach((p) => {
+            if (!params.find((pp) => p.name === pp.name)) {
+              params.push(p)
+            }
+          })
+        }
+
+        operation.parameters = params
+        path = pathToRegexp.compile(path.replace(/\*|\(\*\)/g, '(.*)'))(keys, { encode: (value) => value })
+      }
+
+      doc.paths[path] = doc.paths[path] || {}
+      doc.paths[path][layer.method] = operation
+      setSchema(layer.handle, operation)
+    })
+  })
+
+  return doc
+}
+
+function iterateStack (path, routeLayer, layer, cb) {
+  cb(path, routeLayer, layer)
+  if (layer.name === 'router') {
+    layer.handle.stack.forEach(l => {
+      path = path || ''
+      iterateStack(path + split(layer.regexp, layer.keys).join('/'), layer, l, cb)
+    })
+  }
+  if (!layer.route) {
+    return
+  }
+  if (Array.isArray(layer.route.path)) {
+    const r = layer.regexp.toString()
+    layer.route.path.forEach((p, i) => iterateStack(path + p, layer, {
+      ...layer,
+      // Checking if p is a string here since p may be a regex expression
+      keys: layer.keys.filter((k) => typeof p === 'string' ? p.includes(`/:${k.name}`) : false),
+      // There may be an issue here if the regex has a '|', but that seems to only be the case with user defined regex
+      regexp: new RegExp(`(${r.substring(2, r.length - 3).split('|')[i]})`),
+      route: { ...layer.route, path: '' }
+    }, cb))
+    return
+  }
+  layer.route.stack.forEach((l) => iterateStack(path + layer.route.path, layer, l, cb))
+}
+
+function processComplexMatch (thing, keys) {
+  let i = 0
+
+  return thing
+    .toString()
+    // The replace below replaces the regex used by Express to match dynamic parameters
+    // (i.e. /:id, /:name, etc...) with the name(s) of those parameter(s)
+    // This could have been accomplished with replaceAll for Node version 15 and above
+    // no-useless-escape is disabled since we need three backslashes
+    .replace(/\(\?\:\(\[\^\\\/\]\+\?\)\)/g, () => `{${keys[i++].name}}`) // eslint-disable-line no-useless-escape
+    .replace(/\\(.)/g, '$1')
+    // The replace below removes the regex used at the start of the string and
+    // the regex used to match the query parameters
+    .replace(/\/\^|\/\?(.*)/g, '')
+    .split('/')
+}
+
+// https://github.com/expressjs/express/issues/3308#issuecomment-300957572
+function split (thing, keys) {
+  // In express v5 the router layers regexp (path-to-regexp@3.2.0)
+  // has some additional handling for end of lines, remove those
+  //
+  // layer.regexp
+  // v4 ^\\/sub-route\\/?(?=\\/|$)
+  // v5 ^\\/sub-route(?:\\/(?=$))?(?=\\/|$)
+  //
+  // l.regexp
+  // v4 ^\\/endpoint\\/?$
+  // v5 ^\\/endpoint(?:\\/)?$
+  if (typeof thing === 'string') {
+    return thing.split('/')
+  } else if (thing.fast_slash) {
+    return []
+  } else {
+    const match = thing
+      .toString()
+      .replace('\\/?', '')
+      .replace('(?=\\/|$)', '$')
+      // Added this line to catch the express v5 case after the v4 part is stripped off
+      .replace('(?:\\/(?=$))?$', '$')
+      .match(/^\/\^((?:\\[.*+?^${}()|[\]\\/]|[^.*+?^${}()|[\]\\/])*)\$\//)
+    return match
+      ? match[1].replace(/\\(.)/g, '$1').split('/')
+      : processComplexMatch(thing, keys)
+  }
+}

package/src/vendor/wesleytodd-openapi/lib/layer-schema.js

@@ -0,0 +1,13 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: express-5)
+// License: ISC (see ../LICENSE)
+'use strict'
+const schemas = new Map()
+
+module.exports = {
+  set: (handler, schema) => {
+    schemas.set(handler, schema)
+  },
+  get: (handler) => {
+    return schemas.get(handler)
+  }
+}

package/src/vendor/wesleytodd-openapi/lib/minimum-doc.js

@@ -0,0 +1,12 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: express-5)
+// License: ISC (see ../LICENSE)
+'use strict'
+
+module.exports = {
+  openapi: '3.0.0',
+  info: {
+    title: 'Express App',
+    version: '1.0.0'
+  },
+  paths: {}
+}