@cognigy/rest-api-client 0.11.0 → 0.12.0

package/build/shared/charts/descriptors/nlu/fuzzySearch.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FUZZY_SEARCH = void 0;
+const createNodeDescriptor_1 = require("../../createNodeDescriptor");
+const objectSizeValidator_1 = require("../../../helper/objectSizeValidator");
+const getFuzzySearchMaxObjectSizeInBytes = () => {
+    return parseInt(process.env.FUZZYSEARCH_MAX_OBJECT_SIZE) || 524288;
+};
+exports.FUZZY_SEARCH = createNodeDescriptor_1.createNodeDescriptor({
+    type: "fuzzySearch",
+    defaultLabel: "Fuzzy Search",
+    summary: "Performs a fuzzy search on a given collection of source data",
+    preview: {
+        key: "searchPattern",
+        type: "text"
+    },
+    tags: ["nlu", "fuzzy", "search"],
+    fields: [
+        {
+            key: "searchPattern",
+            label: "Search Pattern",
+            description: "The pattern to search for",
+            type: "cognigyText",
+            params: {
+                required: true
+            }
+        },
+        {
+            key: "items",
+            label: "Source Data",
+            description: "An array of type string or object to search through..",
+            type: "json",
+            params: {
+                required: true
+            },
+            defaultValue: `[
+	"apple",
+	"orange",
+	"banana",
+	"pear"
+]`
+        },
+        {
+            key: "isCaseSensitive",
+            label: "Is Case Sensitive",
+            defaultValue: false,
+            type: "toggle",
+            description: "Indicates whether comparisons should be case sensitive"
+        },
+        {
+            key: "includeScore",
+            label: "Include Score",
+            defaultValue: true,
+            type: "toggle",
+            description: "Whether the score should be included in the result set. A score of 1 indicates a perfect match, while a score of 0 indicates a complete mismatch"
+        },
+        {
+            key: "includeMatches",
+            label: "Include Matches",
+            defaultValue: false,
+            type: "toggle",
+            description: "Whether the matches should be included in the result set. When true, each record in the result set will include the indices of the matched characters."
+        },
+        {
+            key: "minMatchCharLength",
+            label: "Minimum Characters",
+            defaultValue: 1,
+            type: "number",
+            description: "Only the matches whose length exceeds this value will be returned.",
+            params: {
+                min: 1,
+                max: 100
+            }
+        },
+        {
+            key: "shouldSort",
+            label: "Should Sort",
+            defaultValue: true,
+            type: "toggle",
+            description: "Whether to sort the result list, by score."
+        },
+        {
+            key: "findAllMatches",
+            label: "Find All Matches",
+            defaultValue: true,
+            type: "toggle",
+            description: "When activated, the matching function will continue to the end of a search pattern even if a perfect match has already been located in the string."
+        },
+        {
+            key: "location",
+            label: "Location",
+            defaultValue: 0,
+            type: "number",
+            description: "Determines approximately where in the text is the pattern expected to be found.",
+            params: {
+                min: 0,
+                max: 100
+            }
+        },
+        {
+            key: "threshold",
+            label: "Threshold",
+            defaultValue: 0.1,
+            type: "slider",
+            description: "At what point does the match algorithm give up. A threshold of 1.0 requires a perfect match (of both letters and location), a threshold of 0.0 would match anything.",
+            params: {
+                min: 0,
+                max: 1,
+                step: 0.1
+            }
+        },
+        {
+            key: "distance",
+            label: "Distance",
+            defaultValue: 100,
+            type: "number",
+            description: "Determines how close the match must be to the fuzzy location (specified by location).",
+            params: {
+                min: 0,
+                max: 1000
+            }
+        },
+        {
+            key: "ignoreLocation",
+            label: "Ignore Location",
+            defaultValue: true,
+            type: "toggle",
+            description: "When activated, search will ignore location and distance, so it won't matter where in the string the pattern appears."
+        },
+        {
+            key: "storeLocation",
+            type: "select",
+            label: "Where to store the result",
+            params: {
+                options: [
+                    {
+                        label: "Input",
+                        value: "input"
+                    },
+                    {
+                        label: "Context",
+                        value: "context"
+                    }
+                ],
+                required: true
+            },
+            defaultValue: "input"
+        },
+        {
+            key: "inputKey",
+            type: "cognigyText",
+            label: "Input Key to store Result",
+            defaultValue: "search",
+            condition: {
+                key: "storeLocation",
+                value: "input"
+            }
+        },
+        {
+            key: "contextKey",
+            type: "cognigyText",
+            label: "Context Key to store Result",
+            defaultValue: "search",
+            condition: {
+                key: "storeLocation",
+                value: "context"
+            }
+        }
+    ],
+    sections: [
+        {
+            key: "storageOption",
+            label: "Storage Option",
+            defaultCollapsed: true,
+            fields: [
+                "storeLocation",
+                "inputKey",
+                "contextKey"
+            ]
+        },
+        {
+            key: "basicOptions",
+            label: "Basic Options",
+            defaultCollapsed: true,
+            fields: [
+                "isCaseSensitive",
+                "includeScore",
+                "includeMatches",
+                "minMatchCharLength",
+                "shouldSort",
+                "findAllMatches",
+            ]
+        },
+        {
+            key: "fuzzyOptions",
+            label: "Fuzzy Matching Options",
+            defaultCollapsed: true,
+            fields: [
+                "location",
+                "threshold",
+                "distance",
+                "ignoreLocation",
+            ]
+        }
+    ],
+    form: [
+        { type: "field", key: "searchPattern" },
+        { type: "field", key: "items" },
+        { type: "section", key: "basicOptions" },
+        { type: "section", key: "fuzzyOptions" },
+        { type: "section", key: "storageOption" }
+    ],
+    function: async ({ cognigy, config }) => {
+        const { api } = cognigy;
+        const { searchPattern, items, distance, findAllMatches, ignoreLocation, includeMatches, includeScore, isCaseSensitive, location, minMatchCharLength, shouldSort, threshold, storeLocation, inputKey, contextKey } = config;
+        if (!searchPattern)
+            throw new Error("No search pattern provided.");
+        if (!items)
+            throw new Error("No source data provided.");
+        try {
+            // reverse threshold as fuse requires it inverse (0 = perfect match, 1 = matches everything)
+            const newThreshold = 1 - threshold;
+            const options = {
+                distance,
+                findAllMatches,
+                ignoreLocation,
+                includeMatches,
+                includeScore,
+                isCaseSensitive,
+                location,
+                minMatchCharLength,
+                shouldSort,
+                threshold: newThreshold,
+            };
+            const validObjectSize = objectSizeValidator_1.validateObjectSize(items, getFuzzySearchMaxObjectSizeInBytes());
+            let result = null;
+            if (validObjectSize.valid) {
+                result = api.fuseSearch(items, options, searchPattern);
+                // reverse scores from fuse's 0 = perfect match to Cognigy's 1 = perfect match.
+                if (includeScore && result && Array.isArray(result) && result.length > 0) {
+                    result.forEach((item) => {
+                        if (item.score || item.score === 0) {
+                            item.score = 1 - item.score;
+                        }
+                    });
+                }
+            }
+            else {
+                result = {
+                    "error": `Source data file size limit (${getFuzzySearchMaxObjectSizeInBytes()} bytes) exceeded`
+                };
+            }
+            if (storeLocation === "context") {
+                api.addToContext(contextKey, result, "simple");
+            }
+            else {
+                api.addToInput(inputKey, result);
+            }
+        }
+        catch (error) {
+            if (storeLocation === "context") {
+                api.addToContext(contextKey, error, "simple");
+            }
+            else {
+                api.addToInput(inputKey, error);
+            }
+        }
+    }
+});
+//# sourceMappingURL=fuzzySearch.js.map

package/build/shared/charts/descriptors/nlu/index.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REGEX_SLOT_FILLER = exports.EXECUTE_COGNIGY_NLU = exports.ADD_LEXICON_KEYPHRASE = void 0;
+exports.FUZZY_SEARCH = exports.MATCH_PATTERN = exports.REGEX_SLOT_FILLER = exports.EXTRACT_ANSWER = exports.EXECUTE_COGNIGY_NLU = exports.ADD_LEXICON_KEYPHRASE = void 0;
 var addLexiconKeyphrase_1 = require("./addLexiconKeyphrase");
 Object.defineProperty(exports, "ADD_LEXICON_KEYPHRASE", { enumerable: true, get: function () { return addLexiconKeyphrase_1.ADD_LEXICON_KEYPHRASE; } });
 var executeCognigyNLU_1 = require("./executeCognigyNLU");
 Object.defineProperty(exports, "EXECUTE_COGNIGY_NLU", { enumerable: true, get: function () { return executeCognigyNLU_1.EXECUTE_COGNIGY_NLU; } });
+var extractAnswer_1 = require("./extractAnswer");
+Object.defineProperty(exports, "EXTRACT_ANSWER", { enumerable: true, get: function () { return extractAnswer_1.EXTRACT_ANSWER; } });
 var regexSlotFiller_1 = require("./regexSlotFiller");
 Object.defineProperty(exports, "REGEX_SLOT_FILLER", { enumerable: true, get: function () { return regexSlotFiller_1.REGEX_SLOT_FILLER; } });
+var matchPattern_1 = require("./matchPattern");
+Object.defineProperty(exports, "MATCH_PATTERN", { enumerable: true, get: function () { return matchPattern_1.MATCH_PATTERN; } });
+var fuzzySearch_1 = require("./fuzzySearch");
+Object.defineProperty(exports, "FUZZY_SEARCH", { enumerable: true, get: function () { return fuzzySearch_1.FUZZY_SEARCH; } });
 //# sourceMappingURL=index.js.map

package/build/shared/charts/descriptors/nlu/matchPattern.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MATCH_PATTERN = void 0;
+const createNodeDescriptor_1 = require("../../createNodeDescriptor");
+const patternMatcher_1 = require("./utils/patternMatcher");
+exports.MATCH_PATTERN = createNodeDescriptor_1.createNodeDescriptor({
+    type: "matchPattern",
+    defaultLabel: "Match Pattern",
+    preview: {
+        key: "patternGroupName",
+        type: "text"
+    },
+    summary: "Rule-based pattern matching for compound slot groups",
+    tags: ["nlu", "pattern", "patterns"],
+    fields: [
+        {
+            key: "patterns",
+            label: "Patterns",
+            type: "textArray",
+            description: "The patterns to match, e.g. 'from @city>origin to @city>destination'. Maximum: 20.",
+            defaultValue: ["@NUMBER>val1 or @NUMBER>val2"]
+        },
+        {
+            key: "patternGroupName",
+            label: "Pattern Group Name",
+            description: "Name for the slot compound group to be found under input.matchedPatterns.groupname",
+            type: "cognigyText",
+            defaultValue: "patternGroupName",
+            params: {
+                required: true
+            },
+        },
+        {
+            key: "alternateInput",
+            label: "Alternate Input",
+            description: "The input text to use instead of the current input text",
+            type: "cognigyText",
+        },
+        {
+            key: "detailedCompoundSlots",
+            label: "Detailed Match Results",
+            description: "Whether to store detailed results for the matched patterns or not",
+            type: "toggle",
+            defaultValue: false
+        },
+        {
+            key: "createNewSlots",
+            label: "Create New Slots",
+            description: "Whether to create new slots from tags or not",
+            type: "toggle",
+            defaultValue: false
+        },
+        {
+            key: "tagExistingSlots",
+            label: "Tag Existing Slots",
+            description: "Whether to tag existing slots or not",
+            type: "toggle",
+            defaultValue: true
+        }
+    ],
+    sections: [
+        {
+            key: "advanced",
+            label: "Advanced",
+            defaultCollapsed: true,
+            fields: [
+                "createNewSlots",
+                "tagExistingSlots",
+                "detailedCompoundSlots",
+                "alternateInput"
+            ]
+        }
+    ],
+    form: [
+        { type: "field", key: "patterns" },
+        { type: "field", key: "patternGroupName" },
+        { type: "section", key: "advanced" }
+    ],
+    function: async ({ cognigy, config }) => {
+        let { input, api } = cognigy;
+        const { patterns, patternGroupName, alternateInput, detailedCompoundSlots, createNewSlots, tagExistingSlots } = config;
+        if (!patterns || !Array.isArray(patterns) || patterns.length === 0) {
+            throw new Error("No patterns to match specified");
+        }
+        if (patterns.length > 20) {
+            throw new Error("Maximum of 20 patterns allowed");
+        }
+        // When using an alternative input, input.slots is empty - we need to call the cognigy nlu again to get the slots
+        let nluResult = {};
+        if (alternateInput) {
+            nluResult = await api.executeCognigyNLU(alternateInput, {}, input.inputId, {});
+        }
+        patternMatcher_1.patternMatcher({
+            input,
+            patterns,
+            patternGroupName,
+            detailedCompoundSlots,
+            tagExistingSlots,
+            createNewSlots,
+            nluResult
+        });
+    }
+});
+//# sourceMappingURL=matchPattern.js.map

package/build/shared/charts/descriptors/nlu/utils/patternMatcher.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternMatcher = void 0;
+/**
+ * Finds compound slots using pattern inside the user input
+ * @param input Cognigy Input Object
+ * @param patterns The patterns to check for
+ * @param patternGroupName Name for the compound group
+ * @param detailedCompoundSlots Store detailed results for compound slots
+ * @param tagExistingSlots Tag existing slots
+ * @param createNewSlots Create new slots from tags
+ * @param nluResult result from cognigy NLU since there was an alternative input
+ */
+const patternMatcher = (params) => {
+    const { input, patternGroupName, detailedCompoundSlots, tagExistingSlots, createNewSlots, nluResult } = params;
+    let { patterns } = params;
+    // prune patterns if more than 20
+    if (patterns.length > 20) {
+        patterns = patterns.slice(0, 20);
+    }
+    // firstly sort array to start with the longest patterns, as those will win
+    patterns.sort((a, b) => {
+        return b.length - a.length;
+    });
+    // we use let because we strip out found phrases later
+    let inputText = nluResult.text || input.text; // ci.processText
+    let inputSlots = nluResult.slots || input.slots;
+    const regexPatterns = [];
+    // go through patterns and create regex versions of each that is not empty string
+    patterns.forEach((pattern) => {
+        if (pattern) {
+            // set parsedPattern to pattern in case there are no slots
+            let parsedPattern = pattern;
+            // match all mentioned slots in the pattern
+            const foundSlots = pattern.match(/\@[\w>]+/g);
+            const tags = [];
+            const slots = [];
+            // if there are slots, process them
+            if (Array.isArray(foundSlots) && foundSlots.length > 0) {
+                foundSlots.forEach((slot) => {
+                    // splits tags from slots
+                    const split = slot.split(">");
+                    const slotName = split[0].replace("@", "");
+                    slots.push(slotName);
+                    // if there is a tag (SLOT>TAG), remember it
+                    if (split.length === 2)
+                        tags.push(split[1]);
+                    else
+                        tags.push("");
+                    const slotValues = [];
+                    if (inputSlots[slotName]) {
+                        switch (slotName) {
+                            case "DATE":
+                                inputSlots.DATE.forEach((s) => {
+                                    // just add the number
+                                    if (s.start)
+                                        slotValues.push(s["text"]);
+                                });
+                                break;
+                            case "TEMPERATURE":
+                                inputSlots.TEMPERATURE.forEach((s) => {
+                                    // just add the number
+                                    slotValues.push(s.value);
+                                });
+                                break;
+                            case "AGE":
+                                inputSlots.AGE.forEach((s) => {
+                                    // just add the number
+                                    slotValues.push(s.value);
+                                });
+                                break;
+                            case "PERCENTAGE":
+                                inputSlots.PERCENTAGE.forEach((s) => {
+                                    // just add the number
+                                    slotValues.push(s + "%");
+                                    slotValues.push(s + " percent");
+                                });
+                                break;
+                            case "NUMBER":
+                                inputSlots.NUMBER.forEach((s) => {
+                                    // just add the number
+                                    slotValues.push(s);
+                                });
+                                break;
+                            default:
+                                inputSlots[slotName].forEach((s) => {
+                                    // it's important to use the synonym, as this is the text that was actually found
+                                    slotValues.push(s.synonym);
+                                });
+                        }
+                        const slotRegex = slotValues.join("|");
+                        // replace the slots name with the list of actually found entites for this slot
+                        parsedPattern = parsedPattern.replace(new RegExp(`${slot}`, "g"), `(${slotRegex})`);
+                    }
+                });
+            }
+            regexPatterns.push({
+                "pattern": pattern,
+                "parsedPattern": parsedPattern,
+                "tags": tags,
+                "slots": slots
+            });
+        }
+    });
+    const compoundGroups = [];
+    // go through all created patterns and test them
+    regexPatterns.forEach((pattern) => {
+        let result;
+        const regExp = new RegExp(pattern.parsedPattern, "gi");
+        const regexMatches = [];
+        while (result = regExp.exec(inputText)) {
+            regexMatches.push(result);
+        }
+        regexMatches.forEach((m) => {
+            inputText = inputText.replace(m[0], "");
+        });
+        if (regexMatches.length > 0) {
+            // we found a match for this pattern!
+            regexMatches.forEach((matches, mi) => {
+                // set up a compoundGroup scaffold, just in case we need it
+                const matchedPatternGroup = {
+                    "matchedPhrase": matches[0],
+                    "components": []
+                };
+                if (!detailedCompoundSlots)
+                    delete matchedPatternGroup.components;
+                // iterate through matches, starting at the first group result ([0] is the full match)
+                for (let i = 1; i < matches.length; i++) {
+                    let originalSlot = null;
+                    switch (pattern.slots[i - 1]) {
+                        case "PERCENTAGE":
+                            originalSlot = Number(matches[i].replace(new RegExp("[^0-9]", "gi"), ""));
+                            break;
+                        case "TEMPERATURE":
+                        case "AGE":
+                        case "NUMBER":
+                            originalSlot = Number(matches[i]);
+                            break;
+                        case "DATE":
+                            // @ts-ignore
+                            const dateSlot = inputSlots.DATE.find(e => (e["text"] === matches[i]));
+                            originalSlot = (dateSlot === null || dateSlot === void 0 ? void 0 : dateSlot.start) || (dateSlot === null || dateSlot === void 0 ? void 0 : dateSlot.end);
+                            break;
+                        default:
+                            originalSlot = inputSlots[pattern.slots[i - 1]].find(e => (e.synonym) ? e.synonym.toLowerCase() === matches[i].toLowerCase() : false);
+                    }
+                    // create compound groups
+                    if (detailedCompoundSlots) {
+                        const components = {
+                            "slot": pattern.slots[i - 1],
+                            "value": originalSlot.keyphrase || originalSlot
+                        };
+                        if (pattern.tags[i - 1])
+                            components["tag"] = pattern.tags[i - 1];
+                        else
+                            components["tag"] = null;
+                        matchedPatternGroup.components.push(components);
+                    }
+                    else {
+                        if (pattern.tags[i - 1])
+                            matchedPatternGroup[pattern.tags[i - 1]] = (originalSlot === null || originalSlot === void 0 ? void 0 : originalSlot.keyphrase) || originalSlot;
+                        else
+                            matchedPatternGroup[pattern.slots[i - 1]] = originalSlot || originalSlot.keyphrase;
+                    }
+                    if (pattern.tags[i - 1]) {
+                        if (createNewSlots) {
+                            if (inputSlots[pattern.tags[i - 1]]) {
+                                inputSlots[pattern.tags[i - 1]].push(originalSlot);
+                            }
+                            else
+                                inputSlots[pattern.tags[i - 1]] = [originalSlot];
+                        }
+                        if (tagExistingSlots) {
+                            inputSlots[pattern.slots[i - 1]].forEach((s) => {
+                                var _a, _b;
+                                if (((_a = s === null || s === void 0 ? void 0 : s.synonym) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === ((_b = matches[i]) === null || _b === void 0 ? void 0 : _b.toLowerCase())) {
+                                    s["tags"] = (Array.isArray(s["tags"])) ? s["tags"].push(pattern.tags[i - 1]) : [pattern.tags[i - 1]];
+                                }
+                            });
+                        }
+                    }
+                }
+                compoundGroups.push(matchedPatternGroup);
+            });
+        }
+    });
+    if (!input["matchedPatterns"])
+        input["matchedPatterns"] = {};
+    if (compoundGroups && Array.isArray(compoundGroups) && compoundGroups.length > 0) {
+        input["matchedPatterns"][patternGroupName] = compoundGroups;
+    }
+    if (compoundGroups && compoundGroups.length === 0 && (typeof input["matchedPatterns"] !== 'object' || Object.keys(input["matchedPatterns"]).length === 0))
+        delete input["matchedPatterns"];
+    return input;
+};
+exports.patternMatcher = patternMatcher;
+//# sourceMappingURL=patternMatcher.js.map

package/build/shared/charts/descriptors/profile/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OVERWRITE_ANALYTICS = exports.BLIND_MODE = exports.UPDATE_PROFILE = exports.MERGE_PROFILE = exports.DELETE_PROFILE = exports.DEACTIVATE_PROFILE = exports.COMPLETE_GOAL = exports.ACTIVATE_PROFILE = void 0;
+exports.REQUEST_RATING = exports.SET_RATING = exports.OVERWRITE_ANALYTICS = exports.BLIND_MODE = exports.UPDATE_PROFILE = exports.MERGE_PROFILE = exports.DELETE_PROFILE = exports.DEACTIVATE_PROFILE = exports.COMPLETE_GOAL = exports.ACTIVATE_PROFILE = void 0;
 var activateProfile_1 = require("./activateProfile");
 Object.defineProperty(exports, "ACTIVATE_PROFILE", { enumerable: true, get: function () { return activateProfile_1.ACTIVATE_PROFILE; } });
 var completeGoal_1 = require("./completeGoal");
@@ -17,4 +17,8 @@ var blindMode_1 = require("./blindMode");
 Object.defineProperty(exports, "BLIND_MODE", { enumerable: true, get: function () { return blindMode_1.BLIND_MODE; } });
 var overwriteAnalytics_1 = require("./overwriteAnalytics");
 Object.defineProperty(exports, "OVERWRITE_ANALYTICS", { enumerable: true, get: function () { return overwriteAnalytics_1.OVERWRITE_ANALYTICS; } });
+var setRating_1 = require("./setRating");
+Object.defineProperty(exports, "SET_RATING", { enumerable: true, get: function () { return setRating_1.SET_RATING; } });
+var requestRating_1 = require("./requestRating");
+Object.defineProperty(exports, "REQUEST_RATING", { enumerable: true, get: function () { return requestRating_1.REQUEST_RATING; } });
 //# sourceMappingURL=index.js.map