@limetech/lime-crm-building-blocks 1.105.1 → 1.105.2

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.105.2](https://github.com/Lundalogik/lime-crm-building-blocks/compare/v1.105.1...v1.105.2) (2025-12-01)
+
+### Bug Fixes
+
+
+* **lime-query-builder:** validate filter expression keys to prevent backend errors ([c98bc02](https://github.com/Lundalogik/lime-crm-building-blocks/commit/c98bc028f6a6dccabf7fda9808c03e6a59b86256)), closes [Lundalogik/crm-insights-and-intelligence#128](https://github.com/Lundalogik/crm-insights-and-intelligence/issues/128)
+
 ## [1.105.1](https://github.com/Lundalogik/lime-crm-building-blocks/compare/v1.105.0...v1.105.1) (2025-11-27)
 
 ### Bug Fixes

package/dist/cjs/{lime-query-validation-82aa2855.js → lime-query-validation-6d419d03.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 const index_esm = require('./index.esm-d785eb6e.js');
-const propertyResolution = require('./property-resolution-fb42a46b.js');
+const propertyResolution = require('./property-resolution-5f798b03.js');
 
 /**
  * Dynamic filter values and placeholders that are valid in Lime Query
@@ -87,6 +87,46 @@ function validatePlaceholder(value, activeLimetype, limetypes) {
         };
     }
 }
+/**
+ * Validates a filter expression key (property path).
+ * Supports both regular property paths and placeholders.
+ *
+ * @param key - Property path to validate (e.g., "name", "company.name", "%activeObject%.name")
+ * @param limetypes - All limetype definitions
+ * @param limetype - The limetype being filtered
+ * @param activeLimetype - Active limetype for placeholder resolution
+ * @returns Validation result with error message if invalid
+ */
+function validateFilterKey(key, limetypes, limetype, activeLimetype) {
+    // 1. Handle empty/missing keys
+    if (!key) {
+        return { valid: false, error: 'Filter key cannot be empty' };
+    }
+    // 2. Check if key is a placeholder
+    if (key.startsWith('%activeObject%')) {
+        const placeholderResult = validatePlaceholder(key, activeLimetype, limetypes);
+        if (!placeholderResult.valid) {
+            return placeholderResult;
+        }
+        // Extract property path after the placeholder and validate for hasMany/hasAndBelongsToMany
+        const propertyPath = key.replace(/^%activeObject%\.?/, '');
+        if (propertyPath && activeLimetype) {
+            const { error } = propertyResolution.validatePropertyPath(limetypes, activeLimetype, propertyPath);
+            if (error) {
+                return { valid: false, error };
+            }
+        }
+        return placeholderResult;
+    }
+    // 3. Validate regular property path (including intermediate properties)
+    const { error } = propertyResolution.validatePropertyPath(limetypes, limetype, key);
+    if (error) {
+        return { valid: false, error };
+    }
+    // validatePropertyPath always returns an error if property is undefined,
+    // so if we reach here, the property exists and is valid
+    return { valid: true };
+}
 /**
  * Validate a response format against limetype schemas
  * Throws errors for invalid property references
@@ -255,13 +295,19 @@ function validatePropertySelection(selection, limetypes, limetype, visualModeEna
  * @param filter
  * @param activeLimetype
  * @param limetypes
+ * @param limetype
  */
-function validateComparisonExpression(filter, activeLimetype, limetypes) {
+function validateComparisonExpression(filter, activeLimetype, limetypes, limetype) {
     // Validate operator
     const allValidOperators = Object.values(index_esm.Zt);
     if (!allValidOperators.includes(filter.op)) {
         throw new Error(`Unsupported filter operator: ${filter.op}`);
     }
+    // Validate filter key
+    const keyResult = validateFilterKey(filter.key, limetypes, limetype, activeLimetype);
+    if (!keyResult.valid) {
+        throw new Error(`Invalid filter key '${filter.key}': ${keyResult.error}`);
+    }
     // Validate placeholder
     const result = validatePlaceholder(filter.exp, activeLimetype, limetypes);
     if (!result.valid) {
@@ -273,9 +319,10 @@ function validateComparisonExpression(filter, activeLimetype, limetypes) {
  * @param filter
  * @param activeLimetype
  * @param limetypes
+ * @param limetype
  * @param visualModeEnabled
  */
-function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEnabled) {
+function validateGroupExpression(filter, activeLimetype, limetypes, limetype, visualModeEnabled) {
     // Validate operator
     if (filter.op !== index_esm.Zt.AND &&
         filter.op !== index_esm.Zt.OR &&
@@ -284,12 +331,12 @@ function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEn
     }
     // Recursively validate children
     if (filter.op === index_esm.Zt.NOT) {
-        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, visualModeEnabled);
+        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
     else if (filter.op === index_esm.Zt.AND || filter.op === index_esm.Zt.OR) {
         const expressions = filter.exp;
         for (const expr of expressions) {
-            validateFilterPlaceholders(expr, activeLimetype, limetypes, visualModeEnabled);
+            validateFilterPlaceholders(expr, activeLimetype, limetypes, limetype, visualModeEnabled);
         }
     }
 }
@@ -298,37 +345,51 @@ function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEn
  * @param filter Filter expression to validate
  * @param activeLimetype The limetype of the active object
  * @param limetypes Record of all available limetypes
+ * @param limetype The limetype being filtered
  * @param visualModeEnabled Whether visual mode is enabled (affects validation)
  */
-function validateFilterPlaceholders(filter, activeLimetype, limetypes, visualModeEnabled = true) {
+function validateFilterPlaceholders(filter, activeLimetype, limetypes, limetype, visualModeEnabled = true) {
     if (!filter) {
         return;
     }
     if ('key' in filter) {
-        validateComparisonExpression(filter, activeLimetype, limetypes);
+        validateComparisonExpression(filter, activeLimetype, limetypes, limetype);
         return;
     }
     if ('exp' in filter) {
-        validateGroupExpression(filter, activeLimetype, limetypes, visualModeEnabled);
+        validateGroupExpression(filter, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
 }
 /**
- * Validate Lime Query filter and collect errors
+ * Validate Lime Query filter and collect errors and visual mode limitations
  * @param filter The filter expression or group to validate
  * @param activeLimetype Optional active object limetype for placeholder validation
  * @param limetypes Record of all available limetypes
+ * @param limetype The limetype being filtered
  * @param visualModeEnabled Whether visual mode is enabled
- * @returns Array of validation error messages
+ * @returns Object with validation errors and visual mode limitations
  */
-function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, visualModeEnabled) {
+function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, limetype, visualModeEnabled) {
     const errors = [];
+    const limitations = [];
     try {
-        validateFilterPlaceholders(filter, activeLimetype, limetypes, visualModeEnabled);
+        validateFilterPlaceholders(filter, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
     catch (error) {
-        errors.push(`Invalid filter: ${error.message}`);
+        const errorMessage = error.message;
+        // Invalid keys are BOTH spec violations AND rendering limitations:
+        // - Backend will reject them (validation error)
+        // - Visual mode can't show them in property selector (visual limitation)
+        if (errorMessage.includes('Invalid filter key') ||
+            errorMessage.includes('Cannot filter on many-relation')) {
+            errors.push(`Invalid filter: ${errorMessage}`);
+            limitations.push(errorMessage);
+        }
+        else {
+            errors.push(`Invalid filter: ${errorMessage}`);
+        }
     }
-    return errors;
+    return { errors, limitations };
 }
 /**
  * Validate orderBy specification
@@ -497,8 +558,9 @@ function isLimeQuerySupported(limeQuery, limetypes, activeLimetype, visualModeEn
     }
     // Validate filter
     if (limeQuery.filter) {
-        const filterErrors = validateLimeQueryFilterInternal(limeQuery.filter, activeLimetype, limetypes, visualModeEnabled);
-        validationErrors.push(...filterErrors);
+        const { errors, limitations } = validateLimeQueryFilterInternal(limeQuery.filter, activeLimetype, limetypes, limeQuery.limetype, visualModeEnabled);
+        validationErrors.push(...errors);
+        visualModeLimitations.push(...limitations);
     }
     // Validate responseFormat
     if (limeQuery.responseFormat) {

package/dist/cjs/limebb-lime-query-builder.cjs.entry.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-d785eb6e.js');
-const limeQueryValidation = require('./lime-query-validation-82aa2855.js');
-require('./property-resolution-fb42a46b.js');
+const limeQueryValidation = require('./lime-query-validation-6d419d03.js');
+require('./property-resolution-5f798b03.js');
 
 const limeQueryBuilderCss = "*,*:before,*:after{box-sizing:border-box}:host(limebb-lime-query-builder){--header-background-color:rgb(var(--contrast-500));--limebb-lime-query-builder-background-color:rgb(var(--contrast-100));--limebb-lime-query-builder-border-radius:0.75rem;--limebb-lime-query-builder-visual-mode-padding:1rem;--limebb-lime-query-builder-group-color:rgb(var(--color-sky-lighter));box-sizing:border-box;width:calc(100% - 1.5rem);margin:0.75rem auto;display:flex;flex-direction:column;border-radius:var(--limebb-lime-query-builder-border-radius);background-color:var(--limebb-lime-query-builder-background-color);box-shadow:var(--shadow-inflated-16)}.visual-mode{display:flex;flex-direction:column;gap:1rem;padding:var(--limebb-lime-query-builder-visual-mode-padding);border:1px solid var(--header-background-color);border-radius:0 0 var(--limebb-lime-query-builder-border-radius) var(--limebb-lime-query-builder-border-radius)}.code-mode{--code-editor-max-height:70vh;display:flex;flex-direction:column;gap:1rem}.code-mode .validation-errors{padding:0.75rem 1rem;color:rgb(var(--color-red-default));background-color:rgb(var(--color-red-lighter));border-left:0.25rem solid rgb(var(--color-red-default));border-radius:0.25rem;font-size:0.875rem}.code-mode .validation-errors strong{display:block;margin-bottom:0.5rem;font-weight:600}.code-mode .validation-errors ul{margin:0;padding-left:1.5rem}.code-mode .validation-errors li{margin:0.25rem 0}.code-mode .visual-mode-limitations{padding:0.75rem 1rem;color:rgb(var(--color-blue-dark));background-color:rgb(var(--color-blue-lighter));border-left:0.25rem solid rgb(var(--color-blue-default));border-radius:0.25rem;font-size:0.875rem}.code-mode .visual-mode-limitations strong{display:block;margin-bottom:0.5rem;font-weight:600}.code-mode .visual-mode-limitations ul{margin:0;padding-left:1.5rem}.code-mode .visual-mode-limitations li{margin:0.25rem 0}section.description,section.filter,section.query-options{display:flex;flex-direction:column;gap:1rem}section h4{margin:0;font-size:1.125rem;font-weight:600;color:rgb(var(--contrast-1000))}limel-header.is-narrow{--header-top-right-left-border-radius:0;width:calc(100% + var(--limebb-lime-query-builder-visual-mode-padding) * 2);margin-left:calc(var(--limebb-lime-query-builder-visual-mode-padding) * -1)}.query-options-controls{display:flex;flex-direction:column;gap:1rem}";
 const LimebbLimeQueryBuilderStyle0 = limeQueryBuilderCss;

package/dist/cjs/limebb-lime-query-filter-group_3.cjs.entry.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-d785eb6e.js');
-const propertyResolution = require('./property-resolution-fb42a46b.js');
+const propertyResolution = require('./property-resolution-5f798b03.js');
 
 /**
  * Get the subheading text for a filter group based on its operator and expression count

package/dist/cjs/limebb-lime-query-response-format-builder.cjs.entry.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-d785eb6e.js');
-const limeQueryValidation = require('./lime-query-validation-82aa2855.js');
-require('./property-resolution-fb42a46b.js');
+const limeQueryValidation = require('./lime-query-validation-6d419d03.js');
+require('./property-resolution-5f798b03.js');
 
 /**
  * Helper functions for working with ResponseFormat objects

package/dist/cjs/limebb-property-selector.cjs.entry.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-ff255a0d.js');
 const index_esm = require('./index.esm-d785eb6e.js');
-const propertyResolution = require('./property-resolution-fb42a46b.js');
+const propertyResolution = require('./property-resolution-5f798b03.js');
 const limetype = require('./limetype-f2e4376e.js');
 
 const propertySelectorCss = ":host(limebb-property-selector){display:block}limel-menu{display:block;width:100%}";

package/dist/cjs/{property-resolution-fb42a46b.js → property-resolution-5f798b03.js}

@@ -61,6 +61,53 @@ function getPropertyFromPath(limetypes, limetype, path) {
     }
     return property;
 }
+/**
+ * Validates a property path to ensure no intermediate properties are hasMany or hasAndBelongsToMany relations.
+ * These relation types cannot be traversed in filter expressions.
+ * @param limetypes All limetype definitions
+ * @param limetype The starting limetype
+ * @param path The property path to validate (e.g., "company.name")
+ * @returns The property at the end of the path if valid, or undefined with error if invalid
+ */
+function validatePropertyPath(limetypes, limetype, path) {
+    if (!path || !limetype || !limetypes) {
+        return { property: undefined };
+    }
+    const parts = path.split('.');
+    let currentType = limetypes[limetype];
+    let property;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (!currentType) {
+            return { property: undefined };
+        }
+        const normalizedProperties = getNormalizedProperties(currentType);
+        property = normalizedProperties[part];
+        if (!property) {
+            return {
+                property: undefined,
+                error: `Property '${part}' does not exist on limetype '${currentType.name}'`,
+            };
+        }
+        // Check if this property is a hasMany/hasAndBelongsToMany relation
+        // These cannot be traversed in filter expressions
+        if (property.type === 'hasmany' ||
+            property.type === 'hasandbelongstomany') {
+            // Build the path up to this point for the error message
+            const invalidPath = parts.slice(0, i + 1).join('.');
+            return {
+                property: undefined,
+                error: `Cannot filter on many-relation '${invalidPath}'. Use a related limetype's filter instead.`,
+            };
+        }
+        // If this is a relation, get the related limetype for next iteration
+        if (property.relation) {
+            currentType = property.relation.getLimetype();
+        }
+    }
+    return { property };
+}
 
 exports.getNormalizedProperties = getNormalizedProperties;
 exports.getPropertyFromPath = getPropertyFromPath;
+exports.validatePropertyPath = validatePropertyPath;

package/dist/collection/components/lime-query-builder/lime-query-validation.js

@@ -1,6 +1,5 @@
 import { Operator } from "@limetech/lime-web-components";
-import { getNormalizedProperties } from "./property-resolution";
-import { getPropertyFromPath } from "./property-resolution";
+import { getNormalizedProperties, getPropertyFromPath, validatePropertyPath, } from "./property-resolution";
 /**
  * Dynamic filter values and placeholders that are valid in Lime Query
  */
@@ -85,6 +84,46 @@ export function validatePlaceholder(value, activeLimetype, limetypes) {
         };
     }
 }
+/**
+ * Validates a filter expression key (property path).
+ * Supports both regular property paths and placeholders.
+ *
+ * @param key - Property path to validate (e.g., "name", "company.name", "%activeObject%.name")
+ * @param limetypes - All limetype definitions
+ * @param limetype - The limetype being filtered
+ * @param activeLimetype - Active limetype for placeholder resolution
+ * @returns Validation result with error message if invalid
+ */
+export function validateFilterKey(key, limetypes, limetype, activeLimetype) {
+    // 1. Handle empty/missing keys
+    if (!key) {
+        return { valid: false, error: 'Filter key cannot be empty' };
+    }
+    // 2. Check if key is a placeholder
+    if (key.startsWith('%activeObject%')) {
+        const placeholderResult = validatePlaceholder(key, activeLimetype, limetypes);
+        if (!placeholderResult.valid) {
+            return placeholderResult;
+        }
+        // Extract property path after the placeholder and validate for hasMany/hasAndBelongsToMany
+        const propertyPath = key.replace(/^%activeObject%\.?/, '');
+        if (propertyPath && activeLimetype) {
+            const { error } = validatePropertyPath(limetypes, activeLimetype, propertyPath);
+            if (error) {
+                return { valid: false, error };
+            }
+        }
+        return placeholderResult;
+    }
+    // 3. Validate regular property path (including intermediate properties)
+    const { error } = validatePropertyPath(limetypes, limetype, key);
+    if (error) {
+        return { valid: false, error };
+    }
+    // validatePropertyPath always returns an error if property is undefined,
+    // so if we reach here, the property exists and is valid
+    return { valid: true };
+}
 /**
  * Validate a response format against limetype schemas
  * Throws errors for invalid property references
@@ -253,13 +292,19 @@ export function validatePropertySelection(selection, limetypes, limetype, visual
  * @param filter
  * @param activeLimetype
  * @param limetypes
+ * @param limetype
  */
-function validateComparisonExpression(filter, activeLimetype, limetypes) {
+function validateComparisonExpression(filter, activeLimetype, limetypes, limetype) {
     // Validate operator
     const allValidOperators = Object.values(Operator);
     if (!allValidOperators.includes(filter.op)) {
         throw new Error(`Unsupported filter operator: ${filter.op}`);
     }
+    // Validate filter key
+    const keyResult = validateFilterKey(filter.key, limetypes, limetype, activeLimetype);
+    if (!keyResult.valid) {
+        throw new Error(`Invalid filter key '${filter.key}': ${keyResult.error}`);
+    }
     // Validate placeholder
     const result = validatePlaceholder(filter.exp, activeLimetype, limetypes);
     if (!result.valid) {
@@ -271,9 +316,10 @@ function validateComparisonExpression(filter, activeLimetype, limetypes) {
  * @param filter
  * @param activeLimetype
  * @param limetypes
+ * @param limetype
  * @param visualModeEnabled
  */
-function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEnabled) {
+function validateGroupExpression(filter, activeLimetype, limetypes, limetype, visualModeEnabled) {
     // Validate operator
     if (filter.op !== Operator.AND &&
         filter.op !== Operator.OR &&
@@ -282,12 +328,12 @@ function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEn
     }
     // Recursively validate children
     if (filter.op === Operator.NOT) {
-        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, visualModeEnabled);
+        validateFilterPlaceholders(filter.exp, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
     else if (filter.op === Operator.AND || filter.op === Operator.OR) {
         const expressions = filter.exp;
         for (const expr of expressions) {
-            validateFilterPlaceholders(expr, activeLimetype, limetypes, visualModeEnabled);
+            validateFilterPlaceholders(expr, activeLimetype, limetypes, limetype, visualModeEnabled);
         }
     }
 }
@@ -296,37 +342,51 @@ function validateGroupExpression(filter, activeLimetype, limetypes, visualModeEn
  * @param filter Filter expression to validate
  * @param activeLimetype The limetype of the active object
  * @param limetypes Record of all available limetypes
+ * @param limetype The limetype being filtered
  * @param visualModeEnabled Whether visual mode is enabled (affects validation)
  */
-function validateFilterPlaceholders(filter, activeLimetype, limetypes, visualModeEnabled = true) {
+function validateFilterPlaceholders(filter, activeLimetype, limetypes, limetype, visualModeEnabled = true) {
     if (!filter) {
         return;
     }
     if ('key' in filter) {
-        validateComparisonExpression(filter, activeLimetype, limetypes);
+        validateComparisonExpression(filter, activeLimetype, limetypes, limetype);
         return;
     }
     if ('exp' in filter) {
-        validateGroupExpression(filter, activeLimetype, limetypes, visualModeEnabled);
+        validateGroupExpression(filter, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
 }
 /**
- * Validate Lime Query filter and collect errors
+ * Validate Lime Query filter and collect errors and visual mode limitations
  * @param filter The filter expression or group to validate
  * @param activeLimetype Optional active object limetype for placeholder validation
  * @param limetypes Record of all available limetypes
+ * @param limetype The limetype being filtered
  * @param visualModeEnabled Whether visual mode is enabled
- * @returns Array of validation error messages
+ * @returns Object with validation errors and visual mode limitations
  */
-function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, visualModeEnabled) {
+function validateLimeQueryFilterInternal(filter, activeLimetype, limetypes, limetype, visualModeEnabled) {
     const errors = [];
+    const limitations = [];
     try {
-        validateFilterPlaceholders(filter, activeLimetype, limetypes, visualModeEnabled);
+        validateFilterPlaceholders(filter, activeLimetype, limetypes, limetype, visualModeEnabled);
     }
     catch (error) {
-        errors.push(`Invalid filter: ${error.message}`);
+        const errorMessage = error.message;
+        // Invalid keys are BOTH spec violations AND rendering limitations:
+        // - Backend will reject them (validation error)
+        // - Visual mode can't show them in property selector (visual limitation)
+        if (errorMessage.includes('Invalid filter key') ||
+            errorMessage.includes('Cannot filter on many-relation')) {
+            errors.push(`Invalid filter: ${errorMessage}`);
+            limitations.push(errorMessage);
+        }
+        else {
+            errors.push(`Invalid filter: ${errorMessage}`);
+        }
     }
-    return errors;
+    return { errors, limitations };
 }
 /**
  * Validate orderBy specification
@@ -495,8 +555,9 @@ export function isLimeQuerySupported(limeQuery, limetypes, activeLimetype, visua
     }
     // Validate filter
     if (limeQuery.filter) {
-        const filterErrors = validateLimeQueryFilterInternal(limeQuery.filter, activeLimetype, limetypes, visualModeEnabled);
-        validationErrors.push(...filterErrors);
+        const { errors, limitations } = validateLimeQueryFilterInternal(limeQuery.filter, activeLimetype, limetypes, limeQuery.limetype, visualModeEnabled);
+        validationErrors.push(...errors);
+        visualModeLimitations.push(...limitations);
     }
     // Validate responseFormat
     if (limeQuery.responseFormat) {

package/dist/collection/components/lime-query-builder/property-resolution.js

@@ -59,3 +59,49 @@ export function getPropertyFromPath(limetypes, limetype, path) {
     }
     return property;
 }
+/**
+ * Validates a property path to ensure no intermediate properties are hasMany or hasAndBelongsToMany relations.
+ * These relation types cannot be traversed in filter expressions.
+ * @param limetypes All limetype definitions
+ * @param limetype The starting limetype
+ * @param path The property path to validate (e.g., "company.name")
+ * @returns The property at the end of the path if valid, or undefined with error if invalid
+ */
+export function validatePropertyPath(limetypes, limetype, path) {
+    if (!path || !limetype || !limetypes) {
+        return { property: undefined };
+    }
+    const parts = path.split('.');
+    let currentType = limetypes[limetype];
+    let property;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (!currentType) {
+            return { property: undefined };
+        }
+        const normalizedProperties = getNormalizedProperties(currentType);
+        property = normalizedProperties[part];
+        if (!property) {
+            return {
+                property: undefined,
+                error: `Property '${part}' does not exist on limetype '${currentType.name}'`,
+            };
+        }
+        // Check if this property is a hasMany/hasAndBelongsToMany relation
+        // These cannot be traversed in filter expressions
+        if (property.type === 'hasmany' ||
+            property.type === 'hasandbelongstomany') {
+            // Build the path up to this point for the error message
+            const invalidPath = parts.slice(0, i + 1).join('.');
+            return {
+                property: undefined,
+                error: `Cannot filter on many-relation '${invalidPath}'. Use a related limetype's filter instead.`,
+            };
+        }
+        // If this is a relation, get the related limetype for next iteration
+        if (property.relation) {
+            currentType = property.relation.getLimetype();
+        }
+    }
+    return { property };
+}