rework typing system

package-lock.json

 {
-  "name": "myproject",
+  "name": "cordis-decorators",
   "version": "1.0.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
-      "name": "myproject",
+      "name": "cordis-decorators",
       "version": "1.0.7",
       "license": "MIT",
       "dependencies": {

src/def/interfaces.ts

 import { PluginRegistrar } from '../plugin-def';
 import PluginClass = PluginRegistrar.PluginClass;
-import { Context } from 'cordis';
-
 export type Awaitable<T> = [T] extends [Promise<unknown>] ? T : T | Promise<T>;
 
 export type TypedMethodDecorator<F extends (...args: any[]) => any> = <
@@ -13,23 +11,6 @@ export type TypedMethodDecorator<F extends (...args: any[]) => any> = <
   descriptor: TypedPropertyDescriptor<T>,
 ) => void;
 
-export type FunctionParam<F extends (...args: any[]) => any> = F extends (
-  ...args: infer R
-) => any
-  ? R
-  : never;
-export type FunctionReturn<F extends (...args: any[]) => any> = F extends (
-  ...args: any[]
-) => infer R
-  ? R
-  : never;
-
-export type PickEventFunction<M, K extends keyof M = keyof M> = M[K] extends (
-  ...args: any[]
-) => any
-  ? (...args: FunctionParam<M[K]>) => Awaitable<FunctionReturn<M[K]>>
-  : M[K];
-
 export type ParamRenderer = <T>(v: T) => T;
 
 export interface ControlTypeMap {
@@ -57,6 +38,18 @@ export type ParamsFromClass<T> = T extends { new (...args: infer U): any }
   ? U
   : never;
 
+export type FunctionParams<F extends (...args: any[]) => any> = F extends (
+  ...args: infer U
+) => any
+  ? U
+  : never;
+
+export type FunctionReturn<F extends (...args: any[]) => any> = F extends (
+  ...args: any
+) => infer U
+  ? U
+  : never;
+
 export type Prop<T> = T;
 
 export type PartialDeep<T> = T extends

src/plugin-def/index.ts

 import { Context, Plugin } from 'cordis';
 import Schema from 'schemastery';
 import { ClassType } from 'schemastery-gen';
-import type { Registrar } from '../registrar';
 
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace PluginRegistrar {
@@ -20,7 +19,7 @@ export namespace PluginRegistrar {
     name?: string;
     schema?: Schema<T> | ClassType<T>;
     Config?: Schema<T> | ClassType<T>;
-    using?: Registrar.ServiceName<Ctx>[];
+    using?: string[];
     reusable?: boolean;
   }
 

src/registrar-aspect.ts

 import { Context } from 'cordis';
 import { Registrar } from './registrar';
-import { generateRenderer, renderObject } from './utility/render-object';
+import { generateRenderer } from './utility/render-object';
 import { extractObjectMethod } from './utility/utility';
 import { ControlType } from './def';
 import {
@@ -9,13 +9,10 @@ import {
   Observable,
   ObservableInput,
   ObservedValueOf,
-  of,
 } from 'rxjs';
 import _ from 'lodash';
-
-type RecursiveUnwrapObservable<T> = T extends ObservableInput<any>
-  ? RecursiveUnwrapObservable<ObservedValueOf<T>>
-  : T;
+import ContextTransformer = Registrar.ContextTransformer;
+import { RegisterMeta } from './utility/register-meta';
 
 export class RegistrarAspect<Ctx extends Context, T = any> {
   constructor(
@@ -45,8 +42,11 @@ export class RegistrarAspect<Ctx extends Context, T = any> {
       this.obj,
       key,
     );
-    const r = generateRenderer({ ...this.view, ...extraView });
-    return this.registrar.transformContext(ctx, contextFilters, r);
+    return this.registrar.transformContext(
+      ctx,
+      contextFilters as RegisterMeta<ContextTransformer<Ctx, any[]>>[],
+      { ...this.view, ...extraView },
+    );
   }
 
   registerMethod(
@@ -57,12 +57,18 @@ export class RegistrarAspect<Ctx extends Context, T = any> {
     const data = this.registrar.reflector.get('CordisRegister', this.obj, key);
     if (!data) return;
     const specificCtx = this.getScopeContext(ctx, key, extraView, false);
-    const result = data.action(
+    const result = data.run(
+      { ...this.view, ...extraView },
       specificCtx,
       extractObjectMethod(this.obj, key),
-      ...renderObject(data.args, { ...this.view, ...extraView }),
     );
-    return { ...data, key: key, result, ctx: specificCtx };
+    return {
+      ...data,
+      type: data.info.type,
+      key: key,
+      result,
+      ctx: specificCtx,
+    };
   }
 
   private registerWithLoopControl(
@@ -98,7 +104,7 @@ export class RegistrarAspect<Ctx extends Context, T = any> {
   private runLayersWith<R extends ObservableInput<any>>(
     ctx: Ctx,
     cb: Registrar.ContextFunction<Ctx, R>,
-    layers: Registrar.ContextCallbackLayer<Ctx>[],
+    layers: RegisterMeta<Registrar.ContextCallbackLayer<Ctx>>[],
   ): Observable<ObservedValueOf<R>> {
     const rest = [...layers];
     const layer = rest.pop();
@@ -106,7 +112,7 @@ export class RegistrarAspect<Ctx extends Context, T = any> {
       return from(cb(ctx));
     }
     return new Observable((subscriber) => {
-      layer(ctx, async (nextCtx) => {
+      layer.run(this.view, ctx, async (nextCtx) => {
         if (!rest.length) {
           const result = cb(nextCtx);
           if (result) {
@@ -134,7 +140,11 @@ export class RegistrarAspect<Ctx extends Context, T = any> {
       this.obj,
       key as string,
     );
-    return this.runLayersWith(ctx, cb, layers);
+    return this.runLayersWith(
+      ctx,
+      cb,
+      layers as RegisterMeta<Registrar.ContextCallbackLayer<Ctx>>[],
+    );
   }
 
   registerFor(ctx: Ctx, key: keyof T & string) {
@@ -169,6 +179,8 @@ export class RegistrarAspect<Ctx extends Context, T = any> {
       this.registrar.reflector.getArray('CordisTopLevelAction', this.obj),
     );
     const renderer = generateRenderer({ ...this.view, ...extraView });
-    actions.forEach((action) => action(ctx, this.obj, renderer));
+    actions.forEach((action) =>
+      action.run({ ...this.view, ...extraView }, ctx, this.obj, renderer),
+    );
   }
 }

src/registrar.ts

 import 'reflect-metadata';
-import { Context, Events, Fork } from 'cordis';
+import { Context, GetEvents } from 'cordis';
 import { ClassType, SchemaClass } from 'schemastery-gen';
 import { MetadataSetter, Reflector } from 'typed-reflector';
 import type {
   Awaitable,
   Condition,
   ControlType,
-  FunctionParam,
-  FunctionReturn,
-  ParamRenderer,
   PartialDeep,
-  PickEventFunction,
   TypedMethodDecorator,
 } from './def';
 import { RegistrarAspect } from './registrar-aspect';
 import Schema from 'schemastery';
 import { PluginRegistrar } from './plugin-def';
 import _ from 'lodash';
+import { RegisterMeta } from './utility/register-meta';
 
 declare module 'cordis' {
   interface Context {
@@ -26,119 +23,100 @@ declare module 'cordis' {
 
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace Registrar {
-  export interface Methods<Ctx extends Context> {
-    on(event: keyof Events<Ctx>, prepend?: boolean): () => boolean;
-    plugin(): Awaitable<Fork<Ctx>>;
-    apply(): Awaitable<any>;
+  export interface MetadataArrayMap {
+    CordisRegisterKeys: string;
+    CordisContextTransformer: RegisterMeta<ContextTransformer<Context>>;
+    CordisTopLevelAction: RegisterMeta<TopLevelActionDef<Context>>;
+    CordisContextLayers: RegisterMeta<ContextCallbackLayer<Context>>;
+    CordisControl: ControlType;
+    CordisPluginUsing: string;
+    CordisPluginProvide: ProvideDefinition<Context>;
+    CordisPluginInjectKeys: string;
+    CordisPluginSystemKeys: string;
   }
-  export interface MethodLimitations<Ctx extends Context> {
-    on: PickEventFunction<Events<Ctx>>;
-    plugin(
-      ...args: any[]
-    ): Awaitable<PluginRegistrar.PluginDefinition<Ctx> | undefined>;
+  export interface MetadataMap {
+    CordisRegister: MethodMeta<Context>;
+    CordisPluginInject: string;
+    CordisPluginSystem: PluginRegistrar.SystemInjectFun<Context>;
+    CordisPluginPredefineSchema: Schema | ClassType<any>;
+    CordisPluginPredefineName: string;
+    CordisPluginFork: PluginRegistrar.PluginClass<Context>;
+    CordisPluginReusable: boolean;
   }
 
-  export type MethodType<Ctx extends Context> = keyof Methods<Ctx>;
-  export type MethodBody<
-    C extends Context,
-    K extends keyof Methods<C> = keyof Methods<C>,
-  > = Methods<C>[K];
-  export type MethodParams<
-    C extends Context,
-    K extends keyof Methods<C> = keyof Methods<C>,
-  > = FunctionParam<MethodBody<C, K>>;
-  export type MethodReturn<
-    C extends Context,
-    K extends keyof Methods<C> = keyof Methods<C>,
-  > = FunctionReturn<MethodBody<C, K>>;
-  export type MethodClassMethodFunction<
-    C extends Context,
-    K extends keyof Methods<C> = keyof Methods<C>,
-  > = K extends keyof MethodLimitations<C>
-    ? MethodLimitations<C>[K]
-    : (...args: any[]) => any;
-  export type MethodResolver<
-    C extends Context,
-    K extends keyof Methods<C> = keyof Methods<C>,
-  > = (
-    ctx: C,
-    fun: MethodClassMethodFunction<C, K>,
-    ...args: MethodParams<C, K>
-  ) => MethodReturn<C, K>;
-
-  export interface RegisterInfo<C extends Context> {
-    type: MethodType<C>;
-    args: MethodParams<C>;
-    action: MethodResolver<C>;
-  }
+  export type DecorateFunctionParam<
+    Ctx extends Context,
+    A extends any[] = any[],
+    R = any,
+  > = (ctx: Ctx, ...args: A) => R;
 
-  export interface RegisterResult<
-    C extends Context,
-    T,
-    K extends keyof Methods<C> = keyof Methods<C>,
-  > extends RegisterInfo<C> {
+  export type DecorateFunctionParamSingle<
+    Ctx extends Context,
+    P,
+    A extends any[] = any[],
+    R = any,
+  > = (ctx: Ctx, param: P, ...args: A) => R;
+
+  export type MethodResolver<
+    Ctx extends Context,
+    A extends any[] = any[],
+    F extends (...args: any[]) => any = (...args: any[]) => any,
+  > = DecorateFunctionParamSingle<Ctx, F, A>;
+
+  export type MethodMeta<Ctx extends Context> = RegisterMeta<
+    MethodResolver<Ctx>,
+    { type: string }
+  >;
+
+  export type RegisterResult<Ctx extends Context, T> = Omit<
+    MethodMeta<Ctx>,
+    'run'
+  > & {
+    type: string;
     key: keyof T & string;
-    result: MethodReturn<C, K>;
-    ctx: C;
-  }
+    result: any;
+    ctx: Ctx;
+  };
 
   export interface ProvideOptions extends Context.ServiceOptions {
     immediate?: boolean;
   }
   export interface ProvideDefinition<C extends Context> extends ProvideOptions {
-    serviceName: ServiceName<C>;
+    serviceName: string;
   }
 
-  export type ContextFunction<C extends Context, T> = (ctx: C) => T;
-  export type RenderedContextTransformer<C extends Context> = (
-    ctx: C,
-    r: ParamRenderer,
-  ) => C;
-  export type ContextCallbackLayer<C extends Context, T = any> = (
-    ctx: C,
-    cb: ContextFunction<C, void>,
-  ) => T;
-
-  export type ServiceName<C extends Context> = string;
-
-  export type TopLevelActionDef<C extends Context> = (
-    ctx: C,
-    obj: any,
-    renderer: ParamRenderer,
-  ) => void;
-
-  export interface MetadataArrayMap<C extends Context> {
-    CordisRegisterKeys: string;
-    CordisContextTransformer: RenderedContextTransformer<C>;
-    CordisTopLevelAction: TopLevelActionDef<C>;
-    CordisContextLayers: ContextCallbackLayer<C>;
-    CordisControl: ControlType;
-    CordisPluginUsing: ServiceName<C>;
-    CordisPluginProvide: ProvideDefinition<C>;
-    CordisPluginInjectKeys: string;
-    CordisPluginSystemKeys: string;
-  }
-  export interface MetadataMap<C extends Context> {
-    CordisRegister: RegisterInfo<C>;
-    CordisPluginInject: ServiceName<C>;
-    CordisPluginSystem: PluginRegistrar.SystemInjectFun<C>;
-    CordisPluginPredefineSchema: Schema | ClassType<any>;
-    CordisPluginPredefineName: string;
-    CordisPluginFork: PluginRegistrar.PluginClass<C>;
-    CordisPluginReusable: boolean;
-  }
+  export type ContextFunction<Ctx extends Context, T> = DecorateFunctionParam<
+    Ctx,
+    [],
+    T
+  >;
+
+  export type ContextTransformer<
+    Ctx extends Context,
+    A extends any[] = any[],
+  > = DecorateFunctionParam<Ctx, A, Ctx>;
+
+  export type ContextCallbackLayer<
+    Ctx extends Context,
+    A extends any[] = any[],
+  > = DecorateFunctionParamSingle<Ctx, ContextFunction<Ctx, void>, A>;
+
+  export type TopLevelActionDef<
+    Ctx extends Context,
+    A extends any[] = any[],
+  > = DecorateFunctionParamSingle<Ctx, any, A>;
 }
 
 const ThirdEyeSym = Symbol('ThirdEyeSym');
 
 export class Registrar<Ctx extends Context> {
   metadata = new MetadataSetter<
-    Registrar.MetadataMap<Ctx>,
-    Registrar.MetadataArrayMap<Ctx>
+    Registrar.MetadataMap,
+    Registrar.MetadataArrayMap
   >();
   reflector = new Reflector<
-    Registrar.MetadataMap<Ctx>,
-    Registrar.MetadataArrayMap<Ctx>
+    Registrar.MetadataMap,
+    Registrar.MetadataArrayMap
   >();
   constructor(public contextClass: ClassType<Ctx>) {}
 
@@ -146,34 +124,46 @@ export class Registrar<Ctx extends Context> {
     return new RegistrarAspect(this, obj, view);
   }
 
-  decorateMethod<K extends keyof Registrar.Methods<Ctx>>(
-    type: K,
-    action: Registrar.MethodResolver<Ctx, K>,
+  decorateMethod<A extends any[], F extends (...args: any[]) => any>(
+    type: string,
+    action: Registrar.MethodResolver<Ctx, A, F>,
   ) {
-    return (...args: Registrar.MethodParams<Ctx, K>) =>
+    return (...args: A): TypedMethodDecorator<F> =>
       this.metadata.set(
         'CordisRegister',
-        {
-          type,
-          args,
-          action,
-        },
+        new RegisterMeta(action, args, { type }),
         'CordisRegisterKeys',
-      ) as TypedMethodDecorator<Registrar.MethodClassMethodFunction<Ctx, K>>;
+      );
   }
 
-  decorateTransformer(
-    transformer: Registrar.RenderedContextTransformer<Ctx>,
-  ): ClassDecorator & MethodDecorator {
-    return this.metadata.append('CordisContextTransformer', transformer);
+  decorateTransformer<A extends any[]>(
+    transformer: Registrar.ContextTransformer<Ctx, A>,
+  ) {
+    return (...args: A): ClassDecorator & MethodDecorator =>
+      this.metadata.append(
+        'CordisContextTransformer',
+        new RegisterMeta(transformer, args),
+      );
   }
 
-  decorateTopLevelAction(action: Registrar.TopLevelActionDef<Ctx>) {
-    return this.metadata.append('CordisTopLevelAction', action);
+  decorateTopLevelAction<A extends any[]>(
+    action: Registrar.TopLevelActionDef<Ctx, A>,
+  ) {
+    return (...args: A): ClassDecorator =>
+      this.metadata.append(
+        'CordisTopLevelAction',
+        new RegisterMeta(action, args),
+      );
   }
 
-  decorateContextLayer(layer: Registrar.ContextCallbackLayer<Ctx>) {
-    return this.metadata.append('CordisContextLayers', layer);
+  decorateContextLayer<A extends any[]>(
+    action: Registrar.ContextCallbackLayer<Ctx, A>,
+  ) {
+    return (...args: A): ClassDecorator & MethodDecorator =>
+      this.metadata.append(
+        'CordisContextLayers',
+        new RegisterMeta(action, args),
+      );
   }
 
   private getFork(obj: any) {
@@ -184,9 +174,7 @@ export class Registrar<Ctx extends Context> {
     return this.plugin()(fork);
   }
 
-  afterPluginMethodRegistration(
-    result: Registrar.RegisterResult<Ctx, any, keyof Registrar.Methods<Ctx>>,
-  ) {
+  afterPluginMethodRegistration(result: Registrar.RegisterResult<Ctx, any>) {
     // for override
   }
 
@@ -434,34 +422,41 @@ export class Registrar<Ctx extends Context> {
     return {
       UseEvent: this.decorateMethod(
         'on',
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        (ctx, fun, event, prepend) => ctx.on(event, fun, prepend),
+        (ctx, fun, event: keyof GetEvents<Ctx>, prepend?: boolean) =>
+          ctx.on(event as any, fun, prepend),
       ),
-      UsePlugin: this.decorateMethod('plugin', (ctx, fun) => {
-        const result = fun();
-        const register = (def: PluginRegistrar.PluginDefinition<Ctx, any>) => {
-          if (!def) {
-            return;
+      UsePlugin: this.decorateMethod(
+        'plugin',
+        (
+          ctx,
+          fun: (
+            ...args: any[]
+          ) => Awaitable<PluginRegistrar.PluginDefinition<Ctx>>,
+        ) => {
+          const result = fun();
+          const register = (def: PluginRegistrar.PluginDefinition<Ctx>) => {
+            if (!def) {
+              return;
+            }
+            return ctx.plugin(def.plugin, def.options);
+          };
+          if (result instanceof Promise) {
+            return result.then(register);
+          } else {
+            return register(result);
           }
-          return ctx.plugin(def.plugin, def.options);
-        };
-        if (result instanceof Promise) {
-          return result.then(register);
-        } else {
-          return register(result);
-        }
-      }),
+        },
+      ),
       Apply: this.decorateMethod('apply', (ctx, fun) => fun()),
     };
   }
 
   scopeDecorators() {
     return {
-      Isolate: (...services: Registrar.ServiceName<Ctx>[]) =>
+      Isolate: (...services: string[]) =>
         this.decorateTransformer((ctx, r) => ctx.isolate(r(services))),
       UsingService: (
-        ...services: Registrar.ServiceName<Ctx>[]
+        ...services: string[]
       ): ClassDecorator & MethodDecorator => {
         return (obj, key?) => {
           if (!key) {
@@ -472,7 +467,9 @@ export class Registrar<Ctx extends Context> {
             const dec = this.decorateContextLayer((ctx, cb) =>
               ctx.using(services, cb),
             );
-            dec(obj, key);
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            dec()(obj, key);
           }
         };
       },
@@ -510,7 +507,7 @@ export class Registrar<Ctx extends Context> {
           condition: func,
         }),
       Provide: (
-        name: Registrar.ServiceName<Ctx>,
+        name: string,
         options?: Registrar.ProvideOptions,
       ): ClassDecorator => {
         Context.service(name, options);
@@ -563,14 +560,16 @@ export class Registrar<Ctx extends Context> {
     };
   }
 
-  transformContext(
-    ctx: Ctx,
-    filters: Registrar.RenderedContextTransformer<Ctx>[],
-    r: ParamRenderer = (v) => v,
+  transformContext<_Ctx extends Ctx>(
+    ctx: _Ctx,
+    filters: RegisterMeta<Registrar.ContextTransformer<Ctx>>[],
+    view: any,
   ) {
     let targetCtx = ctx;
     for (const fun of filters) {
-      targetCtx = fun(targetCtx, r) || targetCtx;
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      targetCtx = fun.run(view, ctx) || targetCtx;
     }
     return targetCtx;
   }

src/utility/register-meta.ts

+import { renderObject } from './render-object';
+import { FunctionParams, FunctionReturn } from '../def';
+
+export class RegisterMeta<F extends (...args: any[]) => any, I = any> {
+  constructor(public action: F, public args: any[], public info?: I) {}
+
+  run(view: any, ...extras: FunctionParams<F>): FunctionReturn<F> {
+    return this.action(...extras, ...renderObject(this.args, view));
+  }
+}

tests/service-activate.spec.ts

@@ -14,8 +14,8 @@ declare module 'cordis' {
   }
 
   interface Events {
-    'pang'(message: string): Promise<string>;
-    'pong'(message: string): Promise<string>;
+    'pang'(message: string): string;
+    'pong'(message: string): string;
   }
 }
 
@@ -101,14 +101,14 @@ class MyPartialConsumer {
 
   @UsingService('dummyProvider')
   @UseEvent('pang')
-  async onPang(content: string) {
+  onPang(content: string) {
     const msg = `pang: ${content}`;
     console.log(msg);
     return msg;
   }
 
   @UseEvent('pong')
-  async onPong(content: string) {
+  onPong(content: string) {
     const msg = `pong: ${content}`;
     console.log(msg);
     return msg;
@@ -157,16 +157,16 @@ describe('On service', () => {
     await app.start();
     app.plugin(MyPartialConsumer);
     expect(app.myPartialConsumer).toBeDefined();
-    expect(await app.parallel('pang', 'hello')).toEqual('hello');
-    expect(await app.parallel('pong', 'hello')).toEqual('pong: hello');
+    expect(app.bail('pang', 'hello')).toBeUndefined();
+    expect(app.bail('pong', 'hello')).toEqual('pong: hello');
     app.dummyProvider = { foo: 'bar' };
-    expect(await app.parallel('pang', 'hello')).toEqual('pang: hello');
-    expect(await app.parallel('pong', 'hello')).toEqual('pong: hello');
+    expect(app.bail('pang', 'hello')).toEqual('pang: hello');
+    expect(app.bail('pong', 'hello')).toEqual('pong: hello');
     app.dummyProvider = undefined;
-    expect(await app.parallel('pang', 'hi')).toEqual('hi');
-    expect(await app.parallel('pong', 'hi')).toEqual('pong: hi');
+    expect(app.bail('pang', 'hi')).toBeUndefined();
+    expect(app.bail('pong', 'hi')).toEqual('pong: hi');
     app.dummyProvider = { foo: 'baz' };
-    expect(await app.parallel('pang', 'hi')).toEqual('pang: hi');
-    expect(await app.parallel('pong', 'hi')).toEqual('pong: hi');
+    expect(app.bail('pang', 'hi')).toEqual('pang: hi');
+    expect(app.bail('pong', 'hi')).toEqual('pong: hi');
   });
 });