@opra/common 1.5.0 → 1.5.1

package/esm/document/api-document.js

@@ -71,7 +71,6 @@ export class ApiDocument extends DocumentElement {
             url: this.url,
             info: cloneObject(this.info, true),
         });
-        options = options || { scopes: this.scopes };
         if (this.references.size) {
             let i = 0;
             const references = {};
@@ -91,7 +90,7 @@ export class ApiDocument extends DocumentElement {
         if (this.types.size) {
             out.types = {};
             for (const v of this.types.values()) {
-                if (!v.inScope(options.scopes))
+                if (options?.scope && !v.inScope(options?.scope))
                     continue;
                 out.types[v.name] = v.toJSON(options);
             }
@@ -110,7 +109,7 @@ export class ApiDocument extends DocumentElement {
     }
     _findDataType(nameOrCtor, scope, visitedRefs) {
         let result = this.types.get(nameOrCtor);
-        if (result && result.inScope(scope))
+        if (result && (!scope || result.inScope(scope)))
             return result;
         if (!this.references.size)
             return;

package/esm/document/common/document-init-context.js

@@ -6,11 +6,6 @@ export class DocumentInitContext {
         this.showErrorDetails = true;
         this.maxErrors = options?.maxErrors || 0;
         this.error.message = '';
-        this.scopes = options?.scopes
-            ? Array.isArray(options.scopes)
-                ? options?.scopes
-                : [options?.scopes]
-            : undefined;
     }
     addError(error) {
         if (!this.error.details.length) {

package/esm/document/common/document-node.js

@@ -22,9 +22,8 @@ export class DocumentNode {
         return !!this.findDataType(nameOrCtor, scope);
     }
     findDataType(nameOrCtor, scope) {
-        scope = scope || this.getDocument().scopes;
         const dt = this[kDataTypeMap]?.get(nameOrCtor);
-        if (dt && dt.inScope(scope))
+        if (dt && (!scope || dt.inScope(scope)))
             return dt;
         return this.parent
             ? this.parent.findDataType(nameOrCtor, scope)
@@ -35,7 +34,7 @@ export class DocumentNode {
      */
     getDataType(nameOrCtor, scope) {
         const dt = this.findDataType(nameOrCtor);
-        if (dt && dt.inScope(scope))
+        if (dt && (!scope || dt.inScope(scope)))
             return dt;
         let name = '';
         if (typeof nameOrCtor === 'function') {

package/esm/document/data-type/api-field.js

@@ -2,10 +2,10 @@ import { omitUndefined } from '@jsopen/objects';
 import { asMutable } from 'ts-gems';
 import { DocumentElement } from '../common/document-element.js';
 import { DECORATOR } from '../constants.js';
-import { ApiFieldDecorator } from '../decorators/api-field-decorator.js';
+import { ApiFieldDecoratorFactory } from '../decorators/api-field-decorator.js';
+import { testScopeMatch } from '../utils/test-scope-match.js';
 import { ComplexTypeBase } from './complex-type-base.js';
 /**
- * @constructor ApiField
  * @decorator ApiField
  */
 export const ApiField = function (...args) {
@@ -25,7 +25,7 @@ export const ApiField = function (...args) {
         throw new Error('Field origin should be one of ComplexType, MappedType or MixinType');
     }
     _this.origin = origin;
-    _this.scopes = initArgs.scopes;
+    _this.scopePattern = initArgs.scopePattern;
     _this.type = initArgs.type || owner.node.getDataType('any');
     _this.description = initArgs.description;
     _this.isArray = initArgs.isArray;
@@ -41,22 +41,13 @@ export const ApiField = function (...args) {
     _this.examples = initArgs.examples;
 };
 /**
- *
- * @class ApiField
+ * The ApiFieldClass represents a descriptive metadata structure for API fields,
+ * supporting features like data type definition, scoping, localization, and constraints.
+ * This class extends DocumentElement, inheriting base document structure capabilities.
  */
 class ApiFieldClass extends DocumentElement {
-    inScope(scopes) {
-        if (!this.scopes?.length || !scopes)
-            return true;
-        /** this.scope should match all required scopes */
-        scopes = Array.isArray(scopes) ? scopes : [scopes];
-        for (const scope of scopes) {
-            if (!this.scopes.some(s => {
-                return typeof s === 'string' ? scope === s : s.test(scope);
-            }))
-                return false;
-        }
-        return true;
+    inScope(scope) {
+        return testScopeMatch(scope, this.scopePattern);
     }
     toJSON(options) {
         const typeName = this.type
@@ -80,5 +71,5 @@ class ApiFieldClass extends DocumentElement {
     }
 }
 ApiField.prototype = ApiFieldClass.prototype;
-Object.assign(ApiField, ApiFieldDecorator);
-ApiField[DECORATOR] = ApiFieldDecorator;
+Object.assign(ApiField, ApiFieldDecoratorFactory);
+ApiField[DECORATOR] = ApiFieldDecoratorFactory;

package/esm/document/data-type/complex-type-base.js

@@ -1,7 +1,6 @@
 import { asMutable } from 'ts-gems';
 import { validator, vg } from 'valgen';
 import { parseFieldsProjection, ResponsiveMap, } from '../../helpers/index.js';
-import { translate } from '../../i18n/index.js';
 import { DataType } from './data-type.js';
 export const FIELD_PATH_PATTERN = /^([+-])?([a-z$_][\w.]*)$/i;
 /**
@@ -24,21 +23,29 @@ class ComplexTypeBaseClass extends DataType {
     /**
      *
      */
-    findField(nameOrPath) {
+    findField(nameOrPath, scope) {
         if (nameOrPath.includes('.')) {
-            const fieldPath = this.parseFieldPath(nameOrPath);
+            const fieldPath = this.parseFieldPath(nameOrPath, { scope });
+            if (fieldPath.length === 0)
+                throw new Error(`Field "${nameOrPath}" does not exist in scope "${scope}"`);
             const lastItem = fieldPath.pop();
             return lastItem?.field;
         }
-        return this.fields.get(nameOrPath);
+        const field = this.fields.get(nameOrPath);
+        if (field && scope && !field.inScope(scope))
+            return;
+        return field;
     }
     /**
      *
      */
-    getField(nameOrPath) {
+    getField(nameOrPath, scope) {
         const field = this.findField(nameOrPath);
-        if (!field)
-            throw new Error(translate('error:UNKNOWN_FIELD', { field: nameOrPath }));
+        if (field && scope && !field.inScope(scope))
+            throw new Error(`Field "${nameOrPath}" does not exist in scope "${scope}"`);
+        if (!field) {
+            throw new Error(`Field (${nameOrPath}) does not exist`);
+        }
         return field;
     }
     /**
@@ -69,7 +76,7 @@ class ComplexTypeBaseClass extends DataType {
             }
             if (dataType) {
                 if (dataType instanceof ComplexTypeBase) {
-                    field = dataType.fields.get(item.fieldName);
+                    field = dataType.getField(item.fieldName, options?.scope);
                     if (field) {
                         item.fieldName = field.name;
                         item.field = field;
@@ -146,17 +153,12 @@ class ComplexTypeBaseClass extends DataType {
         const schema = {};
         const { currentPath, projection } = context;
         const pickList = !!(projection && Object.values(projection).find(p => !p.sign));
-        const scope = context.scope
-            ? Array.isArray(context.scope)
-                ? context.scope
-                : [context.scope]
-            : undefined;
         // Process fields
         let fieldName;
         for (const field of this.fields.values()) {
             if (
             /** Ignore field if required scope(s) do not match field scopes */
-            (scope && !field.inScope(scope)) ||
+            (context.scope && !field.inScope(context.scope)) ||
                 /** Ignore field if readonly and ignoreReadonlyFields option true */
                 (context.ignoreReadonlyFields && field.readonly) ||
                 /** Ignore field if writeonly and ignoreWriteonlyFields option true */

package/esm/document/data-type/complex-type.js

@@ -69,21 +69,19 @@ class ComplexTypeClass extends ComplexTypeBase {
         return !!this.base?.extendsFrom(baseType);
     }
     toJSON(options) {
+        const superJson = super.toJSON(options);
         const baseName = this.base
             ? this.node.getDataTypeNameWithNs(this.base)
             : undefined;
-        if (options?.scopes && !this.base?.inScope(options?.scopes))
-            throw new TypeError(`Base type ${baseName ? '(' + baseName + ')' : ''} of ${this.name ? +this.name : 'embedded'} type ` +
-                `is not in required scope(s) [${options.scopes}`);
-        const out = omitUndefined({
-            ...ComplexTypeBase.prototype.toJSON.call(this),
+        const out = {
+            ...superJson,
             kind: this.kind,
             base: this.base
                 ? baseName
                     ? baseName
                     : this.base.toJSON(options)
                 : undefined,
-        });
+        };
         if (this.additionalFields) {
             if (this.additionalFields instanceof DataType) {
                 const typeName = this.node.getDataTypeNameWithNs(this.additionalFields);
@@ -98,7 +96,8 @@ class ComplexTypeClass extends ComplexTypeBase {
             const fields = {};
             let i = 0;
             for (const field of this.fields.values()) {
-                if (field.origin === this && field.inScope(options?.scopes)) {
+                if (field.origin === this &&
+                    (!options?.scope || field.inScope(options?.scope))) {
                     fields[field.name] = field.toJSON(options);
                     i++;
                 }
@@ -108,6 +107,14 @@ class ComplexTypeClass extends ComplexTypeBase {
         }
         return omitUndefined(out);
     }
+    _locateBase(callback) {
+        if (!this.base)
+            return;
+        if (callback(this.base))
+            return this.base;
+        if (this.base._locateBase)
+            return this.base._locateBase(callback);
+    }
 }
 ComplexType.prototype = ComplexTypeClass.prototype;
 Object.assign(ComplexType, ComplexTypeDecorator);

package/esm/document/data-type/data-type.js

@@ -3,6 +3,7 @@ import { asMutable } from 'ts-gems';
 import { DocumentElement } from '../common/document-element.js';
 import { CLASS_NAME_PATTERN } from '../constants.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom, } from '../utils/inspect.util.js';
+import { testScopeMatch } from '../utils/test-scope-match.js';
 /**
  * DataType constructor
  */
@@ -17,7 +18,7 @@ context) {
     DocumentElement.call(this, owner);
     const _this = asMutable(this);
     _this.kind = initArgs.kind;
-    _this.scopes = initArgs.scopes;
+    _this.scopePattern = initArgs.scopePattern;
     _this.name = initArgs.name;
     _this.description = initArgs.description;
     _this.abstract = initArgs.abstract;
@@ -31,21 +32,18 @@ class DataTypeClass extends DocumentElement {
     get embedded() {
         return !this.name;
     }
-    inScope(scopes) {
-        if (!this.scopes?.length || !scopes)
-            return true;
-        /** this.scope should match all required scopes */
-        scopes = Array.isArray(scopes) ? scopes : [scopes];
-        for (const scope of scopes) {
-            if (!this.scopes.some(s => {
-                return typeof s === 'string' ? scope === s : s.test(scope);
-            }))
-                return false;
-        }
-        return true;
+    inScope(scope) {
+        return testScopeMatch(scope, this.scopePattern);
     }
-    // eslint-disable-next-line
     toJSON(options) {
+        if (options?.scope) {
+            /** Locate base model which is not available for given scope */
+            const outOfScope = this._locateBase(dt => !dt.inScope(options.scope));
+            if (outOfScope) {
+                const baseName = this.node.getDataTypeNameWithNs(outOfScope);
+                throw new TypeError(`"${baseName}" model is not available for "${options.scope}" scope`);
+            }
+        }
         return omitUndefined({
             kind: this.kind,
             description: this.description,

package/esm/document/data-type/enum-type.js

@@ -49,22 +49,25 @@ class EnumTypeClass extends DataType {
         return vg.isEnum(Object.keys(this.attributes));
     }
     toJSON(options) {
+        const superJson = super.toJSON(options);
         const baseName = this.base
             ? this.node.getDataTypeNameWithNs(this.base)
             : undefined;
-        if (options?.scopes && !this.base?.inScope(options?.scopes))
-            throw new TypeError(`Base type ${baseName ? '(' + baseName + ')' : ''} of ${this.name ? +this.name : 'embedded'} type ` +
-                `is not in required scope(s) [${options.scopes}`);
         return omitUndefined({
-            ...DataType.prototype.toJSON.call(this),
-            base: this.base
-                ? baseName
-                    ? baseName
-                    : this.base.toJSON(options)
-                : undefined,
+            ...superJson,
+            kind: this.kind,
+            base: baseName,
             attributes: cloneObject(this.ownAttributes),
         });
     }
+    _locateBase(callback) {
+        if (!this.base)
+            return;
+        if (callback(this.base))
+            return this.base;
+        if (this.base._locateBase)
+            return this.base._locateBase(callback);
+    }
 }
 EnumType.prototype = EnumTypeClass.prototype;
 Object.assign(EnumType, EnumTypeClass);

package/esm/document/data-type/extended-types/field-path.type.js

@@ -1,33 +1,33 @@
 import { __decorate, __metadata } from "tslib";
 import { toString, validator, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
+import { DataType } from '../data-type.js';
 import { SimpleType } from '../simple-type.js';
 let FieldPathType = class FieldPathType {
     constructor(attributes) {
         if (attributes)
             Object.assign(this, attributes);
     }
-    [DECODER](properties, element) {
+    [DECODER](properties, element, scope) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
         const allowSigns = properties.allowSigns;
-        const decodeFieldPath = validator('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns }));
+        const decodeFieldPath = validator('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns, scope }));
         return vg.pipe([toString, decodeFieldPath]);
     }
-    [ENCODER](properties, element) {
-        return this[DECODER](properties, element);
+    [ENCODER](properties, element, scope) {
+        return this[DECODER](properties, element, scope);
     }
     toJSON(properties, element, options) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
+        /** Test scope */
+        DataType.prototype.toJSON.call(dataType, options);
         const typeName = dataType
             ? element.node.getDataTypeNameWithNs(dataType)
             : undefined;
-        if (options?.scopes && !dataType.inScope(options?.scopes))
-            throw new TypeError(`Data type ${typeName ? '(' + typeName + ')' : ''} ` +
-                `is not in required scope(s) [${options.scopes}`);
         return {
             dataType: typeName ? typeName : dataType.toJSON(options),
             allowSigns: properties.allowSigns,

package/esm/document/data-type/extended-types/filter.type.js

@@ -3,6 +3,7 @@ import { validator } from 'valgen';
 import { FilterRules } from '../../../filter/filter-rules.js';
 import { OpraFilter } from '../../../filter/index.js';
 import { DECODER, ENCODER } from '../../constants.js';
+import { DataType } from '../data-type.js';
 import { SimpleType } from '../simple-type.js';
 let FilterType = class FilterType {
     constructor(attributes) {
@@ -25,12 +26,11 @@ let FilterType = class FilterType {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
+        /** Test scope */
+        DataType.prototype.toJSON.call(dataType, options);
         const typeName = dataType
             ? element.node.getDataTypeNameWithNs(dataType)
             : undefined;
-        if (options?.scopes && !dataType.inScope(options?.scopes))
-            throw new TypeError(`Data type ${typeName ? '(' + typeName + ')' : ''} ` +
-                `is not in required scope(s) [${options.scopes}`);
         return {
             dataType: typeName ? typeName : dataType.toJSON(options),
             rules: properties.rules,
@@ -62,12 +62,12 @@ FilterType = __decorate([
     __metadata("design:paramtypes", [Object])
 ], FilterType);
 export { FilterType };
-const decodeFilter = (dataType, rules, element) => validator('decodeFilter', (input, context, _this) => {
+const decodeFilter = (dataType, rules, scope) => validator('decodeFilter', (input, context, _this) => {
     if (typeof input === 'string') {
         try {
             const filter = OpraFilter.parse(input);
             if (rules)
-                return rules.normalizeFilter(filter, dataType, element);
+                return rules.normalizeFilter(filter, dataType, scope);
             return filter;
         }
         catch (e) {

package/esm/document/data-type/mapped-type.js

@@ -86,14 +86,12 @@ class MappedTypeClass extends ComplexTypeBase {
         return !!this.base?.extendsFrom(baseType);
     }
     toJSON(options) {
+        const superJson = super.toJSON(options);
         const baseName = this.base
             ? this.node.getDataTypeNameWithNs(this.base)
             : undefined;
-        if (options?.scopes && !this.base?.inScope(options?.scopes))
-            throw new TypeError(`Base type ${baseName ? '(' + baseName + ')' : ''} of ${this.name ? +this.name : 'embedded'} type ` +
-                `is not in required scope(s) [${options.scopes}`);
         return omitUndefined({
-            ...ComplexTypeBase.prototype.toJSON.call(this, options),
+            ...superJson,
             base: baseName ? baseName : this.base.toJSON(options),
             kind: this.kind,
             pick: this.pick,
@@ -102,6 +100,14 @@ class MappedTypeClass extends ComplexTypeBase {
             required: this.required,
         });
     }
+    _locateBase(callback) {
+        if (!this.base)
+            return;
+        if (callback(this.base))
+            return this.base;
+        if (this.base._locateBase)
+            return this.base._locateBase(callback);
+    }
 }
 MappedType.prototype = MappedTypeClass.prototype;
 MappedType._applyMixin = () => undefined;

package/esm/document/data-type/mixin-type.js

@@ -55,18 +55,27 @@ class MixinTypeClass extends ComplexTypeBase {
         return false;
     }
     toJSON(options) {
+        const superJson = super.toJSON(options);
         return omitUndefined({
-            ...ComplexTypeBase.prototype.toJSON.call(this),
+            ...superJson,
             kind: this.kind,
             types: this.types.map(base => {
                 const baseName = this.node.getDataTypeNameWithNs(base);
-                if (options?.scopes && !base?.inScope(options?.scopes))
-                    throw new TypeError(`Base type ${baseName ? '(' + baseName + ')' : ''} of ${this.name ? +this.name : 'embedded'} type ` +
-                        `is not in required scope(s) [${options.scopes}`);
                 return baseName ? baseName : base.toJSON(options);
             }),
         });
     }
+    _locateBase(callback) {
+        for (const t of this.types) {
+            if (callback(t))
+                return t;
+            if (t._locateBase) {
+                const x = t._locateBase(callback);
+                if (x)
+                    return x;
+            }
+        }
+    }
 }
 MixinType.prototype = MixinTypeClass.prototype;
 MixinType[DECORATOR] = MixinTypeFactory;

package/esm/document/data-type/simple-type.js

@@ -67,7 +67,7 @@ class SimpleTypeClass extends DataType {
             let t = this;
             while (t) {
                 if (t._generateDecoder)
-                    return t._generateDecoder(prop, options?.documentElement || this.owner);
+                    return t._generateDecoder(prop, options?.documentElement || this.owner, options?.scope);
                 t = this.base;
             }
             return isAny;
@@ -75,12 +75,16 @@ class SimpleTypeClass extends DataType {
         let t = this;
         while (t) {
             if (t._generateEncoder)
-                return t._generateEncoder(prop, options?.documentElement || this.owner);
+                return t._generateEncoder(prop, options?.documentElement || this.owner, options?.scope);
             t = this.base;
         }
         return isAny;
     }
     toJSON(options) {
+        const superJson = super.toJSON(options);
+        const baseName = this.base
+            ? this.node.getDataTypeNameWithNs(this.base)
+            : undefined;
         const attributes = omitUndefined(this.ownAttributes);
         let properties;
         if (this.properties && typeof this.properties.toJSON === 'function') {
@@ -88,22 +92,13 @@ class SimpleTypeClass extends DataType {
         }
         else
             properties = this.properties ? cloneObject(this.properties) : {};
-        const baseName = this.base
-            ? this.node.getDataTypeNameWithNs(this.base)
-            : undefined;
-        if (options?.scopes && !this.base?.inScope(options?.scopes))
-            throw new TypeError(`Base type ${baseName ? '(' + baseName + ')' : ''} of ${this.name ? +this.name : 'embedded'} type ` +
-                `is not in required scope(s) [${options.scopes}`);
-        const out = omitUndefined({
-            ...DataType.prototype.toJSON.apply(this),
-            base: this.base
-                ? baseName
-                    ? baseName
-                    : this.base.toJSON(options)
-                : undefined,
+        const out = {
+            ...superJson,
+            kind: this.kind,
+            base: baseName,
             attributes: attributes && Object.keys(attributes).length ? attributes : undefined,
             properties: Object.keys(properties).length ? properties : undefined,
-        });
+        };
         if (Object.keys(this.ownNameMappings).length)
             out.nameMappings = { ...this.ownNameMappings };
         return omitUndefined(out, true);

package/esm/document/decorators/api-field-decorator.js

@@ -1,7 +1,13 @@
+// import { omitUndefined } from '@jsopen/objects';
+// import { StrictOmit } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
-export function ApiFieldDecorator(options) {
-    return function (target, propertyKey) {
+export function ApiFieldDecoratorFactory(options) {
+    const decoratorChain = [];
+    /**
+     *
+     */
+    const decorator = function (target, propertyKey) {
         if (typeof propertyKey !== 'string')
             throw new TypeError(`Symbol properties can't be used as a field`);
         const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) ||
@@ -11,6 +17,11 @@ export function ApiFieldDecorator(options) {
         const designType = Reflect.getMetadata('design:type', target, propertyKey);
         const elemMeta = (metadata.fields[propertyKey] = {
             ...options,
+            scopePattern: options?.scopePattern
+                ? Array.isArray(options.scopePattern)
+                    ? options.scopePattern
+                    : [options.scopePattern]
+                : undefined,
         });
         if (designType === Array) {
             elemMeta.isArray = true;
@@ -18,5 +29,28 @@ export function ApiFieldDecorator(options) {
         else
             elemMeta.type = elemMeta.type || designType;
         Reflect.defineMetadata(DATATYPE_METADATA, metadata, target.constructor);
+        for (const fn of decoratorChain)
+            fn(metadata, target);
     };
+    // /**
+    //  *
+    //  */
+    // decorator.Override = (
+    //   scopes: (string | RegExp) | (string | RegExp)[],
+    //   opts: StrictOmit<ApiField.Options, 'isArray' | 'type' | 'scopePattern'>,
+    // ): any => {
+    //   decoratorChain.push((meta: ApiField.Metadata): void => {
+    //     meta.overrides = meta.overrides || [];
+    //     meta.overrides.push(
+    //       omitUndefined({
+    //         ...opts,
+    //         scopes: Array.isArray(scopes) ? scopes : [scopes],
+    //         type: undefined,
+    //         isArray: undefined,
+    //       }),
+    //     );
+    //   });
+    //   return decorator;
+    // };
+    return decorator;
 }

package/esm/document/decorators/simple-type.decorator.js

@@ -24,6 +24,8 @@ export function SimpleTypeDecoratorFactory(options) {
         metadata.kind = OpraSchema.SimpleType.Kind;
         metadata.name = name;
         Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
+        for (const fn of decoratorChain)
+            fn(metadata, target);
     };
     decorator.Example = (value, description) => {
         decoratorChain.push((meta) => {

package/esm/document/factory/api-document.factory.js

@@ -27,7 +27,6 @@ export class ApiDocumentFactory {
             : new DocumentInitContext(options);
         try {
             const document = new ApiDocument();
-            document.scopes = context.scopes;
             await factory.initDocument(document, context, schemaOrUrl);
             if (context.error.details.length)
                 throw context.error;

package/esm/document/utils/test-scope-match.js

@@ -0,0 +1,10 @@
+export function testScopeMatch(scope, pattern) {
+    if (!(scope && pattern))
+        return true;
+    if (Array.isArray(pattern)) {
+        return pattern.some(x => {
+            return typeof x === 'string' ? scope === x : x.test(scope);
+        });
+    }
+    return typeof pattern === 'string' ? scope === pattern : pattern.test(scope);
+}

package/esm/filter/filter-rules.js

@@ -29,12 +29,11 @@ export class FilterRules {
             operators,
         }));
     }
-    normalizeFilter(filter, currentType, element) {
+    normalizeFilter(filter, currentType, scope) {
         const ast = typeof filter === 'string' ? parse(filter) : filter;
-        const doc = element?.node.getDocument();
-        return this.normalizeFilterAst(ast, [], currentType, doc?.scopes);
+        return this.normalizeFilterAst(ast, [], currentType, scope);
     }
-    normalizeFilterAst(ast, stack, currentType, scopes) {
+    normalizeFilterAst(ast, stack, currentType, scope) {
         if (ast instanceof ComparisonExpression) {
             stack.push(ast);
             this.normalizeFilterAst(ast.left, stack, currentType);
@@ -97,8 +96,8 @@ export class FilterRules {
             return ast;
         }
         if (ast instanceof QualifiedIdentifier && currentType) {
-            ast.value = currentType.normalizeFieldPath(ast.value);
-            ast.field = currentType.getField(ast.value);
+            ast.value = currentType.normalizeFieldPath(ast.value, { scope });
+            ast.field = currentType.getField(ast.value, scope);
             ast.dataType = ast.field.type;
             return ast;
         }
@@ -126,7 +125,7 @@ export class FilterRules {
                             decoder = this._decoderCache.get(comp.left.field);
                         if (!decoder) {
                             decoder = comp.left.field.type.generateCodec('decode', {
-                                scope: scopes,
+                                scope,
                                 projection: '*',
                                 ignoreWriteonlyFields: true,
                                 coerce: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",