@kenji71089/evaluation 0.0.1

package/lib/modelFactory.mjs

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUser = createUser;
+exports.createFeature = createFeature;
+exports.createTarget = createTarget;
+exports.createFixedStrategy = createFixedStrategy;
+exports.createRolloutStrategy = createRolloutStrategy;
+exports.createStrategy = createStrategy;
+exports.createRule = createRule;
+exports.createClause = createClause;
+exports.createSegmentUser = createSegmentUser;
+exports.createPrerequisite = createPrerequisite;
+exports.createVariation = createVariation;
+exports.createEvaluation = createEvaluation;
+exports.createReason = createReason;
+const clause_pb_1 = require("./proto/feature/clause_pb");
+const evaluation_pb_1 = require("./proto/feature/evaluation_pb");
+const feature_pb_1 = require("./proto/feature/feature_pb");
+const prerequisite_pb_1 = require("./proto/feature/prerequisite_pb");
+const reason_pb_1 = require("./proto/feature/reason_pb");
+const rule_pb_1 = require("./proto/feature/rule_pb");
+const segment_pb_1 = require("./proto/feature/segment_pb");
+const strategy_pb_1 = require("./proto/feature/strategy_pb");
+const target_pb_1 = require("./proto/feature/target_pb");
+const variation_pb_1 = require("./proto/feature/variation_pb");
+const user_pb_1 = require("./proto/user/user_pb");
+// Helper function to create a User instance
+function createUser(id, data) {
+    const user = new user_pb_1.User();
+    user.setId(id);
+    let map = user.getDataMap();
+    if (data != null) {
+        Object.entries(data).forEach(([key, value]) => map.set(key, value));
+    }
+    return user;
+}
+function createFeature(options = {}) {
+    const defaultOptions = {
+        id: '',
+        name: '',
+        version: 0,
+        enabled: false,
+        createdAt: Date.now(),
+        variationType: feature_pb_1.Feature.VariationType.STRING,
+        variations: [],
+        targets: [],
+        rules: [],
+        defaultStrategy: undefined,
+        prerequisitesList: [],
+        tagList: [],
+        offVariation: undefined,
+    };
+    const finalOptions = { ...defaultOptions, ...options };
+    const feature = new feature_pb_1.Feature();
+    feature.setId(finalOptions.id);
+    feature.setName(finalOptions.name);
+    feature.setVersion(finalOptions.version);
+    feature.setEnabled(finalOptions.enabled);
+    feature.setCreatedAt(finalOptions.createdAt);
+    feature.setVariationType(finalOptions.variationType);
+    // Set variations
+    const variationList = finalOptions.variations.map((v) => createVariation(v.id, v.value, v.name, v.description));
+    feature.setVariationsList(variationList);
+    // Set targets
+    const targetList = finalOptions.targets.map((t) => createTarget(t.variation, t.users));
+    feature.setTargetsList(targetList);
+    // Set rules
+    const ruleList = finalOptions.rules.map((r) => createRule(r.id, r.attribute, r.operator, r.values, r.fixedVariation));
+    feature.setRulesList(ruleList);
+    // Set default strategy
+    const defaultStrategy = finalOptions.defaultStrategy;
+    if (defaultStrategy !== undefined) {
+        const defaultFixedStrategy = createFixedStrategy(defaultStrategy.variation);
+        const strategy = createStrategy({
+            type: defaultStrategy.type,
+            fixedStrategy: defaultFixedStrategy,
+        });
+        feature.setDefaultStrategy(strategy);
+    }
+    feature.setPrerequisitesList(finalOptions.prerequisitesList);
+    feature.setTagsList(finalOptions.tagList);
+    if (finalOptions.offVariation !== undefined) {
+        feature.setOffVariation(finalOptions.offVariation);
+    }
+    return feature;
+}
+function createTarget(variation, users) {
+    const target = new target_pb_1.Target();
+    target.setVariation(variation);
+    target.setUsersList(users);
+    return target;
+}
+function createFixedStrategy(variation) {
+    const fixedStrategy = new strategy_pb_1.FixedStrategy();
+    fixedStrategy.setVariation(variation);
+    return fixedStrategy;
+}
+function createRolloutStrategy(options) {
+    const rolloutStrategy = new strategy_pb_1.RolloutStrategy();
+    const variations = options.variations.map((v) => {
+        const variation = new strategy_pb_1.RolloutStrategy.Variation();
+        variation.setVariation(v.variation);
+        variation.setWeight(v.weight);
+        return variation;
+    });
+    rolloutStrategy.setVariationsList(variations);
+    return rolloutStrategy;
+}
+function createStrategy(options) {
+    const strategy = new strategy_pb_1.Strategy();
+    strategy.setType(options.type);
+    strategy.setFixedStrategy(options.fixedStrategy);
+    strategy.setRolloutStrategy(options.rolloutStrategy);
+    return strategy;
+}
+//TODO: FIX ME - Rule should have a constructor that accepts all the parameters
+//Current is missing many parameters
+function createRule(id, attribute, operator, values, fixedVariation) {
+    const rule = new rule_pb_1.Rule();
+    rule.setId(id);
+    const fixedStrategy = createFixedStrategy(fixedVariation);
+    const strategy = createStrategy({ type: strategy_pb_1.Strategy.Type.FIXED, fixedStrategy });
+    rule.setStrategy(strategy);
+    rule.setClausesList([createClause(id, attribute, operator, values)]);
+    return rule;
+}
+function createClause(id, attribute, operator, values) {
+    const clause = new clause_pb_1.Clause();
+    clause.setId(id);
+    clause.setAttribute(attribute);
+    clause.setOperator(operator);
+    clause.setValuesList(values);
+    return clause;
+}
+function createSegmentUser(userId, segmentId, state) {
+    const segmentUser = new segment_pb_1.SegmentUser();
+    segmentUser.setUserId(userId);
+    segmentUser.setSegmentId(segmentId);
+    segmentUser.setState(state);
+    return segmentUser;
+}
+function createPrerequisite(featureId, variationId) {
+    const prerequisite = new prerequisite_pb_1.Prerequisite();
+    prerequisite.setFeatureId(featureId);
+    prerequisite.setVariationId(variationId);
+    return prerequisite;
+}
+// Function to create a Variation instance with the provided parameters
+function createVariation(id, value, name, description) {
+    const variation = new variation_pb_1.Variation();
+    variation.setId(id);
+    variation.setValue(value);
+    variation.setName(name);
+    variation.setDescription(description);
+    return variation;
+}
+function createEvaluation(id, featureId, featureVersion, userId, variationId, variationValue, variationName, reason) {
+    const evaluation = new evaluation_pb_1.Evaluation();
+    evaluation.setId(id);
+    evaluation.setFeatureId(featureId);
+    evaluation.setFeatureVersion(featureVersion);
+    evaluation.setUserId(userId);
+    evaluation.setVariationId(variationId);
+    evaluation.setVariationValue(variationValue);
+    evaluation.setVariationName(variationName);
+    evaluation.setReason(reason);
+    return evaluation;
+}
+//TODO: should we set the ruleId to empty string as default?
+//TODO: create optional constructor for Reason
+function createReason(ruleId, type) {
+    const reason = new reason_pb_1.Reason();
+    reason.setType(type);
+    reason.setRuleId(ruleId);
+    return reason;
+}