@narrative.io/data-collaboration-sdk-ts 0.0.106 → 0.0.108

package/build/nql/NQLParser.js

@@ -1,4 +1,4 @@
-import { NqlBooleanExpressionObj, NqlBudgetObj, NqlFieldObj, NqlFilterExpressionObj, NqlObj, NqlPreSelectExpressionObj, NqlTableObject, NqlWhereObj, NqlFilterUnaryExpressionObj } from './types';
+import { NqlBooleanExpressionObj, NqlBudgetObj, NqlFieldObj, NqlFilterExpressionObj, NqlObj, NqlPreSelectExpressionObj, NqlTableObject, NqlWhereObj, NqlFilterUnaryExpressionObj, } from "./types";
 /**
  * Retrieves the WHERE clause from the given NQL (Nested Query Language) string and returns a parsed NqlWhereClause object.
  *
@@ -8,17 +8,17 @@ import { NqlBooleanExpressionObj, NqlBudgetObj, NqlFieldObj, NqlFilterExpression
  */
 export function getWhere(nql) {
     const regex = /\bWHERE\b(.*?)\bLIMIT\b/i;
-    const match = nql.trim().replace(/\n/g, ' ').match(regex);
-    if (match != null && match[1] !== '') {
+    const match = nql.trim().replace(/\n/g, " ").match(regex);
+    if (match != null && match[1] !== "") {
         const booleanExpressions = getBooleanExpressionsFromWhere(match[1]);
         const filterExpressions = getFilterExpressionsFromWhere(match[1]);
         return NqlWhereObj.parse({
             booleanExpressions,
-            filterExpressions
+            filterExpressions,
         });
     }
     else {
-        throw new Error('No WHERE clause found');
+        throw new Error("No WHERE clause found");
     }
 }
 /**
@@ -30,19 +30,19 @@ export function getWhere(nql) {
  */
 export function getFrom(nql) {
     const regex = /\bFROM\b(.*?)\bWHERE\b/i;
-    const match = nql.trim().replace(/\n/g, ' ').match(regex);
-    if (match != null && match[1] !== '') {
-        const tables = match[1].split(',').map((t) => {
-            const [database, table] = t.trim().split('.');
+    const match = nql.trim().replace(/\n/g, " ").match(regex);
+    if (match != null && match[1] !== "") {
+        const tables = match[1].split(",").map((t) => {
+            const [database, table] = t.trim().split(".");
             return NqlTableObject.parse({
                 database,
-                table
+                table,
             });
         });
         return tables;
     }
     else {
-        throw new Error('No FROM clause found');
+        throw new Error("No FROM clause found");
     }
 }
 /**
@@ -52,7 +52,7 @@ export function getFrom(nql) {
  * @returns {NqlBooleanExpression[]} - An array of parsed NqlBooleanExpression objects representing the boolean expressions.
  */
 function getBooleanExpressionsFromWhere(where) {
-    const booleanRegex = /\s(OR|AND)\s/ig;
+    const booleanRegex = /\s(OR|AND)\s/gi;
     const matches = [];
     let boolMatch;
     while ((boolMatch = booleanRegex.exec(where)) !== null) {
@@ -68,12 +68,12 @@ function getBooleanExpressionsFromWhere(where) {
  */
 function getFilterExpressionsFromWhere(where) {
     let matches = [];
-    const hasBoolean = /\s(?:OR|AND)\s/ig.test(where);
+    const hasBoolean = /\s(?:OR|AND)\s/gi.test(where);
     if (!hasBoolean) {
         matches.push(getFilterExpressionFromString(where));
     }
     else {
-        const expressions = where.split(/\s(?:OR|AND)\s/ig).map((t) => t.trim());
+        const expressions = where.split(/\s(?:OR|AND)\s/gi).map((t) => t.trim());
         matches = matches.concat(expressions.map((e) => getFilterExpressionFromString(e)));
     }
     return NqlFilterExpressionObj.array().parse(matches);
@@ -85,15 +85,17 @@ function getFilterExpressionsFromWhere(where) {
  * @returns {NqlField | string} - The parsed NqlField object or the original field string if parsing fails.
  */
 function parseFieldFromString(fieldStr) {
-    const [database, table, ...f] = fieldStr.trim().split('.');
+    const [database, table, ...f] = fieldStr.trim().split(".");
     const field = {
         table: {
             database,
-            table
+            table,
         },
-        field: f.map((field) => {
-            return field.replace('"value"', 'value').replace('"type"', 'type');
-        }).join('.')
+        field: f
+            .map((field) => {
+            return field.replace('"value"', "value").replace('"type"', "type");
+        })
+            .join("."),
     };
     try {
         return NqlFieldObj.parse(field);
@@ -114,10 +116,10 @@ function parseString(value) {
         return parsedNumber;
     }
     // Attempt to parse as a boolean
-    if (value.toLowerCase() === 'true') {
+    if (value.toLowerCase() === "true") {
         return true;
     }
-    if (value.toLowerCase() === 'false') {
+    if (value.toLowerCase() === "false") {
         return false;
     }
     // Return as string if it is neither a number nor boolean
@@ -130,7 +132,7 @@ function parseString(value) {
  * @returns {NqlField | string} - The parsed NqlField object or the original field string if parsing fails.
  */
 export function getFilterExpressionFromString(str) {
-    const comparison = ['<=', '>=', '!=', '=', '>', '<'];
+    const comparison = ["<=", ">=", "!=", "=", ">", "<"];
     const containsComparison = comparison.find((character) => str.includes(character));
     if (containsComparison !== undefined) {
         const result = str.split(containsComparison);
@@ -140,10 +142,16 @@ export function getFilterExpressionFromString(str) {
         return NqlFilterExpressionObj.parse({
             left,
             operator,
-            right
+            right,
         });
     }
-    const strComparison = [' NOT IN ', ' IN ', ' NOT LIKE ', ' LIKE ', ' BETWEEN '];
+    const strComparison = [
+        " NOT IN ",
+        " IN ",
+        " NOT LIKE ",
+        " LIKE ",
+        " BETWEEN ",
+    ];
     const containsStrComparison = strComparison.find((character) => str.toLowerCase().includes(character.toLowerCase()));
     if (containsStrComparison !== undefined) {
         const result = str.toLowerCase().split(containsStrComparison.toLowerCase());
@@ -153,10 +161,10 @@ export function getFilterExpressionFromString(str) {
         return NqlFilterExpressionObj.parse({
             left,
             operator,
-            right
+            right,
         });
     }
-    const unaryOperators = [' IS NULL', ' IS NOT NULL'];
+    const unaryOperators = [" IS NULL", " IS NOT NULL"];
     const containsUnaryOperator = unaryOperators.find((character) => str.toLowerCase().includes(character.toLowerCase()));
     if (containsUnaryOperator !== undefined) {
         const result = str.toLowerCase().split(containsUnaryOperator.toLowerCase());
@@ -164,7 +172,7 @@ export function getFilterExpressionFromString(str) {
         const operator = containsUnaryOperator.trim().toUpperCase();
         return NqlFilterUnaryExpressionObj.parse({
             field,
-            operator
+            operator,
         });
     }
     throw new Error(`Invalid filter expression: ${str}`);
@@ -184,8 +192,10 @@ export function getPreSelect(nql) {
      * The match is case-insensitive.
      */
     const regex = /^(.*?)(?=SELECT)/i;
-    const match = nql.trim().replace(/\n/g, ' ').match(regex);
-    return match != null && match[1] !== '' ? NqlPreSelectExpressionObj.parse(match[1].toUpperCase().trim()) : undefined;
+    const match = nql.trim().replace(/\n/g, " ").match(regex);
+    return match != null && match[1] !== ""
+        ? NqlPreSelectExpressionObj.parse(match[1].toUpperCase().trim())
+        : undefined;
 }
 /**
  * Builds a pre-select expression for an NQL (Natural Query Language) query based on the provided pre-select expression.
@@ -196,7 +206,7 @@ export function getPreSelect(nql) {
  */
 export function buildPreSelect(preSelect) {
     NqlPreSelectExpressionObj.parse(preSelect);
-    return preSelect ?? '';
+    return preSelect ?? "";
 }
 /**
  * Extracts and parses the selected fields from the given NQL (Natural Query Language) string.
@@ -208,21 +218,21 @@ export function buildPreSelect(preSelect) {
  */
 export function getSelect(nql) {
     const regex = /SELECT\b(.*?)\bFROM/i;
-    const match = nql.trim().replace(/\n/g, ' ').match(regex);
-    if (match != null && match[1] !== '') {
-        const fields = match[1].trim().split(',');
+    const match = nql.trim().replace(/\n/g, " ").match(regex);
+    if (match != null && match[1] !== "") {
+        const fields = match[1].trim().split(",");
         return fields.map((f) => {
-            const trimmedFields = f.trim().split('.');
+            const trimmedFields = f.trim().split(".");
             if (trimmedFields.length < 3) {
-                throw new Error('Invalid field');
+                throw new Error("Invalid field");
             }
             const [database, table, ...field] = trimmedFields;
             const t = NqlTableObject.parse({ database, table });
-            return NqlFieldObj.parse({ table: t, field: field.join('.') });
+            return NqlFieldObj.parse({ table: t, field: field.join(".") });
         });
     }
     else {
-        throw new Error('No selected fields found');
+        throw new Error("No selected fields found");
     }
 }
 /**
@@ -234,7 +244,10 @@ export function getSelect(nql) {
  */
 export function buildSelect(fields) {
     fields.forEach((f) => NqlFieldObj.parse(f));
-    return 'SELECT ' + fields.map((f) => `${f.table.database}.${f.table.table}.${f.field}`).join(', ');
+    return ("SELECT " +
+        fields
+            .map((f) => `${f.table.database}.${f.table.table}.${f.field}`)
+            .join(", "));
 }
 /**
  * Parses a string in NQL format and returns an NqlBudgetType object.
@@ -246,18 +259,18 @@ export function buildSelect(fields) {
  */
 export function getLimit(nql) {
     const regex = /LIMIT\s+(\d+)\s+(\w+)\s+PER\s+(\w+)$/i;
-    const match = nql.trim().replace(/\n/g, ' ').match(regex);
+    const match = nql.trim().replace(/\n/g, " ").match(regex);
     if (match != null) {
         const [, value, currency, period] = match;
         const result = {
             value: parseInt(value, 10),
             currency: currency.toUpperCase(),
-            period: period.toUpperCase()
+            period: period.toUpperCase(),
         };
         return NqlBudgetObj.parse(result);
     }
     else {
-        throw new Error('Invalid budget');
+        throw new Error("Invalid budget");
     }
 }
 /**
@@ -277,12 +290,12 @@ export function buildNql(nql, strict = true) {
         NqlObj.parse(nql);
     }
     // Build the NQL string from each of the clasues
-    let explain = '';
-    if ('explain' in nql && strict) {
+    let explain = "";
+    if ("explain" in nql && strict) {
         explain = buildPreSelect(nql.explain);
     }
-    let limit = '';
-    if ('limit' in nql && strict) {
+    let limit = "";
+    if ("limit" in nql && strict) {
         limit = buildLimit(nql.limit);
     }
     const select = buildSelect(nql.select);
@@ -290,7 +303,7 @@ export function buildNql(nql, strict = true) {
     const where = buildWhere(nql.where);
     const clauses = [explain, select, from, where, limit];
     // Remove any empty clausess and join what's left together
-    return clauses.filter((c) => c !== '').join(' ');
+    return clauses.filter((c) => c !== "").join(" ");
 }
 export function buildFrom(from) {
     NqlTableObject.parse(from);
@@ -298,9 +311,9 @@ export function buildFrom(from) {
 }
 export function buildWhere(where) {
     NqlWhereObj.parse(where);
-    let str = where.filterExpressions.length > 0 ? 'WHERE' : '';
+    let str = where.filterExpressions.length > 0 ? "WHERE" : "";
     where.filterExpressions.forEach((f, i) => {
-        if ('field' in f) {
+        if ("field" in f) {
             str += ` ${buildField(f.field)} ${f.operator}`;
         }
         else {
@@ -322,21 +335,21 @@ export function buildField(field) {
     }
 }
 export function getNqlObject(nql, type) {
-    const cleanedNql = nql.trim().replace(/\n/g, ' ').replace(/\s+/g, ' ');
+    const cleanedNql = nql.trim().replace(/\n/g, " ").replace(/\s+/g, " ");
     const explain = getPreSelect(cleanedNql);
     const limit = getLimit(cleanedNql);
     const where = getWhere(cleanedNql);
     const from = getFrom(cleanedNql);
     const select = getSelect(cleanedNql);
     const parsed = NqlObj.parse({ where, from, explain, select, limit });
-    if (type === undefined || type === 'full') {
+    if (type === undefined || type === "full") {
         return parsed;
     }
     else {
         return {
             where: createSemanticWhere(parsed.where),
             from: parsed.from,
-            select: parsed.select
+            select: parsed.select,
         };
     }
 }
@@ -345,12 +358,16 @@ export function createSemanticWhere(expressionContainer) {
     let index = 0;
     while (index < copy.filterExpressions.length) {
         const filterExp = copy.filterExpressions[index];
-        const fieldObject = 'field' in filterExp ? filterExp.field : null;
-        const leftObject = 'left' in filterExp && typeof filterExp.left === 'object' ? filterExp.left : null;
-        const rightObject = 'right' in filterExp && typeof filterExp.right === 'object' ? filterExp.right : null;
-        if ((fieldObject?.field?.startsWith('_') ?? false) ||
-            (leftObject?.field?.startsWith('_') ?? false) ||
-            (rightObject?.field?.startsWith('_') ?? false)) {
+        const fieldObject = "field" in filterExp ? filterExp.field : null;
+        const leftObject = "left" in filterExp && typeof filterExp.left === "object"
+            ? filterExp.left
+            : null;
+        const rightObject = "right" in filterExp && typeof filterExp.right === "object"
+            ? filterExp.right
+            : null;
+        if ((fieldObject?.field?.startsWith("_") ?? false) ||
+            (leftObject?.field?.startsWith("_") ?? false) ||
+            (rightObject?.field?.startsWith("_") ?? false)) {
             copy.filterExpressions.splice(index, 1);
             if (copy.booleanExpressions.length > index) {
                 copy.booleanExpressions.splice(index, 1);