5htp 0.0.2

package/src/index.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env -S npx ts-node
+
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import { Logger } from "tslog";
+import cp from 'child_process';
+import fs from 'fs-extra';
+
+// Libs
+import Paths from './paths';
+import ConfigParser from '5htp-core/src/server/app/config';
+
+// Types from core
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TCliCommand = { 
+    run: () => Promise<void> 
+}
+
+export type TAppSide = 'server' | 'client'
+
+/*----------------------------------
+- CLASSE
+----------------------------------*/
+/*
+    IMPORTANT: The CLI must be independant of the app instance and libs
+*/
+export class CLI {
+
+    // Context
+    public args: TObjetDonnees = {};
+    public pkg = {
+        app: require(this.paths.app.root + '/package.json'),
+        core: require(this.paths.core.root + '/package.json'),
+    }
+    
+    // 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!: Core.Config.Identity;
+
+    public constructor(
+        public paths = new Paths( process.cwd() )
+    ) {
+        console.log(`[cli] Start debugger ...`);
+        new Logger({ name: "cli", overwriteConsole: true });
+        
+        console.log(`[cli] Apply aliases ...`);
+        this.paths.applyAliases();
+        
+        console.log(`[cli] Loading app config ...`);
+        const configParser = new ConfigParser( paths.appRoot );
+        this.identity = configParser.identity();
+
+        this.start();
+    }
+
+    /*----------------------------------
+    - COMMANDS
+    ----------------------------------*/
+    // Les importations asynchrones permettent d'accéder à l'instance de cli via un import
+    public commands: { [name: string]: TCliCommand } = {
+        "dev": require('./commands/dev'),
+        "build": require('./commands/build'),
+    }
+
+    public start() {
+
+        const [, , commandName, ...argv] = process.argv;
+
+        if (this.commands[commandName] === undefined)
+            throw new Error(`Command ${commandName} does not exists.`);
+
+        const options = {
+            workdir: process.cwd()
+        }
+
+        let opt: string | null = null;
+        for (const a of argv) {
+
+            if (a[0] === '-') {
+
+                opt = a.substring(1);
+                if (!(opt in options)) 
+                    throw new Error(`Unknown option: ${opt}`);
+
+                // Init with default value
+                if (typeof options[opt] === "boolean")
+                    options[opt] = true;
+
+            } else if (opt !== null) {
+
+                const curVal = options[opt];
+
+                if (Array.isArray( curVal ))
+                    curVal.push(a);
+                else
+                    options[opt] = a;
+
+                opt = null;
+
+            } else {
+
+                //args.push(a);
+
+            }
+        }
+
+        this.runCommand(commandName, options);
+    }
+
+    public async runCommand(command: string, args: TObjetDonnees) {
+
+        this.args = args;
+
+        console.info(`Running command ${command}`, this.args);
+
+        // Check existance
+        if (this.commands[command] === undefined)
+            throw new Error(`Command ${command} does not exists.`);
+
+        // Running
+        this.commands[command].run().then(() => {
+
+            console.info(`Command ${command} finished.`);
+
+        }).catch((e) => {
+
+            console.error(`Error during execution of ${command}:`, e);
+
+        }).finally(() => {
+
+            process.exit();
+
+        })
+    }
+
+
+    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}; echo "Entrée pour continuer"; read a;'`;
+            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);
+
+                resolve();
+            })
+
+        });
+        
+    }
+
+}
+
+export default new CLI()

package/src/paths.ts

@@ -0,0 +1,158 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import path from 'path';
+import moduleAlias from 'module-alias';
+
+// Core
+import TsAlias from 'ts-alias';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+import type { TAppSide } from '.';
+
+export type TPathInfos = {
+
+    original: string,
+    absolute: string,
+    relative: string,
+    forImport: string,
+
+    name: string,
+    extension: string,
+    isIndex: boolean
+}
+
+export const staticAssetName = /*isDebug ? '[name].[ext].[hash:8]' :*/ '[hash:8][ext]';
+
+/*----------------------------------
+- LIB
+----------------------------------*/
+export default class Paths {
+
+    /*----------------------------------
+    - LISTE
+    ----------------------------------*/
+
+    public constructor( 
+        public appRoot: string,
+        public coreRoot = appRoot + '/node_modules/5htp-core'
+    ) {
+        
+    }
+
+    public core = {
+        root: this.coreRoot,
+        src: this.coreRoot + '/src',
+        realRoot: path.resolve(__dirname, '..'),
+        pages: this.coreRoot + '/src/client/pages',
+    }
+
+    public app = {
+        root: this.appRoot,
+        src: this.appRoot + '/src',
+        bin: this.appRoot + '/bin',
+        data: this.appRoot + '/var/data',
+        public: this.appRoot + '/bin/public',
+        pages: this.appRoot + '/src/client/pages',
+        cache: this.appRoot + '/src/.cache'
+    }
+
+    /*----------------------------------
+    - EXTRACTION
+    ----------------------------------*/
+
+    public infos(filename: string, basePath?: string, side: TAppSide = 'server'): TPathInfos {
+
+        // Extraction élements du chemin
+        const decomp = filename.split('/')
+        let [nomFichier, extension] = (decomp.pop() as string).split('.');
+        const raccourcir = ['ts', 'js', 'tsx', 'jsx'].includes(extension);
+
+        // Vire l'index
+        const isIndex = nomFichier === 'index'
+        let cheminAbsolu: string;
+        let nomReel: string;
+        if (isIndex && raccourcir) {
+            cheminAbsolu = decomp.join('/');
+            nomReel = decomp.pop() as string;
+        } else {
+            cheminAbsolu = [...decomp, nomFichier].join('/')
+            nomReel = nomFichier
+        }
+
+        // Conserve l'extension si nécessaire
+        if (!raccourcir)
+            cheminAbsolu += '.' + extension;
+
+        const relative = basePath === undefined 
+            ? ''
+            : cheminAbsolu.substring( basePath.length + 1 )
+
+        // Retour
+        const retour = {
+
+            original: filename,
+            absolute: cheminAbsolu,
+            relative,
+
+            forImport: this.withAlias(cheminAbsolu, side),
+
+            name: nomReel,
+            extension,
+            isIndex
+        }
+
+        return retour;
+    }
+
+    public getPageChunk( file: string ) {
+
+        const infos = this.infos( file, file.startsWith( this.app.pages ) 
+            ? this.app.pages 
+            : this.core.pages,
+        );
+
+        const filepath = infos.relative;
+
+        // Before:  /home/.../src/client/pages/landing/index.tsx
+        // After:   landing_index
+        let chunkId = filepath.replace(/\//g, '_');
+
+        // nsure it's non-empty
+        if (chunkId.length === 0) // = /index.tsx
+            chunkId = "main";
+
+        return { filepath, chunkId }
+
+    }
+
+    /*----------------------------------
+    - ALIAS
+    ----------------------------------*/
+
+    public aliases = {
+        client: new TsAlias(this.app.root + '/src/client'),
+        server: new TsAlias(this.app.root + '/src/server'),
+    }
+
+    public withAlias = (filename: string, side: TAppSide) => 
+        this.aliases[side].apply(filename);
+
+    public withoutAlias = (filename: string, side: TAppSide) => 
+        this.aliases[side].realpath(filename);
+
+    public applyAliases() {
+
+        const aliases = new TsAlias( this.core.root + '/cli' );
+
+        console.log('Applying Aliases ...', aliases);
+
+        moduleAlias.addAliases( aliases.forModuleAlias() );
+
+    }
+}

package/src/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/src/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)}';`;

package/src/utils/keyboard.ts

@@ -0,0 +1,78 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// npm
+import readline, { Key } from 'readline';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TKeyboardCommand = {
+    remove?: boolean,
+    run: (str: string, chunk: string, key: Key) => void
+}
+
+/*----------------------------------
+- METHODS
+----------------------------------*/
+class KeyboardCommands {
+
+    private commands: { [input: string]: TKeyboardCommand } = {}
+
+    public constructor() {
+        this.listen();
+    }
+
+    private listen() {
+
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        process.stdin.on('keypress', async (chunk: string, key: Key) => {
+
+            let str = key.name;
+            if (!str) return;
+            if (str === 'return') str = 'enter';
+
+            if (key.ctrl) str = 'ctrl+' + str;
+            if (key.shift) str = 'shift+' + str;
+            if (key.meta) str = 'meta+' + str;
+
+            const kCommand = this.commands[str] || this.commands.fallback;
+            if (kCommand) {
+
+                kCommand.run(str, chunk, key);
+
+                if (kCommand.remove)
+                    delete this.commands[str];
+            }
+
+            if (str === 'ctrl+c') {
+
+                console.log(`Exiting ...`);
+                process.exit();
+
+            } 
+
+
+        });
+    }
+
+
+    public input(str: string, run: TKeyboardCommand["run"], options: Omit<TKeyboardCommand, 'run'> = {}) {
+        this.commands[str] = { run, ...options }
+    }
+
+    public waitForInput(str: string): Promise<void> {
+        return new Promise((resolve) => {
+            this.commands[str] = {
+                run: () => resolve(),
+                remove: true
+            }
+        });
+    }
+
+}
+
+export default new KeyboardCommands

package/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": "./src",
+        "outDir": "./bin",
+
+        "paths": {
+            "@cli/*": [ "./*" ],
+            "@cli": [ "./" ],
+            "@server_old/*": [ "../src/server/*" ]
+        },
+    },
+
+    "ts-node": {
+        "transpileOnly": true,
+    },
+
+    "include": ["./src"]
+}