@opra/common 1.4.4 → 1.5.1

package/esm/document/data-type/primitive-types/any.type.js

@@ -16,6 +16,7 @@ let AnyType = class AnyType {
 };
 AnyType = __decorate([
     SimpleType({
+        name: 'any',
         description: 'Represents any value',
     }),
     __metadata("design:paramtypes", [Object])

package/esm/document/data-type/primitive-types/bigint.type.js

@@ -23,6 +23,7 @@ let BigintType = class BigintType extends NumberType {
 };
 BigintType = __decorate([
     SimpleType({
+        name: 'bigint',
         description: 'BigInt number',
         nameMappings: {
             js: 'bigint',

package/esm/document/data-type/primitive-types/boolean.type.js

@@ -16,6 +16,7 @@ let BooleanType = class BooleanType {
 };
 BooleanType = __decorate([
     SimpleType({
+        name: 'boolean',
         description: 'Simple true/false value',
         nameMappings: {
             js: 'boolean',

package/esm/document/data-type/primitive-types/integer.type.js

@@ -23,6 +23,7 @@ let IntegerType = class IntegerType extends NumberType {
 };
 IntegerType = __decorate([
     SimpleType({
+        name: 'integer',
         description: 'An integer number',
         nameMappings: {
             js: 'number',

package/esm/document/data-type/primitive-types/null.type.js

@@ -16,6 +16,7 @@ let NullType = class NullType {
 };
 NullType = __decorate([
     SimpleType({
+        name: 'null',
         description: 'A Null value',
         nameMappings: {
             js: 'null',

package/esm/document/data-type/primitive-types/number.type.js

@@ -35,6 +35,7 @@ __decorate([
 ], NumberType.prototype, "maxValue", void 0);
 NumberType = __decorate([
     SimpleType({
+        name: 'number',
         description: 'Both Integer as well as Floating-Point numbers',
         nameMappings: {
             js: 'number',

package/esm/document/data-type/primitive-types/string.type.js

@@ -55,6 +55,7 @@ __decorate([
 ], StringType.prototype, "maxLength", void 0);
 StringType = __decorate([
     SimpleType({
+        name: 'string',
         description: 'A sequence of characters',
         nameMappings: {
             js: 'string',

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,28 +75,30 @@ 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() {
+    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') {
-            properties = this.properties.toJSON(this.properties, this.owner);
+            properties = this.properties.toJSON(this.properties, this.owner, options);
         }
         else
             properties = this.properties ? cloneObject(this.properties) : {};
-        const baseName = this.base
-            ? this.node.getDataTypeNameWithNs(this.base)
-            : undefined;
-        const out = omitUndefined({
-            ...DataType.prototype.toJSON.apply(this),
-            base: this.base ? (baseName ? baseName : this.base.toJSON()) : 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/complex-type.decorator.js

@@ -1,6 +1,6 @@
 import { omit } from '@jsopen/objects';
 import { OpraSchema } from '../../schema/index.js';
-import { CLASS_NAME_PATTERN, DATATYPE_METADATA, EXTRACT_TYPENAME_PATTERN, } from '../constants.js';
+import { CLASS_NAME_PATTERN, DATATYPE_METADATA } from '../constants.js';
 export function ComplexTypeDecorator(options) {
     return function (target) {
         let name;
@@ -11,7 +11,7 @@ export function ComplexTypeDecorator(options) {
                 name = options.name;
             }
             else {
-                name = target.name.match(EXTRACT_TYPENAME_PATTERN)?.[1] || target.name;
+                name = target.name;
             }
         }
         let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);

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

@@ -1,5 +1,5 @@
 import { OpraSchema } from '../../schema/index.js';
-import { CLASS_NAME_PATTERN, DATATYPE_METADATA, EXTRACT_TYPENAME_PATTERN, } from '../constants.js';
+import { CLASS_NAME_PATTERN, DATATYPE_METADATA } from '../constants.js';
 export function SimpleTypeDecoratorFactory(options) {
     const decoratorChain = [];
     /**
@@ -14,7 +14,7 @@ export function SimpleTypeDecoratorFactory(options) {
                 name = options.name;
             }
             else {
-                name = target.name.match(EXTRACT_TYPENAME_PATTERN)?.[1] || target.name;
+                name = target.name;
                 name = name.toLowerCase();
             }
         }
@@ -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/http/http-api.js

@@ -20,7 +20,7 @@ export class HttpApi extends ApiBase {
         const controller = this.findController(arg0);
         return controller?.operations.get(operationName);
     }
-    toJSON() {
+    toJSON(options) {
         const schema = super.toJSON();
         const out = {
             ...schema,
@@ -29,7 +29,7 @@ export class HttpApi extends ApiBase {
             controllers: {},
         };
         for (const v of this.controllers.values()) {
-            out.controllers[v.name] = v.toJSON();
+            out.controllers[v.name] = v.toJSON(options);
         }
         return out;
     }

package/esm/document/http/http-controller.js

@@ -111,7 +111,7 @@ class HttpControllerClass extends DocumentElement {
     /**
      *
      */
-    toJSON() {
+    toJSON(options) {
         const out = omitUndefined({
             kind: this.kind,
             description: this.description,
@@ -120,25 +120,25 @@ class HttpControllerClass extends DocumentElement {
         if (this.operations.size) {
             out.operations = {};
             for (const v of this.operations.values()) {
-                out.operations[v.name] = v.toJSON();
+                out.operations[v.name] = v.toJSON(options);
             }
         }
         if (this.controllers.size) {
             out.controllers = {};
             for (const v of this.controllers.values()) {
-                out.controllers[v.name] = v.toJSON();
+                out.controllers[v.name] = v.toJSON(options);
             }
         }
         if (this.types.size) {
             out.types = {};
             for (const v of this.types.values()) {
-                out.types[v.name] = v.toJSON();
+                out.types[v.name] = v.toJSON(options);
             }
         }
         if (this.parameters.length) {
             out.parameters = [];
             for (const prm of this.parameters) {
-                out.parameters.push(prm.toJSON());
+                out.parameters.push(prm.toJSON(options));
             }
         }
         return out;

package/esm/document/http/http-media-type.js

@@ -48,7 +48,7 @@ class HttpMediaTypeClass extends DocumentElement {
             }
         }
     }
-    toJSON() {
+    toJSON(options) {
         const typeName = this.type
             ? this.node.getDataTypeNameWithNs(this.type)
             : undefined;
@@ -56,7 +56,7 @@ class HttpMediaTypeClass extends DocumentElement {
             description: this.description,
             contentType: this.contentType,
             contentEncoding: this.contentEncoding,
-            type: typeName ? typeName : this.type?.toJSON(),
+            type: typeName ? typeName : this.type?.toJSON(options),
             isArray: this.isArray,
             example: this.example,
             examples: this.examples,
@@ -67,7 +67,7 @@ class HttpMediaTypeClass extends DocumentElement {
             maxTotalFileSize: this.maxTotalFileSize,
         });
         if (this.multipartFields?.length) {
-            out.multipartFields = this.multipartFields.map(x => x.toJSON());
+            out.multipartFields = this.multipartFields.map(x => x.toJSON(options));
         }
         return out;
     }

package/esm/document/http/http-multipart-field.js

@@ -17,12 +17,12 @@ export class HttpMultipartField extends HttpMediaType {
         this.fieldType = initArgs.fieldType;
         this.required = initArgs.required;
     }
-    toJSON() {
+    toJSON(options) {
         return omitUndefined({
             fieldName: this.fieldName,
             fieldType: this.fieldType,
             required: this.required,
-            ...super.toJSON(),
+            ...super.toJSON(options),
         });
     }
 }

package/esm/document/http/http-operation-response.js

@@ -23,10 +23,10 @@ export class HttpOperationResponse extends HttpMediaType {
             }
         }
     }
-    toJSON() {
+    toJSON(options) {
         const statusCode = this.statusCode.map(x => x.toJSON());
         const out = omitUndefined({
-            ...super.toJSON(),
+            ...super.toJSON(options),
             statusCode: statusCode.length === 1 && typeof statusCode[0] === 'number'
                 ? statusCode[0]
                 : statusCode,
@@ -35,7 +35,7 @@ export class HttpOperationResponse extends HttpMediaType {
         if (this.parameters.length) {
             out.parameters = [];
             for (const prm of this.parameters) {
-                out.parameters.push(prm.toJSON());
+                out.parameters.push(prm.toJSON(options));
             }
         }
         return out;

package/esm/document/http/http-operation.js

@@ -67,7 +67,7 @@ class HttpOperationClass extends DocumentElement {
         }
         return this.path || '/';
     }
-    toJSON() {
+    toJSON(options) {
         const out = omitUndefined({
             kind: OpraSchema.HttpOperation.Kind,
             description: this.description,
@@ -75,22 +75,22 @@ class HttpOperationClass extends DocumentElement {
             path: this.path,
             mergePath: this.mergePath,
             composition: this.composition,
-            requestBody: this.requestBody?.toJSON(),
+            requestBody: this.requestBody?.toJSON(options),
         });
         if (this.types.size) {
             out.types = {};
             for (const v of this.types.values()) {
-                out.types[v.name] = v.toJSON();
+                out.types[v.name] = v.toJSON(options);
             }
         }
         if (this.parameters.length) {
             out.parameters = [];
             for (const prm of this.parameters) {
-                out.parameters.push(prm.toJSON());
+                out.parameters.push(prm.toJSON(options));
             }
         }
         if (this.responses.length)
-            out.responses = this.responses.map(r => r.toJSON());
+            out.responses = this.responses.map(r => r.toJSON(options));
         return out;
     }
 }

package/esm/document/http/http-parameter.js

@@ -30,9 +30,9 @@ export const HttpParameter = function (owner, initArgs) {
  * @class HttpParameter
  */
 class HttpParameterClass extends Value {
-    toJSON() {
+    toJSON(options) {
         return omitUndefined({
-            ...super.toJSON(),
+            ...super.toJSON(options),
             name: this.name,
             location: this.location,
             arraySeparator: this.arraySeparator,

package/esm/document/http/http-request-body.js

@@ -8,12 +8,14 @@ export class HttpRequestBody extends DocumentElement {
         super(owner);
         this.content = [];
     }
-    toJSON() {
+    toJSON(options) {
         return omitUndefined({
             description: this.description,
             required: this.required,
             maxContentSize: this.maxContentSize,
-            content: this.content.length ? this.content.map(x => x.toJSON()) : [],
+            content: this.content.length
+                ? this.content.map(x => x.toJSON(options))
+                : [],
             partial: this.partial,
             allowPatchOperators: this.allowPatchOperators,
         });

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,11 +29,11 @@ export class FilterRules {
             operators,
         }));
     }
-    normalizeFilter(filter, currentType) {
+    normalizeFilter(filter, currentType, scope) {
         const ast = typeof filter === 'string' ? parse(filter) : filter;
-        return this.normalizeFilterAst(ast, [], currentType);
+        return this.normalizeFilterAst(ast, [], currentType, scope);
     }
-    normalizeFilterAst(ast, stack, currentType) {
+    normalizeFilterAst(ast, stack, currentType, scope) {
         if (ast instanceof ComparisonExpression) {
             stack.push(ast);
             this.normalizeFilterAst(ast.left, stack, currentType);
@@ -96,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;
         }
@@ -125,9 +125,9 @@ export class FilterRules {
                             decoder = this._decoderCache.get(comp.left.field);
                         if (!decoder) {
                             decoder = comp.left.field.type.generateCodec('decode', {
+                                scope,
                                 projection: '*',
                                 ignoreWriteonlyFields: true,
-                                ignoreHiddenFields: true,
                                 coerce: true,
                             });
                             this._decoderCache.set(comp.left.field, decoder);

package/package.json

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

package/types/document/api-document.d.ts

@@ -33,7 +33,12 @@ export declare class ApiDocument extends DocumentElement {
     /**
      * Export as Opra schema definition object
      */
-    export(): OpraSchema.ApiDocument;
+    export(options?: ApiDocument.ExportOptions): OpraSchema.ApiDocument;
     invalidate(): void;
-    protected _findDataType(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject, visitedRefs?: WeakMap<ApiDocument, boolean>): DataType | undefined;
+    protected _findDataType(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject, scope?: string, visitedRefs?: WeakMap<ApiDocument, boolean>): DataType | undefined;
+}
+export declare namespace ApiDocument {
+    interface ExportOptions {
+        scope?: string;
+    }
 }

package/types/document/common/api-base.d.ts

@@ -13,6 +13,6 @@ export declare abstract class ApiBase extends DocumentElement {
     name: string;
     description?: string;
     protected constructor(init: ApiBase.InitArguments);
-    toJSON(): OpraSchema.Api;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.Api;
     protected _initialize(init: ApiBase.InitArguments, context: DocumentInitContext): Promise<void>;
 }

package/types/document/common/document-init-context.d.ts

@@ -2,6 +2,7 @@ import { OpraDocumentError } from './opra-document-error.js';
 export declare namespace DocumentInitContext {
     interface Options {
         maxErrors?: number;
+        scopes?: string | string[];
     }
 }
 export declare class DocumentInitContext {

package/types/document/common/document-node.d.ts

@@ -19,47 +19,41 @@ export declare class DocumentNode {
     readonly element: DocumentElement;
     constructor(element: DocumentElement, parent?: DocumentNode);
     getDocument(): ApiDocument;
-    hasDataType(nameOrCtor: string | Type | Function | object | any[]): boolean;
-    findDataType(nameOrCtor: string | Type | Function | object | any[]): DataType | undefined;
+    hasDataType(nameOrCtor: string | Type | Function | object | any[], scope?: string): boolean;
+    findDataType(nameOrCtor: string | Type | Function | object | any[], scope?: string): DataType | undefined;
     /**
      * Returns DataType instance by name or Constructor. Returns undefined if not found
-     * @param nameOrCtor
      */
-    getDataType(nameOrCtor: string | Type | Function | object | any[]): DataType;
+    getDataType(nameOrCtor: string | Type | Function | object | any[], scope?: string): DataType;
     getDataTypeNameWithNs(dataType: DataType): string | undefined;
     /**
      * Returns ComplexType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a ComplexType
-     * @param nameOrCtor
      */
-    getComplexType(nameOrCtor: string | Type | Function): ComplexType;
+    getComplexType(nameOrCtor: string | Type | Function, scope?: string): ComplexType;
     /**
      * Returns SimpleType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a SimpleType
-     * @param nameOrCtor
      */
-    getSimpleType(nameOrCtor: string | Type): SimpleType;
+    getSimpleType(nameOrCtor: string | Type, scope?: string): SimpleType;
     /**
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a EnumType
-     * @param nameOrCtor
      */
-    getEnumType(nameOrCtor: string | object | any[]): EnumType;
+    getEnumType(nameOrCtor: string | object | any[], scope?: string): EnumType;
     /**
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a MappedType
-     * @param nameOrCtor
      */
-    getMappedType(nameOrCtor: string | object | any[]): MappedType;
+    getMappedType(nameOrCtor: string | object | any[], scope?: string): MappedType;
     /**
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a MixinType
-     * @param nameOrCtor
      */
-    getMixinType(nameOrCtor: string | object | any[]): MixinType;
+    getMixinType(nameOrCtor: string | object | any[], scope?: string): MixinType;
 }

package/types/document/common/value.d.ts

@@ -1,5 +1,6 @@
 import type { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
 import type { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
 import { DataType } from '../data-type/data-type.js';
 import type { EnumType } from '../data-type/enum-type.js';
 import { DocumentElement } from './document-element.js';
@@ -43,6 +44,6 @@ declare class ValueClass extends DocumentElement {
     description?: string;
     examples?: any[] | Record<string, any>;
     isArray?: boolean;
-    toJSON(): OpraSchema.Value;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.Value;
 }
 export {};

package/types/document/constants.d.ts

@@ -7,7 +7,6 @@ export declare const DECORATOR: unique symbol;
 export declare const BUILTIN: unique symbol;
 export declare const NAMESPACE_PATTERN: RegExp;
 export declare const CLASS_NAME_PATTERN: RegExp;
-export declare const EXTRACT_TYPENAME_PATTERN: RegExp;
 export declare const kDataTypeMap: unique symbol;
 export declare const kCtorMap: unique symbol;
 export declare const kTypeNSMap: unique symbol;