@terreno/feature-flags 0.18.0 → 0.20.0

package/dist/tests/featureFlagsApp.liveUpdates.test.js

@@ -0,0 +1,203 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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 node_events_1 = __importDefault(require("node:events"));
+var server_sdk_1 = require("@openfeature/server-sdk");
+var api_1 = require("@terreno/api");
+var tests_1 = require("@terreno/api/src/tests");
+var featureFlagModel_1 = require("../featureFlagModel");
+var featureFlagsApp_1 = require("../featureFlagsApp");
+var FakeChangeStream = /** @class */ (function (_super) {
+    __extends(FakeChangeStream, _super);
+    function FakeChangeStream() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.close = (0, bun_test_1.mock)(function () { return Promise.resolve(); });
+        return _this;
+    }
+    return FakeChangeStream;
+}(node_events_1.default));
+var buildAppWithLive = function (options) {
+    var app = (0, tests_1.getBaseServer)();
+    (0, api_1.setupAuth)(app, tests_1.UserModel);
+    (0, api_1.addAuthRoutes)(app, tests_1.UserModel);
+    var plugin = new featureFlagsApp_1.FeatureFlagsApp({
+        liveUpdates: {
+            eventName: options.eventName,
+            socketIoServer: function () { return options.io; },
+        },
+    });
+    plugin.register(app);
+    app.use(api_1.apiUnauthorizedMiddleware);
+    app.use(api_1.apiErrorMiddleware);
+    return app;
+};
+(0, bun_test_1.describe)("FeatureFlagsApp live updates", function () {
+    var watchSpy;
+    (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, tests_1.setupDb)()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, featureFlagModel_1.FeatureFlag.deleteMany({})];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.afterEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, featureFlagModel_1.FeatureFlag.deleteMany({})];
+                case 1:
+                    _a.sent();
+                    watchSpy === null || watchSpy === void 0 ? void 0 : watchSpy.mockRestore();
+                    return [4 /*yield*/, server_sdk_1.OpenFeature.clearProviders()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("emits the default socket event and payload on change stream events", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var stream, io;
+        return __generator(this, function (_a) {
+            stream = new FakeChangeStream();
+            watchSpy = (0, bun_test_1.spyOn)(featureFlagModel_1.FeatureFlag, "watch").mockReturnValue(stream);
+            io = { emit: (0, bun_test_1.mock)(function () { }) };
+            buildAppWithLive({ io: io });
+            stream.emit("change", { fullDocument: { key: "todo-summary-card" } });
+            (0, bun_test_1.expect)(io.emit).toHaveBeenCalledWith("featureFlagsChanged", { key: "todo-summary-card" });
+            return [2 /*return*/];
+        });
+    }); });
+    (0, bun_test_1.it)("respects a custom liveUpdates.eventName", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var stream, io;
+        return __generator(this, function (_a) {
+            stream = new FakeChangeStream();
+            watchSpy = (0, bun_test_1.spyOn)(featureFlagModel_1.FeatureFlag, "watch").mockReturnValue(stream);
+            io = { emit: (0, bun_test_1.mock)(function () { }) };
+            buildAppWithLive({ eventName: "flagsUpdated", io: io });
+            stream.emit("change", { fullDocument: { key: "k" } });
+            (0, bun_test_1.expect)(io.emit).toHaveBeenCalledWith("flagsUpdated", { key: "k" });
+            return [2 /*return*/];
+        });
+    }); });
+    (0, bun_test_1.it)("logs a warn on stream error, retries once, then disables after a second error", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var warnSpy, stream1, stream2, call, io, disabledMsg;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    warnSpy = (0, bun_test_1.spyOn)(api_1.logger, "warn").mockImplementation(function () { });
+                    stream1 = new FakeChangeStream();
+                    stream2 = new FakeChangeStream();
+                    call = 0;
+                    watchSpy = (0, bun_test_1.spyOn)(featureFlagModel_1.FeatureFlag, "watch").mockImplementation(function () {
+                        call += 1;
+                        if (call === 1) {
+                            return stream1;
+                        }
+                        return stream2;
+                    });
+                    io = { emit: (0, bun_test_1.mock)(function () { }) };
+                    buildAppWithLive({ io: io });
+                    stream1.emit("error", new Error("first"));
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve, 0);
+                        })];
+                case 1:
+                    _a.sent();
+                    stream2.emit("error", new Error("second"));
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve, 0);
+                        })];
+                case 2:
+                    _a.sent();
+                    disabledMsg = warnSpy.mock.calls.find(function (c) { return typeof c[0] === "string" && c[0].includes("change stream disabled"); });
+                    (0, bun_test_1.expect)(disabledMsg).toBeDefined();
+                    warnSpy.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/dist/tests/featureFlagsApp.test.js

@@ -40,6 +40,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var bun_test_1 = require("bun:test");
+var server_sdk_1 = require("@openfeature/server-sdk");
 var api_1 = require("@terreno/api");
 var tests_1 = require("@terreno/api/src/tests");
 var supertest_1 = __importDefault(require("supertest"));
@@ -77,6 +78,9 @@ var buildApp = function (options) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, featureFlagModel_1.FeatureFlag.deleteMany({})];
                 case 1:
+                    _a.sent();
+                    return [4 /*yield*/, server_sdk_1.OpenFeature.clearProviders()];
+                case 2:
                     _a.sent();
                     return [2 /*return*/];
             }
@@ -331,6 +335,151 @@ var buildApp = function (options) {
                 }
             });
         }); });
+        (0, bun_test_1.it)("includes Deprecation and Sunset headers on GET /evaluate", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                            enabled: true,
+                            key: "hdr-flag",
+                            name: "Hdr",
+                            rolloutPercentage: 100,
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, (0, tests_1.authAsUser)(app, "admin")];
+                    case 2:
+                        adminAgent = _a.sent();
+                        return [4 /*yield*/, adminAgent.get("/feature-flags/evaluate").expect(200)];
+                    case 3:
+                        res = _a.sent();
+                        (0, bun_test_1.expect)(res.headers.deprecation).toBe("true");
+                        (0, bun_test_1.expect)(res.headers.sunset).toBeDefined();
+                        (0, bun_test_1.expect)(res.body.data["hdr-flag"]).toBe(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    (0, bun_test_1.describe)("GET /feature-flags/flagConfiguration", function () {
+        (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {
+            var segments;
+            return __generator(this, function (_a) {
+                segments = {
+                    admins: function (user) { return user.admin === true; },
+                };
+                app = buildApp({ segments: segments });
+                return [2 /*return*/];
+            });
+        }); });
+        (0, bun_test_1.it)("returns 401 when unauthenticated", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var unauth;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        unauth = (0, supertest_1.default)(app);
+                        return [4 /*yield*/, unauth.get("/feature-flags/flagConfiguration").expect(401)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("returns OpenFeature-shaped entries for enabled flags and omits disabled and archived", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res, data;
+            var _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                            enabled: true,
+                            key: "bool-active",
+                            name: "Bool",
+                            rolloutPercentage: 100,
+                            type: "boolean",
+                        })];
+                    case 1:
+                        _e.sent();
+                        return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                                defaultVariant: "compact",
+                                enabled: true,
+                                key: "profile",
+                                name: "Profile",
+                                rules: [],
+                                type: "variant",
+                                variants: [
+                                    { key: "compact", weight: 50 },
+                                    { key: "detailed", weight: 50 },
+                                ],
+                            })];
+                    case 2:
+                        _e.sent();
+                        return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                                enabled: false,
+                                key: "disabled-one",
+                                name: "Off",
+                                rolloutPercentage: 100,
+                                type: "boolean",
+                            })];
+                    case 3:
+                        _e.sent();
+                        return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                                archived: true,
+                                enabled: true,
+                                key: "archived-one",
+                                name: "Archived",
+                                rolloutPercentage: 100,
+                                type: "boolean",
+                            })];
+                    case 4:
+                        _e.sent();
+                        return [4 /*yield*/, (0, tests_1.authAsUser)(app, "admin")];
+                    case 5:
+                        adminAgent = _e.sent();
+                        return [4 /*yield*/, adminAgent.get("/feature-flags/flagConfiguration").expect(200)];
+                    case 6:
+                        res = _e.sent();
+                        data = res.body.data;
+                        (0, bun_test_1.expect)(data["bool-active"]).toEqual({
+                            defaultVariant: "on",
+                            disabled: false,
+                            variants: { off: false, on: true },
+                        });
+                        (0, bun_test_1.expect)((_a = data.profile) === null || _a === void 0 ? void 0 : _a.disabled).toBe(false);
+                        (0, bun_test_1.expect)(["compact", "detailed"].includes((_c = (_b = data.profile) === null || _b === void 0 ? void 0 : _b.defaultVariant) !== null && _c !== void 0 ? _c : "")).toBe(true);
+                        (0, bun_test_1.expect)((_d = data.profile) === null || _d === void 0 ? void 0 : _d.variants.compact).toBe("compact");
+                        (0, bun_test_1.expect)(data["disabled-one"]).toBeUndefined();
+                        (0, bun_test_1.expect)(data["archived-one"]).toBeUndefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        (0, bun_test_1.it)("uses resolved boolean variant as defaultVariant (not the persisted schema default alone)", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                            defaultVariant: "off",
+                            enabled: true,
+                            key: "resolved-bool",
+                            name: "Resolved",
+                            rolloutPercentage: 100,
+                            rules: [],
+                            type: "boolean",
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, (0, tests_1.authAsUser)(app, "admin")];
+                    case 2:
+                        adminAgent = _a.sent();
+                        return [4 /*yield*/, adminAgent.get("/feature-flags/flagConfiguration").expect(200)];
+                    case 3:
+                        res = _a.sent();
+                        (0, bun_test_1.expect)(res.body.data["resolved-bool"].defaultVariant).toBe("on");
+                        (0, bun_test_1.expect)(res.body.data["resolved-bool"].variants.on).toBe(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     (0, bun_test_1.describe)("GET /feature-flags/segments", function () {
         (0, bun_test_1.beforeEach)(function () { return __awaiter(void 0, void 0, void 0, function () {

package/dist/tests/openFeatureProvider.test.d.ts

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