proteum 1.0.2 → 2.0.0

package/server/services/email/index.ts

@@ -3,7 +3,7 @@
 ----------------------------------*/
 
 // Core
-import type { Application } from '@server/app';
+import type { Application } from '@server/app/index';
 import Service from '@server/app/service';
 import markdown from '@common/data/markdown';
 
@@ -14,27 +14,18 @@ import { jsonToHtml } from './utils';
 - SERVICE CONFIG
 ----------------------------------*/
 
-const LogPrefix = `[services][email]`
+const LogPrefix = `[services][email]`;
 
 export type Config = {
-    debug: boolean,
-    simulateWhenLocal: boolean,
-    default: {
-        from: TPerson
-    },
-    bugReport: {
-        from: TPerson,
-        to: TPerson
-    },
-}
-
-export type Hooks = {
-
-}
+    debug: boolean;
+    simulateWhenLocal: boolean;
+    default: { from: TPerson };
+    bugReport: { from: TPerson; to: TPerson };
+};
 
-export type Services = {
+export type Hooks = {};
 
-}
+export type Services = {};
 
 /*----------------------------------
 - TYPES: EMAILS
@@ -42,133 +33,84 @@ export type Services = {
 
 export type TEmail = THtmlEmail | TMarkdownEmail;
 
-type TPerson = {
-    name?: string,
-    email: string
-}
+type TPerson = { name?: string; email: string };
 
-type TBaseEmail = { 
-    to: TPerson | TPerson[], 
-    cc?: TPerson | TPerson[]
-    from?: TPerson,
-};
+type TBaseEmail = { to: TPerson | TPerson[]; cc?: TPerson | TPerson[]; from?: TPerson };
 
-export type THtmlEmail = TBaseEmail & {
-    subject: string,
-    html: string | { [label: string]: any },
-}
+export type THtmlEmail = TBaseEmail & { subject: string; html: string | { [label: string]: any } };
 
-export type TMarkdownEmail = TBaseEmail & {
-    subject: string,
-    markdown: string,
-}
+export type TMarkdownEmail = TBaseEmail & { subject: string; markdown: string };
 
-export type TCompleteEmail = With<THtmlEmail, {
-    to: TPerson[],
-    from: TPerson,
-    cc: TPerson[]
-}>;
+export type TCompleteEmail = With<THtmlEmail, { to: TPerson[]; from: TPerson; cc: TPerson[] }>;
 
-type TShortEmailSendArgs =  [
-    to: string, 
-    subject: string, 
-    markdown: string, 
-    options?: TOptions
-]
+type TShortEmailSendArgs = [to: string, subject: string, markdown: string, options?: TOptions];
 
-type TCompleteEmailSendArgs = [
-    emails: TEmail | TEmail[], 
-    options?: TOptions
-]
+type TCompleteEmailSendArgs = [emails: TEmail | TEmail[], options?: TOptions];
 
 type TEmailSendArgs = TShortEmailSendArgs | TCompleteEmailSendArgs;
 
 /*----------------------------------
 - TYPES: OPTIONS
 ----------------------------------*/
-type TOptions = {
-    transporter?: string
-}
+type TOptions = { transporter?: string };
 
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export default abstract class Email<TConfig extends Config> 
-    extends Service<TConfig, Hooks, Application, Application> {
-
+export default abstract class Email<TConfig extends Config, TApplication extends Application = Application> extends Service<
+    TConfig,
+    Hooks,
+    TApplication,
+    TApplication
+> {
     /*----------------------------------
     - 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> {
+    protected abstract sendNow(emails: TCompleteEmail[]): Promise<void>;
 
+    public async send(to: string, subject: string, markdown: string, options?: TOptions): Promise<void>;
+    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
-            }]
+            emails = [{ to: { email: to }, subject, markdown }];
             options = opts;
         } else {
-
-            ([ emails, options ] = args as TCompleteEmailSendArgs);
-            if (!Array.isArray( emails ))
-                emails = [emails];
-            else if (emails.length === 0)
-                return console.warn(LogPrefix, `No email to send.`);
+            [emails, options] = args as TCompleteEmailSendArgs;
+            if (!Array.isArray(emails)) emails = [emails];
+            else if (emails.length === 0) return console.warn(LogPrefix, `No email to send.`);
         }
 
-        options = options || {}
+        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 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 from: TPerson = email.from === undefined
-                ? this.config.default.from
-                : email.from;
+        const emailsToSend: TCompleteEmail[] = emails.map((email) => {
+            const from: TPerson = email.from === undefined ? this.config.default.from : email.from;
 
-            const cc: TPerson[] = email.cc === undefined ? [] : Array.isArray(email.cc)
-                ? email.cc
-                : [email.cc];
+            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];
+            const to: TPerson[] = Array.isArray(email.to) ? email.to : [email.to];
 
             if ('markdown' in email) {
-
-                return {
-                    ...email,
-                    html: htmlWarning + markdown.render(email.markdown),
-                    from,
-                    to,
-                    cc
-                }
-
+                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)),
+                    html: htmlWarning + (typeof email.html === 'string' ? email.html : jsonToHtml(email.html)),
                     from,
                     to,
-                    cc
-                }
+                    cc,
+                };
             }
-            
         });
 
         console.info(LogPrefix, `Sending ${emailsToSend.length} emails:`, emailsToSend[0].subject);
@@ -183,6 +125,5 @@ export default abstract class Email<TConfig extends Config>
         }
 
         await this.sendNow(emailsToSend);
-
     }
-}
+}

package/server/services/email/utils.ts

@@ -2,52 +2,39 @@
 - DEPENDANCES
 ----------------------------------*/
 // Npm
-import dayjs from 'dayjs'; 
+import dayjs from 'dayjs';
 import escapehtml from 'escape-html';
 
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export const espacesVersHtml = (txt: string) => txt
-    .replace(/(\n|\r)/g, '<br>') // Sauts de ligne
-    .replace(/(\t)/g, '&nbsp;'.repeat(8)) // Tabulations
-    .replace(/ /g, '&nbsp;') // Espaces
-    /*.replace(/\"/g, '"') // Doubles quotes
+export const espacesVersHtml = (txt: string) =>
+    txt
+        .replace(/(\n|\r)/g, '<br>') // Sauts de ligne
+        .replace(/(\t)/g, '&nbsp;'.repeat(8)) // Tabulations
+        .replace(/ /g, '&nbsp;'); // Espaces
+/*.replace(/\"/g, '"') // Doubles quotes
     .replace(/\'/g, "'") // Doubles quotes*/
 
-export const jsonToHtml = (objet: {[cle: string]: any}, complet: boolean = false): string => {
-
+export const jsonToHtml = (objet: { [cle: string]: any }, complet: boolean = false): string => {
     let html: string[] = [];
 
     for (const label in objet) {
-
         let valeur = objet[label];
 
         if (valeur === undefined || valeur === null) {
-
             if (complet === true)
                 // quand undefined, JSON.stringify retourne aussi undefined
-                valeur = valeur === undefined 
-                    ? 'undefined' 
-                    : JSON.stringify(valeur, null, 4);
-            else
-                continue;
-            
+                valeur = valeur === undefined ? 'undefined' : JSON.stringify(valeur, null, 4);
+            else continue;
         } else if (typeof valeur === 'object') {
-
-            if (valeur instanceof Date)
-                valeur = dayjs(valeur).format('DD/MM/YYYY HH:mm:ss');
-
+            if (valeur instanceof Date) valeur = dayjs(valeur).format('DD/MM/YYYY HH:mm:ss');
         }
 
-        if (!valeur || typeof valeur !== 'string') 
-            valeur = JSON.stringify(valeur, null, 4);
+        if (!valeur || typeof valeur !== 'string') valeur = JSON.stringify(valeur, null, 4);
 
-        html.push(
-            '<b>' + label + ':</b> ' + espacesVersHtml(escapehtml(valeur))
-        );
+        html.push('<b>' + label + ':</b> ' + espacesVersHtml(escapehtml(valeur)));
     }
 
     return html.join('<br>');
-    
-}
+};

package/server/services/fetch/index.ts

@@ -5,14 +5,14 @@
 // Npm
 import type { default as sharp, Sharp } from 'sharp';
 import fs from 'fs-extra';
-import got, { Method, Options } from 'got';
+import got, { Method, Options, Response as GotResponse } from 'got';
 
 // Node
 import request from 'request';
 
 // Core: general
-import type { Application } from '@server/app';
-import Service, { AnyService } from '@server/app/service';
+import type { Application } from '@server/app/index';
+import Service from '@server/app/service';
 import { viaHttpCode } from '@common/errors';
 
 // Local
@@ -25,75 +25,55 @@ import type FsDriver from '../disks/driver';
 ----------------------------------*/
 
 export type Config = {
-    debug?: boolean,
-    disk?: string,
+    debug?: boolean;
+    disk?: string;
 
-    disks: DisksManager,
-    router?: TAnyRouter
-}
-
-export type Hooks = {
+    disks: DisksManager<any, any, Application>;
+    router?: TAnyRouter;
+};
 
-}
+export type Hooks = {};
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
 export type TImageConfig = {
-    sharp: typeof sharp,
-    width: number,
-    height: number,
-    fit: keyof sharp.FitEnum,
-    quality: number
-}
+    sharp: typeof sharp;
+    width: number;
+    height: number;
+    fit: keyof sharp.FitEnum;
+    quality: number;
+};
 
 /*----------------------------------
 - CONST
 ----------------------------------*/
 
-const LogPrefix = `[services][fetch]`
+const LogPrefix = `[services][fetch]`;
 
 /*----------------------------------
 - SERVICE
 -  Tools that helps to consume external resources (including apis, ..)
 -----------------------------------*/
 export default class FetchService extends Service<Config, Hooks, Application, Application> {
-
     private disk?: FsDriver;
 
     public async ready() {
-
-        if (this.config.disks)
-            this.disk = this.config.disks.get( this.config.disk );
-
+        if (this.config.disks) this.disk = this.config.disks.get(this.config.disk);
     }
 
-    public async shutdown() {
-
-    }
+    public async shutdown() {}
 
     /*----------------------------------
     - EXTERNAL API REQUESTS
     ----------------------------------*/
 
-    public post( 
-        url: string, 
-        data: {[k: string]: any}, 
-        options: {} = {} 
-    ) {
-
-        return this.request('POST', url, data, options);
-
+    public post(url: string, data: { [k: string]: any }, options: {} = {}) {
+        return this.send('POST', url, data, options);
     }
 
-    public async request( 
-        method: Method,
-        url: string, 
-        data: {[k: string]: any}, 
-        options: Options = {} 
-    ) {
-
+    public async send(method: Method, url: string, data: { [k: string]: any }, options: Options = {}) {
         // Parse url if router service is provided
         if (this.config.router === undefined)
             throw new Error(`Please bind the Router service to the Fetch service in order to contact APIs.`);
@@ -101,91 +81,80 @@ export default class FetchService extends Service<Config, Hooks, Application, Ap
         url = this.config.router.url(url);
 
         // Send request
-        const res = await got(url, {
+        const res = (await got(url, {
             throwHttpErrors: false,
-            headers: {
-                'Accept': 'application/json',
-            },
+            headers: { Accept: 'application/json' },
             method,
-            ...(method === 'GET' ? {
-                searchParams: data
-            } : {
-                json: data
-            })
-        })
+            ...(method === 'GET' ? { searchParams: data } : { json: data }),
+            ...options,
+        })) as GotResponse<string>;
 
         // Handle errors
         if (res.statusCode !== 200) {
-
             // Instanciate error from HTTP code
-            const error = viaHttpCode( res.statusCode, res.body );
-            if (error)
-                throw error;
+            const error = viaHttpCode(res.statusCode, res.body);
+            if (error) throw error;
 
             // Not catched via viaHttpCode
-            console.log("RESPONSE", res.body);
-            throw new Error("Error while contacting the API");
+            console.log('RESPONSE', res.body);
+            throw new Error('Error while contacting the API');
         }
 
         // Format & return response
-        return JSON.parse( res.body );
+        return JSON.parse(res.body);
     }
 
     /*----------------------------------
     - IMAGES
     ----------------------------------*/
 
-    public toBuffer( uri: string ): Promise<Buffer> {
+    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 (err)
-                    return reject(err);
-
-                if (!body)
-                    return reject(`Body is empty for ${uri}.`);
+                if (!body) return reject(`Body is empty for ${uri}.`);
 
                 resolve(body);
-            })
-        })
+            });
+        });
     }
 
-    public async image( 
-        imageFileUrl: string, 
-        imageMod: TImageConfig, 
+    public async image(
+        imageFileUrl: string,
+        imageMod: TImageConfig,
         saveToBucket: string,
         saveToPath?: string,
-        disk?: string
+        disk?: string,
     ): Promise<Buffer | null> {
-
         // Define target disk
-        if (this.disk === undefined)
-            throw new Error(`Please provide a Disks service in order to download files.`);
+        if (this.disk === undefined) throw new Error(`Please provide a Disks service in order to download files.`);
 
         // Download
         let imageBuffer: Buffer | null;
         try {
-            imageBuffer = await this.toBuffer( imageFileUrl );
+            imageBuffer = await this.toBuffer(imageFileUrl);
         } catch (error) {
             console.error(LogPrefix, `Error while fetching image at ${imageFileUrl}:`, error);
             return null;
         }
 
         if (imageMod) {
-
             const { sharp, width, height, fit, quality } = imageMod;
 
             // Resize
-            const processing = sharp( imageBuffer )
+            const processing = sharp(imageBuffer)
                 // Max dimensions (save space)
-                .resize(width, height, { fit }) 
-    
-            // Convert to webp and finalize
-            imageBuffer = await processing.webp({ quality }).toBuffer().catch(e => {
-                console.error(LogPrefix, `Error while processing image at ${imageFileUrl}:`, e);
-                return null;
-            })
+                .resize(width, height, { fit });
 
+            // Convert to webp and finalize
+            imageBuffer = await processing
+                .webp({ quality })
+                .toBuffer()
+                .catch((e) => {
+                    console.error(LogPrefix, `Error while processing image at ${imageFileUrl}:`, e);
+                    return null;
+                });
         }
 
         // Save file
@@ -197,5 +166,4 @@ export default class FetchService extends Service<Config, Hooks, Application, Ap
         // We return the original, because Vibrant.js doesn't support webp
         return imageBuffer;
     }
-
-}
+}