@narrative.io/data-collaboration-sdk-ts 2.103.0 → 2.105.0

package/build/collaboration-policy/core/filter-utils.js

@@ -1,49 +0,0 @@
-import { normalizePathValue } from "../utils/path-helpers";
-export function visitFilterAttributes(filter, visitor) {
-    traverseFilter(filter, visitor);
-}
-function traverseFilter(node, visitor) {
-    if (!node || typeof node !== "object") {
-        return;
-    }
-    if (isAttributeReference(node)) {
-        const normalizedPath = normalizePathValue(node.path);
-        visitor(node.attribute_name, normalizedPath);
-        return;
-    }
-    if ("left" in node) {
-        traverseFilter(node.left, visitor);
-    }
-    if ("right" in node) {
-        const right = node.right;
-        if (Array.isArray(right)) {
-            for (const item of right) {
-                traverseFilter(item, visitor);
-            }
-        }
-        else {
-            traverseFilter(right, visitor);
-        }
-    }
-    if ("args" in node && Array.isArray(node.args)) {
-        for (const arg of node.args) {
-            traverseFilter(arg, visitor);
-        }
-    }
-    if ("operand" in node) {
-        traverseFilter(node.operand, visitor);
-    }
-    if ("lower" in node) {
-        traverseFilter(node.lower, visitor);
-    }
-    if ("upper" in node) {
-        traverseFilter(node.upper, visitor);
-    }
-}
-export function isAttributeReference(node) {
-    return (!!node &&
-        typeof node === "object" &&
-        "type" in node &&
-        node.type === "attribute" &&
-        "attribute_name" in node);
-}

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

@@ -1,4 +0,0 @@
-import type { Attribute } from "../../attributes/types";
-import type { CollaborationPolicyType } from "../types";
-import type { AttributePathIndex } from "./types";
-export declare function traversePolicy(policy: CollaborationPolicyType, attributeByName: Map<string, Attribute>, requiredAttributePaths: AttributePathIndex, whereClauses: Set<string>, datasetName: string): void;

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

@@ -1,99 +0,0 @@
-import { markAttributePath, normalizePathValue } from "../utils/path-helpers";
-import { filterToSql } from "./filter-builder";
-import { visitFilterAttributes } from "./filter-utils";
-export function traversePolicy(policy, attributeByName, requiredAttributePaths, whereClauses, datasetName) {
-    const definition = policy.policy.definition;
-    // Only traverse satisfied parts of the structure
-    traverseSatisfiedStructure(definition.structure, attributeByName, (node) => {
-        const field = node.field;
-        const attributeName = field.attribute_name;
-        const attribute = attributeByName.get(attributeName);
-        if (!attribute) {
-            throw new Error(`Attribute "${attributeName}" referenced in policy but not provided.`);
-        }
-        // Always mark the root attribute (without path) for SELECT clause
-        markAttributePath(requiredAttributePaths, attribute, normalizePathValue(undefined));
-        if (field.additional_required_properties) {
-            for (const path of field.additional_required_properties) {
-                // Add IS NOT NULL filter for each additional required property
-                const pathStr = normalizePathValue(path);
-                const expression = `company_data."${datasetName}"."_rosetta_stone"."${attribute.name}"."${pathStr}"`;
-                whereClauses.add(`(${expression} IS NOT NULL)`);
-            }
-        }
-        if (node.filters) {
-            for (const filter of node.filters) {
-                visitFilterAttributes(filter, (attributeName, path) => {
-                    const attribute = attributeByName.get(attributeName);
-                    if (!attribute) {
-                        throw new Error(`Attribute "${attributeName}" referenced in filter but not provided.`);
-                    }
-                    markAttributePath(requiredAttributePaths, attribute, path);
-                });
-                const sql = filterToSql(filter, attributeByName, datasetName);
-                whereClauses.add(sql);
-            }
-        }
-    });
-    if (definition.filters) {
-        for (const filter of definition.filters) {
-            visitFilterAttributes(filter, (attributeName, path) => {
-                const attribute = attributeByName.get(attributeName);
-                if (!attribute) {
-                    throw new Error(`Attribute "${attributeName}" referenced in filter but not provided.`);
-                }
-                markAttributePath(requiredAttributePaths, attribute, path);
-            });
-            const sql = filterToSql(filter, attributeByName, datasetName);
-            whereClauses.add(sql);
-        }
-    }
-}
-function traverseSatisfiedStructure(node, attributeByName, visitor) {
-    if (!node || typeof node !== "object") {
-        return;
-    }
-    if ("field" in node) {
-        visitor(node);
-        return;
-    }
-    if ("anyOf" in node && Array.isArray(node.anyOf)) {
-        // For anyOf, traverse ALL satisfied branches
-        for (const child of node.anyOf) {
-            if (isBranchSatisfied(child, attributeByName)) {
-                traverseSatisfiedStructure(child, attributeByName, visitor);
-            }
-        }
-        return;
-    }
-    if ("allOf" in node && Array.isArray(node.allOf)) {
-        // For allOf, traverse all branches (they must all be satisfied)
-        for (const child of node.allOf) {
-            traverseSatisfiedStructure(child, attributeByName, visitor);
-        }
-    }
-}
-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;
-            // Only check if attribute exists, not mappings since we use company_data format
-            return attributeByName.has(attributeName);
-        }
-        return true;
-    }
-    if ("anyOf" in node && Array.isArray(node.anyOf)) {
-        // For anyOf, at least one child must be satisfied
-        return node.anyOf.some((child) => isBranchSatisfied(child, attributeByName));
-    }
-    if ("allOf" in node && Array.isArray(node.allOf)) {
-        // For allOf, all children must be satisfied
-        return node.allOf.every((child) => isBranchSatisfied(child, attributeByName));
-    }
-    return true;
-}

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

@@ -1,11 +0,0 @@
-import type { Attribute } from "../../attributes/types";
-import type { Dataset } from "../../datasets/types";
-import type { CollaborationPolicyType } from "../types";
-interface PolicyValidationResult {
-    isValid: boolean;
-    missingAttributes: string[];
-    missingMappings: string[];
-    errors: string[];
-}
-export declare function validatePolicyAgainstDataset(policy: CollaborationPolicyType, _dataset: Dataset, attributes: Attribute[]): PolicyValidationResult;
-export {};

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

@@ -1,185 +0,0 @@
-import { visitFilterAttributes } from "./filter-utils";
-export function validatePolicyAgainstDataset(policy, _dataset, attributes) {
-    const result = {
-        isValid: true,
-        missingAttributes: [],
-        missingMappings: [],
-        errors: [],
-    };
-    const attributeByName = new Map();
-    for (const attribute of attributes) {
-        attributeByName.set(attribute.name, attribute);
-    }
-    // Validate the policy structure considering logical operators
-    const validation = validatePolicyStructure(policy.policy.definition.structure, attributeByName);
-    if (!validation.isValid) {
-        result.isValid = false;
-        result.errors.push(...validation.errors);
-        // Extract unique missing attributes for backwards compatibility
-        const allMissingAttributes = new Set();
-        for (const error of validation.errors) {
-            if (error.includes("Missing attributes:")) {
-                const attrs = error
-                    .split("Missing attributes:")[1]
-                    ?.split(",")
-                    .map((s) => s.trim()) || [];
-                for (const attr of attrs) {
-                    allMissingAttributes.add(attr);
-                }
-            }
-        }
-        result.missingAttributes = Array.from(allMissingAttributes);
-    }
-    const missingFilterAttributes = new Set();
-    const filters = policy.policy.definition.filters ?? [];
-    for (const filter of filters) {
-        collectMissingAttributesFromFilter(filter, attributeByName, missingFilterAttributes);
-    }
-    visitStructureFilters(policy.policy.definition.structure, (filter) => collectMissingAttributesFromFilter(filter, attributeByName, missingFilterAttributes), attributeByName);
-    if (missingFilterAttributes.size > 0) {
-        result.isValid = false;
-        const missingList = Array.from(missingFilterAttributes).sort();
-        result.errors.push(`Filters reference missing attributes: ${missingList.join(", ")}`);
-        for (const attr of missingList) {
-            if (!result.missingAttributes.includes(attr)) {
-                result.missingAttributes.push(attr);
-            }
-        }
-    }
-    return result;
-}
-function validatePolicyStructure(structure, attributeByName) {
-    if (!structure || typeof structure !== "object") {
-        return { isValid: true, errors: [] };
-    }
-    const struct = structure;
-    // Handle anyOf - at least one must be valid
-    if (struct.anyOf && Array.isArray(struct.anyOf)) {
-        for (const option of struct.anyOf) {
-            const optionValidation = validatePolicyStructure(option, attributeByName);
-            if (optionValidation.isValid) {
-                // If any option is valid, the whole anyOf is valid
-                return { isValid: true, errors: [] };
-            }
-        }
-        // If no options are valid, collect all errors
-        const allErrors = [];
-        for (const option of struct.anyOf) {
-            const optionValidation = validatePolicyStructure(option, attributeByName);
-            allErrors.push(...optionValidation.errors);
-        }
-        return {
-            isValid: false,
-            errors: [
-                `None of the anyOf options are satisfied. Issues: ${allErrors.join("; ")}`,
-            ],
-        };
-    }
-    // Handle allOf - all must be valid
-    if (struct.allOf && Array.isArray(struct.allOf)) {
-        const allErrors = [];
-        for (const requirement of struct.allOf) {
-            const reqValidation = validatePolicyStructure(requirement, attributeByName);
-            if (!reqValidation.isValid) {
-                allErrors.push(...reqValidation.errors);
-            }
-        }
-        return allErrors.length > 0
-            ? { isValid: false, errors: allErrors }
-            : { isValid: true, errors: [] };
-    }
-    // Handle single field with attribute
-    if (struct.field &&
-        struct.field.type ===
-            "attribute") {
-        const attributeName = struct.field
-            .attribute_name;
-        const errors = [];
-        // Check if attribute exists - we don't need to check mappings anymore
-        // since we use company_data.<attribute_name> format
-        if (!attributeByName.has(attributeName)) {
-            errors.push(`Missing attributes: ${attributeName}`);
-        }
-        return errors.length > 0
-            ? { isValid: false, errors }
-            : { isValid: true, errors: [] };
-    }
-    // For other structures, recursively validate
-    for (const value of Object.values(struct)) {
-        if (typeof value === "object") {
-            const childValidation = validatePolicyStructure(value, attributeByName);
-            if (!childValidation.isValid) {
-                return childValidation;
-            }
-        }
-    }
-    return { isValid: true, errors: [] };
-}
-/**
- * Checks if a branch is satisfied (all required attributes exist).
- * For anyOf: at least one child must be satisfied.
- * For allOf: all children must be satisfied.
- * For field nodes: the attribute must exist.
- */
-function isBranchSatisfied(node, attributeByName) {
-    if (!node || typeof node !== "object") {
-        return true;
-    }
-    if ("field" in node) {
-        const field = node.field;
-        if (field.type === "attribute" && field.attribute_name) {
-            return attributeByName.has(field.attribute_name);
-        }
-        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;
-}
-/**
- * Visits filters only in satisfied branches of the policy structure.
- * For anyOf nodes, only visits filters in branches where the required attributes exist.
- * For allOf nodes, visits filters in all branches (since all must be satisfied).
- */
-function visitStructureFilters(node, visitor, attributeByName) {
-    if (!node || typeof node !== "object") {
-        return;
-    }
-    if ("field" in node) {
-        // Only visit filters if this branch is satisfied
-        if (isBranchSatisfied(node, attributeByName)) {
-            const filters = node.filters;
-            if (filters) {
-                for (const filter of filters) {
-                    visitor(filter);
-                }
-            }
-        }
-        return;
-    }
-    if ("anyOf" in node && Array.isArray(node.anyOf)) {
-        // Only visit filters in satisfied branches
-        for (const child of node.anyOf) {
-            if (isBranchSatisfied(child, attributeByName)) {
-                visitStructureFilters(child, visitor, attributeByName);
-            }
-        }
-    }
-    if ("allOf" in node && Array.isArray(node.allOf)) {
-        // For allOf, visit all branches (they all must be satisfied)
-        for (const child of node.allOf) {
-            visitStructureFilters(child, visitor, attributeByName);
-        }
-    }
-}
-function collectMissingAttributesFromFilter(filter, attributesByName, missingAttributes) {
-    visitFilterAttributes(filter, (attributeName) => {
-        if (!attributesByName.has(attributeName)) {
-            missingAttributes.add(attributeName);
-        }
-    });
-}

package/build/collaboration-policy/core/sql-builder.d.ts

@@ -1,37 +0,0 @@
-import type { Attribute } from "../../attributes/types";
-import type { Dataset } from "../../datasets/types";
-import type { CollaborationPolicyType } from "../types";
-import type { PolicyMatchResult, PolicySqlFragments } from "./types";
-export declare function buildPolicySqlWithValidation(dataset: Dataset, policies: CollaborationPolicyType[], attributes: Attribute[]): PolicyMatchResult;
-/**
- * Categorizes collaboration policies into matching and non-matching groups based on dataset compatibility.
- *
- * This function validates each policy against the provided dataset and attributes to determine
- * whether the policy can be successfully applied. Policies are categorized as matching if they
- * have all required attributes available, or non-matching if they're missing required attributes
- * or mappings.
- *
- * @param policies - Array of collaboration policies to categorize
- * @param dataset - The dataset to validate policies against
- * @param attributes - Available attributes for validation
- * @returns Object containing matching policies, non-matching policies, and detailed skip information
- *
- * @example
- * ```typescript
- * const { matching, nonMatching, skippedDetails } = categorizePolicies(
- *   allPolicies,
- *   myDataset,
- *   availableAttributes
- * );
- *
- * console.log(`${matching.length} policies can be applied`);
- * console.log(`${nonMatching.length} policies were skipped`);
- * skippedDetails.forEach(skip => console.log(`Skipped ${skip.name}: ${skip.reason}`));
- * ```
- */
-export declare function categorizePolicies(policies: CollaborationPolicyType[], dataset: Dataset, attributes: Attribute[]): {
-    matching: CollaborationPolicyType[];
-    nonMatching: CollaborationPolicyType[];
-    skippedDetails: PolicyMatchResult["skippedPolicies"];
-};
-export declare function buildPolicySql(dataset: Dataset, policies: CollaborationPolicyType[], attributes: Attribute[]): PolicySqlFragments;