@aws-cdk/aws-logs/lib/pattern.js

"use strict";
var _a, _b, _c;
Object.defineProperty(exports, "__esModule", { value: true });
exports.SpaceDelimitedTextPattern = exports.FilterPattern = exports.JsonPattern = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
/**
 * Base class for patterns that only match JSON log events.
 */
class JsonPattern {
    // This is a separate class so we have some type safety where users can't
    // combine text patterns and JSON patterns with an 'and' operation.
    constructor(jsonPatternString) {
        this.jsonPatternString = jsonPatternString;
    }
    get logPatternString() {
        return '{ ' + this.jsonPatternString + ' }';
    }
}
exports.JsonPattern = JsonPattern;
_a = JSII_RTTI_SYMBOL_1;
JsonPattern[_a] = { fqn: "@aws-cdk/aws-logs.JsonPattern", version: "1.156.1" };
/**
 * A collection of static methods to generate appropriate ILogPatterns
 */
class FilterPattern {
    /**
     * Use the given string as log pattern.
     *
     * See https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html
     * for information on writing log patterns.
     *
     * @param logPatternString The pattern string to use.
     */
    static literal(logPatternString) {
        return new LiteralLogPattern(logPatternString);
    }
    /**
     * A log pattern that matches all events.
     */
    static allEvents() {
        return new LiteralLogPattern('');
    }
    /**
     * A log pattern that matches if all the strings given appear in the event.
     *
     * @param terms The words to search for. All terms must match.
     */
    static allTerms(...terms) {
        return new TextLogPattern([terms]);
    }
    /**
     * A log pattern that matches if any of the strings given appear in the event.
     *
     * @param terms The words to search for. Any terms must match.
     */
    static anyTerm(...terms) {
        return new TextLogPattern(terms.map(t => [t]));
    }
    /**
     * A log pattern that matches if any of the given term groups matches the event.
     *
     * A term group matches an event if all the terms in it appear in the event string.
     *
     * @param termGroups A list of term groups to search for. Any one of the clauses must match.
     */
    static anyTermGroup(...termGroups) {
        return new TextLogPattern(termGroups);
    }
    /**
     * A JSON log pattern that compares string values.
     *
     * This pattern only matches if the event is a JSON event, and the indicated field inside
     * compares with the string value.
     *
     * Use '$' to indicate the root of the JSON structure. The comparison operator can only
     * compare equality or inequality. The '*' wildcard may appear in the value may at the
     * start or at the end.
     *
     * For more information, see:
     *
     * https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html
     *
     * @param jsonField Field inside JSON. Example: "$.myField"
     * @param comparison Comparison to carry out. Either = or !=.
     * @param value The string value to compare to. May use '*' as wildcard at start or end of string.
     */
    static stringValue(jsonField, comparison, value) {
        return new JSONStringPattern(jsonField, comparison, value);
    }
    /**
     * A JSON log pattern that compares numerical values.
     *
     * This pattern only matches if the event is a JSON event, and the indicated field inside
     * compares with the value in the indicated way.
     *
     * Use '$' to indicate the root of the JSON structure. The comparison operator can only
     * compare equality or inequality. The '*' wildcard may appear in the value may at the
     * start or at the end.
     *
     * For more information, see:
     *
     * https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html
     *
     * @param jsonField Field inside JSON. Example: "$.myField"
     * @param comparison Comparison to carry out. One of =, !=, <, <=, >, >=.
     * @param value The numerical value to compare to
     */
    static numberValue(jsonField, comparison, value) {
        return new JSONNumberPattern(jsonField, comparison, value);
    }
    /**
     * A JSON log pattern that matches if the field exists and has the special value 'null'.
     *
     * @param jsonField Field inside JSON. Example: "$.myField"
     */
    static isNull(jsonField) {
        return new JSONPostfixPattern(jsonField, 'IS NULL');
    }
    /**
     * A JSON log pattern that matches if the field does not exist.
     *
     * @param jsonField Field inside JSON. Example: "$.myField"
     */
    static notExists(jsonField) {
        return new JSONPostfixPattern(jsonField, 'NOT EXISTS');
    }
    /**
     * A JSON log patter that matches if the field exists.
     *
     * This is a readable convenience wrapper over 'field = *'
     *
     * @param jsonField Field inside JSON. Example: "$.myField"
     */
    static exists(jsonField) {
        return new JSONStringPattern(jsonField, '=', '*');
    }
    /**
     * A JSON log pattern that matches if the field exists and equals the boolean value.
     *
     * @param jsonField Field inside JSON. Example: "$.myField"
     * @param value The value to match
     */
    static booleanValue(jsonField, value) {
        return new JSONPostfixPattern(jsonField, value ? 'IS TRUE' : 'IS FALSE');
    }
    /**
     * A JSON log pattern that matches if all given JSON log patterns match
     */
    static all(...patterns) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_logs_JsonPattern(patterns);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.all);
            }
            throw error;
        }
        if (patterns.length === 0) {
            throw new Error('Must supply at least one pattern, or use allEvents() to match all events.');
        }
        if (patterns.length === 1) {
            return patterns[0];
        }
        return new JSONAggregatePattern('&&', patterns);
    }
    /**
     * A JSON log pattern that matches if any of the given JSON log patterns match
     */
    static any(...patterns) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_logs_JsonPattern(patterns);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.any);
            }
            throw error;
        }
        if (patterns.length === 0) {
            throw new Error('Must supply at least one pattern');
        }
        if (patterns.length === 1) {
            return patterns[0];
        }
        return new JSONAggregatePattern('||', patterns);
    }
    /**
     * A space delimited log pattern matcher.
     *
     * The log event is divided into space-delimited columns (optionally
     * enclosed by "" or [] to capture spaces into column values), and names
     * are given to each column.
     *
     * '...' may be specified once to match any number of columns.
     *
     * Afterwards, conditions may be added to individual columns.
     *
     * @param columns The columns in the space-delimited log stream.
     */
    static spaceDelimited(...columns) {
        return SpaceDelimitedTextPattern.construct(columns);
    }
}
exports.FilterPattern = FilterPattern;
_b = JSII_RTTI_SYMBOL_1;
FilterPattern[_b] = { fqn: "@aws-cdk/aws-logs.FilterPattern", version: "1.156.1" };
/**
 * Use a string literal as a log pattern
 */
class LiteralLogPattern {
    constructor(logPatternString) {
        this.logPatternString = logPatternString;
    }
}
/**
 * Search for a set of set of terms
 */
class TextLogPattern {
    constructor(clauses) {
        const quotedClauses = clauses.map(terms => terms.map(quoteTerm).join(' '));
        if (quotedClauses.length === 1) {
            this.logPatternString = quotedClauses[0];
        }
        else {
            this.logPatternString = quotedClauses.map(alt => '?' + alt).join(' ');
        }
    }
}
/**
 * A string comparison for JSON values
 */
class JSONStringPattern extends JsonPattern {
    constructor(jsonField, comparison, value) {
        comparison = validateStringOperator(comparison);
        super(`${jsonField} ${comparison} ${quoteTerm(value)}`);
    }
}
/**
 * A number comparison for JSON values
 */
class JSONNumberPattern extends JsonPattern {
    constructor(jsonField, comparison, value) {
        comparison = validateNumericalOperator(comparison);
        super(`${jsonField} ${comparison} ${value}`);
    }
}
/**
 * A postfix operator for JSON patterns
 */
class JSONPostfixPattern extends JsonPattern {
    constructor(jsonField, postfix) {
        // No validation, we assume these are generated by trusted factory functions
        super(`${jsonField} ${postfix}`);
    }
}
/**
 * Combines multiple other JSON patterns with an operator
 */
class JSONAggregatePattern extends JsonPattern {
    constructor(operator, patterns) {
        if (operator !== '&&' && operator !== '||') {
            throw new Error('Operator must be one of && or ||');
        }
        const clauses = patterns.map(p => '(' + p.jsonPatternString + ')');
        super(clauses.join(` ${operator} `));
    }
}
const COL_ELLIPSIS = '...';
/**
 * Space delimited text pattern
 */
class SpaceDelimitedTextPattern {
    // TODO: Temporarily changed from private to protected to unblock build. We need to think
    //     about how to handle jsii types with private constructors.
    constructor(columns, restrictions) {
        this.columns = columns;
        this.restrictions = restrictions;
    }
    /**
     * Construct a new instance of a space delimited text pattern
     *
     * Since this class must be public, we can't rely on the user only creating it through
     * the `LogPattern.spaceDelimited()` factory function. We must therefore validate the
     * argument in the constructor. Since we're returning a copy on every mutation, and we
     * don't want to re-validate the same things on every construction, we provide a limited
     * set of mutator functions and only validate the new data every time.
     */
    static construct(columns) {
        // Validation happens here because a user could instantiate this object directly without
        // going through the factory
        for (const column of columns) {
            if (!validColumnName(column)) {
                throw new Error(`Invalid column name: ${column}`);
            }
        }
        if (sum(columns.map(c => c === COL_ELLIPSIS ? 1 : 0)) > 1) {
            throw new Error("Can use at most one '...' column");
        }
        return new SpaceDelimitedTextPattern(columns, {});
    }
    /**
     * Restrict where the pattern applies
     */
    whereString(columnName, comparison, value) {
        if (columnName === COL_ELLIPSIS) {
            throw new Error("Can't use '...' in a restriction");
        }
        if (this.columns.indexOf(columnName) === -1) {
            throw new Error(`Column in restrictions that is not in columns: ${columnName}`);
        }
        comparison = validateStringOperator(comparison);
        return new SpaceDelimitedTextPattern(this.columns, this.addRestriction(columnName, {
            comparison,
            stringValue: value,
        }));
    }
    /**
     * Restrict where the pattern applies
     */
    whereNumber(columnName, comparison, value) {
        if (columnName === COL_ELLIPSIS) {
            throw new Error("Can't use '...' in a restriction");
        }
        if (this.columns.indexOf(columnName) === -1) {
            throw new Error(`Column in restrictions that is not in columns: ${columnName}`);
        }
        comparison = validateNumericalOperator(comparison);
        return new SpaceDelimitedTextPattern(this.columns, this.addRestriction(columnName, {
            comparison,
            numberValue: value,
        }));
    }
    get logPatternString() {
        return '[' + this.columns.map(this.columnExpression.bind(this)).join(', ') + ']';
    }
    /**
     * Return the column expression for the given column
     */
    columnExpression(column) {
        const restrictions = this.restrictions[column];
        if (!restrictions) {
            return column;
        }
        return restrictions.map(r => renderRestriction(column, r)).join(' && ');
    }
    /**
     * Make a copy of the current restrictions and add one
     */
    addRestriction(columnName, restriction) {
        const ret = {};
        for (const key of Object.keys(this.restrictions)) {
            ret[key] = this.restrictions[key].slice();
        }
        if (!(columnName in ret)) {
            ret[columnName] = [];
        }
        ret[columnName].push(restriction);
        return ret;
    }
}
exports.SpaceDelimitedTextPattern = SpaceDelimitedTextPattern;
_c = JSII_RTTI_SYMBOL_1;
SpaceDelimitedTextPattern[_c] = { fqn: "@aws-cdk/aws-logs.SpaceDelimitedTextPattern", version: "1.156.1" };
/**
 * Quote a term for use in a pattern expression
 *
 * It's never wrong to quote a string term, and required if the term
 * contains non-alphanumerical characters, so we just always do it.
 *
 * Inner double quotes are escaped using a backslash.
 */
function quoteTerm(term) {
    return '"' + term.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
}
/**
 * Return whether the given column name is valid in a space-delimited table
 */
function validColumnName(column) {
    return column === COL_ELLIPSIS || /^[a-zA-Z0-9_-]+$/.exec(column);
}
/**
 * Validate and normalize the string comparison operator
 *
 * Correct for a common typo/confusion, treat '==' as '='
 */
function validateStringOperator(operator) {
    if (operator === '==') {
        operator = '=';
    }
    if (operator !== '=' && operator !== '!=') {
        throw new Error(`Invalid comparison operator ('${operator}'), must be either '=' or '!='`);
    }
    return operator;
}
const VALID_OPERATORS = ['=', '!=', '<', '<=', '>', '>='];
/**
 * Validate and normalize numerical comparison operators
 *
 * Correct for a common typo/confusion, treat '==' as '='
 */
function validateNumericalOperator(operator) {
    // Correct for a common typo, treat '==' as '='
    if (operator === '==') {
        operator = '=';
    }
    if (VALID_OPERATORS.indexOf(operator) === -1) {
        throw new Error(`Invalid comparison operator ('${operator}'), must be one of ${VALID_OPERATORS.join(', ')}`);
    }
    return operator;
}
/**
 * Render a table restriction
 */
function renderRestriction(column, restriction) {
    if (restriction.numberValue !== undefined) {
        return `${column} ${restriction.comparison} ${restriction.numberValue}`;
    }
    else if (restriction.stringValue) {
        return `${column} ${restriction.comparison} ${quoteTerm(restriction.stringValue)}`;
    }
    else {
        throw new Error('Invalid restriction');
    }
}
function sum(xs) {
    return xs.reduce((a, c) => a + c, 0);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pattern.js","sourceRoot":"","sources":["pattern.ts"],"names":[],"mappings":"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","sourcesContent":["// Implementation of metric patterns\n\n/**\n * Interface for objects that can render themselves to log patterns.\n */\nexport interface IFilterPattern {\n  readonly logPatternString: string;\n}\n\n/**\n * Base class for patterns that only match JSON log events.\n */\nexport abstract class JsonPattern implements IFilterPattern {\n  // This is a separate class so we have some type safety where users can't\n  // combine text patterns and JSON patterns with an 'and' operation.\n  constructor(public readonly jsonPatternString: string) { }\n\n  public get logPatternString(): string {\n    return '{ ' + this.jsonPatternString + ' }';\n  }\n}\n\n/**\n * A collection of static methods to generate appropriate ILogPatterns\n */\nexport class FilterPattern {\n\n  /**\n   * Use the given string as log pattern.\n   *\n   * See https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html\n   * for information on writing log patterns.\n   *\n   * @param logPatternString The pattern string to use.\n   */\n  public static literal(logPatternString: string): IFilterPattern {\n    return new LiteralLogPattern(logPatternString);\n  }\n\n  /**\n   * A log pattern that matches all events.\n   */\n  public static allEvents(): IFilterPattern {\n    return new LiteralLogPattern('');\n  }\n\n  /**\n   * A log pattern that matches if all the strings given appear in the event.\n   *\n   * @param terms The words to search for. All terms must match.\n   */\n  public static allTerms(...terms: string[]): IFilterPattern {\n    return new TextLogPattern([terms]);\n  }\n\n  /**\n   * A log pattern that matches if any of the strings given appear in the event.\n   *\n   * @param terms The words to search for. Any terms must match.\n   */\n  public static anyTerm(...terms: string[]): IFilterPattern {\n    return new TextLogPattern(terms.map(t => [t]));\n  }\n\n  /**\n   * A log pattern that matches if any of the given term groups matches the event.\n   *\n   * A term group matches an event if all the terms in it appear in the event string.\n   *\n   * @param termGroups A list of term groups to search for. Any one of the clauses must match.\n   */\n  public static anyTermGroup(...termGroups: string[][]): IFilterPattern {\n    return new TextLogPattern(termGroups);\n  }\n\n  /**\n   * A JSON log pattern that compares string values.\n   *\n   * This pattern only matches if the event is a JSON event, and the indicated field inside\n   * compares with the string value.\n   *\n   * Use '$' to indicate the root of the JSON structure. The comparison operator can only\n   * compare equality or inequality. The '*' wildcard may appear in the value may at the\n   * start or at the end.\n   *\n   * For more information, see:\n   *\n   * https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html\n   *\n   * @param jsonField Field inside JSON. Example: \"$.myField\"\n   * @param comparison Comparison to carry out. Either = or !=.\n   * @param value The string value to compare to. May use '*' as wildcard at start or end of string.\n   */\n  public static stringValue(jsonField: string, comparison: string, value: string): JsonPattern {\n    return new JSONStringPattern(jsonField, comparison, value);\n  }\n\n  /**\n   * A JSON log pattern that compares numerical values.\n   *\n   * This pattern only matches if the event is a JSON event, and the indicated field inside\n   * compares with the value in the indicated way.\n   *\n   * Use '$' to indicate the root of the JSON structure. The comparison operator can only\n   * compare equality or inequality. The '*' wildcard may appear in the value may at the\n   * start or at the end.\n   *\n   * For more information, see:\n   *\n   * https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html\n   *\n   * @param jsonField Field inside JSON. Example: \"$.myField\"\n   * @param comparison Comparison to carry out. One of =, !=, <, <=, >, >=.\n   * @param value The numerical value to compare to\n   */\n  public static numberValue(jsonField: string, comparison: string, value: number): JsonPattern {\n    return new JSONNumberPattern(jsonField, comparison, value);\n  }\n\n  /**\n   * A JSON log pattern that matches if the field exists and has the special value 'null'.\n   *\n   * @param jsonField Field inside JSON. Example: \"$.myField\"\n   */\n  public static isNull(jsonField: string): JsonPattern {\n    return new JSONPostfixPattern(jsonField, 'IS NULL');\n  }\n\n  /**\n   * A JSON log pattern that matches if the field does not exist.\n   *\n   * @param jsonField Field inside JSON. Example: \"$.myField\"\n   */\n  public static notExists(jsonField: string): JsonPattern {\n    return new JSONPostfixPattern(jsonField, 'NOT EXISTS');\n  }\n\n  /**\n   * A JSON log patter that matches if the field exists.\n   *\n   * This is a readable convenience wrapper over 'field = *'\n   *\n   * @param jsonField Field inside JSON. Example: \"$.myField\"\n   */\n  public static exists(jsonField: string): JsonPattern {\n    return new JSONStringPattern(jsonField, '=', '*');\n  }\n\n  /**\n   * A JSON log pattern that matches if the field exists and equals the boolean value.\n   *\n   * @param jsonField Field inside JSON. Example: \"$.myField\"\n   * @param value The value to match\n   */\n  public static booleanValue(jsonField: string, value: boolean): JsonPattern {\n    return new JSONPostfixPattern(jsonField, value ? 'IS TRUE' : 'IS FALSE');\n  }\n\n  /**\n   * A JSON log pattern that matches if all given JSON log patterns match\n   */\n  public static all(...patterns: JsonPattern[]): JsonPattern {\n    if (patterns.length === 0) { throw new Error('Must supply at least one pattern, or use allEvents() to match all events.'); }\n    if (patterns.length === 1) { return patterns[0]; }\n    return new JSONAggregatePattern('&&', patterns);\n  }\n\n  /**\n   * A JSON log pattern that matches if any of the given JSON log patterns match\n   */\n  public static any(...patterns: JsonPattern[]): JsonPattern {\n    if (patterns.length === 0) { throw new Error('Must supply at least one pattern'); }\n    if (patterns.length === 1) { return patterns[0]; }\n    return new JSONAggregatePattern('||', patterns);\n  }\n\n  /**\n   * A space delimited log pattern matcher.\n   *\n   * The log event is divided into space-delimited columns (optionally\n   * enclosed by \"\" or [] to capture spaces into column values), and names\n   * are given to each column.\n   *\n   * '...' may be specified once to match any number of columns.\n   *\n   * Afterwards, conditions may be added to individual columns.\n   *\n   * @param columns The columns in the space-delimited log stream.\n   */\n  public static spaceDelimited(...columns: string[]): SpaceDelimitedTextPattern {\n    return SpaceDelimitedTextPattern.construct(columns);\n  }\n}\n\n/**\n * Use a string literal as a log pattern\n */\nclass LiteralLogPattern implements IFilterPattern {\n  constructor(public readonly logPatternString: string) {\n  }\n}\n\n/**\n * Search for a set of set of terms\n */\nclass TextLogPattern implements IFilterPattern {\n  public readonly logPatternString: string;\n\n  constructor(clauses: string[][]) {\n    const quotedClauses = clauses.map(terms => terms.map(quoteTerm).join(' '));\n    if (quotedClauses.length === 1) {\n      this.logPatternString = quotedClauses[0];\n    } else {\n      this.logPatternString = quotedClauses.map(alt => '?' + alt).join(' ');\n    }\n  }\n}\n\n/**\n * A string comparison for JSON values\n */\nclass JSONStringPattern extends JsonPattern {\n  public constructor(jsonField: string, comparison: string, value: string) {\n    comparison = validateStringOperator(comparison);\n    super(`${jsonField} ${comparison} ${quoteTerm(value)}`);\n  }\n}\n\n/**\n * A number comparison for JSON values\n */\nclass JSONNumberPattern extends JsonPattern {\n  public constructor(jsonField: string, comparison: string, value: number) {\n    comparison = validateNumericalOperator(comparison);\n    super(`${jsonField} ${comparison} ${value}`);\n  }\n}\n\n/**\n * A postfix operator for JSON patterns\n */\nclass JSONPostfixPattern extends JsonPattern {\n  public constructor(jsonField: string, postfix: string) {\n    // No validation, we assume these are generated by trusted factory functions\n    super(`${jsonField} ${postfix}`);\n  }\n}\n\n/**\n * Combines multiple other JSON patterns with an operator\n */\nclass JSONAggregatePattern extends JsonPattern {\n  public constructor(operator: string, patterns: JsonPattern[]) {\n    if (operator !== '&&' && operator !== '||') {\n      throw new Error('Operator must be one of && or ||');\n    }\n\n    const clauses = patterns.map(p => '(' + p.jsonPatternString + ')');\n\n    super(clauses.join(` ${operator} `));\n  }\n}\n\nexport type RestrictionMap = {[column: string]: ColumnRestriction[]};\n\nconst COL_ELLIPSIS = '...';\n\n/**\n * Space delimited text pattern\n */\nexport class SpaceDelimitedTextPattern implements IFilterPattern {\n  /**\n   * Construct a new instance of a space delimited text pattern\n   *\n   * Since this class must be public, we can't rely on the user only creating it through\n   * the `LogPattern.spaceDelimited()` factory function. We must therefore validate the\n   * argument in the constructor. Since we're returning a copy on every mutation, and we\n   * don't want to re-validate the same things on every construction, we provide a limited\n   * set of mutator functions and only validate the new data every time.\n   */\n  public static construct(columns: string[]) {\n    // Validation happens here because a user could instantiate this object directly without\n    // going through the factory\n    for (const column of columns) {\n      if (!validColumnName(column)) {\n        throw new Error(`Invalid column name: ${column}`);\n      }\n    }\n\n    if (sum(columns.map(c => c === COL_ELLIPSIS ? 1 : 0)) > 1) {\n      throw new Error(\"Can use at most one '...' column\");\n    }\n\n    return new SpaceDelimitedTextPattern(columns, {});\n  }\n\n  // TODO: Temporarily changed from private to protected to unblock build. We need to think\n  //     about how to handle jsii types with private constructors.\n  protected constructor(private readonly columns: string[], private readonly restrictions: RestrictionMap) {\n    // Private constructor so we validate in the .construct() factory function\n  }\n\n  /**\n   * Restrict where the pattern applies\n   */\n  public whereString(columnName: string, comparison: string, value: string): SpaceDelimitedTextPattern {\n    if (columnName === COL_ELLIPSIS) {\n      throw new Error(\"Can't use '...' in a restriction\");\n    }\n    if (this.columns.indexOf(columnName) === -1) {\n      throw new Error(`Column in restrictions that is not in columns: ${columnName}`);\n    }\n\n    comparison = validateStringOperator(comparison);\n\n    return new SpaceDelimitedTextPattern(this.columns, this.addRestriction(columnName, {\n      comparison,\n      stringValue: value,\n    }));\n  }\n\n  /**\n   * Restrict where the pattern applies\n   */\n  public whereNumber(columnName: string, comparison: string, value: number): SpaceDelimitedTextPattern {\n    if (columnName === COL_ELLIPSIS) {\n      throw new Error(\"Can't use '...' in a restriction\");\n    }\n    if (this.columns.indexOf(columnName) === -1) {\n      throw new Error(`Column in restrictions that is not in columns: ${columnName}`);\n    }\n\n    comparison = validateNumericalOperator(comparison);\n\n    return new SpaceDelimitedTextPattern(this.columns, this.addRestriction(columnName, {\n      comparison,\n      numberValue: value,\n    }));\n  }\n\n  public get logPatternString(): string {\n    return '[' + this.columns.map(this.columnExpression.bind(this)).join(', ') + ']';\n  }\n\n  /**\n   * Return the column expression for the given column\n   */\n  private columnExpression(column: string) {\n    const restrictions = this.restrictions[column];\n    if (!restrictions) { return column; }\n\n    return restrictions.map(r => renderRestriction(column, r)).join(' && ');\n  }\n\n  /**\n   * Make a copy of the current restrictions and add one\n   */\n  private addRestriction(columnName: string, restriction: ColumnRestriction) {\n    const ret: RestrictionMap = {};\n    for (const key of Object.keys(this.restrictions)) {\n      ret[key] = this.restrictions[key].slice();\n    }\n    if (!(columnName in ret)) { ret[columnName] = []; }\n    ret[columnName].push(restriction);\n    return ret;\n  }\n}\n\nexport interface ColumnRestriction {\n  /**\n   * Comparison operator to use\n   */\n  readonly comparison: string;\n\n  /**\n   * String value to compare to\n   *\n   * Exactly one of 'stringValue' and 'numberValue' must be set.\n   */\n  readonly stringValue?: string;\n\n  /**\n   * Number value to compare to\n   *\n   * Exactly one of 'stringValue' and 'numberValue' must be set.\n   */\n  readonly numberValue?: number;\n}\n\n/**\n * Quote a term for use in a pattern expression\n *\n * It's never wrong to quote a string term, and required if the term\n * contains non-alphanumerical characters, so we just always do it.\n *\n * Inner double quotes are escaped using a backslash.\n */\nfunction quoteTerm(term: string): string {\n  return '\"' + term.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"') + '\"';\n}\n\n/**\n * Return whether the given column name is valid in a space-delimited table\n */\nfunction validColumnName(column: string) {\n  return column === COL_ELLIPSIS || /^[a-zA-Z0-9_-]+$/.exec(column);\n}\n\n/**\n * Validate and normalize the string comparison operator\n *\n * Correct for a common typo/confusion, treat '==' as '='\n */\nfunction validateStringOperator(operator: string) {\n  if (operator === '==') { operator = '='; }\n\n  if (operator !== '=' && operator !== '!=') {\n    throw new Error(`Invalid comparison operator ('${operator}'), must be either '=' or '!='`);\n  }\n\n  return operator;\n}\n\nconst VALID_OPERATORS = ['=', '!=', '<', '<=', '>', '>='];\n\n/**\n * Validate and normalize numerical comparison operators\n *\n * Correct for a common typo/confusion, treat '==' as '='\n */\nfunction validateNumericalOperator(operator: string) {\n  // Correct for a common typo, treat '==' as '='\n  if (operator === '==') { operator = '='; }\n\n  if (VALID_OPERATORS.indexOf(operator) === -1) {\n    throw new Error(`Invalid comparison operator ('${operator}'), must be one of ${VALID_OPERATORS.join(', ')}`);\n  }\n\n  return operator;\n}\n\n/**\n * Render a table restriction\n */\nfunction renderRestriction(column: string, restriction: ColumnRestriction) {\n  if (restriction.numberValue !== undefined) {\n    return `${column} ${restriction.comparison} ${restriction.numberValue}`;\n  } else if (restriction.stringValue) {\n    return `${column} ${restriction.comparison} ${quoteTerm(restriction.stringValue)}`;\n  } else {\n    throw new Error('Invalid restriction');\n  }\n}\n\nfunction sum(xs: number[]): number {\n  return xs.reduce((a, c) => a + c, 0);\n}\n"]}