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

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

@@ -1,346 +0,0 @@
-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) {
-    const byId = new Map();
-    const byName = new Map();
-    for (const attribute of attributes) {
-        byId.set(attribute.id, attribute);
-        byName.set(attribute.name, attribute);
-    }
-    return { byId, byName };
-}
-/**
- * Converts an ISO 8601 duration string to milliseconds for comparison.
- * This is an approximation for human-readable durations (months/years vary in length).
- *
- * @param duration - ISO 8601 duration string (e.g., "PT1H", "P1D", "P1M")
- * @returns Duration in milliseconds
- */
-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));
-    // Approximate conversions (months = 30 days, years = 365 days)
-    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;
-}
-/**
- * Finds the smallest (most frequent) refresh schedule from a list of ISO 8601 duration strings.
- * The smallest duration means the most frequent refresh rate.
- *
- * @param schedules - Array of ISO 8601 duration strings
- * @returns The smallest duration in milliseconds, or 2592000000 (30 days/1 month) if no schedules provided
- */
-function getSmallestRefreshSchedule(schedules) {
-    // Default to monthly (30 days in milliseconds)
-    const defaultMonthlyMs = 30 * 24 * 60 * 60 * 1000;
-    if (schedules.length === 0) {
-        return defaultMonthlyMs;
-    }
-    if (schedules.length === 1) {
-        try {
-            return parseDurationToMilliseconds(schedules[0]);
-        }
-        catch (error) {
-            console.warn(`Invalid refresh schedule: ${schedules[0]}, using default`, error);
-            return defaultMonthlyMs;
-        }
-    }
-    // Find the schedule with the smallest duration (most frequent refresh)
-    let smallestValue = Number.MAX_SAFE_INTEGER;
-    for (const schedule of schedules) {
-        try {
-            const value = parseDurationToMilliseconds(schedule);
-            if (value < smallestValue) {
-                smallestValue = value;
-            }
-        }
-        catch (error) {
-            // If parsing fails, skip this schedule
-            console.warn(`Skipping invalid refresh schedule: ${schedule}`, error);
-        }
-    }
-    // If all schedules failed to parse, return default
-    return smallestValue === Number.MAX_SAFE_INTEGER
-        ? defaultMonthlyMs
-        : smallestValue;
-}
-/**
- * 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 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);
-        // 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) {
-                globalPaths.add(path);
-            }
-            globalRequiredAttributePaths.set(attributeName, globalPaths);
-        }
-    }
-    const selectClauses = new Set();
-    for (const [attributeName, _paths] of globalRequiredAttributePaths) {
-        const attribute = attributeByName.get(attributeName);
-        if (!attribute) {
-            continue;
-        }
-        // Always select the root attribute (without path)
-        const expression = resolveAttributeExpression(attribute, "", // Empty path for root attribute
-        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,
-    };
-}
-export function buildPolicySqlWithValidation(dataset, policies, attributes) {
-    const attributeIndexes = buildAttributeIndexes(attributes);
-    const validPolicies = [];
-    const skippedPolicies = [];
-    const warnings = [];
-    // Validate each policy against the dataset
-    for (const policy of policies) {
-        const validation = validatePolicyAgainstDataset(policy, dataset, attributes);
-        if (validation.isValid) {
-            validPolicies.push(policy);
-        }
-        else {
-            skippedPolicies.push({
-                name: policy.display_name || policy.name,
-                reason: "Missing required attributes or mappings",
-                details: validation.errors,
-            });
-        }
-    }
-    // Check if we have at least one valid policy
-    if (validPolicies.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(", ")}`);
-    }
-    // Build SQL for valid policies
-    const sqlFragments = buildPolicySqlUsingIndexes(validPolicies, attributeIndexes.byName, dataset.name);
-    // Calculate the smallest refresh schedule from applied policies
-    const refreshSchedules = validPolicies
-        .map((p) => p.policy.metadata?.refresh_schedule?.max)
-        .filter((schedule) => schedule !== undefined);
-    const refreshSchedule = getSmallestRefreshSchedule(refreshSchedules);
-    return {
-        ...sqlFragments,
-        appliedPolicies: validPolicies.map((p) => p.name),
-        skippedPolicies,
-        warnings,
-        refresh_schedule: refreshSchedule,
-    };
-}
-/**
- * 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 function categorizePolicies(policies, dataset, attributes) {
-    const matching = [];
-    const nonMatching = [];
-    const skippedDetails = [];
-    for (const policy of policies) {
-        const validation = validatePolicyAgainstDataset(policy, dataset, attributes);
-        if (validation.isValid) {
-            matching.push(policy);
-        }
-        else {
-            nonMatching.push(policy);
-            skippedDetails.push({
-                name: policy.display_name || policy.name,
-                reason: "Missing required attributes or mappings",
-                details: validation.errors,
-            });
-        }
-    }
-    return { matching, nonMatching, skippedDetails };
-}
-export function buildPolicySql(dataset, policies, attributes) {
-    const attributeIndexes = buildAttributeIndexes(attributes);
-    return buildPolicySqlUsingIndexes(policies, attributeIndexes.byName, dataset.name);
-}

package/build/collaboration-policy/scripts/generate-policy-schema.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};

package/build/collaboration-policy/scripts/generate-policy-schema.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env bun
-import { buildCollaborationPolicyJsonSchema } from "../types";
-const schema = buildCollaborationPolicyJsonSchema();
-console.log(JSON.stringify(schema, null, 2));