@opra/common 1.19.7 → 1.20.0

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

@@ -18,7 +18,7 @@ let DateType = class DateType {
     }
     [DECODER](properties) {
         let fn;
-        if (properties.convertToNative) {
+        if (properties.designType === Date) {
             fn = _isDate;
         }
         else {

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

@@ -8,7 +8,7 @@ let FieldPathType = class FieldPathType {
         if (attributes)
             Object.assign(this, attributes);
     }
-    [DECODER](properties, element, scope) {
+    [DECODER](properties, { element, scope, }) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');
@@ -16,8 +16,8 @@ let FieldPathType = class FieldPathType {
         const decodeFieldPath = validator('decodeFieldPath', (input) => dataType.normalizeFieldPath(input, { allowSigns, scope }));
         return vg.pipe([toString, decodeFieldPath]);
     }
-    [ENCODER](properties, element, scope) {
-        return this[DECODER](properties, element, scope);
+    [ENCODER](properties, args) {
+        return this[DECODER](properties, args);
     }
     toJSON(properties, element, options) {
         const dataType = properties.dataType

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

@@ -10,7 +10,7 @@ let FilterType = class FilterType {
         if (attributes)
             Object.assign(this, attributes);
     }
-    [DECODER](properties, element) {
+    [DECODER](properties, { element }) {
         const dataType = properties.dataType
             ? element.node.getComplexType(properties.dataType)
             : element.node.getComplexType('object');

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

@@ -71,7 +71,11 @@ class SimpleTypeClass extends DataType {
             let t = this;
             while (t) {
                 if (t._generateDecoder)
-                    return t._generateDecoder(prop, options?.documentElement || this.owner, options?.scope);
+                    return t._generateDecoder(prop, {
+                        dataType: this,
+                        element: options?.documentElement || this.owner,
+                        scope: options?.scope,
+                    });
                 t = this.base;
             }
             return isAny;
@@ -79,7 +83,11 @@ class SimpleTypeClass extends DataType {
         let t = this;
         while (t) {
             if (t._generateEncoder)
-                return t._generateEncoder(prop, options?.documentElement || this.owner, options?.scope);
+                return t._generateEncoder(prop, {
+                    dataType: this,
+                    element: options?.documentElement || this.owner,
+                    scope: options?.scope,
+                });
             t = this.base;
         }
         return isAny;

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

@@ -1,3 +1,4 @@
+import { isConstructor } from '@jsopen/objects';
 import { MimeTypes } from '../../enums/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { HTTP_CONTROLLER_METADATA } from '../constants.js';
@@ -31,6 +32,8 @@ export function HttpOperationDecoratorFactory(decoratorChain, options) {
                     type: arg1,
                 }
                 : { ...arg1, name, location: 'cookie' };
+            if (isConstructor(paramMeta.type))
+                paramMeta.designType = paramMeta.type;
             if (meta.parameters) {
                 meta.parameters = meta.parameters.filter(p => !(p.location === 'cookie' && String(p.name) === String(name)));
             }
@@ -52,6 +55,8 @@ export function HttpOperationDecoratorFactory(decoratorChain, options) {
                     type: arg1,
                 }
                 : { ...arg1, name, location: 'header' };
+            if (isConstructor(paramMeta.type))
+                paramMeta.designType = paramMeta.type;
             if (meta.parameters) {
                 meta.parameters = meta.parameters.filter(p => !(p.location === 'header' && String(p.name) === String(name)));
             }
@@ -73,6 +78,8 @@ export function HttpOperationDecoratorFactory(decoratorChain, options) {
                     type: arg1,
                 }
                 : { ...arg1, name, location: 'query' };
+            if (isConstructor(paramMeta.type))
+                paramMeta.designType = paramMeta.type;
             if (meta.parameters) {
                 meta.parameters = meta.parameters.filter(p => !(p.location === 'query' && String(p.name) === String(name)));
             }
@@ -94,6 +101,8 @@ export function HttpOperationDecoratorFactory(decoratorChain, options) {
                     type: arg1,
                 }
                 : { ...arg1, name, location: 'path' };
+            if (isConstructor(paramMeta.type))
+                paramMeta.designType = paramMeta.type;
             if (meta.parameters) {
                 meta.parameters = meta.parameters.filter(p => !(p.location === 'path' && String(p.name) === String(name)));
             }
@@ -119,6 +128,8 @@ export function HttpOperationDecoratorFactory(decoratorChain, options) {
         if (responseMeta.contentType === MimeTypes.opra_response_json) {
             responseMeta.contentEncoding = responseMeta.contentEncoding || 'utf-8';
         }
+        if (isConstructor(responseMeta.type))
+            responseMeta.designType = responseMeta.type;
         decoratorChain.push((meta) => {
             meta.responses = meta.responses || [];
             meta.responses.push(responseMeta);
@@ -130,6 +141,8 @@ export function HttpOperationDecoratorFactory(decoratorChain, options) {
         if (contentMeta.type) {
             contentMeta.contentType = contentMeta.contentType || MimeTypes.json;
             contentMeta.contentEncoding = contentMeta.contentEncoding || 'utf-8';
+            if (isConstructor(contentMeta.type))
+                contentMeta.designType = contentMeta.type;
         }
         decoratorChain.push((operationMetadata) => {
             operationMetadata.requestBody = operationMetadata.requestBody || {

package/esm/document/decorators/mq-operation.decorator.js

@@ -1,8 +1,8 @@
-import { omit } from '@jsopen/objects';
+import { isConstructor, omit } from '@jsopen/objects';
 import { OpraSchema } from '../../schema/index.js';
 import { MQ_CONTROLLER_METADATA } from '../constants.js';
 const augmentationRegistry = [];
-export function MQOperationDecoratorFactory(decoratorChain, payloadType, options) {
+export function MQOperationDecoratorFactory(decoratorChain, type, options) {
     let inResponse = false;
     /**
      *
@@ -13,8 +13,8 @@ export function MQOperationDecoratorFactory(decoratorChain, payloadType, options
         const operationMetadata = {
             kind: OpraSchema.MQOperation.Kind,
             channel: propertyKey,
-            payloadType,
-            ...omit(options, ['kind', 'payloadType']),
+            type,
+            ...omit(options, ['kind', 'type']),
         };
         const controllerMetadata = (Reflect.getOwnMetadata(MQ_CONTROLLER_METADATA, target.constructor) || {});
         controllerMetadata.operations = controllerMetadata.operations || {};
@@ -26,10 +26,10 @@ export function MQOperationDecoratorFactory(decoratorChain, payloadType, options
     /**
      *
      */
-    decorator.UseType = (...type) => {
+    decorator.UseType = (...types) => {
         decoratorChain.push((meta) => {
             meta.types = meta.types || [];
-            meta.types.push(...type);
+            meta.types.push(...types);
         });
         return decorator;
     };
@@ -44,6 +44,8 @@ export function MQOperationDecoratorFactory(decoratorChain, payloadType, options
                     type: arg1,
                 }
                 : { ...arg1, name };
+            if (isConstructor(headerMetadata.type))
+                headerMetadata.designType = headerMetadata.type;
             const subMeta = inResponse ? meta.response : meta;
             if (subMeta.headers) {
                 subMeta.headers = subMeta.headers.filter(p => String(p.name) !== String(name));
@@ -57,17 +59,19 @@ export function MQOperationDecoratorFactory(decoratorChain, payloadType, options
     /**
      *
      */
-    decorator.Response = (_payloadType, _options) => {
+    decorator.Response = (_type, _options) => {
         decoratorChain.push((meta) => {
             inResponse = true;
             meta.response = {
                 ..._options,
-                payloadType: _payloadType,
+                type: _type,
             };
+            if (isConstructor(_type))
+                meta.response.designType = _type;
         });
         return decorator;
     };
-    augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, payloadType, options));
+    augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, type, options));
     return decorator;
 }
 MQOperationDecoratorFactory.augment = function (fn) {

package/esm/document/decorators/ws-controller.decorator.js

@@ -1,6 +1,6 @@
 import { merge } from '@jsopen/objects';
 import { OpraSchema } from '../../schema/index.js';
-import { MQ_CONTROLLER_METADATA } from '../constants.js';
+import { WS_CONTROLLER_METADATA } from '../constants.js';
 const CLASS_NAME_PATTERN = /^(.*)(Controller)$/;
 const augmentationRegistry = [];
 export function WSControllerDecoratorFactory(options) {
@@ -13,10 +13,10 @@ export function WSControllerDecoratorFactory(options) {
         if (!name)
             name = CLASS_NAME_PATTERN.exec(target.name)?.[1] || target.name;
         const metadata = {};
-        const baseMetadata = Reflect.getOwnMetadata(MQ_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        const baseMetadata = Reflect.getOwnMetadata(WS_CONTROLLER_METADATA, Object.getPrototypeOf(target));
         if (baseMetadata)
             merge(metadata, baseMetadata, { deep: true });
-        const oldMetadata = Reflect.getOwnMetadata(MQ_CONTROLLER_METADATA, target);
+        const oldMetadata = Reflect.getOwnMetadata(WS_CONTROLLER_METADATA, target);
         if (oldMetadata)
             merge(metadata, oldMetadata, { deep: true });
         merge(metadata, {
@@ -25,10 +25,10 @@ export function WSControllerDecoratorFactory(options) {
             name,
             path: name,
         }, { deep: true });
-        Reflect.defineMetadata(MQ_CONTROLLER_METADATA, metadata, target);
+        Reflect.defineMetadata(WS_CONTROLLER_METADATA, metadata, target);
         for (const fn of decoratorChain)
             fn(metadata, target);
-        Reflect.defineMetadata(MQ_CONTROLLER_METADATA, metadata, target);
+        Reflect.defineMetadata(WS_CONTROLLER_METADATA, metadata, target);
     };
     /**
      *

package/esm/document/decorators/ws-operation.decorator.js

@@ -1,8 +1,8 @@
 import { omit } from '@jsopen/objects';
 import { OpraSchema } from '../../schema/index.js';
-import { MQ_CONTROLLER_METADATA } from '../constants.js';
+import { WS_CONTROLLER_METADATA } from '../constants.js';
 const augmentationRegistry = [];
-export function WSOperationDecoratorFactory(decoratorChain, payloadType, options) {
+export function WSOperationDecoratorFactory(decoratorChain, options) {
     /**
      *
      */
@@ -11,16 +11,15 @@ export function WSOperationDecoratorFactory(decoratorChain, payloadType, options
             throw new TypeError(`Symbol properties can not be decorated`);
         const operationMetadata = {
             kind: OpraSchema.WSOperation.Kind,
-            channel: propertyKey,
-            payloadType,
-            ...omit(options, ['kind', 'payloadType']),
+            event: propertyKey,
+            ...omit(options, ['kind']),
         };
-        const controllerMetadata = (Reflect.getOwnMetadata(MQ_CONTROLLER_METADATA, target.constructor) || {});
+        const controllerMetadata = (Reflect.getOwnMetadata(WS_CONTROLLER_METADATA, target.constructor) || {});
         controllerMetadata.operations = controllerMetadata.operations || {};
         controllerMetadata.operations[propertyKey] = operationMetadata;
         for (const fn of decoratorChain)
             fn(operationMetadata, target, propertyKey);
-        Reflect.defineMetadata(MQ_CONTROLLER_METADATA, controllerMetadata, target.constructor);
+        Reflect.defineMetadata(WS_CONTROLLER_METADATA, controllerMetadata, target.constructor);
     });
     /**
      *
@@ -32,7 +31,7 @@ export function WSOperationDecoratorFactory(decoratorChain, payloadType, options
         });
         return decorator;
     };
-    augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, payloadType, options));
+    augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, options));
     return decorator;
 }
 WSOperationDecoratorFactory.augment = function (fn) {

package/esm/document/decorators/ws-param.decorator.js

@@ -0,0 +1,19 @@
+import { WS_PARAM_METADATA } from '../constants.js';
+export function WsParam(type) {
+    return (target, propertyKey, parameterIndex) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Un-named properties can not be decorated`);
+        if (!type) {
+            const designTypes = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+            type = designTypes[parameterIndex];
+            if (!type)
+                throw new TypeError(`Missing parameter type`);
+        }
+        let paramMetadata = Reflect.getOwnMetadata(WS_PARAM_METADATA, target, propertyKey);
+        if (!paramMetadata) {
+            paramMetadata = [];
+            Reflect.defineMetadata(WS_PARAM_METADATA, paramMetadata, target, propertyKey);
+        }
+        paramMetadata[parameterIndex] = type;
+    };
+}

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

@@ -9,6 +9,7 @@ import * as primitiveTypes from '../data-type/primitive-types/index.js';
 import { DataTypeFactory } from './data-type.factory.js';
 import { HttpApiFactory } from './http-api.factory.js';
 import { MQApiFactory } from './mq-api.factory.js';
+import { WSApiFactory } from './ws-api.factory.js';
 const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + OpraSchema.SpecVersion;
 /**
  * @class ApiDocumentFactory
@@ -127,6 +128,14 @@ export class ApiDocumentFactory {
                     if (api)
                         document.api = api;
                 }
+                else if (init.api && init.api.transport === 'ws') {
+                    const api = await WSApiFactory.createApi(context, {
+                        ...init.api,
+                        owner: document,
+                    });
+                    if (api)
+                        document.api = api;
+                }
                 else
                     context.addError(`Unknown service transport (${init.api.transport})`);
             });

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

@@ -2,6 +2,7 @@ import { cloneObject, resolveThunk, ResponsiveMap, } from '../../helpers/index.j
 import { OpraSchema } from '../../schema/index.js';
 import { DocumentInitContext } from '../common/document-init-context.js';
 import { DATATYPE_METADATA, DECODER, ENCODER, kCtorMap, kDataTypeMap, } from '../constants.js';
+import { ArrayType } from '../data-type/array-type.js';
 import { ComplexType } from '../data-type/complex-type.js';
 import { ComplexTypeBase } from '../data-type/complex-type-base.js';
 import { DataType } from '../data-type/data-type.js';
@@ -248,6 +249,9 @@ export class DataTypeFactory {
                     }
                 }
                 switch (out.kind) {
+                    case OpraSchema.ArrayType.Kind:
+                        await this._prepareArrayTypeArgs(context, owner, out, metadata);
+                        break;
                     case OpraSchema.ComplexType.Kind:
                         out.ctor = ctor;
                         await this._prepareComplexTypeArgs(context, owner, out, metadata);
@@ -288,6 +292,15 @@ export class DataTypeFactory {
         initArgs.examples = metadata.examples;
         initArgs.scopePattern = metadata.scopePattern;
     }
+    static async _prepareArrayTypeArgs(context, owner, initArgs, metadata) {
+        await this._prepareDataTypeArgs(context, initArgs, metadata);
+        await context.enterAsync('.type', async () => {
+            const baseArgs = await this._importDataTypeArgs(context, owner, metadata.type);
+            if (!baseArgs)
+                return;
+            initArgs.type = preferName(baseArgs);
+        });
+    }
     static async _prepareComplexTypeArgs(context, owner, initArgs, metadata) {
         await this._prepareDataTypeArgs(context, initArgs, metadata);
         initArgs.keyField = metadata.keyField;
@@ -468,6 +481,8 @@ export class DataTypeFactory {
                 dataTypeMap.set(dataType.name, dataType);
             }
             switch (initArgs?.kind) {
+                case OpraSchema.ArrayType.Kind:
+                    return this._createArrayType(context, owner, initArgs);
                 case OpraSchema.ComplexType.Kind:
                     return this._createComplexType(context, owner, initArgs);
                 case OpraSchema.EnumType.Kind:
@@ -486,6 +501,18 @@ export class DataTypeFactory {
         }
         context.addError(`Unknown data type (${String(args)})`);
     }
+    static _createArrayType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, ArrayType.prototype);
+        const initArgs = cloneObject(args);
+        if (args.type) {
+            context.enter('.type', () => {
+                initArgs.type = this._createDataType(context, owner, args.type);
+            });
+        }
+        ArrayType.apply(dataType, [owner, initArgs]);
+        return dataType;
+    }
     static _createComplexType(context, owner, args) {
         const dataType = args._instance || {};
         Object.setPrototypeOf(dataType, ComplexType.prototype);

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

@@ -113,7 +113,7 @@ export class MQApiFactory {
                             ...operationMeta,
                             name: operationName,
                             types: undefined,
-                            payloadType: undefined,
+                            type: undefined,
                             keyType: undefined,
                         });
                         await this._initMQOperation(context, operation, operationMeta);
@@ -137,7 +137,7 @@ export class MQApiFactory {
                 await DataTypeFactory.addDataTypes(context, operation, metadata.types);
             });
         }
-        operation.payloadType = await DataTypeFactory.resolveDataType(context, operation, metadata.payloadType);
+        operation.type = await DataTypeFactory.resolveDataType(context, operation, metadata.type);
         if (metadata.keyType) {
             operation.keyType = await DataTypeFactory.resolveDataType(context, operation, metadata.keyType);
         }
@@ -160,7 +160,7 @@ export class MQApiFactory {
             await context.enterAsync('.response', async () => {
                 const response = new MQOperationResponse(operation, {
                     ...metadata.response,
-                    payloadType: undefined,
+                    type: undefined,
                     keyType: undefined,
                 });
                 await this._initMQOperationResponse(context, response, metadata.response);
@@ -176,7 +176,7 @@ export class MQApiFactory {
      * @protected
      */
     static async _initMQOperationResponse(context, response, metadata) {
-        response.payloadType = await DataTypeFactory.resolveDataType(context, response, metadata.payloadType);
+        response.type = await DataTypeFactory.resolveDataType(context, response, metadata.type);
         if (metadata.keyType) {
             response.keyType = await DataTypeFactory.resolveDataType(context, response, metadata.keyType);
         }

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

@@ -1,6 +1,6 @@
 import { isConstructor } from '@jsopen/objects';
 import { resolveThunk } from '../../helpers/index.js';
-import { WS_CONTROLLER_METADATA } from '../constants.js';
+import { WS_CONTROLLER_METADATA, WS_PARAM_METADATA } from '../constants.js';
 import { WSApi } from '../ws/ws-api.js';
 import { WSController } from '../ws/ws-controller.js';
 import { WSOperation } from '../ws/ws-operation.js';
@@ -84,17 +84,26 @@ export class WSApiFactory {
         }
         if (metadata.operations) {
             await context.enterAsync('.operations', async () => {
-                for (const [operationName, operationMeta] of Object.entries(metadata.operations)) {
+                for (const [operationName, _operationMeta] of Object.entries(metadata.operations)) {
                     await context.enterAsync(`[${operationName}]`, async () => {
+                        const argumentsMetadata = Reflect.getMetadata(WS_PARAM_METADATA, ctor.prototype, operationName);
+                        let operationMeta = _operationMeta;
+                        if (argumentsMetadata) {
+                            operationMeta = {
+                                ...operationMeta,
+                                arguments: argumentsMetadata,
+                            };
+                        }
                         const operation = new WSOperation(controller, {
                             ...operationMeta,
                             name: operationName,
                             types: undefined,
-                            payloadType: undefined,
+                            type: undefined,
                             keyType: undefined,
+                            arguments: undefined,
                         });
                         await this._initWSOperation(context, operation, operationMeta);
-                        controller.operations.set(operation.name, operation);
+                        controller.operations.set(operationName, operation);
                     });
                 }
             });
@@ -114,6 +123,19 @@ export class WSApiFactory {
                 await DataTypeFactory.addDataTypes(context, operation, metadata.types);
             });
         }
-        operation.payloadType = await DataTypeFactory.resolveDataType(context, operation, metadata.payloadType);
+        if (metadata.arguments?.length) {
+            await context.enterAsync('.arguments', async () => {
+                operation.arguments = [];
+                for (const x of metadata.arguments) {
+                    const t = await DataTypeFactory.resolveDataType(context, operation, x);
+                    operation.arguments?.push(t);
+                }
+            });
+        }
+        if (metadata.response) {
+            await context.enterAsync('.response', async () => {
+                operation.response = await DataTypeFactory.resolveDataType(context, operation, metadata.response);
+            });
+        }
     }
 }

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

@@ -3,6 +3,7 @@ import { omitUndefined } from '@jsopen/objects';
 import { asMutable } from 'ts-gems';
 import { isAny, vg } from 'valgen';
 import { DocumentElement } from '../common/document-element.js';
+import { ArrayType } from '../data-type/array-type.js';
 import { DataType } from '../data-type/data-type.js';
 export const HttpMediaType = function (owner, initArgs) {
     if (!this)
@@ -32,6 +33,7 @@ export const HttpMediaType = function (owner, initArgs) {
                 : _this.owner.node.getDataType(initArgs.type);
     }
     _this.isArray = initArgs.isArray;
+    _this.designType = initArgs.designType;
 };
 /**
  * @class HttpMediaType
@@ -71,21 +73,28 @@ class HttpMediaTypeClass extends DocumentElement {
         }
         return out;
     }
-    generateCodec(codec, options) {
+    generateCodec(codec, options, properties) {
         let fn;
         if (this.type) {
-            fn = this.type.generateCodec(codec, options);
+            fn = this.type.generateCodec(codec, options, {
+                designType: this.designType,
+            });
         }
         else if (this.contentType) {
             const arr = Array.isArray(this.contentType)
                 ? this.contentType
                 : [this.contentType];
             if (arr.find(ct => typeIs.is(ct, ['json']))) {
-                fn = this.node.findDataType('object').generateCodec(codec);
+                fn = this.node.findDataType('object').generateCodec(codec, options, {
+                    ...properties,
+                    designType: this.designType,
+                });
             }
         }
         fn = fn || isAny;
-        return this.isArray ? vg.isArray(fn) : fn;
+        return this.isArray && !(this.type instanceof ArrayType)
+            ? vg.isArray(fn)
+            : fn;
     }
 }
 HttpMediaType.prototype = HttpMediaTypeClass.prototype;

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

@@ -1,5 +1,6 @@
 import { omitUndefined } from '@jsopen/objects';
 import { asMutable, } from 'ts-gems';
+import { vg } from 'valgen';
 import { Value } from '../common/value.js';
 import { parseRegExp } from '../utils/parse-regexp.util.js';
 export const HttpParameter = function (owner, initArgs) {
@@ -26,6 +27,7 @@ export const HttpParameter = function (owner, initArgs) {
     _this.arraySeparator = initArgs.arraySeparator;
     _this.keyParam = initArgs.keyParam;
     _this.parser = initArgs.parser;
+    _this.designType = initArgs.designType;
 };
 /**
  * @class HttpParameter
@@ -42,5 +44,11 @@ class HttpParameterClass extends Value {
             deprecated: this.deprecated,
         });
     }
+    generateCodec(codec, options, properties) {
+        return (this.type?.generateCodec(codec, options, {
+            ...properties,
+            designType: this.designType,
+        }) || vg.isAny());
+    }
 }
 HttpParameter.prototype = HttpParameterClass.prototype;

package/esm/document/index.js

@@ -23,6 +23,7 @@ export * from './common/document-node.js';
 export * from './common/opra-document-error.js';
 export * from './constants.js';
 export * from './data-type/api-field.js';
+export * from './data-type/array-type.js';
 export * from './data-type/complex-type.js';
 export * from './data-type/data-type.js';
 export * from './data-type/enum-type.js';
@@ -36,6 +37,7 @@ export * from './data-type/primitive-types/index.js';
 export * from './data-type/required-type.js';
 export * from './data-type/simple-type.js';
 export * from './data-type/union-type.js';
+export * from './decorators/ws-param.decorator.js';
 export * from './factory/api-document.factory.js';
 export * from './http/http-api.js';
 export * from './http/http-controller.js';

package/esm/document/mq/mq-header.js

@@ -1,5 +1,6 @@
 import { omitUndefined } from '@jsopen/objects';
 import { asMutable, } from 'ts-gems';
+import { vg } from 'valgen';
 import { Value } from '../common/value.js';
 import { parseRegExp } from '../utils/parse-regexp.util.js';
 export const MQHeader = function (owner, initArgs) {
@@ -20,6 +21,7 @@ export const MQHeader = function (owner, initArgs) {
     }
     _this.deprecated = initArgs.deprecated;
     _this.required = initArgs.required;
+    _this.designType = initArgs.designType;
 };
 /**
  * @class MQHeader
@@ -33,5 +35,11 @@ class MQHeaderClass extends Value {
             deprecated: this.deprecated,
         });
     }
+    generateCodec(codec, options, properties) {
+        return (this.type?.generateCodec(codec, options, {
+            ...properties,
+            designType: this.designType,
+        }) || vg.isAny());
+    }
 }
 MQHeader.prototype = MQHeaderClass.prototype;

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

@@ -10,20 +10,22 @@ export class MQOperationResponse extends DocumentElement {
         this.headers = [];
         this.channel = initArgs?.channel;
         this.description = initArgs?.description;
-        if (initArgs?.payloadType) {
-            this.payloadType =
-                initArgs?.payloadType instanceof DataType
-                    ? initArgs.payloadType
-                    : this.owner.node.getDataType(initArgs.payloadType);
+        if (initArgs?.type) {
+            this.type =
+                initArgs?.type instanceof DataType
+                    ? initArgs.type
+                    : this.owner.node.getDataType(initArgs.type);
         }
         else
-            this.payloadType = this.owner.node.getDataType('any');
+            this.type = this.owner.node.getDataType('any');
         if (initArgs?.keyType) {
             this.keyType =
                 initArgs?.keyType instanceof DataType
                     ? initArgs.keyType
                     : this.owner.node.getDataType(initArgs.keyType);
         }
+        this.designType = initArgs?.designType;
+        this.keyDesignType = initArgs?.keyDesignType;
     }
     findHeader(paramName) {
         const paramNameLower = paramName.toLowerCase();
@@ -42,9 +44,7 @@ export class MQOperationResponse extends DocumentElement {
         const out = omitUndefined({
             description: this.description,
             channel: this.channel,
-            payloadType: this.payloadType.name
-                ? this.payloadType.name
-                : this.payloadType.toJSON(),
+            type: this.type.name ? this.type.name : this.type.toJSON(),
             keyType: this.keyType
                 ? this.keyType.name
                     ? this.keyType.name