not-node 6.1.5 → 6.1.6

package/src/cli/lib/args.mjs

@@ -0,0 +1,72 @@
+import Logger from "./log.mjs";
+
+const TEMPLATE_OPTIONS = "__options__";
+const VAR_PREFIX = "__";
+
+import * as Readers from "../readers/index.mjs";
+import inquirer from "inquirer";
+
+async function readArgs(structure, config) {
+    let result = {};
+    if (Object.hasOwn(structure, "args")) {
+        for (let entry of structure.args) {
+            if (!Object.hasOwn(config, entry)) {
+                Logger.log(
+                    `no ${entry} in config, reading data from user input`
+                );
+                config[entry] = await Readers[entry](inquirer, config);
+            }
+            result[entry] = config[entry];
+        }
+    }
+    //console.log(JSON.stringify(result, null, 4));
+    if (Object.hasOwn(structure, "options")) {
+        result[TEMPLATE_OPTIONS] = structure.options;
+    }
+    return result;
+}
+
+function isFilename(name, descr) {
+    if (descr.type === "file") {
+        return true;
+    }
+    if (name.startsWith(VAR_PREFIX) && name.endsWith(VAR_PREFIX)) {
+        return false;
+    }
+    return name.indexOf(".") > -1;
+}
+
+function isVariable(name) {
+    return name.startsWith(VAR_PREFIX) && name.endsWith(VAR_PREFIX);
+}
+
+function getVariableName(name) {
+    return name.replace(new RegExp(VAR_PREFIX, "g"), "");
+}
+
+function dirRequiresAbsentModules(subStructure, config) {
+    return (
+        Object.hasOwn(subStructure, "ifModules") &&
+        Array.isArray(subStructure.ifModules) &&
+        !subStructure.ifModules.every((entry) => config.modules.includes(entry))
+    );
+}
+
+function dirRequiresNotNullArgs(subStructure, config) {
+    return (
+        Object.hasOwn(subStructure, "ifArgs") &&
+        Array.isArray(subStructure.ifArgs) &&
+        !subStructure.ifArgs.every((entry) => {
+            return Object.hasOwn(config, entry) && config[entry];
+        })
+    );
+}
+
+export {
+    readArgs,
+    isFilename,
+    isVariable,
+    getVariableName,
+    dirRequiresAbsentModules,
+    dirRequiresNotNullArgs,
+};

package/src/cli/lib/entity.mjs

@@ -0,0 +1,46 @@
+import { firstLetterToLower } from "../../../src/common.js";
+import { resolve } from "node:path";
+import inquirer from "inquirer";
+import * as Readers from "../readers/index.mjs";
+import * as Renderers from "../renderers/index.mjs";
+import { renderFile, createDir } from "./fs.mjs";
+
+import Options from "./opts.mjs";
+
+async function renderEntityFiles(module_src_dir, data, config) {
+    for (let layerName of data.layers) {
+        if (Object.hasOwn(Renderers, layerName)) {
+            await Renderers[layerName](
+                resolve(module_src_dir, `./${layerName}`),
+                data,
+                config,
+                renderFile,
+                Options.PATH_TMPL,
+                createDir
+            );
+        } else {
+            console.error("No renderer for layer: ", layerName);
+        }
+    }
+}
+
+async function createEntity(modules_dir, config) {
+    const ModuleName = await Readers.ModuleName(inquirer);
+    const moduleName = firstLetterToLower(ModuleName);
+    const moduleDir = resolve(modules_dir, ModuleName);
+    const moduleLayers = await Readers.moduleLayers(inquirer);
+    const moduleConfig = { ...config, moduleName, ModuleName, moduleLayers };
+    console.log();
+    const entityData = await Readers.entityData(
+        inquirer,
+        moduleConfig,
+        moduleConfig.moduleLayers
+    );
+    await renderEntityFiles(
+        resolve(moduleDir, "./src"),
+        entityData,
+        moduleConfig
+    );
+}
+
+export { createEntity, renderEntityFiles };

package/src/cli/lib/fs.mjs

@@ -0,0 +1,176 @@
+import Logger from "./log.mjs";
+import {
+    readArgs,
+    isFilename,
+    isVariable,
+    dirRequiresAbsentModules,
+    dirRequiresNotNullArgs,
+    getVariableName,
+} from "./args.mjs";
+
+import { ProjectSubStructures } from "./structures.mjs";
+
+import { spawn } from "node:child_process";
+import { resolve, join } from "node:path";
+import {
+    copyFile,
+    constants,
+    mkdir,
+    writeFile,
+    readFile,
+} from "node:fs/promises";
+
+import ejs from "ejs";
+
+import Options from "./opts.mjs";
+const PATH_TMPL = Options.PATH_TMPL;
+
+async function renderFile(input, dest, data) {
+    Logger.log("render", dest);
+    const renderedFileContent = await ejs.renderFile(input, data, {
+        async: true,
+    });
+    await writeFile(dest, renderedFileContent);
+}
+
+async function createFileContent(filePath, structure, config) {
+    if (typeof structure == "string") {
+        await copyTmplFile(resolve(PATH_TMPL, structure), filePath);
+        return;
+    }
+    if (Object.hasOwn(structure, "tmpl")) {
+        const tmplFilePath = resolve(PATH_TMPL, structure.tmpl);
+        const data = await readArgs(structure, config);
+        await renderFile(tmplFilePath, filePath, data);
+    }
+}
+
+async function copyTmplFile(from, to) {
+    try {
+        //  console.log("cp", from, to);
+        await copyFile(from, to, constants.COPYFILE_EXCL);
+    } catch {
+        //console.error("The file could not be copied", from, to);
+    }
+}
+
+async function createDir(dirPath) {
+    try {
+        //console.log("mkdir", dirPath);
+        await mkdir(dirPath, { recursive: true });
+    } catch {
+        // console.error("Can't create directory", dirPath);
+    }
+}
+
+async function createDirContent(dest, structure = {}, config = {}) {
+    if (typeof structure === "string") {
+        //console.log("need to create sub structure", structure);
+        await createDirContent(dest, ProjectSubStructures[structure], config);
+        return;
+    }
+    const dirs = {};
+    //creating files first
+    for (let entry in structure) {
+        const subStructure = structure[entry];
+        if (isVariable(entry)) {
+            entry = config[getVariableName(entry)];
+        }
+        if (isFilename(entry, subStructure)) {
+            //  console.log(dest, entry);
+            const filePath = join(dest, entry);
+            await createFileContent(filePath, subStructure, config);
+        } else {
+            dirs[entry] = subStructure;
+        }
+    }
+    //then going deeper
+    for (let entry in dirs) {
+        const subStructure = dirs[entry];
+        const directoryPath = join(dest, entry);
+        if (dirRequiresAbsentModules(subStructure, config)) {
+            continue;
+        }
+        if (dirRequiresNotNullArgs(subStructure, config)) {
+            continue;
+        }
+        await createDir(directoryPath);
+        if (Object.hasOwn(subStructure, "content")) {
+            await createDirContent(directoryPath, subStructure.content, config);
+        }
+    }
+}
+
+function makeScriptExecutable(pathToTargetScript) {
+    return new Promise((resolve, reject) => {
+        console.log(`chmod`, "+x", pathToTargetScript);
+        let npmInstall = spawn(`chmod`, ["+x", pathToTargetScript]);
+        npmInstall.stderr.on("data", (data) => {
+            Logger.error(data.toString());
+        });
+        npmInstall.on("exit", (code) => {
+            if (code == 0) {
+                resolve();
+            } else {
+                reject(`chmod +x ${pathToTargetScript}  ${code}`);
+            }
+        });
+    });
+}
+
+function installPackages(siteDir) {
+    return new Promise((resolve, reject) => {
+        console.log("installing packages...");
+        let npmInstall = spawn(`npm`, ["i"], {
+            cwd: siteDir,
+        });
+
+        npmInstall.stderr.on("data", (data) => {
+            Logger.error(data.toString());
+        });
+        npmInstall.on("exit", (code) => {
+            if (code == 0) {
+                resolve();
+            } else {
+                reject(`NPM install exited with code ${code}`);
+            }
+        });
+    });
+}
+
+function buildClientSideScripts(siteDir) {
+    return new Promise((resolve, reject) => {
+        console.log("building client side scripts...");
+        let npmInstall = spawn(`npm`, ["run", "build"], {
+            cwd: siteDir,
+        });
+
+        npmInstall.stderr.on("data", (data) => {
+            Logger.error(data.toString());
+        });
+        npmInstall.on("exit", (code) => {
+            if (code == 0) {
+                resolve();
+            } else {
+                reject(`npm run build job exited with code ${code}`);
+            }
+        });
+    });
+}
+
+async function readJSONFile(fname) {
+    const rawdata = await readFile(fname);
+    return JSON.parse(rawdata);
+}
+
+export {
+    createDir,
+    copyTmplFile,
+    createFileContent,
+    renderFile,
+    createDirContent,
+    makeScriptExecutable,
+    buildClientSideScripts,
+    installPackages,
+    readJSONFile,
+};

package/src/cli/lib/log.mjs

@@ -0,0 +1,25 @@
+class Logger {
+    #silent = true;
+
+    log() {
+        !this.#silent && console.log(...arguments);
+    }
+
+    error() {
+        !this.#silent && console.error(...arguments);
+    }
+
+    debug() {
+        !this.#silent && console.debug(...arguments);
+    }
+
+    info() {
+        !this.#silent && console.info(...arguments);
+    }
+
+    setSilent(val) {
+        this.#silent = val;
+    }
+}
+
+export default new Logger();

package/src/cli/lib/messages.mjs

@@ -0,0 +1,29 @@
+function postStartupInstructions(siteDir, config) {
+    console.log(
+        "Generation of source code, configurations, toolchain and installation of packages successfully finished."
+    );
+    if (config.nginx) {
+        console.log("To enable NGINX reverse proxy:");
+        console.log(
+            "1. Copy config file for desired envrionment to NGINX directory and enable it"
+        );
+        for (let env of ["development", "stage", "production"]) {
+            console.log(
+                `For '${env}' environment exec while in project directory:`
+            );
+            console.log(
+                `$ sudo cp nginx/${env}.conf to /var/nginx/sites-available/${config.hostname[env]}.conf`
+            );
+            console.log(
+                `$ sudo ln -s /var/nginx/sites-available/${config.hostname[env]}.conf /var/nginx/sites-enabled/${config.hostname[env]}.conf`
+            );
+        }
+        console.log("2. Restart NGINX server");
+        console.log("$ sudo systemctl restart nginx");
+    }
+    console.log(
+        `To start server navigate to [project]/site directory (cd '${siteDir}') and run 'npm start'`
+    );
+}
+
+export { postStartupInstructions };

package/src/cli/lib/module.front.mjs

@@ -0,0 +1,57 @@
+import { resolve } from "node:path";
+import { firstLetterToLower } from "../../../src/common.js";
+import { createDir, createDirContent, renderFile } from "./fs.mjs";
+import { ProjectSubStructures } from "./structures.mjs";
+import * as Readers from "../readers/index.mjs";
+import * as Renderers from "../renderers/index.mjs";
+import inquirer from "inquirer";
+import Options from "./opts.mjs";
+
+async function createFrontModule(modules_dir, config) {
+    const ModuleName = await Readers.ModuleName(inquirer);
+    const moduleName = firstLetterToLower(ModuleName);
+    const targetRoles = await Readers.roles(inquirer);
+    for (let role of targetRoles) {
+        const targetModuleRoleDir = resolve(modules_dir, role, moduleName);
+        console.log("creating directory for role", role);
+        await createDir(targetModuleRoleDir);
+        await Renderers.controllersIndex(
+            targetModuleRoleDir,
+            [],
+            { ...config, roles: targetRoles },
+            renderFile,
+            Options.PATH_TMPL
+        );
+    }
+}
+
+async function createBootstrapFrontModule(modules_dir, config) {
+    await createDir(modules_dir);
+    await createDirContent(
+        modules_dir,
+        ProjectSubStructures["module.front"],
+        config
+    );
+    for (let role of config.roles) {
+        await createDir(resolve(modules_dir, role));
+        const targetFrontModuleDir = resolve(modules_dir, role, "main");
+        await createDir(targetFrontModuleDir);
+        if (role === "guest") {
+            await Renderers.frontModuleGuestMain(
+                targetFrontModuleDir,
+                { ...config, roleName: role },
+                renderFile,
+                Options.PATH_TMPL
+            );
+        } else {
+            await Renderers.frontModuleRoleMain(
+                targetFrontModuleDir,
+                { ...config, roleName: role },
+                renderFile,
+                Options.PATH_TMPL
+            );
+        }
+    }
+}
+
+export { createBootstrapFrontModule, createFrontModule };

package/src/cli/lib/module.server.mjs

@@ -0,0 +1,128 @@
+import { firstLetterToLower } from "../../../src/common.js";
+import { resolve } from "node:path";
+import inquirer from "inquirer";
+
+import * as Readers from "../readers/index.mjs";
+import * as Renderers from "../renderers/index.mjs";
+import Options from "../lib/opts.mjs";
+const PATH_TMPL = Options.PATH_TMPL;
+import { renderFile, createDir, createDirContent } from "./fs.mjs";
+import {
+    ProjectSubStructures,
+    ApplicationModuleServerControllersCommonStructure,
+} from "./structures.mjs";
+
+import { renderEntityFiles } from "./entity.mjs";
+
+function entitiesInLayers(layersList = []) {
+    return (
+        layersList.includes("models") ||
+        layersList.includes("routes") ||
+        layersList.includes("logics")
+    );
+}
+
+async function createLayersDirs(modules_dir, layersList, ModuleName) {
+    if (layersList.length) {
+        await createDir(resolve(modules_dir, ModuleName, "./src"));
+    }
+    for (let layer of layersList) {
+        await createDir(resolve(modules_dir, ModuleName, "./src", layer));
+    }
+}
+
+async function renderServerControllersCommons(
+    module_src_dir,
+    entitiesData,
+    config
+) {
+    const dirPath = resolve(module_src_dir, `./common`);
+    await createDir(dirPath);
+    await createDirContent(
+        dirPath,
+        ApplicationModuleServerControllersCommonStructure,
+        {}
+    );
+    await Renderers.controllersCommons(
+        dirPath,
+        entitiesData,
+        config,
+        renderFile,
+        PATH_TMPL
+    );
+}
+
+async function renderServerContollersIndexes(
+    module_src_dir,
+    entitiesData,
+    config
+) {
+    const subDirList = [...config.roles];
+    for (let dirName of subDirList) {
+        await Renderers.controllersIndex(
+            resolve(module_src_dir, `./controllers/${dirName}`),
+            entitiesData,
+            config,
+            renderFile,
+            PATH_TMPL,
+            createDir
+        );
+    }
+}
+
+async function createServerModule(modules_dir, config) {
+    //read module name
+    const ModuleName = await Readers.ModuleName(inquirer);
+    const moduleName = firstLetterToLower(ModuleName);
+    const moduleDir = resolve(modules_dir, ModuleName);
+    const moduleConfig = { ...config, moduleName, ModuleName };
+    await createDir(moduleDir);
+    //console.log(JSON.stringify(moduleConfig, null, 4));
+    await createDirContent(
+        moduleDir,
+        ProjectSubStructures["module.server"],
+        moduleConfig
+    );
+    const layersList = moduleConfig.moduleLayers;
+    await createLayersDirs(modules_dir, layersList, ModuleName);
+    //list of entities and its presence thru all selected layers
+    let entitiesList = [];
+    if (entitiesInLayers(layersList)) {
+        //should collect all first, to have full list of items for index files imports
+        while (await Readers.isUserNeedCreateEntity(inquirer)) {
+            const entityData = await Readers.entityData(
+                inquirer,
+                config,
+                layersList
+            );
+            entitiesList.push(entityData);
+        }
+        for (let entityData of entitiesList) {
+            await renderEntityFiles(
+                resolve(moduleDir, "./src"),
+                entityData,
+                moduleConfig
+            );
+        }
+        if (layersList.includes("controllers")) {
+            await renderServerContollersIndexes(
+                resolve(moduleDir, "./src"),
+                entitiesList,
+                moduleConfig
+            );
+            await renderServerControllersCommons(
+                resolve(moduleDir, "./src/controllers"),
+                entitiesList,
+                moduleConfig
+            );
+        }
+    }
+}
+
+export {
+    createLayersDirs,
+    entitiesInLayers,
+    renderServerControllersCommons,
+    createServerModule,
+    renderServerContollersIndexes,
+};

package/src/cli/lib/opts.mjs

@@ -0,0 +1,33 @@
+import { resolve } from "node:path";
+import { DEFAULT_PRIMARY_ROLES_SET } from "../const.mjs";
+import * as url from "url";
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+
+class Options {
+    #DEFAULT_SERVER_MODULES_SUB_PATH = "./site/app/server/modules";
+    get DEFAULT_SERVER_MODULES_SUB_PATH() {
+        return this.#DEFAULT_SERVER_MODULES_SUB_PATH;
+    }
+
+    #DEFAULT_FRONT_MODULES_SUB_PATH = "./site/app/front/src";
+    get DEFAULT_FRONT_MODULES_SUB_PATH() {
+        return this.#DEFAULT_FRONT_MODULES_SUB_PATH;
+    }
+
+    #PATH_TMPL = resolve(__dirname, "../../../tmpl/files");
+    get PATH_TMPL() {
+        return this.#PATH_TMPL;
+    }
+
+    #roles = DEFAULT_PRIMARY_ROLES_SET;
+    get roles() {
+        return this.#roles;
+    }
+
+    set roles(val) {
+        if (Array.isArray(val)) {
+            this.#roles = val;
+        }
+    }
+}
+export default new Options();

package/src/cli/lib/project.mjs

@@ -0,0 +1,16 @@
+import { readJSONFile } from "./fs.mjs";
+
+async function loadProjectConfig(siteDir) {
+    const fname = `${siteDir}/project.manifest.json`;
+    console.log(fname);
+    const manifest = await readJSONFile(fname);
+    return {
+        AppName: manifest.name,
+        roles: manifest.targets.server.roles,
+        serverModulesDir: manifest.targets.server.modules.serverModulesDir,
+        frontModulesDir: manifest.targets.server.modules.frontModulesDir,
+        modules: Object.keys(manifest.targets.server.modules.npm),
+    };
+}
+
+export { loadProjectConfig };

package/src/cli/lib/structures.mjs

@@ -0,0 +1,37 @@
+//file system structure
+//directories
+//files and information how to render them from which template and with what args with readers names
+
+import ProjectStructure from "../../../tmpl/dirs/project.mjs";
+import ApplicationStructure from "../../../tmpl/dirs/app.mjs";
+import ApplicationServerStructure from "../../../tmpl/dirs/server.mjs";
+import ApplicationFrontStructure from "../../../tmpl/dirs/front.mjs";
+import ApplicationStaticStructure from "../../../tmpl/dirs/static.mjs";
+
+import ApplicationModuleServerStructure from "../../../tmpl/dirs/module.server.mjs";
+import ApplicationModuleServerControllersCommonStructure from "../../../tmpl/dirs/module.server.controllers.common.mjs";
+
+import ApplicationModuleFrontStructure from "../../../tmpl/dirs/module.front.mjs";
+
+const ProjectSubStructures = {
+    app: ApplicationStructure,
+    server: ApplicationServerStructure,
+    front: ApplicationFrontStructure,
+    static: ApplicationStaticStructure,
+    "module.server": ApplicationModuleServerStructure,
+    "module.server.controllers.common":
+        ApplicationModuleServerControllersCommonStructure,
+    "module.front": ApplicationModuleFrontStructure,
+};
+
+export {
+    ProjectStructure,
+    ApplicationStructure,
+    ApplicationServerStructure,
+    ApplicationFrontStructure,
+    ApplicationStaticStructure,
+    ApplicationModuleServerStructure,
+    ApplicationModuleServerControllersCommonStructure,
+    ApplicationModuleFrontStructure,
+    ProjectSubStructures,
+};

package/src/cli/readers/roles.mjs

@@ -1,4 +1,4 @@
-import { DEFAULT_PRIMARY_ROLES_SET } from "../const.mjs";
+import Options from "../lib/opts.mjs";
 
 export default (inquirer) => {
     return inquirer
@@ -7,7 +7,7 @@ export default (inquirer) => {
                 type: "checkbox",
                 message: "Select primary user roles set",
                 name: "roles",
-                choices: DEFAULT_PRIMARY_ROLES_SET.map((role) => {
+                choices: Options.roles.map((role) => {
                     return {
                         name: role,
                         checked: true,

package/src/cli/renderers/controllersIndex.mjs

@@ -11,6 +11,7 @@ export default async (
 ) => {
     const TMPL_FILE_PATH = resolve(PATH_TMPL, CONTROLLER_INDEX_TMPL);
     const DEST_FILE_PATH = resolve(module_layer_dir, `index.js`);
+    console.log("creating", TMPL_FILE_PATH, DEST_FILE_PATH);
     await createFileContent(TMPL_FILE_PATH, DEST_FILE_PATH, {
         ...config,
         entities: data,