@kenji71089/evaluation 0.0.1

package/lib/evaluation.mjs

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Evaluator = void 0;
+exports.EvaluationID = EvaluationID;
+const errors_1 = require("./errors");
+const clause_pb_1 = require("./proto/feature/clause_pb");
+const evaluation_pb_1 = require("./proto/feature/evaluation_pb");
+const reason_pb_1 = require("./proto/feature/reason_pb");
+const variation_pb_1 = require("./proto/feature/variation_pb");
+const ruleEvaluator_1 = require("./ruleEvaluator");
+const strategyEvaluator_1 = require("./strategyEvaluator");
+const userEvaluation_1 = require("./userEvaluation");
+const modelFactory_1 = require("./modelFactory");
+const SECONDS_TO_RE_EVALUATE_ALL = 30 * 24 * 60 * 60; // 30 days
+const SECONDS_FOR_ADJUSTMENT = 10; // 10 seconds
+function EvaluationID(featureID, featureVersion, userID) {
+    return `${featureID}:${featureVersion}:${userID}`;
+}
+class Evaluator {
+    ruleEvaluator;
+    strategyEvaluator;
+    constructor() {
+        this.ruleEvaluator = new ruleEvaluator_1.RuleEvaluator();
+        this.strategyEvaluator = new strategyEvaluator_1.StrategyEvaluator();
+    }
+    async evaluateFeatures(features, user, mapSegmentUsers, targetTag) {
+        return this.evaluate(features, user, mapSegmentUsers, false, targetTag);
+    }
+    // GetPrerequisiteDownwards gets the features specified as prerequisite by the targetFeatures.
+    getPrerequisiteDownwards(targetFeatures, allFeatures) {
+        const allFeaturesMap = new Map();
+        for (const feature of allFeatures) {
+            allFeaturesMap.set(feature.getId(), feature);
+        }
+        const dependedOnTargets = getFeaturesDependedOnTargets(targetFeatures, allFeaturesMap);
+        return Object.values(dependedOnTargets);
+    }
+    evaluateFeaturesByEvaluatedAt(features, user, mapSegmentUsers, prevUEID, evaluatedAt, userAttributesUpdated, targetTag) {
+        if (prevUEID === '') {
+            return this.evaluate(features, user, mapSegmentUsers, true, targetTag);
+        }
+        const now = Math.floor(Date.now() / 1000);
+        if (evaluatedAt < now - SECONDS_TO_RE_EVALUATE_ALL) {
+            return this.evaluate(features, user, mapSegmentUsers, true, targetTag);
+        }
+        const adjustedEvalAt = evaluatedAt - SECONDS_FOR_ADJUSTMENT;
+        const updatedFeatures = features.filter((feature) => feature.getUpdatedAt() > adjustedEvalAt ||
+            (userAttributesUpdated && feature.getRulesList().length > 0));
+        // If the UserEvaluationsID has changed, but both User Attributes and Feature Flags have not been updated,
+        // it is considered unusual and a force update should be performed.
+        if (updatedFeatures.length === 0) {
+            return this.evaluate(features, user, mapSegmentUsers, true, targetTag);
+        }
+        const evalTargets = this.getEvalFeatures(updatedFeatures, features);
+        return this.evaluate(evalTargets, user, mapSegmentUsers, false, targetTag);
+    }
+    evaluate(features, user, mapSegmentUsers, forceUpdate, targetTag) {
+        const flagVariations = {};
+        // fs need to be sorted in order from upstream to downstream.
+        const sortedFeatures = topologicalSort(features);
+        const evaluations = [];
+        const archivedIDs = [];
+        for (const feature of sortedFeatures) {
+            if (feature.getArchived()) {
+                // To keep response size small, the feature flags archived long time ago are excluded.
+                if (!this.isArchivedBeforeLastThirtyDays(feature)) {
+                    archivedIDs.push(feature.getId());
+                }
+                continue;
+            }
+            const segmentUsers = this.listSegmentIDs(feature).flatMap((id) => mapSegmentUsers.get(id) || []);
+            const [reason, variation] = this.assignUser(feature, user, segmentUsers, flagVariations);
+            // VariationId is used to check if prerequisite flag's result is what user expects it to be.
+            flagVariations[feature.getId()] = variation.getId();
+            // When the tag is set in the request,
+            // it will return only the evaluations of flags that match the tag configured on the dashboard.
+            // When empty, it will return all the evaluations of the flags in the environment.
+            if (targetTag !== '' && !this.tagExist(feature.getTagsList(), targetTag)) {
+                continue;
+            }
+            const evaluationID = EvaluationID(feature.getId(), feature.getVersion(), user.getId());
+            const evaluation = new evaluation_pb_1.Evaluation();
+            evaluation.setId(evaluationID);
+            evaluation.setFeatureId(feature.getId());
+            evaluation.setFeatureVersion(feature.getVersion());
+            evaluation.setUserId(user.getId());
+            evaluation.setVariationId(variation.getId());
+            evaluation.setVariationName(variation.getName());
+            evaluation.setVariationValue(variation.getValue());
+            // Deprecated
+            // FIXME: Remove the Variation when is no longer being used.
+            // For security reasons, we should remove the variation description.
+            // We copy the variation object to avoid race conditions when removing
+            // the description directly from the `variation`
+            const copyVariation = new variation_pb_1.Variation();
+            copyVariation.setId(variation.getId());
+            copyVariation.setName(variation.getName());
+            copyVariation.setValue(variation.getValue());
+            evaluation.setVariation(copyVariation);
+            evaluation.setReason(reason);
+            evaluations.push(evaluation);
+        }
+        const id = (0, userEvaluation_1.UserEvaluationsID)(user.getId(), arrayToRecord(user.getDataMap().toArray()), features);
+        const userEvaluations = (0, userEvaluation_1.NewUserEvaluations)(id, evaluations, archivedIDs, forceUpdate);
+        return userEvaluations;
+    }
+    tagExist(tags, target) {
+        return tags.includes(target);
+    }
+    /*
+    IsArchivedBeforeLastThirtyDays returns a bool value
+    indicating whether the feature flag was archived within the last thirty days.
+    */
+    isArchivedBeforeLastThirtyDays(feature) {
+        if (!feature.getArchived()) {
+            return false;
+        }
+        const now = Math.floor(Date.now() / 1000);
+        return feature.getUpdatedAt() < now - SECONDS_TO_RE_EVALUATE_ALL;
+    }
+    listSegmentIDs(feature) {
+        const mapIDs = new Set();
+        for (const rule of feature.getRulesList()) {
+            for (const clause of rule.getClausesList()) {
+                if (clause.getOperator() === clause_pb_1.Clause.Operator.SEGMENT) {
+                    clause.getValuesList().forEach((value) => mapIDs.add(value));
+                }
+            }
+        }
+        return Array.from(mapIDs);
+    }
+    assignUser(feature, user, segmentUsers, flagVariations) {
+        for (const pf of feature.getPrerequisitesList()) {
+            const variationId = flagVariations[pf.getFeatureId()];
+            if (!variationId) {
+                throw errors_1.EVALUATOR_ERRORS.PrerequisiteVariationNotFound;
+            }
+            if (pf.getVariationId() !== variationId) {
+                if (feature.getOffVariation() !== '') {
+                    const variation = this.findVariation(feature.getOffVariation(), feature.getVariationsList());
+                    const reason = (0, modelFactory_1.createReason)('', reason_pb_1.Reason.Type.PREREQUISITE);
+                    return [reason, variation];
+                }
+            }
+        }
+        // It doesn't assign the user in case of the feature is disabled and OffVariation is not set
+        if (!feature.getEnabled() && feature.getOffVariation() !== '') {
+            const variation = this.findVariation(feature.getOffVariation(), feature.getVariationsList());
+            const reason = (0, modelFactory_1.createReason)('', reason_pb_1.Reason.Type.OFF_VARIATION);
+            return [reason, variation];
+        }
+        // evaluate from top to bottom, return if one rule matches
+        // evaluate targeting rules
+        for (const target of feature.getTargetsList()) {
+            if (target.getUsersList().includes(user.getId())) {
+                const variation = this.findVariation(target.getVariation(), feature.getVariationsList());
+                const reason = (0, modelFactory_1.createReason)('', reason_pb_1.Reason.Type.TARGET);
+                return [reason, variation];
+            }
+        }
+        // evaluate ruleset
+        const rule = this.ruleEvaluator.evaluate(feature.getRulesList(), user, segmentUsers, flagVariations);
+        if (rule) {
+            const strategy = rule.getStrategy();
+            if (strategy == undefined) {
+                throw errors_1.EVALUATOR_ERRORS.StrategyNotFound;
+            }
+            const variation = this.strategyEvaluator.evaluate(strategy, user.getId(), feature.getVariationsList(), feature.getId(), feature.getSamplingSeed());
+            const reason = (0, modelFactory_1.createReason)(rule.getId(), reason_pb_1.Reason.Type.RULE);
+            return [reason, variation];
+        }
+        // use default strategy
+        const defaultStrategy = feature.getDefaultStrategy();
+        if (defaultStrategy == undefined) {
+            throw errors_1.EVALUATOR_ERRORS.DefaultStrategyNotFound;
+        }
+        const variation = this.strategyEvaluator.evaluate(defaultStrategy, user.getId(), feature.getVariationsList(), feature.getId(), feature.getSamplingSeed());
+        const reason = (0, modelFactory_1.createReason)('', reason_pb_1.Reason.Type.DEFAULT);
+        return [reason, variation];
+    }
+    getEvalFeatures(targetFeatures, allFeatures) {
+        const allFeaturesMap = new Map();
+        for (const feature of allFeatures) {
+            allFeaturesMap.set(feature.getId(), feature);
+        }
+        const evals1 = getFeaturesDependedOnTargets(targetFeatures, allFeaturesMap);
+        const evals2 = getFeaturesDependsOnTargets(targetFeatures, allFeaturesMap);
+        const mergedEvals = { ...evals1, ...evals2 };
+        return Object.values(mergedEvals);
+    }
+    findVariation(v, variations) {
+        const variation = variations.find((variation) => variation.getId() === v);
+        if (!variation) {
+            throw errors_1.EVALUATOR_ERRORS.VariationNotFound;
+        }
+        return variation;
+    }
+}
+exports.Evaluator = Evaluator;
+var Mark;
+(function (Mark) {
+    Mark[Mark["Unvisited"] = 0] = "Unvisited";
+    Mark[Mark["Temporary"] = 1] = "Temporary";
+    Mark[Mark["Permanently"] = 2] = "Permanently";
+})(Mark || (Mark = {}));
+// FeatureIDsDependsOn returns the ids of the features that this feature depends on.
+function featureIDsDependsOn(feature) {
+    const ids = [];
+    // Iterate over prerequisites and add their FeatureId
+    feature.getPrerequisitesList().forEach((p) => {
+        ids.push(p.getFeatureId());
+    });
+    // Iterate over rules and collect ids from clauses where the operator is FEATURE_FLAG
+    feature.getRulesList().forEach((rule) => {
+        rule.getClausesList().forEach((clause) => {
+            if (clause.getOperator() === clause_pb_1.Clause.Operator.FEATURE_FLAG) {
+                ids.push(clause.getAttribute());
+            }
+        });
+    });
+    return ids;
+}
+// Error types
+class ErrCycleExists extends Error {
+    constructor() {
+        super('Cycle exists in the graph');
+    }
+}
+class ErrFeatureNotFound extends Error {
+    constructor() {
+        super('Feature not found');
+    }
+}
+// Topological sort function
+function topologicalSort(features) {
+    const marks = {};
+    const mapFeatures = {};
+    features.forEach((f) => {
+        marks[f.getId()] = Mark.Unvisited;
+        mapFeatures[f.getId()] = f;
+    });
+    const sortedFeatures = [];
+    const sort = (f) => {
+        const fId = f.getId();
+        if (marks[fId] === Mark.Permanently)
+            return;
+        if (marks[fId] === Mark.Temporary) {
+            throw new ErrCycleExists();
+        }
+        marks[fId] = Mark.Temporary;
+        const dependentFeatureIds = featureIDsDependsOn(f);
+        for (const fid of dependentFeatureIds) {
+            const pf = mapFeatures[fid];
+            if (!pf) {
+                throw new ErrFeatureNotFound();
+            }
+            sort(pf);
+        }
+        marks[fId] = Mark.Permanently;
+        sortedFeatures.push(f);
+    };
+    // Process each feature
+    for (const f of features) {
+        if (marks[f.getId()] === Mark.Unvisited) {
+            sort(f);
+        }
+    }
+    return sortedFeatures;
+}
+// getFeaturesDependedOnTargets returns the features that are depended on the target features.
+// targetFeatures are included in the result.
+function getFeaturesDependedOnTargets(targets, all) {
+    const evals = {};
+    const dfs = (f) => {
+        // If the feature is already in the evals map, skip
+        if (evals[f.getId()])
+            return;
+        // Add feature to evals
+        evals[f.getId()] = f;
+        // Get dependent features recursively
+        const featureDependencies = featureIDsDependsOn(f);
+        featureDependencies.forEach((fid) => {
+            const target = all.get(fid);
+            if (target !== undefined) {
+                dfs(target);
+            }
+        });
+    };
+    // Start DFS for each target feature
+    targets.forEach((f) => dfs(f));
+    return evals;
+}
+// getFeaturesDependsOnTargets returns the features that depend on the target features.
+// targetFeatures are included in the result.
+function getFeaturesDependsOnTargets(targets, all) {
+    const evals = {};
+    // Mark target features in the evals map initially
+    targets.forEach((f) => {
+        evals[f.getId()] = f;
+    });
+    // Depth-first search to determine if a feature depends on a target feature
+    const dfs = (f) => {
+        if (evals[f.getId()]) {
+            return true;
+        }
+        const featureDependencies = featureIDsDependsOn(f);
+        for (const fid of featureDependencies) {
+            const dependentFeature = all.get(fid);
+            if (dependentFeature && dfs(dependentFeature)) {
+                // If the feature depends on one of the target features, add it to evals
+                evals[f.getId()] = f;
+                return true;
+            }
+        }
+        return false;
+    };
+    // Apply DFS for all features, except target features
+    all.forEach((f) => {
+        dfs(f);
+    });
+    return evals;
+}
+function arrayToRecord(arr) {
+    return arr.reduce((acc, [key, value]) => {
+        acc[key] = value;
+        return acc;
+    }, {});
+}

package/lib/google/api/annotations_pb.d.ts

@@ -0,0 +1,8 @@
+// package: google.api
+// file: google/api/annotations.proto
+
+import * as jspb from 'google-protobuf';
+import * as google_api_http_pb from '../../google/api/http_pb';
+
+export const http: jspb.ExtensionFieldInfo<google_api_http_pb.HttpRule>;
+

package/lib/google/api/annotations_pb.js

@@ -0,0 +1,40 @@
+"use strict";
+
+// source: google/api/annotations.proto
+/**
+ * @fileoverview
+ * @enhanceable
+ * @suppress {missingRequire} reports error on implicit type usages.
+ * @suppress {messageConventions} JS Compiler reports an error if a variable or
+ *     field starts with 'MSG_' and isn't a translatable message.
+ * @public
+ */
+// GENERATED CODE -- DO NOT EDIT!
+
+// @ts-nocheck
+
+var jspb = require('google-protobuf');
+var goog = jspb;
+var global = typeof globalThis !== 'undefined' && globalThis || typeof window !== 'undefined' && window || typeof global !== 'undefined' && global || typeof self !== 'undefined' && self || function () {
+  return this;
+}.call(null) || Function('return this')();
+var google_api_http_pb = require('../../google/api/http_pb.js');
+goog.object.extend(proto, google_api_http_pb);
+var google_protobuf_descriptor_pb = require('google-protobuf/google/protobuf/descriptor_pb.js');
+goog.object.extend(proto, google_protobuf_descriptor_pb);
+goog.exportSymbol('proto.google.api.http', null, global);
+
+/**
+ * A tuple of {field number, class constructor} for the extension
+ * field named `http`.
+ * @type {!jspb.ExtensionFieldInfo<!proto.google.api.HttpRule>}
+ */
+proto.google.api.http = new jspb.ExtensionFieldInfo(72295728, {
+  http: 0
+}, google_api_http_pb.HttpRule, /** @type {?function((boolean|undefined),!jspb.Message=): !Object} */
+google_api_http_pb.HttpRule.toObject, 0);
+google_protobuf_descriptor_pb.MethodOptions.extensionsBinary[72295728] = new jspb.ExtensionFieldBinaryInfo(proto.google.api.http, jspb.BinaryReader.prototype.readMessage, jspb.BinaryWriter.prototype.writeMessage, google_api_http_pb.HttpRule.serializeBinaryToWriter, google_api_http_pb.HttpRule.deserializeBinaryFromReader, false);
+// This registers the extension field with the extended class, so that
+// toObject() will function correctly.
+google_protobuf_descriptor_pb.MethodOptions.extensions[72295728] = proto.google.api.http;
+goog.object.extend(exports, proto.google.api);

package/lib/google/api/annotations_pb.mjs

@@ -0,0 +1,54 @@
+// source: google/api/annotations.proto
+/**
+ * @fileoverview
+ * @enhanceable
+ * @suppress {missingRequire} reports error on implicit type usages.
+ * @suppress {messageConventions} JS Compiler reports an error if a variable or
+ *     field starts with 'MSG_' and isn't a translatable message.
+ * @public
+ */
+// GENERATED CODE -- DO NOT EDIT!
+ 
+// @ts-nocheck
+
+var jspb = require('google-protobuf');
+var goog = jspb;
+var global =
+    (typeof globalThis !== 'undefined' && globalThis) ||
+    (typeof window !== 'undefined' && window) ||
+    (typeof global !== 'undefined' && global) ||
+    (typeof self !== 'undefined' && self) ||
+    (function () { return this; }).call(null) ||
+    Function('return this')();
+
+var google_api_http_pb = require('../../google/api/http_pb.js');
+goog.object.extend(proto, google_api_http_pb);
+var google_protobuf_descriptor_pb = require('google-protobuf/google/protobuf/descriptor_pb.js');
+goog.object.extend(proto, google_protobuf_descriptor_pb);
+goog.exportSymbol('proto.google.api.http', null, global);
+
+/**
+ * A tuple of {field number, class constructor} for the extension
+ * field named `http`.
+ * @type {!jspb.ExtensionFieldInfo<!proto.google.api.HttpRule>}
+ */
+proto.google.api.http = new jspb.ExtensionFieldInfo(
+    72295728,
+    {http: 0},
+    google_api_http_pb.HttpRule,
+     /** @type {?function((boolean|undefined),!jspb.Message=): !Object} */ (
+         google_api_http_pb.HttpRule.toObject),
+    0);
+
+google_protobuf_descriptor_pb.MethodOptions.extensionsBinary[72295728] = new jspb.ExtensionFieldBinaryInfo(
+    proto.google.api.http,
+    jspb.BinaryReader.prototype.readMessage,
+    jspb.BinaryWriter.prototype.writeMessage,
+    google_api_http_pb.HttpRule.serializeBinaryToWriter,
+    google_api_http_pb.HttpRule.deserializeBinaryFromReader,
+    false);
+// This registers the extension field with the extended class, so that
+// toObject() will function correctly.
+google_protobuf_descriptor_pb.MethodOptions.extensions[72295728] = proto.google.api.http;
+
+goog.object.extend(exports, proto.google.api);

package/lib/google/api/annotations_pb_service.d.ts

@@ -0,0 +1,3 @@
+// package: google.api
+// file: google/api/annotations.proto
+

package/lib/google/api/annotations_pb_service.js

@@ -0,0 +1,3 @@
+// package: google.api
+// file: google/api/annotations.proto
+"use strict";

package/lib/google/api/annotations_pb_service.mjs

@@ -0,0 +1,3 @@
+// package: google.api
+// file: google/api/annotations.proto
+

package/lib/google/api/http_pb.d.ts

@@ -0,0 +1,132 @@
+// package: google.api
+// file: google/api/http.proto
+
+import * as jspb from 'google-protobuf';
+
+export class Http extends jspb.Message {
+  clearRulesList(): void;
+  getRulesList(): Array<HttpRule>;
+  setRulesList(value: Array<HttpRule>): void;
+  addRules(value?: HttpRule, index?: number): HttpRule;
+
+  getFullyDecodeReservedExpansion(): boolean;
+  setFullyDecodeReservedExpansion(value: boolean): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Http.AsObject;
+  static toObject(includeInstance: boolean, msg: Http): Http.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: Http, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Http;
+  static deserializeBinaryFromReader(message: Http, reader: jspb.BinaryReader): Http;
+}
+
+export namespace Http {
+  export type AsObject = {
+    rulesList: Array<HttpRule.AsObject>,
+    fullyDecodeReservedExpansion: boolean,
+  }
+}
+
+export class HttpRule extends jspb.Message {
+  getSelector(): string;
+  setSelector(value: string): void;
+
+  hasGet(): boolean;
+  clearGet(): void;
+  getGet(): string;
+  setGet(value: string): void;
+
+  hasPut(): boolean;
+  clearPut(): void;
+  getPut(): string;
+  setPut(value: string): void;
+
+  hasPost(): boolean;
+  clearPost(): void;
+  getPost(): string;
+  setPost(value: string): void;
+
+  hasDelete(): boolean;
+  clearDelete(): void;
+  getDelete(): string;
+  setDelete(value: string): void;
+
+  hasPatch(): boolean;
+  clearPatch(): void;
+  getPatch(): string;
+  setPatch(value: string): void;
+
+  hasCustom(): boolean;
+  clearCustom(): void;
+  getCustom(): CustomHttpPattern | undefined;
+  setCustom(value?: CustomHttpPattern): void;
+
+  getBody(): string;
+  setBody(value: string): void;
+
+  clearAdditionalBindingsList(): void;
+  getAdditionalBindingsList(): Array<HttpRule>;
+  setAdditionalBindingsList(value: Array<HttpRule>): void;
+  addAdditionalBindings(value?: HttpRule, index?: number): HttpRule;
+
+  getPatternCase(): HttpRule.PatternCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): HttpRule.AsObject;
+  static toObject(includeInstance: boolean, msg: HttpRule): HttpRule.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: HttpRule, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): HttpRule;
+  static deserializeBinaryFromReader(message: HttpRule, reader: jspb.BinaryReader): HttpRule;
+}
+
+export namespace HttpRule {
+  export type AsObject = {
+    selector: string,
+    get: string,
+    put: string,
+    post: string,
+    pb_delete: string,
+    patch: string,
+    custom?: CustomHttpPattern.AsObject,
+    body: string,
+    additionalBindingsList: Array<HttpRule.AsObject>,
+  }
+
+  export enum PatternCase {
+    PATTERN_NOT_SET = 0,
+    GET = 2,
+    PUT = 3,
+    POST = 4,
+    DELETE = 5,
+    PATCH = 6,
+    CUSTOM = 8,
+  }
+}
+
+export class CustomHttpPattern extends jspb.Message {
+  getKind(): string;
+  setKind(value: string): void;
+
+  getPath(): string;
+  setPath(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CustomHttpPattern.AsObject;
+  static toObject(includeInstance: boolean, msg: CustomHttpPattern): CustomHttpPattern.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: CustomHttpPattern, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CustomHttpPattern;
+  static deserializeBinaryFromReader(message: CustomHttpPattern, reader: jspb.BinaryReader): CustomHttpPattern;
+}
+
+export namespace CustomHttpPattern {
+  export type AsObject = {
+    kind: string,
+    path: string,
+  }
+}
+