5htp-core 0.2.1 → 0.2.2

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

@@ -8,6 +8,7 @@ import type mysql from 'mysql2/promise';
 
 // Core
 import Application from '@server/app';
+import { ucfirst } from '@common/data/chaines';
 
 // Database
 import type DatabaseConnection from './connection';
@@ -66,12 +67,14 @@ export type TMetasColonne = {
     // Column
     table: TMetasTable,
     nom: string,
+    pathname: string,
     attached: boolean, // Si les métadonnées ont bien été enrichies avec celles provenant de MySQL
     primary: boolean,
 
     // Type
     type: TColumnTypes,
     nullable: boolean,
+    optional: boolean,
 
     // Value
     defaut?: any, // ATTENTION: Valeur déjà sérialisée
@@ -88,12 +91,14 @@ export type TColumnTypes = {
 
 export type TMySQLType = {
     name: TMySQLTypeName,
-    params: string[] 
+    params?: string[],
+    raw: string
 }
 
 export type TJsType = {
     name: TJsTypeName,
-    params: string[],
+    params?: string[],
+    raw: string
 }
 
 /*----------------------------------
@@ -103,7 +108,7 @@ export type TJsType = {
 const LogPrefix = '[database][meta]';
 
 const sqlTypeParamsReg = /\'([^\']+)\'\,?/gi;
-const typeViaCommentReg = /^\[type=([a-z]+)\]/g;
+const typeViaCommentReg = /\[type=([a-z]+)\]/g;
 
 const modelsTypesPath = process.cwd() + '/src/server/models.ts';
 
@@ -196,7 +201,10 @@ export default class MySQLMetasParser {
 
             // Extrct tablesIndex
             const table = tablesIndex[database][nomTable];
-            const parsedTypes = this.parseColType(type, comment);
+            const isNullable = nullable === 'YES';
+            const defaultValue = defaut === null ? undefined : defaut;
+            const isOptional = isNullable || defaultValue !== undefined;
+            const parsedTypes = this.parseColType(nomColonne, type, comment, isOptional);
 
             // Reference primary keys
             const isPrimary = cle === 'PRI';
@@ -209,15 +217,17 @@ export default class MySQLMetasParser {
                 // Column
                 table: tablesIndex[database][nomTable],
                 nom: nomColonne,
+                pathname: database + '.' + nomTable + '.' + nomColonne,
                 attached: true,
                 primary: isPrimary,
 
                 // Type
                 type: parsedTypes,
-                nullable: nullable === 'YES',
+                nullable: isNullable,
+                optional: isOptional,
 
                 // Value
-                defaut: defaut === null ? undefined : defaut,
+                defaut: defaultValue,
                 autoIncrement: extra.includes('auto_increment'),
 
                 // Extra
@@ -241,76 +251,92 @@ export default class MySQLMetasParser {
         
     }
 
-    private parseColType( rawType: string, comment: string | null ): TColumnTypes {
+    private parseColType( name: string, rawType: string, comment: string | null, isOptional?: boolean ): TColumnTypes {
 
         const mysqlType = this.parseMySQLType(rawType);
 
-        const jsType = this.parseJsType(mysqlType, comment);
+        const jsType = this.parseJsType(name, mysqlType, comment, isOptional);
 
         return {
             sql: mysqlType,
             js: jsType
         }
-
     }
 
     private parseMySQLType( rawType: string ): TMySQLType {
 
         let name: TMySQLType["name"];
-        let params: TMySQLType["params"] = [];
+        let params: TMySQLType["params"];
 
         // Via native MySQL type: parse type expression + params
         const posParenthese = rawType.indexOf('(');
-        if (posParenthese === -1)
+        if (posParenthese === -1) {
+
             name = rawType.toUpperCase() as TMySQLType["name"];
-        else {
+
+        } else {
+
             name = rawType.substring(0, posParenthese).toUpperCase() as TMySQLType["name"];
+            params = []
 
             // Extraction paramètres du type entre les parentheses
             const paramsStr = rawType.substring(posParenthese + 1, rawType.length - 1)
             let m;
             do {
+
                 m = sqlTypeParamsReg.exec(paramsStr);
                 if (m)
                     params.push(m[1]);
+
             } while (m);
+
+            if (params.length === 0)
+                params = undefined;
         }
 
-        return { name, params }
+        return { name, params, raw: rawType }
 
     }
 
-    private parseJsType( mysqlType: TMySQLType, comment: string | null ): TJsType {
+    private parseJsType( name: string, mysqlType: TMySQLType, comment: string | null, isOptional?: boolean ): TJsType {
+
+        let typeName: TJsType["name"] | undefined;
+        let params: TJsType["params"];
 
-        // Via comment
+        // Find type info via comment
         if (comment) {
             // Exract via comments: [type=array]
-            const foundTypeExpression = typeViaCommentReg.exec( comment );
-            if (foundTypeExpression !== null) {
+            const foundTypeExpression = [...comment.matchAll( typeViaCommentReg )][0];
+            if (foundTypeExpression !== undefined) {
 
                 const typeNameViaComment = foundTypeExpression[1];
                 if (!(typeNameViaComment in jsTypes))
                     console.warn(`Invalid type "${typeNameViaComment}" found in column comments.`);
                 else
-                    return { 
-                        name: typeNameViaComment as TJsTypeName, 
-                        params: []
-                    }
+                    typeName = typeNameViaComment as TJsTypeName;
             }
         }
 
-        // Via mysql Type
-        let jsTypeName = mysqlToJs[ mysqlType.name ];
-        if (jsTypeName === undefined) {
-            console.warn(`The mySQL data type « ${mysqlType.name} » has not been associated with a JS equivalent in mysqlToJs. Using any instead.`);
-            jsTypeName = mysqlToJs['UNKNOWN'];
-        }
+        // Find type info via mysql Type
+        if (typeName === undefined) {
+
+            typeName = mysqlToJs[ mysqlType.name ];
 
-        return { 
-            name: jsTypeName,  
-            params: [],
+            // Equivalent not found
+            if (typeName === undefined) {
+                console.warn(`The mySQL data type « ${mysqlType.name} » has not been associated with a JS equivalent in mysqlToJs. Using any instead.`);
+                typeName = mysqlToJs['UNKNOWN'];
+            }
         }
 
+        // Get utils from name
+        const jsTypeUtils = jsTypes[ typeName ];
+        if (!jsTypeUtils)
+            throw new Error(`Unable to find the typescript print funvction for js type "${typeName}"`);
+
+        const raw = name + (isOptional ? '?' : '') + ': ' + jsTypeUtils.print( mysqlType.params );
+
+        return { name: typeName, params, raw }
     }
 
     private genTypesDef( databases: TDatabasesList ) {
@@ -325,18 +351,18 @@ export default class MySQLMetasParser {
                 const colsDecl: string[] = [];
                 for (const colName in table.colonnes) {
 
+                    // Get column metdata
                     const col = table.colonnes[colName];
-                    const jsTypeUtils = jsTypes[ col.type.js.name ];
-                    if (!jsTypeUtils) {
-                        console.warn(`Unable to find the typescript print funvction for js type "${col.type.js.name}"`);
-                        continue;
-                    }
 
-                    colsDecl.push('\t' + col.nom + (col.nullable ? '?' : '') + ': ' + jsTypeUtils.print( col ));
+                    // Generate typescript typedef
+                    colsDecl.push('\t' + col.type.js.raw);
+
+                    // Generate enum
+                    if (['ENUM', 'SET'].includes( col.type.sql.name ) && col.type.sql.params !== undefined)
+                        types.push('export const ' + table.nom + ucfirst( colName ) + ' = [' + col.type.sql.params.map( p => "'" + p + "'") + '] as const;');
                 }
                 
                 types.push('export type ' + table.nom + ' = {\n' + colsDecl.join(',\n') + '\n}');
-
             }
         }
 

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

@@ -0,0 +1,26 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Specific
+import type Database from '.';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default class QueriesRepository {
+
+    public constructor( 
+        protected database: Database
+    ) {
+
+    }
+
+    protected sql( strings: TemplateStringsArray, ...data: any[] ) {
+        return this.database.sql(strings, ...data);
+    }
+}

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

@@ -8,6 +8,7 @@
 
 // Core
 import Application, { Service } from '@server/app';
+import markdown from '@common/data/markdown';
 
 // Speciic
 import { jsonToHtml } from './utils';
@@ -17,18 +18,21 @@ import type { Transporter } from './transporter';
 - SERVICE CONFIG
 ----------------------------------*/
 
+const LogPrefix = `[services][email]`
+
 export type Config = {
     debug: boolean,
+    simulateWhenLocal: boolean,
     default: {
         transporter: string,
-        from: string
+        from: TPerson
     },
     transporters: {
         [transporterName: string]: Transporter
     },
     bugReport: {
-        from: string,
-        to: string
+        from: TPerson,
+        to: TPerson
     }
 }
 
@@ -42,11 +46,17 @@ export type Hooks = {
 
 export { Transporter } from './transporter';
 
-export type TEmail = THtmlEmail | TTemplateEmail;
+export type TEmail = THtmlEmail | TMarkdownEmail// | TTemplateEmail;
+
+type TPerson = {
+    name?: string,
+    email: string
+}
 
 type TBaseEmail = { 
-    to: string | string[], 
-    from?: string 
+    to: TPerson | TPerson[], 
+    cc?: TPerson | TPerson[]
+    from?: TPerson,
 };
 
 export type THtmlEmail = TBaseEmail & {
@@ -54,22 +64,41 @@ export type THtmlEmail = TBaseEmail & {
     html: string | { [label: string]: any },
 }
 
-export type TTemplateEmail = TBaseEmail & {
+export type TMarkdownEmail = TBaseEmail & {
+    subject: string,
+    markdown: string,
+}
+
+/*export type TTemplateEmail = TBaseEmail & {
     template: keyof typeof templates,
     data?: TObjetDonnees
-}
+}*/
 
 export type TCompleteEmail = With<THtmlEmail, {
-    to: string[],
-    from: string,
+    to: TPerson[],
+    from: TPerson,
+    cc: TPerson[]
 }>;
 
+type TShortEmailSendArgs =  [
+    to: string, 
+    subject: string, 
+    markdown: string, 
+    options?: TOptions
+]
+
+type TCompleteEmailSendArgs = [
+    emails: TEmail | TEmail[], 
+    options?: TOptions
+]
+
+type TEmailSendArgs = TShortEmailSendArgs | TCompleteEmailSendArgs;
+
 /*----------------------------------
 - TYPES: OPTIONS
 ----------------------------------*/
 type TOptions = {
-    transporter?: string,
-    testing?: boolean
+    transporter?: string
 }
 
 /*----------------------------------
@@ -88,30 +117,52 @@ export default class Email extends Service<Config, Hooks, Application> {
     }
 
 
-    public async send(
-        emails: TEmail | TEmail[],
-        options: TOptions = {}
-    ): 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> {
+
+        let emails: TEmail[] | TEmail;
+        let options: TOptions | undefined;
+        if (typeof args[0] === 'string') {
+            const [to, subject, markdown, opts] = args as TShortEmailSendArgs;
+            emails = [{
+                to: { email: to },
+                subject,
+                markdown
+            }]
+            options = opts;
+        } else {
+
+            ([ emails, options ] = args as TCompleteEmailSendArgs);
+            if (!Array.isArray( emails ))
+                emails = [emails];
+        }
 
-        // Normalisation en tableau
-        if (!Array.isArray( emails ))
-            emails = [emails];
+        options = options || {}
 
         this.config.debug && console.log(`Preparing to send ${emails.length} emails ...`);
 
+        const htmlWarning = this.app.env.profile === 'dev'
+            ? `⚠️ This email has been sent for testing purposes. Please ignore it if you're not a developer.<br /><br />`
+            : '';
+
         const emailsToSend: TCompleteEmail[] = emails.map(email => {
 
-            const from = email.from === undefined
+            const from: TPerson = email.from === undefined
                 ? this.config.default.from
                 : email.from;
 
-            const to = typeof email.to === 'string'
-                ? [email.to]
-                : email.to;
+            const cc: TPerson[] = email.cc === undefined ? [] : Array.isArray(email.cc)
+                ? email.cc
+                : [email.cc];
+
+            const to: TPerson[] = Array.isArray(email.to)
+                ? email.to
+                : [email.to];
 
             // Via template
             // TODO: Restore templates feature
-            if ('template' in email) {
+            /*if ('template' in email) {
 
                 const template = templates[email.template];
 
@@ -126,20 +177,32 @@ export default class Email extends Service<Config, Hooks, Application> {
                     ...email,
                     // Vire le "> " au début
                     subject: txt.substring(2, delimTitre),
-                    html: txt.substring(delimTitre + 2),
+                    html: htmlWarning + txt.substring(delimTitre + 2),
                     from,
-                    to
+                    to,
+                    cc
                 }
 
-            }
+            } else */if ('markdown' in email) {
 
-            return {
-                ...email,
-                html: typeof email.html === "string" 
-                    ? email.html 
-                    : jsonToHtml(email.html),
-                from,
-                to
+                return {
+                    ...email,
+                    html: htmlWarning + markdown.render(email.markdown),
+                    from,
+                    to,
+                    cc
+                }
+
+            } else {
+                return {
+                    ...email,
+                    html: htmlWarning + (typeof email.html === "string" 
+                        ? email.html 
+                        : jsonToHtml(email.html)),
+                    from,
+                    to,
+                    cc
+                }
             }
             
         });
@@ -148,17 +211,14 @@ export default class Email extends Service<Config, Hooks, Application> {
         if (transporterName === undefined)
             throw new Error(`Please define at least one mail transporter.`);
 
-        console.info(`Sending ${emailsToSend.length} emails via transporter "${transporterName}"`, emailsToSend[0].subject);
+        console.info(LogPrefix, `Sending ${emailsToSend.length} emails via transporter "${transporterName}"`, emailsToSend[0].subject);
 
         // Pas d'envoi d'email quand local
-        /*if (app.env.name === 'local' && options.testing !== false) {
-            console.log(`Email send canceled: Test mode enabled, or you're in local`, { 
-                'options.testing': options.testing,
-                'app.env.name': app.env.name,
-            });
+        if (this.app.env.name === 'local' && this.config.simulateWhenLocal === true) {
+            console.log(LogPrefix, `Simulate email sending:\n`, emailsToSend[0].html);
             return;
-        } else */if (emailsToSend.length === 0) {
-            console.log(`No email to send.`);
+        } else if (emailsToSend.length === 0) {
+            console.warn(LogPrefix, `No email to send.`);
             return;
         }
 

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

@@ -0,0 +1,110 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import sharp from 'sharp';
+import fs from 'fs-extra';
+
+// Node
+import request from 'request';
+
+// Core: general
+import type Application from '@server/app';
+import Service from '@server/app/service';
+
+/*----------------------------------
+- SERVICE TYPES
+----------------------------------*/
+
+export type Config = {
+
+}
+
+export type Hooks = {
+
+}
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TImageConfig = {
+    width: number,
+    height: number,
+    fit: keyof sharp.FitEnum,
+    quality: number
+}
+
+/*----------------------------------
+- CONST
+----------------------------------*/
+
+const LogPrefix = `[services][fetch]`
+
+/*----------------------------------
+- SERVICE
+-  Tools that helps to consume external resources (including apis, ..)
+-----------------------------------*/
+export default class FetchService extends Service<Config, Hooks, Application> {
+
+    public async register() {
+        
+    }
+
+    public async start() {
+        
+    }
+
+    public toBuffer( uri: string ): Promise<Buffer> {
+        return new Promise<Buffer>((resolve, reject) => {
+            request(uri, { encoding: null }, (err, res, body) => {
+
+                if (err)
+                    return reject(err);
+
+                if (!body)
+                    return reject(`Body is empty for ${uri}.`);
+
+                resolve(body);
+            })
+        })
+    }
+
+    public async image( 
+        imageFileUrl: string, 
+        { width, height, fit, quality }: TImageConfig, 
+        saveToPath?: string
+    ): Promise<Buffer | null> {
+
+        // Download
+        let imageBuffer: Buffer;
+        try {
+            imageBuffer = await this.toBuffer( imageFileUrl );
+        } catch (error) {
+            console.error(LogPrefix, `Error while fetching image at ${imageFileUrl}:`, error);
+            return null;
+        }
+
+        // Resize
+        const processing = sharp( imageBuffer )
+            // Max dimensions (save space)
+            .resize(width, height, { fit })
+
+        // Convert to webp and finalize
+        const processedBuffer = await processing.webp({ quality }).toBuffer().catch(e => {
+            console.error(LogPrefix, `Error while processing image at ${imageBuffer}:`, e);
+            return null;
+        })
+
+        // Save file
+        if (saveToPath !== undefined && processedBuffer !== null) {
+            console.log(LogPrefix, `Saving ${imageFileUrl} logo to ${saveToPath}`);
+            fs.outputFileSync(saveToPath, processedBuffer);
+        }
+
+        // We return the original, because Vibrant.js doesn't support webp
+        return imageBuffer;
+    }
+
+}