@terreno/api 0.16.1 → 0.18.0

package/dist/actions.test.js

@@ -70,7 +70,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var bun_test_1 = require("bun:test");
 var mongoose_1 = require("mongoose");
 var supertest_1 = __importDefault(require("supertest"));
-var zod_1 = require("zod");
 var actions_1 = require("./actions");
 var api_1 = require("./api");
 var auth_1 = require("./auth");
@@ -78,6 +77,7 @@ var errors_1 = require("./errors");
 var permissions_1 = require("./permissions");
 var plugins_1 = require("./plugins");
 var tests_1 = require("./tests");
+var zodOpenApi_1 = require("./zodOpenApi");
 var stuffSchema = new mongoose_1.Schema({
     name: { type: String },
     ownerId: { type: String },
@@ -561,7 +561,7 @@ var allPermissions = {
                             mountFoodRouter({
                                 collectionActions: {
                                     notify: {
-                                        body: zod_1.z.object({ email: zod_1.z.string().email() }),
+                                        body: zodOpenApi_1.z.object({ email: zodOpenApi_1.z.string().email() }),
                                         handler: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
                                             var body = _b.body;
                                             return __generator(this, function (_c) {
@@ -591,7 +591,7 @@ var allPermissions = {
                             mountFoodRouter({
                                 collectionActions: {
                                     notify: {
-                                        body: zod_1.z.object({ email: zod_1.z.string().email() }),
+                                        body: zodOpenApi_1.z.object({ email: zodOpenApi_1.z.string().email() }),
                                         handler: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
                                             return [2 /*return*/, ({ sent: true })];
                                         }); }); },
@@ -628,7 +628,7 @@ var allPermissions = {
                                         }); },
                                         method: "GET",
                                         permissions: [permissions_1.Permissions.IsAny],
-                                        query: zod_1.z.object({ count: zod_1.z.coerce.number() }),
+                                        query: zodOpenApi_1.z.object({ count: zodOpenApi_1.z.coerce.number() }),
                                     },
                                 },
                                 permissions: allPermissions,
@@ -642,6 +642,33 @@ var allPermissions = {
                     }
                 });
             }); });
+            (0, bun_test_1.it)("returns 400 with meta.fields for invalid query", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var res;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            mountFoodRouter({
+                                collectionActions: {
+                                    lookup: {
+                                        handler: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                            return [2 /*return*/, ({ ok: true })];
+                                        }); }); },
+                                        method: "GET",
+                                        permissions: [permissions_1.Permissions.IsAny],
+                                        query: zodOpenApi_1.z.object({ email: zodOpenApi_1.z.string().email() }),
+                                    },
+                                },
+                                permissions: allPermissions,
+                            });
+                            return [4 /*yield*/, server.get("/food/lookup?email=bad").expect(400)];
+                        case 1:
+                            res = _a.sent();
+                            (0, bun_test_1.expect)(res.body.title).toBe("Validation failed");
+                            (0, bun_test_1.expect)(res.body.meta.fields.email).toBeDefined();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
             (0, bun_test_1.it)("coerces body values via zod in ctx", function () { return __awaiter(void 0, void 0, void 0, function () {
                 var seenCount, res;
                 return __generator(this, function (_a) {
@@ -650,7 +677,7 @@ var allPermissions = {
                             mountFoodRouter({
                                 collectionActions: {
                                     tally: {
-                                        body: zod_1.z.object({ count: zod_1.z.coerce.number() }),
+                                        body: zodOpenApi_1.z.object({ count: zodOpenApi_1.z.coerce.number() }),
                                         handler: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
                                             var parsed;
                                             var body = _b.body;
@@ -684,7 +711,7 @@ var allPermissions = {
                             mountFoodRouter({
                                 collectionActions: {
                                     strictish: {
-                                        body: zod_1.z.object({ known: zod_1.z.string() }),
+                                        body: zodOpenApi_1.z.object({ known: zodOpenApi_1.z.string() }),
                                         handler: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
                                             var body = _b.body;
                                             return __generator(this, function (_c) {
@@ -910,7 +937,7 @@ var allPermissions = {
     (0, bun_test_1.describe)("defineInstanceAction type ergonomics", function () {
         (0, bun_test_1.it)("preserves handler types at compile time", function () {
             var action = (0, actions_1.defineInstanceAction)({
-                body: zod_1.z.object({ notifyUsers: zod_1.z.boolean() }),
+                body: zodOpenApi_1.z.object({ notifyUsers: zodOpenApi_1.z.boolean() }),
                 handler: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
                     var _doc, _notify;
                     var _c, _d;
@@ -928,7 +955,7 @@ var allPermissions = {
         });
         (0, bun_test_1.it)("defineCollectionAction preserves body types", function () {
             var action = (0, actions_1.defineCollectionAction)({
-                body: zod_1.z.object({ ids: zod_1.z.array(zod_1.z.string()) }),
+                body: zodOpenApi_1.z.object({ ids: zodOpenApi_1.z.array(zodOpenApi_1.z.string()) }),
                 handler: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
                     var _ids;
                     var body = _b.body;
@@ -943,4 +970,113 @@ var allPermissions = {
             (0, bun_test_1.expect)(action.method).toBe("POST");
         });
     });
+    (0, bun_test_1.describe)("createActionOpenApiMiddleware", function () {
+        var createMockOpenApi = function () {
+            var captured;
+            var pathFn = function (op) {
+                captured = op;
+                return function (_req, _res, next) {
+                    return next();
+                };
+            };
+            return {
+                get captured() {
+                    return captured;
+                },
+                middleware: { path: pathFn },
+            };
+        };
+        (0, bun_test_1.it)("returns no-op middleware when openApi is not configured", function () {
+            var handler = (0, actions_1.createActionOpenApiMiddleware)({
+                action: { method: "GET", permissions: [] },
+                actionName: "test",
+                model: tests_1.FoodModel,
+                options: {},
+                scope: "collection",
+            });
+            (0, bun_test_1.expect)(typeof handler).toBe("function");
+        });
+        (0, bun_test_1.it)("generates query parameters from action.query schema", function () {
+            var _a;
+            var mock = createMockOpenApi();
+            (0, actions_1.createActionOpenApiMiddleware)({
+                action: {
+                    method: "GET",
+                    permissions: [],
+                    query: zodOpenApi_1.z.object({ page: zodOpenApi_1.z.coerce.number(), search: zodOpenApi_1.z.string() }),
+                },
+                actionName: "search",
+                model: tests_1.FoodModel,
+                options: { openApi: mock.middleware },
+                scope: "collection",
+            });
+            var params = (_a = mock.captured) === null || _a === void 0 ? void 0 : _a.parameters;
+            (0, bun_test_1.expect)(params.length).toBe(2);
+            (0, bun_test_1.expect)(params.some(function (p) { return p.name === "search"; })).toBe(true);
+            (0, bun_test_1.expect)(params.some(function (p) { return p.name === "page"; })).toBe(true);
+        });
+        (0, bun_test_1.it)("includes id path parameter for instance-scoped actions", function () {
+            var _a;
+            var mock = createMockOpenApi();
+            (0, actions_1.createActionOpenApiMiddleware)({
+                action: { method: "GET", permissions: [] },
+                actionName: "peek",
+                model: tests_1.FoodModel,
+                options: { openApi: mock.middleware },
+                scope: "instance",
+            });
+            var params = (_a = mock.captured) === null || _a === void 0 ? void 0 : _a.parameters;
+            (0, bun_test_1.expect)(params.some(function (p) { return p.name === "id" && p.in === "path"; })).toBe(true);
+        });
+        (0, bun_test_1.it)("uses fallback data schema when response is not provided", function () {
+            var _a;
+            var mock = createMockOpenApi();
+            (0, actions_1.createActionOpenApiMiddleware)({
+                action: { method: "POST", permissions: [] },
+                actionName: "noop",
+                model: tests_1.FoodModel,
+                options: { openApi: mock.middleware },
+                scope: "collection",
+            });
+            var responses = (_a = mock.captured) === null || _a === void 0 ? void 0 : _a.responses;
+            var ok = responses["200"];
+            var schema = ok.content["application/json"].schema;
+            (0, bun_test_1.expect)(schema.properties.data).toEqual({ type: "object" });
+        });
+        (0, bun_test_1.it)("uses zod response schema when provided", function () {
+            var _a;
+            var mock = createMockOpenApi();
+            (0, actions_1.createActionOpenApiMiddleware)({
+                action: {
+                    method: "POST",
+                    permissions: [],
+                    response: zodOpenApi_1.z.object({ count: zodOpenApi_1.z.number() }),
+                },
+                actionName: "tally",
+                model: tests_1.FoodModel,
+                options: { openApi: mock.middleware },
+                scope: "collection",
+            });
+            var responses = (_a = mock.captured) === null || _a === void 0 ? void 0 : _a.responses;
+            var ok = responses["200"];
+            var schema = ok.content["application/json"].schema;
+            (0, bun_test_1.expect)(schema.properties.data.properties).toBeDefined();
+        });
+        (0, bun_test_1.it)("includes requestBody when action.body is defined", function () {
+            var _a;
+            var mock = createMockOpenApi();
+            (0, actions_1.createActionOpenApiMiddleware)({
+                action: {
+                    body: zodOpenApi_1.z.object({ name: zodOpenApi_1.z.string() }),
+                    method: "POST",
+                    permissions: [],
+                },
+                actionName: "create",
+                model: tests_1.FoodModel,
+                options: { openApi: mock.middleware },
+                scope: "collection",
+            });
+            (0, bun_test_1.expect)((_a = mock.captured) === null || _a === void 0 ? void 0 : _a.requestBody).toBeDefined();
+        });
+    });
 });

package/dist/envConfigurationPlugin.test.js

@@ -319,4 +319,53 @@ var setupLoader = function () {
             }
         });
     }); });
+    (0, bun_test_1.it)("mapToObject handles a plain Record (non-Map) env field", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var col;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    col = (_a = mongoose_1.default.connection.db) === null || _a === void 0 ? void 0 : _a.collection("testenvconfigs");
+                    return [4 /*yield*/, (col === null || col === void 0 ? void 0 : col.insertOne({ env: { TERRENO_PLUGIN_KEY: "plainObj" } }))];
+                case 1:
+                    _b.sent();
+                    // Trigger refresh via findOneAndUpdate hook
+                    return [4 /*yield*/, TestEnvConfig.findOneAndUpdate({}, { $set: { __v: 1 } })];
+                case 2:
+                    // Trigger refresh via findOneAndUpdate hook
+                    _b.sent();
+                    (0, bun_test_1.expect)(config_1.Config.get("TERRENO_PLUGIN_KEY")).toBe("plainObj");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("refreshFromDoc logs a warning and does not throw when the model query fails", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var doc, originalFind;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    doc = new TestEnvConfig();
+                    doc.env.set("TERRENO_PLUGIN_KEY", "initial");
+                    return [4 /*yield*/, doc.save()];
+                case 1:
+                    _a.sent();
+                    // Pre-set cache to verify it is NOT overwritten when the hook errors
+                    config_1.Config.setCachedEnv({ TERRENO_PLUGIN_KEY: "cached" });
+                    originalFind = TestEnvConfig.find;
+                    TestEnvConfig.find = function () {
+                        throw new Error("Simulated DB error");
+                    };
+                    // Trigger the post-findOneAndUpdate hook → refreshFromDoc → findOneOrNoneFor → throws
+                    return [4 /*yield*/, TestEnvConfig.findOneAndUpdate({ _id: doc._id }, { $set: { __v: 2 } })];
+                case 2:
+                    // Trigger the post-findOneAndUpdate hook → refreshFromDoc → findOneOrNoneFor → throws
+                    _a.sent();
+                    // Restore immediately
+                    TestEnvConfig.find = originalFind;
+                    // The catch block should have swallowed the error; cache keeps old value
+                    (0, bun_test_1.expect)(config_1.Config.get("TERRENO_PLUGIN_KEY")).toBe("cached");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/package.json

@@ -109,5 +109,5 @@
     "updateSnapshot": "bun test --update-snapshots"
   },
   "types": "dist/index.d.ts",
-  "version": "0.16.1"
+  "version": "0.18.0"
 }

package/src/actions.test.ts

@@ -4,14 +4,19 @@ import type express from "express";
 import {type Model, model, Schema} from "mongoose";
 import supertest from "supertest";
 import type TestAgent from "supertest/lib/agent";
-import {z} from "zod";
-import {ACTION_NAME_PATTERN, defineCollectionAction, defineInstanceAction} from "./actions";
-import {modelRouter} from "./api";
+import {
+  ACTION_NAME_PATTERN,
+  createActionOpenApiMiddleware,
+  defineCollectionAction,
+  defineInstanceAction,
+} from "./actions";
+import {modelRouter, type OpenApiMiddleware} from "./api";
 import {addAuthRoutes, setupAuth} from "./auth";
 import {apiUnauthorizedMiddleware} from "./errors";
 import {Permissions} from "./permissions";
 import {type IsDeleted, isDeletedPlugin} from "./plugins";
 import {authAsUser, type Food, FoodModel, getBaseServer, setupDb, UserModel} from "./tests";
+import {z} from "./zodOpenApi";
 
 interface Stuff extends IsDeleted {
   _id: string;
@@ -430,6 +435,23 @@ describe("modelRouter actions", () => {
         expect(originalQ).toBe("5");
       });
 
+      it("returns 400 with meta.fields for invalid query", async () => {
+        mountFoodRouter({
+          collectionActions: {
+            lookup: {
+              handler: async () => ({ok: true}),
+              method: "GET",
+              permissions: [Permissions.IsAny],
+              query: z.object({email: z.string().email()}),
+            },
+          },
+          permissions: allPermissions,
+        });
+        const res = await server.get("/food/lookup?email=bad").expect(400);
+        expect(res.body.title).toBe("Validation failed");
+        expect(res.body.meta.fields.email).toBeDefined();
+      });
+
       it("coerces body values via zod in ctx", async () => {
         let seenCount: number | undefined;
         mountFoodRouter({
@@ -633,4 +655,129 @@ describe("modelRouter actions", () => {
       expect(action.method).toBe("POST");
     });
   });
+
+  describe("createActionOpenApiMiddleware", () => {
+    const createMockOpenApi = (): {
+      captured: Record<string, unknown> | undefined;
+      middleware: OpenApiMiddleware;
+    } => {
+      let captured: Record<string, unknown> | undefined;
+      const pathFn = (op: Record<string, unknown>): express.RequestHandler => {
+        captured = op;
+        return (_req: express.Request, _res: express.Response, next: express.NextFunction) =>
+          next();
+      };
+      return {
+        get captured() {
+          return captured;
+        },
+        middleware: {path: pathFn} as unknown as OpenApiMiddleware,
+      };
+    };
+
+    it("returns no-op middleware when openApi is not configured", () => {
+      const handler = createActionOpenApiMiddleware({
+        action: {method: "GET", permissions: []},
+        actionName: "test",
+        model: FoodModel as Model<Food>,
+        options: {},
+        scope: "collection",
+      });
+      expect(typeof handler).toBe("function");
+    });
+
+    it("generates query parameters from action.query schema", () => {
+      const mock = createMockOpenApi();
+      createActionOpenApiMiddleware({
+        action: {
+          method: "GET",
+          permissions: [],
+          query: z.object({page: z.coerce.number(), search: z.string()}),
+        },
+        actionName: "search",
+        model: FoodModel as Model<Food>,
+        options: {openApi: mock.middleware},
+        scope: "collection",
+      });
+      const params = mock.captured?.parameters as Record<string, unknown>[];
+      expect(params.length).toBe(2);
+      expect(params.some((p) => p.name === "search")).toBe(true);
+      expect(params.some((p) => p.name === "page")).toBe(true);
+    });
+
+    it("includes id path parameter for instance-scoped actions", () => {
+      const mock = createMockOpenApi();
+      createActionOpenApiMiddleware({
+        action: {method: "GET", permissions: []},
+        actionName: "peek",
+        model: FoodModel as Model<Food>,
+        options: {openApi: mock.middleware},
+        scope: "instance",
+      });
+      const params = mock.captured?.parameters as Record<string, unknown>[];
+      expect(params.some((p) => p.name === "id" && p.in === "path")).toBe(true);
+    });
+
+    it("uses fallback data schema when response is not provided", () => {
+      const mock = createMockOpenApi();
+      createActionOpenApiMiddleware({
+        action: {method: "POST", permissions: []},
+        actionName: "noop",
+        model: FoodModel as Model<Food>,
+        options: {openApi: mock.middleware},
+        scope: "collection",
+      });
+      const responses = mock.captured?.responses as Record<string, Record<string, unknown>>;
+      const ok = responses["200"] as Record<
+        string,
+        Record<string, Record<string, Record<string, unknown>>>
+      >;
+      const schema = ok.content["application/json"].schema as Record<
+        string,
+        Record<string, unknown>
+      >;
+      expect(schema.properties.data).toEqual({type: "object"});
+    });
+
+    it("uses zod response schema when provided", () => {
+      const mock = createMockOpenApi();
+      createActionOpenApiMiddleware({
+        action: {
+          method: "POST",
+          permissions: [],
+          response: z.object({count: z.number()}),
+        },
+        actionName: "tally",
+        model: FoodModel as Model<Food>,
+        options: {openApi: mock.middleware},
+        scope: "collection",
+      });
+      const responses = mock.captured?.responses as Record<string, Record<string, unknown>>;
+      const ok = responses["200"] as Record<
+        string,
+        Record<string, Record<string, Record<string, unknown>>>
+      >;
+      const schema = ok.content["application/json"].schema as Record<
+        string,
+        Record<string, unknown>
+      >;
+      expect((schema.properties.data as Record<string, unknown>).properties).toBeDefined();
+    });
+
+    it("includes requestBody when action.body is defined", () => {
+      const mock = createMockOpenApi();
+      createActionOpenApiMiddleware({
+        action: {
+          body: z.object({name: z.string()}),
+          method: "POST",
+          permissions: [],
+        },
+        actionName: "create",
+        model: FoodModel as Model<Food>,
+        options: {openApi: mock.middleware},
+        scope: "collection",
+      });
+      expect(mock.captured?.requestBody).toBeDefined();
+    });
+  });
 });

package/src/envConfigurationPlugin.test.ts

@@ -140,4 +140,41 @@ describe("envConfigurationPlugin", () => {
     // mapToObject(undefined) returns {}, so Config falls back to the registered default
     expect(Config.get("TERRENO_PLUGIN_KEY")).toBe("fallback");
   });
+
+  it("mapToObject handles a plain Record (non-Map) env field", async () => {
+    // Insert a document with env as a plain object via raw DB operation
+    const col = mongoose.connection.db?.collection("testenvconfigs");
+    await col?.insertOne({env: {TERRENO_PLUGIN_KEY: "plainObj"}});
+
+    // Trigger refresh via findOneAndUpdate hook
+    await TestEnvConfig.findOneAndUpdate({}, {$set: {__v: 1}});
+
+    expect(Config.get("TERRENO_PLUGIN_KEY")).toBe("plainObj");
+  });
+
+  it("refreshFromDoc logs a warning and does not throw when the model query fails", async () => {
+    // Seed a document so findOneAndUpdate has a target
+    const doc = new TestEnvConfig();
+    doc.env.set("TERRENO_PLUGIN_KEY", "initial");
+    await doc.save();
+
+    // Pre-set cache to verify it is NOT overwritten when the hook errors
+    Config.setCachedEnv({TERRENO_PLUGIN_KEY: "cached"});
+
+    // Override Model.find to simulate a DB error inside refreshFromDoc
+    // (findOneOrNoneFor falls back to model.find when the findOneOrNone static is absent)
+    const originalFind = TestEnvConfig.find;
+    (TestEnvConfig as any).find = () => {
+      throw new Error("Simulated DB error");
+    };
+
+    // Trigger the post-findOneAndUpdate hook → refreshFromDoc → findOneOrNoneFor → throws
+    await TestEnvConfig.findOneAndUpdate({_id: doc._id}, {$set: {__v: 2}});
+
+    // Restore immediately
+    (TestEnvConfig as any).find = originalFind;
+
+    // The catch block should have swallowed the error; cache keeps old value
+    expect(Config.get("TERRENO_PLUGIN_KEY")).toBe("cached");
+  });
 });