proteum 1.0.2 → 2.0.0

package/cli/app/index.ts

@@ -18,30 +18,30 @@ import type { TEnvConfig } from '../../server/app/container/config';
 - TYPES
 ----------------------------------*/
 
-export type TAppSide = 'server' | 'client'
-
-type TServiceSetup = {
-    id: string,
-    name: string,
-    config: {},
-    subservices: TServiceSubservices,
-    type: 'service.setup'
-}
+export type TAppSide = 'server' | 'client';
 
-type TServiceRef = {
-    refTo: string,
-    type: 'service.ref'
-}
+type TServiceSetup = { id: string; name: string; config: {}; subservices: TServiceSubservices; type: 'service.setup' };
 
-type TServiceSubservices = {
-    [key: string]: TServiceSetup | TServiceRef
-}
+type TServiceRef = { refTo: string; type: 'service.ref' };
+
+type TServiceSubservices = { [key: string]: TServiceSetup | TServiceRef };
+
+const parseRouterPortOverride = (rawPort: string | boolean | string[] | undefined): number | undefined => {
+    if (rawPort === undefined || rawPort === '') return undefined;
+
+    if (typeof rawPort !== 'string') throw new Error(`Invalid value for -port: expected a numeric value.`);
+
+    const port = Number(rawPort);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new Error(`Invalid value for -port: "${rawPort}". Expected an integer between 1 and 65535.`);
+
+    return port;
+};
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export class App {
-
     // config
     // WARNING: High level config files (env and services) shouldn't be loaded from the CLI
     //  The CLI will be run on CircleCI, and no env file should be sent to this service
@@ -49,36 +49,34 @@ export class App {
 
     public env: TEnvConfig;
 
-    public packageJson: {[key: string]: any};
+    public routerPortOverride?: number;
+
+    public devEventPort?: number;
+
+    public packageJson: { [key: string]: any };
 
     public buildId: number = Date.now();
 
     public paths = {
-
         root: cli.paths.appRoot,
-        bin: path.join( cli.paths.appRoot, 'bin'),
-        data: path.join( cli.paths.appRoot, 'var', 'data'),
-        public: path.join( cli.paths.appRoot, 'public'),
-        pages: path.join( cli.paths.appRoot, 'client', 'pages'),
-        cache: path.join( cli.paths.appRoot, '.cache'),
-
-        client: {
-            generated: path.join( cli.paths.appRoot, 'client', '.generated')
-        },
+        bin: path.join(cli.paths.appRoot, 'bin'),
+        dev: path.join(cli.paths.appRoot, 'dev'),
+        data: path.join(cli.paths.appRoot, 'var', 'data'),
+        public: path.join(cli.paths.appRoot, 'public'),
+        pages: path.join(cli.paths.appRoot, 'client', 'pages'),
+        cache: path.join(cli.paths.appRoot, '.cache'),
+
+        client: { generated: path.join(cli.paths.appRoot, 'client', '.generated') },
         server: {
-            generated: path.join( cli.paths.appRoot, 'server', '.generated'),
-            configs: path.join( cli.paths.appRoot, 'server', 'app')
+            generated: path.join(cli.paths.appRoot, 'server', '.generated'),
+            configs: path.join(cli.paths.appRoot, 'server', 'app'),
         },
-        common: {
-            generated: path.join( cli.paths.appRoot, 'common', '.generated')
-        },
-        
-        withAlias: (filename: string, side: TAppSide) => 
-            this.aliases[side].apply(filename),
+        common: { generated: path.join(cli.paths.appRoot, 'common', '.generated') },
 
-        withoutAlias: (filename: string, side: TAppSide) => 
-            this.aliases[side].realpath(filename),
-    }
+        withAlias: (filename: string, side: TAppSide) => this.aliases[side].apply(filename),
+
+        withoutAlias: (filename: string, side: TAppSide) => this.aliases[side].realpath(filename),
+    };
 
     public containerServices = [
         //'Services',
@@ -87,16 +85,20 @@ export class App {
         /*'Application',
         'Path',
         'Event'*/
-    ]
+    ];
 
     public constructor() {
-        
         cli.debug && console.log(`[cli] Loading app config ...`);
-        const configParser = new ConfigParser( cli.paths.appRoot );
+        this.routerPortOverride = parseRouterPortOverride(cli.args.port);
+
+        const configParser = new ConfigParser(cli.paths.appRoot, undefined, this.routerPortOverride);
         this.identity = configParser.identity();
         this.env = configParser.env();
         this.packageJson = this.loadPkg();
-        
+    }
+
+    public outputPath(target: 'dev' | 'bin') {
+        return target === 'dev' ? this.paths.dev : this.paths.bin;
     }
 
     /*----------------------------------
@@ -106,21 +108,15 @@ export class App {
     public aliases = {
         client: new TsAlias({
             rootDir: this.paths.root + '/client',
-            modulesDir: [ 
-                cli.paths.appRoot + '/node_modules',  
-                cli.paths.coreRoot + '/node_modules'
-            ],
-            debug: false
+            modulesDir: [cli.paths.appRoot + '/node_modules', cli.paths.coreRoot + '/node_modules'],
+            debug: false,
         }),
         server: new TsAlias({
             rootDir: this.paths.root + '/server',
-            modulesDir: [ 
-                cli.paths.appRoot + '/node_modules',  
-                cli.paths.coreRoot + '/node_modules'
-            ],
-            debug: false
+            modulesDir: [cli.paths.appRoot + '/node_modules', cli.paths.coreRoot + '/node_modules'],
+            debug: false,
         }),
-    }
+    };
 
     private loadPkg() {
         return fs.readJSONSync(this.paths.root + '/package.json');
@@ -130,66 +126,62 @@ export class App {
     - WARMUP (Services awareness)
     ----------------------------------*/
 
-    public registered = {}
-
-    public use( referenceName: string ): TServiceRef {
+    public registered = {};
 
+    public use(referenceName: string): TServiceRef {
         // We don't check because all service are not regstered when we register subservices
         /*if (this.registered[referenceName] === undefined) {
             throw new Error(`Service ${referenceName} is not registered`);
         }*/
 
-        return {
-            refTo: referenceName,
-            type: 'service.ref'
-        }
+        return { refTo: referenceName, type: 'service.ref' };
     }
 
-    public setup(...args: [
-        // { user: app.setup('Core/User') }
-        servicePath: string,
-        serviceConfig?: {},
-    ] | [
-        // app.setup('User', 'Core/User')
-        serviceName: string, 
-        servicePath: string,
-        serviceConfig?: {},
-    ]): TServiceSetup {
-
+    public setup(
+        ...args:
+            | [
+                  // { user: app.setup('Core/User') }
+                  servicePath: string,
+                  serviceConfig?: {},
+              ]
+            | [
+                  // app.setup('User', 'Core/User')
+                  serviceName: string,
+                  servicePath: string,
+                  serviceConfig?: {},
+              ]
+    ): TServiceSetup {
         // Registration to app root
         if (typeof args[1] === 'string') {
-            
             const [name, id, config] = args;
 
-            const service = { id, name, config, type: 'service.setup' } as TServiceSetup
+            const service = { id, name, config, type: 'service.setup' } as TServiceSetup;
 
             this.registered[name] = service;
 
             return service;
 
-        // Scoped to a parent service
+            // Scoped to a parent service
         } else {
-
             const [id, config] = args;
 
-            const service = { id, config, type: 'service.setup' } as TServiceSetup
+            const service = { id, config, type: 'service.setup' } as TServiceSetup;
 
             return service;
         }
     }
 
     public async warmup() {
-
         // Require all config files in @/server/config
         const configDir = path.resolve(cli.paths.appRoot, 'server', 'config');
         const configFiles = fs.readdirSync(configDir);
         for (const configFile of configFiles) {
-            console.log("Loading config file:", configFile);
-            require( path.resolve(configDir, configFile) );
+            console.log('Loading config file:', configFile);
+            require(path.resolve(configDir, configFile));
         }
     }
 }
 
-export const app = new App
+export const app = new App();
 
-export default app
+export default app;

package/cli/bin.js

@@ -23,7 +23,7 @@ if (!process.env.TS_NODE_IGNORE) {
         // Default ts-node ignore rule (works when deps are nested under `../node_modules/...`)
         '(node_modules\/(?!proteum\/))|(\.generated\/)|(\.cache\/)',
         // Extra rule for deps hoisted next to Proteum (ex: `../../tailwindcss/...`)
-        '^\\.\\./\\.\\./(?!\\./|\\.\\./)[^/]+/'
+        '^\\.\\./\\.\\./(?!\\./|\\.\\./)[^/]+/',
     ].join(',');
 }
 

package/cli/commands/build.ts

@@ -2,33 +2,70 @@
 - DEPENDANCES
 ----------------------------------*/
 
-// Npm
-import prompts from 'prompts';
+// Core
+import cli from '..';
+import { app } from '../app';
 
 // Configs
 import Compiler from '../compiler';
+import type { TCompileMode } from '../compiler/common';
+import {
+    getClientBundleAnalysisReportPaths,
+    waitForClientBundleAnalysisArtifacts,
+} from '../compiler/common/bundleAnalysis';
 
-/*----------------------------------
-- TYPES
-----------------------------------*/
+const allowedBuildArgs = new Set(['prod', 'cache', 'analyze']);
 
 /*----------------------------------
 - COMMAND
 ----------------------------------*/
-export const run = (): Promise<void> => new Promise(async (resolve) => {
+function resolveBuildMode(): TCompileMode {
+    const enabledArgs = Object.entries(cli.args)
+        .filter(([name, value]) => name !== 'workdir' && value === true)
+        .map(([name]) => name);
+
+    const invalidArgs = enabledArgs.filter((arg) => !allowedBuildArgs.has(arg));
+    if (invalidArgs.length > 0)
+        throw new Error(`Unknown build argument(s): ${invalidArgs.join(', ')}. Allowed values: prod, cache, analyze.`);
+
+    const requestedModes = enabledArgs.filter((arg): arg is TCompileMode => arg === 'prod');
+    if (requestedModes.length > 1)
+        throw new Error(`Please specify only one build mode. Received: ${requestedModes.join(', ')}.`);
 
-    const compiler = new Compiler('prod');
+    return requestedModes[0] ?? 'prod';
+}
 
+export const run = async (): Promise<void> => {
+    const mode = resolveBuildMode();
+    const compiler = new Compiler(mode, {}, false, 'bin');
     const multiCompiler = await compiler.create();
 
-    multiCompiler.run((error, stats) => {
+    await new Promise<void>((resolve, reject) => {
+        multiCompiler.run((error, stats) => {
+            if (error) {
+                console.error('An error occurred during the compilation:', error);
+                reject(error);
+                return;
+            }
 
-        if (error) {
-            console.error("An error occurred during the compilation:", error);
-            throw error;
-        }
+            if (stats?.hasErrors()) {
+                reject(new Error(`Compilation failed for build mode "${mode}".`));
+                return;
+            }
 
-        //resolve();
+            if (cli.args.analyze === true) {
+                waitForClientBundleAnalysisArtifacts(app, 'bin')
+                    .then(() => {
+                        const { reportPath, statsPath } = getClientBundleAnalysisReportPaths(app, 'bin');
+                        console.info(`Client bundle analysis report: ${reportPath}`);
+                        console.info(`Client bundle analysis stats: ${statsPath}`);
+                        resolve();
+                    })
+                    .catch(reject);
+                return;
+            }
 
+            resolve();
+        });
     });
-});
+};

package/cli/commands/check.ts

@@ -0,0 +1,19 @@
+import cli from '..';
+import { refreshGeneratedTypings, runAppLint, runAppTypecheck } from '../utils/check';
+
+const validateCheckArgs = () => {
+    const enabledArgs = Object.entries(cli.args).filter(([name, value]) => name !== 'workdir' && value === true);
+
+    if (enabledArgs.length > 0)
+        throw new Error(
+            `Unknown check argument(s): ${enabledArgs.map(([name]) => name).join(', ')}. This command does not accept options.`,
+        );
+};
+
+export const run = async (): Promise<void> => {
+    validateCheckArgs();
+
+    await refreshGeneratedTypings();
+    await runAppTypecheck();
+    await runAppLint();
+};

package/cli/commands/deploy/app.ts

@@ -13,17 +13,13 @@ import { api } from '../../utils';
 - COMMAND
 ----------------------------------*/
 export async function run() {
-
     const { project, local } = cli.args;
 
-    const versionfile = fs.readFileSync( project + '/version.txt', 'utf-8' );
+    const versionfile = fs.readFileSync(project + '/version.txt', 'utf-8');
 
     const [platform, version, build] = versionfile.split('\n');
 
     console.log({ project, platform, version, build });
-    
-    await cli.shell(
-        api('POST', '/app/release', { platform, version, build }, local)
-    );
-    
-}
+
+    await cli.shell(api('POST', '/app/release', { platform, version, build }, local));
+}

package/cli/commands/deploy/web.ts

@@ -10,51 +10,47 @@ import prompts from 'prompts';
 import cli from '../..';
 import { api } from '../../utils';
 
-0/*----------------------------------
+0; /*----------------------------------
 - HELPERS
 ----------------------------------*/
 
 const mergeDeps = ({ dependencies: coreDeps }, { dependencies: appDeps }) => {
     for (const dep in appDeps)
         if (dep in coreDeps) {
-
             if (coreDeps[dep] !== appDeps[dep])
-                throw new Error(`Duplicate dependency "${dep}" with different version in core (${coreDeps[dep]}) and app (${appDeps[dep]})`);
-            else
-                console.warn(`Duplicate dependency "${dep}" in core and app`);
-
-        } else
-            coreDeps[dep] = appDeps[dep];
+                throw new Error(
+                    `Duplicate dependency "${dep}" with different version in core (${coreDeps[dep]}) and app (${appDeps[dep]})`,
+                );
+            else console.warn(`Duplicate dependency "${dep}" in core and app`);
+        } else coreDeps[dep] = appDeps[dep];
     return coreDeps;
-}
+};
 
 const toast = (type: string, title: string, content: string) =>
-    api('POST', '/admin/api/notification', { type, title, content }, true)
+    api('POST', '/admin/api/notification', { type, title, content }, true);
 
 /*----------------------------------
 - COMMAND
 ----------------------------------*/
 export async function run() {
-
     const { simulate } = cli.args;
 
     const temp = app.paths.root + '/.deployment';
     fs.emptyDirSync(temp);
 
     // Merge package.json: framework + app
-    fs.outputJSONSync(temp + '/package.json', {
-        ...appPkg,
-        dependencies: mergeDeps(cli.packageJson, appPkg),
-        devDependencies: {}
-    }, { spaces: 4 });
+    fs.outputJSONSync(
+        temp + '/package.json',
+        { ...appPkg, dependencies: mergeDeps(cli.packageJson, appPkg), devDependencies: {} },
+        { spaces: 4 },
+    );
 
     // Copy config file
-    fs.copyFileSync( app.paths.root + (simulate ? '/env.yaml' : '/env.server.yaml'), temp + '/env.yaml' );
+    fs.copyFileSync(app.paths.root + (simulate ? '/env.yaml' : '/env.server.yaml'), temp + '/env.yaml');
 
     // Compile & Run Docker
     await cli.shell(`docker compose up --build`);
-    toast("info", "Server update", "A server update will start. You might experience some temporary slowdowns.")
+    toast('info', 'Server update', 'A server update will start. You might experience some temporary slowdowns.');
 
     fs.removeSync(temp);
-
-}
+}