@narrative.io/data-collaboration-sdk-ts 3.0.0 → 3.1.0

package/build/datasets/types.d.ts

@@ -21,7 +21,17 @@ export interface Dataset {
     is_narrative_managed: boolean;
     external_id?: string;
     data_plane?: DataPlane;
-    materialized_view_config?: string;
+    materialized_view_config?: {
+        nql: string;
+        refresh_schedule_config?: {
+            schedule: string;
+            schedule_zone_id: string;
+            status: "active" | "pending" | "archived";
+            updated_at: string;
+            created_at: string;
+            stats_enabled?: boolean;
+        };
+    };
     compute_pool_config?: {
         default_compute_pool_id?: string;
     };

package/build/nql/AstParser.js

@@ -32,14 +32,86 @@ export function parseExplain(n) {
             return nqlOrFail(n);
     }
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function walkNodes(value, visit) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            walkNodes(item, visit);
+        return;
+    }
+    if (isRecord(value)) {
+        visit(value);
+        for (const key of Object.keys(value))
+            walkNodes(value[key], visit);
+    }
+}
+// The server qualifies first-party (`company_data`) refs by dataset NAME when a
+// query was written by name (e.g. `company_data.my_dataset`), echoing the name in
+// the `table` field and carrying the numeric dataset id only in a table node's
+// `metadata.id`. `parseTable`/`parseColumnRef` bind a dataset node only when
+// `table` is the numeric id, so we first rewrite name-qualified first-party refs
+// back to their id: build a name/alias -> id map from the FROM tables' metadata,
+// then rewrite both the table refs and the column refs that point at them. Id-form
+// queries are unaffected, and non-`company_data` schemas (e.g. third-party access
+// rules `<slug>.<name>`) are left untouched.
+function resolveFirstPartyDatasetId(node) {
+    const table = node.table;
+    if (typeof table === "string" && /^\d+$/.test(table)) {
+        return Number.parseInt(table, 10);
+    }
+    const metadata = node.metadata;
+    if (isRecord(metadata)) {
+        const id = metadata.id;
+        if (typeof id === "number")
+            return id;
+        if (typeof id === "string" && /^\d+$/.test(id)) {
+            return Number.parseInt(id, 10);
+        }
+    }
+    return undefined;
+}
+function normalizeFirstPartyRefs(n) {
+    const clone = JSON.parse(JSON.stringify(n));
+    const idByRef = new Map();
+    // Pass 1: first-party FROM tables — record name/alias -> id, rewrite to id.
+    walkNodes(clone, (node) => {
+        if (node.type !== "table" || node.schema !== "company_data")
+            return;
+        const id = resolveFirstPartyDatasetId(node);
+        if (id === undefined)
+            return;
+        if (typeof node.table === "string")
+            idByRef.set(node.table, id);
+        if (typeof node.as === "string")
+            idByRef.set(node.as, id);
+        idByRef.set(String(id), id);
+        node.table = String(id);
+    });
+    if (idByRef.size === 0)
+        return clone;
+    // Pass 2: first-party column refs still qualified by name -> rewrite to id.
+    walkNodes(clone, (node) => {
+        if (node.type !== "column" || node.schema !== "company_data")
+            return;
+        if (typeof node.table !== "string" || /^\d+$/.test(node.table))
+            return;
+        const id = idByRef.get(node.table);
+        if (id !== undefined)
+            node.table = String(id);
+    });
+    return clone;
+}
 export function parseSelect(n) {
+    const normalized = normalizeFirstPartyRefs(n);
     const select = {
         type: "select",
-        budget: n.budget,
-        columns: n.columns.map((col) => parseOutput(col)),
-        deduplication: parseDeduplication(n),
-        from: n.from !== null ? parseFrom(n.from) : [],
-        where: n.where !== null ? parseWhere(n.where) : null,
+        budget: normalized.budget,
+        columns: normalized.columns.map((col) => parseOutput(col)),
+        deduplication: parseDeduplication(normalized),
+        from: normalized.from !== null ? parseFrom(normalized.from) : [],
+        where: normalized.where !== null ? parseWhere(normalized.where) : null,
     };
     return select;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narrative.io/data-collaboration-sdk-ts",
-	"version": "3.0.0",
+	"version": "3.1.0",
 	"main": "build/index.js",
 	"repository": "github:narrative-io/data-collaboration-sdk-ts",
 	"source": "src/index.ts",
@@ -41,7 +41,7 @@
 	},
 	"dependencies": {
 		"zod": "4.4.3",
-		"bignumber.js": "11.1.2"
+		"bignumber.js": "11.1.3"
 	},
 	"overrides": {
 		"semver@<7.5.2": "7.5.2"