proteum 1.0.2 → 2.0.0

package/server/services/prisma/Facet.ts

@@ -1,142 +1,90 @@
-import type { Prisma, PrismaClient } from '@models/types';
-import * as runtime from '@/var/prisma/runtime/library.js';
+import type { PrismaClient } from '@models/types';
 
-/*export type TDelegate<R> = {
-    findMany(args?: any): Promise<R[]>
-    findFirst(args?: any): Promise<R | null>
-}*/
+export type TDelegate<R = unknown> = {
+    findMany(args?: Record<string, unknown>): Promise<R[]>;
+    findFirst(args?: Record<string, unknown>): Promise<R | null>;
+};
 
-/*
+export type TWithStats = { $table: string; $key: string } & Record<string, string>;
 
-*/
+export type TSubset = (...args: any[]) => Record<string, unknown> & { withStats?: TWithStats };
 
-
-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 type Transform<S extends TSubset, R, RT> = (row: R) => RT;
 
 export default class Facet<
     D extends TDelegate<R>,
     S extends TSubset,
-    R, // Result type
-    RT // Transformed result type
+    R = unknown,
+    RT = R,
 > {
     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[]> {
+    ) {}
 
+    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 [];
+        if (results.length === 0) return [];
 
-        // Load stats
-        const stats = withStats 
-            ? await this.fetchStats( withStats, results )
-            : [];
+        const stats = withStats ? await this.fetchStats(withStats, results) : [];
 
-        return results.map(row => this.transformResult(row, stats, withStats));
+        return results.map((row) => this.transformResult(row, stats, withStats));
     }
 
-    public async findFirst(
-        ...args: Parameters<S>
-    ): Promise<RT | null> {
-
+    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;
+        if (!result) return null;
 
-        const stats = withStats 
-            ? await this.fetchStats( withStats, [result] )
-            : [];
+        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((
+        results: R[],
+    ): Promise<Record<string, unknown>[]> {
+        const select = Object.entries(withStats).map(
+            ([key, sql]) =>
+                `(COALESCE((
                 ${sql}
-            ), 0)) as ${key}`
+            ), 0)) as ${key}`,
         );
 
-        const stats = await this.prisma.$queryRawUnsafe(`
+        const statRows = (await this.prisma.$queryRawUnsafe(`
             SELECT ${$key}, ${select.join(', ')} 
             FROM ${$table} 
             WHERE ${$key} IN (
-                ${results.map(r => "'" + r[ $key ] + "'").join(',')}
+                ${(results as Array<Record<string, unknown>>).map((row) => "'" + row[$key] + "'").join(',')}
             )
-        `);
+        `)) as Record<string, unknown>[];
 
-        for (const stat of stats) {
+        for (const stat of statRows) {
             for (const key in stat) {
-    
-                if (key === $key)
-                    continue;
-    
-                stat[key] = stat[key] ? parseInt(stat[key]) : 0;
+                if (key === $key) continue;
+                stat[key] = stat[key] ? parseInt(String(stat[key]), 10) : 0;
             }
         }
 
-        return stats;
+        return statRows;
     }
 
-    private transformResult( result: any, stats: any[], withStats?: TWithStats ) {
-
-        // Transform stats
+    private transformResult(result: R, stats: Record<string, unknown>[], withStats?: TWithStats): RT {
+        const resultRecord = result as Record<string, unknown>;
         const resultStats = withStats
-            ? stats.find(stat => stat[withStats.$key] === result[withStats.$key]) || {}
+            ? stats.find((stat) => stat[withStats.$key] === resultRecord[withStats.$key]) || {}
             : {};
 
-        if (this.transform)
-            result = this.transform(result);
+        if (!this.transform) return { ...resultRecord, ...resultStats } as RT;
 
-        return {
-            ...result,
-            ...resultStats
-        }
+        const transformed = this.transform(result);
+
+        return { ...(transformed as object), ...resultStats } as RT;
     }
-}
+}

package/server/services/prisma/index.ts

@@ -9,7 +9,7 @@ import type PrismaClientType from '@prisma/client';
 const safeStringify = require('fast-safe-stringify'); // remplace les références circulairs par un [Circular]
 
 // Core
-import type { Application } from '@server/app';
+import type { Application } from '@server/app/index';
 import Service from '@server/app/service';
 
 // Specific
@@ -20,182 +20,146 @@ import { NotFound } from '@common/errors';
 - TYPES
 ----------------------------------*/
 
-export type SqlQuery = ReturnType<ModelsManager["SQL"]>
+export type SqlQuery = ReturnType<ModelsManager['SQL']>;
 
 /*----------------------------------
 - SERVICE CONFIG
 ----------------------------------*/
 
-export type Config = {
-   debug?: boolean
-}
-
-export type Hooks = {
-
-}
+export type Config = { debug?: boolean };
 
-export type Services = {
+export type Hooks = {};
 
-}
+export type Services = {};
 
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
 
 export default class ModelsManager extends Service<Config, Hooks, Application, Application> {
-
     public client = new PrismaClient() as PrismaClientType.PrismaClient;
 
     public async ready() {
-
         await this.client.$executeRaw`SET time_zone = '+00:00'`;
-
     }
-  
+
     public async shutdown() {
-        await this.client.$disconnect()
+        await this.client.$disconnect();
     }
 
-    public Facet<
-        D extends TDelegate<R>,
-        S extends TSubset,
-        R,
-        RT
-    >(...args: [D, S, Transform<S, R, RT>]) {
-
-        return new Facet(
-            this.client,
-            ...args
-        );
+    public Facet<D extends TDelegate<R>, S extends TSubset, R, RT>(...args: [D, S, Transform<S, R, RT>]) {
+        return new Facet(this.client, ...args);
     }
 
     /*----------------------------------
     - OPERATIONS: PARSING
     ----------------------------------*/
-    public SQL<TRowData extends {}|number|string>( strings: TemplateStringsArray, ...data: any[] ) {
-
+    public SQL<TRowData extends {} | number | string>(strings: TemplateStringsArray, ...data: any[]) {
         const string = this.string(strings, ...data);
 
         const query = () => {
             return this.client.$queryRawUnsafe(string) as Promise<TRowData[]>;
-        }
+        };
 
         query.all = query;
-        query.value = <TValue extends any = number>() => query().then((resultatRequetes: any) => {
+        query.value = <TValue extends any = number>() =>
+            query().then((resultatRequetes: any) => {
+                const resultat = resultatRequetes[0];
+
+                if (!resultat) return null;
 
-            const resultat = resultatRequetes[0];
+                return Object.values(resultat)[0] as TValue;
+            });
 
-            if (!resultat)
-                return null;
+        query.first = () =>
+            query().then((resultatRequetes: any) => {
+                return resultatRequetes[0] || null;
+            });
 
-            return Object.values(resultat)[0] as TValue;
-        });
+        query.firstOrFail = (message: string) =>
+            query().then((resultatRequetes: any) => {
+                if (resultatRequetes.length === 0) throw new NotFound(message);
 
-        query.first = () => query().then((resultatRequetes: any) => {
-            return resultatRequetes[0] || null;
-        });
-        
-        query.firstOrFail = (message: string) => query().then((resultatRequetes: any) => {
-            
-            if (resultatRequetes.length === 0)
-                throw new NotFound(message);
-    
-            return resultatRequetes[0];
-        });
+                return resultatRequetes[0];
+            });
 
         query.string = string;
 
         return query;
     }
 
-    public esc( data: any, forStorage: boolean = false ) {
-
+    public esc(data: any, forStorage: boolean = false) {
         // JSON object
         // TODO: do it via datatypes.ts
         if (typeof data === 'object' && data !== null) {
-
             // Object: stringify in JSON
-            if (data.constructor.name === "Object")
-                data = safeStringify(data);
+            if (data.constructor.name === 'Object') data = safeStringify(data);
             // Array: if for storage, reparate items with a comma
-            else if (forStorage && Array.isArray( data )) {
-                data = data.join(',')
-            } 
+            else if (forStorage && Array.isArray(data)) {
+                data = data.join(',');
+            }
         }
-    
+
         return mysql.escape(data);
     }
 
     public string = (strings: TemplateStringsArray, ...data: any[]) => {
         const iMax = data.length - 1;
 
-        if (typeof data === 'function') 
+        if (typeof data === 'function')
             throw new Error(`A function has been passed into the sql string template: ` + data);
 
-        return strings.map((stringBefore, i) => {
-
-            if (i <= iMax) {
-
-                let value = data[i];
-                stringBefore = stringBefore.trim();
-                const prefix = stringBefore[stringBefore.length - 1];
-
-                // Null
-                if (value === undefined || value === null) {
+        return strings
+            .map((stringBefore, i) => {
+                if (i <= iMax) {
+                    let value = data[i];
+                    stringBefore = stringBefore.trim();
+                    const prefix = stringBefore[stringBefore.length - 1];
 
-                    value = 'NULL';
+                    // Null
+                    if (value === undefined || value === null) {
+                        value = 'NULL';
 
-                    // Replace ""= NULL" by "IS NULL"
-                    if (prefix === '=')
-                        stringBefore = stringBefore.substring(0, stringBefore.length - 1) + 'IS ';
+                        // Replace ""= NULL" by "IS NULL"
+                        if (prefix === '=') stringBefore = stringBefore.substring(0, stringBefore.length - 1) + 'IS ';
 
-                // Prefix = special parse
-                } else if (prefix === ':' || prefix === '&') {
+                        // Prefix = special parse
+                    } else if (prefix === ':' || prefix === '&') {
+                        // Remove the prefix
+                        stringBefore = stringBefore.substring(0, stringBefore.length - 1);
 
-                    // Remove the prefix
-                    stringBefore = stringBefore.substring(0, stringBefore.length - 1);
+                        // Object: `WHERE :${filters}` => `SET requestId = "" AND col = 3`
+                        if (typeof value === 'object') {
+                            const keyword = prefix === '&' ? ' AND ' : ', ';
 
-                    // Object: `WHERE :${filters}` => `SET requestId = "" AND col = 3`
-                    if (typeof value === 'object') {
+                            value = Object.keys(value).length === 0 ? '1' : this.equalities(value).join(keyword);
 
-                        const keyword = prefix === '&' ? ' AND ' : ', '
+                            // String: `SET :${column} = ${data}` => `SET balance = 10`
+                        } else {
+                        }
 
-                        value = Object.keys(value).length === 0 ? '1' : this.equalities(value).join( keyword );
-                        
-                    // String: `SET :${column} = ${data}` => `SET balance = 10`
-                    } else {
+                        // SQL query
+                    } else if (typeof value === 'function' && value.string !== undefined) value = ' ' + value.string;
+                    // Escape value
+                    else {
+                        const lastKeyword = stringBefore.trim().split(' ').pop();
 
+                        // Escape table name
+                        if (lastKeyword === 'FROM') value = '`' + value + '`';
+                        else value = mysql.escape(value);
 
+                        value = ' ' + value;
                     }
-
-                // SQL query
-                } else if (typeof value === 'function' && value.string !== undefined)
-                    value = ' ' + value.string;
-                // Escape value
-                else {
-
-                    const lastKeyword = stringBefore.trim().split(' ').pop();
-
-                    // Escape table name
-                    if (lastKeyword === 'FROM')
-                        value = '`' + value + '`';
-                    else
-                        value = mysql.escape(value);
-
-                    value = ' ' + value;
+                    stringBefore += value;
                 }
-                stringBefore += value;
 
-            }
-
-            return stringBefore;
-
-        }).join(' ').trim();
-    }
+                return stringBefore;
+            })
+            .join(' ')
+            .trim();
+    };
 
     public equalities = (data: TObjetDonnees, forStorage: boolean = false) => {
-        return Object.keys(data).map(k => '' + k + ' = ' + this.esc( data[k], forStorage ))
-    }
-
-   
-}
+        return Object.keys(data).map((k) => '' + k + ' = ' + this.esc(data[k], forStorage));
+    };
+}

package/server/services/router/generatedRuntime.ts

@@ -0,0 +1,29 @@
+import fs from 'fs';
+import path from 'path';
+
+type TGeneratedRuntimeBundleName = 'routes' | 'controllers';
+
+const generatedRuntimeBundleFiles: Record<TGeneratedRuntimeBundleName, string> = {
+    routes: '__proteum_dev_routes.js',
+    controllers: '__proteum_dev_controllers.js',
+};
+
+// Use Node's native require so the running server can reload freshly compiled
+// dev bundles from disk instead of resolving the copies embedded in server.js.
+const nativeRequire = eval('require') as NodeJS.Require;
+
+const getGeneratedRuntimeBundlePath = (bundleName: TGeneratedRuntimeBundleName) =>
+    path.join(process.cwd(), APP_OUTPUT_DIR, generatedRuntimeBundleFiles[bundleName]);
+
+export const loadGeneratedRuntimeBundle = <T>(bundleName: TGeneratedRuntimeBundleName): T | undefined => {
+    if (!__DEV__) return undefined;
+
+    const bundlePath = getGeneratedRuntimeBundlePath(bundleName);
+    if (!fs.existsSync(bundlePath)) return undefined;
+
+    const resolvedPath = nativeRequire.resolve(bundlePath);
+    delete nativeRequire.cache[resolvedPath];
+
+    const loadedModule = nativeRequire(resolvedPath);
+    return (loadedModule.default || loadedModule) as T;
+};