8542469313

Committed 03 Apr 2024 04:47PM UTC coverage: 84.48%. Remained the same

Build # 8542469313

Build Type

Pull #4640

github

Committed by

web-flow

Commit Message

Merge da51f1d5a into 7ceb965f3

Pull Request Pull Request #4640: chore: Moved @types/jsonwebtoken to dependencies

Run Details

9986 of 13105 branches covered (76.2%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

5 existing lines in 1 file now uncovered.

20415 of 22881 relevant lines covered (89.22%)

7391.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.28

/libraries/botbuilder-dialogs/src/memory/dialogStateManager.ts

/**
 * @module botbuilder-dialogs
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */

import { ComponentMemoryScopes, isComponentMemoryScopes } from './componentMemoryScopes';
import { ComponentPathResolvers, isComponentPathResolvers } from './componentPathResolvers';
import { ComponentRegistration } from 'botbuilder-core';
import { DialogContext } from '../dialogContext';
import { DialogPath } from './dialogPath';
import { DialogsComponentRegistration } from '../dialogsComponentRegistration';
import { MemoryScope } from './scopes';
import { PathResolver } from './pathResolvers';

export interface DialogStateManagerConfiguration {
    /**
     * List of path resolvers used to evaluate memory paths.
     */
    readonly pathResolvers: PathResolver[];

    /**
     * List of the supported memory scopes.
     */
    readonly memoryScopes: MemoryScope[];
}

const PATH_TRACKER = 'dialog._tracker.paths';

const DIALOG_STATE_MANAGER_CONFIGURATION = 'DialogStateManagerConfiguration';

/**
 * The DialogStateManager manages memory scopes and path resolvers.
 *
 * @remarks
 * MemoryScopes are named root level objects, which can exist either in the dialog context or off
 * of turn state. Path resolvers allow for shortcut behavior for mapping things like
 * $foo -> dialog.foo
 */
export class DialogStateManager {
    private readonly dialogContext: DialogContext;

    /**
     * Initializes a new instance of the [DialogStateManager](xref:botbuilder-dialogs.DialogStateManager) class.
     *
     * @param dc The dialog context for the current turn of the conversation.
     * @param configuration Configuration for the dialog state manager.
     */
    constructor(dc: DialogContext, configuration?: DialogStateManagerConfiguration) {
        ComponentRegistration.add(new DialogsComponentRegistration());

        this.dialogContext = dc;
        this.configuration = configuration ?? dc.context.turnState.get(DIALOG_STATE_MANAGER_CONFIGURATION);

        if (!this.configuration) {
            this.configuration = { memoryScopes: [], pathResolvers: [] };

            // get all of the component memory scopes.
            ComponentRegistration.components
                .filter((component: ComponentRegistration) => isComponentMemoryScopes(component))
                .forEach((component: ComponentMemoryScopes) => {
                    this.configuration.memoryScopes.push(...component.getMemoryScopes());
                });

            // merge in turn state memory scopes
            const memoryScopes = dc.context.turnState.get<MemoryScope[]>('memoryScopes') ?? [];
            this.configuration.memoryScopes.push(...memoryScopes);

            // get all of the component path resolvers.
            ComponentRegistration.components
                .filter((component: ComponentRegistration) => isComponentPathResolvers(component))
                .forEach((component: ComponentPathResolvers) => {
                    this.configuration.pathResolvers.push(...component.getPathResolvers());
                });

            // merge in turn state ones path resolvers
            const pathResolvers = dc.context.turnState.get<PathResolver[]>('pathResolvers') ?? [];
            this.configuration.pathResolvers.push(...pathResolvers);

            // cache for any other new dialogStateManager instances in this turn
            dc.context.turnState.set(DIALOG_STATE_MANAGER_CONFIGURATION, this.configuration);
        }
    }

    /**
     * Gets or sets the configured path resolvers and memory scopes for the dialog state manager.
     *
     * @remarks
     * There is a single set of configuration information for a given chain of dialog contexts.
     * Assigning a new configuration to any DialogStateManager within the chain will update the
     * configuration for the entire chain.
     */
    configuration: DialogStateManagerConfiguration;

    /**
     * Get the value from memory using path expression.
     *
     * @remarks
     * This always returns a CLONE of the memory, any modifications to the result will not affect memory.
     * @template T The value type to return.
     * @param pathExpression Path expression to use.
     * @param defaultValue (Optional) default value to use if the path isn't found. May be a function that returns the default value to use.
     * @returns The found value or undefined if not found and no `defaultValue` specified.
     */
    getValue<T = any>(pathExpression: string, defaultValue?: T | (() => T)): T {
        function returnDefault(): T {
            return typeof defaultValue == 'function' ? (defaultValue as Function)() : defaultValue;
        }

        // Get path segments
        const segments = this.parsePath(this.transformPath(pathExpression));
        if (segments.length < 1) {
            return returnDefault();
        }

        // Get memory scope to search over
        const scope = this.getMemoryScope(segments[0].toString());
        if (scope == undefined) {
            console.warn(`DialogStateManager.getValue: a scope of '${segments[0]}' wasn't found for '${pathExpression}'.`);
            return returnDefault();
        }

        // Search over path
        const memory = this.resolveSegments(scope.getMemory(this.dialogContext), segments, false);

        // Return default value if nothing found
        return memory != undefined ? memory : returnDefault();
    }

    /**
     * Set memory to value.
     *
     * @param pathExpression Path to memory.
     * @param value Value to set.
     */
    setValue(pathExpression: string, value: any): void {
        // Get path segments
        const tpath = this.transformPath(pathExpression);
        const segments = this.parsePath(tpath);
        if (segments.length < 1) {
            throw new Error("DialogStateManager.setValue: path wasn't specified.");
        }

        // Track changes
        this.trackChange(tpath);

        // Get memory scope to update
        const scope = this.getMemoryScope(segments[0].toString());
        if (scope == undefined) {
            throw new Error(`DialogStateManager.setValue: a scope of '${segments[0]}' wasn't found.`);
        }

        // Update memory
        if (segments.length > 1) {
            // Find value up to last key
            // - Missing paths will be populated as needed
            let memory = scope.getMemory(this.dialogContext);
            memory = this.resolveSegments(memory, segments, true);

            // Update value
            let key = segments[segments.length - 1];
            if (key === 'first()') {
                key = 0;
            }
            if (typeof key == 'number' && Array.isArray(memory)) {
                // Only allow positive indexes
                if (key < 0) {
                    throw new Error(
                        `DialogStateManager.setValue: unable to update value for '${pathExpression}'. Negative indexes aren't allowed.`
                    );
                }

                // Expand array as needed and update array
                const l = key + 1;
                while (memory.length < l) {
                    memory.push(undefined);
                }
                memory[key] = value;
            } else if (
                typeof key == 'string' &&
                key.length > 0 &&
                typeof memory == 'object' &&
                !Array.isArray(memory)
            ) {
                // Find key to use and update object
                key = this.findObjectKey(memory, key) || key;
                memory[key] = value;
            } else {
                throw new Error(`DialogStateManager.setValue: unable to update value for '${pathExpression}'.`);
            }
        } else {
            // Just update memory scope
            scope.setMemory(this.dialogContext, value);
        }
    }

    /**
     * Delete property from memory
     *
     * @param pathExpression The leaf property to remove.
     */
    deleteValue(pathExpression: string): void {
        // Get path segments
        const tpath = this.transformPath(pathExpression);
        const segments = this.parsePath(tpath);
        if (segments.length < 2) {
            throw new Error(`DialogStateManager.deleteValue: invalid path of '${pathExpression}'.`);
        }

        // Track change
        this.trackChange(tpath);

        // Get memory scope to update
        const scope = this.getMemoryScope(segments[0].toString());
        if (scope == undefined) {
            throw new Error(`DialogStateManager.deleteValue: a scope of '${segments[0]}' wasn't found.`);
        }

        // Find value up to last key
        const key = segments.pop();
        const memory = this.resolveSegments(scope.getMemory(this.dialogContext), segments, false);

        // Update value
        if (typeof key == 'number' && Array.isArray(memory)) {
            if (key < memory.length) {
                memory.splice(key, 1);
            }
        } else if (typeof key == 'string' && key.length > 0 && typeof memory == 'object' && !Array.isArray(memory)) {
            const found = this.findObjectKey(memory, key);
            if (found) {
                delete memory[found];
            }
        }
    }

    /**
     * Ensures that all memory scopes have been loaded for the current turn.
     *
     * @remarks
     * This should be called at the beginning of the turn.
     */
    async loadAllScopes(): Promise<void> {
        const scopes = this.configuration.memoryScopes;
        for (let i = 0; i < scopes.length; i++) {
            await scopes[i].load(this.dialogContext);
        }
    }

    /**
     * Saves any changes made to memory scopes.
     *
     * @remarks
     * This should be called at the end of the turn.
     */
    async saveAllChanges(): Promise<void> {
        const scopes = this.configuration.memoryScopes;
        for (let i = 0; i < scopes.length; i++) {
            await scopes[i].saveChanges(this.dialogContext);
        }
    }

    /**
     * Deletes all of the backing memory for a given scope.
     *
     * @param name Name of the scope.
     */
    async deleteScopesMemory(name: string): Promise<void> {
        name = name.toLowerCase();
        const scopes = this.configuration.memoryScopes;
        for (let i = 0; i < scopes.length; i++) {
            const scope = scopes[i];
            if (scope.name.toLowerCase() == name) {
                await scope.delete(this.dialogContext);
                break;
            }
        }
    }

    /**
     * Normalizes the path segments of a passed in path.
     *
     * @remarks
     * A path of `profile.address[0]` will be normalized to `profile.address.0`.
     * @param pathExpression The path to normalize.
     * @param allowNestedPaths Optional. If `false` then detection of a nested path will cause an empty path to be returned. Defaults to 'true'.
     * @returns The normalized path.
     */
    parsePath(pathExpression: string, allowNestedPaths = true): (string | number)[] {
        // Expand path segments
        let segment = '';
        let depth = 0;
        let quote = '';
        const output: (string | number)[] = [];
        for (let i = 0; i < pathExpression.length; i++) {
            const c = pathExpression[i];
            if (depth > 0) {
                // We're in a set of brackets
                if (quote.length) {
                    // We're in a string
                    switch (c) {
                        case '\\':
                            // Escape code detected
                            i++;
                            segment += pathExpression[i];
                            break;
                        default:
                            segment += c;
                            if (c == quote) {
                                quote = '';
                            }
                            break;
                    }
                } else {
                    // We're in a bracket
                    switch (c) {
                        case '[':
                            depth++;
                            segment += c;
                            break;
                        case ']':
                            depth--;
                            if (depth > 0) {
                                segment += c;
                            }
                            break;
                        case "'":
                        case '"':
                            quote = c;
                            segment += c;
                            break;
                        default:
                            segment += c;
                            break;
                    }

                    // Are we out of the brackets
                    if (depth == 0) {
                        if (isQuoted(segment)) {
                            // Quoted segment
                            output.push(segment.length > 2 ? segment.substr(1, segment.length - 2) : '');
                        } else if (isIndex(segment)) {
                            // Array index
                            output.push(parseInt(segment));
                        } else if (allowNestedPaths) {
                            // Resolve nested value
                            const val = this.getValue(segment);
                            const t = typeof val;
                            output.push(t == 'string' || t == 'number' ? val : '');
                        } else {
                            // Abort parsing and return empty path (used for change tracking.)
                            return [];
                        }
                        segment = '';
                    }
                }
            } else {
                // We're parsing the outer path
                switch (c) {
                    case '[':
                        if (segment.length > 0) {
                            output.push(segment);
                            segment = '';
                        }
                        depth++;
                        break;
                    case '.':
                        if (segment.length > 0) {
                            output.push(segment);
                            segment = '';
                        } else if (i == 0 || i == pathExpression.length - 1) {
                            // Special case a "." at beginning or end of path
                            output.push('');
                        } else if (pathExpression[i - 1] == '.') {
                            // Special case ".."
                            output.push('');
                        }
                        break;
                    default:
                        if (i > 1 && pathExpression[i - 1] == '.' && c == '$') {
                            segment += c; // x.$foo should be valid
                        } else if (isValidPathChar(c)) {
                            segment += c;
                        } else {
                            throw new Error(
                                `DialogStateManager.normalizePath: Invalid path detected - ${pathExpression}`
                            );
                        }
                        break;
                }
            }
        }
        if (depth > 0) {
            throw new Error(`DialogStateManager.normalizePath: Invalid path detected - ${pathExpression}`);
        } else if (segment.length > 0) {
            output.push(segment);
        }

        return output;
    }

    /**
     * Transform the path using the registered path transformers.
     *
     * @param pathExpression The path to transform.
     * @returns The transformed path.
     */
    transformPath(pathExpression: string): string {
        // Run path through registered resolvers.
        const resolvers = this.configuration.pathResolvers;
        for (let i = 0; i < resolvers.length; i++) {
            pathExpression = resolvers[i].transformPath(pathExpression);
        }

        return pathExpression;
    }

    /**
     * Gets all memory scopes suitable for logging.
     *
     * @returns Object which represents all memory scopes.
     */
    getMemorySnapshot(): object {
        const output = {};
        this.configuration.memoryScopes.forEach((scope) => {
            if (scope.includeInSnapshot) {
                output[scope.name] = scope.getMemory(this.dialogContext);
            }
        });

        return output;
    }

    /**
     * Track when specific paths are changed.
     *
     * @param paths Paths to track.
     * @returns Normalized paths to pass to [anyPathChanged()](#anypathchanged).
     */
    trackPaths(paths: string[]): string[] {
        const allPaths: string[] = [];
        paths.forEach((path) => {
            const tpath = this.transformPath(path);
            const segments = this.parsePath(tpath, false);
            if (segments.length > 0 && (segments.length == 1 || !segments[1].toString().startsWith('_'))) {
                // Normalize path and initialize change tracker
                const npath = segments.join('_').toLowerCase();
                this.setValue(`${PATH_TRACKER}.${npath}`, 0);

                // Return normalized path
                allPaths.push(npath);
            }
        });

        return allPaths;
    }

    /**
     * Check to see if any path has changed since watermark.
     *
     * @param counter Time counter to compare to.
     * @param paths Paths from [trackPaths()](#trackpaths) to check.
     * @returns True if any path has changed since counter.
     */
    anyPathChanged(counter: number, paths: string[]): boolean {
        let found = false;
        if (paths) {
            for (let i = 0; i < paths.length; i++) {
                if (this.getValue(`${PATH_TRACKER}.${paths[i]}`, 0) > counter) {
                    found = true;
                    break;
                }
            }
        }

        return found;
    }

    /**
     * @private
     * @param path Track path to change.
     */
    private trackChange(path: string): void {
        // Normalize path and scan for any matches or children that match.
        // - We're appending an extra '_' so that we can do substring matches and
        //   avoid any false positives.
        let counter: number = undefined;
        const npath = this.parsePath(path, false).join('_') + '_';
        const tracking: object = this.getValue(PATH_TRACKER) || {};
        for (const key in tracking) {
            if (`${key}_`.startsWith(npath)) {
                // Populate counter on first use
                if (counter == undefined) {
                    counter = this.getValue(DialogPath.eventCounter);
                }

                // Update tracking watermark
                this.setValue(`${PATH_TRACKER}.${key}`, counter);
            }
        }
    }

    /**
     * @private
     * @param memory Object memory to resolve.
     * @param segments Segments of the memory to resolve.
     * @param assignment Optional.
     * @returns The value of the memory segment.
     */
    private resolveSegments(memory: object, segments: (string | number)[], assignment?: boolean): any {
        let value: any = memory;
        const l = assignment ? segments.length - 1 : segments.length;
        for (let i = 1; i < l && value != undefined; i++) {
            const key = segments[i];
            if (typeof key == 'number') {
                // Key is an array index
                if (Array.isArray(value)) {
                    value = value[key];
                } else {
                    value = undefined;
                }
            } else if (key === 'first()') {
                // Special case returning the first entity in an array of entities.
                if (Array.isArray(value) && value.length > 0) {
                    value = value[0];
                    if (Array.isArray(value)) {
                        // Nested array detected
                        if (value.length > 0) {
                            value = value[0];
                        } else {
                            value = undefined;
                        }
                    }
                } else {
                    value = undefined;
                }
            } else if (typeof key == 'string' && key.length > 0) {
                // Key is an object index
                if (typeof value == 'object' && !Array.isArray(value)) {
                    // Case-insensitive search for prop
                    let found = this.findObjectKey(value, key);

                    // Ensure path exists as needed
                    if (assignment) {
                        const nextKey = segments[i + 1];
                        if (typeof nextKey == 'number' || nextKey === 'first()') {
                            // Ensure prop contains an array
                            if (found) {
                                if (value[found] == undefined) {
                                    value[found] = [];
                                }
                            } else {
                                found = key;
                                value[found] = [];
                            }
                        } else if (typeof nextKey == 'string' && nextKey.length > 0) {
                            // Ensure prop contains an object
                            if (found) {
                                if (value[found] == undefined) {
                                    value[found] = {};
                                }
                            } else {
                                found = key;
                                value[found] = {};
                            }
                        } else {
                            // We can't determine type so return undefined
                            found = undefined;
                        }
                    }

                    value = found ? value[found] : undefined;
                } else {
                    value = undefined;
                }
            } else {
                // Key is missing
                value = undefined;
            }
        }

        return value;
    }

    /**
     * @private
     */
    private findObjectKey(obj: object, key: string): string | undefined {
        const k = key.toLowerCase();
        for (const prop in obj) {
            if (prop.toLowerCase() == k) {
                return prop;
            }
        }

        return undefined;
    }

    /**
     * @private
     * Gets [MemoryScope](xref:botbuilder-dialogs.MemoryScope) by name.
     * @param name Name of scope.
     * @returns The [MemoryScope](xref:botbuilder-dialogs.MemoryScope).
     */
    private getMemoryScope(name: string): MemoryScope | undefined {
        const key = name.toLowerCase();
        const scopes = this.configuration.memoryScopes;
        for (let i = 0; i < scopes.length; i++) {
            const scope = scopes[i];
            if (scope.name.toLowerCase() == key) {
                return scope;
            }
        }

        return undefined;
    }

    /**
     * Gets the version number.
     *
     * @returns A string with the version number.
     */
    version(): string {
        return '0';
    }
}

/**
 * @private
 */
function isIndex(segment: string): boolean {
    const digits = '0123456789';
    for (let i = 0; i < segment.length; i++) {
        const c = segment[i];
        if (digits.indexOf(c) < 0) {
            // Check for negative sign
            if (c != '-' || i > 0 || segment.length < 2) {
                return false;
            }
        }
    }

    return segment.length > 0;
}

/**
 * @private
 */
function isQuoted(segment: string): boolean {
    return (
        (segment.length > 1 && segment.startsWith("'") && segment.endsWith("'")) ||
        (segment.startsWith('"') && segment.endsWith('"'))
    );
}

/**
 * @private
 */
function isValidPathChar(c: string): boolean {
    return '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-()'.indexOf(c) >= 0;
}

1	/**
2	* @module botbuilder-dialogs
3	*/
4	/**
5	* Copyright (c) Microsoft Corporation. All rights reserved.
6	* Licensed under the MIT License.
7	*/
8
9	import { ComponentMemoryScopes, isComponentMemoryScopes } from './componentMemoryScopes';	2✔
10	import { ComponentPathResolvers, isComponentPathResolvers } from './componentPathResolvers';	2✔
11	import { ComponentRegistration } from 'botbuilder-core';	2✔
12	import { DialogContext } from '../dialogContext';
13	import { DialogPath } from './dialogPath';	2✔
14	import { DialogsComponentRegistration } from '../dialogsComponentRegistration';	2✔
15	import { MemoryScope } from './scopes';
16	import { PathResolver } from './pathResolvers';
17
18	export interface DialogStateManagerConfiguration {
19	/**
20	* List of path resolvers used to evaluate memory paths.
21	*/
22	readonly pathResolvers: PathResolver[];
23
24	/**
25	* List of the supported memory scopes.
26	*/
27	readonly memoryScopes: MemoryScope[];
28	}
29
30	const PATH_TRACKER = 'dialog._tracker.paths';	2✔
31
32	const DIALOG_STATE_MANAGER_CONFIGURATION = 'DialogStateManagerConfiguration';	2✔
33
34	/**
35	* The DialogStateManager manages memory scopes and path resolvers.
36	*
37	* @remarks
38	* MemoryScopes are named root level objects, which can exist either in the dialog context or off
39	* of turn state. Path resolvers allow for shortcut behavior for mapping things like
40	* $foo -> dialog.foo
41	*/
42	export class DialogStateManager {	2✔
43	private readonly dialogContext: DialogContext;
44
45	/**
46	* Initializes a new instance of the [DialogStateManager](xref:botbuilder-dialogs.DialogStateManager) class.
47	*
48	* @param dc The dialog context for the current turn of the conversation.
49	* @param configuration Configuration for the dialog state manager.
50	*/
51	constructor(dc: DialogContext, configuration?: DialogStateManagerConfiguration) {
52	ComponentRegistration.add(new DialogsComponentRegistration());	13,350✔
53
54	this.dialogContext = dc;	13,350✔
55	this.configuration = configuration ?? dc.context.turnState.get(DIALOG_STATE_MANAGER_CONFIGURATION);	13,350✔
56
57	if (!this.configuration) {	13,350✔
58	this.configuration = { memoryScopes: [], pathResolvers: [] };	3,448✔
59
60	// get all of the component memory scopes.
61	ComponentRegistration.components	3,448✔
62	.filter((component: ComponentRegistration) => isComponentMemoryScopes(component))	3,448✔
63	.forEach((component: ComponentMemoryScopes) => {
64	this.configuration.memoryScopes.push(...component.getMemoryScopes());	3,448✔
65	});
66
67	// merge in turn state memory scopes
68	const memoryScopes = dc.context.turnState.get<MemoryScope[]>('memoryScopes') ?? [];	3,448!
69	this.configuration.memoryScopes.push(...memoryScopes);	3,448✔
70
71	// get all of the component path resolvers.
72	ComponentRegistration.components	3,448✔
73	.filter((component: ComponentRegistration) => isComponentPathResolvers(component))	3,448✔
74	.forEach((component: ComponentPathResolvers) => {
75	this.configuration.pathResolvers.push(...component.getPathResolvers());	3,448✔
76	});
77
78	// merge in turn state ones path resolvers
79	const pathResolvers = dc.context.turnState.get<PathResolver[]>('pathResolvers') ?? [];	3,448!
80	this.configuration.pathResolvers.push(...pathResolvers);	3,448✔
81
82	// cache for any other new dialogStateManager instances in this turn
83	dc.context.turnState.set(DIALOG_STATE_MANAGER_CONFIGURATION, this.configuration);	3,448✔
84	}
85	}
86
87	/**
88	* Gets or sets the configured path resolvers and memory scopes for the dialog state manager.
89	*
90	* @remarks
91	* There is a single set of configuration information for a given chain of dialog contexts.
92	* Assigning a new configuration to any DialogStateManager within the chain will update the
93	* configuration for the entire chain.
94	*/
95	configuration: DialogStateManagerConfiguration;
96
97	/**
98	* Get the value from memory using path expression.
99	*
100	* @remarks
101	* This always returns a CLONE of the memory, any modifications to the result will not affect memory.
102	* @template T The value type to return.
103	* @param pathExpression Path expression to use.
104	* @param defaultValue (Optional) default value to use if the path isn't found. May be a function that returns the default value to use.
105	* @returns The found value or undefined if not found and no `defaultValue` specified.
106	*/
107	getValue<T = any>(pathExpression: string, defaultValue?: T \| (() => T)): T {
108	function returnDefault(): T {
109	return typeof defaultValue == 'function' ? (defaultValue as Function)() : defaultValue;	71,264✔
110	}
111
112	// Get path segments
113	const segments = this.parsePath(this.transformPath(pathExpression));	111,228✔
114	if (segments.length < 1) {	111,224✔
115	return returnDefault();	4✔
116	}
117
118	// Get memory scope to search over
119	const scope = this.getMemoryScope(segments[0].toString());	111,220✔
120	if (scope == undefined) {	111,220✔
121	console.warn(`DialogStateManager.getValue: a scope of '${segments[0]}' wasn't found for '${pathExpression}'.`);	2✔
122	return returnDefault();	2✔
123	}
124
125	// Search over path
126	const memory = this.resolveSegments(scope.getMemory(this.dialogContext), segments, false);	111,218✔
127
128	// Return default value if nothing found
129	return memory != undefined ? memory : returnDefault();	111,218✔
130	}
131
132	/**
133	* Set memory to value.
134	*
135	* @param pathExpression Path to memory.
136	* @param value Value to set.
137	*/
138	setValue(pathExpression: string, value: any): void {
139	// Get path segments
140	const tpath = this.transformPath(pathExpression);	52,101✔
141	const segments = this.parsePath(tpath);	52,101✔
142	if (segments.length < 1) {	52,099✔
143	throw new Error("DialogStateManager.setValue: path wasn't specified.");	2✔
144	}
145
146	// Track changes
147	this.trackChange(tpath);	52,097✔
148
149	// Get memory scope to update
150	const scope = this.getMemoryScope(segments[0].toString());	52,097✔
151	if (scope == undefined) {	52,097✔
152	throw new Error(`DialogStateManager.setValue: a scope of '${segments[0]}' wasn't found.`);	4✔
153	}
154
155	// Update memory
156	if (segments.length > 1) {	52,093✔
157	// Find value up to last key
158	// - Missing paths will be populated as needed
159	let memory = scope.getMemory(this.dialogContext);	52,091✔
160	memory = this.resolveSegments(memory, segments, true);	52,091✔
161
162	// Update value
163	let key = segments[segments.length - 1];	52,091✔
164	if (key === 'first()') {	52,091✔
165	key = 0;	2✔
166	}
167	if (typeof key == 'number' && Array.isArray(memory)) {	52,091✔
168	// Only allow positive indexes
169	if (key < 0) {	4✔
170	throw new Error(	2✔
171	`DialogStateManager.setValue: unable to update value for '${pathExpression}'. Negative indexes aren't allowed.`
172	);
173	}
174
175	// Expand array as needed and update array
176	const l = key + 1;	2✔
177	while (memory.length < l) {	2✔
178	memory.push(undefined);	2✔
179	}
180	memory[key] = value;	2✔
181	} else if (	52,087✔
182	typeof key == 'string' &&	208,342✔
183	key.length > 0 &&
184	typeof memory == 'object' &&
185	!Array.isArray(memory)
186	) {
187	// Find key to use and update object
188	key = this.findObjectKey(memory, key) \|\| key;	52,085✔
189	memory[key] = value;	52,085✔
190	} else {
191	throw new Error(`DialogStateManager.setValue: unable to update value for '${pathExpression}'.`);	2✔
192	}
193	} else {
194	// Just update memory scope
195	scope.setMemory(this.dialogContext, value);	2✔
196	}
197	}
198
199	/**
200	* Delete property from memory
201	*
202	* @param pathExpression The leaf property to remove.
203	*/
204	deleteValue(pathExpression: string): void {
205	// Get path segments
206	const tpath = this.transformPath(pathExpression);	752✔
207	const segments = this.parsePath(tpath);	752✔
208	if (segments.length < 2) {	752✔
209	throw new Error(`DialogStateManager.deleteValue: invalid path of '${pathExpression}'.`);	2✔
210	}
211
212	// Track change
213	this.trackChange(tpath);	750✔
214
215	// Get memory scope to update
216	const scope = this.getMemoryScope(segments[0].toString());	750✔
217	if (scope == undefined) {	750✔
218	throw new Error(`DialogStateManager.deleteValue: a scope of '${segments[0]}' wasn't found.`);	2✔
219	}
220
221	// Find value up to last key
222	const key = segments.pop();	748✔
223	const memory = this.resolveSegments(scope.getMemory(this.dialogContext), segments, false);	748✔
224
225	// Update value
226	if (typeof key == 'number' && Array.isArray(memory)) {	748✔
227	if (key < memory.length) {	4✔
228	memory.splice(key, 1);	2✔
229	}
230	} else if (typeof key == 'string' && key.length > 0 && typeof memory == 'object' && !Array.isArray(memory)) {	744✔
231	const found = this.findObjectKey(memory, key);	730✔
232	if (found) {	730✔
233	delete memory[found];	94✔
234	}
235	}
236	}
237
238	/**
239	* Ensures that all memory scopes have been loaded for the current turn.
240	*
241	* @remarks
242	* This should be called at the beginning of the turn.
243	*/
244	async loadAllScopes(): Promise<void> {
245	const scopes = this.configuration.memoryScopes;	1,630✔
246	for (let i = 0; i < scopes.length; i++) {	1,630✔
247	await scopes[i].load(this.dialogContext);	14,654✔
248	}
249	}
250
251	/**
252	* Saves any changes made to memory scopes.
253	*
254	* @remarks
255	* This should be called at the end of the turn.
256	*/
257	async saveAllChanges(): Promise<void> {
258	const scopes = this.configuration.memoryScopes;	1,824✔
259	for (let i = 0; i < scopes.length; i++) {	1,824✔
260	await scopes[i].saveChanges(this.dialogContext);	16,400✔
261	}
262	}
263
264	/**
265	* Deletes all of the backing memory for a given scope.
266	*
267	* @param name Name of the scope.
268	*/
269	async deleteScopesMemory(name: string): Promise<void> {
UNCOV 270	name = name.toLowerCase();	×
UNCOV 271	const scopes = this.configuration.memoryScopes;	×
272	for (let i = 0; i < scopes.length; i++) {	×
273	const scope = scopes[i];	×
274	if (scope.name.toLowerCase() == name) {	×
275	await scope.delete(this.dialogContext);	×
276	break;	×
277	}
278	}
279	}
280
281	/**
282	* Normalizes the path segments of a passed in path.
283	*
284	* @remarks
285	* A path of `profile.address[0]` will be normalized to `profile.address.0`.
286	* @param pathExpression The path to normalize.
287	* @param allowNestedPaths Optional. If `false` then detection of a nested path will cause an empty path to be returned. Defaults to 'true'.
288	* @returns The normalized path.
289	*/
290	parsePath(pathExpression: string, allowNestedPaths = true): (string \| number)[] {	164,081✔
291	// Expand path segments
292	let segment = '';	216,938✔
293	let depth = 0;	216,938✔
294	let quote = '';	216,938✔
295	const output: (string \| number)[] = [];	216,938✔
296	for (let i = 0; i < pathExpression.length; i++) {	216,938✔
297	const c = pathExpression[i];	3,967,752✔
298	if (depth > 0) {	3,967,752✔
299	// We're in a set of brackets
300	if (quote.length) {	509✔
301	// We're in a string
302	switch (c) {	131✔
303	case '\\':	131✔
304	// Escape code detected
305	i++;	4✔
306	segment += pathExpression[i];	4✔
307	break;	4✔
308	default:
309	segment += c;	127✔
310	if (c == quote) {	127✔
311	quote = '';	14✔
312	}
313	break;	127✔
314	}
315	} else {
316	// We're in a bracket
317	switch (c) {	378✔
318	case '[':	386✔
319	depth++;	2✔
320	segment += c;	2✔
321	break;	2✔
322	case ']':
323	depth--;	94✔
324	if (depth > 0) {	94✔
325	segment += c;	2✔
326	}
327	break;	94✔
328	case "'":
329	case '"':
330	quote = c;	16✔
331	segment += c;	16✔
332	break;	16✔
333	default:
334	segment += c;	266✔
335	break;	266✔
336	}
337
338	// Are we out of the brackets
339	if (depth == 0) {	378✔
340	if (isQuoted(segment)) {	92✔
341	// Quoted segment
342	output.push(segment.length > 2 ? segment.substr(1, segment.length - 2) : '');	14!
343	} else if (isIndex(segment)) {	78✔
344	// Array index
345	output.push(parseInt(segment));	62✔
346	} else if (allowNestedPaths) {	16✔
347	// Resolve nested value
348	const val = this.getValue(segment);	12✔
349	const t = typeof val;	12✔
350	output.push(t == 'string' \|\| t == 'number' ? val : '');	12!
351	} else {
352	// Abort parsing and return empty path (used for change tracking.)
353	return [];	4✔
354	}
355	segment = '';	88✔
356	}
357	}
358	} else {
359	// We're parsing the outer path
360	switch (c) {	3,967,243✔
361	case '[':	3,967,243✔
362	if (segment.length > 0) {	96✔
363	output.push(segment);	90✔
364	segment = '';	90✔
365	}
366	depth++;	96✔
367	break;	96✔
368	case '.':
369	if (segment.length > 0) {	315,309✔
370	output.push(segment);	315,251✔
371	segment = '';	315,251✔
372	} else if (i == 0 \|\| i == pathExpression.length - 1) {	58✔
373	// Special case a "." at beginning or end of path
374	output.push('');	4✔
375	} else if (pathExpression[i - 1] == '.') {	54✔
376	// Special case ".."
377	output.push('');	2✔
378	}
379	break;	315,309✔
380	default:
381	if (i > 1 && pathExpression[i - 1] == '.' && c == '$') {	3,651,838✔
382	segment += c; // x.$foo should be valid	30✔
383	} else if (isValidPathChar(c)) {	3,651,808✔
384	segment += c;	3,651,806✔
385	} else {
386	throw new Error(	2✔
387	`DialogStateManager.normalizePath: Invalid path detected - ${pathExpression}`
388	);
389	}
390	break;	3,651,836✔
391	}
392	}
393	}
394	if (depth > 0) {	216,932✔
395	throw new Error(`DialogStateManager.normalizePath: Invalid path detected - ${pathExpression}`);	4✔
396	} else if (segment.length > 0) {	216,928✔
397	output.push(segment);	216,888✔
398	}
399
400	return output;	216,928✔
401	}
402
403	/**
404	* Transform the path using the registered path transformers.
405	*
406	* @param pathExpression The path to transform.
407	* @returns The transformed path.
408	*/
409	transformPath(pathExpression: string): string {
410	// Run path through registered resolvers.
411	const resolvers = this.configuration.pathResolvers;	164,091✔
412	for (let i = 0; i < resolvers.length; i++) {	164,091✔
413	pathExpression = resolvers[i].transformPath(pathExpression);	820,455✔
414	}
415
416	return pathExpression;	164,091✔
417	}
418
419	/**
420	* Gets all memory scopes suitable for logging.
421	*
422	* @returns Object which represents all memory scopes.
423	*/
424	getMemorySnapshot(): object {
425	const output = {};	1,506✔
426	this.configuration.memoryScopes.forEach((scope) => {	1,506✔
427	if (scope.includeInSnapshot) {	13,554✔
428	output[scope.name] = scope.getMemory(this.dialogContext);	7,530✔
429	}
430	});
431
432	return output;	1,506✔
433	}
434
435	/**
436	* Track when specific paths are changed.
437	*
438	* @param paths Paths to track.
439	* @returns Normalized paths to pass to [anyPathChanged()](#anypathchanged).
440	*/
441	trackPaths(paths: string[]): string[] {
442	const allPaths: string[] = [];	6✔
443	paths.forEach((path) => {	6✔
444	const tpath = this.transformPath(path);	10✔
445	const segments = this.parsePath(tpath, false);	10✔
446	if (segments.length > 0 && (segments.length == 1 \|\| !segments[1].toString().startsWith('_'))) {	10!
447	// Normalize path and initialize change tracker
448	const npath = segments.join('_').toLowerCase();	10✔
449	this.setValue(`${PATH_TRACKER}.${npath}`, 0);	10✔
450
451	// Return normalized path
452	allPaths.push(npath);	10✔
453	}
454	});
455
456	return allPaths;	6✔
457	}
458
459	/**
460	* Check to see if any path has changed since watermark.
461	*
462	* @param counter Time counter to compare to.
463	* @param paths Paths from [trackPaths()](#trackpaths) to check.
464	* @returns True if any path has changed since counter.
465	*/
466	anyPathChanged(counter: number, paths: string[]): boolean {
467	let found = false;	66✔
468	if (paths) {	66✔
469	for (let i = 0; i < paths.length; i++) {	44✔
470	if (this.getValue(`${PATH_TRACKER}.${paths[i]}`, 0) > counter) {	58✔
471	found = true;	16✔
472	break;	16✔
473	}
474	}
475	}
476
477	return found;	66✔
478	}
479
480	/**
481	* @private
482	* @param path Track path to change.
483	*/
484	private trackChange(path: string): void {
485	// Normalize path and scan for any matches or children that match.
486	// - We're appending an extra '_' so that we can do substring matches and
487	// avoid any false positives.
488	let counter: number = undefined;	52,847✔
489	const npath = this.parsePath(path, false).join('_') + '_';	52,847✔
490	const tracking: object = this.getValue(PATH_TRACKER) \|\| {};	52,847✔
491	for (const key in tracking) {	52,847✔
492	if (`${key}_`.startsWith(npath)) {	2,634✔
493	// Populate counter on first use
494	if (counter == undefined) {	10!
495	counter = this.getValue(DialogPath.eventCounter);	10✔
496	}
497
498	// Update tracking watermark
499	this.setValue(`${PATH_TRACKER}.${key}`, counter);	10✔
500	}
501	}
502	}
503
504	/**
505	* @private
506	* @param memory Object memory to resolve.
507	* @param segments Segments of the memory to resolve.
508	* @param assignment Optional.
509	* @returns The value of the memory segment.
510	*/
511	private resolveSegments(memory: object, segments: (string \| number)[], assignment?: boolean): any {
512	let value: any = memory;	164,057✔
513	const l = assignment ? segments.length - 1 : segments.length;	164,057✔
514	for (let i = 1; i < l && value != undefined; i++) {	164,057✔
515	const key = segments[i];	134,694✔
516	if (typeof key == 'number') {	134,694✔
517	// Key is an array index
518	if (Array.isArray(value)) {	48✔
519	value = value[key];	46✔
520	} else {
521	value = undefined;	2✔
522	}
523	} else if (key === 'first()') {	134,646✔
524	// Special case returning the first entity in an array of entities.
525	if (Array.isArray(value) && value.length > 0) {	132✔
526	value = value[0];	130✔
527	if (Array.isArray(value)) {	130✔
528	// Nested array detected
529	if (value.length > 0) {	56✔
530	value = value[0];	54✔
531	} else {
532	value = undefined;	2✔
533	}
534	}
535	} else {
536	value = undefined;	2✔
537	}
538	} else if (typeof key == 'string' && key.length > 0) {	134,514✔
539	// Key is an object index
540	if (typeof value == 'object' && !Array.isArray(value)) {	134,512✔
541	// Case-insensitive search for prop
542	let found = this.findObjectKey(value, key);	134,508✔
543
544	// Ensure path exists as needed
545	if (assignment) {	134,508✔
546	const nextKey = segments[i + 1];	5,828✔
547	if (typeof nextKey == 'number' \|\| nextKey === 'first()') {	5,828✔
548	// Ensure prop contains an array
549	if (found) {	6✔
550	if (value[found] == undefined) {	2!
UNCOV 551	value[found] = [];	×
552	}
553	} else {
554	found = key;	4✔
555	value[found] = [];	4✔
556	}
557	} else if (typeof nextKey == 'string' && nextKey.length > 0) {	5,822!
558	// Ensure prop contains an object
559	if (found) {	5,822✔
560	if (value[found] == undefined) {	5,754!
UNCOV 561	value[found] = {};	×
562	}
563	} else {
564	found = key;	68✔
565	value[found] = {};	68✔
566	}
567	} else {
568	// We can't determine type so return undefined
UNCOV 569	found = undefined;	×
570	}
571	}
572
573	value = found ? value[found] : undefined;	134,508✔
574	} else {
575	value = undefined;	4✔
576	}
577	} else {
578	// Key is missing
579	value = undefined;	2✔
580	}
581	}
582
583	return value;	164,057✔
584	}
585
586	/**
587	* @private
588	*/
589	private findObjectKey(obj: object, key: string): string \| undefined {
590	const k = key.toLowerCase();	187,323✔
591	for (const prop in obj) {	187,323✔
592	if (prop.toLowerCase() == k) {	1,320,864✔
593	return prop;	101,312✔
594	}
595	}
596
597	return undefined;	86,011✔
598	}
599
600	/**
601	* @private
602	* Gets [MemoryScope](xref:botbuilder-dialogs.MemoryScope) by name.
603	* @param name Name of scope.
604	* @returns The [MemoryScope](xref:botbuilder-dialogs.MemoryScope).
605	*/
606	private getMemoryScope(name: string): MemoryScope \| undefined {
607	const key = name.toLowerCase();	164,067✔
608	const scopes = this.configuration.memoryScopes;	164,067✔
609	for (let i = 0; i < scopes.length; i++) {	164,067✔
610	const scope = scopes[i];	408,149✔
611	if (scope.name.toLowerCase() == key) {	408,149✔
612	return scope;	164,059✔
613	}
614	}
615
616	return undefined;	8✔
617	}
618
619	/**
620	* Gets the version number.
621	*
622	* @returns A string with the version number.
623	*/
624	version(): string {
625	return '0';	2,264✔
626	}
627	}
628
629	/**
630	* @private
631	*/
632	function isIndex(segment: string): boolean {
633	const digits = '0123456789';	78✔
634	for (let i = 0; i < segment.length; i++) {	78✔
635	const c = segment[i];	82✔
636	if (digits.indexOf(c) < 0) {	82✔
637	// Check for negative sign
638	if (c != '-' \|\| i > 0 \|\| segment.length < 2) {	20✔
639	return false;	16✔
640	}
641	}
642	}
643
644	return segment.length > 0;	62✔
645	}
646
647	/**
648	* @private
649	*/
650	function isQuoted(segment: string): boolean {
651	return (	92✔
652	(segment.length > 1 && segment.startsWith("'") && segment.endsWith("'")) \|\|	226✔
653	(segment.startsWith('"') && segment.endsWith('"'))
654	);
655	}
656
657	/**
658	* @private
659	*/
660	function isValidPathChar(c: string): boolean {
661	return '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-()'.indexOf(c) >= 0;	3,651,808✔
662	}

microsoft / botbuilder-js / 8542469313

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous