5htp 0.4.6-5 → 0.5.9

package/{src/compiler → compiler}/common/babel/routes/routes.ts

@@ -39,11 +39,16 @@ module.exports = (options: TOptions) => (
     [Plugin, options]
 )
 
+const clientServices = ['Router'];
+// Others will be called via app.<Service> (backend) or api.post(<path>, <params>) (frontend)
+
 /*----------------------------------
 - PLUGIN
 ----------------------------------*/
 function Plugin(babel, { app, side, debug }: TOptions) {
 
+    debug = true;
+
     const t = babel.types as typeof types;
 
     /*
@@ -78,7 +83,8 @@ function Plugin(babel, { app, side, debug }: TOptions) {
             // Replace by:      nothing
             ImportDeclaration(path) {
                 
-                if (!this.file.process)
+                const shouldTransformImports = this.file.process && this.file.side === 'front';
+                if (!shouldTransformImports)
                     return;
                 
                 if (path.node.source.value !== '@app')
@@ -92,7 +98,12 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     if (specifier.imported.type !== 'Identifier')
                         continue;
 
-                    this.file.importedServices[ specifier.local.name ] = specifier.imported.name;
+                    const serviceName = specifier.imported.name;
+
+                    if (clientServices.includes(serviceName))
+                        this.file.importedServices[ specifier.local.name ] = serviceName;
+                    else
+                        this.file.importedServices[ specifier.local.name ] = 'app';
                 }
 
                 // Remove this import
@@ -100,9 +111,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
             },
 
-            // Find Router definitions
-            // Test:            Router.xxx()
-            // Replace by:      nothing
+            // Transform services service calls
             CallExpression(path) {
 
                 if (!this.file.process)
@@ -112,36 +121,121 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                 const callee = path.node.callee
                 if (!(
                     callee.type === 'MemberExpression'
-                    &&
-                    callee.object.type === 'Identifier'
-                    &&
-                    callee.property.type === 'Identifier'
-                    &&
-                    // Should be at the root of the document
-                    path.parent.type === 'ExpressionStatement'
-                    &&
-                    path.parentPath.parent.type === 'Program'
-                    // And make reference to a service
-                    &&
-                    (callee.object.name in this.file.importedServices)
                 ))
                     return;
 
-                const routeDef: TRouteDefinition = {
-                    definition: path.node,
-                    dataFetchers: []
-                }
+                // Create full path
+                const completePath: string[] = [];
+                let currCallee: types.MemberExpression = callee;
+                while (1) {
+
+                    if (currCallee.property.type === 'Identifier')
+                        completePath.unshift(currCallee.property.name);
+
+                    if (currCallee.object.type === 'MemberExpression')
+                        currCallee = currCallee.object;
+                    else {
 
-                // Adjust
-                if (this.file.side === 'front') {
-                    transformDataFetchers(path, this, routeDef);
+                        if (currCallee.object.type === 'Identifier')
+                            completePath.unshift(currCallee.object.name);
+
+                        break;
+                    }
                 }
+
+                // If we actually call a service
+                const serviceName = completePath[0];
+
+                /*
+                    Router.page: wrap with export const __register = ({ Router }) => Router.page(...)
+                */
+                if (
+                    serviceName === 'Router' 
+                    && 
+                    callee.property.type === 'Identifier' 
+                    && 
+                    ['page', 'error', 'get', 'post', 'put', 'delete'].includes(callee.property.name)
+                ) {
+
+                    // Should be at the root of the document
+                    if (!(
+                        path.parent.type === 'ExpressionStatement'
+                        &&
+                        path.parentPath.parent.type === 'Program'
+                    ))
+                        return;
+
+                    const routeDef: TRouteDefinition = {
+                        definition: path.node,
+                        dataFetchers: []
+                    }
+
+                    // Adjust
+                    if (this.file.side === 'front') {
+                        transformDataFetchers(path, this, routeDef);
+                    }
+                        
+                    // Add to the list of route definitons to wrap
+                    this.file.routeDefinitions.push(routeDef);
+
+                    // 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') {
                     
-                // Add to the list of route definitons to wrap
-                this.file.routeDefinitions.push(routeDef);
+                    const isAService = (
+                        serviceName in this.file.importedServices
+                        &&
+                        serviceName[0] === serviceName[0].toUpperCase()
+                    );
+                    if(!isAService)
+                        return;
+
+                    if (side === 'client') {
 
-                // Delete the route def since it will be replaced by a wrapper
-                path.replaceWithMultiple([]);
+                        // 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)
+                            apiPostArgs.push( path.node.arguments[0] );
+
+                        path.replaceWith(
+                            t.callExpression(
+                                t.memberExpression(
+                                    t.identifier('api'), t.identifier('post')
+                                ), apiPostArgs
+                            )
+                        )
+                    } else {
+
+                        // Rebuild member expression from completePath, adding a api prefix
+                        let newCallee = t.memberExpression(
+                            t.identifier('app'),
+                            t.identifier(completePath[0])
+                        );
+                        for (let i = 1; i < completePath.length; i++) {
+                            newCallee = t.memberExpression(
+                                newCallee,
+                                t.identifier(completePath[i])
+                            );
+                        }
+                        
+                        // Replace by app.<service>.<method>(...)
+                        path.replaceWith(
+                            t.callExpression(
+                                newCallee, [...path.node.arguments]
+                            )
+                        )
+                    }
+                }
                
             },
             Program: {
@@ -153,7 +247,6 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                     const wrappedrouteDefs = wrapRouteDefs( this.file );
                     if (wrappedrouteDefs)
                         path.pushContainer('body', [wrappedrouteDefs])
-                    
                 }
             }
         }
@@ -185,9 +278,9 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         }
         
         // Differenciate back / front
-        if (relativeFileName.startsWith('/src/client/pages')) {
+        if (relativeFileName.startsWith('/client/pages')) {
             file.side = 'front';
-        } else if (relativeFileName.startsWith('/src/server/routes')) {
+        } else if (relativeFileName.startsWith('/server/routes')) {
             file.side = 'back';
         } else 
             file.process = false;
@@ -201,12 +294,13 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         routeDef: TRouteDefinition 
     ) {
         path.traverse({
+            // api.load => move data fetchers to route.options.data
+            // So the router is able to load data before rendering the component
             CallExpression(path) {
 
                 const callee = path.node.callee
 
-                // api.load => move data fetchers to route.options.data
-                // So the router is able to load data before rendering the component
+                // Detect api.fetch
                 if (!(
                     callee.type === 'MemberExpression'
                     &&
@@ -220,11 +314,23 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                 ))
                     return;
 
+                /*  Reference data fetchers
+                    {
+                        stats: api.get(...)
+                    }
+                */
                 routeDef.dataFetchers.push(
                     ...path.node.arguments[0].properties
                 );
 
-                // Delete routerDefContext node
+                /*  Replace the: 
+                        const { stats } = api.fetch({
+                            stats: api.get(...)
+                        })
+
+                    by:
+                        const { stats } = context.data.stats;
+                */
                 path.replaceWith(
                     t.memberExpression(
                         t.identifier( routeDef.contextName || 'context' ),
@@ -235,7 +341,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
         }, routerDefContext);
     }
 
-    function injectOptions( 
+    function enrichRouteOptions( 
         routeDef: TRouteDefinition,
         routeArgs: types.CallExpression["arguments"],
         filename: string
@@ -366,7 +472,9 @@ function Plugin(babel, { app, side, debug }: TOptions) {
 
             // Limit to one route def per file
             const routesDefCount = file.routeDefinitions.length;
-            if (routesDefCount !== 1)
+            if (routesDefCount === 0)
+                return;
+            else if (routesDefCount > 1)
                 throw new Error(`Frontend route definition files (/client/pages/**/**.ts) can contain only one route definition. 
                     ${routesDefCount} were given in ${file.path}.`);
 
@@ -379,7 +487,7 @@ function Plugin(babel, { app, side, debug }: TOptions) {
             if (callee.object.name === 'Router') {
 
                 // Inject chunk id in options (2nd arg)
-                const newRouteArgs = injectOptions(routeDef, routeArgs, file.path);
+                const newRouteArgs = enrichRouteOptions(routeDef, routeArgs, file.path);
                 if (newRouteArgs === 'ALREADY_PROCESSED')
                     return;
 
@@ -426,9 +534,10 @@ function Plugin(babel, { app, side, debug }: TOptions) {
                 )
             ])
         );
+                    
 
-        /*(file.side === 'front' && file.path.includes('/headhunter/talents/index.tsx')) 
-            && console.log( file.path, generate(exportDeclaration).code );*/
+        (file.side === 'front' && file.path.includes('/server/routes/events.ts')) 
+        && console.log( file.path, generate(exportDeclaration).code );
 
         return exportDeclaration;
     }

package/{src/compiler → compiler}/common/files/style.ts

@@ -18,16 +18,16 @@ module.exports = (app: App, dev: Boolean, client: boolean) => {
 
         // Process external/third-party styles
         {
-            exclude: [/*process.env.framework + '/kernel', */app.paths.src],
+            exclude: [app.paths.root],
             loader: 'css-loader',
             options: {
                 sourceMap: dev
             },
         },
 
-        // Process internal/project styles (from src folder)
+        // Process internal/project styles (from root folder)
         {
-            include: [/*process.env.framework + '/kernel', */app.paths.src],
+            include: [app.paths.root],
             loader: 'css-loader',
             options: {
                 // CSS Loader https://github.com/webpack/css-loader

package/{src/compiler → compiler}/common/plugins/indexage/icones-svg/index.ts

@@ -38,10 +38,10 @@ export default class IconesSVG extends Indexeur {
         super();
 
         this.formats = ['woff2'];
-        this.dossierIcones = cli.paths.core.src + '/client/assets/icons/';
+        this.dossierIcones = cli.paths.core.root + '/client/assets/icons/';
         this.dossierSortie = app.paths.bin + '/public/'; 
         
-        this.cacheTypes = cli.paths.core.src + '/types/icons.d.ts';
+        this.cacheTypes = cli.paths.core.root + '/types/icons.d.ts';
         this.cacheIndex = this.dossierIcones + 'index.json';
 
         if (fs.existsSync(this.cacheIndex)) {

package/{src/compiler → compiler}/index.ts

@@ -6,6 +6,7 @@
 import path from 'path';
 import webpack from 'webpack';
 import fs from 'fs-extra';
+import serialize from 'serialize-javascript';
 
 import SpeedMeasurePlugin from "speed-measure-webpack-plugin";
 const smp = new SpeedMeasurePlugin({ disable: true });
@@ -137,21 +138,19 @@ export default class Compiler {
 
     private indexServices() {
         
-        const imported: string[] = []
-        const exportedType: string[] = []
-        const exportedMetas: string[] = []
 
         // Index services
         const searchDirs = {
             // The less priority is the first
             // The last override the first if there are duplicates
-            '@server/services/': path.join(cli.paths.core.src, 'server', 'services'),
-            '@/server/services/': path.join(app.paths.src, 'server', 'services'),
+            '@server/services/': path.join(cli.paths.core.root, 'server', 'services'),
+            '@/server/services/': path.join(app.paths.root, 'server', 'services'),
             // Temp disabled because compile issue on vercel
             //'': path.join(app.paths.root, 'node_modules'),
         }
 
-        const servicesIndex: {[id: string]: TServiceMetas} = {};
+        // Generate app class file
+        const servicesAvailable: {[id: string]: TServiceMetas} = {};
         for (const importationPrefix in searchDirs) {
 
             const searchDir = searchDirs[ importationPrefix ];
@@ -165,32 +164,88 @@ export default class Compiler {
 
                 const serviceMetas = require(metasFile);
 
-                servicesIndex[ metasFile ] = {
+                servicesAvailable[ serviceMetas.id ] = {
                     ...serviceMetas,
                     importationPath
                 };
             }
         }
 
-        // Create importation directives
-        for (const serviceId in servicesIndex) {
+        // Read app services
+        const imported: string[] = []
+        const referencedNames: {[serviceId: string]: string} = {} // ID to Name
+
+        const refService = (serviceName: string, serviceConfig: any, level: number = 0) => {
 
-            const { id, name, parent, dependences, importationPath } = servicesIndex[ serviceId ];
+            if (serviceConfig.refTo !== undefined) {
+                const refTo = serviceConfig.refTo;
+                return {
+                    name: serviceName,
+                    code: `${serviceName}: this.${refTo},`,
+                    priority: 0
+                }
+            }
+
+            const serviceMetas = servicesAvailable[ serviceConfig.id ];
+            if (serviceMetas === undefined)
+                throw new Error(`Service ${serviceConfig.id} not found. Referenced services: ${Object.keys(servicesAvailable).join('\n')}`);
+
+            const referencedName = referencedNames[serviceConfig.id];
+            if (referencedName !== undefined)
+                throw new Error(`Service ${serviceConfig.id} is already setup as ${referencedName}`);
             
             // Generate index & typings
-            imported.push(`import type ${name} from "${importationPath}";`);
-            exportedType.push(`'${id}': ${name},`);
-            // NOTE: only import enabled packages to optimize memory
-            // TODO: don't index non-setuped packages in the exported metas
-            exportedMetas.push(`'${id}': {
-class: () => require("${importationPath}"),
-id: "${id}",
-name: "${name}",
-parent: "${parent}",
-dependences: ${JSON.stringify(dependences)},
-            },`);
+            imported.push(`import ${serviceMetas.name} from "${serviceMetas.importationPath}";`);
+
+            if (serviceConfig.name !== undefined)
+                referencedNames[serviceConfig.id] = serviceConfig.name;
+
+            // Subservices
+            let subservices = '';
+            if (serviceConfig.subservices) {
+
+                const subservicesList = serviceConfig.subservices;
+                const subservicesCode = Object.entries(subservicesList).map(([name, service]) => 
+                    refService(name, service, level + 1) 
+                );
+
+                // Sort by priority
+                const sortedSubservices = subservicesCode.sort((a, b) => a.priority - b.priority);
+
+                // Generate code
+                subservices = sortedSubservices.map(s => s.code).join('\n');
+            }
+
+            // Generate the service instance
+            const instanciation = `new ${serviceMetas.name}( 
+                this, 
+                ${serialize(serviceConfig.config || {}) || '{}'}, 
+                () => ({
+                    ${subservices}
+                }), 
+                this 
+            )`
+
+            if (level === 0)
+                return {
+                    name: serviceName,
+                    code: `public ${serviceName} = ${instanciation};`,
+                    priority: serviceConfig.config?.priority || 0
+                };
+            else
+                return {
+                    name: serviceName,
+                    code: `${serviceName}: ${instanciation},`,
+                    priority: serviceConfig.config?.priority || 0
+                };
         }
 
+        const servicesCode = Object.values(app.registered).map( s => refService(s.name, s, 0));
+        const sortedServices = servicesCode.sort((a, b) => a.priority - b.priority);
+        
+        const services = sortedServices.map(s => s.code).join('\n');
+        const servicesNames = sortedServices.map(s => s.name);
+
         // Define the app class identifier
         const appClassIdentifier = app.identity.identifier;
         const containerServices = app.containerServices.map( s => "'" + s + "'").join('|');
@@ -200,30 +255,70 @@ dependences: ${JSON.stringify(dependences)},
             path.join( app.paths.client.generated, 'services.d.ts'),
 `declare module "@app" {
 
-    import { ${appClassIdentifier} } from '@/client/index';
+    import { RouenEvents as RouenEventsClient } from "@/client";
+    import RouenEventsServer 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 CombinedServices = ClientServices & ServerServices;
+  
+    const appClass: CombinedServices;
+    export = appClass;
+}
 
-    const appClass: ${appClassIdentifier};
 
-    export = appClass
-}`
+// 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;
+}
+  `
         );
 
         fs.outputFileSync(
-            path.join( app.paths.server.generated, 'services.ts'),
-`${imported.join('\n')}
-export type Services = {
-    ${exportedType.join('\n')}
+            path.join( app.paths.server.generated, 'app.ts'),
+`import { Application } from '@server/app/index';
+
+${imported.join('\n')}
+
+export default class ${appClassIdentifier} extends Application {
+
+    protected serviceNames = [
+        ${Object.values(servicesNames).map(name => `"${name}"`).join(',\n')}
+    ] as const;
+
+    protected servicesIdToName = {
+        ${Object.entries(referencedNames).map(([id, name]) => `"${id}": "${name}"`).join(',\n')}
+    } as const;
+
+    ${services}
 }
-export default {
-    ${exportedMetas.join('\n')}
-}`
-        );
+
+
+`);
 
         fs.outputFileSync(
             path.join( app.paths.server.generated, 'services.d.ts'),
 `type InstalledServices = import('./services').Services;
 
-declare type ${appClassIdentifier} = import("@/server").default;
+declare type ${appClassIdentifier} = import("@/server/.generated/app").default;
 
 declare module "@app" {
 
@@ -243,7 +338,8 @@ declare module "@app" {
 
 declare module '@server/app' {
 
-    import { Application } from "@server/app/index";
+    import { Application } from "@server/app";
+    import { Environment } from "@server/app";
     import { ServicesContainer } from "@server/app/service/container";
 
     abstract class ApplicationWithServices extends Application<
@@ -252,18 +348,34 @@ declare module '@server/app' {
 
     export interface Exported {
         Application: typeof ApplicationWithServices,
-        Services: ServicesContainer<InstalledServices>,
+        Environment: Environment,
     }
 
     const foo: Exported;
 
     export = foo;
+}
+    
+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;
 }`
         );
     }
 
     public async create() {
 
+        await app.warmup();
+
         this.cleanup();
 
         this.fixNpmLinkIssues();

package/{src/compiler → compiler}/server/index.ts

@@ -17,7 +17,7 @@ import createCommonConfig, { TCompileMode, regex } from '../common';
 // Type
 import type App from '../../app';
 
-const getCorePluginsList = (app: App,) => {
+/*const getCorePluginsList = (app: App,) => {
 
     const corePlugins: string[] = [];
 
@@ -32,7 +32,7 @@ const getCorePluginsList = (app: App,) => {
                 corePlugins.push(cli.paths.core.root + '/node_modules/' + moduleName + '/src');
 
     return corePlugins;
-}
+}*/
 
 const debug = false;
 
@@ -63,7 +63,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
         target: 'node',
         entry: {
             server: [
-                cli.paths.coreRoot + '/src/server/index.ts'
+                cli.paths.coreRoot + '/server/index.ts'
             ],
         },
 
@@ -106,7 +106,9 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                     request.startsWith('5htp-')
                     ||
                     // Compile 5HTP modules
-                    request.startsWith('@mantine/')
+                    request.startsWith('@mantine/') ||
+                    request.startsWith('react-number-format') ||
+                    request.startsWith('@floating-ui')
                 )
 
                 //console.log('isNodeModule', request, isNodeModule);
@@ -128,7 +130,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
 
             alias: aliases,
 
-            extensions: ['.ts', '.tsx', ".json", ".sql"],
+            extensions: ['.ts', '.tsx', ".json", ".sql", ".js"],
         },
 
         module: {
@@ -140,15 +142,15 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                     test: regex.scripts,
                     include: [
 
-                        app.paths.root + '/src/client',
-                        cli.paths.core.root + '/src/client',
+                        app.paths.root + '/client',
+                        cli.paths.core.root + '/client',
 
-                        app.paths.root + '/src/common',
-                        cli.paths.core.root + '/src/common',
+                        app.paths.root + '/common',
+                        cli.paths.core.root + '/common',
 
                         // Dossiers server uniquement pour le bundle server
-                        app.paths.root + '/src/server',
-                        cli.paths.core.root + '/src/server',
+                        app.paths.root + '/server',
+                        cli.paths.core.root + '/server',
 
                         // Complle 5HTP modules so they can refer to the framework instance and aliases
                         // Temp disabled because compile issue on vercel