@terreno/api 0.17.0 → 0.18.0

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.17.0"
+  "version": "0.18.0"
 }

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");
+  });
 });