5htp-core 0.2.1 → 0.2.2

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

@@ -187,7 +187,8 @@ export default class DatabaseConnection extends Service<DatabaseServiceConfig, T
 
             const mysqlType = {
                 name: field.type as TMySQLTypeName,
-                params: []
+                params: [],
+                raw: 'undefined', // Not needed here
             }
 
             let jsTypeName = mysqlToJs[ mysqlType.name ];
@@ -200,7 +201,8 @@ export default class DatabaseConnection extends Service<DatabaseServiceConfig, T
                 sql: mysqlType,
                 js: {
                     name: jsTypeName,
-                    params: []
+                    params: [],
+                    raw: 'undefined', // Not needed here
                 }
             }
         }
@@ -244,6 +246,23 @@ export default class DatabaseConnection extends Service<DatabaseServiceConfig, T
 
     }
 
+    public checkValue( value: unknown, column: TMetasColonne ): string | false {
+
+        const jsType = jsTypes[ column.type.js.name ];
+        
+        const isValid = (value === undefined || value === null) 
+            ? column.optional
+            : jsType.check( value, column );
+
+        if (isValid)
+            return false;
+
+        console.log(column.type.sql.params)
+
+        return `Data expected to match: ${column.type.js.raw} (MySQL: ${column.type.sql.raw}) ||. Got: ` + JSON.stringify(value);;
+
+    }
+
     /*----------------------------------
     - QUERY
     ----------------------------------*/
@@ -254,30 +273,30 @@ export default class DatabaseConnection extends Service<DatabaseServiceConfig, T
         return new Bucket(queryOptions, queriesList);
     }
 
-    public async query<TResult extends TQueryResult>(
+    public query<TResult extends TQueryResult>(
         query: string,
         opts: TQueryOptions<'bucket', 'bucket'>
-    ): Promise<Bucket>;
+    ): Bucket;
 
-    public async query<TResult extends TQueryResult>(
+    public query<TResult extends TQueryResult>(
         query: string,
         opts: TQueryOptions<'returnQuery', 'returnQuery'>
-    ): Promise<string>;
+    ): string;
 
-    public async query<TResult extends TQueryResult>(
+    public query<TResult extends TQueryResult>(
         query: string,
         opts: TQueryOptions<'simulate', 'simulate'>
-    ): Promise<void>;
+    ): void;
 
-    public async query<TResult extends TQueryResult>(
+    public query<TResult extends TQueryResult>(
         query: string,
         opts?: TQueryOptions
     ): Promise<TResult>;
 
-    public async query<TResult extends TQueryResult>(
+    public query<TResult extends TQueryResult>(
         query: string,
         opts: TQueryOptions = {}
-    ): Promise<TResult | Bucket | string | void> {
+    ): Promise<TResult> | Bucket | string | void {
 
         if (opts.bucket) 
             return opts.bucket.add(query);
@@ -285,28 +304,25 @@ export default class DatabaseConnection extends Service<DatabaseServiceConfig, T
         if (opts.returnQuery === true)
             return query;
 
-        if (opts.log === true)
+        if (opts.log === true || opts.simulate === true)
             console.log(`[database][query]`, query);
 
         if (opts.simulate === true)
             return;
-
-        try {
-
-            const startTime = Date.now();
-
-            // Lancement de la requête
-            const [rows, fields] = await this.connection.query(query);
+            
+        const startTime = Date.now();
+        return this.connection.query(query).then(([rows, fields]) => {
 
             if (opts.log !== false)
                 this.log(query, startTime);
 
             return rows as unknown as TResult;
-            
-        } catch (error) {
+
+        }).catch((error) => {
 
             throw new SqlError(error, query);
-        }
+
+        })
     }
 
     private log( query: string, startTime: number ) {

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

@@ -1,7 +1,7 @@
 /*----------------------------------
 - DEPENDANCES
 ----------------------------------*/
-import type { TMetasColonne } from './metas';
+import type { TMetasColonne, TMySQLType } from './metas';
 
 /*----------------------------------
 - TYPES
@@ -9,7 +9,8 @@ import type { TMetasColonne } from './metas';
 
 type JsType = {
     parse: (value: string) => any,
-    print: (col: TMetasColonne) => string
+    check: (value: unknown, col: TMetasColonne) => boolean,
+    print: (mysqlTypeParams: TMySQLType["params"]) => string,
 }
 
 export type TJsTypeName = keyof typeof js;
@@ -18,43 +19,81 @@ export type TMySQLTypeName = keyof typeof mysqlToJs;
 /*----------------------------------
 - LISTS
 ----------------------------------*/
+/*
+    TODO: to merge avec the schema library
+*/
 export const js = {
     array: {
         parse: (val: string) => val.split(','),
-        print: (col) => (col.type.sql.params.length 
-            ? '(' + col.type.sql.params.map( param => "'" + param + "'").join(' | ') + ')'
+        print: (mysqlTypeParams: TMySQLType["params"]) => (mysqlTypeParams !== undefined 
+            ? '(' + mysqlTypeParams.map( param => "'" + param + "'").join(' | ') + ')'
             : 'string'
-        ) + '[]'
+        ) + '[]',
+        // Check before using into a mysql query
+        check: (val: unknown, col: TMetasColonne) => Array.isArray(val) && (
+            col.type.sql.params === undefined
+            ||
+            val.every( item => col.type.sql.params?.includes( item ))
+        )
     },
     enum: {
         parse: (val: string) => val,
-        print: (col) => col.type.sql.params.map( param => "'" + param + "'").join(' | ')
+        print: (mysqlTypeParams: TMySQLType["params"]) => mysqlTypeParams !== undefined
+            ? mysqlTypeParams.map( param => "'" + param + "'").join(' | ')
+            : 'string',
+        // Check before using into a mysql query
+        check: (val: unknown, col: TMetasColonne) => typeof val === 'string' && (
+            col.type.sql.params === undefined
+            ||
+            col.type.sql.params.includes( val )
+        )
     },
     float: {
         parse: (val: string) => parseFloat(val),
-        print: (col) => 'number'
+        print: () => 'number',
+        // Check before using into a mysql query
+        check: (val: unknown) => typeof val === 'number'
     },
     int: {
         parse: (val: string) => parseFloat(val),
-        print: (col) => 'number'
+        print: () => 'number',
+        // Check before using into a mysql query
+        check: (val: unknown, col: TMetasColonne) => (
+            typeof val === 'number'
+            ||
+            // We assume that a int(1) is possibly a boolean
+            (
+                typeof val === 'boolean'
+                /*&&
+                col.type.sql.params[]*/
+            )
+        )
     },
     date: {
         parse: (val: string) => new Date(val),
-        print: (col) => 'Date'
+        print: () => 'Date',
+        // Check before using into a mysql query
+        check: (val: unknown) => typeof val === 'number' || typeof val === 'string' || (typeof val === 'object' && val instanceof Date)
     },
     string: {
         parse: (val: string) => val,
-        print: (col) => 'string'
+        print: () => 'string',
+        // Check before using into a mysql query
+        check: (val: unknown) => typeof val === 'string'
     },
     object: {
         parse: (val: string) => JSON.parse(val),
-        print: (col) => 'object'
+        print: () => 'object',
+        // Check before using into a mysql query
+        check: (val: unknown) => typeof val === 'object'
     },
     
     // When we were not able to find an equivalent
     unknown: {
         parse: (val: any) => val,
-        print: (col) => 'any'
+        print: (mysqlTypeParams: TMySQLType["params"]) => 'any',
+        // Check before using into a mysql query
+        check: (val: unknown) => true
     },
 } as const
 

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

@@ -4,6 +4,7 @@
 
 // Npm
 import mysql from 'mysql2/promise';
+import type { ResultSetHeader } from 'mysql2';
 import dottie from 'dottie';
 const safeStringify = require('fast-safe-stringify'); // remplace les références circulairs par un [Circular]
 
@@ -21,6 +22,8 @@ import type { TMetasTable } from './metas';
 - SERVICE TYPES
 ----------------------------------*/
 
+export { default as Repository } from './repository';
+
 export type Config = {
 
 }
@@ -33,28 +36,32 @@ export type Hooks = {
 - DEFINITIONS TYPES
 ----------------------------------*/
 
-export type SqlQuery = SQL
+export type SqlQuery = ReturnType<SQL["sql"]>
 
 export type TSelectQueryOptions = TQueryOptions & {
 
 }
 
+export type TUpdateQueryOptions<TData extends TObjetDonnees = TObjetDonnees> = TQueryOptions;
+
 export type TInsertQueryOptions<TData extends TObjetDonnees = TObjetDonnees> = TQueryOptions & {
-    upsert?: (keyof TData)[] | true, // When true, we use table.upsertableColumns
+    upsert?: TColsToUpsert<TData>, // When "*", 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;
-}
+type TColsToUpsert<TData extends TObjetDonnees> = (
+    // Update all updatable columns (default)
+    '*' 
+    | 
+    // Specify which values exactly we have to update
+    // If '*', provided, we update all the updatable values and override with specific values
+    // { '*': true } is equivalent to '*'
+    ({ '*'?: true } & Partial<TData>)
+    | 
+    // A list of columns to update
+    (keyof TData)[] 
+)
 
 /*----------------------------------
 - HELPERS
@@ -63,7 +70,7 @@ type TInsertResult = {
 const LogPrefix = '[database]'
 
 const equalities = (data: TObjetDonnees, keys = Object.keys(data)) => 
-    keys.map(k => '`' + k + '` = ' + mysql.escape( data[k] ))
+    keys.map(k => '' + k + ' = ' + mysql.escape( data[k] ))
 
 /*----------------------------------
 - CORE
@@ -164,15 +171,16 @@ export default class SQL extends Service<Config, Hooks, Application> {
                 stringBefore = stringBefore.trim();
                 const prefix = stringBefore[stringBefore.length - 1];
 
+                // Null
                 if (value === undefined || value === null) {
 
                     value = 'NULL';
 
                     // Replace ""= NULL" by "IS NULL"
-                    console.log("signBeforesignBefore", prefix, stringBefore);
                     if (prefix === '=')
                         stringBefore = stringBefore.substring(0, stringBefore.length - 1) + 'IS ';
 
+                // Prefix = special parse
                 } else if (prefix === ':' || prefix === '&') {
 
                     // Remove the prefix
@@ -191,6 +199,7 @@ export default class SQL extends Service<Config, Hooks, Application> {
 
                     }
 
+                // SQL query
                 } else if (typeof value === 'function' && value.string !== undefined)
                     value = value.string;
                 else
@@ -266,18 +275,61 @@ export default class SQL extends Service<Config, Hooks, Application> {
     - OPERATIONS: UPDATE
     ----------------------------------*/
 
-    public update = <TData extends TObjetDonnees>(
-        table: string, 
+    // Update multiple records
+    public update<TData extends TObjetDonnees>(
+        tableName: string, 
+        data: TData[], 
+        where: (keyof TData)[], 
+        opts?: TUpdateQueryOptions<TData>
+    );
+
+    // Update one record
+    public update<TData extends TObjetDonnees>(
+        tableName: string, 
         data: TData, 
-        where: TObjetDonnees, 
-        opts?: TInsertQueryOptions<TData>
-    ) => {
+        where: (keyof TData)[] | TObjetDonnees, 
+        opts?: TUpdateQueryOptions<TData>
+    );
+
+    public update<TData extends TObjetDonnees>(...args: [
+        tableName: string, 
+        data: TData[], 
+        where: (keyof TData)[], 
+        opts?: TUpdateQueryOptions<TData>
+    ] | [
+        tableName: string, 
+        data: TData, 
+        where: (keyof TData)[] | TObjetDonnees, 
+        opts?: TUpdateQueryOptions<TData>
+    ]) {
+
+        let [tableName, data, where, opts] = args;
+
+        // Multiple updates in one
+        if (Array.isArray( data ))
+            return this.database.query(
+                data.map(record => this.update(tableName, record, where, opts)).join(';\n')
+            )
+
+        // No condition specified = use the pks
+        if (Array.isArray(where)) {
+            const whereColNames = where;
+            where = {}
+            for (const whereCol of whereColNames) {
+                const whereValue = data[whereCol];
+                if (whereValue === undefined)
+                    throw new Error(`The column "${whereCol}" is used as a where value, but no value has been provided in the data to update.`);
+                where[ whereCol ] = whereValue;
+            }
+        }
 
+        // Create equalities
         const egalitesData = equalities(data).join(', ')
         const egalitesWhere = equalities(where).join(' AND ')
 
+        // Build query
         return this.database.query(`
-            UPDATE ${table} SET ${egalitesData} WHERE ${egalitesWhere};
+            UPDATE ${tableName} SET ${egalitesData} WHERE ${egalitesWhere};
         `, opts);
 
     }
@@ -285,12 +337,12 @@ export default class SQL extends Service<Config, Hooks, Application> {
     public upsert<TData extends TObjetDonnees>(
         path: string, 
         data: TData[] | TData, 
-        colsToUpdate?: (keyof TData)[], 
+        colsToUpdate: TColsToUpsert<TData> = '*', 
         opts: TInsertQueryOptions<TData> = {}
     ) {
         return this.insert(path, data, {
             ...opts,
-            upsert: colsToUpdate || true
+            upsert: colsToUpdate
         });
     }
 
@@ -305,7 +357,7 @@ export default class SQL extends Service<Config, Hooks, Application> {
         path: string, 
         data: TData | TData[], 
         opts: TInsertQueryOptions<TData> = {}
-    ): Promise<TInsertResult> {
+    ): Promise<ResultSetHeader> {
 
         const table = this.database.getTable(path);
 
@@ -320,9 +372,8 @@ export default class SQL extends Service<Config, Hooks, Application> {
                 changedRows: 0,
                 insertId: 0,
                 serverStatus: 0,
-                warningCount: 0,
-                message: '',
-                procotol41: false,
+                warningStatus: 0,
+                info: undefined
             };
         }
 
@@ -387,29 +438,71 @@ export default class SQL extends Service<Config, Hooks, Application> {
         opts: With<TInsertQueryOptions<TData>, 'upsert'> 
     ): string | null {
 
-        let upsert = opts.upsert;
-
-        // Auto
-        if (upsert === true) {
-            console.log(LogPrefix, `Automatic upsert into ${table.chemin} using ${table.pk.join(', ')} as pk`);
-            upsert = table.columnNamesButPk;
-        }
+        const valuesToUpdate = this.getValuesToUpdate(table, opts.upsert);
 
         // All columns are ps
-        if (upsert.length === 0)
+        const valuesToUpdatesEntries = Object.entries(valuesToUpdate);
+        if (valuesToUpdatesEntries.length === 0)
             // Replace by insert ignore
             return null;
 
-        return 'ON DUPLICATE KEY UPDATE ' + upsert.map((col: string) => 
-            '`' + col + '` = ' + (opts.upsertMode === 'increment' ? '`' + col + '` + ' : '') + 'VALUES(' + col + ')'
+        return 'ON DUPLICATE KEY UPDATE ' + valuesToUpdatesEntries.map(([ colName, value ]) => 
+            '`' + colName + '` = ' + value
         )
     }
 
+    // TODO: Fix typings
+    private getValuesToUpdate<TData extends TObjetDonnees>(
+        table: TMetasTable,
+        colsToUpdate: TColsToUpsert<TData>
+    ) {
+
+        // Column name => SQL
+        let valuesToUpdate: Partial<TData> = {};
+
+        // Define which columns to update when the record already exists
+        let valuesNamesToUpdate: (keyof TData)[] = [];
+        if (colsToUpdate === '*') {
+
+            console.log(LogPrefix, `Automatic upsert into ${table.chemin} using ${table.pk.join(', ')} as pk`);
+            valuesNamesToUpdate = table.columnNamesButPk;
+
+        } else if (Array.isArray( colsToUpdate )) {
+
+            valuesNamesToUpdate = colsToUpdate;
+
+        } else {
+
+            const { '*': updateAll, ...customValuesToUpdate } = colsToUpdate;
+
+            for (const colKey in customValuesToUpdate)
+                valuesToUpdate[ colKey ] = this.esc(customValuesToUpdate[ colKey ]);
+
+            if (updateAll)
+                valuesNamesToUpdate = table.columnNamesButPk;
+
+        }
+
+        for (const colToUpdate of valuesNamesToUpdate)   
+            if (!( colToUpdate in valuesToUpdate ))
+                valuesToUpdate[ colToUpdate ] = "VALUES(`" + colToUpdate + "`)";
+
+        return valuesToUpdate;
+    }
+
     /*----------------------------------
     - OTHER
     ----------------------------------*/
-    public delete = (table: string, where: TObjetDonnees = {}, opts?: TQueryOptions) =>
-        this.database.query(`
-            DELETE FROM ${table} WHERE ${equalities(where).join(' AND ')};
-        `, opts);   
+    public delete(
+        table: string, 
+        where: TObjetDonnees | SQL = {}, 
+        opts?: TQueryOptions
+    ): Promise<ResultSetHeader> {
+
+        const whereSql = typeof where === 'function' && where['string'] !== undefined
+            ? where['string']
+            : equalities(where).join(' AND ');
+
+        return this.database.query(`DELETE FROM ${table} WHERE ${whereSql};`, opts);   
+    }
 }