proteum 1.0.2 → 2.0.0-1

package/server/app/service/index.ts

@@ -2,15 +2,12 @@
 - DEPENDANCES
 ----------------------------------*/
 
-// Npm
-import zod from 'zod';
-
 // Specific
-import type { Application } from "..";
-import type { Command } from "../commands"; 
+import type { Application } from '../index';
+import type { Command } from '../commands';
 import type { TServiceMetas } from './container';
-import type { TControllerDefinition, TRoute } from '../../services/router';
-import { Anomaly } from "@common/errors";
+import context from '@server/context';
+import type { TRouterContext, TAnyRouter } from '../../services/router';
 
 export { schema } from '../../services/router/request/validation/zod';
 export type { z } from '../../services/router/request/validation/zod';
@@ -19,8 +16,7 @@ export type { z } from '../../services/router/request/validation/zod';
 - TYPES: OPTIONS
 ----------------------------------*/
 
-export type AnyService<TSubServices extends StartedServicesIndex = StartedServicesIndex> = 
-    Service<{}, {}, Application>
+export type AnyService = Service<{}, {}, Application, any>;
 
 export type { TRegisteredServicesIndex, TRegisteredService } from './container';
 
@@ -28,27 +24,49 @@ export type { TRegisteredServicesIndex, TRegisteredService } from './container';
 - TYPES: HOOKS
 ----------------------------------*/
 
-export type THookCallback<THookArgs extends THookOptions> = (...args: THookArgs["args"]) => Promise<void>;
+export type THookCallback<THookArgs extends THookOptions> = (...args: THookArgs['args']) => Promise<void>;
 
-type THooksList = {
-    [hookName: string]: THookOptions
-}
+type THooksList = { [hookName: string]: THookOptions };
 
-type THookOptions = {
-    args: any[]
-}
+type THookOptions = { args: any[] };
 
-export type THooksIndex<THooks extends THooksList> = {[name in keyof THooks]?: THookCallback< THooks[name] >[]}
+export type THooksIndex<THooks extends THooksList> = { [name in keyof THooks]?: THookCallback<THooks[name]>[] };
 
-export type StartedServicesIndex = {
-    [serviceId: string]: AnyService
-}
+export type StartedServicesIndex = { [serviceId: string]: AnyService };
+
+type TServiceRouter<TApplication extends Application> = TApplication extends { Router: infer TRouter }
+    ? TRouter extends TAnyRouter
+        ? TRouter
+        : TAnyRouter
+    : TAnyRouter;
 
-export type TServiceArgs<TService extends AnyService> = [
-    parent: AnyService | 'self',
-    config: null | undefined | TService['config'],
-    app: TService['app'] | 'self'
-]
+export type TServiceRequestContext<TApplication extends Application = Application> = TRouterContext<
+    TServiceRouter<TApplication>
+>;
+
+export type TServiceModelsClient<TApplication extends Application = Application> = TApplication extends {
+    Models: { client: infer TModels };
+}
+    ? TModels
+    : TApplication extends {
+            models: { client: infer TModels };
+        }
+      ? TModels
+      : never;
+
+export type TSetupConfig<TConfig> = TConfig extends (...args: any[]) => any
+    ? TConfig
+    : TConfig extends Array<infer TItem>
+      ? Array<TSetupConfig<TItem>>
+      : TConfig extends object
+        ? ({ [K in keyof TConfig]?: TSetupConfig<TConfig[K]> } & Record<string, unknown>)
+        : TConfig;
+
+export type TServiceArgs<TService extends { config: any; app: any; parent: any }> = [
+    parent: TService['parent'] | 'self',
+    config: null | undefined | TSetupConfig<TService['config']>,
+    app: TService['app'] | 'self',
+];
 
 /*----------------------------------
 - CONFIG
@@ -56,128 +74,100 @@ export type TServiceArgs<TService extends AnyService> = [
 
 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;
-    };
-}
+const resolveSelfReference = <TSelf extends object, TValue extends object>(
+    value: TValue | 'self',
+    self: TSelf,
+): TValue | (TSelf & TValue) => (value === 'self' ? (self as TSelf & TValue) : value);
 
 /*----------------------------------
 - CLASS
 ----------------------------------*/
 export default abstract class Service<
-    TConfig extends {}, 
+    TConfig extends {},
     THooks extends THooksList,
-    TApplication extends Application,
-    TParent extends AnyService
+    TApplication extends Application = Application,
+    TParent extends object = AnyService,
 > {
-
     public started?: Promise<void>;
+    public starting?: Promise<void>;
     public status: 'stopped' | 'starting' | 'running' | 'paused' = 'starting';
 
     public commands?: Command[];
     public metas!: TServiceMetas;
-    public bindings: string[] = []
+    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;
+    public constructor(
+        parent: TParent | 'self',
+        config: null | undefined | TSetupConfig<TConfig>,
+        app: TApplication | 'self',
+    ) {
+        this.parent = resolveSelfReference(parent, this) as TParent;
 
-        this.app = app === 'self'
-            ? this as unknown as TApplication
-            : app
+        this.app = resolveSelfReference(app, this) as TApplication;
 
-        this.config = config || {};
-        
+        this.config = (config || {}) as TConfig;
     }
 
     public getServiceInstance() {
         return this;
     }
 
+    public get services(): TApplication {
+        return this.app;
+    }
+
+    public get models(): TServiceModelsClient<TApplication> {
+        const app = this.app as {
+            models?: { client?: TServiceModelsClient<TApplication> };
+            Models?: { client?: TServiceModelsClient<TApplication> };
+        };
+        const models = app.models?.client ?? app.Models?.client;
+
+        if (!models)
+            throw new Error(`${this.constructor.name} tried to access models but no Models service is registered.`);
+
+        return models;
+    }
+
+    protected get request(): TServiceRequestContext<TApplication> {
+        const store = context.getStore() as { requestContext?: TServiceRequestContext<TApplication> } | undefined;
+        const requestContext = store?.requestContext;
+
+        if (!requestContext)
+            throw new Error(
+                `${this.constructor.name} tried to access request context outside of a controller request.`,
+            );
+
+        return requestContext;
+    }
+
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
 
-    protected async ready(): Promise<void> {}
+    protected async ready(): Promise<any> {}
 
-    protected async shutdown(): Promise<void> {}
+    protected async shutdown(): Promise<any> {}
 
     /*----------------------------------
     - SUBSERVICES
     ----------------------------------*/
 
-    // TODO:; babel plugin: transform Service references to app.use('Service')
-    public use<TService extends AnyService = AnyService>( 
+    public use<TService extends AnyService = AnyService>(
         serviceId: string,
-        useOptions: { optional?: boolean } = {}
+        useOptions: { optional?: boolean } = {},
     ): TService | undefined {
+        const app = this.app as {
+            registered?: Record<string, { name: string }>;
+        } & Record<string, unknown>;
+        const registeredService = app.registered?.[serviceId];
+        if (registeredService !== undefined) return app[registeredService.name] as TService;
 
-        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.`);
+        if (useOptions.optional === false) throw new Error(`Service ${registeredService} not registered.`);
 
         return undefined;
     }
@@ -186,50 +176,33 @@ export default abstract class Service<
     - HOOKS
     ----------------------------------*/
 
-    public hooks: THooksIndex<THooks> = {}
-
-    public on<THookName extends keyof THooksList>( 
-        name: THookName, 
-        callback: THookCallback<THooksList[THookName]> 
-    ) {
+    public hooks: THooksIndex<THooks> = {};
 
-        const callbacks = this.hooks[ name ];
-        if (callbacks)
-            callbacks.push( callback );
-        else
-            this.hooks[ name ] = [callback]
+    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"]
-    ) {
-
+    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.`);
+        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;
-            }
-        })
+        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/context.ts

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

package/server/index.ts

@@ -1,4 +1,28 @@
 import AppContainer from './app/container';
 import Application from '@/server/.generated/app';
+import { isServerHotReloadRequest, serverHotReloadMessageType } from '@common/dev/serverHotReload';
 
-AppContainer.start( Application );
+const application = AppContainer.start(Application);
+
+if (__DEV__ && typeof process.send === 'function') {
+    process.on('message', (message: unknown) => {
+        if (!isServerHotReloadRequest(message)) return;
+
+        void (async () => {
+            try {
+                await application.Router?.started;
+                await application.Router.reloadGeneratedDefinitions(message.changedFiles);
+
+                process.send?.({ type: serverHotReloadMessageType.succeeded, changedFiles: message.changedFiles });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.stack || error.message : String(error);
+
+                process.send?.({
+                    type: serverHotReloadMessageType.failed,
+                    changedFiles: message.changedFiles,
+                    error: errorMessage,
+                });
+            }
+        })();
+    });
+}