miqro 7.0.10 → 7.2.0

package/src/inflate/setup-db.ts

@@ -1,6 +1,6 @@
 import { Logger } from "@miqro/core";
 import { Migration, migration } from "@miqro/query";
-import { importDBConfigModule, importMigrationModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { importDBConfigModule, ImportJSXFileOptions, importMigrationModule, InflateError, inflateJSX } from "../common/jsx.js";
 import { getDBConfigPath, getMigrationsPath, getServicePath } from "../common/paths.js";
 import { dirname, extname, relative, resolve } from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
@@ -11,15 +11,15 @@ export interface MigrationModule extends Migration, NamedMigration {
 
 }
 
-export async function inflateDBConfig(logger: Logger, service: string, dbConfigList: DBConfig[] | undefined, inflateDir: string | undefined | false, errors: InflateError[]) {
+export async function inflateDBConfig(logger: Logger, service: string, dbConfigList: DBConfig[] | undefined, inflateDir: string | undefined | false, options: ImportJSXFileOptions, errors: InflateError[]) {
   const servicePath = getServicePath(service);
   const dbConfigPath = getDBConfigPath(servicePath);
   if (dbConfigPath) {
     try {
       //logger.debug("loading DBConfig for service[%s]", service);
-      const config = await importDBConfigModule(dbConfigPath, logger);
+      const config = await importDBConfigModule(dbConfigPath, options, logger);
       if (config && dbConfigList && dbConfigList.filter(c => c.name === config.name).length > 0) {
-        throw new Error(`ws path [${config.name}] already defined! error from [${dbConfigPath}]`);
+        throw new Error(`db name [${config.name}] already defined! error from [${dbConfigPath}]`);
       } else if (config) {
         //logger.debug("DBConfig [%s] loaded from service [%s]", config.name, service);
         if (dbConfigList) {
@@ -62,7 +62,7 @@ export async function inflateDBConfig(logger: Logger, service: string, dbConfigL
   return false;
 }
 
-export async function inflateDBMigrations(logger: Logger, service: string, dbName: string, inflateDir: string | undefined | false, errors: InflateError[]) {
+export async function inflateDBMigrations(logger: Logger, service: string, dbName: string, inflateDir: string | undefined | false, options: ImportJSXFileOptions, errors: InflateError[]) {
   const servicePath = getServicePath(service);
   const migrationsFolderPath = getMigrationsPath(servicePath);
   if (migrationsFolderPath) {
@@ -76,7 +76,7 @@ export async function inflateDBMigrations(logger: Logger, service: string, dbNam
     for (const migrationName of serviceMigrations) {
       const migrationPath = resolve(migrationsFolderPath, migrationName);
       try {
-        const migrationModule = await importMigrationModule(migrationPath);
+        const migrationModule = await importMigrationModule(migrationPath, options, logger);
         migrationModules.push({
           name: migrationName,
           service,

package/src/inflate/setup-error.ts

@@ -1,16 +1,16 @@
 import { Logger, Router } from "@miqro/core";
-import { importErrorConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { importErrorConfigModule, ImportJSXFileOptions, InflateError, inflateJSX } from "../common/jsx.js";
 import { getErrorConfigPath } from "../common/paths.js";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { cwd } from "node:process";
 
-export async function setupError(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]): Promise<void> {
+export async function setupError(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, options: ImportJSXFileOptions, errors: InflateError[]): Promise<void> {
   const errorPath = getErrorConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
 
   if (errorPath) {
     try {
-      const errorModule = await importErrorConfigModule(errorPath, logger);
+      const errorModule = await importErrorConfigModule(errorPath, options, logger);
       logger.debug("setting up error handling from [%s]", join(service, basename(errorPath)));
       if (errorModule && errorModule.catch) {
         for (const m of errorModule.catch) {

package/src/inflate/setup-http.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdir, readFile, readFileSync, readdirSync, statSync } from
 import { dirname, join, relative, resolve as pathResolve } from "node:path";
 
 import { CONTENT_TYPE_MAP, DEFAULT_CONTENT_TYPE } from "../common/content-type.js";
-import { InflateError, importHTMLModule, importAPIRoute, inflateJSX, importJSONModule, JSONModuleValue, jsx2HTML } from "../common/jsx.js";
+import { InflateError, importHTMLModule, importAPIRoute, inflateJSX, importJSONModule, JSONModuleValue, jsx2HTML, ImportJSXFileOptions } from "../common/jsx.js";
 import { createNodeRuntime } from "@miqro/jsx-node";
 import { getHotReloadScript } from "../services/hot-reload.js";
 import { RuntimeURL } from "@miqro/jsx";
@@ -45,27 +45,27 @@ export interface StaticFileMap {
   }
 }
 
-export async function setupHTTPRouter(server: ServerInterface, logger: Logger, hotreload: boolean, servicePath: string, service: string, routeFileMap: RouteFileMap, staticFileMap: StaticFileMap | null, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[], inflateParallel?: number) {
+export async function setupHTTPRouter(importOptions: ImportJSXFileOptions, inflateOptions: InflateJSXFileOptions, server: ServerInterface, logger: Logger, hotreload: boolean, servicePath: string, service: string, routeFileMap: RouteFileMap, staticFileMap: StaticFileMap | null, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[], inflateParallel?: number) {
   const mainRouter = new Router();
   const apiRouterPath = getHTTPRouterPath(servicePath); //resolve(process.cwd(), service, "http");
   let middlewareConfig: MiddlewareConfig | null = null;
 
-  await setupError(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
+  await setupError(logger, servicePath, service, mainRouter, inflateDir, inflateSea, importOptions, errors);
 
-  await setupCORS(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
-  await setupAUTH(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
-  middlewareConfig = await setupMiddleware(logger, servicePath, service, mainRouter, inflateDir, inflateSea, errors);
+  await setupCORS(logger, servicePath, service, mainRouter, inflateDir, inflateSea, importOptions, errors);
+  await setupAUTH(logger, servicePath, service, mainRouter, inflateDir, inflateSea, importOptions, errors);
+  middlewareConfig = await setupMiddleware(logger, servicePath, service, mainRouter, inflateDir, inflateSea, importOptions, 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, inflateParallel);
+    const { router: httpRouter } = await createRouterFromDirectory(importOptions, inflateOptions, 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 = await createStaticRouterFromDirectory(service, logger, staticFilesPath, inflateDir, routeFileMap, staticFileMap, inflateParallel);
+    const staticRouter = await createStaticRouterFromDirectory(inflateOptions, service, logger, staticFilesPath, inflateDir, routeFileMap, staticFileMap, inflateParallel);
     mainRouter.use(staticRouter);
   }
 
@@ -78,7 +78,7 @@ export async function setupHTTPRouter(server: ServerInterface, logger: Logger, h
   return mainRouter;
 }
 
-async function createStaticRoute(service: string, logger: Logger, router: Router, dir: string, file: ScannedFile, inflateDir?: string | undefined | false, routeFileMap?: RouteFileMap, staticFileMap?: StaticFileMap) {
+async function createStaticRoute(inflateJSXOptions: InflateJSXFileOptions, service: string, logger: Logger, router: Router, dir: string, file: ScannedFile, inflateDir?: string | undefined | false, routeFileMap?: RouteFileMap, staticFileMap?: StaticFileMap) {
   return new Promise<void>(async (resolve, reject) => {
     try {
       logger.trace("creating static route for [%s]", file.filePath);
@@ -100,8 +100,8 @@ async function createStaticRoute(service: string, logger: Logger, router: Router
         previewMethod: "html"
       };
 
-      if (inflateDir) {
-        const inflatePath = join(inflateDir, service, "static", path);
+      if (inflateDir && (inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined)) {
+        const inflatePath = join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path);
         mkdir(dirname(inflatePath), {
           recursive: true
         }, (err) => {
@@ -121,7 +121,7 @@ async function createStaticRoute(service: string, logger: Logger, router: Router
             method: "GET",
             path: normalizePath(path),
             body: Buffer.from(body),
-            inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+            inflatePath: inflateDir ? join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path) : undefined
           }
         }
       }
@@ -162,14 +162,14 @@ async function createStaticRoute(service: string, logger: Logger, router: Router
   });
 }
 
-async function createStaticRouterFromDirectory(service: string, logger: Logger, dir: string, inflateDir: string | false | undefined, routeFileMap: RouteFileMap | undefined, staticFileMap: StaticFileMap | null, inflateParallel?: number): Promise<Router> {
+async function createStaticRouterFromDirectory(inflateOptions: InflateJSXFileOptions, service: string, logger: Logger, dir: string, inflateDir: string | false | undefined, routeFileMap: RouteFileMap | undefined, staticFileMap: StaticFileMap | null, inflateParallel?: number): Promise<Router> {
   const router = new Router();
   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));
+    tR.push(await createStaticRoute(inflateOptions, service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap));
     if (tR.length >= maxParallel) {
       await Promise.all(tR);
       tR = [];
@@ -182,7 +182,13 @@ async function createStaticRouterFromDirectory(service: string, logger: Logger,
   return router;
 }
 
-async function createRouterFromDirectory(server: ServerInterface, hotreload: boolean, service: string, logger: Logger, dir: string, errors: InflateError[] = [], routeFileMap: RouteFileMap = {}, staticFileMap: StaticFileMap | null = null, inflateDir: string | undefined | false, inflateSea: boolean, inflateParallel?: number): Promise<{
+interface InflateJSXFileOptions {
+  noMinify?: boolean;
+  inflateOnlyAssets?: boolean;
+  inflateFlat?: boolean;
+}
+
+async function createRouterFromDirectory(importOptions: ImportJSXFileOptions, inflateJSXOptions: InflateJSXFileOptions, server: ServerInterface, hotreload: boolean, service: string, logger: Logger, dir: string, errors: InflateError[] = [], routeFileMap: RouteFileMap = {}, staticFileMap: StaticFileMap | null = null, inflateDir: string | undefined | false, inflateSea: boolean, inflateParallel?: number): Promise<{
   router: Router;
   errors: InflateError[];
   routeFileMap: RouteFileMap;
@@ -210,7 +216,12 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                 return resolve();
               case ".api": {
 
-                const module = await importAPIRoute(file.filePath, logger);
+                if (inflateJSXOptions.inflateOnlyAssets) {
+                  logger.warn("ignoring [%s]", file.filePath);
+                  return resolve();
+                }
+
+                const module = await importAPIRoute(file.filePath, importOptions, logger);
 
                 const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName, module);
 
@@ -221,7 +232,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                   previewMethod: "api"
                 };
 
-                const inflatedCode = inflateDir ? await inflateJSX(file.filePath, {
+                const inflatedCode = inflateDir && inflateSea && (!inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined) ? await inflateJSX(file.filePath, {
                   // embemedJSX: false,
                   minify: false,
                   useExport: true,
@@ -243,7 +254,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
 
                   if (inflateDir && r.defaultInflatePath && inflateSea) {
                     const rPath = r.defaultInflatePath;
-                    const inflatePath = join(inflateDir, service, "http", rPath + ".api.cjs");
+                    const inflatePath = join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "http", rPath + ".api.cjs");
                     await mkdirASync(dirname(inflatePath), {
                       recursive: true
                     });
@@ -258,7 +269,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                 return resolve();
               }
               case ".json": {
-                const module = await importJSONModule(file.filePath, logger);
+                const module = await importJSONModule(file.filePath, importOptions, logger);
                 const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName + ".json", module.apiOptions as Partial<APIRoute>);
 
                 routeFileMap[file.filePath] = {
@@ -274,12 +285,12 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
 
 
 
-                  if (inflateDir) {
+                  if (inflateDir && (inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined)) {
 
                     if (r.inflatePath) {
                       //if (r.method === "GET" || r.method === "get") {
                       const rPath = r.inflatePath;
-                      const inflatePath = join(inflateDir, service, "static", rPath);
+                      const inflatePath = join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", rPath);
                       await mkdirASync(dirname(inflatePath), {
                         recursive: true
                       });
@@ -301,7 +312,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                           previewMethod: "html",
                           path: r.path,
                           body: Buffer.from(JSON_STATIC),
-                          inflatePath: inflateDir ? join(inflateDir, service, "static", r.inflatePath) : undefined
+                          inflatePath: inflateDir ? join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", r.inflatePath) : undefined
                         }
                       }
                     }
@@ -326,7 +337,12 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
               }
               case ".html": {
 
-                const module = await importHTMLModule(file.filePath, logger);
+                if (inflateJSXOptions.inflateOnlyAssets) {
+                  logger.warn("ignoring [%s]", file.filePath);
+                  return resolve();
+                }
+
+                const module = await importHTMLModule(file.filePath, importOptions, logger);
 
                 const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName + ".html", module.apiOptions as Partial<APIRoute>);
 
@@ -341,12 +357,12 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
 
                   const contentType = CONTENT_TYPE_MAP[".html"] ? CONTENT_TYPE_MAP[".html"] : DEFAULT_CONTENT_TYPE;
 
-                  if (inflateDir) {
+                  if (inflateDir && (!inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined)) {
 
                     if (r.inflatePath) {
                       //if (r.method === "GET" || r.method === "get") {
                       const rPath = r.inflatePath;
-                      const inflatePath = join(inflateDir, service, "static", rPath);
+                      const inflatePath = join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", rPath);
                       await mkdirASync(dirname(inflatePath), {
                         recursive: true
                       });
@@ -362,7 +378,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                       //}
 
 
-                      if (staticFileMap && inflateSea) {
+                      if (staticFileMap && inflateSea && (!inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined)) {
                         staticFileMap[file.filePath + r.method + r.path] = {
                           filePath: file.filePath,
                           contentType,
@@ -370,7 +386,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                           previewMethod: "html",
                           path: r.path,
                           body: Buffer.from(HTML_STATIC),
-                          inflatePath: inflateDir ? join(inflateDir, service, "static", r.inflatePath) : undefined
+                          inflatePath: inflateDir ? join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", r.inflatePath) : undefined
                         }
                       }
                     }
@@ -397,7 +413,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
               default: {
                 // allow fall-through when extension is .js and .ts because is a static route without embemedJSX
                 if (file.ext !== ".js" && file.ext !== ".ts") {
-                  const code = await inflateJSX(file.filePath, {
+                  const code = inflateJSXOptions.noMinify ? readFileSync(file.filePath).toString() : await inflateJSX(file.filePath, {
                     // embemedJSX: true,
                     minify: file.subExt === ".min" ? true : false,
                     useExport: true,
@@ -416,8 +432,8 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     previewMethod: "html"
                   };
 
-                  if (inflateDir) {
-                    const inflatePath = join(inflateDir, service, "static", path);
+                  if (inflateDir && (inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined)) {
+                    const inflatePath = join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path);
                     await mkdirASync(dirname(inflatePath), {
                       recursive: true
                     });
@@ -433,7 +449,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                         previewMethod: "html",
                         path,
                         body: Buffer.from(code),
-                        inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+                        inflatePath: inflateDir ? join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path) : undefined
                       }
                     }
                   }
@@ -469,8 +485,8 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                   previewMethod: "html"
                 };
 
-                if (inflateDir) {
-                  const inflatePath = join(inflateDir, service, "static", path);
+                if (inflateDir && (inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined)) {
+                  const inflatePath = join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path);
                   await mkdirASync(dirname(inflatePath), {
                     recursive: true
                   });
@@ -484,7 +500,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                       previewMethod: "html",
                       path,
                       body: Buffer.from(code),
-                      inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+                      inflatePath: inflateDir ? join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path) : undefined
                     }
                   }
                 }
@@ -512,7 +528,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                 }
                 case ".bundle":
                 case ".min": {
-                  const code = await inflateJSX(file.filePath, {
+                  const code = inflateJSXOptions.noMinify ? readFileSync(file.filePath).toString() : await inflateJSX(file.filePath, {
                     // embemedJSX: false,
                     minify: file.subExt === ".min" ? true : false,
                     useExport: true,
@@ -530,8 +546,8 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     previewMethod: "html"
                   };
 
-                  if (inflateDir) {
-                    const inflatePath = join(inflateDir, service, "static", path);
+                  if (inflateDir && (inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined)) {
+                    const inflatePath = join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path);
                     await mkdirASync(dirname(inflatePath), {
                       recursive: true
                     });
@@ -545,7 +561,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                         previewMethod: "html",
                         path,
                         body: Buffer.from(code),
-                        inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+                        inflatePath: inflateDir ? join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path) : undefined
                       }
                     }
                   }
@@ -588,8 +604,8 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                     previewMethod: "html"
                   };
 
-                  if (inflateDir) {
-                    const inflatePath = join(inflateDir, service, "static", path);
+                  if (inflateDir && (inflateJSXOptions.inflateOnlyAssets || inflateJSXOptions.inflateOnlyAssets === undefined)) {
+                    const inflatePath = join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path);
                     await mkdirASync(dirname(inflatePath), {
                       recursive: true
                     });
@@ -603,7 +619,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                         previewMethod: "html",
                         path,
                         body: Buffer.from(code),
-                        inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+                        inflatePath: inflateDir ? join(inflateDir, !inflateJSXOptions.inflateFlat ? service : "", "static", path) : undefined
                       }
                     }
                   }
@@ -622,7 +638,7 @@ async function createRouterFromDirectory(server: ServerInterface, hotreload: boo
                 }
               }
             }
-            await createStaticRoute(service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap);
+            await createStaticRoute(inflateJSXOptions, service, logger, router, dir, file, inflateDir, routeFileMap, staticFileMap);
             return resolve();
 
         }
@@ -684,16 +700,16 @@ export function scanFiles(path: string, ret: ScannedFile[] = []): ScannedFile[]
 
 
 function getHTML(hotreload: boolean, req: ServerRequest, res: Response | null, url: RuntimeURL, basePath: string | undefined, out: JSX.Element): string {
-  let HTML = `<!DOCTYPE html>\n${jsx2HTML(out, createNodeRuntime({
+  let HTML = `<!DOCTYPE html>\n${hotreload ? `${getHotReloadScript()}\n` : ""}${jsx2HTML(out, createNodeRuntime({
     url,
     basePath
   }))}`;
 
   //console.log("GET_HTML[%s] [%o]", HTML, out);
 
-  if (hotreload) {
+  /*if (hotreload) {
     HTML += getHotReloadScript()
-  }
+  }*/
   return HTML;
 }
 

package/src/inflate/setup-log.ts

@@ -1,5 +1,5 @@
 import { Logger } from "@miqro/core";
-import { importLogConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { ImportJSXFileOptions, importLogConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
 import { getLogConfigPath } from "../common/paths.js";
 import { dirname, relative, resolve } from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
@@ -10,13 +10,13 @@ export interface LogConfigMap {
   [service: string]: LogConfig | undefined;
 }
 
-export async function setupLogConfig(logger: Logger, servicePath: string, service: string, logConfigMap: LogConfigMap, inflateDir: string | undefined | false, errors: InflateError[]) {
+export async function setupLogConfig(logger: Logger, servicePath: string, service: string, logConfigMap: LogConfigMap, inflateDir: string | undefined | false, options: ImportJSXFileOptions, errors: InflateError[]) {
   const logPath = getLogConfigPath(servicePath); // resolve(process.cwd(), service, "server.ts");
   if (logPath) {
     try {
       //logger.debug("setting up server config from [%s]", join(service, basename(serverPath)));
 
-      const logConfig = await importLogConfigModule(logPath, logger);
+      const logConfig = await importLogConfigModule(logPath, options, logger);
       logConfigMap[service] = logConfig;
 
       if (inflateDir) {

package/src/inflate/setup-middleware.ts

@@ -1,17 +1,17 @@
 import { Logger, Router } from "@miqro/core";
-import { importMiddlewareConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { ImportJSXFileOptions, importMiddlewareConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
 import { getMiddlewareConfigPath } from "../common/paths.js";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { cwd } from "node:process";
 import { MiddlewareConfig } from "../types.js";
 
-export async function setupMiddleware(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, errors: InflateError[]): Promise<MiddlewareConfig | null> {
+export async function setupMiddleware(logger: Logger, servicePath: string, service: string, mainRouter: Router, inflateDir: string | undefined | false, inflateSea: boolean, options: ImportJSXFileOptions, errors: InflateError[]): Promise<MiddlewareConfig | null> {
   const middlewarePath = getMiddlewareConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
 
   if (middlewarePath) {
     try {
-      const middewareModule = await importMiddlewareConfigModule(middlewarePath, logger);
+      const middewareModule = await importMiddlewareConfigModule(middlewarePath, options, logger);
       logger.debug("setting up middleware from [%s]", join(service, basename(middlewarePath)));
       if (middewareModule && middewareModule.middleware) {
         for (const m of middewareModule.middleware) {

package/src/inflate/setup-server-config.ts

@@ -3,7 +3,7 @@ import { Logger } from "@miqro/core";
 import { dirname, relative, resolve } from "node:path";
 import { cwd } from "node:process";
 
-import { importServerConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { ImportJSXFileOptions, importServerConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
 import { getServerConfigPath } from "../common/paths.js";
 import { ServerConfig } from "../types.js";
 
@@ -11,14 +11,14 @@ export interface ServerConfigMap {
   [service: string]: ServerConfig | undefined;
 }
 
-export async function setupServerConfig(logger: Logger, servicePath: string, service: string, serverConfigMap: ServerConfigMap, inflateDir: string | undefined | false, errors: InflateError[]) {
+export async function setupServerConfig(logger: Logger, servicePath: string, service: string, serverConfigMap: ServerConfigMap, inflateDir: string | undefined | false, errors: InflateError[], options: ImportJSXFileOptions) {
 
   const serverPath = getServerConfigPath(servicePath); // resolve(process.cwd(), service, "server.ts");
   if (serverPath) {
     try {
       //logger.debug("setting up server config from [%s]", join(service, basename(serverPath)));
       
-      const serverConfig = await importServerConfigModule(serverPath, logger);
+      const serverConfig = await importServerConfigModule(serverPath, options, logger);
       serverConfigMap[service] = serverConfig;
 
 

package/src/inflate/setup-test.ts

@@ -1,9 +1,9 @@
-import { importJSXFile } from "../common/jsx.js";
+import { importJSXFile, ImportJSXFileOptions } from "../common/jsx.js";
 import { Logger } from "@miqro/core";
 import { scanFiles } from "./setup-http.js";
 import { resolve } from "node:path";
 
-export async function setupTests(logger: Logger, servicePath: string) {
+export async function setupTests(logger: Logger, servicePath: string, options: ImportJSXFileOptions) {
   logger.debug("setting up tests from [%s]", servicePath);
   const files = scanFiles(resolve(servicePath));
   await Promise.allSettled(files.map((file) => {
@@ -14,7 +14,7 @@ export async function setupTests(logger: Logger, servicePath: string) {
       case ".tsx": {
         switch (file.subExt) {
           case ".test":
-            return importJSXFile(file.filePath, logger);
+            return importJSXFile(file.filePath, options, logger);
         }
       }
     }

package/src/inflate/setup-ws.ts

@@ -3,17 +3,17 @@ import { dirname, join, relative, resolve } from "node:path";
 import { cwd } from "node:process";
 import { mkdirSync, writeFileSync } from "node:fs";
 
-import { importWSConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { ImportJSXFileOptions, importWSConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
 import { getWSConfigPath } from "../common/paths.js";
 import { WSConfig } from "../types.js";
 
-export async function inflateWSConfig(logger: Logger, servicePath: string, service: string, wsConfigList: WSConfig[] | undefined, inflateDir: string | undefined | false, errors: InflateError[]): Promise<void> {
+export async function inflateWSConfig(logger: Logger, servicePath: string, service: string, wsConfigList: WSConfig[] | undefined, inflateDir: string | undefined | false, errors: InflateError[], options: ImportJSXFileOptions): Promise<void> {
   const wsPath = getWSConfigPath(servicePath); // resolve(process.cwd(), service, "ws.ts");
 
   if (wsPath) {
     try {
       logger.debug("importing websocket socket for service [%s]", service);
-      const wsConfig = await importWSConfigModule(wsPath, logger);
+      const wsConfig = await importWSConfigModule(wsPath, options, logger);
       if (wsConfig && wsConfigList.filter(c => c.path === wsConfig.path).length > 0) {
         throw new Error(`ws path [${wsConfig.path}] already defined! from [${wsPath}]`);
       } else if (wsConfigList) {

package/src/inflate/setup.doc.ts

@@ -1,5 +1,5 @@
 import { Logger, Router } from "@miqro/core";
-import { importDocConfigModule, InflateError, inflateJSX } from "../common/jsx.js";
+import { importDocConfigModule, ImportJSXFileOptions, InflateError } from "../common/jsx.js";
 import { getDocConfigPath } from "../common/paths.js";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
@@ -8,12 +8,12 @@ import { getDocOutput } from "../bin/generate-doc.js";
 import { RouteFileMap, StaticFileMap } from "./setup-http.js";
 import { CONTENT_TYPE_MAP } from "../common/content-type.js";
 
-export async function setupDoc(logger: Logger, servicePath: string, service: string, mainRouter: Router, fileMap: RouteFileMap, staticFileMap: StaticFileMap, inflateDir: string | undefined | false, errors: InflateError[]) {
+export async function setupDoc(logger: Logger, servicePath: string, service: string, mainRouter: Router, fileMap: RouteFileMap, staticFileMap: StaticFileMap, inflateDir: string | undefined | false, errors: InflateError[], options: ImportJSXFileOptions, inflateFlat: boolean) {
   const docPath = getDocConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
 
   if (docPath) {
     try {
-      const docModule = await importDocConfigModule(docPath, logger);
+      const docModule = await importDocConfigModule(docPath, options, logger);
       logger.debug("setting up error handling from [%s]", join(service, basename(docPath)));
       if (docModule && docModule.publish) {
         const paths = Object.keys(docModule.publish);
@@ -47,7 +47,7 @@ export async function setupDoc(logger: Logger, servicePath: string, service: str
           });
 
           if (inflateDir) {
-            const inflatePath = join(inflateDir, service, "static", path);
+            const inflatePath = join(inflateDir, !inflateFlat ? service : "", "static", path);
             mkdirSync(dirname(inflatePath), {
               recursive: true
             });
@@ -72,7 +72,7 @@ export async function setupDoc(logger: Logger, servicePath: string, service: str
                 method: "GET",
                 path,
                 body: Buffer.from(body),
-                inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+                inflatePath: inflateDir ? join(inflateDir, !inflateFlat ? service : "", "static", path) : undefined
               }
             }
           }

package/src/main.ts

@@ -26,7 +26,9 @@ async function main(args: Arguments) {
       watch: args.test ? false : args.watch,
       https: args.test ? false : args.https,
       serverOptions: args.serverOptions,
-      httpRedirect: args.test ? undefined : args.httpsRedirect
+      httpRedirect: args.test ? undefined : args.httpsRedirect,
+      noBuild: args.noBuild,
+      noMinify: args.noMinify
     });
     // check arguments
     if (args.generateDoc) {
@@ -51,7 +53,9 @@ async function main(args: Arguments) {
         inflateParallel: args.inflateParallel
       });
       await app.start();
-      await testMain(app);
+      await testMain(app, {
+        noBuild: args.noBuild
+      });
       await app.stop();
       await app.dbManager.closeAll();
       await app.webSocketManager.disconnectAll();
@@ -71,6 +75,8 @@ async function main(args: Arguments) {
       // --inflate and --inflate-sea
       // loadApp with inflateDir arg to inflate inflatable files
       await app.inflate({
+        inflateOnlyAssets: args.inflateOnlyAssets,
+        inflateFlat: args.inflateFlat,      
         inflateDir: args.inflateDir,
         inflateSea: args.inflateSEA,
         inflateParallel: args.inflateParallel