@pptb/types 1.1.3-beta.2 → 1.2.1

package/dataverseAPI.d.ts

@@ -480,7 +480,7 @@ declare namespace DataverseAPI {
          *
          * @param entityLogicalName - Logical name of the entity
          * @param searchByLogicalName - Whether to search by logical name (true) or metadata ID (false)
-         * @param selectColumns - Optional array of column names to retrieve (retrieves all if not specified)
+         * @param entityProperties - Optional array of property names to retrieve (retrieves all if not specified)
          * @param connectionTarget - Optional connection target for multi-connection tools ('primary' or 'secondary'). Defaults to 'primary'.
          * @returns Object containing entity metadata
          *
@@ -500,11 +500,11 @@ declare namespace DataverseAPI {
          * // Multi-connection tool using secondary connection
          * const metadata = await dataverseAPI.getEntityMetadata('account', true, ['LogicalName'], 'secondary');
          */
-        getEntityMetadata: (entityLogicalName: string, searchByLogicalName: boolean, selectColumns?: string[], connectionTarget?: "primary" | "secondary") => Promise<EntityMetadata>;
+        getEntityMetadata: (entityLogicalName: string, searchByLogicalName: boolean, entityProperties?: string[], connectionTarget?: "primary" | "secondary") => Promise<EntityMetadata>;
 
         /**
          * Get metadata for all entities
-         * @param selectColumns - Optional array of column names to retrieve (retrieves LogicalName, DisplayName, MetadataId by default)
+         * @param entityProperties - Optional array of property names to retrieve (retrieves LogicalName, DisplayName, MetadataId by default)
          * @param connectionTarget - Optional connection target for multi-connection tools ('primary' or 'secondary'). Defaults to 'primary'.
          * @returns Object with value array containing all entity metadata
          *
@@ -519,14 +519,14 @@ declare namespace DataverseAPI {
          * // Multi-connection tool using secondary connection
          * const allEntities = await dataverseAPI.getAllEntitiesMetadata(['LogicalName'], 'secondary');
          */
-        getAllEntitiesMetadata: (selectColumns?: string[], connectionTarget?: "primary" | "secondary") => Promise<EntityMetadataCollection>;
+        getAllEntitiesMetadata: (entityProperties?: string[], connectionTarget?: "primary" | "secondary") => Promise<EntityMetadataCollection>;
 
         /**
          * Get related metadata for a specific entity (attributes, relationships, etc.)
          *
          * @param entityLogicalName - Logical name of the entity
          * @param relatedPath - Path after EntityDefinitions(LogicalName='name') (e.g., 'Attributes', 'OneToManyRelationships', 'ManyToOneRelationships', 'ManyToManyRelationships', 'Keys')
-         * @param selectColumns - Optional array of column names to retrieve (retrieves all if not specified)
+         * @param relatedProperties - Optional array of property names to retrieve (retrieves all if not specified)
          * @param connectionTarget - Optional connection target for multi-connection tools ('primary' or 'secondary'). Defaults to 'primary'.
          * @returns Object containing the related metadata
          *
@@ -600,7 +600,7 @@ declare namespace DataverseAPI {
         getEntityRelatedMetadata: <P extends EntityRelatedMetadataPath>(
             entityLogicalName: string,
             relatedPath: P,
-            selectColumns?: string[],
+            relatedProperties?: string[],
             connectionTarget?: "primary" | "secondary",
         ) => Promise<EntityRelatedMetadataResponse<P>>;
 

package/lib/validate.js

@@ -7,7 +7,7 @@
  */
 
 /** @typedef {{ name: string; url?: string }} Contributor */
-/** @typedef {{ "connect-src"?: string[]; "script-src"?: string[]; "style-src"?: string[]; "img-src"?: string[]; "font-src"?: string[]; "frame-src"?: string[] }} CspExceptions */
+/** @typedef {{ "connect-src"?: string[]; "script-src"?: string[]; "style-src"?: string[]; "img-src"?: string[]; "font-src"?: string[]; "frame-src"?: string[]; "media-src"?: string[] }} CspExceptions */
 /** @typedef {{ repository?: string; website?: string; funding?: string; readmeUrl?: string }} Configurations */
 /** @typedef {{ multiConnection?: "required" | "optional" | "none"; minAPI?: string }} Features */
 /**
@@ -85,6 +85,16 @@ function validateIconPath(fieldName, iconPath, errors) {
         errors.push(`${fieldName} must be a relative path (e.g., 'icon.svg' or 'icons/icon.svg')`);
         return;
     }
+    // Reject Windows absolute paths like "C:\..." or "C:/"
+    if (/^[a-zA-Z]:/.test(iconPath)) {
+        errors.push(`${fieldName} must be a relative path (e.g., 'icon.svg' or 'icons/icon.svg')`);
+        return;
+    }
+    // Reject backslashes — icon paths must use forward slashes
+    if (iconPath.includes("\\")) {
+        errors.push(`${fieldName} must use forward slashes, not backslashes (e.g., 'icons/icon.svg')`);
+        return;
+    }
     if (iconPath.includes("..")) {
         errors.push(`${fieldName} cannot contain '..' (path traversal not allowed)`);
         return;
@@ -205,14 +215,14 @@ async function validatePackageJson(packageJson, options = {}) {
         }
 
         // Funding validation (optional but recommended)
-        if (!configs.funding) {
-            warnings.push("configurations.funding is not set; consider adding a sponsorship or funding URL to support contributors");
-        } else if (!isValidUrl(configs.funding)) {
-            warnings.push("configurations.funding has an invalid URL format");
-        } else if (!skipUrlChecks) {
-            const accessible = await isUrlAccessible(configs.funding);
-            if (!accessible) {
-                warnings.push("configurations.funding URL is not accessible");
+        if (configs.funding) {
+            if (!isValidUrl(configs.funding)) {
+                warnings.push("configurations.funding has an invalid URL format");
+            } else if (!skipUrlChecks) {
+                const accessible = await isUrlAccessible(configs.funding);
+                if (!accessible) {
+                    warnings.push("configurations.funding URL is not accessible");
+                }
             }
         }
 
@@ -233,45 +243,57 @@ async function validatePackageJson(packageJson, options = {}) {
 
     // CSP Exceptions validation (optional, but validated if present)
     if (packageJson.cspExceptions) {
-        const validCspDirectives = ["connect-src", "script-src", "style-src", "img-src", "font-src", "frame-src"];
+        const cspExceptions = packageJson.cspExceptions;
 
-        const hasAnyDirectives = Object.keys(packageJson.cspExceptions).length > 0;
-        if (!hasAnyDirectives) {
-            errors.push("cspExceptions cannot be empty. If CSP exceptions are not needed, remove the cspExceptions field");
-        }
+        if (typeof cspExceptions !== "object" || cspExceptions === null || Array.isArray(cspExceptions)) {
+            errors.push("cspExceptions must be an object mapping CSP directives to arrays of strings");
+        } else {
+            const validCspDirectives = ["connect-src", "script-src", "style-src", "img-src", "font-src", "frame-src", "media-src"];
 
-        Object.keys(packageJson.cspExceptions).forEach((directive) => {
-            if (!validCspDirectives.includes(directive)) {
-                warnings.push(`Unknown CSP directive: ${directive}`);
-            }
-            const values = packageJson.cspExceptions?.[/** @type {keyof CspExceptions} */ (directive)];
-            if (values && !Array.isArray(values)) {
-                errors.push(`CSP directive "${directive}" must be an array of strings`);
-            } else if (values && values.length === 0) {
-                errors.push(`CSP directive "${directive}" cannot be an empty array`);
+            const hasAnyDirectives = Object.keys(cspExceptions).length > 0;
+            if (!hasAnyDirectives) {
+                errors.push("cspExceptions cannot be empty. If CSP exceptions are not needed, remove the cspExceptions field");
             }
-        });
+
+            Object.keys(cspExceptions).forEach((directive) => {
+                if (!validCspDirectives.includes(directive)) {
+                    warnings.push(`Unknown CSP directive: ${directive}`);
+                }
+                const values = cspExceptions[/** @type {keyof CspExceptions} */ (directive)];
+                if (values && !Array.isArray(values)) {
+                    errors.push(`CSP directive "${directive}" must be an array of strings`);
+                } else if (values && values.length === 0) {
+                    errors.push(`CSP directive "${directive}" cannot be an empty array`);
+                }
+            });
+        }
     }
 
     // Features validation (optional, but validated if present)
-    if (packageJson.features) {
-        const VALID_FEATURE_KEYS = ["multiConnection", "minAPI"];
-        const featureKeys = Object.keys(packageJson.features);
-        const invalidKeys = featureKeys.filter((key) => !VALID_FEATURE_KEYS.includes(key));
-
-        if (invalidKeys.length > 0) {
-            errors.push(`features can only contain ${VALID_FEATURE_KEYS.map((k) => `'${k}'`).join(", ")} properties. Invalid properties: ${invalidKeys.join(", ")}`);
-        }
+    if (packageJson.features !== undefined) {
+        const features = packageJson.features;
+
+        if (features === null || typeof features !== "object" || Array.isArray(features)) {
+            errors.push("features must be a non-array object with optional 'multiConnection' and 'minAPI' properties");
+        } else {
+            const VALID_FEATURE_KEYS = ["multiConnection", "minAPI"];
+            const featureKeys = Object.keys(features);
+            const invalidKeys = featureKeys.filter((key) => !VALID_FEATURE_KEYS.includes(key));
+
+            if (invalidKeys.length > 0) {
+                errors.push(`features can only contain ${VALID_FEATURE_KEYS.map((k) => `'${k}'`).join(", ")} properties. Invalid properties: ${invalidKeys.join(", ")}`);
+            }
 
-        if (packageJson.features.multiConnection === undefined) {
-            errors.push("features.multiConnection is required when features object is provided");
-        } else if (!VALID_MULTI_CONNECTION_VALUES.includes(packageJson.features.multiConnection)) {
-            errors.push(`features.multiConnection must be one of: ${VALID_MULTI_CONNECTION_VALUES.join(", ")}`);
-        }
+            if (features.multiConnection === undefined) {
+                errors.push("features.multiConnection is required when features object is provided");
+            } else if (!VALID_MULTI_CONNECTION_VALUES.includes(features.multiConnection)) {
+                errors.push(`features.multiConnection must be one of: ${VALID_MULTI_CONNECTION_VALUES.join(", ")}`);
+            }
 
-        if (packageJson.features.minAPI !== undefined) {
-            if (typeof packageJson.features.minAPI !== "string" || !SEMVER_REGEX.test(packageJson.features.minAPI)) {
-                errors.push("features.minAPI must be a valid semantic version string (e.g., '1.0.0')");
+            if (features.minAPI !== undefined) {
+                if (typeof features.minAPI !== "string" || !SEMVER_REGEX.test(features.minAPI)) {
+                    errors.push("features.minAPI must be a valid semantic version string (e.g., '1.0.0')");
+                }
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pptb/types",
-  "version": "1.1.3-beta.2",
+  "version": "1.2.1",
   "description": "Type definitions for Power Platform ToolBox APIs and validity checks for tool packages",
   "main": "index.d.ts",
   "types": "index.d.ts",

package/toolboxAPI.d.ts

@@ -191,11 +191,13 @@ declare namespace ToolBoxAPI {
         /**
          * Show a loading screen in the tool's context
          * @param message Optional message to display (default: "Loading...")
+         * @deprecated Use a tool-level loading pattern instead. Will be removed in a future version.
          */
         showLoading: (message?: string) => Promise<void>;
 
         /**
          * Hide the loading screen in the tool's context
+         * @deprecated Use a tool-level loading pattern instead. Will be removed in a future version.
          */
         hideLoading: () => Promise<void>;
     }