5htp 0.0.2

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

@@ -0,0 +1,337 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Node
+import path from 'path';
+
+// Npm
+import { PluginObj } from '@babel/core';
+import * as types from '@babel/types'
+import generate from '@babel/generator';
+import micromatch from 'micromatch';
+import fs from 'fs-extra';
+
+/*----------------------------------
+- REGEX
+----------------------------------*/
+
+type TRequest = {
+    source: string,
+    from: string
+} & ({
+    type: 'import',
+    default?: string,
+    specifiers: string[]
+} | {
+    type: 'require'
+})
+
+type TUnresolvedRequest = {
+    source: string,
+    from: string,
+    type: 'import' | 'require',
+}
+
+type FileMatch = { filename: string, matches: string[] };
+
+type TTransformer = (
+    request: TRequest,
+    matches: FileMatch[],
+    t: typeof types
+) => types.Node[] | void
+
+type TTransformRule = {
+    test: (request: TUnresolvedRequest) => boolean,
+    replace: TTransformer
+}
+
+type TOptions = {
+    debug?: boolean,
+    removeAliases?: (source: string) => string
+}
+
+/*----------------------------------
+- WEBPACK RULE
+----------------------------------*/
+
+const ruleBuilder = (options: TOptions, rules: TTransformRule[]) => [Plugin, { ...options, rules }];
+export default ruleBuilder;
+
+/*----------------------------------
+- PLUGIN
+----------------------------------*/
+
+function getFiles( dir: string ) {
+    const files: string[] = [];
+    const dirents = fs.readdirSync(dir, { withFileTypes: true });
+    for (const dirent of dirents) {
+        const res = path.resolve(dir, dirent.name);
+        if (dirent.isDirectory()) {
+            files.push(...getFiles(res));
+        } else {
+            files.push(res);
+        }
+    }
+    return files;
+}
+
+function Plugin (babel, { rules, debug, removeAliases }: TOptions & { rules: TTransformRule[] }) {
+
+    //debug = true;
+
+    const t = babel.types as typeof types;
+
+    const findFiles = (request: TUnresolvedRequest): { 
+        files: FileMatch[], 
+        replace: TTransformer | undefined
+    } | null => {
+
+        const matchingRule = rules.find(({ test }) => test(request));
+        if (!request.source.includes('*'))
+            return null;
+
+        let cheminGlob: string = request.source;
+
+        // Chemin relatif => Transformation en absolu
+        if (cheminGlob[0] === '.')
+            cheminGlob = path.resolve( path.dirname(request.from), request.source );
+        // Chemin absolu => Remplacement alias
+        else if (removeAliases !== undefined)
+            cheminGlob = removeAliases(request.source);
+
+        // List files in the search directory
+        const wildcardPos = cheminGlob.indexOf('*');
+        const rootDir = cheminGlob.substring(0, wildcardPos);
+        const allfiles = getFiles(rootDir);
+
+        // Find matches + keep captured groups
+        debug && console.log(`Searching for files matching ${request.source} in directory ${rootDir}`);
+        const regex = micromatch.makeRe(cheminGlob, { capture: true });
+        const matchedFiles: FileMatch[] = [];
+        for (const file of allfiles) {
+            const matches = file.match(regex);
+            if (matches) 
+                matchedFiles.push({ filename: file, matches: matches.slice(1) });
+        }
+        debug && console.log('IMPORT GLOB', request.source, '=>', cheminGlob, matchingRule ? 'from rule' : '', matchedFiles)
+
+        return { files: matchedFiles, replace: matchingRule?.replace };
+     }
+
+    const plugin: PluginObj<{ fichier: string }> = {
+        pre(state) {
+            this.fichier = state.opts.filename as string;
+        },
+        visitor: {
+
+            // require("path")
+            CallExpression(instruction) {
+
+                const { callee, arguments: args } = instruction.node;
+                if (!(
+                    callee.type === "Identifier" && callee.name === 'require' 
+                    && 
+                    args.length === 1 && args[0].type === "StringLiteral"
+                ))
+                    return;
+
+                const chemin = args[0].value;
+
+                // Glob
+                const unresolvedRequest: TUnresolvedRequest = {
+                    type: 'require',
+                    source: chemin,
+                    from: this.fichier
+                };
+                const result = findFiles(unresolvedRequest);
+                if (result === null) return;
+                const { replace, files } = result
+
+                let remplacement: types.Node[] | void;
+                if (replace !== undefined)
+                    remplacement = replace(unresolvedRequest, files, t);
+
+                if (remplacement === undefined) {
+
+                    remplacement = files.map(fichier => t.callExpression(
+                        t.identifier('require'),
+                        [t.stringLiteral(fichier.filename)]
+                    ))
+
+                }
+
+                /*debug && console.log(
+                    generate(instruction.node).code,
+                    '=>',
+                    generate(t.program(remplacement)).code,
+                );*/
+
+                instruction.replaceWithMultiple(remplacement);
+
+            },
+
+            ImportDeclaration(instruction) {
+
+                const chemin = instruction.node.source.value;
+                const unresolvedRequest: TUnresolvedRequest = {
+                    type: 'import',
+                    source: chemin,
+                    from: this.fichier
+                };
+                const result = findFiles(unresolvedRequest);
+                if (result === null) return;
+                const { replace, files } = result
+
+                // Référe,ncement des noms à importer
+                let importDefault: string | undefined = undefined;
+                let importClassique: string[] = []
+                let importAll: boolean = false;
+                for (const specifier of instruction.node.specifiers) {
+                    
+                    console.log("specifier.type", specifier.type);
+
+                    /*
+                        import templates from '@/earn/serveur/emails/*.hbs';
+                        =>
+                        import templates_notifications from '@/earn/serveur/emails/notifications.hbs';
+                        import templates_inscription from '@/earn/serveur/emails/inscription.hbs';
+                        const templates = {
+                            notifications: templates_notifications,
+                            inscription: templates_inscription,
+                        }
+                    */
+                    if (specifier.type === 'ImportDefaultSpecifier') {
+
+                        importDefault = specifier.local.name;
+
+                    /*
+                        import { notifications, inscription } from '@/earn/serveur/emails/*.hbs';
+                        =>
+                        import notifications from '@/earn/serveur/emails/notifications.hbs';
+                        import inscription from '@/earn/serveur/emails/inscription.hbs';
+                    */
+                    } else if (specifier.type === 'ImportSpecifier') {
+
+                        importClassique.push( specifier.local.name );
+
+                    /*
+                        import * as templates from '@/earn/serveur/emails/*.hbs';
+                        =>
+                        import * as templates_notifications from '@/earn/serveur/emails/notifications.hbs';
+                        import * as templates_inscription from '@/earn/serveur/emails/inscription.hbs';
+                        const templates = {
+                            notifications: templates_notifications,
+                            inscription: templates_inscription,
+                        }
+                    */
+                    } else if (specifier.type === 'ImportNamespaceSpecifier') {
+
+                        importDefault = specifier.local.name;
+                        importAll = true;
+
+                    }
+
+                }
+
+                let remplacement: types.Node[] | void;
+                if (replace !== undefined)
+                    remplacement = replace({
+                        ...unresolvedRequest,
+                        default: importDefault,
+                        specifiers: importClassique
+                    }, files, t);
+
+                if (remplacement === undefined) {
+
+                    // Recup liste files disponibles et création des importations
+                    let nomImports: [string, string][] = []
+                    remplacement = [];
+                    
+                    for (const fichier of files) {
+
+                        /// Exclusion du fichier actuel
+                        if (fichier.filename === this.fichier)
+                            continue;
+
+                        // import <chemin>
+                        if (instruction.node.specifiers.length === 0) {
+
+                            remplacement.push(
+                                t.importDeclaration(
+                                    [],
+                                    t.stringLiteral(fichier.filename)
+                                )
+                            );
+
+                        } else {
+
+                            // Création nom d'importation via le nom du fichier
+                            const posSlash = fichier.filename.lastIndexOf('/') + 1;
+                            const posExt = fichier.filename.lastIndexOf('.');
+                            const nomFichier = fichier.filename.substring(
+                                posSlash,
+                                posExt > posSlash ? posExt : undefined
+                            )
+                            const nomFichierPourImport = fichier.matches.join('_')
+
+                            //console.log({ posSlash, posExt, length: fichier.length, nomFichier });
+                            
+                            let nomImport: string;
+                            // import <nom> from <chemin>
+                            if (importClassique.includes( nomFichier ))
+                                nomImport = nomFichierPourImport;
+                            // import <prefixe>_<nom> from <chemin>
+                            else if (importDefault !== undefined) {
+                                nomImport = importDefault + '_' + nomFichierPourImport.replace(
+                                    /[ \/]/g, '_'
+                                );
+                                nomImports.push([nomImport, nomFichierPourImport])
+                            } else
+                                continue;
+
+                            // Création de l'importation
+                            remplacement.push(
+                                t.importDeclaration(
+                                    [ importAll
+                                        ? t.importNamespaceSpecifier( t.identifier(nomImport) )
+                                        : t.importDefaultSpecifier( t.identifier(nomImport) )
+                                    ],
+                                    t.stringLiteral(fichier.filename)
+                                )
+                            );
+
+                        }
+
+                    }
+
+                    // Import default
+                    if (importDefault !== undefined)
+                        remplacement.push(
+                            t.variableDeclaration('const', [
+                                t.variableDeclarator(
+                                    t.identifier(importDefault),
+                                    t.objectExpression(
+                                        nomImports.map(([nomImport, nomFichier]) => t.objectProperty(
+                                            t.stringLiteral(nomFichier),
+                                            t.identifier(nomImport),
+                                        ))
+                                    )
+                                )
+                            ])
+                        )
+                }
+
+                debug && console.log(
+                    generate(instruction.node).code,
+                    '=>',
+                    generate( t.program(remplacement) ).code,
+                );
+                
+                instruction.replaceWithMultiple(remplacement);
+            }
+        }
+    };
+
+    return plugin;
+}

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

@@ -0,0 +1,223 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import { PluginObj } from '@babel/core';
+import * as types from '@babel/types'
+var minimatch = require("minimatch")
+
+import cli from '@cli';
+
+/*----------------------------------
+- WEBPACK RULE
+----------------------------------*/
+const globServices = cli.paths.app.root + '/src/server/services/**/*.ts';
+const globModuleService = '@app/server/services/**';
+const globRoutes = cli.paths.app.root + '/src/server/routes/**/*.ts';
+
+module.exports = {
+    test: [globRoutes, globServices],
+    plugins: [
+        [Plugin]
+    ]
+}
+
+/*----------------------------------
+- PLUGIN
+----------------------------------*/
+function Plugin (babel) {
+
+    const t = babel.types as typeof types;
+
+    const remplacerFonction = require('./remplacerFonction').default(t);
+
+    const plugin: PluginObj<{
+        fichier: string,
+        cheminApi: string | undefined,
+        dependances: {[fichier: string]: {  }}
+        nbDependances: number,
+        servicesImportes: {[nom: string]: string}
+    }> = {
+        pre(state) {
+
+            this.fichier = state.opts.filename as string;
+
+            this.cheminApi = getCheminControleur(this.fichier);
+
+            //console.log('fichier', fichier);
+
+            this.dependances = {}; // fichier service => { classe, dependances }
+            this.nbDependances = 0;
+
+            // Permet d'identifier le chemin du module associé à un nom de type
+            this.servicesImportes = {};
+
+            for (const nomBinding in state.scope.bindings) {
+                const binding = state.scope.bindings[nomBinding].path;
+                // Les services doitvent être importés via un import default
+                if (binding.type === 'ImportDefaultSpecifier' && binding.parent.type === 'ImportDeclaration') {
+
+                    const fichier = binding.parent.source.value;
+
+                    if (!minimatch(fichier, globModuleService))
+                        continue;
+
+                    this.servicesImportes[nomBinding] = fichier;
+
+                }
+            }
+
+        },
+        visitor: {
+
+            // Typescript vire les imports quand ils sont utilisés uniquement comme des types
+            // Etant donné que ces derniers sont encore visibles dans pre(state) mais qu'ils le sont plus ici,
+            // On les rajoute
+            Program(path) {
+                for (const nomService in this.servicesImportes) {
+                    if (!( nomService in path.scope.bindings )) {
+
+                        console.log('Importation forcée de ' + nomService + ' dans ' + this.fichier);
+
+                        path.unshiftContainer(
+                            'body',
+                            t.importDeclaration(
+                                [t.importDefaultSpecifier( t.identifier(nomService) )],
+                                t.stringLiteral( this.servicesImportes[ nomService ] )
+                            )
+                        )
+                    }
+                }
+            },
+
+            // Classe service
+            ClassMethod(i) {
+                try {
+
+                    const constructeurService = (
+                        i.node.kind === 'constructor' 
+                        && 
+                        i.node.params.length !== 0
+                    );
+                    if (!constructeurService) return;
+
+                    const classeParent = i.findParent(p => p.node.type === 'ClassDeclaration');
+                    const parentService = (
+                        classeParent !== undefined
+                        &&
+                        (classeParent.node as types.ClassDeclaration).id.name.endsWith('Service')
+                    )
+                    if (!parentService) return;
+
+                    // Extraction de la liste des dépendances
+                    const remplacement = remplacerFonction.bind(this)(i.node)
+                    if (remplacement !== null)
+                        i.replaceWith(remplacement);
+
+                } catch (e) {
+                    console.error("[plugin injection-dependances] Erreur traitement constructeur classe", e);
+                    throw e;
+                }
+            },
+
+            // Route
+            CallExpression(i) {
+                try {
+
+                    if (i.node.loc === undefined) return; // Pas de loc = nouvellement créé = Pas besoin de retraiter
+
+                    // xxx.get('/', ...)
+                    if (
+                        i.node.callee.type === 'MemberExpression'
+                        &&
+                        i.node.callee.property.type === 'Identifier'
+                        &&
+                        ['get', 'post', 'put', 'delete'].includes(i.node.callee.property.name)
+                        &&
+                        i.node.arguments.length >= 2 // url + au moins 1 middleware
+                        &&
+                        i.node.arguments[0].type === 'StringLiteral'
+                    ) {
+
+                        i.replaceWith(
+                            t.callExpression(
+                                i.node.callee, 
+                                i.node.arguments.map((arg) => (
+                                    // async ( ... ) => { ... }
+                                    arg.type === 'ArrowFunctionExpression'
+                                    &&
+                                    arg.async === true
+                                    &&
+                                    arg.params.length !== 0
+                                ) ? remplacerFonction.bind(this)(arg) || arg : arg)
+                            )
+                        );
+
+                    }
+
+                } catch (e) {
+                    console.error("[plugin injection-dependances] Erreur traitement controleur route", e);
+                    throw e;
+                }
+
+            },
+
+            // Injection chemin fichier dans la définition des requetes api
+            ExportDefaultDeclaration(instruction) {
+
+                if (this.cheminApi === undefined)
+                    return;
+
+                const declaration = instruction.node.declaration;
+
+                // Avant: export default Route.api({ ... });
+                // Après: export default Route.api({ ... }, 'Earn.Tasks.Missions.Get');
+                if (
+                    declaration.type === 'CallExpression'
+                    &&
+                    declaration.callee.type === 'MemberExpression'
+                    &&
+                    declaration.callee.object.type === 'Identifier'
+                    &&
+                    declaration.callee.object.name === 'Route'
+                    &&
+                    declaration.callee.property.type === 'Identifier'
+                    &&
+                    declaration.callee.property.name === 'api'
+                    &&
+                    declaration.arguments.length === 1
+                    &&
+                    declaration.arguments[0].type === 'ObjectExpression'
+                ) {
+
+                    //console.log('METHODES API', this.cheminApi);
+
+                    const chemin = this.cheminApi;
+
+                    instruction.replaceWith(
+                        t.exportDefaultDeclaration(
+                            t.callExpression(
+                                declaration.callee,
+                                [
+                                    declaration.arguments[0],
+                                    t.stringLiteral(chemin)
+                                ]
+                            )
+                        )
+                    )
+
+                }
+
+            }
+        },
+        post(state) {
+
+            if (this.nbDependances !== 0)
+                state.metadata['injection-dependances'] = this.dependances;
+
+        }
+    };
+
+    return plugin;
+}