Merge pull request #40 from jsonjoy-com/fn-value

Fn value

Author: streamich

src/type/classes/FnType.ts

@@ -4,6 +4,7 @@ import {AbsType} from './AbsType';
 import type {SchemaOf, Type} from '../types';
 import type {ResolveType} from '../../system';
 import type {Observable} from 'rxjs';
+import {Value} from '../../value';
 
 const fnNotImplemented: schema.FunctionValue<any, any> = async () => {
   throw new Error('NOT_IMPLEMENTED');
@@ -40,28 +41,40 @@ export class FnType<Req extends Type, Res extends Type, Ctx = unknown> extends A
     } as any;
   }
 
-  public request<T extends Type>(req: T): FnType<T, Res> {
+  public input<T extends Type>(req: T): FnType<T, Res> {
+    return this.inp(req);
+  }
+
+  public inp<T extends Type>(req: T): FnType<T, Res> {
     (this as any).req = req;
     return this as any;
   }
 
-  public inp<T extends Type>(req: T): FnType<T, Res> {
-    return this.request(req);
+  public output<T extends Type>(res: T): FnType<Req, T> {
+    return this.out(res);
   }
 
-  public response<T extends Type>(res: T): FnType<Req, T> {
+  public out<T extends Type>(res: T): FnType<Req, T> {
     (this as any).res = res;
     return this as any;
   }
 
-  public out<T extends Type>(res: T): FnType<Req, T> {
-    return this.response(res);
+  public io<I extends Type, O extends Type>(request: I, response: O): FnType<I, O, Ctx> {
+    return this.inp(request).out(response) as FnType<I, O, Ctx>;
+  }
+
+  public signature<I extends Type, O extends Type>(request: I, response: O): FnType<I, O, Ctx> {
+    return this.io(request, response) as FnType<I, O, Ctx>;
   }
 
   public ctx<T>(): FnType<Req, Res, T> {
     return this as any;
   }
 
+  public value(data: ResolveType<FnType<Req, Res, Ctx>>) {
+    return new Value<FnType<Req, Res, Ctx>>(this, data);
+  }
+
   public getSchema(): schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>, Ctx> {
     return {
       ...this.schema,
@@ -70,13 +83,6 @@ export class FnType<Req extends Type, Res extends Type, Ctx = unknown> extends A
     };
   }
 
-  public singleton?: FunctionImpl<Req, Res, Ctx> = undefined;
-
-  public implement(singleton: FunctionImpl<Req, Res, Ctx>): this {
-    this.singleton = singleton;
-    return this;
-  }
-
   public toString(tab: string = ''): string {
     return super.toString(tab) + toStringTree(tab, this);
   }
@@ -131,13 +137,6 @@ export class FnRxType<Req extends Type, Res extends Type, Ctx = unknown> extends
     };
   }
 
-  public singleton?: FunctionStreamingImpl<Req, Res, Ctx> = undefined;
-
-  public implement(singleton: FunctionStreamingImpl<Req, Res, Ctx>): this {
-    this.singleton = singleton;
-    return this;
-  }
-
   public toString(tab: string = ''): string {
     return super.toString(tab) + toStringTree(tab, this);
   }

src/typescript/converter.ts

@@ -1,5 +1,6 @@
 import type * as ts from './types';
 import type * as schema from '../schema';
+import type {ObjType} from '../type/classes';
 
 /**
  * Main router function that converts any Schema to TypeScript AST.
@@ -242,3 +243,23 @@ export function toTypeScriptAst(schema: schema.Schema): ts.TsType {
     }
   }
 }
+
+export const objToModule = (obj: ObjType<any>): ts.TsModuleDeclaration => {
+  const node: ts.TsModuleDeclaration = {
+    node: 'ModuleDeclaration',
+    name: 'Router',
+    export: true,
+    statements: [
+      {
+        node: 'TypeAliasDeclaration',
+        name: 'Routes',
+        type: toTypeScriptAst(obj.getSchema()),
+        export: true,
+      },
+    ],
+  };
+  const system = obj.system;
+  if (!system) throw new Error('system is undefined');
+  for (const alias of system.aliases.values()) node.statements.push({...alias.toTypeScriptAst(), export: true});
+  return node;
+};

src/value/ObjValue.ts

@@ -0,0 +1,86 @@
+import {Value} from './Value';
+import {TypeSystem} from '../system/TypeSystem';
+import {printTree} from 'tree-dump/lib/printTree';
+import type * as classes from '../type';
+import type {TypeBuilder} from '../type/TypeBuilder';
+import type {Printable} from 'tree-dump/lib/types';
+import type {ResolveType} from '../system/types';
+
+export type UnObjType<T> = T extends classes.ObjType<infer U> ? U : never;
+export type UnObjValue<T> = T extends ObjValue<infer U> ? U : never;
+export type UnObjFieldTypeVal<T> = T extends classes.ObjectFieldType<any, infer U> ? U : never;
+export type ObjFieldToTuple<F> = F extends classes.ObjectFieldType<infer K, infer V> ? [K, V] : never;
+export type ToObject<T> = T extends [string, unknown][] ? {[K in T[number] as K[0]]: K[1]} : never;
+export type ObjValueToTypeMap<F> = ToObject<{
+  [K in keyof F]: ObjFieldToTuple<F[K]>;
+}>;
+
+export class ObjValue<T extends classes.ObjType<any>> extends Value<T> implements Printable {
+  public static new = (system: TypeSystem = new TypeSystem()) => new ObjValue(system.t.obj, {});
+
+  public get system(): TypeSystem {
+    return (this.type as T).getSystem();
+  }
+
+  public get t(): TypeBuilder {
+    return this.system.t;
+  }
+
+  public keys(): string[] {
+    const type = this.type as T;
+    return type.fields.map((field: classes.ObjectFieldType<string, any>) => field.key);
+  }
+
+  public get<K extends keyof ObjValueToTypeMap<UnObjType<T>>>(
+    key: K,
+  ): Value<
+    ObjValueToTypeMap<UnObjType<T>>[K] extends classes.Type ? ObjValueToTypeMap<UnObjType<T>>[K] : classes.Type
+  > {
+    const field = this.type.getField(<string>key);
+    if (!field) throw new Error('NO_FIELD');
+    const type = field.value;
+    const data = this.data[<string>key];
+    return new Value(type, data) as any;
+  }
+
+  public field<F extends classes.ObjectFieldType<any, any>>(
+    field: F | ((t: TypeBuilder) => F),
+    data: ResolveType<UnObjFieldTypeVal<F>>,
+  ): ObjValue<classes.ObjType<[...UnObjType<T>, F]>> {
+    field = typeof field === 'function' ? field((this.type as classes.ObjType<any>).getSystem().t) : field;
+    this.data[field.key] = data;
+    const type = this.type;
+    const system = type.system;
+    if (!system) throw new Error('NO_SYSTEM');
+    type.fields.push(field);
+    return this as any;
+  }
+
+  public add<K extends string, V extends classes.Type>(
+    key: K,
+    type: V | ((t: TypeBuilder) => V),
+    data: ResolveType<V>,
+  ) {
+    const system = (this.type as classes.ObjType<any>).getSystem();
+    const t = system.t;
+    type = typeof type === 'function' ? type(t) : type;
+    return this.field(t.prop(key, type), data);
+  }
+
+  public set<K extends string, V extends classes.Type>(key: K, value: Value<V>) {
+    return this.add(key, value.type, value.data);
+  }
+
+  public merge<O extends ObjValue<any>>(obj: O): ObjValue<classes.ObjType<[...UnObjType<T>, ...UnObjType<O['type']>]>> {
+    Object.assign(this.data as object, obj.data);
+    const type = this.type;
+    const system = type.system;
+    if (!system) throw new Error('NO_SYSTEM');
+    type.fields.push(...type.fields);
+    return this as any;
+  }
+
+  public toString(tab: string = ''): string {
+    return 'ObjValue' + printTree(tab, [(tab) => this.type.toString(tab)]);
+  }
+}