5htp 0.6.2 → 0.6.3-2

package/app/index.ts

@@ -69,7 +69,10 @@ export class 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),
 

package/compiler/client/index.ts

@@ -126,7 +126,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                 // On ne compile les ressources (css) qu'une seule fois
                 {
                     test: regex.style,
-                    rules: require('../common/files/style')(app, true, dev),
+                    rules: require('../common/files/style')(app, dev, true),
 
                     // Don't consider CSS imports dead code even if the
                     // containing package claims to have no side effects.
@@ -331,4 +331,4 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
     };
 
     return config;
-};
+};

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/babel/routes/routes.ts

@@ -53,6 +53,13 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
     const t = babel.types as typeof types;
 
+    type TPluginState = {
+        filename: string,
+        file: TFileInfos,
+        apiInjectedRootFunctions: WeakSet<types.Node>,
+        needsUseContextImport: boolean
+    }
+
     /*
         - Wrap route.get(...) with (app: Application) => { }
         - Inject chunk ID into client route options
@@ -70,14 +77,14 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         const stats = page.data.stats;
     */
 
-    const plugin: PluginObj<{ 
-        filename: string,
-        file: TFileInfos
-    }> = {
+    const plugin: PluginObj<TPluginState> = {
         pre(state) {
             this.filename = state.opts.filename as string;
 
             this.file = getFileInfos(this.filename);
+
+            this.apiInjectedRootFunctions = new WeakSet();
+            this.needsUseContextImport = false;
         },
         visitor: {
             // Find @app imports
@@ -203,6 +210,8 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     */
                     if (side === 'client' && !clientServices.includes(serviceName)) {
 
+                        ensureApiExposedInRootFunction(path, this);
+
                         // Get complete call path
                         const apiPath = '/api/' + completePath.join('/');
                         
@@ -255,6 +264,8 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
                     if (!this.file.process)
                         return;
+
+                    ensureUseContextImport(path, this);
                         
                     const wrappedrouteDefs = wrapRouteDefs( this.file );
                     if (wrappedrouteDefs)
@@ -264,6 +275,187 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         }
     }
 
+    function ensureApiExposedInRootFunction(
+        path: NodePath<types.CallExpression>,
+        pluginState: TPluginState
+    ) {
+        if (path.scope.hasBinding('api'))
+            return;
+
+        const rootFunctionPath = getRootFunctionPath(path);
+        if (!rootFunctionPath)
+            return;
+
+        // Root function should be at the program body level (not nested in another function / expression)
+        if (rootFunctionPath.getFunctionParent())
+            return;
+        if (!isProgramBodyLevelFunction(rootFunctionPath))
+            return;
+
+        if (pluginState.apiInjectedRootFunctions.has(rootFunctionPath.node))
+            return;
+
+        const exposeApiDeclaration = t.variableDeclaration('const', [
+            t.variableDeclarator(
+                t.objectPattern([
+                    t.objectProperty(t.identifier('api'), t.identifier('api'), false, true),
+                ]),
+                t.callExpression(t.identifier('useContext'), [])
+            )
+        ]);
+
+        const body = rootFunctionPath.node.body;
+        if (body.type === 'BlockStatement') {
+            body.body.unshift(exposeApiDeclaration);
+        } else {
+            rootFunctionPath.node.body = t.blockStatement([
+                exposeApiDeclaration,
+                t.returnStatement(body)
+            ]);
+        }
+
+        pluginState.apiInjectedRootFunctions.add(rootFunctionPath.node);
+        pluginState.needsUseContextImport = true;
+    }
+
+    function getRootFunctionPath(path: NodePath): NodePath<types.Function | types.ArrowFunctionExpression> | undefined {
+
+        let functionPath = path.getFunctionParent();
+        if (!functionPath)
+            return;
+
+        // Only support plain functions / arrow functions (no class/object methods)
+        if (!(
+            functionPath.isFunctionDeclaration()
+            || functionPath.isFunctionExpression()
+            || functionPath.isArrowFunctionExpression()
+        ))
+            return;
+
+        let parentFunction = functionPath.getFunctionParent();
+        while (parentFunction) {
+
+            if (!(
+                parentFunction.isFunctionDeclaration()
+                || parentFunction.isFunctionExpression()
+                || parentFunction.isArrowFunctionExpression()
+            ))
+                break;
+
+            functionPath = parentFunction;
+            parentFunction = functionPath.getFunctionParent();
+        }
+
+        return functionPath;
+    }
+
+    function isProgramBodyLevelFunction(path: NodePath): boolean {
+
+        const parent = path.parentPath;
+        if (!parent)
+            return false;
+
+        // function Foo() {}
+        if (parent.isProgram())
+            return true;
+
+        // export default function Foo() {} / export default () => {}
+        if (
+            parent.isExportDefaultDeclaration()
+            &&
+            parent.parentPath?.isProgram()
+        )
+            return true;
+
+        // export const Foo = () => {}
+        if (
+            parent.isExportNamedDeclaration()
+            &&
+            parent.parentPath?.isProgram()
+        )
+            return true;
+
+        // const Foo = () => {} (top-level) / export const Foo = () => {}
+        if (parent.isVariableDeclarator()) {
+
+            const declaration = parent.parentPath;
+            if (!declaration?.isVariableDeclaration())
+                return false;
+
+            const declarationParent = declaration.parentPath;
+            if (!declarationParent)
+                return false;
+
+            if (declarationParent.isProgram())
+                return true;
+
+            if (
+                declarationParent.isExportNamedDeclaration()
+                &&
+                declarationParent.parentPath?.isProgram()
+            )
+                return true;
+        }
+
+        return false;
+    }
+
+    function ensureUseContextImport(path: NodePath<types.Program>, pluginState: TPluginState) {
+
+        if (!pluginState.needsUseContextImport)
+            return;
+
+        const body = path.node.body;
+
+        // Already imported as a value import
+        for (const stmt of body) {
+            if (
+                stmt.type === 'ImportDeclaration'
+                &&
+                stmt.source.value === '@/client/context'
+                &&
+                stmt.importKind !== 'type'
+                &&
+                stmt.specifiers.some(s =>
+                    s.type === 'ImportDefaultSpecifier' && s.local.name === 'useContext'
+                )
+            )
+                return;
+        }
+
+        // Try to reuse an existing value import from the same module
+        for (const stmt of body) {
+            if (
+                stmt.type !== 'ImportDeclaration'
+                ||
+                stmt.source.value !== '@/client/context'
+                ||
+                stmt.importKind === 'type'
+            )
+                continue;
+
+            const hasDefaultImport = stmt.specifiers.some(s => s.type === 'ImportDefaultSpecifier');
+            if (!hasDefaultImport) {
+                stmt.specifiers.unshift(
+                    t.importDefaultSpecifier(t.identifier('useContext'))
+                );
+                return;
+            }
+        }
+
+        // Otherwise, add a new import (placed after existing imports)
+        const importDeclaration = t.importDeclaration(
+            [t.importDefaultSpecifier(t.identifier('useContext'))],
+            t.stringLiteral('@/client/context')
+        );
+
+        let insertIndex = 0;
+        while (insertIndex < body.length && body[insertIndex].type === 'ImportDeclaration')
+            insertIndex++;
+
+        body.splice(insertIndex, 0, importDeclaration);
+    }
+
     function getFileInfos( filename: string ): TFileInfos {
 
         const file: TFileInfos = {
@@ -290,7 +482,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         }
         
         // Differenciate back / front
-        if (relativeFileName.startsWith('/client/pages')) {
+        if (relativeFileName.startsWith('/client/pages') || relativeFileName.startsWith('/client/components') || relativeFileName.startsWith('/client/hooks')) {
             file.side = 'front';
         } else if (relativeFileName.startsWith('/server/routes')) {
             file.side = 'back';
@@ -302,7 +494,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
     function transformDataFetchers( 
         path: NodePath<types.CallExpression>, 
-        routerDefContext: PluginObj, 
+        routerDefContext: TPluginState, 
         routeDef: TRouteDefinition 
     ) {
         path.traverse({
@@ -638,4 +830,4 @@ function Plugin(babel, { app, side, debug }: TOptions) {
     }
 
     return plugin;
-}
+}

package/compiler/common/files/autres.ts

@@ -24,7 +24,7 @@ module.exports = (app: App, dev: boolean, client: boolean) => ([
     // Texte brut
     {
         type: 'asset/source',
-        test: /\.(md|hbs|sql|txt|csv)$/,
+        test: /\.(md|hbs|sql|txt|csv|html)$/,
     },
 
     // Polices dans un fichier distinc dans le dossier dédié