proteum 2.0.0 → 2.1.0

package/server/app/commands.ts

@@ -3,12 +3,12 @@
 ----------------------------------*/
 
 // Npm
-import yargsParser from 'yargs-parser';
+import { Cli, Command as ClipanionCommand, Option, UsageError } from 'clipanion';
 
 // Core
 import type { Application } from './index';
 import Service from '@server/app/service';
-import { NotFound } from '@common/errors';
+import { InputError, NotFound } from '@common/errors';
 
 /*----------------------------------
 - TYPES
@@ -16,9 +16,9 @@ import { NotFound } from '@common/errors';
 
 type CommandCallback<TArgs extends any[]> = (...args: TArgs) => Promise<any>;
 
-export type CommandsList = { [commandName: string]: Command };
+export type CommandsList = { [commandName: string]: RuntimeCommand };
 
-export type Command<TArgs extends any[] = any[]> = {
+export type RuntimeCommand<TArgs extends any[] = any[]> = {
     name: string;
     description: string;
     run?: CommandCallback<TArgs>;
@@ -37,6 +37,166 @@ export type Hooks = {};
 
 export type Services = {};
 
+type TCommandArgumentValue = string | number | boolean;
+type TParsedCommandArgs = { [key: string]: TCommandArgumentValue | TCommandArgumentValue[] };
+
+const commandValuePattern = /^-?(?:\d+|\d*\.\d+)$/;
+
+const tokenizeCommandString = (commandString: string) => {
+    const tokens: string[] = [];
+    let currentToken = '';
+    let quote: '"' | "'" | undefined;
+    let escaping = false;
+
+    for (const character of commandString) {
+        if (escaping) {
+            currentToken += character;
+            escaping = false;
+            continue;
+        }
+
+        if (character === '\\') {
+            escaping = true;
+            continue;
+        }
+
+        if (quote) {
+            if (character === quote) {
+                quote = undefined;
+                continue;
+            }
+
+            currentToken += character;
+            continue;
+        }
+
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+
+        if (/\s/.test(character)) {
+            if (!currentToken) continue;
+
+            tokens.push(currentToken);
+            currentToken = '';
+            continue;
+        }
+
+        currentToken += character;
+    }
+
+    if (escaping) currentToken += '\\';
+    if (currentToken) tokens.push(currentToken);
+
+    return tokens;
+};
+
+const isOptionToken = (token: string) => /^-(?!\d+(\.\d+)?$).+/.test(token);
+
+const normalizeCommandValue = (value: string): TCommandArgumentValue => {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    if (commandValuePattern.test(value)) return Number(value);
+
+    return value;
+};
+
+const addParsedArgValue = (args: TParsedCommandArgs, key: string, value: TCommandArgumentValue) => {
+    const existingValue = args[key];
+
+    if (existingValue === undefined) {
+        args[key] = value;
+        return;
+    }
+
+    args[key] = Array.isArray(existingValue) ? [...existingValue, value] : [existingValue, value];
+};
+
+const parseCommandOptionTokens = (tokens: string[]) => {
+    const namedArguments: TParsedCommandArgs = {};
+    const positionalArguments: string[] = [];
+
+    let usePositionalOnly = false;
+
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+
+        if (usePositionalOnly) {
+            positionalArguments.push(token);
+            continue;
+        }
+
+        if (token === '--') {
+            usePositionalOnly = true;
+            continue;
+        }
+
+        if (token === '--help' || token === '-h') return { help: true as const, args: namedArguments, positionalArguments };
+
+        if (token.startsWith('--') && token.length > 2) {
+            const body = token.slice(2);
+
+            if (body.startsWith('no-') && body.length > 3) {
+                addParsedArgValue(namedArguments, body.slice(3), false);
+                continue;
+            }
+
+            const equalsIndex = body.indexOf('=');
+
+            if (equalsIndex >= 0) {
+                addParsedArgValue(
+                    namedArguments,
+                    body.slice(0, equalsIndex),
+                    normalizeCommandValue(body.slice(equalsIndex + 1)),
+                );
+                continue;
+            }
+
+            const nextToken = tokens[index + 1];
+
+            if (nextToken !== undefined && !isOptionToken(nextToken)) {
+                addParsedArgValue(namedArguments, body, normalizeCommandValue(nextToken));
+                index++;
+                continue;
+            }
+
+            addParsedArgValue(namedArguments, body, true);
+            continue;
+        }
+
+        if (token.startsWith('-') && token.length > 1 && !commandValuePattern.test(token)) {
+            const body = token.slice(1);
+            const equalsIndex = body.indexOf('=');
+
+            if (equalsIndex >= 0) {
+                addParsedArgValue(
+                    namedArguments,
+                    body.slice(0, equalsIndex),
+                    normalizeCommandValue(body.slice(equalsIndex + 1)),
+                );
+                continue;
+            }
+
+            const nextToken = tokens[index + 1];
+
+            if (body.length === 1 && nextToken !== undefined && !isOptionToken(nextToken)) {
+                addParsedArgValue(namedArguments, body, normalizeCommandValue(nextToken));
+                index++;
+                continue;
+            }
+
+            for (const shortFlag of body) addParsedArgValue(namedArguments, shortFlag, true);
+
+            continue;
+        }
+
+        positionalArguments.push(token);
+    }
+
+    return { help: false as const, args: namedArguments, positionalArguments };
+};
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
@@ -45,68 +205,192 @@ export default class CommandsManager extends Service<Config, Hooks, Application>
 
     public commandsIndex: CommandsList = {};
 
+    private runtimeCli?: Cli;
+
     public command<TArgs extends any[]>(
         ...args:
-            | [name: string, description: string, childrens: Command[]]
-            | [name: string, description: string, run: CommandCallback<TArgs>, childrens?: Command[]]
-    ): Command {
+            | [name: string, description: string, childrens: RuntimeCommand[]]
+            | [name: string, description: string, run: CommandCallback<TArgs>, childrens?: RuntimeCommand[]]
+    ): RuntimeCommand {
         let name: string, description: string;
-        let childrens: Command[] | undefined;
+        let childrens: RuntimeCommand[] | undefined;
         let run: CommandCallback<TArgs> | undefined;
 
         if (typeof args[2] === 'object') [name, description, childrens] = args;
         else [name, description, run, childrens] = args;
 
-        const command: Command = { name, description, run, childrens: childrens ? this.indexFromList(childrens) : {} };
+        const command: RuntimeCommand = { name, description, run, childrens: childrens ? this.indexFromList(childrens) : {} };
 
         return command;
     }
 
-    private indexFromList(list: Command[]): CommandsList {
+    private indexFromList(list: RuntimeCommand[]): CommandsList {
         const index: CommandsList = {};
         for (const command of list) index[command.name] = command;
 
         return index;
     }
 
+    private invalidateRuntimeCli() {
+        this.runtimeCli = undefined;
+    }
+
+    private createRuntimeCommandClass(command: RuntimeCommand, path: string[]) {
+        const manager = this;
+        const usage = ClipanionCommand.Usage({ description: command.description });
+
+        if (command.run === undefined) {
+            class RuntimeNamespaceCommand extends ClipanionCommand {
+                public static override paths = [path];
+                public static override usage = usage;
+
+                public async execute() {
+                    throw new NotFound(`This command isn't runnable.`);
+                }
+            }
+
+            Object.defineProperty(RuntimeNamespaceCommand, 'name', {
+                value: `${path.map((segment) => segment.replace(/[^A-Za-z0-9]/g, '_')).join('_') || 'Root'}NamespaceCommand`,
+            });
+
+            return RuntimeNamespaceCommand;
+        }
+
+        class RuntimeRunnableCommand extends ClipanionCommand {
+            public static override paths = [path];
+            public static override usage = usage;
+
+            public proxy = Option.Proxy({ name: 'args' });
+
+            public async execute() {
+                return manager.executeRegisteredCommand(command, path, this.proxy);
+            }
+        }
+
+        Object.defineProperty(RuntimeRunnableCommand, 'name', {
+            value: `${path.map((segment) => segment.replace(/[^A-Za-z0-9]/g, '_')).join('_') || 'Root'}RunnableCommand`,
+        });
+
+        return RuntimeRunnableCommand;
+    }
+
+    private createRuntimeCli() {
+        const cli = new Cli({
+            binaryName: this.app.identity.identifier || 'app',
+            enableCapture: false,
+        });
+
+        const registerCommands = (commands: CommandsList, parentPath: string[] = []) => {
+            for (const command of Object.values(commands)) {
+                const path = [...parentPath, command.name];
+
+                cli.register(this.createRuntimeCommandClass(command, path));
+
+                if (Object.keys(command.childrens).length > 0) registerCommands(command.childrens, path);
+            }
+        };
+
+        registerCommands(this.commandsIndex);
+
+        return cli;
+    }
+
+    private getRuntimeCli() {
+        this.runtimeCli ??= this.createRuntimeCli();
+
+        return this.runtimeCli;
+    }
+
+    private async executeRegisteredCommand(command: RuntimeCommand, path: string[], proxyTokens: string[]) {
+        if (command.run === undefined) throw new NotFound(`This command isn't runnable.`);
+
+        const { help, args, positionalArguments } = parseCommandOptionTokens(proxyTokens);
+
+        this.config.debug &&
+            console.log(LogPrefix, `Run command path: ${path.join(' ')} | Parsed proxy tokens:`, {
+                proxyTokens,
+                args,
+                positionalArguments,
+            });
+
+        if (help) {
+            const cli = this.getRuntimeCli();
+            const runtimeCommand = cli.process(path, Cli.defaultContext);
+
+            return cli.usage(runtimeCommand, { detailed: true });
+        }
+
+        if (positionalArguments.length > 0) {
+            throw new UsageError(
+                `Unexpected positional arguments for "${path.join(' ')}": ${positionalArguments.join(', ')}.`,
+            );
+        }
+
+        const argsList = Object.values(args);
+
+        return command.run(...(argsList as Parameters<NonNullable<typeof command.run>>));
+    }
+
+    private createRuntimeCliApi(cli: Cli) {
+        return {
+            binaryLabel: cli.binaryLabel,
+            binaryName: cli.binaryName,
+            binaryVersion: cli.binaryVersion,
+            enableCapture: cli.enableCapture,
+            enableColors: cli.enableColors,
+            definitions: () => cli.definitions(),
+            definition: (commandClass: any) => cli.definition(commandClass),
+            error: (error: Error, opts?: any) => cli.error(error, opts),
+            format: (colored?: boolean) => cli.format(colored),
+            process: (input: string[]) => cli.process(input, Cli.defaultContext),
+            run: (input: string[]) => cli.run(input, Cli.defaultContext),
+            usage: (command?: any, opts?: any) => cli.usage(command, opts),
+        };
+    }
+
     /*----------------------------------
     - REGISTER
     ----------------------------------*/
-    public fromList(list: Command[]) {
+    public fromList(list: RuntimeCommand[]) {
         for (const command of list) {
             if (this.commandsIndex[command.name] !== undefined)
                 throw new Error(`Tried to register command "${command.name}", but it already has been defined.`);
 
             this.commandsIndex[command.name] = command;
         }
+
+        this.invalidateRuntimeCli();
     }
 
     /*----------------------------------
     - RUN
     ----------------------------------*/
     public async run(commandString: string) {
-        const { _, ...args } = yargsParser(commandString);
+        const tokens = tokenizeCommandString(commandString);
 
-        this.config.debug && console.log(LogPrefix, `Run command: ${commandString} | Parsed:`, { _, ...args });
+        this.config.debug && console.log(LogPrefix, `Run command: ${commandString} | Tokens:`, tokens);
 
-        let command: Command | undefined;
-        for (const commandName of _) {
-            const commandsList: CommandsList = command === undefined ? this.commandsIndex : command.childrens;
+        if (tokens.length === 0) throw new NotFound(`Command not found.`);
 
-            command = commandsList[commandName];
+        const cli = this.getRuntimeCli();
 
-            if (command === undefined) break;
-        }
+        try {
+            const command = cli.process(tokens, Cli.defaultContext);
 
-        if (command === undefined) throw new NotFound(`Command not found.`);
+            if (command.help) return cli.usage(command, { detailed: true });
 
-        if (command.run === undefined) throw new NotFound(`This command isn't runnable.`);
+            command.context = Cli.defaultContext;
+            command.cli = this.createRuntimeCliApi(cli);
 
-        // TODO: order correctly & validate type according to injected typescript typedefs (command.run.params)
-        const argsList = Object.values(args);
+            return await command.validateAndExecute();
+        } catch (error) {
+            if (error instanceof UsageError) throw new InputError(error.message);
 
-        const result = await command.run(...(argsList as Parameters<NonNullable<typeof command.run>>));
+            if (error instanceof Error && ['UnknownSyntaxError', 'AmbiguousSyntaxError'].includes(error.name)) {
+                throw new NotFound(error.message);
+            }
 
-        return result;
+            throw error;
+        }
     }
 }

package/server/app/container/config.ts

@@ -122,7 +122,7 @@ export default class ConfigParser {
     public env(): TEnvConfig {
         // We assume that when we run 5htp dev, we're in local
         // Otherwise, we're in production environment (docker)
-        console.log('[app] Using environment:', process.env.NODE_ENV);
+        debug && console.info('[app] Using environment:', process.env.NODE_ENV);
         const envFileName = this.appDir + '/env.yaml';
         const envFile = this.loadYaml(envFileName);
         const routerPortOverride = getRouterPortOverride();

package/server/app/container/index.ts

@@ -38,8 +38,8 @@ export class ApplicationContainer<TServicesIndex extends StartedServicesIndex =
         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') },
+        client: { generated: path.join(process.cwd(), '.proteum', 'client') },
+        server: { generated: path.join(process.cwd(), '.proteum', 'server') },
     };
 
     /*----------------------------------

package/server/app/controller/index.ts

@@ -8,6 +8,7 @@ import zod from 'zod';
 // Core
 import context from '@server/context';
 import type { Application } from '../index';
+import type { TServiceModelsClient } from '../service';
 import type { TRouterContext, TAnyRouter } from '@server/services/router';
 import {
     toValidationSchema,
@@ -22,7 +23,15 @@ export type { z } from '@server/services/router/request/validation/zod';
 - TYPES
 ----------------------------------*/
 
-type TControllerContext = TRouterContext<TAnyRouter>;
+type TControllerRouter<TApplication extends Application = Application> = TApplication extends { Router: infer TRouter }
+    ? TRouter extends TAnyRouter
+        ? TRouter
+        : TAnyRouter
+    : TAnyRouter;
+
+export type TControllerRequestContext<TApplication extends Application = Application> = TRouterContext<
+    TControllerRouter<TApplication>
+>;
 
 /*----------------------------------
 - CLASS
@@ -30,7 +39,7 @@ type TControllerContext = TRouterContext<TAnyRouter>;
 
 export default abstract class Controller<
     TApplication extends Application = Application,
-    TContext extends TControllerContext = TControllerContext,
+    TContext extends TControllerRequestContext<TApplication> = TControllerRequestContext<TApplication>,
 > {
     public constructor(public request: TContext) {}
 
@@ -42,9 +51,9 @@ export default abstract class Controller<
         return this.app;
     }
 
-    public get models() {
+    public get models(): TServiceModelsClient<TApplication> {
         const app = this.app as { models?: { client?: unknown }; Models?: { client?: unknown } };
-        return app.models?.client ?? app.Models?.client;
+        return (app.models?.client ?? app.Models?.client) as TServiceModelsClient<TApplication>;
     }
 
     public input<TSchema extends TValidationSchema>(schema: TSchema): zod.output<TSchema>;

package/server/app/index.ts

@@ -14,6 +14,7 @@ import { Anomaly } from '@common/errors';
 import { TBasicUser } from '@server/services/auth';
 
 export { default as Services } from './service/container';
+export type { ServiceConfig } from './service/container';
 export type { TEnvConfig as Environment } from './container/config';
 
 /*----------------------------------
@@ -34,6 +35,17 @@ export const Service = ServicesContainer;
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
 
 export type ApplicationProperties = Prettify<keyof Application>;
+export type RootServicesOf<TApplication extends Application = Application> = Prettify<{
+    [TKey in Exclude<keyof TApplication, ApplicationProperties> as TApplication[TKey] extends AnyService ? TKey : never]: TApplication[TKey];
+}>;
+
+const isServiceInstance = (value: unknown): value is AnyService => {
+    if (!value || typeof value !== 'object') return false;
+
+    const service = value as Partial<AnyService>;
+
+    return typeof service.runHook === 'function' && typeof service.getServiceInstance === 'function' && service.status !== undefined;
+};
 
 /*----------------------------------
 - FUNCTIONS
@@ -68,8 +80,6 @@ export abstract class Application<
     public debug: boolean = false;
     public launched: boolean = false;
 
-    protected abstract registered: { [serviceId: string]: { name: string; start: () => AnyService } };
-
     /*----------------------------------
     - INIT
     ----------------------------------*/
@@ -120,14 +130,8 @@ export abstract class Application<
         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;
@@ -139,65 +143,77 @@ export abstract class Application<
     - ERROR HANDLING
     ----------------------------------*/
 
-    private startServices() {
-        // Satrt services
-        for (const serviceId in this.registered) {
-            try {
-                const service = this.registered[serviceId];
-                const instance = service.start();
-                (this as Record<string, unknown>)[service.name] = instance.getServiceInstance();
-            } catch (error) {
-                console.error('Error while starting service', serviceId, error);
-                throw error;
-            }
+    private listRootServices(): Array<[string, AnyService]> {
+        return Object.keys(this)
+            .map((serviceName) => [serviceName, (this as Record<string, unknown>)[serviceName]] as const)
+            .filter(
+                ([, service]) =>
+                    isServiceInstance(service) &&
+                    service !== this &&
+                    service.parent === this &&
+                    service.app === this,
+            )
+            .map(([serviceName, service]) => [serviceName, service as AnyService]);
+    }
+
+    public getRootServices(): RootServicesOf<this> {
+        const services: Record<string, AnyService> = {};
+
+        for (const [serviceName, service] of this.listRootServices()) {
+            services[serviceName] = service;
         }
+
+        return services as RootServicesOf<this>;
+    }
+
+    public findService(serviceId: string): AnyService | undefined {
+        const rootServices = this.getRootServices() as Record<string, AnyService>;
+        const directService = rootServices[serviceId];
+        if (directService) return directService;
+
+        const serviceName = serviceId.split('/').pop();
+        if (!serviceName) return undefined;
+
+        return rootServices[serviceName];
     }
 
     public register(service: AnyService) {
-        return service.ready();
+        return (service as AnyService & { ready: () => Promise<any> }).ready();
     }
 
     public async ready() {
         const startingServices: Promise<any>[] = [];
 
-        // Print services
-        const processService = async (propKey: string, service: AnyService, level: number = 0) => {
+        const processService = async (_propKey: string, service: AnyService) => {
             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();
+            service.starting = (service as AnyService & { ready: () => Promise<any> }).ready();
             startingServices.push(service.starting);
             service.status = 'running';
-            console.log('-' + '-'.repeat(level * 1), propKey + ': ' + service.constructor.name);
 
             // Subservices
             for (const propKey in service) {
-                if (propKey === 'app') continue;
-                    const propValue = (service as Record<string, any>)[propKey];
+                if (propKey === 'app' || propKey === 'parent') continue;
+                const propValue = (service as Record<string, any>)[propKey];
 
                 // Check if service
-                const isService =
-                    typeof propValue === 'object' &&
-                    !(propValue instanceof Application) &&
-                    propValue !== null &&
-                    propValue.status !== undefined;
-                if (!isService) continue;
+                if (!isServiceInstance(propValue) || propValue instanceof Application) continue;
 
                 // Services start shouldn't block app boot
-                processService(propKey, propValue, level + 1);
+                processService(propKey, propValue);
             }
         };
 
-        for (const serviceId in this.registered) {
-            const registeredService = this.registered[serviceId];
-            const service = (this as Record<string, any>)[registeredService.name];
+        for (const [serviceName, service] of this.listRootServices()) {
+            const rootService = service as AnyService;
 
             // TODO: move to router
             //  Application.on('service.ready')
 
             // Services start shouldn't block app boot
-            processService(serviceId, service);
+            processService(serviceName, rootService);
         }
 
         return startingServices;