5htp 0.2.3 → 0.3.0-3

package/src/compiler/common/babel/routes/routes.ts

@@ -9,7 +9,7 @@ import generate from '@babel/generator';
 
 // Core
 import cli from '@cli';
-import App, { TAppSide } from '../../../../app';
+import { App, TAppSide } from '../../../../app';
 
 /*----------------------------------
 - WEBPACK RULE
@@ -17,19 +17,18 @@ import App, { TAppSide } from '../../../../app';
 
 type TOptions = {
     side: TAppSide,
-    app: App
+    app: App,
+    debug?: boolean
 }
 
 module.exports = (options: TOptions) => (
     [Plugin, options]
 )
 
-const debug = true;
-
 /*----------------------------------
 - PLUGIN
 ----------------------------------*/
-function Plugin(babel, { app, side }: TOptions) {
+function Plugin(babel, { app, side, debug }: TOptions) {
 
     const t = babel.types as typeof types;
 
@@ -41,7 +40,8 @@ function Plugin(babel, { app, side }: TOptions) {
     const plugin: PluginObj<{ 
 
         filename: string,
-        fileType: 'front' | 'back',
+        part: 'routes',
+        side: 'front' | 'back',
         processFile: boolean,
 
         // Identifier => Name
@@ -52,30 +52,44 @@ function Plugin(babel, { app, side }: TOptions) {
 
             this.filename = state.opts.filename as string;
             this.processFile = true;
+
+            // Relative path
+            let relativeFileName: string | undefined;
+            if (this.filename.startsWith( cli.paths.appRoot ))
+                relativeFileName = this.filename.substring( cli.paths.appRoot.length );
+            if (this.filename.startsWith( cli.paths.coreRoot ))
+                relativeFileName = this.filename.substring( cli.paths.coreRoot.length );
+            if (this.filename.startsWith('/node_modules/5htp-core/'))
+                relativeFileName = this.filename.substring( '/node_modules/5htp-core/'.length );
+            
+            // The file isn't a route definition
+            if (relativeFileName === undefined) {
+                this.processFile = false;
+                return false;
+            }
             
-            if (
-                this.filename.startsWith( cli.paths.appRoot + '/src/client/pages' )
-                ||
-                this.filename.startsWith( cli.paths.coreRoot + '/src/client/pages' )
-            ) {
+            // Differenciate back / front
+            if (relativeFileName.startsWith('/src/client/pages')) {
 
-                this.fileType = 'front';
+                this.side = 'front';
+                this.part = 'routes';
 
-            } else if (this.filename.startsWith( cli.paths.appRoot + '/src/server/routes' )) {
+            } else if (relativeFileName.startsWith('/src/server/routes')) {
 
-                this.fileType = 'back';
-            
-            } else
+                this.side = 'back';
+                this.part = 'routes';
+
+             } else 
                 this.processFile = false;
 
+            // Init output
             this.importedServices = {}
             this.routeDefinitions = []
-
         },
         visitor: {
 
             // Find @app imports
-            // Test:            import { router } from '@app';
+            // Test:            import { Router } from '@app';
             // Replace by:      nothing
             ImportDeclaration(path) {
 
@@ -98,10 +112,11 @@ function Plugin(babel, { app, side }: TOptions) {
 
                 // Remove this import
                 path.replaceWithMultiple([]);
+
             },
 
-            // Find router definitions
-            // Test:            router.xxx()
+            // Find Router definitions
+            // Test:            Router.xxx()
             // Replace by:      nothing
             CallExpression(path) {
 
@@ -131,7 +146,7 @@ function Plugin(babel, { app, side }: TOptions) {
 
                 // Client route definition: Add chunk id
                 let [routePath, ...routeArgs] = path.node.arguments;
-                if (this.fileType === 'front' && callee.object.name === 'router') {
+                if (this.side === 'front' && callee.object.name === 'Router') {
 
                     // Inject chunk id in options (2nd arg)
                     const newRouteArgs = injectChunkId(routeArgs, this.filename);
@@ -160,21 +175,24 @@ function Plugin(babel, { app, side }: TOptions) {
 
             // Wrap declarations into a exported const app function
             /*  
-                export const __register = ({ router }} => {
+                export const __register = ({ Router }} => {
 
-                    router.page(..)
+                    Router.page(..)
 
                 }
             */
             Program: {
                 exit: function(path, parent) {
 
+                    if (!this.processFile)
+                        return;
+
                     const importedServices = Object.entries(this.importedServices);
                     if (importedServices.length === 0)
                         return;
 
                     let exportValue: types.Expression | types.BlockStatement;
-                    if (this.fileType === 'front') {
+                    if (this.side === 'front') {
 
                         const routesDefCount = this.routeDefinitions.length;
                         if (routesDefCount !== 1)

package/src/compiler/common/plugins/indexage/icones-svg/index.ts

@@ -34,7 +34,7 @@ export default class IconesSVG extends Indexeur {
     private cacheTypes: string;
     private cacheIndex: string;
 
-    public constructor( app: App ) {
+    public constructor( app: App, private debug?: boolean ) {
         super();
 
         this.formats = ['woff2'];
@@ -46,18 +46,18 @@ export default class IconesSVG extends Indexeur {
 
         if (fs.existsSync(this.cacheIndex)) {
 
-            console.log('[icones] Getting icons list from cache ...');
+            this.debug && console.log('[icones] Getting icons list from cache ...');
             this.iconesExistantes = fs.readJSONSync(this.cacheIndex);
 
         } else {
 
-            console.log('[icones] Référencement des icones existantes ...');
+            this.debug && console.log('[icones] Référencement des icones existantes ...');
             this.iconesExistantes = this.refExistant('');
             fs.outputJSONSync(this.cacheIndex, this.iconesExistantes);
 
         }
 
-        console.log('[icones] ' + this.iconesExistantes.length + ' icones référencées');
+        this.debug && console.log('[icones] ' + this.iconesExistantes.length + ' icones référencées');
     }
 
     private refExistant = (dir: string): string[] => {
@@ -121,7 +121,7 @@ export default class IconesSVG extends Indexeur {
             typeIcones.push('"' + icone.nom + '"');
         }
 
-        console.log('[icones] Création police avec ' + typeIcones.length +' icones ...');
+        this.debug && console.log('[icones] Création police avec ' + typeIcones.length +' icones ...');
         //console.log('[icones] Liste des icones rféérencées: ', cheminIcones);
 
         const optionsMetadata = {
@@ -170,13 +170,12 @@ export default class IconesSVG extends Indexeur {
 
                 });
             }
-        })
-            .catch(error => {
-                console.error("Erreur lors de la création de la police d'icones", error);
-                throw error;
-            });
+        }).catch(error => {
+            console.error("Erreur lors de la création de la police d'icones", error);
+            throw error;
+        });
 
-        console.log('[icones] Enregistrement de la police avec ' + typeIcones.length +' icones ...');
+        this.debug && console.log('[icones] Enregistrement de la police avec ' + typeIcones.length +' icones ...');
 
         // Enregistrement fichiers
         for (const format of this.formats)
@@ -185,7 +184,7 @@ export default class IconesSVG extends Indexeur {
 
         fs.outputFileSync(this.cacheTypes, 'export type TIcones = ' + typeIcones.join('|') );
 
-        console.log("[icones] Police enregistrée.");
+        this.debug && console.log("[icones] Police enregistrée.");
 
         return [
             /*{ 

package/src/compiler/common/plugins/indexage/index.ts

@@ -1,9 +1,11 @@
 import Indexeur from './indexeur';
 
-import { Compiler } from 'webpack';
+import { Compiler, NormalModule } from 'webpack';
 
 type TListeIndexeurs = {[nom: string]: Indexeur}
 
+const debug = false;
+
 export default class SelecteursApiPlugin {
 
     public static metadataContextFunctionName = "metadataSelecteursApiPlugin";
@@ -21,14 +23,14 @@ export default class SelecteursApiPlugin {
         const nomCompileur = compiler.options.name;
 
         for (const nomIndexeur in this.indexeurs) {
-            console.log(`[indexage][${nomCompileur}][${nomIndexeur}] Init`);
+            debug && console.log(`[indexage][${nomCompileur}][${nomIndexeur}] Init`);
             this.indexeurs[nomIndexeur].Init();
         }
 
         compiler.hooks.compilation.tap("SelecteursApiPlugin", (compilation) => {
             //console.log("The compiler is starting a new compilation...");
 
-            compilation.hooks.normalModuleLoader.tap("SelecteursApiPlugin", (context, module) => {
+            NormalModule.getCompilationHooks(compilation).loader.tap("SelecteursApiPlugin", (context, module) => {
 
                 // Fonction de récupération des métadatas
                 context["metadataSelecteursApiPlugin"] = (metadata) => {
@@ -66,7 +68,7 @@ export default class SelecteursApiPlugin {
                     try {
                         if (this.indexeurs[nomIndexeur].derniereModif > this.indexeurs[nomIndexeur].derniereMaj) {
 
-                            console.log(`[indexage][${nomCompileur}][${nomIndexeur}] Enregistrement des modifications`);
+                            debug && console.log(`[indexage][${nomCompileur}][${nomIndexeur}] Enregistrement des modifications`);
 
                             this.indexeurs[nomIndexeur].derniereMaj = this.indexeurs[nomIndexeur].derniereModif;
                             const aEnregistrer = await this.indexeurs[nomIndexeur].Enregistrer();

package/src/compiler/index.ts

@@ -11,111 +11,272 @@ import SpeedMeasurePlugin from "speed-measure-webpack-plugin";
 const smp = new SpeedMeasurePlugin({ disable: true });
 
 // Core
+import app from '../app';
+import cli from '..';
 import createServerConfig from './server';
 import createClientConfig from './client';
 import { TCompileMode } from './common';
-import { fixNpmLinkIssues } from './common/utils/fixNpmLink'; 
-
-// types
-import type App from '../app';
 
 type TCompilerCallback = () => void
 
 /*----------------------------------
 - FONCTION
 ----------------------------------*/
-export const compiling: { [compiler: string]: Promise<void> } = {};
-
-export default async function createCompilers( 
-    app: App,
-    mode: TCompileMode,
-    { before, after }: {
-        before?: TCompilerCallback,
-        after?: TCompilerCallback,
-    } = {}
-) {
-
-    // Cleanup
-    fs.emptyDirSync( app.paths.bin );
-    fs.ensureDirSync( path.join(app.paths.bin, 'public') )
-    const publicFiles = fs.readdirSync(app.paths.public);
-    for (const publicFile of publicFiles) {
-        // Dev: faster to use symlink
-        if (mode === 'dev')
-            fs.symlinkSync( 
-                path.join(app.paths.public, publicFile), 
-                path.join(app.paths.bin, 'public', publicFile) 
-            );
-        // Prod: Symlink not always supported by CI / Containers solutions
-        else
-            fs.copySync( 
-                path.join(app.paths.public, publicFile), 
-                path.join(app.paths.bin, 'public', publicFile) 
-            );
+export default class Compiler {
+
+    public compiling: { [compiler: string]: Promise<void> } = {};     
+
+    public constructor(
+        private mode: TCompileMode,
+        private callbacks: {
+            before?: TCompilerCallback,
+            after?: TCompilerCallback,
+        } = {},
+        private debug: boolean = false
+    ) {
+
     }
 
+    public cleanup() {
+
+        fs.emptyDirSync( app.paths.bin );
+        fs.ensureDirSync( path.join(app.paths.bin, 'public') )
+        const publicFiles = fs.readdirSync(app.paths.public);
+        for (const publicFile of publicFiles) {
+            // Dev: faster to use symlink
+            if (this.mode === 'dev')
+                fs.symlinkSync( 
+                    path.join(app.paths.public, publicFile), 
+                    path.join(app.paths.bin, 'public', publicFile) 
+                );
+            // Prod: Symlink not always supported by CI / Containers solutions
+            else
+                fs.copySync( 
+                    path.join(app.paths.public, publicFile), 
+                    path.join(app.paths.bin, 'public', publicFile) 
+                );
+        }
+    }
     /* FIX issue with npm link
         When we install a module with npm link, this module's deps are not installed in the parent project scope
         Which causes some issues:
         - The module's deps are not found by Typescript
         - Including React, so VSCode shows that JSX is missing
     */
-    fixNpmLinkIssues(app);
-
-    // Create compilers
-    const multiCompiler = webpack([
-        smp.wrap( createServerConfig(app, mode) ),
-        smp.wrap( createClientConfig(app, mode) )
-    ]);
+    public fixNpmLinkIssues() {
+        const corePath = path.join(app.paths.root, '/node_modules/5htp-core');
+        if (!fs.lstatSync( corePath ).isSymbolicLink())
+            return console.info("Not fixing npm issue because 5htp-core wasn't installed with npm link.");
 
-    for (const compiler of multiCompiler.compilers) {
+        this.debug && console.info(`Fix NPM link issues ...`);
 
-        const name = compiler.name;
-        if (name === undefined)
-            throw new Error(`A name must be specified to each compiler.`);
+        const appModules = path.join(app.paths.root, 'node_modules');
+        const coreModules = path.join(corePath, 'node_modules');
 
-        let timeStart = new Date();
+        // When the 5htp package is installed from npm link,
+        // Modules are installed locally and not glbally as with with the 5htp package from NPM.
+        // So we need to symbilnk the http-core node_modules in one of the parents of server.js.
+        // It avoids errors like: "Error: Cannot find module 'intl'"
+        fs.symlinkSync( coreModules, path.join(app.paths.bin, 'node_modules') );
 
-        let finished: (() => void);
-        compiling[name] = new Promise((resolve) => finished = resolve);
+        // Same problem: when 5htp-core is installed via npm link, 
+        // Typescript doesn't detect React and shows mission JSX errors
+        const preactCoreModule = path.join(coreModules, 'preact');
+        const preactAppModule = path.join(appModules, 'preact');
+        const reactAppModule = path.join(appModules, 'react');
 
-        compiler.hooks.compile.tap(name, () => {
+        if (!fs.existsSync( preactAppModule ))
+            fs.symlinkSync( preactCoreModule, preactAppModule );
+        if (!fs.existsSync( reactAppModule ))
+            fs.symlinkSync( path.join(preactCoreModule, 'compat'), reactAppModule );
+    }
 
-            before && before();
+    private findServices( dir: string ) {
+        const files: string[] = [];
+        const dirents = fs.readdirSync(dir, { withFileTypes: true });
+        for (const dirent of dirents) {
+            const res = path.resolve(dir, dirent.name);
+            if (dirent.isDirectory()) {
+                files.push( ...this.findServices(res) );
+            } else if (dirent.name === 'service.json') {
+                files.push( path.dirname(res) );
+            }
+        }
+        return files;
+    }
 
-            compiling[name] = new Promise((resolve) => finished = resolve);
+    private indexServices() {
+        
+        const imported: string[] = []
+        const exportedType: string[] = []
+        const exportedMetas: string[] = []
 
-            timeStart = new Date();
-            console.info(`[${name}] ########## Compiling ...`);
-        });
+        // Index services
+        const searchDirs = {
+            '@server/services': path.join(cli.paths.core.src, 'server', 'services'),
+            '@/server/services': path.join(app.paths.src, 'server', 'services'),
+            // TODO: node_modules
+        }
 
-        /* TODO: Ne pas résoudre la promise tant que la recompilation des données indexées (icones, identité, ...) 
-            n'a pas été achevée */
-        compiler.hooks.done.tap(name, stats => {
+        for (const importationPrefix in searchDirs) {
 
-            // Affiche les détails de la compilation
-            console.info(stats.toString(compiler.options.stats));
+            const searchDir = searchDirs[ importationPrefix ];
+            const services = this.findServices(searchDir);
 
-            // Shiow status
-            const timeEnd = new Date();
-            const time = timeEnd.getTime() - timeStart.getTime();
-            if (stats.hasErrors()) {
-                console.error(`############## Failed to compile '${name}' after ${time} ms`);
+            for (const serviceDir of services) {
 
-                // Exit process with code 0, so the CI container can understand building failed
-                // Only in prod, because in dev, we want the compiler watcher continue running
-                if (mode === 'prod')
-                    process.exit(0);
+                const metasFile = path.join( serviceDir, 'service.json');
+                const { id, name, parent, dependences } = require(metasFile);
 
-            } else {
-                console.info(`############## [${name}] Finished compilation after ${time} ms`);
+                const importationPath = importationPrefix + serviceDir.substring( searchDir.length );
+                
+                // Generate index & typings
+                imported.push(`import type ${name} from "${importationPath}";`);
+                exportedType.push(`'${id}': ${name},`);
+                // NOTE: only import enabled packages to optimize memory
+                // TODO: don't index non-setuped packages in the exported metas
+                exportedMetas.push(`'${id}': {
+class: () => require("${importationPath}"),
+id: "${id}",
+name: "${name}",
+parent: "${parent}",
+dependences: ${JSON.stringify(dependences)},
+                },`);
             }
+        }
+
+        // Define the app class identifier
+        const appClassIdentifier = app.identity.identifier;
+        const containerServices = app.containerServices.map( s => "'" + s + "'").join('|');
+
+        // Output the services index
+        fs.outputFileSync(
+            path.join( app.paths.client.generated, 'services.d.ts'),
+`declare module "@app" {
+
+    import { CrossPathClient } from '@/client/index';
+
+    const appClass: CrossPathClient;
+
+    export = appClass
+}`
+        );
+
+        fs.outputFileSync(
+            path.join( app.paths.server.generated, 'services.ts'),
+`${imported.join('\n')}
+export type Services = {
+    ${exportedType.join('\n')}
+}
+export default {
+    ${exportedMetas.join('\n')}
+}`
+        );
+
+        fs.outputFileSync(
+            path.join( app.paths.server.generated, 'services.d.ts'),
+`type InstalledServices = import('./services').Services;
+
+declare type ${appClassIdentifier} = import("@/server").default;
+
+declare module "@app" {
+
+    import { ApplicationContainer } from '@server/app/container';
+
+    const ServerServices: (
+        Pick< 
+            ApplicationContainer<InstalledServices>, 
+            ${containerServices}
+        >
+        & 
+        ${appClassIdentifier}
+    )
+
+    export = ServerServices
+}
+
+declare module '@server/app' {
+
+    import { Application } from "@server/app/index";
+    import { ServicesContainer } from "@server/app/service/container";
+
+    export interface Exported {
+        Application: typeof Application,
+        Services: ServicesContainer<InstalledServices>,
+    }
+
+    const foo: Exported;
+
+    export = foo;
+}`
+        );
+    }
+
+    public async create() {
+
+        this.cleanup();
+
+        this.fixNpmLinkIssues();
+
+        this.indexServices();
+
+        // Create compilers
+        const multiCompiler = webpack([
+            smp.wrap( createServerConfig(app, this.mode) ),
+            smp.wrap( createClientConfig(app, this.mode) )
+        ]);
+
+        for (const compiler of multiCompiler.compilers) {
+
+            const name = compiler.name;
+            if (name === undefined)
+                throw new Error(`A name must be specified to each compiler.`);
+
+            let timeStart = new Date();
+
+            let finished: (() => void);
+            this.compiling[name] = new Promise((resolve) => finished = resolve);
+
+            compiler.hooks.compile.tap(name, () => {
+
+                this.callbacks.before && this.callbacks.before();
+
+                this.compiling[name] = new Promise((resolve) => finished = resolve);
+
+                timeStart = new Date();
+                console.info(`[${name}] Compiling ...`);
+            });
+
+            /* TODO: Ne pas résoudre la promise tant que la recompilation des données indexées (icones, identité, ...) 
+                n'a pas été achevée */
+            compiler.hooks.done.tap(name, stats => {
+
+                // Shiow status
+                const timeEnd = new Date();
+                const time = timeEnd.getTime() - timeStart.getTime();
+                if (stats.hasErrors()) {
+
+                    console.info(stats.toString(compiler.options.stats));
+                    console.error(`[${name}] Failed to compile after ${time} ms`);
+
+                    // Exit process with code 0, so the CI container can understand building failed
+                    // Only in prod, because in dev, we want the compiler watcher continue running
+                    if (this.mode === 'prod')
+                        process.exit(0);
+
+                } else {
+                    this.debug && console.info(stats.toString(compiler.options.stats));
+                    console.info(`[${name}] Finished compilation after ${time} ms`);
+                }
+
+                // Mark as finished
+                finished();
+                delete this.compiling[name];
+            });
+        }
+
+        return multiCompiler;
 
-            // Mark as finished
-            finished();
-            delete compiling[name];
-        });
     }
 
-    return multiCompiler;
 }

package/src/compiler/server/index.ts

@@ -179,7 +179,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
         ],
 
         optimization: {
-            minimizer: [
+            minimizer: dev ? [] : [
                 new TerserPlugin({
                     terserOptions: {
                         // Consere les classnames
@@ -191,9 +191,9 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
         },
 
         // https://webpack.js.org/configuration/devtool/#devtool
-        devtool: /*dev 
+        devtool: dev 
             ? 'eval-source-map' // Recommended choice for development builds with high quality SourceMaps.
-            :*/ 'source-map', // Recommended choice for production builds with high quality SourceMaps.
+            : 'source-map', // Recommended choice for production builds with high quality SourceMaps.
 
             // eval-source-map n'est pas précis
         /*devServer: {