5htp-core 0.1.2 → 0.2.0

package/src/server/services/database/stats.ts

@@ -2,12 +2,13 @@
 - OUTILS DE TRAITEMENT
 ----------------------------------*/
 
-// nPM
+// Npm
 import hInterval from 'human-interval';
 
-// Cor elibs
-import { $ } from '@server/app';
-import Cache from '@server/data/Cache';
+// Core
+import Service from '@server/app/service';
+import type CacheService from '../cache';
+import type SQL from '../database';
 
 /*----------------------------------
 - CONST
@@ -41,6 +42,11 @@ const debug = false;
 /*----------------------------------
 - TYPES
 ----------------------------------*/
+
+type TStatsServiceConfig = {
+
+}
+
 type TObjDonneesStats = { [cheminStats: string]: number }
 export type TStat<TDonnees extends TObjDonneesStats> = { date: string } & TDonnees
 export type TTimeStat<TDonnees extends TObjDonneesStats> = { time: number } & TDonnees
@@ -55,141 +61,160 @@ type TRetourStats<TDonnees extends TObjDonneesStats> = {
     interval: number,
 }
 
-export default async function fetchStats<TDonnees extends TObjDonneesStats>(
-    
-    table: string, columns: (string | [string, string])[], {
-
-    // Query
-    where,
-    // time
-    period, interval,
-    // Options
-    relative, cache
-    
-}: {
-    // Database
-    where?: string,
-    // Time
-    period: string,
-    interval: string,
-    // Options
-    relative?: boolean,
-    cache?: { id: string, duration?: string },
-}): Promise< TRetourStats<TDonnees> > {
-
-    if (!debug && cache !== undefined) {
-        const fromCache = await Cache.getVal<TRetourStats<TDonnees>>(cache.id);
-        if (fromCache !== null) {
-            console.log("Using value from cache " + cache.id);
-            return fromCache;
-        }
-    }
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class StatsService extends Service<TStatsServiceConfig> {
 
-    // NOTE: On ne génère pas le timestamp via la bdd pour éviter les incohérences de timezone
-    const periodTime = hInterval(period);
-    if (periodTime === undefined) throw new Error(`Invalid period string: ` + period);
-    const intervalTime = hInterval(interval);
-    if (intervalTime === undefined) throw new Error(`Invalid interval string: ` + interval);
-    const periodSec = Math.floor(periodTime / 1000);
-
-    const startTime = scaleTime(Date.now() - periodTime, intervalTime); // Round start date to the specified interval
-    const endTime = scaleTime(Date.now(), intervalTime);
-    const stats: TRetourStats<TDonnees> = {
-        graph: [],
-        stats: {} as TDonnees,
-        start: new Date(startTime),
-        end: new Date(endTime),
-        interval: intervalTime
-    }
+    public constructor(
+        config: TStatsServiceConfig,
+        private cache: CacheService,
+        private sql: SQL
+    ) {
 
-    let rows: TDonnees[];
-    let previousRow: TObjetDonnees = {};
-    
-    const selector = statsCols(columns, relative ? 'SUM' : '');
-
-    // Fetch data (initial point + variations)
-    // Since values are relative, we will use stats.total as initialValues, 
-    //      and then increment it to get the latest tota value
-    ([[previousRow], rows] = await $.sql.query(`
-
-        # Latest values before start time
-        SELECT ${selector}
-        FROM ${table}
-        WHERE date < (NOW() - INTERVAL ${periodSec} SECOND) ${where ? 'AND ' + where : ''}
-        ORDER BY date DESC 
-        LIMIT 1;
-
-        # First value for each peiod of time
-        SELECT ${selector},
-            FLOOR( UNIX_TIMESTAMP(date) * 1000 / ${intervalTime}) * ${intervalTime} as periodTime
-        FROM ${table}
-        WHERE (date BETWEEN (NOW() - INTERVAL ${periodSec} SECOND) AND NOW())
-            ${where ? 'AND ' + where : ''}
-
-        # In addition of the variations between start and end date, we take the latest values
-        GROUP BY (date = (SELECT MAX(date) FROM core.NetworkStats)), periodTime
-        ORDER BY date DESC;
-
-    `) as [[TDonnees | undefined], TDonnees[]]);
-
-    // Process
-    if (rows.length === 0)
-        return stats;
-    if (previousRow === undefined)
-        previousRow = {};
+        super(config);
 
-    rows.reverse();
+    }
 
-    // Index entries by time
-    const periods: { [periodTime: number]: TTimeStat<TDonnees> } = {};
-    for (const { periodTime, ...row } of rows)
-        periods[periodTime] = row;
+    public async register() {}
+    public async start() {}
 
-    // Completion
-    for (let time = startTime; time <= endTime; time += intervalTime) {
+    public async fetchStats<TDonnees extends TObjDonneesStats>(
+        
+        table: string, columns: (string | [string, string])[], {
+
+        // Query
+        where,
+        // time
+        period, interval,
+        // Options
+        relative, cache
+        
+    }: {
+        // Database
+        where?: string,
+        // Time
+        period: string,
+        interval: string,
+        // Options
+        relative?: boolean,
+        cache?: { id: string, duration?: string },
+    }): Promise< TRetourStats<TDonnees> > {
+
+        if (!debug && cache !== undefined) {
+            const fromCache = await this.cache.get<TRetourStats<TDonnees>>(cache.id);
+            if (fromCache !== null) {
+                console.log("Using value from cache " + cache.id);
+                return fromCache.value;
+            }
+        }
 
-        const row = relative ? { ...previousRow, time } : { time };
-        stats.graph.push(row);
+        // NOTE: On ne génère pas le timestamp via la bdd pour éviter les incohérences de timezone
+        const periodTime = hInterval(period);
+        if (periodTime === undefined) throw new Error(`Invalid period string: ` + period);
+        const intervalTime = hInterval(interval);
+        if (intervalTime === undefined) throw new Error(`Invalid interval string: ` + interval);
+        const periodSec = Math.floor(periodTime / 1000);
+
+        const startTime = scaleTime(Date.now() - periodTime, intervalTime); // Round start date to the specified interval
+        const endTime = scaleTime(Date.now(), intervalTime);
+        const stats: TRetourStats<TDonnees> = {
+            graph: [],
+            stats: {} as TDonnees,
+            start: new Date(startTime),
+            end: new Date(endTime),
+            interval: intervalTime
+        }
 
-        // No data for this period
-        if (periods[time] === undefined)
-            continue;
+        let rows: TDonnees[];
+        let previousRow: TObjetDonnees = {};
         
-        for (const nom in periods[time]) {
+        const selector = statsCols(columns, relative ? 'SUM' : '');
+
+        // Fetch data (initial point + variations)
+        // Since values are relative, we will use stats.total as initialValues, 
+        //      and then increment it to get the latest tota value
+        ([[previousRow], rows] = await this.sql.query(`
+
+            # Latest values before start time
+            SELECT ${selector}
+            FROM ${table}
+            WHERE date < (NOW() - INTERVAL ${periodSec} SECOND) ${where ? 'AND ' + where : ''}
+            ORDER BY date DESC 
+            LIMIT 1;
+
+            # First value for each peiod of time
+            SELECT ${selector},
+                FLOOR( UNIX_TIMESTAMP(date) * 1000 / ${intervalTime}) * ${intervalTime} as periodTime
+            FROM ${table}
+            WHERE (date BETWEEN (NOW() - INTERVAL ${periodSec} SECOND) AND NOW())
+                ${where ? 'AND ' + where : ''}
+
+            # In addition of the variations between start and end date, we take the latest values
+            GROUP BY (date = (SELECT MAX(date) FROM core.NetworkStats)), periodTime
+            ORDER BY date DESC;
+
+        `) as [[TDonnees | undefined], TDonnees[]]);
+
+        // Process
+        if (rows.length === 0)
+            return stats;
+        if (previousRow === undefined)
+            previousRow = {};
+
+        rows.reverse();
+
+        // Index entries by time
+        const periods: { [periodTime: number]: TTimeStat<TDonnees> } = {};
+        for (const { periodTime, ...row } of rows)
+            periods[periodTime] = row;
+
+        // Completion
+        for (let time = startTime; time <= endTime; time += intervalTime) {
+
+            const row = relative ? { ...previousRow, time } : { time };
+            stats.graph.push(row);
+
+            // No data for this period
+            if (periods[time] === undefined)
+                continue;
+            
+            for (const nom in periods[time]) {
 
-            const value = periods[time][nom];
+                const value = periods[time][nom];
 
-            row[nom] = (relative && typeof row[nom] === 'number')
-                ? row[nom] + value
-                : value;
+                row[nom] = (relative && typeof row[nom] === 'number')
+                    ? row[nom] + value
+                    : value;
 
-        }
+            }
 
-        previousRow = { ...row };
-    }
+            previousRow = { ...row };
+        }
 
-    // Total = latest known values
-    stats.stats = previousRow;
-
-    // Check if the times selected from the database matches with the times iéterated from the completion
-    if (debug) {
-        for (const period in periods)
-            if (!stats.graph.find( g => g.time.toString() === period )) {
-                console.warn(
-                    `The timetamps selected from the database do not match with the one generated by the completion function`,
-                    '\nStart date:', startTime, stats.start.toISOString(), ' End date:', endTime, stats.end.toISOString(),
-                    '\nFrom database', Object.keys(periods).map(time => time + ' (' + new Date( parseInt(time) ).toISOString() + ')'),
-                    '\nFrom completion (now - period ; now):', stats.graph.map(g => g.time + ' (' + new Date(g.time).toISOString() + ')')
-                );
-                throw new Error("Integrity check failed.");
+        // Total = latest known values
+        stats.stats = previousRow;
+
+        // Check if the times selected from the database matches with the times iéterated from the completion
+        if (debug) {
+            for (const period in periods)
+                if (!stats.graph.find( g => g.time.toString() === period )) {
+                    console.warn(
+                        `The timetamps selected from the database do not match with the one generated by the completion function`,
+                        '\nStart date:', startTime, stats.start.toISOString(), ' End date:', endTime, stats.end.toISOString(),
+                        '\nFrom database', Object.keys(periods).map(time => time + ' (' + new Date( parseInt(time) ).toISOString() + ')'),
+                        '\nFrom completion (now - period ; now):', stats.graph.map(g => g.time + ' (' + new Date(g.time).toISOString() + ')')
+                    );
+                    throw new Error("Integrity check failed.");
+                    
+                }
                 
-            }
-            
-        console.log(cache?.id, "Cumulative stats: total =", stats.stats, "rows =", rows, "periods =", periods, "stats =", stats);
-    }
+            console.log(cache?.id, "Cumulative stats: total =", stats.stats, "rows =", rows, "periods =", periods, "stats =", stats);
+        }
 
-    if (cache !== undefined)
-        await Cache.set( cache.id, stats, cache.duration || interval );
-    
-    return stats;
+        if (cache !== undefined)
+            await this.cache.set( cache.id, stats, cache.duration || interval );
+        
+        return stats;
+    }
 }

package/src/server/services/email/index.ts

@@ -7,35 +7,38 @@
 */
 
 // Core
-import app, { $ } from '@server/app';
-//import templates from './templates';
-const templates = {} as {[template: string]: (data: any) => string}
+import Application, { Service } from '@server/app';
 import { jsonToHtml } from './utils';
 
+const templates = {} as {[template: string]: (data: any) => string}
+
 /*----------------------------------
 - SERVICE CONFIG
 ----------------------------------*/
 
-export type EmailServiceConfig = {
+export type Config = {
     debug: boolean,
     default: {
         transporter: string,
         from: string
     },
-    transporters: Core.EmailTransporters
+    transporters: Config.EmailTransporters,
+    bugReport: {
+        from: string,
+        to: string
+    }
+}
+
+export type Hooks = {
+
 }
 
 declare global {
-    namespace Core {
+    namespace Config {
         interface EmailTransporters { }
-        namespace Config {
-            interface Services {
-                email: EmailServiceConfig
-            }
-        }
     }
 }
-    
+
 /*----------------------------------
 - TYPES: EMAILS
 ----------------------------------*/
@@ -75,40 +78,25 @@ type TOptions = {
     testing?: boolean
 }
 
-const config = app.config.email;
-
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export default class Email {
+export default class Email extends Service<Config, Hooks, Application> {
+
+    public async register() {
 
-    private transporters = {} as {[name: string]: Transporter};
-    public register( name: string, transporter: (new () => Transporter) ) {
-        console.log(`[email] registering email transporter: ${name}`);
-        this.transporters[ name ] = new transporter();
     }
 
-    public load() {
-        $.console.bugReport.addTransporter('email', (report) => this.send(report.type === 'server' ? {
-            to: app.identity.author.email,
-            subject: "Bug on server: " + (report.error.message),
-            html: `
-                <a href="${app.env.url}/admin/activity/requests/${report.channelId}">
-                    View Request details & console
-                </a>
-                <br/>
-                ${report.logs}
-            `
-        } : {
-            to: app.identity.author.email,
-            subject: "Bug on application " + (report.action),
-            html: {
-                ...report
-            }
-        }));
+    public async start() {
         
     }
 
+    private transporters = {} as {[name: string]: Transporter};
+    public addTransporter( name: string, transporter: (new () => Transporter) ) {
+        console.log(`[email] registering email transporter: ${name}`);
+        this.transporters[ name ] = new transporter();
+    }
+
     public async send(
         emails: TEmail | TEmail[],
         options: TOptions = {}
@@ -118,12 +106,12 @@ export default class Email {
         if (!Array.isArray( emails ))
             emails = [emails];
 
-        config.debug && console.log(`Preparing to send ${emails.length} emails ...`);
+        this.config.debug && console.log(`Preparing to send ${emails.length} emails ...`);
 
         const emailsToSend: TCompleteEmail[] = emails.map(email => {
 
             const from = email.from === undefined
-                ? config.default.from
+                ? this.config.default.from
                 : email.from;
 
             const to = typeof email.to === 'string'
@@ -164,7 +152,7 @@ export default class Email {
             
         });
 
-        const transporterName = options.transporter || app.config.email.default.transporter;
+        const transporterName = options.transporter || this.config.default.transporter;
         if (transporterName === undefined)
             throw new Error(`Please define at least one mail transporter.`);
 
@@ -186,16 +174,4 @@ export default class Email {
         await Transporter.send(emailsToSend);
 
     }
-}
-
-/*----------------------------------
-- REGISTER SERVICE
-----------------------------------*/
-app.register('email', Email);
-declare global {
-    namespace Core {
-        interface Services {
-            email: Email;
-        }
-    }
 }

package/src/server/services/{router/request/services → metrics}/detect.ts

@@ -3,17 +3,14 @@
 ----------------------------------*/
 
 // Npm
-import express from 'express';
+import got from 'got';
 
 // Core
 import { Forbidden } from '@common/errors';
-import request from '@server/data/ApiClient';
-import ServerRequest from '..';
-import TrackerService from './tracking';
+import ServerRequest from '../router/request';
 
 // App
 import app from '@server/app';
-import { IP } from '@models';
 
 /*----------------------------------
 - TYPES
@@ -80,6 +77,8 @@ export default class ProtectService {
 
         return conflict;*/
 
+        return false;
+
     }
 
     public async captcha(token?: string) {
@@ -92,14 +91,13 @@ export default class ProtectService {
         if (!token)
             throw new Forbidden("Le captcha n'a pas été complété.");
 
-        const res = await request.post('https://www.google.com/recaptcha/api/siteverify', {}, {
-            params: {
+        const res = await got.post('https://www.google.com/recaptcha/api/siteverify', {
+            body: JSON.stringify({
                 secret: app.config.http.security.recaptcha.prv,
                 response: token, 
                 remoteip: null
-            },
-            debug: false
-        }).then(res => res.data)
+            })
+        }).json()
 
         console.info(`Réponse captcha`, res);