5htp 0.6.3-1 → 0.6.3-2

package/compiler/common/babel/index.ts

@@ -5,8 +5,6 @@
 // Npm
 import type webpack from 'webpack';
 import PresetBabel, { Options } from '@babel/preset-env';
-// Core
-import PluginIndexage from '../plugins/indexage';
 
 import cli from '@cli';
 import type { TAppSide, App } from '@cli/app';
@@ -70,10 +68,6 @@ module.exports = (app: App, side: TAppSide, dev: boolean): webpack.RuleSetRule[]
             // Désactive car ralenti compilation
             cacheCompression: false,
 
-            metadataSubscribers: [
-                PluginIndexage.metadataContextFunctionName
-            ],
-
             compact: !dev,
 
             // https://babeljs.io/docs/usage/options/
@@ -165,14 +159,10 @@ module.exports = (app: App, side: TAppSide, dev: boolean): webpack.RuleSetRule[]
             ],
 
             overrides: [
-
-                require('./plugins/icones-svg')(app),
                 
                 ...(side === 'client' ? [
 
                 ] : [
-                    //require('./plugins/queries'),
-                    //require('./plugins/injection-dependances'),
                 ]),
             ]
         }

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

@@ -6,6 +6,10 @@
 import * as types from '@babel/types'
 import type { NodePath, PluginObj } from '@babel/core';
 import generate from '@babel/generator';
+import fs from 'fs';
+import path from 'path';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
 
 // Core
 import cli from '@cli';
@@ -38,6 +42,170 @@ type TImportedIndex = {
     source: TImportSource            // container | application | models
 }
 
+type TRoutesIndex = {
+    byFile: Map<string, Set<string>>,
+    all: Set<string>,
+    initialized: boolean
+}
+
+const routesIndexByAppRoot = new Map<string, TRoutesIndex>();
+
+function isRouteDecoratorExpression(expression: types.Expression): boolean {
+    return (
+        // Handles the case of @Route without parameters
+        (types.isIdentifier(expression) && expression.name === 'Route')
+        ||
+        // Handles the case of @Route() with parameters
+        (
+            types.isCallExpression(expression)
+            &&
+            types.isIdentifier(expression.callee)
+            &&
+            expression.callee.name === 'Route'
+        )
+    );
+}
+
+function getRoutePathFromDecoratorExpression(expression: types.Expression): string | undefined {
+    if (
+        !types.isCallExpression(expression)
+        ||
+        !types.isIdentifier(expression.callee)
+        ||
+        expression.callee.name !== 'Route'
+    )
+        return;
+
+    const firstArg = expression.arguments[0];
+    if (!types.isStringLiteral(firstArg))
+        return;
+
+    return firstArg.value;
+}
+
+function extractRoutePathsFromCode(code: string, filename: string): Set<string> {
+    const routePaths = new Set<string>();
+
+    let ast: ReturnType<typeof parse> | undefined;
+    try {
+        ast = parse(code, {
+            sourceType: 'module',
+            sourceFilename: filename,
+            plugins: [
+                'typescript',
+                'decorators-legacy',
+                'jsx',
+                'classProperties',
+                'classPrivateProperties',
+                'classPrivateMethods',
+                'dynamicImport',
+                'importMeta',
+                'optionalChaining',
+                'nullishCoalescingOperator',
+                'topLevelAwait',
+            ],
+        });
+    } catch {
+        return routePaths;
+    }
+
+    traverse(ast, {
+        ClassMethod(path) {
+            const { node } = path;
+            if (!node.decorators || node.key.type !== 'Identifier')
+                return;
+
+            for (const decorator of node.decorators) {
+                if (!isRouteDecoratorExpression(decorator.expression))
+                    continue;
+
+                const routePath = getRoutePathFromDecoratorExpression(decorator.expression);
+                if (routePath)
+                    routePaths.add(routePath);
+            }
+        }
+    });
+
+    return routePaths;
+}
+
+function listTsFiles(dirPath: string): string[] {
+    let entries: fs.Dirent[];
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+
+    const files: string[] = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listTsFiles(fullPath));
+            continue;
+        }
+
+        const isTs = fullPath.endsWith('.ts') || fullPath.endsWith('.tsx');
+        if (!isTs || fullPath.endsWith('.d.ts'))
+            continue;
+
+        files.push(fullPath);
+    }
+    return files;
+}
+
+function initializeRoutesIndex(appRoot: string, index: TRoutesIndex) {
+    const servicesDir = path.join(appRoot, 'server', 'services');
+    const files = listTsFiles(servicesDir);
+
+    for (const file of files) {
+        let code: string;
+        try {
+            code = fs.readFileSync(file, 'utf8');
+        } catch {
+            continue;
+        }
+
+        const routes = extractRoutePathsFromCode(code, file);
+        index.byFile.set(file, routes);
+    }
+
+    index.all.clear();
+    for (const routes of index.byFile.values()) {
+        for (const route of routes)
+            index.all.add(route);
+    }
+    index.initialized = true;
+}
+
+function getRoutesIndex(appRoot: string): TRoutesIndex {
+    let index = routesIndexByAppRoot.get(appRoot);
+    if (!index) {
+        index = {
+            byFile: new Map(),
+            all: new Set(),
+            initialized: false
+        };
+        routesIndexByAppRoot.set(appRoot, index);
+    }
+
+    if (!index.initialized) {
+        initializeRoutesIndex(appRoot, index);
+    }
+
+    return index;
+}
+
+function updateRoutesIndexForFile(index: TRoutesIndex, filename: string, routePaths: Set<string>) {
+    index.byFile.set(filename, routePaths);
+
+    index.all.clear();
+    for (const routes of index.byFile.values()) {
+        for (const route of routes)
+            index.all.add(route);
+    }
+}
+
 /*----------------------------------
 - PLUGIN
 ----------------------------------*/
@@ -75,6 +243,9 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         // Count how many total imports we transform
         importedCount: number,
         routeMethods: string[],
+        routePaths: Set<string>,
+        routesIndex: TRoutesIndex,
+        contextGuardedClassMethods: WeakSet<types.ClassMethod>,
 
         // For every local identifier, store info about how it should be rewritten
         imported: {
@@ -92,6 +263,10 @@ function Plugin(babel, { app, side, debug }: TOptions) {
             this.debug = debug || false;
 
             this.routeMethods = [];
+            this.routePaths = new Set();
+
+            this.routesIndex = getRoutesIndex(app.paths.root);
+            this.contextGuardedClassMethods = new WeakSet();
         },
 
         visitor: {
@@ -109,28 +284,21 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
                         for (const decorator of node.decorators) {
 
-                            const isRoute = (
-                                // Handles the case of @Route without parameters
-                                (
-                                    t.isIdentifier(decorator.expression) && decorator.expression.name === 'Route'
-                                ) 
-                                || 
-                                // Handles the case of @Route() with parameters
-                                (
-                                    t.isCallExpression(decorator.expression) &&
-                                    t.isIdentifier(decorator.expression.callee) &&
-                                    decorator.expression.callee.name === 'Route'
-                                )
-                            );
+                            const isRoute = isRouteDecoratorExpression(decorator.expression);
 
                             if (!isRoute) continue;
 
                             const methodName = node.key.name;
                             this.routeMethods.push( methodName );
 
+                            const routePath = getRoutePathFromDecoratorExpression(decorator.expression);
+                            if (routePath)
+                                this.routePaths.add(routePath);
                         }
                     }
                 });
+
+                updateRoutesIndexForFile(this.routesIndex, this.filename, this.routePaths);
             },
 
             /**
@@ -203,6 +371,88 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                 path.replaceWithMultiple(replaceWith);
             },
 
+            CallExpression(path) {
+                if (!this.processFile)
+                    return;
+
+                const classMethodPath = path.findParent(p => p.isClassMethod()) as NodePath<types.ClassMethod> | null;
+                if (!classMethodPath)
+                    return;
+
+                // Ignore constructors
+                if (classMethodPath.node.kind === 'constructor')
+                    return;
+
+                const callee = path.node.callee;
+                if (!t.isMemberExpression(callee) && !(t as any).isOptionalMemberExpression?.(callee))
+                    return;
+
+                // Build member chain segments: this.app.<Service>.<...>
+                const segments: string[] = [];
+                let current: any = callee;
+                while (t.isMemberExpression(current) || (t as any).isOptionalMemberExpression?.(current)) {
+                    const prop = current.property;
+                    if (t.isIdentifier(prop)) {
+                        segments.unshift(prop.name);
+                    } else if (t.isStringLiteral(prop)) {
+                        segments.unshift(prop.value);
+                    } else {
+                        return;
+                    }
+                    current = current.object;
+                }
+
+                if (!t.isThisExpression(current))
+                    return;
+
+                // Expect: this.app.<Service>.<method>
+                if (segments.length < 3 || segments[0] !== 'app')
+                    return;
+
+                const serviceLocalName = segments[1];
+                const importedRef = this.imported[serviceLocalName];
+                if (!importedRef || importedRef.source !== 'services')
+                    return;
+
+                const routePath = [
+                    importedRef.imported || serviceLocalName,
+                    ...segments.slice(2)
+                ].join('/');
+
+                if (!this.routesIndex.all.has(routePath))
+                    return;
+
+                // Ensure the parent function checks that `context` exists
+                if (!this.contextGuardedClassMethods.has(classMethodPath.node)) {
+                    const guard = t.ifStatement(
+                        t.binaryExpression(
+                            '===',
+                            t.unaryExpression('typeof', t.identifier('context')),
+                            t.stringLiteral('undefined')
+                        ),
+                        t.blockStatement([
+                            t.throwStatement(
+                                t.newExpression(t.identifier('Error'), [
+                                    t.stringLiteral('context variable should be passed in this function')
+                                ])
+                            )
+                        ])
+                    );
+                    classMethodPath.get('body').unshiftContainer('body', guard);
+                    this.contextGuardedClassMethods.add(classMethodPath.node);
+                }
+
+                // Ensure call arguments: second argument is `context`
+                const args = path.node.arguments;
+                if (args.length === 0) {
+                    args.push(t.identifier('undefined'), t.identifier('context'));
+                } else if (args.length === 1) {
+                    args.push(t.identifier('context'));
+                } else {
+                    args[1] = t.identifier('context') as any;
+                }
+            },
+
             // This visitor fires for every class method.
             ClassMethod(path) {
 

package/compiler/common/index.ts

@@ -8,9 +8,6 @@ import dayjs from 'dayjs';
 
 // Plugins
 const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
-import PluginIndexage from './plugins/indexage';
-import IconesSvg from './plugins/indexage/icones-svg';
-import InjectDeps from './plugins/indexage/injection-dependances';
 
 // Core
 import cli from '../..';
@@ -88,12 +85,6 @@ export default function createCommonConfig(
 
             }),
 
-            new PluginIndexage(side === 'client' ? {
-                'icones-svg': new IconesSvg(app),
-            } : {
-                //'injection-dependances': new InjectDeps,
-            }),
-
             ...(side === 'client' && cli.args.analyze ? [
 
                 new BundleAnalyzerPlugin({

package/compiler/index.ts

@@ -344,13 +344,15 @@ export default (): ClientContext => React.useContext<ClientContext>(ReactClientC
         // @/server/.generated/app.ts
         fs.outputFileSync(
             path.join( app.paths.server.generated, 'app.ts'),
-`import { Application } from '@server/app/index';
+`
+import { Application } from '@server/app/index';
+import { ServicesContainer } from '@server/app/service/container';
 
 ${imported.join('\n')}
 
-export default class ${appClassIdentifier} extends Application {
+export default class ${appClassIdentifier} extends Application<ServicesContainer, CurrentUser> {
 
-    // Makke sure the services typigs are reflecting the config and referring to the app
+    // Make sure the services typigs are reflecting the config and referring to the app
     ${sortedServices.map(service => 
         `public ${service.name}!: ReturnType<${appClassIdentifier}["registered"]["${service.id}"]["start"]>;`
     ).join('\n')}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.6.3-1",
+	"version": "0.6.3-2",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp.git",
 	"license": "MIT",

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

@@ -1,191 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-import { PluginObj } from '@babel/core'; 
-
-import * as types from '@babel/types'
-import generate from '@babel/generator';
-
-/*----------------------------------
-- WEBPACK RULE
-----------------------------------*/
-module.exports = {
-    test: "**/client/**/*.tsx",
-    plugins: [
-        [Plugin]
-    ]
-}
-
-const debug = false
-
-/*----------------------------------
-- PLUGIN
-----------------------------------*/
-function Plugin (babel) {
-
-    const t = babel.types as typeof types;
-
-    const plugin: PluginObj<{
-        fichier: string,
-        cancel: boolean
-    }> = {
-        pre(state) {
-
-            this.fichier = state.opts.filename as string;
-
-            if (!('useForm' in state.scope.bindings))
-                this.cancel = true;
-
-        },
-        visitor: {
-            JSXElement(instruction) {
-
-                if (this.cancel === true)
-                    return;
-
-                const balise = instruction.node.openingElement;
-
-                /*
-                    <Champs.metas.titre className="full" attrsChamp={{ className: "h1" }} />
-                */
-
-                if (!(
-                    balise.selfClosing === true
-                    &&
-                    balise.name.type === 'JSXMemberExpression'
-                    &&
-                    balise.name.property.type === 'JSXIdentifier'
-                ))
-                    return;
-
-                debug && console.log(`[compilation][babel][form] Original: `, generate(instruction.node).code);
-
-                // Si le premier element du memberexpression est Champ
-                let nomA: types.JSXMemberExpression | types.JSXIdentifier = balise.name;
-                while (nomA.type === 'JSXMemberExpression')
-                    nomA = nomA.object;
-                if (!nomA.name.startsWith('Champs'))
-                    return;
-
-                // Ne pas parcourir les élements enfant
-                // Avec .stop, babel arrête d'itérer les élements voisins à partir du 6ème - 7ème
-                //instruction.stop();
-                instruction.skip();
-
-                // Transformation de la lste des attributs en un objet
-                /*
-                    className="full" attrsChamp={{ className: "h1" }}
-
-                    =>
-
-                    { className: "full", attrsChamp: { className: "h1" } }
-                */
-                let objAttributs: types.ObjectProperty[] = [];
-                for (const attribut of balise.attributes)
-                    if (
-                        attribut.type === 'JSXAttribute' && 
-                        attribut.value !== undefined && 
-                        typeof attribut.name.name === "string"
-                    ) {
-
-                        let propValue: types.ObjectProperty["value"];
-                        if (attribut.value === null) // <Champ.titre autoFocus />
-                            propValue = t.booleanLiteral(true);
-                        else if (attribut.value.type !== 'JSXExpressionContainer')
-                            propValue = attribut.value;
-                        else if (attribut.value.expression.type !== 'JSXEmptyExpression')
-                            propValue = attribut.value.expression;
-                        else
-                            propValue = t.nullLiteral();
-
-                        objAttributs.push(
-                            t.objectProperty(
-                                t.identifier( attribut.name.name ),
-                                propValue
-                            )
-                        )
-                    }
-
-                // Traverse chaque branche du chemin du champ, dans l'ordre inverse
-                // NOTE: on aurai pu reconstituer le chemin et créer les memberexpressions en une seule itération
-                //      Mais le fait d ele faire en deux itérations rend le code plus claire et maintenable
-                let cheminComposant: string[] = []
-                let brancheA: types.JSXMemberExpression | types.JSXIdentifier = balise.name;
-                while (brancheA.type === 'JSXMemberExpression') {
-
-                    const { property } = brancheA;
-                    
-                    cheminComposant.unshift(property.name)
-                    brancheA = brancheA.object;
-                }
-
-                let cheminSchema: types.MemberExpression | types.OptionalMemberExpression = t.memberExpression( 
-                    t.identifier('Champs'), 
-                    t.identifier('schema') 
-                );
-                let cheminDonnees: types.MemberExpression | types.OptionalMemberExpression = t.memberExpression( 
-                    t.identifier('Champs'), 
-                    t.identifier('data') 
-                );
-                const iDerniereBranche = cheminComposant.length - 1
-                for (let iBranche = iDerniereBranche; iBranche >= 0; iBranche--) {
-
-                    const branche = cheminComposant[ iBranche ];
-
-                    cheminSchema = t.optionalMemberExpression(
-                        cheminSchema,
-                        t.identifier( branche ),
-                        undefined,
-                        true
-                    )
-
-                    if (iBranche !== iDerniereBranche)
-                        cheminDonnees = t.optionalMemberExpression(
-                            cheminDonnees,
-                            t.identifier(branche),
-                            undefined,
-                            true
-                        )
-
-                }
-
-                // Remplacement
-                /*
-                    {Champs._render( Champs.metas?.titre, Champs._data.metas?.titre, 'metas.titre', {
-                        className: "full",
-                        attrsChamp: { className: "h1" }
-                    })}
-                */
-                const remplacement = t.callExpression(
-
-                    // Champs.render
-                    t.memberExpression(
-                        t.identifier('Champs'),
-                        t.identifier('render')
-                    ),
-                    [
-                        // Champs.<chemin>
-                        cheminSchema,
-
-                        // Champs._data.<chemin>
-                        cheminDonnees,
-
-                        // Chemin
-                        t.stringLiteral( cheminComposant.join('.') ),
-
-                        // { <attrs> }
-                        t.objectExpression(objAttributs)
-                    ]
-                )
-
-                debug && console.log(`[compilation][babel][form] Remplacement: `, generate(remplacement).code );
-
-                instruction.replaceWith(remplacement);
-                
-            }
-        },
-    };
-
-    return plugin;
-}