@terreno/api 0.7.0 → 0.7.2

package/dist/__tests__/versionCheck.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/versionCheck.test.js

@@ -0,0 +1,263 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var bun_test_1 = require("bun:test");
+var supertest_1 = __importDefault(require("supertest"));
+var versionConfig_1 = require("../models/versionConfig");
+var terrenoApp_1 = require("../terrenoApp");
+var tests_1 = require("../tests");
+var versionCheckPlugin_1 = require("../versionCheckPlugin");
+(0, bun_test_1.describe)("VersionCheckPlugin", function () {
+    var app;
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var expressApp;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, tests_1.setupDb)()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, versionConfig_1.VersionConfig.deleteMany({})];
+                case 2:
+                    _a.sent();
+                    expressApp = new terrenoApp_1.TerrenoApp({
+                        skipListen: true,
+                        userModel: tests_1.UserModel,
+                    })
+                        .register(new versionCheckPlugin_1.VersionCheckPlugin())
+                        .build();
+                    app = (0, supertest_1.default)(expressApp);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.deleteMany({})];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns ok when no VersionConfig exists", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 100 })];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body).toEqual({ status: "ok" });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns ok when version param is missing", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, app.get("/version-check")];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body).toEqual({ status: "ok" });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns ok when version param is invalid", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: "invalid" })];
+                case 1:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body).toEqual({ status: "ok" });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns ok when client version >= warning and required (web)", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        webRequiredVersion: 50,
+                        webWarningVersion: 100,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 150 })];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body).toEqual({ status: "ok" });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns warning when client version < warning (web)", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        warningMessage: "Please update!",
+                        webRequiredVersion: 50,
+                        webWarningVersion: 100,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 80 })];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body.status).toBe("warning");
+                    (0, bun_test_1.expect)(res.body.message).toBe("Please update!");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("returns required when client version < required (web)", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        requiredMessage: "Update required",
+                        updateUrl: "https://example.com/update",
+                        webRequiredVersion: 100,
+                        webWarningVersion: 150,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 50 })];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body.status).toBe("required");
+                    (0, bun_test_1.expect)(res.body.message).toBe("Update required");
+                    (0, bun_test_1.expect)(res.body.updateUrl).toBe("https://example.com/update");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("uses mobile thresholds when platform is mobile", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var webRes, mobileRes;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        mobileRequiredVersion: 200,
+                        mobileWarningVersion: 250,
+                        webRequiredVersion: 50,
+                        webWarningVersion: 80,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 100 })];
+                case 2:
+                    webRes = _a.sent();
+                    (0, bun_test_1.expect)(webRes.body.status).toBe("ok");
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "mobile", version: 100 })];
+                case 3:
+                    mobileRes = _a.sent();
+                    (0, bun_test_1.expect)(mobileRes.body.status).toBe("required");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("defaults to web when platform is invalid", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        webRequiredVersion: 100,
+                        webWarningVersion: 150,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "invalid", version: 50 })];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.body.status).toBe("required");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("version equal to threshold returns ok (not warning)", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        webRequiredVersion: 50,
+                        webWarningVersion: 100,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 100 })];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body).toEqual({ status: "ok" });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("version equal to required returns warning not required", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, versionConfig_1.VersionConfig.create({
+                        webRequiredVersion: 100,
+                        webWarningVersion: 150,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, app.get("/version-check").query({ platform: "web", version: 100 })];
+                case 2:
+                    res = _a.sent();
+                    (0, bun_test_1.expect)(res.status).toBe(200);
+                    (0, bun_test_1.expect)(res.body.status).toBe("warning");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/dist/expressServer.js

@@ -105,7 +105,6 @@ exports.setupServer = setupServer;
 exports.cronjob = cronjob;
 exports.wrapScript = wrapScript;
 var Sentry = __importStar(require("@sentry/bun"));
-var openapi_1 = __importDefault(require("@wesleytodd/openapi"));
 var cors_1 = __importDefault(require("cors"));
 var cron_1 = __importDefault(require("cron"));
 var express_1 = __importDefault(require("express"));
@@ -120,6 +119,7 @@ var logger_1 = require("./logger");
 var notifiers_1 = require("./notifiers");
 var openApiCompat_1 = require("./openApiCompat");
 var openApiEtag_1 = require("./openApiEtag");
+var index_1 = __importDefault(require("./vendor/wesleytodd-openapi/index"));
 var SLOW_READ_MAX = 200;
 var SLOW_WRITE_MAX = 500;
 var IS_JEST = process.env.JEST_WORKER_ID !== undefined;
@@ -276,7 +276,7 @@ function initializeRoutes(UserModel, addRoutes, options) {
     // Add ETag middleware for OpenAPI JSON endpoint before the openapi middleware
     app.use(openApiCompat_1.openApiCompatMiddleware);
     app.use(openApiEtag_1.openApiEtagMiddleware);
-    var oapi = (0, openapi_1.default)({
+    var oapi = (0, index_1.default)({
         info: {
             description: "Generated docs from an Express api",
             title: "Express Application",

package/dist/index.d.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/dist/index.js

@@ -26,6 +26,7 @@ __exportStar(require("./expressServer"), exports);
 __exportStar(require("./githubAuth"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./middleware"), exports);
+__exportStar(require("./models/versionConfig"), exports);
 __exportStar(require("./notifiers"), exports);
 __exportStar(require("./openApiBuilder"), exports);
 __exportStar(require("./openApiCompat"), exports);
@@ -40,3 +41,4 @@ __exportStar(require("./terrenoApp"), exports);
 __exportStar(require("./terrenoPlugin"), exports);
 __exportStar(require("./transformers"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./versionCheckPlugin"), exports);

package/dist/models/versionConfig.d.ts

@@ -0,0 +1,17 @@
+import mongoose, { type Document } from "mongoose";
+import { type APIErrorConstructor } from "../errors";
+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>;
+}
+export declare const VersionConfig: VersionConfigModel;

package/dist/models/versionConfig.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionConfig = void 0;
+var mongoose_1 = __importDefault(require("mongoose"));
+var plugins_1 = require("../plugins");
+var versionConfigSchema = new mongoose_1.default.Schema({
+    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.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(plugins_1.createdUpdatedPlugin);
+versionConfigSchema.plugin(plugins_1.findOneOrNone);
+exports.VersionConfig = mongoose_1.default.model("VersionConfig", versionConfigSchema);

package/dist/terrenoApp.js

@@ -60,7 +60,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TerrenoApp = void 0;
 var Sentry = __importStar(require("@sentry/bun"));
-var openapi_1 = __importDefault(require("@wesleytodd/openapi"));
 var cors_1 = __importDefault(require("cors"));
 var express_1 = __importDefault(require("express"));
 var qs_1 = __importDefault(require("qs"));
@@ -72,6 +71,7 @@ var githubAuth_1 = require("./githubAuth");
 var logger_1 = require("./logger");
 var openApiCompat_1 = require("./openApiCompat");
 var openApiEtag_1 = require("./openApiEtag");
+var index_1 = __importDefault(require("./vendor/wesleytodd-openapi/index"));
 /**
  * Fluent API for building Express applications with Terreno framework.
  *
@@ -300,7 +300,7 @@ var TerrenoApp = /** @class */ (function () {
         // OpenAPI
         app.use(openApiCompat_1.openApiCompatMiddleware);
         app.use(openApiEtag_1.openApiEtagMiddleware);
-        var oapi = (0, openapi_1.default)({
+        var oapi = (0, index_1.default)({
             info: {
                 description: "Generated docs from an Express api",
                 title: "Express Application",

package/dist/vendor/wesleytodd-openapi/index.d.ts

@@ -0,0 +1,27 @@
+declare function _exports(_routePrefix: any, _doc: any, _opts: any): {
+    (req: any, res: any, next: any): void;
+    routePrefix: any;
+    document: any;
+    generateDocument: (baseDocument: any, router: any, basePath: any) => any;
+    options: any;
+    path(schema?: {}): (req: any, res: any, next: any) => void;
+    validPath(schema?: {}, pathOpts?: {}): (req: any, res: any, next: any) => any;
+    component(type: any, name: any, description: any): any;
+    schema: (name?: any, description?: any) => any;
+    response: (name?: any, description?: any) => any;
+    parameters: (name?: any, description?: any) => any;
+    examples: (name?: any, description?: any) => any;
+    requestBodies: (name?: any, description?: any) => any;
+    headers: (name?: any, description?: any) => any;
+    securitySchemes: (name?: any, description?: any) => any;
+    links: (name?: any, description?: any) => any;
+    callbacks: (name?: any, description?: any) => any;
+    swaggerui(options: any): any[];
+};
+declare namespace _exports {
+    export { minimumViableDocument };
+    export { defaultRoutePrefix };
+}
+export = _exports;
+import minimumViableDocument = require("./lib/minimum-doc");
+declare const defaultRoutePrefix: "/openapi";

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

@@ -0,0 +1,176 @@
+// 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';
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var httpErrors = require('http-errors');
+var Router = require('router');
+var SwaggerParser = require('swagger-parser');
+var ui = require('./lib/ui');
+var makeValidator = require('./lib/validate');
+var _a = require('./lib/layer-schema'), getSchema = _a.get, setSchema = _a.set;
+var minimumViableDocument = require('./lib/minimum-doc');
+var generateDocument = require('./lib/generate-doc');
+var defaultRoutePrefix = '/openapi';
+var 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
+    var routePrefix = _routePrefix || defaultRoutePrefix;
+    var doc = _doc || minimumViableDocument;
+    var 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
+    var router = new Router();
+    // Fully generate the doc on the first request
+    var isFirstRequest = true;
+    // Where the magic happens
+    var 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) {
+        if (schema === void 0) { schema = {}; }
+        function schemaMiddleware(req, res, next) {
+            next();
+        }
+        setSchema(schemaMiddleware, schema);
+        return schemaMiddleware;
+    };
+    // Validate path middleware
+    middleware.validPath = function (schema, pathOpts) {
+        if (schema === void 0) { schema = {}; }
+        if (pathOpts === void 0) { pathOpts = {}; }
+        var validate;
+        function validSchemaMiddleware(req, res, next) {
+            if (!validate) {
+                validate = makeValidator(middleware, getSchema(validSchemaMiddleware), __assign(__assign({}, 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 ".concat(type, " ref: ").concat(name));
+            }
+            return { $ref: "#/components/".concat(type, "/").concat(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 = function (options) { return ui.serveSwaggerUI("".concat(routePrefix, ".json"), options); };
+    // OpenAPI document as json
+    router.get("".concat(routePrefix, ".json"), function (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(["".concat(routePrefix, ".yaml"), "".concat(routePrefix, ".yml")], function (req, res) {
+        var jsonSpec = generateDocument(middleware.document, req.app._router || req.app.router, opts.basePath);
+        var yamlSpec = YAML.stringify(jsonSpec);
+        res.type('yaml');
+        res.send(yamlSpec);
+    });
+    router.get("".concat(routePrefix, "/components/:type/:name.json"), function (req, res, next) {
+        var _a = req.params, type = _a.type, name = _a.name;
+        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: ".concat(type, "/").concat(name)));
+        }
+        // Return component
+        res.json(middleware.document.components[type][name]);
+    });
+    // Validate full open api document
+    router.get("".concat(routePrefix, "/validate"), function (req, res) {
+        middleware.document = generateDocument(middleware.document, req.app._router || req.app.router, opts.basePath);
+        SwaggerParser.validate(middleware.document, function (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) {
+        var ui_1 = opts.htmlui;
+        if (!Array.isArray(opts.htmlui)) {
+            ui_1 = [opts.htmlui];
+        }
+        if (ui_1.includes('swagger-ui')) {
+            router.get("".concat(routePrefix), function (req, res) { res.redirect("".concat(routePrefix, "/swagger-ui")); });
+            router.use("".concat(routePrefix, "/swagger-ui"), middleware.swaggerui);
+        }
+    }
+    return middleware;
+};
+module.exports.minimumViableDocument = minimumViableDocument;
+module.exports.defaultRoutePrefix = defaultRoutePrefix;

package/dist/vendor/wesleytodd-openapi/lib/convert-yaml.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(jsonObject: object): string;
+export = _exports;

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

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

package/dist/vendor/wesleytodd-openapi/lib/generate-doc.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(baseDocument: any, router: any, basePath: any): any;
+export = _exports;