proteum 1.0.0-1

package/server/services/email/index.ts

@@ -0,0 +1,188 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import type { Application } from '@server/app';
+import Service from '@server/app/service';
+import markdown from '@common/data/markdown';
+
+// Speciic
+import { jsonToHtml } from './utils';
+
+/*----------------------------------
+- SERVICE CONFIG
+----------------------------------*/
+
+const LogPrefix = `[services][email]`
+
+export type Config = {
+    debug: boolean,
+    simulateWhenLocal: boolean,
+    default: {
+        from: TPerson
+    },
+    bugReport: {
+        from: TPerson,
+        to: TPerson
+    },
+}
+
+export type Hooks = {
+
+}
+
+export type Services = {
+
+}
+
+/*----------------------------------
+- TYPES: EMAILS
+----------------------------------*/
+
+export type TEmail = THtmlEmail | TMarkdownEmail;
+
+type TPerson = {
+    name?: string,
+    email: string
+}
+
+type TBaseEmail = { 
+    to: TPerson | TPerson[], 
+    cc?: TPerson | TPerson[]
+    from?: TPerson,
+};
+
+export type THtmlEmail = TBaseEmail & {
+    subject: string,
+    html: string | { [label: string]: any },
+}
+
+export type TMarkdownEmail = TBaseEmail & {
+    subject: string,
+    markdown: string,
+}
+
+export type TCompleteEmail = With<THtmlEmail, {
+    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
+}
+
+/*----------------------------------
+- FONCTIONS
+----------------------------------*/
+export default abstract class Email<TConfig extends Config> 
+    extends Service<TConfig, Hooks, Application, Application> {
+
+    /*----------------------------------
+    - 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> {
+
+        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];
+            else if (emails.length === 0)
+                return console.warn(LogPrefix, `No email to send.`);
+        }
+
+        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: 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 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
+                }
+
+            } else {
+                return {
+                    ...email,
+                    html: htmlWarning + (typeof email.html === "string" 
+                        ? email.html 
+                        : jsonToHtml(email.html)),
+                    from,
+                    to,
+                    cc
+                }
+            }
+            
+        });
+
+        console.info(LogPrefix, `Sending ${emailsToSend.length} emails:`, emailsToSend[0].subject);
+
+        // Pas d'envoi d'email quand local
+        if (this.app.env.profile !== 'prod' && this.config.simulateWhenLocal === true) {
+            console.log(LogPrefix, `Simulate email sending:\n`, emailsToSend[0].html);
+            return;
+        } else if (emailsToSend.length === 0) {
+            console.warn(LogPrefix, `No email to send.`);
+            return;
+        }
+
+        await this.sendNow(emailsToSend);
+
+    }
+}

package/server/services/email/utils.ts

@@ -0,0 +1,53 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+// Npm
+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
+    .replace(/\'/g, "'") // Doubles quotes*/
+
+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;
+            
+        } else if (typeof valeur === 'object') {
+
+            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);
+
+        html.push(
+            '<b>' + label + ':</b> ' + espacesVersHtml(escapehtml(valeur))
+        );
+    }
+
+    return html.join('<br>');
+    
+}

package/server/services/fetch/index.ts

@@ -0,0 +1,201 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import type { default as sharp, Sharp } from 'sharp';
+import fs from 'fs-extra';
+import got, { Method, Options } from 'got';
+
+// Node
+import request from 'request';
+
+// Core: general
+import type { Application } from '@server/app';
+import Service, { AnyService } from '@server/app/service';
+import { viaHttpCode } from '@common/errors';
+
+// Local
+import type { TAnyRouter } from '../router';
+import type DisksManager from '../disks';
+import type FsDriver from '../disks/driver';
+
+/*----------------------------------
+- SERVICE TYPES
+----------------------------------*/
+
+export type Config = {
+    debug?: boolean,
+    disk?: string,
+
+    disks: DisksManager,
+    router?: TAnyRouter
+}
+
+export type Hooks = {
+
+}
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TImageConfig = {
+    sharp: typeof sharp,
+    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, Application> {
+
+    private disk?: FsDriver;
+
+    public async ready() {
+
+        if (this.config.disks)
+            this.disk = this.config.disks.get( this.config.disk );
+
+    }
+
+    public async shutdown() {
+
+    }
+
+    /*----------------------------------
+    - EXTERNAL API REQUESTS
+    ----------------------------------*/
+
+    public post( 
+        url: string, 
+        data: {[k: string]: any}, 
+        options: {} = {} 
+    ) {
+
+        return this.request('POST', url, data, options);
+
+    }
+
+    public async request( 
+        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.`);
+
+        url = this.config.router.url(url);
+
+        // Send request
+        const res = await got(url, {
+            throwHttpErrors: false,
+            headers: {
+                'Accept': 'application/json',
+            },
+            method,
+            ...(method === 'GET' ? {
+                searchParams: data
+            } : {
+                json: data
+            })
+        })
+
+        // Handle errors
+        if (res.statusCode !== 200) {
+
+            // Instanciate error from HTTP code
+            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");
+        }
+
+        // Format & return response
+        return JSON.parse( res.body );
+    }
+
+    /*----------------------------------
+    - IMAGES
+    ----------------------------------*/
+
+    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, 
+        imageMod: TImageConfig, 
+        saveToBucket: string,
+        saveToPath?: 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.`);
+
+        // Download
+        let imageBuffer: Buffer | null;
+        try {
+            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 )
+                // 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;
+            })
+
+        }
+
+        // Save file
+        if (saveToPath !== undefined && imageBuffer !== null) {
+            console.log(LogPrefix, `Saving ${imageFileUrl} logo to ${saveToPath}`);
+            await this.disk.outputFile(saveToBucket, saveToPath, imageBuffer);
+        }
+
+        // We return the original, because Vibrant.js doesn't support webp
+        return imageBuffer;
+    }
+
+}

package/server/services/fetch/service.json

@@ -0,0 +1,7 @@
+{
+    "id": "Core/Fetch",
+    "name": "Fetch",
+    "parent": "app",
+    "dependences": [],
+    "priority": 0
+}

package/server/services/prisma/Facet.ts

@@ -0,0 +1,142 @@
+import type { Prisma, PrismaClient } from '@models/types';
+import * as runtime from '@/var/prisma/runtime/library.js';
+
+/*export type TDelegate<R> = {
+    findMany(args?: any): Promise<R[]>
+    findFirst(args?: any): Promise<R | null>
+}*/
+
+/*
+
+*/
+
+
+export type TDelegate<R> = PrismaClient[string];
+
+/*export type TExtractPayload<D extends TDelegate<never>> =
+  D extends { [K in symbol]: { types: { payload: infer P } } } ? P : never;
+
+export type TExtractPayload2<D> =
+  D extends { [K: symbol]: { types: Prisma.TypeMap<infer E>['model'][infer M] } }
+    ? Prisma.TypeMap<E>['model'][M & keyof Prisma.TypeMap<E>['model']]['payload']
+    : never;*/
+
+export type Transform<S extends TSubset, R, RT> = (
+    row: runtime.Types.Result.GetResult<
+        Prisma.$ProspectContactLeadPayload,
+        ReturnType<S>,
+        'findMany'
+    >[number]
+) => RT
+
+export type TWithStats = {
+    $table: string,
+    $key: string
+} & {
+    [key: string]: string // key => SQL
+}
+
+export type TSubset = (...a: any[]) => Prisma.ProspectContactLeadFindFirstArgs & {
+    withStats?: TWithStats
+}
+
+export default class Facet<
+    D extends TDelegate<R>,
+    S extends TSubset,
+    R, // Result type
+    RT // Transformed result type
+> {
+    constructor(
+
+        private readonly prisma: PrismaClient,
+
+        private readonly delegate: D,
+        private readonly subset: S,
+
+        /* the **ONLY** line that changed ↓↓↓ */
+        private readonly transform?: Transform<S, R, RT>,
+    ) { }
+
+    public async findMany(
+        ...args: Parameters<S>
+    ): Promise<RT[]> {
+
+        const { withStats, ...subset } = this.subset(...args);
+
+        const results = await this.delegate.findMany(subset);
+        if (results.length === 0)
+            return [];
+
+        // Load stats
+        const stats = withStats 
+            ? await this.fetchStats( withStats, results )
+            : [];
+
+        return results.map(row => this.transformResult(row, stats, withStats));
+    }
+
+    public async findFirst(
+        ...args: Parameters<S>
+    ): Promise<RT | null> {
+
+        const { withStats, ...subset } = this.subset(...args);
+
+        const result = await this.delegate.findFirst(subset);
+        if (!result)
+            return null;
+
+        const stats = withStats 
+            ? await this.fetchStats( withStats, [result] )
+            : [];
+
+        return this.transformResult(result, stats, withStats);
+    }
+
+    private async fetchStats(
+        { $table, $key, ...withStats }: TWithStats,
+        results: any[]
+    ): Promise<any[]> {
+
+        const select = Object.entries(withStats).map(([key, sql]) =>    
+            `(COALESCE((
+                ${sql}
+            ), 0)) as ${key}`
+        );
+
+        const stats = await this.prisma.$queryRawUnsafe(`
+            SELECT ${$key}, ${select.join(', ')} 
+            FROM ${$table} 
+            WHERE ${$key} IN (
+                ${results.map(r => "'" + r[ $key ] + "'").join(',')}
+            )
+        `);
+
+        for (const stat of stats) {
+            for (const key in stat) {
+    
+                if (key === $key)
+                    continue;
+    
+                stat[key] = stat[key] ? parseInt(stat[key]) : 0;
+            }
+        }
+
+        return stats;
+    }
+
+    private transformResult( result: any, stats: any[], withStats?: TWithStats ) {
+
+        // Transform stats
+        const resultStats = withStats
+            ? stats.find(stat => stat[withStats.$key] === result[withStats.$key]) || {}
+            : {};
+
+        if (this.transform)
+            result = this.transform(result);
+
+        return {
+            ...result,
+            ...resultStats
+        }
+    }
+}