feat: Support for query types

Author: Gerrit0

src/lib/converter/plugins/TypePlugin.ts

@@ -1,5 +1,5 @@
 import { Reflection, ReflectionKind, Decorator, DeclarationReflection, DeclarationHierarchy } from '../../models/reflections/index';
-import { Type, ReferenceType, TupleType, UnionType, IntersectionType, ArrayType, TypeOperatorType } from '../../models/types/index';
+import { Type, ReferenceType, TupleType, UnionType, IntersectionType, ArrayType, TypeOperatorType, QueryType } from '../../models/types/index';
 import { Component, ConverterComponent } from '../components';
 import { Converter } from '../converter';
 import { Context } from '../context';
@@ -108,6 +108,8 @@ export class TypePlugin extends ConverterComponent {
                 resolveType(reflection, type.elementType);
             } else if (type instanceof TypeOperatorType) {
                 resolveType(reflection, type.target);
+            } else if (type instanceof QueryType) {
+                resolveType(reflection, type.queryType);
             }
         }
     }

src/lib/converter/types/index.ts

@@ -8,6 +8,7 @@ export { InferredConverter } from './inferred';
 export { IndexedAccessConverter } from './indexed-access';
 export { IntrinsicConverter } from './intrinsic';
 export { PredicateConverter } from './predicate';
+export { QueryConverter } from './query';
 export { StringLiteralConverter } from './string-literal';
 export { ReferenceConverter } from './reference';
 export { ThisConverter } from './this';

src/lib/converter/types/query.ts

@@ -0,0 +1,24 @@
+import * as ts from 'typescript';
+
+import { Type, QueryType } from '../../models/types/index';
+import { Component, ConverterTypeComponent, TypeNodeConverter } from '../components';
+import { Context } from '../context';
+import { createReferenceType } from '../factories';
+
+@Component({name: 'type:query'})
+export class QueryConverter extends ConverterTypeComponent implements TypeNodeConverter<ts.Type, ts.TypeQueryNode> {
+    supportsNode(_context: Context, node: ts.Node): boolean {
+        return ts.isTypeQueryNode(node);
+    }
+
+    convertNode(context: Context, node: ts.TypeQueryNode): Type | undefined {
+        const querySymbol = context.getSymbolAtLocation(node.exprName);
+        if (querySymbol) {
+            const reference = createReferenceType(context, querySymbol);
+            if (reference) {
+                return new QueryType(reference);
+            }
+        }
+    }
+
+}

src/lib/models/types/index.ts

@@ -5,6 +5,7 @@ export { IndexedAccessType } from './indexed-access';
 export { InferredType } from './inferred';
 export { IntersectionType } from './intersection';
 export { IntrinsicType } from './intrinsic';
+export { QueryType } from './query';
 export { PredicateType } from './predicate';
 export { ReferenceType } from './reference';
 export { ReflectionType } from './reflection';

src/lib/models/types/query.ts

@@ -0,0 +1,32 @@
+import { Type } from './abstract';
+import { ReferenceType } from './reference';
+
+/**
+ * Represents a type that is constructed by querying the type of a reflection.
+ * ```ts
+ * const x = 1
+ * type Z = typeof x // query on reflection for x
+ * ```
+ */
+export class QueryType extends Type {
+    readonly queryType: ReferenceType;
+
+    readonly type = 'query';
+
+    constructor(reference: ReferenceType) {
+        super();
+        this.queryType = reference;
+    }
+
+    clone(): Type {
+        return new QueryType(this.queryType);
+    }
+
+    equals(other: Type) {
+        return other instanceof QueryType && this.queryType.equals(other.queryType);
+    }
+
+    toString() {
+        return `typeof ${this.queryType.toString()}`;
+    }
+}

src/lib/serialization/schema.ts

@@ -198,6 +198,9 @@ export interface IntersectionType extends Type, S<M.IntersectionType, 'type' | '
 export interface IntrinsicType extends Type, S<M.IntrinsicType, 'type' | 'name'> {
 }
 
+export interface QueryType extends Type, S<M.QueryType, 'type' | 'queryType'> {
+}
+
 export interface PredicateType extends Type, S<M.PredicateType, 'type' | 'name' | 'asserts' | 'targetType'> {
 }
 

src/lib/serialization/serializer.ts

@@ -114,6 +114,7 @@ const serializerComponents: (new (owner: Serializer) => SerializerComponent<any>
     S.InferredTypeSerializer,
     S.IntersectionTypeSerializer,
     S.IntrinsicTypeSerializer,
+    S.QueryTypeSerializer,
     S.PredicateTypeSerializer,
     S.ReferenceTypeSerializer,
     S.ReferenceTypeSerializer,

src/lib/serialization/serializers/types/index.ts

@@ -6,6 +6,7 @@ export * from './inferred';
 export * from './intersection';
 export * from './intrinsic';
 export * from './predicate';
+export * from './query';
 export * from './reference';
 export * from './reflection';
 export * from './string-literal';

src/lib/serialization/serializers/types/query.ts

@@ -0,0 +1,16 @@
+import { QueryType } from '../../../models';
+import { TypeSerializerComponent } from '../../components';
+import { QueryType as JSONQueryType } from '../../schema';
+
+export class QueryTypeSerializer extends TypeSerializerComponent<QueryType> {
+    supports(t: unknown) {
+        return t instanceof QueryType;
+    }
+
+    toObject(type: QueryType, obj: Pick<JSONQueryType, 'type'>): JSONQueryType {
+        return {
+            ...obj,
+            queryType: this.owner.toObject(type.queryType)
+        };
+    }
+}

src/test/converter/mixin/specs.json

@@ -1318,8 +1318,12 @@
             "id": 51,
             "typeArguments": [
               {
-                "type": "reference",
-                "name": "Mixin3"
+                "type": "query",
+                "queryType": {
+                  "type": "reference",
+                  "id": 61,
+                  "name": "Mixin3"
+                }
               }
             ],
             "name": "Mixin"