5htp 0.6.3 → 0.6.4

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

@@ -5,7 +5,6 @@
 // Npm
 import * as types from '@babel/types'
 import type { PluginObj, NodePath } from '@babel/core';
-import generate from '@babel/generator';
 
 // Core
 import cli from '@cli';
@@ -53,6 +52,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 +76,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
@@ -184,9 +190,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     // Delete the route def since it will be replaced by a wrapper
                     path.replaceWithMultiple([]);
 
-                /*
-                    Any api call via the front pages / components
-                */
+      
                 } else if (this.file.side === 'front') {
                     
                     const isAService = (
@@ -201,10 +205,12 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
                         Events.Create( form.data ).then(res => toast.success(res.message))
                         =>
-                        api.post( '/api/events/create', form.data ).then(res => toast.success(res.message))
+                        api.post( '/api/events/create', form.data ).then(res => toast.success(res.message)).catch(app.handleError)
                     */
                     if (side === 'client' && !clientServices.includes(serviceName)) {
 
+                        ensureApiExposedInRootFunction(path, this);
+
                         // Get complete call path
                         const apiPath = '/api/' + completePath.join('/');
                         
@@ -220,6 +226,8 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                                 ), apiPostArgs
                             )
                         )
+                        
+                        ensureBackendServicePromiseCatch(path);
 
                     /* [server] Backend Service calls
 
@@ -257,6 +265,8 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
                     if (!this.file.process)
                         return;
+
+                    ensureUseContextImport(path, this);
                         
                     const wrappedrouteDefs = wrapRouteDefs( this.file );
                     if (wrappedrouteDefs)
@@ -266,6 +276,485 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         }
     }
 
+    function ensureBackendServicePromiseCatch(path: NodePath<types.CallExpression>) {
+
+        const chainRoot = getPromiseChainRoot(path);
+
+        // Only append if we are in a promise chain (e.g. .then(...))
+        if (chainRoot === path)
+            return;
+
+        if (isCatchWithAppHandleErrorArrow(chainRoot))
+            return;
+
+        if (isCatchWithAppHandleErrorMember(chainRoot)) {
+            const updatedCatch = t.callExpression(
+                chainRoot.node.callee,
+                [buildCatchHandler()]
+            );
+            chainRoot.replaceWith(updatedCatch);
+            return;
+        }
+
+        if (isCatchWithAppHandleErrorWrapped(chainRoot)) {
+            const updatedCatch = t.callExpression(
+                chainRoot.node.callee,
+                [buildCatchHandler()]
+            );
+            chainRoot.replaceWith(updatedCatch);
+            return;
+        }
+
+        const newChain = t.callExpression(
+            t.memberExpression(chainRoot.node, t.identifier('catch')),
+            [buildCatchHandler()]
+        );
+
+        chainRoot.replaceWith(newChain);
+    }
+
+    function buildCatchHandler(): types.ArrowFunctionExpression {
+        const errorIdentifier = t.identifier('e');
+        return t.arrowFunctionExpression(
+            [errorIdentifier],
+            t.callExpression(
+                t.memberExpression(t.identifier('app'), t.identifier('handleError')),
+                [t.identifier(errorIdentifier.name)]
+            )
+        );
+    }
+
+    function getPromiseChainRoot(path: NodePath<types.CallExpression>): NodePath<types.CallExpression> {
+
+        let current = path;
+
+        while (1) {
+
+            const member = current.parentPath;
+            if (!member?.isMemberExpression())
+                break;
+
+            if (member.node.object !== current.node)
+                break;
+
+            if (member.node.property.type !== 'Identifier')
+                break;
+
+            const propName = member.node.property.name;
+            if (!['then', 'catch', 'finally'].includes(propName))
+                break;
+
+            const call = member.parentPath;
+            if (!call?.isCallExpression())
+                break;
+
+            if (call.node.callee !== member.node)
+                break;
+
+            current = call;
+        }
+
+        return current;
+    }
+
+    function isCatchCall(path: NodePath<types.CallExpression>): boolean {
+
+        const callee = path.node.callee;
+        if (callee.type !== 'MemberExpression')
+            return false;
+
+        if (callee.property.type !== 'Identifier' || callee.property.name !== 'catch')
+            return false;
+
+        return true;
+    }
+
+    function isCatchWithAppHandleErrorMember(path: NodePath<types.CallExpression>): boolean {
+
+        if (!isCatchCall(path))
+            return false;
+
+        if (path.node.arguments.length !== 1)
+            return false;
+
+        const handler = path.node.arguments[0];
+        if (handler.type !== 'MemberExpression')
+            return false;
+
+        if (handler.object.type !== 'Identifier' || handler.object.name !== 'app')
+            return false;
+
+        if (handler.property.type !== 'Identifier' || handler.property.name !== 'handleError')
+            return false;
+
+        return true;
+    }
+
+    function isCatchWithAppHandleErrorArrow(path: NodePath<types.CallExpression>): boolean {
+
+        if (!isCatchCall(path))
+            return false;
+
+        if (path.node.arguments.length !== 1)
+            return false;
+
+        const handler = path.node.arguments[0];
+        if (handler.type !== 'ArrowFunctionExpression')
+            return false;
+
+        if (
+            handler.params.length !== 1
+            ||
+            handler.params[0].type !== 'Identifier'
+        )
+            return false;
+
+        const errorName = handler.params[0].name;
+
+        if (handler.body.type !== 'CallExpression')
+            return false;
+
+        const call = handler.body;
+        if (call.callee.type !== 'MemberExpression')
+            return false;
+
+        if (call.callee.object.type !== 'Identifier' || call.callee.object.name !== 'app')
+            return false;
+
+        if (call.callee.property.type !== 'Identifier' || call.callee.property.name !== 'handleError')
+            return false;
+
+        if (call.arguments.length !== 1)
+            return false;
+
+        const arg = call.arguments[0];
+        if (arg.type !== 'Identifier' || arg.name !== errorName)
+            return false;
+
+        return true;
+    }
+
+    function isCatchWithAppHandleErrorWrapped(path: NodePath<types.CallExpression>): boolean {
+
+        if (!isCatchCall(path))
+            return false;
+
+        if (path.node.arguments.length !== 1)
+            return false;
+
+        const handler = path.node.arguments[0];
+        if (handler.type !== 'ArrowFunctionExpression')
+            return false;
+
+        if (
+            handler.params.length !== 1
+            ||
+            handler.params[0].type !== 'Identifier'
+        )
+            return false;
+
+        const errorName = handler.params[0].name;
+
+        if (handler.body.type !== 'BlockStatement')
+            return false;
+
+        const statements = handler.body.body;
+        if (statements.length < 2)
+            return false;
+
+        const first = statements[0];
+        if (!(
+            first.type === 'ExpressionStatement'
+            &&
+            first.expression.type === 'CallExpression'
+            &&
+            first.expression.callee.type === 'MemberExpression'
+            &&
+            first.expression.callee.object.type === 'Identifier'
+            &&
+            first.expression.callee.object.name === 'console'
+            &&
+            first.expression.callee.property.type === 'Identifier'
+            &&
+            first.expression.callee.property.name === 'log'
+            &&
+            first.expression.arguments.length === 2
+            &&
+            first.expression.arguments[0].type === 'StringLiteral'
+            &&
+            first.expression.arguments[0].value === 'Error catched'
+            &&
+            first.expression.arguments[1].type === 'Identifier'
+            &&
+            first.expression.arguments[1].name === errorName
+        ))
+            return false;
+
+        const second = statements[1];
+        if (!(
+            second.type === 'ExpressionStatement'
+            &&
+            second.expression.type === 'CallExpression'
+            &&
+            second.expression.callee.type === 'MemberExpression'
+            &&
+            second.expression.callee.object.type === 'Identifier'
+            &&
+            second.expression.callee.object.name === 'app'
+            &&
+            second.expression.callee.property.type === 'Identifier'
+            &&
+            second.expression.callee.property.name === 'handleError'
+            &&
+            second.expression.arguments.length === 1
+            &&
+            second.expression.arguments[0].type === 'Identifier'
+            &&
+            second.expression.arguments[0].name === errorName
+        ))
+            return false;
+
+        return true;
+    }
+
+    function ensureApiExposedInRootFunction(
+        path: NodePath<types.CallExpression>,
+        pluginState: TPluginState
+    ) {
+        const needsApi = !path.scope.hasBinding('api');
+        const needsApp = !path.scope.hasBinding('app');
+        if (!needsApi && !needsApp)
+            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;
+
+        const existingContextObjectPattern = findUseContextDestructuringObjectPattern(rootFunctionPath);
+        if (existingContextObjectPattern) {
+
+            const existingKeys = new Set(
+                existingContextObjectPattern.properties
+                    .filter((p): p is types.ObjectProperty =>
+                        p.type === 'ObjectProperty'
+                        && p.key.type === 'Identifier'
+                    )
+                    .map(p => (p.key as types.Identifier).name)
+            );
+
+            if (needsApi && !existingKeys.has('api')) {
+                existingContextObjectPattern.properties.push(
+                    t.objectProperty(t.identifier('api'), t.identifier('api'), false, true),
+                );
+            }
+
+            if (needsApp && !existingKeys.has('app')) {
+                existingContextObjectPattern.properties.push(
+                    t.objectProperty(t.identifier('app'), t.identifier('app'), false, true),
+                );
+            }
+
+            pluginState.needsUseContextImport = true;
+            return;
+        }
+
+        if (pluginState.apiInjectedRootFunctions.has(rootFunctionPath.node))
+            return;
+
+        const exposeApiDeclaration = t.variableDeclaration('const', [
+            t.variableDeclarator(
+                t.objectPattern([
+                    ...(needsApi ? [t.objectProperty(t.identifier('api'), t.identifier('api'), false, true)] : []),
+                    ...(needsApp ? [t.objectProperty(t.identifier('app'), t.identifier('app'), 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 findUseContextDestructuringObjectPattern(
+        rootFunctionPath: NodePath<types.Function | types.ArrowFunctionExpression>
+    ): types.ObjectPattern | undefined {
+
+        const body = rootFunctionPath.node.body;
+        if (body.type !== 'BlockStatement')
+            return;
+
+        for (const stmt of body.body) {
+            if (stmt.type !== 'VariableDeclaration' || stmt.kind !== 'const')
+                continue;
+
+            for (const declarator of stmt.declarations) {
+                if (declarator.id.type !== 'ObjectPattern')
+                    continue;
+                if (!declarator.init || declarator.init.type !== 'CallExpression')
+                    continue;
+                if (declarator.init.callee.type !== 'Identifier' || declarator.init.callee.name !== 'useContext')
+                    continue;
+                if (declarator.init.arguments.length !== 0)
+                    continue;
+                return declarator.id;
+            }
+        }
+    }
+
+    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 = {
@@ -282,8 +771,6 @@ function Plugin(babel, { app, side, debug }: TOptions) {
             relativeFileName = filename.substring( cli.paths.appRoot.length );
         if (filename.startsWith( cli.paths.coreRoot ))
             relativeFileName = filename.substring( cli.paths.coreRoot.length );
-        /*if (filename.startsWith('/node_modules/5htp-core/'))
-            relativeFileName = filename.substring( '/node_modules/5htp-core/'.length );*/
         
         // The file isn't a route definition
         if (relativeFileName === undefined) {
@@ -304,7 +791,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
     function transformDataFetchers( 
         path: NodePath<types.CallExpression>, 
-        routerDefContext: PluginObj, 
+        routerDefContext: TPluginState, 
         routeDef: TRouteDefinition 
     ) {
         path.traverse({
@@ -640,4 +1127,4 @@ function Plugin(babel, { app, side, debug }: TOptions) {
     }
 
     return plugin;
-}
+}

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 '../..';
@@ -48,6 +45,7 @@ export default function createCommonConfig(
 ): webpack.Configuration {
 
     const dev = mode === 'dev';
+    const buildCheck = dev && cli.commandName === 'build';
     const config: webpack.Configuration = {
 
         // Project root
@@ -88,12 +86,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({
@@ -136,13 +128,17 @@ export default function createCommonConfig(
         // "webpack" The "path" argument must be of type string. Received undefined
         // https://github.com/webpack/webpack/issues/12616
         // Update: Hum it's fixed, just had to update webpack deps
-        cache: dev,
+        cache: dev && !buildCheck,
 
-        profile: true,
+        profile: !buildCheck,
 
         // Pour bundle-stats
         // https://github.com/relative-ci/bundle-stats/tree/master/packages/cli#webpack-configuration
-        stats: {
+        stats: buildCheck ? {
+            colors: true,
+            errorDetails: true,
+            timings: true,
+        } : {
             cached: dev,
             cachedAssets: dev,
             chunks: dev,
@@ -160,4 +156,4 @@ export default function createCommonConfig(
 
     return config;
 
-}
+}