powerplatform-mcp 0.4.4 → 1.0.0

package/build/models/ApiCollectionResponse.js

@@ -0,0 +1 @@
+export {};

package/build/models/index.js

@@ -0,0 +1 @@
+export {};

package/build/prompts/entityPrompts.js

@@ -0,0 +1,244 @@
+import { z } from "zod";
+import { powerPlatformPrompts } from "./templates.js";
+/**
+ * Register entity prompts with the MCP server.
+ */
+export function registerEntityPrompts(server, ctx) {
+    // Entity Overview Prompt
+    server.registerPrompt("entity-overview", {
+        title: "Entity Overview",
+        description: "Get an overview of a Power Platform entity",
+        argsSchema: {
+            entityName: z.string().describe("The logical name of the entity"),
+        },
+    }, async (args) => {
+        try {
+            const service = ctx.getEntityService();
+            const entityName = args.entityName;
+            // Get entity metadata and key attributes
+            const [metadata, attributes] = await Promise.all([
+                service.getEntityMetadata(entityName),
+                service.getEntityAttributes(entityName),
+            ]);
+            // Format entity details
+            const entityDetails = `- Display Name: ${metadata.DisplayName?.UserLocalizedLabel?.Label || entityName}\n` +
+                `- Schema Name: ${metadata.SchemaName}\n` +
+                `- Description: ${metadata.Description?.UserLocalizedLabel?.Label || "No description"}\n` +
+                `- Primary Key: ${metadata.PrimaryIdAttribute}\n` +
+                `- Primary Name: ${metadata.PrimaryNameAttribute}`;
+            // Get key attributes
+            const keyAttributes = attributes.value
+                .map((attr) => {
+                const attrType = attr["@odata.type"] || attr.odata?.type || "Unknown type";
+                return `- ${attr.LogicalName}: ${attrType}`;
+            })
+                .join("\n");
+            // Get relationships summary
+            const relationships = await service.getEntityRelationships(entityName);
+            const oneToManyCount = relationships.oneToMany.value.length;
+            const manyToManyCount = relationships.manyToMany.value.length;
+            const relationshipsSummary = `- One-to-Many Relationships: ${oneToManyCount}\n` +
+                `- Many-to-Many Relationships: ${manyToManyCount}`;
+            let promptContent = powerPlatformPrompts.ENTITY_OVERVIEW(entityName);
+            promptContent = promptContent
+                .replace("{{entity_details}}", entityDetails)
+                .replace("{{key_attributes}}", keyAttributes)
+                .replace("{{relationships}}", relationshipsSummary);
+            return {
+                messages: [
+                    {
+                        role: "assistant",
+                        content: {
+                            type: "text",
+                            text: promptContent,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error(`Error handling entity-overview prompt:`, error);
+            return {
+                messages: [
+                    {
+                        role: "assistant",
+                        content: {
+                            type: "text",
+                            text: `Error: ${error.message}`,
+                        },
+                    },
+                ],
+            };
+        }
+    });
+    // Attribute Details Prompt
+    server.registerPrompt("attribute-details", {
+        title: "Attribute Details",
+        description: "Get detailed information about a specific entity attribute/field",
+        argsSchema: {
+            entityName: z.string().describe("The logical name of the entity"),
+            attributeName: z.string().describe("The logical name of the attribute"),
+        },
+    }, async (args) => {
+        try {
+            const service = ctx.getEntityService();
+            const { entityName, attributeName } = args;
+            // Get attribute details
+            const attribute = await service.getEntityAttribute(entityName, attributeName);
+            // Format attribute details
+            const attrDetails = `- Display Name: ${attribute.DisplayName?.UserLocalizedLabel?.Label || attributeName}\n` +
+                `- Description: ${attribute.Description?.UserLocalizedLabel?.Label || "No description"}\n` +
+                `- Type: ${attribute.AttributeType}\n` +
+                `- Format: ${attribute.Format || "N/A"}\n` +
+                `- Is Required: ${attribute.RequiredLevel?.Value || "No"}\n` +
+                `- Is Searchable: ${attribute.IsValidForAdvancedFind || false}`;
+            let promptContent = powerPlatformPrompts.ATTRIBUTE_DETAILS(entityName, attributeName);
+            promptContent = promptContent
+                .replace("{{attribute_details}}", attrDetails)
+                .replace("{{data_type}}", attribute.AttributeType)
+                .replace("{{required}}", attribute.RequiredLevel?.Value || "No")
+                .replace("{{max_length}}", attribute.MaxLength || "N/A");
+            return {
+                messages: [
+                    {
+                        role: "assistant",
+                        content: {
+                            type: "text",
+                            text: promptContent,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error(`Error handling attribute-details prompt:`, error);
+            return {
+                messages: [
+                    {
+                        role: "assistant",
+                        content: {
+                            type: "text",
+                            text: `Error: ${error.message}`,
+                        },
+                    },
+                ],
+            };
+        }
+    });
+    // Query Template Prompt
+    server.registerPrompt("query-template", {
+        title: "Query Template",
+        description: "Get a template for querying a Power Platform entity",
+        argsSchema: {
+            entityName: z.string().describe("The logical name of the entity"),
+        },
+    }, async (args) => {
+        try {
+            const service = ctx.getEntityService();
+            const entityName = args.entityName;
+            // Get entity metadata to determine plural name
+            const metadata = await service.getEntityMetadata(entityName);
+            const entityNamePlural = metadata.EntitySetName;
+            // Get a few important fields for the select example
+            const attributes = await service.getEntityAttributes(entityName);
+            const selectFields = attributes.value
+                .filter((attr) => attr.IsValidForRead === true && !attr.AttributeOf)
+                .slice(0, 5) // Just take first 5 for example
+                .map((attr) => attr.LogicalName)
+                .join(",");
+            let promptContent = powerPlatformPrompts.QUERY_TEMPLATE(entityNamePlural);
+            promptContent = promptContent
+                .replace("{{selected_fields}}", selectFields)
+                .replace("{{filter_conditions}}", `${metadata.PrimaryNameAttribute} eq 'Example'`)
+                .replace("{{order_by}}", `${metadata.PrimaryNameAttribute} asc`)
+                .replace("{{max_records}}", "50");
+            return {
+                messages: [
+                    {
+                        role: "assistant",
+                        content: {
+                            type: "text",
+                            text: promptContent,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error(`Error handling query-template prompt:`, error);
+            return {
+                messages: [
+                    {
+                        role: "assistant",
+                        content: {
+                            type: "text",
+                            text: `Error: ${error.message}`,
+                        },
+                    },
+                ],
+            };
+        }
+    });
+    // Relationship Map Prompt
+    server.registerPrompt("relationship-map", {
+        title: "Relationship Map",
+        description: "Get a list of relationships for a Power Platform entity",
+        argsSchema: {
+            entityName: z.string().describe("The logical name of the entity"),
+        },
+    }, async (args) => {
+        try {
+            const service = ctx.getEntityService();
+            const entityName = args.entityName;
+            // Get relationships
+            const relationships = await service.getEntityRelationships(entityName);
+            // Format one-to-many relationships where this entity is primary
+            const oneToManyPrimary = relationships.oneToMany.value
+                .filter((rel) => rel.ReferencingEntity !== entityName)
+                .map((rel) => `- ${rel.SchemaName}: ${entityName} (1) → ${rel.ReferencingEntity} (N)`)
+                .join("\n");
+            // Format one-to-many relationships where this entity is related
+            const oneToManyRelated = relationships.oneToMany.value
+                .filter((rel) => rel.ReferencingEntity === entityName)
+                .map((rel) => `- ${rel.SchemaName}: ${rel.ReferencedEntity} (1) → ${entityName} (N)`)
+                .join("\n");
+            // Format many-to-many relationships
+            const manyToMany = relationships.manyToMany.value
+                .map((rel) => {
+                const otherEntity = rel.Entity1LogicalName === entityName ? rel.Entity2LogicalName : rel.Entity1LogicalName;
+                return `- ${rel.SchemaName}: ${entityName} (N) ↔ ${otherEntity} (N)`;
+            })
+                .join("\n");
+            let promptContent = powerPlatformPrompts.RELATIONSHIP_MAP(entityName);
+            promptContent = promptContent
+                .replace("{{one_to_many_primary}}", oneToManyPrimary || "None found")
+                .replace("{{one_to_many_related}}", oneToManyRelated || "None found")
+                .replace("{{many_to_many}}", manyToMany || "None found");
+            return {
+                messages: [
+                    {
+                        role: "assistant",
+                        content: {
+                            type: "text",
+                            text: promptContent,
+                        },
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error(`Error handling relationship-map prompt:`, error);
+            return {
+                messages: [
+                    {
+                        role: "assistant",
+                        content: {
+                            type: "text",
+                            text: `Error: ${error.message}`,
+                        },
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/prompts/index.js

@@ -0,0 +1,9 @@
+import { registerEntityPrompts } from "./entityPrompts.js";
+export { registerEntityPrompts } from "./entityPrompts.js";
+export { powerPlatformPrompts } from "./templates.js";
+/**
+ * Register all prompts with the MCP server.
+ */
+export function registerAllPrompts(server, ctx) {
+    registerEntityPrompts(server, ctx);
+}

package/build/prompts/templates.js

@@ -0,0 +1,34 @@
+/**
+ * Pre-defined PowerPlatform prompt templates.
+ */
+export const powerPlatformPrompts = {
+    // Entity exploration prompts
+    ENTITY_OVERVIEW: (entityName) => `## Power Platform Entity: ${entityName}\n\n` +
+        `This is an overview of the '${entityName}' entity in Microsoft Power Platform/Dataverse:\n\n` +
+        `### Entity Details\n{{entity_details}}\n\n` +
+        `### Attributes\n{{key_attributes}}\n\n` +
+        `### Relationships\n{{relationships}}\n\n` +
+        `You can query this entity using OData filters against the plural name.`,
+    ATTRIBUTE_DETAILS: (entityName, attributeName) => `## Attribute: ${attributeName}\n\n` +
+        `Details for the '${attributeName}' attribute of the '${entityName}' entity:\n\n` +
+        `{{attribute_details}}\n\n` +
+        `### Usage Notes\n` +
+        `- Data Type: {{data_type}}\n` +
+        `- Required: {{required}}\n` +
+        `- Max Length: {{max_length}}`,
+    // Query builder prompts
+    QUERY_TEMPLATE: (entityNamePlural) => `## OData Query Template for ${entityNamePlural}\n\n` +
+        `Use this template to build queries against the ${entityNamePlural} entity:\n\n` +
+        `\`\`\`\n${entityNamePlural}?$select={{selected_fields}}&$filter={{filter_conditions}}&$orderby={{order_by}}&$top={{max_records}}\n\`\`\`\n\n` +
+        `### Common Filter Examples\n` +
+        `- Equals: \`name eq 'Contoso'\`\n` +
+        `- Contains: \`contains(name, 'Contoso')\`\n` +
+        `- Greater than date: \`createdon gt 2023-01-01T00:00:00Z\`\n` +
+        `- Multiple conditions: \`name eq 'Contoso' and statecode eq 0\``,
+    // Relationship exploration prompts
+    RELATIONSHIP_MAP: (entityName) => `## Relationship Map for ${entityName}\n\n` +
+        `This shows all relationships for the '${entityName}' entity:\n\n` +
+        `### One-to-Many Relationships (${entityName} as Primary)\n{{one_to_many_primary}}\n\n` +
+        `### One-to-Many Relationships (${entityName} as Related)\n{{one_to_many_related}}\n\n` +
+        `### Many-to-Many Relationships\n{{many_to_many}}\n\n`,
+};

package/build/services/EntityService.js

@@ -0,0 +1,128 @@
+/**
+ * Service for entity metadata operations.
+ * Handles entity definitions, attributes, and relationships.
+ */
+export class EntityService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get metadata about an entity
+     * @param entityName The logical name of the entity
+     */
+    async getEntityMetadata(entityName) {
+        const response = await this.client.get(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')`);
+        // Remove Privileges property if it exists
+        if (response && typeof response === 'object' && 'Privileges' in response) {
+            delete response.Privileges;
+        }
+        return response;
+    }
+    /**
+     * Get metadata about entity attributes/fields
+     * @param entityName The logical name of the entity
+     */
+    async getEntityAttributes(entityName) {
+        const selectProperties = [
+            'LogicalName',
+        ].join(',');
+        // Make the request to get attributes
+        const response = await this.client.get(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')/Attributes?$select=${selectProperties}&$filter=AttributeType ne 'Virtual'`);
+        if (response && response.value) {
+            // First pass: Filter out attributes that end with 'yominame'
+            response.value = response.value.filter((attribute) => {
+                const logicalName = attribute.LogicalName || '';
+                return !logicalName.endsWith('yominame');
+            });
+            // Filter out attributes that end with 'name' if there is another attribute with the same name without the 'name' suffix
+            const baseNames = new Set();
+            const namesAttributes = new Map();
+            for (const attribute of response.value) {
+                const logicalName = attribute.LogicalName || '';
+                if (logicalName.endsWith('name') && logicalName.length > 4) {
+                    const baseName = logicalName.slice(0, -4); // Remove 'name' suffix
+                    namesAttributes.set(baseName, attribute);
+                }
+                else {
+                    // This is a potential base attribute
+                    baseNames.add(logicalName);
+                }
+            }
+            // Find attributes to remove that match the pattern
+            const attributesToRemove = new Set();
+            for (const [baseName, nameAttribute] of namesAttributes.entries()) {
+                if (baseNames.has(baseName)) {
+                    attributesToRemove.add(nameAttribute);
+                }
+            }
+            response.value = response.value.filter(attribute => !attributesToRemove.has(attribute));
+        }
+        return response;
+    }
+    /**
+     * Get metadata about a specific entity attribute/field
+     * @param entityName The logical name of the entity
+     * @param attributeName The logical name of the attribute
+     */
+    async getEntityAttribute(entityName, attributeName) {
+        return this.client.get(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')/Attributes(LogicalName='${attributeName}')`);
+    }
+    /**
+     * Get one-to-many relationships for an entity
+     * @param entityName The logical name of the entity
+     */
+    async getEntityOneToManyRelationships(entityName) {
+        const selectProperties = [
+            'SchemaName',
+            'RelationshipType',
+            'ReferencedAttribute',
+            'ReferencedEntity',
+            'ReferencingAttribute',
+            'ReferencingEntity',
+            'ReferencedEntityNavigationPropertyName',
+            'ReferencingEntityNavigationPropertyName'
+        ].join(',');
+        // Only filter by ReferencingAttribute in the OData query since startswith isn't supported
+        const response = await this.client.get(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')/OneToManyRelationships?$select=${selectProperties}&$filter=ReferencingAttribute ne 'regardingobjectid'`);
+        // Filter the response to exclude relationships with ReferencingEntity starting with 'msdyn_' or 'adx_'
+        if (response && response.value) {
+            response.value = response.value.filter((relationship) => {
+                const referencingEntity = relationship.ReferencingEntity || '';
+                return !(referencingEntity.startsWith('msdyn_') || referencingEntity.startsWith('adx_'));
+            });
+        }
+        return response;
+    }
+    /**
+     * Get many-to-many relationships for an entity
+     * @param entityName The logical name of the entity
+     */
+    async getEntityManyToManyRelationships(entityName) {
+        const selectProperties = [
+            'SchemaName',
+            'RelationshipType',
+            'Entity1LogicalName',
+            'Entity2LogicalName',
+            'Entity1IntersectAttribute',
+            'Entity2IntersectAttribute',
+            'Entity1NavigationPropertyName',
+            'Entity2NavigationPropertyName'
+        ].join(',');
+        return this.client.get(`api/data/v9.2/EntityDefinitions(LogicalName='${entityName}')/ManyToManyRelationships?$select=${selectProperties}`);
+    }
+    /**
+     * Get all relationships (one-to-many and many-to-many) for an entity
+     * @param entityName The logical name of the entity
+     */
+    async getEntityRelationships(entityName) {
+        const [oneToMany, manyToMany] = await Promise.all([
+            this.getEntityOneToManyRelationships(entityName),
+            this.getEntityManyToManyRelationships(entityName)
+        ]);
+        return {
+            oneToMany,
+            manyToMany
+        };
+    }
+}

package/build/services/OptionSetService.js

@@ -0,0 +1,18 @@
+/**
+ * Service for option set operations.
+ * Handles global option set definitions.
+ */
+export class OptionSetService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a global option set definition by name
+     * @param optionSetName The name of the global option set
+     * @returns The global option set definition
+     */
+    async getGlobalOptionSet(optionSetName) {
+        return this.client.get(`api/data/v9.2/GlobalOptionSetDefinitions(Name='${optionSetName}')`);
+    }
+}