5htp-core 0.6.0 → 0.6.1

package/server/app/container/console/index.ts

@@ -17,7 +17,7 @@ import Ansi2Html from 'ansi-to-html';
 // Core libs
 import type ApplicationContainer from '..';
 import context from '@server/context';
-import type { ServerBug, Anomaly, CoreError } from '@common/errors';
+import type { ServerBug, TCatchedError, CoreError } from '@common/errors';
 import type ServerRequest from '@server/services/router/request';
 import { SqlError } from '@server/services/database/debug';
 
@@ -49,6 +49,11 @@ export type Services = {
 export type ChannelInfos = {
     channelType: 'cron' | 'master' | 'request' | 'socket',
     channelId?: string,
+
+    method?: string,
+    path?: string,
+
+    user?: string
 }
 
 export type TGuestLogs = {
@@ -99,8 +104,6 @@ export type TJsonLog = {
 
 const LogPrefix = '[console]'
 
-const errorMailInterval = (1 * 60 * 60 * 1000); // 1 hour
-
 const logLevels = {
     'log': 0, 
     'info': 3, 
@@ -144,13 +147,6 @@ export default class Console {
     public logger!: Logger<ILogObj>;
     // Buffers
     public logs: TJsonLog[] = [];
-    // Bug ID => Timestamp latest send
-    private sentBugs: {[bugId: string]: number} = {};
-
-    // Old (still useful???)
-    /*public clients: TGuestLogs[] = [];
-    public requests: TRequestLogs[] = [];
-    public sqlQueries: TDbQueryLog[] = [];*/
 
     /*----------------------------------
     - LIFECYCLE
@@ -283,10 +279,9 @@ export default class Console {
             this.logs = this.logs.slice(bufferOverflow);
     }
 
-    public async createBugReport( error: Error | CoreError | Anomaly, request?: ServerRequest ) {
+    // We don't prevent duplicates because we want to receive all variants of the same error
+    public async createBugReport( error: TCatchedError, request?: ServerRequest ) {
 
-        // Print error
-        this.logger.error(LogPrefix, `Sending bug report for the following error:`, error);
         /*const youchRes = new Youch(error, {});
         const jsonResponse = await youchRes.toJSON()
         console.log( forTerminal(jsonResponse, {
@@ -313,28 +308,6 @@ export default class Console {
         if (application === undefined) 
             return console.error(LogPrefix, "Can't send bug report because the application is not instanciated");
 
-        // Print the error so it's accessible via logs
-        if (error instanceof SqlError)  {
-            let printedQuery: string;
-            try {
-                printedQuery = this.printSql( error.query );
-            } catch (error) {
-                printedQuery = 'Failed to print query:' + (error || 'unknown error');
-            }
-            console.error(`Error caused by this query:`, printedQuery);
-        }
-
-        if (('dataForDebugging' in error) && error.dataForDebugging !== undefined)
-            console.error(LogPrefix, `More data about the error:`, error.dataForDebugging);
-
-        // Prevent spamming the mailbox if infinite loop 
-        const bugId = ['server', request?.user?.name, undefined, error.message].filter(e => !!e).join('::');
-        const lastSending = this.sentBugs[bugId];
-        this.sentBugs[bugId] = Date.now();
-        const shouldSendReport = lastSending === undefined || lastSending < Date.now() - errorMailInterval;
-        if (!shouldSendReport)
-            return;
-
         // Get context
         const now = new Date();
         const hash = uuid();
@@ -342,7 +315,43 @@ export default class Console {
 
         // On envoi l'email avant l'insertion dans bla bdd
         // Car cette denrière a plus de chances de provoquer une erreur
-        const logs = this.logs.filter(e => e.channel.channelId === channelId).slice(-100);
+        //const logs = this.logs.filter(e => e.channel.channelId === channelId).slice(-100);
+        const stacktraces: string[] = [];
+        const context: object[] = [];
+
+        let currentError: TCatchedError | undefined = error;
+        let title: string | undefined;
+        while (currentError !== undefined) {
+
+            if (title === undefined)
+                title = currentError.message;
+
+            // Stacktrace
+            this.logger.error(LogPrefix, `Sending bug report for the following error:`, currentError);
+            stacktraces.push(currentError.stack || currentError.message);
+
+            // Context
+            if (('dataForDebugging' in currentError) && currentError.dataForDebugging !== undefined) {
+                console.error(LogPrefix, `More data about the error:`, currentError.dataForDebugging);
+                context.push(currentError.dataForDebugging || {});
+            }
+
+            // Print the error so it's accessible via logs
+            if (currentError instanceof SqlError)  {
+                let printedQuery: string;
+                try {
+                    printedQuery = this.printSql( currentError.query );
+                } catch (error) {
+                    printedQuery = 'Failed to print query:' + (error || 'unknown error');
+                }
+                console.error(`Error caused by this query:`, printedQuery);
+            }
+
+            // Go deeper
+            currentError = 'originalError' in currentError 
+                ? currentError.originalError
+                : undefined
+        }
 
         const bugReport: ServerBug = {
 
@@ -371,9 +380,9 @@ export default class Console {
             } : {}),
 
             // Error
-            error,
-            stacktrace: error.stack || error.message,
-            logs
+            title,
+            stacktraces,
+            context
         }
 
         await application.runHook('bug', bugReport);
@@ -391,12 +400,23 @@ export default class Console {
     ----------------------------------*/
 
     public bugToHtml( report: ServerBug ) {
+
         return `
 <b>Channel</b>: ${report.channelType} (${report.channelId})<br />
 <b>User</b>: ${report.user ? (report.user.name + ' (' + report.user.email + ')') : 'Unknown'}<br />
 <b>IP</b>: ${report.ip}<br />
-<b>Error</b>: ${report.error.message}<br />
-${this.printHtml(report.stacktrace)}<br />
+
+${report.stacktraces.map((stacktrace, index) => `
+    <hr />
+    <b>Error ${index + 1}</b>:
+    ${this.printHtml(stacktrace)}<br />
+`).join('')}
+
+${report.context.map((context, index) => `
+    <hr />
+    <b>Context ${index + 1}</b>: ${this.jsonToHTML(context)}<br />
+`).join('')}
+
 ${report.request ? `
     <hr />
     <b>Request</b>: ${report.request.method} ${report.request.url}<br />
@@ -432,7 +452,7 @@ Logs: ${this.config.enable ? `<br/>` + this.logsToHTML(report.logs) : 'Logs coll
         });
 
         // Print args as ANSI
-        const logArgsAndErrorsMarkup = this.logger.runtime.prettyFormatLogObj(log.args, this.logger.settings);
+        const logArgsAndErrorsMarkup = this.logger["runtime"].prettyFormatLogObj(log.args, this.logger.settings);
         const logErrors = logArgsAndErrorsMarkup.errors;
         const logArgs = logArgsAndErrorsMarkup.args;
         const logErrorsStr = (logErrors.length > 0 && logArgs.length > 0 ? "\n" : "") + logErrors.join("\n");

package/server/app/container/index.ts

@@ -2,6 +2,10 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Set timezone
+process.env.TZ = 'UTC';
+import 'source-map-support/register';
+
 // Npm
 import path from 'path';
 

package/server/app/service/index.ts

@@ -42,7 +42,7 @@ export type StartedServicesIndex = {
 
 export type TServiceArgs<TService extends AnyService> = [
     parent: AnyService | 'self',
-    getConfig: (instance: TService) => {},
+    getConfig: null | undefined | ((instance: TService) => {}),
     app: TService['app'] | 'self'
 ]
 
@@ -94,7 +94,8 @@ export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
 export default abstract class Service<
     TConfig extends {}, 
     THooks extends THooksList,
-    TApplication extends Application
+    TApplication extends Application,
+    TParent extends AnyService | Application = Application
 > {
 
     public started?: Promise<void>;
@@ -104,6 +105,7 @@ export default abstract class Service<
     public metas!: TServiceMetas;
     public bindings: string[] = []
 
+    public parent: TParent;
     public app: TApplication;
     public config: TConfig = {} as TConfig;
 

package/server/services/auth/index.ts

@@ -41,7 +41,7 @@ export type TConfig = {
     jwt: {
         // 2048 bits
         key: string,
-        expiration: string,
+        expiration: number,
     },
 }
 
@@ -173,7 +173,9 @@ export default abstract class AuthService<
 
         this.config.debug && console.info(LogPrefix, `Generated JWT token for session:` + token);
 
-        request.res.cookie('authorization', token);
+        request.res.cookie('authorization', token, {
+            maxAge: this.config.jwt.expiration,
+        });
 
         return token;
     }
@@ -187,13 +189,30 @@ export default abstract class AuthService<
         request.res.clearCookie('authorization');
     }
 
-    public check( request: TRequest, entity: string, role: TUserRole): TUser;
-    public check( request: TRequest, entity: string, role: false): null;
-    public check( request: TRequest, entity: string, role: TUserRole | false = 'USER'): TUser | null {
+    public check( 
+        request: TRequest, 
+        role: TUserRole, 
+        motivation?: string, 
+        dataForDebug?: { [key: string]: any }
+    ): TUser;
+
+    public check( 
+        request: TRequest, 
+        role: false, 
+        motivation?: string, 
+        dataForDebug?: { [key: string]: any }
+    ): null;
+
+    public check( 
+        request: TRequest, 
+        role: TUserRole | false = 'USER', 
+        motivation?: string, 
+        dataForDebug?: { [key: string]: any }
+    ): TUser | null {
 
         const user = request.user;
 
-        this.config.debug && console.warn(LogPrefix, `Check auth, role = ${role}. Current user =`, user?.name);
+        this.config.debug && console.warn(LogPrefix, `Check auth, role = ${role}. Current user =`, user?.name, motivation);
 
         if (user === undefined) {
 
@@ -208,23 +227,18 @@ export default abstract class AuthService<
         } else if (user === null) {
 
             this.config.debug && console.warn(LogPrefix, "Refusé pour anonyme (" + request.ip + ")");
-            throw new AuthRequired('Please login to continue');
-
-        } else if (user.type !== entity) {
-
-            this.config.debug && console.warn(LogPrefix, `User type mismatch: ${user.type} (user) vs ${entity} (expected) (${request.ip})`);
-            throw new AuthRequired("Your account type doesn't have access to the requested content.");
+            throw new AuthRequired('Please login to continue', motivation, dataForDebug);
             
         // Insufficient permissions
         } else if (!user.roles.includes(role)) {
 
-            console.warn(LogPrefix, "Refusé: " + role + " pour " + user.name + " (" + (user.roles || 'role inconnu') + ")");
+            this.config.debug && console.warn(LogPrefix, "Refusé: " + role + " pour " + user.name + " (" + (user.roles || 'role inconnu') + ")");
 
             throw new Forbidden("You do not have sufficient permissions to access this resource.");
 
         } else {
 
-            console.warn(LogPrefix, "Autorisé " + role + " pour " + user.name + " (" + user.roles + ")");
+            this.config.debug && console.warn(LogPrefix, "Autorisé " + role + " pour " + user.name + " (" + user.roles + ")");
 
         }
 

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

@@ -66,7 +66,7 @@ export default class AuthenticationRouterService<
             if (route.options.auth !== undefined) {
 
                 // Basic auth check
-                this.users.check(request, 'User', route.options.auth);
+                this.users.check(request, route.options.auth);
 
                 // Redirect to logged page
                 if (route.options.auth === false && request.user && route.options.redirectLogged)

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

@@ -45,9 +45,9 @@ export default class UsersRequestService<
     }
 
     // TODO: return user type according to entity
-    public check( entity: string, role: TUserRole, motivation?: string): TUser;
-    public check( entity: string, role: false, motivation?: string): null;
-    public check( entity: string, role: TUserRole | boolean = 'USER', motivation?: string): TUser | null {
-        return this.users.check( this.request, entity, role, motivation );
+    public check(role: TUserRole, motivation?: string, dataForDebug?: {}): TUser;
+    public check(role: false, motivation?: string, dataForDebug?: {}): null;
+    public check(role: TUserRole | boolean = 'USER', motivation?: string, dataForDebug?: {}): TUser | null {
+        return this.users.check( this.request, role, motivation, dataForDebug );
     }
 }

package/server/services/email/index.ts

@@ -2,10 +2,6 @@
 - DEPENDANCES
 ----------------------------------*/
 
-/* NOTE: On évite d'utiliser les alias ici,
-        Afin que l'envoi des rapports de bug fonctionne même en cas d'erreur avec les alias
-*/
-
 // Core
 import type { Application } from '@server/app';
 import Service from '@server/app/service';
@@ -13,7 +9,6 @@ import markdown from '@common/data/markdown';
 
 // Speciic
 import { jsonToHtml } from './utils';
-import type { Transporter } from './transporter';
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -25,16 +20,12 @@ export type Config = {
     debug: boolean,
     simulateWhenLocal: boolean,
     default: {
-        transporter: string,
         from: TPerson
     },
     bugReport: {
         from: TPerson,
         to: TPerson
     },
-    transporters: {
-        [transporterId: string]: Transporter
-    }
 }
 
 export type Hooks = {
@@ -49,9 +40,7 @@ export type Services = {
 - TYPES: EMAILS
 ----------------------------------*/
 
-export { Transporter } from './transporter';
-
-export type TEmail = THtmlEmail | TMarkdownEmail// | TTemplateEmail;
+export type TEmail = THtmlEmail | TMarkdownEmail;
 
 type TPerson = {
     name?: string,
@@ -74,11 +63,6 @@ export type TMarkdownEmail = TBaseEmail & {
     markdown: string,
 }
 
-/*export type TTemplateEmail = TBaseEmail & {
-    template: keyof typeof templates,
-    data?: TObjetDonnees
-}*/
-
 export type TCompleteEmail = With<THtmlEmail, {
     to: TPerson[],
     from: TPerson,
@@ -109,14 +93,15 @@ type TOptions = {
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export default class Email extends Service<Config, Hooks, Application> {
-    
-    private transporters = this.config.transporters;
+export default abstract class Email<TConfig extends Config> 
+    extends Service<TConfig, Hooks, Application> {
 
     /*----------------------------------
     - ACTIONS
     ----------------------------------*/
 
+    protected abstract sendNow( emails: TCompleteEmail[] ): Promise<void>;
+
     public async send( to: string, subject: string, markdown: string, options?: TOptions );
     public async send( emails: TEmail | TEmail[], options?: TOptions ): Promise<void>;
     public async send( ...args: TEmailSendArgs ): Promise<void> {
@@ -162,30 +147,7 @@ export default class Email extends Service<Config, Hooks, Application> {
                 ? email.to
                 : [email.to];
 
-            // Via template
-            // TODO: Restore templates feature
-            /*if ('template' in email) {
-
-                const template = templates[email.template];
-
-                if (template === undefined)
-                    throw new Error(`Impossible de charger la template email ${email.template} depuis le cache (NotFound).`);
-
-                const txt = template(email.data || {})
-
-                const delimTitre = txt.indexOf('\n\n');
-
-                return {
-                    ...email,
-                    // Vire le "> " au début
-                    subject: txt.substring(2, delimTitre),
-                    html: htmlWarning + txt.substring(delimTitre + 2),
-                    from,
-                    to,
-                    cc
-                }
-
-            } else */if ('markdown' in email) {
+            if ('markdown' in email) {
 
                 return {
                     ...email,
@@ -209,11 +171,7 @@ export default class Email extends Service<Config, Hooks, Application> {
             
         });
 
-        const transporterName = options.transporter || this.config.default.transporter;
-        if (transporterName === undefined)
-            throw new Error(`Please define at least one mail transporter.`);
-
-        console.info(LogPrefix, `Sending ${emailsToSend.length} emails via transporter "${transporterName}"`, emailsToSend[0].subject);
+        console.info(LogPrefix, `Sending ${emailsToSend.length} emails via transporter`, emailsToSend[0].subject);
 
         // Pas d'envoi d'email quand local
         if (this.app.env.name === 'local' && this.config.simulateWhenLocal === true) {
@@ -224,8 +182,7 @@ export default class Email extends Service<Config, Hooks, Application> {
             return;
         }
 
-        const transporter = this.transporters[ transporterName ];
-        await transporter.send(emailsToSend);
+        await this.sendNow(emailsToSend);
 
     }
 }

package/server/services/prisma/Facet.ts

@@ -0,0 +1,118 @@
+import type { Prisma, PrismaClient } from '@models/types';
+import * as runtime from '@/var/prisma/runtime/library.js';
+
+export type TWithStats = {
+    $table: string,
+    $key: string
+} & {
+    [key: string]: string // key => SQL
+}
+
+export type TSubset = (...a: any[]) => Prisma.ProspectContactLeadFindFirstArgs & {
+    withStats?: TWithStats
+}
+
+export default class Facet<
+    D extends {
+        findMany(args?: any): Promise<any>
+        findFirst(args?: any): Promise<any>
+    },
+    S extends TSubset,
+    R
+> {
+    constructor(
+
+        private readonly prisma: PrismaClient,
+
+        private readonly delegate: D,
+        private readonly subset: S,
+
+        /* the **ONLY** line that changed ↓↓↓ */
+        private readonly transform?: (
+            row: runtime.Types.Result.GetResult<
+                Prisma.$ProspectContactLeadPayload,
+                ReturnType<S>,
+                'findMany'
+            >[number]
+        ) => R,
+    ) { }
+
+    public async findMany(
+        ...args: Parameters<S>
+    ): Promise<R[]> {
+
+        const { withStats, ...subset } = this.subset(...args);
+
+        const results = await this.delegate.findMany(subset);
+
+        // Load stats
+        const stats = withStats 
+            ? await this.fetchStats( withStats, results )
+            : [];
+
+        return results.map(row => this.transformResult(row, stats, withStats));
+    }
+
+    public async findFirst(
+        ...args: Parameters<S>
+    ): Promise<R | null> {
+
+        const { withStats, ...subset } = this.subset(...args);
+
+        const result = await this.delegate.findFirst(subset);
+
+        const stats = withStats 
+            ? await this.fetchStats( withStats, [result] )
+            : [];
+
+        return result ? this.transformResult(result, stats, withStats) : null;
+    }
+
+    private async fetchStats(
+        { $table, $key, ...withStats }: TWithStats,
+        results: any[]
+    ): Promise<any[]> {
+
+        const select = Object.entries(withStats).map(([key, sql]) =>    
+            `(COALESCE((
+                ${sql}
+            ), 0)) as ${key}`
+        );
+
+        const stats = await this.prisma.$queryRawUnsafe(`
+            SELECT ${$key}, ${select.join(', ')} 
+            FROM ${$table} 
+            WHERE ${$key} IN (
+                ${results.map(r => "'" + r[ $key ] + "'").join(',')}
+            )
+        `);
+
+        for (const stat of stats) {
+            for (const key in stat) {
+    
+                if (key === $key)
+                    continue;
+    
+                stat[key] = stat[key] ? parseInt(stat[key]) : 0;
+            }
+        }
+
+        return stats;
+    }
+
+    private transformResult( result: any, stats: any[], withStats?: TWithStats ) {
+
+        // Transform stats
+        const resultStats = withStats
+            ? stats.find(stat => stat[withStats.$key] === result[withStats.$key]) || {}
+            : {};
+
+        if (this.transform)
+            result = this.transform(result);
+
+        return {
+            ...result,
+            ...resultStats
+        }
+    }
+}

package/server/services/prisma/index.ts

@@ -9,6 +9,9 @@ import { PrismaClient } from '@/var/prisma';
 import type { Application } from '@server/app';
 import Service from '@server/app/service';
 
+// Specific
+import Facet, { TSubset } from './Facet';
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -37,10 +40,31 @@ export type Services = {
 export default class ModelsManager extends Service<Config, Hooks, Application> {
 
     public client = new PrismaClient();
+
+    public async ready() {
+
+        await this.client.$executeRaw`SET time_zone = '+00:00'`;
+
+    }
   
     public async shutdown() {
         await this.client.$disconnect()
     }
 
+    public Facet<
+        D extends {
+            findMany(args?: any): Promise<any>
+            findFirst(args?: any): Promise<any>
+        },
+        S extends TSubset,
+        R
+    >(...args: [D, S, R]) {
+
+        return new Facet(
+            this.client,
+            ...args
+        );
+    }
+
    
 }

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

@@ -144,8 +144,6 @@ export default class HttpServer {
 
         routes.get("/ping", (req, res) => res.send("pong"));
 
-        routes.all('*', morgan('short'));
-
         /*----------------------------------
         - SESSION & SECURITE
         ----------------------------------*/