miqro 6.2.12 → 6.3.0

package/build/esm/src/inflate/setup-http.js

@@ -1,5 +1,5 @@
 import { Router, newURL, normalizePath } from "@miqro/core";
-import { existsSync, mkdirSync, readFile, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdir, readFile, readFileSync, readdirSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve as pathResolve } from "node:path";
 import { CONTENT_TYPE_MAP, DEFAULT_CONTENT_TYPE } from "../common/content-type.js";
 import { importHTMLModule, importAPIRoute, inflateJSX, importJSONModule, jsx2HTML } from "../common/jsx.js";
@@ -11,11 +11,11 @@ import { getHTTPRouterPath, getStaticFilesPath } from "../common/paths.js";
 import { setupCORS } from "./setup-cors.js";
 import { setupAUTH } from "./setup-auth.js";
 import { getRoutes } from "../services/utils/get-route.js";
-import { describeFilePath } from "../common/fs.js";
+import { describeFilePath, mkdirASync, writeFileASync } from "../common/fs.js";
 import { inflateMD2HTML } from "./md.js";
 import { setupMiddleware } from "./setup-middleware.js";
 import { setupError } from "./setup-error.js";
-export async function setupHTTPRouter(server, logger, hotreload, servicePath, service, routeFileMap, staticFileMap, inflateDir, inflateSea, errors) {
+export async function setupHTTPRouter(server, logger, hotreload, servicePath, service, routeFileMap, staticFileMap, inflateDir, inflateSea, errors, inflateParallel) {
     const mainRouter = new Router();
     const apiRouterPath = getHTTPRouterPath(servicePath); //resolve(process.cwd(), service, "http");
     let middlewareConfig = null;
@@ -25,13 +25,13 @@ export async function setupHTTPRouter(server, logger, hotreload, servicePath, se
     middlewareConfig = await setupMiddleware(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
     if (apiRouterPath) {
         logger.trace("setting up http routes from [%s]", service);
-        const { router: httpRouter } = await createRouterFromDirectory(server, hotreload, service, logger, apiRouterPath, errors, routeFileMap, staticFileMap, inflateDir, inflateSea);
+        const { router: httpRouter } = await createRouterFromDirectory(server, hotreload, service, logger, apiRouterPath, errors, routeFileMap, staticFileMap, inflateDir, inflateSea, inflateParallel);
         mainRouter.use(httpRouter);
     }
     const staticFilesPath = getStaticFilesPath(servicePath); //resolve(process.cwd(), service, "static");
     if (staticFilesPath) {
         logger.trace("setting up static file routes from [%s]", service);
-        const staticRouter = createStaticRouterFromDirectory(service, logger, staticFilesPath, inflateDir, routeFileMap, staticFileMap);
+        const staticRouter = await createStaticRouterFromDirectory(service, logger, staticFilesPath, inflateDir, routeFileMap, staticFileMap, inflateParallel);
         mainRouter.use(staticRouter);
     }
     if (middlewareConfig && middlewareConfig.post) {
@@ -41,86 +41,114 @@ export async function setupHTTPRouter(server, logger, hotreload, servicePath, se
     }
     return mainRouter;
 }
-function createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap) {
-    logger.trace("creating static route for [%s]", file.filePath);
-    logger.trace("[%o]", {
-        file,
-        dir
-    });
-    const contentType = CONTENT_TYPE_MAP[String(file.ext).toLocaleLowerCase()];
-    const path = join("/", relative(dir, file.filePath));
-    routeFileMap[file.filePath] = {
-        routes: [{
-                method: "GET",
-                path: normalizePath(path)
-            }],
-        service,
-        filePath: file.filePath,
-        previewMethod: "html"
-    };
-    if (inflateDir) {
-        const inflatePath = join(inflateDir, service, "static", path);
-        mkdirSync(dirname(inflatePath), {
-            recursive: true
-        });
-        logger.log("writing [%s]", relative(cwd(), inflatePath));
-        const body = readFileSync(file.filePath);
-        writeFileSync(inflatePath, body);
-        if (staticFileMap) {
-            staticFileMap[file.filePath] = {
-                contentType,
+async function createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            logger.trace("creating static route for [%s]", file.filePath);
+            logger.trace("[%o]", {
+                file,
+                dir
+            });
+            const contentType = CONTENT_TYPE_MAP[String(file.ext).toLocaleLowerCase()];
+            const path = join("/", relative(dir, file.filePath));
+            routeFileMap[file.filePath] = {
+                routes: [{
+                        method: "GET",
+                        path: normalizePath(path)
+                    }],
+                service,
                 filePath: file.filePath,
-                previewMethod: "html",
-                method: "GET",
-                path: normalizePath(path),
-                body: Buffer.from(body),
-                inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+                previewMethod: "html"
             };
-        }
-    }
-    router.use(assertGlobalTampered);
-    router.get(path, async function (_req, res) {
-        await new Promise((resolve, reject) => {
-            try {
-                readFile(file.filePath, async (err, body) => {
-                    if (err) {
-                        reject(err);
+            if (inflateDir) {
+                const inflatePath = join(inflateDir, service, "static", path);
+                mkdir(dirname(inflatePath), {
+                    recursive: true
+                }, (err) => {
+                });
+                await mkdirASync(dirname(inflatePath), {
+                    recursive: true
+                });
+                logger.log("writing [%s]", relative(cwd(), inflatePath));
+                const body = readFileSync(file.filePath);
+                await writeFileASync(inflatePath, body);
+                if (staticFileMap) {
+                    staticFileMap[file.filePath] = {
+                        contentType,
+                        filePath: file.filePath,
+                        previewMethod: "html",
+                        method: "GET",
+                        path: normalizePath(path),
+                        body: Buffer.from(body),
+                        inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+                    };
+                }
+            }
+            router.use(assertGlobalTampered);
+            router.get(path, async function (_req, res) {
+                await new Promise((resolve, reject) => {
+                    try {
+                        readFile(file.filePath, async (err, body) => {
+                            if (err) {
+                                reject(err);
+                            }
+                            else {
+                                try {
+                                    await res.asyncEnd({
+                                        status: 200,
+                                        headers: {
+                                            ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
+                                        },
+                                        body
+                                    });
+                                    resolve();
+                                }
+                                catch (e) {
+                                    reject(e);
+                                }
+                            }
+                        });
                     }
-                    else {
-                        try {
-                            await res.asyncEnd({
-                                status: 200,
-                                headers: {
-                                    ["Content-Type"]: contentType ? contentType : DEFAULT_CONTENT_TYPE
-                                },
-                                body
-                            });
-                            resolve();
-                        }
-                        catch (e) {
-                            reject(e);
-                        }
+                    catch (e) {
+                        reject(e);
                     }
                 });
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
+            });
+            resolve();
+        }
+        catch (e) {
+            reject(e);
+        }
     });
 }
-function createStaticRouterFromDirectory(service, logger, dir, inflateDir, routeFileMap, staticFileMap) {
+async function createStaticRouterFromDirectory(service, logger, dir, inflateDir, routeFileMap, staticFileMap, inflateParallel) {
     const router = new Router();
-    scanFiles(dir).forEach(file => {
-        createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap);
-    });
+    const maxParallel = inflateParallel ? inflateParallel : 1;
+    logger.debug("loading static directory with parallel [%s]", maxParallel);
+    let tR = [];
+    const files = scanFiles(dir);
+    for (const file of files) {
+        tR.push(await createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap));
+        if (tR.length >= maxParallel) {
+            await Promise.all(tR);
+            tR = [];
+        }
+    }
+    if (tR.length > 0) {
+        await Promise.all(tR);
+        tR = [];
+    }
     return router;
 }
-async function createRouterFromDirectory(server, hotreload, service, logger, dir, errors = [], routeFileMap = {}, staticFileMap = null, inflateDir, inflateSea) {
+async function createRouterFromDirectory(server, hotreload, service, logger, dir, errors = [], routeFileMap = {}, staticFileMap = null, inflateDir, inflateSea, inflateParallel) {
     const router = new Router();
+    const maxParallel = inflateParallel ? inflateParallel : 1;
+    server.logger.debug("loading http directory with parallel [%s]", maxParallel);
+    let tR = [];
     router.use(assertGlobalTampered);
-    for (const file of scanFiles(dir)) {
-        await new Promise(async (resolve) => {
+    const files = scanFiles(dir);
+    for (const file of files) {
+        tR.push(new Promise(async (resolve) => {
             try {
                 switch (file.ext) {
                     case ".jsx":
@@ -163,11 +191,11 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                     if (inflateDir && r.defaultInflatePath && inflateSea) {
                                         const rPath = r.defaultInflatePath;
                                         const inflatePath = join(inflateDir, service, "http", rPath + ".api.cjs");
-                                        mkdirSync(dirname(inflatePath), {
+                                        await mkdirASync(dirname(inflatePath), {
                                             recursive: true
                                         });
                                         logger.log("writing [%s]", relative(cwd(), inflatePath));
-                                        writeFileSync(inflatePath, inflatedCode);
+                                        await writeFileASync(inflatePath, inflatedCode);
                                     }
                                     router.use(assertGlobalTampered);
                                     router.use(module.handler, r.path, r.method, r.options);
@@ -190,7 +218,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             //if (r.method === "GET" || r.method === "get") {
                                             const rPath = r.inflatePath;
                                             const inflatePath = join(inflateDir, service, "static", rPath);
-                                            mkdirSync(dirname(inflatePath), {
+                                            await mkdirASync(dirname(inflatePath), {
                                                 recursive: true
                                             });
                                             if (existsSync(inflatePath) && statSync(inflatePath).isDirectory()) {
@@ -200,7 +228,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             const JSON_STATIC = await getJSON({ server }, null, newURL(r.path), module.apiOptions?.basePath, module.default);
                                             //const JSON = await getJSON({ server } as ServerRequest, null, newURL(r.path), module.apiOptions?.basePath, module.default);
                                             logger.log("writing [%s]", relative(cwd(), inflatePath));
-                                            writeFileSync(inflatePath, JSON_STATIC);
+                                            await writeFileASync(inflatePath, JSON_STATIC);
                                             //}
                                             if (staticFileMap && inflateSea) {
                                                 staticFileMap[file.filePath] = {
@@ -245,7 +273,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             //if (r.method === "GET" || r.method === "get") {
                                             const rPath = r.inflatePath;
                                             const inflatePath = join(inflateDir, service, "static", rPath);
-                                            mkdirSync(dirname(inflatePath), {
+                                            await mkdirASync(dirname(inflatePath), {
                                                 recursive: true
                                             });
                                             if (existsSync(inflatePath) && statSync(inflatePath).isDirectory()) {
@@ -255,7 +283,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             const toRender = typeof module.default === "function" ? module.default({ server }, null) : module.default;
                                             const HTML_STATIC = await getHTML(hotreload, { server }, null, newURL(r.path), module.apiOptions?.basePath, await toRender);
                                             logger.log("writing [%s]", relative(cwd(), inflatePath));
-                                            writeFileSync(inflatePath, HTML_STATIC);
+                                            await writeFileASync(inflatePath, HTML_STATIC);
                                             //}
                                             if (staticFileMap && inflateSea) {
                                                 staticFileMap[file.filePath + r.method + r.path] = {
@@ -309,11 +337,11 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                     };
                                     if (inflateDir) {
                                         const inflatePath = join(inflateDir, service, "static", path);
-                                        mkdirSync(dirname(inflatePath), {
+                                        await mkdirASync(dirname(inflatePath), {
                                             recursive: true
                                         });
                                         logger.log("writing [%s]", relative(cwd(), inflatePath));
-                                        writeFileSync(inflatePath, code);
+                                        await writeFileASync(inflatePath, code);
                                         if (staticFileMap && inflateSea) {
                                             staticFileMap[file.filePath] = {
                                                 contentType,
@@ -358,11 +386,11 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                 };
                                 if (inflateDir) {
                                     const inflatePath = join(inflateDir, service, "static", path);
-                                    mkdirSync(dirname(inflatePath), {
+                                    await mkdirASync(dirname(inflatePath), {
                                         recursive: true
                                     });
                                     logger.log("writing [%s]", relative(cwd(), inflatePath));
-                                    writeFileSync(inflatePath, code);
+                                    await writeFileASync(inflatePath, code);
                                     if (staticFileMap && inflateSea) {
                                         staticFileMap[file.filePath] = {
                                             contentType,
@@ -417,11 +445,11 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                     };
                                     if (inflateDir) {
                                         const inflatePath = join(inflateDir, service, "static", path);
-                                        mkdirSync(dirname(inflatePath), {
+                                        await mkdirASync(dirname(inflatePath), {
                                             recursive: true
                                         });
                                         logger.log("writing [%s]", relative(cwd(), inflatePath));
-                                        writeFileSync(inflatePath, code);
+                                        await writeFileASync(inflatePath, code);
                                         if (staticFileMap && inflateSea) {
                                             staticFileMap[file.filePath] = {
                                                 contentType,
@@ -474,11 +502,11 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                     };
                                     if (inflateDir) {
                                         const inflatePath = join(inflateDir, service, "static", path);
-                                        mkdirSync(dirname(inflatePath), {
+                                        await mkdirASync(dirname(inflatePath), {
                                             recursive: true
                                         });
                                         logger.log("writing [%s]", relative(cwd(), inflatePath));
-                                        writeFileSync(inflatePath, code);
+                                        await writeFileASync(inflatePath, code);
                                         if (staticFileMap && inflateSea) {
                                             staticFileMap[file.filePath] = {
                                                 contentType,
@@ -505,7 +533,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                 }
                             }
                         }
-                        createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap);
+                        await createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap);
                         return resolve();
                 }
             }
@@ -520,7 +548,15 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
             finally {
                 return resolve();
             }
-        });
+        }));
+        if (tR.length >= maxParallel) {
+            await Promise.all(tR);
+            tR = [];
+        }
+    }
+    if (tR.length > 0) {
+        await Promise.all(tR);
+        tR = [];
     }
     router.use(assertGlobalTampered);
     return {

package/build/esm/src/main.js

@@ -22,6 +22,7 @@ async function main(args) {
             browser: args.browser,
             logFile: args.logFile,
             hotreload: args.test ? false : args.hotreload,
+            watch: args.test ? false : args.watch,
             https: args.test ? false : args.https,
             serverOptions: args.serverOptions,
             httpRedirect: args.test ? undefined : args.httpsRedirect
@@ -29,7 +30,9 @@ async function main(args) {
         // check arguments
         if (args.generateDoc) {
             // --generate-doc
-            const inflated = await app.inflate();
+            const inflated = await app.inflate({
+                inflateParallel: args.inflateParallel
+            });
             await generateDocs(args, app.logger, inflated);
             process.exit(EXIT_CODES.NORMAL_EXIT);
         }
@@ -45,7 +48,9 @@ async function main(args) {
         }
         else if (args.test) {
             // --test
-            await app.inflate();
+            await app.inflate({
+                inflateParallel: args.inflateParallel
+            });
             await app.start();
             await testMain(app);
             await app.stop();
@@ -57,7 +62,8 @@ async function main(args) {
             // --compile
             await app.inflate({
                 inflateDir: args.inflateDir,
-                inflateSea: true
+                inflateSea: true,
+                inflateParallel: args.inflateParallel
             });
             await app.dbManager.closeAll();
             await app.webSocketManager.disconnectAll();
@@ -69,7 +75,8 @@ async function main(args) {
             // loadApp with inflateDir arg to inflate inflatable files
             await app.inflate({
                 inflateDir: args.inflateDir,
-                inflateSea: args.inflateSEA
+                inflateSea: args.inflateSEA,
+                inflateParallel: args.inflateParallel
             });
             await app.dbManager.closeAll();
             await app.webSocketManager.disconnectAll();
@@ -77,7 +84,9 @@ async function main(args) {
         }
         else {
             // server
-            await app.inflate();
+            await app.inflate({
+                inflateParallel: args.inflateParallel
+            });
             await app.start();
         }
     }

package/build/esm/src/services/app.d.ts

@@ -22,6 +22,7 @@ export interface MiqroOptions {
     browser?: string | boolean;
     logFile?: string | boolean;
     hotreload?: boolean;
+    watch?: boolean;
     serverOptions?: ServerOptions<any, any>;
     https?: boolean;
     httpRedirect?: number;
@@ -29,6 +30,7 @@ export interface MiqroOptions {
 export interface InflateOptions {
     inflateDir?: string;
     inflateSea?: boolean;
+    inflateParallel?: number;
 }
 export interface InflatedResult {
     router: Router;

package/build/esm/src/services/app.js

@@ -127,6 +127,7 @@ export class Miqro {
         });
         await app.inflate({
             inflateDir: miqroJSON.inflateDir ? String(miqroJSON.inflateDir) : undefined,
+            inflateParallel: miqroJSON.inflateParallel ? miqroJSON.inflateParallel : undefined,
             ...(inflate ? inflate : {}),
         });
         return app;
@@ -290,7 +291,8 @@ export class Miqro {
                 inflateDir: options?.inflateDir,
                 inflateSea: options?.inflateSea ? true : false,
                 //inflateTests: options?.inflateTests ? true : false,
-                hotreload: this.options?.hotreload ? true : false
+                hotreload: this.options?.hotreload ? true : false,
+                inflateParallel: options?.inflateParallel
             });
             wsConfigList.push(...serviceWSConfigList);
             router.use(serviceRouter);
@@ -398,7 +400,7 @@ export class Miqro {
             this.logger?.debug("\t\t==listening on [%s][%s]==", this.options.https ? "https" : "http", this.options.port);
         }
         await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, this.inflated.serverConfigMap, "start");
-        if (this.options.hotreload && (cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
+        if (this.options.watch && (cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
             this.watcher = await watchAndServer(this);
         }
         this.logger?.debug("\t\t==start done==");