5htp 0.4.6 → 0.5.9-4

package/{src/app → app}/config.ts

@@ -15,7 +15,7 @@ import fs from 'fs-extra';
 import yaml from 'yaml';
 
 // Types
-import type { TEnvConfig } from '../../../core/src/server/app/container/config';
+import type { TEnvConfig } from '../../core/server/app/container/config';
 
 /*----------------------------------
 - LOADE
@@ -38,12 +38,12 @@ 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)
-        return process.env.NODE_ENV === 'development' ? {
-            name: 'local',
-            profile: 'dev',
-        } : {
-            name: 'server',
-            profile: 'prod',
+        console.log("[app] Using environment:", process.env.NODE_ENV);
+        const envFileName = this.appDir + '/env.yaml';
+        const envFile = this.loadYaml( envFileName );
+        return {
+            ...envFile,
+            version: 'CLI'
         }
     }
 

package/app/index.ts

@@ -0,0 +1,190 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// npm
+import path from 'path';
+import TsAlias from 'ts-alias';
+import fs from 'fs-extra';
+
+// Cre
+import cli from '..';
+
+// Specific
+import ConfigParser from './config';
+import type { TEnvConfig } from '../../core/server/app/container/config';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TAppSide = 'server' | 'client'
+
+type TServiceSetup = {
+    id: string,
+    name: string,
+    config: {},
+    subservices: TServiceSubservices,
+    type: 'service.setup'
+}
+
+type TServiceRef = {
+    refTo: string,
+    type: 'service.ref'
+}
+
+type TServiceSubservices = {
+    [key: string]: TServiceSetup | TServiceRef
+}
+
+/*----------------------------------
+- 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
+    public identity: Config.Identity;
+
+    public env: TEnvConfig;
+
+    public packageJson: {[key: string]: any};
+
+    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')
+        },
+        server: {
+            generated: path.join( cli.paths.appRoot, 'server', '.generated'),
+            configs: path.join( cli.paths.appRoot, 'server', 'app')
+        },
+
+        withAlias: (filename: string, side: TAppSide) => 
+            this.aliases[side].apply(filename),
+
+        withoutAlias: (filename: string, side: TAppSide) => 
+            this.aliases[side].realpath(filename),
+    }
+
+    public containerServices = [
+        //'Services',
+        'Environment',
+        'Identity',
+        /*'Application',
+        'Path',
+        'Event'*/
+    ]
+
+    public constructor() {
+        
+        cli.debug && console.log(`[cli] Loading app config ...`);
+        const configParser = new ConfigParser( cli.paths.appRoot );
+        this.identity = configParser.identity();
+        this.env = configParser.env();
+        this.packageJson = this.loadPkg();
+        
+    }
+
+    /*----------------------------------
+    - ALIAS
+    ----------------------------------*/
+
+    public aliases = {
+        client: new TsAlias({
+            rootDir: this.paths.root + '/client',
+            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
+        }),
+    }
+
+    private loadPkg() {
+        return fs.readJSONSync(this.paths.root + '/package.json');
+    }
+
+    /*----------------------------------
+    - WARMUP (Services awareness)
+    ----------------------------------*/
+
+    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'
+        }
+    }
+
+    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
+
+            this.registered[name] = service;
+
+            return service;
+
+        // Scoped to a parent service
+        } else {
+
+            const [id, config] = args;
+
+            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) );
+        }
+    }
+}
+
+export const app = new App
+
+export default app

package/{src/commands → commands}/dev.ts

@@ -7,7 +7,7 @@ import fs from 'fs-extra';
 import { spawn, ChildProcess } from 'child_process';
 
 // Cor elibs
-import cli from '../';
+import cli from '..';
 import Keyboard from '../utils/keyboard';
 
 // Configs
@@ -51,7 +51,7 @@ export const run = () => new Promise<void>(async () => {
         // Ignore updated from:
         // - Node modules except 5HTP core (framework dev mode)
         // - Generated files during runtime (cause infinite loop. Ex: models.d.ts)
-        ignored: /(node_modules\/(?!5htp\-core\/src\/))|(\.generated\/)/
+        ignored: /(node_modules\/(?!5htp\-core\/))|(\.generated\/)/
 
         //aggregateTimeout: 1000,
     }, async (error, stats) => {

package/{src/commands → commands}/init.ts

@@ -10,7 +10,7 @@ import cmd from 'node-cmd';
 import replaceOnce from 'replace-once';
 
 // Cor elibs
-import cli from '../';
+import cli from '..';
 
 // Configs
 const filesToConfig = [

package/{src/compiler → compiler}/client/identite.ts

@@ -19,7 +19,7 @@ export default async ( app: App ) => {
 
         const identity = app.identity;
 
-        const response = await favicons( app.paths.root + '/src/client/assets/identity/logo.svg', {
+        const response = await favicons( app.paths.root + '/client/assets/identity/logo.svg', {
 
             path: '/assets/img/identite/favicons/',
             appName: identity.name,

package/{src/compiler → compiler}/client/index.ts

@@ -75,7 +75,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                     // https://github.com/webpack-contrib/webpack-hot-middleware#config
                     cli.paths.core.root + '/node_modules' + '/webpack-hot-middleware/client?name=client&reload=true',
                 ] : []),*/
-                cli.paths.core.root + '/src/client/index.ts'
+                cli.paths.core.root + '/client/index.ts'
             ]
         },
 
@@ -110,13 +110,13 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                     test: regex.scripts,
                     include: [
 
-                        app.paths.root + '/src/client',
-                        cli.paths.core.root + '/src/client',
+                        app.paths.root + '/client',
+                        cli.paths.core.root + '/client',
 
-                        app.paths.root + '/src/common',
-                        cli.paths.core.root + '/src/common',
+                        app.paths.root + '/common',
+                        cli.paths.core.root + '/common',
 
-                        app.paths.root + '/src/server/.generated/models.ts',
+                        app.paths.root + '/server/.generated/models.ts',
 
                     ],
                     rules: require('../common/babel')(app, 'client', dev)

package/{src/compiler → compiler}/common/babel/index.ts

@@ -42,7 +42,25 @@ module.exports = (app: App, side: TAppSide, dev: boolean): webpack.RuleSetRule[]
     }
 
     return [{
-        loader: 'babel-loader',
+        loader: require.resolve('babel-loader'),
+        exclude: (filePath) => {
+            // 1) If not in "node_modules" at all => transpile it
+            if (!filePath.includes('node_modules')) {
+                return false;
+            }
+        
+            // 2) If it’s "node_modules/5htp-core" but NOT "node_modules/5htp-core/node_modules",
+            //    then transpile. Otherwise, exclude.
+            if (
+                filePath.includes('node_modules/5htp-core') &&
+                !filePath.includes('node_modules/5htp-core/node_modules')
+            ) {
+                return false;
+            }
+        
+            // 3) Everything else in node_modules is excluded
+            return true;
+          },
         options: { 
             
             // https://github.com/babel/babel-loader#options
@@ -83,7 +101,7 @@ module.exports = (app: App, side: TAppSide, dev: boolean): webpack.RuleSetRule[]
                 // NOTE: On résoud les plugins et presets directement ici
                 //      Autrement, babel-loader les cherchera dans projet/node_modules
 
-                //[require("@babel/plugin-proposal-decorators"), { "legacy": true }],
+                [require("@babel/plugin-proposal-decorators"), { "legacy": true }],
 
                 [require('@babel/plugin-proposal-class-properties'), { "loose": true }],
 

package/{src/compiler → compiler}/common/babel/plugins/injection-dependances/index.ts

@@ -12,9 +12,9 @@ import cli from '@cli';
 /*----------------------------------
 - WEBPACK RULE
 ----------------------------------*/
-const globServices = app.paths.root + '/src/server/services/**/*.ts';
+const globServices = app.paths.root + '/server/services/**/*.ts';
 const globModuleService = '@app/server/services/**';
-const globRoutes = app.paths.root + '/src/server/routes/**/*.ts';
+const globRoutes = app.paths.root + '/server/routes/**/*.ts';
 
 module.exports = {
     test: [globRoutes, globServices],
@@ -23,6 +23,8 @@ module.exports = {
     ]
 }
 
+const routerMethods = ['get', 'post', 'put', 'delete', 'patch'];
+
 /*----------------------------------
 - PLUGIN
 ----------------------------------*/
@@ -133,7 +135,7 @@ function Plugin (babel) {
                         &&
                         i.node.callee.property.type === 'Identifier'
                         &&
-                        ['get', 'post', 'put', 'delete'].includes(i.node.callee.property.name)
+                        routerMethods.includes(i.node.callee.property.name)
                         &&
                         i.node.arguments.length >= 2 // url + au moins 1 middleware
                         &&

package/{src/compiler → compiler}/common/babel/plugins/queries/index.ts

@@ -48,7 +48,7 @@ function Plugin (babel) {
 
             this.fichier = filename;
 
-            const prefixeRoot = root + '/src/'
+            const prefixeRoot = root;
             this.dossier = path.dirname(filename).substring(prefixeRoot.length)
         },
         visitor: {

package/compiler/common/babel/plugins/services.ts

@@ -0,0 +1,245 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import * as types from '@babel/types'
+import type { PluginObj } from '@babel/core';
+
+// Core
+import cli from '@cli';
+import { App, TAppSide } from '../../../../app';
+
+/*----------------------------------
+- WEBPACK RULE
+----------------------------------*/
+
+type TOptions = {
+    side: TAppSide,
+    app: App,
+    debug?: boolean
+}
+
+/**
+ * Extended source type: now includes "models"
+ * so we can differentiate how we rewrite references.
+ */
+type TImportSource = 'container' | 'application' | 'models';
+
+module.exports = (options: TOptions) => (
+    [Plugin, options]
+)
+
+/*----------------------------------
+- PLUGIN
+----------------------------------*/
+function Plugin(babel, { app, side, debug }: TOptions) {
+
+    const t = babel.types as typeof types;
+
+    /*
+        Transforms:
+          import { MyService, Environment } from '@app';
+          import { MyModel } from '@models';
+          ...
+          MyService.method();
+          Environment.name;
+          MyModel.someCall();
+  
+        To:
+          import container from '<path>/server/app/container';
+          ...
+          container.Environment.name;
+          this.app.MyService.method();
+          this.app.Models.client.MyModel.someCall();
+  
+        Processed files:
+          @/server/config
+          @/server/routes
+          @/server/services
+    */
+
+    const plugin: PluginObj<{
+
+        debug: boolean,
+
+        filename: string,
+        processFile: boolean,
+
+        // Count how many total imports we transform
+        importedCount: number,
+
+        // For every local identifier, store info about how it should be rewritten
+        importedReferences: {
+            [localName: string]: {
+                imported: string,                // The original “imported” name
+                bindings: any,                   // reference paths
+                source: TImportSource            // container | application | models
+            }
+        }
+
+        // Tally how many references per kind
+        bySource: { [s in TImportSource]: number }
+    }> = {
+
+        pre(state) {
+            this.filename = state.opts.filename as string;
+            this.processFile = (
+                this.filename.startsWith(cli.paths.appRoot + '/server/config')
+                ||
+                this.filename.startsWith(cli.paths.appRoot + '/server/services')
+            );
+
+            this.importedReferences = {};
+            this.bySource = {
+                container: 0,
+                application: 0,
+                models: 0
+            };
+            this.importedCount = 0;
+            this.debug = debug || false;
+        },
+
+        visitor: {
+
+            /**
+             * Detect import statements from '@app' or '@models'
+             */
+            ImportDeclaration(path) {
+                if (!this.processFile) return;
+
+                const source = path.node.source.value;
+                if (source !== '@app' && source !== '@models') {
+                    return;
+                }
+
+                // For '@app' and '@models', gather imported symbols
+                for (const specifier of path.node.specifiers) {
+                    if (specifier.type !== 'ImportSpecifier') continue;
+                    if (specifier.imported.type !== 'Identifier') continue;
+
+                    this.importedCount++;
+
+                    let importSource: TImportSource;
+                    if (source === '@app') {
+                        // Distinguish whether it's a container service or an application service
+                        if (app.containerServices.includes(specifier.imported.name)) {
+                            importSource = 'container';
+                        } else {
+                            importSource = 'application';
+                        }
+                    } else {
+                        // source === '@models'
+                        importSource = 'models';
+                    }
+
+                    this.importedReferences[specifier.local.name] = {
+                        imported: specifier.imported.name,
+                        bindings: path.scope.bindings[specifier.local.name].referencePaths,
+                        source: importSource
+                    };
+
+                    this.bySource[importSource]++;
+                }
+
+                // Remove the original import line(s) and replace with any needed new import
+                // For @app imports, we might import "container" if needed
+                // For @models, we don’t import anything
+                const replaceWith: any[] = [];
+
+                // If this line had container references, add a default import for container
+                // Example: import container from '<root>/server/app/container'
+                if (source === '@app' && this.bySource.container > 0) {
+                    replaceWith.push(
+                        t.importDeclaration(
+                            [t.importDefaultSpecifier(t.identifier('container'))],
+                            t.stringLiteral(
+                                cli.paths.core.root + '/server/app/container'
+                            )
+                        )
+                    );
+                }
+
+                // Replace the original import statement with our new import(s) if any
+                // or remove it entirely if no container references exist.
+                path.replaceWithMultiple(replaceWith);
+            },
+
+            /**
+             * Rewrite references to the imports
+             */
+            Identifier(path) {
+                if (!this.processFile || this.importedCount === 0) {
+                    return;
+                }
+
+                const name = path.node.name;
+                const ref = this.importedReferences[name];
+                if (!ref || !ref.bindings) {
+                    return;
+                }
+
+                // Find a specific binding that hasn't been replaced yet
+                let foundBinding = undefined;
+                for (const binding of ref.bindings) {
+                    if (!binding.replaced && path.getPathLocation() === binding.getPathLocation()) {
+                        foundBinding = binding;
+                        break;
+                    }
+                }
+                if (!foundBinding) {
+                    return;
+                }
+
+                // Mark as replaced to avoid loops
+                foundBinding.replaced = true;
+
+                // Based on the source, replace the identifier with the proper MemberExpression
+                if (ref.source === 'container') {
+                    // container.[identifier]
+                    // e.g. container.Environment
+                    path.replaceWith(
+                        t.memberExpression(
+                            t.identifier('container'),
+                            path.node
+                        )
+                    );
+                }
+                else if (ref.source === 'application') {
+                    // this.app.[identifier]
+                    // e.g. this.app.MyService
+                    path.replaceWith(
+                        t.memberExpression(
+                            t.memberExpression(
+                                t.thisExpression(),
+                                t.identifier('app')
+                            ),
+                            path.node
+                        )
+                    );
+                }
+                else if (ref.source === 'models') {
+                    // this.app.Models.client.[identifier]
+                    // e.g. this.app.Models.client.MyModel
+                    path.replaceWith(
+                        t.memberExpression(
+                            t.memberExpression(
+                                t.memberExpression(
+                                    t.memberExpression(
+                                        t.thisExpression(),
+                                        t.identifier('app')
+                                    ),
+                                    t.identifier('Models')
+                                ),
+                                t.identifier('client')
+                            ),
+                            path.node
+                        )
+                    );
+                }
+            }
+        }
+    };
+
+    return plugin;
+}

package/{src/compiler → compiler}/common/babel/routes/imports.ts

@@ -13,7 +13,7 @@ import cli from '@cli';
 import type { TAppSide, default as App } from '@cli/app';
 
 // Resources
-const routesToPreload = require( cli.paths.appRoot + '/src/client/pages/preload.json' );
+const routesToPreload = require( cli.paths.appRoot + '/client/pages/preload.json' );
 
 /*----------------------------------
 - CONFIG
@@ -109,10 +109,10 @@ module.exports = (app: App, side: TAppSide, dev: boolean): ImportTransformer =>
             }
         }
         
-        console.log( generate(t.variableDeclaration("const", [t.variableDeclarator(
+        /*console.log( generate(t.variableDeclaration("const", [t.variableDeclarator(
             t.identifier(request.imported.name),
             t.objectExpression(pageLoaders)
-        )])).code );
+        )])).code );*/
 
         return [
             ...imports,