5htp 0.2.3 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.2.3",
+	"version": "0.3.0",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp.git",
 	"license": "MIT",
@@ -41,7 +41,6 @@
 		"@types/webpack-env": "^1.16.2",
 		"@types/ws": "^7.4.7",
 		"babel-loader": "^8.2.2",
-		"babel-plugin-glob-import": "^0.0.6-3",
 		"babel-plugin-transform-imports": "^2.0.0",
 		"babel-plugin-transform-react-remove-prop-types": "^0.4.24",
 		"brotli-webpack-plugin": "^1.1.0",
@@ -73,7 +72,6 @@
 		"terser-webpack-plugin": "^5.2.4",
 		"ts-alias": "^0.0.7",
 		"ts-node": "^10.9.1",
-		"tslog": "^3.3.4",
 		"webfont": "^11.2.26",
 		"webpack": "^5.56.0",
 		"webpack-assets-manifest": "^5.0.6",
@@ -89,6 +87,7 @@
 		"@types/node": "^16.9.1",
 		"@types/nodemailer": "^6.4.4",
 		"@types/prompts": "^2.0.14",
-		"@types/webpack-env": "^1.16.2"
+		"@types/webpack-env": "^1.16.2",
+		"babel-plugin-glob-import": "^0.0.7"
 	}
 }

package/readme.md

@@ -41,16 +41,20 @@ Full Stack Typescript framework designed for **developers and users experience**
 ## To be done:
 
 - [ ] Update templates & documentation
-- [ ] Improved debugability & debug tools
-    - Cleaner logs (tweak ts-logs settings)
-    - Cleaner stacktraces
-    - export all default exports as classical functions instead of arrow funcs
+- [ ] HMR
+- [ ] Debugging / Monitoring UI
+    - All services and status: installed / paused / running
+    - Router: 
+        - list of registered files
+        - list of pages / api / error routes / layouts
+        - latest requests + performance
+    - Logs: recent logs terminal
+    - Database: recent queries + performance
+    - Page rendering: performance
+    - Socket: who is connected
+- [ ] Add testing tools
+- [ ] Possibility to generate static pages
+- [ ] Improve ORM: make definition based on code instead of database structure
 - [ ] Automatically generates types that associate api routes urls to their return types
-- [ ] Fix forms system
 - [ ] Allow to create CLI apps
-- [ ] Debugging / Monitoring UI
-    - Admin dashboard
-- [ ] Fix Typescript errors
-- [ ] Completely replace expressjs
-- [ ] Improve stability
-- [ ] Improve modularity
+- [ ] Fix Typescript errors

package/skeleton/src/server/models.ts

@@ -0,0 +1,117 @@
+export type BugApp = {
+	action: string,
+	build: string,
+	client: string,
+	date: Date,
+	device?: string,
+	hash: string,
+	ip: string,
+	message?: string,
+	side: string,
+	solved?: Date,
+	stacktrace: string,
+	status?: string,
+	user?: string
+}
+export type BugGUI = {
+	before?: string,
+	date: Date,
+	device: string,
+	guiVersion: string,
+	hash: string,
+	ip: string,
+	observation?: string,
+	serverVersion: string,
+	solved?: Date,
+	context?: object,
+	stacktrace?: string,
+	url: string,
+	user?: string
+}
+export type BugServer = {
+	channelId?: string,
+	channelType: string,
+	date: Date,
+	hash: string,
+	ip?: string,
+	logs: string,
+	solved?: Date,
+	stacktrace: string,
+	user?: string
+}
+export type Countries = {
+	id: string,
+	name: string
+}
+export type Devices = {
+	activity: Date,
+	bandwidth: number,
+	build: number,
+	connectedSince: Date,
+	id: string,
+	invalid: number,
+	ip: string,
+	meet: Date,
+	name?: string,
+	platform: string,
+	rewards: number,
+	user: string,
+	valid: number
+}
+export type Locales = {
+	id: string,
+	name: string
+}
+export type User = {
+	activity: Date,
+	balance: number,
+	balanceGoal: number,
+	balanceGoalReached: number,
+	banned?: Date,
+	boosterEnd?: Date,
+	country?: string,
+	donationPc: number,
+	email: string,
+	emailHash: string,
+	exp: number,
+	level: number,
+	levelsReached: number,
+	meet: Date,
+	name: string,
+	phone?: string,
+	referrer?: string,
+	refPeriodEnd?: Date,
+	roles: string[],
+	smscode?: string,
+	utm?: string
+}
+export type UserLogin = {
+	date: Date,
+	device: string,
+	id: number,
+	ip: string,
+	user: string
+}
+export type UserStats = {
+	activity: Date,
+	balance: number,
+	bandwidth: number,
+	date: Date,
+	failures: number,
+	refClics: number,
+	refCommission: number,
+	refSignups: number,
+	success: number,
+	user: string
+}
+export type Withdraw = {
+	address: string,
+	amount: number,
+	btcPrice: number,
+	date: Date,
+	fees: number,
+	id: number,
+	sent: number,
+	transactionId?: string,
+	user: string
+}

package/src/app/config.ts

@@ -14,6 +14,9 @@
 import fs from 'fs-extra';
 import yaml from 'yaml';
 
+// Types
+import type { TEnvConfig } from '../../../core/src/server/app/container/config';
+
 /*----------------------------------
 - LOADE
 ----------------------------------*/
@@ -32,10 +35,9 @@ export default class ConfigParser {
         return yaml.parse(rawConfig);
     }
 
-    public env() {
+    public env(): TEnvConfig {
         // We assume that when we run 5htp dev, we're in local
         // Otherwise, we're in production environment (docker)
-        console.log("[cli] Using environment:", process.env.NODE_ENV);
         return process.env.NODE_ENV === 'development' ? {
             name: 'local',
             profile: 'dev',

package/src/app/index.ts

@@ -3,6 +3,7 @@
 ----------------------------------*/
 
 // npm
+import path from 'path';
 import TsAlias from 'ts-alias';
 
 // Cre
@@ -10,7 +11,7 @@ import cli from '..';
 
 // Specific
 import ConfigParser from './config';
-import type {  } from '../../../core/src/server/app/config';
+import type { TEnvConfig } from '../../../core/src/server/app/container/config';
 
 /*----------------------------------
 - TYPES
@@ -21,21 +22,32 @@ export type TAppSide = 'server' | 'client'
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class App {
+export class App {
 
     // config
     // WARNING: High level config files (env and services) shouldn't be loaded from the CLI
     //  The CLI will be run on CircleCI, and no env file should be sent to this service
     public identity: Config.Identity;
 
+    public env: TEnvConfig;
+
     public paths = {
+
         root: cli.paths.appRoot,
-        src: cli.paths.appRoot + '/src',
-        bin: cli.paths.appRoot + '/bin',
-        data: cli.paths.appRoot + '/var/data',
-        public: cli.paths.appRoot + '/public',
-        pages: cli.paths.appRoot + '/src/client/pages',
-        cache: cli.paths.appRoot + '/src/.cache',
+        src: path.join( cli.paths.appRoot, 'src'),
+        bin: path.join( cli.paths.appRoot, 'bin'),
+        data: path.join( cli.paths.appRoot, 'var', 'data'),
+        public: path.join( cli.paths.appRoot, 'public'),
+        pages: path.join( cli.paths.appRoot, 'src', 'client', 'pages'),
+        cache: path.join( cli.paths.appRoot, 'src', '.cache'),
+
+        client: {
+            generated: path.join( cli.paths.appRoot, 'src', 'client', '.generated')
+        },
+        server: {
+            generated: path.join( cli.paths.appRoot, 'src', 'server', '.generated'),
+            configs: path.join( cli.paths.appRoot, 'src', 'server', 'app')
+        },
 
         withAlias: (filename: string, side: TAppSide) => 
             this.aliases[side].apply(filename),
@@ -46,9 +58,10 @@ export default class App {
 
     public constructor() {
         
-        console.log(`[cli] Loading app config ...`);
+        cli.debug && console.log(`[cli] Loading app config ...`);
         const configParser = new ConfigParser( cli.paths.appRoot );
         this.identity = configParser.identity();
+        this.env = configParser.env();
     }
 
     /*----------------------------------
@@ -73,4 +86,8 @@ export default class App {
             debug: false
         }),
     }
-}
+}
+
+export const app = new App
+
+export default app

package/src/commands/build.ts

@@ -6,10 +6,7 @@
 import prompts from 'prompts';
 
 // Configs
-import createCompilers from '../compiler';
-
-// Core
-import App from '../app';
+import Compiler from '../compiler';
 
 /*----------------------------------
 - TYPES
@@ -20,9 +17,9 @@ import App from '../app';
 ----------------------------------*/
 export const run = (): Promise<void> => new Promise(async (resolve) => {
 
-    const app = new App();
+    const compiler = new Compiler('prod');
 
-    const multiCompiler = await createCompilers(app, 'prod');
+    const multiCompiler = await compiler.create();
 
     multiCompiler.run((error, stats) => {
 

package/src/commands/dev.ts

@@ -11,19 +11,17 @@ import cli from '../';
 import Keyboard from '../utils/keyboard';
 
 // Configs
-import createCompilers, { compiling } from '../compiler';
+import Compiler from '../compiler';
 
 // Core
-import App from '../app';
+import { app, App } from '../app';
 
 /*----------------------------------
 - COMMANDE
 ----------------------------------*/
 export const run = () => new Promise<void>(async () => {
-    
-    const app = new App();
 
-    const multiCompiler = await createCompilers(app, 'dev', {
+    const compiler = new Compiler('dev', {
         before: () => {
 
             stopApp();
@@ -35,6 +33,8 @@ export const run = () => new Promise<void>(async () => {
         }
     });
 
+    const multiCompiler = await compiler.create();
+
     multiCompiler.watch({
 
         // https://webpack.js.org/configuration/watch/#watchoptions
@@ -60,8 +60,8 @@ export const run = () => new Promise<void>(async () => {
 
     Keyboard.input('ctrl+r', async () => {
 
-        console.log(`Waiting for compilers to be ready ...`, Object.keys(compiling));
-        await Promise.all(Object.values(compiling));
+        console.log(`Waiting for compilers to be ready ...`, Object.keys(compiler.compiling));
+        await Promise.all(Object.values(compiler.compiling));
 
         console.log(`Reloading app ...`);
         startApp(app);

package/src/compiler/client/index.ts

@@ -178,7 +178,7 @@ export default function createCompiler( app: App, mode: TCompileMode ): webpack.
                                 ...c.chunks.reduce(
                                     (files, cc) => [
                                         ...files,
-                                        ...cc.files.filter(fileFilter).map(addPath),
+                                        ...[...cc.files].filter(fileFilter).map(addPath),
                                     ],
                                     [],
                                 ),

package/src/compiler/common/babel/index.ts

@@ -124,12 +124,11 @@ module.exports = (app: App, side: TAppSide, dev: boolean): webpack.RuleSetRule[]
 
                 //require("./plugins/pages")({ side }),
 
-                require('./routes/routes')({ side, app }),
+                require('./routes/routes')({ side, app, debug: false }),
 
                 ...(side === 'client' ? [] : [
 
-                    // Dependancies injection
-                    //require('./plugins/services')({ side }),
+                    require('./plugins/services')({ side, app, debug: false }),
 
                 ]),
 

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

@@ -4,157 +4,189 @@
 
 // Npm
 import * as types from '@babel/types'
-import type { PluginObj, NodePath } from '@babel/core';
-import generate from '@babel/generator';
+import type { PluginObj } from '@babel/core';
 
 // Core
 import cli from '@cli';
-import App, { TAppSide } from '../../../../app';
+import { App, TAppSide } from '../../../../app';
+
+const containerServices = [
+    'Environment',
+    'Application',
+    'Path',
+    'Services',
+    'Event'
+]
 
 /*----------------------------------
 - WEBPACK RULE
 ----------------------------------*/
 
 type TOptions = {
-    side: TAppSide
+    side: TAppSide,
+    app: App,
+    debug?: boolean
 }
 
-const filenamePrefix = cli.paths.appRoot + '/src/server/services';
-const processFile = (filename: string) => (
-    filename.startsWith( cli.paths.appRoot + '/src/server/services' )
-    | 
-    filename.startsWith( cli.paths.appRoot + '/src/server/routes' )
-)
+type TImportSource = 'container' | 'application';
 
 module.exports = (options: TOptions) => (
     [Plugin, options]
 )
 
-const debug = true;
 
 /*----------------------------------
 - PLUGIN
 ----------------------------------*/
-function Plugin(babel, { side }: TOptions) {
+function Plugin(babel, { app, side, debug }: TOptions) {
 
     const t = babel.types as typeof types;
-    let program: NodePath<types.Program>;
+
+    /*
+        - Wrap route.get(...) with (app: Application) => { }
+        - Inject chunk ID into client route options
+    */
 
     const plugin: PluginObj<{ 
 
-        filename: string,
+        debug: boolean,
 
-        appImport: string | null,
+        filename: string,
+        processFile: boolean,
 
         // Identifier => Name
-        importedServices: {[identifier: string]: string}
+        importedServicesCount: number,
+        importedServices: {
+            [local: string]: {
+                imported: string,
+                bindings: any, // TODO: Scope.Binding[] type
+                source: TImportSource
+            }
+        },
+        bySource: {[importSource in TImportSource] : number}
     }> = {
         pre(state) {
 
             this.filename = state.opts.filename as string;
+            this.processFile = this.filename.startsWith( cli.paths.appRoot + '/src/server' );
 
-            this.appImport = null
             this.importedServices = {}
+            this.bySource = {
+                container: 0,
+                application: 0
+            }
+            this.importedServicesCount = 0
+            this.debug = debug || false;
 
         },
         visitor: {
 
-            Program(path) {
-                program = path;
-            },
-
-            // Transform imports
+            // Find @app imports
+            // Test:            import { router } from '@app';
+            // Replace by:      nothing
             ImportDeclaration(path) {
 
-                if (!this.filename.startsWith( cli.paths.appRoot + '/src/server' ))
+                if (!this.processFile)
                     return;
                 
-                if (path.node.source.value !== '@server/app')
+                if (path.node.source.value !== '@app')
                     return;
 
-                const importedServices: { local: string, imported: string }[] = []
-                let appName: string = 'app';
-
                 for (const specifier of path.node.specifiers) {
-                    /*
-                        import app from '@server/app';
-                    */
-                    if (specifier.type === 'ImportDefaultSpecifier') {
+                    
+                    if (specifier.type !== 'ImportSpecifier')
+                        continue;
 
-                        appName = specifier.local.name;
+                    if (specifier.imported.type !== 'Identifier')
+                        continue;
 
-                    /*
-                        import { sql } from '@server/app';
-                        => 
-                        import app from '@server/app';
-                        app.use('sql');
-                    */
-                    } else if (specifier.type === 'ImportSpecifier') {
+                    this.importedServicesCount++;
 
-                        if (specifier.imported.type !== 'Identifier')
-                            continue;
+                    let importSource: TImportSource;
+                    if (containerServices.includes(specifier.imported.name))
+                        importSource = 'container';
+                    else
+                        importSource = 'application';
 
-                        importedServices.push({
-                            local: specifier.local.name,
-                            imported: specifier.imported.name
-                        });
+                    this.importedServices[ specifier.local.name ] = {
+                        imported: specifier.imported.name,
+                        bindings: path.scope.bindings[ specifier.local.name ].referencePaths,
+                        source: importSource
+                    }
 
-                    /*
-                        import * as templates from '@server/app';
-                        =>
+                    this.bySource[ importSource ]++;
+                }
 
-                    */
-                    } else if (specifier.type === 'ImportNamespaceSpecifier') {
+                // Replace by simple import 
+                this.debug && console.log("[babel][services] Replace importation");
+                const replaceWith: any[] = []
 
-                        //importDefault = specifier.local.name;
-                        //importAll = true;
+                if (this.bySource.container > 0)
+                    replaceWith.push(
+                        t.importDeclaration(
+                            [t.importDefaultSpecifier( t.identifier('container') )],
+                            t.stringLiteral( cli.paths.core.src + '/server/app/container')
+                        )
+                    );
 
-                    }
-                }
+                if (this.bySource.application > 0)
+                    replaceWith.push(
+                        t.importDeclaration(
+                            [t.importDefaultSpecifier( t.identifier('application') )],
+                            t.stringLiteral( cli.paths.core.src + '/server/app/instance')
+                        )
+                    );
+
+                path.replaceWithMultiple(replaceWith);
+            },
 
-                // No service imported
-                // This verification avoids ininite loop
-                if (importedServices.length === 0)
+            Identifier(path) {
+
+                if (!this.processFile || this.importedServicesCount === 0)
                     return;
 
-                const replacements: types.Statement[] = [
-                    t.importDeclaration(
-                        [
-                            t.importDefaultSpecifier( t.identifier( appName )),
-                        ],
-                        t.stringLiteral('@server/app')
-                    )
-                ]
-
-                for (const { imported, local } of importedServices) {
-
-                    replacements.push(
-                        t.expressionStatement(
-                            t.callExpression(
-                                t.memberExpression(
-                                    t.identifier( appName ),
-                                    t.identifier('use')
-                                ),
-                                [
-                                    t.stringLiteral( imported )
-                                ]
-                            )
-                        )
-                    );
+                // Get service the identifier makes rfeerence to
+                const name = path.node.name;
+                const service = this.importedServices[ name ];
+                if (service === undefined)
+                    return;
+
+                // sometimes not iterable
+                if (!service.bindings)
+                    return;
+
+                // Replace by app.services.name
+                let serviceBinding: any;
+                for (const binding of service.bindings) {
+                    if (binding.replaced !== true && path.getPathLocation() === binding.getPathLocation()) {
+                        
+                        serviceBinding = binding;
 
-                    this.importedServices[ local ] = imported;
+                        break;
+                    }
                 }
 
-                debug && console.log(`############ [compilation][babel][services] Remplacement: `, 
-                    generate(t.program(replacements)).code 
-                );
+                // This identifier is a binding to a service
+                if (serviceBinding === undefined)
+                    return;
 
-                path.replaceWithMultiple(replacements);
-            },
+                // Replace to reference to app.services.serviceName
+                path.replaceWith(
+                    t.memberExpression(
+                        service.source === 'container'
+                            // container.Environment
+                            ? t.identifier( service.source )
+                            // application.services.Disks
+                            : t.memberExpression(
+                                t.identifier( service.source ),
+                                t.identifier('services'),
+                            ),
+                        path.node
+                    )
+                );
 
-            // transform accesses
-            Identifier() {
-                
+                // Avoid circular loop
+                serviceBinding.replaced = true;
             }
         }
     }