proteum 2.0.0 → 2.1.0

package/server/services/disks/index.ts

@@ -4,7 +4,7 @@
 
 // Core
 import type { Application } from '@server/app/index';
-import Service, { AnyService, TRegisteredServicesIndex, TServiceArgs } from '@server/app/service';
+import Service, { AnyService, TServiceArgs } from '@server/app/service';
 
 // Specific
 import type Driver from './driver';

package/server/services/prisma/Facet.ts

@@ -9,7 +9,7 @@ export type TWithStats = { $table: string; $key: string } & Record<string, strin
 
 export type TSubset = (...args: any[]) => Record<string, unknown> & { withStats?: TWithStats };
 
-export type Transform<S extends TSubset, R, RT> = (row: R) => RT;
+export type Transform<R, RT> = (row: R) => RT;
 
 export default class Facet<
     D extends TDelegate<R>,
@@ -21,7 +21,7 @@ export default class Facet<
         private readonly prisma: PrismaClient,
         private readonly delegate: D,
         private readonly subset: S,
-        private readonly transform?: Transform<S, R, RT>,
+        private readonly transform?: Transform<R, RT>,
     ) {}
 
     public async findMany(...args: Parameters<S>): Promise<RT[]> {

package/server/services/prisma/index.ts

@@ -3,17 +3,18 @@
 ----------------------------------*/
 
 // Npm
-import { PrismaClient } from '@/var/prisma';
+import dotenv from 'dotenv';
+import { PrismaClient } from '@generated/server/models';
 import mysql from 'mysql2/promise';
-import type PrismaClientType from '@prisma/client';
 const safeStringify = require('fast-safe-stringify'); // remplace les références circulairs par un [Circular]
 
 // Core
 import type { Application } from '@server/app/index';
-import Service from '@server/app/service';
+import Service, { TServiceArgs } from '@server/app/service';
 
 // Specific
 import Facet, { TDelegate, TSubset, Transform } from './Facet';
+import { createMariaDbAdapter } from './mariadb';
 import { NotFound } from '@common/errors';
 
 /*----------------------------------
@@ -37,7 +38,23 @@ export type Services = {};
 ----------------------------------*/
 
 export default class ModelsManager extends Service<Config, Hooks, Application, Application> {
-    public client = new PrismaClient() as PrismaClientType.PrismaClient;
+    public client: PrismaClient;
+
+    public constructor(...args: TServiceArgs<ModelsManager>) {
+        super(...args);
+
+        dotenv.config();
+
+        const databaseUrl = process.env.DATABASE_URL;
+        if (!databaseUrl)
+            throw new Error(
+                'DATABASE_URL is required before starting the Models service. Prisma 7 no longer auto-loads runtime env files.',
+            );
+
+        this.client = new PrismaClient({
+            adapter: createMariaDbAdapter(databaseUrl),
+        });
+    }
 
     public async ready() {
         await this.client.$executeRaw`SET time_zone = '+00:00'`;
@@ -47,7 +64,7 @@ export default class ModelsManager extends Service<Config, Hooks, Application, A
         await this.client.$disconnect();
     }
 
-    public Facet<D extends TDelegate<R>, S extends TSubset, R, RT>(...args: [D, S, Transform<S, R, RT>]) {
+    public Facet<D extends TDelegate<R>, S extends TSubset, R, RT = R>(...args: [D, S, Transform<R, RT>?]) {
         return new Facet(this.client, ...args);
     }
 

package/server/services/prisma/mariadb.ts

@@ -0,0 +1,47 @@
+import { PrismaMariaDb } from '@prisma/adapter-mariadb';
+
+const defaultConnectTimeout = 5_000;
+const defaultIdleTimeout = 300;
+const defaultPort = 3306;
+
+const parseInteger = (value: string | null | undefined) => {
+    if (!value) return undefined;
+
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) return undefined;
+
+    return parsed;
+};
+
+const decodeUrlSegment = (value: string) => {
+    if (!value) return value;
+
+    return decodeURIComponent(value);
+};
+
+export const createMariaDbAdapter = (databaseUrl: string) => {
+    const url = new URL(databaseUrl);
+
+    if (url.protocol !== 'mysql:' && url.protocol !== 'mariadb:')
+        throw new Error(
+            `Unsupported DATABASE_URL protocol "${url.protocol}". Prisma 7 Proteum support expects mysql:// or mariadb://.`,
+        );
+
+    const database = url.pathname.replace(/^\/+/, '');
+    if (!database) throw new Error('DATABASE_URL must include a database name.');
+
+    const connectionLimit = parseInteger(url.searchParams.get('connection_limit'));
+    const connectTimeoutSeconds = parseInteger(url.searchParams.get('connect_timeout'));
+    const idleTimeoutSeconds = parseInteger(url.searchParams.get('max_idle_connection_lifetime'));
+
+    return new PrismaMariaDb({
+        host: url.hostname,
+        port: parseInteger(url.port) ?? defaultPort,
+        user: decodeUrlSegment(url.username),
+        password: decodeUrlSegment(url.password),
+        database: decodeUrlSegment(database),
+        connectTimeout: connectTimeoutSeconds ? connectTimeoutSeconds * 1_000 : defaultConnectTimeout,
+        idleTimeout: idleTimeoutSeconds ?? defaultIdleTimeout,
+        ...(connectionLimit !== undefined ? { connectionLimit } : {}),
+    });
+};

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

@@ -22,6 +22,7 @@ import * as csp from 'express-csp-header';
 // Core
 import Container from '@server/app/container';
 import type { TServerRouter } from '..';
+import { serverHotReloadMessageType } from '@common/dev/serverHotReload';
 
 // Middlewaees (core)
 import { isMutipart, MiddlewareFormData } from './multipart';
@@ -210,8 +211,15 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
         /*----------------------------------
         - BOOT SERVICES
         ----------------------------------*/
-        console.info('Lancement du serveur web');
         this.http.listen(this.config.port, () => {
+            if (__DEV__ && typeof process.send === 'function') {
+                process.send({
+                    type: serverHotReloadMessageType.ready,
+                    publicUrl: this.publicUrl,
+                });
+                return;
+            }
+
             console.info(`Web server ready on ${this.publicUrl}`);
         });
     }

package/server/services/router/index.ts

@@ -56,7 +56,7 @@ import { loadGeneratedRuntimeBundle } from './generatedRuntime';
 export { type AnyRouterService, default as RouterService } from './service';
 export { default as RequestService } from './request/service';
 export type { default as Request, UploadedFile } from './request';
-export type { default as Response, TRouterContext } from './response';
+export type { default as Response, TRouterContext, TRouterContextServices } from './response';
 export type { TRoute, TAnyRoute } from '@common/router';
 
 export type TApiRegisterArgs<TRouter extends TServerRouter> =
@@ -145,7 +145,13 @@ export default class ServerRouter<
     extends Service<TConfig, Hooks, TApplication, TApplication>
     implements BaseRouter
 {
-    public disks = this.use<DisksManager<any, any, TApplication>>('Core/Disks', { optional: true });
+    public get disks() {
+        const { Disks } = this.app as TApplication & {
+            Disks?: DisksManager<any, any, TApplication>;
+        };
+
+        return Disks;
+    }
 
     // Services
     public http: HTTP;
@@ -490,7 +496,7 @@ export default class ServerRouter<
     private loadGeneratedControllerDefinitions() {
         return (
             loadGeneratedRuntimeBundle<TGeneratedControllerDefinition[]>('controllers') ||
-            require('@/server/.generated/controllers').default ||
+            require('@generated/server/controllers').default ||
             []
         );
     }
@@ -498,7 +504,7 @@ export default class ServerRouter<
     private loadGeneratedRouteModules() {
         return (
             loadGeneratedRuntimeBundle<TGeneratedRouteModule[]>('routes') ||
-            require('@/server/.generated/routes').default ||
+            require('@generated/server/routes').default ||
             []
         );
     }

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

@@ -19,8 +19,8 @@ import { NotFound, Forbidden, Anomaly } from '@common/errors';
 import BaseResponse, { TResponseData } from '@common/router/response';
 import { splitRouteSetupResult } from '@common/router/pageSetup';
 import Page from './page';
-import createControllers from '@/common/.generated/controllers';
-import type { TControllers } from '@/common/.generated/controllers';
+import createControllers from '@generated/common/controllers';
+import type { TControllers } from '@generated/common/controllers';
 
 // To move into a new npm module: json-mask
 import jsonMask from './mask';
@@ -41,10 +41,27 @@ export type TBasicSSrData = {
     domains: TDomainsList;
 };
 
+type TServerRouterApplication<TRouter extends TServerRouter> =
+    TRouter extends ServerRouter<infer TApplication, any, any> ? TApplication : never;
+
+type TServerRouterPlugins<TRouter extends TServerRouter> =
+    TRouter extends ServerRouter<any, any, infer TConfig>
+        ? TConfig extends { plugins: infer TPlugins }
+            ? TPlugins
+            : {}
+        : {};
+
+type TServerRouterCustomContext<TRouter extends TServerRouter> =
+    TRouter extends ServerRouter<any, any, infer TConfig>
+        ? TConfig extends { context: (...args: any[]) => infer TContext }
+            ? TContext
+            : {}
+        : {};
+
 export type TRouterContext<TRouter extends TServerRouter> =
     // Request context
     {
-        app: TRouter['app'];
+        app: TServerRouterApplication<TRouter>;
         context: TRouterContext<TRouter>; // = this
         request: ServerRequest<TRouter>;
         api: ServerRequest<TRouter>['api'];
@@ -55,9 +72,12 @@ export type TRouterContext<TRouter extends TServerRouter> =
         Router: TRouter;
     } & TRouterContextServices<TRouter> &
         TControllers &
-        TRouterRequestContext<TRouter>;
+        TServerRouterCustomContext<TRouter>;
 
-export type TRouterContextServices<TRouter extends TServerRouter, TPlugins = TRouter['config']['plugins']> =
+export type TRouterContextServices<
+    TRouter extends TServerRouter,
+    TPlugins extends object = TServerRouterPlugins<TRouter>,
+> =
     // Custom context via servuces
     // For each roiuter service, return the request service (returned by roiuterService.requestService() )
     {
@@ -66,7 +86,7 @@ export type TRouterContextServices<TRouter extends TServerRouter, TPlugins = TRo
             : TPlugins[serviceName];
     };
 
-export type TRouterRequestContext<TRouter extends TServerRouter> = ReturnType<TRouter['config']['context']>;
+export type TRouterRequestContext<TRouter extends TServerRouter> = TServerRouterCustomContext<TRouter>;
 
 /*----------------------------------
 - CLASSE

package/types/auth-check-rules.test.ts

@@ -0,0 +1,51 @@
+import type { TRouteOptions } from '@common/router';
+import { AuthRequired, UpgradeRequired } from '@common/errors';
+import type {
+    TAuthCheckConditions,
+    TAuthRulesFactory,
+    TAuthRuleNoInput,
+    TAuthTrackingContext,
+    TBasicUser,
+    TUserRole,
+} from '@server/services/auth';
+import type { Request as ServerRequest, TAnyRouter } from '@server/services/router';
+
+type Assert<T extends true> = T;
+
+type Equals<TLeft, TRight> = (<T>() => T extends TLeft ? 1 : 2) extends <T>() => T extends TRight ? 1 : 2
+    ? (<T>() => T extends TRight ? 1 : 2) extends <T>() => T extends TLeft ? 1 : 2
+        ? true
+        : false
+    : false;
+
+declare global {
+    interface ProteumAuthRuleCatalog {
+        isPaid: TAuthRuleNoInput;
+        hasFeature: 'radar' | 'api';
+        matchesPlanWindow: [string, 'modal' | 'page'];
+    }
+}
+
+type TResolvedConditions = TAuthCheckConditions;
+
+type _AssertRoleCondition = Assert<Equals<TResolvedConditions['role'], TUserRole | undefined>>;
+type _AssertZeroArgCondition = Assert<Equals<TResolvedConditions['isPaid'], true | undefined>>;
+type _AssertSingleArgCondition = Assert<Equals<TResolvedConditions['hasFeature'], 'radar' | 'api' | undefined>>;
+type _AssertTupleArgCondition = Assert<
+    Equals<TResolvedConditions['matchesPlanWindow'], [string, 'modal' | 'page'] | undefined>
+>;
+type _AssertRouteAuthOptions = Assert<
+    Equals<TRouteOptions['auth'], TAuthCheckConditions | TUserRole | boolean | null | undefined>
+>;
+type _AssertRouteAuthTracking = Assert<Equals<TRouteOptions['authTracking'], TAuthTrackingContext | undefined>>;
+
+type TExampleRulesFactory = TAuthRulesFactory<TBasicUser, ServerRequest<TAnyRouter>>;
+type _AssertRulesFactoryArgs = Assert<
+    Equals<Parameters<TExampleRulesFactory>, [user: TBasicUser, tracking: TAuthTrackingContext, request: ServerRequest<TAnyRouter>]>
+>;
+
+const authRequiredFromRule = new AuthRequired('Please login to continue', 'auth', 'view');
+const upgradeRequiredFromRule = new UpgradeRequired('Please upgrade to continue', 'radar', 'view');
+
+type _AssertInjectedAuthRequired = Assert<typeof authRequiredFromRule extends Error ? true : false>;
+type _AssertInjectedUpgradeRequired = Assert<typeof upgradeRequiredFromRule extends Error ? true : false>;

package/types/controller-request-context.test.ts

@@ -0,0 +1,55 @@
+import type { Application } from '@server/app';
+import Controller from '@server/app/controller';
+import type { TServerRouter } from '@server/services/router';
+import type { TServiceModelsClient, TServiceRequestContext } from '@server/app/service';
+
+type Assert<T extends true> = T;
+
+type Equals<TLeft, TRight> = (<T>() => T extends TLeft ? 1 : 2) extends <T>() => T extends TRight ? 1 : 2
+    ? (<T>() => T extends TRight ? 1 : 2) extends <T>() => T extends TLeft ? 1 : 2
+        ? true
+        : false
+    : false;
+
+type TTypedAuthRequestService = {
+    check(): 'typed-user';
+};
+
+type TTestRouter = TServerRouter & {
+    app: TTestApp;
+    config: TServerRouter['config'] & {
+        plugins: TServerRouter['config']['plugins'] & {
+            auth: {
+                requestService(request: any): TTypedAuthRequestService;
+            };
+        };
+        context: () => {};
+    };
+};
+
+interface TTestApp extends Application {
+    Router: TTestRouter;
+    Models: {
+        client: {
+            post: {
+                findMany(): 'posts';
+            };
+        };
+    };
+}
+
+class TypedRequestController extends Controller<TTestApp> {
+    public useAuth() {
+        return this.request.auth.check();
+    }
+}
+
+type TRequestAuth = TypedRequestController['request']['auth'];
+type TAuthCheckResult = ReturnType<TypedRequestController['useAuth']>;
+type TServiceContextAuth = TServiceRequestContext<TTestApp>['auth'];
+type TModelsClient = TServiceModelsClient<TTestApp>;
+
+type _AssertTypedRequestService = Assert<Equals<TRequestAuth['check'], TTypedAuthRequestService['check']>>;
+type _AssertTypedAuthCheckResult = Assert<Equals<TAuthCheckResult, 'typed-user'>>;
+type _AssertTypedServiceRequestContext = Assert<Equals<TServiceContextAuth['check'], TTypedAuthRequestService['check']>>;
+type _AssertTypedModelsClient = Assert<Equals<ReturnType<TModelsClient['post']['findMany']>, 'posts'>>;

package/types/service-config.test.ts

@@ -0,0 +1,39 @@
+import { Services, type ServiceConfig } from '@server/app';
+import Service from '@server/app/service';
+import Router from '@server/services/router';
+
+type Assert<T extends true> = T;
+
+type Equals<TLeft, TRight> = (<T>() => T extends TLeft ? 1 : 2) extends <T>() => T extends TRight ? 1 : 2
+    ? (<T>() => T extends TRight ? 1 : 2) extends <T>() => T extends TLeft ? 1 : 2
+        ? true
+        : false
+    : false;
+
+class ExampleService extends Service<
+    {
+        enabled: boolean;
+        nested: { count: number };
+    },
+    {}
+> {}
+
+const exampleConfig = Services.config(ExampleService, {
+    enabled: true,
+    nested: { count: 1 },
+});
+
+type RouterBaseConfig = Omit<ServiceConfig<typeof Router>, 'plugins'>;
+
+type _AssertLiteralEnabled = Assert<Equals<typeof exampleConfig.enabled, true>>;
+type _AssertLiteralNestedCount = Assert<Equals<typeof exampleConfig.nested.count, 1>>;
+type _AssertRouterBaseConfigExtendsObject = Assert<RouterBaseConfig extends object ? true : false>;
+
+// @ts-expect-error Services.config should reject unknown top-level config keys.
+Services.config(ExampleService, { enabled: true, nested: { count: 1 }, extra: true });
+
+// @ts-expect-error Services.config should reject unknown nested config keys.
+Services.config(ExampleService, { enabled: true, nested: { count: 1, extra: true } });
+
+// @ts-expect-error Services.config should reject invalid property types.
+Services.config(ExampleService, { enabled: 'yes', nested: { count: 1 } });

package/agents/codex/AGENTS.md

@@ -1,95 +0,0 @@
-# Architecture
-
-This is a full stack monolith project using Typescript, NodeJS, Preact, and Proteum.
-
-`/client`: frontend
-    `/assets`: CSS, images and other frontend assets
-    `/components`: reusable components
-    `/pages`: page route files and page-local UI
-    `/hooks`
-`/common`: shared functions, constants and typings
-`/server`: backend
-    `/config`: service configuration
-    `/services`: backend services and controllers
-    `/routes`: explicit non-controller routes
-    `/lib`: helper functions
-`/tests`
-
-# Coding style
-
-See `CODING_STYLE.md`.
-This file is the source of truth for formatting, section-comment structure, and general coding style.
-
-# Files organization
-
-- Always keep one class / react component per file
-- Prefer a deep tree structure that groups files by business concern instead of long file names
-- The default `*.ts` / `*.tsx` file is the browser implementation; use `*.ssr.ts` / `*.ssr.tsx` only for SSR-safe fallbacks
-
-## Centralize feature catalogs (Single Source of Truth)
-
-When implementing a feature that relies on a **curated list of items**, keep **one canonical catalog/registry file** and make all other code import it.
-
-## Runtime access rules
-
-- `@models/types`: Prisma typings only. Can be imported anywhere.
-- Never use runtime value imports from `@request` or `@models`.
-- Never expose request-scoped state through imports.
-
-## Client runtime access
-
-- Page route files use `Router.page(...)`.
-- `Router.page(path, render)` for pages without SSR setup.
-- `Router.page(path, setup, render)` for pages with SSR config/data.
-- `setup` receives the normal page context plus the generated controller tree spread into it.
-- `render` receives the normal page context plus the resolved setup data and the same controller tree spread into it.
-- Components and hooks use `useContext()` to access controller instances and client runtime services.
-
-## Server runtime access
-
-- Normal business logic lives in `/server/services/**/index.ts` classes that extend `Service`.
-- Route entrypoints live in `*.controller.ts` classes that extend `Controller`.
-- Only controller files are indexed as callable API endpoints.
-- Controller methods validate input with `this.input(schema)` and access request scope through `this.request`.
-- Service classes access other services via `this.services` and prisma models via `this.models`.
-- Never use request-scoped state directly inside normal service methods.
-
-# Agent behavior
-
-**Make sure the code you generate integrates perfectly with the current codebase by avoiding repetition and centralizing each purpose.**
-
-## Typings
-
-- Fix typing issues only on the code you wrote.
-- Never cast with `as any` or `as unknown`; fix the type contract or introduce an explicit typed adapter instead. If you find no other solution, tell me in the output.
-
-## Workflow
-
-- Everytime I input error messages without any instructions, don't implement fixes.
-Instead, ivestigate the potential causes of the errors, and for each:
-    1. Evaluate / quantify the probabiliies
-    2. Give why and
-    3. Suggest how to fix it
-- When you have finished your work, summarize in one top-level short sentence the changes you made since the beginning of the conversation. Output as "Commit message".
-
-## Never edit the following files
-
-- Prisma files (except schema.prisma)
-- tsconfigs
-- env
-- Any file / folder that is a symbolic link
-
-If you need to edit them, just suggest it in the chat.
-
-## Don't run any of these commands
-
-```
-git restore
-git reset
-prisma *
-And any git command in the write mode.
-```
-
-# Copy and UX
-
-Before making UX/copy decisions, read `docs/PERSONAS.md`, `docs/PRODUCT.md`, `docs/MARKETING.md`.

package/agents/codex/client/AGENTS.md

@@ -1,102 +0,0 @@
-# Frontend designing
-
-UI components are defined in `/client/pages` and `/client/components`.
-
-## Stack
-
-- Typescript strict
-- Preact with SSR
-- Base UI
-- `@/client/components/Motion`
-- Tailwind CSS 4
-
-Don't use React.useCallback unless strictly necessary.
-
-## Communicate with the server
-
-### Pages
-
-Pages use `Router.page(...)`.
-
-Use `Router.page(path, render)` when there is no SSR setup.
-
-Use `Router.page(path, setup, render)` when the page needs SSR config or SSR data:
-
-```typescript
-Router.page('/dashboard/example', ({ Missions }) => ({
-    _auth: 'USER',
-    missions: Missions.Get(),
-}), ({ request, missions, Missions }) => {
-    return <Page missions={missions} />;
-});
-```
-
-- `setup` returns one flat object
-- keys like `_auth`, `_layout`, `_priority` are route config
-- all other keys are SSR data fetchers
-- never use `api.fetch(...)` in page files
-
-### Components and hooks
-
-Components and hooks access controllers through `useContext()`:
-
-```typescript
-const { Auth, Domains } = useContext();
-```
-
-Then call controller methods directly:
-
-```typescript
-Auth.Signup(data).then((result) => {
-    ...
-});
-```
-
-### Async calls
-
-- Prefer direct controller calls from the context or page render args
-- The thrown errors will automatically be displayed to the user, so don't silent them
-- Never depend on legacy `@app` imports on the client
-
-## Errors handling
-
-Errors catched from controller calls should never be silented.
-If a catch is needed, rethrow or surface the failure clearly.
-
-## Design
-
-- Beautiful, modern, minimalist and intuitive design
-- Responsive layout
-- Enhance the UX with meaningful animations
-
-## Rules
-
-- Always import React in react files (`.tsx`)
-- Don't use any component from `@client/components` unless the codebase already does in that area
-- To create a link / button, always use the `Link` component when the codebase expects navigation links
-
-## Keep the code organized
-
-- Split big components (more than 1000 lines) into smaller components
-- Always use one component per file
-- Everytime possible, load data and define action handlers in the directly concerned component instead of passing everything from the parent
-
-## Split the page by sections via comments
-
-Use:
-
-```typescript
-/*----------------------------------
-- SECTION NAME
-----------------------------------*/
-```
-
-File sections:
-- DEPENDENCIES
-- TYPES
-- COMPONENT / PAGE
-
-Component / page sections:
-- INIT
-- ACTIONS
-- RENDER