5htp-core 0.1.2 → 0.2.0

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

@@ -8,385 +8,408 @@ import dottie from 'dottie';
 const safeStringify = require('fast-safe-stringify'); // remplace les références circulairs par un [Circular]
 
 // Core: general
-import app, { $ } from '@server/app';
+import type Application from '@server/app';
+import Service from '@server/app/service';
+import { callableInstance } from '@common/data/objets';
 import { NotFound } from '@common/errors';
 
 // Services
-import './connection';
+import Database, { DatabaseServiceConfig, TQueryOptions } from './connection';
+import type { TMetasTable } from './metas';
 
 /*----------------------------------
-- DEFINITIONS TYPES
+- SERVICE TYPES
 ----------------------------------*/
 
-export type SqlQuery = ReturnType<typeof sql>;
+export type Config = {
+
+}
+
+export type Hooks = {
 
-export type TQueryOptions = {
-    simulate?: boolean,
-    log?: boolean,
-    returnQuery?: boolean
 }
 
+/*----------------------------------
+- DEFINITIONS TYPES
+----------------------------------*/
+
+export type SqlQuery = SQL
+
 export type TSelectQueryOptions = TQueryOptions & {
 
 }
 
 export type TInsertQueryOptions<TData extends TObjetDonnees = TObjetDonnees> = TQueryOptions & {
-    upsert?: (keyof TData)[],
+    upsert?: (keyof TData)[] | true, // When true, we use table.upsertableColumns
     upsertMode?: 'increment'
     try?: boolean
 }
 
+type TInsertResult = {
+    fieldCount: number;
+    affectedRows: number;
+    changedRows: number;
+    insertId: number;
+    serverStatus: number;
+    warningCount: number;
+    message: string;
+    procotol41: boolean;
+}
+
 /*----------------------------------
-- SERVICE CONFIG
+- HELPERS
 ----------------------------------*/
 
-export type DatabaseServiceConfig = {
-    list: string[],
-    dev: {
-        host: string,
-        port: number,
-        login: string,
-        password: string,
-    },
-    prod: {
-        host: string,
-        port: number,
-        login: string,
-        password: string,
-    }
-}
+const LogPrefix = '[database]'
 
-declare global {
-    namespace Core {
-        namespace Config {
-            interface Services {
-                database: DatabaseServiceConfig
-            }
-        }
-    }
-}
+const equalities = (data: TObjetDonnees, keys = Object.keys(data)) => 
+    keys.map(k => '`' + k + '` = ' + mysql.escape( data[k] ))
 
 /*----------------------------------
-- HELPERS
+- CORE
 ----------------------------------*/
 
-const escape = (data: any) => {
+// TODO: build callable instance sithut instanciating the service
 
-    // JSON object
-    if (typeof data === 'object' && data !== null) {
+export default class SQL extends Service<Config, Hooks, Application> {
 
-        if (data.constructor.name === "Object" || Array.isArray(data))
-            data = safeStringify(data);
+    public database: Database;
 
+    public constructor( app: Application, config: DatabaseServiceConfig ) {
+        
+        super(app, {});
 
+        this.database = new Database(app, config);
     }
 
-    return mysql.escape(data);
-}
+    public async register() {
+        await this.database.register();
+    }
 
-const equalities = (data: TObjetDonnees, keys = Object.keys(data)) => 
-    keys.map(k => '`' + k + '` = ' + escape( data[k] ))
+    public async start() {
+        await this.database.start();
+    }
 
-/*----------------------------------
-- CORE
-----------------------------------*/
+    public callableInstance() {
+        return callableInstance( this, 'sql' );
+    }
 
-export type SQL = typeof sql;
+    /*----------------------------------
+    - OPERATIONS: PARSING
+    ----------------------------------*/
+    public sql<TRowData extends TObjetDonnees = {}>( strings: TemplateStringsArray, ...data: any[] ) {
 
-export function sql<TRowData extends TObjetDonnees = {}>(strings: TemplateStringsArray, ...data: any[]) {
+        const string = this.string(strings, ...data);
 
-    const string = sql.string(strings, ...data);
+        const query = (opts: TSelectQueryOptions = {}) => this.select<TRowData>(string, opts);
 
-    const query = (options: TSelectQueryOptions = {}) => sql.select<TRowData>(string, options);
+        query.all = query;
+        query.run = (opts: TQueryOptions = {}) => this.database.query<TRowData[]>(string, opts);
+        query.then = (cb: (data: any) => void) => query().then(cb);
 
-    query.all = query;
-    query.run = (opts: TQueryOptions = {}) => sql.query<TRowData[]>(string, opts);
-    query.then = (cb: (data: any) => void) => query().then(cb);
+        query.first = <TRowData extends TObjetDonnees = {}>(opts: TSelectQueryOptions = {}) => this.first<TRowData>(string, opts);
+        query.firstOrFail = (message?: string, opts: TQueryOptions = {}) => this.firstOrFail<TRowData>(string, message, opts);
 
-    query.first = <TRowData extends TObjetDonnees = {}>() => sql.first<TRowData>(string);
-    query.value = <TValue extends any = number>() => sql.selectVal<TValue>(string);
-    query.count = () => sql.count(string);
-    query.firstOrFail = (message?: string) => sql.firstOrFail<TRowData>(string, message);
-    query.exists = () => sql.exists(string);
+        query.value = <TValue extends any = number>(opts: TQueryOptions = {}) => this.selectVal<TValue>(string, opts);
+        
+        query.count = (opts: TQueryOptions = {}) => this.count(string, opts);
+        query.exists = (opts: TQueryOptions = {}) => this.exists(string, opts);
 
-    /*query.stats = (periodStr: string, intervalStr: string, columns: string[]) =>
-        fetchStats(columns, string, periodStr, intervalStr)*/
+        /*query.stats = (periodStr: string, intervalStr: string, columns: string[]) =>
+            fetchStats(columns, string, periodStr, intervalStr)*/
 
-    query.mergeValues = (options: TQueryOptions = {}) => 
-        sql.query(string, options).then( queriesResult => {
+        query.mergeValues = (options: TQueryOptions = {}) => 
+            this.database.query(string, options).then( queriesResult => {
 
-            const data: TObjetDonnees = {};
-            for (const queryResult of queriesResult)
-                if (queryResult.length !== 0)
-                    for (const k in queryResult[0])
-                        data[k] = queryResult[0][k];
-            return data;
+                const data: TObjetDonnees = {};
+                for (const queryResult of queriesResult)
+                    if (queryResult.length !== 0)
+                        for (const k in queryResult[0])
+                            data[k] = queryResult[0][k];
+                return data;
 
-        })
+            })
 
-    query.string = string;
+        query.string = string;
 
-    return query;
-}
+        return query;
+    }
 
-sql.esc = escape;
+    public esc(data: any) {
 
-sql.string = (strings: TemplateStringsArray, ...data: any[]) => {
-    const iMax = data.length - 1;
-    return strings.map((s, i) => {
+        // JSON object
+        // TODO: do it via datatypes.ts
+        if (typeof data === 'object' && data !== null) {
 
-        if (i <= iMax) {
+            if (Array.isArray(data))
+                data = data.join(',')
+            else if (data.constructor.name === "Object")
+                data = safeStringify(data);
+        }
+    
+        return mysql.escape(data);
+    }
 
-            let d = data[i];
-            const prefix = s[s.length - 1];
+    public string = (strings: TemplateStringsArray, ...data: any[]) => {
+        const iMax = data.length - 1;
 
-            if (typeof data === 'function') 
-                throw new Error(`A function has been passed into the sql string template: ` + data);
+        if (typeof data === 'function') 
+            throw new Error(`A function has been passed into the sql string template: ` + data);
 
-            if (prefix === ':' || prefix === '&') {
+        return strings.map((stringBefore, i) => {
 
-                s = s.substring(0, s.length - 1);
+            if (i <= iMax) {
 
-                // Object: `WHERE :${filters}` => `SET requestId = "" AND col = 3`
-                if (typeof d === 'object') {
+                let value = data[i];
+                stringBefore = stringBefore.trim();
+                const prefix = stringBefore[stringBefore.length - 1];
 
-                    const keyword = prefix === '&' ? ' AND ' : ', '
+                if (value === undefined || value === null) {
 
-                    d = Object.keys(d).length === 0 ? '1' : equalities(d).join( keyword );
-                    
-                // String: `SET :${column} = ${data}` => `SET balance = 10`
-                } else {
+                    value = 'NULL';
 
-                }
+                    // Replace ""= NULL" by "IS NULL"
+                    console.log("signBeforesignBefore", prefix, stringBefore);
+                    if (prefix === '=')
+                        stringBefore = stringBefore.substring(0, stringBefore.length - 1) + 'IS ';
 
-            } else if (typeof d === 'function' && d.string !== undefined)
-                d = d.string;
-            else
-                d = escape(d);
+                } else if (prefix === ':' || prefix === '&') {
 
-            s += d;
+                    // Remove the prefix
+                    stringBefore = stringBefore.substring(0, stringBefore.length - 1);
 
-        }
+                    // Object: `WHERE :${filters}` => `SET requestId = "" AND col = 3`
+                    if (typeof value === 'object') {
 
-        return s;
+                        const keyword = prefix === '&' ? ' AND ' : ', '
 
-    }).join(' ').trim();
-}
+                        value = Object.keys(value).length === 0 ? '1' : equalities(value).join( keyword );
+                        
+                    // String: `SET :${column} = ${data}` => `SET balance = 10`
+                    } else {
 
-/*----------------------------------
-- OPERATIONS: LOW LEVELf
-----------------------------------*/
 
-sql.query = async <TRowData extends TObjetDonnees = {}>(
-    query: string,
-    opts: TQueryOptions = {}
-): Promise<TRowData[] | string | void> => {
+                    }
 
-    if (opts.returnQuery === true)
-        return query;
+                } else if (typeof value === 'function' && value.string !== undefined)
+                    value = value.string;
+                else
+                    value = mysql.escape(value);
 
-    await $.database.loading;
+                stringBefore += value;
 
-    if (opts.log === true)
-        console.log(`[database][query]`, query);
+            }
 
-    if (opts.simulate === true)
-        return;
+            return stringBefore;
 
-    try {
+        }).join(' ').trim();
+    }
 
-        const startTime = Date.now();
+    /*----------------------------------
+    - OPERATIONS: LOW LEVELf
+    ----------------------------------*/
 
-        // Lancement de la requête
-        const [rows, fields] = await $.database.connection.query(query);
+    public bulk = (queries: (SqlQuery | string)[], opts?: TQueryOptions) => {
+        const allqueries = queries.map(q => typeof q === "string" ? q : q.string).join(';\n');
+        //console.log("Bulk query", allqueries);
+        return this.database.query(allqueries, opts);
+    }
 
-        if (opts.log !== false) {
-            const { channelType, channelId } = $.console.getChannel();
-            if (channelId !== 'admin')
-                $.console.sqlQueries.push({
-                    channelType,
-                    channelId,
-                    date: new Date(),
-                    query: query.trim(),
-                    time: Date.now() - startTime,
-                });
-        }
+    /*----------------------------------
+    - OPERATIONS: READ
+    ----------------------------------*/
 
-        return rows as unknown as TRowData[];
-        
-    } catch (error) {
-        
-        // NOTE: Le formatteur sql peut planter quand la requete est trop complexe (ex: json)
-        try {
-            console.error("Query that caused error:\n", $.console.printSql(query));
-        } catch (error) {
-            console.error("Query that caused error:\n", query);
-        }
-        
-        throw error;
-        
+    public select = async <TRowData extends any>(query: string, opts: TSelectQueryOptions = {}): Promise<TRowData[]> => {
+        const rows = await this.database.query(query, opts);
+        return dottie.transform(rows);
     }
+    public query = this.select;
 
-}
+    public first = <TRowData extends TObjetDonnees = {}>(query: string, opts: TSelectQueryOptions = {}): Promise<TRowData> =>
+        this.database.query(query, opts).then((resultatRequetes: any) => {
+            return resultatRequetes[0] || null;
+        });
 
-sql.bulk = (queries: (SqlQuery | string)[]) => {
-    const allqueries = queries.map(q => typeof q === "string" ? q : q.string).join(';\n');
-    console.log("Bulk query", allqueries);
-    return sql.query(allqueries);
-}
+    public firstOrFail = <TRowData extends TObjetDonnees = {}>(query: string, message?: string, opts: TSelectQueryOptions = {}): Promise<TRowData> =>
+        this.database.query(query, opts).then((resultatRequetes: any) => {
 
-/*----------------------------------
-- OPERATIONS: READ
-----------------------------------*/
-sql.select = async <TRowData extends any>(query: string, opts: TSelectQueryOptions): Promise<TRowData[]> => {
-    const rows = await sql.query(query, opts);
-    return dottie.transform(rows);
-}
+            if (resultatRequetes.length === 0)
+                throw new NotFound(message);
 
-sql.first = <TRowData extends TObjetDonnees = {}>(query: string, opts: TSelectQueryOptions = {}): Promise<TRowData> =>
-    sql.query(query, opts).then((resultatRequetes: any) => {
-        return resultatRequetes[0] || null;
-    });
+            return resultatRequetes[0];
 
-sql.firstOrFail = <TRowData extends TObjetDonnees = {}>(query: string, message?: string, opts: TSelectQueryOptions = {}): Promise<TRowData> =>
-    sql.query(query, opts).then((resultatRequetes: any) => {
+        });
 
-        if (resultatRequetes.length === 0)
-            throw new NotFound(message);
+    public selectVal = <TVal extends any>(query: string, opts?: TQueryOptions): Promise<TVal | null> =>
+        this.database.query(query, opts).then((resultatRequetes: any) => {
 
-        return resultatRequetes[0];
+            const resultat = resultatRequetes[0];
 
-    });
+            if (!resultat)
+                return null;
 
-sql.selectVal = <TVal extends any>(query: string, opts?: TQueryOptions): Promise<TVal | null> =>
-    sql.query(query, opts).then((resultatRequetes: any) => {
+            return Object.values(resultat)[0] as TVal;
 
-        const resultat = resultatRequetes[0];
+        });
 
-        if (!resultat)
-            return null;
-
-        return Object.values(resultat)[0] as TVal;
+    public count = (query: string, opts?: TQueryOptions): Promise<number> =>
+        this.selectVal<number>('SELECT COUNT(*) ' + query).then(val => 
+            val === null ? 0 : val
+        );
 
-    });
+    public exists = async (query: string, opts?: TQueryOptions): Promise<boolean> => {
+        const count = await this.count(query, opts);
+        return count !== 0;
+    }
 
-sql.count = (query: string, opts?: TQueryOptions): Promise<number> =>
-    sql.selectVal<number>('SELECT COUNT(*) ' + query).then(val => 
-        val === null ? 0 : val
-    );
+    /*----------------------------------
+    - OPERATIONS: UPDATE
+    ----------------------------------*/
 
-sql.exists = async (query: string, opts?: TQueryOptions): Promise<boolean> => {
-    const count = await sql.count(query);
-    return count !== 0;
-}
+    public update = <TData extends TObjetDonnees>(
+        table: string, 
+        data: TData, 
+        where: TObjetDonnees, 
+        opts?: TInsertQueryOptions<TData>
+    ) => {
 
-/*----------------------------------
-- OPERATIONS: UPDATE
-----------------------------------*/
+        const egalitesData = equalities(data).join(', ')
+        const egalitesWhere = equalities(where).join(' AND ')
 
-sql.update = <TData extends TObjetDonnees>(
-    table: string, 
-    data: TData, 
-    where: TObjetDonnees, 
-    opts?: TInsertQueryOptions<TData>
-) => {
+        return this.database.query(`
+            UPDATE ${table} SET ${egalitesData} WHERE ${egalitesWhere};
+        `, opts);
 
-    const egalitesData = equalities(data).join(', ')
-    const egalitesWhere = equalities(where).join(' AND ')
+    }
 
-    return sql.query(`
-        UPDATE ${table} SET ${egalitesData} WHERE ${egalitesWhere};
-    `, opts);
+    public upsert<TData extends TObjetDonnees>(
+        path: string, 
+        data: TData[] | TData, 
+        colsToUpdate?: (keyof TData)[], 
+        opts: TInsertQueryOptions<TData> = {}
+    ) {
+        return this.insert(path, data, {
+            ...opts,
+            upsert: colsToUpdate || true
+        });
+    }
 
-}
+    /*----------------------------------
+    - OPERATIONS: INSERT
+    ----------------------------------*/
+
+    public tryInsert = (table: string, data: TObjetDonnees) =>
+        this.insert(table, data, { try: true });
+
+    public async insert<TData extends TObjetDonnees>(
+        path: string, 
+        data: TData | TData[], 
+        opts: TInsertQueryOptions<TData> = {}
+    ): Promise<TInsertResult> {
+
+        const table = this.database.getTable(path);
+
+        // Normalize data
+        if (!Array.isArray(data))
+            data = [data];
+        else if (data.length === 0) {
+            console.warn(LogPrefix, `Insert nothing in ${path}. Cancelled.`);
+            return {
+                fieldCount: 0,
+                affectedRows: 0,
+                changedRows: 0,
+                insertId: 0,
+                serverStatus: 0,
+                warningCount: 0,
+                message: '',
+                procotol41: false,
+            };
+        }
 
-sql.upsert = <TData extends TObjetDonnees>(
-    path: string, 
-    data: TData | TData[], 
-    colsToUpdate: (keyof TData)[], 
-    opts: TInsertQueryOptions<TData> = {}
-) =>
-    sql.insert(path, data, {
-        ...opts,
-        upsert: colsToUpdate
-    });
+        let querySuffix: string = '';
 
-/*----------------------------------
-- OPERATIONS: INSERT
-----------------------------------*/
+        // Upsert
+        if (opts.upsert !== undefined) {
+            const upsertStatement = this.buildUpsertStatement<TData>(table, opts as With<TInsertQueryOptions<TData>, 'upsert'>);
+            if (upsertStatement === null)
+                opts.try = true;
+            else
+                querySuffix += ' ' + upsertStatement;
+        }
 
-sql.tryInsert = (table: string, data: TObjetDonnees) =>
-    sql.insert(table, data, { try: true });
-
-sql.insert = async <TData extends TObjetDonnees>(
-    path: string, 
-    data: TData | TData[], 
-    opts: TInsertQueryOptions<TData> = {}
-) => {
-
-    let db: string, table: string;
-    if (path.includes('.'))
-        ([db, table] = path.split('.'));
-    else {
-        // Only the table = use the main database (first of the list in the config)
-        db = $.database.config.list[0];
-        table = path;
-    }
+        // Create basic insert query
+        const query = this.buildInsertStatement(table, data, opts) + querySuffix;
+
+        const queryResult = await this.database.query<mysql.OkPacket>(query + ';', opts);
+
+        return {
+            fieldCount: queryResult.fieldCount,
+            affectedRows: queryResult.affectedRows,
+            changedRows: queryResult.changedRows,
+            insertId: queryResult.insertId,
+            serverStatus: queryResult.serverStatus,
+            warningCount: queryResult.warningCount,
+            message: queryResult.message,
+            procotol41: queryResult.procotol41,
+        };
         
-    if ($.database.tables[db] === undefined)
-        throw new Error(`Database "${db}" not loaded. Did you add it in the database config ?`);
-    if ($.database.tables[db][table] === undefined)
-        throw new Error(`Table "${db}.${table}" not loaded.`);
-
-    const columns = $.database.tables[db][table].colonnes;
-    const colNames = Object.keys(columns);
+        // OLD: return [data, queryResult?.insertId, queryResult];
+    }
 
-    if (!Array.isArray(data))
-        data = [data];
+    private buildInsertStatement<TData extends TObjetDonnees>(
+        table: TMetasTable, 
+        data: TData[],
+        opts:  TInsertQueryOptions<TData>
+    ) {
 
-    let query = `INSERT ` + (opts.try ? 'IGNORE ' : '') + 
-        `INTO ` + path + ` (` + colNames.map(col => '`' + col + '`').join(', ') + `) VALUES ` +
-        data.map(entry => {
+        const colNames = Object.keys(table.colonnes);
 
-            const values: string[] = [];
-            for (const col of colNames)
-                if (col in entry)
-                    values.push( escape(entry[col]) );
-                else
-                    values.push("DEFAULT");
+        return (
+            `INSERT ` + (opts.try ? 'IGNORE ' : '') + 
+            `INTO ` + table.chemin + ` (` + colNames.map( col => '`' + col + '`').join(', ') + `) VALUES ` +
+            data.map(entry => {
 
-            return '(' + values.join(', ') + ')';
+                const values: string[] = [];
+                for (const col of colNames)
+                    if (col in entry)
+                        values.push( this.esc( entry[col] ));
+                    else
+                        values.push("DEFAULT");
 
-        }).join(', ');
+                return '(' + values.join(', ') + ')';
 
-    if (opts.upsert !== undefined)
-        query += ' ON DUPLICATE KEY UPDATE ' + opts.upsert.map( col => 
-            '`' + col + '` = ' + (opts.upsertMode === 'increment' ? '`' + col + '` + ' : '') + 'VALUES(' + col + ')'
+            }).join(', ')
         )
+    }
 
-    const queryResult = await sql.query(query + ';', opts);
+    private buildUpsertStatement<TData extends TObjetDonnees>( 
+        table: TMetasTable, 
+        opts: With<TInsertQueryOptions<TData>, 'upsert'> 
+    ): string | null {
 
-    console.log("opts.returnQuery", opts.returnQuery, "queryResult", queryResult);
-    
-    return [data, queryResult.insertId, queryResult];
-}
+        let upsert = opts.upsert;
 
-/*----------------------------------
-- OTHER
-----------------------------------*/
-sql.delete = (table: string, where: TObjetDonnees = {}, opts?: TInsertQueryOptions) =>
-    sql.query(`
-        DELETE FROM ${table} WHERE ${equalities(where).join(' AND ')};
-    `, opts);
-
-/*----------------------------------
-- REGISTER SERVICE
-----------------------------------*/
-app.register('sql', sql, { instanciate: false });
-declare global {
-    namespace Core {
-        interface Services {
-            sql: SQL;
+        // Auto
+        if (upsert === true) {
+            console.log(LogPrefix, `Automatic upsert into ${table.chemin} using ${table.pk.join(', ')} as pk`);
+            upsert = table.columnNamesButPk;
         }
+
+        // All columns are ps
+        if (upsert.length === 0)
+            // Replace by insert ignore
+            return null;
+
+        return 'ON DUPLICATE KEY UPDATE ' + upsert.map((col: string) => 
+            '`' + col + '` = ' + (opts.upsertMode === 'increment' ? '`' + col + '` + ' : '') + 'VALUES(' + col + ')'
+        )
     }
-}
+
+    /*----------------------------------
+    - OTHER
+    ----------------------------------*/
+    public delete = (table: string, where: TObjetDonnees = {}, opts?: TQueryOptions) =>
+        this.database.query(`
+            DELETE FROM ${table} WHERE ${equalities(where).join(' AND ')};
+        `, opts);   
+}