@microsoft/power-apps 1.0.0

package/lib/internal/data/core/data/dataverseDataOperation.d.ts

@@ -0,0 +1,164 @@
+/*!
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+import { IRuntimeClientProvider, IXrmContext } from '../common/types';
+import { IDataOperation, IDataSourceInfo, IOperationResult } from '../types';
+import { RuntimeDataSourceService } from '../metadata/runtimeDataSourceService';
+export declare const ODATA_CONTEXT = "@odata.context";
+export declare const ODATA_NEXT_LINK = "@odata.nextLink";
+export declare const CRM_TOTAL_RECORD_COUNT = "@Microsoft.Dynamics.CRM.totalrecordcount";
+export declare const CRM_TOTAL_RECORD_COUNT_LIMIT_EXCEEDED = "@Microsoft.Dynamics.CRM.totalrecordcountlimitexceeded";
+export declare const CRM_GLOBAL_METADATA_VERSION = "@Microsoft.Dynamics.CRM.globalmetadataversion";
+/**
+ * DataverseDataOperation provides functionality for performing CRUD operations
+ * against the Dataverse data source using the XRM WebApi or runtime metadata client.
+ */
+export declare class DataverseDataOperation {
+    private readonly _xrm;
+    private readonly _dataverseDataSourceService;
+    private readonly _clientProvider;
+    private _databaseReferences;
+    constructor(xrm: IXrmContext, dataverseDataSourceService: RuntimeDataSourceService, clientProvider: IRuntimeClientProvider);
+    /**
+     * Creates a new record in Dataverse
+     * @param tableName - The name of the table
+     * @param data - The record data to create
+     * @returns Promise resolving to operation result
+     */
+    createRecordAsync<TRequest, TResponse>(tableName: string, data: TRequest): Promise<IOperationResult<TResponse>>;
+    /**
+     * Updates an existing record in Dataverse
+     * @param tableName - The name of the table
+     * @param id - The record identifier
+     * @param data - The updated record data
+     * @returns Promise resolving to operation result
+     */
+    updateRecordAsync<TRequest, TResponse>(tableName: string, id: string, data: TRequest): Promise<IOperationResult<TResponse>>;
+    /**
+     * Deletes a record from Dataverse
+     * @param tableName - The name of the table
+     * @param id - The record identifier
+     * @returns Promise resolving to operation result
+     */
+    deleteRecordAsync(tableName: string, id: string): Promise<IOperationResult<void>>;
+    /**
+     * Retrieves a single record from Dataverse
+     * @param tableName - The name of the table
+     * @param id - The record identifier
+     * @param options - The retrieval options
+     * @returns Promise resolving to operation result
+     */
+    retrieveRecordAsync<TResponse>(tableName: string, id: string, options: string, maxPageSize?: number): Promise<IOperationResult<TResponse>>;
+    /**
+     * Retrieves multiple records from Dataverse
+     * @param tableName - The name of the table
+     * @param options - The retrieval options
+     * @param maxPageSize - Optional maximum page size
+     * @returns Promise resolving to operation result
+     */
+    retrieveMultipleRecordsAsync<TResponse>(tableName: string, options: string, maxPageSize?: number): Promise<IOperationResult<TResponse[]>>;
+    /**
+     * Executes a custom Dataverse operation
+     * @param operation - The operation to execute
+     * @returns Promise resolving to operation result
+     */
+    executeAsync<TRequest, TResponse>(operation: IDataOperation<TRequest>): Promise<IOperationResult<TResponse>>;
+    /**
+     * Returns the database references for Dataverse, grouped by environment/database.
+     * These come from the launch app response via runtime metadata client.
+     */
+    getDatabaseReferences(): Promise<DatabaseReferences>;
+    /**
+     * Loads database references from runtime metadata client (launch app response).
+     */
+    private _loadDatabaseReferencesFromRuntime;
+    private _extractInstanceUrlFromRuntimeUrl;
+    /**
+     * Validates operation parameters
+     * @param params - The parameters to validate
+     * @throws Error if validation fails
+     */
+    private _validateParams;
+    /**
+     * Creates a success result object
+     * @param data - The response data
+     * @param totalCount - Optional total count for multiple record operations
+     * @returns IDataOperationResult with success status
+     */
+    private _createSuccessResult;
+    /**
+     * Helper to check if XRM context is present and valid
+     */
+    private _hasCrm;
+    /**
+     * Helper to get a native data client and database reference
+     */
+    private _getDataClient;
+    /**
+     * Gets the metadata client instance
+     */
+    private _getMetadataClient;
+    /**
+     * Template method for connector-style CRUD operations to reduce duplication.
+     * Handles client, dataSourceInfo, requestUrl, and error handling.
+     */
+    private _executeNativeDataverseOperation;
+    /**
+     * Helper to get the Dataverse datasourceinfo from databaseReferences
+     */
+    private _getDataverseDataSourceInfo;
+    /**
+     * Helper to construct the Dataverse API URL using instanceUrl if available, otherwise fallback to runtimeUrl.
+     */
+    private _getDataverseRequestUrl;
+}
+export interface ILinkedEnvironmentMetadata {
+    resourceId: string;
+    friendlyName: string;
+    uniqueName: string;
+    domainName: string;
+    version: string;
+    instanceUrl: string;
+    instanceApiUrl: string;
+    baseLanguage: number;
+    instanceState: string;
+    createdTime: string;
+    platformSku: string;
+}
+export interface DataverseDataSourceInfo extends IDataSourceInfo {
+    datasetName: string;
+    referenceType?: string;
+    linkedEnvironmentMetadata?: ILinkedEnvironmentMetadata;
+    entitySetName?: string;
+    logicalName?: string;
+    isHidden?: boolean;
+}
+interface IDatabaseReference {
+    databaseDetails: {
+        referenceType: string;
+        environmentName: string;
+        overrideValues: {
+            status: string;
+            environmentVariableName: string;
+        };
+        linkedEnvironmentMetadata?: ILinkedEnvironmentMetadata;
+    };
+    dataSources: {
+        [dataSourceName: string]: {
+            entitySetName: string;
+            logicalName: string;
+            isHidden: boolean;
+        };
+    };
+}
+/**
+ * Extracts the skip token from the next link URL.
+ * @param nextLink - The @odata.nextLink URL containing the skip token
+ * @returns The extracted skip token or undefined if not found.
+ */
+export declare function extractSkipToken(nextLink: string | undefined): string | undefined;
+export type DatabaseReferences = {
+    [key: string]: IDatabaseReference;
+};
+export {};
+//# sourceMappingURL=dataverseDataOperation.d.ts.map

package/lib/internal/data/core/data/dataverseDataOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataverseDataOperation.d.ts","sourceRoot":"","sources":["../../../../../src/internal/data/core/data/dataverseDataOperation.ts"],"names":[],"mappings":"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"}

package/lib/internal/data/core/data/dataverseDataOperation.js

@@ -0,0 +1,508 @@
+/*!
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ */
+import { DataSources, HttpMethod, } from '../common/types';
+import { createErrorResponse, DataOperationErrorMessages, ErrorCodes, PowerDataRuntimeError, } from '../error/error';
+import { Log } from '../telemetry/log';
+import { DataverseOperationName } from '../error/constants';
+// OData annotation constants
+export const ODATA_CONTEXT = '@odata.context';
+export const ODATA_NEXT_LINK = '@odata.nextLink';
+export const CRM_TOTAL_RECORD_COUNT = '@Microsoft.Dynamics.CRM.totalrecordcount';
+export const CRM_TOTAL_RECORD_COUNT_LIMIT_EXCEEDED = '@Microsoft.Dynamics.CRM.totalrecordcountlimitexceeded';
+export const CRM_GLOBAL_METADATA_VERSION = '@Microsoft.Dynamics.CRM.globalmetadataversion';
+/**
+ * DataverseDataOperation provides functionality for performing CRUD operations
+ * against the Dataverse data source using the XRM WebApi or runtime metadata client.
+ */
+export class DataverseDataOperation {
+    // Static identifiers for services and actions
+    // Used to identify specific services and actions within the PowerApps environment
+    _xrm;
+    _dataverseDataSourceService;
+    _clientProvider;
+    _databaseReferences;
+    constructor(xrm, dataverseDataSourceService, clientProvider) {
+        this._xrm = xrm;
+        this._dataverseDataSourceService = dataverseDataSourceService;
+        this._clientProvider = clientProvider;
+    }
+    /**
+     * Creates a new record in Dataverse
+     * @param tableName - The name of the table
+     * @param data - The record data to create
+     * @returns Promise resolving to operation result
+     */
+    async createRecordAsync(tableName, data) {
+        if (this._hasCrm()) {
+            // XRM WebApi code path
+            try {
+                this._validateParams({ tableName, data });
+                const response = await this._xrm.WebApi.createRecord(tableName, data);
+                return this._createSuccessResult(response);
+            }
+            catch (error) {
+                Log.trackEvent('DataverseDataOperation.CreateRecordFailed', {
+                    message: '[DataverseDataOperation] Failed to create record',
+                    tableName,
+                    error,
+                });
+                return createErrorResponse(error, DataOperationErrorMessages.CreateFailed);
+            }
+        }
+        else {
+            return this._executeNativeDataverseOperation(tableName, (dataSourceInfo, tblName) => this._getDataverseRequestUrl(dataSourceInfo, tblName), async (dataClient, requestUrl, dataSourceInfo) => {
+                const dataverseResponse = await dataClient.createDataAsync(requestUrl, DataSources.Dataverse, // Use environment name for Dataverse authentication
+                tableName, data, {
+                    operationName: DataverseOperationName.CreateRecord,
+                    datasetName: dataSourceInfo.datasetName,
+                    isDataVerseOperation: true,
+                });
+                const returnValue = {
+                    success: dataverseResponse.success,
+                    data: dataverseResponse.data,
+                    error: dataverseResponse.error,
+                };
+                return returnValue;
+            }, DataOperationErrorMessages.CreateFailed);
+        }
+    }
+    /**
+     * Updates an existing record in Dataverse
+     * @param tableName - The name of the table
+     * @param id - The record identifier
+     * @param data - The updated record data
+     * @returns Promise resolving to operation result
+     */
+    async updateRecordAsync(tableName, id, data) {
+        if (this._hasCrm()) {
+            try {
+                this._validateParams({ tableName, id, data });
+                const response = await this._xrm.WebApi.updateRecord(tableName, id, data);
+                return this._createSuccessResult(response);
+            }
+            catch (error) {
+                Log.trackEvent('DataverseDataOperation.UpdateRecordFailed', {
+                    message: '[DataverseDataOperation] Failed to update record',
+                    tableName,
+                    id,
+                    error,
+                });
+                return createErrorResponse(error, DataOperationErrorMessages.UpdateFailed);
+            }
+        }
+        else {
+            return this._executeNativeDataverseOperation(tableName, (dataSourceInfo, tblName) => this._getDataverseRequestUrl(dataSourceInfo, tblName, `(${id})`), async (dataClient, requestUrl, dataSourceInfo) => {
+                const dataverseResponse = await dataClient.updateDataAsync(requestUrl, DataSources.Dataverse, tableName, data, {
+                    operationName: DataverseOperationName.UpdateRecord,
+                    datasetName: dataSourceInfo.datasetName,
+                    isDataVerseOperation: true,
+                });
+                const returnValue = {
+                    success: dataverseResponse.success,
+                    data: dataverseResponse.data,
+                    error: dataverseResponse.error,
+                };
+                return returnValue;
+            }, DataOperationErrorMessages.UpdateFailed);
+        }
+    }
+    /**
+     * Deletes a record from Dataverse
+     * @param tableName - The name of the table
+     * @param id - The record identifier
+     * @returns Promise resolving to operation result
+     */
+    async deleteRecordAsync(tableName, id) {
+        if (this._hasCrm()) {
+            try {
+                this._validateParams({ tableName, id });
+                await this._xrm.WebApi.deleteRecord(tableName, id);
+                return this._createSuccessResult(undefined);
+            }
+            catch (error) {
+                Log.trackEvent('DataverseDataOperation.DeleteRecordFailed', {
+                    message: '[DataverseDataOperation] Failed to delete record',
+                    tableName,
+                    id,
+                    error,
+                });
+                return createErrorResponse(error, DataOperationErrorMessages.DeleteFailed);
+            }
+        }
+        else {
+            return this._executeNativeDataverseOperation(tableName, (dataSourceInfo, tblName) => this._getDataverseRequestUrl(dataSourceInfo, tblName, `(${id})`), async (dataClient, requestUrl, dataSourceInfo) => {
+                const dataverseResponse = await dataClient.deleteDataAsync(requestUrl, DataSources.Dataverse, tableName, {
+                    operationName: DataverseOperationName.DeleteRecord,
+                    datasetName: dataSourceInfo.datasetName,
+                    isDataVerseOperation: true,
+                });
+                const returnValue = {
+                    success: dataverseResponse.success,
+                    data: dataverseResponse.data,
+                    error: dataverseResponse.error,
+                };
+                return returnValue;
+            }, DataOperationErrorMessages.DeleteFailed);
+        }
+    }
+    /**
+     * Retrieves a single record from Dataverse
+     * @param tableName - The name of the table
+     * @param id - The record identifier
+     * @param options - The retrieval options
+     * @returns Promise resolving to operation result
+     */
+    async retrieveRecordAsync(tableName, id, options, maxPageSize = 500 // Default max page size
+    ) {
+        if (this._hasCrm()) {
+            try {
+                this._validateParams({ tableName, id });
+                const response = await this._xrm.WebApi.retrieveRecord(tableName, id, options);
+                return this._createSuccessResult(response);
+            }
+            catch (error) {
+                Log.trackEvent('DataverseDataOperation.RetrieveRecordFailed', {
+                    message: '[DataverseDataOperation] Failed to retrieve record',
+                    tableName,
+                    id,
+                    options,
+                    error,
+                });
+                return createErrorResponse(error, DataOperationErrorMessages.RetrieveFailed);
+            }
+        }
+        else {
+            // Build Prefer header with updated maxPageSize
+            const headers = { Prefer: `odata.maxpagesize=${maxPageSize},odata.include-annotations=*` };
+            return this._executeNativeDataverseOperation(tableName, (dataSourceInfo, tblName) => this._getDataverseRequestUrl(dataSourceInfo, tblName, `/${id}${options}`), async (dataClient, requestUrl, dataSourceInfo) => {
+                const dataverseResponse = await dataClient.retrieveDataAsync(requestUrl, DataSources.Dataverse, tableName, HttpMethod.GET, headers, undefined, // No body for GET requests
+                {
+                    operationName: DataverseOperationName.RetrieveRecord,
+                    datasetName: dataSourceInfo.datasetName,
+                    isDataVerseOperation: true,
+                });
+                const returnValue = {
+                    success: dataverseResponse.success,
+                    data: dataverseResponse.data,
+                    error: dataverseResponse.error,
+                };
+                return returnValue;
+            }, DataOperationErrorMessages.RetrieveFailed);
+        }
+    }
+    /**
+     * Retrieves multiple records from Dataverse
+     * @param tableName - The name of the table
+     * @param options - The retrieval options
+     * @param maxPageSize - Optional maximum page size
+     * @returns Promise resolving to operation result
+     */
+    async retrieveMultipleRecordsAsync(tableName, options, maxPageSize = 500 // Default max page size,
+    ) {
+        if (this._hasCrm()) {
+            try {
+                this._validateParams({ tableName });
+                const response = await this._xrm.WebApi.retrieveMultipleRecords(tableName, options, maxPageSize);
+                return this._createSuccessResult(response);
+            }
+            catch (error) {
+                Log.trackEvent('DataverseDataOperation.RetrieveMultipleRecordsFailed', {
+                    message: '[DataverseDataOperation] Failed to retrieve multiple records',
+                    tableName,
+                    options,
+                    maxPageSize,
+                    error,
+                });
+                return createErrorResponse(error, DataOperationErrorMessages.RetrieveMultipleFailed);
+            }
+        }
+        else {
+            // Build Prefer header with updated maxPageSize
+            const headers = { Prefer: `odata.maxpagesize=${maxPageSize},odata.include-annotations=*` };
+            return this._executeNativeDataverseOperation(tableName, (dataSourceInfo, tblName) => this._getDataverseRequestUrl(dataSourceInfo, tblName, options), async (dataClient, requestUrl, dataSourceInfo) => {
+                const dataverseResponse = await dataClient.retrieveDataAsync(requestUrl, DataSources.Dataverse, tableName, HttpMethod.GET, headers, undefined, // No body for GET requests
+                {
+                    operationName: DataverseOperationName.RetrieveMultipleRecords,
+                    datasetName: dataSourceInfo.datasetName,
+                    isDataVerseOperation: true,
+                });
+                const returnValue = {
+                    success: dataverseResponse.success,
+                    data: dataverseResponse?.data?.value || [],
+                    skipToken: extractSkipToken(dataverseResponse?.data?.[ODATA_NEXT_LINK]),
+                    error: dataverseResponse.error,
+                };
+                return returnValue;
+            }, DataOperationErrorMessages.RetrieveMultipleFailed);
+        }
+    }
+    /**
+     * Executes a custom Dataverse operation
+     * @param operation - The operation to execute
+     * @returns Promise resolving to operation result
+     */
+    async executeAsync(operation) {
+        try {
+            if (!operation?.dataverseRequest) {
+                const errMsg = `${DataOperationErrorMessages.InvalidRequest}: ${DataOperationErrorMessages.MissingDataverseRequest}`;
+                Log.trackEvent('DataverseDataOperation.ExecuteInvalidRequest', {
+                    message: '[DataverseDataOperation] Invalid execute request',
+                    error: errMsg,
+                });
+                throw new Error(errMsg);
+            }
+            const response = await this._xrm.WebApi.execute(operation);
+            return this._createSuccessResult(response);
+        }
+        catch (error) {
+            Log.trackEvent('DataverseDataOperation.ExecuteFailed', {
+                message: '[DataverseDataOperation] Failed to execute operation',
+                error,
+            });
+            return createErrorResponse(error, DataOperationErrorMessages.ExecuteFailed);
+        }
+    }
+    /**
+     * Returns the database references for Dataverse, grouped by environment/database.
+     * These come from the launch app response via runtime metadata client.
+     */
+    async getDatabaseReferences() {
+        if (this._databaseReferences) {
+            return this._databaseReferences;
+        }
+        // Get database references from runtime metadata (launch app response)
+        // This is the authoritative source containing the complete linkedEnvironmentMetadata
+        const runtimeDatabaseReferences = await this._loadDatabaseReferencesFromRuntime();
+        if (runtimeDatabaseReferences && Object.keys(runtimeDatabaseReferences).length > 0) {
+            this._databaseReferences = runtimeDatabaseReferences;
+            return this._databaseReferences;
+        }
+        throw new PowerDataRuntimeError(ErrorCodes.DataSourceNotFound, 'Failed to load Dataverse database references from runtime.');
+    }
+    /**
+     * Loads database references from runtime metadata client (launch app response).
+     */
+    async _loadDatabaseReferencesFromRuntime() {
+        try {
+            const metadataClient = await this._getMetadataClient();
+            // Get CDS data source configs from runtime metadata
+            const response = await metadataClient.getAppDataSourceConfigsAsync();
+            if (!response.success || !response.data) {
+                return undefined;
+            }
+            const cdsDataSources = Object.values(response.data);
+            if (cdsDataSources.length === 0) {
+                return undefined;
+            }
+            // Build database references from runtime CDS data source configs
+            const databaseReferences = {};
+            for (const cdsDataSource of cdsDataSources) {
+                // Type assertion for CDS data source config
+                const cdsConfig = cdsDataSource;
+                // Extract instance URL and other metadata from runtime URL
+                const instanceUrl = this._extractInstanceUrlFromRuntimeUrl(cdsConfig.runtimeUrl);
+                // Use a standard environment name for CDS
+                const envName = 'default.cds';
+                if (!databaseReferences[envName]) {
+                    databaseReferences[envName] = {
+                        databaseDetails: {
+                            referenceType: 'Environmental',
+                            environmentName: envName,
+                            overrideValues: {
+                                status: 'NotSpecified',
+                                environmentVariableName: '',
+                            },
+                            linkedEnvironmentMetadata: {
+                                resourceId: '',
+                                friendlyName: '',
+                                uniqueName: '',
+                                domainName: '',
+                                version: cdsConfig.version || '9.2',
+                                instanceUrl,
+                                instanceApiUrl: cdsConfig.runtimeUrl,
+                                baseLanguage: 1033,
+                                instanceState: 'Ready',
+                                createdTime: '',
+                                platformSku: '',
+                            },
+                        },
+                        dataSources: {},
+                    };
+                }
+                // Add the data source
+                const dataSourceName = cdsConfig.entitySetName || cdsConfig.logicalName;
+                databaseReferences[envName].dataSources[dataSourceName] = {
+                    entitySetName: cdsConfig.entitySetName,
+                    logicalName: cdsConfig.logicalName,
+                    isHidden: false,
+                };
+            }
+            return databaseReferences;
+        }
+        catch (error) {
+            // Info-level logging for tracing errors loading from runtime
+            Log.trackEvent('DataverseDataOperation.FailedToLoadDatabaseReferences', {
+                message: '[DataverseDataOperation] Failed to load database references from runtime',
+                error,
+            });
+            // Silently fail and return undefined if there's any error loading from runtime
+            return undefined;
+        }
+    }
+    _extractInstanceUrlFromRuntimeUrl(runtimeUrl) {
+        try {
+            // Runtime URL format: https://org.crm.dynamics.com/api/data/v9.2/
+            // Extract: https://org.crm.dynamics.com
+            // Using a simpler approach to avoid URL import issues
+            const matches = runtimeUrl.match(/^(https?:\/\/[^\/]+)/);
+            return matches ? matches[1] : runtimeUrl;
+        }
+        catch (error) {
+            Log.trackEvent('DataverseDataOperation.FailedToExtractInstanceUrl', {
+                message: '[DataverseDataOperation] Failed to extract instance URL from runtime URL',
+                error,
+            });
+            // Fallback to original URL on error
+            return runtimeUrl;
+        }
+    }
+    /**
+     * Validates operation parameters
+     * @param params - The parameters to validate
+     * @throws Error if validation fails
+     */
+    _validateParams(params) {
+        for (const [key, value] of Object.entries(params)) {
+            if (!value) {
+                throw new Error(`${DataOperationErrorMessages.InvalidOperationParameters}: ${key} is required`);
+            }
+            if (!this._dataverseDataSourceService) {
+                throw new PowerDataRuntimeError(ErrorCodes.DataClientInitFailed);
+            }
+        }
+    }
+    /**
+     * Creates a success result object
+     * @param data - The response data
+     * @param totalCount - Optional total count for multiple record operations
+     * @returns IDataOperationResult with success status
+     */
+    _createSuccessResult(data, totalCount) {
+        return {
+            success: true,
+            data,
+        };
+    }
+    /**
+     * Helper to check if XRM context is present and valid
+     */
+    _hasCrm() {
+        return !!(this._xrm && this._xrm.WebApi && typeof this._xrm.WebApi.createRecord === 'function');
+    }
+    /**
+     * Helper to get a native data client and database reference
+     */
+    async _getDataClient() {
+        const dataClient = await this._clientProvider.getDataClientAsync();
+        if (!dataClient) {
+            Log.trackEvent('DataverseDataOperation.DataClientNotAvailable', {
+                message: '[DataverseDataOperation] Data client is not available',
+            });
+            throw new PowerDataRuntimeError(ErrorCodes.DataClientNotAvailable, 'Data client is not available.');
+        }
+        return dataClient;
+    }
+    /**
+     * Gets the metadata client instance
+     */
+    async _getMetadataClient() {
+        const metadataClient = await this._clientProvider.getMetadataClientAsync();
+        if (!metadataClient) {
+            Log.trackEvent('DataverseDataOperation.MetadataClientNotAvailable', {
+                message: '[DataverseDataOperation] Metadata client is not available',
+            });
+            throw new PowerDataRuntimeError(ErrorCodes.MetadataClientNotAvailable);
+        }
+        return metadataClient;
+    }
+    /**
+     * Template method for connector-style CRUD operations to reduce duplication.
+     * Handles client, dataSourceInfo, requestUrl, and error handling.
+     */
+    async _executeNativeDataverseOperation(tableName, buildUrl, operation, errorMessage) {
+        try {
+            const dataClient = await this._getDataClient();
+            const dataSourceInfo = await this._getDataverseDataSourceInfo(tableName);
+            const requestUrl = buildUrl(dataSourceInfo, tableName);
+            return operation(dataClient, requestUrl, dataSourceInfo);
+        }
+        catch (error) {
+            return createErrorResponse(error, errorMessage);
+        }
+    }
+    /**
+     * Helper to get the Dataverse datasourceinfo from databaseReferences
+     */
+    async _getDataverseDataSourceInfo(tableName) {
+        try {
+            const dbRefs = await this.getDatabaseReferences();
+            // Find the environment/database that contains this table
+            for (const dbKey of Object.keys(dbRefs)) {
+                const db = dbRefs[dbKey];
+                if (db.dataSources[tableName]) {
+                    const ds = db.dataSources[tableName];
+                    return {
+                        datasetName: db.databaseDetails?.environmentName,
+                        referenceType: db.databaseDetails?.referenceType,
+                        linkedEnvironmentMetadata: db.databaseDetails?.linkedEnvironmentMetadata,
+                        entitySetName: ds?.entitySetName,
+                        logicalName: ds?.logicalName,
+                        isHidden: ds?.isHidden,
+                        tableId: ds?.logicalName,
+                        apis: {},
+                    };
+                }
+            }
+            const notFoundMsg = `No Dataverse data source found for table: ${tableName}`;
+            Log.trackEvent('DataverseDataOperation.DataSourceNotFound', {
+                message: notFoundMsg,
+                tableName,
+            });
+            throw new PowerDataRuntimeError(ErrorCodes.DataSourceNotFound, notFoundMsg);
+        }
+        catch (error) {
+            Log.trackEvent('DataverseDataOperation.GetDataSourceInfoFailed', {
+                message: '[DataverseDataOperation] Failed to get Dataverse data source info',
+                tableName,
+                error,
+            });
+            throw new PowerDataRuntimeError(ErrorCodes.DataSourceNotFound, `Failed to get Dataverse data source info for table '${tableName}': ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Helper to construct the Dataverse API URL using instanceUrl if available, otherwise fallback to runtimeUrl.
+     */
+    _getDataverseRequestUrl(dataSourceInfo, tableName, urlPath = '') {
+        const instanceUrl = dataSourceInfo.linkedEnvironmentMetadata?.instanceUrl;
+        if (!instanceUrl) {
+            throw new PowerDataRuntimeError(ErrorCodes.DataClientInitFailed, 'No instanceUrl found for Dataverse table.');
+        }
+        // Ensure instanceUrl ends with a slash and construct proper URL
+        const baseUrl = instanceUrl.endsWith('/') ? instanceUrl : `${instanceUrl}/`;
+        return `${baseUrl}api/data/v9.0/${tableName}${urlPath}`;
+    }
+}
+/**
+ * Extracts the skip token from the next link URL.
+ * @param nextLink - The @odata.nextLink URL containing the skip token
+ * @returns The extracted skip token or undefined if not found.
+ */
+export function extractSkipToken(nextLink) {
+    if (!nextLink?.trim()) {
+        return undefined;
+    }
+    const match = nextLink.match(/[\?&]\$?skiptoken=([^&#]+)/i);
+    return match ? decodeURIComponent(match[1]) : undefined;
+}
+//# sourceMappingURL=dataverseDataOperation.js.map