Fix test failures, rename FunType to FnType, and fix type casting

Copilot · streamich · Copilot · commit 94254ae43ab2 · 2025-07-28T14:19:00.000Z
Co-authored-by: streamich &lt;9773803+streamich@users.noreply.github.com&gt;
diff --git a/src/codegen/capacity/estimators.ts b/src/codegen/capacity/estimators.ts
@@ -6,6 +6,7 @@ import type {
   CompiledCapacityEstimator,
 } from './CapacityEstimatorCodegenContext';
 import type {Type} from '../../type';
+import type {ConType} from '../../type/classes/ConType';
 
 type EstimatorFunction = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, type: Type) => void;
 
@@ -59,7 +60,7 @@ export const bin = (ctx: CapacityEstimatorCodegenContext, value: JsExpression):
 };
 
 export const const_ = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, type: Type): void => {
-  const constType = type as any; // ConType
+  const constType = type as ConType;
   ctx.inc(maxEncodingCapacity(constType.value()));
 };
 
diff --git a/src/random/generator.ts b/src/random/generator.ts
@@ -4,7 +4,7 @@ import type {ArrType} from '../type/classes/ArrType';
 import type {BinType} from '../type/classes/BinType';
 import type {BoolType} from '../type/classes/BoolType';
 import type {ConType} from '../type/classes/ConType';
-import type {FunType} from '../type/classes/FunType';
+import type {FnType} from '../type/classes/FnType';
 import type {MapType} from '../type/classes/MapType';
 import type {NumType} from '../type/classes/NumType';
 import type {ObjType} from '../type/classes/ObjType';
@@ -35,7 +35,7 @@ export function random(type: AbsType<any>): unknown {
       return gen.const_(type as ConType);
     case 'fn':
     case 'fn$':
-      return gen.fn(type as FunType<any, any>);
+      return gen.fn(type as FnType<any, any>);
     case 'map':
       return gen.map(type as MapType<any>);
     case 'num':
diff --git a/src/random/generators.ts b/src/random/generators.ts
@@ -5,7 +5,7 @@ import type {ArrType} from '../type/classes/ArrType';
 import type {BinType} from '../type/classes/BinType';
 import type {BoolType} from '../type/classes/BoolType';
 import type {ConType} from '../type/classes/ConType';
-import type {FunType} from '../type/classes/FunType';
+import type {FnType} from '../type/classes/FnType';
 import type {MapType} from '../type/classes/MapType';
 import type {NumType} from '../type/classes/NumType';
 import type {ObjType} from '../type/classes/ObjType';
@@ -46,7 +46,7 @@ export const const_ = (type: ConType): unknown => {
   return cloneBinary(type.getSchema().value);
 };
 
-export const fn = (type: FunType<any, any>): unknown => {
+export const fn = (type: FnType<any, any>): unknown => {
   return async () => type.res.random();
 };
 
diff --git a/src/schema/SchemaBuilder.ts b/src/schema/SchemaBuilder.ts
@@ -232,9 +232,9 @@ export class SchemaBuilder {
   }
 
   public Map<V extends Schema, K extends Schema = StringSchema>(
-    value: V, 
+    value: V,
     key?: K,
-    options?: Omit<NoT<MapSchema<V, K>>, 'value' | 'key'>
+    options?: Omit<NoT<MapSchema<V, K>>, 'value' | 'key'>,
   ): MapSchema<V, K> {
     return {kind: 'map', value, ...(key && {key}), ...options};
   }
diff --git a/src/schema/__tests__/validate.spec.ts b/src/schema/__tests__/validate.spec.ts
@@ -340,7 +340,7 @@ describe('validateSchema', () => {
       expect(() =>
         validateSchema({
           kind: 'bin',
-          type: {kind: 'str'},
+          value: {kind: 'str'},
           format: 'invalid',
         } as any),
       ).toThrow('FORMAT');
@@ -396,7 +396,7 @@ describe('validateSchema', () => {
           {
             kind: 'field',
             key: 'name',
-            type: {kind: 'str'},
+            value: {kind: 'str'},
           },
         ],
       };
@@ -428,7 +428,7 @@ describe('validateSchema', () => {
       const schema: Schema = {
         kind: 'field',
         key: 'test',
-        type: {kind: 'str'},
+        value: {kind: 'str'},
       };
       expect(() => validateSchema(schema)).not.toThrow();
     });
@@ -437,7 +437,7 @@ describe('validateSchema', () => {
       const schema: Schema = {
         kind: 'field',
         key: 'test',
-        type: {kind: 'str'},
+        value: {kind: 'str'},
         optional: true,
       };
       expect(() => validateSchema(schema)).not.toThrow();
@@ -448,7 +448,7 @@ describe('validateSchema', () => {
         validateSchema({
           kind: 'field',
           key: 123,
-          type: {kind: 'str'},
+          value: {kind: 'str'},
         } as any),
       ).toThrow('KEY_TYPE');
     });
@@ -458,7 +458,7 @@ describe('validateSchema', () => {
         validateSchema({
           kind: 'field',
           key: 'test',
-          type: {kind: 'str'},
+          value: {kind: 'str'},
           optional: 'true',
         } as any),
       ).toThrow('OPTIONAL_TYPE');
@@ -469,7 +469,7 @@ describe('validateSchema', () => {
     test('validates valid map schema', () => {
       const schema: Schema = {
         kind: 'map',
-        type: {kind: 'str'},
+        value: {kind: 'str'},
       };
       expect(() => validateSchema(schema)).not.toThrow();
     });
diff --git a/src/schema/schema.ts b/src/schema/schema.ts
@@ -374,7 +374,9 @@ export interface ObjectOptionalFieldSchema<K extends string = string, V extends
  * Represents an object, which is treated as a map. All keys are strings and all
  * values are of the same type.
  */
-export interface MapSchema<V extends TType = any, K extends TType = any> extends TType<Record<string, unknown>>, WithValidator {
+export interface MapSchema<V extends TType = any, K extends TType = any>
+  extends TType<Record<string, unknown>>,
+    WithValidator {
   kind: 'map';
   /**
    * Type of all keys in the map. Defaults to string type.
diff --git a/src/type/TypeBuilder.ts b/src/type/TypeBuilder.ts
@@ -251,7 +251,7 @@ export class TypeBuilder {
     res: Res,
     options?: schema.Optional<schema.FunctionSchema>,
   ) {
-    const fn = new classes.FunType<Req, Res>(req, res, options);
+    const fn = new classes.FnType<Req, Res>(req, res, options);
     fn.system = this.system;
     return fn;
   }
diff --git a/src/type/__tests__/toTypeScriptAst.spec.ts b/src/type/__tests__/toTypeScriptAst.spec.ts
@@ -277,7 +277,7 @@ describe('fn', () => {
     const type = system.t.Function(t.str, t.num);
     expect(type.toTypeScriptAst()).toMatchInlineSnapshot(`
 {
-  "node": "FunType",
+  "node": "FnType",
   "parameters": [
     {
       "name": {
@@ -314,7 +314,7 @@ describe('fn$', () => {
     const type = system.t.Function$(t.str, t.num);
     expect(type.toTypeScriptAst()).toMatchInlineSnapshot(`
 {
-  "node": "FunType",
+  "node": "FnType",
   "parameters": [
     {
       "name": {
diff --git a/src/type/classes.ts b/src/type/classes.ts
@@ -11,7 +11,7 @@ import {ObjType, ObjectFieldType, ObjectOptionalFieldType} from './classes/ObjTy
 import {MapType} from './classes/MapType';
 import {RefType} from './classes/RefType';
 import {OrType} from './classes/OrType';
-import {FunType, FunctionStreamingType} from './classes/FunType';
+import {FnType, FunctionStreamingType} from './classes/FnType';
 
 export {
   AbsType,
@@ -29,6 +29,6 @@ export {
   MapType,
   RefType,
   OrType,
-  FunType,
+  FnType,
   FunctionStreamingType,
 };
diff --git a/src/type/classes/FnType.ts b/src/type/classes/FnType.ts
@@ -10,7 +10,7 @@ const fnNotImplemented: schema.FunctionValue<any, any> = async () => {
   throw new Error('NOT_IMPLEMENTED');
 };
 
-const toStringTree = (tab: string = '', type: FunType<Type, Type> | FunctionStreamingType<Type, Type>) => {
+const toStringTree = (tab: string = '', type: FnType<Type, Type> | FunctionStreamingType<Type, Type>) => {
   return printTree(tab, [
     (tab) => 'req: ' + type.req.toString(tab + '     '),
     (tab) => 'res: ' + type.res.toString(tab + '     '),
@@ -22,7 +22,7 @@ type FunctionImpl<Req extends Type, Res extends Type, Ctx = unknown> = (
   ctx: Ctx,
 ) => Promise<ResolveType<Res>>;
 
-export class FunType<Req extends Type, Res extends Type> extends AbsType<
+export class FnType<Req extends Type, Res extends Type> extends AbsType<
   schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>>
 > {
   protected schema: schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>>;
@@ -41,21 +41,21 @@ export class FunType<Req extends Type, Res extends Type> extends AbsType<
     } as any;
   }
 
-  public request<T extends Type>(req: T): FunType<T, Res> {
+  public request<T extends Type>(req: T): FnType<T, Res> {
     (this as any).req = req;
     return this as any;
   }
 
-  public inp<T extends Type>(req: T): FunType<T, Res> {
+  public inp<T extends Type>(req: T): FnType<T, Res> {
     return this.request(req);
   }
 
-  public response<T extends Type>(res: T): FunType<Req, T> {
+  public response<T extends Type>(res: T): FnType<Req, T> {
     (this as any).res = res;
     return this as any;
   }
 
-  public out<T extends Type>(res: T): FunType<Req, T> {
+  public out<T extends Type>(res: T): FnType<Req, T> {
     return this.response(res);
   }
 
@@ -102,21 +102,21 @@ export class FunctionStreamingType<Req extends Type, Res extends Type> extends A
     } as any;
   }
 
-  public request<T extends Type>(req: T): FunType<T, Res> {
+  public request<T extends Type>(req: T): FnType<T, Res> {
     (this as any).req = req;
     return this as any;
   }
 
-  public inp<T extends Type>(req: T): FunType<T, Res> {
+  public inp<T extends Type>(req: T): FnType<T, Res> {
     return this.request(req);
   }
 
-  public response<T extends Type>(res: T): FunType<Req, T> {
+  public response<T extends Type>(res: T): FnType<Req, T> {
     (this as any).res = res;
     return this as any;
   }
 
-  public out<T extends Type>(res: T): FunType<Req, T> {
+  public out<T extends Type>(res: T): FnType<Req, T> {
     return this.response(res);
   }
 
diff --git a/src/type/types.ts b/src/type/types.ts
@@ -20,7 +20,7 @@ export type Type =
   | classes.MapType<any>
   | classes.RefType<any>
   | classes.OrType<any>
-  | classes.FunType<any, any>
+  | classes.FnType<any, any>
   | classes.FunctionStreamingType<any, any>;
 
 export type SchemaOf<T extends Type | Type[]> = T extends BaseType<infer U> ? U : never;
@@ -41,11 +41,11 @@ export type SchemaOfObjectFields<F> = {
 export type TypeMap = {[name: string]: schema.Schema};
 
 export type FilterFunctions<T> = {
-  [K in keyof T as T[K] extends classes.FunType<any, any>
+  [K in keyof T as T[K] extends classes.FnType<any, any>
     ? K
     : T[K] extends classes.FunctionStreamingType<any, any>
       ? K
-      : never]: T[K] extends classes.FunType<any, any>
+      : never]: T[K] extends classes.FnType<any, any>
     ? T[K]
     : T[K] extends classes.FunctionStreamingType<any, any>
       ? T[K]
diff --git a/src/typescript/converter.ts b/src/typescript/converter.ts
@@ -176,8 +176,8 @@ export function toTypeScriptAst(schema: schema.Schema): ts.TsType {
       const reqSchema = (fnSchema.req as any).getSchema ? (fnSchema.req as any).getSchema() : fnSchema.req;
       const resSchema = (fnSchema.res as any).getSchema ? (fnSchema.res as any).getSchema() : fnSchema.res;
 
-      const node: ts.TsFunType = {
-        node: 'FunType',
+      const node: ts.TsFnType = {
+        node: 'FnType',
         parameters: [
           {
             node: 'Parameter',
@@ -205,8 +205,8 @@ export function toTypeScriptAst(schema: schema.Schema): ts.TsType {
       const reqSchema = (fnSchema.req as any).getSchema ? (fnSchema.req as any).getSchema() : fnSchema.req;
       const resSchema = (fnSchema.res as any).getSchema ? (fnSchema.res as any).getSchema() : fnSchema.res;
 
-      const node: ts.TsFunType = {
-        node: 'FunType',
+      const node: ts.TsFnType = {
+        node: 'FnType',
         parameters: [
           {
             node: 'Parameter',
diff --git a/src/typescript/toText.ts b/src/typescript/toText.ts
@@ -106,7 +106,7 @@ export const toText = (node: TsNode | TsNode[] | TsIdentifier | TsParameter, __:
     case 'Identifier': {
       return node.name;
     }
-    case 'FunType': {
+    case 'FnType': {
       const {parameters, type} = node;
       const params = parameters.map((p) => toText(p, __)).join(', ');
       return `(${params}) => ${toText(type, __)}`;
diff --git a/src/typescript/types.ts b/src/typescript/types.ts
@@ -141,8 +141,8 @@ export interface TsTypeReference {
   typeArguments?: TsType[];
 }
 
-export interface TsFunType {
-  node: 'FunType';
+export interface TsFnType {
+  node: 'FnType';
   parameters: TsParameter[];
   type: TsType;
 }
@@ -172,7 +172,7 @@ export type TsType =
   | TsUnionType
   | TsTypeReference
   | TsGenericTypeAnnotation
-  | TsFunType;
+  | TsFnType;
 
 /** Any possible TypeScript AST node. */
 export type TsNode = TsDeclaration | TsType | TsPropertySignature | TsIndexSignature;
diff --git a/src/value/ObjectValue.ts b/src/value/ObjectValue.ts
@@ -40,9 +40,7 @@ export class ObjectValue<T extends classes.ObjType<any>> extends Value<T> implem
   public get<K extends keyof ObjectValueToTypeMap<UnObjType<T>>>(
     key: K,
   ): Value<
-    ObjectValueToTypeMap<UnObjType<T>>[K] extends classes.Type
-      ? ObjectValueToTypeMap<UnObjType<T>>[K]
-      : classes.Type
+    ObjectValueToTypeMap<UnObjType<T>>[K] extends classes.Type ? ObjectValueToTypeMap<UnObjType<T>>[K] : classes.Type
   > {
     const field = this.type.getField(<string>key);
     if (!field) throw new Error('NO_FIELD');

Original file line number	Diff line number	Diff line change
`@@ -232,9 +232,9 @@ export class SchemaBuilder {`
`232`	`232`	`}`
`233`	`233`
`234`	`234`	`public Map<V extends Schema, K extends Schema = StringSchema>(`
`235`		`- value: V,`
	`235`	`+ value: V,`
`236`	`236`	`key?: K,`
`237`		`- options?: Omit<NoT<MapSchema<V, K>>, 'value' \| 'key'>`
	`237`	`+ options?: Omit<NoT<MapSchema<V, K>>, 'value' \| 'key'>,`
`238`	`238`	`): MapSchema<V, K> {`
`239`	`239`	`return {kind: 'map', value, ...(key && {key}), ...options};`
`240`	`240`	`}`
Original file line number	Diff line number	Diff line change
`@@ -251,7 +251,7 @@ export class TypeBuilder {`
`251`	`251`	`res: Res,`
`252`	`252`	`options?: schema.Optional<schema.FunctionSchema>,`
`253`	`253`	`) {`
`254`		`- const fn = new classes.FunType<Req, Res>(req, res, options);`
	`254`	`+ const fn = new classes.FnType<Req, Res>(req, res, options);`
`255`	`255`	`fn.system = this.system;`
`256`	`256`	`return fn;`
`257`	`257`	`}`
Original file line number	Diff line number	Diff line change
`@@ -277,7 +277,7 @@ describe('fn', () => {`
`277`	`277`	`const type = system.t.Function(t.str, t.num);`
`278`	`278`	expect(type.toTypeScriptAst()).toMatchInlineSnapshot(`
`279`	`279`	`{`
`280`		`- "node": "FunType",`
	`280`	`+ "node": "FnType",`
`281`	`281`	`"parameters": [`
`282`	`282`	`{`
`283`	`283`	`"name": {`
`@@ -314,7 +314,7 @@ describe('fn$', () => {`
`314`	`314`	`const type = system.t.Function$(t.str, t.num);`
`315`	`315`	expect(type.toTypeScriptAst()).toMatchInlineSnapshot(`
`316`	`316`	`{`
`317`		`- "node": "FunType",`
	`317`	`+ "node": "FnType",`
`318`	`318`	`"parameters": [`
`319`	`319`	`{`
`320`	`320`	`"name": {`