@simonecoelhosfo/optimizely-mcp-server/dist/tools/EntityDependencyKnowledge.js

Optimizely MCP Server for AI assistants with integrated CLI tools

/**
 * Entity Dependency Knowledge - Domain knowledge about Optimizely entity relationships
 * @description Hard-coded domain knowledge about entity dependencies, relationships, and creation orders.
 * This knowledge supplements what can be automatically extracted from OpenAPI schemas.
 */
export const ENTITY_DEPENDENCIES = {
    project: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['project'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    },
    experiment: {
        required_entities: ['page', 'event'],
        optional_entities: ['audience', 'attribute'],
        creation_order: ['page', 'event', 'audience', 'experiment'],
        platform_differences: {
            feature_experimentation: {
                required: ['event'],
                optional: ['page', 'audience', 'attribute']
            },
            web_experimentation: {
                required: ['page', 'event'],
                optional: ['audience', 'attribute']
            }
        }
    },
    flag: {
        required_entities: ['variation'],
        optional_entities: ['variable_definition', 'audience', 'ruleset'],
        creation_order: ['variable_definition', 'variation', 'flag', 'ruleset'],
        platform_differences: {
            feature_experimentation: {
                required: ['variation'],
                optional: ['variable_definition', 'audience', 'ruleset']
            },
            web_experimentation: {
                required: ['variation'],
                optional: ['audience', 'ruleset']
            }
        }
    },
    variation: {
        required_entities: ['flag'],
        optional_entities: ['variable_definition'],
        creation_order: ['flag', 'variable_definition', 'variation'],
        platform_differences: {
            feature_experimentation: {
                required: ['flag'],
                optional: ['variable_definition']
            },
            web_experimentation: {
                required: ['flag'],
                optional: []
            }
        }
    },
    ruleset: {
        required_entities: ['flag', 'environment'],
        optional_entities: ['audience', 'rule'],
        creation_order: ['flag', 'environment', 'audience', 'ruleset', 'rule'],
        platform_differences: {
            feature_experimentation: {
                required: ['flag', 'environment'],
                optional: ['audience', 'rule']
            },
            web_experimentation: {
                required: ['flag', 'environment'],
                optional: ['audience', 'rule']
            }
        }
    },
    rule: {
        required_entities: ['ruleset'],
        optional_entities: ['audience', 'variation'],
        creation_order: ['ruleset', 'audience', 'variation', 'rule'],
        platform_differences: {
            feature_experimentation: {
                required: ['ruleset'],
                optional: ['audience', 'variation']
            },
            web_experimentation: {
                required: ['ruleset'],
                optional: ['audience', 'variation']
            }
        }
    },
    audience: {
        required_entities: [],
        optional_entities: ['attribute'],
        creation_order: ['attribute', 'audience'],
        platform_differences: {
            feature_experimentation: { required: [], optional: ['attribute'] },
            web_experimentation: { required: [], optional: ['attribute'] }
        }
    },
    attribute: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['attribute'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    },
    event: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['event'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    },
    page: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['page'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    },
    campaign: {
        required_entities: ['experiment'],
        optional_entities: ['page'],
        creation_order: ['page', 'experiment', 'campaign'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: ['experiment'], optional: ['page'] }
        }
    },
    variable_definition: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['variable_definition'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    },
    environment: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['environment'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    },
    webhook: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['webhook'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    },
    extension: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['extension'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    },
    group: {
        required_entities: [],
        optional_entities: ['collaborator'],
        creation_order: ['collaborator', 'group'],
        platform_differences: {
            feature_experimentation: { required: [], optional: ['collaborator'] },
            web_experimentation: { required: [], optional: ['collaborator'] }
        }
    },
    collaborator: {
        required_entities: [],
        optional_entities: [],
        creation_order: ['collaborator'],
        platform_differences: {
            feature_experimentation: { required: [], optional: [] },
            web_experimentation: { required: [], optional: [] }
        }
    }
};
export const ENTITY_RELATIONSHIPS = {
    project: {
        parent_entities: [],
        child_entities: ['experiment', 'flag', 'audience', 'attribute', 'event', 'page', 'environment'],
        referenced_by: ['experiment', 'flag', 'audience', 'attribute', 'event', 'page'],
        references: []
    },
    experiment: {
        parent_entities: ['project'],
        child_entities: ['variation', 'campaign'],
        referenced_by: ['campaign'],
        references: ['project', 'page', 'event', 'audience']
    },
    flag: {
        parent_entities: ['project'],
        child_entities: ['variation', 'ruleset'],
        referenced_by: ['ruleset', 'rule'],
        references: ['project', 'environment']
    },
    variation: {
        parent_entities: ['flag', 'experiment'],
        child_entities: [],
        referenced_by: ['rule'],
        references: ['flag', 'experiment', 'variable_definition']
    },
    ruleset: {
        parent_entities: ['flag', 'environment'],
        child_entities: ['rule'],
        referenced_by: ['rule'],
        references: ['flag', 'environment']
    },
    rule: {
        parent_entities: ['ruleset'],
        child_entities: [],
        referenced_by: [],
        references: ['ruleset', 'audience', 'variation']
    },
    audience: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: ['experiment', 'rule'],
        references: ['project', 'attribute']
    },
    attribute: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: ['audience'],
        references: ['project']
    },
    event: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: ['experiment'],
        references: ['project']
    },
    page: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: ['experiment', 'campaign'],
        references: ['project']
    },
    campaign: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: [],
        references: ['project', 'experiment', 'page']
    },
    variable_definition: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: ['flag', 'variation'],
        references: ['project']
    },
    environment: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: ['flag', 'ruleset'],
        references: ['project']
    },
    webhook: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: [],
        references: ['project']
    },
    extension: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: [],
        references: ['project']
    },
    group: {
        parent_entities: ['project'],
        child_entities: [],
        referenced_by: [],
        references: ['project', 'collaborator']
    },
    collaborator: {
        parent_entities: [],
        child_entities: [],
        referenced_by: ['group'],
        references: []
    }
};
export const DETAILED_DEPENDENCY_INFO = {
    experiment: {
        create: [
            {
                entity_type: 'page',
                relationship: 'required_for_web',
                field_mapping: 'page_ids',
                description: 'Web experiments require at least one page to run on',
                minimum_count: 1,
                platform_specific: 'web_experimentation',
                creation_hints: 'Create page first, then reference page.id in experiment.page_ids array'
            },
            {
                entity_type: 'event',
                relationship: 'required_for_tracking',
                field_mapping: 'metrics[].event_id',
                description: 'Experiments require at least one goal event for tracking conversions',
                minimum_count: 1,
                platform_specific: 'both',
                creation_hints: 'Create event first, then reference event.id in experiment.metrics array'
            },
            {
                entity_type: 'audience',
                relationship: 'optional_targeting',
                field_mapping: 'audience_ids',
                description: 'Optional audience targeting for experiment',
                minimum_count: 0,
                platform_specific: 'both',
                creation_hints: 'Create audience first, then reference audience.id in experiment.audience_ids array'
            }
        ]
    },
    flag: {
        create: [
            {
                entity_type: 'variation',
                relationship: 'required_variations',
                field_mapping: 'variations',
                description: 'Feature flags require at least two variations (control and treatment)',
                minimum_count: 2,
                platform_specific: 'both',
                creation_hints: 'Create flag first with inline variations, or create variations separately and reference'
            },
            {
                entity_type: 'variable_definition',
                relationship: 'optional_variables',
                field_mapping: 'variables',
                description: 'Optional variable definitions for dynamic content',
                minimum_count: 0,
                platform_specific: 'feature_experimentation',
                creation_hints: 'Create variable definitions before flag, then reference in flag.variables array'
            }
        ]
    },
    ruleset: {
        create: [
            {
                entity_type: 'flag',
                relationship: 'parent_flag',
                field_mapping: 'flag_key',
                description: 'Rulesets belong to a specific flag',
                minimum_count: 1,
                maximum_count: 1,
                platform_specific: 'both',
                creation_hints: 'Flag must exist before creating ruleset'
            },
            {
                entity_type: 'environment',
                relationship: 'target_environment',
                field_mapping: 'environment_key',
                description: 'Rulesets target a specific environment',
                minimum_count: 1,
                maximum_count: 1,
                platform_specific: 'both',
                creation_hints: 'Environment must exist before creating ruleset'
            }
        ]
    }
};
export const COMMON_CREATION_PATTERNS = {
    'basic_experiment': {
        description: 'Create a basic A/B test experiment',
        entities_needed: ['page', 'event', 'experiment'],
        creation_order: ['page', 'event', 'experiment'],
        platform: 'web_experimentation'
    },
    'feature_flag': {
        description: 'Create a feature flag with variations',
        entities_needed: ['flag', 'variation'],
        creation_order: ['flag'],
        platform: 'feature_experimentation'
    },
    'targeted_experiment': {
        description: 'Create an experiment with audience targeting',
        entities_needed: ['attribute', 'audience', 'page', 'event', 'experiment'],
        creation_order: ['attribute', 'audience', 'page', 'event', 'experiment'],
        platform: 'web_experimentation'
    },
    'flag_with_rules': {
        description: 'Create a flag with environment-specific rules',
        entities_needed: ['flag', 'variation', 'environment', 'ruleset', 'rule'],
        creation_order: ['flag', 'variation', 'environment', 'ruleset', 'rule'],
        platform: 'feature_experimentation'
    }
};
export function getDependenciesForEntity(entityType, operation = 'create') {
    const dependencies = ENTITY_DEPENDENCIES[entityType];
    if (!dependencies) {
        return [];
    }
    const detailedDeps = DETAILED_DEPENDENCY_INFO[entityType]?.[operation] || [];
    // Combine basic and detailed dependency information
    const basicRequired = dependencies.required_entities.map(entity => ({
        entity_type: entity,
        relationship: 'required',
        field_mapping: 'unknown',
        description: `Required dependency for ${entityType}`,
        platform_specific: 'both'
    }));
    const basicOptional = dependencies.optional_entities.map(entity => ({
        entity_type: entity,
        relationship: 'optional',
        field_mapping: 'unknown',
        description: `Optional dependency for ${entityType}`,
        platform_specific: 'both'
    }));
    return [...detailedDeps, ...basicRequired, ...basicOptional];
}
export function getRelationshipsForEntity(entityType) {
    const relationships = ENTITY_RELATIONSHIPS[entityType];
    if (!relationships) {
        return [];
    }
    const result = [];
    // Add parent relationships
    relationships.parent_entities.forEach(parent => {
        result.push({
            entity_type: parent,
            relationship_type: 'many-to-one',
            field_name: `${parent}_id`,
            description: `${entityType} belongs to ${parent}`,
            cascade_behavior: 'delete'
        });
    });
    // Add child relationships
    relationships.child_entities.forEach(child => {
        result.push({
            entity_type: child,
            relationship_type: 'one-to-many',
            field_name: `${child}s`,
            description: `${entityType} can have multiple ${child}s`,
            cascade_behavior: 'delete'
        });
    });
    // Add reference relationships
    relationships.references.forEach(ref => {
        result.push({
            entity_type: ref,
            relationship_type: 'many-to-one',
            field_name: `${ref}_id`,
            description: `${entityType} references ${ref}`,
            cascade_behavior: 'none'
        });
    });
    return result;
}
export function getCreationOrder(entityType) {
    const dependencies = ENTITY_DEPENDENCIES[entityType];
    return dependencies?.creation_order ? [...dependencies.creation_order] : [entityType];
}
export function getPlatformDifferences(entityType) {
    const dependencies = ENTITY_DEPENDENCIES[entityType];
    return dependencies?.platform_differences || {
        feature_experimentation: { required: [], optional: [] },
        web_experimentation: { required: [], optional: [] }
    };
}
//# sourceMappingURL=EntityDependencyKnowledge.js.map