proteum 1.0.0-1

package/cli/compiler/server/index.ts

@@ -0,0 +1,211 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import webpack from 'webpack';
+import fs from 'fs-extra';
+
+// Minimizers
+const TerserPlugin = require("terser-webpack-plugin");
+//var VirtualModulesPlugin = require('webpack-virtual-modules');
+
+// Core
+import cli from '@cli';
+import createCommonConfig, { TCompileMode, regex } from '../common';
+
+// Type
+import type { App } from '../../app';
+
+/*const getCorePluginsList = (app: App,) => {
+
+    const corePlugins: string[] = [];
+
+    if (fs.existsSync( app.paths.root + '/node_modules' ))
+        for (const moduleName of fs.readdirSync( app.paths.root + '/node_modules' ))
+            if (moduleName.startsWith('proteum'))
+                corePlugins.push(app.paths.root + '/node_modules/' + moduleName + '/src');
+
+    if (fs.existsSync( cli.paths.core.root + '/node_modules' ))
+        for (const moduleName of fs.readdirSync( cli.paths.core.root+ '/node_modules' ))
+            if (moduleName.startsWith('proteum'))
+                corePlugins.push(cli.paths.core.root + '/node_modules/' + moduleName + '/src');
+
+    return corePlugins;
+}*/
+
+const debug = false;
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+export default function createCompiler( app: App, mode: TCompileMode ): webpack.Configuration {
+
+    debug && console.info(`Creating compiler for server (${mode}).`);
+    const dev = mode === 'dev';
+
+    const commonConfig = createCommonConfig(app, 'server', mode);
+    const { aliases } = app.aliases.server.forWebpack({
+        modulesPath: app.paths.root + '/node_modules'
+    });
+
+    // We're not supposed in any case to import client services from server
+    delete aliases["@client/services"]; 
+    delete aliases["@/client/services"];
+
+    debug && console.log(`[${mode}] node_modules dirs:`, commonConfig.resolveLoader?.modules,
+        '\nModule aliases for webpack:', aliases);
+    const config: webpack.Configuration = {
+
+        ...commonConfig,
+
+        name: 'server',
+        target: 'node',
+        entry: {
+            server: [
+                cli.paths.coreRoot + '/server/index.ts'
+            ],
+        },
+
+        output: {
+
+            pathinfo: dev,
+
+            libraryTarget: 'commonjs2',
+
+            path: app.paths.bin,
+            filename: '[name].js',
+            publicPath: '/',
+            assetModuleFilename: 'public/[hash][ext]',
+
+            chunkFilename: 'chunks/[name].js',
+            // HMR
+            hotUpdateMainFilename: 'updates/[fullhash].hot-update.json',
+            hotUpdateChunkFilename: 'updates/[id].[fullhash].hot-update.js',
+
+        },
+
+        externalsPresets: { node: true }, // in order to ignore built-in modules like path, fs, etc.
+        externals: [
+
+            './chunk-manifest.json',
+            './asset-manifest.json',
+
+            // node_modules
+            function ({ request }, callback) {
+
+                const shouldCompile = request !== undefined && (
+                    // Local files
+                    request[0] === '.' || request[0] === '/'
+                    ||
+                    // Aliased modules
+                    app.aliases.server.containsAlias(request)
+                    ||
+                    // TODO: proteum.conf: compile: include
+                    // Compile proteum modules
+                    request.startsWith('proteum')
+                    ||
+                    // Compile 5HTP modules
+                    request.startsWith('react-number-format') ||
+                    request.startsWith('@floating-ui')
+                )
+
+                //console.log('isNodeModule', request, isNodeModule);
+
+                if (!shouldCompile) {
+                    
+                    // Externalize to a commonjs module using the request path
+                    return callback(undefined, 'commonjs ' + request);
+                }
+
+                // Continue without externalizing the import
+                callback();
+            },
+        ],
+
+        resolve: {
+
+            ...commonConfig.resolve,
+
+            alias: aliases,
+
+            extensions: ['.ts', '.tsx', ".json", ".sql", ".js"],
+        },
+
+        module: {
+            // Make missing exports an error instead of warning
+            strictExportPresence: true,
+
+            rules: [
+                {
+                    test: regex.scripts,
+                    include: [
+
+                        app.paths.root + '/client',
+                        cli.paths.core.root + '/client',
+
+                        app.paths.root + '/common',
+                        cli.paths.core.root + '/common',
+
+                        // Dossiers server uniquement pour le bundle 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
+                        //...getCorePluginsList(app)
+                    ],
+                    rules: require('../common/babel')(app, 'server', dev)
+                }, 
+
+                // Les pages étan tà la fois compilées dans le bundle client et serveur
+                // On ne compile les ressources (css) qu'une seule fois (coté client)
+                {
+                    test: regex.style,
+                    loader: 'null-loader'
+                },
+
+                ...require('../common/files/images')(app, dev, false),
+
+                ...require('../common/files/autres')(app, dev, false),
+
+                // Exclude dev modules from production build
+                /*...(dev ? [] : [
+                    {
+                        test: app.paths.root + '/node_modules/react-deep-force-update/lib/index.js'),
+                        loader: 'null-loader',
+                    },
+                ]),*/
+            ],
+        },
+
+        plugins: [
+
+            ...(commonConfig.plugins || [])
+        ],
+
+        optimization: {
+            minimizer: dev ? [] : [
+                new TerserPlugin({
+                    terserOptions: {
+                        // Consere les classnames
+                        //keep_classnames: true,
+                        //keep_fnames: true,
+                    }
+                }),
+            ]
+        },
+
+        // https://webpack.js.org/configuration/devtool/#devtool
+        devtool: dev 
+            ? 'eval-source-map' // Recommended choice for development builds with high quality SourceMaps.
+            : 'source-map', // Recommended choice for production builds with high quality SourceMaps.
+
+            // eval-source-map n'est pas précis
+        /*devServer: {
+            hot: true,
+        },*/
+    };
+
+    return config;
+};

package/cli/index.ts

@@ -0,0 +1,189 @@
+#!/usr/bin/env -S npx ts-node
+
+process.traceDeprecation = true;
+
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import fs from 'fs-extra';
+import cp from 'child_process';
+
+// Libs
+import Paths from './paths';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TCliCommand = () => Promise<{ 
+    run: () => Promise<void> 
+}>
+
+type TArgsObject = {
+    [key: string]: string | boolean | string[]
+}
+
+/*----------------------------------
+- CLASSE
+----------------------------------*/
+/*
+    IMPORTANT: The CLI must be independant of the app instance and libs
+*/
+export class CLI {
+
+    // Context
+    public args: TArgsObject = {};
+    
+    public debug: boolean = false;
+
+    public packageJson: {[key: string]: any};
+
+    public constructor(
+        public paths = new Paths( process.cwd() )
+    ) {
+        this.debug && console.log(`[cli] 5HTP CLI`, process.env.npm_package_version);
+
+        this.debug && console.log(`[cli] Apply aliases ...`);
+        this.paths.applyAliases();
+
+        this.packageJson = this.loadPkg();
+
+        this.start();
+    }
+
+    /*----------------------------------
+    - COMMANDS
+    ----------------------------------*/
+    // Les importations asynchrones permettent d'accéder à l'instance de cli via un import
+    // WARN: We load commands asynchonously, so the aliases are applied before the file is imported
+    public commands: { [name: string]: TCliCommand } = {
+        "init": () => import('./commands/init'),
+        "dev": () => import('./commands/dev'),
+        "build": () => import('./commands/build'),
+    }
+
+    private loadPkg() {
+        return fs.readJSONSync(this.paths.core.root + '/package.json');
+    }
+
+    public start() {
+        
+        const [, , commandName, ...argv] = process.argv;
+
+        if (this.commands[commandName] === undefined)
+            throw new Error(`Command ${commandName} does not exists.`);
+
+        this.args.workdir = process.cwd();
+
+        let opt: string | null = null;
+        for (const a of argv) {
+
+            if (a[0] === '-') {
+
+                opt = a.substring(1);
+                if (!(opt in this.args)) 
+                    throw new Error(`Unknown option: ${opt}`);
+
+                // Init with default value
+                if (typeof this.args[opt] === "boolean")
+                    this.args[opt] = true;
+
+            } else if (opt !== null) {
+
+                const curVal = this.args[opt];
+
+                if (Array.isArray( curVal ))
+                    curVal.push(a);
+                else
+                    this.args[opt] = a;   
+
+                opt = null;
+
+            } else {
+
+                this.args[ a ] = true;
+
+            }
+        }
+
+        this.runCommand(commandName);
+    }
+
+    public async runCommand(command: string) {
+
+        this.debug && console.info(`Running command ${command}`, this.args);
+
+        // Check existance
+        if (this.commands[command] === undefined)
+            throw new Error(`Command ${command} does not exists.`);
+
+        const runner = await this.commands[command]();
+
+        // Running
+        runner.run().then(() => {
+
+            this.debug && console.info(`Command ${command} finished.`);
+
+        }).catch((e) => {
+
+            console.error(`Error during execution of ${command}:`, e);
+
+        }).finally(() => {
+
+            process.exit(0);
+
+        })
+    }
+
+
+    public shell(...commands: string[]) {
+
+        return new Promise<void>(async (resolve) => {
+
+            const fullCommand = commands.map(command => {
+
+                command = command.trim();
+
+                if (command.endsWith(';'))
+                    command = command.substring(0, command.length - 1);
+
+                return command;
+
+            }).join(';');
+
+            console.log('$ ' + fullCommand);
+
+            /*const tempFile = this.paths.app.root + '/.exec.sh';
+            fs.outputFileSync(tempFile, '#! /bin/bash\n' + fullCommand);
+            const wrappedCommand =  `tilix --new-process -e bash -c 'chmod +x "${tempFile}"; "${tempFile}"; echo "Entrée pour continuer"; read a;'`;*/
+            const wrappedCommand =  `bash -c '${fullCommand}'`;
+            console.log("Running command: " + wrappedCommand)
+            //await this.waitForInput('enter');
+
+            const proc = cp.spawn(wrappedCommand, [], {
+                cwd: process.cwd(),
+                detached: false,
+                // Permer de lancer les commandes via des chaines pures (autrement, il faut separer chaque arg dans un tableau)
+                // https://stackoverflow.com/questions/23487363/how-can-i-parse-a-string-into-appropriate-arguments-for-child-process-spawn
+                shell: true
+            });
+
+            console.log( proc.exitCode );
+
+            proc.on('exit', function () {
+
+                //fs.removeSync(tempFile);
+
+                console.log("Command finished.");
+                resolve();
+            })
+
+        });
+        
+    }
+
+}
+
+export default new CLI()

package/cli/paths.ts

@@ -0,0 +1,165 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import fs from 'fs';
+import path from 'path';
+import TsAlias from 'ts-alias';
+import moduleAlias from 'module-alias';
+import { filenameToImportName } from 'babel-plugin-glob-import';
+
+// Core
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+import type { App } from './app';
+import type { TAppSide } from './app';
+
+export type TPathInfosOptions = {
+    basePath?: string,
+    shortenExtensions: string[],
+    // Indexed will be trimed only when the extension can be shorten
+    trimIndex: boolean,
+}
+
+export type TPathInfos = {
+
+    original: string,
+    absolute: string,
+    relative: string,
+    //forImport: string,
+
+    name: string,
+    extension: string,
+    isIndex: boolean
+}
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+export const staticAssetName = /*isDebug ? '[name].[ext].[hash:8]' :*/ '[hash:8][ext]';
+
+const pathInfosDefaultOpts = {
+    shortenExtensions: ['ts', 'js', 'tsx', 'jsx'],
+    trimIndex: true,
+}
+
+const resolveCoreRoot = (appRoot: string) => {
+    const localInstall = path.join(appRoot, 'node_modules', 'proteum');
+    if (fs.existsSync(localInstall)) return localInstall;
+
+    // When running `npx`/global installs, there may be no local `node_modules/proteum` yet.
+    // Fall back to the installed package root (this file lives in `<root>/cli`).
+    return path.resolve(__dirname, '..');
+}
+
+/*----------------------------------
+- LIB
+----------------------------------*/
+export default class Paths {
+
+    /*----------------------------------
+    - LISTE
+    ----------------------------------*/
+
+    public constructor( 
+        public appRoot: string,
+        public coreRoot = resolveCoreRoot(appRoot)
+    ) {
+        
+    }
+
+    public core = {
+        cli: path.resolve(__dirname, '.'),
+        root: this.coreRoot,
+        pages: this.coreRoot + '/client/pages',
+    }
+
+    /*----------------------------------
+    - EXTRACTION
+    ----------------------------------*/
+
+    public infos(filename: string, givenOpts: Partial<TPathInfosOptions> = {}): TPathInfos {
+
+        const opts: TPathInfosOptions = { ...pathInfosDefaultOpts, ...givenOpts }
+
+        // Extraction élements du chemin
+        const decomp = filename.split('/')
+        let [nomFichier, extension] = (decomp.pop() as string).split('.');
+        const shortenExtension = opts.shortenExtensions && opts.shortenExtensions.includes(extension);
+
+        // Vire l'index
+        const isIndex = nomFichier === 'index'
+        let cheminAbsolu: string;
+        let nomReel: string;
+        if (isIndex && shortenExtension && opts.trimIndex) {
+            cheminAbsolu = decomp.join('/');
+            nomReel = decomp.pop() as string;
+        } else {
+            cheminAbsolu = [...decomp, nomFichier].join('/')
+            nomReel = nomFichier
+        }
+
+        // Conserve l'extension si nécessaire
+        if (!shortenExtension)
+            cheminAbsolu += '.' + extension;
+
+        const relative = opts.basePath === undefined 
+            ? ''
+            : cheminAbsolu.substring( opts.basePath.length + 1 )
+
+        // Retour
+        const retour = {
+
+            original: filename,
+            absolute: cheminAbsolu,
+            relative,
+
+            // Not used anymore, but can be useful in the future
+            //forImport: this.withAlias(cheminAbsolu, side),
+
+            name: nomReel,
+            extension,
+            isIndex
+        }
+
+        return retour;
+    }
+
+    public getPageChunk( app: App, file: string ) {
+
+        const infos = this.infos( file, {
+            basePath: file.startsWith( app.paths.pages ) ? app.paths.pages : this.core.pages,
+            // Avoid potential conflicts between /landing.tsx and /landing/index.tsx
+            trimIndex: false,
+        });
+
+        const filepath = infos.relative;
+
+        // Before:  /home/.../src/client/pages/landing/index.tsx
+        // After:   landing
+        let chunkId = filenameToImportName(filepath);
+
+        // nsure it's non-empty
+        if (chunkId.length === 0) // = /index.tsx
+            chunkId = "main";
+
+        return { filepath, chunkId }
+
+    }
+
+    public applyAliases() {
+
+        const aliases = new TsAlias({
+            rootDir: this.core.cli
+        });
+
+        //console.log('Applying Aliases ...', aliases.forModuleAlias());
+        moduleAlias.addAliases( aliases.forModuleAlias() );
+
+    }
+}

package/cli/print.ts

@@ -0,0 +1,12 @@
+export const h1 = (titre: string) => console.log(
+    '\n' +
+    '######################################################\n' +
+    '# ' + titre.toUpperCase() + '\n' +
+    '######################################################'
+);
+
+export const h2 = (titre: string) => console.log(
+    '------------------------------------------------------\n' +
+    '> ' + titre.toUpperCase() + '\n' +
+    '------------------------------------------------------'
+);

package/cli/tsconfig.json

@@ -0,0 +1,38 @@
+{
+    "compilerOptions": {
+        
+
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "allowJs": true,
+        "strict": false,
+        "downlevelIteration": true,
+
+        // Equivalent webpack: resolve.symblinks = false
+        "preserveSymlinks": true,
+        // Décorateurs
+        "experimentalDecorators": true,
+
+        // React
+        "jsx": "react-jsx",
+        "jsxImportSource": "preact",
+
+        "strictPropertyInitialization": true,
+        "strictNullChecks": true,
+        
+        "baseUrl": "./",
+        "outDir": "./bin",
+
+        "paths": {
+            "@cli/*": [ "./*" ],
+            "@cli/app": [ "./app" ],
+            "@cli": [ "./" ]
+        },
+    },
+
+    "ts-node": {
+        "transpileOnly": true,
+    },
+
+    "include": ["./"]
+}

package/cli/utils/index.ts

@@ -0,0 +1,22 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import fs from 'fs-extra';
+import path from 'path';
+
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+/*----------------------------------
+- UTILS
+----------------------------------*/
+
+export const api = (method: string, path: string, data: object, local: boolean = false) =>
+    `curl -X ${method} ${local ? 'http://localhost:3010' : 'https://dopamyn.io'}${path} ` +
+    `-H 'Content-Type: application/json' -H 'Accept: application/json' ` +
+    `-d '${JSON.stringify(data)}';`;