postgres-query-box 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +16 -0
- package/LICENSE +21 -0
- package/README.md +178 -2
- package/dist/chunk-VMCU5JEN.js +1196 -0
- package/dist/chunk-VMCU5JEN.js.map +1 -0
- package/dist/core.cjs +1235 -0
- package/dist/core.cjs.map +1 -0
- package/dist/core.d.cts +84 -0
- package/dist/core.d.ts +84 -0
- package/dist/core.js +45 -0
- package/dist/core.js.map +1 -0
- package/dist/index.cjs +2555 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +42 -0
- package/dist/index.d.ts +42 -0
- package/dist/index.js +1357 -0
- package/dist/index.js.map +1 -0
- package/dist/styles.css +313 -0
- package/package.json +83 -4
package/dist/core.cjs
ADDED
|
@@ -0,0 +1,1235 @@
|
|
|
1
|
+
var __defProp = Object.defineProperty;
|
|
2
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
3
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
4
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
5
|
+
var __export = (target, all) => {
|
|
6
|
+
for (var name in all)
|
|
7
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
8
|
+
};
|
|
9
|
+
var __copyProps = (to, from, except, desc) => {
|
|
10
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
11
|
+
for (let key of __getOwnPropNames(from))
|
|
12
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
13
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
14
|
+
}
|
|
15
|
+
return to;
|
|
16
|
+
};
|
|
17
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
18
|
+
|
|
19
|
+
// src/core/index.js
|
|
20
|
+
var core_exports = {};
|
|
21
|
+
__export(core_exports, {
|
|
22
|
+
LATENCY: () => LATENCY,
|
|
23
|
+
LAT_FIELD: () => LAT_FIELD,
|
|
24
|
+
METHODS: () => METHODS,
|
|
25
|
+
OP_INFO: () => OP_INFO,
|
|
26
|
+
STATUS_CODES: () => STATUS_CODES,
|
|
27
|
+
TYPE_LABEL: () => TYPE_LABEL,
|
|
28
|
+
buildSchema: () => buildSchema,
|
|
29
|
+
context: () => context,
|
|
30
|
+
evaluate: () => evaluate,
|
|
31
|
+
format: () => format,
|
|
32
|
+
fromTree: () => fromTree,
|
|
33
|
+
ipToBig: () => ipToBig,
|
|
34
|
+
opsFor: () => opsFor,
|
|
35
|
+
parse: () => parse,
|
|
36
|
+
parseRange: () => parseRange,
|
|
37
|
+
schemaFromFields: () => schemaFromFields,
|
|
38
|
+
toSql: () => toSql,
|
|
39
|
+
toTree: () => toTree,
|
|
40
|
+
tokenize: () => tokenize,
|
|
41
|
+
validate: () => validate
|
|
42
|
+
});
|
|
43
|
+
module.exports = __toCommonJS(core_exports);
|
|
44
|
+
|
|
45
|
+
// src/core/engine.js
|
|
46
|
+
var LAT_A = "metadata.responseTimestamp";
|
|
47
|
+
var LAT_B = "metadata.requestTimestamp";
|
|
48
|
+
var LATENCY = `(${LAT_A} - ${LAT_B})`;
|
|
49
|
+
var VALUE_FIELDS = ["data.request.verb", "data.response.statusCode"];
|
|
50
|
+
var METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "TRACE", "CONNECT", "QUERY"];
|
|
51
|
+
var STATUS_CODES = [100, 101, 102, 103, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 300, 301, 302, 303, 304, 305, 307, 308, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451, 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511].map(String);
|
|
52
|
+
var CATALOG = { "data.request.verb": METHODS, "data.response.statusCode": STATUS_CODES };
|
|
53
|
+
var COMMON = ["data.request.verb", "data.response.statusCode", "data.request.path", "data.request.hostname"];
|
|
54
|
+
var KW = /* @__PURE__ */ new Set(["AND", "OR", "NOT", "CONTAINS", "PRESENT", "ABSENT", "BETWEEN", "ANYONE", "NONEOF", "IP", "IN_RANGE", "NOT_IN_RANGE", "COUNT", "WITHIN", "GROUP", "BY", "LATENCY"]);
|
|
55
|
+
var OPS = ["!~*", "!~", "~*", "==", "!=", "<=", ">=", "~", "<", ">", "="];
|
|
56
|
+
var CMP = /* @__PURE__ */ new Set(["<", "<=", ">", ">="]);
|
|
57
|
+
var REGEX = /* @__PURE__ */ new Set(["~", "~*", "!~", "!~*"]);
|
|
58
|
+
var TEXT_OPS = /* @__PURE__ */ new Set(["~", "~*", "!~", "!~*", "CONTAINS", "NOT CONTAINS"]);
|
|
59
|
+
var UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
|
|
60
|
+
var pgRegex = (p) => {
|
|
61
|
+
const hex = (k, n) => [...Array(n)].every((_, j) => /[0-9a-fA-F]/.test(p[k + j] || "")) && !/[0-9a-fA-F]/.test(p[k + n] || "");
|
|
62
|
+
const open = [];
|
|
63
|
+
const closed = /* @__PURE__ */ new Set();
|
|
64
|
+
let groups = 0;
|
|
65
|
+
let cls = -1;
|
|
66
|
+
let first = 0;
|
|
67
|
+
let fixed = "";
|
|
68
|
+
let wb = false;
|
|
69
|
+
let bare = false;
|
|
70
|
+
let last = 0;
|
|
71
|
+
const size = [0];
|
|
72
|
+
const add = (w) => {
|
|
73
|
+
size[size.length - 1] += w;
|
|
74
|
+
last = w;
|
|
75
|
+
};
|
|
76
|
+
for (let i = 0; i < p.length; ) {
|
|
77
|
+
const c = p[i];
|
|
78
|
+
const d = p[i + 1];
|
|
79
|
+
if (cls < 0 && bare && (c === "*" || c === "+" || c === "?" || c === "{" && /\d/.test(d || ""))) return { msg: "Postgres cannot repeat \\y, \\m, \\A, \\Z or a lookaround" };
|
|
80
|
+
bare = false;
|
|
81
|
+
if (c === "\\") {
|
|
82
|
+
if (/[1-9]/.test(d) && !/\d/.test(p[i + 2] || "") && cls < 0 && !closed.has(+d)) return { msg: `\\${d} needs group ${d} to be closed before it` };
|
|
83
|
+
if (cls >= 0 && /\d/.test(d)) return { msg: `Inside brackets, write the character itself instead of \\${d}` };
|
|
84
|
+
if (d === "x" && !hex(i + 2, 2)) return { msg: "Write \\x with exactly two hex digits, like \\x41" };
|
|
85
|
+
if (d === "u" && !hex(i + 2, 4)) return { msg: "Write \\u with exactly four hex digits, like \\u0041" };
|
|
86
|
+
if (d === "c" && !/[A-Za-z]/.test(p[i + 2] || "")) return { msg: "Write \\c with a letter, like \\cA" };
|
|
87
|
+
if (cls >= 0 && /[dDwWsS]/.test(d) && (p[i + 2] === "-" && p[i + 3] && p[i + 3] !== "]" || p[i - 1] === "-" && i - 1 !== first)) return { msg: `A range like a-z cannot start or end with \\${d}` };
|
|
88
|
+
if ((d === "b" || d === "B") && cls < 0) {
|
|
89
|
+
wb = bare = true;
|
|
90
|
+
add(1);
|
|
91
|
+
fixed += "\\" + (d === "b" ? "y" : "Y");
|
|
92
|
+
i += 2;
|
|
93
|
+
continue;
|
|
94
|
+
}
|
|
95
|
+
if (/[A-Za-z]/.test(d) && !"dDwWsStnrfvxuc".includes(d) && !(cls < 0 ? "yYmMAZ" : "b").includes(d)) return { msg: `Postgres does not understand \\${d}. To match the letter ${d}, write ${d} without the backslash.` };
|
|
96
|
+
bare = cls < 0 && "yYmMAZ".includes(d);
|
|
97
|
+
if (cls < 0) add(1);
|
|
98
|
+
fixed += c + d;
|
|
99
|
+
i += 2;
|
|
100
|
+
continue;
|
|
101
|
+
}
|
|
102
|
+
if (cls >= 0) {
|
|
103
|
+
if (c === "[" && ":.=".includes(d || "-")) {
|
|
104
|
+
const m = p.slice(i).match(/^\[:(alnum|alpha|blank|cntrl|digit|graph|lower|print|punct|space|upper|xdigit|word):\]/);
|
|
105
|
+
if (!m) return { msg: "Inside brackets, write \\[ for a literal [" };
|
|
106
|
+
fixed += m[0];
|
|
107
|
+
i += m[0].length;
|
|
108
|
+
continue;
|
|
109
|
+
}
|
|
110
|
+
if (c === "]" && i > first) {
|
|
111
|
+
cls = -1;
|
|
112
|
+
add(1);
|
|
113
|
+
}
|
|
114
|
+
} else if (c === "[") {
|
|
115
|
+
if (d === "]" || d === "^" && p[i + 2] === "]") return { msg: "Postgres does not allow empty brackets [] or [^]" };
|
|
116
|
+
cls = i;
|
|
117
|
+
first = i + (d === "^" ? 2 : 1);
|
|
118
|
+
} else if (c === "(") {
|
|
119
|
+
size.push(0);
|
|
120
|
+
if (d !== "?") open.push(++groups);
|
|
121
|
+
else if (p[i + 2] === "<" && p[i + 3] !== "=" && p[i + 3] !== "!") return { msg: "Postgres does not support named groups like (?<name>...). Use ( ) instead." };
|
|
122
|
+
else {
|
|
123
|
+
open.push(p[i + 2] === ":" ? 0 : -1);
|
|
124
|
+
const pre = p.slice(i).match(/^\(\?(?:<[=!]|[:=!])/)[0];
|
|
125
|
+
fixed += pre;
|
|
126
|
+
i += pre.length;
|
|
127
|
+
continue;
|
|
128
|
+
}
|
|
129
|
+
} else if (c === ")") {
|
|
130
|
+
if (!open.length) return { msg: "Postgres reads this ) as having no matching (. Check where the brackets [ ] close." };
|
|
131
|
+
const g = open.pop();
|
|
132
|
+
if (g > 0) closed.add(g);
|
|
133
|
+
add(Math.max(size.pop(), 1));
|
|
134
|
+
bare = g === -1;
|
|
135
|
+
} else if (c === "{" && /\d/.test(d || "")) {
|
|
136
|
+
const m = p.slice(i).match(/^\{(\d+)(?:,(\d*))?\}/);
|
|
137
|
+
if (!m) return { msg: "Finish the repeat count, like {2} or {1,3}, or write \\{ for a literal {" };
|
|
138
|
+
if (+m[1] > 255 || +(m[2] || 0) > 255) return { msg: "Postgres allows at most 255 repeats, like {255}" };
|
|
139
|
+
const k = Math.max(+m[1], +(m[2] || 0));
|
|
140
|
+
size[size.length - 1] += last * (k - 1);
|
|
141
|
+
last *= k;
|
|
142
|
+
fixed += m[0];
|
|
143
|
+
i += m[0].length;
|
|
144
|
+
continue;
|
|
145
|
+
} else if (!"*+?".includes(c)) add(1);
|
|
146
|
+
fixed += c;
|
|
147
|
+
i++;
|
|
148
|
+
}
|
|
149
|
+
if (cls >= 0) return { msg: "Close the brackets with ]" };
|
|
150
|
+
if (size[0] > 1e4) return { msg: "This regex is too large for Postgres. Use smaller repeat counts." };
|
|
151
|
+
if (wb) return { msg: "Postgres reads \\b as a backspace. Use \\y for a word boundary and \\Y for the opposite.", fix: fixed };
|
|
152
|
+
return null;
|
|
153
|
+
};
|
|
154
|
+
var OP_INFO = {
|
|
155
|
+
"==": "equals",
|
|
156
|
+
"!=": "not equal",
|
|
157
|
+
"~": "matches regex",
|
|
158
|
+
"~*": "matches regex, any case",
|
|
159
|
+
"!~": "does not match regex",
|
|
160
|
+
"!~*": "does not match regex, any case",
|
|
161
|
+
"<": "less than",
|
|
162
|
+
"<=": "at most",
|
|
163
|
+
">": "greater than",
|
|
164
|
+
">=": "at least",
|
|
165
|
+
CONTAINS: "contains text",
|
|
166
|
+
"NOT CONTAINS": "does not contain text",
|
|
167
|
+
PRESENT: "has this field",
|
|
168
|
+
ABSENT: "missing this field",
|
|
169
|
+
BETWEEN: "between, both ends included",
|
|
170
|
+
ANYONE: "any one of",
|
|
171
|
+
NONEOF: "none of",
|
|
172
|
+
"IP IN_RANGE": "IP in range",
|
|
173
|
+
"IP NOT_IN_RANGE": "IP not in range"
|
|
174
|
+
};
|
|
175
|
+
var TYPE_LABEL = { string: "text", number: "number", boolean: "boolean", ip: "ip", numtext: "text", latency: "ms" };
|
|
176
|
+
function opsFor(f) {
|
|
177
|
+
if (!f) return [];
|
|
178
|
+
if (f.type === "latency") return [">", "<", ">=", "<=", "BETWEEN"];
|
|
179
|
+
if (f.type === "number") return ["==", "!=", "<", "<=", ">", ">=", "BETWEEN", "ANYONE", "NONEOF", "PRESENT", "ABSENT"];
|
|
180
|
+
if (f.type === "boolean") return ["==", "!=", "PRESENT", "ABSENT"];
|
|
181
|
+
if (f.type === "ip") return ["IP IN_RANGE", "IP NOT_IN_RANGE", "==", "!=", "CONTAINS", "NOT CONTAINS", "~", "~*", "!~", "!~*", "ANYONE", "NONEOF", "PRESENT", "ABSENT"];
|
|
182
|
+
if (f.type === "numtext") return ["==", "!=", ">=", ">", "<", "<=", "BETWEEN", "ANYONE", "NONEOF", "~", "!~", "CONTAINS", "NOT CONTAINS", "PRESENT", "ABSENT"];
|
|
183
|
+
return ["==", "!=", "CONTAINS", "NOT CONTAINS", "~", "~*", "!~", "!~*", "ANYONE", "NONEOF", "PRESENT", "ABSENT"];
|
|
184
|
+
}
|
|
185
|
+
var GROUPS = [
|
|
186
|
+
["data.request.headerParams.", "Request headers"],
|
|
187
|
+
["data.request.queryParams.", "Query params"],
|
|
188
|
+
["data.request.", "Request"],
|
|
189
|
+
["data.response.headerParams.", "Response headers"],
|
|
190
|
+
["data.response.", "Response"],
|
|
191
|
+
["metadata.additionalMetadata.", "Additional metadata"],
|
|
192
|
+
["metadata.", "Metadata"]
|
|
193
|
+
];
|
|
194
|
+
function buildSchema(rows) {
|
|
195
|
+
const map = /* @__PURE__ */ new Map();
|
|
196
|
+
const visit = (o, segs) => {
|
|
197
|
+
for (const k of Object.keys(o)) {
|
|
198
|
+
const v = o[k];
|
|
199
|
+
const ks = [...segs, k];
|
|
200
|
+
const p = ks.join(".");
|
|
201
|
+
if (v && typeof v === "object" && !Array.isArray(v)) visit(v, ks);
|
|
202
|
+
else {
|
|
203
|
+
let f = map.get(p);
|
|
204
|
+
if (!f) map.set(p, f = { path: p, segs: ks, count: 0, kinds: /* @__PURE__ */ new Set(), numeric: true, ip: true, values: /* @__PURE__ */ new Map() });
|
|
205
|
+
f.count++;
|
|
206
|
+
f.kinds.add(typeof v);
|
|
207
|
+
if (typeof v === "string") {
|
|
208
|
+
if (!/^-?\d+(\.\d+)?$/.test(v)) f.numeric = false;
|
|
209
|
+
if (!ipToBig(v)) f.ip = false;
|
|
210
|
+
}
|
|
211
|
+
if (VALUE_FIELDS.includes(p)) f.values.set(v, (f.values.get(v) || 0) + 1);
|
|
212
|
+
}
|
|
213
|
+
}
|
|
214
|
+
};
|
|
215
|
+
for (const r of rows) visit({ data: r.data, metadata: r.metadata }, []);
|
|
216
|
+
return schemaFromFields(
|
|
217
|
+
[...map.values()].map((f) => {
|
|
218
|
+
const kind = f.kinds.size === 1 ? [...f.kinds][0] : "string";
|
|
219
|
+
const type = kind === "number" ? "number" : kind === "boolean" ? "boolean" : f.ip ? "ip" : f.numeric ? "numtext" : "string";
|
|
220
|
+
const values = [...f.values.entries()].sort((a, b) => b[1] - a[1]).map(([v, n]) => ({ v, n }));
|
|
221
|
+
return { path: f.path, segs: f.segs, count: f.count, type, values };
|
|
222
|
+
}),
|
|
223
|
+
rows.length
|
|
224
|
+
);
|
|
225
|
+
}
|
|
226
|
+
function schemaFromFields(list, total = 0) {
|
|
227
|
+
const fields = list.map((f) => ({
|
|
228
|
+
...f,
|
|
229
|
+
segs: f.segs || f.path.split("."),
|
|
230
|
+
type: f.type || "string",
|
|
231
|
+
count: f.count ?? total,
|
|
232
|
+
group: f.group || (COMMON.includes(f.path) ? "Common" : (GROUPS.find(([p]) => f.path.startsWith(p)) || [, "Other"])[1]),
|
|
233
|
+
values: f.values || []
|
|
234
|
+
}));
|
|
235
|
+
const order = ["Common", ...GROUPS.map((g) => g[1]), "Other"];
|
|
236
|
+
fields.sort((a, b) => order.indexOf(a.group) - order.indexOf(b.group) || (a.group === "Common" ? COMMON.indexOf(a.path) - COMMON.indexOf(b.path) : a.path.localeCompare(b.path)));
|
|
237
|
+
const byPath = Object.fromEntries(fields.map((f) => [f.path, f]));
|
|
238
|
+
const short = {};
|
|
239
|
+
for (const f of fields) {
|
|
240
|
+
for (let n = 1; n <= f.segs.length; n++) {
|
|
241
|
+
const tail = f.segs.slice(-n).join(".");
|
|
242
|
+
if (fields.filter((g) => g.segs.length >= n && g.segs.slice(-n).join(".") === tail).length === 1) {
|
|
243
|
+
short[f.path] = tail;
|
|
244
|
+
break;
|
|
245
|
+
}
|
|
246
|
+
}
|
|
247
|
+
}
|
|
248
|
+
return { fields, byPath, short, total };
|
|
249
|
+
}
|
|
250
|
+
function ipToBig(s) {
|
|
251
|
+
if (typeof s !== "string") return null;
|
|
252
|
+
const v4 = (x2) => {
|
|
253
|
+
const p = x2.split(".");
|
|
254
|
+
if (p.length !== 4 || p.some((n2) => !/^\d{1,3}$/.test(n2) || +n2 > 255)) return null;
|
|
255
|
+
return p.reduce((a2, n2) => a2 * 256n + BigInt(n2), 0n);
|
|
256
|
+
};
|
|
257
|
+
if (s.includes(".") && !s.includes(":")) {
|
|
258
|
+
const n2 = v4(s);
|
|
259
|
+
return n2 === null ? null : { v: 4, n: n2 };
|
|
260
|
+
}
|
|
261
|
+
if (!/^[0-9a-fA-F:.]+$/.test(s) || !s.includes(":")) return null;
|
|
262
|
+
let tail = null;
|
|
263
|
+
let x = s;
|
|
264
|
+
const m = s.match(/^(.*:)(\d+\.\d+\.\d+\.\d+)$/);
|
|
265
|
+
if (m) {
|
|
266
|
+
tail = /(^|\.)0\d/.test(m[2]) ? null : v4(m[2]);
|
|
267
|
+
if (tail === null) return null;
|
|
268
|
+
x = m[1] + "0:0";
|
|
269
|
+
}
|
|
270
|
+
const halves = x.split("::");
|
|
271
|
+
if (halves.length > 2) return null;
|
|
272
|
+
const a = halves[0] ? halves[0].split(":") : [];
|
|
273
|
+
const b = halves.length === 2 && halves[1] ? halves[1].split(":") : [];
|
|
274
|
+
const fill = halves.length === 2 ? 8 - a.length - b.length : 0;
|
|
275
|
+
if (halves.length === 2 && fill < 1) return null;
|
|
276
|
+
const parts = [...a, ...Array(fill).fill("0"), ...b];
|
|
277
|
+
if (parts.length !== 8 || parts.some((p) => !/^[0-9a-fA-F]{1,4}$/.test(p))) return null;
|
|
278
|
+
let n = parts.reduce((acc, p) => acc * 65536n + BigInt(parseInt(p, 16)), 0n);
|
|
279
|
+
if (tail !== null) n = (n >> 32n << 32n) + tail;
|
|
280
|
+
if (n >> 32n === 0xffffn) return { v: 4, n: n & 0xffffffffn };
|
|
281
|
+
return { v: 6, n };
|
|
282
|
+
}
|
|
283
|
+
function parseRange(s) {
|
|
284
|
+
if (typeof s !== "string") return null;
|
|
285
|
+
if (s.includes("/")) {
|
|
286
|
+
const [base, bits, extra2] = s.split("/");
|
|
287
|
+
const ip = ipToBig(base);
|
|
288
|
+
const max = ip && ip.v === 4 ? 32 : 128;
|
|
289
|
+
if (!ip || extra2 !== void 0 || !/^(0|[1-9]\d*)$/.test(bits) || +bits > max) return null;
|
|
290
|
+
const host = BigInt(max - +bits);
|
|
291
|
+
const lo = ip.n >> host << host;
|
|
292
|
+
return { v: ip.v, lo, hi: lo + (1n << host) - 1n };
|
|
293
|
+
}
|
|
294
|
+
const [a, b, extra] = s.split("-");
|
|
295
|
+
const x = ipToBig(a);
|
|
296
|
+
const y = ipToBig(b);
|
|
297
|
+
if (!x || !y || extra !== void 0 || x.v !== y.v || x.n > y.n) return null;
|
|
298
|
+
return { v: x.v, lo: x.n, hi: y.n };
|
|
299
|
+
}
|
|
300
|
+
var LAT_FIELD = { path: "@latency", type: "latency" };
|
|
301
|
+
function tokenize(src) {
|
|
302
|
+
const out = [];
|
|
303
|
+
let i = 0;
|
|
304
|
+
while (i < src.length) {
|
|
305
|
+
const c = src[i];
|
|
306
|
+
if (/\s/.test(c)) {
|
|
307
|
+
i++;
|
|
308
|
+
continue;
|
|
309
|
+
}
|
|
310
|
+
const s = i;
|
|
311
|
+
if (c === '"') {
|
|
312
|
+
i++;
|
|
313
|
+
let v = "";
|
|
314
|
+
let closed = false;
|
|
315
|
+
while (i < src.length) {
|
|
316
|
+
if (src[i] === "\\" && (src[i + 1] === '"' || src[i + 1] === "\\")) {
|
|
317
|
+
v += src[i + 1];
|
|
318
|
+
i += 2;
|
|
319
|
+
continue;
|
|
320
|
+
}
|
|
321
|
+
if (src[i] === '"') {
|
|
322
|
+
closed = true;
|
|
323
|
+
i++;
|
|
324
|
+
break;
|
|
325
|
+
}
|
|
326
|
+
v += src[i++];
|
|
327
|
+
}
|
|
328
|
+
out.push({ t: "str", v, s, e: i, closed, raw: src.slice(s, i) });
|
|
329
|
+
continue;
|
|
330
|
+
}
|
|
331
|
+
const prev = out[out.length - 1];
|
|
332
|
+
const neg = c === "-" && /\d/.test(src[i + 1] || "") && prev && (prev.t === "op" || prev.t === "punct" && prev.v !== ")" || prev.t === "kw" && prev.v !== "COUNT");
|
|
333
|
+
if (/\d/.test(c) || neg) {
|
|
334
|
+
const m = src.slice(i).match(/^-?\d+(?:\.\d+)?/)[0];
|
|
335
|
+
i += m.length;
|
|
336
|
+
if (/[smhd]/.test(src[i] || "") && !/[A-Za-z0-9_]/.test(src[i + 1] || "")) {
|
|
337
|
+
i++;
|
|
338
|
+
out.push({ t: "dur", v: m + src[i - 1], ms: Number(m) * UNIT[src[i - 1]], s, e: i, raw: src.slice(s, i) });
|
|
339
|
+
} else out.push({ t: "num", v: Number(m), s, e: i, raw: m });
|
|
340
|
+
continue;
|
|
341
|
+
}
|
|
342
|
+
if (/[A-Za-z_]/.test(c)) {
|
|
343
|
+
const m = src.slice(i).match(/^[A-Za-z_](?:[A-Za-z0-9_.-]|\\\.)*/)[0];
|
|
344
|
+
i += m.length;
|
|
345
|
+
const up = m.toUpperCase();
|
|
346
|
+
if (KW.has(up)) out.push({ t: "kw", v: up, s, e: i, raw: m });
|
|
347
|
+
else if (up === "TRUE" || up === "FALSE") out.push({ t: "bool", v: up === "TRUE", s, e: i, raw: m });
|
|
348
|
+
else out.push({ t: "word", v: m, s, e: i, raw: m });
|
|
349
|
+
continue;
|
|
350
|
+
}
|
|
351
|
+
const op = OPS.find((o) => src.startsWith(o, i));
|
|
352
|
+
if (op) {
|
|
353
|
+
i += op.length;
|
|
354
|
+
out.push({ t: "op", v: op, s, e: i, raw: op });
|
|
355
|
+
continue;
|
|
356
|
+
}
|
|
357
|
+
i++;
|
|
358
|
+
if (c === "-") out.push({ t: "minus", v: "-", s, e: i, raw: "-" });
|
|
359
|
+
else if ("()[],".includes(c)) out.push({ t: "punct", v: c, s, e: i, raw: c });
|
|
360
|
+
else out.push({ t: "bad", v: c, s, e: i, raw: c });
|
|
361
|
+
}
|
|
362
|
+
return out;
|
|
363
|
+
}
|
|
364
|
+
var near = (word, schema) => {
|
|
365
|
+
const w = word.toLowerCase();
|
|
366
|
+
const leaf = w.split(".").pop();
|
|
367
|
+
const hits = schema.fields.filter((f) => f.path.toLowerCase().includes(leaf) || leaf.includes(f.path.split(".").pop().toLowerCase()));
|
|
368
|
+
return hits.slice(0, 4).map((f) => f.path);
|
|
369
|
+
};
|
|
370
|
+
var lit = (v) => typeof v === "string" ? '"' + v.replace(/\\(?=[\\"]|$)/g, "\\\\").replace(/"/g, '\\"') + '"' : String(v);
|
|
371
|
+
function parse(src, schema) {
|
|
372
|
+
const toks = tokenize(src);
|
|
373
|
+
const errors = [];
|
|
374
|
+
let p = 0;
|
|
375
|
+
const peek = (o = 0) => toks[p + o];
|
|
376
|
+
const isKw = (t, k) => t && t.t === "kw" && t.v === k;
|
|
377
|
+
const isP = (t, v) => t && t.t === "punct" && t.v === v;
|
|
378
|
+
const role = (t, r) => t && (t.role = r);
|
|
379
|
+
const fail = (t, msg, extra) => {
|
|
380
|
+
throw { s: t ? t.s : src.length, e: t ? t.e : src.length, msg, eof: !t, ...extra };
|
|
381
|
+
};
|
|
382
|
+
const word = (t) => t ? t.raw : "";
|
|
383
|
+
const latencyAhead = () => {
|
|
384
|
+
var _a, _b, _c;
|
|
385
|
+
return isP(peek(), "(") && ((_a = peek(1)) == null ? void 0 : _a.t) === "word" && ((_b = peek(2)) == null ? void 0 : _b.t) === "minus" && ((_c = peek(3)) == null ? void 0 : _c.t) === "word" && isP(peek(4), ")");
|
|
386
|
+
};
|
|
387
|
+
const value = (allowBool = true, type) => {
|
|
388
|
+
const t = peek();
|
|
389
|
+
if (!t) fail(null, "Add a value");
|
|
390
|
+
if (t.t === "str") {
|
|
391
|
+
if (!t.closed) fail(t, "Close the quote", { at: t.e, fix: { s: t.e, e: t.e, text: '"', verb: "Add", label: '"' } });
|
|
392
|
+
if (t.v.includes("\0")) errors.push({ s: t.s, e: t.e, msg: "Remove the hidden NUL character from this text" });
|
|
393
|
+
role(t, "str");
|
|
394
|
+
} else if (t.t === "num") role(t, "num");
|
|
395
|
+
else if (t.t === "bool" && allowBool) role(t, "bool");
|
|
396
|
+
else if (t.t !== "word" || type === "number" || type === "latency") fail(t, `Expected a ${type === "number" || type === "latency" ? "number" : "value"}, found ${word(t)}`);
|
|
397
|
+
else fail(t, `Expected a value, found ${word(t)}`, { fix: (type === "boolean" ? ["true", "false"] : [lit(t.raw)]).map((x) => ({ s: t.s, e: t.e, text: x, verb: "Use", label: x })) });
|
|
398
|
+
p++;
|
|
399
|
+
return { v: t.v, raw: t.t === "str" ? t.raw : t.t === "bool" ? String(t.v) : t.raw, tok: t };
|
|
400
|
+
};
|
|
401
|
+
const list = (allowBool = true, type) => {
|
|
402
|
+
const o = peek();
|
|
403
|
+
if (!isP(o, "[")) fail(o, `Expected a list like ${type === "number" ? "[1, 2]" : type === "boolean" ? "[true, false]" : '["a", "b"]'}`, o && ["str", "num", "bool"].includes(o.t) ? { fix: { s: o.s, e: o.s, text: "[", verb: "Add", label: "[" } } : void 0);
|
|
404
|
+
p++;
|
|
405
|
+
const vals = [];
|
|
406
|
+
if (isP(peek(), "]")) fail(peek(), "Add at least one value to the list");
|
|
407
|
+
for (; ; ) {
|
|
408
|
+
vals.push(value(allowBool, type));
|
|
409
|
+
if (isP(peek(), ",")) {
|
|
410
|
+
p++;
|
|
411
|
+
continue;
|
|
412
|
+
}
|
|
413
|
+
if (isP(peek(), "]")) {
|
|
414
|
+
const c2 = peek();
|
|
415
|
+
p++;
|
|
416
|
+
return { vals, e: c2.e };
|
|
417
|
+
}
|
|
418
|
+
const c = peek();
|
|
419
|
+
const prev = peek(-1);
|
|
420
|
+
const ins = (text, verb, label) => ({ s: prev.e, e: prev.e, text, verb, label });
|
|
421
|
+
if (c && ["str", "num", "bool"].includes(c.t)) fail(c, `Separate list values with a comma, between ${prev.raw} and ${c.raw}`, { s: prev.s, at: prev.e, fix: ins(",", "Add", ",") });
|
|
422
|
+
fail(c, `Close the list with ] after ${prev.raw}`, { s: o.s, e: o.e, at: prev.e, fix: ins("]", "Add", "]") });
|
|
423
|
+
}
|
|
424
|
+
};
|
|
425
|
+
const typeFix = (f, val, display) => {
|
|
426
|
+
if (!f) return;
|
|
427
|
+
const t = val.tok;
|
|
428
|
+
const isNumText = typeof val.v === "string" && /^-?\d+(\.\d+)?$/.test(val.v);
|
|
429
|
+
if ((f.type === "string" || f.type === "numtext" || f.type === "ip") && t.t !== "str") {
|
|
430
|
+
errors.push({ s: t.s, e: t.e, msg: `${display} is stored as text, so ${t.raw} never matches. Use "${t.raw}".`, fix: { s: t.s, e: t.e, text: `"${t.raw}"`, label: `"${t.raw}"` } });
|
|
431
|
+
} else if (f.type === "number" && t.t !== "num") {
|
|
432
|
+
if (isNumText) errors.push({ s: t.s, e: t.e, msg: `${display} is stored as a number, so ${t.raw} never matches. Use ${val.v}.`, fix: { s: t.s, e: t.e, text: val.v, label: val.v } });
|
|
433
|
+
else errors.push({ s: t.s, e: t.e, msg: `${display} holds numbers, ${t.raw} is not one` });
|
|
434
|
+
} else if (f.type === "boolean" && t.t !== "bool") {
|
|
435
|
+
if (t.t === "str" && /^(true|false)$/i.test(val.v)) errors.push({ s: t.s, e: t.e, msg: `${display} is a boolean, write ${val.v.toLowerCase()} without quotes`, fix: { s: t.s, e: t.e, text: val.v.toLowerCase(), label: val.v.toLowerCase() } });
|
|
436
|
+
else errors.push({ s: t.s, e: t.e, msg: `${display} is a boolean, use true or false` });
|
|
437
|
+
}
|
|
438
|
+
};
|
|
439
|
+
const numFix = (val, display) => {
|
|
440
|
+
const t = val.tok;
|
|
441
|
+
if (t.t === "num") return;
|
|
442
|
+
if (t.t === "str" && /^-?\d+(\.\d+)?$/.test(val.v)) errors.push({ s: t.s, e: t.e, msg: `Numeric operators take a bare number. Use ${val.v}.`, fix: { s: t.s, e: t.e, text: val.v, label: val.v } });
|
|
443
|
+
else errors.push({ s: t.s, e: t.e, msg: `${display} needs a number here, found ${t.raw}` });
|
|
444
|
+
};
|
|
445
|
+
const condition = () => {
|
|
446
|
+
const t = peek();
|
|
447
|
+
let field;
|
|
448
|
+
let fs = t.s;
|
|
449
|
+
let fe;
|
|
450
|
+
if (isP(t, "(")) {
|
|
451
|
+
const a = peek(1);
|
|
452
|
+
const b = peek(3);
|
|
453
|
+
[t, a, peek(2), b, peek(4)].forEach((x) => role(x, "field"));
|
|
454
|
+
if (a.v !== LAT_A || b.v !== LAT_B) errors.push({ s: t.s, e: peek(4).e, msg: `Latency is written ${LATENCY}`, fix: { s: t.s, e: peek(4).e, text: LATENCY, label: LATENCY } });
|
|
455
|
+
field = "@latency";
|
|
456
|
+
fe = peek(4).e;
|
|
457
|
+
p += 5;
|
|
458
|
+
} else if (isKw(t, "LATENCY")) {
|
|
459
|
+
role(t, "field");
|
|
460
|
+
field = "@latency";
|
|
461
|
+
fe = t.e;
|
|
462
|
+
p++;
|
|
463
|
+
} else if (t.t === "word") {
|
|
464
|
+
role(t, "field");
|
|
465
|
+
field = t.v.replace(/\\\./g, ".");
|
|
466
|
+
fe = t.e;
|
|
467
|
+
p++;
|
|
468
|
+
if (!schema.byPath[field]) {
|
|
469
|
+
const n = near(field, schema);
|
|
470
|
+
errors.push({ s: t.s, e: t.e, msg: `${field} is not a field in this index`, near: n });
|
|
471
|
+
}
|
|
472
|
+
} else fail(t, t.t === "kw" ? `${t.raw} needs a condition before it` : `Expected a field, found ${word(t)}`);
|
|
473
|
+
const f = field === "@latency" ? LAT_FIELD : schema.byPath[field];
|
|
474
|
+
const display = field === "@latency" ? "Latency" : field;
|
|
475
|
+
const o = peek();
|
|
476
|
+
if (!o && !f) throw errors.pop();
|
|
477
|
+
if (!o) fail(null, `Add an operator after ${display}`);
|
|
478
|
+
let op;
|
|
479
|
+
if (o.t === "op") {
|
|
480
|
+
op = o.v === "=" ? "==" : o.v;
|
|
481
|
+
role(o, "op");
|
|
482
|
+
p++;
|
|
483
|
+
} else if (o.t === "kw" && ["CONTAINS", "PRESENT", "ABSENT", "BETWEEN", "ANYONE", "NONEOF"].includes(o.v)) {
|
|
484
|
+
op = o.v;
|
|
485
|
+
role(o, "op");
|
|
486
|
+
p++;
|
|
487
|
+
} else if (isKw(o, "NOT") && isKw(peek(1), "CONTAINS")) {
|
|
488
|
+
op = "NOT CONTAINS";
|
|
489
|
+
role(o, "op");
|
|
490
|
+
role(peek(1), "op");
|
|
491
|
+
p += 2;
|
|
492
|
+
} else if (isKw(o, "IP") && (isKw(peek(1), "IN_RANGE") || isKw(peek(1), "NOT_IN_RANGE"))) {
|
|
493
|
+
op = "IP " + peek(1).v;
|
|
494
|
+
role(o, "op");
|
|
495
|
+
role(peek(1), "op");
|
|
496
|
+
p += 2;
|
|
497
|
+
} else if (isKw(o, "IP")) fail(peek(1) || o, "After IP write IN_RANGE or NOT_IN_RANGE");
|
|
498
|
+
else if (o.t === "minus") {
|
|
499
|
+
const b = peek(1);
|
|
500
|
+
const open = peek(-2);
|
|
501
|
+
if ((b == null ? void 0 : b.t) === "word" && isP(open, "(")) fail(o, `Missing ) after ${b.raw}`, { s: open.s, e: open.e, at: b.e, fix: { s: b.e, e: b.e, text: ")", verb: "Add", label: ")" } });
|
|
502
|
+
if ((b == null ? void 0 : b.t) === "word") fail(o, `Latency is written ${LATENCY}`, { s: t.s, e: b.e, at: b.e, fix: { s: t.s, e: b.e, text: LATENCY, verb: "Wrap in", label: "( )" } });
|
|
503
|
+
fail(o, `Latency is written ${LATENCY}`);
|
|
504
|
+
} else fail(o, `Expected an operator after ${display}, found ${word(o)}`);
|
|
505
|
+
const node = { k: "cond", field, op, s: fs };
|
|
506
|
+
if (f && !opsFor(f).includes(op)) {
|
|
507
|
+
const why = f.type === "latency" ? "Latency takes >, <, >=, <= or BETWEEN" : op.startsWith("IP") ? "IP operators work only on fields that hold IP addresses" : CMP.has(op) || op === "BETWEEN" ? `${op} needs a number field, ${display} holds ${TYPE_LABEL[f.type]}` : `${op} does not apply to ${display} (${TYPE_LABEL[f.type]})`;
|
|
508
|
+
const base = op.endsWith("*") && opsFor(f).includes(op.slice(0, -1)) ? op.slice(0, -1) : null;
|
|
509
|
+
errors.push({ s: o.s, e: (peek(-1) || o).e, msg: base ? `${op} does not apply to ${display}, use ${base}` : why, ...base ? { fix: { s: o.s, e: o.e, text: base, verb: "Use", label: base } } : {} });
|
|
510
|
+
}
|
|
511
|
+
if (op === "PRESENT" || op === "ABSENT") {
|
|
512
|
+
node.e = o.e;
|
|
513
|
+
return node;
|
|
514
|
+
}
|
|
515
|
+
if (op === "BETWEEN") {
|
|
516
|
+
const lo = value(false, "number");
|
|
517
|
+
const a = peek();
|
|
518
|
+
if (!isKw(a, "AND")) fail(a, "BETWEEN needs AND, like BETWEEN 200 AND 299", (a == null ? void 0 : a.t) === "num" ? { s: lo.tok.s, e: a.e, at: lo.tok.e, fix: { s: lo.tok.e, e: lo.tok.e, text: " AND", verb: "Add", label: "AND" } } : void 0);
|
|
519
|
+
role(a, "op");
|
|
520
|
+
p++;
|
|
521
|
+
const hi = value(false, "number");
|
|
522
|
+
numFix(lo, display);
|
|
523
|
+
numFix(hi, display);
|
|
524
|
+
if (Number(lo.v) > Number(hi.v)) errors.push({ s: lo.tok.s, e: hi.tok.e, msg: "The first number must be the smaller one", fix: { s: lo.tok.s, e: hi.tok.e, text: `${hi.raw} AND ${lo.raw}`, verb: "Swap to", label: `${hi.raw} AND ${lo.raw}` } });
|
|
525
|
+
Object.assign(node, { lo, hi, e: hi.tok.e });
|
|
526
|
+
return node;
|
|
527
|
+
}
|
|
528
|
+
if (op === "ANYONE" || op === "NONEOF") {
|
|
529
|
+
const l = list(true, f == null ? void 0 : f.type);
|
|
530
|
+
for (const v2 of l.vals) typeFix(f, v2, display);
|
|
531
|
+
Object.assign(node, { vals: l.vals, e: l.e });
|
|
532
|
+
return node;
|
|
533
|
+
}
|
|
534
|
+
if (op.startsWith("IP")) {
|
|
535
|
+
let vals;
|
|
536
|
+
if (isP(peek(), "[")) {
|
|
537
|
+
const l = list(false);
|
|
538
|
+
vals = l.vals;
|
|
539
|
+
node.e = l.e;
|
|
540
|
+
node.list = true;
|
|
541
|
+
} else {
|
|
542
|
+
const v2 = value(false);
|
|
543
|
+
vals = [v2];
|
|
544
|
+
node.e = v2.tok.e;
|
|
545
|
+
}
|
|
546
|
+
for (const v2 of vals) {
|
|
547
|
+
if (v2.tok.t !== "str") errors.push({ s: v2.tok.s, e: v2.tok.e, msg: 'Write the range in quotes, like "10.0.0.0/8"' });
|
|
548
|
+
else if (!v2.v.trim()) errors.push({ s: v2.tok.s, e: v2.tok.e, msg: 'Add a range, like "10.0.0.0/8" or "10.0.0.1-10.0.0.50"' });
|
|
549
|
+
else if (!parseRange(v2.v.includes("/") || v2.v.includes("-") ? v2.v : v2.v + (v2.v.includes(":") ? "/128" : "/32"))) errors.push({ s: v2.tok.s, e: v2.tok.e, msg: `${v2.raw} is not a valid CIDR or range. Use "10.0.0.0/8" or "10.0.0.1-10.0.0.50".` });
|
|
550
|
+
}
|
|
551
|
+
node.vals = vals;
|
|
552
|
+
return node;
|
|
553
|
+
}
|
|
554
|
+
const v = value(!TEXT_OPS.has(op), f == null ? void 0 : f.type);
|
|
555
|
+
node.val = v;
|
|
556
|
+
node.e = v.tok.e;
|
|
557
|
+
if (TEXT_OPS.has(op) && v.tok.t !== "str") errors.push({ s: v.tok.s, e: v.tok.e, msg: `${op} takes text in quotes`, fix: { s: v.tok.s, e: v.tok.e, text: `"${v.tok.raw}"`, label: `"${v.tok.raw}"` } });
|
|
558
|
+
else if (REGEX.has(op)) {
|
|
559
|
+
try {
|
|
560
|
+
new RegExp(v.v);
|
|
561
|
+
const pg = pgRegex(v.v);
|
|
562
|
+
if (pg) errors.push({ s: v.tok.s, e: v.tok.e, msg: pg.msg, ...pg.fix ? { fix: { s: v.tok.s, e: v.tok.e, text: lit(pg.fix), label: lit(pg.fix) } } : {} });
|
|
563
|
+
} catch (err) {
|
|
564
|
+
errors.push({ s: v.tok.s, e: v.tok.e, msg: `Invalid regex: ${String(err.message).replace(/^Invalid regular expression: /, "")}` });
|
|
565
|
+
}
|
|
566
|
+
} else if (CMP.has(op)) numFix(v, display);
|
|
567
|
+
else if (op === "==" || op === "!=") typeFix(f, v, display);
|
|
568
|
+
return node;
|
|
569
|
+
};
|
|
570
|
+
const countClause = () => {
|
|
571
|
+
const t = peek();
|
|
572
|
+
role(t, "fn");
|
|
573
|
+
p++;
|
|
574
|
+
if (!isP(peek(), "(") || !isP(peek(1), ")")) fail(peek(), "Write COUNT()");
|
|
575
|
+
role(peek(), "fn");
|
|
576
|
+
role(peek(1), "fn");
|
|
577
|
+
p += 2;
|
|
578
|
+
const o = peek();
|
|
579
|
+
if (!o || o.t !== "op" || REGEX.has(o.v) || o.v === "!=") fail(o, "COUNT() takes >, <, >=, <= or ==", (o == null ? void 0 : o.t) === "num" ? { fix: { s: o.s, e: o.s, text: "> ", verb: "Add", label: ">" } } : void 0);
|
|
580
|
+
role(o, "op");
|
|
581
|
+
p++;
|
|
582
|
+
const n = peek();
|
|
583
|
+
if (!n || n.t !== "num") fail(n, "COUNT() needs a number, like COUNT() > 50");
|
|
584
|
+
role(n, "num");
|
|
585
|
+
p++;
|
|
586
|
+
const node = { k: "count", op: o.v === "=" ? "==" : o.v, n: n.v, s: t.s, e: n.e };
|
|
587
|
+
if (isKw(peek(), "WITHIN")) {
|
|
588
|
+
role(peek(), "kw");
|
|
589
|
+
p++;
|
|
590
|
+
const d = peek();
|
|
591
|
+
if (d && d.t === "num") fail(d, `Add a unit: ${d.raw}s, ${d.raw}m, ${d.raw}h or ${d.raw}d`, { fix: ["s", "m", "h", "d"].map((u) => ({ s: d.s, e: d.e, text: d.raw + u, verb: "Use", label: d.raw + u })) });
|
|
592
|
+
if (!d || d.t !== "dur") fail(d, "WITHIN takes a window like 5m");
|
|
593
|
+
role(d, "num");
|
|
594
|
+
p++;
|
|
595
|
+
node.within = d.v;
|
|
596
|
+
node.ms = d.ms;
|
|
597
|
+
node.e = d.e;
|
|
598
|
+
}
|
|
599
|
+
if (isKw(peek(), "GROUP")) {
|
|
600
|
+
role(peek(), "kw");
|
|
601
|
+
p++;
|
|
602
|
+
if (!isKw(peek(), "BY")) fail(peek(), "Write GROUP BY");
|
|
603
|
+
role(peek(), "kw");
|
|
604
|
+
p++;
|
|
605
|
+
const g = peek();
|
|
606
|
+
if (!g || g.t !== "word") fail(g, "GROUP BY needs a field");
|
|
607
|
+
role(g, "field");
|
|
608
|
+
p++;
|
|
609
|
+
const by = g.v.replace(/\\\./g, ".");
|
|
610
|
+
if (!schema.byPath[by]) errors.push({ s: g.s, e: g.e, msg: `${g.v} is not a field in this index`, near: near(g.v, schema) });
|
|
611
|
+
node.by = by;
|
|
612
|
+
node.e = g.e;
|
|
613
|
+
}
|
|
614
|
+
return node;
|
|
615
|
+
};
|
|
616
|
+
const primary = () => {
|
|
617
|
+
const t = peek();
|
|
618
|
+
if (!t) fail(null, "Add a condition");
|
|
619
|
+
if (isP(t, "(") && !latencyAhead()) {
|
|
620
|
+
role(t, "punct");
|
|
621
|
+
p++;
|
|
622
|
+
const x = orExpr();
|
|
623
|
+
const c = peek();
|
|
624
|
+
if (!isP(c, ")")) {
|
|
625
|
+
const end = peek(-1).e;
|
|
626
|
+
const ins = (text, label) => ({ s: end, e: end, text, verb: "Add", label });
|
|
627
|
+
if (c) fail(c, `Expected ) or AND/OR before ${word(c)}`, { at: end, fix: [...toks.slice(p).some((x2) => isP(x2, ")")) ? [] : [ins(")", ")")], ins(" AND", "AND"), ins(" OR", "OR")] });
|
|
628
|
+
fail(c, "Close the group with ). The highlighted ( is never closed.", { s: t.s, e: t.e, at: end, fix: [ins(")", ")"), { s: t.s, e: t.e, text: "", verb: "Remove", label: "this (" }] });
|
|
629
|
+
}
|
|
630
|
+
role(c, "punct");
|
|
631
|
+
p++;
|
|
632
|
+
return { k: "group", x, s: t.s, e: c.e };
|
|
633
|
+
}
|
|
634
|
+
if (isKw(t, "COUNT")) return countClause();
|
|
635
|
+
return condition();
|
|
636
|
+
};
|
|
637
|
+
const notExpr = () => {
|
|
638
|
+
const t = peek();
|
|
639
|
+
if (isKw(t, "NOT")) {
|
|
640
|
+
role(t, "kw");
|
|
641
|
+
p++;
|
|
642
|
+
const x = notExpr();
|
|
643
|
+
return { k: "not", x, s: t.s, e: x.e };
|
|
644
|
+
}
|
|
645
|
+
return primary();
|
|
646
|
+
};
|
|
647
|
+
const join = (k, next) => () => {
|
|
648
|
+
const items = [next()];
|
|
649
|
+
while (isKw(peek(), k)) {
|
|
650
|
+
role(peek(), "kw");
|
|
651
|
+
p++;
|
|
652
|
+
items.push(next());
|
|
653
|
+
}
|
|
654
|
+
return items.length === 1 ? items[0] : { k: k.toLowerCase(), items, s: items[0].s, e: items[items.length - 1].e };
|
|
655
|
+
};
|
|
656
|
+
const andExpr = join("AND", notExpr);
|
|
657
|
+
const orExpr = join("OR", andExpr);
|
|
658
|
+
let ast = null;
|
|
659
|
+
let syntax = null;
|
|
660
|
+
if (toks.length) {
|
|
661
|
+
try {
|
|
662
|
+
ast = orExpr();
|
|
663
|
+
if (p < toks.length) {
|
|
664
|
+
const t = peek();
|
|
665
|
+
const end = peek(-1).e;
|
|
666
|
+
if (isP(t, ")")) fail(t, "This ) has no matching (", { fix: { s: t.s, e: t.e, text: "", verb: "Remove", label: "this )" } });
|
|
667
|
+
fail(t, `Join conditions with AND or OR before ${word(t)}`, { at: end, fix: [" AND", " OR"].map((x) => ({ s: end, e: end, text: x, verb: "Add", label: x.trim() })) });
|
|
668
|
+
}
|
|
669
|
+
} catch (err) {
|
|
670
|
+
if (!err || err.msg === void 0) throw err;
|
|
671
|
+
syntax = err;
|
|
672
|
+
ast = null;
|
|
673
|
+
const k = toks.findIndex((t, j) => {
|
|
674
|
+
var _a;
|
|
675
|
+
return t.t === "str" && t.closed && ((_a = toks[j + 1]) == null ? void 0 : _a.t) === "word" && toks[j + 1].s === t.e && /\s(?:AND|OR|ANYONE|NONEOF|CONTAINS|BETWEEN)\s|[=!<>~[]|,\s*$|\b(?:data|metadata)\./.test(t.v);
|
|
676
|
+
});
|
|
677
|
+
if (k >= 0 && toks[k].s <= Math.max(syntax.s, syntax.e, syntax.at ?? 0)) {
|
|
678
|
+
const w = toks[k].raw.slice(1).match(/^[^\s",]*/)[0];
|
|
679
|
+
const at = toks[k].s + 1 + w.length;
|
|
680
|
+
syntax = { s: toks[k].s, e: at, at, msg: `Missing " after ${w}`, fix: { s: at, e: at, text: '"', verb: "Add", label: `" after ${w}` } };
|
|
681
|
+
}
|
|
682
|
+
}
|
|
683
|
+
}
|
|
684
|
+
if (ast) {
|
|
685
|
+
const counts = [];
|
|
686
|
+
const walk = (n, top) => {
|
|
687
|
+
if (n.k === "count") counts.push({ n, top });
|
|
688
|
+
if (n.items) n.items.forEach((x, i) => walk(x, n === ast && n.k === "and" && i === n.items.length - 1));
|
|
689
|
+
if (n.x) walk(n.x, false);
|
|
690
|
+
};
|
|
691
|
+
walk(ast, ast.k === "count");
|
|
692
|
+
if (counts.length > 1) counts.slice(1).forEach(({ n }) => errors.push({ s: n.s, e: n.e, msg: "Only one COUNT() per query" }));
|
|
693
|
+
else if (counts.length === 1 && !counts[0].top) errors.push({ s: counts[0].n.s, e: counts[0].n.e, msg: "COUNT() goes last, joined with AND" });
|
|
694
|
+
}
|
|
695
|
+
const all = syntax ? [syntax, ...errors] : errors;
|
|
696
|
+
all.sort((a, b) => a.s - b.s);
|
|
697
|
+
return { ast, errors: all, toks };
|
|
698
|
+
}
|
|
699
|
+
function format(ast, name, pretty) {
|
|
700
|
+
const f = (x) => x === "@latency" ? name ? name(x) : LATENCY : name ? name(x) : x;
|
|
701
|
+
const one = (n, d = 0) => {
|
|
702
|
+
if (n.k === "cond") {
|
|
703
|
+
const head = `${f(n.field)} ${n.op}`;
|
|
704
|
+
if (n.op === "PRESENT" || n.op === "ABSENT") return head;
|
|
705
|
+
if (n.op === "BETWEEN") return `${head} ${n.lo.raw} AND ${n.hi.raw}`;
|
|
706
|
+
if (n.vals && (n.list || !n.op.startsWith("IP"))) return `${head} [${n.vals.map((v) => v.raw).join(", ")}]`;
|
|
707
|
+
if (n.vals) return `${head} ${n.vals[0].raw}`;
|
|
708
|
+
return `${head} ${n.val.raw}`;
|
|
709
|
+
}
|
|
710
|
+
if (n.k === "count") return `COUNT() ${n.op} ${n.n}${n.within ? " WITHIN " + n.within : ""}${n.by ? " GROUP BY " + f(n.by) : ""}`;
|
|
711
|
+
const ind = (k) => "\n" + " ".repeat(k);
|
|
712
|
+
if (n.k === "group") return pretty && n.x.items ? `(${ind(d + 1)}${one(n.x, d + 1)}${ind(d)})` : `(${one(n.x, d)})`;
|
|
713
|
+
if (n.k === "not") return `NOT ${one(n.x, d)}`;
|
|
714
|
+
if (pretty) return n.items.map((x, i) => (i ? `${ind(d)}${n.k.toUpperCase()} ` : "") + one(x, d)).join("");
|
|
715
|
+
return n.items.map((x) => one(x)).join(` ${n.k.toUpperCase()} `);
|
|
716
|
+
};
|
|
717
|
+
return ast ? one(ast) : "";
|
|
718
|
+
}
|
|
719
|
+
var get = (row, path) => {
|
|
720
|
+
const segs = path.replace(/\\\./g, ".").split(".");
|
|
721
|
+
let o = row;
|
|
722
|
+
let i = 0;
|
|
723
|
+
while (i < segs.length) {
|
|
724
|
+
if (o == null || typeof o !== "object") return void 0;
|
|
725
|
+
let j = segs.length;
|
|
726
|
+
while (j > i && !(segs.slice(i, j).join(".") in o)) j--;
|
|
727
|
+
if (j === i) return void 0;
|
|
728
|
+
o = o[segs.slice(i, j).join(".")];
|
|
729
|
+
i = j;
|
|
730
|
+
}
|
|
731
|
+
return o;
|
|
732
|
+
};
|
|
733
|
+
var asNum = (v) => typeof v === "number" ? v : typeof v === "string" && /^-?\d+(\.\d+)?$/.test(v) ? Number(v) : null;
|
|
734
|
+
var inRanges = (v, vals) => {
|
|
735
|
+
const ip = ipToBig(v);
|
|
736
|
+
if (!ip) return null;
|
|
737
|
+
return vals.some((x) => {
|
|
738
|
+
const r = parseRange(x.v.includes("/") || x.v.includes("-") ? x.v : x.v + (x.v.includes(":") ? "/128" : "/32"));
|
|
739
|
+
return r && r.v === ip.v && ip.n >= r.lo && ip.n <= r.hi;
|
|
740
|
+
});
|
|
741
|
+
};
|
|
742
|
+
function test(n, row) {
|
|
743
|
+
if (n.k === "group") return test(n.x, row);
|
|
744
|
+
if (n.k === "not") {
|
|
745
|
+
const r = test(n.x, row);
|
|
746
|
+
return r === null ? null : !r;
|
|
747
|
+
}
|
|
748
|
+
if (n.k === "and") {
|
|
749
|
+
let unknown = false;
|
|
750
|
+
for (const x2 of n.items) {
|
|
751
|
+
const r = test(x2, row);
|
|
752
|
+
if (r === false) return false;
|
|
753
|
+
if (r === null) unknown = true;
|
|
754
|
+
}
|
|
755
|
+
return unknown ? null : true;
|
|
756
|
+
}
|
|
757
|
+
if (n.k === "or") {
|
|
758
|
+
let unknown = false;
|
|
759
|
+
for (const x2 of n.items) {
|
|
760
|
+
const r = test(x2, row);
|
|
761
|
+
if (r === true) return true;
|
|
762
|
+
if (r === null) unknown = true;
|
|
763
|
+
}
|
|
764
|
+
return unknown ? null : false;
|
|
765
|
+
}
|
|
766
|
+
if (n.k === "count") return true;
|
|
767
|
+
let v;
|
|
768
|
+
if (n.field === "@latency") {
|
|
769
|
+
const a = get(row, LAT_A);
|
|
770
|
+
const b = get(row, LAT_B);
|
|
771
|
+
v = typeof a === "number" && typeof b === "number" ? a - b : void 0;
|
|
772
|
+
} else v = get(row, n.field);
|
|
773
|
+
if (n.op === "PRESENT") return v !== void 0 && v !== null;
|
|
774
|
+
if (n.op === "ABSENT") return v === void 0 || v === null;
|
|
775
|
+
if (v === void 0 || v === null) return null;
|
|
776
|
+
switch (n.op) {
|
|
777
|
+
case "==":
|
|
778
|
+
return v === n.val.v;
|
|
779
|
+
case "!=":
|
|
780
|
+
return v !== n.val.v;
|
|
781
|
+
case "~":
|
|
782
|
+
case "~*":
|
|
783
|
+
case "!~":
|
|
784
|
+
case "!~*": {
|
|
785
|
+
const hit = new RegExp(n.val.v, n.op.endsWith("*") ? "i" : "").test(String(v));
|
|
786
|
+
return n.op.startsWith("!") ? !hit : hit;
|
|
787
|
+
}
|
|
788
|
+
case "CONTAINS":
|
|
789
|
+
return String(v).includes(n.val.v);
|
|
790
|
+
case "NOT CONTAINS":
|
|
791
|
+
return !String(v).includes(n.val.v);
|
|
792
|
+
case "ANYONE":
|
|
793
|
+
return n.vals.some((x2) => x2.v === v);
|
|
794
|
+
case "NONEOF":
|
|
795
|
+
return !n.vals.some((x2) => x2.v === v);
|
|
796
|
+
case "IP IN_RANGE":
|
|
797
|
+
return inRanges(v, n.vals);
|
|
798
|
+
case "IP NOT_IN_RANGE": {
|
|
799
|
+
const r = inRanges(v, n.vals);
|
|
800
|
+
return r === null ? null : !r;
|
|
801
|
+
}
|
|
802
|
+
}
|
|
803
|
+
const x = asNum(v);
|
|
804
|
+
if (x === null) return null;
|
|
805
|
+
if (n.op === "BETWEEN") return x >= Number(n.lo.v) && x <= Number(n.hi.v);
|
|
806
|
+
const y = Number(n.val.v);
|
|
807
|
+
return n.op === "<" ? x < y : n.op === "<=" ? x <= y : n.op === ">" ? x > y : x >= y;
|
|
808
|
+
}
|
|
809
|
+
var cmp = (a, op, b) => op === ">" ? a > b : op === "<" ? a < b : op === ">=" ? a >= b : op === "<=" ? a <= b : a === b;
|
|
810
|
+
function evaluate(ast, rows) {
|
|
811
|
+
if (!ast) return { rows, count: null };
|
|
812
|
+
const count = ast.k === "count" ? ast : ast.k === "and" && ast.items[ast.items.length - 1].k === "count" ? ast.items[ast.items.length - 1] : null;
|
|
813
|
+
const hit = rows.filter((r) => test(ast, r) === true);
|
|
814
|
+
if (!count) return { rows: hit, count: null };
|
|
815
|
+
const buckets = /* @__PURE__ */ new Map();
|
|
816
|
+
for (const r of hit) {
|
|
817
|
+
const key = count.by ? get(r, count.by) : "*";
|
|
818
|
+
if (key === void 0 || key === null) continue;
|
|
819
|
+
const win = count.ms ? Math.floor(r.metadata.requestTimestamp / count.ms) * count.ms : 0;
|
|
820
|
+
const id = key + "\0" + win;
|
|
821
|
+
let b = buckets.get(id);
|
|
822
|
+
if (!b) buckets.set(id, b = { key, win, rows: [] });
|
|
823
|
+
b.rows.push(r);
|
|
824
|
+
}
|
|
825
|
+
const pass = [...buckets.values()].filter((b) => cmp(b.rows.length, count.op, count.n)).sort((a, b) => b.rows.length - a.rows.length);
|
|
826
|
+
return { rows: pass.flatMap((b) => b.rows).sort((a, b) => b.metadata.requestTimestamp - a.metadata.requestTimestamp), count: { node: count, groups: pass, buckets: buckets.size, filtered: hit.length } };
|
|
827
|
+
}
|
|
828
|
+
function context(src, caret, schema) {
|
|
829
|
+
const toks = tokenize(src.slice(0, caret));
|
|
830
|
+
let part = null;
|
|
831
|
+
const last = toks[toks.length - 1];
|
|
832
|
+
if (last && last.e === caret && ["word", "kw", "bool", "op", "num", "dur"].includes(last.t)) part = toks.pop();
|
|
833
|
+
else if (last && last.t === "str" && !last.closed) part = toks.pop();
|
|
834
|
+
let st = "term";
|
|
835
|
+
let depth = 0;
|
|
836
|
+
let field = null;
|
|
837
|
+
let op = null;
|
|
838
|
+
let between = false;
|
|
839
|
+
let hasCount = /\bCOUNT\s*\(/i.test(src.slice(caret));
|
|
840
|
+
let used = [];
|
|
841
|
+
let inList = false;
|
|
842
|
+
let opTok = null;
|
|
843
|
+
let eq = null;
|
|
844
|
+
for (let i = 0; i < toks.length; i++) {
|
|
845
|
+
const t = toks[i];
|
|
846
|
+
const kw = t.t === "kw" ? t.v : null;
|
|
847
|
+
if (kw === "COUNT") hasCount = true;
|
|
848
|
+
if (st === "term") {
|
|
849
|
+
if (kw === "NOT") continue;
|
|
850
|
+
if (t.v === "(" && t.t === "punct") depth++;
|
|
851
|
+
else if (kw === "COUNT") st = "countParen";
|
|
852
|
+
else if (kw === "LATENCY") field = LAT_FIELD, st = "op";
|
|
853
|
+
else if (t.t === "word") field = schema.byPath[t.v.replace(/\\\./g, ".")] || { path: t.v, type: null }, st = "op";
|
|
854
|
+
else st = "bad";
|
|
855
|
+
} else if (st === "op") {
|
|
856
|
+
if (t.t === "minus") st = "lat2";
|
|
857
|
+
else if (t.t === "op") op = t.v === "=" ? "==" : t.v, opTok = t, st = "value";
|
|
858
|
+
else if (kw === "PRESENT" || kw === "ABSENT") st = "joiner";
|
|
859
|
+
else if (kw === "CONTAINS") op = kw, st = "value";
|
|
860
|
+
else if (kw === "NOT") st = "notc";
|
|
861
|
+
else if (kw === "IP") st = "ipop";
|
|
862
|
+
else if (kw === "BETWEEN") op = kw, between = true, st = "value";
|
|
863
|
+
else if (kw === "ANYONE" || kw === "NONEOF") op = kw, opTok = t, st = "listStart";
|
|
864
|
+
else st = "bad";
|
|
865
|
+
} else if (st === "lat2") st = t.t === "word" ? "latClose" : "bad";
|
|
866
|
+
else if (st === "latClose") {
|
|
867
|
+
if (t.v === ")") depth = Math.max(0, depth - 1), field = LAT_FIELD, st = "op";
|
|
868
|
+
else st = "bad";
|
|
869
|
+
} else if (st === "notc") st = kw === "CONTAINS" ? (op = "NOT CONTAINS", "value") : "bad";
|
|
870
|
+
else if (st === "ipop") st = kw === "IN_RANGE" || kw === "NOT_IN_RANGE" ? (op = "IP " + kw, "value") : "bad";
|
|
871
|
+
else if (st === "listStart") st = t.v === "[" ? (used = [], inList = true, "list") : "bad";
|
|
872
|
+
else if (st === "value") {
|
|
873
|
+
if (t.v === "[" && t.t === "punct") used = [], inList = true, st = "list";
|
|
874
|
+
else if (t.t === "str" || t.t === "num" || t.t === "bool") st = between ? "betAnd" : "joiner", eq = (op === "==" || op === "!=") && opTok ? { op, from: opTok.s, to: t.e, vals: [t.v] } : null;
|
|
875
|
+
else st = "bad";
|
|
876
|
+
} else if (st === "list") {
|
|
877
|
+
if (t.t === "str" || t.t === "num" || t.t === "bool") used.push(t.v);
|
|
878
|
+
else if (t.v === "]") inList = false, st = "joiner", eq = (op === "ANYONE" || op === "NONEOF") && opTok ? { op, from: opTok.s, to: t.e, vals: [...used] } : null;
|
|
879
|
+
else if (t.v !== ",") st = "bad";
|
|
880
|
+
} else if (st === "betAnd") st = kw === "AND" ? (between = false, "value") : "bad";
|
|
881
|
+
else if (st === "joiner") {
|
|
882
|
+
if (kw === "AND" || kw === "OR") st = "term", field = null, op = null, eq = null;
|
|
883
|
+
else if (t.v === ")" && t.t === "punct") depth = Math.max(0, depth - 1);
|
|
884
|
+
else st = "bad";
|
|
885
|
+
} else if (st === "countParen") st = t.v === "(" ? "countParen2" : "bad";
|
|
886
|
+
else if (st === "countParen2") st = t.v === ")" ? "countOp" : "bad";
|
|
887
|
+
else if (st === "countOp") st = t.t === "op" ? "countN" : "bad";
|
|
888
|
+
else if (st === "countN") st = t.t === "num" ? "countAfter" : "bad";
|
|
889
|
+
else if (st === "countAfter") st = kw === "WITHIN" ? "dur" : kw === "GROUP" ? "by" : "bad";
|
|
890
|
+
else if (st === "dur") st = t.t === "dur" ? "countAfter2" : "bad";
|
|
891
|
+
else if (st === "countAfter2") st = kw === "GROUP" ? "by" : "bad";
|
|
892
|
+
else if (st === "by") st = kw === "BY" ? "groupField" : "bad";
|
|
893
|
+
else if (st === "groupField") st = t.t === "word" ? "end" : "bad";
|
|
894
|
+
}
|
|
895
|
+
let to = caret;
|
|
896
|
+
const tail = src.slice(caret).match(/^(?:[A-Za-z0-9_.-]|\\\.)+/);
|
|
897
|
+
if (part && part.t !== "str" && tail) to += tail[0].length;
|
|
898
|
+
if (part && part.t === "str") {
|
|
899
|
+
const m = src.slice(caret).match(/^(?:[^"\\\n]|\\.)*"/);
|
|
900
|
+
if (m) to += m[0].length;
|
|
901
|
+
}
|
|
902
|
+
const from = part ? part.s : caret;
|
|
903
|
+
const q = part ? (part.t === "str" ? part.v : part.raw).toLowerCase() : "";
|
|
904
|
+
const before = src.slice(0, from);
|
|
905
|
+
const pad = before && !/[\s([]$/.test(before) ? " " : "";
|
|
906
|
+
const res = (kind, title, items, extra) => ({ kind, title, items, from, to, q, ...extra });
|
|
907
|
+
const kws = (list, title) => res("kw", title, list.filter((x) => !q || x.label.toLowerCase().startsWith(q) || x.label.toLowerCase().includes(" " + q)));
|
|
908
|
+
if (st === "term" || st === "groupField") {
|
|
909
|
+
const items = [];
|
|
910
|
+
const match = (s) => !q || s.toLowerCase().includes(q);
|
|
911
|
+
for (const f of schema.fields) if (match(f.path)) items.push({ kind: "field", label: f.path, insert: f.path + " ", type: f.type, count: f.count, group: f.group, reopen: st === "term" });
|
|
912
|
+
if (st === "term") {
|
|
913
|
+
const at = items.findIndex((x) => x.group !== "Common");
|
|
914
|
+
if (match("latency") || match(LATENCY)) items.splice(at < 0 ? items.length : at, 0, { kind: "field", label: LATENCY, sub: "latency in ms", insert: LATENCY + " ", type: "latency", group: "Common", reopen: true });
|
|
915
|
+
const prev = toks[toks.length - 1];
|
|
916
|
+
if (!hasCount && depth === 0 && (!prev || prev.t === "kw" && prev.v === "AND") && match("count()")) items.push({ kind: "fn", label: "COUNT()", sub: "number of matching calls, e.g. COUNT() > 50 WITHIN 5m", insert: "COUNT() ", group: "Functions", reopen: true, pin: true });
|
|
917
|
+
if (match("not")) items.push({ kind: "kw", label: "NOT", sub: 'exclude matching calls, e.g. NOT data.request.verb == "GET"', insert: "NOT ", group: "Logic", reopen: true, pin: true });
|
|
918
|
+
if (!q) items.push({ kind: "kw", label: "(", sub: "start a group", insert: "(", group: "Logic", reopen: true, pin: true });
|
|
919
|
+
}
|
|
920
|
+
return res("fields", st === "term" ? "Fields" : "Group by", items, { total: schema.fields.length });
|
|
921
|
+
}
|
|
922
|
+
if (st === "op") {
|
|
923
|
+
if (!field || !field.type) return null;
|
|
924
|
+
const allowed = opsFor(field);
|
|
925
|
+
const ops = BUILD_OPS.flatMap(([g, list]) => list.flatMap((o) => o === "~" || o === "!~" ? [o, o + "*"] : [o]).map((o) => [o, g])).filter(([o]) => allowed.includes(o) && (!q || o.toLowerCase().startsWith(q) || OP_INFO[o].includes(q)));
|
|
926
|
+
const hasValues = VALUE_FIELDS.includes(field.path);
|
|
927
|
+
const after = src.slice(to);
|
|
928
|
+
const valued = /^\s*(?:"|\[|-?\d|true\b|false\b)/i.test(after);
|
|
929
|
+
const items = ops.map(([o, group]) => {
|
|
930
|
+
let insert = o + " ";
|
|
931
|
+
let caretAt = null;
|
|
932
|
+
let reopen = false;
|
|
933
|
+
if (o === "PRESENT" || o === "ABSENT" || o === "BETWEEN" || CMP.has(o)) reopen = true;
|
|
934
|
+
else if (o === "ANYONE" || o === "NONEOF") insert = o + " []", caretAt = insert.length - 1, reopen = hasValues || field.type === "boolean";
|
|
935
|
+
else if (o.startsWith("IP")) insert = o + ' ""', caretAt = insert.length - 1, reopen = true;
|
|
936
|
+
else if (o === "==" || o === "!=") {
|
|
937
|
+
if (hasValues || field.type === "boolean") reopen = true;
|
|
938
|
+
else if (field.type !== "number" && field.type !== "latency") insert = o + ' ""', caretAt = insert.length - 1;
|
|
939
|
+
} else if (TEXT_OPS.has(o)) insert = o + ' ""', caretAt = insert.length - 1, reopen = o.includes("~");
|
|
940
|
+
if (valued) insert = o + (/^\s/.test(after) ? "" : " "), caretAt = null, reopen = false;
|
|
941
|
+
return { kind: "op", label: o, sub: OP_INFO[o], insert, caretAt, reopen, group };
|
|
942
|
+
});
|
|
943
|
+
return res("ops", "Operators", items, { field });
|
|
944
|
+
}
|
|
945
|
+
if (st === "notc") return kws([{ kind: "op", label: "CONTAINS", sub: OP_INFO["NOT CONTAINS"], insert: 'CONTAINS ""', caretAt: 10 }], "Operators");
|
|
946
|
+
if (st === "ipop") return kws(["IN_RANGE", "NOT_IN_RANGE"].map((x) => ({ kind: "op", label: x, sub: OP_INFO["IP " + x], insert: x + ' ""', caretAt: x.length + 2, reopen: true })), "Operators");
|
|
947
|
+
const catalog = field && CATALOG[field.path];
|
|
948
|
+
const another = (e) => catalog.filter((v) => !e.vals.includes(v)).map((v) => ({ kind: "value", label: lit(v), insert: `${e.op === "!=" || e.op === "NONEOF" ? "NONEOF" : "ANYONE"} [${[...e.vals, v].map(lit).join(", ")}] `, from: e.from, to: e.to, reopen: true, group: "Add another value" }));
|
|
949
|
+
if (st === "value" && catalog && opTok && (op === "==" || op === "!=") && (part == null ? void 0 : part.t) === "str" && catalog.includes(part.v)) return res("values", "Add another value", another({ op, from: opTok.s, to, vals: [part.v] }));
|
|
950
|
+
const ranges = {
|
|
951
|
+
"data.response.statusCode": ["Informational", "Success", "Redirect", "Client error", "Server error"].map((n, i) => [`${i + 1}00 AND ${i + 1}99`, `${i + 1}XX \xB7 ${n}`]),
|
|
952
|
+
"data.request.port": [["0 AND 1023", "Well-known ports"], ["1024 AND 49151", "Registered ports"], ["49152 AND 65535", "Dynamic ports"], ["8000 AND 8999", "8xxx app ports"]]
|
|
953
|
+
};
|
|
954
|
+
const nums = (list, title) => res("ops", title, list.map(([label, sub]) => ({ kind: "op", label: String(label), sub, insert: label + " ", num: true, reopen: true })).filter((x) => !q || x.label.startsWith(q)));
|
|
955
|
+
if (st === "value" && between && (field == null ? void 0 : field.type) === "latency" && !q) return nums([["0 AND 100", "under 100 ms"], ["100 AND 500", "100 to 500 ms"], ["500 AND 1000", "500 ms to 1 s"], ["1000 AND 5000", "1 to 5 s"], ["5000 AND 10000", "5 to 10 s"]], "Example ranges \xB7 latency in ms");
|
|
956
|
+
if (st === "value" && between && ranges[field == null ? void 0 : field.path]) return nums(ranges[field.path], `Example ranges \xB7 ${field.path}`);
|
|
957
|
+
if ((st === "value" || st === "list") && (op == null ? void 0 : op.startsWith("IP"))) {
|
|
958
|
+
const lastTok = toks[toks.length - 1];
|
|
959
|
+
const lead = inList && !part && used.length && !(lastTok && lastTok.v === ",") ? ", " : "";
|
|
960
|
+
return res("ops", `Example ranges \xB7 ${field == null ? void 0 : field.path}`, [["10.0.0.0/8", "Private network, 10.x.x.x"], ["172.16.0.0/12", "Private network, 172.16 to 172.31"], ["192.168.0.0/16", "Private network, 192.168.x.x"], ["127.0.0.0/8", "Loopback"], ["169.254.0.0/16", "Link-local"], ["10.0.0.1-10.0.0.50", "First to last address"]].filter(([v]) => !used.includes(v)).map(([v, sub]) => ({ kind: "op", label: `"${v}"`, sub, insert: lead + `"${v}"` + (inList ? "" : " "), str: true, reopen: true })).filter((x) => !q || x.label.includes(q)), { list: inList });
|
|
961
|
+
}
|
|
962
|
+
if (st === "value" && (op == null ? void 0 : op.includes("~")) && field) {
|
|
963
|
+
const patterns = {
|
|
964
|
+
"data.response.statusCode": [["^5\\d\\d$", "any 5XX code"], ["^4\\d\\d$", "any 4XX code"], ["^(401|403)$", "401 or 403"], ["^2", "starts with 2"]],
|
|
965
|
+
"data.request.verb": [["^(GET|HEAD)$", "GET or HEAD"], ["^P", "POST, PUT or PATCH"], ["^(POST|PUT|PATCH|DELETE)$", "any write method"]]
|
|
966
|
+
}[field.path];
|
|
967
|
+
if (patterns) return res("ops", `Example patterns \xB7 ${field.path}`, patterns.map(([v, sub]) => ({ kind: "op", label: lit(v), sub, insert: lit(v) + " ", str: true, reopen: true })).filter((x) => !q || x.label.toLowerCase().includes(q)));
|
|
968
|
+
if ((part == null ? void 0 : part.t) === "str") {
|
|
969
|
+
const syntax = [["^", "start of text"], ["$", "end of text"], [".", "any one character"], ["\\d", "a digit"], ["\\w", "a letter, digit or _"], ["\\s", "a space"], ["[abc]", "one of a, b or c", "[]", 1], ["[^abc]", "anything except a, b or c", "[^]", 2], ["a|b", "a or b", "|"], ["(ab)", "a group", "()", 1], ["*", "zero or more of the previous"], ["+", "one or more of the previous"], ["?", "previous is optional"], ["{3}", "exactly 3 of the previous", "{}", 1], ["\\.", "a literal dot"]];
|
|
970
|
+
return res("ops", `Regex syntax \xB7 ${field.path}`, syntax.map(([label, sub, ins = label, at]) => ({ kind: "op", label, sub, insert: ins, caretAt: at, from: caret, to: caret, str: true, reopen: true })));
|
|
971
|
+
}
|
|
972
|
+
}
|
|
973
|
+
const bands = {
|
|
974
|
+
"data.response.statusCode": [[100, 199, "1XX"], [200, 299, "2XX"], [300, 399, "3XX"], [400, 499, "4XX"], [500, 599, "5XX"], ""],
|
|
975
|
+
"data.request.port": [[0, 1023, "well-known"], [1024, 49151, "registered"], [49152, 65535, "dynamic"], " ports"]
|
|
976
|
+
}[field == null ? void 0 : field.path];
|
|
977
|
+
if (st === "value" && CMP.has(op) && bands && !q) {
|
|
978
|
+
const cls = bands.slice(0, -1);
|
|
979
|
+
const suf = bands[bands.length - 1];
|
|
980
|
+
const test2 = (x, t) => op === "<" ? x < t : op === "<=" ? x <= t : op === ">" ? x > t : x >= t;
|
|
981
|
+
const label = (t) => {
|
|
982
|
+
const cs = cls.filter(([lo, hi]) => test2(lo, t) && test2(hi, t)).map(([, , n]) => n);
|
|
983
|
+
return cs.length === 1 ? `${cs[0]}${suf} only` : `${cs[0]} ${cs.length === 2 ? "and" : "to"} ${cs[cs.length - 1]}${suf}`;
|
|
984
|
+
};
|
|
985
|
+
const edges = op === "<" || op === ">=" ? cls.slice(1).map(([lo]) => lo) : cls.slice(0, -1).map(([, hi]) => hi);
|
|
986
|
+
return nums(edges.map((t) => [t, label(t)]), `Example thresholds \xB7 ${field.path}`);
|
|
987
|
+
}
|
|
988
|
+
if (st === "value" && CMP.has(op) && (field == null ? void 0 : field.type) === "latency" && !q) return nums([[100, "100 ms"], [250, "250 ms"], [500, "500 ms"], [1e3, "1 s"], [2e3, "2 s"], [5e3, "5 s"], [1e4, "10 s"]], "Example thresholds \xB7 latency in ms");
|
|
989
|
+
if (st === "value" && !between && !(op == null ? void 0 : op.startsWith("IP")) && !CMP.has(op) || st === "list") {
|
|
990
|
+
if (!field) return null;
|
|
991
|
+
const fresh = (v) => !used.includes(v);
|
|
992
|
+
let vals = [];
|
|
993
|
+
if (catalog && (op === "==" || op === "!=" || inList)) vals = catalog.filter(fresh).map((v) => ({ v }));
|
|
994
|
+
else if (field.type === "boolean" && (op === "==" || op === "!=" || inList)) vals = [true, false].filter(fresh).map((v) => ({ v }));
|
|
995
|
+
if (!vals.length) return null;
|
|
996
|
+
const lastTok = toks[toks.length - 1];
|
|
997
|
+
const comma = inList && used.length && !(lastTok && lastTok.v === ",") ? ", " : "";
|
|
998
|
+
const items = vals.filter((x) => !q || String(x.v).toLowerCase().startsWith(q.replace(/^"/, ""))).map((x) => ({ kind: "value", label: lit(x.v), insert: (part ? "" : comma) + lit(x.v) + (inList ? "" : " "), reopen: true }));
|
|
999
|
+
return res("values", inList && used.length ? `Add another \xB7 ${field.path}` : `Values \xB7 ${field.path}`, items, { list: inList });
|
|
1000
|
+
}
|
|
1001
|
+
if (st === "betAnd") return kws([{ kind: "kw", label: "AND", sub: "then the upper bound", insert: pad + "AND " }], "Between");
|
|
1002
|
+
if (st === "joiner" || st === "end") {
|
|
1003
|
+
const items = [];
|
|
1004
|
+
if (st === "joiner") {
|
|
1005
|
+
items.push({ kind: "kw", label: "AND", sub: "both must match, e.g. AND data.response.statusCode >= 500", insert: pad + "AND ", reopen: true });
|
|
1006
|
+
items.push({ kind: "kw", label: "OR", sub: 'either can match, e.g. OR data.request.verb == "PUT"', insert: pad + "OR ", reopen: true });
|
|
1007
|
+
items.push({ kind: "kw", label: "AND NOT", sub: 'exclude matching calls, e.g. AND NOT data.request.path CONTAINS "/health"', insert: pad + "AND NOT ", reopen: true });
|
|
1008
|
+
if (depth > 0) items.push({ kind: "kw", label: ")", sub: "close the group, e.g. (A OR B) AND C", insert: ") ", trim: true, reopen: true });
|
|
1009
|
+
if (!hasCount && depth === 0) items.push({ kind: "fn", label: "AND COUNT()", sub: "number of matching calls, e.g. AND COUNT() > 50 WITHIN 5m", insert: pad + "AND COUNT() ", reopen: true });
|
|
1010
|
+
}
|
|
1011
|
+
if (st === "joiner" && eq && catalog && !q) return res("kw", "Combine", [...another(eq), ...items.map((x) => ({ ...x, group: "Join conditions", pin: true }))]);
|
|
1012
|
+
return kws(items, "Combine");
|
|
1013
|
+
}
|
|
1014
|
+
if (st === "countOp") return kws([">", ">=", "<", "<=", "=="].map((o) => ({ kind: "op", label: o, sub: OP_INFO[o], insert: o + " " })), "COUNT()");
|
|
1015
|
+
if (st === "countAfter" || st === "countAfter2") {
|
|
1016
|
+
const items = [];
|
|
1017
|
+
if (st === "countAfter") items.push({ kind: "kw", label: "WITHIN", sub: "window, defaults to the time range", insert: pad + "WITHIN ", reopen: true });
|
|
1018
|
+
items.push({ kind: "kw", label: "GROUP BY", sub: "count each value on its own", insert: pad + "GROUP BY ", reopen: true });
|
|
1019
|
+
return kws(items, "COUNT()");
|
|
1020
|
+
}
|
|
1021
|
+
if (st === "dur") return kws(["1m", "5m", "10m", "15m", "1h", "1d"].map((d) => ({ kind: "value", label: d, insert: d + " ", reopen: true })), "Window");
|
|
1022
|
+
if (st === "by") return kws([{ kind: "kw", label: "BY", insert: "BY ", reopen: true }], "COUNT()");
|
|
1023
|
+
return null;
|
|
1024
|
+
}
|
|
1025
|
+
var uid = 0;
|
|
1026
|
+
var nid = () => "b" + ++uid;
|
|
1027
|
+
var RE_META = /[.*+?^${}()|[\]\\]/;
|
|
1028
|
+
var escRe = (v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
1029
|
+
var unescRe = (p) => {
|
|
1030
|
+
let out = "";
|
|
1031
|
+
for (let i = 0; i < p.length; i++) {
|
|
1032
|
+
if (p[i] === "\\" && i + 1 < p.length && RE_META.test(p[i + 1])) out += p[++i];
|
|
1033
|
+
else if (RE_META.test(p[i])) return null;
|
|
1034
|
+
else out += p[i];
|
|
1035
|
+
}
|
|
1036
|
+
return out;
|
|
1037
|
+
};
|
|
1038
|
+
var BUILD_OPS = [
|
|
1039
|
+
["Equality", ["==", "!=", "ANYONE", "NONEOF"]],
|
|
1040
|
+
["Compare", ["<", "<=", ">", ">=", "BETWEEN"]],
|
|
1041
|
+
["Text", ["CONTAINS", "NOT CONTAINS", "~", "!~"]],
|
|
1042
|
+
["Existence", ["PRESENT", "ABSENT"]],
|
|
1043
|
+
["Network", ["IP IN_RANGE", "IP NOT_IN_RANGE"]]
|
|
1044
|
+
];
|
|
1045
|
+
var arity = (op) => op === "PRESENT" || op === "ABSENT" ? "none" : op === "BETWEEN" ? "two" : op === "ANYONE" || op === "NONEOF" ? "list" : op.startsWith("IP") ? "ip" : "one";
|
|
1046
|
+
var isComplete = (c) => {
|
|
1047
|
+
if (!c.field) return false;
|
|
1048
|
+
const a = arity(c.op);
|
|
1049
|
+
const vals = c.values.filter((v) => String(v).trim());
|
|
1050
|
+
return a === "none" || (a === "two" ? vals.length === 2 : vals.length > 0);
|
|
1051
|
+
};
|
|
1052
|
+
function toTree(ast) {
|
|
1053
|
+
const root = { kind: "group", id: nid(), join: "AND", not: false, items: [], count: null };
|
|
1054
|
+
if (!ast) return root;
|
|
1055
|
+
const node = (n, not = false) => {
|
|
1056
|
+
if (n.k === "not") return node(n.x, !not);
|
|
1057
|
+
if (n.k === "group") return node(n.x, not);
|
|
1058
|
+
if (n.k === "and" || n.k === "or") return { kind: "group", id: nid(), join: n.k.toUpperCase(), not, items: n.items.map((x) => node(x)) };
|
|
1059
|
+
let op = n.op;
|
|
1060
|
+
let ci = false;
|
|
1061
|
+
if (op === "~*" || op === "!~*") ci = true, op = op.slice(0, -1);
|
|
1062
|
+
let values = n.op === "BETWEEN" ? [String(n.lo.v), String(n.hi.v)] : n.vals ? n.vals.map((v) => String(v.v)) : n.val ? [String(n.val.v)] : [];
|
|
1063
|
+
if (ci) {
|
|
1064
|
+
const plain = unescRe(values[0]);
|
|
1065
|
+
if (plain !== null) op = op === "~" ? "CONTAINS" : "NOT CONTAINS", values = [plain];
|
|
1066
|
+
}
|
|
1067
|
+
return { kind: "cond", id: nid(), field: n.field, op, values, ci, not };
|
|
1068
|
+
};
|
|
1069
|
+
const top = ast.k === "and" ? ast.items : [ast];
|
|
1070
|
+
const rest = [];
|
|
1071
|
+
for (const n of top) {
|
|
1072
|
+
if (n.k === "count") root.count = { op: n.op, n: String(n.n), within: n.within || "", by: n.by || "" };
|
|
1073
|
+
else rest.push(n);
|
|
1074
|
+
}
|
|
1075
|
+
if (ast.k === "and") root.items = rest.map((x) => node(x));
|
|
1076
|
+
else if (rest.length) {
|
|
1077
|
+
const one = node(rest[0]);
|
|
1078
|
+
if (one.kind === "group" && !one.not) root.join = one.join, root.items = one.items;
|
|
1079
|
+
else root.items = [one];
|
|
1080
|
+
}
|
|
1081
|
+
return root;
|
|
1082
|
+
}
|
|
1083
|
+
function fromTree(root, schema) {
|
|
1084
|
+
const quoted = (field) => {
|
|
1085
|
+
const f = field === "@latency" ? LAT_FIELD : schema.byPath[field];
|
|
1086
|
+
return !f || f.type !== "number" && f.type !== "boolean" && f.type !== "latency";
|
|
1087
|
+
};
|
|
1088
|
+
const cond = (c2) => {
|
|
1089
|
+
const head = c2.field === "@latency" ? LATENCY : c2.field;
|
|
1090
|
+
const vals = c2.values.map((v) => String(v).trim()).filter(Boolean);
|
|
1091
|
+
const val = (v) => quoted(c2.field) ? lit(v) : v;
|
|
1092
|
+
const a = arity(c2.op);
|
|
1093
|
+
let s;
|
|
1094
|
+
if (a === "none") s = `${head} ${c2.op}`;
|
|
1095
|
+
else if (a === "two") s = `${head} BETWEEN ${vals[0]} AND ${vals[1]}`;
|
|
1096
|
+
else if (a === "list") s = `${head} ${c2.op} [${vals.map(val).join(", ")}]`;
|
|
1097
|
+
else if (a === "ip") s = `${head} ${c2.op} ${vals.length > 1 ? `[${vals.map(lit).join(", ")}]` : lit(vals[0])}`;
|
|
1098
|
+
else if (CMP.has(c2.op)) s = `${head} ${c2.op} ${vals[0]}`;
|
|
1099
|
+
else if (c2.op === "CONTAINS" || c2.op === "NOT CONTAINS") s = c2.ci ? `${head} ${c2.op === "CONTAINS" ? "~*" : "!~*"} ${lit(escRe(vals[0]))}` : `${head} ${c2.op} ${lit(vals[0])}`;
|
|
1100
|
+
else if (c2.op === "~" || c2.op === "!~") s = `${head} ${c2.op}${c2.ci ? "*" : ""} ${lit(vals[0])}`;
|
|
1101
|
+
else s = `${head} ${c2.op} ${val(vals[0])}`;
|
|
1102
|
+
return c2.not ? `NOT ${s}` : s;
|
|
1103
|
+
};
|
|
1104
|
+
const group = (g, top) => {
|
|
1105
|
+
const parts = g.items.map((x) => [x.j || g.join, x.kind === "group" ? group(x, false) : isComplete(x) ? cond(x) : ""]).filter((x) => x[1]);
|
|
1106
|
+
if (!parts.length) return "";
|
|
1107
|
+
const body = parts.map(([j, x], i) => i ? ` ${j} ${x}` : x).join("");
|
|
1108
|
+
if (top) return body;
|
|
1109
|
+
if (parts.length === 1) return g.not ? `NOT ${body.startsWith("NOT ") ? `(${body})` : body}` : body;
|
|
1110
|
+
return `${g.not ? "NOT " : ""}(${body})`;
|
|
1111
|
+
};
|
|
1112
|
+
let t = group(root, true);
|
|
1113
|
+
const c = root.count;
|
|
1114
|
+
if (c && String(c.n).trim()) {
|
|
1115
|
+
const cnt = `COUNT() ${c.op} ${String(c.n).trim()}${c.within.trim() ? ` WITHIN ${c.within.trim()}` : ""}${c.by ? ` GROUP BY ${c.by}` : ""}`;
|
|
1116
|
+
t = t ? `${root.items.some((x, i) => i && (x.j || root.join) === "OR") && root.items.filter((x) => x.kind === "group" || isComplete(x)).length > 1 ? `(${t})` : t} AND ${cnt}` : cnt;
|
|
1117
|
+
}
|
|
1118
|
+
return t;
|
|
1119
|
+
}
|
|
1120
|
+
|
|
1121
|
+
// src/core/sql.js
|
|
1122
|
+
var OCT = "(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
|
|
1123
|
+
var V4 = `(${OCT}\\.){3}${OCT}`;
|
|
1124
|
+
var H = "[0-9a-f]{1,4}";
|
|
1125
|
+
var V6 = [
|
|
1126
|
+
`(${H}:){7}${H}`,
|
|
1127
|
+
`(${H}:){1,7}:`,
|
|
1128
|
+
`(${H}:){1,6}:${H}`,
|
|
1129
|
+
`(${H}:){1,5}(:${H}){1,2}`,
|
|
1130
|
+
`(${H}:){1,4}(:${H}){1,3}`,
|
|
1131
|
+
`(${H}:){1,3}(:${H}){1,4}`,
|
|
1132
|
+
`(${H}:){1,2}(:${H}){1,5}`,
|
|
1133
|
+
`${H}:(:${H}){1,6}`,
|
|
1134
|
+
`:((:${H}){1,7}|:)`,
|
|
1135
|
+
`(${H}:){6}${V4}`,
|
|
1136
|
+
`(${H}:){1,5}:${V4}`,
|
|
1137
|
+
`::(${H}:){0,5}${V4}`
|
|
1138
|
+
];
|
|
1139
|
+
var IP_RE = `^(${V4}|${V6.join("|")})$`;
|
|
1140
|
+
var NUM_RE = "^-?\\d+(\\.\\d+)?$";
|
|
1141
|
+
var SQL_OP = { "==": "=", "!=": "<>", "<": "<", "<=": "<=", ">": ">", ">=": ">=" };
|
|
1142
|
+
var str = (s) => {
|
|
1143
|
+
if (s.includes("\0")) throw new Error("Text values cannot contain a NUL character");
|
|
1144
|
+
return "'" + s.replace(/'/g, "''") + "'";
|
|
1145
|
+
};
|
|
1146
|
+
function toSql(ast, schema) {
|
|
1147
|
+
const segs = (field) => {
|
|
1148
|
+
var _a, _b;
|
|
1149
|
+
return ((_b = (_a = schema == null ? void 0 : schema.byPath) == null ? void 0 : _a[field]) == null ? void 0 : _b.segs) || field.split(".");
|
|
1150
|
+
};
|
|
1151
|
+
const path = (field, last2) => {
|
|
1152
|
+
const s = segs(field).map(str);
|
|
1153
|
+
return `data${s.slice(0, -1).map((k) => `->${k}`).join("")}${last2}${s[s.length - 1]}`;
|
|
1154
|
+
};
|
|
1155
|
+
const json = (field) => `NULLIF(${path(field, "->")},'null'::jsonb)`;
|
|
1156
|
+
const text = (field) => path(field, "->>");
|
|
1157
|
+
const num = (field) => {
|
|
1158
|
+
if (field === "@latency") {
|
|
1159
|
+
const a = path(LAT_A, "->");
|
|
1160
|
+
const b = path(LAT_B, "->");
|
|
1161
|
+
return `(CASE WHEN jsonb_typeof(${a}) = 'number' AND jsonb_typeof(${b}) = 'number' THEN (${a})::numeric - (${b})::numeric END)`;
|
|
1162
|
+
}
|
|
1163
|
+
const t = text(field);
|
|
1164
|
+
return `(CASE WHEN ${t} ~ '${NUM_RE}' THEN (${t})::numeric END)`;
|
|
1165
|
+
};
|
|
1166
|
+
const numLit = (x) => /^-?\d+(\.\d+)?$/.test(x.raw) ? x.raw : String(Number(x.v));
|
|
1167
|
+
const jv = (x) => `to_jsonb(${typeof x.v === "string" ? str(x.v) + "::text" : typeof x.v === "boolean" ? String(x.v) : numLit(x)})`;
|
|
1168
|
+
const ipCond = (field, vals) => {
|
|
1169
|
+
const t = text(field);
|
|
1170
|
+
const v = `(${t})::inet`;
|
|
1171
|
+
const m = `(CASE WHEN ${v}<<='::ffff:0.0.0.0/96' THEN '0.0.0.0'::inet+(${v}-'::ffff:0.0.0.0'::inet) ELSE ${v} END)`;
|
|
1172
|
+
const nets = vals.filter((x) => !x.includes("-"));
|
|
1173
|
+
const tests = vals.filter((x) => x.includes("-")).map((x) => `${m} BETWEEN ${str(x.split("-")[0])}::inet AND ${str(x.split("-")[1])}::inet`);
|
|
1174
|
+
if (nets.length) tests.unshift(`${m}<<=ANY(ARRAY[${nets.map(str).join(",")}]::inet[])`);
|
|
1175
|
+
return `(CASE WHEN ${t}~*'${IP_RE}' THEN ${tests.join(" OR ")} END)`;
|
|
1176
|
+
};
|
|
1177
|
+
const cond = (n) => {
|
|
1178
|
+
const { field, op } = n;
|
|
1179
|
+
if (op === "PRESENT") return `${text(field)} IS NOT NULL`;
|
|
1180
|
+
if (op === "ABSENT") return `${text(field)} IS NULL`;
|
|
1181
|
+
if (op === "BETWEEN") return `${num(field)} BETWEEN ${numLit(n.lo)} AND ${numLit(n.hi)}`;
|
|
1182
|
+
if (op === "ANYONE" || op === "NONEOF") return `${json(field)} ${op === "NONEOF" ? "NOT IN" : "IN"} (${n.vals.map(jv).join(", ")})`;
|
|
1183
|
+
if (op.startsWith("IP")) return `${op === "IP NOT_IN_RANGE" ? "NOT " : ""}${ipCond(field, n.vals.map((x) => x.v))}`;
|
|
1184
|
+
const v = n.val.v;
|
|
1185
|
+
if (op === "CONTAINS") return `strpos(${text(field)}, ${str(v)}) > 0`;
|
|
1186
|
+
if (op === "NOT CONTAINS") return `strpos(${text(field)}, ${str(v)}) = 0`;
|
|
1187
|
+
if (op.includes("~")) return `${text(field)} ${op} ${str(v)}`;
|
|
1188
|
+
if (op === "==" || op === "!=") return `${json(field)} ${SQL_OP[op]} ${jv(n.val)}`;
|
|
1189
|
+
return `${num(field)} ${SQL_OP[op]} ${numLit(n.val)}`;
|
|
1190
|
+
};
|
|
1191
|
+
const one = (n) => {
|
|
1192
|
+
if (n.k === "cond") return cond(n);
|
|
1193
|
+
if (n.k === "group") return `(${one(n.x)})`;
|
|
1194
|
+
if (n.k === "not") return `NOT (${one(n.x)})`;
|
|
1195
|
+
return n.items.map(one).join(` ${n.k.toUpperCase()} `);
|
|
1196
|
+
};
|
|
1197
|
+
if (!ast) return { where: "", count: null };
|
|
1198
|
+
const items = ast.k === "and" ? ast.items : [ast];
|
|
1199
|
+
const last = items[items.length - 1];
|
|
1200
|
+
const c = last.k === "count" ? last : null;
|
|
1201
|
+
const rest = c ? items.slice(0, -1) : items;
|
|
1202
|
+
const where = rest.length ? `(${one(rest.length === 1 ? rest[0] : { k: "and", items: rest })})` : "";
|
|
1203
|
+
const count = c && { op: SQL_OP[c.op], value: c.n, window: c.ms || 0, by: c.by ? segs(c.by) : null };
|
|
1204
|
+
return { where, count };
|
|
1205
|
+
}
|
|
1206
|
+
|
|
1207
|
+
// src/core/index.js
|
|
1208
|
+
var validate = (text, schema) => {
|
|
1209
|
+
var _a;
|
|
1210
|
+
return text.trim() ? ((_a = parse(text, schema).errors[0]) == null ? void 0 : _a.msg) || "" : "";
|
|
1211
|
+
};
|
|
1212
|
+
// Annotate the CommonJS export names for ESM import in node:
|
|
1213
|
+
0 && (module.exports = {
|
|
1214
|
+
LATENCY,
|
|
1215
|
+
LAT_FIELD,
|
|
1216
|
+
METHODS,
|
|
1217
|
+
OP_INFO,
|
|
1218
|
+
STATUS_CODES,
|
|
1219
|
+
TYPE_LABEL,
|
|
1220
|
+
buildSchema,
|
|
1221
|
+
context,
|
|
1222
|
+
evaluate,
|
|
1223
|
+
format,
|
|
1224
|
+
fromTree,
|
|
1225
|
+
ipToBig,
|
|
1226
|
+
opsFor,
|
|
1227
|
+
parse,
|
|
1228
|
+
parseRange,
|
|
1229
|
+
schemaFromFields,
|
|
1230
|
+
toSql,
|
|
1231
|
+
toTree,
|
|
1232
|
+
tokenize,
|
|
1233
|
+
validate
|
|
1234
|
+
});
|
|
1235
|
+
//# sourceMappingURL=core.cjs.map
|