@terreno/feature-flags 0.19.0 → 0.20.0

package/dist/featureFlagModel.js

@@ -12,6 +12,13 @@ var featureFlagSchema = new mongoose_1.default.Schema({
         description: "Archived flags are excluded from evaluation. Use this instead of deleting flags to prevent bloat as new features are added.",
         type: Boolean,
     },
+    defaultVariant: {
+        description: "OpenFeature defaultVariant key. Returned when the flag is disabled or errors during evaluation. " +
+            "For boolean flags, must be 'on' or 'off'. For variant flags, must be one of the keys in `variants`. " +
+            "Auto-populated on save when omitted (boolean → 'off', variant → first variant key).",
+        required: false,
+        type: String,
+    },
     description: {
         default: "",
         description: "Explanation of what this flag controls",
@@ -99,6 +106,7 @@ featureFlagSchema.plugin(api_1.findExactlyOne);
 featureFlagSchema.plugin(api_1.findOneOrNone);
 featureFlagSchema.index({ archived: 1, enabled: 1 });
 featureFlagSchema.pre("save", function () {
+    var _a;
     if (this.type === "variant") {
         if (!this.variants || this.variants.length === 0) {
             throw new api_1.APIError({
@@ -115,6 +123,35 @@ featureFlagSchema.pre("save", function () {
             });
         }
     }
+    if (this.defaultVariant === undefined ||
+        this.defaultVariant === null ||
+        this.defaultVariant === "") {
+        if (this.type === "boolean") {
+            this.set("defaultVariant", "off");
+        }
+        else if (this.type === "variant" && ((_a = this.variants) === null || _a === void 0 ? void 0 : _a.length)) {
+            this.set("defaultVariant", this.variants[0].key);
+        }
+    }
+    if (this.defaultVariant) {
+        if (this.type === "boolean") {
+            if (this.defaultVariant !== "on" && this.defaultVariant !== "off") {
+                throw new api_1.APIError({
+                    status: 400,
+                    title: "Boolean flags must use defaultVariant 'on' or 'off'",
+                });
+            }
+        }
+        else if (this.type === "variant") {
+            var keys = new Set(this.variants.map(function (v) { return v.key; }));
+            if (!keys.has(this.defaultVariant)) {
+                throw new api_1.APIError({
+                    status: 400,
+                    title: "defaultVariant must match one of the variant keys",
+                });
+            }
+        }
+    }
 });
 exports.FeatureFlag = mongoose_1.default.model("FeatureFlag", featureFlagSchema);
 /**
@@ -136,7 +173,7 @@ exports.FeatureFlag = mongoose_1.default.model("FeatureFlag", featureFlagSchema)
  */
 exports.featureFlagAdminConfig = {
     displayName: "Feature Flags",
-    listFields: ["key", "name", "type", "enabled", "archived", "created"],
+    listFields: ["key", "name", "type", "enabled", "archived", "defaultVariant", "created"],
     model: exports.FeatureFlag,
     routePath: "/feature-flags",
 };

package/dist/featureFlagsApp.d.ts

@@ -22,6 +22,7 @@ import type { FeatureFlagsOptions } from "./types";
 export declare class FeatureFlagsApp implements TerrenoPlugin {
     private options;
     private segments;
+    private mongoProvider?;
     constructor(options?: FeatureFlagsOptions);
     register(app: express.Application, openApi?: unknown): void;
 }

package/dist/featureFlagsApp.js

@@ -46,11 +46,37 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FeatureFlagsApp = void 0;
+var server_sdk_1 = require("@openfeature/server-sdk");
 var api_1 = require("@terreno/api");
+var mongoose_1 = __importDefault(require("mongoose"));
 var evaluate_1 = require("./evaluate");
 var featureFlagModel_1 = require("./featureFlagModel");
+var flagConfiguration_1 = require("./flagConfiguration");
+var openFeatureProvider_1 = require("./openFeatureProvider");
+var evaluateDeprecationWarned = false;
+var resolveSocketServer = function (live) {
+    var server = live.socketIoServer;
+    if (typeof server === "function") {
+        return server();
+    }
+    return server;
+};
 /**
  * TerrenoPlugin that provides feature flags and A/B testing.
  *
@@ -77,24 +103,69 @@ var FeatureFlagsApp = /** @class */ (function () {
     }
     FeatureFlagsApp.prototype.register = function (app, openApi) {
         var _this = this;
-        var _a, _b;
+        var _a, _b, _c, _d;
         var basePath = (_a = this.options.basePath) !== null && _a !== void 0 ? _a : "/feature-flags";
-        var routerOptions = __assign(__assign({}, (openApi ? { openApi: openApi } : {})), { permissions: (_b = this.options.permissions) !== null && _b !== void 0 ? _b : {
+        var openFeatureDomain = (_b = this.options.openFeatureDomain) !== null && _b !== void 0 ? _b : "feature-flags";
+        var routerOptions = __assign(__assign({}, (openApi ? { openApi: openApi } : {})), { permissions: (_c = this.options.permissions) !== null && _c !== void 0 ? _c : {
                 create: [api_1.Permissions.IsAdmin],
                 delete: [api_1.Permissions.IsAdmin],
                 list: [api_1.Permissions.IsAdmin],
                 read: [api_1.Permissions.IsAdmin],
                 update: [api_1.Permissions.IsAdmin],
             }, sort: "-created" });
-        // Admin CRUD routes for flags
+        this.mongoProvider = new openFeatureProvider_1.MongoFeatureFlagProvider({
+            flagModel: featureFlagModel_1.FeatureFlag,
+            segments: this.segments,
+        });
+        server_sdk_1.OpenFeature.setProvider(openFeatureDomain, this.mongoProvider);
         app.use("".concat(basePath, "/flags"), (0, api_1.modelRouter)(featureFlagModel_1.FeatureFlag, routerOptions));
-        // GET /feature-flags/evaluate — evaluate all flags for current user
+        app.get("".concat(basePath, "/flagConfiguration"), (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var user, targetingKey, flags, config, flags_1, flags_1_1, flag, body;
+            var e_1, _a;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        user = req.user;
+                        if (!user) {
+                            throw new api_1.APIError({ status: 401, title: "Authentication required" });
+                        }
+                        targetingKey = String((_b = user._id) !== null && _b !== void 0 ? _b : user.id);
+                        return [4 /*yield*/, featureFlagModel_1.FeatureFlag.find({ archived: { $ne: true }, enabled: true })];
+                    case 1:
+                        flags = _c.sent();
+                        config = {};
+                        try {
+                            for (flags_1 = __values(flags), flags_1_1 = flags_1.next(); !flags_1_1.done; flags_1_1 = flags_1.next()) {
+                                flag = flags_1_1.value;
+                                config[flag.key] = (0, flagConfiguration_1.buildFlagDefinition)(flag, targetingKey, user, this.segments);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (flags_1_1 && !flags_1_1.done && (_a = flags_1.return)) _a.call(flags_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        body = { data: config };
+                        return [2 /*return*/, res.json(body)];
+                }
+            });
+        }); }));
         app.get("".concat(basePath, "/evaluate"), (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
-            var user, userId, results;
+            var sunset, user, userId, results;
             var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
+                        if (!evaluateDeprecationWarned) {
+                            evaluateDeprecationWarned = true;
+                            api_1.logger.warn("[feature-flags] GET /evaluate is deprecated; migrate clients to GET /flagConfiguration or use @terreno/rtk useFeatureFlags / useTerrenoFeatureFlags.");
+                        }
+                        sunset = new Date(Date.now() + 90 * 86400000).toUTCString();
+                        res.setHeader("Deprecation", "true");
+                        res.setHeader("Sunset", sunset);
                         user = req.user;
                         if (!user) {
                             throw new api_1.APIError({ status: 401, title: "Authentication required" });
@@ -107,7 +178,6 @@ var FeatureFlagsApp = /** @class */ (function () {
                 }
             });
         }); }));
-        // GET /feature-flags/segments — list registered segment names (admin only)
         app.get("".concat(basePath, "/segments"), (0, api_1.authenticateMiddleware)(), (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
             var user, allowed;
             return __generator(this, function (_a) {
@@ -121,6 +191,54 @@ var FeatureFlagsApp = /** @class */ (function () {
                 return [2 /*return*/, res.json({ data: Object.keys(this.segments) })];
             });
         }); }));
+        var live = this.options.liveUpdates;
+        if (live && this.mongoProvider) {
+            var eventName_1 = (_d = live.eventName) !== null && _d !== void 0 ? _d : "featureFlagsChanged";
+            var stream_1 = null;
+            var didRetry_1 = false;
+            var cleanupStream_1 = function () {
+                try {
+                    stream_1 === null || stream_1 === void 0 ? void 0 : stream_1.close();
+                }
+                catch (_a) {
+                    /* ignore close errors */
+                }
+                stream_1 = null;
+            };
+            var bindStream_1 = function () {
+                try {
+                    stream_1 = featureFlagModel_1.FeatureFlag.watch([], { fullDocument: "updateLookup" });
+                }
+                catch (err) {
+                    api_1.logger.warn("[feature-flags] FeatureFlag.watch() failed \u2014 live updates require MongoDB as a replica set (even single-node). ".concat(String(err)));
+                    return;
+                }
+                stream_1.on("change", function (change) {
+                    var _a, _b;
+                    var key = (_a = change.fullDocument) === null || _a === void 0 ? void 0 : _a.key;
+                    var ioResolved = resolveSocketServer(live);
+                    if (ioResolved) {
+                        ioResolved.emit(eventName_1, { key: key });
+                    }
+                    (_b = _this.mongoProvider) === null || _b === void 0 ? void 0 : _b.emitConfigurationChanged();
+                });
+                stream_1.on("error", function (err) {
+                    api_1.logger.warn("[feature-flags] change stream error: ".concat(String(err)));
+                    cleanupStream_1();
+                    if (!didRetry_1) {
+                        didRetry_1 = true;
+                        bindStream_1();
+                        return;
+                    }
+                    api_1.logger.warn("[feature-flags] change stream disabled after repeated errors");
+                });
+            };
+            bindStream_1();
+            var onConnectionClose = function () {
+                cleanupStream_1();
+            };
+            mongoose_1.default.connection.on("close", onConnectionClose);
+        }
     };
     return FeatureFlagsApp;
 }());

package/dist/flagConfiguration.d.ts

@@ -0,0 +1,11 @@
+import type { FeatureFlagDocument, FlagDefinition, SegmentFunction } from "./types";
+/**
+ * Resolves the OpenFeature defaultVariant for a flag document, including legacy
+ * documents that omit the field.
+ */
+export declare const effectiveDefaultVariantForFlag: (flag: FeatureFlagDocument) => string;
+/**
+ * Builds a {@link FlagDefinition} for the `/flagConfiguration` wire shape from a
+ * persisted flag and the resolved evaluation for one user.
+ */
+export declare const buildFlagDefinition: (flag: FeatureFlagDocument, targetingKey: string, user: unknown, segments: Record<string, SegmentFunction>) => FlagDefinition;

package/dist/flagConfiguration.js

@@ -0,0 +1,74 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFlagDefinition = exports.effectiveDefaultVariantForFlag = void 0;
+var evaluate_1 = require("./evaluate");
+/**
+ * Resolves the OpenFeature defaultVariant for a flag document, including legacy
+ * documents that omit the field.
+ */
+var effectiveDefaultVariantForFlag = function (flag) {
+    var _a, _b;
+    if (flag.defaultVariant) {
+        return flag.defaultVariant;
+    }
+    if (flag.type === "boolean") {
+        return "off";
+    }
+    return (_b = (_a = flag.variants[0]) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : "off";
+};
+exports.effectiveDefaultVariantForFlag = effectiveDefaultVariantForFlag;
+/**
+ * Builds a {@link FlagDefinition} for the `/flagConfiguration` wire shape from a
+ * persisted flag and the resolved evaluation for one user.
+ */
+var buildFlagDefinition = function (flag, targetingKey, user, segments) {
+    var e_1, _a;
+    var evaluated = (0, evaluate_1.evaluateFlag)(flag, targetingKey, user, segments);
+    if (flag.type === "boolean") {
+        var active = evaluated === true;
+        return {
+            defaultVariant: active ? "on" : "off",
+            disabled: false,
+            variants: { off: false, on: true },
+        };
+    }
+    var variantKeys = flag.variants.map(function (v) { return v.key; });
+    var resolved;
+    if (typeof evaluated === "string" && variantKeys.includes(evaluated)) {
+        resolved = evaluated;
+    }
+    else {
+        resolved = (0, exports.effectiveDefaultVariantForFlag)(flag);
+    }
+    var variants = {};
+    try {
+        for (var variantKeys_1 = __values(variantKeys), variantKeys_1_1 = variantKeys_1.next(); !variantKeys_1_1.done; variantKeys_1_1 = variantKeys_1.next()) {
+            var k = variantKeys_1_1.value;
+            variants[k] = k;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (variantKeys_1_1 && !variantKeys_1_1.done && (_a = variantKeys_1.return)) _a.call(variantKeys_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return {
+        defaultVariant: resolved,
+        disabled: false,
+        variants: variants,
+    };
+};
+exports.buildFlagDefinition = buildFlagDefinition;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { deterministicHash, evaluateAllFlags, evaluateFlag } from "./evaluate";
 export { FeatureFlag, featureFlagAdminConfig } from "./featureFlagModel";
 export { FeatureFlagsApp } from "./featureFlagsApp";
-export type { EvaluationResult, FeatureFlagDocument, FeatureFlagModel, FeatureFlagRule, FeatureFlagsOptions, FeatureFlagType, FeatureFlagVariant, SegmentFunction, } from "./types";
+export { buildFlagDefinition, effectiveDefaultVariantForFlag } from "./flagConfiguration";
+export { MongoFeatureFlagProvider } from "./openFeatureProvider";
+export type { EvaluationResult, FeatureFlagDocument, FeatureFlagModel, FeatureFlagRule, FeatureFlagsLiveUpdatesOptions, FeatureFlagsOptions, FeatureFlagsSocketEmitter, FeatureFlagType, FeatureFlagVariant, FlagConfigurationResponse, FlagDefinition, SegmentFunction, } from "./types";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeatureFlagsApp = exports.featureFlagAdminConfig = exports.FeatureFlag = exports.evaluateFlag = exports.evaluateAllFlags = exports.deterministicHash = void 0;
+exports.MongoFeatureFlagProvider = exports.effectiveDefaultVariantForFlag = exports.buildFlagDefinition = exports.FeatureFlagsApp = exports.featureFlagAdminConfig = exports.FeatureFlag = exports.evaluateFlag = exports.evaluateAllFlags = exports.deterministicHash = void 0;
 var evaluate_1 = require("./evaluate");
 Object.defineProperty(exports, "deterministicHash", { enumerable: true, get: function () { return evaluate_1.deterministicHash; } });
 Object.defineProperty(exports, "evaluateAllFlags", { enumerable: true, get: function () { return evaluate_1.evaluateAllFlags; } });
@@ -10,3 +10,8 @@ Object.defineProperty(exports, "FeatureFlag", { enumerable: true, get: function
 Object.defineProperty(exports, "featureFlagAdminConfig", { enumerable: true, get: function () { return featureFlagModel_1.featureFlagAdminConfig; } });
 var featureFlagsApp_1 = require("./featureFlagsApp");
 Object.defineProperty(exports, "FeatureFlagsApp", { enumerable: true, get: function () { return featureFlagsApp_1.FeatureFlagsApp; } });
+var flagConfiguration_1 = require("./flagConfiguration");
+Object.defineProperty(exports, "buildFlagDefinition", { enumerable: true, get: function () { return flagConfiguration_1.buildFlagDefinition; } });
+Object.defineProperty(exports, "effectiveDefaultVariantForFlag", { enumerable: true, get: function () { return flagConfiguration_1.effectiveDefaultVariantForFlag; } });
+var openFeatureProvider_1 = require("./openFeatureProvider");
+Object.defineProperty(exports, "MongoFeatureFlagProvider", { enumerable: true, get: function () { return openFeatureProvider_1.MongoFeatureFlagProvider; } });

package/dist/openFeatureProvider.d.ts

@@ -0,0 +1,22 @@
+import { type EvaluationContext, type JsonValue, type Logger, OpenFeatureEventEmitter, type Provider, type ResolutionDetails } from "@openfeature/server-sdk";
+import type { FeatureFlagModel, SegmentFunction } from "./types";
+export interface MongoFeatureFlagProviderOptions {
+    flagModel: FeatureFlagModel;
+    segments?: Record<string, SegmentFunction>;
+}
+export declare class MongoFeatureFlagProvider implements Provider {
+    readonly metadata: {
+        readonly name: "MongoFeatureFlagProvider";
+    };
+    readonly runsOn: "server";
+    readonly events: OpenFeatureEventEmitter;
+    private readonly flagModel;
+    private readonly segments;
+    constructor(options: MongoFeatureFlagProviderOptions);
+    resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext, _logger: Logger): Promise<ResolutionDetails<boolean>>;
+    resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext, _logger: Logger): Promise<ResolutionDetails<string>>;
+    resolveNumberEvaluation(_flagKey: string, defaultValue: number, _context: EvaluationContext, _logger: Logger): Promise<ResolutionDetails<number>>;
+    resolveObjectEvaluation<T extends JsonValue>(_flagKey: string, defaultValue: T, _context: EvaluationContext, _logger: Logger): Promise<ResolutionDetails<T>>;
+    emitConfigurationChanged(): void;
+    private resolve;
+}

package/dist/openFeatureProvider.js

@@ -0,0 +1,150 @@
+"use strict";
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoFeatureFlagProvider = void 0;
+var server_sdk_1 = require("@openfeature/server-sdk");
+var evaluate_1 = require("./evaluate");
+var MongoFeatureFlagProvider = /** @class */ (function () {
+    function MongoFeatureFlagProvider(options) {
+        var _a;
+        this.metadata = { name: "MongoFeatureFlagProvider" };
+        this.runsOn = "server";
+        this.events = new server_sdk_1.OpenFeatureEventEmitter();
+        this.flagModel = options.flagModel;
+        this.segments = (_a = options.segments) !== null && _a !== void 0 ? _a : {};
+    }
+    MongoFeatureFlagProvider.prototype.resolveBooleanEvaluation = function (flagKey, defaultValue, context, _logger) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.resolve(flagKey, defaultValue, context, "boolean", _logger)];
+            });
+        });
+    };
+    MongoFeatureFlagProvider.prototype.resolveStringEvaluation = function (flagKey, defaultValue, context, _logger) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.resolve(flagKey, defaultValue, context, "variant", _logger)];
+            });
+        });
+    };
+    MongoFeatureFlagProvider.prototype.resolveNumberEvaluation = function (_flagKey, defaultValue, _context, _logger) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        errorCode: server_sdk_1.ErrorCode.FLAG_NOT_FOUND,
+                        reason: server_sdk_1.StandardResolutionReasons.ERROR,
+                        value: defaultValue,
+                    }];
+            });
+        });
+    };
+    MongoFeatureFlagProvider.prototype.resolveObjectEvaluation = function (_flagKey, defaultValue, _context, _logger) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        errorCode: server_sdk_1.ErrorCode.FLAG_NOT_FOUND,
+                        reason: server_sdk_1.StandardResolutionReasons.ERROR,
+                        value: defaultValue,
+                    }];
+            });
+        });
+    };
+    MongoFeatureFlagProvider.prototype.emitConfigurationChanged = function () {
+        this.events.emit(server_sdk_1.ServerProviderEvents.ConfigurationChanged, { flagsChanged: [] });
+    };
+    MongoFeatureFlagProvider.prototype.resolve = function (flagKey, defaultValue, context, expectedType, _logger) {
+        return __awaiter(this, void 0, void 0, function () {
+            var flag, targetingKey, userFromContext, user, result, value;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.flagModel.findOneOrNone({ archived: { $ne: true }, key: flagKey })];
+                    case 1:
+                        flag = _b.sent();
+                        if (!flag) {
+                            return [2 /*return*/, {
+                                    errorCode: server_sdk_1.ErrorCode.FLAG_NOT_FOUND,
+                                    reason: server_sdk_1.StandardResolutionReasons.ERROR,
+                                    value: defaultValue,
+                                }];
+                        }
+                        if (flag.type !== expectedType) {
+                            return [2 /*return*/, {
+                                    errorCode: server_sdk_1.ErrorCode.TYPE_MISMATCH,
+                                    reason: server_sdk_1.StandardResolutionReasons.ERROR,
+                                    value: defaultValue,
+                                }];
+                        }
+                        if (!flag.enabled) {
+                            return [2 /*return*/, {
+                                    reason: server_sdk_1.StandardResolutionReasons.DISABLED,
+                                    value: defaultValue,
+                                    variant: flag.defaultVariant,
+                                }];
+                        }
+                        targetingKey = (_a = context.targetingKey) !== null && _a !== void 0 ? _a : "";
+                        userFromContext = context.user;
+                        user = userFromContext !== undefined ? userFromContext : context;
+                        result = (0, evaluate_1.evaluateFlag)(flag, targetingKey, user, this.segments);
+                        if (expectedType === "boolean") {
+                            value = result;
+                            return [2 /*return*/, {
+                                    reason: server_sdk_1.StandardResolutionReasons.TARGETING_MATCH,
+                                    value: value,
+                                    variant: value ? "on" : "off",
+                                }];
+                        }
+                        if (result === null) {
+                            return [2 /*return*/, {
+                                    reason: server_sdk_1.StandardResolutionReasons.DISABLED,
+                                    value: defaultValue,
+                                    variant: flag.defaultVariant,
+                                }];
+                        }
+                        return [2 /*return*/, {
+                                reason: server_sdk_1.StandardResolutionReasons.TARGETING_MATCH,
+                                value: result,
+                                variant: result,
+                            }];
+                }
+            });
+        });
+    };
+    return MongoFeatureFlagProvider;
+}());
+exports.MongoFeatureFlagProvider = MongoFeatureFlagProvider;

package/dist/tests/featureFlagModel.test.js

@@ -339,6 +339,76 @@ var featureFlagModel_1 = require("../featureFlagModel");
             }
         });
     }); });
+    (0, bun_test_1.it)("auto-fills defaultVariant to off for boolean flags when omitted", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var flag;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                        key: "default-variant-bool",
+                        name: "Default variant bool",
+                    })];
+                case 1:
+                    flag = _a.sent();
+                    (0, bun_test_1.expect)(flag.defaultVariant).toBe("off");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("auto-fills defaultVariant to the first variant key when omitted on variant flags", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var flag;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                        key: "default-variant-var",
+                        name: "Default variant var",
+                        type: "variant",
+                        variants: [
+                            { key: "control", weight: 40 },
+                            { key: "treatment", weight: 60 },
+                        ],
+                    })];
+                case 1:
+                    flag = _a.sent();
+                    (0, bun_test_1.expect)(flag.defaultVariant).toBe("control");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("accepts explicit defaultVariant on for boolean flags", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var flag;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, featureFlagModel_1.FeatureFlag.create({
+                        defaultVariant: "on",
+                        enabled: true,
+                        key: "explicit-on-bool",
+                        name: "Explicit on",
+                        rolloutPercentage: 100,
+                        type: "boolean",
+                    })];
+                case 1:
+                    flag = _a.sent();
+                    (0, bun_test_1.expect)(flag.defaultVariant).toBe("on");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    (0, bun_test_1.it)("rejects boolean defaultVariant values other than on or off", function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, bun_test_1.expect)(featureFlagModel_1.FeatureFlag.create({
+                        defaultVariant: "maybe",
+                        enabled: true,
+                        key: "bad-default-variant",
+                        name: "Bad default",
+                        type: "boolean",
+                    })).rejects.toMatchObject({ title: "Boolean flags must use defaultVariant 'on' or 'off'" })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
 (0, bun_test_1.describe)("featureFlagAdminConfig", function () {
     (0, bun_test_1.it)("has the expected shape for AdminApp registration", function () {
@@ -351,6 +421,7 @@ var featureFlagModel_1 = require("../featureFlagModel");
             "type",
             "enabled",
             "archived",
+            "defaultVariant",
             "created",
         ]);
     });

package/dist/tests/featureFlagsApp.liveUpdates.test.d.ts

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