@narrative.io/data-collaboration-sdk-ts 3.5.0 → 3.5.1

package/build/nql/AstParser.js

@@ -182,21 +182,35 @@ export function parseOutput(n) {
     const parse = oneOf(parseColumnRef, parseLit, parseFunction, parsePlaceholder);
     return parse(n);
 }
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function parseFunction(n) {
     if (n.type !== "function") {
         return nqlOrFail(n);
     }
-    // Only structure functions whose original text is exactly the standard
-    // call syntax `NAME(arg, arg, ...)`. Functions with special syntax —
+    // Only structure functions whose original text is the standard call
+    // syntax `NAME(arg, arg, ...)`, optionally followed by an alias — the
+    // server serializes `expr AS alias` as the inner node with the alias
+    // wrapper's `as`/`nql` merged on top, so an aliased function's `nql`
+    // span reads `NAME(args) AS alias`. Functions with special syntax —
     // EXTRACT(unit FROM x), CAST(x AS type), TRIM(BOTH ' ' FROM x) — cannot
     // be regenerated from name + args and must stay Raw passthroughs, or
-    // compiling would emit comma syntax and corrupt the query.
+    // compiling would emit comma syntax and corrupt the query. The match
+    // tolerates whitespace differences (and a missing/implicit AS keyword)
+    // because compiling name + args back to `NAME(arg, arg, ...) AS "alias"`
+    // only ever normalizes those, never changes semantics.
     const argTexts = n.args.map((a) => "nql" in a ? a.nql : undefined);
     if (argTexts.some((t) => t === undefined)) {
         return nqlOrFail(n);
     }
-    const reconstructed = `${n.name}(${argTexts.join(", ")})`;
-    if (reconstructed !== n.nql) {
+    const aliasSuffix = n.as !== undefined
+        ? `(?:\\s+(?:AS\\s+)?(?:"${escapeRegExp(n.as)}"|${escapeRegExp(n.as)}))?`
+        : "";
+    const standardCall = new RegExp(`^${escapeRegExp(n.name)}\\s*\\(\\s*${argTexts
+        .map(escapeRegExp)
+        .join("\\s*,\\s*")}\\s*\\)${aliasSuffix}$`, "i");
+    if (!standardCall.test(n.nql)) {
         return nqlOrFail(n);
     }
     const func = {
@@ -611,10 +625,18 @@ function oneOf(...fs) {
 function nqlOrFail(n) {
     if ("nql" in n) {
         const as = "as" in n ? n.as : undefined;
+        // The server serializes `expr AS alias` by merging the alias wrapper's
+        // `as`/`nql` onto the inner node, so an aliased node's span carries a
+        // trailing ` AS alias`. Strip it: a Raw node's `nql` holds the bare
+        // expression and `as` holds the alias — otherwise compiling the node
+        // re-appends the alias and emits a corrupt double alias.
+        const nqlText = as !== undefined
+            ? n.nql.replace(new RegExp(`\\s+(?:AS\\s+)?(?:"${escapeRegExp(as)}"|${escapeRegExp(as)})\\s*$`, "i"), "")
+            : n.nql;
         const nql = {
             type: "nql",
             as,
-            nql: n.nql,
+            nql: nqlText,
         };
         return nql;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narrative.io/data-collaboration-sdk-ts",
-	"version": "3.5.0",
+	"version": "3.5.1",
 	"main": "build/index.js",
 	"repository": "github:narrative-io/data-collaboration-sdk-ts",
 	"source": "src/index.ts",
@@ -43,7 +43,7 @@
 	},
 	"dependencies": {
 		"zod": "4.4.3",
-		"bignumber.js": "11.1.4"
+		"bignumber.js": "11.1.5"
 	},
 	"overrides": {
 		"semver@<7.5.2": "7.5.2"