@narrative.io/data-collaboration-sdk-ts 3.7.0 → 3.8.0

package/build/compute-pools/types.d.ts

@@ -45,11 +45,17 @@ export interface ParticipantsAll {
 export interface ParticipantsNone {
     type: "none";
 }
+/** Only these companies. `company_ids` must be non-empty. */
 export interface ParticipantsInclusion {
     type: "inclusion";
     company_ids: number[];
 }
-export type Participants = ParticipantsAll | ParticipantsNone | ParticipantsInclusion;
+/** Every company except these. `company_ids` must be non-empty. */
+export interface ParticipantsExclusion {
+    type: "exclusion";
+    company_ids: number[];
+}
+export type Participants = ParticipantsAll | ParticipantsNone | ParticipantsInclusion | ParticipantsExclusion;
 export interface ComputePoolCollaborators {
     use: Participants;
 }

package/build/nql/AstParser.js

@@ -189,17 +189,40 @@ function parseFunction(n) {
     if (n.type !== "function") {
         return nqlOrFail(n);
     }
+    // CAST is the one special-syntax call the server structures completely:
+    // its args arrive as [value, type_spec], and the only non-standard piece
+    // is the `AS` argument separator in the text. Parse it into a Func whose
+    // second argument is a string literal carrying the type keyword —
+    // compileFunction owns the matching `CAST(value AS TYPE)` serialization,
+    // so the pair round-trips without falling back to Raw.
+    if (n.name.toUpperCase() === "CAST" &&
+        n.args.length === 2 &&
+        n.args[1].type === "type_spec") {
+        return {
+            type: "function",
+            as: n.as,
+            name: n.name,
+            args: [
+                parseExpression(n.args[0]),
+                {
+                    type: "lit",
+                    value_type: { type: "string" },
+                    value: n.args[1].nql,
+                },
+            ],
+        };
+    }
     // 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. 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.
+    // EXTRACT(unit FROM x), 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. 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);

package/build/nql/NqlBuilder.js

@@ -219,7 +219,10 @@ export function compileOutput(n, dsMap) {
         case "raw_ref":
             return compileRawRef(n.nql, n.as);
         case "nql":
-            return raw(n);
+            // like functions, aliased raw outputs compile bare — the server's
+            // parser rejects `(expr AS "alias")` (an alias isn't valid inside
+            // a parenthesized expression)
+            return aliased(n.nql, n.as, false);
         case "placeholder":
             return compilePlaceholder(n);
     }
@@ -360,6 +363,16 @@ function compileRawRef(nql, as) {
     return aliased(nql, as);
 }
 function compileFunction(n, dsMap, parens) {
+    // CAST uses `AS` as its argument separator, never a comma — the second
+    // argument is the type keyword AstParser lifted out of the server's
+    // type_spec node.
+    if (n.name.toUpperCase() === "CAST" &&
+        n.args.length === 2 &&
+        n.args[1].type === "lit" &&
+        typeof n.args[1].value === "string") {
+        const value = compileExpression(n.args[0], dsMap);
+        return aliased(`${n.name}(${value} AS ${n.args[1].value})`, n.as, parens);
+    }
     const args = n.args.map((arg) => compileExpression(arg, dsMap)).join(", ");
     return aliased(`${n.name}(${args})`, n.as, parens);
 }

package/package.json

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