5htp 0.0.2

package/src/compiler/common/babel/plugins/injection-dependances/remplacerFonction.ts

@@ -0,0 +1,226 @@
+
+import * as types from '@babel/types'
+import generate from "@babel/generator";
+
+const servicesViaContexte: {
+    [nomService: string]: string
+} = {
+    User: 'user',
+
+    Request: 'req',
+    Response: 'res',
+    NextFunction: 'next'
+} as const
+
+const debug = false
+
+export default (t: typeof types) => {
+
+    function remplacerFonction(arg: types.ArrowFunctionExpression): null | types.ArrowFunctionExpression;
+    function remplacerFonction(arg: types.ClassMethod): null | types.ClassMethod;
+    function remplacerFonction(
+        arg: types.ArrowFunctionExpression | types.ClassMethod
+    ): null | types.ArrowFunctionExpression | types.ClassMethod {
+
+        const dejaTraite = (
+            arg.params.length === 1
+            &&
+            arg.params[0].type === 'RestElement'
+        )
+        if (dejaTraite)
+            return null;
+
+        // Return null = inchangé
+        if (arg.body.type !== 'BlockStatement')
+            return null;
+
+        let declarations: types.VariableDeclarator[] = [];
+        let instanciations: types.ExpressionStatement[] = [];
+        let extractions: types.ExpressionStatement[] = [];
+
+        // Transforme les paramètres en une liste d'instanciations
+        for (let iParam = 0; iParam < arg.params.length; iParam++) {
+            const param = arg.params[iParam];
+
+            // utilisateur: User
+            if (
+                param.type === 'Identifier' && param.typeAnnotation
+                &&
+                param.typeAnnotation.type === 'TSTypeAnnotation'
+                &&
+                param.typeAnnotation.typeAnnotation.type === 'TSTypeReference'
+                &&
+                param.typeAnnotation.typeAnnotation.typeName.type === 'Identifier'
+            ) {
+
+                const typeParam = param.typeAnnotation.typeAnnotation.typeName.name;
+                const nomParam = param.name;
+
+                // Déclaration
+                declarations.push(
+                    t.variableDeclarator(
+                        t.identifier(nomParam)
+                    )
+                );
+
+                // Instanciation (quand args[0] = contexte)
+                if (typeParam in servicesViaContexte) {
+
+                    // <nomParam> = args[ 0 ][ servicesViaContexte[ typeParam ] ];
+                    instanciations.push(
+                        t.expressionStatement(
+                            t.assignmentExpression(
+                                '=',
+                                t.identifier(nomParam),
+                                t.memberExpression(
+                                    t.memberExpression(
+                                        t.identifier('args'),
+                                        t.numericLiteral(0),
+                                        true
+                                    ),
+                                    t.identifier(servicesViaContexte[typeParam])
+                                )
+                            )
+                        )
+                    )
+
+                    // Le type du paramètre est un service reconnu
+                } else if (this.servicesImportes[typeParam] !== undefined) {
+
+                    // <nomParam> = new <typeParam>( args[0] );
+                    instanciations.push(
+                        t.expressionStatement(
+                            t.assignmentExpression(
+                                '=',
+                                t.identifier(nomParam),
+                                t.newExpression(
+                                    t.identifier(typeParam),
+                                    [
+                                        t.memberExpression(
+                                            t.identifier('args'),
+                                            t.numericLiteral(0),
+                                            true
+                                        )
+                                    ]
+                                )
+                            )
+                        )
+                    );
+
+                } else {
+                    console.log(this.servicesImportes);
+                    throw new Error(`Impossible de trouver l'import associée au type portant pour nom ${typeParam} (fichier: ${this.fichier}). Liste des iportations trouvées au dessus.`)
+                }
+
+                // Extractions
+                // <nomParam> = args[ <index> ]
+                extractions.push(
+                    t.expressionStatement(
+                        t.assignmentExpression(
+                            '=',
+                            t.identifier(nomParam),
+                            t.memberExpression(
+                                t.identifier('args'),
+                                t.identifier( iParam.toString() ),
+                                true
+                            )
+                        )
+                    )
+                );
+
+            }
+        }
+
+        // Inchangé
+        if (instanciations.length === 0)
+            return null;
+
+        const conditionSiDoitInstancier = (
+            t.logicalExpression(
+                '&&',
+                t.logicalExpression(
+                    '&&',
+
+                    // args[0] !== undefined
+                    t.binaryExpression(
+                        '!==',
+                        t.memberExpression(
+                            t.identifier('args'),
+                            t.numericLiteral(0),
+                            true
+                        ),
+                        t.identifier('undefined')
+                    ),
+
+                    // typeof args[0] === 'object'
+                    t.binaryExpression(
+                        '===',
+                        t.unaryExpression(
+                            'typeof',
+                            t.memberExpression(
+                                t.identifier('args'),
+                                t.identifier('0'),
+                                true
+                            )
+                        ),
+                        t.stringLiteral('object')
+                    )
+                ),
+
+                // args[0].type === 'contexte_requete'
+                t.binaryExpression(
+                    '===',
+                    t.memberExpression(
+                        t.memberExpression(
+                            t.identifier('args'),
+                            t.identifier('0'),
+                            true
+                        ),
+                        t.identifier('type')
+                    ),
+                    t.stringLiteral('contexte_requete')
+                )
+            )
+        )
+
+        const body = t.blockStatement([
+            t.variableDeclaration('let', declarations),
+
+            // if (args[0] !== undefined && typeof args[0] === 'object' && args[0].type === 'contexte_requete')
+            t.ifStatement(
+                conditionSiDoitInstancier,
+
+                t.blockStatement(instanciations),
+
+                t.blockStatement(extractions)
+            ),
+            ...arg.body.body
+        ]);
+
+        // Remplacement paramètres et ajout des instanciations
+        const remplacement = arg.type === 'ArrowFunctionExpression'
+            ? t.arrowFunctionExpression(
+                [t.restElement( t.identifier('args') )],
+                body,
+                arg.async
+            )
+            : t.classMethod(
+                'constructor',
+                t.identifier('constructor'),
+                [t.restElement( t.identifier('args') )],
+                body
+            )
+
+        if (debug) {
+            console.log('-----------------------------');
+            console.log(generate(arg).code);
+            console.log('=>');
+            console.log(generate(remplacement).code);
+            console.log('-----------------------------');
+        }
+
+        return remplacement;
+    }
+
+    return remplacerFonction;
+}

package/src/compiler/common/babel/plugins/models.ts

@@ -0,0 +1,241 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import * as types from '@babel/types'
+import type { PluginObj, NodePath } from '@babel/core';
+import generate from '@babel/generator';
+
+// Core
+import type { TAppSide } from '@cli/index';
+
+/*----------------------------------
+- WEBPACK RULE
+----------------------------------*/
+
+type TOptions = {
+    side: TAppSide
+}
+
+module.exports = (options: TOptions) => ({
+    test: "**/server/models/**/*.ts",
+    plugins: [
+        [Plugin, options]
+    ]
+})
+
+module.exports.Plugin = Plugin;
+
+const debug = true;
+
+const metasKey = 'metadata';
+
+/*----------------------------------
+- PLUGIN
+----------------------------------*/
+function Plugin(babel, {  }: TOptions) {
+
+    const t = babel.types as typeof types;
+
+    const plugin: PluginObj<{ filename: string }> = {
+        pre(state) {
+
+            this.filename = state.opts.filename as string;
+
+        },
+        visitor: {
+            Program(path) {
+
+                const filename = this.filename;
+
+                // Lorsque les visiteurs sont déclarés à la racine du plugin,
+                //    Impossible d'obtenir les ast des décorateurs car ils ont déjà été compilés ...
+                //    Pourquoi cela fonctionne en passant par Program.traverse ?
+                path.traverse({
+                    Decorator(path) {
+
+                        injectMetadatas(path, filename, t);
+
+                    },
+                });
+                
+
+            }
+           
+        }
+    };
+
+    return plugin;
+}
+
+/*----------------------------------
+- EXTRACTION
+----------------------------------*/
+function injectMetadatas( path: NodePath<types.Decorator>, filename: string, t: typeof types ) {
+
+    // @Table( <database>, <table>, <options?> )
+    const expression = path.node.expression;
+    if (!(
+        expression.type === 'CallExpression'
+        &&
+        expression.callee.type === 'Identifier'
+        &&
+        expression.callee.name === 'Table'
+        &&
+        expression.arguments.length >= 2
+    ))
+        return;
+
+    // Class
+    const classe = path.parent;
+    if (classe.type !== 'ClassDeclaration')
+        return;
+
+    debug && console.log(`Processing class ${classe.id.name}`);
+
+    // Only process if metadata are not already defined
+    let [database, table, options] = expression.arguments;
+    if (options !== undefined) {
+
+        if (options.type !== 'ObjectExpression')
+            throw new Error(`Error in ${filename}: The 3rd argument of @Table must be an object expression.`);
+
+        const hasMetas = options.properties.some(p =>
+            p.type === 'ObjectProperty'
+            &&
+            p.key.type === 'Identifier'
+            &&
+            p.key.name === metasKey
+        );
+
+        if (hasMetas) {
+            debug && console.log(`Metadata already provides for class ${classe.id.name} (${filename})`);
+            return;
+        }
+    }
+
+    // Extract metadata
+    const attributes = extractMetadata(classe, t);
+    //debug && console.log( generate(attributes).code );
+    const metasProperty = t.objectProperty(
+        t.identifier(metasKey),
+        t.objectExpression(attributes)
+    )
+
+    // Insert metas in options
+    if (options === undefined)
+        options = t.objectExpression([metasProperty]);
+    else
+        options = t.objectExpression([...options.properties, metasProperty]);
+
+    // Update decorator
+    path.replaceWith(t.decorator(
+        t.callExpression(t.identifier('Table'), [
+            database,
+            table,
+            options
+        ])
+    ));
+}
+
+function extractMetadata(classe: types.ClassDeclaration, t: typeof types) {
+
+    const attributes: types.ObjectProperty[] = [];
+
+    // Lecture des propriétés et méthodes de la classe
+    for (const prop of classe.body.body) {
+
+        if (!(
+            // non-statique
+            !prop.static
+            &&
+            (
+                // Propriété simple
+                prop.type === 'ClassProperty'
+                || 
+                // Getter
+                (prop.type === 'ClassMethod' && prop.kind === 'get')
+            )
+            &&
+            // Publique
+            prop.accessibility === 'public'
+            &&
+            prop.key.type === 'Identifier'
+        ))
+            continue;
+
+        const nomProp = prop.key.name;
+
+        // Détermine si la propriété est exposée à l'api
+        // = possède le décorateur @API()
+        const exposeToAPI = prop.decorators && prop.decorators.some((decorateur) =>
+            decorateur.expression.type === 'CallExpression'
+            &&
+            decorateur.expression.callee.type === 'Identifier'
+            &&
+            decorateur.expression.callee.name === 'API'
+        );
+
+        if (!exposeToAPI) continue;
+
+        let type: any;
+        if (prop.type === 'ClassProperty')
+            type = prop.typeAnnotation;
+        else
+            type = prop.returnType;
+
+        // Verif si type spécifié
+        if (!type)
+            throw new Error(`Unable to extract type of ${classe.id.name}.${prop.key.name}.`);
+
+        // Sérialisation du type
+        const typeString = generate(type.typeAnnotation).code;
+
+        debug && console.log( classe.id.name + '.' + nomProp + ': ' + typeString );
+
+        // Sérialisation valeur defaut
+        const defaut = prop.type === 'ClassProperty' && prop.value && ('value' in prop.value)
+            ? prop.value
+            : t.identifier('undefined')
+
+        attributes.push(
+            t.objectProperty( t.identifier(nomProp), t.objectExpression([
+
+                t.objectProperty( 
+                    t.identifier('nom'), 
+                    t.stringLiteral(nomProp)
+                ),
+
+                t.objectProperty( 
+                    t.identifier('nomComplet'), 
+                    t.stringLiteral(prop.optional ? nomProp + '?' : nomProp)
+                ),
+
+                t.objectProperty( 
+                    t.identifier('type'), 
+                    t.stringLiteral(typeString)
+                ),
+
+                t.objectProperty( 
+                    t.identifier('optionnel'), 
+                    t.booleanLiteral(prop.optional === true)
+                ),
+
+                t.objectProperty(
+                    t.identifier('api'),
+                    t.booleanLiteral(exposeToAPI)
+                ),
+
+                t.objectProperty(
+                    t.identifier('defaut'),
+                    defaut
+                ),
+                
+            ]))
+        );
+    }
+
+    return attributes;
+
+}

package/src/compiler/common/babel/plugins/pages.ts

@@ -0,0 +1,185 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import * as types from '@babel/types'
+import type { PluginObj, NodePath } from '@babel/core';
+import generate from '@babel/generator';
+
+// Core
+import cli from '@cli';
+import { TAppSide } from '@cli/index';
+
+/*----------------------------------
+- WEBPACK RULE
+----------------------------------*/
+
+type TOptions = {
+    side: TAppSide
+}
+
+module.exports = (options: TOptions) => ({
+    test: "**/client/pages/**/*.tsx",
+    plugins: [
+        [Plugin, options]
+    ]
+})
+
+const debug = false;
+
+/*----------------------------------
+- PLUGIN
+----------------------------------*/
+function Plugin(babel, { side }: TOptions) {
+
+    const t = babel.types as typeof types;
+    let program: NodePath<types.Program>;
+
+    const plugin: PluginObj<{ 
+        filename: string
+    }> = {
+        pre(state) {
+
+            this.filename = state.opts.filename as string;
+
+        },
+        visitor: {
+
+            Program(path) {
+                program = path;
+            },
+
+            CallExpression(path) {
+                
+                // route.xxx( <PATH>, ... )
+                if (!(
+                    path.node.callee.type === 'MemberExpression'
+                    &&
+                    path.node.callee.object.type === "Identifier"
+                    &&
+                    path.node.callee.object.name === "route"
+                    &&
+                    path.node.arguments.length >= 2
+                ))
+                    return;
+
+                const [routePath, ...routeArgs] = path.node.arguments;
+                debug && console.log(`[routes]`, this.filename, ...routeArgs.map(n => n.type));
+                    
+                // Inject chunk id in options (2nd arg)
+                const status = addChunkId(routeArgs, this.filename);
+                if (status === 'ALREADY_PROCESSED')
+                    return;
+
+                // Transform 2nd arg of renderer to a useContext spread
+                addRendererContext(routeArgs, this.filename);
+
+                const replacement = t.callExpression( path.node.callee, [ routePath, ...routeArgs ]);
+                debug && console.log( generate(replacement).code );
+
+                // Force export default
+                if (path.parent.type === 'ExportDefaultDeclaration')
+                    path.replaceWith( replacement );
+                else
+                    path.parentPath.replaceWith(
+                        t.exportDefaultDeclaration( replacement )
+                    )
+                
+            }
+           
+        }
+    };
+
+    function addChunkId( 
+        routeArgs: types.CallExpression["arguments"],
+        filename: string
+    ): void | 'ALREADY_PROCESSED' {
+
+        if (routeArgs[0].type === 'ObjectExpression') {
+
+            if (routeArgs[0].properties.some(o =>
+                o.type === 'ObjectProperty'
+                &&
+                o.key.type === 'Identifier'
+                &&
+                o.key.name === 'id'
+            )) {
+                debug && console.log(`[routes]`, filename, 'Already Processed');
+                return 'ALREADY_PROCESSED';
+            }
+
+        } else
+            routeArgs.unshift(t.objectExpression([]));
+
+        const { filepath, chunkId } = cli.paths.getPageChunk(filename);
+        debug && console.log(`[routes]`, filename, '=>', chunkId);
+
+        // Add object property
+        (routeArgs[0] as types.ObjectExpression).properties.push(
+            t.objectProperty(
+                t.identifier('id'),
+                t.stringLiteral(chunkId)
+            ),
+            t.objectProperty(
+                t.identifier('filepath'),
+                t.stringLiteral(filepath)
+            )
+        );
+
+    }
+
+    function addRendererContext( 
+        routeArgs: types.CallExpression["arguments"],
+        filename: string
+    ) {
+
+        // ( <data>, { response, api }) => ....
+        const renderer = routeArgs[ routeArgs.length - 1 ];
+        if (!(
+            renderer.type === 'ArrowFunctionExpression' 
+            && 
+            renderer.params.length > 1
+        ))
+            return;
+
+        // Remove 2nd arg (renderer = react component, so only 1 arg for props)
+        const declaration = renderer.params.pop() as types.ArrowFunctionExpression["params"][number];
+        // const <param2> = useContext();
+        const ctxDeclaration = t.variableDeclaration('const', [t.variableDeclarator(
+            declaration,
+            t.callExpression(t.identifier('useContext'), [])
+        )])
+
+        // Add Declaration
+        switch (renderer.body.type) {
+            case 'BlockStatement':
+                renderer.body.body.unshift(ctxDeclaration);
+                break;
+            // TODO: Si type === JSXElement, remplacer par BlockStatement (ctxDeclaration + return JSX)
+            /*case 'BlockStatement':
+                renderer.re
+                break;*/
+            default:
+                throw new Error(`Unknown body type for the renderer: ${renderer.body.type}`);
+        }
+
+        // Add usecontext import if it doesn't exists
+        if (program.scope.bindings["useContext"] === undefined) {
+
+            debug && console.log(`[routes]`, filename, `Adding useContext import from @context`);
+
+            program.unshiftContainer(
+                'body',
+                t.importDeclaration(
+                    [t.importDefaultSpecifier(t.identifier('useContext'))],
+                    t.stringLiteral('@client/context')
+                )
+            );
+        }
+        
+
+    }
+
+    return plugin;
+}