@malloydata/malloy-filter 0.0.350 → 0.0.351

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy-filter",
-  "version": "0.0.350",
+  "version": "0.0.351",
   "license": "MIT",
   "description": "Parsers for the Malloy filtering sub-languages",
   "main": "dist/index.js",
@@ -12,25 +12,23 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "npm run build-parsers && tsc --build && npm run generate-flow",
-    "build-parsers": "mkdir -p src/lib && nearleyc src/grammars/fexpr_string.ne --out src/lib/fexpr_string_parser.ts && nearleyc src/grammars/fexpr_number.ne --out src/lib/fexpr_number_parser.ts && nearleyc src/grammars/ftemporal.ne --out src/lib/ftemporal_parser.ts",
-    "clean": "tsc --build --clean && rm -f tsconfig.tsbuildinfo && rimraf src/lib/* dist @flowtyped",
+    "codegen": "node ../../scripts/femto-build.js codegen",
+    "generate-flow": "node ../../scripts/femto-build.js flow",
+    "dev": "npm run codegen && tsc --build",
+    "build": "npm run codegen && tsc --build && npm run generate-flow",
+    "clean": "tsc --build --clean && rm -f tsconfig.tsbuildinfo && node ../../scripts/femto-build.js --clean && rimraf src/lib/* dist @flowtyped",
     "test": "jest",
-    "prepublishOnly": "npm run clean && npm run build",
-    "generate-flow": "ts-node ../../scripts/gen-flow.ts"
+    "prepublishOnly": "npm run clean && npm run build"
   },
   "keywords": [],
   "author": "",
   "dependencies": {
     "jest-diff": "^29.6.2",
-    "luxon": "^3.5.0",
-    "moo": "^0.5.2",
-    "nearley": "^2.20.1"
+    "luxon": "^3.5.0"
   },
   "devDependencies": {
     "@types/luxon": "^3.5.0",
-    "@types/moo": "^0.5.10",
-    "@types/nearley": "^2.11.5",
+    "peggy": "^4.2.0",
     "rimraf": "^6.0.1"
   }
 }

package/src/clause_utils.ts

@@ -25,7 +25,7 @@ import {
 /**
  * If there is a minus token, add "not:true" to the clause
  */
-export function maybeNot(data: (Object | undefined)[]) {
+export function maybeNot(data: unknown[]) {
   const [isMinus, op] = data;
   if (isMinus && op && isStringFilter(op)) {
     return {...op, not: true};
@@ -150,9 +150,9 @@ function sameAs<T extends FilterExpression>(a: T, b: FilterExpression): b is T {
 }
 
 export function conjoin(
-  left: Object,
+  left: unknown,
   op: string,
-  right: Object
+  right: unknown
 ): StringFilter | null {
   op = op.toLowerCase();
   if (isStringFilter(left) && isStringFilter(right)) {
@@ -180,9 +180,9 @@ export function conjoin(
 }
 
 export function joinNumbers(
-  left: Object,
+  left: unknown,
   op: string,
-  right: Object
+  right: unknown
 ): NumberFilter | null {
   op = op.toLowerCase();
   if (isNumberFilter(left) && isNumberFilter(right)) {
@@ -225,7 +225,7 @@ export function mkValues(n: string, nList: string[]) {
   return {values: [n, ...nList]};
 }
 
-export function numNot(op: Object, notToken: unknown) {
+export function numNot(op: unknown, notToken: unknown) {
   if (isNumberFilter(op) && notToken) {
     if (op.operator === '=') return {operator: '!=', values: op.values};
     if (op.operator === '!=') return {operator: '=', values: op.values};
@@ -234,7 +234,7 @@ export function numNot(op: Object, notToken: unknown) {
   return op;
 }
 
-export function temporalNot(op: Object, notToken: unknown) {
+export function temporalNot(op: unknown, notToken: unknown) {
   if (isTemporalFilter(op) && notToken) {
     // maintain not-ness for ease of testing
     if ('not' in op) {
@@ -252,26 +252,12 @@ export function temporalNot(op: Object, notToken: unknown) {
 }
 
 export function joinTemporal(
-  left: Object,
+  left: unknown,
   op: string,
-  right: Object
+  right: unknown
 ): TemporalFilter | null {
   op = op.toLowerCase();
   if (isTemporalFilter(left) && isTemporalFilter(right)) {
-    // if (
-    //   (op === ',' || op === 'or') &&
-    //   left.operator === '=' &&
-    //   sameAs(left, right)
-    // ) {
-    //   const ret: NumberClause = {
-    //     operator: '=',
-    //     values: [...left.values, ...right.values],
-    //   };
-    //   if (left.not) {
-    //     ret.not = true;
-    //   }
-    //   return ret;
-    // }
     if (op === 'and' || op === 'or') {
       if (left.operator === op) {
         return {...left, members: [...left.members, right]};

package/src/filter_interface.ts

@@ -58,8 +58,10 @@ export type StringFilter =
   | ClauseChain<StringFilter>
   | ClauseGroup<StringFilter>;
 
-export function isStringFilter(sc: Object): sc is StringFilter {
+export function isStringFilter(sc: unknown): sc is StringFilter {
   return (
+    typeof sc === 'object' &&
+    sc !== null &&
     'operator' in sc &&
     typeof sc.operator === 'string' &&
     [
@@ -86,8 +88,10 @@ export interface BooleanCondition extends Negatable {
 
 export type BooleanFilter = BooleanCondition | Null;
 
-export function isBooleanFilter(bc: Object): bc is BooleanFilter {
+export function isBooleanFilter(bc: unknown): bc is BooleanFilter {
   return (
+    typeof bc === 'object' &&
+    bc !== null &&
     'operator' in bc &&
     typeof bc.operator === 'string' &&
     ['null', 'true', 'false', '=false', '=true'].includes(bc.operator)
@@ -118,8 +122,10 @@ export type NumberFilter =
   | ClauseGroup<NumberFilter>
   | BooleanChain<NumberFilter>;
 
-export function isNumberFilter(sc: Object): sc is NumberFilter {
+export function isNumberFilter(sc: unknown): sc is NumberFilter {
   return (
+    typeof sc === 'object' &&
+    sc !== null &&
     'operator' in sc &&
     typeof sc.operator === 'string' &&
     [
@@ -246,8 +252,10 @@ export type TemporalFilter =
   | BooleanChain<TemporalFilter>
   | ClauseGroup<TemporalFilter>;
 
-export function isTemporalFilter(sc: Object): sc is TemporalFilter {
+export function isTemporalFilter(sc: unknown): sc is TemporalFilter {
   return (
+    typeof sc === 'object' &&
+    sc !== null &&
     'operator' in sc &&
     typeof sc.operator === 'string' &&
     [
@@ -275,10 +283,8 @@ export type FilterExpression =
   | StringFilter
   | TemporalFilter;
 
-export function isFilterExpression(
-  obj: Object | undefined
-): obj is FilterExpression {
-  return !!obj && 'operator' in obj;
+export function isFilterExpression(obj: unknown): obj is FilterExpression {
+  return typeof obj === 'object' && obj !== null && 'operator' in obj;
 }
 
 export type FilterLogSeverity = 'error' | 'warn';

package/src/grammars/fexpr_number.peggy

@@ -0,0 +1,46 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+{{
+const {numNot, mkRange, joinNumbers, mkValues} = require('../clause_utils');
+}}
+
+numberFilter
+  = head:numberUnary tail:(_ conjunction _ numberUnary)*
+    {
+      return tail.reduce((left, [, cop, , right]) => joinNumbers(left, cop, right), head);
+    }
+
+numberUnary
+  = not:NOT _ clause:clause { return numNot(clause, not); }
+  / clause:clause { return clause; }
+
+clause
+  = NULL { return {operator: 'null'}; }
+  / "(" _ expr:numberFilter _ ")" { return {operator: "()", expr}; }
+  / open:openInterval _ b:N _ TO _ e:N _ close:closeInterval { return mkRange(open, b, e, close); }
+  / "!=" _ n:N nList:(_ "," _ N)* { return {operator: '!=', ...mkValues(n, nList.map(x => x[3]))}; }
+  / "=" _ n:N nList:(_ "," _ N)* { return {operator: '=', ...mkValues(n, nList.map(x => x[3]))}; }
+  / op:$("<=" / ">=" / "<" / ">") _ n:N { return {operator: op, values: [n]}; }
+  / n:N nList:(_ "," _ N)* { return {operator: '=', ...mkValues(n, nList.map(x => x[3]))}; }
+
+openInterval = "[" { return "["; } / "(" { return "("; }
+closeInterval = "]" { return "]"; } / ")" { return ")"; }
+
+N = n:$("-"? ([0-9]+ "."? [0-9]* / [0-9]* "." [0-9]+) ([Ee] [+-]? [0-9]+)?) { return n; }
+
+conjunction
+  = OR { return "or"; }
+  / AND { return "and"; }
+
+NOT = "not"i !idChar { return "not"; }
+NULL = "null"i !idChar
+AND = "and"i !idChar
+OR = "or"i !idChar
+TO = "to"i !idChar
+
+idChar = [a-zA-Z]
+
+_ "whitespace" = [ \t]*

package/src/grammars/fexpr_string.peggy

@@ -0,0 +1,32 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+{{
+const {conjoin, maybeNot, matchOp} = require('../clause_utils');
+}}
+
+stringFilter
+  = _ head:sfUnary tail:(_ conjunction _ sfUnary)*
+    {
+      return tail.reduce((left, [, cop, , right]) => conjoin(left, cop, right), head);
+    }
+
+sfUnary
+  = "-" _ clause:clause { return maybeNot([true, clause]); }
+  / clause:clause { return clause; }
+
+clause
+  = "(" _ expr:stringFilter _ ")" { return {operator: "()", expr}; }
+  / str:matchStr { return matchOp(str); }
+
+matchStr "match string"
+  = s:$(("\\" . / [^\n,;()|])+) { return s; }
+
+conjunction
+  = "," { return ","; }
+  / ";" { return ";"; }
+  / "|" { return "|"; }
+
+_ "whitespace" = [ \t]*

package/src/grammars/ftemporal.peggy

@@ -0,0 +1,112 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+{{
+const {temporalNot, joinTemporal, timeLiteral, mkUnits} = require('../clause_utils');
+}}
+
+temporalFilter
+  = head:temporalUnary tail:(_ conjunction _ temporalUnary)*
+    {
+      return tail.reduce((left, [, cop, , right]) => joinTemporal(left, cop, right), head);
+    }
+
+temporalUnary
+  = NOT __ clause:clause { return temporalNot(clause, true); }
+  / clause:clause { return clause; }
+
+clause
+  = NULL { return {operator: 'null'}; }
+  / "(" _ expr:temporalFilter _ ")" { return {operator: "()", expr}; }
+  / BEFORE __ m:moment { return {operator: 'before', before: m}; }
+  / STARTING __ m:moment { return {operator: 'before', before: m, not: true}; }
+  / AFTER __ m:moment { return {operator: 'after', after: m}; }
+  / THROUGH __ m:moment { return {operator: 'after', after: m, not: true}; }
+  / ln:lastOrNext __ d:duration { return {operator: ln, ...d}; }
+  / m:moment __ TO __ m2:moment { return {operator: 'to', fromMoment: m, toMoment: m2}; }
+  / m:moment __ FOR __ d:duration { return {...d, operator: 'for', begin: m}; }
+  / m:moment { return {operator: 'in', in: m}; }
+  / d:duration { return {operator: 'in_last', ...d}; }
+
+lastOrNext
+  = LAST { return 'last'; }
+  / NEXT { return 'next'; }
+
+duration = n:integer __ u:unit { return {units: u, n}; }
+
+integer = n:$[0-9]+ { return n; }
+
+unit
+  = u:$("second"i / "minute"i / "hour"i / "day"i / "week"i / "month"i / "quarter"i / "year"i) "s"i? !idChar
+    { return mkUnits(u); }
+
+moment
+  = NOW { return {moment: 'now'}; }
+  / TODAY { return {moment: 'today'}; }
+  / YESTERDAY { return {moment: 'yesterday'}; }
+  / TOMORROW { return {moment: 'tomorrow'}; }
+  / d:duration __ AGO { return {moment: 'ago', ...d}; }
+  / d:duration __ FROM __ NOW { return {moment: 'from_now', ...d}; }
+  / NEXT __ dn:weekday { return {moment: dn.toLowerCase(), which: 'next'}; }
+  / LAST __ dn:weekday { return {moment: dn.toLowerCase(), which: 'last'}; }
+  / lnt:lastNextThis __ u:unit { return {moment: lnt, units: u}; }
+  / dn:weekday { return {moment: dn.toLowerCase(), which: 'last'}; }
+  / tl:timeLiteral { return tl; }
+
+lastNextThis
+  = THIS { return 'this'; }
+  / NEXT { return 'next'; }
+  / LAST { return 'last'; }
+
+timeLiteral
+  = l:$([0-9][0-9][0-9][0-9] "-" [0-9][0-9] "-" [0-9][0-9] [ Tt] [0-9][0-9] ":" [0-9][0-9] ":" [0-9][0-9] ([.,] [0-9]*)?) { return timeLiteral(l); }
+  / l:$([0-9][0-9][0-9][0-9] "-" [0-9][0-9] "-" [0-9][0-9] "-" [Ww] [Kk]) { return timeLiteral(l, 'week'); }
+  / l:$([0-9][0-9][0-9][0-9] "-" [Qq] [1234]) { return timeLiteral(l, 'quarter'); }
+  / l:$([0-9][0-9][0-9][0-9] "-" [0-9][0-9] "-" [0-9][0-9] [ Tt] [0-9][0-9] ":" [0-9][0-9]) { return timeLiteral(l, 'minute'); }
+  / l:$([0-9][0-9][0-9][0-9] "-" [0-9][0-9] "-" [0-9][0-9] [ Tt] [0-9][0-9]) { return timeLiteral(l, 'hour'); }
+  / l:$([0-9][0-9][0-9][0-9] "-" [0-9][0-9] "-" [0-9][0-9]) { return timeLiteral(l, 'day'); }
+  / l:$([0-9][0-9][0-9][0-9] "-" [0-9][0-9]) { return timeLiteral(l, 'month'); }
+  / l:$([0-9][0-9][0-9][0-9]) { return timeLiteral(l, 'year'); }
+
+weekday
+  = w:$(MONDAY / TUESDAY / WEDNESDAY / THURSDAY / FRIDAY / SATURDAY / SUNDAY) { return w; }
+
+conjunction
+  = OR { return "or"; }
+  / AND { return "and"; }
+
+// Keywords - case insensitive, must not be followed by more id chars
+NOT = "not"i !idChar
+NULL = "null"i !idChar
+TO = "to"i !idChar
+NOW = "now"i !idChar
+LAST = "last"i !idChar
+THIS = "this"i !idChar
+NEXT = "next"i !idChar
+AGO = "ago"i !idChar
+FROM = "from"i !idChar
+BEFORE = "before"i !idChar
+AFTER = "after"i !idChar
+THROUGH = "through"i !idChar
+STARTING = "starting"i !idChar
+FOR = "for"i !idChar
+TODAY = "today"i !idChar
+YESTERDAY = "yesterday"i !idChar
+TOMORROW = "tomorrow"i !idChar
+AND = "and"i !idChar
+OR = "or"i !idChar
+
+MONDAY = "monday"i !idChar
+TUESDAY = "tuesday"i !idChar
+WEDNESDAY = "wednesday"i !idChar
+THURSDAY = "thursday"i !idChar
+FRIDAY = "friday"i !idChar
+SATURDAY = "saturday"i !idChar
+SUNDAY = "sunday"i !idChar
+
+idChar = [a-zA-Z]
+
+_ "optional whitespace" = [ \t]*
+__ "whitespace" = [ \t]+