5htp 0.6.3-2 → 0.6.3-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';
@@ -206,7 +205,7 @@ 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)) {
 
@@ -227,6 +226,8 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                                 ), apiPostArgs
                             )
                         )
+                        
+                        ensureBackendServicePromiseCatch(path);
 
                     /* [server] Backend Service calls
 
@@ -275,11 +276,254 @@ 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
     ) {
-        if (path.scope.hasBinding('api'))
+        const needsApi = !path.scope.hasBinding('api');
+        const needsApp = !path.scope.hasBinding('app');
+        if (!needsApi && !needsApp)
             return;
 
         const rootFunctionPath = getRootFunctionPath(path);
@@ -292,13 +536,42 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         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([
-                    t.objectProperty(t.identifier('api'), t.identifier('api'), false, true),
+                    ...(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'), [])
             )
@@ -318,6 +591,32 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         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();
@@ -472,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) {

package/compiler/index.ts

@@ -273,17 +273,14 @@ export default class Compiler {
 
     import { ${appClassIdentifier} as ${appClassIdentifier}Client } from "@/client";
     import ${appClassIdentifier}Server from "@/server/.generated/app";
-    
-    import { ApplicationProperties as ClientApplicationProperties } from "@client/app";
-    import { ApplicationProperties as ServerApplicationProperties } from "@server/app";
-
-    type ClientServices = Omit<${appClassIdentifier}Client, ClientApplicationProperties>;
-    type ServerServices = Omit<${appClassIdentifier}Server, ServerApplicationProperties | keyof ClientServices>;
-  
-    type CombinedServices = ClientServices & ServerServices;
   
-    const appClass: CombinedServices;
-    export = appClass;
+    export const Router: ${appClassIdentifier}Client['Router'];
+
+    ${sortedServices.map(service => service.name !== 'Router'
+        ? `export const ${service.name}: ${appClassIdentifier}Server["${service.name}"];`
+        : ''
+    ).join('\n')}
+
 }
     
 declare module '@models/types' {

package/package.json

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