5htp 0.6.3 → 0.6.4

package/app/index.ts

@@ -56,7 +56,13 @@ export class App {
     public paths = {
 
         root: cli.paths.appRoot,
-        bin: path.join( cli.paths.appRoot, 'bin'),
+        binBuild: path.join( cli.paths.appRoot, 'bin'),
+        binDev: path.join( cli.paths.appRoot, 'bin-dev'),
+        get bin() {
+            return cli.commandName === 'dev'
+                ? this.binDev
+                : this.binBuild;
+        },
         data: path.join( cli.paths.appRoot, 'var', 'data'),
         public: path.join( cli.paths.appRoot, 'public'),
         pages: path.join( cli.paths.appRoot, 'client', 'pages'),
@@ -192,4 +198,4 @@ export class App {
 
 export const app = new App
 
-export default app
+export default app

package/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+console.log('=== Running 5HTP via ts-node ===');
+
+const path = require('path');
+const tsNode = require('ts-node');
+
+tsNode.register({
+  project: path.join(__dirname, 'tsconfig.json'),
+  transpileOnly: true,
+});
+
+require('./index.ts');

package/commands/build.ts

@@ -2,22 +2,35 @@
 - DEPENDANCES
 ----------------------------------*/
 
-// Npm
-import prompts from 'prompts';
-
 // Configs
+import cli from '..';
 import Compiler from '../compiler';
+import type { TCompileMode } from '../compiler/common';
 
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
+const buildModes: TCompileMode[] = ['dev', 'prod'];
+
+function getBuildMode(): TCompileMode {
+
+    const selectedModes = buildModes.filter(mode => cli.args[mode] === true);
+
+    if (selectedModes.length > 1)
+        throw new Error(`Build mode is ambiguous. Use only one mode among: ${buildModes.join(', ')}`);
+
+    return selectedModes[0] || 'dev';
+}
+
 /*----------------------------------
 - COMMAND
 ----------------------------------*/
-export const run = (): Promise<void> => new Promise(async (resolve) => {
+export const run = (): Promise<void> => new Promise(async (resolve, reject) => {
 
-    const compiler = new Compiler('prod');
+    const mode = getBuildMode();
+
+    const compiler = new Compiler(mode);
 
     const multiCompiler = await compiler.create();
 
@@ -25,10 +38,24 @@ export const run = (): Promise<void> => new Promise(async (resolve) => {
 
         if (error) {
             console.error("An error occurred during the compilation:", error);
-            throw error;
+            reject(error);
+            return;
+        }
+
+        if (stats?.hasErrors()) {
+            reject(new Error(`Build failed in ${mode} mode.`));
+            return;
         }
 
-        //resolve();
+        multiCompiler.close((closeError) => {
+
+            if (closeError) {
+                reject(closeError);
+                return;
+            }
+
+            resolve();
+        });
 
     });
-});
+});

package/commands/refresh.ts

@@ -0,0 +1,18 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Configs
+import Compiler from '../compiler';
+
+/*----------------------------------
+- COMMAND
+----------------------------------*/
+export const run = (): Promise<void> => new Promise(async (resolve) => {
+
+    const compiler = new Compiler('dev');
+
+    await compiler.refreshGeneratedTypings();
+
+    resolve();
+});

package/compiler/client/index.ts

@@ -11,9 +11,6 @@ const TerserPlugin = require('terser-webpack-plugin');
 // Optimisations
 const BrotliCompression = require("brotli-webpack-plugin");
 import CompressionPlugin from "compression-webpack-plugin";
-const ImageMinimizerPlugin = require("image-minimizer-webpack-plugin");
-const imageminWebp = require('imagemin-webp');
-const { extendDefaultPlugins } = require("svgo");
 // Ressources
 const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");
 import MiniCssExtractPlugin from "mini-css-extract-plugin";
@@ -38,6 +35,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
 
     console.info(`Creating compiler for client (${mode}).`);
     const dev = mode === 'dev';
+    const buildCheck = dev && cli.commandName === 'build';
 
     const commonConfig = createCommonConfig(app, 'client', mode);
 
@@ -81,7 +79,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
 
         output: {
 
-            pathinfo: dev,
+            pathinfo: dev && !buildCheck,
             path: app.paths.bin + '/public',
             filename: '[name].js', // Output client.js
             assetModuleFilename: '[hash][ext]',
@@ -160,7 +158,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
             // Emit a file with assets cli.paths
             // https://github.com/webdeveric/webpack-assets-manifest#options
             new WebpackAssetsManifest({
-                output: app.paths.root + `/bin/asset-manifest.json`,
+                output: app.paths.bin + `/asset-manifest.json`,
                 publicPath: true,
                 writeToDisk: true, // Force la copie du fichier sur e disque, au lieu d'en mémoire en mode dev
                 customize: ({ key, value }) => {
@@ -170,7 +168,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                 },
                 done: (manifest, stats) => {
                     // Write chunk-manifest.json.json
-                    const chunkFileName = app.paths.root + `/bin/chunk-manifest.json`;
+                    const chunkFileName = app.paths.bin + `/chunk-manifest.json`;
                     try {
                         const fileFilter = file => !file.endsWith('.map');
                         const addPath = file => manifest.getPublicPath(file);
@@ -229,7 +227,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
         ],
 
         // https://webpack.js.org/configuration/devtool/#devtool
-        devtool: 'source-map',
+        devtool: buildCheck ? false : 'source-map',
         /*devServer: {
             hot: true,
         },*/

package/compiler/common/babel/index.ts

@@ -5,8 +5,6 @@
 // Npm
 import type webpack from 'webpack';
 import PresetBabel, { Options } from '@babel/preset-env';
-// Core
-import PluginIndexage from '../plugins/indexage';
 
 import cli from '@cli';
 import type { TAppSide, App } from '@cli/app';
@@ -70,10 +68,6 @@ module.exports = (app: App, side: TAppSide, dev: boolean): webpack.RuleSetRule[]
             // Désactive car ralenti compilation
             cacheCompression: false,
 
-            metadataSubscribers: [
-                PluginIndexage.metadataContextFunctionName
-            ],
-
             compact: !dev,
 
             // https://babeljs.io/docs/usage/options/
@@ -165,14 +159,10 @@ module.exports = (app: App, side: TAppSide, dev: boolean): webpack.RuleSetRule[]
             ],
 
             overrides: [
-
-                require('./plugins/icones-svg')(app),
                 
                 ...(side === 'client' ? [
 
                 ] : [
-                    //require('./plugins/queries'),
-                    //require('./plugins/injection-dependances'),
                 ]),
             ]
         }

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

@@ -6,6 +6,10 @@
 import * as types from '@babel/types'
 import type { NodePath, PluginObj } from '@babel/core';
 import generate from '@babel/generator';
+import fs from 'fs';
+import path from 'path';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
 
 // Core
 import cli from '@cli';
@@ -38,6 +42,170 @@ type TImportedIndex = {
     source: TImportSource            // container | application | models
 }
 
+type TRoutesIndex = {
+    byFile: Map<string, Set<string>>,
+    all: Set<string>,
+    initialized: boolean
+}
+
+const routesIndexByAppRoot = new Map<string, TRoutesIndex>();
+
+function isRouteDecoratorExpression(expression: types.Expression): boolean {
+    return (
+        // Handles the case of @Route without parameters
+        (types.isIdentifier(expression) && expression.name === 'Route')
+        ||
+        // Handles the case of @Route() with parameters
+        (
+            types.isCallExpression(expression)
+            &&
+            types.isIdentifier(expression.callee)
+            &&
+            expression.callee.name === 'Route'
+        )
+    );
+}
+
+function getRoutePathFromDecoratorExpression(expression: types.Expression): string | undefined {
+    if (
+        !types.isCallExpression(expression)
+        ||
+        !types.isIdentifier(expression.callee)
+        ||
+        expression.callee.name !== 'Route'
+    )
+        return;
+
+    const firstArg = expression.arguments[0];
+    if (!types.isStringLiteral(firstArg))
+        return;
+
+    return firstArg.value;
+}
+
+function extractRoutePathsFromCode(code: string, filename: string): Set<string> {
+    const routePaths = new Set<string>();
+
+    let ast: ReturnType<typeof parse> | undefined;
+    try {
+        ast = parse(code, {
+            sourceType: 'module',
+            sourceFilename: filename,
+            plugins: [
+                'typescript',
+                'decorators-legacy',
+                'jsx',
+                'classProperties',
+                'classPrivateProperties',
+                'classPrivateMethods',
+                'dynamicImport',
+                'importMeta',
+                'optionalChaining',
+                'nullishCoalescingOperator',
+                'topLevelAwait',
+            ],
+        });
+    } catch {
+        return routePaths;
+    }
+
+    traverse(ast, {
+        ClassMethod(path) {
+            const { node } = path;
+            if (!node.decorators || node.key.type !== 'Identifier')
+                return;
+
+            for (const decorator of node.decorators) {
+                if (!isRouteDecoratorExpression(decorator.expression))
+                    continue;
+
+                const routePath = getRoutePathFromDecoratorExpression(decorator.expression);
+                if (routePath)
+                    routePaths.add(routePath);
+            }
+        }
+    });
+
+    return routePaths;
+}
+
+function listTsFiles(dirPath: string): string[] {
+    let entries: fs.Dirent[];
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+
+    const files: string[] = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listTsFiles(fullPath));
+            continue;
+        }
+
+        const isTs = fullPath.endsWith('.ts') || fullPath.endsWith('.tsx');
+        if (!isTs || fullPath.endsWith('.d.ts'))
+            continue;
+
+        files.push(fullPath);
+    }
+    return files;
+}
+
+function initializeRoutesIndex(appRoot: string, index: TRoutesIndex) {
+    const servicesDir = path.join(appRoot, 'server', 'services');
+    const files = listTsFiles(servicesDir);
+
+    for (const file of files) {
+        let code: string;
+        try {
+            code = fs.readFileSync(file, 'utf8');
+        } catch {
+            continue;
+        }
+
+        const routes = extractRoutePathsFromCode(code, file);
+        index.byFile.set(file, routes);
+    }
+
+    index.all.clear();
+    for (const routes of index.byFile.values()) {
+        for (const route of routes)
+            index.all.add(route);
+    }
+    index.initialized = true;
+}
+
+function getRoutesIndex(appRoot: string): TRoutesIndex {
+    let index = routesIndexByAppRoot.get(appRoot);
+    if (!index) {
+        index = {
+            byFile: new Map(),
+            all: new Set(),
+            initialized: false
+        };
+        routesIndexByAppRoot.set(appRoot, index);
+    }
+
+    if (!index.initialized) {
+        initializeRoutesIndex(appRoot, index);
+    }
+
+    return index;
+}
+
+function updateRoutesIndexForFile(index: TRoutesIndex, filename: string, routePaths: Set<string>) {
+    index.byFile.set(filename, routePaths);
+
+    index.all.clear();
+    for (const routes of index.byFile.values()) {
+        for (const route of routes)
+            index.all.add(route);
+    }
+}
+
 /*----------------------------------
 - PLUGIN
 ----------------------------------*/
@@ -75,6 +243,9 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         // Count how many total imports we transform
         importedCount: number,
         routeMethods: string[],
+        routePaths: Set<string>,
+        routesIndex: TRoutesIndex,
+        contextGuardedClassMethods: WeakSet<types.ClassMethod>,
 
         // For every local identifier, store info about how it should be rewritten
         imported: {
@@ -92,6 +263,10 @@ function Plugin(babel, { app, side, debug }: TOptions) {
             this.debug = debug || false;
 
             this.routeMethods = [];
+            this.routePaths = new Set();
+
+            this.routesIndex = getRoutesIndex(app.paths.root);
+            this.contextGuardedClassMethods = new WeakSet();
         },
 
         visitor: {
@@ -109,28 +284,21 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
                         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'
-                                )
-                            );
+                            const isRoute = isRouteDecoratorExpression(decorator.expression);
 
                             if (!isRoute) continue;
 
                             const methodName = node.key.name;
                             this.routeMethods.push( methodName );
 
+                            const routePath = getRoutePathFromDecoratorExpression(decorator.expression);
+                            if (routePath)
+                                this.routePaths.add(routePath);
                         }
                     }
                 });
+
+                updateRoutesIndexForFile(this.routesIndex, this.filename, this.routePaths);
             },
 
             /**
@@ -203,6 +371,88 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                 path.replaceWithMultiple(replaceWith);
             },
 
+            CallExpression(path) {
+                if (!this.processFile)
+                    return;
+
+                const classMethodPath = path.findParent(p => p.isClassMethod()) as NodePath<types.ClassMethod> | null;
+                if (!classMethodPath)
+                    return;
+
+                // Ignore constructors
+                if (classMethodPath.node.kind === 'constructor')
+                    return;
+
+                const callee = path.node.callee;
+                if (!t.isMemberExpression(callee) && !(t as any).isOptionalMemberExpression?.(callee))
+                    return;
+
+                // Build member chain segments: this.app.<Service>.<...>
+                const segments: string[] = [];
+                let current: any = callee;
+                while (t.isMemberExpression(current) || (t as any).isOptionalMemberExpression?.(current)) {
+                    const prop = current.property;
+                    if (t.isIdentifier(prop)) {
+                        segments.unshift(prop.name);
+                    } else if (t.isStringLiteral(prop)) {
+                        segments.unshift(prop.value);
+                    } else {
+                        return;
+                    }
+                    current = current.object;
+                }
+
+                if (!t.isThisExpression(current))
+                    return;
+
+                // Expect: this.app.<Service>.<method>
+                if (segments.length < 3 || segments[0] !== 'app')
+                    return;
+
+                const serviceLocalName = segments[1];
+                const importedRef = this.imported[serviceLocalName];
+                if (!importedRef || importedRef.source !== 'services')
+                    return;
+
+                const routePath = [
+                    importedRef.imported || serviceLocalName,
+                    ...segments.slice(2)
+                ].join('/');
+
+                if (!this.routesIndex.all.has(routePath))
+                    return;
+
+                // Ensure the parent function checks that `context` exists
+                if (!this.contextGuardedClassMethods.has(classMethodPath.node)) {
+                    const guard = t.ifStatement(
+                        t.binaryExpression(
+                            '===',
+                            t.unaryExpression('typeof', t.identifier('context')),
+                            t.stringLiteral('undefined')
+                        ),
+                        t.blockStatement([
+                            t.throwStatement(
+                                t.newExpression(t.identifier('Error'), [
+                                    t.stringLiteral('context variable should be passed in this function')
+                                ])
+                            )
+                        ])
+                    );
+                    classMethodPath.get('body').unshiftContainer('body', guard);
+                    this.contextGuardedClassMethods.add(classMethodPath.node);
+                }
+
+                // Ensure call arguments: second argument is `context`
+                const args = path.node.arguments;
+                if (args.length === 0) {
+                    args.push(t.identifier('undefined'), t.identifier('context'));
+                } else if (args.length === 1) {
+                    args.push(t.identifier('context'));
+                } else {
+                    args[1] = t.identifier('context') as any;
+                }
+            },
+
             // This visitor fires for every class method.
             ClassMethod(path) {