@terreno/feature-flags 0.7.1

package/biome.jsonc

@@ -0,0 +1,20 @@
+{
+  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
+  "extends": ["../biome.jsonc"],
+  "files": {
+    "includes": [
+      "package.json",
+      "src/**/*.ts",
+      "src/**/*.tsx",
+      "!!**/node_modules",
+      "!!node_modules",
+      "!!**/dist",
+      "!!dist",
+      "!!**/build",
+      "!!build",
+      "!!**/coverage",
+      "!!coverage"
+    ]
+  },
+  "root": true
+}

package/bunfig.toml

@@ -0,0 +1,8 @@
+[test]
+preload = ["../api/src/tests/bunSetup.ts"]
+root = "./src"
+coveragePathIgnorePatterns = ["**/dist/**", "**/*.test.ts", "**/tests/**", "**/node_modules/**", "../**"]
+# Enforced by scripts/check-coverage.ts; Bun parses this key but does not
+# fail the run when coverage is below threshold. See
+# https://github.com/oven-sh/bun/issues/7367 and https://github.com/oven-sh/bun/pull/27933.
+coverageThreshold = { line = 95, function = 95 }

package/dist/evaluate.d.ts

@@ -0,0 +1,17 @@
+import type { EvaluationResult, FeatureFlagDocument, SegmentFunction } from "./types";
+/**
+ * Deterministic hash of a string to a number between 0 and 99.
+ * Uses a simple but effective hash (djb2) to ensure the same user+flag
+ * combination always produces the same result.
+ */
+export declare const deterministicHash: (input: string) => number;
+/**
+ * Evaluate a single feature flag for a user.
+ * Returns boolean for boolean flags, string key for variant flags, or null for disabled variant flags.
+ */
+export declare const evaluateFlag: (flag: FeatureFlagDocument, userId: string, user: unknown, segments: Record<string, SegmentFunction>) => boolean | string | null;
+/**
+ * Evaluate all enabled, non-archived feature flags for a user.
+ * Returns a map of flag key to evaluation result.
+ */
+export declare const evaluateAllFlags: (flagModel: typeof import("./featureFlagModel").FeatureFlag, userId: string, user: unknown, segments: Record<string, SegmentFunction>) => Promise<EvaluationResult>;

package/dist/evaluate.js

@@ -0,0 +1,233 @@
+"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 };
+    }
+};
+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.evaluateAllFlags = exports.evaluateFlag = exports.deterministicHash = void 0;
+var api_1 = require("@terreno/api");
+var get_1 = __importDefault(require("lodash/get"));
+var isDebugEnabled = function () { return process.env.FEATURE_FLAGS_DEBUG !== "false"; };
+/**
+ * Deterministic hash of a string to a number between 0 and 99.
+ * Uses a simple but effective hash (djb2) to ensure the same user+flag
+ * combination always produces the same result.
+ */
+var deterministicHash = function (input) {
+    var hash = 5381;
+    for (var i = 0; i < input.length; i++) {
+        hash = (hash * 33) ^ input.charCodeAt(i);
+    }
+    return Math.abs(hash) % 100;
+};
+exports.deterministicHash = deterministicHash;
+var matchesFieldRule = function (user, rule) {
+    if (!rule.field || !rule.operator) {
+        return false;
+    }
+    var fieldValue = (0, get_1.default)(user, rule.field);
+    var ruleValue = rule.value;
+    var result = false;
+    switch (rule.operator) {
+        case "eq":
+            result = ruleValue !== undefined && fieldValue === ruleValue;
+            break;
+        case "neq":
+            result = ruleValue !== undefined && fieldValue !== ruleValue;
+            break;
+        case "in":
+            result = Array.isArray(ruleValue) && ruleValue.includes(fieldValue);
+            break;
+        case "nin":
+            result = Array.isArray(ruleValue) && !ruleValue.includes(fieldValue);
+            break;
+        case "gt":
+            result =
+                typeof fieldValue === "number" && typeof ruleValue === "number" && fieldValue > ruleValue;
+            break;
+        case "lt":
+            result =
+                typeof fieldValue === "number" && typeof ruleValue === "number" && fieldValue < ruleValue;
+            break;
+        case "contains":
+            result =
+                typeof fieldValue === "string" &&
+                    typeof ruleValue === "string" &&
+                    fieldValue.includes(ruleValue);
+            break;
+        default:
+            break;
+    }
+    if (isDebugEnabled()) {
+        api_1.logger.info("[feature-flags] field rule: user.".concat(rule.field, "=").concat(JSON.stringify(fieldValue), " ").concat(rule.operator, " ").concat(JSON.stringify(ruleValue), " \u2192 ").concat(result));
+    }
+    return result;
+};
+var matchesRule = function (user, rule, segments) {
+    if (rule.segment) {
+        var segmentFn = segments[rule.segment];
+        if (!segmentFn) {
+            api_1.logger.warn("Segment function not found: ".concat(rule.segment));
+            return false;
+        }
+        try {
+            var result = segmentFn(user);
+            if (isDebugEnabled()) {
+                api_1.logger.info("[feature-flags] segment rule: \"".concat(rule.segment, "\" \u2192 ").concat(result));
+            }
+            return result;
+        }
+        catch (err) {
+            api_1.logger.warn("Segment function \"".concat(rule.segment, "\" threw: ").concat(err));
+            return false;
+        }
+    }
+    return matchesFieldRule(user, rule);
+};
+/**
+ * Evaluate a single feature flag for a user.
+ * Returns boolean for boolean flags, string key for variant flags, or null for disabled variant flags.
+ */
+var evaluateFlag = function (flag, userId, user, segments) {
+    var e_1, _a;
+    var _b, _c;
+    var debug = isDebugEnabled();
+    if (!flag.enabled) {
+        if (debug) {
+            api_1.logger.info("[feature-flags] \"".concat(flag.key, "\" is disabled \u2192 ").concat(flag.type === "variant" ? "null" : "false"));
+        }
+        return flag.type === "variant" ? null : false;
+    }
+    // Check rules in order — first match wins
+    for (var i = 0; i < flag.rules.length; i++) {
+        var rule = flag.rules[i];
+        var matched = matchesRule(user, rule, segments);
+        if (matched) {
+            var result = flag.type === "variant" ? ((_b = rule.variant) !== null && _b !== void 0 ? _b : null) : ((_c = rule.enabled) !== null && _c !== void 0 ? _c : false);
+            if (debug) {
+                api_1.logger.info("[feature-flags] \"".concat(flag.key, "\" matched rule ").concat(i, " \u2192 ").concat(JSON.stringify(result)));
+            }
+            return result;
+        }
+    }
+    // No rules matched — use deterministic hashing
+    var hash = (0, exports.deterministicHash)("".concat(userId, ":").concat(flag.key));
+    if (flag.type === "boolean") {
+        var result = hash < flag.rolloutPercentage;
+        if (debug) {
+            api_1.logger.info("[feature-flags] \"".concat(flag.key, "\" no rules matched, hash=").concat(hash, " rollout=").concat(flag.rolloutPercentage, "% \u2192 ").concat(result));
+        }
+        return result;
+    }
+    // Variant assignment based on cumulative weights
+    var cumulativeWeight = 0;
+    try {
+        for (var _d = __values(flag.variants), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var variant = _e.value;
+            cumulativeWeight += variant.weight;
+            if (hash < cumulativeWeight) {
+                if (debug) {
+                    api_1.logger.info("[feature-flags] \"".concat(flag.key, "\" no rules matched, hash=").concat(hash, " \u2192 variant \"").concat(variant.key, "\""));
+                }
+                return variant.key;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    // Fallback (shouldn't happen if weights sum to 100)
+    var fallback = flag.variants.length > 0 ? flag.variants[flag.variants.length - 1].key : null;
+    if (debug) {
+        api_1.logger.info("[feature-flags] \"".concat(flag.key, "\" variant fallback \u2192 ").concat(JSON.stringify(fallback)));
+    }
+    return fallback;
+};
+exports.evaluateFlag = evaluateFlag;
+/**
+ * Evaluate all enabled, non-archived feature flags for a user.
+ * Returns a map of flag key to evaluation result.
+ */
+var evaluateAllFlags = function (flagModel, userId, user, segments) { return __awaiter(void 0, void 0, void 0, function () {
+    var flags, results, flags_1, flags_1_1, flag;
+    var e_2, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, flagModel.find({ archived: { $ne: true }, enabled: true })];
+            case 1:
+                flags = _b.sent();
+                results = {};
+                if (isDebugEnabled()) {
+                    api_1.logger.info("[feature-flags] evaluating ".concat(flags.length, " flags for user ").concat(userId));
+                }
+                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;
+                        results[flag.key] = (0, exports.evaluateFlag)(flag, userId, user, segments);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (flags_1_1 && !flags_1_1.done && (_a = flags_1.return)) _a.call(flags_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                if (isDebugEnabled()) {
+                    api_1.logger.info("[feature-flags] results: ".concat(JSON.stringify(results)));
+                }
+                return [2 /*return*/, results];
+        }
+    });
+}); };
+exports.evaluateAllFlags = evaluateAllFlags;

package/dist/featureFlagModel.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureFlagModel } from "./types";
+export declare const FeatureFlag: FeatureFlagModel;

package/dist/featureFlagModel.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlag = void 0;
+var api_1 = require("@terreno/api");
+var mongoose_1 = __importDefault(require("mongoose"));
+var featureFlagSchema = new mongoose_1.default.Schema({
+    archived: {
+        default: false,
+        description: "Archived flags are excluded from evaluation. Use this instead of deleting flags to prevent bloat as new features are added.",
+        type: Boolean,
+    },
+    description: {
+        default: "",
+        description: "Explanation of what this flag controls",
+        type: String,
+    },
+    enabled: {
+        default: false,
+        description: "Global kill switch — if false, flag is off for everyone",
+        type: Boolean,
+    },
+    key: {
+        description: "Unique identifier for the flag, e.g., 'new-checkout-flow'",
+        required: true,
+        trim: true,
+        type: String,
+        unique: true,
+    },
+    name: {
+        description: "Human-readable display name",
+        required: true,
+        type: String,
+    },
+    rolloutPercentage: {
+        default: 100,
+        description: "For boolean flags with no matching rules: percentage of users who get true",
+        max: 100,
+        min: 0,
+        type: Number,
+    },
+    rules: [
+        {
+            enabled: {
+                description: "Whether the flag/variant is turned on when this rule matches. For boolean flags this is the override value; for variant flags it gates whether the forced variant applies.",
+                type: Boolean,
+            },
+            field: {
+                description: "User field to match against (use with operator + value). Supports dot notation, e.g., 'email', 'admin', 'address.zip'. Use field/operator/value together, OR segment alone.",
+                type: String,
+            },
+            operator: {
+                description: "Comparison operator for field-based rules (use with field + value). Use field/operator/value together, OR segment alone.",
+                enum: ["eq", "neq", "in", "nin", "gt", "lt", "contains"],
+                type: String,
+            },
+            segment: {
+                description: "Name of a registered segment function, e.g., 'pro-users'. Use segment alone, OR field/operator/value together.",
+                type: String,
+            },
+            value: {
+                description: "Value to compare against (use with field + operator). String, number, boolean, or array for in/nin. Use field/operator/value together, OR segment alone.",
+                type: mongoose_1.default.Schema.Types.Mixed,
+            },
+            variant: {
+                description: "For variant flags only: forced variant key when this rule matches. Use field/operator/value together, OR segment alone.",
+                type: String,
+            },
+        },
+    ],
+    type: {
+        default: "boolean",
+        description: "Boolean toggle or multi-variant A/B test",
+        enum: ["boolean", "variant"],
+        type: String,
+    },
+    variants: [
+        {
+            key: {
+                description: "Variant identifier, e.g., 'control', 'variant-a'",
+                required: true,
+                type: String,
+            },
+            weight: {
+                description: "Percentage weight for assignment (0-100, all must sum to 100)",
+                max: 100,
+                min: 0,
+                required: true,
+                type: Number,
+            },
+        },
+    ],
+}, { strict: "throw", toJSON: { virtuals: true }, toObject: { virtuals: true } });
+featureFlagSchema.plugin(api_1.createdUpdatedPlugin);
+featureFlagSchema.plugin(api_1.isDeletedPlugin);
+featureFlagSchema.plugin(api_1.findExactlyOne);
+featureFlagSchema.plugin(api_1.findOneOrNone);
+featureFlagSchema.index({ archived: 1, enabled: 1 });
+featureFlagSchema.pre("save", function () {
+    if (this.type === "variant") {
+        if (!this.variants || this.variants.length === 0) {
+            throw new api_1.APIError({
+                status: 400,
+                title: "Variant flags must have at least one variant",
+            });
+        }
+        var totalWeight = this.variants.reduce(function (sum, v) { return sum + v.weight; }, 0);
+        if (totalWeight !== 100) {
+            throw new api_1.APIError({
+                detail: "Total weight is ".concat(totalWeight, ", expected 100"),
+                status: 400,
+                title: "Variant weights must sum to 100",
+            });
+        }
+    }
+});
+exports.FeatureFlag = mongoose_1.default.model("FeatureFlag", featureFlagSchema);

package/dist/featureFlagsApp.d.ts

@@ -0,0 +1,27 @@
+import { type TerrenoPlugin } from "@terreno/api";
+import type express from "express";
+import type { FeatureFlagsOptions } from "./types";
+/**
+ * TerrenoPlugin that provides feature flags and A/B testing.
+ *
+ * Creates admin CRUD endpoints for managing flags and a user-facing
+ * evaluation endpoint that returns all flag values for the current user.
+ *
+ * @example
+ * ```typescript
+ * const segments = {
+ *   "pro-users": (user) => user.plan === "pro",
+ *   "beta-testers": (user) => user.betaTester === true,
+ * };
+ *
+ * new TerrenoApp({ userModel: User })
+ *   .register(new FeatureFlagsApp({ segments }))
+ *   .start();
+ * ```
+ */
+export declare class FeatureFlagsApp implements TerrenoPlugin {
+    private options;
+    private segments;
+    constructor(options?: FeatureFlagsOptions);
+    register(app: express.Application, openApi?: unknown): void;
+}

package/dist/featureFlagsApp.js

@@ -0,0 +1,124 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagsApp = void 0;
+var api_1 = require("@terreno/api");
+var evaluate_1 = require("./evaluate");
+var featureFlagModel_1 = require("./featureFlagModel");
+/**
+ * TerrenoPlugin that provides feature flags and A/B testing.
+ *
+ * Creates admin CRUD endpoints for managing flags and a user-facing
+ * evaluation endpoint that returns all flag values for the current user.
+ *
+ * @example
+ * ```typescript
+ * const segments = {
+ *   "pro-users": (user) => user.plan === "pro",
+ *   "beta-testers": (user) => user.betaTester === true,
+ * };
+ *
+ * new TerrenoApp({ userModel: User })
+ *   .register(new FeatureFlagsApp({ segments }))
+ *   .start();
+ * ```
+ */
+var FeatureFlagsApp = /** @class */ (function () {
+    function FeatureFlagsApp(options) {
+        var _a;
+        this.options = options !== null && options !== void 0 ? options : {};
+        this.segments = (_a = this.options.segments) !== null && _a !== void 0 ? _a : {};
+    }
+    FeatureFlagsApp.prototype.register = function (app, openApi) {
+        var _this = this;
+        var _a;
+        var basePath = (_a = this.options.basePath) !== null && _a !== void 0 ? _a : "/feature-flags";
+        var routerOptions = __assign(__assign({}, (openApi ? { openApi: openApi } : {})), { permissions: {
+                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
+        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, "/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 _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        user = req.user;
+                        if (!user) {
+                            throw new api_1.APIError({ status: 401, title: "Authentication required" });
+                        }
+                        userId = String((_a = user._id) !== null && _a !== void 0 ? _a : user.id);
+                        return [4 /*yield*/, (0, evaluate_1.evaluateAllFlags)(featureFlagModel_1.FeatureFlag, userId, user, this.segments)];
+                    case 1:
+                        results = _b.sent();
+                        return [2 /*return*/, res.json({ data: results })];
+                }
+            });
+        }); }));
+        // 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;
+            return __generator(this, function (_a) {
+                user = req.user;
+                if (!(user === null || user === void 0 ? void 0 : user.admin)) {
+                    throw new api_1.APIError({ status: 403, title: "Only admins can view segments" });
+                }
+                return [2 /*return*/, res.json({ data: Object.keys(this.segments) })];
+            });
+        }); }));
+    };
+    return FeatureFlagsApp;
+}());
+exports.FeatureFlagsApp = FeatureFlagsApp;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { deterministicHash, evaluateAllFlags, evaluateFlag } from "./evaluate";
+export { FeatureFlag } from "./featureFlagModel";
+export { FeatureFlagsApp } from "./featureFlagsApp";
+export type { EvaluationResult, FeatureFlagDocument, FeatureFlagModel, FeatureFlagRule, FeatureFlagsOptions, FeatureFlagType, FeatureFlagVariant, SegmentFunction, } from "./types";

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagsApp = 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; } });
+Object.defineProperty(exports, "evaluateFlag", { enumerable: true, get: function () { return evaluate_1.evaluateFlag; } });
+var featureFlagModel_1 = require("./featureFlagModel");
+Object.defineProperty(exports, "FeatureFlag", { enumerable: true, get: function () { return featureFlagModel_1.FeatureFlag; } });
+var featureFlagsApp_1 = require("./featureFlagsApp");
+Object.defineProperty(exports, "FeatureFlagsApp", { enumerable: true, get: function () { return featureFlagsApp_1.FeatureFlagsApp; } });

package/dist/tests/bunSetup.d.ts

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

package/dist/tests/bunSetup.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var bun_test_1 = require("bun:test");
+// Mock @sentry/bun module
+bun_test_1.mock.module("@sentry/bun", function () {
+    var mockFn = function () { return (0, bun_test_1.mock)(function () { }); };
+    return {
+        addBreadcrumb: mockFn(),
+        captureException: mockFn(),
+        captureMessage: mockFn(),
+        close: (0, bun_test_1.mock)(function () { return Promise.resolve(true); }),
+        default: {
+            captureException: mockFn(),
+            captureMessage: mockFn(),
+            Handlers: {
+                errorHandler: (0, bun_test_1.mock)(function () { return function (err, _req, _res, next) {
+                    return next(err);
+                }; }),
+                requestHandler: (0, bun_test_1.mock)(function () { return function (_req, _res, next) { return next(); }; }),
+                tracingHandler: (0, bun_test_1.mock)(function () { return function (_req, _res, next) { return next(); }; }),
+            },
+            init: mockFn(),
+            isInitialized: (0, bun_test_1.mock)(function () { return true; }),
+            setupExpressErrorHandler: mockFn(),
+        },
+        flush: (0, bun_test_1.mock)(function () { return Promise.resolve(true); }),
+        init: mockFn(),
+        isInitialized: (0, bun_test_1.mock)(function () { return true; }),
+        setContext: mockFn(),
+        setTag: mockFn(),
+        setUser: mockFn(),
+        setupExpressErrorHandler: mockFn(),
+        withScope: (0, bun_test_1.mock)(function (callback) { return callback({}); }),
+    };
+});

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

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