@opra/common 1.19.7 → 1.20.0

package/types/document/index.d.ts

@@ -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';
@@ -40,6 +41,7 @@ export type { MQControllerDecorator } from './decorators/mq-controller.decorator
 export type { MQOperationDecorator } from './decorators/mq-operation.decorator.js';
 export type { WSControllerDecorator } from './decorators/ws-controller.decorator.js';
 export type { WSOperationDecorator } from './decorators/ws-operation.decorator.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/types/document/mq/mq-header.d.ts

@@ -1,4 +1,5 @@
-import { type Combine, type StrictOmit, type TypeThunkAsync } from 'ts-gems';
+import { type Combine, type StrictOmit, Type, type TypeThunkAsync } from 'ts-gems';
+import { Validator } from 'valgen';
 import type { OpraSchema } from '../../schema/index.js';
 import { DocumentElement } from '../common/document-element.js';
 import { Value } from '../common/value.js';
@@ -11,6 +12,7 @@ export declare namespace MQHeader {
     interface Metadata extends StrictOmit<OpraSchema.MQHeader, 'type'> {
         name: string | RegExp;
         type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+        designType?: Type;
     }
     interface Options extends Partial<StrictOmit<Metadata, 'type'>> {
         type?: string | TypeThunkAsync | object;
@@ -42,6 +44,8 @@ declare class MQHeaderClass extends Value {
     readonly owner: DocumentElement;
     deprecated?: boolean | string;
     required?: boolean;
+    designType?: Type;
     toJSON(): OpraSchema.MQHeader;
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: any): Validator;
 }
 export {};

package/types/document/mq/mq-operation-response.d.ts

@@ -10,19 +10,21 @@ import type { MQOperation } from './mq-operation.js';
  */
 export declare namespace MQOperationResponse {
     interface Metadata extends Combine<{
-        payloadType?: TypeThunkAsync | string;
+        type?: TypeThunkAsync | string;
         keyType?: TypeThunkAsync | string;
         headers?: MQHeader.Metadata[];
     }, OpraSchema.MQOperationResponse> {
+        designType?: Type;
+        keyDesignType?: Type;
     }
     interface Options extends Combine<{
         keyType?: Type | string;
     }, Pick<Metadata, 'channel' | 'description'>> {
     }
     interface InitArguments extends Combine<{
-        payloadType?: DataType | string | Type;
+        type?: DataType | string | Type;
         keyType?: DataType | string | Type;
-    }, Pick<Metadata, 'channel' | 'description'>> {
+    }, Pick<Metadata, 'channel' | 'description' | 'designType' | 'keyDesignType'>> {
     }
 }
 /**
@@ -32,9 +34,11 @@ export declare class MQOperationResponse extends DocumentElement {
     readonly owner: MQOperation;
     channel?: string | RegExp | (string | RegExp)[];
     description?: string;
-    payloadType: DataType;
+    type: DataType;
     keyType?: DataType;
     headers: MQHeader[];
+    designType?: Type;
+    keyDesignType?: Type;
     constructor(owner: MQOperation, initArgs?: MQOperationResponse.InitArguments);
     findHeader(paramName: string): MQHeader | undefined;
     toJSON(): OpraSchema.MQOperationResponse;

package/types/document/mq/mq-operation.d.ts

@@ -1,5 +1,6 @@
 import type { Combine, ThunkAsync, Type } from 'ts-gems';
 import { TypeThunkAsync } from 'ts-gems/lib/types';
+import { Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
@@ -14,11 +15,13 @@ import type { MQOperationResponse } from './mq-operation-response.js';
  */
 export declare namespace MQOperation {
     interface Metadata extends Pick<OpraSchema.MQOperation, 'description' | 'channel'> {
-        payloadType: TypeThunkAsync | string;
+        type: TypeThunkAsync | string;
         keyType?: TypeThunkAsync | string;
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
         headers?: MQHeader.Metadata[];
         response?: MQOperationResponse.Metadata;
+        designType?: Type;
+        keyDesignType?: Type;
     }
     interface Options extends Partial<Pick<Metadata, 'description' | 'keyType'>> {
         channel?: (string | RegExp) | (string | RegExp)[];
@@ -26,9 +29,9 @@ export declare namespace MQOperation {
     interface InitArguments extends Combine<{
         name: string;
         types?: DataType[];
-        payloadType?: DataType | string | Type;
+        type?: DataType | string | Type;
         keyType?: DataType | string | Type;
-    }, Pick<Metadata, 'description' | 'channel'>> {
+    }, Pick<Metadata, 'description' | 'channel' | 'designType' | 'keyDesignType'>> {
     }
 }
 /**
@@ -44,9 +47,9 @@ export interface MQOperationStatic {
     new (controller: MQController, args: MQOperation.InitArguments): MQOperation;
     /**
      * Property decorator
-     * @param payloadType
+     * @param type
      * @param options
-     */ <T extends MQOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): MQOperationDecorator;
+     */ <T extends MQOperation.Options>(type: ThunkAsync<Type> | string, options?: T): MQOperationDecorator;
     prototype: MQOperation;
 }
 /**
@@ -66,12 +69,16 @@ declare class MQOperationClass extends DocumentElement {
     readonly name: string;
     channel: string | RegExp | (string | RegExp)[];
     description?: string;
-    payloadType: DataType;
+    type: DataType;
     keyType?: DataType;
     types: DataTypeMap;
     headers: MQHeader[];
     response: MQOperationResponse;
+    designType?: Type;
+    keyDesignType?: Type;
     findHeader(paramName: string): MQHeader | undefined;
     toJSON(): OpraSchema.MQOperation;
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: any): Validator;
+    generateKeyCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: any): Validator;
 }
 export {};

package/types/document/ws/ws-controller.d.ts

@@ -58,7 +58,6 @@ declare class WSControllerClass extends DocumentElement {
     readonly kind: OpraSchema.WSController.Kind;
     readonly name: string;
     description?: string;
-    path: string;
     instance?: any;
     ctor?: Type;
     operations: ResponsiveMap<WSOperation>;

package/types/document/ws/ws-operation.d.ts

@@ -1,5 +1,4 @@
 import type { Combine, ThunkAsync, Type } from 'ts-gems';
-import { TypeThunkAsync } from 'ts-gems/lib/types';
 import { OpraSchema } from '../../schema/index.js';
 import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
@@ -11,20 +10,22 @@ import { WSController } from './ws-controller.js';
  * @namespace WSOperation
  */
 export declare namespace WSOperation {
-    interface Metadata extends Pick<OpraSchema.WSOperation, 'description' | 'channel'> {
-        payloadType: TypeThunkAsync | string;
-        keyType?: TypeThunkAsync | string;
+    interface Metadata extends Pick<OpraSchema.WSOperation, 'description' | 'event'> {
+        arguments?: (ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray> | string)[];
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
+        response?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
     }
-    interface Options extends Partial<Pick<Metadata, 'description' | 'keyType'>> {
-        channel?: (string | RegExp) | (string | RegExp)[];
+    interface Options extends Partial<Pick<Metadata, 'description'>> {
+        event?: string | RegExp;
+        response?: string | ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>;
     }
     interface InitArguments extends Combine<{
         name: string;
         types?: DataType[];
-        payloadType?: DataType | string | Type;
-        keyType?: DataType | string | Type;
-    }, Pick<Metadata, 'description' | 'channel'>> {
+        arguments?: (DataType | string | Type)[];
+    }, Pick<Metadata, 'description'>> {
+        event?: string | RegExp;
+        response?: DataType | string | Type;
     }
 }
 /**
@@ -40,9 +41,8 @@ export interface WSOperationStatic {
     new (controller: WSController, args: WSOperation.InitArguments): WSOperation;
     /**
      * Property decorator
-     * @param payloadType
      * @param options
-     */ <T extends WSOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): WSOperationDecorator;
+     */ <T extends WSOperation.Options>(options?: T): WSOperationDecorator;
     prototype: WSOperation;
 }
 /**
@@ -60,11 +60,11 @@ export declare const WSOperation: WSOperationStatic;
 declare class WSOperationClass extends DocumentElement {
     readonly owner: WSController;
     readonly name: string;
-    channel: string | RegExp | (string | RegExp)[];
     description?: string;
-    payloadType: DataType;
-    keyType?: DataType;
+    event: string | RegExp;
+    arguments?: DataType[];
     types: DataTypeMap;
+    response?: DataType;
     toJSON(): OpraSchema.WSOperation;
 }
 export {};

package/types/schema/data-type/array-type.interface.d.ts

@@ -0,0 +1,16 @@
+import type { StrictOmit } from 'ts-gems';
+import type { DataType, DataTypeBase } from './data-type.interface.js';
+/**
+ *
+ * @interface ArrayType
+ */
+export interface ArrayType extends StrictOmit<DataTypeBase, 'kind'> {
+    kind: ArrayType.Kind;
+    type?: DataType.Name | DataType;
+    minOccurs?: number;
+    maxOccurs?: number;
+}
+export declare namespace ArrayType {
+    const Kind = "ArrayType";
+    type Kind = 'ArrayType';
+}

package/types/schema/data-type/data-type.interface.d.ts

@@ -1,13 +1,14 @@
+import { ArrayType } from './array-type.interface.js';
 import type { ComplexType } from './complex-type.interface.js';
 import type { EnumType } from './enum-type.interface.js';
 import type { MappedType } from './mapped-type.interface.js';
 import type { MixinType } from './mixin-type.interface.js';
 import type { SimpleType } from './simple-type.interface.js';
 import type { UnionType } from './union-type.interface.js';
-export type DataType = SimpleType | EnumType | ComplexType | MappedType | MixinType | UnionType;
+export type DataType = SimpleType | EnumType | ComplexType | MappedType | MixinType | UnionType | ArrayType;
 export declare namespace DataType {
     type Name = string;
-    type Kind = ComplexType.Kind | EnumType.Kind | MappedType.Kind | SimpleType.Kind | MixinType.Kind | UnionType.Kind;
+    type Kind = ComplexType.Kind | EnumType.Kind | MappedType.Kind | SimpleType.Kind | MixinType.Kind | UnionType.Kind | ArrayType.Kind;
 }
 export interface DataTypeBase {
     kind: DataType.Kind;

package/types/schema/data-type/field.interface.d.ts

@@ -44,6 +44,7 @@ export interface Field {
      * If true, the value is recognized as an array.
      * If false, the value is not an array.
      * This property is optional and may be undefined.
+     * @deprecated
      */
     isArray?: boolean;
     /**

package/types/schema/http/http-media-type.interface.d.ts

@@ -24,6 +24,7 @@ export interface HttpMediaType {
     type?: DataType.Name | DataType;
     /**
      * Determines if content is array
+     * @deprecated
      */
     isArray?: boolean;
     /**

package/types/schema/mq/mq-operation.interface.d.ts

@@ -8,7 +8,7 @@ export interface MQOperation extends DataTypeContainer {
     kind: MQOperation.Kind;
     description?: string;
     channel: string | RegExp | (string | RegExp)[];
-    payloadType: string | DataType;
+    type: string | DataType;
     keyType?: string | DataType;
     headers?: MQHeader[];
     response?: MQOperationResponse;
@@ -16,7 +16,7 @@ export interface MQOperation extends DataTypeContainer {
 export interface MQOperationResponse {
     description?: string;
     channel?: string | RegExp | (string | RegExp)[];
-    payloadType: string | DataType;
+    type: string | DataType;
     keyType?: string | DataType;
     headers?: MQHeader[];
 }

package/types/schema/opra-schema.d.ts

@@ -1,6 +1,7 @@
 export * from './api.interface.js';
 export * from './api-document.interface.js';
 export * from './constants.js';
+export * from './data-type/array-type.interface.js';
 export * from './data-type/complex-type.interface.js';
 export * from './data-type/data-type.interface.js';
 export * from './data-type/enum-type.interface.js';

package/types/schema/type-guards.d.ts

@@ -1,3 +1,4 @@
+import { ArrayType } from './data-type/array-type.interface.js';
 import { ComplexType } from './data-type/complex-type.interface.js';
 import type { DataType } from './data-type/data-type.interface.js';
 import { EnumType } from './data-type/enum-type.interface.js';
@@ -13,4 +14,5 @@ export declare function isMixinType(obj: any): obj is MixinType;
 export declare function isMappedType(obj: any): obj is MappedType;
 export declare function isEnumType(obj: any): obj is EnumType;
 export declare function isUnionType(obj: any): obj is UnionType;
+export declare function isArrayType(obj: any): obj is ArrayType;
 export declare function isHttpController(obj: any): obj is HttpController;

package/types/schema/value.interface.d.ts

@@ -10,6 +10,7 @@ export interface Value {
     type?: DataType.Name | DataType;
     /**
      * Indicates if the value is an array
+     * @deprecated
      */
     isArray?: boolean;
     /**

package/types/schema/ws/ws-operation.interface.d.ts

@@ -6,8 +6,9 @@ import type { DataTypeContainer } from '../data-type-container.interface.js';
 export interface WSOperation extends DataTypeContainer {
     kind: WSOperation.Kind;
     description?: string;
-    channel: string | RegExp | (string | RegExp)[];
-    payloadType: string | DataType;
+    event: string | RegExp;
+    arguments?: (string | DataType)[];
+    response?: string | DataType;
 }
 export declare namespace WSOperation {
     const Kind = "WSOperation";