Dataverse MCP Server

Dataverse MCP Server

A Model Context Protocol (MCP) server for Microsoft Dataverse that enables schema operations including creating and updating tables, columns, relationships, and option sets using the Dataverse Web API.

🚀 Key Features

✅ Manage Tables & Columns - Create, update, delete, and list custom tables with all column types (String, Integer, Boolean, DateTime, Picklist, Lookup, etc.)

✅ Manage Relationships - Create One-to-Many and Many-to-Many relationships between entities with proper cascade behaviors

✅ Manage Option Sets - Create and manage global option sets with custom options, colors, and values

✅ Solution-Based Architecture - Enterprise-grade solution management with persistent context and automatic customization prefixes

✅ Security & Access Control - Complete security role management, team operations, and business unit hierarchy management

✅ WebAPI Call Generator - Generate ready-to-use HTTP requests, cURL commands, and JavaScript code for any Dataverse operation

✅ PowerPages WebAPI Generator - Generate PowerPages-specific WebAPI calls using the /_api/[logicalEntityName] format with React examples

✅ PowerPages Configuration Management - Manage table permissions and WebAPI site settings for PowerPages Code Sites with YAML file automation

✅ Schema Export - Export complete solution schemas to JSON with filtering options for documentation and backup

✅ Professional Integration - OAuth2 authentication, comprehensive error handling, and enterprise-ready deployment

Table of Contents

• Features
  • Table Operations
  • Column Operations
  • Relationship Operations
  • Option Set Operations
  • Solution & Publisher Operations
  • Security Role Operations
  • Team Operations
  • Business Unit Operations
  • Schema Export Operations
  • WebAPI Call Generator
  • PowerPages WebAPI Generator
  • PowerPages Configuration Management
• Solution-Based Architecture
  • Key Benefits
  • Solution Workflow
  • Example: XYZ Organization Setup
  • Persistent Solution Context
• Supported Column Types
  • Column Type Details
  • Tested Column Scenarios
  • Column Operations Status
• Prerequisites
• Setup
  • 1. Azure App Registration
  • 2. Create Client Secret
  • 3. Create Application User in Dataverse
  • 4. Get Required Information
• Installation
• Configuration
  • Option 1: Using .env file (Recommended for Development)
  • Option 2: Using MCP environment variables (Recommended for Production)
  • Option 3: Hybrid Configuration
• Usage Examples
  • Creating a Custom Table
  • Adding Columns to a Table
  • Creating Relationships
  • Managing Option Sets
  • Managing Security Roles
  • Managing Teams
  • Managing Business Units
• Authentication
• Error Handling
• Security Considerations
• Troubleshooting
  • Common Issues
  • Debug Mode
• API Reference
• Solution Management Best Practices
  • Publisher Configuration
  • Solution Context Management
  • Environment Promotion
  • Git Integration
• Contributing
• Releasing
  • Creating a Release
  • Automated GitHub Releases
  • Manual Release Process
• Changelog
• License
• Support

Features

This MCP server provides comprehensive tools for Dataverse schema management:

Table Operations

• create_dataverse_table - Create new custom tables
• get_dataverse_table - Retrieve table metadata
• update_dataverse_table - Update table properties
• delete_dataverse_table - Delete custom tables
• list_dataverse_tables - List tables with filtering options

Column Operations

• create_dataverse_column - Create columns of various types (see Supported Column Types below)
• get_dataverse_column - Retrieve column metadata
• update_dataverse_column - Update column properties
• delete_dataverse_column - Delete custom columns
• list_dataverse_columns - List columns for a table

Relationship Operations

• create_dataverse_relationship - Create One-to-Many or Many-to-Many relationships
• get_dataverse_relationship - Retrieve relationship metadata
• delete_dataverse_relationship - Delete custom relationships
• list_dataverse_relationships - List relationships with filtering

Option Set Operations

• create_dataverse_optionset - Create global option sets
• get_dataverse_optionset - Retrieve option set metadata
• update_dataverse_optionset - Update option sets (add/update/remove options)
• delete_dataverse_optionset - Delete custom option sets
• list_dataverse_optionsets - List option sets
• get_dataverse_optionset_options - Get options for a specific option set

Solution & Publisher Operations

• create_dataverse_publisher - Create custom publishers with prefixes
• get_dataverse_publisher - Retrieve publisher metadata
• list_dataverse_publishers - List publishers with filtering
• create_dataverse_solution - Create solutions linked to publishers
• get_dataverse_solution - Retrieve solution metadata
• list_dataverse_solutions - List solutions with publisher details
• set_solution_context - Set active solution for schema operations
• get_solution_context - View current solution context
• clear_solution_context - Remove solution context

Security Role Operations

• create_dataverse_role - Create new security roles
• get_dataverse_role - Retrieve security role metadata
• update_dataverse_role - Update security role properties
• delete_dataverse_role - Delete custom security roles
• list_dataverse_roles - List security roles with filtering options
• add_privileges_to_role - Add privileges to a security role
• remove_privilege_from_role - Remove privileges from a security role
• replace_role_privileges - Replace all privileges for a security role
• get_role_privileges - Retrieve all privileges for a security role
• assign_role_to_user - Assign security roles to users
• remove_role_from_user - Remove security roles from users
• assign_role_to_team - Assign security roles to teams
• remove_role_from_team - Remove security roles from teams

Team Operations

• create_dataverse_team - Create new teams with various types and configurations
• get_dataverse_team - Retrieve team metadata and details
• update_dataverse_team - Update team properties and settings
• delete_dataverse_team - Delete teams
• list_dataverse_teams - List teams with filtering options
• add_members_to_team - Add users as team members
• remove_members_from_team - Remove users from teams
• get_team_members - Retrieve all members of a team
• convert_owner_team_to_access_team - Convert owner teams to access teams

Business Unit Operations

• create_dataverse_businessunit - Create new business units with comprehensive address and contact information
• get_dataverse_businessunit - Retrieve business unit metadata and details
• update_dataverse_businessunit - Update business unit properties, addresses, and settings
• delete_dataverse_businessunit - Delete business units
• list_dataverse_businessunits - List business units with filtering and sorting options
• get_businessunit_hierarchy - Retrieve the hierarchical structure of business units
• set_businessunit_parent - Change the parent business unit in the hierarchy
• get_businessunit_users - Get users associated with a business unit (with subsidiary option)
• get_businessunit_teams - Get teams associated with a business unit (with subsidiary option)

Schema Export Operations

• export_solution_schema - Export solution schema to JSON file including tables, columns, and global option sets. Supports filtering by customization prefix to export only solution-specific entities. Note: Relationship export is not yet implemented.

WebAPI Call Generator

• generate_webapi_call - Generate complete WebAPI calls for Dataverse operations including URLs, headers, and request bodies. Supports all major operations (retrieve, create, update, delete, associate, disassociate, actions, functions) with OData query options and provides output in multiple formats (HTTP, cURL, JavaScript fetch).

PowerPages WebAPI Generator

• generate_powerpages_webapi_call - Generate PowerPages-specific WebAPI calls using the /_api/[logicalEntityName] format. Includes request verification token handling, authentication context, React component examples, and PowerPages-specific features for SPA development.

PowerPages Configuration Management

• manage_powerpages_webapi_config - Manage table permissions and WebAPI site settings for PowerPages Code Sites. Automates YAML configuration files in .powerpages-site directory including sitesetting.yml, webrole.yml, and table-permissions/*.yml files with comprehensive status checking and configuration management.

Solution-Based Architecture

The MCP server implements enterprise-grade solution management following Microsoft Dataverse best practices.

Key Benefits

• Professional Schema Naming: Uses publisher-based customization prefixes
• Solution Association: All schema changes are automatically associated with the active solution
• ALM Support: Enables proper solution packaging and deployment across environments
• Persistent Context: Solution context survives server restarts via .mcp-dataverse file
• Enterprise Governance: Supports multiple publishers and solutions with proper isolation

Solution Workflow

1. Create Publisher: Define your organization's customization prefix
2. Create Solution: Link solution to publisher for schema organization
3. Set Context: Activate solution for subsequent operations
4. Create Schema: All tables, columns, and option sets use the publisher's prefix automatically
5. Deploy: Export solution for deployment to other environments

Example: XYZ Organization Setup

Persistent Solution Context

The server automatically persists solution context to a .mcp-dataverse file in the project root:

Benefits of Persistence:

• No Context Loss: Solution context survives server restarts
• Instant Productivity: Developers can immediately continue work
• Consistent Prefixes: No need to remember and re-set solution context
• Team Isolation: Each developer can have their own solution context (file is git-ignored)

Supported Column Types

The MCP server supports all major Dataverse column types with comprehensive configuration options. The following table shows implementation status and testing verification:

Column Type Details

String Columns ✅ Tested

• Formats: Email, Text, TextArea, Url, Phone
• Max Length: Configurable (default: 100)
• Default Values: Supported
• Example: Employee name, email address, phone number

Integer Columns ✅ Tested

• Constraints: Min/max value validation
• Default Values: Supported
• Example: Age, quantity, score with range 0-100

Boolean Columns ✅ Tested

• Custom Labels: Configurable true/false option labels
• Default Values: Supported
• Example: "Active/Inactive", "Yes/No", "Enabled/Disabled"

DateTime Columns ✅ Tested

• DateOnly: Date without time component (e.g., hire date, birthday)
• DateAndTime: Full timestamp with timezone handling (e.g., last login, created date)
• Behavior: Uses UserLocal timezone behavior

Picklist Columns ✅ Tested

• Local Option Sets: Create inline options with the column
• Global Option Sets: Reference existing global option sets by name
• Color Support: Options can have associated colors
• Example: Status (Active, Inactive), Priority (High, Medium, Low)

Lookup Columns ✅ Tested

• Target Entity: Specify which table to reference
• Relationships: Automatically creates underlying relationship
• Example: Customer lookup, Account reference

Tested Column Scenarios

The following specific scenarios have been successfully tested and verified:

1. String Column Creation ✅
   • Basic text field with default settings
   • Email format validation
   • Custom max length constraints
2. Integer Column Creation ✅
   • Numeric field with min/max constraints (0-100 range)
   • Default value assignment
3. Boolean Column Creation ✅
   • Custom true/false labels ("Active"/"Inactive")
   • Default value configuration
4. DateTime Column Creation ✅
   • DateOnly format for hire dates
   • DateAndTime format for login timestamps
5. Picklist Column Creation ✅
   • Local option set with custom options
   • Global option set reference using existing "Colors" option set
6. Lookup Column Creation ✅
   • Cross-table reference (MCP Test 2 → MCP Test)
   • Automatic relationship creation

Column Operations Status

Prerequisites

1. Dataverse Environment - You need access to a Microsoft Dataverse environment
2. Azure App Registration - An Azure AD app registration with appropriate permissions
3. Client Credentials - Client ID, Client Secret, and Tenant ID for authentication

Setup

1. Azure App Registration

1. Go to the Azure Portal
2. Navigate to Azure Active Directory > App registrations
3. Click New registration
4. Provide a name (e.g., "Dataverse MCP Server")
5. Select Accounts in this organizational directory only
6. Click Register

2. Create Client Secret

1. Go to Certificates & secrets
2. Click New client secret
3. Provide a description and expiration
4. Click Add
5. Copy the secret value immediately (you won't be able to see it again)

3. Create Application User in Dataverse

Critical Step: You must create an Application User in your Dataverse environment and assign appropriate permissions.

1. Navigate to Dataverse Admin Center
   • Go to Power Platform Admin Center
   • Select your environment
   • Go to Settings > Users + permissions > Application users
2. Create Application User
   • Click + New app user
   • Click + Add an app
   • Search for and select your Azure app registration (by Client ID)
   • Enter a Business unit (usually the root business unit)
   • Click Create
3. Assign Security Roles
   • Select the newly created application user
   • Click Manage roles
   • Assign appropriate security roles based on your needs:
     • System Administrator: Full access (recommended for development/testing)
     • System Customizer: Schema operations without data access
     • Custom Role: Create specific permissions for production use
4. Verify Application User Status
   • Ensure the application user is Enabled
   • Verify it shows as Application type (not User)
   • Note the Application ID matches your Azure app registration Client ID

4. Get Required Information

You'll need:

• Tenant ID: Found in Azure AD > Overview
• Client ID: Found in your app registration > Overview
• Client Secret: The secret you just created
• Dataverse URL: Your Dataverse environment URL (e.g., https://yourorg.crm.dynamics.com)

Installation

1. Install dependencies:

2. Build the server:

3. Copy the full path to the built index.js file:
   • The server will be built to the build/ directory
   • Copy the complete file path (e.g., /Users/yourname/path/to/mcp-dataverse/build/index.js)
   • You'll use this path in your MCP configuration file
4. Configure the MCP server in your MCP settings file using the copied path (see Configuration section below for details)

Configuration

The server supports flexible environment variable configuration with the following precedence (highest to lowest):

1. MCP environment variables (highest priority)
2. System environment variables
3. .env file variables (lowest priority)

Option 1: Using .env file (Recommended for MCP Server Development)

The server automatically loads environment variables from a .env file in the project root. This is the recommended approach when contributing to or modifying the MCP server itself.

1. Create your .env file:

2. Add the following configuration to your MCP settings file:

Note: The timeout setting is increased to 900 seconds (15 minutes) to accommodate longer-running operations like schema export, which may need to process large amounts of metadata.

Option 2: Using MCP environment variables (Recommended for Normal Usage)

You can configure environment variables directly in the MCP settings. This is the recommended approach for normal usage when using the MCP Dataverse tool for development activities. These will override any values in the .env file:

Option 3: Hybrid Configuration

You can also use a combination approach where common settings are in .env and sensitive or environment-specific settings are overridden via MCP:

.env file:

MCP settings (overrides for production):

Usage Examples

Creating a Custom Table

Important: Before creating tables, ensure you have set a solution context using set_solution_context to provide the customization prefix. The system automatically uses the prefix from the active solution's publisher.

Adding Columns to a Table

Creating Relationships

Managing Option Sets

Managing Security Roles

Managing Teams

Managing Business Units

Exporting Solution Schema

Schema Export Features:

• Schema Capture: Exports tables, columns, and global option sets (relationships not yet implemented)
• Flexible Filtering: Choose to include or exclude system entities
• Solution Context Aware: Automatically includes solution metadata when context is set
• Comprehensive Metadata: Captures all entity properties and column types
• JSON Format: Human-readable or minified output options
• Directory Creation: Automatically creates output directories if they don't exist

Example Output Structure:

Note: Relationship export functionality is planned for a future release.

WebAPI Call Generator

The WebAPI Call Generator tool helps developers construct proper Dataverse WebAPI calls by generating complete HTTP requests with correct URLs, headers, and request bodies. This is particularly useful for:

• Learning WebAPI syntax - See how different operations translate to HTTP calls
• Debugging API issues - Generate reference calls to compare against your implementation
• Documentation - Create examples for team members or API documentation
• Testing - Get ready-to-use cURL commands and JavaScript fetch examples

Output Features:

• Complete HTTP Request: Method, URL, headers, and body
• cURL Command: Ready-to-execute command-line example
• JavaScript Fetch: Copy-paste JavaScript code
• Solution Context: Automatically includes current solution headers
• Authentication Placeholder: Optional Bearer token placeholder
• OData Query Building: Proper encoding of complex filter expressions

Example Output:

Supported Operations:

• retrieve - Get a single record by ID
• retrieveMultiple - Query multiple records with OData
• create - Create new records
• update - Update existing records (PATCH)
• delete - Delete records
• associate - Create relationships between records
• disassociate - Remove relationships between records
• callAction - Execute Dataverse actions (bound/unbound)
• callFunction - Execute Dataverse functions (bound/unbound)

Advanced Features:

• OData Query Options: $select, $filter, $orderby, $top, $skip, $expand, $count
• Prefer Headers: return=representation, odata.include-annotations=*
• Conditional Updates: If-Match, If-None-Match headers
• Impersonation: MSCRMCallerID header support
• Solution Context: Automatic MSCRM.SolutionUniqueName header inclusion

PowerPages WebAPI Generator

The PowerPages WebAPI Generator creates API calls specifically for PowerPages Single Page Applications (SPAs) using the PowerPages WebAPI format /_api/[logicalEntityName]s. This tool is designed for developers building modern React, Angular, or Vue applications within PowerPages environments.

Key Differences from Standard Dataverse WebAPI:

• URL Format: Uses /_api/[logicalEntityName]s instead of /api/data/v9.2/[entitySetName] (note: 's' suffix is automatically added)
• Authentication: Integrates with PowerPages authentication context and request verification tokens
• Client-Side Focus: Optimized for browser-based applications with React component examples
• PowerPages Security: Respects PowerPages table permissions and web roles

Output Features:

• PowerPages URL Format: Correct /_api/[logicalEntityName]s endpoint construction (automatic 's' suffix)
• Request Verification Token: Automatic token handling for POST/PATCH/DELETE operations
• JavaScript Examples: Ready-to-use fetch code with error handling
• React Components: Complete React hook examples for data fetching
• Authentication Context: PowerPages user context and token management
• OData Query Support: Full OData query parameter support with proper encoding

Example Output:

React Component Example:

Authentication Context Integration:

PowerPages-Specific Features:

• Request Verification Token: Automatic __RequestVerificationToken header handling for secure operations
• Authentication Integration: Built-in PowerPages user context access
• React-Ready: Complete React component examples with hooks and state management
• Error Handling: Comprehensive error handling patterns for PowerPages environments
• Security Compliance: Respects PowerPages table permissions and web role security
• SPA Optimization: Designed for single-page application development patterns

Supported Operations:

• retrieve - Get a single record by ID
• retrieveMultiple - Query multiple records with OData filtering
• create - Create new records with request verification token
• update - Update existing records (PATCH) with token handling
• delete - Delete records with proper authentication

This tool is essential for PowerPages developers building modern SPAs that need to interact with Dataverse data while maintaining PowerPages security and authentication patterns.

PowerPages Configuration Management

The manage_powerpages_webapi_config tool helps manage table permissions and WebAPI site settings for PowerPages Code Sites. It automates the configuration of YAML files in the .powerpages-site directory structure, making it easier to set up and maintain WebAPI access for your PowerPages applications.

Key Features

• Automated YAML Management: Creates and updates sitesetting.yml, webrole.yml, and table permission files
• WebAPI Configuration: Enables WebAPI access with proper site settings
• Table Permissions: Manages granular permissions for specific tables and web roles
• Status Checking: Provides comprehensive status of current configurations
• PowerPages Code Site Integration: Works seamlessly with the .powerpages-site directory structure

Usage Examples

Check Configuration Status

Sample Output:

Enable WebAPI for a Table

Result:

• Updates .powerpages-site/sitesetting.yml with WebAPI settings
• Enables WebAPI access for the specified table
• Configures allowed fields for WebAPI operations

Create Table Permissions

Result:

• Creates .powerpages-site/table-permissions/cr7ae_creditcardses_authenticated_users.yml
• Configures specific CRUD permissions for the web role
• Sets appropriate scope (Global, Contact, Account, Self, Parent, etc.)

List Current Configurations

Sample Output:

Operations

status

Provides a comprehensive overview of the current PowerPages WebAPI configuration including:

• WebAPI enablement status for tables
• Configured fields and permissions
• Web role definitions
• Table permission summaries

configure-webapi

Enables or configures WebAPI access for specific tables:

• tableName (required): Logical name of the table
• fields (optional): Array of field names to allow in WebAPI calls
• enabled (optional): Boolean to enable/disable WebAPI access

create-table-permission

Creates granular table permissions for web roles:

• tableName (required): Logical name of the table
• webRoleName (required): Name of the web role
• permissions (required): Object with read, create, write, delete boolean values
• scope (optional): Permission scope (Global, Contact, Account, Self, Parent, etc.)

list-configurations

Lists all current configurations including:

• Site settings with their values
• Web roles with IDs
• Table permissions with detailed permission breakdown

PowerPages Code Site Integration

This tool is designed to work with PowerPages Code Sites that follow the standard directory structure:

Example Workflow

1. Check Current Status:
   {"operation": "status"}
2. Enable WebAPI for Your Custom Table:
   { "operation": "configure-webapi", "tableName": "cr7ae_creditcardses", "fields": ["cr7ae_name", "cr7ae_type", "cr7ae_limit"], "enabled": true }
3. Create Table Permissions:
   { "operation": "create-table-permission", "tableName": "cr7ae_creditcardses", "webRoleName": "Authenticated Users", "permissions": { "read": true, "create": true, "write": true, "delete": false }, "scope": "Global" }
4. Verify Configuration:
   {"operation": "list-configurations"}
5. Use with PowerPages WebAPI Generator:
   { "operation": "retrieveMultiple", "logicalEntityName": "cr7ae_creditcardses", "select": ["cr7ae_name", "cr7ae_type", "cr7ae_limit"] }

This workflow ensures your PowerPages Code Site is properly configured to handle WebAPI calls for your custom tables with appropriate security permissions.

Authentication

The server uses Client Credentials flow (Server-to-Server authentication) with Azure AD. This provides:

• Secure authentication without user interaction
• Application-level permissions
• Suitable for automated scenarios
• Token refresh handling

Error Handling

The server includes comprehensive error handling:

• Authentication errors - Invalid credentials or expired tokens
• API errors - Dataverse-specific error messages with codes
• Validation errors - Parameter validation and type checking
• Network errors - Connection and timeout handling

Security Considerations

1. Store secrets securely - Never commit client secrets to version control
2. Use environment variables - Configure secrets through environment variables
3. Principle of least privilege - Grant only necessary permissions
4. Monitor usage - Track API calls and authentication attempts
5. Rotate secrets regularly - Update client secrets periodically

Troubleshooting

Common Issues

1. Authentication Failed
   • Verify client ID, secret, and tenant ID
   • Check that the app registration is properly configured
2. Permission Denied
   • Verify Application User Exists: Check that an application user has been created in Dataverse for your app registration
   • Check Security Roles: Ensure the application user has appropriate security roles:
     • System Administrator: Required for full schema operations
     • System Customizer: Minimum for table/column operations
     • Environment Maker: May be needed for solution operations
   • Verify User Status: Ensure the application user is enabled and not disabled
   • Check Business Unit: Verify the application user is assigned to the correct business unit
   • Validate Client ID: Confirm the Application ID in Dataverse matches your Azure app registration Client ID
3. Entity Not Found
   • Verify entity logical names are correct
   • Check if entities exist in the target environment
4. Invalid Column Type
   • Review supported column types in the documentation
   • Verify required parameters for specific column types

Debug Mode

Set environment variable DEBUG=true for verbose logging:

API Reference

For detailed parameter information for each tool, refer to the tool definitions in the source code:

• src/tools/table-tools.ts - Table operations
• src/tools/column-tools.ts - Column operations
• src/tools/relationship-tools.ts - Relationship operations
• src/tools/optionset-tools.ts - Option set operations
• src/tools/solution-tools.ts - Solution and publisher operations
• src/tools/role-tools.ts - Security role operations
• src/tools/team-tools.ts - Team operations
• src/tools/businessunit-tools.ts - Business unit operations
• src/tools/schema-tools.ts - Schema export operations
• src/tools/webapi-tools.ts - WebAPI call generator operations
• src/tools/powerpages-webapi-tools.ts - PowerPages WebAPI call generator operations
• src/tools/powerpages-config-tools.ts - PowerPages configuration management operations

Solution Management Best Practices

Publisher Configuration

When creating publishers, follow these guidelines:

• Unique Prefixes: Use 2-8 character prefixes that identify your organization
• Option Value Ranges: Use non-overlapping ranges (e.g., 10000-19999 for one publisher, 20000-29999 for another)
• Descriptive Names: Use clear, professional names for publishers and solutions

Solution Context Management

Environment Promotion

1. Development: Create and test schema changes in dev environment with solution context
2. Export: Use Power Platform CLI or admin center to export solution
3. Import: Deploy solution to test/production environments
4. Validation: Verify all customizations use proper prefixes

Git Integration

The .mcp-dataverse file is automatically excluded from version control:

This allows each developer to maintain their own solution context while preventing accidental sharing of environment-specific settings.

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

Changelog

For a detailed history of changes, new features, and bug fixes, see the CHANGELOG.md file.

Recent Updates

• v0.1.2: Added comprehensive Security Role Management system with 13 new tools
• v0.1.1: Introduced Solution-Based Architecture with persistent context
• v0.1.0: Initial release with core table, column, relationship, and option set operations

The changelog follows Keep a Changelog format and includes:

• Added: New features and capabilities
• Changed: Modifications to existing functionality
• Fixed: Bug fixes and corrections
• Security: Security-related updates

Releasing

This project includes automated release scripts for maintainers:

Creating a Release

These scripts will:

1. Build the project
2. Bump the version in package.json
3. Create a git tag
4. Push the changes and tag to GitHub

Automated GitHub Releases

When a tag is pushed to GitHub, the GitHub Actions workflow will automatically:

1. Build the project
2. Create release archives (.tar.gz and .zip)
3. Create a GitHub release with the archives attached
4. Include installation instructions in the release notes

Manual Release Process

If you prefer to create releases manually:

1. Build the project: npm run build
2. Update version: npm version [patch|minor|major]
3. Push changes: git push && git push --tags
4. The GitHub Actions workflow will handle the rest

License

MIT License - see LICENSE file for details.

Support

For issues and questions:

1. Check the troubleshooting section
2. Review Dataverse Web API documentation
3. Create an issue in the repository