proteum 2.2.7 → 2.2.9

package/server/app/service/container.ts

@@ -3,29 +3,32 @@
 ----------------------------------*/
 
 // Specific
-import type { AnyService, AnyServiceClass, StartedServicesIndex } from '.';
+import type { AnyServiceClass, StartedServicesIndex } from '.';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-export type ServiceConfig<TServiceClass extends AnyServiceClass> = NonNullable<ConstructorParameters<TServiceClass>[1]>;
+type ConstructorConfig<TServiceClass extends AnyServiceClass> = ConstructorParameters<TServiceClass> extends [
+    _parent: object | 'self',
+    config: infer TConfig,
+    _app: object | 'self',
+    ..._rest: []
+]
+    ? NonNullable<TConfig>
+    : ConstructorParameters<TServiceClass> extends [config: infer TConfig, _app: object | 'self', ..._rest: []]
+      ? NonNullable<TConfig>
+      : {};
 
-type ExactConfig<TValue, TShape> = TValue extends TShape
-    ? TShape extends (...args: never[]) => infer _TReturn
-        ? TValue
-        : TValue extends readonly (infer TValueItem)[]
-          ? TShape extends readonly (infer TShapeItem)[]
-            ? readonly ExactConfig<TValueItem, TShapeItem>[]
-            : never
-          : TValue extends object
-            ? TShape extends object
-                ? Exclude<keyof TValue, keyof TShape> extends never
-                    ? { [K in keyof TValue]: K extends keyof TShape ? ExactConfig<TValue[K], TShape[K]> : never }
-                    : never
-                : TValue
-            : TValue
-    : never;
+export type ServiceConfig<TServiceClass extends AnyServiceClass> = ConstructorConfig<TServiceClass>;
+
+type ExactConfig<TConfig, TExpected> = TExpected extends object
+    ? TConfig extends object
+        ? { [TKey in Exclude<keyof TConfig, keyof TExpected>]: never } & {
+                  [TKey in keyof TConfig & keyof TExpected]?: ExactConfig<TConfig[TKey], NonNullable<TExpected[TKey]>>;
+              }
+        : {}
+    : {};
 
 /*----------------------------------
 - CLASS
@@ -41,7 +44,7 @@ export class ServicesContainer<TServicesIndex extends StartedServicesIndex = Sta
     public callableInstance = <TInstance extends object, TCallableName extends keyof TInstance>(
         instance: TInstance,
         funcName: TCallableName,
-    ): TInstance[TCallableName] & TInstance => {
+    ): TInstance[TCallableName] & { serviceInstance: TInstance } => {
         const instanceRecord = instance as Record<string, unknown>;
         const callableFunc = instance[funcName];
         if (typeof callableFunc !== 'function') throw new Error(`instance[funcName] isn't callable.`);
@@ -66,7 +69,7 @@ export class ServicesContainer<TServicesIndex extends StartedServicesIndex = Sta
         // Allow us to recognize a callable as a service
         callable.serviceInstance = instance;
 
-        return callable as TInstance[TCallableName] & TInstance;
+        return callable as TInstance[TCallableName] & { serviceInstance: TInstance };
     };
 }
 

package/server/app/service/index.ts

@@ -5,16 +5,27 @@
 // Specific
 import type { Application } from '../index';
 import type { Command } from '../commands';
-import type { TRouterContext, TAnyRouter } from '../../services/router';
+import type {
+    Request as ServerRequest,
+    Response as ServerResponse,
+    TRouterContextServices,
+    TAnyRouter,
+} from '../../services/router';
 
 export { schema } from '../../services/router/request/validation/zod';
-export type { z } from '../../services/router/request/validation/zod';
+export type {
+    z,
+    TInferValidationSchema,
+    TTypedValidationSchema,
+    TValidationSchema,
+    TValidationShape,
+} from '../../services/router/request/validation/zod';
 
 /*----------------------------------
 - TYPES: OPTIONS
 ----------------------------------*/
 
-export type AnyService = Service<{}, {}, Application, any>;
+export type AnyService = Service<{}, any, any, any>;
 export type AnyServiceClass = ClassType<AnyService>;
 
 /*----------------------------------
@@ -31,7 +42,7 @@ export type THooksIndex<THooks extends THooksList> = { [name in keyof THooks]?:
 
 export type StartedServicesIndex = { [serviceId: string]: AnyService };
 
-type TServiceRouter<TApplication extends Application> = TApplication extends { Router: infer TRouter }
+type TServiceRouter<TApplication extends object> = TApplication extends { Router: infer TRouter }
     ? TRouter extends TAnyRouter
         ? TRouter
         : TAnyRouter
@@ -41,11 +52,18 @@ type TServiceRouter<TApplication extends Application> = TApplication extends { R
  * @deprecated Services should not depend on request context.
  * Resolve auth/input/request data in controllers and pass explicit typed values into services instead.
  */
-export type TServiceRequestContext<TApplication extends Application = Application> = TRouterContext<
-    TServiceRouter<TApplication>
->;
-
-export type TServiceModelsClient<TApplication extends Application = Application> = TApplication extends {
+export type TServiceRequestContext<TApplication extends object = object> = {
+    app: TApplication;
+    context: object;
+    request: ServerRequest<TServiceRouter<TApplication>>;
+    api: ServerRequest<TServiceRouter<TApplication>>['api'];
+    response: ServerResponse<TServiceRouter<TApplication>>;
+    route: object;
+    page?: object;
+    Router: TServiceRouter<TApplication>;
+} & TRouterContextServices<TServiceRouter<TApplication>>;
+
+export type TServiceModelsClient<TApplication extends object = object> = TApplication extends {
     Models: { client: infer TModels };
 }
     ? TModels
@@ -53,10 +71,12 @@ export type TServiceModelsClient<TApplication extends Application = Application>
             models: { client: infer TModels };
         }
       ? TModels
-      : never;
+      : object;
 
-export type TSetupConfig<TConfig> = TConfig extends (...args: any[]) => any
+export type TSetupConfig<TConfig> = TConfig extends (...args: infer TFunctionArgs) => infer TFunctionResult
     ? TConfig
+    : TConfig extends { getServiceInstance: (...args: infer TServiceArgs) => infer TServiceInstance }
+      ? TConfig
     : TConfig extends Array<infer TItem>
       ? Array<TSetupConfig<TItem>>
       : TConfig extends object
@@ -86,8 +106,8 @@ const resolveSelfReference = <TSelf extends object, TValue extends object>(
 export default abstract class Service<
     TConfig extends {},
     THooks extends THooksList,
-    TApplication extends Application = Application,
-    TParent extends object = AnyService,
+    TApplication extends object = object,
+    TParent extends object = object,
 > {
     public started?: Promise<void>;
     public starting?: Promise<void>;

package/server/app.tsconfig.json

@@ -6,7 +6,6 @@
         "paths": {
 
             "@/server/models": ["./.proteum/server/models.ts"],
-            "@/client/context": ["./.proteum/client/context.ts"],
             "@generated/client/*": ["./.proteum/client/*"],
             "@generated/common/*": ["./.proteum/common/*"],
             "@generated/server/*": ["./.proteum/server/*"],

package/server/services/auth/index.ts

@@ -10,7 +10,6 @@ import type http from 'http';
 // Core
 import type { Application } from '@server/app/index';
 import Service from '@server/app/service';
-import { type TAnyRouter, Request as ServerRequest } from '@server/services/router';
 import * as AuthErrors from '@common/errors';
 import type { TTraceCaptureMode, TTraceEventType } from '@common/dev/requestTrace';
 
@@ -103,7 +102,13 @@ export type TAuthConfiguredRules = {
 
 export type TAuthTrackingContext = ProteumAuthTrackingContext | null;
 
-export type TAuthRulesFactory<TUser extends TBasicUser, TRequest extends ServerRequest<TAnyRouter>> = (
+export type TAuthRequest = {
+    id: string;
+    res: Pick<express.Response, 'clearCookie' | 'cookie'>;
+    user: TBasicUser | null;
+};
+
+export type TAuthRulesFactory<TUser extends TBasicUser, TRequest extends TAuthRequest> = (
     user: TUser,
     tracking: TAuthTrackingContext,
     request: TRequest,
@@ -121,7 +126,7 @@ export const UserRoles = ['USER', 'ADMIN', 'TEST', 'DEV'] as const;
 
 export type TConfig<
     TUser extends TBasicUser = TBasicUser,
-    TRequest extends ServerRequest<TAnyRouter> = ServerRequest<TAnyRouter>,
+    TRequest extends TAuthRequest = TAuthRequest,
 > = {
     debug: boolean;
     logoutUrl: string;
@@ -155,7 +160,7 @@ export default abstract class AuthService<
     TUser extends TBasicUser,
     TApplication extends Application,
     TJwtSession extends TBasicJwtSession = TBasicJwtSession,
-    TRequest extends ServerRequest<TAnyRouter> = ServerRequest<TAnyRouter>,
+    TRequest extends TAuthRequest = TAuthRequest,
 > extends Service<TConfig<TUser, TRequest>, THooks, TApplication, TApplication> {
     public login?(request: TRequest, email: string): Promise<unknown>;
     public abstract decodeSession(jwt: TJwtSession, req: THttpRequest): Promise<TUser | null>;
@@ -200,7 +205,8 @@ export default abstract class AuthService<
         if ('apiKey' in session) {
             return {
                 payloadKind: 'api-key',
-                payloadAccountType: session.accountType ?? null,
+                payloadAccountType:
+                    'accountType' in session && typeof session.accountType === 'string' ? session.accountType : null,
             };
         }
 
@@ -602,7 +608,7 @@ export default abstract class AuthService<
     ): TUser | null {
         const user = this.getDecodedUser(request);
         const conditionRuleNames =
-            conditions && conditions !== false
+            conditions
                 ? (Object.keys(conditions) as Array<Extract<keyof TAuthConfiguredRules, string>>)
                 : [];
 

package/server/services/auth/router/index.ts

@@ -11,32 +11,30 @@ import {
     TAnyRoute,
     RouterService,
     TAnyRouter,
+    TServerRouter,
 } from '@server/services/router';
 
 import type { Application } from '@server/app/index';
+import AppContainer from '@server/app/container';
 
 import type { TRouterServiceArgs } from '@server/services/router/service';
 
 // Specific
 import type { default as UsersService, TAuthCheckConditions, TBasicUser } from '..';
-import UsersRequestService from './request';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
+import { createUsersRequestService, type TUsersRequestContext } from './request';
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class AuthenticationRouterService<
-    TApplication extends Application = Application,
-    TUser extends TBasicUser = TApplication['app']['userType'],
-    TRouter extends TAnyRouter = TAnyRouter,
+    TApplication extends Application,
+    TUser extends TBasicUser,
+    TRouter extends TAnyRouter = TServerRouter,
     TRequest extends ServerRequest<TRouter> = ServerRequest<TRouter>,
 > extends RouterService<
     { users: UsersService<TUser, TApplication> },
     TRouter,
-    UsersRequestService<TRouter, TUser, TRequest>
+    TUsersRequestContext<TUser>
 > {
     /*----------------------------------
     - LIFECYCLE
@@ -45,7 +43,7 @@ export default class AuthenticationRouterService<
     public users: UsersService<TUser, TApplication>;
 
     public constructor(
-        getConfig: TRouterServiceArgs<{ users: UsersService<TUser, TApplication> }, TRouter>[0],
+        getConfig: TRouterServiceArgs<{ users: UsersService<TUser, TApplication> }>[0],
         app: TApplication,
     ) {
         super(getConfig, app);
@@ -59,11 +57,11 @@ export default class AuthenticationRouterService<
         details: Record<string, any>,
         minimumCapture: 'summary' | 'resolve' | 'deep' = 'resolve',
     ) {
-        this.app.container.Trace.record(
+        AppContainer.Trace.record(
             request.id,
             'auth.route',
             {
-                routePath: route.path || '',
+                routePath: 'path' in route ? route.path || '' : '',
                 routeId: route.options.id || '',
                 authInput: route.options.auth ?? null,
                 tracking: route.options.authTracking ?? null,
@@ -219,7 +217,7 @@ export default class AuthenticationRouterService<
     - ROUTER SERVICE LIFECYCLE
     ----------------------------------*/
 
-    public requestService(request: TRequest): UsersRequestService<TRouter, TUser, TRequest> {
-        return new UsersRequestService(request, this);
+    public requestService(request: TRequest): TUsersRequestContext<TUser> {
+        return createUsersRequestService(request, this.users);
     }
 }

package/server/services/auth/router/request.ts

@@ -2,13 +2,11 @@
 - DEPENDANCES
 ----------------------------------*/
 
-// Core
-import type { Request as ServerRequest, TAnyRouter } from '@server/services/router';
-import RequestService from '@server/services/router/request/service';
+import type { Application } from '@server/app/index';
 
 // Specific
-import type AuthenticationRouterService from '.';
-import type { TAuthCheckConditions, TAuthTrackingContext, TUserRole } from '..';
+import type UsersService from '..';
+import type { TAuthCheckConditions, TAuthRequest, TAuthTrackingContext, TUserRole } from '..';
 
 // Types
 import type { TBasicUser } from '@server/services/auth';
@@ -17,21 +15,36 @@ import type { TBasicUser } from '@server/services/auth';
 - TYPES
 ----------------------------------*/
 
+type TUsersRouterService<TUser extends TBasicUser> = {
+    users: UsersService<TUser, Application>;
+};
+
+export interface TUsersRequestContext<TUser extends TBasicUser> {
+    login(email: string): Promise<unknown>;
+    logout(): void;
+
+    check(): TUser;
+    check(conditions: null, tracking?: TAuthTrackingContext): TUser;
+    check(conditions: TAuthCheckConditions, tracking?: TAuthTrackingContext): TUser;
+    check(conditions: false, tracking?: TAuthTrackingContext): null;
+    check(role: TUserRole, feature: null): TUser;
+    check(role: false): null;
+    check(role: TUserRole | true, feature: FeatureKeys, action?: string): TUser;
+    check(role: false, feature: FeatureKeys, action?: string): null;
+}
+
 /*----------------------------------
 - MODULE
 ----------------------------------*/
 export default class UsersRequestService<
-    TRouter extends TAnyRouter,
     TUser extends TBasicUser,
-    TRequest extends ServerRequest<TRouter> = ServerRequest<TRouter>,
-> extends RequestService<TRequest> {
+    TRequest extends TAuthRequest,
+> implements TUsersRequestContext<TUser> {
     public constructor(
-        request: TRequest,
-        public auth: AuthenticationRouterService<TRouter['app'], TUser, TRouter, TRequest>,
+        public request: TRequest,
+        public auth: TUsersRouterService<TUser>,
         public users = auth.users,
-    ) {
-        super(request);
-    }
+    ) {}
 
     public login(email: string) {
         if (!this.users.login) throw new Error('The current auth service does not implement login().');
@@ -93,3 +106,11 @@ export default class UsersRequestService<
         return this.users.check(this.request, roleOrConditions, featureOrTracking, action);
     }
 }
+
+export const createUsersRequestService = <
+    TUser extends TBasicUser,
+    TRequest extends TAuthRequest,
+>(
+    request: TRequest,
+    users: UsersService<TUser, Application>,
+): TUsersRequestContext<TUser> => new UsersRequestService<TUser, TRequest>(request, { users });

package/server/services/disks/driver.ts

@@ -27,7 +27,7 @@ export type TDrivercnfig = {
 
 export type SourceFile = { name: string; path: string; modified: number; parentFolder: string; source: string };
 
-export type TOutputFileOptions = { encoding: string };
+export type TOutputFileOptions = { encoding: BufferEncoding };
 
 export type TReadFileOptions = { encoding?: 'string' | 'buffer'; withMetas?: boolean };
 

package/server/services/disks/index.ts

@@ -32,8 +32,6 @@ export default class DisksManager<
     TConfig extends Config & { default: keyof MountpointList & string; drivers: MountpointList },
     TApplication extends Application,
 > extends Service<TConfig, Hooks, TApplication, TApplication> {
-    public default!: MountpointList[keyof MountpointList & string];
-
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
@@ -50,10 +48,14 @@ export default class DisksManager<
             drivers[driverId].parent = this;
         }*/
 
-        const defaultDisk = drivers[this.config.default];
-        if (defaultDisk === undefined) console.log(`Default disk "${this.config.default as string}" not mounted.`);
+        this.default;
+    }
 
-        this.default = defaultDisk;
+    public get default(): Driver {
+        const drivers: Services = this.config.drivers;
+        const defaultDisk = drivers[this.config.default];
+        if (defaultDisk === undefined) throw new Error(`Default disk "${String(this.config.default)}" not mounted.`);
+        return defaultDisk;
     }
 
     public async shutdown() {}
@@ -62,13 +64,14 @@ export default class DisksManager<
     - LIFECYCLE
     ----------------------------------*/
 
-    public get(diskName?: 'default' | keyof MountpointList) {
+    public get(diskName?: 'default' | keyof MountpointList): Driver {
+        const drivers: Services = this.config.drivers;
         const disk =
             diskName === 'default' || diskName === undefined
                 ? this.default
-                : this.config.drivers[diskName as keyof MountpointList];
+                : drivers[String(diskName)];
 
-        if (disk === undefined) throw new Error(`Disk "${diskName as string}" not found.`);
+        if (disk === undefined) throw new Error(`Disk "${String(diskName)}" not found.`);
 
         return disk;
     }

package/server/services/email/index.ts

@@ -57,7 +57,7 @@ type TOptions = { transporter?: string };
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export default abstract class Email<TConfig extends Config, TApplication extends Application = Application> extends Service<
+export default abstract class Email<TConfig extends Config, TApplication extends Application> extends Service<
     TConfig,
     Hooks,
     TApplication,

package/server/services/prisma/Facet.ts

@@ -1,9 +1,10 @@
-import type { PrismaClient } from '@models/types';
-
 export type TDelegate<R = unknown> = {
     findMany(args?: Record<string, unknown>): Promise<R[]>;
     findFirst(args?: Record<string, unknown>): Promise<R | null>;
 };
+type TPrismaRawClient = {
+    $queryRawUnsafe(query: string): Promise<Record<string, unknown>[]>;
+};
 
 export type TWithStats = { $table: string; $key: string } & Record<string, string>;
 
@@ -18,7 +19,7 @@ export default class Facet<
     RT = R,
 > {
     constructor(
-        private readonly prisma: PrismaClient,
+        private readonly prisma: TPrismaRawClient,
         private readonly delegate: D,
         private readonly subset: S,
         private readonly transform?: Transform<R, RT>,
@@ -57,13 +58,13 @@ export default class Facet<
             ), 0)) as ${key}`,
         );
 
-        const statRows = (await this.prisma.$queryRawUnsafe(`
+        const statRows = await this.prisma.$queryRawUnsafe(`
             SELECT ${$key}, ${select.join(', ')} 
             FROM ${$table} 
             WHERE ${$key} IN (
                 ${(results as Array<Record<string, unknown>>).map((row) => "'" + row[$key] + "'").join(',')}
             )
-        `)) as Record<string, unknown>[];
+        `);
 
         for (const stat of statRows) {
             for (const key in stat) {

package/server/services/router/index.ts

@@ -19,7 +19,8 @@ import zod, { ZodError } from 'zod';
 export { default as schema } from 'zod';
 
 // Core
-import Service, { AnyService, TServiceArgs } from '@server/app/service';
+import type { Application } from '@server/app/index';
+import Service, { TServiceArgs } from '@server/app/service';
 import context from '@server/context';
 import type DisksManager from '@server/services/disks';
 import { CoreError, InputError, NotFound, toJson as errorToJson } from '@common/errors';
@@ -104,16 +105,16 @@ const staticHtmlCacheControl = 'public, max-age=0, must-revalidate';
 ----------------------------------*/
 
 export type TAnyRouter = ServerRouter<
-    AnyService['app'],
+    Application,
     TRouterServicesList,
-    Config<TRouterServicesList, AnyService['app']>
+    Config<TRouterServicesList, Application>
 >;
 
 const LogPrefix = '[router]';
 
 export type Config<
     TServices extends TRouterServicesList,
-    TApplication extends AnyService['app'] = AnyService['app'],
+    TApplication extends Application = Application,
 > = {
     debug: boolean;
 
@@ -147,16 +148,16 @@ export type TControllerDefinition = {
 };
 
 export type TServerRouter = ServerRouter<
-    AnyService['app'],
+    Application,
     TRouterServicesList,
-    Config<TRouterServicesList, AnyService['app']>
+    Config<TRouterServicesList, Application>
 >;
 
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
 export default class ServerRouter<
-        TApplication extends AnyService['app'] = AnyService['app'],
+        TApplication extends Application = Application,
         TServices extends TRouterServicesList = TRouterServicesList,
         TConfig extends Config<TServices, TApplication> = Config<TServices, TApplication>,
     >

package/server/services/router/request/validation/zod.ts

@@ -4,6 +4,8 @@ import zod from 'zod';
 export type TRichTextValidatorOptions = { attachements?: boolean };
 export type TValidationSchema = zod.ZodTypeAny;
 export type TValidationShape = zod.ZodRawShape;
+export type TInferValidationSchema<TSchema extends TValidationSchema> = zod.infer<TSchema>;
+export type TTypedValidationSchema<TOutput> = zod.ZodType<TOutput>;
 
 type TChoiceOption = { value: PrimitiveValue; label: string };
 

package/server/services/router/response/index.ts

@@ -12,7 +12,7 @@ import express from 'express';
 
 // Core
 import context from '@server/context';
-import type { AnyRouterService, default as ServerRouter, TServerRouter, TAnyRouter } from '@server/services/router';
+import type { default as ServerRouter, TServerRouter, TAnyRouter } from '@server/services/router';
 import ServerRequest from '@server/services/router/request';
 import { TMatchedRoute, TRoute, TAnyRoute } from '@common/router';
 import { NotFound, Forbidden, Anomaly } from '@common/errors';
@@ -40,8 +40,7 @@ export type TBasicSSrData = {
     currentDomain: string;
 };
 
-type TServerRouterApplication<TRouter extends TServerRouter> =
-    TRouter extends ServerRouter<infer TApplication, any, any> ? TApplication : never;
+type TServerRouterApplication<TRouter extends TServerRouter> = TRouter['app'];
 
 type TServerRouterPlugins<TRouter extends TServerRouter> =
     TRouter extends ServerRouter<any, any, infer TConfig>
@@ -80,8 +79,10 @@ export type TRouterContextServices<
     // Custom context via servuces
     // For each roiuter service, return the request service (returned by roiuterService.requestService() )
     {
-        [serviceName in keyof TPlugins]: TPlugins[serviceName] extends AnyRouterService
-            ? Exclude<ReturnType<TPlugins[serviceName]['requestService']>, null | undefined>
+        [serviceName in keyof TPlugins]: TPlugins[serviceName] extends { requestService: infer TRequestServiceMethod }
+            ? TRequestServiceMethod extends (...args: infer TRequestServiceArgs) => infer TRequestService
+                ? Exclude<TRequestService, null | undefined>
+                : TPlugins[serviceName]
             : TPlugins[serviceName];
     };
 
@@ -97,7 +98,6 @@ const getRouteTraceTarget = (route: TAnyRoute<TRouterContext<TServerRouter>>) =>
 ----------------------------------*/
 export default class ServerResponse<
     TRouter extends TAnyRouter,
-    TRequestContext extends TRouterContext<TRouter> = TRouterContext<TRouter>,
     TData extends TResponseData = TResponseData,
 > extends BaseResponse<TData, ServerRequest<TRouter>> {
     // Services
@@ -220,13 +220,13 @@ export default class ServerResponse<
     ----------------------------------*/
 
     // Start controller services
-    private async createContext(route: TAnyRoute<TRouterContext<TRouter>>): Promise<TRequestContext> {
+    private async createContext(route: TAnyRoute<TRouterContext<TRouter>>): Promise<TRouterContext<TRouter>> {
         const contextServices = this.router.createContextServices(this.request);
         const controllers = createControllers(this.request.api);
         const customSsrData = this.router.config.context(this.request, this.app) as TRouterRequestContext<TRouter>;
 
         // TODO: transmiss safe data (especially for Router), as Router info could be printed on client side
-        const requestContext = {
+        const requestContext: TRouterContext<TRouter> = {
             // Router context
             app: this.app,
             context: undefined!,
@@ -242,7 +242,7 @@ export default class ServerResponse<
             // Router services
             ...(contextServices as TRouterContextServices<TRouter>),
             ...customSsrData,
-        } as TRequestContext;
+        };
 
         requestContext.context = requestContext;
 

package/server/services/router/service.ts

@@ -7,15 +7,16 @@ import type { Application } from '@server/app/index';
 import Service, { TSetupConfig } from '@server/app/service';
 
 // Specific
-import type { default as Router } from '.';
 import type ServerRequest from './request';
 import type { TAnyRouter } from '.';
 
-export type AnyRouterService = RouterService<any, TAnyRouter, object | null>;
+export type AnyRouterService = Service<{}, {}, Application, object> & {
+    requestService(request: object): object | null;
+};
 
-export type TRouterServiceArgs<TConfig extends {} = {}, TRouter extends TAnyRouter = TAnyRouter> = [
+export type TRouterServiceArgs<TConfig extends {} = {}> = [
     getConfig: TSetupConfig<TConfig> | null | undefined,
-    app: TRouter['app'],
+    app: Application,
 ];
 
 /*----------------------------------
@@ -23,11 +24,14 @@ export type TRouterServiceArgs<TConfig extends {} = {}, TRouter extends TAnyRout
 ----------------------------------*/
 export default abstract class RouterService<
     TConfig extends {},
-    TRouter extends TAnyRouter = TAnyRouter,
+    TRouter extends TAnyRouter,
     TRequestService extends object | null = object | null,
-> extends Service<TConfig, {}, TRouter['app'], TRouter> {
-    public constructor(...[config, app]: TRouterServiceArgs<TConfig, TRouter>) {
-        super(app as TRouter['app'] & TRouter, config, app);
+> extends Service<TConfig, {}, Application, object> {
+    public declare parent: TRouter;
+    public declare app: TRouter extends { app: infer TApplication extends Application } ? TApplication : Application;
+
+    public constructor(...[config, app]: TRouterServiceArgs<TConfig>) {
+        super(app, config, app);
     }
 
     public abstract requestService(request: ServerRequest<TRouter>): TRequestService;