@opra/common 1.14.0 → 1.15.0

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

@@ -7,6 +7,7 @@ import type { EnumType } from '../data-type/enum-type.js';
 import type { MappedType } from '../data-type/mapped-type.js';
 import type { MixinType } from '../data-type/mixin-type.js';
 import type { SimpleType } from '../data-type/simple-type.js';
+import type { UnionType } from '../data-type/union-type.js';
 import type { DataTypeMap } from './data-type-map.js';
 import type { DocumentElement } from './document-element.js';
 /**
@@ -56,4 +57,10 @@ export declare class DocumentNode {
      * Throws error if data type is not a MixinType
      */
     getMixinType(nameOrCtor: string | object | any[], scope?: string | '*'): MixinType;
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a UnionType
+     */
+    getUnionType(nameOrCtor: string | object | any[], scope?: string | '*'): UnionType;
 }

package/types/document/data-type/complex-type.d.ts

@@ -19,7 +19,7 @@ export declare namespace ComplexType {
         additionalFields?: boolean | string | TypeThunkAsync | ['error'] | ['error', string];
     }, DataType.Metadata, OpraSchema.ComplexType> {
     }
-    interface Options extends Combine<Pick<Metadata, 'additionalFields' | 'keyField'>, DataType.Options, Pick<OpraSchema.ComplexType, 'abstract'>> {
+    interface Options extends Combine<Pick<Metadata, 'additionalFields' | 'keyField' | 'discriminatorField' | 'discriminatorValue'>, DataType.Options, Pick<OpraSchema.ComplexType, 'abstract'>> {
     }
     interface InitArguments extends Combine<{
         kind: OpraSchema.ComplexType.Kind;
@@ -72,6 +72,8 @@ declare abstract class ComplexTypeClass extends ComplexTypeBase {
     readonly kind: OpraSchema.ComplexType.Kind;
     readonly base?: ComplexType | MappedType | MixinType;
     readonly ctor?: Type;
+    discriminatorField?: string;
+    discriminatorValue?: string;
     extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(options?: ApiDocument.ExportOptions): OpraSchema.ComplexType;
     protected _locateBase(callback: (base: ComplexTypeBase) => boolean): ComplexTypeBase | undefined;

package/types/document/data-type/mapped-type.d.ts

@@ -68,6 +68,8 @@ declare class MappedTypeClass extends ComplexTypeBase {
     readonly pick?: Field.Name[];
     readonly partial?: Field.Name[] | boolean;
     readonly required?: Field.Name[] | boolean;
+    discriminatorField?: string;
+    discriminatorValue?: string;
     extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(options?: ApiDocument.ExportOptions): OpraSchema.MappedType;
     protected _locateBase(callback: (base: ComplexTypeBase) => boolean): ComplexTypeBase | undefined;

package/types/document/data-type/mixin-type.d.ts

@@ -39,25 +39,35 @@ export interface MixinTypeStatic {
     new (owner: DocumentElement, args: MixinType.InitArguments): MixinType;
     /**
      * Create a new mixin type from given two types
-     * @param c1
-     * @param c2
+     * @param types
      * @param options
-     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, options?: DataType.Options): Class<any[], I1 & I2, S1 & S2>;
+     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2>(types: [Class<A1, I1, S1>, Class<A2, I2, S2>], options?: DataType.Options): Class<any[], I1 & I2, S1 & S2>;
     /**
      * Helper method that mixes given types
-     * @param c1
-     * @param c2
-     * @param c3
+     * @param types
      * @param options
-     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, options?: DataType.Options): Class<any[], I1 & I2 & I3, S1 & S2 & S3>;
+     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3>(types: [Class<A1, I1, S1>, Class<A2, I2, S2>, Class<A3, I3, S3>], options?: DataType.Options): Class<any[], I1 & I2 & I3, S1 & S2 & S3>;
     /**
      * Helper method that mixes given types
-     * @param c1
-     * @param c2
-     * @param c3
-     * @param c4
+     * @param types
      * @param options
-     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>, options?: DataType.Options): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;
+     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(types: [
+        Class<A1, I1, S1>,
+        Class<A2, I2, S2>,
+        Class<A3, I3, S3>,
+        Class<A4, I4, S4>
+    ], options?: DataType.Options): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;
+    /**
+     * Helper method that mixes given types
+     * @param types
+     * @param options
+     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4, A5 extends any[], I5, S5>(types: [
+        Class<A1, I1, S1>,
+        Class<A2, I2, S2>,
+        Class<A3, I3, S3>,
+        Class<A4, I4, S4>,
+        Class<A5, I5, S5>
+    ], options?: DataType.Options): Class<any[], I1 & I2 & I3 & I4 & I5, S1 & S2 & S3 & S4 & S5>;
     prototype: MixinType;
 }
 /**

package/types/document/data-type/union-type.d.ts

@@ -0,0 +1,73 @@
+import 'reflect-metadata';
+import type { Combine, Type } from 'ts-gems';
+import { Validator } from 'valgen';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import type { DocumentElement } from '../common/document-element.js';
+import type { ComplexType } from './complex-type.js';
+import { DataType } from './data-type.js';
+import type { MappedType } from './mapped-type.js';
+import type { MixinType } from './mixin-type.js';
+import type { SimpleType } from './simple-type.js';
+/**
+ * @namespace UnionType
+ */
+export declare namespace UnionType {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.UnionType.Kind;
+        name?: string;
+        types: Type[];
+    }, DataType.Metadata, OpraSchema.UnionType> {
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.UnionType.Kind;
+        types: (ComplexType | MappedType | MixinType | SimpleType)[];
+        ctor?: Type;
+    }, DataType.InitArguments, UnionType.Metadata> {
+    }
+    interface Options extends Combine<Pick<OpraSchema.UnionType, 'discriminator'>, DataType.Options> {
+    }
+}
+/**
+ * Type definition for UnionType
+ * @class UnionType
+ */
+export interface UnionTypeStatic {
+    /**
+     * Class constructor of UnionType
+     *
+     * @param owner
+     * @param args
+     * @constructor
+     */
+    new (owner: DocumentElement, args: UnionType.InitArguments): UnionType;
+    /**
+     * Create a new mixin type from given two types
+     */
+    (types: (string | Type)[], options?: UnionType.Options): Type;
+    prototype: UnionType;
+}
+/**
+ * Type definition of UnionType prototype
+ * @interface
+ */
+export interface UnionType extends UnionTypeClass {
+}
+/**
+ * @class UnionType
+ */
+export declare const UnionType: UnionTypeStatic;
+/**
+ *
+ * @class UnionType
+ */
+declare class UnionTypeClass extends DataType {
+    readonly kind: OpraSchema.UnionType.Kind;
+    readonly types: (ComplexType | MixinType | MappedType | SimpleType)[];
+    readonly discriminator?: string;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.UnionType;
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
+    extendsFrom(): boolean;
+    protected _locateBase(): UnionType | undefined;
+}
+export {};

package/types/document/factory/data-type.factory.d.ts

@@ -10,6 +10,7 @@ import { EnumType } from '../data-type/enum-type.js';
 import { MappedType } from '../data-type/mapped-type.js';
 import { MixinType } from '../data-type/mixin-type.js';
 import { SimpleType } from '../data-type/simple-type.js';
+import { UnionType } from '../data-type/union-type.js';
 /**
  *
  * @namespace DataTypeFactory
@@ -44,11 +45,16 @@ export declare namespace DataTypeFactory {
         base?: string | SimpleTypeInit;
     }, SimpleType.InitArguments> {
     }
+    interface UnionTypeInit extends Combine<{
+        _instance?: MixinType;
+        types: (string | ComplexTypeInit | MappedTypeInit | MixinTypeInit)[];
+    }, UnionType.InitArguments> {
+    }
     interface ApiFieldInit extends Combine<{
         type: string | DataTypeInitArguments;
     }, ApiField.InitArguments> {
     }
-    type DataTypeInitArguments = ComplexTypeInit | EnumTypeInit | MappedTypeInit | MixinTypeInit | SimpleTypeInit;
+    type DataTypeInitArguments = ComplexTypeInit | EnumTypeInit | MappedTypeInit | MixinTypeInit | SimpleTypeInit | UnionTypeInit;
     interface Context extends DocumentInitContext {
         importQueue?: ResponsiveMap<any>;
         initArgsMap?: ResponsiveMap<DataTypeInitArguments>;
@@ -98,12 +104,16 @@ export declare class DataTypeFactory {
     protected static _prepareMixinTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.MixinTypeInit, metadata: (MixinType.Metadata | OpraSchema.MixinType) & {
         ctor?: Type;
     }): Promise<void>;
+    protected static _prepareUnionTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.UnionTypeInit, metadata: (UnionType.Metadata | OpraSchema.UnionType) & {
+        ctor?: Type;
+    }): Promise<void>;
     protected static _createDataType(context: DocumentInitContext & {
         initArgsMap?: ResponsiveMap<DataTypeFactory.DataTypeInitArguments>;
-    }, owner: DocumentElement, args: DataTypeFactory.DataTypeInitArguments | string): ComplexType | EnumType | MappedType | MixinType | SimpleType | undefined;
+    }, owner: DocumentElement, args: DataTypeFactory.DataTypeInitArguments | string): ComplexType | EnumType | MappedType | MixinType | SimpleType | UnionType | undefined;
     protected static _createComplexType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.ComplexTypeInit): ComplexType;
     protected static _createEnumType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.EnumTypeInit): EnumType;
     protected static _createMappedType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.MappedTypeInit): MappedType;
     protected static _createMixinType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.MixinTypeInit): MixinType;
     protected static _createSimpleType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.SimpleTypeInit): SimpleType;
+    protected static _createUnionType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.UnionTypeInit): UnionType;
 }

package/types/document/index.d.ts

@@ -33,6 +33,7 @@ export * from './data-type/pick-type.js';
 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 type { RpcControllerDecorator } from './decorators/rpc-controller.decorator.js';
 export type { RpcOperationDecorator } from './decorators/rpc-operation.decorator.js';
 export * from './factory/api-document.factory.js';

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

@@ -10,6 +10,8 @@ export interface ComplexType extends StrictOmit<DataTypeBase, 'kind'> {
     fields?: Record<Field.Name, Field | DataType.Name>;
     additionalFields?: boolean | string | DataType | ['error'] | ['error', string];
     keyField?: Field.Name;
+    discriminatorField?: string;
+    discriminatorValue?: string;
 }
 export declare namespace ComplexType {
     const Kind = "ComplexType";

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

@@ -3,10 +3,11 @@ 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';
-export type DataType = SimpleType | EnumType | ComplexType | MappedType | MixinType;
+import type { UnionType } from './union-type.interface.js';
+export type DataType = SimpleType | EnumType | ComplexType | MappedType | MixinType | UnionType;
 export declare namespace DataType {
     type Name = string;
-    type Kind = ComplexType.Kind | EnumType.Kind | MappedType.Kind | SimpleType.Kind | MixinType.Kind;
+    type Kind = ComplexType.Kind | EnumType.Kind | MappedType.Kind | SimpleType.Kind | MixinType.Kind | UnionType.Kind;
 }
 export interface DataTypeBase {
     kind: DataType.Kind;

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

@@ -10,6 +10,10 @@ export declare namespace Field {
  */
 export type Field = {
     type?: DataType.Name | DataType;
+    /**
+     * Defines the label of the field. Mostly used for UI.
+     */
+    label?: string;
     /**
      * Defines the description of the field
      */

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

@@ -10,6 +10,8 @@ export interface MappedType extends StrictOmit<DataTypeBase, 'kind'> {
     pick?: Field.Name[];
     partial?: Field.Name[] | boolean;
     required?: Field.Name[] | boolean;
+    discriminatorField?: string;
+    discriminatorValue?: string;
 }
 export declare namespace MappedType {
     const Kind = "MappedType";

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

@@ -0,0 +1,15 @@
+import type { StrictOmit } from 'ts-gems';
+import type { ComplexType } from './complex-type.interface.js';
+import type { DataType, DataTypeBase } from './data-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';
+export interface UnionType extends StrictOmit<DataTypeBase, 'kind'> {
+    kind: UnionType.Kind;
+    types: (DataType.Name | ComplexType | MixinType | MappedType | SimpleType)[];
+    discriminator?: string;
+}
+export declare namespace UnionType {
+    const Kind = "UnionType";
+    type Kind = 'UnionType';
+}

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

@@ -7,6 +7,7 @@ export * from './data-type/field.interface.js';
 export * from './data-type/mapped-type.interface.js';
 export * from './data-type/mixin-type.interface.js';
 export * from './data-type/simple-type.interface.js';
+export * from './data-type/union-type.interface.js';
 export * from './data-type-container.interface.js';
 export * from './http/http-controller.interface.js';
 export * from './http/http-media-type.interface.js';

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

@@ -4,6 +4,7 @@ import { EnumType } from './data-type/enum-type.interface.js';
 import { MappedType } from './data-type/mapped-type.interface.js';
 import { MixinType } from './data-type/mixin-type.interface.js';
 import { SimpleType } from './data-type/simple-type.interface.js';
+import { UnionType } from './data-type/union-type.interface.js';
 import { HttpController } from './http/http-controller.interface.js';
 export declare function isDataType(obj: any): obj is DataType;
 export declare function isComplexType(obj: any): obj is ComplexType;
@@ -11,4 +12,5 @@ export declare function isSimpleType(obj: any): obj is SimpleType;
 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 isHttpController(obj: any): obj is HttpController;