@malloydata/malloy-filter 0.0.237-dev250222025222 → 0.0.237-dev250222034547

package/src/date_serializer.ts

@@ -1,17 +1,13 @@
 import {
-  DateRange,
   DateMoment,
-  DateMomentInterval,
-  DateMomentNumberInterval,
-  DateMomentNumberUnit,
-  DateMomentNumber,
-  Clause,
-} from './clause_types';
-import {BaseSerializer} from './base_serializer';
+  DateBetweenClause,
+  DateForClause,
+  DateClause,
+} from './date_types';
 
-export class DateSerializer extends BaseSerializer {
-  constructor(clauses: Clause[]) {
-    super(clauses);
+export class DateSerializer {
+  constructor(private clauses: DateClause[]) {
+    this.clauses = clauses;
   }
 
   public serialize(): string {
@@ -19,95 +15,67 @@ export class DateSerializer extends BaseSerializer {
     return result.trim().replace(/,$/, '');
   }
 
-  private static dateMomentToString(operator: string, clause: Clause): string {
-    if (
-      operator === 'NOW' ||
-      operator === 'TODAY' ||
-      operator === 'YESTERDAY' ||
-      operator === 'TOMORROW'
-    ) {
-      const custom: DateMoment = clause as DateMoment;
-      return custom.prefix ? custom.prefix + ' ' + operator : operator;
-    } else if (
-      operator === 'LAST' ||
-      operator === 'THIS' ||
-      operator === 'NEXT'
-    ) {
-      const custom: DateMomentInterval = clause as DateMomentInterval;
-      let value = custom.operator + ' ' + custom.unit;
-      if (custom.prefix) {
-        value = custom.prefix + ' ' + value;
-      }
-      return value;
-    } else if (operator === 'LASTN' || operator === 'NEXTN') {
-      const custom: DateMomentNumberInterval =
-        clause as DateMomentNumberInterval;
-      operator = operator.substring(0, 4); // Strip "N"
-      let value = operator + ' ' + custom.value + ' ' + custom.unit;
-      if (custom.prefix) {
-        value = custom.prefix + ' ' + value;
-      }
-      return value;
-    } else if (operator === 'AGO' || operator === 'FROMNOW') {
-      const custom: DateMomentNumberInterval =
-        clause as DateMomentNumberInterval;
-      if (operator === 'FROMNOW') operator = 'FROM NOW';
-      let value = custom.value + ' ' + custom.unit + ' ' + operator;
-      if (custom.prefix) {
-        value = custom.prefix + ' ' + value;
-      }
-      return value;
-    } else if (operator === 'TIMEBLOCK') {
-      const custom: DateMomentNumberUnit = clause as DateMomentNumberUnit;
-      let value = custom.value + ' ' + custom.unit;
-      if (custom.prefix) {
-        value = custom.prefix + ' ' + value;
-      }
-      return value;
-    } else if (operator === 'DATE' || operator === 'DATETIME') {
-      const custom: DateMomentNumber = clause as DateMomentNumber;
-      let value = custom.date;
-      if (custom.time) {
-        value = value + ' ' + custom.time;
-      }
-      if (custom.prefix) {
-        value = custom.prefix + ' ' + value;
-      }
-      return value;
+  private static dateMomentToString(moment: DateMoment): string {
+    if (moment.type === 'ABSOLUTE') {
+      return moment.date;
+    } else if (moment.type === 'INTERVAL') {
+      return moment.kind + ' ' + moment.unit;
+    } else if (moment.type === 'NAMED') {
+      return moment.name;
+    } else if (moment.type === 'OFFSET_FROM_NOW') {
+      const direction = moment.direction === 'FROMNOW' ? 'FROM NOW' : 'AGO';
+      return moment.amount + ' ' + moment.unit + ' ' + direction;
+    } else if (moment.type === 'SPAN_FROM_NOW') {
+      return moment.direction + ' ' + moment.amount + ' ' + moment.unit;
+    } else {
+      throw new Error('moment type not recognized ' + JSON.stringify(moment));
     }
-    return '';
   }
 
-  private static dateRangeToString(
-    operator: 'TO' | 'FOR',
-    clause: DateRange
-  ): string {
+  private static goDateBetweenClause(clause: DateBetweenClause): string {
     return (
-      DateSerializer.dateMomentToString(clause.start.operator, clause.start) +
-      ' ' +
-      clause.operator +
+      DateSerializer.dateMomentToString(clause.from) +
+      ' TO ' +
+      DateSerializer.dateMomentToString(clause.to)
+    );
+  }
+
+  private static goDateForClause(clause: DateForClause): string {
+    return (
+      DateSerializer.dateMomentToString(clause.from) +
+      ' FOR ' +
+      clause.duration.amount +
       ' ' +
-      DateSerializer.dateMomentToString(clause.end.operator, clause.end)
+      clause.duration.unit
     );
   }
 
-  private static clauseToString(operator: string, clause: Clause): string {
-    if (operator === 'TO' || operator === 'FOR') {
-      const custom = clause as DateRange;
-      return DateSerializer.dateRangeToString(operator, custom);
+  private static clauseToString(clause: DateClause): string {
+    if (!('operator' in clause)) {
+      throw new Error('Invalid date clause ' + JSON.stringify(clause));
+    }
+    if (clause.operator === 'TO_RANGE') {
+      return DateSerializer.goDateBetweenClause(clause);
+    } else if (clause.operator === 'FOR_RANGE') {
+      return DateSerializer.goDateForClause(clause);
+    } else if (clause.operator === 'BEFORE') {
+      return 'BEFORE ' + DateSerializer.dateMomentToString(clause.moment);
+    } else if (clause.operator === 'AFTER') {
+      return 'AFTER ' + DateSerializer.dateMomentToString(clause.moment);
+    } else if (clause.operator === 'ON') {
+      return DateSerializer.dateMomentToString(clause.moment);
+    } else if (clause.operator === 'DURATION') {
+      return clause.duration.amount + ' ' + clause.duration.unit;
+    } else {
+      throw new Error('Clause type not recognized ' + JSON.stringify(clause));
     }
-    return DateSerializer.dateMomentToString(operator, clause);
   }
 
-  private static clausesToString(clauses: Clause[]): string {
+  private static clausesToString(clauses: DateClause[]): string {
     let result = '';
     for (const clause of clauses) {
-      if ('operator' in clause) {
-        result += DateSerializer.clauseToString(clause.operator, clause);
-        result += ', ';
-      } else {
-        throw new Error('Invalid date clause ' + JSON.stringify(clause));
-      }
+      result += DateSerializer.clauseToString(clause);
+      result += ', ';
     }
     return result;
   }

package/src/date_types.ts

@@ -0,0 +1,149 @@
+import {FilterError} from './clause_types';
+
+export type DateTimeUnit =
+  | 'YEAR'
+  | 'QUARTER'
+  | 'MONTH'
+  | 'WEEK'
+  | 'DAY'
+  | 'HOUR'
+  | 'MINUTE'
+  | 'SECOND';
+
+export type DateWeekday =
+  | 'MONDAY'
+  | 'TUESDAY'
+  | 'WEDNESDAY'
+  | 'THURSDAY'
+  | 'FRIDAY'
+  | 'SATURDAY'
+  | 'SUNDAY';
+
+// 7 weeks, 32 hours
+export interface Duration {
+  amount: number;
+  unit: DateTimeUnit;
+}
+
+export type DateMomentName = 'NOW' | 'TODAY' | 'YESTERDAY' | 'TOMORROW';
+
+// now, today, yesterday, tomorrow
+export interface NamedMoment {
+  type: 'NAMED';
+  name: DateMomentName;
+}
+
+export type DateMomentIntervalOperator = 'LAST' | 'THIS' | 'NEXT';
+
+// LAST|UNITOFTIME, LAST|DAYOFWEEK
+// THIS|UNITOFTIME
+// NEXT|UNITOFTIME, NEXT|DAYOFWEEK
+// last month, next tuesday, this month
+export interface IntervalMoment {
+  type: 'INTERVAL';
+  kind: DateMomentIntervalOperator;
+  unit: DateTimeUnit | DateWeekday;
+}
+
+export type DateMomentOffsetFromNowDirection = 'AGO' | 'FROMNOW';
+
+// NUMBER|UNITOFTIME|AGO
+// NUMBER|UNITOFTIME|FROM|NOW
+// 3 hours ago, 6 weeks from now
+export interface OffsetMoment {
+  type: 'OFFSET_FROM_NOW';
+  direction: DateMomentOffsetFromNowDirection;
+  unit: DateTimeUnit;
+  amount: number;
+}
+
+export type DateMomentSpanFromNowDirection = 'LAST' | 'NEXT';
+
+// LAST|NUMBER|UNITOFTIME
+// NEXT|NUMBER|UNITOFTIME
+// last 3 hours, next 2025 seconds, last 6 weeks
+export interface SpanMoment {
+  type: 'SPAN_FROM_NOW';
+  direction: DateMomentSpanFromNowDirection;
+  unit: DateTimeUnit;
+  amount: number;
+}
+
+// 2005, 2005-01, 2005-01-01, 2005-01-01 00:00, 2005-01-01 00:00:01
+export interface AbsoluteMoment {
+  type: 'ABSOLUTE';
+  date: string;
+  unit: DateTimeUnit;
+}
+
+// 2025-01
+// {
+//   operator: 'ON';
+//   moment: { date: '2025-01';
+//   unit: 'MONTH' }
+// }
+
+// after 2025-01
+// {
+//   operator: 'AFTER';
+//   moment: { date: '2025-01';
+//   unit: 'MONTH' }
+// }
+
+export type DateMoment =
+  | AbsoluteMoment //  2005-01
+  | NamedMoment // "today"
+  | IntervalMoment // "this month"
+  | SpanMoment // "last 3 weeks, next 3 weeks
+  | OffsetMoment; // "3 days ago"
+
+// after 2005-01, after 3 hours ago
+export interface DateAfterClause {
+  operator: 'AFTER';
+  moment: DateMoment;
+}
+
+// before 2005-01, before 3 hours ago
+export interface DateBeforeClause {
+  operator: 'BEFORE';
+  moment: DateMoment;
+}
+
+// next week, last 3 weeks, 3 days ago
+export interface DateOnClause {
+  operator: 'ON';
+  moment: DateMoment;
+}
+
+// 2015 to next month
+export interface DateBetweenClause {
+  operator: 'TO_RANGE';
+  from: DateMoment;
+  to: DateMoment;
+}
+
+// 2025-01-01 12:00:00 for 3 days
+export interface DateForClause {
+  operator: 'FOR_RANGE';
+  from: DateMoment;
+  duration: Duration;
+}
+
+// 3 days
+export interface DateDurationClause {
+  operator: 'DURATION';
+  duration: Duration;
+}
+
+export type DateClause =
+  | DateAfterClause
+  | DateBeforeClause
+  | DateOnClause
+  | DateBetweenClause
+  | DateForClause
+  | DateDurationClause;
+
+export interface DateParserResponse {
+  clauses: DateClause[];
+  errors: FilterError[];
+}

package/src/generate_samples.ts

@@ -1,15 +1,16 @@
-import {Clause} from './clause_types';
 import {SpecialToken, Tokenizer, TokenizerParams} from './tokenizer';
 import {BooleanParser} from './boolean_parser';
 import {StringParser} from './string_parser';
 import {NumberParser} from './number_parser';
 import {DateParser} from './date_parser';
-import {BaseParser} from './base_parser';
 import {BooleanSerializer} from './boolean_serializer';
 import {StringSerializer} from './string_serializer';
 import {NumberSerializer} from './number_serializer';
 import {DateSerializer} from './date_serializer';
-import {BaseSerializer} from './base_serializer';
+import {BooleanClause, NumberClause, StringClause} from './clause_types';
+import {DateClause} from './date_types';
+
+type Clause = BooleanClause | DateClause | NumberClause | StringClause;
 
 const numberExamples = [
   '5',
@@ -88,7 +89,7 @@ const dateExamples = [
   'before 3 days ago',
   'before 2025-08-30 08:30:20',
   'after 2025-10-05',
-  '2025-08-30 12:00:00 to 2025-09-18 14:00:00',
+  '2025-08-30 12:00 to 2025-09-18 14:30',
   'this year',
   'next tuesday',
   '7 years from now',
@@ -108,6 +109,7 @@ const dateExamples = [
   'for', // Bad syntax
   '7', // Bad syntax
   'from now', // Bad syntax
+  '2025-12-25 12:32:', // Bad syntax
   '',
 ];
 
@@ -207,77 +209,86 @@ function testTokenizerNumber() {
   }
 }
 
-function testParserSingle(
+function testNumberParserSingle(
   str: string,
-  parser: BaseParser,
   outputFormatter?: (clauses: Clause[]) => string
 ): void {
   console.log('Input: ', str);
-  try {
-    const response = parser.parse();
-    // console.log('Tokens: ', parser.getTokens());
-    if (response.clauses && response.clauses.length > 0) {
-      if (outputFormatter) {
-        console.log('Output: ', outputFormatter(response.clauses));
-      } else {
-        console.log('Output: ', ...response.clauses);
-      }
-    }
-    if (response.errors && response.errors.length > 0) {
-      console.log('Errors: ', ...response.errors);
-    }
-  } catch (ex: Error | unknown) {
-    if (ex instanceof Error) console.error('Thrown Error: ', ex.message);
-    else {
-      console.error('Thrown Unknown error: ', ex);
+  const parser = new NumberParser(str);
+  const response = parser.parse();
+  // console.log('Tokens: ', parser.getTokens());
+  if (response.clauses && response.clauses.length > 0) {
+    if (outputFormatter) {
+      console.log('Output: ', outputFormatter(response.clauses));
+    } else {
+      console.log('Output: ', ...response.clauses);
     }
   }
+  if (response.errors && response.errors.length > 0) {
+    console.log('Errors: ', ...response.errors);
+  }
   console.log('');
 }
 
-function testSerializerRoundtrip(
+function testNumberParser() {
+  for (const example of numberExamples) {
+    testNumberParserSingle(example);
+  }
+}
+
+function testStringParserSingle(
   str: string,
-  parser: BaseParser,
-  serializerFunc: (clauses: Clause[]) => BaseSerializer
+  outputFormatter?: (clauses: Clause[]) => string
 ): void {
-  console.log('Input:  ' + str);
-  try {
-    const response = parser.parse();
-    // console.log('Clause: ', ...response.clauses, '\n');
-    if (response.clauses && response.clauses.length > 0) {
-      const result = serializerFunc(response.clauses || []).serialize();
-      console.log('Output: ' + result);
-    }
-    if (response.errors && response.errors.length > 0) {
-      console.log('Errors: ', ...response.errors);
-    }
-  } catch (ex: Error | unknown) {
-    if (ex instanceof Error) console.error('Thrown Error: ', ex.message);
-    else {
-      console.error('Thrown Unknown error: ', ex);
+  console.log('Input: ', str);
+  const parser = new StringParser(str);
+  const response = parser.parse();
+  // console.log('Tokens: ', parser.getTokens());
+  if (response.clauses && response.clauses.length > 0) {
+    if (outputFormatter) {
+      console.log('Output: ', outputFormatter(response.clauses));
+    } else {
+      console.log('Output: ', ...response.clauses);
     }
   }
-  console.log('');
-}
-
-function testNumberParser() {
-  for (const example of numberExamples) {
-    const parser = new NumberParser(example);
-    testParserSingle(example, parser);
+  if (response.errors && response.errors.length > 0) {
+    console.log('Errors: ', ...response.errors);
   }
+  console.log('');
 }
 
 function testStringParser() {
   for (const example of stringExamples) {
     const parser = new StringParser(example);
-    testParserSingle(example, parser);
+    testStringParserSingle(example);
   }
 }
 
+function testBooleanParserSingle(
+  str: string,
+  outputFormatter?: (clauses: Clause[]) => string
+): void {
+  console.log('Input: ', str);
+  const parser = new BooleanParser(str);
+  const response = parser.parse();
+  // console.log('Tokens: ', parser.getTokens());
+  if (response.clauses && response.clauses.length > 0) {
+    if (outputFormatter) {
+      console.log('Output: ', outputFormatter(response.clauses));
+    } else {
+      console.log('Output: ', ...response.clauses);
+    }
+  }
+  if (response.errors && response.errors.length > 0) {
+    console.log('Errors: ', ...response.errors);
+  }
+  console.log('');
+}
+
 function testBooleanParser() {
   for (const example of booleanExamples) {
     const parser = new BooleanParser(example);
-    testParserSingle(example, parser);
+    testBooleanParserSingle(example);
   }
 }
 
@@ -289,67 +300,112 @@ function jsonFormatter(clauses: Clause[]): string {
   return str;
 }
 
+function testDateParserSingle(
+  str: string,
+  outputFormatter?: (clauses: Clause[]) => string
+): void {
+  console.log('Input: ', str);
+  const parser = new DateParser(str);
+  const response = parser.parse();
+  // console.log('Tokens: ', parser.getTokens());
+  if (response.clauses && response.clauses.length > 0) {
+    if (outputFormatter) {
+      console.log('Output: ', outputFormatter(response.clauses));
+    } else {
+      console.log('Output: ', ...response.clauses);
+    }
+  }
+  if (response.errors && response.errors.length > 0) {
+    console.log('Errors: ', ...response.errors);
+  }
+  console.log('');
+}
+
 function testDateParser() {
   for (const example of dateExamples) {
     const parser = new DateParser(example);
-    testParserSingle(example, parser);
-    //testParserSingle(example, parser, jsonFormatter);
+    testDateParserSingle(example);
   }
 }
 
+function testNumberRoundtrip(str: string): void {
+  console.log('Input:  ' + str);
+  const response = new NumberParser(str).parse();
+  // console.log('Clause: ', ...response.clauses, '\n');
+  if (response.clauses && response.clauses.length > 0) {
+    const result = new NumberSerializer(response.clauses || []).serialize();
+    console.log('Output: ' + result);
+  }
+  if (response.errors && response.errors.length > 0) {
+    console.log('Errors: ', ...response.errors);
+  }
+  console.log('');
+}
+
 function testNumberSerializer(): void {
-  const examples = [
-    [{operator: '>', value: 10}],
-    [{startOperator: '>=', startValue: 20, endOperator: '<=', endValue: 30}],
-  ];
   for (const example of numberExamples) {
-    testSerializerRoundtrip(
-      example,
-      new NumberParser(example),
-      clauses => new NumberSerializer(clauses)
-    );
+    testNumberRoundtrip(example);
+  }
+}
+
+function testStringRoundtrip(str: string): void {
+  console.log('Input:  ' + str);
+  const response = new StringParser(str).parse();
+  // console.log('Clause: ', ...response.clauses, '\n');
+  if (response.clauses && response.clauses.length > 0) {
+    const result = new StringSerializer(response.clauses || []).serialize();
+    console.log('Output: ' + result);
   }
+  if (response.errors && response.errors.length > 0) {
+    console.log('Errors: ', ...response.errors);
+  }
+  console.log('');
 }
 
 function testStringSerializer(): void {
   for (const example of stringExamples) {
-    testSerializerRoundtrip(
-      example,
-      new StringParser(example),
-      clauses => new StringSerializer(clauses)
-    );
+    testStringRoundtrip(example);
   }
 }
 
+function testBooleanRoundtrip(str: string): void {
+  console.log('Input:  ' + str);
+  const response = new BooleanParser(str).parse();
+  // console.log('Clause: ', ...response.clauses, '\n');
+  if (response.clauses && response.clauses.length > 0) {
+    const result = new BooleanSerializer(response.clauses || []).serialize();
+    console.log('Output: ' + result);
+  }
+  if (response.errors && response.errors.length > 0) {
+    console.log('Errors: ', ...response.errors);
+  }
+  console.log('');
+}
+
 function testBooleanSerializer(): void {
   const examples = [[{operator: 'TRUE'}]];
   for (const example of booleanExamples) {
-    testSerializerRoundtrip(
-      example,
-      new BooleanParser(example),
-      clauses => new BooleanSerializer(clauses)
-    );
+    testBooleanRoundtrip(example);
   }
 }
 
+function testDateRoundtrip(str: string): void {
+  console.log('Input:  ' + str);
+  const response = new DateParser(str).parse();
+  // console.log('Clause: ', ...response.clauses, '\n');
+  if (response.clauses && response.clauses.length > 0) {
+    const result = new DateSerializer(response.clauses || []).serialize();
+    console.log('Output: ' + result);
+  }
+  if (response.errors && response.errors.length > 0) {
+    console.log('Errors: ', ...response.errors);
+  }
+  console.log('');
+}
+
 function testDateSerializer(): void {
-  const examples = [
-    [{prefix: 'BEFORE', values: [{type: 'day', value: 'yesterday'}]}],
-    [
-      {
-        start: [{type: 'day', value: 'today'}],
-        operator: 'TO',
-        end: [{type: 'day', value: 'tomorrow'}],
-      },
-    ],
-    [{type: 'day', value: 'today'}],
-  ];
   for (const example of dateExamples) {
-    testSerializerRoundtrip(
-      example,
-      new DateParser(example),
-      clauses => new DateSerializer(clauses)
-    );
+    testDateRoundtrip(example);
   }
 }
 
@@ -362,26 +418,33 @@ function printHeader(title: string): void {
 
 // Comment or uncomment the following function calls to disable/enable examples.
 function generateSamples() {
-  //printHeader('Tokenizer');
-  //testTokenizerString();
-  //testTokenizerNumber();
-  //testTokenizerMatchTypes();
-  //printHeader('Numbers');
-  //testNumberParser();
-  //printHeader('Strings');
-  //testStringParser();
-  //printHeader('Booleans');
-  //testBooleanParser();
-  //printHeader('Dates and Times');
-  //testDateParser();
-  printHeader('Number Serializer');
-  testNumberSerializer();
-  printHeader('String Serializer');
-  testStringSerializer();
-  printHeader('Boolean Serializer');
-  testBooleanSerializer();
-  printHeader('Date and Time Serializer');
-  testDateSerializer();
+  try {
+    //printHeader('Tokenizer');
+    //testTokenizerString();
+    //testTokenizerNumber();
+    //testTokenizerMatchTypes();
+    printHeader('Numbers');
+    testNumberParser();
+    printHeader('Strings');
+    testStringParser();
+    printHeader('Booleans');
+    testBooleanParser();
+    printHeader('Dates and Times');
+    testDateParser();
+    printHeader('Number Serializer');
+    testNumberSerializer();
+    printHeader('String Serializer');
+    testStringSerializer();
+    printHeader('Boolean Serializer');
+    testBooleanSerializer();
+    printHeader('Date and Time Serializer');
+    testDateSerializer();
+  } catch (ex: Error | unknown) {
+    if (ex instanceof Error) console.error('Thrown Error: ', ex.message);
+    else {
+      console.error('Thrown Unknown error: ', ex);
+    }
+  }
 }
 
 generateSamples();