@opra/common 1.5.0 → 1.5.2

package/cjs/document/api-document.js

@@ -74,7 +74,6 @@ class ApiDocument extends document_element_js_1.DocumentElement {
             url: this.url,
             info: (0, index_js_1.cloneObject)(this.info, true),
         });
-        options = options || { scopes: this.scopes };
         if (this.references.size) {
             let i = 0;
             const references = {};
@@ -94,7 +93,7 @@ class ApiDocument extends document_element_js_1.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);
             }
@@ -113,7 +112,7 @@ class ApiDocument extends document_element_js_1.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/cjs/document/common/document-init-context.js

@@ -9,11 +9,6 @@ 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/cjs/document/common/document-node.js

@@ -25,9 +25,8 @@ class DocumentNode {
         return !!this.findDataType(nameOrCtor, scope);
     }
     findDataType(nameOrCtor, scope) {
-        scope = scope || this.getDocument().scopes;
         const dt = this[constants_js_1.kDataTypeMap]?.get(nameOrCtor);
-        if (dt && dt.inScope(scope))
+        if (dt && (!scope || dt.inScope(scope)))
             return dt;
         return this.parent
             ? this.parent.findDataType(nameOrCtor, scope)
@@ -38,7 +37,7 @@ 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/cjs/document/data-type/api-field.js

@@ -6,9 +6,9 @@ const ts_gems_1 = require("ts-gems");
 const document_element_js_1 = require("../common/document-element.js");
 const constants_js_1 = require("../constants.js");
 const api_field_decorator_js_1 = require("../decorators/api-field-decorator.js");
+const test_scope_match_js_1 = require("../utils/test-scope-match.js");
 const complex_type_base_js_1 = require("./complex-type-base.js");
 /**
- * @constructor ApiField
  * @decorator ApiField
  */
 exports.ApiField = function (...args) {
@@ -28,7 +28,7 @@ exports.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;
@@ -44,22 +44,13 @@ exports.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 document_element_js_1.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 (0, test_scope_match_js_1.testScopeMatch)(scope, this.scopePattern);
     }
     toJSON(options) {
         const typeName = this.type
@@ -83,5 +74,5 @@ class ApiFieldClass extends document_element_js_1.DocumentElement {
     }
 }
 exports.ApiField.prototype = ApiFieldClass.prototype;
-Object.assign(exports.ApiField, api_field_decorator_js_1.ApiFieldDecorator);
-exports.ApiField[constants_js_1.DECORATOR] = api_field_decorator_js_1.ApiFieldDecorator;
+Object.assign(exports.ApiField, api_field_decorator_js_1.ApiFieldDecoratorFactory);
+exports.ApiField[constants_js_1.DECORATOR] = api_field_decorator_js_1.ApiFieldDecoratorFactory;

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

@@ -4,7 +4,6 @@ exports.ComplexTypeBase = exports.FIELD_PATH_PATTERN = void 0;
 const ts_gems_1 = require("ts-gems");
 const valgen_1 = require("valgen");
 const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../i18n/index.js");
 const data_type_js_1 = require("./data-type.js");
 exports.FIELD_PATH_PATTERN = /^([+-])?([a-z$_][\w.]*)$/i;
 /**
@@ -27,21 +26,29 @@ class ComplexTypeBaseClass extends data_type_js_1.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((0, index_js_2.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;
     }
     /**
@@ -72,7 +79,7 @@ class ComplexTypeBaseClass extends data_type_js_1.DataType {
             }
             if (dataType) {
                 if (dataType instanceof exports.ComplexTypeBase) {
-                    field = dataType.fields.get(item.fieldName);
+                    field = dataType.getField(item.fieldName, options?.scope);
                     if (field) {
                         item.fieldName = field.name;
                         item.field = field;
@@ -149,17 +156,12 @@ class ComplexTypeBaseClass extends data_type_js_1.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/cjs/document/data-type/complex-type.js

@@ -72,21 +72,19 @@ class ComplexTypeClass extends complex_type_base_js_1.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 = (0, objects_1.omitUndefined)({
-            ...complex_type_base_js_1.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 data_type_js_1.DataType) {
                 const typeName = this.node.getDataTypeNameWithNs(this.additionalFields);
@@ -101,7 +99,8 @@ class ComplexTypeClass extends complex_type_base_js_1.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++;
                 }
@@ -111,6 +110,14 @@ class ComplexTypeClass extends complex_type_base_js_1.ComplexTypeBase {
         }
         return (0, objects_1.omitUndefined)(out);
     }
+    _locateBase(callback) {
+        if (!this.base)
+            return;
+        if (callback(this.base))
+            return this.base;
+        if (this.base._locateBase)
+            return this.base._locateBase(callback);
+    }
 }
 exports.ComplexType.prototype = ComplexTypeClass.prototype;
 Object.assign(exports.ComplexType, complex_type_decorator_js_1.ComplexTypeDecorator);

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

@@ -6,6 +6,7 @@ const ts_gems_1 = require("ts-gems");
 const document_element_js_1 = require("../common/document-element.js");
 const constants_js_1 = require("../constants.js");
 const inspect_util_js_1 = require("../utils/inspect.util.js");
+const test_scope_match_js_1 = require("../utils/test-scope-match.js");
 /**
  * DataType constructor
  */
@@ -20,7 +21,7 @@ context) {
     document_element_js_1.DocumentElement.call(this, owner);
     const _this = (0, ts_gems_1.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;
@@ -34,21 +35,18 @@ class DataTypeClass extends document_element_js_1.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 (0, test_scope_match_js_1.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 (0, objects_1.omitUndefined)({
             kind: this.kind,
             description: this.description,

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

@@ -52,22 +52,25 @@ class EnumTypeClass extends data_type_js_1.DataType {
         return valgen_1.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 (0, objects_1.omitUndefined)({
-            ...data_type_js_1.DataType.prototype.toJSON.call(this),
-            base: this.base
-                ? baseName
-                    ? baseName
-                    : this.base.toJSON(options)
-                : undefined,
+            ...superJson,
+            kind: this.kind,
+            base: baseName,
             attributes: (0, index_js_1.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);
+    }
 }
 exports.EnumType.prototype = EnumTypeClass.prototype;
 Object.assign(exports.EnumType, EnumTypeClass);

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

@@ -4,33 +4,33 @@ exports.FieldPathType = void 0;
 const tslib_1 = require("tslib");
 const valgen_1 = require("valgen");
 const constants_js_1 = require("../../constants.js");
+const data_type_js_1 = require("../data-type.js");
 const simple_type_js_1 = require("../simple-type.js");
 let FieldPathType = class FieldPathType {
     constructor(attributes) {
         if (attributes)
             Object.assign(this, attributes);
     }
-    [constants_js_1.DECODER](properties, element) {
+    [constants_js_1.DECODER](properties, element, scope) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
         const allowSigns = properties.allowSigns;
-        const decodeFieldPath = (0, valgen_1.validator)('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns }));
+        const decodeFieldPath = (0, valgen_1.validator)('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns, scope }));
         return valgen_1.vg.pipe([valgen_1.toString, decodeFieldPath]);
     }
-    [constants_js_1.ENCODER](properties, element) {
-        return this[constants_js_1.DECODER](properties, element);
+    [constants_js_1.ENCODER](properties, element, scope) {
+        return this[constants_js_1.DECODER](properties, element, scope);
     }
     toJSON(properties, element, options) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
+        /** Test scope */
+        data_type_js_1.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/cjs/document/data-type/extended-types/filter.type.js

@@ -6,6 +6,7 @@ const valgen_1 = require("valgen");
 const filter_rules_js_1 = require("../../../filter/filter-rules.js");
 const index_js_1 = require("../../../filter/index.js");
 const constants_js_1 = require("../../constants.js");
+const data_type_js_1 = require("../data-type.js");
 const simple_type_js_1 = require("../simple-type.js");
 let FilterType = class FilterType {
     constructor(attributes) {
@@ -28,12 +29,11 @@ let FilterType = class FilterType {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
+        /** Test scope */
+        data_type_js_1.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,
@@ -65,12 +65,12 @@ exports.FilterType = FilterType = tslib_1.__decorate([
     }),
     tslib_1.__metadata("design:paramtypes", [Object])
 ], FilterType);
-const decodeFilter = (dataType, rules, element) => (0, valgen_1.validator)('decodeFilter', (input, context, _this) => {
+const decodeFilter = (dataType, rules, scope) => (0, valgen_1.validator)('decodeFilter', (input, context, _this) => {
     if (typeof input === 'string') {
         try {
             const filter = index_js_1.OpraFilter.parse(input);
             if (rules)
-                return rules.normalizeFilter(filter, dataType, element);
+                return rules.normalizeFilter(filter, dataType, scope);
             return filter;
         }
         catch (e) {

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

@@ -89,14 +89,12 @@ class MappedTypeClass extends complex_type_base_js_1.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 (0, objects_1.omitUndefined)({
-            ...complex_type_base_js_1.ComplexTypeBase.prototype.toJSON.call(this, options),
+            ...superJson,
             base: baseName ? baseName : this.base.toJSON(options),
             kind: this.kind,
             pick: this.pick,
@@ -105,6 +103,14 @@ class MappedTypeClass extends complex_type_base_js_1.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);
+    }
 }
 exports.MappedType.prototype = MappedTypeClass.prototype;
 exports.MappedType._applyMixin = () => undefined;

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

@@ -58,18 +58,27 @@ class MixinTypeClass extends complex_type_base_js_1.ComplexTypeBase {
         return false;
     }
     toJSON(options) {
+        const superJson = super.toJSON(options);
         return (0, objects_1.omitUndefined)({
-            ...complex_type_base_js_1.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;
+            }
+        }
+    }
 }
 exports.MixinType.prototype = MixinTypeClass.prototype;
 exports.MixinType[constants_js_1.DECORATOR] = MixinTypeFactory;

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

@@ -70,7 +70,7 @@ class SimpleTypeClass extends data_type_js_1.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 valgen_1.isAny;
@@ -78,12 +78,16 @@ class SimpleTypeClass extends data_type_js_1.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 valgen_1.isAny;
     }
     toJSON(options) {
+        const superJson = super.toJSON(options);
+        const baseName = this.base
+            ? this.node.getDataTypeNameWithNs(this.base)
+            : undefined;
         const attributes = (0, objects_1.omitUndefined)(this.ownAttributes);
         let properties;
         if (this.properties && typeof this.properties.toJSON === 'function') {
@@ -91,22 +95,13 @@ class SimpleTypeClass extends data_type_js_1.DataType {
         }
         else
             properties = this.properties ? (0, index_js_1.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 = (0, objects_1.omitUndefined)({
-            ...data_type_js_1.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 (0, objects_1.omitUndefined)(out, true);

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

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiFieldDecorator = ApiFieldDecorator;
+exports.ApiFieldDecoratorFactory = ApiFieldDecoratorFactory;
+// import { omitUndefined } from '@jsopen/objects';
+// import { StrictOmit } from 'ts-gems';
 const index_js_1 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
-function ApiFieldDecorator(options) {
-    return function (target, propertyKey) {
+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(constants_js_1.DATATYPE_METADATA, target.constructor) ||
@@ -14,6 +20,11 @@ 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;
@@ -21,5 +32,28 @@ function ApiFieldDecorator(options) {
         else
             elemMeta.type = elemMeta.type || designType;
         Reflect.defineMetadata(constants_js_1.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/cjs/document/decorators/simple-type.decorator.js

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

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testScopeMatch = testScopeMatch;
+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/cjs/filter/filter-rules.js

@@ -32,12 +32,11 @@ class FilterRules {
             operators,
         }));
     }
-    normalizeFilter(filter, currentType, element) {
+    normalizeFilter(filter, currentType, scope) {
         const ast = typeof filter === 'string' ? (0, parse_js_1.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 index_js_4.ComparisonExpression) {
             stack.push(ast);
             this.normalizeFilterAst(ast.left, stack, currentType);
@@ -100,8 +99,8 @@ class FilterRules {
             return ast;
         }
         if (ast instanceof index_js_4.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;
         }
@@ -129,7 +128,7 @@ 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,