terraconstructs 0.0.8

package/lib/aws/cloudwatch/pattern.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Interface for objects that can render themselves to log patterns.
+ */
+export interface IFilterPattern {
+    readonly logPatternString: string;
+}
+/**
+ * Base class for patterns that only match JSON log events.
+ */
+export declare abstract class JsonPattern implements IFilterPattern {
+    readonly jsonPatternString: string;
+    constructor(jsonPatternString: string);
+    get logPatternString(): string;
+}
+/**
+ * A collection of static methods to generate appropriate ILogPatterns
+ */
+export declare 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: string): IFilterPattern;
+    /**
+     * A log pattern that matches all events.
+     */
+    static allEvents(): IFilterPattern;
+    /**
+     * 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: string[]): IFilterPattern;
+    /**
+     * 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: string[]): IFilterPattern;
+    /**
+     * 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: string[][]): IFilterPattern;
+    /**
+     * 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: string, comparison: string, value: string): JsonPattern;
+    /**
+     * 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: string, comparison: string, value: number): JsonPattern;
+    /**
+     * 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: string): JsonPattern;
+    /**
+     * A JSON log pattern that matches if the field does not exist.
+     *
+     * @param jsonField Field inside JSON. Example: "$.myField"
+     */
+    static notExists(jsonField: string): JsonPattern;
+    /**
+     * 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: string): JsonPattern;
+    /**
+     * 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: string, value: boolean): JsonPattern;
+    /**
+     * A JSON log pattern that matches if all given JSON log patterns match
+     */
+    static all(...patterns: JsonPattern[]): JsonPattern;
+    /**
+     * A JSON log pattern that matches if any of the given JSON log patterns match
+     */
+    static any(...patterns: JsonPattern[]): JsonPattern;
+    /**
+     * 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: string[]): SpaceDelimitedTextPattern;
+}
+export type RestrictionMap = {
+    [column: string]: ColumnRestriction[];
+};
+/**
+ * Space delimited text pattern
+ */
+export declare class SpaceDelimitedTextPattern implements IFilterPattern {
+    private readonly columns;
+    private readonly 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: string[]): SpaceDelimitedTextPattern;
+    protected constructor(columns: string[], restrictions: RestrictionMap);
+    /**
+     * Restrict where the pattern applies
+     */
+    whereString(columnName: string, comparison: string, value: string): SpaceDelimitedTextPattern;
+    /**
+     * Restrict where the pattern applies
+     */
+    whereNumber(columnName: string, comparison: string, value: number): SpaceDelimitedTextPattern;
+    get logPatternString(): string;
+    /**
+     * Return the column expression for the given column
+     */
+    private columnExpression;
+    /**
+     * Make a copy of the current restrictions and add one
+     */
+    private addRestriction;
+}
+export interface ColumnRestriction {
+    /**
+     * Comparison operator to use
+     */
+    readonly comparison: string;
+    /**
+     * String value to compare to
+     *
+     * Exactly one of 'stringValue' and 'numberValue' must be set.
+     */
+    readonly stringValue?: string;
+    /**
+     * Number value to compare to
+     *
+     * Exactly one of 'stringValue' and 'numberValue' must be set.
+     */
+    readonly numberValue?: number;
+}

package/lib/aws/cloudwatch/pattern.js

@@ -0,0 +1,412 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaceDelimitedTextPattern = exports.FilterPattern = exports.JsonPattern = void 0;
+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: "terraconstructs.aws.cloudwatch.JsonPattern", version: "0.0.8" };
+/**
+ * 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) {
+        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) {
+        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: "terraconstructs.aws.cloudwatch.FilterPattern", version: "0.0.8" };
+/**
+ * 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 {
+    /**
+     * 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, {});
+    }
+    // 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;
+        // Private constructor so we validate in the .construct() factory function
+    }
+    /**
+     * 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: "terraconstructs.aws.cloudwatch.SpaceDelimitedTextPattern", version: "0.0.8" };
+/**
+ * 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":["../../../src/aws/cloudwatch/pattern.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-logs/lib/pattern.ts\n\n// 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   * 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(\n    jsonField: string,\n    comparison: string,\n    value: string,\n  ): 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(\n    jsonField: string,\n    comparison: string,\n    value: number,\n  ): 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) {\n      throw new Error(\n        \"Must supply at least one pattern, or use allEvents() to match all events.\",\n      );\n    }\n    if (patterns.length === 1) {\n      return patterns[0];\n    }\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) {\n      throw new Error(\"Must supply at least one pattern\");\n    }\n    if (patterns.length === 1) {\n      return patterns[0];\n    }\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(\n    ...columns: string[]\n  ): 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 * 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) =>\n      terms.map(quoteTerm).join(\" \"),\n    );\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(\n    private readonly columns: string[],\n    private readonly restrictions: RestrictionMap,\n  ) {\n    // Private constructor so we validate in the .construct() factory function\n  }\n\n  /**\n   * Restrict where the pattern applies\n   */\n  public whereString(\n    columnName: string,\n    comparison: string,\n    value: string,\n  ): 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(\n        `Column in restrictions that is not in columns: ${columnName}`,\n      );\n    }\n\n    comparison = validateStringOperator(comparison);\n\n    return new SpaceDelimitedTextPattern(\n      this.columns,\n      this.addRestriction(columnName, {\n        comparison,\n        stringValue: value,\n      }),\n    );\n  }\n\n  /**\n   * Restrict where the pattern applies\n   */\n  public whereNumber(\n    columnName: string,\n    comparison: string,\n    value: number,\n  ): 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(\n        `Column in restrictions that is not in columns: ${columnName}`,\n      );\n    }\n\n    comparison = validateNumericalOperator(comparison);\n\n    return new SpaceDelimitedTextPattern(\n      this.columns,\n      this.addRestriction(columnName, {\n        comparison,\n        numberValue: value,\n      }),\n    );\n  }\n\n  public get logPatternString(): string {\n    return (\n      \"[\" + this.columns.map(this.columnExpression.bind(this)).join(\", \") + \"]\"\n    );\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) {\n      return column;\n    }\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)) {\n      ret[columnName] = [];\n    }\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 === \"==\") {\n    operator = \"=\";\n  }\n\n  if (operator !== \"=\" && operator !== \"!=\") {\n    throw new Error(\n      `Invalid comparison operator ('${operator}'), must be either '=' or '!='`,\n    );\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 === \"==\") {\n    operator = \"=\";\n  }\n\n  if (VALID_OPERATORS.indexOf(operator) === -1) {\n    throw new Error(\n      `Invalid comparison operator ('${operator}'), must be one of ${VALID_OPERATORS.join(\", \")}`,\n    );\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"]}