proteum 1.0.2 → 2.0.0-1

package/common/router/index.ts

@@ -6,17 +6,10 @@
 import type zod from 'zod';
 
 // types
-import type {
-    default as ClientRouter,
-    TRouterContext as ClientRouterContext,
-    TRegisterPageArgs
-} from '@client/services/router';
-
-import type { 
-    TAnyRouter,
-    TRouterContext as ServerRouterContext,
-    TRouteHttpMethod 
-} from '@server/services/router';
+import type { default as ClientRouter, TRouterContext as ClientRouterContext } from '@client/services/router';
+import type { TRegisterPageArgs } from './contracts';
+
+import type { TAnyRouter, TRouterContext as ServerRouterContext, TRouteHttpMethod } from '@server/services/router';
 
 import type RouterRequest from './request';
 
@@ -25,7 +18,7 @@ import type { TUserRole } from '@server/services/auth';
 import type { TAppArrowFunction } from '@common/app';
 
 // Specfic
-import type { default as Page, TFrontRenderer, TDataProvider } from './response/page';
+import type { default as Page, TFrontRenderer, TPageSetup } from './response/page';
 
 /*----------------------------------
 - TYPES: ROUTES
@@ -38,176 +31,164 @@ export type { default as Response } from './response';
 
 export type ClientOrServerRouter = ClientRouter | TAnyRouter;
 
-export type TRoute<RouterContext extends TClientOrServerContextForPage = TClientOrServerContextForPage> = {
+type TRouteMatch = { regex: RegExp; keys: (number | string)[] };
 
+type TRouteBase<RouterContext = unknown, TResult = any> = {
     // Match
-    method: TRouteHttpMethod,
-    path: string,
+    method: TRouteHttpMethod;
+    path: string;
 
     // Execute
-    schema?: zod.ZodSchema,
-    controller: TRouteController<RouterContext>,
-    options: TRouteOptions
-} & (
-    // With regex
-    {
-        regex: RegExp,
-        keys: (number | string)[],
-    }
-    // Without regex (for ex: controllers)
-    | 
-    {
-        regex?: undefined,
-        keys?: undefined,
-    }
-)
+    schema?: zod.ZodSchema;
+    controller: TRouteController<RouterContext, TResult>;
+    options: TRouteOptions;
+};
 
-export type TErrorRoute<RouterContext extends TClientOrServerContextForPage = TClientOrServerContextForPage> = {
-    code,
-    controller: TRouteController<RouterContext>,
-    options: TRouteOptions
-}
+export type TMatchedRoute<RouterContext = unknown, TResult = any> = TRouteBase<RouterContext, TResult> & TRouteMatch;
+
+export type TRoute<RouterContext = unknown, TResult = any> =
+    | TMatchedRoute<RouterContext, TResult>
+    | TRouteBase<RouterContext, TResult>;
 
-export type TAnyRoute<RouterContext extends TClientOrServerContextForPage = TClientOrServerContextForPage> =
-    TRoute<RouterContext> | TErrorRoute<RouterContext>
+export type TErrorRoute<RouterContext = unknown, TResult = any> = {
+    code: number;
+    controller: TRouteController<RouterContext, TResult>;
+    options: TRouteOptions;
+};
+
+export type TAnyRoute<RouterContext = unknown, TResult = any> =
+    | TRoute<RouterContext, TResult>
+    | TErrorRoute<RouterContext, TResult>;
 
 // ClientRouterContext already includes server context
-export type TClientOrServerContext = ClientRouterContext;// | ServerRouterContext;
+export type TClientOrServerContext = ClientRouterContext; // | ServerRouterContext;
 
-export type TClientOrServerContextForPage = With<TClientOrServerContext, 'page'>
+export type TClientOrServerContextForPage = With<TClientOrServerContext, 'page'>;
 
-export type TRouteController<RouterContext extends TClientOrServerContextForPage = TClientOrServerContextForPage> = 
-    (context: RouterContext) => /* Page to render */Page | /* Any data (html, json) */Promise<any>
+export type TRouteController<RouterContext = unknown, TResult = any> = (context: RouterContext) => TResult;
 
-export type TRouteOptions = {
+export type TPageRoute = TRoute<TClientOrServerContextForPage, Page | Promise<any>>;
+
+export type TPageErrorRoute = TErrorRoute<TClientOrServerContextForPage, Page | Promise<any>>;
 
+export type TRouteOptions = {
     // Injected by the page plugin
-    filepath?: string,
-    data?: TDataProvider
+    id?: string;
+    filepath?: string;
+    setup?: TPageSetup;
 
     // Indexing
-    bodyId?: string,
-    priority: number,
-    preload?: boolean,
+    bodyId?: string;
+    priority: number;
+    preload?: boolean;
 
     // Resolving
-    domain?: string,
-    accept?: string,
-    raw?: boolean, // true to return raw data
-    auth?: TUserRole | boolean,
-    redirectLogged?: string, // Redirect to this route if auth: false and user is logged
+    domain?: string;
+    accept?: string;
+    raw?: boolean; // true to return raw data
+    auth?: TUserRole | boolean;
+    redirectLogged?: string; // Redirect to this route if auth: false and user is logged
 
     // Rendering
-    static?: { 
-        refresh?: string, 
-        urls: string[] 
-    },
-    whenStatic?: boolean, // If true, the route is only executed even if the page is cached
-    canonicalParams?: string[], // For SEO + unique ID for static cache
-    layout?: false | string, // The nale of the layout
+    static?: { refresh?: string; urls: string[] };
+    whenStatic?: boolean; // If true, the route is only executed even if the page is cached
+    canonicalParams?: string[]; // For SEO + unique ID for static cache
+    layout?: false | string; // The nale of the layout
 
     // To cleanup
-    TESTING?: boolean,
-    logging?: boolean,
-}
+    TESTING?: boolean;
+    logging?: boolean;
+};
 
-export type TRouteModule<TRegisteredRoute = any> = { 
+export type TRouteModule<TRegisteredRoute = any> = {
     // exporing __register is a way to know we axport a TAppArrowFunction
-    __register?: TAppArrowFunction<TRegisteredRoute> 
-}
+    __register: TAppArrowFunction<TRegisteredRoute>;
+};
 
-export type TDomainsList = {
-    [endpointId: string]: string
-} & {
-    current: string
-}
+export type TDomainsList = { [endpointId: string]: string } & { current: string };
 
-export const defaultOptions = {
-    priority: 0,
-}
+export const defaultOptions: Pick<TRouteOptions, 'priority'> = { priority: 0 };
 
 /*----------------------------------
 - FUNCTIONS
 ----------------------------------*/
 export const buildUrl = (
     path: string,
-    params: {[key: string]: any},
-    domains: {[alias: string]: string},
-    absolute: boolean
+    params: { [key: string]: any },
+    domains: { [alias: string]: string },
+    absolute: boolean,
 ) => {
-
     let prefix: string = '';
 
     // Relative to domain
-    if (path[0] === '/' && absolute)
-        prefix = domains.current;
+    if (path[0] === '/' && absolute) prefix = domains.current;
     // Other domains of the project
     else if (path[0] === '@') {
-
         // Extract domain ID from path
         let domainId: string;
         let slackPos = path.indexOf('/');
-        if (slackPos === -1)
-            slackPos = path.length;
+        if (slackPos === -1) slackPos = path.length;
         domainId = path.substring(1, slackPos);
         path = path.substring(slackPos);
 
         // Get domain
-        const domain = domains[ domainId ];
-        if (domain === undefined)
-            throw new Error("Unknown API endpoint ID: " + domainId);
+        const domain = domains[domainId];
+        if (domain === undefined) throw new Error('Unknown API endpoint ID: ' + domainId);
 
         // Return full url
         prefix = domain;
 
-    // Absolute URL
+        // Absolute URL
     }
 
     // Path parapeters
     const searchParams = new URLSearchParams();
     for (const key in params) {
-
         // Exclude undefined of empty
-        if (!params[key])
-            continue;
+        if (!params[key]) continue;
         // Path placeholder
-        else if (path.includes(':' + key))
-            path = path.replace(':' + key, params[key]);
+        else if (path.includes(':' + key)) path = path.replace(':' + key, params[key]);
         // Query string
-        else 
-            searchParams.set(key, params[key]);
+        else searchParams.set(key, params[key]);
     }
 
     // Return final url
     return prefix + path + (searchParams.toString() ? '?' + searchParams.toString() : '');
-}
+};
 
-export const matchRoute = (route: TRoute, request: RouterRequest) => {
+export const hasRouteMatcher = <TRouteLike extends { regex?: unknown; keys?: unknown }>(
+    route: TRouteLike,
+): route is TRouteLike & TRouteMatch => 'regex' in route && route.regex instanceof RegExp;
 
+export const matchRoute = (route: TRouteMatch, request: RouterRequest) => {
     // Match Path
     const match = route.regex.exec(request.path);
-    if (!match)
-        return false;
+    if (!match) return false;
 
     // Extract URL params
     for (let iKey = 0; iKey < route.keys.length; iKey++) {
         const key = route.keys[iKey];
-        const value =  match[iKey + 1];
-        if (typeof key === 'string' && value) // number = sans nom
-            request.data[key] = decodeURIComponent( value.replaceAll('+', '%20') );
+        const value = match[iKey + 1];
+        if (typeof key === 'string' && value)
+            // number = sans nom
+            request.data[key] = decodeURIComponent(value.replace(/\+/g, '%20'));
     }
 
     return true;
-}
+};
 
 /*----------------------------------
 - BASE ROUTER
 ----------------------------------*/
 
 export default abstract class RouterInterface {
-
-    public abstract page<TControllerData extends TObjetDonnees = {}>(...args: TRegisterPageArgs<TControllerData>);
-
-    public abstract error(code: number, options, renderer: TFrontRenderer<{}, { message: string }>);
-
-}
+    public abstract page<TControllerData extends TObjetDonnees = {}>(
+        ...args: TRegisterPageArgs<TControllerData, TRouteOptions>
+    ): unknown;
+
+    public abstract error(
+        code: number,
+        options: Partial<TRouteOptions>,
+        renderer: TFrontRenderer<{}, { message: string }>,
+    ): unknown;
+}

package/common/router/layouts.ts

@@ -6,88 +6,75 @@
 import type { ComponentChild } from 'preact';
 
 // Core
-import type { ClientContext } from '@/client/context';
 import type { TRouteOptions } from '.';
-import type { TDataProvider } from './response/page';
+import type { TDataProvider, TPageRenderContext } from './response/page';
 
 // App
 import internalLayout from '@client/pages/_layout';
-
-import * as layouts from '@/client/pages/**/_layout/index.tsx';
+import generatedLayouts, { layoutOrder } from '@/client/.generated/layouts';
 
 /*----------------------------------
 - CONST
 ----------------------------------*/
 
-export const layoutsList = layouts as ImportedLayouts;
+export const layoutsList: ImportedLayouts = generatedLayouts;
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
-type LayoutComponent = (attributes: { context: ClientContext }) => ComponentChild;
+export type LayoutProps = {
+    [key: string]: unknown;
+    context: TPageRenderContext;
+    menu: ComponentChild;
+    children: ComponentChild;
+} & TPageRenderContext;
+
+type LayoutComponent = (attributes: LayoutProps) => ComponentChild;
 
-export type Layout = { 
-    path: string, 
-    Component: LayoutComponent,
-    data?: TDataProvider
-}
+export type Layout = { path: string; Component: LayoutComponent; data?: TDataProvider };
 
-export type ImportedLayouts = {
-    [chunkId: string]: Layout["Component"]
-}
+export type ImportedLayouts = { [chunkId: string]: { default: Layout['Component']; data?: TDataProvider } };
 
 /*----------------------------------
 - UTILS
 ----------------------------------*/
 // TODO: getLayot only on server side, and pass the layout chunk id
-export const getLayout = (routePath: string, routeOptions?: TRouteOptions): Layout | undefined => {
-
-    if (routeOptions === undefined)
-        return undefined;
+export const getLayout = (routePath: string, routeOptions?: Partial<TRouteOptions>): Layout | undefined => {
+    if (routeOptions === undefined) return undefined;
     // W don't want a layout on this page
-    if (routeOptions.layout === false)
-        return undefined;
+    if (routeOptions.layout === false) return undefined;
 
     // options.id has been injected via the babel plugon
-    const chunkId = routeOptions["id"];
+    const chunkId = routeOptions.id;
     if (chunkId === undefined) {
-        console.error("Route informations where ID cas not injected:", routeOptions);
+        console.error('Route informations where ID cas not injected:', routeOptions);
         throw new Error(`ID has not injected for the following page route: ${routePath}`);
     }
-    
+
     // Layout via name
     if (routeOptions.layout !== undefined) {
-
-        const { default: LayoutComponent, data } = layouts[routeOptions.layout];
+        const layoutModule = layoutsList[routeOptions.layout];
+        const { default: LayoutComponent, data } = layoutModule || {};
         if (LayoutComponent === undefined)
-            throw new Error(`No layout found with ID: ${routeOptions.layout}. registered layouts: ${Object.keys(layouts)}`);
+            throw new Error(
+                `No layout found with ID: ${routeOptions.layout}. registered layouts: ${Object.keys(layoutsList)}`,
+            );
+
+        return { path: routeOptions.layout, Component: layoutModule.default, data };
+    }
 
-        return { 
-            path: routeOptions.layout, 
-            Component: layouts[routeOptions.layout].default,
-            data
-        }
-    } 
-            
     // Automatic layout via the nearest _layout folder
-    for (const layoutPath in layouts)
+    for (const layoutPath of layoutOrder as string[])
         if (
             // The layout is nammed '' when it's at the root (@/client/pages/_layout)
-            layoutPath === '' // Root layout
+            layoutPath === '' || // Root layout
             // Exact match
-            || chunkId === layoutPath 
+            chunkId === layoutPath ||
             // Parent
-            || chunkId.startsWith( layoutPath + '_' )
+            chunkId.startsWith(layoutPath + '_')
         )
-            return { 
-                path: layoutPath, 
-                Component: layouts[layoutPath].default,
-                data: layouts[layoutPath].data,
-            };
+            return { path: layoutPath, Component: layoutsList[layoutPath].default, data: layoutsList[layoutPath].data };
 
     // Internal layout
-    return {
-        path: '/',
-        Component: internalLayout
-    }
-}
+    return { path: '/', Component: internalLayout };
+};

package/common/router/pageSetup.ts

@@ -0,0 +1,50 @@
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+import type { TRouteOptions } from '.';
+
+export const routeSetupOptionKeys = [
+    'priority',
+    'preload',
+    'domain',
+    'accept',
+    'raw',
+    'auth',
+    'redirectLogged',
+    'static',
+    'whenStatic',
+    'canonicalParams',
+    'layout',
+    'TESTING',
+    'logging',
+] as const satisfies (keyof TRouteOptions)[];
+
+export const reservedRouteSetupKeys = ['id', 'filepath', 'bodyId', 'data', 'setup'] as const;
+
+const routeSetupOptionKeysSet = new Set<string>(routeSetupOptionKeys);
+const reservedRouteSetupKeysSet = new Set<string>(reservedRouteSetupKeys);
+
+export const getRouteSetupOptionKey = (key: string) => {
+    const normalizedKey = key.startsWith('_') ? key.substring(1) : key;
+
+    if (reservedRouteSetupKeysSet.has(normalizedKey)) throw new Error(`"${key}" is a reserved Router.page setup key.`);
+
+    return routeSetupOptionKeysSet.has(normalizedKey) ? (normalizedKey as keyof TRouteOptions) : null;
+};
+
+export const splitRouteSetupResult = (result: TObjetDonnees | undefined) => {
+    const options: Partial<TRouteOptions> = {};
+    const data: TObjetDonnees = {};
+
+    if (!result) return { options, data };
+
+    for (const key in result) {
+        const optionKey = getRouteSetupOptionKey(key);
+
+        if (optionKey) options[optionKey] = result[key];
+        else data[key] = result[key];
+    }
+
+    return { options, data };
+};

package/common/router/register.ts

@@ -7,49 +7,78 @@ import { pathToRegexp, Key } from 'path-to-regexp';
 
 // Core
 import { getLayout } from './layouts';
+import type { TRegisterPageArgs } from './contracts';
 
 // types
 import type { TRouteOptions } from '.';
-import type { TFrontRenderer } from './response/page';
-import type { TRegisterPageArgs } from '@client/services/router';
+import type { TFrontRenderer, TPageSetup } from './response/page';
 
 /*----------------------------------
 - UTILS
 ----------------------------------*/
 
-export const getRegisterPageArgs = (...args: TRegisterPageArgs) => {
-
+export const getRegisterPageArgs = (...args: TRegisterPageArgs<any, TRouteOptions>) => {
     let path: string;
     let options: Partial<TRouteOptions> = {};
+    let setup: TPageSetup | undefined;
     let renderer: TFrontRenderer;
 
-    if (args.length === 2)
-        ([path, renderer] = args)
-    else
-        ([path, options, renderer] = args)
+    if (args.length === 2) {
+        [path, renderer] = args;
+    } else if (args.length === 3) {
+        const [pathArg, optionsOrSetupArg, rendererArg] = args;
+        path = pathArg;
+        renderer = rendererArg;
+
+        if (typeof optionsOrSetupArg === 'function') setup = optionsOrSetupArg;
+        else options = optionsOrSetupArg;
+    } else {
+        const [pathArg, optionsArg, setupArg, rendererArg] = args;
+        path = pathArg;
+        options = optionsArg;
+        setup = setupArg;
+        renderer = rendererArg;
+    }
 
-    // Automatic layout form the nearest _layout folder
+    // Automatic layout form the nearest _layout folder using static options only.
     const layout = getLayout(path, options);
 
-    return { path, options, renderer, layout }
+    return { path, options, setup, renderer, layout };
+};
+
+export const getRegisterPageOptions = (...args: TRegisterPageArgs<any, TRouteOptions>) => {
+    let path: string;
+    let options: Partial<TRouteOptions> = {};
+    let setup: TPageSetup | undefined;
+    let renderer: TFrontRenderer;
+
+    if (args.length === 2) {
+        [path, renderer] = args;
+    } else if (args.length === 3) {
+        const [pathArg, optionsOrSetupArg, rendererArg] = args;
+        path = pathArg;
+        renderer = rendererArg;
 
-}
+        if (typeof optionsOrSetupArg === 'function') setup = optionsOrSetupArg;
+        else options = optionsOrSetupArg;
+    } else {
+        const [pathArg, optionsArg, setupArg, rendererArg] = args;
+        path = pathArg;
+        options = optionsArg;
+        setup = setupArg;
+        renderer = rendererArg;
+    }
 
-export const buildRegex = ( path: string ) => {
+    return { path, options, setup, renderer };
+};
 
+export const buildRegex = (path: string) => {
     // pathToRegexp ne supporte plus les wildcards depuis 4.0
-    if (path.endsWith('*'))
-        path = path.substring(0, path.length - 1) + '(.*)';
+    if (path.endsWith('*')) path = path.substring(0, path.length - 1) + '(.*)';
 
     // path => regex
-    const keys: Key[] = []
-    const regex = pathToRegexp(path, keys, {
-        sensitive: true
-    }); 
-
-    return { 
-        keys: keys.map(k => k.name), 
-        regex 
-    }
+    const keys: Key[] = [];
+    const regex = pathToRegexp(path, keys, { sensitive: true });
 
-}
+    return { keys: keys.map((k) => k.name), regex };
+};

package/common/router/request/api.ts

@@ -10,62 +10,56 @@ import type { HttpMethod } from '@server/services/router';
 
 // The fetcher can be undefined if we put a condition on it
 // By example if we want to fetch an api endpoint only if the url contains a certain url parameter
-export type TFetcherList = { [id: string]: /*TFetcher | */Promise<any> | undefined }
+export type TFetcherList = { [id: string]: TFetcher<any> | Promise<any> | undefined };
 
 export type TFetcher<TData extends any = unknown> = {
-
     // For async calls: api.post(...).then((data) => ...)
-    then: (callback: (data: TData) => void) => Promise<TData>,
-    catch: (callback: (data: any) => false | void) => Promise<TData>,
-    finally: (callback: () => void) => Promise<TData>,
-    run: () => Promise<TData>,
-    
-    method: HttpMethod,
-    path: string,
-    data?: TPostDataWithFile,
-    options?: TApiFetchOptions
-}
-
-export type TFetcherArgs = [
-    method: HttpMethod,
-    path: string,
-    data?: TPostDataWithFile,
-    options?: TApiFetchOptions
-]
+    then: <TResult1 = TData, TResult2 = never>(
+        onfulfilled?: ((value: TData) => TResult1 | PromiseLike<TResult1>) | null,
+        onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+    ) => Promise<TResult1 | TResult2>;
+    catch: <TResult = never>(
+        onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null,
+    ) => Promise<TData | TResult>;
+    finally: (onfinally?: (() => void) | null) => Promise<TData>;
+    run: () => Promise<TData>;
+
+    method: HttpMethod;
+    path: string;
+    data?: TPostDataWithFile;
+    options?: TApiFetchOptions;
+};
+
+export type TFetcherArgs = [method: HttpMethod, path: string, data?: TPostDataWithFile, options?: TApiFetchOptions];
 
 export type TApiFetchOptions = {
-    captcha?: string, // Action id (required by recaptcha)
-    onProgress?: (percent: number) => void,
+    captcha?: string; // Action id (required by recaptcha)
+    onProgress?: (percent: number) => void;
     // Default: json
-    encoding?: 'json' | 'multipart'
-}
+    encoding?: 'json' | 'multipart';
+};
 
-export type TPostData = TPostDataWithFile
+export type TPostData = TPostDataWithFile;
 
-export type TPostDataWithFile = { [key: string]: PrimitiveValue }
+export type TPostDataWithFile = { [key: string]: PrimitiveValue };
 
-export type TPostDataWithoutFile = { [key: string]: PrimitiveValue }
-
-// https://stackoverflow.com/questions/44851268/typescript-how-to-extract-the-generic-parameter-from-a-type
-type TypeWithGeneric<T> = TFetcher<T>
-type extractGeneric<Type> = Type extends TypeWithGeneric<infer X> ? X : never
+export type TPostDataWithoutFile = { [key: string]: PrimitiveValue };
 
 export type TDataReturnedByFetchers<TProvidedData extends TFetcherList = {}> = {
-    [Property in keyof TProvidedData]: ThenArg< TProvidedData[Property] >
-}
+    [Property in keyof TProvidedData]: ThenArg<TProvidedData[Property]>;
+};
 
 /*----------------------------------
 - CLASS
 ----------------------------------*/
 export default abstract class ApiClient {
-
     /*----------------------------------
     - TOP LEVEL
     ----------------------------------*/
 
-    public abstract set( newData: TObjetDonnees );
+    public abstract set(newData: TObjetDonnees): void;
 
-    public abstract reload( ids?: string | string[], params?: TObjetDonnees );
+    public abstract reload(ids?: string | string[], params?: TObjetDonnees): void;
 
     /*----------------------------------
     - LOW LEVEL
@@ -74,4 +68,4 @@ export default abstract class ApiClient {
     public abstract createFetcher<TData extends unknown = unknown>(...args: TFetcherArgs): TFetcher<TData>;
 
     public abstract fetchSync(fetchers: TFetcherList, alreadyLoadedData: {}): Promise<TObjetDonnees>;
-}
+}