@narrative.io/data-collaboration-sdk-ts 0.0.57 → 0.0.59

package/build/authentication/types.d.ts

@@ -24,5 +24,5 @@ export interface LoggedInUser {
 }
 export interface StytchToken {
     token: string;
-    token_type: 'magiclinkstoken' | 'oauth';
+    token_type: 'magiclinks' | 'oauth';
 }

package/build/nql/NQLParser.d.ts

@@ -1,4 +1,4 @@
-import { type Nql, type NqlBudget, type NqlField, type NqlPreSelectExpression, type NqlTable, type NqlWhere } from './types';
+import { type Nql, type NqlBudget, type NqlField, type NqlFilterExpression, type NqlPreSelectExpression, type NqlTable, type NqlWhere } from './types';
 /**
  * Retrieves the WHERE clause from the given NQL (Nested Query Language) string and returns a parsed NqlWhereClause object.
  *
@@ -15,6 +15,13 @@ export declare function getWhere(nql: string): NqlWhere;
  * @throws {Error} - Throws an error if no FROM clause is found in the NQL string.
  */
 export declare function getFrom(nql: string): NqlTable[];
+/**
+ * Parses a field string into an NqlField object or a plain string if parsing fails.
+ *
+ * @param {string} fieldStr - The field string to parse.
+ * @returns {NqlField | string} - The parsed NqlField object or the original field string if parsing fails.
+ */
+export declare function getFilterExpressionFromString(str: string): NqlFilterExpression;
 /**
  * Parses the pre-select expression from the given NQL (Natural Query Language) string.
  *
@@ -66,22 +73,15 @@ export declare function getLimit(nql: string): NqlBudget;
  * @throws {Error} - If the provided budget object is invalid.
  */
 export declare function buildLimit(budget: NqlBudget): string;
-/**
- * Builds an NQL (Nested Query Language) string based on the provided Nql object.
- *
- * @param {Nql} nql - The Nql object containing the clauses for building the NQL string.
- * @returns {string} - The constructed NQL string.
- * @throws {Error} - Throws an error if the provided Nql object is invalid.
- */
-export declare function buildNql(nql: Nql): string;
+type Strict = true;
+type NotStrict = false;
+export declare function buildNql(nql: Nql, strict?: Strict): string;
+export declare function buildNql(nql: Nql | SemanticNql, strict?: NotStrict): string;
 export declare function buildFrom(from: NqlTable): string;
 export declare function buildWhere(where: NqlWhere): string;
 export declare function buildField(field: NqlField | string | number | boolean): string;
-/**
- * Parses the given NQL string and returns an Nql object.
- *
- * @param {string} nql - The NQL string to parse.
- * @returns {Nql} - The parsed Nql object.
- * @throws {Error} - If the provided NQL string is invalid.
- */
-export declare function getNqlObject(nql: string): Nql;
+type ParseType = 'full' | 'semantic';
+type SemanticNql = Omit<Nql, 'explain' | 'limit'>;
+export declare function getNqlObject<T extends ParseType = 'full'>(nql: string, type?: T): T extends 'full' ? Nql : SemanticNql;
+export declare function createSemanticWhere(expressionContainer: NqlWhere): NqlWhere;
+export {};

package/build/nql/NQLParser.js

@@ -1,4 +1,4 @@
-import { NqlBooleanExpressionObj, NqlBudgetObj, NqlFieldObj, NqlFilterExpressionObj, NqlObj, NqlPreSelectExpressionObj, NqlTableObject, NqlWhereObj } 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.
  *
@@ -127,7 +127,7 @@ function parseString(value) {
  * @param {string} fieldStr - The field string to parse.
  * @returns {NqlField | string} - The parsed NqlField object or the original field string if parsing fails.
  */
-function getFilterExpressionFromString(str) {
+export function getFilterExpressionFromString(str) {
     const comparison = ['<=', '>=', '!=', '=', '>', '<'];
     const containsComparison = comparison.find((character) => str.includes(character));
     if (containsComparison !== undefined) {
@@ -141,10 +141,10 @@ function getFilterExpressionFromString(str) {
             right
         });
     }
-    const strComparison = [' IN ', ' NOT IN ', ' LIKE ', ' NOT LIKE '];
+    const strComparison = [' NOT IN ', ' IN ', ' NOT LIKE ', ' LIKE '];
     const containsStrComparison = strComparison.find((character) => str.toLowerCase().includes(character.toLowerCase()));
     if (containsStrComparison !== undefined) {
-        const result = str.split(containsStrComparison);
+        const result = str.toLowerCase().split(containsStrComparison.toLowerCase());
         const left = parseFieldFromString(result[0]);
         const operator = containsStrComparison.trim().toUpperCase();
         const right = parseFieldFromString(result[1]);
@@ -157,10 +157,10 @@ function getFilterExpressionFromString(str) {
     const unaryOperators = [' IS NULL', ' IS NOT NULL'];
     const containsUnaryOperator = unaryOperators.find((character) => str.toLowerCase().includes(character.toLowerCase()));
     if (containsUnaryOperator !== undefined) {
-        const result = str.split(containsUnaryOperator);
+        const result = str.toLowerCase().split(containsUnaryOperator.toLowerCase());
         const field = parseFieldFromString(result[0]);
         const operator = containsUnaryOperator.trim().toUpperCase();
-        return NqlFilterExpressionObj.parse({
+        return NqlFilterUnaryExpressionObj.parse({
             field,
             operator
         });
@@ -269,19 +269,20 @@ export function buildLimit(budget) {
     NqlBudgetObj.parse(budget);
     return `LIMIT ${budget.value} ${budget.currency} PER ${budget.period}`;
 }
-/**
- * Builds an NQL (Nested Query Language) string based on the provided Nql object.
- *
- * @param {Nql} nql - The Nql object containing the clauses for building the NQL string.
- * @returns {string} - The constructed NQL string.
- * @throws {Error} - Throws an error if the provided Nql object is invalid.
- */
-export function buildNql(nql) {
+export function buildNql(nql, strict = true) {
     // Validate our object
-    NqlObj.parse(nql);
+    if (strict) {
+        NqlObj.parse(nql);
+    }
     // Build the NQL string from each of the clasues
-    const explain = buildPreSelect(nql.explain);
-    const limit = buildLimit(nql.limit);
+    let explain = '';
+    if ('explain' in nql && strict) {
+        explain = buildPreSelect(nql.explain);
+    }
+    let limit = '';
+    if ('limit' in nql && strict) {
+        limit = buildLimit(nql.limit);
+    }
     const select = buildSelect(nql.select);
     const from = buildFrom(nql.from[0]);
     const where = buildWhere(nql.where);
@@ -318,18 +319,44 @@ export function buildField(field) {
         return String(field);
     }
 }
-/**
- * Parses the given NQL string and returns an Nql object.
- *
- * @param {string} nql - The NQL string to parse.
- * @returns {Nql} - The parsed Nql object.
- * @throws {Error} - If the provided NQL string is invalid.
- */
-export function getNqlObject(nql) {
+export function getNqlObject(nql, type) {
     const explain = getPreSelect(nql);
     const limit = getLimit(nql);
     const where = getWhere(nql);
     const from = getFrom(nql);
     const select = getSelect(nql);
-    return NqlObj.parse({ where, from, explain, select, limit });
+    const parsed = NqlObj.parse({ where, from, explain, select, limit });
+    if (type === undefined || type === 'full') {
+        return parsed;
+    }
+    else {
+        return {
+            where: createSemanticWhere(parsed.where),
+            from: parsed.from,
+            select: parsed.select
+        };
+    }
+}
+export function createSemanticWhere(expressionContainer) {
+    const copy = JSON.parse(JSON.stringify(expressionContainer)); // deep copy
+    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)) {
+            copy.filterExpressions.splice(index, 1);
+            // Make sure the booleanExpressions array has an element to remove
+            if (index > 0 && copy.booleanExpressions.length >= index) {
+                copy.booleanExpressions.splice(index - 1, 1);
+            }
+        }
+        else {
+            index++; // Only increment if no element was removed
+        }
+    }
+    return copy;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@narrative.io/data-collaboration-sdk-ts",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "main": "build/index.js",
   "repository": "github:narrative-io/data-collaboration-sdk-ts",
   "source": "src/index.ts",