proteum 2.2.6 → 2.2.8

package/client/dev/profiler/ApexChart.tsx

@@ -18,7 +18,7 @@ export default function ApexChart({
         if (!target || !options) return;
 
         let disposed = false;
-        let chart: { destroy: () => void } | undefined;
+        let chart: { destroy: () => void; render: () => Promise<unknown> | void } | undefined;
 
         target.innerHTML = '';
         setErrorMessage(undefined);
@@ -29,8 +29,9 @@ export default function ApexChart({
                 if (disposed || !mountRef.current) return;
 
                 const ApexCharts = module.default;
-                chart = new ApexCharts(mountRef.current, options);
-                await chart.render();
+                const nextChart = new ApexCharts(mountRef.current, options);
+                chart = nextChart;
+                await nextChart.render();
             } catch (error) {
                 if (!disposed) setErrorMessage(readErrorMessage(error));
             }

package/common/dev/serverHotReload.ts

@@ -27,33 +27,34 @@ export type TServerReadyMessage = {
     connectedProjects?: TServerReadyConnectedProject[];
 };
 
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;
+
 export const isServerHotReloadRequest = (value: unknown): value is TServerHotReloadRequest =>
-    typeof value === 'object' &&
-    value !== null &&
-    (value as TServerHotReloadRequest).type === serverHotReloadMessageType.request &&
-    Array.isArray((value as TServerHotReloadRequest).changedFiles);
+    isRecord(value) &&
+    value.type === serverHotReloadMessageType.request &&
+    Array.isArray(value.changedFiles);
 
 export const isServerHotReloadResult = (value: unknown): value is TServerHotReloadResult =>
-    typeof value === 'object' &&
-    value !== null &&
-    ((value as TServerHotReloadResult).type === serverHotReloadMessageType.succeeded ||
-        (value as TServerHotReloadResult).type === serverHotReloadMessageType.failed) &&
-    Array.isArray((value as TServerHotReloadResult).changedFiles);
+    isRecord(value) &&
+    (value.type === serverHotReloadMessageType.succeeded || value.type === serverHotReloadMessageType.failed) &&
+    Array.isArray(value.changedFiles);
 
 const isServerReadyConnectedProject = (value: unknown): value is TServerReadyConnectedProject =>
-    typeof value === 'object' &&
-    value !== null &&
-    typeof (value as TServerReadyConnectedProject).namespace === 'string' &&
-    typeof (value as TServerReadyConnectedProject).identifier === 'string' &&
-    typeof (value as TServerReadyConnectedProject).name === 'string' &&
-    typeof (value as TServerReadyConnectedProject).urlInternal === 'string' &&
-    typeof (value as TServerReadyConnectedProject).healthUrl === 'string';
-
-export const isServerReadyMessage = (value: unknown): value is TServerReadyMessage =>
-    typeof value === 'object' &&
-    value !== null &&
-    (value as TServerReadyMessage).type === serverHotReloadMessageType.ready &&
-    typeof (value as TServerReadyMessage).publicUrl === 'string' &&
-    ((value as TServerReadyMessage).connectedProjects === undefined ||
-        (Array.isArray((value as TServerReadyMessage).connectedProjects) &&
-            (value as TServerReadyMessage).connectedProjects.every(isServerReadyConnectedProject)));
+    isRecord(value) &&
+    typeof value.namespace === 'string' &&
+    typeof value.identifier === 'string' &&
+    typeof value.name === 'string' &&
+    typeof value.urlInternal === 'string' &&
+    typeof value.healthUrl === 'string';
+
+export const isServerReadyMessage = (value: unknown): value is TServerReadyMessage => {
+    if (!isRecord(value)) return false;
+
+    const connectedProjects = value.connectedProjects;
+    return (
+        value.type === serverHotReloadMessageType.ready &&
+        typeof value.publicUrl === 'string' &&
+        (connectedProjects === undefined ||
+            (Array.isArray(connectedProjects) && connectedProjects.every(isServerReadyConnectedProject)))
+    );
+};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "proteum",
 	"description": "LLM-first Opinionated Typescript Framework for web applications.",
-	"version": "2.2.6",
+	"version": "2.2.8",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/proteum.git",
 	"license": "MIT",

package/server/app/commands.ts

@@ -3,26 +3,25 @@
 ----------------------------------*/
 
 import { Command as ClipanionCommand, Option, UsageError } from 'clipanion';
-import type CurrentCommandApplication from '@/server/index';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
 export type TCommandApplication = {
-    env: {
+    env?: {
         profile?: string;
         name?: string;
         [key: string]: unknown;
     };
-    identity: {
+    identity?: {
         identifier?: string;
         [key: string]: unknown;
     };
-    getRootServices: () => Record<string, unknown>;
+    getRootServices?: () => Record<string, unknown>;
     findService?: (serviceId: string) => unknown;
-    models?: { client?: any };
-    Models?: { client?: any };
+    models?: { client?: object };
+    Models?: { client?: object };
 };
 
 export type TCommandService = {
@@ -33,23 +32,19 @@ export type TCommandService = {
 - COMMAND CLASSES
 ----------------------------------*/
 
-export abstract class Commands<TApplication extends TCommandApplication = CurrentCommandApplication> {
-    public app: CurrentCommandApplication;
+export abstract class Commands<TApplication extends TCommandApplication = TCommandApplication> {
+    public app: TApplication;
 
-    public constructor(app: CurrentCommandApplication) {
+    public constructor(app: TApplication) {
         this.app = app;
     }
 
-    public get services(): CurrentCommandApplication {
+    public get services(): TApplication {
         return this.app;
     }
 
-    public get models(): any {
-        const app = this.app as {
-            models?: { client?: any };
-            Models?: { client?: any };
-        };
-        const models = app.models?.client ?? app.Models?.client;
+    public get models(): object {
+        const models = this.app.models?.client ?? this.app.Models?.client;
 
         if (!models)
             throw new Error(`${this.constructor.name} tried to access models but no Models service is registered.`);

package/server/app/commandsManager.ts

@@ -197,13 +197,17 @@ const parseCommandOptionTokens = (tokens: string[]) => {
 - SERVICE
 ----------------------------------*/
 
-export default class CommandsManager extends Service<Config, Hooks, Application> {
+export default class CommandsManager extends Service<Config, Hooks, Application, object> {
     public priority = 2 as 2;
 
     public commandsIndex: CommandsList = {};
 
     private runtimeCli?: Cli;
 
+    public constructor(parent: object | 'self', config: Config | null | undefined, app: Application | 'self') {
+        super(parent, config, app);
+    }
+
     public command<TArgs extends any[]>(
         ...args:
             | [name: string, description: string, childrens: RuntimeCommand[]]

package/server/app/controller/index.ts

@@ -7,39 +7,88 @@ import zod from 'zod';
 
 // Core
 import context from '@server/context';
-import type { Application } from '../index';
-import type { TServiceModelsClient } from '../service';
-import type { TRouterContext, TAnyRouter } from '@server/services/router';
 import {
     toValidationSchema,
     type TValidationSchema,
     type TValidationShape,
 } from '@server/services/router/request/validation/zod';
+import type {
+    Request as ServerRequest,
+    Response as ServerResponse,
+    TAnyRouter,
+    TRouterContextServices,
+} from '@server/services/router';
 
 export { schema } from '@server/services/router/request/validation/zod';
-export type { z } from '@server/services/router/request/validation/zod';
+export type {
+    z,
+    TInferValidationSchema,
+    TTypedValidationSchema,
+    TValidationSchema,
+    TValidationShape,
+} from '@server/services/router/request/validation/zod';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-type TControllerRouter<TApplication extends Application = Application> = TApplication extends { Router: infer TRouter }
-    ? TRouter extends TAnyRouter
-        ? TRouter
-        : TAnyRouter
+type TControllerModelsClient<TApplication extends object = object> = TApplication extends {
+    Models: { client: infer TModels };
+}
+    ? TModels
+    : TApplication extends {
+            models: { client: infer TModels };
+        }
+      ? TModels
+      : object;
+
+type TControllerRouter<TRouter> = TRouter extends TAnyRouter ? TRouter : TAnyRouter;
+type TControllerApplicationRouter<TApplication extends object> = TApplication extends { Router: infer TRouter }
+    ? TControllerRouter<TRouter>
     : TAnyRouter;
 
-export type TControllerRequestContext<TApplication extends Application = Application> = TRouterContext<
-    TControllerRouter<TApplication>
->;
+export type TControllerRequestContext<
+    TApplication extends object = object,
+    TRouter extends object = object,
+    TRequestServices extends object = {},
+> = {
+    app: TApplication;
+    context: object;
+    request: ServerRequest<TControllerRouter<TRouter>>;
+    api: ServerRequest<TControllerRouter<TRouter>>['api'];
+    response: ServerResponse<TControllerRouter<TRouter>>;
+    route: object;
+    page?: object;
+    Router: TControllerRouter<TRouter>;
+} & (TRouter extends TAnyRouter ? TRouterContextServices<TControllerRouter<TRouter>> : {}) &
+    TRequestServices;
+
+type TControllerBaseContext<TApplication extends object> = {
+    app: TApplication;
+    request: { data: TObjetDonnees };
+};
+
+type TControllerDefaultContext<TApplication extends object, TRequestServices extends object> = {
+    app: TApplication;
+    context: object;
+    request: ServerRequest<TControllerApplicationRouter<TApplication>>;
+    api: ServerRequest<TControllerApplicationRouter<TApplication>>['api'];
+    response: ServerResponse<TControllerApplicationRouter<TApplication>>;
+    route: object;
+    page?: object;
+    Router: TControllerApplicationRouter<TApplication>;
+} & TRouterContextServices<TControllerApplicationRouter<TApplication>> &
+    TRequestServices;
 
 /*----------------------------------
 - CLASS
 ----------------------------------*/
 
 export default abstract class Controller<
-    TApplication extends Application = Application,
-    TContext extends TControllerRequestContext<TApplication> = TControllerRequestContext<TApplication>,
+    TApplication extends object = object,
+    TRouter extends object = object,
+    TRequestServices extends object = {},
+    TContext extends TControllerBaseContext<TApplication> = TControllerDefaultContext<TApplication, TRequestServices>,
 > {
     public constructor(public request: TContext) {}
 
@@ -51,9 +100,12 @@ export default abstract class Controller<
         return this.app;
     }
 
-    public get models(): TServiceModelsClient<TApplication> {
-        const app = this.app as { models?: { client?: unknown }; Models?: { client?: unknown } };
-        return (app.models?.client ?? app.Models?.client) as TServiceModelsClient<TApplication>;
+    public get models(): TControllerModelsClient<TApplication> {
+        const app = this.app as {
+            models?: { client?: TControllerModelsClient<TApplication> };
+            Models?: { client?: TControllerModelsClient<TApplication> };
+        };
+        return (app.models?.client ?? app.Models?.client) as TControllerModelsClient<TApplication>;
     }
 
     public input<TSchema extends TValidationSchema>(schema: TSchema): zod.output<TSchema>;

package/server/app/devCommands.ts

@@ -112,10 +112,10 @@ const loadGeneratedCommandDefinitions = () =>
         (a, b) => a.path.localeCompare(b.path),
     );
 
-export default class DevCommandsRegistry<TApplication extends Application = Application> {
+export default class DevCommandsRegistry {
     private definitions = loadGeneratedCommandDefinitions();
 
-    public constructor(private app: TApplication) {}
+    public constructor(private app: Application) {}
 
     public list() {
         return this.definitions.map((definition) => ({
@@ -150,7 +150,7 @@ export default class DevCommandsRegistry<TApplication extends Application = Appl
 
         try {
             const instance = new definition.Command(this.app);
-            const method = (instance as Record<string, unknown>)[definition.methodName];
+            const method = Reflect.get(instance, definition.methodName);
 
             if (typeof method !== 'function') {
                 throw new Error(

package/server/app/devDiagnostics.ts

@@ -36,8 +36,8 @@ const isExplainSectionName = (value: string): value is TExplainSectionName =>
 const isConsoleLogLevel = (value: string): value is TDevConsoleLogLevel =>
     ['silly', 'log', 'info', 'warn', 'error'].includes(value);
 
-export default class DevDiagnosticsRegistry<TApplication extends Application = Application> {
-    public constructor(private app: TApplication) {}
+export default class DevDiagnosticsRegistry {
+    public constructor(private app: Application) {}
 
     private getManifestFilepath() {
         return path.join(this.app.container.path.root, '.proteum', 'manifest.json');

package/server/app/index.ts

@@ -44,8 +44,13 @@ export const Service = ServicesContainer;
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
 
 export type ApplicationProperties = Prettify<keyof Application>;
-export type RootServicesOf<TApplication extends Application = Application> = Prettify<{
-    [TKey in Exclude<keyof TApplication, ApplicationProperties> as TApplication[TKey] extends AnyService ? TKey : never]: TApplication[TKey];
+type RootServiceCandidate = {
+    runHook: object;
+    getServiceInstance: object;
+    status: string | undefined;
+};
+export type RootServicesOf<TApplication extends object = object> = Prettify<{
+    [TKey in Exclude<keyof TApplication, ApplicationProperties> as TApplication[TKey] extends RootServiceCandidate ? TKey : never]: TApplication[TKey];
 }>;
 
 const isServiceInstance = (value: unknown): value is AnyService => {
@@ -56,19 +61,24 @@ const isServiceInstance = (value: unknown): value is AnyService => {
     return typeof service.runHook === 'function' && typeof service.getServiceInstance === 'function' && service.status !== undefined;
 };
 
+const createCommandsManager = (app: Application) => new CommandsManager(app, { debug: true }, app);
+const createDevCommandsRegistry = (app: Application) => new DevCommandsRegistry(app);
+const createDevDiagnosticsRegistry = (app: Application) => new DevDiagnosticsRegistry(app);
+
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
 export abstract class Application<
     TServicesContainer extends ServicesContainerClass = ServicesContainerClass,
     TUser extends TBasicUser = TBasicUser,
-> extends ApplicationService<Config, Hooks, Application, Application> {
+> extends ApplicationService<Config, Hooks, object, object> {
     public static identity = ConfigApplication.identity;
     public static setup = ConfigApplication.setup;
 
     public app!: this;
     public servicesContainer!: TServicesContainer;
     public userType!: TUser;
+    public declare Router: object;
 
     /*----------------------------------
     - PROPERTIES
@@ -122,21 +132,22 @@ export abstract class Application<
     - COMMANDS
     ----------------------------------*/
 
-    private commandsManager = new CommandsManager(this, { debug: true }, this);
-    private devCommandsRegistry?: DevCommandsRegistry<this>;
-    private devDiagnosticsRegistry?: DevDiagnosticsRegistry<this>;
+    private commandsManager?: CommandsManager;
+    private devCommandsRegistry?: DevCommandsRegistry;
+    private devDiagnosticsRegistry?: DevDiagnosticsRegistry;
 
     public command(...args: Parameters<CommandsManager['command']>) {
+        this.commandsManager ??= createCommandsManager(this as Application);
         return this.commandsManager.command(...args);
     }
 
     public getDevCommands() {
-        this.devCommandsRegistry ??= new DevCommandsRegistry(this);
+        this.devCommandsRegistry ??= createDevCommandsRegistry(this as Application);
         return this.devCommandsRegistry;
     }
 
     public getDevDiagnostics() {
-        this.devDiagnosticsRegistry ??= new DevDiagnosticsRegistry(this);
+        this.devDiagnosticsRegistry ??= createDevDiagnosticsRegistry(this as Application);
         return this.devDiagnosticsRegistry;
     }
 

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>>)
                 : [];