miqro 7.1.0 → 7.2.1

package/src/services/app.ts

@@ -4,8 +4,8 @@ import { migration } from "@miqro/query";
 import { WebSocketManager } from "./utils/websocketmanager.js";
 import { DBManager } from "./utils/db-manager.js";
 import { inflateApp } from "../inflate/inflate.js";
-import { InflateError } from "../common/jsx.js";
-import { DBConfig, MigrateOptions, ServerInterface, ServerRequest, WSConfig } from "../types.js";
+import { ImportJSXFileOptions, InflateError } from "../common/jsx.js";
+import { DBConfig, MigrateOptions, ServerInterface, ServerRequest, ServerResponse, WSConfig } from "../types.js";
 import { RouteFileMap } from "../inflate/setup-http.js";
 import { ServerConfigMap, setupServerConfig } from "../inflate/setup-server-config.js";
 import { BASEEDITOR_PATH, LOG_SOCKET_PATH, LOG_WRITE_EVENT } from "../../editor/common/constants.js";
@@ -14,7 +14,7 @@ import editorServerConfig from "../../editor/server.js";
 
 import { ClusterCache } from "./utils/cluster-cache.js";
 import { createEditorRouter } from "./editor.js";
-import { EDITOR_CONFIG_KEY, HOT_RELOAD_PATH } from "../common/constants.js";
+import { EDITOR_CONFIG_KEY, HOT_RELOAD_PATH, HOT_RELOAD_SCRIPT_PATH } from "../common/constants.js";
 import { watchAndServer } from "../common/watch.js";
 import { LocalCache } from "./utils/cache.js";
 // import { initGlobals } from "./globals.js";
@@ -32,8 +32,9 @@ import { createAdminInterface } from "./utils/admin-interface.js";
 import { dirname, join, relative, resolve } from "node:path";
 import { cwd } from "node:process";
 import { ServerOptions } from "node:https";
+import { HOT_RELOAD_JS_SCRIPT } from "./hot-reload.js";
 
-export interface MiqroOptions {
+export interface MiqroOptions extends ImportJSXFileOptions {
   name: string;
   logger?: Logger;
   logProviderOptions?: LogProviderOptions;
@@ -47,12 +48,15 @@ export interface MiqroOptions {
   serverOptions?: ServerOptions<any, any>;
   https?: boolean;
   httpRedirect?: number;
+  noMinify?: boolean;
 }
 
 export interface InflateOptions {
   inflateDir?: string;
   inflateSea?: boolean;
+  inflateOnlyAssets?: boolean;
   inflateParallel?: number;
+  inflateFlat?: boolean;
 }
 
 export interface InflatedResult {
@@ -101,8 +105,10 @@ export class Miqro {
 
   constructor(options?: Partial<MiqroOptions>) {
     this.options = {
+      noMinify: false,
       editor: false,
       name: "server",
+      noBuild: false,
       port: getPORT(),
       services: [],
       ...(options ? options : {})
@@ -127,8 +133,8 @@ export class Miqro {
           msg &&
           msg.action &&
           msg.type === MiqroApplicationMessageType &&
-          msg.target === this.options.name,
-          msg.fromPID !== process.pid,
+          msg.target === this.options.name &&
+          msg.fromPID !== process.pid &&
           (msg.action === "reload" || msg.action === "restart")) {
           this.logger?.debug("remote server message from [%s] [%s]", msg.fromPID, msg.action);
           switch (msg.action) {
@@ -139,7 +145,7 @@ export class Miqro {
               await this.restart(true);
               break;
             default:
-              throw new Error("unsopported message for ApplicaitonServer");
+              throw new Error("unsupported message for ApplicationServer");
           }
         }
       } catch (e) {
@@ -187,6 +193,7 @@ export class Miqro {
       name: miqroJSON.name ? miqroJSON.name : undefined,
       port: miqroJSON.port ? String(miqroJSON.port) : undefined,
       services: miqroJSON.services ? miqroJSON.services.map(s => join(relative(cwd(), miqroJSONDir), s)) : undefined,
+      noBuild: miqroJSON.noBuild !== undefined ? miqroJSON.noBuild : false,
       ...(options ? options : {}),
     });
     await app.inflate({
@@ -244,7 +251,7 @@ export class Miqro {
     const errors: InflateError[] = [];
     for (const service of this.options.services) {
       const servicePath = getServicePath(service);
-      await setupServerConfig(this.logger, servicePath, service, serverConfigMap, options && options.inflateSea ? options.inflateDir : undefined, errors);
+      await setupServerConfig(this.logger, servicePath, service, serverConfigMap, options && options.inflateSea ? options.inflateDir : undefined, errors, this.options);
     }
     return {
       serverConfigMap,
@@ -267,9 +274,9 @@ export class Miqro {
     }[] = [];
     const dbConfigListALL: DBConfig[] = [];
     for (const service of this.options.services) {
-      const dbConfig = await inflateDBConfig(this.logger, service, dbConfigListALL, options?.inflateSea ? options?.inflateDir : undefined, errors);
+      const dbConfig = await inflateDBConfig(this.logger, service, dbConfigListALL, options?.inflateSea ? options?.inflateDir : undefined, this.options, errors);
       if (dbConfig) {
-        const migrations = await inflateDBMigrations(this.logger, service, dbConfig.name, options?.inflateSea ? options?.inflateDir : undefined, errors);
+        const migrations = await inflateDBMigrations(this.logger, service, dbConfig.name, options?.inflateSea ? options?.inflateDir : undefined, this.options, errors);
         dbList.push({
           service,
           dbConfig,
@@ -330,7 +337,7 @@ export class Miqro {
       // block others from inflating while inflateApp is running
       this.inflated = undefined;
       // init assets only once for all ApplicationServer's
-      if (Miqro.initAssetsPromise === null) {
+      if (Miqro.initAssetsPromise === null && (this.options.noBuild === false || this.options.noMinify === false)) {
         // init globals only once for all inflations
         // initGlobals();
         Miqro.initAssetsPromise = initAssets(this.logger);
@@ -363,6 +370,10 @@ export class Miqro {
         wsConfigList.push({
           path: HOT_RELOAD_PATH
         });
+        this.logger?.debug("setting up hot-reload script on [%s]", HOT_RELOAD_SCRIPT_PATH);
+        const hotReloadScriptRouter = new Router();
+        hotReloadScriptRouter.get(HOT_RELOAD_SCRIPT_PATH, async (req, res) => res.js(HOT_RELOAD_JS_SCRIPT));
+        router.use(hotReloadScriptRouter);
       }
 
       await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, serverConfigMap, "preload");
@@ -378,7 +389,11 @@ export class Miqro {
         inflateSea: options?.inflateSea ? true : false,
         //inflateTests: options?.inflateTests ? true : false,
         hotreload: this.options?.hotreload ? true : false,
-        inflateParallel: options?.inflateParallel
+        inflateParallel: options?.inflateParallel,
+        noBuild: this.options?.noBuild,
+        noMinify: this.options?.noMinify,
+        inflateOnlyAssets: options?.inflateOnlyAssets,
+        inflateFlat: options?.inflateFlat
       });
 
       wsConfigList.push(...serviceWSConfigList);

package/src/services/hot-reload.ts

@@ -1,9 +1,8 @@
 //import { checkEnvVariable } from "@miqro/core";
 
-import { HOT_RELOAD_PATH } from "../common/constants.js";
+import { HOT_RELOAD_PATH, HOT_RELOAD_SCRIPT_PATH } from "../common/constants.js";
 
-export function getHotReloadScript() {
-  const HOT_RELOAD_JS_SCRIPT = `
+export const HOT_RELOAD_JS_SCRIPT = `
 // Create WebSocket connection.
 
 function getSocket() {
@@ -13,13 +12,14 @@ function getSocket() {
 const socket = getSocket();
 
 let timeout;
+let reloadtimeout;
 
 function tryConnection() {
     try {
         const newSocket = getSocket();
         newSocket.addEventListener("open", (event) => {
             console.log("reloading");
-            setTimeout(()=>{
+            reloadtimeout = setTimeout(()=>{
               window.location.reload();
             }, 500);
             
@@ -37,13 +37,17 @@ function tryConnection() {
 // Connection closed
 socket.addEventListener("close", (event) => {
     clearTimeout(timeout);
+    clearTimeout(reloadtimeout);
     timeout = setTimeout(tryConnection, 500);
 });
 
 socket.addEventListener("error", (err) => {
+    clearTimeout(reloadtimeout);
     console.error(err);
 });`;
-  return `<script>${HOT_RELOAD_JS_SCRIPT}</script>`;
+
+export function getHotReloadScript() {
+  return `<script src="${HOT_RELOAD_SCRIPT_PATH}"></script>`;
 }
 
 /*export function isHotReloadEnabled() {

package/src/services/migrations.ts

@@ -5,16 +5,16 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { cwd } from "node:process";
 
 import { getMigrationsPath } from "../common/paths.js";
-import { importJSXFile, inflateJSX } from "../common/jsx.js";
+import { importJSXFile, ImportJSXFileOptions, inflateJSX } from "../common/jsx.js";
 
-export async function runMigrations(logger: Logger | undefined, db: Database | null, servicePath: string, service: string, inflateDir: string | undefined | false, migrations: string[]) {
+export async function runMigrations(logger: Logger | undefined, db: Database | null, servicePath: string, service: string, inflateDir: string | undefined | false, migrations: string[], options: ImportJSXFileOptions) {
   const migrationsFolderPath = getMigrationsPath(servicePath);
   if (migrationsFolderPath) {
     logger?.debug("running migrations from [%s]", service);
     if (!db) {
       throw new Error("cannot run migrations with the database disabled!");
     }
-    const serviceMigrations = await migration.up.folder(db as any, migrationsFolderPath, logger as DatabaseLogger, (inFile: string) => importJSXFile(inFile, logger));
+    const serviceMigrations = await migration.up.folder(db as any, migrationsFolderPath, logger as DatabaseLogger, (inFile: string) => importJSXFile(inFile, options, logger));
     migrations.push(...serviceMigrations);
 
     if (inflateDir) {
@@ -37,14 +37,14 @@ export async function runMigrations(logger: Logger | undefined, db: Database | n
   return migrations;
 }
 
-export async function runMigrationsDown(logger: Logger | Console | undefined, db: Database | null, servicePath: string, service: string, inflateDir: string | undefined, migrations: string[]) {
+export async function runMigrationsDown(logger: Logger | Console | undefined, db: Database | null, servicePath: string, service: string, inflateDir: string | undefined, migrations: string[], options: ImportJSXFileOptions) {
   const migrationsFolderPath = getMigrationsPath(servicePath)
   if (migrationsFolderPath) {
     logger?.debug("running migrations from [%s]", service);
     if (!db) {
       throw new Error("cannot run migrations with the database disabled!");
     }
-    const serviceMigrations = await migration.down.folder(db as any, migrationsFolderPath, logger as DatabaseLogger, (inFile: string) => importJSXFile(inFile, logger));
+    const serviceMigrations = await migration.down.folder(db as any, migrationsFolderPath, logger as DatabaseLogger, (inFile: string) => importJSXFile(inFile, options, logger));
     migrations.push(...serviceMigrations);
 
     if (inflateDir) {

package/src/services/utils/cluster-cache.ts

@@ -6,7 +6,7 @@ const ClusterCacheType = "$$$$$$$$$$$ClusterCacheType$$$$$$$$$$$";
 interface ClusterCacheMessage {
   type: typeof ClusterCacheType;
   target: string;
-  action: "set" | "unset" | "set_add" | "set_delete" | "array_push";
+  action: "set" | "unset" | "set_add" | "set_delete" | "array_push" | "set_clear" | "array_clear";
   fromPID: number;
   key: string;
   value?: string;
@@ -28,11 +28,29 @@ export class ClusterCache implements CacheInterface {
           msg.key &&
           msg.action &&
           msg.type === ClusterCacheType &&
-          msg.fromPID !== process.pid,
-          (msg.action === "set_add" || msg.action === "set" || msg.action === "unset" || msg.action === "set_delete" || msg.action === "array_push") &&
+          msg.fromPID !== process.pid &&
+          (msg.action === "set_clear" || msg.action === "array_clear" || msg.action === "set_add" || msg.action === "set" || msg.action === "unset" || msg.action === "set_delete" || msg.action === "array_push") &&
           msg.target === this.name) {
           this.logger?.debug("remote cluster cache message from [%s] [%s] [%s] [%s]", msg.fromPID, msg.target, msg.action, msg.key);
           switch (msg.action) {
+            case "set_clear": {
+              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : new Set<string>();
+              if (!(list instanceof Set)) {
+                throw new Error("cannot apply clear on non set");
+              }
+              list.clear();
+              this.localCache.set(msg.key, list);
+              break;
+            }
+            case "array_clear": {
+              //this.localCache.set(msg.key, msg.value);
+              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : [];
+              if (!(list instanceof Array)) {
+                throw new Error("cannot apply clear on non array");
+              }
+              this.localCache.set(msg.key, []);
+              break;
+            }
             case "unset":
               this.localCache.delete(msg.key);
               break;
@@ -43,7 +61,7 @@ export class ClusterCache implements CacheInterface {
               //this.localCache.set(msg.key, msg.value);
               const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : new Set<string>();
               if (!(list instanceof Set)) {
-                throw new Error("cannot apply push on non array");
+                throw new Error("cannot apply add on non set");
               }
               if (!list.has(msg.value)) {
                 list.add(msg.value);
@@ -55,7 +73,7 @@ export class ClusterCache implements CacheInterface {
               //this.localCache.set(msg.key, msg.value);
               const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : new Set<string>();
               if (!(list instanceof Set)) {
-                throw new Error("cannot apply push on non array");
+                throw new Error("cannot apply delete on non set");
               }
               if (list.has(msg.value)) {
                 list.delete(msg.value);
@@ -100,33 +118,25 @@ export class ClusterCache implements CacheInterface {
   set(key: string, value: unknown): void {
     this.localCache.set(key, value);
     this.logger?.trace("set(%s, ...)", key);
-    if (process.send) {
-      setTimeout(() => {
-        process.send({
-          type: ClusterCacheType,
-          action: "set",
-          target: this.name,
-          fromPID: process.pid,
-          key,
-          value
-        } as ClusterCacheMessage);
-      }, 10);
-    }
+    sendTimeout({
+      type: ClusterCacheType,
+      action: "set",
+      target: this.name,
+      fromPID: process.pid,
+      key,
+      value
+    } as ClusterCacheMessage);
   }
   unset(key: string): void {
     this.logger?.trace("unset(%s)", key);
     this.localCache.delete(key);
-    if (process.send) {
-      setTimeout(() => {
-        process.send({
-          type: ClusterCacheType,
-          target: this.name,
-          action: "unset",
-          fromPID: process.pid,
-          key
-        } as ClusterCacheMessage);
-      }, 10);
-    }
+    sendTimeout({
+      type: ClusterCacheType,
+      target: this.name,
+      action: "unset",
+      fromPID: process.pid,
+      key
+    } as ClusterCacheMessage);
   }
   has(key: string): boolean {
     this.logger?.trace("has(%s)", key);
@@ -143,19 +153,14 @@ export class ClusterCache implements CacheInterface {
       list.add(value);
     }
     this.localCache.set(key, list);
-
-    if (process.send) {
-      setTimeout(() => {
-        process.send({
-          type: ClusterCacheType,
-          target: this.name,
-          action: "set_add",
-          fromPID: process.pid,
-          key,
-          value
-        } as ClusterCacheMessage);
-      }, 10);
-    }
+    sendTimeout({
+      type: ClusterCacheType,
+      target: this.name,
+      action: "set_add",
+      fromPID: process.pid,
+      key,
+      value
+    } as ClusterCacheMessage);
   }
   set_delete(key: string, value: unknown): void {
     this.logger?.trace("delete(%s)", key);
@@ -167,18 +172,14 @@ export class ClusterCache implements CacheInterface {
       list.delete(value);
     }
     this.localCache.set(key, list);
-    if (process.send) {
-      setTimeout(() => {
-        process.send({
-          type: ClusterCacheType,
-          target: this.name,
-          action: "set_delete",
-          fromPID: process.pid,
-          key,
-          value
-        } as ClusterCacheMessage);
-      }, 10);
-    }
+    sendTimeout({
+      type: ClusterCacheType,
+      target: this.name,
+      action: "set_delete",
+      fromPID: process.pid,
+      key,
+      value
+    } as ClusterCacheMessage);
   }
   set_has(key: string, value: unknown): boolean {
     this.logger?.trace("set_has(%s)", key);
@@ -198,6 +199,13 @@ export class ClusterCache implements CacheInterface {
     }
     list.clear();
     this.localCache.set(key, list);
+    sendTimeout({
+      type: ClusterCacheType,
+      target: this.name,
+      action: "set_clear",
+      fromPID: process.pid,
+      key
+    } as ClusterCacheMessage);
   }
   array_push(key: string, value: unknown): void {
     this.logger?.trace("array_push(%s)", key);
@@ -207,18 +215,14 @@ export class ClusterCache implements CacheInterface {
     }
     list.push(value);
     this.localCache.set(key, list);
-    if (process.send) {
-      setTimeout(() => {
-        process.send({
-          type: ClusterCacheType,
-          target: this.name,
-          action: "array_push",
-          fromPID: process.pid,
-          key,
-          value
-        } as ClusterCacheMessage);
-      }, 10);
-    }
+    sendTimeout({
+      type: ClusterCacheType,
+      target: this.name,
+      action: "array_push",
+      fromPID: process.pid,
+      key,
+      value
+    } as ClusterCacheMessage);
   }
   array_clear(key: string): void {
     this.logger?.trace("array_clear(%s)", key);
@@ -226,5 +230,26 @@ export class ClusterCache implements CacheInterface {
       throw new Error("cannot apply on non Array");
     }
     this.localCache.set(key, []);
+    sendTimeout({
+      type: ClusterCacheType,
+      target: this.name,
+      action: "array_clear",
+      fromPID: process.pid,
+      key
+    } as ClusterCacheMessage);
   }
 }
+
+function sendTimeout(msg: ClusterCacheMessage) {
+  if (process.send) {
+    setTimeout(() => {
+      try {
+        if (process.send) {
+          process.send(msg);
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    }, 10);
+  }
+}

package/src/services/utils/websocketmanager.ts

@@ -28,7 +28,8 @@ export class WebSocketManager {
   public deleteWS(path: string) {
     const ws = this.runningGlobalWSMap.get(path);
     this.disconnectAllFrom(path);
-    ws.dispose();
+    if (ws)
+      ws.dispose();
     this.runningGlobalWSMap.delete(path);
   }