proteum 1.0.0-1

package/server/app/index.ts

@@ -0,0 +1,273 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import type express from 'express';
+
+// Core
+import AppContainer from './container';
+import ApplicationService, { AnyService, StartedServicesIndex } from './service';
+import CommandsManager from './commands';
+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 { 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';
+export type { TEnvConfig as Environment } from './container/config';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type Config = {
+    
+}
+
+type Hooks = {
+    ready: {
+        args: [],
+    },
+    cleanup: {
+        args: [],
+    },
+    error: {
+        args: [error: Error, request?: ServerRequest<Router>],
+    }
+}
+
+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];
+  } & {};
+
+export type ApplicationProperties = Prettify<keyof Application>;
+
+/*----------------------------------
+- FUNCTIONS
+----------------------------------*/
+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;
+
+    /*----------------------------------
+    - PROPERTIES
+    ----------------------------------*/
+
+    public side = 'server' as 'server';
+    public metas: TServiceMetas = {
+        id: 'application',
+        name: 'Application',
+        parent: 'root',
+        dependences: [],
+        class: () => ({ 'default': Application })
+    }
+
+    // Shortcuts to ApplicationContainer
+    public container = AppContainer;
+    public env = AppContainer.Environment;
+    public identity = AppContainer.Identity;
+
+    // Status
+    public debug: boolean = false;
+    public launched: boolean = false;
+    
+    protected abstract registered: { 
+        [serviceId: string]: {
+            name: string,
+            start: () => AnyService
+        }
+    };
+
+    /*----------------------------------
+    - INIT
+    ----------------------------------*/
+
+    public constructor() {
+
+        const self = 'self' as unknown as Application;
+
+        // 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) => {
+
+            // Log so we know it's coming from unhandledRejection
+            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);
+        });
+
+        // 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)
+        );
+    }
+
+    /*----------------------------------
+    - COMMANDS
+    ----------------------------------*/
+
+    private commandsManager = new CommandsManager(this, { debug: true }, {}, this);
+
+    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);
+        const startTime = Date.now();
+
+        this.startServices();
+
+        console.log('----------------------------------');
+        console.log('- SERVICES');
+        console.log('----------------------------------');
+        const startingServices = await this.ready();
+        await Promise.all(startingServices);
+        console.log('All services are ready');
+        await this.runHook('ready');
+
+        const startedTime = (Date.now() - startTime) / 1000;
+        console.info(`[boot] Application launched in ${startedTime}s`);
+        this.launched = true;
+    }
+
+    /*----------------------------------
+    - ERROR HANDLING
+    ----------------------------------*/
+
+    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();
+            } catch (error) {
+                console.error("Error while starting service", serviceId, error);
+                throw error;
+            }
+        }
+    }
+
+    public register( service: AnyService ) {
+
+        return service.ready();
+
+    }
+
+    protected async ready() {
+
+        const startingServices: Promise<any>[] = [];
+
+        // Print services
+        const processService = async (propKey: string, service: AnyService, level: number = 0) => {
+
+            if (service.status !== 'starting')
+                return;
+
+            // Services start shouldn't block app boot
+            // use await ServiceName.started to make services depends on each other
+            service.starting = service.ready();
+            startingServices.push(service.starting);
+            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];
+
+                // Check if service
+                const isService = 
+                    typeof propValue === 'object' && 
+                    !(propValue instanceof Application) &&
+                    propValue !== null && 
+                    propValue.status !== undefined;
+                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];
+
+            // TODO: move to router
+            //  Application.on('service.ready')
+            
+            // Services start shouldn't block app boot
+            processService(serviceId, service);
+        }
+
+        return startingServices;
+    }
+
+}
+
+export default Application

package/server/app/service/container.ts

@@ -0,0 +1,88 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Specific
+import type { 
+    AnyService, StartedServicesIndex,
+    // Hooks
+    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 TRegisteredServicesIndex<TServiceClass extends AnyService = AnyService> = {
+    [serviceId: string]: TRegisteredService<TServiceClass>
+}
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[service]';
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export class ServicesContainer<
+    TServicesIndex extends StartedServicesIndex = StartedServicesIndex
+> {
+
+    public registered: TRegisteredServicesIndex = {}
+
+    // All service instances by service id
+    public allServices: TServicesIndex = {} as TServicesIndex
+
+    public callableInstance = <TInstance extends object, TCallableName extends keyof TInstance>(
+        instance: TInstance, 
+        funcName: TCallableName
+    ): TInstance[TCallableName] & TInstance => {
+
+        const callableFunc = instance[funcName];
+        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 ),
+            // service.launch() isn't included, maybe because parent abstract class
+            'launch',
+            'bindServices'
+        ];
+
+        for (const method of methods)
+            if (method !== 'constructor')
+                callable[ method ] = typeof instance[ method ] === 'function'
+                    ? instance[ method ].bind( instance )
+                    : instance[ method ];
+
+        // Allow us to recognize a callable as a service 
+        callable.serviceInstance = instance;
+
+        return callable as TInstance[TCallableName] & TInstance;
+    }
+}
+
+export default new ServicesContainer

package/server/app/service/index.ts

@@ -0,0 +1,235 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import zod from 'zod';
+
+// Specific
+import type { Application } from "..";
+import type { Command } from "../commands"; 
+import type { TServiceMetas } from './container';
+import type { TControllerDefinition, TRoute } from '../../services/router';
+import { Anomaly } from "@common/errors";
+
+export { schema } from '../../services/router/request/validation/zod';
+export type { z } from '../../services/router/request/validation/zod';
+
+/*----------------------------------
+- TYPES: OPTIONS
+----------------------------------*/
+
+export type AnyService<TSubServices extends StartedServicesIndex = StartedServicesIndex> = 
+    Service<{}, {}, Application>
+
+export type { TRegisteredServicesIndex, TRegisteredService } from './container';
+
+/*----------------------------------
+- TYPES: HOOKS
+----------------------------------*/
+
+export type THookCallback<THookArgs extends THookOptions> = (...args: THookArgs["args"]) => Promise<void>;
+
+type THooksList = {
+    [hookName: string]: THookOptions
+}
+
+type THookOptions = {
+    args: any[]
+}
+
+export type THooksIndex<THooks extends THooksList> = {[name in keyof THooks]?: THookCallback< THooks[name] >[]}
+
+export type StartedServicesIndex = {
+    [serviceId: string]: AnyService
+}
+
+export type TServiceArgs<TService extends AnyService> = [
+    parent: AnyService | 'self',
+    config: null | undefined | TService['config'],
+    app: TService['app'] | 'self'
+]
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[service]';
+
+type TDecoratorArgs = (
+    [path: string] |
+    [path: string, schema: zod.ZodSchema] |
+    [path: string, schema: zod.ZodSchema, options?: Omit<TControllerDefinition, 'controller'|'schema'|'path'>] |
+    [options: Omit<TControllerDefinition, 'controller'>]
+)
+
+export function Route( ...args: TDecoratorArgs ) {
+
+    let path: string | undefined;
+    let schema: zod.ZodSchema | undefined;
+    let options: Omit<TControllerDefinition, 'controller'|'schema'|'path'> = {};
+
+    if (typeof args[0] === 'object') {
+        const { path: path_, schema: schema_, ...options_ } = args[0];
+        path = path_;
+        schema = schema_;
+        options = options_;
+    } else {
+        path = args[0];
+        schema = args[1];
+        options = args[2] || {};
+    }
+
+    return function (
+        target: any,
+        propertyKey: string,
+        descriptor: PropertyDescriptor
+    ) {
+        // Store the original method
+        const originalMethod = descriptor.value;
+
+        if (path === undefined)
+            path = target.constructor.name + '/' + propertyKey;
+
+        // Ensure the class has a static property to collect routes
+        if (!target.__routes) {
+            target.__routes = [];
+        }
+
+        // Create route object
+        const route: TRoute = {
+            method: 'POST',
+            path: '/api/' + path,
+            controller: originalMethod,
+            schema: schema,
+            options: {
+                priority: options.priority || 0
+            }
+        };
+        
+        // Add this route to the class's routes collection
+        target.__routes.push(route);
+
+        // Original method is unchanged, just registered with router
+        return descriptor;
+    };
+}
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default abstract class Service<
+    TConfig extends {}, 
+    THooks extends THooksList,
+    TApplication extends Application,
+    TParent extends AnyService
+> {
+
+    public started?: Promise<void>;
+    public status: 'stopped' | 'starting' | 'running' | 'paused' = 'starting';
+
+    public commands?: Command[];
+    public metas!: TServiceMetas;
+    public bindings: string[] = []
+
+    public parent: TParent;
+    public app: TApplication;
+    public config: TConfig = {} as TConfig;
+
+    public constructor(...[parent, config, app]: TServiceArgs<AnyService>) {
+
+        this.parent = parent;
+        if (this.parent === 'self') 
+            this.parent = this as unknown as TParent;
+
+        this.app = app === 'self'
+            ? this as unknown as TApplication
+            : app
+
+        this.config = config || {};
+        
+    }
+
+    public getServiceInstance() {
+        return this;
+    }
+
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    protected async ready(): Promise<void> {}
+
+    protected async shutdown(): Promise<void> {}
+
+    /*----------------------------------
+    - SUBSERVICES
+    ----------------------------------*/
+
+    // TODO:; babel plugin: transform Service references to app.use('Service')
+    public use<TService extends AnyService = AnyService>( 
+        serviceId: string,
+        useOptions: { optional?: boolean } = {}
+    ): TService | undefined {
+
+        const registeredService = this.app.registered[serviceId];
+        if (registeredService !== undefined) 
+            return this.app[ registeredService.name ];
+
+        if (useOptions.optional === false)
+            throw new Error(`Service ${registeredService} not registered.`);
+
+        return undefined;
+    }
+
+    /*----------------------------------
+    - HOOKS
+    ----------------------------------*/
+
+    public hooks: THooksIndex<THooks> = {}
+
+    public on<THookName extends keyof THooksList>( 
+        name: THookName, 
+        callback: THookCallback<THooksList[THookName]> 
+    ) {
+
+        const callbacks = this.hooks[ name ];
+        if (callbacks)
+            callbacks.push( callback );
+        else
+            this.hooks[ name ] = [callback]
+
+        return this;
+    }
+
+    public runHook<THookName extends keyof THooksList>( 
+        name: THookName, 
+        ...args: THooksList[THookName]["args"]
+    ) {
+
+        const callbacks = this.hooks[name];
+        if (!callbacks)
+            return;// console.info(LogPrefix, `No ${name} hook defined in the current service instance.`);
+
+        //this.config.debug && console.info(`[hook] Run all ${name} hook (${callbacks.length}).`);
+        return Promise.all( 
+            callbacks.map(
+                cb => cb(...args)
+            ) 
+        ).then(() => {
+            //this.config.debug && console.info(`[hook] Hooks ${name} executed with success.`);
+        }).catch(e => {
+            if (name === 'error') {
+
+                // In error hook = avoid infinite loop
+                console.error("Error hook", e);
+
+            } else {
+
+                // Let the error hook handle it
+                throw e;
+            }
+        })
+    }
+
+}

package/server/app.tsconfig.json

@@ -0,0 +1,28 @@
+{
+    "extends": "../../node_modules/proteum/tsconfig.common.json",
+    "compilerOptions": {
+        "rootDir": "..",
+        "baseUrl": "..",
+        "paths": {
+
+            "@/server/models": ["./server/.generated/models.ts"],
+
+            "@client/*": ["../node_modules/proteum/client/*"],
+            "@common/*": ["../node_modules/proteum/common/*"],
+            "@server/*": ["../node_modules/proteum/server/*"],
+
+            "@/*": ["./*"],
+
+            // ATTENTION: Les références à preact doivent toujours pointer vers la même instance
+            "react": ["preact/compat"],
+            "react-dom/test-utils": ["preact/test-utils"],
+            "react-dom": ["preact/compat"], // Must be below test-utils
+            "react/jsx-runtime": ["preact/jsx-runtime"]
+        }
+    },
+    
+    "include": [
+        ".",
+        "../../node_modules/proteum/types/global"
+    ]
+}

package/server/context.ts

@@ -0,0 +1,4 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import type { ChannelInfos } from '@server/app/container/console';
+
+export default new AsyncLocalStorage<ChannelInfos>();

package/server/index.ts

@@ -0,0 +1,4 @@
+import AppContainer from './app/container';
+import Application from '@/server/.generated/app';
+
+AppContainer.start( Application );