@malloydata/malloy-filter 0.0.237-dev250221201621

package/src/a_simple_serializer.ts

@@ -0,0 +1,40 @@
+import {FilterSerializer} from './filter_serializer';
+import {
+  NumberClause,
+  StringCondition,
+  BooleanClause,
+  DateClause,
+} from './clause_types';
+
+/* eslint-disable no-console */
+function aSimpleSerializer() {
+  const strings: StringCondition[] = [{operator: '=', values: ['CAT', 'DOG']}];
+  let response = new FilterSerializer(strings, 'string').serialize();
+  console.log(...strings, '\n', response.result, '\n');
+
+  const numbers: NumberClause[] = [
+    {
+      operator: 'range',
+      startOperator: '>=',
+      startValue: -5.5,
+      endOperator: '<',
+      endValue: 10,
+    },
+  ];
+  response = new FilterSerializer(numbers, 'number').serialize();
+  console.log(...numbers, '\n', response.result, '\n');
+
+  const booleans: BooleanClause[] = [{operator: 'NULL'}, {operator: 'TRUE'}];
+
+  response = new FilterSerializer(booleans, 'boolean').serialize();
+  console.log(...booleans, '\n', response.result, '\n');
+
+  const dates: DateClause[] = [
+    {operator: 'YESTERDAY'},
+    {operator: 'NEXT', unit: 'TUESDAY'},
+  ];
+  response = new FilterSerializer(dates, 'date').serialize();
+  console.log(...dates, '\n', response.result, '\n');
+}
+
+aSimpleSerializer();

package/src/base_parser.ts

@@ -0,0 +1,45 @@
+import {Token} from './token_types';
+import {FilterParserResponse} from './filter_types';
+
+export abstract class BaseParser {
+  protected inputString: string;
+  protected index: number;
+  protected tokens: Token[];
+
+  constructor(inputString: string) {
+    this.index = 0;
+    this.tokens = [];
+    this.inputString = inputString;
+  }
+
+  public getTokens(): Token[] {
+    return this.tokens;
+  }
+
+  public abstract parse(): FilterParserResponse;
+
+  protected getAt(index: number): Token {
+    return this.tokens[index];
+  }
+
+  protected getNext(): Token {
+    return this.getAt(this.index);
+  }
+
+  protected static matchTokenTypes(
+    candidates: string[],
+    index: number,
+    tokens: Token[]
+  ): boolean {
+    const maxIndex = index + candidates.length;
+    if (index < 0 || maxIndex > tokens.length) {
+      return false;
+    }
+    for (let i = 0; i < candidates.length; i++) {
+      if (candidates[i] !== tokens[i + index].type) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

package/src/base_serializer.ts

@@ -0,0 +1,9 @@
+import {Clause} from './clause_types';
+
+export abstract class BaseSerializer {
+  constructor(protected clauses: Clause[]) {
+    this.clauses = clauses;
+  }
+
+  public abstract serialize(): string;
+}

package/src/boolean_parser.ts

@@ -0,0 +1,60 @@
+import {SpecialToken, Tokenizer, TokenizerParams} from './tokenizer';
+import {BooleanClause, BooleanOperator} from './clause_types';
+import {BaseParser} from './base_parser';
+import {FilterParserResponse, FilterError} from './filter_types';
+
+export class BooleanParser extends BaseParser {
+  constructor(input: string) {
+    super(input);
+  }
+
+  private tokenize(): void {
+    const specialSubstrings: SpecialToken[] = [{type: ',', value: ','}];
+    const specialWords: SpecialToken[] = [
+      {type: 'NULL', value: 'null', ignoreCase: true},
+      {type: 'NOTNULL', value: '-null', ignoreCase: true},
+      {type: 'TRUE', value: 'true', ignoreCase: true},
+      {type: 'FALSE', value: 'false', ignoreCase: true},
+    ];
+    const params: TokenizerParams = {
+      trimWordWhitespace: true,
+      splitOnWhitespace: true,
+      specialSubstrings,
+      specialWords: specialWords,
+    };
+
+    const tokenizer = new Tokenizer(this.inputString, params);
+    this.tokens = tokenizer.parse();
+    this.tokens = Tokenizer.convertSpecialWords(this.tokens, specialWords);
+  }
+
+  public parse(): FilterParserResponse {
+    this.index = 0;
+    this.tokenize();
+    const clauses: BooleanClause[] = [];
+    const errors: FilterError[] = [];
+    while (this.index < this.tokens.length) {
+      const token = this.getNext();
+      if (token.type === ',') {
+        this.index++;
+      } else if (
+        token.type === 'NULL' ||
+        token.type === 'TRUE' ||
+        token.type === 'FALSE' ||
+        token.type === 'NOTNULL'
+      ) {
+        const clause: BooleanClause = {operator: token.type as BooleanOperator};
+        clauses.push(clause);
+        this.index++;
+      } else {
+        errors.push({
+          message: 'Invalid token ' + token.value,
+          startIndex: token.startIndex,
+          endIndex: token.endIndex,
+        });
+        this.index++;
+      }
+    }
+    return {clauses, errors};
+  }
+}

package/src/boolean_serializer.ts

@@ -0,0 +1,32 @@
+import {BooleanClause, Clause} from './clause_types';
+import {BaseSerializer} from './base_serializer';
+
+export class BooleanSerializer extends BaseSerializer {
+  constructor(clauses: Clause[]) {
+    super(clauses);
+  }
+
+  public serialize(): string {
+    const result = BooleanSerializer.clauseToString(this.clauses);
+    return result.trim().replace(/,$/, '');
+  }
+
+  private static booleanClauseToString(clause: BooleanClause): string {
+    return clause.operator === 'NOTNULL' ? '-NULL' : clause.operator;
+  }
+
+  private static clauseToString(clauses: Clause[]): string {
+    let result = '';
+    for (const clause of clauses) {
+      if ('operator' in clause) {
+        result += BooleanSerializer.booleanClauseToString(
+          clause as BooleanClause
+        );
+      } else {
+        throw new Error('Invalid boolean clause ' + JSON.stringify(clause));
+      }
+      result += ', ';
+    }
+    return result;
+  }
+}

package/src/clause_types.ts

@@ -0,0 +1,160 @@
+export type NumberOperator = '<=' | '>=' | '!=' | '=' | '>' | '<';
+
+export type NumberValue = number | null;
+
+export interface NumberCondition {
+  operator: NumberOperator;
+  values: NumberValue[];
+}
+
+export type NumberRangeOperator = '<=' | '>=' | '>' | '<';
+
+export interface NumberRange {
+  operator: 'range';
+  startOperator: NumberRangeOperator;
+  startValue: NumberValue;
+  endOperator: NumberRangeOperator;
+  endValue: NumberValue;
+}
+
+export type QuoteType =
+  | 'SINGLE'
+  | 'DOUBLE'
+  | 'BACKTICK'
+  | 'TRIPLESINGLE'
+  | 'TRIPLEDOUBLE'
+  | 'ESCAPEDSINGLE'
+  | 'ESCAPEDDOUBLE'
+  | 'ESCAPEDBACKTICK';
+
+export type StringOperator =
+  | 'EMPTY'
+  | 'NOTEMPTY'
+  | 'starts'
+  | 'ends'
+  | 'contains'
+  | 'notStarts'
+  | 'notEnds'
+  | 'notContains'
+  | '~'
+  | '='
+  | '!~'
+  | '!=';
+
+export type StringValue = string | null;
+
+export interface StringCondition {
+  operator: StringOperator;
+  values: StringValue[];
+  quotes?: QuoteType[]; // List of quote types found in the string.
+}
+
+export type BooleanOperator = 'TRUE' | 'FALSE' | 'NULL' | 'NOTNULL';
+
+export interface BooleanClause {
+  operator: BooleanOperator;
+}
+
+export type DatePrefix = 'BEFORE' | 'AFTER';
+
+export type DateTimeUnit =
+  | 'YEAR'
+  | 'QUARTER'
+  | 'MONTH'
+  | 'WEEK'
+  | 'DAY'
+  | 'HOUR'
+  | 'MINUTE'
+  | 'SECOND';
+
+export type DateWeekday =
+  | 'MONDAY'
+  | 'TUESDAY'
+  | 'WEDNESDAY'
+  | 'THURSDAY'
+  | 'FRIDAY'
+  | 'SATURDAY'
+  | 'SUNDAY';
+
+export type DateMomentNowOperator = 'NOW' | 'TODAY' | 'YESTERDAY' | 'TOMORROW';
+
+// now, after today, before yesterday, tomorrow
+export interface DateMomentNow {
+  prefix?: DatePrefix;
+  operator: DateMomentNowOperator;
+}
+
+export type DateMomentIntervalOperator = 'LAST' | 'THIS' | 'NEXT';
+
+// LAST|UNITOFTIME, LAST|DAYOFWEEK
+// THIS|UNITOFTIME
+// NEXT|UNITOFTIME, NEXT|DAYOFWEEK
+// before last month, after next tuesday, this month
+export interface DateMomentInterval {
+  prefix?: DatePrefix;
+  operator: DateMomentIntervalOperator;
+  unit: DateTimeUnit | DateWeekday;
+}
+
+export type DateMomentNumberIntervalOperator =
+  | 'LASTN'
+  | 'NEXTN'
+  | 'AGO'
+  | 'FROMNOW';
+
+// LAST|NUMBER|UNITOFTIME
+// NEXT|NUMBER|UNITOFTIME
+// NUMBER|UNITOFTIME|AGO
+// NUMBER|UNITOFTIME|FROM|NOW
+// before 3 hours ago, next 5 days, 2025 seconds ago, after 6 weeks from now
+export interface DateMomentNumberInterval {
+  prefix?: DatePrefix;
+  operator: DateMomentNumberIntervalOperator;
+  unit: DateTimeUnit;
+  value: string;
+}
+
+export type DateMomentNumberUnitOperator = 'TIMEBLOCK';
+
+// NUMBER|UNITOFTIME
+// 2025 seconds, after 32 hours
+export interface DateMomentNumberUnit {
+  prefix?: DatePrefix;
+  operator: DateMomentNumberUnitOperator;
+  unit: DateTimeUnit;
+  value: string;
+}
+
+export type DateMomentNumberOperator = 'DATE' | 'DATETIME';
+
+// DATE|TIME, DATE
+// after 2025, before 2025-08-04, 2025-08-04 08:11:52
+export interface DateMomentNumber {
+  prefix?: DatePrefix;
+  operator: DateMomentNumberOperator;
+  date: string;
+  time?: string;
+}
+
+export type DateMoment =
+  | DateMomentNow
+  | DateMomentInterval
+  | DateMomentNumberInterval
+  | DateMomentNumberUnit
+  | DateMomentNumber;
+
+export interface DateRange {
+  start: DateMoment;
+  operator: 'TO' | 'FOR';
+  end: DateMoment;
+}
+
+export type NumberClause = NumberCondition | NumberRange;
+
+export type DateClause = DateMoment | DateRange;
+
+export type Clause =
+  | NumberClause
+  | StringCondition
+  | BooleanClause
+  | DateClause;