proteum 1.0.3 → 2.0.0

package/server/app/container/index.ts

@@ -20,12 +20,9 @@ import type ServerRequest from '@server/services/router/request';
 /*----------------------------------
 - CLASS
 ----------------------------------*/
-export class ApplicationContainer<
-    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
-> {
-
+export class ApplicationContainer<TServicesIndex extends StartedServicesIndex = StartedServicesIndex> {
     /*----------------------------------
-    - INIT
+    - STATE
     ----------------------------------*/
 
     public Services = Services as ServicesContainer<TServicesIndex>;
@@ -35,38 +32,38 @@ export class ApplicationContainer<
 
     public application?: Application;
 
-    public constructor() {
+    // Runtime path registry used by the application container and generators.
+    public path = {
+        root: process.cwd(),
+        public: path.join(process.cwd(), '/public'),
+        var: path.join(process.cwd(), '/var'),
+
+        client: { generated: path.join(process.cwd(), 'src', 'client', '.generated') },
+        server: { generated: path.join(process.cwd(), 'src', 'server', '.generated') },
+    };
 
+    /*----------------------------------
+    - CONFIG
+    ----------------------------------*/
+
+    public constructor() {
         // Load config files
-        const configParser = new ConfigParser( this.path.root );
+        const configParser = new ConfigParser(this.path.root);
         this.Environment = configParser.env();
         this.Identity = configParser.identity();
         this.Console = new Console(this, this.Environment.console);
     }
 
-    // Context
-    public hmr: __WebpackModuleApi.Hot | undefined = module.hot;
-
-    public path = {
-        root: process.cwd(),
-        public: path.join( process.cwd(), '/public'),
-        var: path.join( process.cwd(), '/var'),
-
-        client: {
-            generated: path.join( process.cwd(), 'src', 'client', '.generated')
-        },
-        server: {
-            generated: path.join( process.cwd(), 'src', 'server', '.generated')
-        },
-    }
-
-    public start( ApplicationClass: typeof Application ): Application {
+    /*----------------------------------
+    - PUBLIC API
+    ----------------------------------*/
 
+    public start<TApplication extends Application>(ApplicationClass: new () => TApplication): TApplication {
         // Instanciate Application
         try {
-            this.application = new ApplicationClass;
+            this.application = new ApplicationClass();
         } catch (error) {
-            this.handleBug(error, "Failed to instanciate the Application Class");
+            this.handleBug(error, 'Failed to instanciate the Application Class');
             process.exit(1);
         }
 
@@ -74,64 +71,29 @@ export class ApplicationContainer<
         try {
             this.application.start();
         } catch (error) {
-            this.handleBug(error, "Failed to start the Application");
+            this.handleBug(error, 'Failed to start the Application');
             process.exit(1);
         }
 
-        return this.application;
+        return this.application as TApplication;
     }
 
-    public async handleBug( rejection: Error, message: string, request?: ServerRequest ) {
+    public async handleBug(rejection: unknown, message: string, request?: ServerRequest) {
+        const error =
+            rejection instanceof Error ? rejection : new Error(typeof rejection === 'string' ? rejection : message);
+
         if (this.Console) {
             try {
-
-                this.Console.createBugReport(rejection, request);
-
+                this.Console.createBugReport(error, request);
             } catch (consoleError) {
-                console.error(
-                    message, rejection, 
-                    "Failed to transmiss the previous error to console:", consoleError
-                );
+                console.error(message, error, 'Failed to transmiss the previous error to console:', consoleError);
                 process.exit(1);
             }
         } else {
-            console.error(message, rejection);
+            console.error(message, error);
             process.exit(1);
         }
     }
-
-
-    /*----------------------------------
-    - HMR
-    - TODO: move in dev server
-    ----------------------------------*/
-    private activateHMR() {
-
-        if (!module.hot) return;
-
-        console.info(`Activating HMR ...`);
-
-        module.hot.accept();
-        module.hot.accept( this.path.root + '/.cache/commun/routes.ts' );
-
-        module.hot.addDisposeHandler((data) => {
-
-            console.info(`Cleaning application ...`);
-
-            // Services hooks
-            //this.app.shutdown();
-
-            /*
-            console.log("[nettoyage] Arrêt serveur socket ...");
-            if (socket !== undefined)
-                socket.serveur.close()
-
-            console.log("[nettoyage] Reset du cache requêtes JSQL ...");
-            QueryParser.clearCache();*/
-
-        });
-    }
-
 }
 
-export default new ApplicationContainer;
+export default new ApplicationContainer();

package/server/app/controller/index.ts

@@ -0,0 +1,61 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import zod from 'zod';
+
+// Core
+import context from '@server/context';
+import type { Application } from '../index';
+import type { TRouterContext, TAnyRouter } from '@server/services/router';
+import {
+    toValidationSchema,
+    type TValidationSchema,
+    type TValidationShape,
+} from '@server/services/router/request/validation/zod';
+
+export { schema } from '@server/services/router/request/validation/zod';
+export type { z } from '@server/services/router/request/validation/zod';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TControllerContext = TRouterContext<TAnyRouter>;
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+
+export default abstract class Controller<
+    TApplication extends Application = Application,
+    TContext extends TControllerContext = TControllerContext,
+> {
+    public constructor(public request: TContext) {}
+
+    public get app(): TApplication {
+        return this.request.app as TApplication;
+    }
+
+    public get services(): TApplication {
+        return this.app;
+    }
+
+    public get models() {
+        const app = this.app as { models?: { client?: unknown }; Models?: { client?: unknown } };
+        return app.models?.client ?? app.Models?.client;
+    }
+
+    public input<TSchema extends TValidationSchema>(schema: TSchema): zod.output<TSchema>;
+    public input<TShape extends TValidationShape>(schema: TShape): zod.output<zod.ZodObject<TShape>>;
+    public input(schema: TValidationSchema | TValidationShape) {
+        const store = context.getStore() as { inputSchemaUsed?: boolean } | undefined;
+
+        if (store?.inputSchemaUsed) throw new Error('Controller.input() can only be called once per request handler.');
+
+        if (store) store.inputSchemaUsed = true;
+
+        return toValidationSchema(schema).parse(this.request.request.data);
+    }
+}

package/server/app/index.ts

@@ -2,22 +2,15 @@
 - DEPENDANCES
 ----------------------------------*/
 
-// Npm
-import type express from 'express';
-
 // Core
 import AppContainer from './container';
-import ApplicationService, { AnyService, StartedServicesIndex } from './service';
+import ApplicationService, { AnyService } from './service';
 import CommandsManager from './commands';
-import ServicesContainer, { 
-    ServicesContainer as ServicesContainerClass, 
-    TServiceMetas 
-} from './service/container';
+import ServicesContainer, { ServicesContainer as ServicesContainerClass, TServiceMetas } from './service/container';
 
 // Built-in
-import type { default as Router, Request as ServerRequest, TRoute } from '@server/services/router';
+import type { TServerRouter, Request as ServerRequest } from '@server/services/router';
 import { Anomaly } from '@common/errors';
-import { preprocessSchema } from '@server/services/router/request/validation/zod';
 import { TBasicUser } from '@server/services/auth';
 
 export { default as Services } from './service/container';
@@ -27,28 +20,18 @@ export type { TEnvConfig as Environment } from './container/config';
 - TYPES
 ----------------------------------*/
 
-type Config = {
-    
-}
+type Config = {};
 
 type Hooks = {
-    ready: {
-        args: [],
-    },
-    cleanup: {
-        args: [],
-    },
-    error: {
-        args: [error: Error, request?: ServerRequest<Router>],
-    }
-}
+    ready: { args: [] };
+    cleanup: { args: [] };
+    error: { args: [error: Error, request?: ServerRequest<TServerRouter>] };
+};
 
 export const Service = ServicesContainer;
 
 // Without prettify, we don't get a clear list of the class properties
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-  } & {};
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
 
 export type ApplicationProperties = Prettify<keyof Application>;
 
@@ -59,7 +42,6 @@ export abstract class Application<
     TServicesContainer extends ServicesContainerClass = ServicesContainerClass,
     TUser extends TBasicUser = TBasicUser,
 > extends ApplicationService<Config, Hooks, Application, Application> {
-
     public app!: this;
     public servicesContainer!: TServicesContainer;
     public userType!: TUser;
@@ -74,8 +56,8 @@ export abstract class Application<
         name: 'Application',
         parent: 'root',
         dependences: [],
-        class: () => ({ 'default': Application })
-    }
+        class: () => ({ default: Application }),
+    };
 
     // Shortcuts to ApplicationContainer
     public container = AppContainer;
@@ -85,33 +67,26 @@ export abstract class Application<
     // Status
     public debug: boolean = false;
     public launched: boolean = false;
-    
-    protected abstract registered: { 
-        [serviceId: string]: {
-            name: string,
-            start: () => AnyService
-        }
-    };
+
+    protected abstract registered: { [serviceId: string]: { name: string; start: () => AnyService } };
 
     /*----------------------------------
     - INIT
     ----------------------------------*/
 
     public constructor() {
-
-        const self = 'self' as unknown as Application;
+        const self = 'self' as const;
 
         // Application itself doesnt have configuration
         // Configuration must be handled by application services
         super(self, {}, self);
-        
+
         // Handle unhandled crash
-        this.on('error', (e, request) => this.container.handleBug(e, "An error occured in the application", request));
-        
-        process.on('unhandledRejection', (error: any, promise: any) => {
+        this.on('error', (e, request) => this.container.handleBug(e, 'An error occured in the application', request));
 
+        process.on('unhandledRejection', (error: any, _promise: any) => {
             // Log so we know it's coming from unhandledRejection
-            console.error("unhandledRejection", error);
+            console.error('unhandledRejection', error);
 
             // We don't log the error here because it's the role of the app to decidehiw to log errors
             this.runHook('error', error);
@@ -120,33 +95,29 @@ export abstract class Application<
         // We can't pass this in super so we assign here
         this.parent = this;
         this.app = this;
-
     }
 
     public report(...anomalyArgs: ConstructorParameters<typeof Anomaly>) {
-        return this.container.Console.createBugReport(
-            new Anomaly(...anomalyArgs)
-        );
+        return this.container.Console.createBugReport(new Anomaly(...anomalyArgs));
     }
 
     /*----------------------------------
     - COMMANDS
     ----------------------------------*/
 
-    private commandsManager = new CommandsManager(this, { debug: true }, {}, this);
+    private commandsManager = new CommandsManager(this, { debug: true }, this);
 
-    public command( ...args: Parameters<CommandsManager["command"]> ) {
+    public command(...args: Parameters<CommandsManager['command']>) {
         return this.commandsManager.command(...args);
     }
 
     /*----------------------------------
     - LAUNCH
     ----------------------------------*/
-    
-    public async start() {
 
-        console.log("Build date", BUILD_DATE);
-        console.log("Core version", CORE_VERSION);
+    public async start() {
+        console.log('Build date', BUILD_DATE);
+        console.log('Core version', CORE_VERSION);
         const startTime = Date.now();
 
         this.startServices();
@@ -169,35 +140,29 @@ export abstract class Application<
     ----------------------------------*/
 
     private startServices() {
-        
         // Satrt services
         for (const serviceId in this.registered) {
             try {
                 const service = this.registered[serviceId];
                 const instance = service.start();
-                this[service.name] = instance.getServiceInstance();
+                (this as Record<string, unknown>)[service.name] = instance.getServiceInstance();
             } catch (error) {
-                console.error("Error while starting service", serviceId, error);
+                console.error('Error while starting service', serviceId, error);
                 throw error;
             }
         }
     }
 
-    public register( service: AnyService ) {
-
+    public register(service: AnyService) {
         return service.ready();
-
     }
 
-    protected async ready() {
-
+    public async ready() {
         const startingServices: Promise<any>[] = [];
 
         // Print services
         const processService = async (propKey: string, service: AnyService, level: number = 0) => {
-
-            if (service.status !== 'starting')
-                return;
+            if (service.status !== 'starting') return;
 
             // Services start shouldn't block app boot
             // use await ServiceName.started to make services depends on each other
@@ -206,68 +171,37 @@ export abstract class Application<
             service.status = 'running';
             console.log('-' + '-'.repeat(level * 1), propKey + ': ' + service.constructor.name);
 
-            // Routes
-            const routes = service.__routes as TRoute[];
-            if (routes) for (const route of routes) { 
-
-                console.log('Attached service', service.constructor.name, 'to route', route.path);
-
-                const preprocessedSchema = route.schema ? preprocessSchema(route.schema) : undefined;
-
-                const origController = route.controller;
-                route.controller = (context: RouterContext) => {
-
-                    // Filter data
-                    const data = preprocessedSchema 
-                        ? preprocessedSchema.parse( context.request.data )
-                        : {};
-
-                    // Run controller
-                    return origController.bind( service )(
-                        data, 
-                        context
-                    );
-                }
-
-                this.Router.controllers[ route.path ] = route;
-            }
-            
             // Subservices
             for (const propKey in service) {
-
-                if (propKey === 'app')
-                    continue;
-                const propValue = service[propKey];
+                if (propKey === 'app') continue;
+                    const propValue = (service as Record<string, any>)[propKey];
 
                 // Check if service
-                const isService = 
-                    typeof propValue === 'object' && 
+                const isService =
+                    typeof propValue === 'object' &&
                     !(propValue instanceof Application) &&
-                    propValue !== null && 
+                    propValue !== null &&
                     propValue.status !== undefined;
-                if (!isService)
-                    continue;
+                if (!isService) continue;
 
                 // Services start shouldn't block app boot
                 processService(propKey, propValue, level + 1);
             }
-        }
+        };
 
         for (const serviceId in this.registered) {
-
             const registeredService = this.registered[serviceId];
-            const service = this[registeredService.name];
+            const service = (this as Record<string, any>)[registeredService.name];
 
             // TODO: move to router
             //  Application.on('service.ready')
-            
+
             // Services start shouldn't block app boot
             processService(serviceId, service);
         }
 
         return startingServices;
     }
-
 }
 
-export default Application
+export default Application;

package/server/app/service/container.ts

@@ -3,37 +3,39 @@
 ----------------------------------*/
 
 // Specific
-import type { 
-    AnyService, StartedServicesIndex,
+import type {
+    AnyService,
+    StartedServicesIndex,
     // Hooks
-    THookCallback, THooksIndex 
-} from ".";
+    THookCallback,
+    THooksIndex,
+} from '.';
 
 /*----------------------------------
 - TYPES: REGISTRATION
 ----------------------------------*/
 
 // From service/service.json
-export type TServiceMetas<TServiceClass extends AnyService = AnyService>  = {
-    id: string,
-    name: string,
-    parent: string,
-    dependences: string[],
-    class: () => { default: ClassType<TServiceClass> }
-}
-
-export type TRegisteredService<TServiceClass extends AnyService = AnyService>  = {
-    type: 'service', // Used to recognize if an object is a registered service
-    config?: {},
-    metas: TServiceMetas<TServiceClass>,
-    hooks: THooksIndex<{}>,
-    on: (hookName: string, hookFunc: THookCallback<any>) => void,
-    subServices: TRegisteredServicesIndex
-}
+export type TServiceMetas<TServiceClass extends AnyService = AnyService> = {
+    id: string;
+    name: string;
+    parent: string;
+    dependences: string[];
+    class: () => { default: ClassType<TServiceClass> };
+};
+
+export type TRegisteredService<TServiceClass extends AnyService = AnyService> = {
+    type: 'service'; // Used to recognize if an object is a registered service
+    config?: {};
+    metas: TServiceMetas<TServiceClass>;
+    hooks: THooksIndex<{}>;
+    on: (hookName: string, hookFunc: THookCallback<any>) => void;
+    subServices: TRegisteredServicesIndex;
+};
 
 export type TRegisteredServicesIndex<TServiceClass extends AnyService = AnyService> = {
-    [serviceId: string]: TRegisteredService<TServiceClass>
-}
+    [serviceId: string]: TRegisteredService<TServiceClass>;
+};
 
 /*----------------------------------
 - CONFIG
@@ -44,45 +46,42 @@ const LogPrefix = '[service]';
 /*----------------------------------
 - CLASS
 ----------------------------------*/
-export class ServicesContainer<
-    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
-> {
-
-    public registered: TRegisteredServicesIndex = {}
+export class ServicesContainer<TServicesIndex extends StartedServicesIndex = StartedServicesIndex> {
+    public registered: TRegisteredServicesIndex = {};
 
     // All service instances by service id
-    public allServices: TServicesIndex = {} as TServicesIndex
+    public allServices: TServicesIndex = {} as TServicesIndex;
 
     public callableInstance = <TInstance extends object, TCallableName extends keyof TInstance>(
-        instance: TInstance, 
-        funcName: TCallableName
+        instance: TInstance,
+        funcName: TCallableName,
     ): TInstance[TCallableName] & TInstance => {
-
+        const instanceRecord = instance as Record<string, unknown>;
         const callableFunc = instance[funcName];
-        if (typeof callableFunc !== 'function')
-            throw new Error(`instance[funcName] isn't callable.`);
+        if (typeof callableFunc !== 'function') throw new Error(`instance[funcName] isn't callable.`);
 
         const callable = callableFunc.bind(instance);
 
         const methods = [
-            ...Object.getOwnPropertyNames( Object.getPrototypeOf( instance )),
-            ...Object.getOwnPropertyNames( instance ),
+            ...Object.getOwnPropertyNames(Object.getPrototypeOf(instance)),
+            ...Object.getOwnPropertyNames(instance),
             // service.launch() isn't included, maybe because parent abstract class
             'launch',
-            'bindServices'
+            'bindServices',
         ];
 
         for (const method of methods)
             if (method !== 'constructor')
-                callable[ method ] = typeof instance[ method ] === 'function'
-                    ? instance[ method ].bind( instance )
-                    : instance[ method ];
+                (callable as Record<string, unknown>)[method] =
+                    typeof instanceRecord[method] === 'function'
+                        ? (instanceRecord[method] as Function).bind(instance)
+                        : instanceRecord[method];
 
-        // Allow us to recognize a callable as a service 
+        // Allow us to recognize a callable as a service
         callable.serviceInstance = instance;
 
         return callable as TInstance[TCallableName] & TInstance;
-    }
+    };
 }
 
-export default new ServicesContainer
+export default new ServicesContainer();