Merge pull request #39 from jsonjoy-com/impr-fn

Impr fn

Author: streamich

src/schema/schema.ts

@@ -412,19 +412,22 @@ export interface OrSchema<T extends TType[] = TType[]> extends TType {
 
 export type FunctionValue<Req, Res, Ctx = unknown> = (req: Req, ctx?: Ctx) => Res | Promise<Res>;
 
-export interface FunctionSchema<Req extends TType = TType, Res extends TType = TType> extends TType {
+export interface FunctionSchema<Req extends TType = TType, Res extends TType = TType, Ctx = unknown> extends TType {
   kind: 'fn';
   req: Req;
   res: Res;
+  __ctx_brand?: Ctx;
 }
 
 export type FunctionStreamingValue<Req, Res, Ctx = unknown> = (req: Observable<Req>, ctx?: Ctx) => Observable<Res>;
 
-export interface FunctionStreamingSchema<Req extends TType = TType, Res extends TType = TType> extends TType {
+export interface FunctionStreamingSchema<Req extends TType = TType, Res extends TType = TType, Ctx = unknown>
+  extends TType {
   /** @todo Rename to `fn`. Make it a property on the schema instead. */
   kind: 'fn$';
   req: Req;
   res: Res;
+  __ctx_brand?: Ctx;
 }
 
 export interface TypeSystemSchema {
@@ -480,10 +483,10 @@ export type TypeOfValue<T> = T extends BooleanSchema
                 ? Record<string, TypeOf<U>>
                 : T extends BinarySchema
                   ? Uint8Array
-                  : T extends FunctionSchema<infer Req, infer Res>
-                    ? (req: TypeOf<Req>, ctx?: unknown) => Promise<TypeOf<Res>>
-                    : T extends FunctionStreamingSchema<infer Req, infer Res>
-                      ? (req$: Observable<TypeOf<Req>>, ctx?: unknown) => Observable<TypeOf<Res>>
+                  : T extends FunctionSchema<infer Req, infer Res, infer Ctx>
+                    ? (req: TypeOf<Req>, ctx: Ctx) => UndefToVoid<TypeOf<Res>> | Promise<UndefToVoid<TypeOf<Res>>>
+                    : T extends FunctionStreamingSchema<infer Req, infer Res, infer Ctx>
+                      ? (req$: Observable<TypeOf<Req>>, ctx: Ctx) => Observable<UndefToVoid<TypeOf<Res>>>
                       : never;
 
 export type TypeOfMap<M extends Record<string, Schema>> = {
@@ -510,6 +513,8 @@ type TypeOfFieldMap<T> = {[K in keyof T]: TypeOf<FieldValue<T[K]>>};
 
 type FieldValue<F> = F extends ObjectFieldSchema<any, infer V> ? V : never;
 
+type UndefToVoid<T> = T extends undefined ? void : T;
+
 export type OptionalProps<T extends object> = Exclude<
   {
     [K in keyof T]: T extends Record<K, T[K]> ? never : K;

src/type/TypeBuilder.ts

@@ -246,22 +246,22 @@ export class TypeBuilder {
     return type;
   }
 
-  public Function<Req extends Type, Res extends Type>(
+  public Function<Req extends Type, Res extends Type, Ctx = unknown>(
     req: Req,
     res: Res,
     options?: schema.Optional<schema.FunctionSchema>,
   ) {
-    const fn = new classes.FnType<Req, Res>(req, res, options);
+    const fn = new classes.FnType<Req, Res, Ctx>(req, res, options);
     fn.system = this.system;
     return fn;
   }
 
-  public Function$<Req extends Type, Res extends Type>(
+  public Function$<Req extends Type, Res extends Type, Ctx = unknown>(
     req: Req,
     res: Res,
     options?: schema.Optional<schema.FunctionStreamingSchema>,
   ) {
-    const fn = new classes.FunctionStreamingType<Req, Res>(req, res, options);
+    const fn = new classes.FnRxType<Req, Res, Ctx>(req, res, options);
     fn.system = this.system;
     return fn;
   }

src/type/__tests__/TypeBuilder.spec.ts

@@ -1,6 +1,7 @@
 import {NumType, ObjectFieldType, ObjType, StrType} from '../classes';
 import {type SchemaOf, t} from '..';
 import type {TypeOf} from '../../schema';
+import {fn} from '../../random';
 
 test('number', () => {
   const type = t.Number({
@@ -114,11 +115,25 @@ test('can build type using lowercase shortcuts', () => {
     offsets: [1, 2, 3],
     enum: 'three',
     optional: undefined,
-  } as ObjType2;
+  } satisfies ObjType2;
   MyObject.validate(obj);
   MyObject2.validate(obj);
 });
 
+test('can specify function with context', () => {
+  const MyObject = t.object({
+    fn: t.fn.inp(t.str).out(t.undef).ctx<{ip: string}>(),
+  });
+  // console.log(MyObject + '');
+  const MyObject2 = t.obj.prop('fn', t.Function(t.str, t.undef).ctx<{ip: string}>());
+  expect(MyObject.getSchema()).toEqual(MyObject2.getSchema());
+  type ObjType = t.infer<typeof MyObject>;
+  type ObjType2 = t.infer<typeof MyObject2>;
+  const obj: ObjType = {
+    fn: async (req: string, ctx: {ip: string}): Promise<void> => {},
+  } satisfies ObjType2;
+});
+
 describe('import()', () => {
   test('can import a number schema', () => {
     const type = t.import({

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 {FnType, FunctionStreamingType} from './classes/FnType';
+import {FnType, FnRxType} from './classes/FnType';
 
 export {
   AbsType,
@@ -30,5 +30,5 @@ export {
   RefType,
   OrType,
   FnType,
-  FunctionStreamingType,
+  FnRxType,
 };

src/type/classes/FnType.ts

@@ -2,15 +2,14 @@ import {printTree} from 'tree-dump/lib/printTree';
 import * as schema from '../../schema';
 import {AbsType} from './AbsType';
 import type {SchemaOf, Type} from '../types';
-import type * as ts from '../../typescript/types';
 import type {ResolveType} from '../../system';
 import type {Observable} from 'rxjs';
 
 const fnNotImplemented: schema.FunctionValue<any, any> = async () => {
   throw new Error('NOT_IMPLEMENTED');
 };
 
-const toStringTree = (tab: string = '', type: FnType<Type, Type> | FunctionStreamingType<Type, Type>) => {
+const toStringTree = (tab: string = '', type: FnType<Type, Type, any> | FnRxType<Type, Type, any>) => {
   return printTree(tab, [
     (tab) => 'req: ' + type.req.toString(tab + '     '),
     (tab) => 'res: ' + type.res.toString(tab + '     '),
@@ -20,12 +19,12 @@ const toStringTree = (tab: string = '', type: FnType<Type, Type> | FunctionStrea
 type FunctionImpl<Req extends Type, Res extends Type, Ctx = unknown> = (
   req: ResolveType<Req>,
   ctx: Ctx,
-) => Promise<ResolveType<Res>>;
+) => ResolveType<Res> | Promise<ResolveType<Res>>;
 
-export class FnType<Req extends Type, Res extends Type> extends AbsType<
-  schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>>
+export class FnType<Req extends Type, Res extends Type, Ctx = unknown> extends AbsType<
+  schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>, Ctx>
 > {
-  protected schema: schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>>;
+  protected schema: schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>, Ctx>;
 
   public fn: schema.FunctionValue<schema.TypeOf<SchemaOf<Req>>, schema.TypeOf<SchemaOf<Res>>> = fnNotImplemented;
 
@@ -59,17 +58,21 @@ export class FnType<Req extends Type, Res extends Type> extends AbsType<
     return this.response(res);
   }
 
-  public getSchema(): schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>> {
+  public ctx<T>(): FnType<Req, Res, T> {
+    return this as any;
+  }
+
+  public getSchema(): schema.FunctionSchema<SchemaOf<Req>, SchemaOf<Res>, Ctx> {
     return {
       ...this.schema,
       req: this.req.getSchema() as SchemaOf<Req>,
       res: this.res.getSchema() as SchemaOf<Res>,
     };
   }
 
-  public singleton?: FunctionImpl<Req, Res, any> = undefined;
+  public singleton?: FunctionImpl<Req, Res, Ctx> = undefined;
 
-  public implement<Ctx = unknown>(singleton: FunctionImpl<Req, Res, Ctx>): this {
+  public implement(singleton: FunctionImpl<Req, Res, Ctx>): this {
     this.singleton = singleton;
     return this;
   }
@@ -84,11 +87,11 @@ type FunctionStreamingImpl<Req extends Type, Res extends Type, Ctx = unknown> =
   ctx: Ctx,
 ) => Observable<ResolveType<Res>>;
 
-export class FunctionStreamingType<Req extends Type, Res extends Type> extends AbsType<
-  schema.FunctionStreamingSchema<SchemaOf<Req>, SchemaOf<Res>>
+export class FnRxType<Req extends Type, Res extends Type, Ctx = unknown> extends AbsType<
+  schema.FunctionStreamingSchema<SchemaOf<Req>, SchemaOf<Res>, Ctx>
 > {
   public readonly isStreaming = true;
-  protected schema: schema.FunctionStreamingSchema<SchemaOf<Req>, SchemaOf<Res>>;
+  protected schema: schema.FunctionStreamingSchema<SchemaOf<Req>, SchemaOf<Res>, Ctx>;
 
   constructor(
     public readonly req: Req,
@@ -120,17 +123,17 @@ export class FunctionStreamingType<Req extends Type, Res extends Type> extends A
     return this.response(res);
   }
 
-  public getSchema(): schema.FunctionStreamingSchema<SchemaOf<Req>, SchemaOf<Res>> {
+  public getSchema(): schema.FunctionStreamingSchema<SchemaOf<Req>, SchemaOf<Res>, Ctx> {
     return {
       ...this.schema,
       req: this.req.getSchema() as SchemaOf<Req>,
       res: this.res.getSchema() as SchemaOf<Res>,
     };
   }
 
-  public singleton?: FunctionStreamingImpl<Req, Res, any> = undefined;
+  public singleton?: FunctionStreamingImpl<Req, Res, Ctx> = undefined;
 
-  public implement<Ctx = unknown>(singleton: FunctionStreamingImpl<Req, Res, Ctx>): this {
+  public implement(singleton: FunctionStreamingImpl<Req, Res, Ctx>): this {
     this.singleton = singleton;
     return this;
   }

src/type/index.ts

@@ -1,8 +1,8 @@
 export * from './types';
 export * from './classes';
 
-import type {TypeOf} from '../schema';
 import {TypeBuilder} from './TypeBuilder';
+import type {TypeOf} from '../schema';
 import type {SchemaOf, Type} from './types';
 
 export const t = new TypeBuilder();

src/type/types.ts

@@ -20,8 +20,8 @@ export type Type =
   | classes.MapType<any>
   | classes.RefType<any>
   | classes.OrType<any>
-  | classes.FnType<any, any>
-  | classes.FunctionStreamingType<any, any>;
+  | classes.FnType<any, any, any>
+  | classes.FnRxType<any, any, any>;
 
 export type SchemaOf<T extends Type | Type[]> = T extends BaseType<infer U> ? U : never;
 export type SchemaOfMap<M extends Record<string, Type>> = {
@@ -41,13 +41,13 @@ export type SchemaOfObjectFields<F> = {
 export type TypeMap = {[name: string]: schema.Schema};
 
 export type FilterFunctions<T> = {
-  [K in keyof T as T[K] extends classes.FnType<any, any>
+  [K in keyof T as T[K] extends classes.FnType<any, any, any>
     ? K
-    : T[K] extends classes.FunctionStreamingType<any, any>
+    : T[K] extends classes.FnRxType<any, any, any>
       ? K
-      : never]: T[K] extends classes.FnType<any, any>
+      : never]: T[K] extends classes.FnType<any, any, any>
     ? T[K]
-    : T[K] extends classes.FunctionStreamingType<any, any>
+    : T[K] extends classes.FnRxType<any, any, any>
       ? T[K]
       : never;
 };