proteum 1.0.0-1

package/common/data/stats.ts

@@ -0,0 +1,90 @@
+import hInterval from 'human-interval';
+
+type TObjDonneesStats = { [cheminStats: string]: number }
+export type TStat<TDonnees extends TObjDonneesStats> = { date: string } & TDonnees
+export type TTimeStat<TDonnees extends TObjDonneesStats> = { time: number } & TDonnees
+
+/*----------------------------------
+- OUTILS DE TRAITEMENT
+----------------------------------*/
+type TRetourStats<TDonnees extends TObjDonneesStats> = {
+    graph: TTimeStat<TDonnees>[],
+    total: TDonnees,
+
+    start: Date,
+    end: Date,
+    interval: number,
+}
+
+export const buildStats = <TDonnees extends TObjDonneesStats>(
+    periodStr: string,
+    intervalStr: string,
+    data: TStat<TDonnees>[]
+): TRetourStats<TDonnees> => {
+
+    // NOTE: On ne génère pas le timestamp via la bdd pour éviter les incohérences de timezone
+
+    if (!Array.isArray(data)) {
+        console.log('data =', data);
+        throw new Error(`Stats data must be an array (received ${typeof data}). See console for full provided data.`);
+    }
+
+    const periodTime = hInterval(periodStr);
+    if (periodTime === undefined) throw new Error(`Invalid period string`);
+    const intervalTime = hInterval(intervalStr);
+    if (intervalTime === undefined) throw new Error(`Invalid interval string`);
+
+    let start = Date.now() - periodTime
+    start -= start % intervalTime; // Round start date to the specified interval
+    const end = Date.now()
+
+    const total: TDonnees = {} as TDonnees
+    let graph: TTimeStat<TDonnees>[] = []
+    if (data.length > 0) {
+
+        // Group data by time
+        const groups: { [timestamp: number]: TTimeStat<TDonnees> } = {};
+        for (const { date, ...stats } of data) {
+
+            if (date === undefined)
+                throw new Error(`La date est absente des données statistiques. Est-elle bien spécifiée dans le SELECT ?`);
+
+            const timeA = new Date(date).getTime();
+            groups[timeA] = { time: timeA, ...stats };
+        }
+
+        // Completion
+        for (let timeA = start; timeA <= end; timeA += intervalTime) {
+
+            const stats = { time: timeA, ...total }
+
+            if (groups[timeA] !== undefined)
+                for (const nom in groups[timeA]) {
+
+                    // numeric value only
+                    if (typeof groups[timeA][nom] !== 'number')
+                        continue;
+
+                    // Add cumulated value
+                    stats[nom] = stats[nom] === undefined
+                        ? groups[timeA][nom]
+                        : stats[nom] + groups[timeA][nom];
+
+                    total[nom] = stats[nom];
+
+                }
+
+            graph.push(stats);
+
+        }
+    }
+
+    return { 
+        graph, 
+        total, 
+        start: new Date(start), 
+        end: new Date(end),
+        interval: intervalTime
+    };
+
+}

package/common/errors/index.tsx

@@ -0,0 +1,326 @@
+import React from 'react';
+import type { ComponentChild } from 'preact';
+
+import type { TJsonLog } from '@server/app/container/console';
+import type ServerRequest from '@server/services/router/request';
+import type { TBasicUser } from '@server/services/auth';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TListeErreursSaisie<TClesDonnees extends string = string> = {[champ in TClesDonnees]: string[]}
+
+export type TJsonError = {
+    code: number,
+    origin?: string,
+    message: string,
+    // Form fields
+    errors?: TListeErreursSaisie
+} & TErrorDetails
+
+type TErrorDetails = {
+
+    // Allow to identify the error catched (ex: displaying custop content, running custom actions, ...)
+    id?: string,
+    data?: {},
+
+    cta?: {
+        label: string,
+        link: string,
+    },
+
+    // For debugging
+    stack?: string,
+    origin?: string,
+}
+
+/*----------------------------------
+- TYPES: AUTH REQUIRED FEATURE
+----------------------------------*/
+
+/**
+ * Global, augmentable feature catalog used to constrain the `feature` argument
+ * of `AuthRequired`.
+ *
+ * Default behavior (no augmentation): `feature` stays a free-form string.
+ * App behavior (augmentation provided by the host app): `feature` becomes a
+ * curated union of feature keys.
+ */
+declare global {
+    interface TAuthRequiredFeatureCatalog {}
+}
+
+type TAuthRequiredFeatureKey = Extract<keyof TAuthRequiredFeatureCatalog, string>;
+type TAuthRequiredFeature = [TAuthRequiredFeatureKey] extends [never]
+    ? string
+    : TAuthRequiredFeatureKey;
+
+/*----------------------------------
+- TYPES: BUG REPORT
+----------------------------------*/
+
+export type ServerBug = {
+
+    // Context
+    hash: string,
+    isDuplicate: boolean,
+    date: Date, // Timestamp
+    channelType?: string, 
+    channelId?: string,
+
+    // User
+    user?: TBasicUser | null,
+    ip?: string | null,
+
+    // Request
+    request?: {
+        method: ServerRequest["method"],
+        url: ServerRequest["url"],
+        data: ServerRequest["data"],
+        validatedData: ServerRequest["validatedData"],
+        headers: ServerRequest["headers"],
+        cookies: ServerRequest["cookies"],
+    },
+    
+    // Error
+    title?: string,
+    stacktraces: string[],
+    context: object[],
+}
+
+export type TCatchedError = Error | CoreError | Anomaly;
+
+/*----------------------------------
+- ERREURS
+----------------------------------*/
+export abstract class CoreError extends Error {
+    
+    public static msgDefaut: string;
+
+    public abstract http: number;
+    public title: string = "Uh Oh ...";
+    public message: string;
+    public details: TErrorDetails = {};
+
+    // Note: On ne le redéfini pas ici, car déjà présent dans Error
+    //      La redéfinition reset la valeur du stacktrace
+    //public stack?: string;
+
+    public constructor(message?: string, details?: TErrorDetails) {
+
+        super(message);
+
+        this.message = message || (this.constructor as typeof CoreError).msgDefaut;
+        this.details = details || {}; 
+
+        // Inject stack
+        if (details !== undefined)
+            this.stack = details.stack;
+
+    }
+
+    public json(): TJsonError {
+
+        return {
+            code: this.http,
+            message: this.message,
+            ...this.details
+        }
+    }
+
+    public toString() {
+        return this.message;
+    }
+
+    public render?(): ComponentChild;
+}
+
+export class InputError extends CoreError {
+    public http = 400;
+    public title = "Bad Request";
+    public static msgDefaut = "Bad Request.";
+}
+
+export class InputErrorSchema extends CoreError {
+
+    public http = 400;
+    public title = "Bad Request";
+    public static msgDefaut = "Bad Request.";
+
+    private static listeToString(liste: TListeErreursSaisie) {
+        let chaines: string[] = []
+        for (const champ in liste)
+            chaines.push(champ + ': ' + liste[champ].join('. '));
+        return chaines.join('; ');
+    }
+
+    public constructor( public errors: TListeErreursSaisie, details?: TErrorDetails) {
+
+        super( InputErrorSchema.listeToString(errors), details );
+
+    }
+
+    public json(): TJsonError {
+        return {
+            ...super.json(),
+            errors: this.errors,
+        }
+    }
+
+    public render(): ComponentChild {
+        return (
+            <ul class="col al-left">
+                {Object.keys(this.errors).map( champ => (
+                    <li>{champ}: {this.errors[champ].join('. ')}</li>
+                ))}
+            </ul>
+        )
+    }
+}
+
+export class AuthRequired extends CoreError {
+    public http = 401;
+    public title = "Authentication Required";
+    public static msgDefaut = "Please Login to Continue.";
+
+    public constructor(message: string, feature?: TAuthRequiredFeature);
+    public constructor(message: string, motivation: string | undefined, details: TErrorDetails | undefined);
+    public constructor( 
+        message: string, 
+        public feature?: string,
+        details?: TErrorDetails
+    ) {
+        super(message, details);
+    }
+
+    public json(): TJsonError & { feature?: string } {
+        return {
+            ...super.json(),
+            feature: this.feature,
+        }
+    }
+}
+
+export class UpgradeRequired extends CoreError {
+    public http = 402;
+    public title = "Upgrade Required";
+    public static msgDefaut = "Please Upgrade to Continue.";
+
+    public constructor( 
+        message: string, 
+        public feature: string,
+        details?: TErrorDetails
+    ) {
+        super(message, details);
+    }
+
+    public json(): TJsonError & { feature: string } {
+        return {
+            ...super.json(),
+            feature: this.feature,
+        }
+    }
+}
+
+export class Forbidden extends CoreError {
+    public http = 403;
+    public title = "Access Denied";
+    public static msgDefaut = "You do not have sufficient permissions to access this content.";
+}
+
+export class NotFound extends CoreError {
+    public http = 404;
+    public title = "Not Found";
+    public static msgDefaut = "The resource you asked for was not found.";
+}
+
+export class Gone extends CoreError {
+    public http = 410;
+    public title = "Gone";
+    public static msgDefaut = "The resource you asked for has been removed.";
+}
+
+export class RateLimit extends CoreError {
+    public http = 429;
+    public title = "You're going too fast";
+    public static msgDefaut = "Please slow down a bit and retry again later.";
+}
+
+export class Anomaly extends CoreError {
+
+    public http = 500;
+    public title = "Technical Error";
+    public static msgDefaut = "A technical error has occurred. A notification has just been sent to the admin.";
+
+    public constructor( 
+        message: string, 
+        public dataForDebugging?: object,
+        public originalError?: Error, 
+    ) {
+        super(message);
+    }
+}
+
+export class NotAvailable extends CoreError {
+
+    // TODO: page erreur pour code 503
+    public http = 404;
+    public title = "Not Available";
+    public static msgDefaut = "Sorry, the service is currently not available.";
+}
+
+export class NetworkError extends Error {
+    public title = "Network Error";
+}
+
+
+export const viaHttpCode = (
+    code: number, 
+    message: string, 
+    details?: TErrorDetails
+): CoreError => {
+    return fromJson({
+        code,
+        message,
+        ...details
+    });
+}
+
+export const toJson = (e: Error | CoreError): TJsonError => {
+
+    if (('json' in e) && typeof e.json === 'function')
+        return e.json();
+
+    const details = ('details' in e) 
+        ? e.details
+        : { stack: e.stack };
+
+    return { code: 500, message: e.message, ...details }
+}
+
+export const fromJson = ({ code, message, ...details }: TJsonError) => {
+
+    switch (code) {
+        case 400: 
+            if (details.errors)
+                return new InputErrorSchema( details.errors, details );
+            else
+                return new InputError( message, details );
+
+        case 401: return new AuthRequired( message, (details as any).feature, details );
+
+        case 402: return new UpgradeRequired( message, details.feature, details );
+
+        case 403: return new Forbidden( message, details );
+
+        case 404: return new NotFound( message, details );
+
+        case 429: return new RateLimit( message, details );
+
+        default: return new Anomaly( message, details );
+    }
+
+}
+
+export default CoreError;

package/common/router/index.ts

@@ -0,0 +1,213 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+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 RouterRequest from './request';
+
+import type { TUserRole } from '@server/services/auth';
+
+import type { TAppArrowFunction } from '@common/app';
+
+// Specfic
+import type { default as Page, TFrontRenderer, TDataProvider } from './response/page';
+
+/*----------------------------------
+- TYPES: ROUTES
+----------------------------------*/
+
+export type { Layout } from './layouts';
+
+export type { default as Request } from './request';
+export type { default as Response } from './response';
+
+export type ClientOrServerRouter = ClientRouter | TAnyRouter;
+
+export type TRoute<RouterContext extends TClientOrServerContextForPage = TClientOrServerContextForPage> = {
+
+    // Match
+    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,
+    }
+)
+
+export type TErrorRoute<RouterContext extends TClientOrServerContextForPage = TClientOrServerContextForPage> = {
+    code,
+    controller: TRouteController<RouterContext>,
+    options: TRouteOptions
+}
+
+export type TAnyRoute<RouterContext extends TClientOrServerContextForPage = TClientOrServerContextForPage> =
+    TRoute<RouterContext> | TErrorRoute<RouterContext>
+
+// ClientRouterContext already includes server context
+export type TClientOrServerContext = ClientRouterContext;// | ServerRouterContext;
+
+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 TRouteOptions = {
+
+    // Injected by the page plugin
+    filepath?: string,
+    data?: TDataProvider
+
+    // Indexing
+    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
+
+    // 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
+
+    // To cleanup
+    TESTING?: boolean,
+    logging?: boolean,
+}
+
+export type TRouteModule<TRegisteredRoute = any> = { 
+    // exporing __register is a way to know we axport a TAppArrowFunction
+    __register?: TAppArrowFunction<TRegisteredRoute> 
+}
+
+export type TDomainsList = {
+    [endpointId: string]: string
+} & {
+    current: string
+}
+
+export const defaultOptions = {
+    priority: 0,
+}
+
+/*----------------------------------
+- FUNCTIONS
+----------------------------------*/
+export const buildUrl = (
+    path: string,
+    params: {[key: string]: any},
+    domains: {[alias: string]: string},
+    absolute: boolean
+) => {
+
+    let prefix: string = '';
+
+    // Relative to domain
+    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;
+        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);
+
+        // Return full url
+        prefix = domain;
+
+    // Absolute URL
+    }
+
+    // Path parapeters
+    const searchParams = new URLSearchParams();
+    for (const key in params) {
+
+        // Exclude undefined of empty
+        if (!params[key])
+            continue;
+        // Path placeholder
+        else if (path.includes(':' + key))
+            path = path.replace(':' + key, params[key]);
+        // Query string
+        else 
+            searchParams.set(key, params[key]);
+    }
+
+    // Return final url
+    return prefix + path + (searchParams.toString() ? '?' + searchParams.toString() : '');
+}
+
+export const matchRoute = (route: TRoute, request: RouterRequest) => {
+
+    // Match Path
+    const match = route.regex.exec(request.path);
+    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') );
+    }
+
+    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 }>);
+
+}