fix: asyncify action

packages/app/src/Application.ts

@@ -74,7 +74,8 @@ export class Application<C extends Context> {
         Object.freeze(state);
         await request.linkState?.(state);
 
-        return this.#unit.run(route.action, state);
+        // @todo
+        return this.#unit.run(route.action as any, state);
     }
 
     public getRoutes(): IRoute<ActionAny<C>>[] {

packages/app/src/Route/Route.ts

@@ -1,15 +1,22 @@
 import {ActionAny, ActionFactory} from "@bunt/unit";
-import {Ctor, ILogable, isFunction, isString} from "@bunt/util";
-import {IRoute, IRouteMatcher, RouteFactory, RouteMatcherFactory, RouteRuleArg, RouteRuleVariants} from "./interfaces";
+import {ILogable, isFunction, isString} from "@bunt/util";
+import {
+    IRoute,
+    IRouteMatcher,
+    RouteFactory,
+    RouteMatcherFactory,
+    RouteRuleArg,
+    RouteRuleVariants,
+} from "./interfaces";
 import {RouteRule} from "./RouteRule";
 
 export class Route<A extends ActionAny> implements IRoute<A>, ILogable<{route: string}> {
     public readonly route: string;
-    public readonly action: ActionFactory<any>;
+    public readonly action: ActionFactory<A>;
     public readonly payload?: RouteRule<A>;
     readonly #matcher: IRouteMatcher;
 
-    constructor(matcher: RouteMatcherFactory, action: ActionFactory<any>, rule: RouteRuleArg<A>) {
+    constructor(matcher: RouteMatcherFactory, action: ActionFactory<A>, rule: RouteRuleArg<A>) {
         const {route, payload} = this.getRuleArgs(rule);
         this.route = route;
         this.action = action;
@@ -18,8 +25,14 @@ export class Route<A extends ActionAny> implements IRoute<A>, ILogable<{route: s
         this.#matcher = isFunction(matcher) ? matcher(this.route) : matcher;
     }
 
+    /**
+     * @deprecated
+     *
+     * @param matcher RouteMatcherFactory
+     * @returns RouteFactory
+     */
     public static create(matcher: RouteMatcherFactory): RouteFactory {
-        return <A extends ActionAny>(action: Ctor<A>, rule: RouteRuleArg<A>) => (
+        return <A extends ActionAny>(action: ActionFactory<A>, rule: RouteRuleArg<A>) => (
             new Route<A>(matcher, action, rule)
         );
     }

packages/app/src/Route/fn.ts

@@ -0,0 +1,8 @@
+import {ActionAny, ActionFactory} from "@bunt/unit";
+import {RouteRuleArg} from "./interfaces";
+import {RegexpMatcher} from "./Matcher/RegexpMatcher";
+import {Route} from "./Route";
+
+export function route<A extends ActionAny>(action: ActionFactory<A>, rule: RouteRuleArg<A>): Route<A> {
+    return new Route<A>(RegexpMatcher.factory, action, rule);
+}

packages/app/src/Route/index.ts

@@ -4,3 +4,4 @@ export * from "./Matcher/EqualMatcher";
 export * from "./RouteNotFound";
 export * from "./RouteRule";
 export * from "./Route";
+export * from "./fn";

packages/app/src/Route/interfaces.ts

@@ -1,5 +1,4 @@
 import {ActionAny, ActionContext, ActionFactory, ActionState, ApplyContext} from "@bunt/unit";
-import {Ctor} from "@bunt/util";
 import {IRequest} from "../interfaces";
 import {Payload} from "../Payload";
 import {Route} from "./Route";
@@ -8,7 +7,7 @@ import {RouteRule} from "./RouteRule";
 export interface IRoute<A extends ActionAny> {
     readonly route: string;
 
-    readonly action: ActionFactory<any>;
+    readonly action: ActionFactory<A>;
 
     readonly payload?: Payload<A>;
 
@@ -25,7 +24,7 @@ export type RouteRuleVariants<A extends ActionAny> = {route: string; payload: un
 export type RouteRuleArg<A extends ActionAny> = ActionState<A> extends null
     ? string : RouteRule<A>;
 
-export type RouteFactory = <A extends ActionAny>(action: Ctor<A>, rule: RouteRuleArg<A>) => Route<A>;
+export type RouteFactory = <A extends ActionAny>(action: ActionFactory<A>, rule: RouteRuleArg<A>) => Route<A>;
 
 export interface IRouteContext<A extends ActionAny> {
     request: IRequest;

packages/app/test/src/Action.test.ts

@@ -1,4 +1,5 @@
 import {Application, RouteNotFound} from "../../src";
+import BaseTestAsyncRoute from "./app/Action/BaseTestAsyncRoute";
 import HelloWorldRoute from "./app/Action/HelloWorldRoute";
 import {BaseContext} from "./app/Context/BaseContext";
 import {Request} from "./app/Request/Request";
@@ -36,4 +37,10 @@ describe("Route", () => {
         const request = new Request("/wrong-uri", {});
         await expect(app.run(request)).rejects.toThrowError(RouteNotFound);
     });
+
+    test("Async route", async () => {
+        const app = await Application.factory(new BaseContext(), [BaseTestAsyncRoute]);
+        const request = new Request("GET /async/test", {});
+        await expect(app.run(request)).resolves.toBe("Hello, async!");
+    });
 });

packages/app/test/src/app/Action/BaseTestAction.ts

@@ -6,3 +6,5 @@ export class BaseTestAction extends Action<BaseContext, {name: string}> {
         return `Hello, ${this.state.name}!`;
     }
 }
+
+export default BaseTestAction;

packages/app/test/src/app/Action/BaseTestAsyncRoute.ts

@@ -0,0 +1,12 @@
+import {Fields, Text} from "@bunt/input";
+import {asyncify} from "@bunt/unit";
+import {Resolver, route, RouteRule} from "../../../../src";
+
+export default route(
+    asyncify(() => import("./BaseTestAction")),
+    new RouteRule(
+        "GET /async/test",
+        new Fields({name: Text}),
+        new Resolver({name: () => "async"}),
+    ),
+);

packages/app/test/src/app/Action/HelloWorldRoute.ts

@@ -1,7 +1,6 @@
 import {Bool, Fields, Text, ToNumber} from "@bunt/input";
 import {Action} from "@bunt/unit";
-import {Resolver, RouteRule} from "../../../../src";
-import {route} from "../../route";
+import {Resolver, route, RouteRule} from "../../../../src";
 import {BaseContext} from "../Context/BaseContext";
 
 interface IHelloWorldActionState {

packages/cli/src/Commander.ts

@@ -11,13 +11,14 @@ export class Commander<C extends CommandContext> {
     }
 
     public static async execute<C extends CommandContext>(
-        context: ContextArg<C>, routes: IRoute<Action<C, any, IRunnable>>[] = []): Promise<IRunnable | undefined> {
+        context: ContextArg<C>,
+        routes: IRoute<Action<C, any, IRunnable | void>>[] = []): Promise<IRunnable | void> {
         const command = new this<C>(await Application.factory<C>(context, routes));
 
         return command.handle();
     }
 
-    public async handle(): Promise<IRunnable | undefined> {
+    public async handle(): Promise<IRunnable | void> {
         const {context} = this.#application;
         const request = new RequestCommand(context.program.args);
 

packages/cli/src/fn.ts

@@ -0,0 +1,6 @@
+import {EqualMatcher, Route, RouteRuleArg} from "@bunt/app";
+import {ActionAny, ActionFactory} from "@bunt/unit";
+
+export function command<A extends ActionAny>(action: ActionFactory<A>, rule: RouteRuleArg<A>): Route<A> {
+    return new Route<A>(EqualMatcher.factory, action, rule);
+}

packages/cli/src/index.ts

@@ -2,3 +2,4 @@ export * from "./Request";
 export * from "./Commander";
 export * from "./Action/Command";
 export * from "./Context/CommandContext";
+export * from "./fn";

packages/cli/test/src/Command.test.ts

@@ -2,9 +2,8 @@ import {Resolver, RouteRule} from "@bunt/app";
 import {Fields, Nullable, Text} from "@bunt/input";
 import {dispose, Heartbeat, isDisposable, isRunnable} from "@bunt/unit";
 import {ok} from "assert";
-import {Commander} from "../../src";
+import {command, Commander} from "../../src";
 import {BaseTestCommand} from "./app/Action/BaseTestCommand";
-import {command} from "./app/command";
 import {BaseContext} from "./app/Context/BaseContext";
 
 describe("Command", () => {

packages/cli/test/src/RunnableCommand.test.ts

@@ -1,8 +1,7 @@
 import {dispose, isDisposable, isRunnable} from "@bunt/unit";
 import {ok} from "assert";
-import {Commander} from "../../src";
+import {command, Commander} from "../../src";
 import {RunnableTestCommand} from "./app/Action/RunnableTestCommand";
-import {command} from "./app/command";
 import {BaseContext} from "./app/Context/BaseContext";
 
 test("Runnable Command", async () => {

packages/project/src/Command/UpdateLintCommand.ts

@@ -1,4 +1,4 @@
-import {command} from "../route";
+import {command} from "@bunt/cli";
 import {BaseCommand} from "./BaseCommand";
 
 class UpdateLintCommand extends BaseCommand {

packages/queue/src/Dispatcher.ts

@@ -1,4 +1,4 @@
-import {ActionCtor, Context, ContextArg, Disposer, Heartbeat, IRunnable, unit, Unit} from "@bunt/unit";
+import {ActionFactory, Context, ContextArg, Disposer, Heartbeat, IRunnable, unit, Unit} from "@bunt/unit";
 import {Ctor, Defer, logger, Logger} from "@bunt/util";
 import {Handler} from "./Handler";
 import {ITransport} from "./interfaces";
@@ -10,7 +10,7 @@ export class Dispatcher<C extends Context> extends Disposer implements IRunnable
 
     readonly #unit: Unit<C>;
     readonly #queue: QueueAbstract<ITransport>;
-    readonly #route = new Map<MessageCtor<any>, ActionCtor<C>>();
+    readonly #route = new Map<MessageCtor<any>, ActionFactory<C>>();
 
     protected constructor(u: Unit<C>, queue: QueueAbstract<ITransport>) {
         super();

packages/unit/src/Unit.ts

@@ -2,13 +2,13 @@ import {assert, isFunction, isInstanceOf, logger, Logger} from "@bunt/util";
 import {ApplyContext, Context} from "./Context";
 import {Action} from "./Action";
 import {
+    ActionAny,
     ActionCtor,
-    ActionCtorImport,
     ActionFactory,
     ActionReturn,
     ActionState,
+    AsyncActionFactory,
     ContextArg,
-    StateType,
 } from "./interfaces";
 
 export class Unit<C extends Context> {
@@ -44,10 +44,10 @@ export class Unit<C extends Context> {
         return Context.apply(syncContext);
     }
 
-    public async run<A extends Action<C, S, R>, S extends StateType, R = unknown>(
-        factory: ActionFactory<C, S, R, A>,
-        state: ActionState<A>): Promise<ActionReturn<Action<C, S, R>>> {
-        const ctor = await Unit.getAction(factory) as ActionCtor<C, S, R, A>;
+    public async run<A extends ActionAny<C>>(
+        factory: ActionFactory<A>,
+        state: ActionState<A>): Promise<ActionReturn<A>> {
+        const ctor = await Unit.getAction(factory);
         assert(Action.isPrototypeOf(ctor), "The 'ctor' hasn't prototype of the Action class");
 
         const finish = this.logger.perf("run", {action: ctor.name});
@@ -58,15 +58,15 @@ export class Unit<C extends Context> {
 
     public static async getAction(action: ActionFactory<any>): Promise<ActionCtor<any>> {
         if (this.isActionFactory(action)) {
-            const {default: ctor} = await action();
+            const {default: ctor} = await action.factory();
 
             return ctor;
         }
 
         return action;
     }
 
-    private static isActionFactory(action: ActionFactory<any>): action is ActionCtorImport<any> {
+    private static isActionFactory(action: ActionFactory<any>): action is AsyncActionFactory<any> {
         return !Action.isPrototypeOf(action);
     }
 }

packages/unit/src/fn.ts

@@ -0,0 +1,5 @@
+import {ActionAny, AsyncActionFactory, ActionImport} from "./interfaces";
+
+export function asyncify<A extends ActionAny>(factory: ActionImport<A>): AsyncActionFactory<A> {
+    return {factory};
+}

packages/unit/src/index.ts

@@ -5,3 +5,4 @@ export * from "./Context";
 export * from "./Service";
 export * from "./Runtime";
 export * from "./Dispose";
+export * from "./fn";

packages/unit/src/interfaces.ts

@@ -1,30 +1,19 @@
-import {Promisify} from "@bunt/util";
+import {Fn, Promisify} from "@bunt/util";
 import {Action} from "./Action";
 import {ApplyContext, Context} from "./Context";
 
 export type ActionAny<C extends Context = Context, S extends StateType | null = any, R = any> = Action<C, S, R>;
 
 export type ContextArg<C extends Context> = (() => Promisify<C>) | Promisify<C>;
 
-export type ActionCtor<C extends Context,
-    S extends StateType | null = any,
-    R = unknown,
-    A extends Action<C, S, R> = Action<C, S, R>> = {
-        new(context: ApplyContext<C>, state: S): A;
-
-        prototype: A;
-    };
-
-export type ActionCtorImport<C extends Context,
-    S extends StateType | null = any,
-    R = unknown,
-    A extends Action<C, S, R> = Action<C, S, R>> = () => Promise<{default: ActionCtor<C, S, R, A>}>;
-
-export type ActionFactory<C extends Context,
-    S extends StateType | null = any,
-    R = unknown,
-    A extends Action<C, S, R> = Action<C, S, R>> = ActionCtor<C, S, R, A> | ActionCtorImport<C, S, R, A>;
+export type ActionCtor<A extends ActionAny> = {
+    new(context: ApplyContext<ActionContext<A>>, state: ActionState<A>): A;
+    prototype: A;
+};
 
+export type ActionImport<A extends ActionAny> = Fn<[], Promise<{default: ActionCtor<A>}>>;
+export type AsyncActionFactory<A extends ActionAny> = {factory: ActionImport<A>};
+export type ActionFactory<A extends ActionAny> = ActionCtor<A> | AsyncActionFactory<A>;
 
 export type ActionContext<A> = A extends ActionAny<infer T> ? T : never;
 export type ActionState<A> = A extends ActionAny<any, infer T> ? T : never;
@@ -41,3 +30,4 @@ export type StateType = Record<string, any> | null;
 export interface IShadowState<T> {
     getShadowState(): T;
 }
+

packages/unit/test/src/Unit.test.ts

@@ -1,11 +1,9 @@
-import {unit, Unit} from "../../src";
+import {asyncify, unit, Unit} from "../../src";
 import {BaseTestAction} from "./actions/BaseTestAction";
 import {ProfileTestAction} from "./actions/ProfileTestAction";
 import {TestExceptionAction} from "./actions/TestExceptionAction";
 import {BaseContext} from "./context/BaseContext";
 
-const ActionImport = () => import("./actions/BaseTestAction");
-
 test("Unit", async () => {
     const app = await unit(new BaseContext());
 
@@ -18,7 +16,8 @@ test("Unit", async () => {
     const helloWorldRun: string = await app.run(BaseTestAction, {name});
     expect(helloWorldRun).toBe(`Hello, ${name}!`);
 
-    const asyncTest = await app.run(ActionImport, {name: "AsyncTest"});
+    const AsyncBaseTestAction = asyncify(() => import("./actions/BaseTestAction"));
+    const asyncTest = await app.run(AsyncBaseTestAction, {name: "AsyncTest"});
     expect(asyncTest).toBe("Hello, AsyncTest!");
 
     await app.run(ProfileTestAction, null);

packages/ws/src/WebSocketServer.ts

@@ -217,7 +217,8 @@ export class WebSocketServer<C extends Context> extends Disposer implements IRun
                 ws.emit("connection", connection, req);
                 ShadowState.set(state, connection);
 
-                this.handle(connection, () => this.#unit.run(route.action, state));
+                // @todo
+                this.handle(connection, () => this.#unit.run(route.action as any, state));
             });
         } catch (error) {
             this.logger.error("Unexpected error", error);

run-tests

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-docker ps --filter name=redis-test -q || \
+test "$(docker ps --filter name=redis-test -q)" = "" && \
     docker run --rm --name redis-test -p 6379:6379 -d redis:alpine || exit 1
 
 yarn jest $@