@terreno/api 0.0.1

package/dist/openApiBuilder.test.js

@@ -0,0 +1,509 @@
+"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 __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 api_1 = require("./api");
+var auth_1 = require("./auth");
+var expressServer_1 = require("./expressServer");
+var openApiBuilder_1 = require("./openApiBuilder");
+var permissions_1 = require("./permissions");
+var tests_1 = require("./tests");
+function addRoutesWithBuilder(router, options) {
+    var _this = this;
+    // Add a custom endpoint using the OpenApiMiddlewareBuilder
+    var statsMiddleware = (0, openApiBuilder_1.createOpenApiBuilder)(options !== null && options !== void 0 ? options : {})
+        .withTags(["Stats"])
+        .withSummary("Get food statistics")
+        .withDescription("Returns aggregated statistics about food items")
+        .withQueryParameter("category", { type: "string" }, {
+        description: "Filter by food category",
+        required: false,
+    })
+        .withResponse(200, {
+        avgCalories: { description: "Average calories", type: "number" },
+        count: { description: "Total number of food items", type: "number" },
+    })
+        .build();
+    router.get("/food/stats", statsMiddleware, function (_req, res) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            res.json({ avgCalories: 250, count: 10 });
+            return [2 /*return*/];
+        });
+    }); });
+    // Add endpoint with request body
+    var createReportMiddleware = (0, openApiBuilder_1.createOpenApiBuilder)(options !== null && options !== void 0 ? options : {})
+        .withTags(["Reports"])
+        .withSummary("Create a food report")
+        .withDescription("Generates a report based on provided criteria")
+        .withRequestBody({
+        endDate: {
+            description: "Report end date",
+            format: "date",
+            required: true,
+            type: "string",
+        },
+        includeDeleted: {
+            description: "Whether to include deleted items",
+            type: "boolean",
+        },
+        startDate: {
+            description: "Report start date",
+            format: "date",
+            required: true,
+            type: "string",
+        },
+    })
+        .withResponse(201, {
+        reportId: { description: "Generated report ID", type: "string" },
+    }, { description: "Report created successfully" })
+        .build();
+    router.post("/food/reports", createReportMiddleware, function (_req, res) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            res.status(201).json({ reportId: "report-123" });
+            return [2 /*return*/];
+        });
+    }); });
+    // Add endpoint with array response
+    var listCategoriesMiddleware = (0, openApiBuilder_1.createOpenApiBuilder)(options !== null && options !== void 0 ? options : {})
+        .withTags(["Categories"])
+        .withSummary("List food categories")
+        .withArrayResponse(200, {
+        count: { description: "Number of items in category", type: "number" },
+        id: { description: "Category ID", type: "string" },
+        name: { description: "Category name", type: "string" },
+    }, { description: "List of categories" })
+        .build();
+    router.get("/food/categories", listCategoriesMiddleware, function (_req, res) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            res.json([
+                { count: 5, id: "1", name: "Fruits" },
+                { count: 3, id: "2", name: "Vegetables" },
+            ]);
+            return [2 /*return*/];
+        });
+    }); });
+    // Add endpoint with path parameter
+    var getCategoryMiddleware = (0, openApiBuilder_1.createOpenApiBuilder)(options !== null && options !== void 0 ? options : {})
+        .withTags(["Categories"])
+        .withSummary("Get category by ID")
+        .withPathParameter("categoryId", { type: "string" }, {
+        description: "The category identifier",
+    })
+        .withResponse(200, {
+        id: { type: "string" },
+        name: { type: "string" },
+    })
+        .withResponse(404, "Category not found")
+        .build();
+    router.get("/food/categories/:categoryId", getCategoryMiddleware, function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            res.json({ id: req.params.categoryId, name: "Fruits" });
+            return [2 /*return*/];
+        });
+    }); });
+    // Standard modelRouter for food
+    router.use("/food", (0, api_1.modelRouter)(tests_1.FoodModel, __assign(__assign({}, options), { allowAnonymous: true, permissions: {
+            create: [permissions_1.Permissions.IsAny],
+            delete: [permissions_1.Permissions.IsAny],
+            list: [permissions_1.Permissions.IsAny],
+            read: [permissions_1.Permissions.IsAny],
+            update: [permissions_1.Permissions.IsAny],
+        } })));
+}
+(0, bun_test_1.describe)("OpenApiMiddlewareBuilder", function () {
+    var server;
+    var app;
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            process.env.REFRESH_TOKEN_SECRET = "testsecret1234";
+            process.env.ENABLE_SWAGGER = "true";
+            app = (0, expressServer_1.setupServer)({
+                addRoutes: addRoutesWithBuilder,
+                skipListen: true,
+                userModel: tests_1.UserModel,
+            });
+            (0, auth_1.setupAuth)(app, tests_1.UserModel);
+            (0, auth_1.addAuthRoutes)(app, tests_1.UserModel);
+            return [2 /*return*/];
+        });
+    }); });
+    (0, bun_test_1.describe)("builder pattern", function () {
+        (0, bun_test_1.it)("returns a builder instance from createOpenApiBuilder", function () {
+            var builder = (0, openApiBuilder_1.createOpenApiBuilder)({});
+            (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
+        });
+        (0, bun_test_1.it)("supports method chaining", function () {
+            var builder = (0, openApiBuilder_1.createOpenApiBuilder)({});
+            var result = builder
+                .withTags(["test"])
+                .withSummary("Test summary")
+                .withDescription("Test description");
+            (0, bun_test_1.expect)(result).toBe(builder);
+        });
+        (0, bun_test_1.it)("returns noop middleware when openApi is not configured", function () {
+            var middleware = (0, openApiBuilder_1.createOpenApiBuilder)({}).build();
+            (0, bun_test_1.expect)(typeof middleware).toBe("function");
+            (0, bun_test_1.expect)(middleware.length).toBe(3); // Express middleware signature
+        });
+    });
+    (0, bun_test_1.describe)("OpenAPI spec generation", function () {
+        (0, bun_test_1.it)("includes custom endpoint with query parameter in OpenAPI spec", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, statsPath, categoryParam;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/openapi.json").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        statsPath = res.body.paths["/food/stats"];
+                        (0, bun_test_1.expect)(statsPath).toBeDefined();
+                        (0, bun_test_1.expect)(statsPath.get).toBeDefined();
+                        (0, bun_test_1.expect)(statsPath.get.tags).toContain("Stats");
+                        (0, bun_test_1.expect)(statsPath.get.summary).toBe("Get food statistics");
+                        (0, bun_test_1.expect)(statsPath.get.description).toBe("Returns aggregated statistics about food items");
+                        categoryParam = statsPath.get.parameters.find(function (p) { return p.name === "category"; });
+                        (0, bun_test_1.expect)(categoryParam).toBeDefined();
+                        (0, bun_test_1.expect)(categoryParam.in).toBe("query");
+                        (0, bun_test_1.expect)(categoryParam.schema.type).toBe("string");
+                        (0, bun_test_1.expect)(categoryParam.description).toBe("Filter by food category");
+                        (0, bun_test_1.expect)(categoryParam.required).toBe(false);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("includes request body schema in OpenAPI spec", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, reportsPath, requestBody, schema;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/openapi.json").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        reportsPath = res.body.paths["/food/reports"];
+                        (0, bun_test_1.expect)(reportsPath).toBeDefined();
+                        (0, bun_test_1.expect)(reportsPath.post).toBeDefined();
+                        (0, bun_test_1.expect)(reportsPath.post.tags).toContain("Reports");
+                        requestBody = reportsPath.post.requestBody;
+                        (0, bun_test_1.expect)(requestBody).toBeDefined();
+                        (0, bun_test_1.expect)(requestBody.required).toBe(true);
+                        schema = requestBody.content["application/json"].schema;
+                        (0, bun_test_1.expect)(schema.type).toBe("object");
+                        (0, bun_test_1.expect)(schema.properties.startDate.type).toBe("string");
+                        (0, bun_test_1.expect)(schema.properties.startDate.format).toBe("date");
+                        (0, bun_test_1.expect)(schema.properties.endDate.type).toBe("string");
+                        (0, bun_test_1.expect)(schema.properties.includeDeleted.type).toBe("boolean");
+                        (0, bun_test_1.expect)(schema.required).toContain("startDate");
+                        (0, bun_test_1.expect)(schema.required).toContain("endDate");
+                        (0, bun_test_1.expect)(schema.required).not.toContain("includeDeleted");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("includes response schema in OpenAPI spec", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, statsPath, response200, schema;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/openapi.json").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        statsPath = res.body.paths["/food/stats"];
+                        response200 = statsPath.get.responses["200"];
+                        (0, bun_test_1.expect)(response200).toBeDefined();
+                        (0, bun_test_1.expect)(response200.description).toBe("Success");
+                        schema = response200.content["application/json"].schema;
+                        (0, bun_test_1.expect)(schema.type).toBe("object");
+                        (0, bun_test_1.expect)(schema.properties.count.type).toBe("number");
+                        (0, bun_test_1.expect)(schema.properties.avgCalories.type).toBe("number");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("includes array response schema in OpenAPI spec", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, categoriesPath, response200, schema;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/openapi.json").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        categoriesPath = res.body.paths["/food/categories"];
+                        (0, bun_test_1.expect)(categoriesPath).toBeDefined();
+                        response200 = categoriesPath.get.responses["200"];
+                        (0, bun_test_1.expect)(response200.description).toBe("List of categories");
+                        schema = response200.content["application/json"].schema;
+                        (0, bun_test_1.expect)(schema.type).toBe("array");
+                        (0, bun_test_1.expect)(schema.items.type).toBe("object");
+                        (0, bun_test_1.expect)(schema.items.properties.id.type).toBe("string");
+                        (0, bun_test_1.expect)(schema.items.properties.name.type).toBe("string");
+                        (0, bun_test_1.expect)(schema.items.properties.count.type).toBe("number");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("includes path parameter in OpenAPI spec", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, categoryPath, pathParam;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/openapi.json").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        categoryPath = res.body.paths["/food/categories/{categoryId}"];
+                        (0, bun_test_1.expect)(categoryPath).toBeDefined();
+                        pathParam = categoryPath.get.parameters.find(function (p) { return p.name === "categoryId"; });
+                        (0, bun_test_1.expect)(pathParam).toBeDefined();
+                        (0, bun_test_1.expect)(pathParam.in).toBe("path");
+                        (0, bun_test_1.expect)(pathParam.required).toBe(true);
+                        (0, bun_test_1.expect)(pathParam.schema.type).toBe("string");
+                        (0, bun_test_1.expect)(pathParam.description).toBe("The category identifier");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("includes custom response without body in OpenAPI spec", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, reportsPath, response201;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/openapi.json").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        reportsPath = res.body.paths["/food/reports"];
+                        response201 = reportsPath.post.responses["201"];
+                        (0, bun_test_1.expect)(response201).toBeDefined();
+                        (0, bun_test_1.expect)(response201.description).toBe("Report created successfully");
+                        (0, bun_test_1.expect)(response201.content).toBeDefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("includes default error responses", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, statsPath, responses;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/openapi.json").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        statsPath = res.body.paths["/food/stats"];
+                        responses = statsPath.get.responses;
+                        // Default error responses should be merged
+                        (0, bun_test_1.expect)(responses["400"]).toBeDefined();
+                        (0, bun_test_1.expect)(responses["401"]).toBeDefined();
+                        (0, bun_test_1.expect)(responses["403"]).toBeDefined();
+                        (0, bun_test_1.expect)(responses["404"]).toBeDefined();
+                        (0, bun_test_1.expect)(responses["405"]).toBeDefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, bun_test_1.describe)("endpoint functionality", function () {
+        (0, bun_test_1.it)("stats endpoint returns correct data", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/food/stats").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        (0, bun_test_1.expect)(res.body).toEqual({ avgCalories: 250, count: 10 });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("reports endpoint returns correct data", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server
+                                .post("/food/reports")
+                                .send({ endDate: "2024-12-31", startDate: "2024-01-01" })
+                                .expect(201)];
+                    case 1:
+                        res = _a.sent();
+                        (0, bun_test_1.expect)(res.body).toEqual({ reportId: "report-123" });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("categories endpoint returns array data", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/food/categories").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        (0, bun_test_1.expect)(res.body).toHaveLength(2);
+                        (0, bun_test_1.expect)(res.body[0]).toHaveProperty("id");
+                        (0, bun_test_1.expect)(res.body[0]).toHaveProperty("name");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("category by id endpoint returns correct data", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/food/categories/cat-123").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        (0, bun_test_1.expect)(res.body).toEqual({ id: "cat-123", name: "Fruits" });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, bun_test_1.describe)("snapshot tests", function () {
+        (0, bun_test_1.it)("matches OpenAPI spec snapshot", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        server = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, server.get("/openapi.json").expect(200)];
+                    case 1:
+                        res = _a.sent();
+                        (0, bun_test_1.expect)(res.body).toMatchSnapshot();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+(0, bun_test_1.describe)("OpenApiMiddlewareBuilder without OpenAPI", function () {
+    (0, bun_test_1.it)("build returns noop middleware when openApi.path is not configured", function () {
+        var builder = new openApiBuilder_1.OpenApiMiddlewareBuilder({});
+        var middleware = builder
+            .withTags(["test"])
+            .withSummary("Test")
+            .withResponse(200, { id: { type: "string" } })
+            .build();
+        // Middleware should be a function
+        (0, bun_test_1.expect)(typeof middleware).toBe("function");
+        // Should call next() without error
+        var nextCalled = false;
+        middleware({}, {}, function () {
+            nextCalled = true;
+        });
+        (0, bun_test_1.expect)(nextCalled).toBe(true);
+    });
+    (0, bun_test_1.it)("build returns noop middleware when options is empty", function () {
+        var middleware = (0, openApiBuilder_1.createOpenApiBuilder)({}).build();
+        var nextCalled = false;
+        middleware({}, {}, function () {
+            nextCalled = true;
+        });
+        (0, bun_test_1.expect)(nextCalled).toBe(true);
+    });
+});
+(0, bun_test_1.describe)("OpenApiMiddlewareBuilder configuration", function () {
+    (0, bun_test_1.it)("correctly extracts required fields from request body schema", function () {
+        // We can't easily test this without a mock openApi.path, but we can at least
+        // verify the builder accepts the configuration
+        var builder = (0, openApiBuilder_1.createOpenApiBuilder)({}).withRequestBody({
+            optional: { type: "string" },
+            required1: { required: true, type: "string" },
+            required2: { required: true, type: "string" },
+        });
+        (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
+    });
+    (0, bun_test_1.it)("supports custom media types for request body", function () {
+        var builder = (0, openApiBuilder_1.createOpenApiBuilder)({}).withRequestBody({ data: { type: "string" } }, { mediaType: "application/xml" });
+        (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
+    });
+    (0, bun_test_1.it)("supports custom media types for response", function () {
+        var builder = (0, openApiBuilder_1.createOpenApiBuilder)({}).withResponse(200, { data: { type: "string" } }, { mediaType: "text/plain" });
+        (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
+    });
+    (0, bun_test_1.it)("supports optional request body", function () {
+        var builder = (0, openApiBuilder_1.createOpenApiBuilder)({}).withRequestBody({ data: { type: "string" } }, { required: false });
+        (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
+    });
+    (0, bun_test_1.it)("supports multiple query parameters", function () {
+        var builder = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withQueryParameter("limit", { type: "number" }, { required: false })
+            .withQueryParameter("offset", { type: "number" }, { required: false })
+            .withQueryParameter("search", { type: "string" });
+        (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
+    });
+    (0, bun_test_1.it)("supports multiple path parameters", function () {
+        var builder = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withPathParameter("userId", { type: "string" })
+            .withPathParameter("postId", { type: "string" });
+        (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
+    });
+    (0, bun_test_1.it)("supports multiple responses", function () {
+        var builder = (0, openApiBuilder_1.createOpenApiBuilder)({})
+            .withResponse(200, { data: { type: "string" } })
+            .withResponse(201, { id: { type: "string" } })
+            .withResponse(204, "No content")
+            .withResponse(404, "Not found");
+        (0, bun_test_1.expect)(builder).toBeInstanceOf(openApiBuilder_1.OpenApiMiddlewareBuilder);
+    });
+});

package/dist/openApiEtag.d.ts

@@ -0,0 +1,7 @@
+import type { NextFunction, Request, Response } from "express";
+/**
+ * Middleware to add ETag support for OpenAPI JSON endpoint.
+ * This middleware should be added before the @wesleytodd/openapi middleware
+ * to intercept requests to /openapi.json and add conditional request support.
+ */
+export declare function openApiEtagMiddleware(req: Request, res: Response, next: NextFunction): void;

package/dist/openApiEtag.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openApiEtagMiddleware = openApiEtagMiddleware;
+var node_crypto_1 = __importDefault(require("node:crypto"));
+/**
+ * Middleware to add ETag support for OpenAPI JSON endpoint.
+ * This middleware should be added before the @wesleytodd/openapi middleware
+ * to intercept requests to /openapi.json and add conditional request support.
+ */
+function openApiEtagMiddleware(req, res, next) {
+    // Only handle GET requests to /openapi.json
+    if (req.method !== "GET" || req.path !== "/openapi.json") {
+        next();
+        return;
+    }
+    // Store original res.json to intercept the response
+    var originalJson = res.json.bind(res);
+    res.json = function (body) {
+        // Generate ETag based on the JSON content
+        var jsonString = JSON.stringify(body);
+        var etag = "\"".concat(node_crypto_1.default.createHash("sha256").update(jsonString).digest("hex").substring(0, 16), "\"");
+        // Set ETag header
+        res.set("ETag", etag);
+        // Check If-None-Match header for conditional requests
+        var ifNoneMatch = req.get("If-None-Match");
+        if (ifNoneMatch === etag) {
+            // Resource hasn't changed, return 304 Not Modified
+            res.status(304).end();
+            return res;
+        }
+        // Resource has changed or no conditional header, return the content
+        return originalJson(body);
+    };
+    next();
+}

package/dist/permissions.d.ts

@@ -0,0 +1,26 @@
+import type express from "express";
+import type { NextFunction } from "express";
+import { type Model } from "mongoose";
+import { type modelRouterOptions, type RESTMethod } from "./api";
+import type { User } from "./auth";
+export type PermissionMethod<T> = (method: RESTMethod, user?: User, obj?: T) => boolean | Promise<boolean>;
+export interface RESTPermissions<T> {
+    create: PermissionMethod<T>[];
+    list: PermissionMethod<T>[];
+    read: PermissionMethod<T>[];
+    update: PermissionMethod<T>[];
+    delete: PermissionMethod<T>[];
+}
+export declare const OwnerQueryFilter: (user?: User) => {
+    ownerId: string;
+} | null;
+export declare const Permissions: {
+    IsAdmin: (_method: RESTMethod, user?: User) => boolean;
+    IsAny: () => boolean;
+    IsAuthenticated: (_method: RESTMethod, user?: User) => boolean;
+    IsAuthenticatedOrReadOnly: (method: RESTMethod, user?: User) => boolean;
+    IsOwner: (_method: RESTMethod, user?: User, obj?: any) => any;
+    IsOwnerOrReadOnly: (method: RESTMethod, user?: User, obj?: any) => boolean;
+};
+export declare function checkPermissions<T>(method: RESTMethod, permissions: PermissionMethod<T>[], user?: User, obj?: T): Promise<boolean>;
+export declare function permissionMiddleware<T>(baseModel: Model<T>, options: Pick<modelRouterOptions<T>, "permissions" | "populatePaths" | "discriminatorKey">): (req: express.Request, _res: express.Response, next: NextFunction) => Promise<void>;