@narrative.io/data-collaboration-sdk-ts 2.66.0 → 2.68.0

package/build/collaboration-policy/core/policy-traverser.js

@@ -58,11 +58,10 @@ function traverseSatisfiedStructure(node, attributeByName, visitor) {
         return;
     }
     if ("anyOf" in node && Array.isArray(node.anyOf)) {
-        // For anyOf, only traverse the FIRST satisfied branch
+        // For anyOf, traverse ALL satisfied branches
         for (const child of node.anyOf) {
             if (isBranchSatisfied(child, attributeByName)) {
                 traverseSatisfiedStructure(child, attributeByName, visitor);
-                return; // Only process the first satisfied branch
             }
         }
         return;

package/build/collaboration-policy/core/sql-builder.js

@@ -1,4 +1,6 @@
+import { normalizePathValue } from "../utils/path-helpers";
 import { buildSelectAlias, resolveAttributeExpression, } from "../utils/sql-helpers";
+import { filterToSql } from "./filter-builder";
 import { traversePolicy } from "./policy-traverser";
 import { validatePolicyAgainstDataset } from "./policy-validator";
 function buildAttributeIndexes(attributes) {
@@ -41,14 +43,134 @@ function getSmallestRefreshSchedule(schedules) {
     }
     return smallestSchedule;
 }
+/**
+ * Builds structured WHERE clauses for a single branch node
+ */
+function buildBranchWhere(node, attributeByName, datasetName) {
+    if (!node || typeof node !== "object") {
+        return null;
+    }
+    // Handle field nodes (leaf nodes with attributes)
+    if ("field" in node) {
+        const extendedNode = node;
+        const field = extendedNode.field;
+        const attributeName = field.attribute_name;
+        const attribute = attributeByName.get(attributeName);
+        if (!attribute) {
+            return null;
+        }
+        const clauses = [];
+        // Add IS NOT NULL filters for additional_required_properties
+        if (field.additional_required_properties) {
+            for (const path of field.additional_required_properties) {
+                const pathStr = normalizePathValue(path);
+                const expression = `company_data."${datasetName}"."_rosetta_stone"."${attribute.name}"."${pathStr}"`;
+                clauses.push(`(${expression} IS NOT NULL)`);
+            }
+        }
+        // Add filters
+        if (extendedNode.filters) {
+            for (const filter of extendedNode.filters) {
+                const sql = filterToSql(filter, attributeByName, datasetName);
+                clauses.push(sql);
+            }
+        }
+        // If only one clause, return as string
+        if (clauses.length === 0) {
+            return null;
+        }
+        if (clauses.length === 1) {
+            return clauses[0];
+        }
+        // Multiple clauses for a single field - AND them together
+        return {
+            operation: "AND",
+            fragments: clauses,
+        };
+    }
+    // Handle anyOf nodes
+    if ("anyOf" in node && Array.isArray(node.anyOf)) {
+        const satisfiedBranches = [];
+        for (const child of node.anyOf) {
+            if (isBranchSatisfied(child, attributeByName)) {
+                const branchWhere = buildBranchWhere(child, attributeByName, datasetName);
+                if (branchWhere) {
+                    satisfiedBranches.push(branchWhere);
+                }
+            }
+        }
+        if (satisfiedBranches.length === 0) {
+            return null;
+        }
+        if (satisfiedBranches.length === 1) {
+            return satisfiedBranches[0];
+        }
+        // Multiple satisfied anyOf branches - OR them together
+        return {
+            operation: "OR",
+            fragments: satisfiedBranches,
+        };
+    }
+    // Handle allOf nodes
+    if ("allOf" in node && Array.isArray(node.allOf)) {
+        const allBranches = [];
+        for (const child of node.allOf) {
+            const branchWhere = buildBranchWhere(child, attributeByName, datasetName);
+            if (branchWhere) {
+                allBranches.push(branchWhere);
+            }
+        }
+        if (allBranches.length === 0) {
+            return null;
+        }
+        if (allBranches.length === 1) {
+            return allBranches[0];
+        }
+        // Multiple allOf branches - AND them together
+        return {
+            operation: "AND",
+            fragments: allBranches,
+        };
+    }
+    return null;
+}
+/**
+ * Checks if a branch is satisfied (all required attributes exist)
+ */
+function isBranchSatisfied(node, attributeByName) {
+    if (!node || typeof node !== "object") {
+        return true;
+    }
+    if ("field" in node) {
+        const field = node
+            .field;
+        if (field.type === "attribute") {
+            const attributeName = field.attribute_name;
+            return attributeByName.has(attributeName);
+        }
+        return true;
+    }
+    if ("anyOf" in node && Array.isArray(node.anyOf)) {
+        return node.anyOf.some((child) => isBranchSatisfied(child, attributeByName));
+    }
+    if ("allOf" in node && Array.isArray(node.allOf)) {
+        return node.allOf.every((child) => isBranchSatisfied(child, attributeByName));
+    }
+    return true;
+}
 function buildPolicySqlUsingIndexes(policies, attributeByName, datasetName) {
     const globalRequiredAttributePaths = new Map();
-    const policyWhereClauses = [];
+    const policyWhereGroups = [];
     for (const policy of policies) {
         const policyRequiredAttributePaths = new Map();
         const policyWhereClausesSet = new Set();
+        // Still use traversePolicy to collect required attributes for SELECT
         traversePolicy(policy, attributeByName, policyRequiredAttributePaths, policyWhereClausesSet, datasetName);
-        policyWhereClauses.push(Array.from(policyWhereClausesSet));
+        // Build structured WHERE for this policy
+        const policyWhere = buildBranchWhere(policy.policy.definition.structure, attributeByName, datasetName);
+        if (policyWhere) {
+            policyWhereGroups.push(policyWhere);
+        }
         for (const [attributeName, paths] of policyRequiredAttributePaths) {
             const globalPaths = globalRequiredAttributePaths.get(attributeName) ?? new Set();
             for (const path of paths) {
@@ -69,9 +191,26 @@ function buildPolicySqlUsingIndexes(policies, attributeByName, datasetName) {
         const alias = buildSelectAlias(attributeName, "");
         selectClauses.add(`${expression} AS ${alias}`);
     }
+    // Build the root AND structure
+    // Root level is always AND (combines policies)
+    // Each policy's branches are already OR'd/AND'd by buildBranchWhere
+    let where;
+    if (policyWhereGroups.length === 0) {
+        where = [];
+    }
+    else {
+        // Wrap all policies in root AND
+        // Each policy in policyWhereGroups is already a complete policy structure
+        where = [
+            {
+                fragments: policyWhereGroups,
+                operation: "AND",
+            },
+        ];
+    }
     return {
         select: Array.from(selectClauses),
-        where: policyWhereClauses,
+        where,
     };
 }
 export function buildPolicySqlWithValidation(dataset, policies, attributes) {

package/build/collaboration-policy/core/types.d.ts

@@ -7,9 +7,13 @@ export type ExtendedAttributeNode = Extract<StructureNode, {
 export type PolicyFilter = NonNullable<PolicyDefinition["filters"]>[number];
 export type PathValue = NonNullable<ExtendedAttributeNode["field"]["additional_required_properties"]>[number];
 export type AttributePathIndex = Map<string, Set<string>>;
+export interface PolicySqlGroup {
+    fragments: Array<string | PolicySqlGroup>;
+    operation: "AND" | "OR";
+}
 export interface PolicySqlFragments {
     select: string[];
-    where: string[][];
+    where: Array<PolicySqlGroup | string>;
 }
 export interface PolicyMatchResult extends PolicySqlFragments {
     appliedPolicies: string[];

package/build/collaboration-policy/index.d.ts

@@ -1,4 +1,4 @@
 export { buildPolicySql, buildPolicySqlWithValidation, categorizePolicies, } from "./core/sql-builder";
-export type { AttributePathIndex, ExtendedAttributeNode, PathValue, PolicyFilter, PolicyMatchResult, PolicySqlFragments, StructureNode, } from "./core/types";
+export type { AttributePathIndex, ExtendedAttributeNode, PathValue, PolicyFilter, PolicyMatchResult, PolicySqlFragments, PolicySqlGroup, StructureNode, } from "./core/types";
 export type { CollaborationPolicyInput, CollaborationPolicyType, } from "./types";
 export { buildCollaborationPolicyJsonSchema, CollaborationPolicy, } from "./types";

package/build/collaboration-policy/utils/sql-helpers.d.ts

@@ -1,5 +1,5 @@
 import type { Attribute } from "../../attributes/types";
+import type { PolicySqlGroup } from "../core/types";
 export declare function resolveAttributeExpression(attribute: Attribute, path: string, datasetName: string): string;
 export declare function buildSelectAlias(attributeName: string, path: string): string;
-export declare function buildPolicyWhereGroups(policyWhereClauses: string[][]): string[];
-export declare function formatWhereClause(policyWhereClauses: string[][]): string;
+export declare function formatWhereClause(where: Array<PolicySqlGroup | string>): string;

package/build/collaboration-policy/utils/sql-helpers.js

@@ -35,29 +35,35 @@ export function buildSelectAlias(attributeName, path) {
     const suffix = path.replace(/[^a-zA-Z0-9]+/g, "_");
     return quoteIdentifier(`${attributeName}_${suffix}`);
 }
-export function buildPolicyWhereGroups(policyWhereClauses) {
-    const groups = [];
-    for (const clauses of policyWhereClauses) {
-        if (clauses.length === 0) {
-            continue;
-        }
-        const firstClause = clauses[0];
-        if (firstClause === undefined) {
-            continue;
-        }
-        groups.push(clauses.length === 1 ? firstClause : `(${clauses.join(" AND ")})`);
+/**
+ * Recursively builds SQL string from PolicySqlGroup structure
+ */
+function buildSqlFromGroup(item) {
+    if (typeof item === "string") {
+        return item;
     }
-    return groups;
+    const { fragments, operation } = item;
+    const separator = operation === "AND" ? " AND " : " OR ";
+    const parts = fragments.map(buildSqlFromGroup);
+    if (parts.length === 0) {
+        return "";
+    }
+    if (parts.length === 1) {
+        return parts[0];
+    }
+    return `(${parts.join(separator)})`;
 }
-export function formatWhereClause(policyWhereClauses) {
-    const groups = buildPolicyWhereGroups(policyWhereClauses);
-    if (groups.length === 0) {
+export function formatWhereClause(where) {
+    if (where.length === 0) {
         return "";
     }
-    if (groups.length === 1) {
-        return `\nWHERE\n  ${groups[0]}`;
+    const sqlParts = where
+        .map(buildSqlFromGroup)
+        .filter((part) => part.length > 0);
+    if (sqlParts.length === 0) {
+        return "";
     }
-    return `\nWHERE\n  ${groups.join(" OR\n  ")}`;
+    return `\nWHERE\n  ${sqlParts.join("\n  ")}`;
 }
 function quoteIdentifier(identifier) {
     const safe = identifier.replace(/"/g, "");

package/package.json

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