5htp 0.5.9-42 → 0.5.9-7

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

@@ -4,7 +4,8 @@
 
 // Npm
 import * as types from '@babel/types'
-import type { PluginObj } from '@babel/core';
+import type { NodePath, PluginObj } from '@babel/core';
+import generate from '@babel/generator';
 
 // Core
 import cli from '@cli';
@@ -24,12 +25,19 @@ type TOptions = {
  * Extended source type: now includes "models"
  * so we can differentiate how we rewrite references.
  */
-type TImportSource = 'container' | 'application' | 'models';
+type TImportSource = 'container' | 'services' | 'models' | 'request';
 
 module.exports = (options: TOptions) => (
     [Plugin, options]
 )
 
+type TImportedIndex = {
+    local: string,
+    imported: string,                // The original “imported” name
+    references: NodePath<types.Node>[],                   // reference paths
+    source: TImportSource            // container | application | models
+}
+
 /*----------------------------------
 - PLUGIN
 ----------------------------------*/
@@ -54,8 +62,6 @@ function Plugin(babel, { app, side, debug }: TOptions) {
           this.app.Models.client.MyModel.someCall();
   
         Processed files:
-          @/server/config
-          @/server/routes
           @/server/services
     */
 
@@ -68,40 +74,65 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
         // Count how many total imports we transform
         importedCount: number,
+        routeMethods: string[],
 
         // 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
-            }
+        imported: {
+            [localName: string]: TImportedIndex
         }
-
-        // 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.processFile = this.filename.startsWith(cli.paths.appRoot + '/server/services');
+
+            this.imported = {};
+            
             this.importedCount = 0;
             this.debug = debug || false;
+
+            this.routeMethods = [];
         },
 
         visitor: {
 
+            // Detect decored methods before other plugins remove decorators
+            Program(path) {
+
+                if (!this.processFile) return;
+
+                // Traverse the AST within the Program node
+                path.traverse({
+                    ClassMethod: (subPath) => {
+                        const { node } = subPath;
+                        if (!node.decorators || node.key.type !== 'Identifier') return;
+
+                        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'
+                                )
+                            );
+
+                            if (!isRoute) continue;
+
+                            const methodName = node.key.name;
+                            this.routeMethods.push( methodName );
+
+                        }
+                    }
+                });
+            },
+
             /**
              * Detect import statements from '@app' or '@models'
              */
@@ -109,7 +140,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                 if (!this.processFile) return;
 
                 const source = path.node.source.value;
-                if (source !== '@app' && source !== '@models') {
+                if (source !== '@app' && source !== '@models' && source !== '@request') {
                     return;
                 }
 
@@ -121,25 +152,32 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     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';
+                    switch (source) {
+                        case '@app':
+                            // Distinguish whether it's a container service or an application service
+                            if (app.containerServices.includes(specifier.imported.name)) {
+                                importSource = 'container';
+                            } else {
+                                importSource = 'services';
+                            }
+                            break;
+                        case '@request':
+                            importSource = 'request';
+                            break;
+                        case '@models':
+                            // source === '@models'
+                            importSource = 'models';
+                            break;
+                        default:
+                            throw new Error(`Unknown import source: ${source}`);
                     }
 
-                    this.importedReferences[specifier.local.name] = {
+                    this.imported[specifier.local.name] = {
+                        local: specifier.local.name,
                         imported: specifier.imported.name,
-                        bindings: path.scope.bindings[specifier.local.name].referencePaths,
+                        references: 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
@@ -149,7 +187,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
                 // 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) {
+                if (source === '@app') {
                     replaceWith.push(
                         t.importDeclaration(
                             [t.importDefaultSpecifier(t.identifier('container'))],
@@ -165,78 +203,124 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                 path.replaceWithMultiple(replaceWith);
             },
 
-            /**
-             * Rewrite references to the imports
-             */
-            Identifier(path) {
-                if (!this.processFile || this.importedCount === 0) {
-                    return;
-                }
+            // This visitor fires for every class method.
+            ClassMethod(path) {
 
-                const name = path.node.name;
-                const ref = this.importedReferences[name];
-                if (!ref || !ref.bindings) {
-                    return;
-                }
+                // Must be a server service
+                if (!this.processFile || path.replaced) 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;
+                // Must have a method name
+                if (path.node.key.type !== 'Identifier') return;
+
+                // Init context
+                const methodName = path.node.key.name;
+                let params = path.node.params;
+
+                // Prefix references
+                path.traverse({ Identifier: (subPath) => {
+
+                    const { node } = subPath;
+                    const name = node.name;
+                    const ref = this.imported[name];
+                    if (!ref || !ref.references) {
+                        return;
                     }
-                }
-                if (!foundBinding) {
-                    return;
-                }
 
-                // Mark as replaced to avoid loops
-                foundBinding.replaced = true;
+                    // Find a specific binding that hasn't been replaced yet
+                    const foundBinding = ref.references.find(binding => {
+                        return subPath.getPathLocation() === binding.getPathLocation();
+                    });
 
-                // 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(
+                    if (!foundBinding || foundBinding.replaced)
+                        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
+                        subPath.replaceWith(
                             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.identifier('container'),
+                                subPath.node
+                            )
+                        );
+                    }
+                    else if (ref.source === 'services') {
+                        // this.app.[identifier]
+                        // e.g. this.app.MyService
+                        subPath.replaceWith(
+                            t.memberExpression(
+                                t.memberExpression(
+                                    t.thisExpression(),
+                                    t.identifier('app')
+                                ),
+                                subPath.node
+                            )
+                        );
+                    }
+                    else if (ref.source === 'models') {
+                        // this.app.Models.client.[identifier]
+                        // e.g. this.app.Models.client.MyModel
+                        subPath.replaceWith(
                             t.memberExpression(
                                 t.memberExpression(
                                     t.memberExpression(
-                                        t.thisExpression(),
-                                        t.identifier('app')
+                                        t.memberExpression(
+                                            t.thisExpression(),
+                                            t.identifier('app')
+                                        ),
+                                        t.identifier('Models')
                                     ),
-                                    t.identifier('Models')
+                                    t.identifier('client')
                                 ),
-                                t.identifier('client')
-                            ),
-                            path.node
+                                subPath.node
+                            )
+                        );
+                    }
+                    else if (ref.source === 'request') {
+                        // this.app.Models.client.[identifier]
+                        // e.g. this.app.Models.client.MyModel
+                        subPath.replaceWith(
+                            t.memberExpression(
+                                t.identifier('context'),
+                                subPath.node
+                            )
+                        );
+                    }
+
+                } });
+
+                if (
+                    this.routeMethods.includes(methodName) 
+                    && 
+                    path.node.params.length < 2
+                ) {
+
+                    // Expose router context variable via the second parameter
+                    params = [
+                        path.node.params[0] || t.objectPattern([]),
+                        t.identifier('context'),
+                    ];
+
+                    // Apply changes
+                    path.replaceWith(
+                        t.classMethod(
+                            path.node.kind,
+                            path.node.key,
+                            params,
+                            path.node.body,
+                            false,
+                            false,
+                            false,
+                            path.node.async
                         )
                     );
                 }
+
+                //console.log("ROUTE METHOD", this.filename, methodName, generate(path.node).code);
             }
         }
     };

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

@@ -173,6 +173,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     }
 
                     // Adjust
+                    // /client/pages/*
                     if (this.file.side === 'front') {
                         transformDataFetchers(path, this, routeDef);
                     }
@@ -183,12 +184,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     // Delete the route def since it will be replaced by a wrapper
                     path.replaceWithMultiple([]);
 
-                /* [client] Backend Service calls: Transform to api.post( <method path>, <params> )
-
-                    Events.Create( form.data ).then(res => toast.success(res.message))
-                    =>
-                    api.post( '/api/events/create', form.data ).then(res => toast.success(res.message))
-                */
+      
                 } else if (this.file.side === 'front') {
                     
                     const isAService = (
@@ -199,14 +195,20 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     if(!isAService)
                         return;
 
-                    if (side === 'client') {
+                    /* [client] Backend Service calls: Transform to api.post( <method path>, <params> )
+
+                        Events.Create( form.data ).then(res => toast.success(res.message))
+                        =>
+                        api.post( '/api/events/create', form.data ).then(res => toast.success(res.message))
+                    */
+                    if (side === 'client' && !clientServices.includes(serviceName)) {
 
                         // Get complete call path
                         const apiPath = '/api/' + completePath.join('/');
                         
                         // Replace by api.post( <method path>, <params> )
                         const apiPostArgs: types.CallExpression["arguments"] = [t.stringLiteral(apiPath)];
-                        if (path.node.arguments.length === 1)
+                        if (path.node.arguments.length >= 1)
                             apiPostArgs.push( path.node.arguments[0] );
 
                         path.replaceWith(
@@ -216,6 +218,13 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                                 ), apiPostArgs
                             )
                         )
+
+                    /* [server] Backend Service calls
+
+                        Events.Create( form.data ).then(res => toast.success(res.message))
+                        =>
+                        app.Events.Create( form.data, context ).then(res => toast.success(res.message))
+                    */
                     } else {
 
                         // Rebuild member expression from completePath, adding a api prefix
@@ -233,7 +242,8 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                         // Replace by app.<service>.<method>(...)
                         path.replaceWith(
                             t.callExpression(
-                                newCallee, [...path.node.arguments]
+                                newCallee, 
+                                [...path.node.arguments]
                             )
                         )
                     }
@@ -322,7 +332,39 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     }
                 */
                 routeDef.dataFetchers.push(
-                    ...path.node.arguments[0].properties
+                    ...path.node.arguments[0].properties.map(p => {
+
+                        // Server side: Pass request context as 2nd argument
+                        // companies: Companies.create( <params>, context )
+                        if (
+                            side === 'server'
+                            &&
+                            p.type === 'ObjectProperty'
+                            &&
+                            p.key.type === 'Identifier'
+                            &&
+                            p.value.type === 'CallExpression'
+                            && 
+                            // TODO: reliable way to know if it's a service
+                            !(
+                                p.value.callee.type === 'MemberExpression'
+                                &&
+                                p.value.callee.object.type === 'Identifier'
+                                &&
+                                p.value.callee.object.name === 'api'
+                            )
+                        ) {
+                            
+                            // Pass request context as 2nd argument
+                            p.value.arguments = p.value.arguments.length === 0
+                                ? [ t.objectExpression([]), t.identifier('context') ]
+                                : [ p.value.arguments[0], t.identifier('context') ];
+
+                        }
+
+                        return p;
+
+                    })
                 );
 
                 /*  Replace the: 
@@ -376,9 +418,19 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         // Add data fetchers
         if (routeDef.dataFetchers.length !== 0) {
 
+            const rendererContext = t.cloneNode( renderer.params[0] );
+            // If not already present, add context to the 1st argument (a object spread)
+            if (!rendererContext.properties.some( p => p.key.name === 'context' ))
+                rendererContext.properties.push(
+                    t.objectProperty(
+                        t.identifier('context'),
+                        t.identifier('context')
+                    )
+                )
+
             // (contollerParams) => { stats: api.get(...) }
             const dataFetchersFunc = t.arrowFunctionExpression(
-                renderer.params.map( param => t.cloneNode( param )),
+                [rendererContext],
                 t.objectExpression(
                     routeDef.dataFetchers.map( df => t.cloneNode( df ))
                 )
@@ -530,6 +582,10 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                 t.objectProperty(
                     t.identifier('app'),
                     t.identifier('app'),
+                ),
+                t.objectProperty(
+                    t.identifier('context'),
+                    t.identifier('context'),
                 )
             ]
             for (const [local, imported] of importedServicesList) {
@@ -575,8 +631,8 @@ function Plugin(babel, { app, side, debug }: TOptions) {
             );
                     
 
-        /*(file.path.includes('client/pages/convert/auth/login.tsx')) 
-        && console.log( file.path, generate(exportDeclaration).code );*/
+        // (file.path.includes('clients/prospect/search') && side === 'client') 
+        // && console.log( file.path, generate(exportDeclaration).code );
 
         return exportDeclaration;
     }

package/compiler/index.ts

@@ -17,6 +17,7 @@ import cli from '..';
 import createServerConfig from './server';
 import createClientConfig from './client';
 import { TCompileMode } from './common';
+import { routerServices } from './common/babel/plugins/services';
 
 type TCompilerCallback = (compiler: webpack.Compiler) => void
 
@@ -32,6 +33,7 @@ type TServiceMetas = {
 type TRegisteredService = {
     id?: string,
     name: string,
+    className: string,
     instanciation: (parentRef: string) => string,
     priority: number,
 }
@@ -253,6 +255,7 @@ export default class Compiler {
                 id: serviceConfig.id,
                 name: serviceName,
                 instanciation,
+                className: serviceMetas.name,
                 priority: serviceConfig.config?.priority || serviceMetas.priority || 0,
             };
         }
@@ -269,43 +272,67 @@ export default class Compiler {
             path.join( app.paths.client.generated, 'services.d.ts'),
 `declare module "@app" {
 
-    import { RouenEvents as RouenEventsClient } from "@/client";
-    import RouenEventsServer from "@/server/.generated/app";
+    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<RouenEventsClient, ClientApplicationProperties>;
-    type ServerServices = Omit<RouenEventsServer, ServerApplicationProperties | keyof ClientServices>;
+    type ClientServices = Omit<${appClassIdentifier}Client, ClientApplicationProperties>;
+    type ServerServices = Omit<${appClassIdentifier}Server, ServerApplicationProperties | keyof ClientServices>;
   
     type CombinedServices = ClientServices & ServerServices;
   
     const appClass: CombinedServices;
     export = appClass;
 }
+    
+declare module '@models/types' {
+    export * from '@/var/prisma/index';
+}
 
+declare module '@request' {
+    
+}
 
-// Temporary
-/*declare module '@models' {
-    export * from '@/var/prisma/index';
-}*/
-  
-declare module '@models' {
-    import { Prisma, PrismaClient } from '@/var/prisma/index';
-  
-    type ModelNames = Prisma.ModelName;
-  
-    type ModelDelegates = {
-        [K in ModelNames]: PrismaClient[Uncapitalize<K>];
-    };
-  
-    const models: ModelDelegates;
-  
-    export = models;
+declare namespace preact.JSX {
+    interface HTMLAttributes {
+        src?: string;
+    }
 }
-  `
+`
         );
 
+        fs.outputFileSync(
+            path.join( app.paths.client.generated, 'context.ts'),
+`// TODO: move it into core (but how to make sure usecontext returns ${appClassIdentifier}'s context ?)
+import React from 'react';
+
+import type ${appClassIdentifier}Server from '@/server/.generated/app';
+import type { TRouterContext as TServerRouterRequestContext } from '@server/services/router/response';
+import type { TRouterContext as TClientRouterRequestContext } from '@client/services/router/response';
+import type ${appClassIdentifier}Client from '.';
+
+// TO Fix: TClientRouterRequestContext is unable to get the right type of ${appClassIdentifier}Client["router"]
+    //    (it gets ClientApplication instead of ${appClassIdentifier}Client)
+type ClientRequestContext = TClientRouterRequestContext<${appClassIdentifier}Client["Router"], ${appClassIdentifier}Client>;
+type ServerRequestContext = TServerRouterRequestContext<${appClassIdentifier}Server["Router"]>
+type UniversalServices = ClientRequestContext | ServerRequestContext
+
+// Non-universla services are flagged as potentially undefined
+export type ClientContext = (
+    UniversalServices 
+    & 
+    Partial<Omit<ClientRequestContext, keyof UniversalServices>>
+    &
+    {
+        Router: ${appClassIdentifier}Client["Router"],
+    }
+)
+
+export const ReactClientContext = React.createContext<ClientContext>({} as ClientContext);
+export default (): ClientContext => React.useContext<ClientContext>(ReactClientContext);`);
+
         fs.outputFileSync(
             path.join( app.paths.server.generated, 'app.ts'),
 `import { Application } from '@server/app/index';
@@ -315,7 +342,7 @@ ${imported.join('\n')}
 export default class ${appClassIdentifier} extends Application {
 
     ${sortedServices.map(service => 
-        `public ${service.name}!: ReturnType<${appClassIdentifier}["registered"]["${service.id}"]["start"]>;`
+        `public ${service.name}!: ${service.className};`
     ).join('\n')}
 
     protected registered = {
@@ -373,6 +400,12 @@ declare module '@server/app' {
 
     export = foo;
 }
+
+declare module '@request' {
+    import type { TRouterContext } from '@server/services/router/response';
+    const routerContext: TRouterContext<CrossPath["Router"]>;
+    export = routerContext;
+}
     
 declare module '@models' {
     import { Prisma, PrismaClient } from '@/var/prisma/index';
@@ -386,6 +419,10 @@ declare module '@models' {
     const models: ModelDelegates;
   
     export = models;
+}
+    
+declare module '@models/types' {
+    export * from '@/var/prisma/index';
 }`
         );
     }

package/package.json

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