5htp-core 0.6.2 → 0.6.3-2

package/server/services/auth/router/index.ts

@@ -7,11 +7,15 @@
 // Core
 import { 
     default as Router, Request as ServerRequest, Response as ServerResponse, TAnyRoute,
-    RouterService, TRouterServiceArgs
+    RouterService
 } from '@server/services/router';
 
+import type { Application } from '@server/app';
+
+import type { TRouterServiceArgs } from '@server/services/router/service';
+
 // Specific
-import type { default as UsersService, TUserRole } from '..';
+import type { default as UsersService, TUserRole, TBasicUser } from '..';
 import UsersRequestService from './request';
 
 /*----------------------------------
@@ -29,7 +33,7 @@ const LogPrefix = '[router][auth]';
 - SERVICE
 ----------------------------------*/
 export default class AuthenticationRouterService<
-    TUser extends {} = {},
+    TUser extends TBasicUser = TBasicUser,
     TRequest extends ServerRequest<Router> = ServerRequest<Router>,
 > extends RouterService {
 
@@ -37,7 +41,7 @@ export default class AuthenticationRouterService<
     - LIFECYCLE
     ----------------------------------*/
 
-    public users: UsersService;
+    public users: UsersService<TUser, Application>;
 
     public constructor(...args: TRouterServiceArgs) {
         super(...args);

package/server/services/database/connection.ts

@@ -36,7 +36,6 @@ type ConnectionConfig = {
 
 export type DatabaseServiceConfig = {
     debug: boolean,
-    connections: ConnectionConfig[],
     connectionsLimit: number
 }
 
@@ -66,6 +65,9 @@ export type TQueryResult = TSelectQueryResult;
 // TODO: specifiy return type of every mysql query type
 type TSelectQueryResult = any;
 
+const DATABASE_URL = process.env.DATABASE_URL;
+if (!DATABASE_URL) throw new Error("Missing env var: DATABASE_URL");
+
 /*----------------------------------
 - SERVICES
 ----------------------------------*/
@@ -99,14 +101,12 @@ export default class DatabaseManager {
 
         // Try to connect to one of the databases
         const connectionErrors: string[] = []
-        for (const connectionConfig of this.config.connections){
-            try {
-                await this.connect(connectionConfig)
-                break;
-            } catch (error) {
-                this.config.debug && console.warn(LogPrefix, `Failed to connect to ${connectionConfig.name}: ` + error);
-                connectionErrors.push(connectionConfig.name + ': ' + error);
-            }
+
+        try {
+            await this.connect()
+        } catch (error) {
+            this.config.debug && console.warn(LogPrefix, `Failed to connect to database: ` + error);
+            connectionErrors.push('database: ' + error);
         }
 
         // Coudnt connect to any database
@@ -127,17 +127,31 @@ export default class DatabaseManager {
     /*----------------------------------
     - INIT
     ----------------------------------*/
-    public async connect(config: ConnectionConfig) {
+    public async connect() {
+
+
+        const u = new URL(DATABASE_URL as string);
+        const connectionConfig = {
+            name: u.hostname,
+            databases: [u.pathname.replace(/^\//, "")],
+            host: u.hostname,
+            port: u.port ? Number(u.port) : 3306,
+            login: decodeURIComponent(u.username),
+            password: decodeURIComponent(u.password),
+        }
+
+        console.log('connectionConfig', connectionConfig);
+        
 
-        this.config.debug && console.info(LogPrefix, `Trying to connect to ${config.name} ...`);
+        this.config.debug && console.info(LogPrefix, `Trying to connect to database...`, connectionConfig);
         this.connection = mysql.createPool({
 
             // Identification
-            host: config.host,
-            port: config.port,
-            user: config.login,
-            password: config.password,
-            database: config.databases[0],
+            host: connectionConfig.host,
+            port: connectionConfig.port,
+            user: connectionConfig.login,
+            password: connectionConfig.password,
+            database: connectionConfig.databases[0],
 
             // Pool
             waitForConnections: true,
@@ -164,10 +178,10 @@ export default class DatabaseManager {
             }
         })
 
-        this.tables = await this.metas.load( config.databases );
-        this.connectionConfig = config; // Memorise configuration if connection succeed
+        this.tables = await this.metas.load(connectionConfig.databases);
+        this.connectionConfig = connectionConfig; // Memorise configuration if connection succeed
         this.status = 'connected';
-        this.config.debug && console.info(LogPrefix, `Successfully connected to ${config.name}.`);
+        this.config.debug && console.info(LogPrefix, `Successfully connected to database.`);
     }
 
     private typeCast( field: mysql.Field, next: Function ) {

package/server/services/disks/driver.ts

@@ -56,7 +56,11 @@ export type TReadFileOptions = {
 export default abstract class FsDriver<
     Config extends TDrivercnfig = TDrivercnfig,
     TBucketName = keyof Config["buckets"]
-> extends Service<Config, {}, Application> {
+> extends Service<Config, {}, Application, Application> {
+
+    public constructor( config: Config, app: Application ) {
+        super(app, config, app);
+    }
 
     public abstract mount(): Promise<void>;
 

package/server/services/disks/drivers/s3/index.ts

@@ -50,9 +50,9 @@ export default class S3Driver<
 
     public s3: AWS.S3; 
 
-    public constructor(...args: TServiceArgs) {
+    public constructor( config: TConfig, app: Application ) {
 
-        super(...args);
+        super(config, app);
 
         AWS.config.update({
             accessKeyId: this.config.accessKeyId,

package/server/services/disks/index.ts

@@ -34,10 +34,10 @@ export type Services = {
 - SERVICE
 ----------------------------------*/
 export default class DisksManager<
-    MountpointList extends Services = {},
-    TConfig extends Config = Config,
-    TApplication extends Application = Application
-> extends Service<TConfig, Hooks, TApplication> {
+    MountpointList extends Services,
+    TConfig extends Config,
+    TApplication extends Application
+> extends Service<TConfig, Hooks, TApplication, TApplication> {
 
     public default!: Driver;
 
@@ -45,7 +45,7 @@ export default class DisksManager<
     - LIFECYCLE
     ----------------------------------*/
 
-    public constructor( ...args: TServiceArgs<DisksManager>) {
+    public constructor( ...args: TServiceArgs<DisksManager<MountpointList, TConfig, TApplication>>) {
 
         super(...args);
 
@@ -54,6 +54,11 @@ export default class DisksManager<
         if (Object.keys( drivers ).length === 0)
             throw new Error("At least one disk driver should be mounted.");
 
+        // Bind current instance of the service as parent
+        /*for (const driverId in drivers) {
+            drivers[driverId].parent = this;
+        }*/
+
         const defaultDisk = drivers[ this.config.default ];
         if (defaultDisk === undefined)
             console.log(`Default disk "${this.config.default as string}" not mounted.`);

package/server/services/email/index.ts

@@ -174,7 +174,7 @@ export default abstract class Email<TConfig extends Config>
         console.info(LogPrefix, `Sending ${emailsToSend.length} emails:`, emailsToSend[0].subject);
 
         // Pas d'envoi d'email quand local
-        if (this.app.env.name === 'local' && this.config.simulateWhenLocal === true) {
+        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) {

package/server/services/prisma/Facet.ts

@@ -1,6 +1,34 @@
 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
@@ -13,12 +41,10 @@ export type TSubset = (...a: any[]) => Prisma.ProspectContactLeadFindFirstArgs &
 }
 
 export default class Facet<
-    D extends {
-        findMany(args?: any): Promise<any>
-        findFirst(args?: any): Promise<any>
-    },
+    D extends TDelegate<R>,
     S extends TSubset,
-    R
+    R, // Result type
+    RT // Transformed result type
 > {
     constructor(
 
@@ -28,22 +54,18 @@ export default class Facet<
         private readonly subset: S,
 
         /* the **ONLY** line that changed ↓↓↓ */
-        private readonly transform?: (
-            row: runtime.Types.Result.GetResult<
-                Prisma.$ProspectContactLeadPayload,
-                ReturnType<S>,
-                'findMany'
-            >[number]
-        ) => R,
+        private readonly transform?: Transform<S, R, RT>,
     ) { }
 
     public async findMany(
         ...args: Parameters<S>
-    ): Promise<R[]> {
+    ): 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 
@@ -55,17 +77,19 @@ export default class Facet<
 
     public async findFirst(
         ...args: Parameters<S>
-    ): Promise<R | null> {
+    ): 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 result ? this.transformResult(result, stats, withStats) : null;
+        return this.transformResult(result, stats, withStats);
     }
 
     private async fetchStats(

package/server/services/prisma/index.ts

@@ -10,7 +10,7 @@ import type { Application } from '@server/app';
 import Service from '@server/app/service';
 
 // Specific
-import Facet, { TSubset } from './Facet';
+import Facet, { TDelegate, TSubset, Transform } from './Facet';
 
 /*----------------------------------
 - TYPES
@@ -52,13 +52,11 @@ export default class ModelsManager extends Service<Config, Hooks, Application> {
     }
 
     public Facet<
-        D extends {
-            findMany(args?: any): Promise<any>
-            findFirst(args?: any): Promise<any>
-        },
+        D extends TDelegate<R>,
         S extends TSubset,
-        R
-    >(...args: [D, S, R]) {
+        R,
+        RT
+    >(...args: [D, S, Transform<S, R, RT>]) {
 
         return new Facet(
             this.client,

package/server/services/router/http/multipart.ts

@@ -81,11 +81,16 @@ export const traiterMultipart = (...canaux: any[]) => {
                     && 
                     donnee.data instanceof Buffer
                 ){
+                    const md5 = donnee.md5;
+                    const data = donnee.data;
                     donnee = new File(donnee.data, donnee.name, { 
                         type: donnee.mimetype,
                         lastModified: Date.now(),
                         //size: donnee.size,
                     });
+
+                    donnee.md5 = md5;
+                    donnee.data = data;
                 }
                 
                 brancheA[ cle ] = donnee;

package/server/services/router/index.ts

@@ -55,7 +55,7 @@ export type { default as Request, UploadedFile } from "./request";
 export type { default as Response, TRouterContext } from "./response";
 export type { TRoute, TAnyRoute } from '@common/router';
 
-export type TApiRegisterArgs<TRouter extends ServerRouter> = ([
+export type TApiRegisterArgs<TRouter extends TServerRouter> = ([
     path: string,
     controller: TServerController<TRouter>
 ] | [
@@ -64,7 +64,7 @@ export type TApiRegisterArgs<TRouter extends ServerRouter> = ([
     controller: TServerController<TRouter>
 ])
 
-export type TServerController<TRouter extends ServerRouter> = (context: TRouterContext<TRouter>) => any;
+export type TServerController<TRouter extends TServerRouter> = (context: TRouterContext<TRouter>) => any;
 
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS'
 export type TRouteHttpMethod = HttpMethod | '*';
@@ -83,8 +83,7 @@ export type HttpHeaders = { [cle: string]: string }
 const LogPrefix = '[router]';
 
 export type Config<
-    TServiceList extends TRouterServicesList = TRouterServicesList,
-    TAdditionnalSsrData extends {} = {}
+    TServices extends TRouterServicesList
 > = {
 
     debug: boolean,
@@ -96,18 +95,16 @@ export type Config<
     http: HttpServiceConfig,
 
     context: (
-        request: ServerRequest<ServerRouter>, 
+        request: ServerRequest<TServerRouter>, 
         app: Application
-    ) => TAdditionnalSsrData,
+    ) => {},
 
-    plugins: {
-        [routerServiceId: string]: RouterService
-    }
+    plugins: TServices
 }
 
 // Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
 type TRouterServicesList = {
-    [serviceName: string]: RouterService<ServerRouter>
+    [serviceName: string]: RouterService
 }
 
 export type Hooks = {
@@ -117,14 +114,20 @@ export type Hooks = {
 export type TControllerDefinition = {
     path?: string,
     schema?: zod.ZodSchema,
-    controller: TServerController<ServerRouter>,
+    controller: TServerController<TServerRouter>,
 }
 
+export type TServerRouter = ServerRouter<Application, TRouterServicesList, Config<TRouterServicesList>>;
+
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
-export default class ServerRouter 
-    extends Service<Config, Hooks, Application> implements BaseRouter {
+export default class ServerRouter<
+    TApplication extends Application,
+    TServices extends TRouterServicesList,
+    TConfig extends Config<TServices>,
+>
+    extends Service<TConfig, Hooks, TApplication, TApplication> implements BaseRouter {
 
     public disks = this.use<DisksManager>('Core/Disks', { optional: true });
     
@@ -151,7 +154,7 @@ export default class ServerRouter
     - SERVICE
     ----------------------------------*/
 
-    public constructor( ...args: TServiceArgs<ServerRouter>) {
+    public constructor( ...args: TServiceArgs< ServerRouter<TApplication, TServices, TConfig> >) {
 
         super(...args);
 
@@ -165,14 +168,11 @@ export default class ServerRouter
 
     public async ready() {
 
-        // Every hours
-        setInterval(() => {
-            this.refreshStaticPages();
-        }, 1000 * 60 * 60);
-
         // Detect router services
         for (const serviceName in this.config.plugins) {
-            this.app.register( this.config.plugins[serviceName] )
+            const service = this.config.plugins[serviceName];
+            service.parent = this;
+            this.app.register( service )
         }
 
          // Use require to avoid circular references
@@ -211,6 +211,12 @@ export default class ServerRouter
             );
         };
 
+
+        // When all the services are ready, initialize static routes
+        this.app.on('ready', () => {
+            this.initStaticRoutes();
+        });
+
     }
 
     public async shutdown() {
@@ -233,6 +239,8 @@ export default class ServerRouter
 
         if (!rendered) {
 
+            console.log('[router] renderStatic: url', url);
+
             const fullUrl = this.url(url, {}, true);
             const response = await got( fullUrl, {
                 method: 'GET',
@@ -261,6 +269,26 @@ export default class ServerRouter
         
     }
 
+    private initStaticRoutes() {
+
+        for (const route of this.routes) {
+
+            if (!route.options.static)
+                continue;
+
+            // Add to static pages
+            // Should be a GET oage that don't take any parameter
+            for (const url of route.options.static.urls) {
+                this.renderStatic(url, route.options.static);
+            }
+        }
+
+        // Every hours, refresh static pages
+        setInterval(() => {
+            this.refreshStaticPages();
+        }, 1000 * 60 * 60);
+    }
+
     private refreshStaticPages() {
 
         console.log('[router] refreshStaticPages');
@@ -270,15 +298,10 @@ export default class ServerRouter
             if (page.expire && page.expire < Date.now()) {
 
                 this.renderStatic(pageUrl, page.options);
-
             }
         }
     }
 
-
-
-
-
     private registerRoutes(defModules: GlobImportedWithMetas<TRouteModule>) {
         for (const routeModule of defModules) {
 
@@ -327,14 +350,6 @@ export default class ServerRouter
 
         this.routes.push(route);
 
-        // Add to static pages
-        // Should be a GET oage that don't take any parameter
-        if (options.static) {
-            for (const url of options.static.urls) {
-                this.renderStatic(url, options.static);
-            }
-        }
-
         return this;
 
     }
@@ -370,10 +385,10 @@ export default class ServerRouter
             req: Request,
             res: Response,
             next: NextFunction,
-            requestContext: TRouterContext
+            requestContext: TRouterContext<this>
         ) => void
     ) {
-        return (context: TRouterContext) => new Promise((resolve) => {
+        return (context: TRouterContext<this>) => new Promise((resolve) => {
             
             context.request.res.on('finish', function() {
                 //console.log('the response has been sent', request.res.statusCode);

package/server/services/router/request/api.ts

@@ -31,18 +31,6 @@ export default class ApiClientRequest extends RequestService implements ApiClien
         throw new Error("api.fetch shouldn't be called here.");
     }
 
-    public get = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-        this.createFetcher<TData>('GET', path, data, opts);
-
-    public post = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-        this.createFetcher<TData>('POST', path, data, opts);
-
-    public put = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-        this.createFetcher<TData>('PUT', path, data, opts);
-
-    public delete = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-        this.createFetcher<TData>('DELETE', path, data, opts);
-
     /*----------------------------------
     - PLACEHOLDERS
     ----------------------------------*/