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

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,71 @@ 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 === 'NULL') {
+      return 'NULL';
+    } else if (clause.operator === 'NOTNULL') {
+      return '-NULL';
+    } 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,159 @@
+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;
+}
+
+export interface DateNullClause {
+  operator: 'NULL';
+}
+
+export interface DateNotNullClause {
+  operator: 'NOTNULL';
+}
+
+// 3 days
+export interface DateDurationClause {
+  operator: 'DURATION';
+  duration: Duration;
+}
+
+export type DateClause =
+  | DateAfterClause
+  | DateBeforeClause
+  | DateOnClause
+  | DateBetweenClause
+  | DateForClause
+  | DateNullClause
+  | DateNotNullClause
+  | DateDurationClause;
+
+export interface DateParserResponse {
+  clauses: DateClause[];
+  errors: FilterError[];
+}