@terreno/api 0.10.0 → 0.11.1

package/dist/openApi.test.js

@@ -71,6 +71,7 @@ var supertest_1 = __importDefault(require("supertest"));
 var api_1 = require("./api");
 var auth_1 = require("./auth");
 var expressServer_1 = require("./expressServer");
+var openApi_1 = require("./openApi");
 var permissions_1 = require("./permissions");
 var tests_1 = require("./tests");
 function getMessageSummaryOpenApiMiddleware(options) {
@@ -450,3 +451,124 @@ function addRoutesPopulate(router, options) {
         });
     }); });
 });
+(0, bun_test_1.describe)("openApi middleware no-op paths", function () {
+    (0, bun_test_1.it)("getOpenApiMiddleware returns noop when openApi not configured", function () {
+        var mw = (0, openApi_1.getOpenApiMiddleware)(tests_1.FoodModel, {});
+        (0, bun_test_1.expect)(typeof mw).toBe("function");
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("getOpenApiMiddleware returns noop when read permissions are empty", function () {
+        var mw = (0, openApi_1.getOpenApiMiddleware)(tests_1.FoodModel, {
+            openApi: { component: function () { }, path: function () { return (function () { }); } },
+            permissions: {
+                create: [],
+                delete: [],
+                list: [],
+                read: [],
+                update: [],
+            },
+        });
+        (0, bun_test_1.expect)(typeof mw).toBe("function");
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("listOpenApiMiddleware returns noop when openApi not configured", function () {
+        var mw = (0, openApi_1.listOpenApiMiddleware)(tests_1.FoodModel, {});
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("listOpenApiMiddleware returns noop when list permissions are empty", function () {
+        var mw = (0, openApi_1.listOpenApiMiddleware)(tests_1.FoodModel, {
+            openApi: { path: function () { return (function () { }); } },
+            permissions: {
+                create: [],
+                delete: [],
+                list: [],
+                read: [],
+                update: [],
+            },
+        });
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("createOpenApiMiddleware returns noop when openApi not configured", function () {
+        var mw = (0, openApi_1.createOpenApiMiddleware)(tests_1.FoodModel, {});
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("createOpenApiMiddleware returns noop when create permissions are empty", function () {
+        var mw = (0, openApi_1.createOpenApiMiddleware)(tests_1.FoodModel, {
+            openApi: { path: function () { return (function () { }); } },
+            permissions: {
+                create: [],
+                delete: [],
+                list: [],
+                read: [],
+                update: [],
+            },
+        });
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("patchOpenApiMiddleware returns noop when openApi not configured", function () {
+        var mw = (0, openApi_1.patchOpenApiMiddleware)(tests_1.FoodModel, {});
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("patchOpenApiMiddleware returns noop when update permissions are empty", function () {
+        var mw = (0, openApi_1.patchOpenApiMiddleware)(tests_1.FoodModel, {
+            openApi: { path: function () { return (function () { }); } },
+            permissions: {
+                create: [],
+                delete: [],
+                list: [],
+                read: [],
+                update: [],
+            },
+        });
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("deleteOpenApiMiddleware returns noop when openApi not configured", function () {
+        var mw = (0, openApi_1.deleteOpenApiMiddleware)(tests_1.FoodModel, {});
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("deleteOpenApiMiddleware returns noop when delete permissions are empty", function () {
+        var mw = (0, openApi_1.deleteOpenApiMiddleware)(tests_1.FoodModel, {
+            openApi: { path: function () { return (function () { }); } },
+            permissions: {
+                create: [],
+                delete: [],
+                list: [],
+                read: [],
+                update: [],
+            },
+        });
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("readOpenApiMiddleware returns noop when openApi not configured", function () {
+        var mw = (0, openApi_1.readOpenApiMiddleware)({}, {}, [], []);
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("readOpenApiMiddleware returns noop when read permissions are empty", function () {
+        var mw = (0, openApi_1.readOpenApiMiddleware)({
+            openApi: { path: function () { return (function () { }); } },
+            permissions: {
+                create: [],
+                delete: [],
+                list: [],
+                read: [],
+                update: [],
+            },
+        }, { id: { type: "string" } }, ["id"], []);
+        (0, bun_test_1.expect)(mw.length).toBe(3);
+    });
+    (0, bun_test_1.it)("readOpenApiMiddleware returns middleware when configured with permissions", function () {
+        // Use a simple path stub that returns a middleware function
+        var pathFn = function () { return (function (_req, _res, next) { return next(); }); };
+        var mw = (0, openApi_1.readOpenApiMiddleware)({
+            openApi: { path: pathFn },
+            permissions: {
+                create: [],
+                delete: [],
+                list: [],
+                read: [permissions_1.Permissions.IsAny],
+                update: [],
+            },
+        }, { name: { type: "string" } }, ["name"], [{ in: "query", name: "search", schema: { type: "string" } }]);
+        (0, bun_test_1.expect)(typeof mw).toBe("function");
+    });
+});

package/dist/openApiBuilder.d.ts

@@ -210,6 +210,7 @@ export declare class OpenApiMiddlewareBuilder {
      * @param options - Router options containing the OpenAPI path configuration
      */
     constructor(options: Partial<ModelRouterOptions<unknown>>);
+    private describeRoute;
     /**
      * Sets the tags for the OpenAPI operation.
      *

package/dist/openApiBuilder.js

@@ -108,6 +108,17 @@ var OpenApiMiddlewareBuilder = /** @class */ (function () {
         };
         this.validationConfig = {};
     }
+    OpenApiMiddlewareBuilder.prototype.describeRoute = function () {
+        var _c;
+        var parts = [];
+        if (this.config.summary) {
+            parts.push("\"".concat(this.config.summary, "\""));
+        }
+        if ((_c = this.config.tags) === null || _c === void 0 ? void 0 : _c.length) {
+            parts.push("tags=[".concat(this.config.tags.join(", "), "]"));
+        }
+        return parts.length > 0 ? parts.join(" ") : "unnamed route";
+    };
     /**
      * Sets the tags for the OpenAPI operation.
      *
@@ -423,7 +434,7 @@ var OpenApiMiddlewareBuilder = /** @class */ (function () {
             openApiMiddleware = this.options.openApi.path((0, merge_1.default)(__assign(__assign({}, this.config), { responses: __assign(__assign({}, this.config.responses), openApi_1.defaultOpenApiErrorResponses) }), (_e = (_d = this.options.openApiOverwrite) === null || _d === void 0 ? void 0 : _d.get) !== null && _e !== void 0 ? _e : {}));
         }
         else {
-            logger_1.logger.debug("No options.openApi provided, skipping OpenApiMiddleware");
+            logger_1.logger.debug("No options.openApi provided in buildWithSchemas for ".concat(this.describeRoute(), ", skipping OpenApiMiddleware"));
         }
         var globalConfig = (0, openApiValidator_1.getOpenApiValidatorConfig)();
         var validationEnabled = (_f = this.validationConfig.enabled) !== null && _f !== void 0 ? _f : ((0, openApiValidator_1.isOpenApiValidatorConfigured)() && ((_g = globalConfig.validateRequests) !== null && _g !== void 0 ? _g : false));
@@ -468,7 +479,7 @@ var OpenApiMiddlewareBuilder = /** @class */ (function () {
             openApiMiddleware = this.options.openApi.path((0, merge_1.default)(__assign(__assign({}, this.config), { responses: __assign(__assign({}, this.config.responses), openApi_1.defaultOpenApiErrorResponses) }), (_e = (_d = this.options.openApiOverwrite) === null || _d === void 0 ? void 0 : _d.get) !== null && _e !== void 0 ? _e : {}));
         }
         else {
-            logger_1.logger.debug("No options.openApi provided, skipping OpenApiMiddleware");
+            logger_1.logger.debug("No options.openApi provided in build for ".concat(this.describeRoute(), ", skipping OpenApiMiddleware"));
         }
         // Check if validation should be enabled
         var globalConfig = (0, openApiValidator_1.getOpenApiValidatorConfig)();

package/dist/openApiBuilder.test.js

@@ -507,3 +507,69 @@ function addRoutesWithBuilder(router, options) {
         (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
     });
 });
+(0, bun_test_1.describe)("OpenApiMiddlewareBuilder withValidation / buildWithSchemas", function () {
+    (0, bun_test_1.beforeEach)(function () {
+        var resetOpenApiValidatorConfig = require("./openApiValidator").resetOpenApiValidatorConfig;
+        resetOpenApiValidatorConfig();
+    });
+    (0, bun_test_1.it)("buildWithSchemas returns bodySchema and querySchema", function () {
+        var _a, _b;
+        var result = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withRequestBody({ name: { required: true, type: "string" } })
+            .withQueryParameter("page", { type: "number" })
+            .buildWithSchemas();
+        (0, bun_test_1.expect)(result.bodySchema).toBeDefined();
+        (0, bun_test_1.expect)((_a = result.bodySchema) === null || _a === void 0 ? void 0 : _a.name).toBeDefined();
+        (0, bun_test_1.expect)(result.querySchema).toBeDefined();
+        (0, bun_test_1.expect)((_b = result.querySchema) === null || _b === void 0 ? void 0 : _b.page).toBeDefined();
+        (0, bun_test_1.expect)(typeof result.middleware).toBe("function");
+    });
+    (0, bun_test_1.it)("buildWithSchemas returns undefined schemas when no body/query defined", function () {
+        var result = (0, openApiBuilder_1.createOpenApiBuilder)({}).buildWithSchemas();
+        (0, bun_test_1.expect)(result.bodySchema).toBeUndefined();
+        (0, bun_test_1.expect)(result.querySchema).toBeUndefined();
+    });
+    (0, bun_test_1.it)("withValidation with defaults enables body and query validation", function () {
+        var result = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withRequestBody({ name: { required: true, type: "string" } })
+            .withQueryParameter("page", { type: "number" })
+            .withValidation()
+            .buildWithSchemas();
+        (0, bun_test_1.expect)(result.validationEnabled).toBe(true);
+    });
+    (0, bun_test_1.it)("withValidation with enabled=false disables validation", function () {
+        var result = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withRequestBody({ name: { required: true, type: "string" } })
+            .withValidation({ enabled: false })
+            .buildWithSchemas();
+        (0, bun_test_1.expect)(result.validationEnabled).toBe(false);
+    });
+    (0, bun_test_1.it)("build() returns an array with validators when validation is enabled", function () {
+        var result = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withRequestBody({ name: { required: true, type: "string" } })
+            .withQueryParameter("page", { type: "number" })
+            .withValidation()
+            .build();
+        (0, bun_test_1.expect)(Array.isArray(result)).toBe(true);
+        (0, bun_test_1.expect)(result.length).toBeGreaterThan(1);
+    });
+    (0, bun_test_1.it)("build() returns a single middleware when validation is disabled", function () {
+        var result = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withRequestBody({ name: { required: true, type: "string" } })
+            .build();
+        (0, bun_test_1.expect)(typeof result).toBe("function");
+    });
+    (0, bun_test_1.it)("build() falls back to single middleware when there is nothing to validate", function () {
+        var result = (0, openApiBuilder_1.createOpenApiBuilder)({}).withValidation().build();
+        (0, bun_test_1.expect)(typeof result).toBe("function");
+    });
+    (0, bun_test_1.it)("withValidation options body=false and query=false is respected", function () {
+        var result = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withRequestBody({ name: { required: true, type: "string" } })
+            .withQueryParameter("page", { type: "number" })
+            .withValidation({ body: false, query: false })
+            .build();
+        // No body/query validation = just the openApi middleware (single fn)
+        (0, bun_test_1.expect)(typeof result).toBe("function");
+    });
+});

package/dist/openApiValidator.test.js

@@ -342,5 +342,314 @@ var setupFreshApp = function () { return __awaiter(void 0, void 0, void 0, funct
                 middleware(req, res, function () { });
             }).toThrow();
         });
+        (0, bun_test_1.it)("calls onError callback instead of throwing when provided at option level", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)();
+            var capturedErrors = [];
+            var middleware = (0, openApiValidator_1.validateRequestBody)({ name: { required: true, type: "string" } }, {
+                onError: function (errors) {
+                    capturedErrors = errors;
+                },
+            });
+            var nextCalled = false;
+            var req = { body: {}, method: "POST", path: "/test" };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+            (0, bun_test_1.expect)(capturedErrors.length).toBeGreaterThan(0);
+        });
+        (0, bun_test_1.it)("calls global onValidationError when no per-route handler", function () {
+            var capturedErrors = [];
+            (0, openApiValidator_1.configureOpenApiValidator)({
+                onValidationError: function (errors) {
+                    capturedErrors = errors;
+                },
+            });
+            var middleware = (0, openApiValidator_1.validateRequestBody)({ name: { required: true, type: "string" } });
+            var nextCalled = false;
+            var req = { body: {}, method: "POST", path: "/test" };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+            (0, bun_test_1.expect)(capturedErrors.length).toBeGreaterThan(0);
+        });
+        (0, bun_test_1.it)("skips validation when enabled=false on options", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)();
+            var middleware = (0, openApiValidator_1.validateRequestBody)({ name: { required: true, type: "string" } }, { enabled: false });
+            var nextCalled = false;
+            var req = { body: {}, method: "POST", path: "/test" };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+        });
+        (0, bun_test_1.it)("respects validateRequests=false in global config", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ validateRequests: false });
+            var middleware = (0, openApiValidator_1.validateRequestBody)({ name: { required: true, type: "string" } });
+            var nextCalled = false;
+            var req = { body: {}, method: "POST", path: "/test" };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+        });
+    });
+    (0, bun_test_1.describe)("validateQueryParams middleware", function () {
+        (0, bun_test_1.it)("is a no-op when not configured", function () {
+            (0, openApiValidator_1.resetOpenApiValidatorConfig)();
+            var middleware = (0, openApiValidator_1.validateQueryParams)({
+                page: { type: "number" },
+            });
+            var nextCalled = false;
+            var req = { method: "GET", path: "/test", query: {} };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+        });
+        (0, bun_test_1.it)("coerces types when configured", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ coerceTypes: true });
+            var middleware = (0, openApiValidator_1.validateQueryParams)({
+                page: { type: "number" },
+            });
+            var req = { method: "GET", path: "/test", query: { page: "3" } };
+            var res = {};
+            middleware(req, res, function () { });
+            (0, bun_test_1.expect)(req.query.page).toBe(3);
+        });
+        (0, bun_test_1.it)("throws validation error when query does not match", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ coerceTypes: false });
+            var middleware = (0, openApiValidator_1.validateQueryParams)({
+                page: { required: true, type: "number" },
+            });
+            var req = { method: "GET", path: "/test", query: {} };
+            var res = {};
+            // Required top-level property missing triggers an error
+            // We need required: [] at schema level via required: true on property. Confirm via calling.
+            (0, bun_test_1.expect)(function () {
+                middleware(req, res, function () { });
+            }).toThrow();
+        });
+        (0, bun_test_1.it)("uses onError callback for query validation", function () {
+            var captured = [];
+            (0, openApiValidator_1.configureOpenApiValidator)({ coerceTypes: false });
+            var middleware = (0, openApiValidator_1.validateQueryParams)({ page: { required: true, type: "number" } }, {
+                onError: function (errors) {
+                    captured = errors;
+                },
+            });
+            var nextCalled = false;
+            var req = { method: "GET", path: "/test", query: {} };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+            (0, bun_test_1.expect)(captured.length).toBeGreaterThan(0);
+        });
+        (0, bun_test_1.it)("skips query validation when enabled=false", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)();
+            var middleware = (0, openApiValidator_1.validateQueryParams)({ page: { required: true, type: "number" } }, { enabled: false });
+            var nextCalled = false;
+            var req = { method: "GET", path: "/test", query: {} };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+        });
+    });
+    (0, bun_test_1.describe)("validateResponseData", function () {
+        (0, bun_test_1.it)("returns valid when validateResponses is disabled", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ validateResponses: false });
+            var result = (0, openApiValidator_1.validateResponseData)({ foo: "bar" }, { name: { type: "string" } });
+            (0, bun_test_1.expect)(result.valid).toBe(true);
+        });
+        (0, bun_test_1.it)("validates response shape when validateResponses is enabled", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ validateResponses: true });
+            var result = (0, openApiValidator_1.validateResponseData)({ name: "Apple" }, { name: { required: true, type: "string" } });
+            (0, bun_test_1.expect)(result.valid).toBe(true);
+        });
+        (0, bun_test_1.it)("returns errors for invalid response shape", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ coerceTypes: false, validateResponses: true });
+            var result = (0, openApiValidator_1.validateResponseData)({ name: 42 }, { name: { required: true, type: "string" } });
+            (0, bun_test_1.expect)(result.valid).toBe(false);
+            (0, bun_test_1.expect)(result.errors).toBeDefined();
+        });
+    });
+    (0, bun_test_1.describe)("createValidator", function () {
+        (0, bun_test_1.it)("runs body then query validation and calls next once both pass", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ coerceTypes: true });
+            var middleware = (0, openApiValidator_1.createValidator)({
+                body: { name: { required: true, type: "string" } },
+                query: { page: { type: "number" } },
+            });
+            var nextCalled = false;
+            var req = {
+                body: { name: "ok" },
+                method: "POST",
+                path: "/test",
+                query: { page: "2" },
+            };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+            (0, bun_test_1.expect)(req.query.page).toBe(2);
+        });
+        (0, bun_test_1.it)("skips when neither body nor query schemas are provided", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)();
+            var middleware = (0, openApiValidator_1.createValidator)({});
+            var nextCalled = false;
+            var req = { body: {}, method: "POST", path: "/test", query: {} };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+        });
+        (0, bun_test_1.it)("runs only query validation when only query provided", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ coerceTypes: true });
+            var middleware = (0, openApiValidator_1.createValidator)({
+                query: { page: { type: "number" } },
+            });
+            var nextCalled = false;
+            var req = { method: "GET", path: "/test", query: { page: "5" } };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+            (0, bun_test_1.expect)(req.query.page).toBe(5);
+        });
+        (0, bun_test_1.it)("propagates body validation error via next", function () {
+            var capturedErrors = [];
+            (0, openApiValidator_1.configureOpenApiValidator)({
+                onValidationError: function (errors) {
+                    capturedErrors = errors;
+                },
+            });
+            var middleware = (0, openApiValidator_1.createValidator)({
+                body: { name: { required: true, type: "string" } },
+                query: { page: { type: "number" } },
+            });
+            var req = { body: {}, method: "POST", path: "/test", query: {} };
+            var res = {};
+            var nextCalled = false;
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(capturedErrors.length).toBeGreaterThan(0);
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+        });
+    });
+    (0, bun_test_1.describe)("createModelValidators", function () {
+        (0, bun_test_1.beforeEach)(function () {
+            (0, openApiValidator_1.configureOpenApiValidator)();
+        });
+        (0, bun_test_1.it)("returns create and update middleware", function () {
+            var validators = (0, openApiValidator_1.createModelValidators)(tests_1.RequiredModel);
+            (0, bun_test_1.expect)(typeof validators.create).toBe("function");
+            (0, bun_test_1.expect)(typeof validators.update).toBe("function");
+        });
+        (0, bun_test_1.it)("create validator rejects body with wrong type", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ coerceTypes: false });
+            var create = (0, openApiValidator_1.createModelValidators)(tests_1.RequiredModel).create;
+            var req = { body: { name: 123 }, method: "POST", path: "/required" };
+            var res = {};
+            (0, bun_test_1.expect)(function () {
+                create(req, res, function () { });
+            }).toThrow();
+        });
+        (0, bun_test_1.it)("update validator allows a partial body", function () {
+            var update = (0, openApiValidator_1.createModelValidators)(tests_1.RequiredModel).update;
+            var nextCalled = false;
+            var req = { body: { about: "info" }, method: "PATCH", path: "/required" };
+            var res = {};
+            update(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+        });
+        (0, bun_test_1.it)("supports onAdditionalPropertiesRemoved option", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ removeAdditional: true });
+            var removedProps = [];
+            var create = (0, openApiValidator_1.createModelValidators)(tests_1.RequiredModel, {
+                onAdditionalPropertiesRemoved: function (props) {
+                    removedProps.push.apply(removedProps, __spreadArray([], __read(props), false));
+                },
+            }).create;
+            // Extra property gets stripped and hook is called
+            var req = {
+                body: { extra: "strip me", name: "Apple" },
+                method: "POST",
+                path: "/required",
+            };
+            create(req, {}, function () { });
+            (0, bun_test_1.expect)(removedProps).toContain("extra");
+        });
+        (0, bun_test_1.it)("supports onError option", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ coerceTypes: false });
+            var errorHandled = [];
+            var create = (0, openApiValidator_1.createModelValidators)(tests_1.RequiredModel, {
+                onError: function (errors) {
+                    errorHandled = errors;
+                },
+            }).create;
+            // Wrong type triggers error handler
+            var req = { body: { name: 42 }, method: "POST", path: "/required" };
+            create(req, {}, function () { });
+            (0, bun_test_1.expect)(errorHandled.length).toBeGreaterThan(0);
+        });
+    });
+    (0, bun_test_1.describe)("validateModelRequestBody", function () {
+        (0, bun_test_1.beforeEach)(function () {
+            (0, openApiValidator_1.configureOpenApiValidator)();
+        });
+        (0, bun_test_1.it)("creates a validator from a Mongoose model", function () {
+            var middleware = (0, openApiValidator_1.validateModelRequestBody)(tests_1.RequiredModel);
+            var req = { body: {}, method: "POST", path: "/required" };
+            var res = {};
+            (0, bun_test_1.expect)(function () {
+                middleware(req, res, function () { });
+            }).toThrow();
+        });
+        (0, bun_test_1.it)("respects excludeFields option", function () {
+            var middleware = (0, openApiValidator_1.validateModelRequestBody)(tests_1.RequiredModel, {
+                excludeFields: ["name"],
+            });
+            // Without 'name' required, empty body passes
+            var nextCalled = false;
+            var req = { body: {}, method: "POST", path: "/required" };
+            var res = {};
+            middleware(req, res, function () {
+                nextCalled = true;
+            });
+            (0, bun_test_1.expect)(nextCalled).toBe(true);
+        });
+    });
+    (0, bun_test_1.describe)("getSchemaFromModel", function () {
+        (0, bun_test_1.it)("returns properties for a Mongoose model", function () {
+            var schema = (0, openApiValidator_1.getSchemaFromModel)(tests_1.RequiredModel);
+            (0, bun_test_1.expect)(schema.name).toBeDefined();
+            (0, bun_test_1.expect)(schema.about).toBeDefined();
+        });
+    });
+    (0, bun_test_1.describe)("getOpenApiValidatorConfig", function () {
+        (0, bun_test_1.it)("returns a shallow copy of the config", function () {
+            (0, openApiValidator_1.configureOpenApiValidator)({ removeAdditional: false });
+            var config = (0, openApiValidator_1.getOpenApiValidatorConfig)();
+            (0, bun_test_1.expect)(config.removeAdditional).toBe(false);
+            // Mutating the returned copy should not affect internal state
+            config.removeAdditional = true;
+            (0, bun_test_1.expect)((0, openApiValidator_1.getOpenApiValidatorConfig)().removeAdditional).toBe(false);
+        });
     });
 });

package/dist/plugins.d.ts

@@ -4,13 +4,13 @@ export interface BaseUser {
     admin: boolean;
     email: string;
 }
-export declare function baseUserPlugin(schema: Schema<any, any, any, any>): void;
+export declare const baseUserPlugin: (schema: Schema<any, any, any, any>) => void;
 /** For models with the isDeletedPlugin, extend this interface to add the appropriate fields. */
 export interface IsDeleted {
     deleted: boolean;
 }
-export declare function isDeletedPlugin(schema: Schema<any, any, any, any>, defaultValue?: boolean): void;
-export declare function isDisabledPlugin(schema: Schema<any, any, any, any>, defaultValue?: boolean): void;
+export declare const isDeletedPlugin: (schema: Schema<any, any, any, any>, defaultValue?: boolean) => void;
+export declare const isDisabledPlugin: (schema: Schema<any, any, any, any>, defaultValue?: boolean) => void;
 export interface CreatedDeleted {
     updated: {
         type: Date;
@@ -21,8 +21,8 @@ export interface CreatedDeleted {
         required: true;
     };
 }
-export declare function createdUpdatedPlugin(schema: Schema<any, any, any, any>): void;
-export declare function firebaseJWTPlugin(schema: Schema): void;
+export declare const createdUpdatedPlugin: (schema: Schema<any, any, any, any>) => void;
+export declare const firebaseJWTPlugin: (schema: Schema) => void;
 /**
  * This adds a static method `Model.findOneOrNone` to the schema. This should replace `Model.findOne` in most instances.
  * `Model.findOne` should only be used with a unique index, but that's not apparent from the docs. Otherwise you can wind
@@ -30,7 +30,7 @@ export declare function firebaseJWTPlugin(schema: Schema): void;
  * document, or throws an exception if multiple are found.
  * @param schema Mongoose Schema
  */
-export declare function findOneOrNone<T>(schema: Schema<T>): void;
+export declare const findOneOrNone: <T>(schema: Schema<T>) => void;
 /**
  * This adds a static method `Model.findExactlyOne` to the schema. This or findOneOrNone should replace `Model.findOne`
  * in most instances.
@@ -39,14 +39,14 @@ export declare function findOneOrNone<T>(schema: Schema<T>): void;
  * multiple or none are found.
  * @param schema Mongoose Schema
  */
-export declare function findExactlyOne<T>(schema: Schema<T>): void;
+export declare const findExactlyOne: <T>(schema: Schema<T>) => void;
 /**
  * This adds a static method `Model.upsert` to the schema. This method will either update an existing document
  * that matches the conditions or create a new document if none exists. It throws an error if multiple documents
  * match the conditions to prevent ambiguous updates.
  * @param schema Mongoose Schema
  */
-export declare function upsertPlugin<T>(schema: Schema<any, any, any, any>): void;
+export declare const upsertPlugin: <T>(schema: Schema<any, any, any, any>) => void;
 /** For models with the upsertPlugin, extend this interface to add the upsert static method. */
 export interface HasUpsert<T> {
     upsert(conditions: Record<string, any>, update: Record<string, any>): Promise<T>;