@narrative.io/data-collaboration-sdk-ts 2.98.1-beta.0 → 2.100.0

package/build/collaboration-policy/core/jsonschema/policy-evaluator.js

@@ -1,260 +0,0 @@
-/**
- * Collect filters for a list of required attribute names by looking them up
- * in the property definitions object (sibling to anyOf).
- *
- * In the real API shape, filters live on individual property definitions:
- *
- *   schema.properties.properties.properties = {
- *     "sha256_hashed_email": {
- *       "$ref": "#/$defs/object_value",
- *       "attribute": "https://api.narrative.io/attributes/sha256_hashed_email",
- *       "filters": [ ... ]
- *     }
- *   }
- *
- * @param requiredAttrs - Attribute names whose filters should be collected.
- * @param propertyDefs - The property definitions object from the schema.
- * @returns Collected filters from all matching property definitions.
- */
-function collectFiltersForAttributes(requiredAttrs, propertyDefs) {
-    if (!propertyDefs)
-        return [];
-    const filters = [];
-    for (const attrName of requiredAttrs) {
-        const propDef = propertyDefs[attrName];
-        if (propDef?.filters && Array.isArray(propDef.filters)) {
-            filters.push(...propDef.filters);
-        }
-    }
-    return filters;
-}
-/**
- * Resolve a `$ref` on a property definition to its `$defs` entry and extract
- * the required data subfields that should generate IS NOT NULL WHERE clauses.
- *
- * Only object-type `$defs` (where `properties.type.const === "object"`) have
- * data subfields. For these:
- *   - Top-level `required` entries (excluding "properties") map to data subfields (e.g., "type")
- *   - Inner `properties.properties.required` entries map to nested data subfields (e.g., "value")
- *
- * Primitive types (like `string_value_type`) return no subfields.
- *
- * @param propDef - The property definition that may have a `$ref`.
- * @param defs - The `$defs` object from the schema root.
- * @returns Array of subfield names that require IS NOT NULL checks.
- */
-function resolveRefRequiredSubfields(propDef, defs) {
-    if (!propDef.$ref || !defs)
-        return [];
-    const defName = propDef.$ref.replace(/^#\/\$defs\//, "");
-    const def = defs[defName];
-    if (!def)
-        return [];
-    const defProperties = def.properties;
-    if (!defProperties)
-        return [];
-    // Only object-type $defs have data subfields
-    const typeProperty = defProperties.type;
-    if (typeProperty?.const !== "object")
-        return [];
-    const subfields = [];
-    // Top-level required, minus "properties" (structural wrapper)
-    const topRequired = def.required;
-    if (topRequired) {
-        for (const field of topRequired) {
-            if (field !== "properties")
-                subfields.push(field);
-        }
-    }
-    // Inner properties.properties.required
-    const innerProps = defProperties.properties;
-    const innerRequired = innerProps?.required;
-    if (innerRequired) {
-        for (const field of innerRequired) {
-            if (!subfields.includes(field))
-                subfields.push(field);
-        }
-    }
-    return subfields;
-}
-/**
- * Collect required data subfields for a list of attribute names by resolving
- * their `$ref` entries against the schema's `$defs`.
- *
- * These generate IS NOT NULL WHERE clauses in the SQL builder.
- *
- * @param requiredAttrs - Attribute names whose required subfields should be collected.
- * @param propertyDefs - The property definitions object from the schema.
- * @param defs - The `$defs` object from the schema root.
- * @returns Per-attribute list of subfield paths that require IS NOT NULL checks.
- */
-function collectRequiredSubfieldsFromRefs(requiredAttrs, propertyDefs, defs) {
-    if (!propertyDefs)
-        return [];
-    const result = [];
-    for (const attrName of requiredAttrs) {
-        const propDef = propertyDefs[attrName];
-        if (!propDef)
-            continue;
-        const paths = resolveRefRequiredSubfields(propDef, defs);
-        if (paths.length > 0) {
-            result.push({ attributeName: attrName, paths });
-        }
-    }
-    return result;
-}
-/**
- * Determine which branches in a JSON-Schema policy are satisfied for the given attributes.
- *
- * Expects the real API structure:
- *
- *   schema.properties.properties = {
- *     anyOf: [
- *       { required: ["sha256_hashed_email"] },
- *       { allOf: [
- *           { required: ["person_name"] },
- *           { required: ["iso_3166_1_country"] },
- *           { required: ["postal_address"] }
- *         ]
- *       }
- *     ],
- *     properties: {
- *       "sha256_hashed_email": {
- *         "$ref": "#/$defs/attribute_value",
- *         "attribute": "https://api.narrative.io/attributes/sha256_hashed_email",
- *         "filters": [ ... ],
- *         "$ref": "#/$defs/object_value"
- *       },
- *       ...
- *     }
- *   }
- *
- * Branches only contain `required` arrays. Filters are defined on the property
- * definitions (sibling `properties` object next to `anyOf`). Required subfields
- * for IS NOT NULL clauses are derived by resolving `$ref` entries against `$defs`.
- *
- * A branch is considered satisfied if:
- *   - For a simple branch: all required property names exist as Attributes by name.
- *   - For an allOf group: all sub-branches' required property names exist as Attributes.
- *
- * @param policy - The JSON-Schema connector policy to inspect.
- * @param attributes - Attributes available on the dataset.
- * @returns A list of matching branches with their required attributes, filters, and additional requirements.
- */
-function findMatchingBranches(policy, attributes) {
-    const attributeByName = new Map();
-    for (const attr of attributes) {
-        attributeByName.set(attr.name, attr);
-    }
-    const schema = policy.policy;
-    const schemaProps = schema.properties;
-    // Extract $defs from the schema root for $ref resolution
-    const defs = schema.$defs;
-    // Expect something like: schema.properties.properties.anyOf
-    const propertiesObj = schemaProps &&
-        schemaProps.properties;
-    const anyOfBranches = propertiesObj?.anyOf;
-    if (!Array.isArray(anyOfBranches)) {
-        return [];
-    }
-    // Property definitions live as a sibling to anyOf — this is where filters are.
-    const propertyDefs = propertiesObj?.properties;
-    const matches = [];
-    anyOfBranches.forEach((branch, index) => {
-        if (!branch || typeof branch !== "object")
-            return;
-        const branchObj = branch;
-        // Case 1: "allOf" group branch (bundle of multiple fields)
-        if (Array.isArray(branchObj.allOf)) {
-            const groupRequiredAttrs = [];
-            let allSubBranchesSatisfied = true;
-            for (const sub of branchObj.allOf) {
-                if (!sub || typeof sub !== "object") {
-                    allSubBranchesSatisfied = false;
-                    break;
-                }
-                const subObj = sub;
-                const subRequired = Array.isArray(subObj.required)
-                    ? subObj.required
-                    : [];
-                // Sub-branch is satisfied if all required keys exist as attributes.
-                const missingSub = subRequired.filter((key) => !attributeByName.has(key));
-                if (missingSub.length > 0) {
-                    allSubBranchesSatisfied = false;
-                    break;
-                }
-                groupRequiredAttrs.push(...subRequired);
-            }
-            if (!allSubBranchesSatisfied) {
-                return; // this outer anyOf branch is not satisfied
-            }
-            const deduped = Array.from(new Set(groupRequiredAttrs));
-            matches.push({
-                branchIndex: index,
-                requiredAttributes: deduped,
-                filters: collectFiltersForAttributes(deduped, propertyDefs),
-                additionalRequiredProperties: collectRequiredSubfieldsFromRefs(deduped, propertyDefs, defs),
-            });
-            return;
-        }
-        // Case 2: simple single-field branch
-        const branchRequired = Array.isArray(branchObj.required)
-            ? branchObj.required
-            : [];
-        const missing = branchRequired.filter((key) => !attributeByName.has(key));
-        if (missing.length > 0) {
-            return; // this branch is not satisfied
-        }
-        matches.push({
-            branchIndex: index,
-            requiredAttributes: branchRequired,
-            filters: collectFiltersForAttributes(branchRequired, propertyDefs),
-            additionalRequiredProperties: collectRequiredSubfieldsFromRefs(branchRequired, propertyDefs, defs),
-        });
-    });
-    return matches;
-}
-/**
- * Evaluate an array of JSON-Schema-based connector policies against a dataset.
- *
- * Eligibility is determined by checking whether the dataset's Rosetta Stone
- * attributes satisfy at least one anyOf branch in the policy schema. This uses
- * the `attributes` array (resolved from dataset mappings) as the source of truth,
- * NOT the raw dataset.schema — the raw schema contains storage-level column names
- * and flat types that don't match the policy's Rosetta Stone attribute names.
- *
- * A policy is considered valid (compatible) if `findMatchingBranches` finds at
- * least one satisfied branch.
- *
- * @param _dataset - The dataset (currently unused; attributes carry the relevant info).
- * @param attributes - Rosetta Stone attributes associated with the dataset.
- * @param policies - JSON-Schema-based connector policies to evaluate.
- * @returns An array of PolicyEvaluation results, one per policy.
- */
-export function evaluateJsonSchemaPolicies(_dataset, attributes, policies) {
-    const evaluations = [];
-    for (const policy of policies) {
-        // Determine which branches within the policy are satisfied by the
-        // dataset's Rosetta Stone attributes.
-        const matches = findMatchingBranches(policy, attributes);
-        if (matches.length > 0) {
-            evaluations.push({
-                policy,
-                isValid: true,
-                matches,
-                errors: [],
-            });
-        }
-        else {
-            evaluations.push({
-                policy,
-                isValid: false,
-                matches: [],
-                errors: [
-                    `No anyOf branches are satisfied by the available attributes for policy "${policy.name}"`,
-                ],
-            });
-        }
-    }
-    return evaluations;
-}

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

@@ -1,79 +0,0 @@
-import type { Attribute } from "../../../attributes/types";
-import type { Dataset } from "../../../datasets/types";
-import type { PolicyMatchResult, PolicySqlFragments } from "../types";
-import type { JsonSchemaConnectorPolicy } from "./json-schema-types";
-import type { PolicyBranchMatch } from "./policy-branches";
-/**
- * JSON-Schema-based equivalent of PolicyMatchResult, but instead of fully-built SQL,
- * it carries branch-level matches that your existing SQL builder can consume.
- */
-export interface JsonSchemaPolicyMatchResult {
-    /** Names of policies whose JSON Schemas were compatible with the dataset. */
-    appliedPolicies: string[];
-    /** Policies that were skipped because validation failed. */
-    skippedPolicies: PolicyMatchResult["skippedPolicies"];
-    /** Non-fatal warnings (e.g. some policies were skipped). */
-    warnings: string[];
-    /**
-     * The minimum refresh schedule (most frequent) across all applied policies,
-     * expressed as an ISO 8601 duration string.
-     */
-    refresh_schedule: string;
-    /**
-     * For each applied policy, which branches matched and what filters/attributes
-     * they require. This is what your SQL builder layer should consume.
-     */
-    branchMatches: Array<{
-        policyName: string;
-        branches: PolicyBranchMatch[];
-    }>;
-}
-/**
- * Categorize JSON-Schema-based connector policies into matching and non-matching
- * groups based on dataset compatibility.
- *
- * @param policies - JSON-Schema-based connector policies.
- * @param dataset - Dataset whose schema is used for validation.
- * @param attributes - Attributes associated with the dataset.
- * @returns Object with matching policies, nonMatching policies, and skip details.
- */
-export declare function categorizePolicies(policies: JsonSchemaConnectorPolicy[], dataset: Dataset, attributes: Attribute[]): {
-    matching: JsonSchemaConnectorPolicy[];
-    nonMatching: JsonSchemaConnectorPolicy[];
-    skippedDetails: PolicyMatchResult["skippedPolicies"];
-};
-/**
- * Helper that evaluates JSON-Schema-based policies and returns branch-level
- * matches plus scheduling information.
- *
- * This is intended to be consumed by a separate SQL builder layer or for
- * inspection of branch-level match details.
- *
- * @param dataset - The dataset against which policies should be evaluated.
- * @param policies - JSON-Schema-based connector policies.
- * @param attributes - Attributes associated with the dataset.
- * @returns JsonSchemaPolicyMatchResult with applied/skipped policies and branch matches.
- * @throws If no policies are compatible with the dataset.
- */
-export declare function buildPolicySqlWithJsonSchema(dataset: Dataset, policies: JsonSchemaConnectorPolicy[], attributes: Attribute[]): JsonSchemaPolicyMatchResult;
-/**
- * Uses JSON Schema branch matching to determine valid policies, then builds
- * SELECT and WHERE SQL fragments.
- *
- * @param dataset - Dataset for which to evaluate policies and produce SQL.
- * @param policies - JSON-Schema-based connector policies.
- * @param attributes - Attributes associated with the dataset.
- * @returns PolicyMatchResult with select, where, applied/skipped policies, warnings, and refresh schedule.
- */
-export declare function buildPolicySqlWithValidation(dataset: Dataset, policies: JsonSchemaConnectorPolicy[], attributes: Attribute[]): PolicyMatchResult;
-/**
- * Build SQL fragments without validation. Assumes you already filtered the policies
- * however you want (e.g. via categorizePolicies). Builds SELECT and WHERE SQL
- * fragments from all provided policies.
- *
- * @param dataset - Dataset for which to build SQL fragments.
- * @param policies - JSON-Schema-based connector policies.
- * @param attributes - Attributes associated with the dataset.
- * @returns PolicySqlFragments with select and where arrays.
- */
-export declare function buildPolicySql(dataset: Dataset, policies: JsonSchemaConnectorPolicy[], attributes: Attribute[]): PolicySqlFragments;

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

@@ -1,306 +0,0 @@
-import { buildSelectAlias, resolveAttributeExpression, } from "../../utils/sql-helpers";
-import { filterToSql } from "../filter-builder";
-import { evaluateJsonSchemaPolicies } from "./policy-evaluator";
-/**
- * Convert an ISO 8601 duration string (e.g. "P1D", "PT1H") into milliseconds.
- * This is an approximation (months and years are treated as 30 and 365 days respectively).
- *
- * @param duration - The ISO 8601 duration string.
- * @returns The approximate duration in milliseconds.
- * @throws If the duration string does not match the ISO 8601 duration format.
- */
-function parseDurationToMilliseconds(duration) {
-    const regex = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
-    const matches = duration.match(regex);
-    if (!matches) {
-        throw new Error(`Invalid ISO 8601 duration format: ${duration}`);
-    }
-    const [, years, months, weeks, days, hours, minutes, seconds] = matches.map((m) => Number.parseInt(m || "0", 10));
-    const milliseconds = years * 365 * 24 * 60 * 60 * 1000 +
-        months * 30 * 24 * 60 * 60 * 1000 +
-        weeks * 7 * 24 * 60 * 60 * 1000 +
-        days * 24 * 60 * 60 * 1000 +
-        hours * 60 * 60 * 1000 +
-        minutes * 60 * 1000 +
-        seconds * 1000;
-    return milliseconds;
-}
-/**
- * Find the "smallest" (most frequent) ISO 8601 duration within a list.
- *
- * @param schedules - Array of ISO 8601 duration strings.
- * @returns The smallest duration as an ISO 8601 string, or "P1M" if none are valid.
- */
-function getSmallestRefreshSchedule(schedules) {
-    const defaultMonthly = "P1M";
-    if (schedules.length === 0)
-        return defaultMonthly;
-    if (schedules.length === 1) {
-        try {
-            parseDurationToMilliseconds(schedules[0]);
-            return schedules[0];
-        }
-        catch {
-            return defaultMonthly;
-        }
-    }
-    let smallestValue = Number.MAX_SAFE_INTEGER;
-    let smallestSchedule = null;
-    for (const schedule of schedules) {
-        try {
-            const value = parseDurationToMilliseconds(schedule);
-            if (value < smallestValue) {
-                smallestValue = value;
-                smallestSchedule = schedule;
-            }
-        }
-        catch {
-            // skip invalid schedule
-        }
-    }
-    return smallestSchedule ?? defaultMonthly;
-}
-/**
- * Build SQL fragments (SELECT + WHERE) from branch matches across all applied policies.
- *
- * SELECT: one entry per unique required attribute (root level, no subfield paths):
- *   company_data."<dataset>"."_rosetta_stone"."<attr>" AS "<attr>"
- *
- * WHERE: structured as root AND → per-policy structure → OR of branches.
- *   Each branch contains IS NOT NULL clauses (from additionalRequiredProperties)
- *   and filter SQL (from filters), ANDed together.
- *
- * @param branchMatches - Per-policy branch match results from evaluateJsonSchemaPolicies.
- * @param attributeByName - Map of attribute name → Attribute for SQL expression building.
- * @param datasetName - Dataset name used in SQL column paths.
- * @returns PolicySqlFragments with select and where arrays.
- */
-function buildSqlFromBranchMatches(branchMatches, attributeByName, datasetName) {
-    // --- SELECT ---
-    // Collect all unique required attributes across all policies and branches
-    const globalRequiredAttributes = new Set();
-    for (const policyMatch of branchMatches) {
-        for (const branch of policyMatch.branches) {
-            for (const attrName of branch.requiredAttributes) {
-                globalRequiredAttributes.add(attrName);
-            }
-        }
-    }
-    const selectClauses = new Set();
-    for (const attrName of globalRequiredAttributes) {
-        const attribute = attributeByName.get(attrName);
-        if (!attribute)
-            continue;
-        const expression = resolveAttributeExpression(attribute, "", datasetName);
-        const alias = buildSelectAlias(attrName, "");
-        selectClauses.add(`${expression} AS ${alias}`);
-    }
-    // --- WHERE ---
-    const policyWhereGroups = [];
-    for (const policyMatch of branchMatches) {
-        const branchWheres = [];
-        for (const branch of policyMatch.branches) {
-            const branchClauses = [];
-            // 1. IS NOT NULL clauses derived from $ref/$defs resolution
-            for (const req of branch.additionalRequiredProperties) {
-                const attribute = attributeByName.get(req.attributeName);
-                if (!attribute)
-                    continue;
-                for (const path of req.paths) {
-                    const expression = resolveAttributeExpression(attribute, path, datasetName);
-                    branchClauses.push(`(${expression} IS NOT NULL)`);
-                }
-            }
-            // 2. Filter SQL
-            for (const filter of branch.filters) {
-                const sql = filterToSql(filter, attributeByName, datasetName);
-                branchClauses.push(sql);
-            }
-            if (branchClauses.length === 0) {
-                continue; // branch has no WHERE contribution
-            }
-            if (branchClauses.length === 1) {
-                branchWheres.push(branchClauses[0]);
-            }
-            else {
-                branchWheres.push({
-                    operation: "AND",
-                    fragments: branchClauses,
-                });
-            }
-        }
-        if (branchWheres.length === 0) {
-            continue; // policy has no WHERE contribution
-        }
-        if (branchWheres.length === 1) {
-            policyWhereGroups.push(branchWheres[0]);
-        }
-        else {
-            // Multiple branches → OR them (anyOf semantics)
-            policyWhereGroups.push({
-                operation: "OR",
-                fragments: branchWheres,
-            });
-        }
-    }
-    let where;
-    if (policyWhereGroups.length === 0) {
-        where = [];
-    }
-    else {
-        // Root AND wrapping all policies
-        where = [
-            {
-                fragments: policyWhereGroups,
-                operation: "AND",
-            },
-        ];
-    }
-    return {
-        select: Array.from(selectClauses),
-        where,
-    };
-}
-/**
- * Categorize JSON-Schema-based connector policies into matching and non-matching
- * groups based on dataset compatibility.
- *
- * @param policies - JSON-Schema-based connector policies.
- * @param dataset - Dataset whose schema is used for validation.
- * @param attributes - Attributes associated with the dataset.
- * @returns Object with matching policies, nonMatching policies, and skip details.
- */
-export function categorizePolicies(policies, dataset, attributes) {
-    const evaluations = evaluateJsonSchemaPolicies(dataset, attributes, policies);
-    const matching = [];
-    const nonMatching = [];
-    const skippedDetails = [];
-    for (const evalResult of evaluations) {
-        const { policy, isValid, errors } = evalResult;
-        if (isValid) {
-            matching.push(policy);
-        }
-        else {
-            nonMatching.push(policy);
-            skippedDetails.push({
-                name: policy.name,
-                reason: "Dataset schema not compatible with policy JSON Schema",
-                details: errors,
-            });
-        }
-    }
-    return { matching, nonMatching, skippedDetails };
-}
-/**
- * Helper that evaluates JSON-Schema-based policies and returns branch-level
- * matches plus scheduling information.
- *
- * This is intended to be consumed by a separate SQL builder layer or for
- * inspection of branch-level match details.
- *
- * @param dataset - The dataset against which policies should be evaluated.
- * @param policies - JSON-Schema-based connector policies.
- * @param attributes - Attributes associated with the dataset.
- * @returns JsonSchemaPolicyMatchResult with applied/skipped policies and branch matches.
- * @throws If no policies are compatible with the dataset.
- */
-export function buildPolicySqlWithJsonSchema(dataset, policies, attributes) {
-    const evaluations = evaluateJsonSchemaPolicies(dataset, attributes, policies);
-    const appliedPolicies = [];
-    const skippedPolicies = [];
-    const warnings = [];
-    const branchMatches = [];
-    for (const evalResult of evaluations) {
-        const { policy, isValid, matches, errors } = evalResult;
-        if (!isValid) {
-            skippedPolicies.push({
-                name: policy.name,
-                reason: "Dataset schema not compatible with policy JSON Schema",
-                details: errors,
-            });
-            continue;
-        }
-        appliedPolicies.push(policy.name);
-        branchMatches.push({
-            policyName: policy.name,
-            branches: matches,
-        });
-    }
-    if (appliedPolicies.length === 0) {
-        const errorMessage = policies.length === 0
-            ? "No policies provided"
-            : `No policies are compatible with dataset "${dataset.display_name || dataset.name}".`;
-        const details = skippedPolicies.length > 0
-            ? [`Skipped policies: ${skippedPolicies.map((p) => p.name).join(", ")}`]
-            : [];
-        throw new Error(`${errorMessage}\n${details.join("\n")}`);
-    }
-    if (skippedPolicies.length > 0) {
-        warnings.push(`Skipped ${skippedPolicies.length} incompatible policies: ${skippedPolicies
-            .map((p) => p.name)
-            .join(", ")}`);
-    }
-    const refreshSchedules = evaluations
-        .filter((e) => e.isValid && e.policy.metadata.refresh_schedule?.max)
-        .map((e) => e.policy.metadata.refresh_schedule?.max)
-        .filter((max) => max != null);
-    const refresh_schedule = getSmallestRefreshSchedule(refreshSchedules);
-    return {
-        appliedPolicies,
-        skippedPolicies,
-        warnings,
-        refresh_schedule,
-        branchMatches,
-    };
-}
-/**
- * Uses JSON Schema branch matching to determine valid policies, then builds
- * SELECT and WHERE SQL fragments.
- *
- * @param dataset - Dataset for which to evaluate policies and produce SQL.
- * @param policies - JSON-Schema-based connector policies.
- * @param attributes - Attributes associated with the dataset.
- * @returns PolicyMatchResult with select, where, applied/skipped policies, warnings, and refresh schedule.
- */
-export function buildPolicySqlWithValidation(dataset, policies, attributes) {
-    const matchResult = buildPolicySqlWithJsonSchema(dataset, policies, attributes);
-    const attributeByName = new Map();
-    for (const attr of attributes) {
-        attributeByName.set(attr.name, attr);
-    }
-    const sqlFragments = buildSqlFromBranchMatches(matchResult.branchMatches, attributeByName, dataset.name);
-    return {
-        ...sqlFragments,
-        appliedPolicies: matchResult.appliedPolicies,
-        skippedPolicies: matchResult.skippedPolicies,
-        warnings: matchResult.warnings,
-        refresh_schedule: matchResult.refresh_schedule,
-    };
-}
-/**
- * Build SQL fragments without validation. Assumes you already filtered the policies
- * however you want (e.g. via categorizePolicies). Builds SELECT and WHERE SQL
- * fragments from all provided policies.
- *
- * @param dataset - Dataset for which to build SQL fragments.
- * @param policies - JSON-Schema-based connector policies.
- * @param attributes - Attributes associated with the dataset.
- * @returns PolicySqlFragments with select and where arrays.
- */
-export function buildPolicySql(dataset, policies, attributes) {
-    const evaluations = evaluateJsonSchemaPolicies(dataset, attributes, policies);
-    const attributeByName = new Map();
-    for (const attr of attributes) {
-        attributeByName.set(attr.name, attr);
-    }
-    const branchMatches = [];
-    for (const evalResult of evaluations) {
-        if (evalResult.isValid) {
-            branchMatches.push({
-                policyName: evalResult.policy.name,
-                branches: evalResult.matches,
-            });
-        }
-    }
-    return buildSqlFromBranchMatches(branchMatches, attributeByName, dataset.name);
-}