miqro 6.0.9 → 6.0.11

package/build/lib.cjs

@@ -4336,11 +4336,12 @@ var init_reload_api = __esm({
       },
       handler: async (req, res) => {
         const errors = await req?.editor?.reload();
+        const parsedErrors = parseInflateErrors2(errors);
         return res.json({
           message: "OK",
           reloadString: req.uuid,
           migrations: req?.editor?.getMigrations().map((m) => m.name),
-          errors: parseInflateErrors2(errors)
+          errors: parsedErrors ? parsedErrors : []
         });
       }
     };
@@ -7067,568 +7068,6 @@ function createFrame(payload) {
   return buffer;
 }
 
-// src/services/utils/cluster-ws.ts
-var ClusterWebSocketServer2MessageType = "$$$$ClusterWebSocketServer2Message$$$$$";
-var ClusterWebSocketServer2 = class extends WebSocketServer {
-  constructor(name, options) {
-    super({
-      ...options,
-      validate: (req) => {
-        if (this.options.maxConnections !== void 0 && this.clients.size + this.remoteClients.size >= this.options.maxConnections) {
-          return false;
-        } else {
-          return options.validate ? options.validate(req) : true;
-        }
-      },
-      onError: (req, error2) => {
-        if (process.send) {
-          process.send({
-            type: ClusterWebSocketServer2MessageType,
-            action: "error",
-            target: this.name,
-            clientUUID: req.uuid,
-            fromPID: String(process.pid),
-            errorMessage: error2.message
-          });
-        }
-        if (options.onError) {
-          options.onError(req, error2);
-        }
-      },
-      onConnection: (req) => {
-        if (process.send) {
-          process.send({
-            type: ClusterWebSocketServer2MessageType,
-            action: "connection",
-            target: this.name,
-            fromPID: String(process.pid),
-            clientUUID: req.uuid
-          });
-        }
-        if (options.onConnection) {
-          options.onConnection(req);
-        }
-      },
-      onDisconnect: (req) => {
-        if (process.send) {
-          process.send({
-            type: ClusterWebSocketServer2MessageType,
-            action: "disconnection",
-            target: this.name,
-            fromPID: String(process.pid),
-            clientUUID: req.uuid
-          });
-        }
-        if (options.onDisconnect) {
-          options.onDisconnect(req);
-        }
-      }
-    });
-    this.name = name;
-    this.listener = async (data) => {
-      try {
-        const msg = data;
-        if (msg && msg.type === ClusterWebSocketServer2MessageType && msg.target === this.name && msg.action) {
-          switch (msg.action) {
-            case "sync":
-              if (process.send) {
-                for (const clientUUID of this.clients.keys()) {
-                  process.send({
-                    type: ClusterWebSocketServer2MessageType,
-                    action: "connection",
-                    target: this.name,
-                    fromPID: String(process.pid),
-                    clientUUID
-                  });
-                }
-              }
-              break;
-            case "connection":
-              if (!msg.clientUUID) {
-                throw new Error(`action [${msg.action}] without clientUUID`);
-              }
-              if (!this.remoteClients.has(msg.clientUUID)) {
-                this.remoteClients.add(msg.clientUUID);
-              }
-              break;
-            case "disconnection":
-              if (!msg.clientUUID) {
-                throw new Error(`action [${msg.action}] without clientUUID`);
-              }
-              if (this.remoteClients.has(msg.clientUUID)) {
-                this.remoteClients.delete(msg.clientUUID);
-              }
-              break;
-            case "sendMessage": {
-              const payload = String(msg.payload);
-              if (!msg.clientUUID) {
-                await super.broadcast(payload, msg.fromUUID);
-              } else if (this.isConnected(msg.clientUUID)) {
-                await super.writeTo(msg.clientUUID, payload);
-              }
-              break;
-            }
-            default:
-              throw new Error(`action [${msg.action}] not supported`);
-          }
-        }
-      } catch (e) {
-        console.error(e);
-      }
-    };
-    if (process.send) {
-      process.on("message", this.listener);
-      process.send({
-        type: ClusterWebSocketServer2MessageType,
-        action: "sync",
-        fromPID: String(process.pid),
-        target: this.name
-      });
-    }
-  }
-  remoteClients = /* @__PURE__ */ new Set();
-  listener;
-  dispose() {
-    process.removeListener("message", this.listener);
-  }
-  async broadcast(payload, fromUUID) {
-    if (process.send) {
-      process.send({
-        type: ClusterWebSocketServer2MessageType,
-        action: "sendMessage",
-        payload,
-        target: this.name,
-        fromPID: String(process.pid),
-        fromUUID
-      });
-    }
-    return super.broadcast(payload, fromUUID);
-  }
-  async writeTo(clientUUID, payload) {
-    if (this.remoteClients.has(clientUUID)) {
-      if (process.send) {
-        process.send({
-          type: ClusterWebSocketServer2MessageType,
-          action: "sendMessage",
-          clientUUID,
-          target: this.name,
-          fromPID: String(process.pid),
-          payload
-        });
-        return;
-      }
-    }
-    if (this.clients.has(clientUUID)) {
-      return super.writeTo(clientUUID, payload);
-    }
-  }
-  isUUIDValid(uuid) {
-    return !this.clients.has(uuid) && !this.remoteClients.has(uuid);
-  }
-};
-
-// src/services/utils/cluster-cache.ts
-var ClusterCacheType = "$$$$$$$$$$$ClusterCacheType$$$$$$$$$$$";
-var ClusterCache = class {
-  constructor(name, logger) {
-    this.name = name;
-    this.logger = logger;
-    this.listener = async (data) => {
-      try {
-        const msg = data;
-        if (msg && 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.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 "unset":
-              this.localCache.delete(msg.key);
-              break;
-            case "set":
-              this.localCache.set(msg.key, msg.value);
-              break;
-            case "set_add": {
-              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : /* @__PURE__ */ new Set();
-              if (!(list instanceof Set)) {
-                throw new Error("cannot apply push on non array");
-              }
-              if (list.has(msg.value)) {
-                list.add(msg.value);
-              }
-              this.localCache.set(msg.key, list);
-              break;
-            }
-            case "set_delete": {
-              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : /* @__PURE__ */ new Set();
-              if (!(list instanceof Set)) {
-                throw new Error("cannot apply push on non array");
-              }
-              if (list.has(msg.value)) {
-                list.delete(msg.value);
-              }
-              this.localCache.set(msg.key, list);
-              break;
-            }
-            case "array_push": {
-              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : [];
-              if (!(list instanceof Array)) {
-                throw new Error("cannot apply push on non array");
-              }
-              list.push(msg.value);
-              this.localCache.set(msg.key, list);
-              break;
-            }
-          }
-        }
-      } catch (e) {
-        this.logger?.error(e);
-      }
-    };
-    if (process.send) {
-      process.on("message", this.listener);
-    }
-  }
-  localCache = /* @__PURE__ */ new Map();
-  //private logger: Logger;
-  listener;
-  dispose() {
-    process.removeListener("message", this.listener);
-  }
-  get(key) {
-    this.logger?.trace("get(%s)", key);
-    return this.localCache.get(key);
-  }
-  set(key, value) {
-    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
-        });
-      }, 10);
-    }
-  }
-  unset(key) {
-    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
-        });
-      }, 10);
-    }
-  }
-  has(key) {
-    this.logger?.trace("has(%s)", key);
-    return this.localCache.has(key);
-  }
-  set_add(key, value) {
-    this.logger?.trace("push(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    if (list.has(value)) {
-      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
-        });
-      }, 10);
-    }
-  }
-  set_delete(key, value) {
-    this.logger?.trace("delete(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    if (list.has(value)) {
-      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
-        });
-      }, 10);
-    }
-  }
-  set_has(key, value) {
-    this.logger?.trace("set_has(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    const ret = list.has(value);
-    this.localCache.set(key, list);
-    return ret;
-  }
-  set_clear(key) {
-    this.logger?.trace("set_clear(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    list.clear();
-    this.localCache.set(key, list);
-  }
-  array_push(key, value) {
-    this.logger?.trace("array_push(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : [];
-    if (!(list instanceof Array)) {
-      throw new Error("cannot apply on non Array");
-    }
-    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
-        });
-      }, 10);
-    }
-  }
-  array_clear(key) {
-    this.logger?.trace("array_clear(%s)", key);
-    if (this.localCache.has(key) && !(this.localCache.get(key) instanceof Array)) {
-      throw new Error("cannot apply on non Array");
-    }
-    this.localCache.set(key, []);
-  }
-};
-
-// src/services/utils/cache.ts
-var LocalCache = class {
-  constructor(name, logger) {
-    this.name = name;
-    this.logger = logger;
-  }
-  localCache = /* @__PURE__ */ new Map();
-  dispose() {
-  }
-  get(key) {
-    this.logger?.trace("get(%s)", key);
-    return this.localCache.get(key);
-  }
-  set(key, value) {
-    this.localCache.set(key, value);
-    this.logger?.trace("set(%s, ...)", key);
-  }
-  unset(key) {
-    this.logger?.trace("unset(%s)", key);
-    this.localCache.delete(key);
-  }
-  has(key) {
-    this.logger?.trace("has(%s)", key);
-    return this.localCache.has(key);
-  }
-  set_add(key, value) {
-    this.logger?.trace("set_add(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    if (list.has(value)) {
-      list.add(value);
-    }
-    this.localCache.set(key, list);
-  }
-  set_delete(key, value) {
-    this.logger?.trace("set_delete(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    if (list.has(value)) {
-      list.delete(value);
-    }
-    this.localCache.set(key, list);
-  }
-  set_has(key, value) {
-    this.logger?.trace("set_has(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    const ret = list.has(value);
-    this.localCache.set(key, list);
-    return ret;
-  }
-  set_clear(key) {
-    this.logger?.trace("set_clear(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
-    if (!(list instanceof Set)) {
-      throw new Error("cannot apply on non Set");
-    }
-    list.clear();
-    this.localCache.set(key, list);
-  }
-  array_push(key, value) {
-    this.logger?.trace("array_push(%s)", key);
-    const list = this.localCache.has(key) ? this.localCache.get(key) : [];
-    if (!(list instanceof Array)) {
-      throw new Error("cannot apply on non Array");
-    }
-    list.push(value);
-    this.localCache.set(key, list);
-  }
-  array_clear(key) {
-    this.logger?.trace("array_clear(%s)", key);
-    if (this.localCache.has(key) && !(this.localCache.get(key) instanceof Array)) {
-      throw new Error("cannot apply on non Array");
-    }
-    this.localCache.set(key, []);
-  }
-};
-
-// src/services/utils/websocketmanager.ts
-init_constants();
-var WebSocketManager = class {
-  runningGlobalWSMap = /* @__PURE__ */ new Map();
-  logger = null;
-  name;
-  avoidLogSocket;
-  constructor(options) {
-    this.onUpgrade = this.onUpgrade.bind(this);
-    this.logger = options && options.logger ? options.logger : null;
-    this.name = options && options.name ? options.name : "WebSocketManager";
-    this.avoidLogSocket = options && options.avoidLogSocket ? options.avoidLogSocket : false;
-  }
-  deleteAllWS() {
-    this.runningGlobalWSMap.clear();
-  }
-  getWS(path) {
-    return this.runningGlobalWSMap.get(path);
-  }
-  replaceALLWS(list) {
-    this.deleteAllWS();
-    for (const wsConfig of list) {
-      if (!wsConfig.disabled) {
-        if (this.runningGlobalWSMap.has(wsConfig.path)) {
-          throw new Error(`ws on path ${wsConfig.path} already setup!`);
-        }
-        this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
-        const server2 = new ClusterWebSocketServer2(wsConfig.path, wsConfig);
-        this.runningGlobalWSMap.set(wsConfig.path, server2);
-      }
-    }
-  }
-  replaceALLWSBuLOGSocket(list) {
-    for (const path of this.runningGlobalWSMap.keys()) {
-      if (path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
-        this.runningGlobalWSMap.delete(path);
-      }
-    }
-    for (const wsConfig of list) {
-      if (!wsConfig.disabled) {
-        if (wsConfig.path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
-          if (this.runningGlobalWSMap.has(wsConfig.path)) {
-            throw new Error(`ws on path ${wsConfig.path} already setup!`);
-          }
-          this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
-          const server2 = new ClusterWebSocketServer2(this.name + wsConfig.path, wsConfig);
-          this.runningGlobalWSMap.set(wsConfig.path, server2);
-        }
-      }
-    }
-  }
-  /*public setupWS(path: string, server: ClusterWebSocketServer2) {
-    if (this.runningGlobalWSMap.has(path)) {
-      throw new Error(`ws on path ${path} already setup!`);
-    }
-    this.runningGlobalWSMap.set(path, server);
-  }*/
-  disconnectAllFrom(path) {
-    try {
-      this.logger?.debug("disconnect all from [%s]", path);
-      const ws = this.getWS(path);
-      if (ws) {
-        const clients = ws.clients.values();
-        if (clients) {
-          for (const client of clients) {
-            try {
-              client.socket.destroy();
-            } catch (e2) {
-              this.logger?.error("error disconnecting web socket client");
-              this.logger?.error(e2);
-            }
-          }
-        }
-        ws.dispose();
-      }
-    } catch (e) {
-      this.logger?.error("error disconnecting web socket clients");
-      this.logger?.error(e.message);
-    }
-  }
-  disconnectAllButLOGSocket() {
-    try {
-      for (const wsPath of this.runningGlobalWSMap.keys()) {
-        if (wsPath !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
-          this.disconnectAllFrom(wsPath);
-        }
-      }
-    } catch (e) {
-      this.logger?.error("error disconnecting web socket clients");
-      this.logger?.error(e.message);
-    }
-  }
-  disconnectAll() {
-    try {
-      for (const wsPath of this.runningGlobalWSMap.keys()) {
-        this.disconnectAllFrom(wsPath);
-      }
-    } catch (e) {
-      this.logger?.error("error disconnecting web socket clients");
-      this.logger?.error(e.message);
-    }
-  }
-  onUpgrade(req, socket, head) {
-    try {
-      const wsServer = this.getWS(req.path);
-      if (wsServer) {
-        return wsServer.onUpgrade(req, socket, head);
-      } else {
-        socket.destroy();
-      }
-    } catch (e) {
-      this.logger?.error(e);
-    }
-  }
-};
-
-// src/services/utils/db-manager.ts
-var import_node_cluster = __toESM(require("node:cluster"), 1);
-
 // node_modules/@miqro/query/build/executors/sqlite3/utils.js
 function sqlite3ExecutorPrepare(args) {
   switch (args._type) {
@@ -8541,625 +7980,1200 @@ var Where = class {
     });
     return this;
   }
-  neq(column, value) {
-    this._filters.push({
-      _type: "neq",
-      _column: column,
-      _value: value
-    });
+  neq(column, value) {
+    this._filters.push({
+      _type: "neq",
+      _column: column,
+      _value: value
+    });
+    return this;
+  }
+  literal(literal) {
+    this._filters.push({
+      _type: "literal",
+      _literal: literal
+    });
+    return this;
+  }
+};
+
+// node_modules/@miqro/query/build/query/select.js
+var Select = class _Select extends Where {
+  constructor(db) {
+    super();
+    this.db = db;
+    this._type = "select";
+    this._columns = [];
+    this._selectFrom = [];
+    this._groupBy = [];
+    this._joins = [];
+    this._orderBy = [];
+  }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
+  }
+  clone() {
+    const ret = new _Select(this.db);
+    ret._filters = structuredClone(this._filters);
+    ret._columns = structuredClone(this._columns);
+    ret._groupBy = structuredClone(this._groupBy);
+    ret._selectFrom = structuredClone(this._selectFrom);
+    ret._orderBy = structuredClone(this._orderBy);
+    ret._joins = structuredClone(this._joins);
+    ret._limitBy = this._limitBy;
+    ret._offsetBy = this._offsetBy;
+    return ret;
+  }
+  async yield(logger) {
+    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  }
+  column(column) {
+    if (column instanceof Array) {
+      this._columns = this._columns.concat(column);
+    } else {
+      this._columns.push(column);
+    }
+    return this;
+  }
+  columns(column) {
+    return this.column(column);
+  }
+  from(from) {
+    if (from instanceof Array) {
+      this._selectFrom = this._selectFrom.concat(from);
+    } else {
+      this._selectFrom.push(from);
+    }
+    return this;
+  }
+  join(table, on, verb) {
+    this._joins.push({
+      _table: table,
+      _on: on,
+      _verb: verb
+    });
+    return this;
+  }
+  left(table, on) {
+    return this.join(table, on, "LEFT");
+  }
+  right(table, on) {
+    return this.join(table, on, "RIGHT");
+  }
+  group(column) {
+    this._groupBy.push(column);
+    return this;
+  }
+};
+
+// node_modules/@miqro/query/build/query/count.js
+var Count = class _Count extends Where {
+  constructor(db) {
+    super();
+    this.db = db;
+    this._type = "count";
+    this._selectFrom = [];
+    this._groupBy = [];
+    this._joins = [];
+  }
+  clone() {
+    const ret = new _Count(this.db);
+    ret._filters = structuredClone(this._filters);
+    ret._groupBy = structuredClone(this._groupBy);
+    ret._joins = structuredClone(this._joins);
+    ret._selectFrom = structuredClone(this._selectFrom);
+    ret._orderBy = structuredClone(this._orderBy);
+    ret._limitBy = this._limitBy;
+    ret._offsetBy = this._offsetBy;
+    return ret;
+  }
+  from(from) {
+    this._selectFrom = this._selectFrom.concat(from);
+    return this;
+  }
+  join(table, on, verb) {
+    this._joins.push({
+      _table: table,
+      _on: on,
+      _verb: verb
+    });
+    return this;
+  }
+  left(table, on) {
+    return this.join(table, on, "LEFT");
+  }
+  right(table, on) {
+    return this.join(table, on, "RIGHT");
+  }
+  group(column) {
+    this._groupBy.push(column);
+    return this;
+  }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
+  }
+  async yield(logger) {
+    return parseCountResult(await runStatements(this.db, this.db.getExecutor().prepare(this), logger));
+  }
+};
+async function parseCountResult(rows) {
+  return {
+    count: parseInt(rows[0].count, 10)
+  };
+}
+
+// node_modules/@miqro/query/build/query/update.js
+var Update = class _Update extends Where {
+  constructor(db, _table) {
+    super();
+    this.db = db;
+    this._table = _table;
+    this._type = "update";
+    this._sets = [];
+    this._returning = [];
+  }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
+  }
+  async yield(logger) {
+    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  }
+  clone() {
+    const ret = new _Update(this.db, this._table);
+    ret._filters = structuredClone(this._filters);
+    ret._orderBy = structuredClone(this._orderBy);
+    ret._sets = structuredClone(this._sets);
+    ret._returning = structuredClone(this._returning);
+    ret._limitBy = this._limitBy;
+    ret._offsetBy = this._offsetBy;
+    return ret;
+  }
+  returning(column) {
+    this._returning = this._returning.concat(column);
     return this;
   }
-  literal(literal) {
-    this._filters.push({
-      _type: "literal",
-      _literal: literal
+  set(column, value) {
+    this._sets.push({
+      column,
+      value
     });
     return this;
   }
 };
 
-// node_modules/@miqro/query/build/query/select.js
-var Select = class _Select extends Where {
-  constructor(db) {
+// node_modules/@miqro/query/build/query/delete.js
+var Delete = class _Delete extends Where {
+  constructor(db, _table) {
     super();
     this.db = db;
-    this._type = "select";
-    this._columns = [];
-    this._selectFrom = [];
-    this._groupBy = [];
-    this._joins = [];
-    this._orderBy = [];
+    this._table = _table;
+    this._type = "delete";
+    this._returning = [];
   }
   prepare() {
     return getStatements(this.db.getExecutor().prepare(this));
   }
+  async yield(logger) {
+    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  }
   clone() {
-    const ret = new _Select(this.db);
+    const ret = new _Delete(this.db, this._table);
     ret._filters = structuredClone(this._filters);
-    ret._columns = structuredClone(this._columns);
-    ret._groupBy = structuredClone(this._groupBy);
-    ret._selectFrom = structuredClone(this._selectFrom);
     ret._orderBy = structuredClone(this._orderBy);
-    ret._joins = structuredClone(this._joins);
+    ret._returning = structuredClone(this._returning);
     ret._limitBy = this._limitBy;
     ret._offsetBy = this._offsetBy;
     return ret;
   }
+  returning(column) {
+    this._returning = this._returning.concat(column);
+    return this;
+  }
+};
+
+// node_modules/@miqro/query/build/query/drop-database.js
+var DropDatabase = class _DropDatabase {
+  constructor(db, _dbName) {
+    this.db = db;
+    this._dbName = _dbName;
+    this._type = "drop-database";
+    this._ignoreDuplicate = false;
+  }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
+  }
+  ignoreDuplicates(ignore = true) {
+    this._ignoreDuplicate = ignore;
+    return this;
+  }
   async yield(logger) {
     return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
   }
-  column(column) {
-    if (column instanceof Array) {
-      this._columns = this._columns.concat(column);
-    } else {
-      this._columns.push(column);
+  clone() {
+    const ret = new _DropDatabase(this.db, this._dbName);
+    ret._ignoreDuplicate = this._ignoreDuplicate;
+    return ret;
+  }
+};
+
+// node_modules/@miqro/query/build/executors/sqlite3-cli/lib.js
+var import_child_process = require("child_process");
+var SQLITE_CONFIG_SCHEMA2 = {
+  type: "object",
+  mode: "remove_extra",
+  properties: {
+    storage: "string"
+  }
+};
+async function sqlite3CLIExecutor(config) {
+  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA2);
+  if (!databaseOptions) {
+    throw new Error("config not valid");
+  }
+  (config.logger ? config.logger : console).error(`sqlite3-cli is affected by sql injection. do not use! only for testing!`);
+  return {
+    // we just use the sqlite3Executor prepare function
+    prepare: sqlite3ExecutorPrepare,
+    disconnect: async function sqlite3ExecutorDisconnect() {
+    },
+    query: async function sqlite3Executor2(sql, values) {
+      return new Promise((resolve20, reject) => {
+        try {
+          let i = 0;
+          const raw = sql.replaceAll("?", (sub) => {
+            const value = values ? values[i] : void 0;
+            if (value === void 0) {
+              throw new Error("cannot convert query");
+            }
+            i++;
+            return `'${value}'`;
+          });
+          if (values && i !== values.length) {
+            throw new Error("cannot convert query");
+          }
+          (0, import_child_process.exec)(`sqlite3 -json "${databaseOptions.storage}" "${raw}"`, (error2, stdout, stderr) => {
+            try {
+              if (error2) {
+                if (stderr) {
+                  reject(new Error(stderr));
+                } else {
+                  reject(error2);
+                }
+              } else {
+                if (stderr) {
+                  reject(new Error(stderr));
+                } else {
+                  if (stdout) {
+                    resolve20(JSON.parse(stdout));
+                  } else {
+                    resolve20([]);
+                  }
+                }
+              }
+            } catch (e2) {
+              reject(e2);
+            }
+          });
+        } catch (e) {
+          reject(e);
+        }
+      });
     }
-    return this;
+  };
+}
+
+// node_modules/@miqro/query/build/executors/sqlite-native/lib.js
+var SQLITE_CONFIG_SCHEMA3 = {
+  type: "object",
+  mode: "remove_extra",
+  properties: {
+    storage: "string"
   }
-  columns(column) {
-    return this.column(column);
+};
+async function nativeSqlite(config) {
+  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA3);
+  if (!databaseOptions) {
+    throw new Error("config not valid");
   }
-  from(from) {
-    if (from instanceof Array) {
-      this._selectFrom = this._selectFrom.concat(from);
-    } else {
-      this._selectFrom.push(from);
+  const sqliteModule = await import("node:sqlite");
+  const driver = new sqliteModule.DatabaseSync(databaseOptions.storage);
+  return {
+    // we just use the sqlite3Executor prepare function
+    prepare: sqlite3ExecutorPrepare,
+    disconnect: async function sqlite3ExecutorDisconnect() {
+      return driver.close();
+    },
+    query: async function sqlite3Executor2(sql, values) {
+      return new Promise((resolve20, reject) => {
+        try {
+          if (values) {
+            for (let i = 0; i < values.length; i++) {
+              switch (typeof values[i]) {
+                case "object":
+                  if (values[i] instanceof Date) {
+                    values[i] = values[i].toString();
+                  }
+                  break;
+                case "boolean":
+                  values[i] = values[i] ? 1 : 0;
+                  break;
+              }
+            }
+          }
+          const stmt = driver.prepare(sql);
+          stmt.setReadBigInts(true);
+          if (values && values.length > 0) {
+            const ret = stmt.all(...values);
+            resolve20(ret);
+          } else {
+            const ret = stmt.all();
+            resolve20(ret);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }
+  };
+}
+
+// node_modules/@miqro/query/build/db.js
+var Database = class {
+  constructor(config) {
+    this.config = config;
+    this.status = "disconnected";
+    this.executor = null;
+    parser.parse(config, DATABASE_CONFIG_SCHEMA, "no_extra");
+    this.executor = null;
+  }
+  async connect() {
+    if (this.status !== "disconnected") {
+      throw new Error(`cannot connect while ${this.status}`);
+    }
+    if (this.executor !== null) {
+      throw new Error(`cannot connect executor exists!`);
+    }
+    this.status = "connecting";
+    try {
+      this.executor = await getExecutor(this.config);
+      this.status = "connected";
+    } catch (e) {
+      this.status = "error";
+      throw e;
+    }
+  }
+  async disconnect() {
+    if (this.status !== "connected") {
+      throw new Error(`cannot disconnect while ${this.status}`);
+    }
+    this.status = "disconnecting";
+    try {
+      await this.getExecutor().disconnect();
+      this.executor = null;
+      this.status = "disconnected";
+    } catch (e) {
+      this.status = "error";
+      throw e;
+    }
+  }
+  getExecutor() {
+    if (!this.executor) {
+      throw new Error("executor not initialized!");
+    }
+    return this.executor;
+  }
+  async query(sql, values, logger) {
+    const l = logger ? logger : this.config.logger ? this.config.logger : void 0;
+    try {
+      l?.log(sql);
+      const result = await this.getExecutor().query(sql, values);
+      return result;
+    } catch (e) {
+      l?.error(e);
+      throw e;
     }
-    return this;
-  }
-  join(table, on, verb) {
-    this._joins.push({
-      _table: table,
-      _on: on,
-      _verb: verb
-    });
-    return this;
   }
-  left(table, on) {
-    return this.join(table, on, "LEFT");
+  async transaction(transactionCB, logger) {
+    try {
+      await this.query("BEGIN", void 0, logger);
+      const ret = await transactionCB(this, logger);
+      await this.query("COMMIT", void 0, logger);
+      return ret;
+    } catch (e) {
+      await this.query("ROLLBACK", void 0, logger);
+      throw e;
+    }
   }
-  right(table, on) {
-    return this.join(table, on, "RIGHT");
+  createDatabase(dbName) {
+    return new CreateDatabase(this, dbName);
   }
-  group(column) {
-    this._groupBy.push(column);
-    return this;
+  createTable(table, definition) {
+    return new CreateTable(this, table, definition);
   }
-};
-
-// node_modules/@miqro/query/build/query/count.js
-var Count = class _Count extends Where {
-  constructor(db) {
-    super();
-    this.db = db;
-    this._type = "count";
-    this._selectFrom = [];
-    this._groupBy = [];
-    this._joins = [];
+  dropTable(table) {
+    return new DropTable(this, table);
   }
-  clone() {
-    const ret = new _Count(this.db);
-    ret._filters = structuredClone(this._filters);
-    ret._groupBy = structuredClone(this._groupBy);
-    ret._joins = structuredClone(this._joins);
-    ret._selectFrom = structuredClone(this._selectFrom);
-    ret._orderBy = structuredClone(this._orderBy);
-    ret._limitBy = this._limitBy;
-    ret._offsetBy = this._offsetBy;
-    return ret;
+  dropDatabase(dbname) {
+    return new DropDatabase(this, dbname);
   }
-  from(from) {
-    this._selectFrom = this._selectFrom.concat(from);
-    return this;
+  alterTable(table, inTransaction) {
+    return new AlterTable(this, table, inTransaction);
   }
-  join(table, on, verb) {
-    this._joins.push({
-      _table: table,
-      _on: on,
-      _verb: verb
-    });
-    return this;
+  insert(table) {
+    return new Insert(this, table);
   }
-  left(table, on) {
-    return this.join(table, on, "LEFT");
+  select() {
+    return new Select(this);
   }
-  right(table, on) {
-    return this.join(table, on, "RIGHT");
+  count() {
+    return new Count(this);
   }
-  group(column) {
-    this._groupBy.push(column);
-    return this;
+  update(table) {
+    return new Update(this, table);
   }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
+  delete(table) {
+    return new Delete(this, table);
   }
-  async yield(logger) {
-    return parseCountResult(await runStatements(this.db, this.db.getExecutor().prepare(this), logger));
+  where() {
+    return new Where();
   }
 };
-async function parseCountResult(rows) {
-  return {
-    count: parseInt(rows[0].count, 10)
-  };
+async function getExecutor(config) {
+  switch (config.dialect) {
+    case "node:sqlite":
+      return await nativeSqlite(config);
+    case "sqlite3-cli":
+      return await sqlite3CLIExecutor(config);
+    case "pg":
+      return await postgresExecutor(config);
+    case "sqlite3":
+      return await sqlite3Executor(config);
+    default:
+      if (config.executor) {
+        return config.executor;
+      }
+      throw new Error("dialect [" + config.dialect + "] not defined");
+  }
 }
 
-// node_modules/@miqro/query/build/query/update.js
-var Update = class _Update extends Where {
-  constructor(db, _table) {
-    super();
-    this.db = db;
-    this._table = _table;
-    this._type = "update";
-    this._sets = [];
-    this._returning = [];
-  }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
+// node_modules/@miqro/query/build/migrations/lib.js
+var lib_exports = {};
+__export(lib_exports, {
+  down: () => down,
+  getSortedMigrations: () => getMigrationFolderSortedFiles,
+  init: () => initMigrationsTable,
+  up: () => up
+});
+
+// node_modules/@miqro/query/build/migrations/utils.js
+var import_fs = require("fs");
+var import_path = require("path");
+
+// node_modules/@miqro/query/build/migrations/constants.js
+var MIGRATIONS_TABLE_NAME = "migrations";
+var MIGRATIONS_SCHEMA = {
+  name: {
+    type: "string",
+    primaryKey: true,
+    allowNull: false
   }
-  async yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+};
+var NULL_LOGGER = {
+  error: (...args) => {
+  },
+  log: (...args) => {
   }
-  clone() {
-    const ret = new _Update(this.db, this._table);
-    ret._filters = structuredClone(this._filters);
-    ret._orderBy = structuredClone(this._orderBy);
-    ret._sets = structuredClone(this._sets);
-    ret._returning = structuredClone(this._returning);
-    ret._limitBy = this._limitBy;
-    ret._offsetBy = this._offsetBy;
-    return ret;
+};
+
+// node_modules/@miqro/query/build/migrations/utils.js
+async function upMigrationFolder(db, migrationsFolderPath, logger, importFN) {
+  const startMS = Date.now();
+  logger?.log("\n\n====== [running migrations folder] ======\n====== [%s] ======\n", (0, import_path.relative)(process.cwd(), migrationsFolderPath));
+  await initMigrationsTable(db, NULL_LOGGER);
+  const migrations = getMigrationFolderSortedFiles(migrationsFolderPath);
+  for (const migrationName of migrations) {
+    const migrationPath = (0, import_path.resolve)(migrationsFolderPath, migrationName);
+    await upMigration(db, migrationPath, logger, importFN);
   }
-  returning(column) {
-    this._returning = this._returning.concat(column);
-    return this;
+  const took = Date.now() - startMS;
+  logger?.log("\n\n====== [running migrations folder done] ======\n====== [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationsFolderPath), took);
+  return migrations;
+}
+async function downMigrationFolder(db, migrationsFolderPath, logger, importFN) {
+  const startMS = Date.now();
+  logger?.log("\n\n====== [running migrations folder] ======\n====== [%s] ======\n", (0, import_path.relative)(process.cwd(), migrationsFolderPath));
+  await initMigrationsTable(db, NULL_LOGGER);
+  const migrations = getMigrationFolderSortedFiles(migrationsFolderPath).reverse();
+  for (const migrationName of migrations) {
+    const migrationPath = (0, import_path.resolve)(migrationsFolderPath, migrationName);
+    await downMigration(db, migrationPath, logger, importFN);
   }
-  set(column, value) {
-    this._sets.push({
-      column,
-      value
-    });
-    return this;
+  const took = Date.now() - startMS;
+  logger?.log("\n\n====== [running migrations folder done] ======\n====== [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationsFolderPath), took);
+  return migrations;
+}
+async function upMigration(db, migrationPath, logger, importFN) {
+  return runMigration(db, migrationPath, false, logger ? logger : db.config.logger, importFN);
+}
+async function upMigrationModule(db, migrationName, migrationModule, logger) {
+  return runMigrationModule(db, migrationName, migrationModule, false, logger ? logger : db.config.logger);
+}
+async function downMigrationModule(db, migrationName, migrationModule, logger) {
+  return runMigrationModule(db, migrationName, migrationModule, true, logger ? logger : db.config.logger);
+}
+async function downMigration(db, migrationPath, logger, importFN) {
+  return runMigration(db, migrationPath, true, logger ? logger : db.config.logger, importFN);
+}
+async function initMigrationsTable(db, logger) {
+  return db.createTable(MIGRATIONS_TABLE_NAME, MIGRATIONS_SCHEMA).ignoreDuplicates(true).yield(logger);
+}
+function getMigrationFolderSortedFiles(migrationsFolderPath) {
+  const files = (0, import_fs.readdirSync)(migrationsFolderPath);
+  return files.map((file) => {
+    const ext = (0, import_path.extname)(file);
+    if (ext === ".js" || ext === ".mjs" || ext === ".ts" || ext === ".tsx" || ext === ".tsx") {
+      const firstDash = file.indexOf("-");
+      if (firstDash !== -1) {
+        const number = parseInt(file.substring(0, firstDash), 10);
+        if (!isNaN(number)) {
+          return {
+            number,
+            file
+          };
+        }
+      }
+    }
+    return {
+      number: 0,
+      file: ""
+    };
+  }).filter((file) => file.file !== "").sort((a, b) => {
+    return a.number - b.number;
+  }).map((file) => file.file);
+}
+async function runMigrationModule(db, migrationName, migrationModule, down2 = false, logger) {
+  const startMS = Date.now();
+  const alreadyRun = (await db.select().from(MIGRATIONS_TABLE_NAME).column("name").limit(1).eq("name", migrationName).yield(NULL_LOGGER)).length > 0;
+  if (down2) {
+    if (alreadyRun) {
+      logger?.log("		====== [%s] ======", (0, import_path.relative)(process.cwd(), migrationName));
+      await migrationModule.down(db, logger);
+      await db.delete(MIGRATIONS_TABLE_NAME).eq("name", migrationName).yield(NULL_LOGGER);
+      const took = Date.now() - startMS;
+      logger?.log("		====== [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationName), took);
+    } else {
+      const took = Date.now() - startMS;
+      logger?.log("		====== skipping down [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationName), took);
+    }
+  } else {
+    if (alreadyRun) {
+      const took = Date.now() - startMS;
+      logger?.log("		====== skipping up [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationName), took);
+    } else {
+      logger?.log("		====== [%s] ======", (0, import_path.relative)(process.cwd(), migrationName));
+      await migrationModule.up(db, logger);
+      await db.insert(MIGRATIONS_TABLE_NAME).column("name").value([{
+        name: migrationName
+      }]).ignoreDuplicates(true).yield(NULL_LOGGER);
+      const took = Date.now() - startMS;
+      logger?.log("		====== [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationName), took);
+    }
   }
-};
+}
+async function runMigration(db, migrationPath, down2 = false, logger, importFN) {
+  const migrationName = (0, import_path.basename)(migrationPath).substring(0, (0, import_path.basename)(migrationPath).length - (0, import_path.extname)(migrationPath).length);
+  const migrationModule = (await (importFN ? importFN(migrationPath) : import(migrationPath))).default;
+  return runMigrationModule(db, migrationName, migrationModule, down2, logger);
+}
 
-// node_modules/@miqro/query/build/query/delete.js
-var Delete = class _Delete extends Where {
-  constructor(db, _table) {
-    super();
-    this.db = db;
-    this._table = _table;
-    this._type = "delete";
-    this._returning = [];
-  }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
-  }
-  async yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
-  }
-  clone() {
-    const ret = new _Delete(this.db, this._table);
-    ret._filters = structuredClone(this._filters);
-    ret._orderBy = structuredClone(this._orderBy);
-    ret._returning = structuredClone(this._returning);
-    ret._limitBy = this._limitBy;
-    ret._offsetBy = this._offsetBy;
-    return ret;
-  }
-  returning(column) {
-    this._returning = this._returning.concat(column);
-    return this;
-  }
+// node_modules/@miqro/query/build/migrations/lib.js
+var up = {
+  file: upMigration,
+  module: upMigrationModule,
+  folder: upMigrationFolder
 };
-
-// node_modules/@miqro/query/build/query/drop-database.js
-var DropDatabase = class _DropDatabase {
-  constructor(db, _dbName) {
-    this.db = db;
-    this._dbName = _dbName;
-    this._type = "drop-database";
-    this._ignoreDuplicate = false;
-  }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
-  }
-  ignoreDuplicates(ignore = true) {
-    this._ignoreDuplicate = ignore;
-    return this;
-  }
-  async yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
-  }
-  clone() {
-    const ret = new _DropDatabase(this.db, this._dbName);
-    ret._ignoreDuplicate = this._ignoreDuplicate;
-    return ret;
-  }
+var down = {
+  file: downMigration,
+  module: downMigrationModule,
+  folder: downMigrationFolder
 };
 
-// node_modules/@miqro/query/build/executors/sqlite3-cli/lib.js
-var import_child_process = require("child_process");
-var SQLITE_CONFIG_SCHEMA2 = {
-  type: "object",
-  mode: "remove_extra",
-  properties: {
-    storage: "string"
-  }
-};
-async function sqlite3CLIExecutor(config) {
-  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA2);
-  if (!databaseOptions) {
-    throw new Error("config not valid");
-  }
-  (config.logger ? config.logger : console).error(`sqlite3-cli is affected by sql injection. do not use! only for testing!`);
-  return {
-    // we just use the sqlite3Executor prepare function
-    prepare: sqlite3ExecutorPrepare,
-    disconnect: async function sqlite3ExecutorDisconnect() {
-    },
-    query: async function sqlite3Executor2(sql, values) {
-      return new Promise((resolve20, reject) => {
-        try {
-          let i = 0;
-          const raw = sql.replaceAll("?", (sub) => {
-            const value = values ? values[i] : void 0;
-            if (value === void 0) {
-              throw new Error("cannot convert query");
-            }
-            i++;
-            return `'${value}'`;
+// src/services/utils/cluster-ws.ts
+var ClusterWebSocketServer2MessageType = "$$$$ClusterWebSocketServer2Message$$$$$";
+var ClusterWebSocketServer2 = class extends WebSocketServer {
+  constructor(name, options) {
+    super({
+      ...options,
+      validate: (req) => {
+        if (this.options.maxConnections !== void 0 && this.clients.size + this.remoteClients.size >= this.options.maxConnections) {
+          return false;
+        } else {
+          return options.validate ? options.validate(req) : true;
+        }
+      },
+      onError: (req, error2) => {
+        if (process.send) {
+          process.send({
+            type: ClusterWebSocketServer2MessageType,
+            action: "error",
+            target: this.name,
+            clientUUID: req.uuid,
+            fromPID: String(process.pid),
+            errorMessage: error2.message
           });
-          if (values && i !== values.length) {
-            throw new Error("cannot convert query");
-          }
-          (0, import_child_process.exec)(`sqlite3 -json "${databaseOptions.storage}" "${raw}"`, (error2, stdout, stderr) => {
-            try {
-              if (error2) {
-                if (stderr) {
-                  reject(new Error(stderr));
-                } else {
-                  reject(error2);
-                }
-              } else {
-                if (stderr) {
-                  reject(new Error(stderr));
-                } else {
-                  if (stdout) {
-                    resolve20(JSON.parse(stdout));
-                  } else {
-                    resolve20([]);
-                  }
+        }
+        if (options.onError) {
+          options.onError(req, error2);
+        }
+      },
+      onConnection: (req) => {
+        if (process.send) {
+          process.send({
+            type: ClusterWebSocketServer2MessageType,
+            action: "connection",
+            target: this.name,
+            fromPID: String(process.pid),
+            clientUUID: req.uuid
+          });
+        }
+        if (options.onConnection) {
+          options.onConnection(req);
+        }
+      },
+      onDisconnect: (req) => {
+        if (process.send) {
+          process.send({
+            type: ClusterWebSocketServer2MessageType,
+            action: "disconnection",
+            target: this.name,
+            fromPID: String(process.pid),
+            clientUUID: req.uuid
+          });
+        }
+        if (options.onDisconnect) {
+          options.onDisconnect(req);
+        }
+      }
+    });
+    this.name = name;
+    this.listener = async (data) => {
+      try {
+        const msg = data;
+        if (msg && msg.type === ClusterWebSocketServer2MessageType && msg.target === this.name && msg.action) {
+          switch (msg.action) {
+            case "sync":
+              if (process.send) {
+                for (const clientUUID of this.clients.keys()) {
+                  process.send({
+                    type: ClusterWebSocketServer2MessageType,
+                    action: "connection",
+                    target: this.name,
+                    fromPID: String(process.pid),
+                    clientUUID
+                  });
                 }
               }
-            } catch (e2) {
-              reject(e2);
+              break;
+            case "connection":
+              if (!msg.clientUUID) {
+                throw new Error(`action [${msg.action}] without clientUUID`);
+              }
+              if (!this.remoteClients.has(msg.clientUUID)) {
+                this.remoteClients.add(msg.clientUUID);
+              }
+              break;
+            case "disconnection":
+              if (!msg.clientUUID) {
+                throw new Error(`action [${msg.action}] without clientUUID`);
+              }
+              if (this.remoteClients.has(msg.clientUUID)) {
+                this.remoteClients.delete(msg.clientUUID);
+              }
+              break;
+            case "sendMessage": {
+              const payload = String(msg.payload);
+              if (!msg.clientUUID) {
+                await super.broadcast(payload, msg.fromUUID);
+              } else if (this.isConnected(msg.clientUUID)) {
+                await super.writeTo(msg.clientUUID, payload);
+              }
+              break;
             }
-          });
-        } catch (e) {
-          reject(e);
+            default:
+              throw new Error(`action [${msg.action}] not supported`);
+          }
         }
+      } catch (e) {
+        console.error(e);
+      }
+    };
+    this.connect();
+  }
+  remoteClients = /* @__PURE__ */ new Set();
+  listener;
+  connect() {
+    if (process.send) {
+      process.removeListener("message", this.listener);
+      process.on("message", this.listener);
+      process.send({
+        type: ClusterWebSocketServer2MessageType,
+        action: "sync",
+        fromPID: String(process.pid),
+        target: this.name
+      });
+    }
+  }
+  dispose() {
+    process.removeListener("message", this.listener);
+  }
+  async broadcast(payload, fromUUID) {
+    if (process.send) {
+      process.send({
+        type: ClusterWebSocketServer2MessageType,
+        action: "sendMessage",
+        payload,
+        target: this.name,
+        fromPID: String(process.pid),
+        fromUUID
       });
     }
-  };
-}
-
-// node_modules/@miqro/query/build/executors/sqlite-native/lib.js
-var SQLITE_CONFIG_SCHEMA3 = {
-  type: "object",
-  mode: "remove_extra",
-  properties: {
-    storage: "string"
+    return super.broadcast(payload, fromUUID);
   }
-};
-async function nativeSqlite(config) {
-  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA3);
-  if (!databaseOptions) {
-    throw new Error("config not valid");
+  async writeTo(clientUUID, payload) {
+    if (this.remoteClients.has(clientUUID)) {
+      if (process.send) {
+        process.send({
+          type: ClusterWebSocketServer2MessageType,
+          action: "sendMessage",
+          clientUUID,
+          target: this.name,
+          fromPID: String(process.pid),
+          payload
+        });
+        return;
+      }
+    }
+    if (this.clients.has(clientUUID)) {
+      return super.writeTo(clientUUID, payload);
+    }
   }
-  const sqliteModule = await import("node:sqlite");
-  const driver = new sqliteModule.DatabaseSync(databaseOptions.storage);
-  return {
-    // we just use the sqlite3Executor prepare function
-    prepare: sqlite3ExecutorPrepare,
-    disconnect: async function sqlite3ExecutorDisconnect() {
-      return driver.close();
-    },
-    query: async function sqlite3Executor2(sql, values) {
-      return new Promise((resolve20, reject) => {
-        try {
-          if (values) {
-            for (let i = 0; i < values.length; i++) {
-              switch (typeof values[i]) {
-                case "object":
-                  if (values[i] instanceof Date) {
-                    values[i] = values[i].toString();
-                  }
-                  break;
-                case "boolean":
-                  values[i] = values[i] ? 1 : 0;
-                  break;
+  isUUIDValid(uuid) {
+    return !this.clients.has(uuid) && !this.remoteClients.has(uuid);
+  }
+};
+
+// src/services/utils/cluster-cache.ts
+var ClusterCacheType = "$$$$$$$$$$$ClusterCacheType$$$$$$$$$$$";
+var ClusterCache = class {
+  constructor(name, logger) {
+    this.name = name;
+    this.logger = logger;
+    this.listener = async (data) => {
+      try {
+        const msg = data;
+        if (msg && 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.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 "unset":
+              this.localCache.delete(msg.key);
+              break;
+            case "set":
+              this.localCache.set(msg.key, msg.value);
+              break;
+            case "set_add": {
+              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : /* @__PURE__ */ new Set();
+              if (!(list instanceof Set)) {
+                throw new Error("cannot apply push on non array");
               }
+              if (list.has(msg.value)) {
+                list.add(msg.value);
+              }
+              this.localCache.set(msg.key, list);
+              break;
+            }
+            case "set_delete": {
+              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : /* @__PURE__ */ new Set();
+              if (!(list instanceof Set)) {
+                throw new Error("cannot apply push on non array");
+              }
+              if (list.has(msg.value)) {
+                list.delete(msg.value);
+              }
+              this.localCache.set(msg.key, list);
+              break;
+            }
+            case "array_push": {
+              const list = this.localCache.has(msg.key) ? this.localCache.get(msg.key) : [];
+              if (!(list instanceof Array)) {
+                throw new Error("cannot apply push on non array");
+              }
+              list.push(msg.value);
+              this.localCache.set(msg.key, list);
+              break;
             }
           }
-          const stmt = driver.prepare(sql);
-          stmt.setReadBigInts(true);
-          if (values && values.length > 0) {
-            const ret = stmt.all(...values);
-            resolve20(ret);
-          } else {
-            const ret = stmt.all();
-            resolve20(ret);
-          }
-        } catch (e) {
-          reject(e);
         }
-      });
+      } catch (e) {
+        this.logger?.error(e);
+      }
+    };
+    this.connect();
+  }
+  localCache = /* @__PURE__ */ new Map();
+  //private logger: Logger;
+  listener;
+  connect() {
+    if (process.send) {
+      process.removeListener("message", this.listener);
+      process.on("message", this.listener);
     }
-  };
-}
-
-// node_modules/@miqro/query/build/db.js
-var Database = class {
-  constructor(config) {
-    this.config = config;
-    this.status = "disconnected";
-    this.executor = null;
-    parser.parse(config, DATABASE_CONFIG_SCHEMA, "no_extra");
-    this.executor = null;
   }
-  async connect() {
-    if (this.status !== "disconnected") {
-      throw new Error(`cannot connect while ${this.status}`);
+  disconnect() {
+    process.removeListener("message", this.listener);
+  }
+  get(key) {
+    this.logger?.trace("get(%s)", key);
+    return this.localCache.get(key);
+  }
+  set(key, value) {
+    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
+        });
+      }, 10);
     }
-    if (this.executor !== null) {
-      throw new Error(`cannot connect executor exists!`);
+  }
+  unset(key) {
+    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
+        });
+      }, 10);
     }
-    this.status = "connecting";
-    try {
-      this.executor = await getExecutor(this.config);
-      this.status = "connected";
-    } catch (e) {
-      this.status = "error";
-      throw e;
+  }
+  has(key) {
+    this.logger?.trace("has(%s)", key);
+    return this.localCache.has(key);
+  }
+  set_add(key, value) {
+    this.logger?.trace("push(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
+    if (!(list instanceof Set)) {
+      throw new Error("cannot apply on non Set");
+    }
+    if (list.has(value)) {
+      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
+        });
+      }, 10);
     }
   }
-  async disconnect() {
-    if (this.status !== "connected") {
-      throw new Error(`cannot disconnect while ${this.status}`);
+  set_delete(key, value) {
+    this.logger?.trace("delete(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
+    if (!(list instanceof Set)) {
+      throw new Error("cannot apply on non Set");
     }
-    this.status = "disconnecting";
-    try {
-      await this.getExecutor().disconnect();
-      this.executor = null;
-      this.status = "disconnected";
-    } catch (e) {
-      this.status = "error";
-      throw e;
+    if (list.has(value)) {
+      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
+        });
+      }, 10);
+    }
+  }
+  set_has(key, value) {
+    this.logger?.trace("set_has(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
+    if (!(list instanceof Set)) {
+      throw new Error("cannot apply on non Set");
     }
+    const ret = list.has(value);
+    this.localCache.set(key, list);
+    return ret;
   }
-  getExecutor() {
-    if (!this.executor) {
-      throw new Error("executor not initialized!");
+  set_clear(key) {
+    this.logger?.trace("set_clear(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
+    if (!(list instanceof Set)) {
+      throw new Error("cannot apply on non Set");
     }
-    return this.executor;
+    list.clear();
+    this.localCache.set(key, list);
   }
-  async query(sql, values, logger) {
-    const l = logger ? logger : this.config.logger ? this.config.logger : void 0;
-    try {
-      l?.log(sql);
-      const result = await this.getExecutor().query(sql, values);
-      return result;
-    } catch (e) {
-      l?.error(e);
-      throw e;
+  array_push(key, value) {
+    this.logger?.trace("array_push(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : [];
+    if (!(list instanceof Array)) {
+      throw new Error("cannot apply on non Array");
+    }
+    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
+        });
+      }, 10);
     }
   }
-  async transaction(transactionCB, logger) {
-    try {
-      await this.query("BEGIN", void 0, logger);
-      const ret = await transactionCB(this, logger);
-      await this.query("COMMIT", void 0, logger);
-      return ret;
-    } catch (e) {
-      await this.query("ROLLBACK", void 0, logger);
-      throw e;
+  array_clear(key) {
+    this.logger?.trace("array_clear(%s)", key);
+    if (this.localCache.has(key) && !(this.localCache.get(key) instanceof Array)) {
+      throw new Error("cannot apply on non Array");
     }
+    this.localCache.set(key, []);
   }
-  createDatabase(dbName) {
-    return new CreateDatabase(this, dbName);
+};
+
+// src/services/utils/cache.ts
+var LocalCache = class {
+  constructor(name, logger) {
+    this.name = name;
+    this.logger = logger;
   }
-  createTable(table, definition) {
-    return new CreateTable(this, table, definition);
+  localCache = /* @__PURE__ */ new Map();
+  dispose() {
   }
-  dropTable(table) {
-    return new DropTable(this, table);
+  get(key) {
+    this.logger?.trace("get(%s)", key);
+    return this.localCache.get(key);
   }
-  dropDatabase(dbname) {
-    return new DropDatabase(this, dbname);
+  set(key, value) {
+    this.localCache.set(key, value);
+    this.logger?.trace("set(%s, ...)", key);
   }
-  alterTable(table, inTransaction) {
-    return new AlterTable(this, table, inTransaction);
+  unset(key) {
+    this.logger?.trace("unset(%s)", key);
+    this.localCache.delete(key);
   }
-  insert(table) {
-    return new Insert(this, table);
+  has(key) {
+    this.logger?.trace("has(%s)", key);
+    return this.localCache.has(key);
   }
-  select() {
-    return new Select(this);
+  set_add(key, value) {
+    this.logger?.trace("set_add(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
+    if (!(list instanceof Set)) {
+      throw new Error("cannot apply on non Set");
+    }
+    if (list.has(value)) {
+      list.add(value);
+    }
+    this.localCache.set(key, list);
   }
-  count() {
-    return new Count(this);
+  set_delete(key, value) {
+    this.logger?.trace("set_delete(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
+    if (!(list instanceof Set)) {
+      throw new Error("cannot apply on non Set");
+    }
+    if (list.has(value)) {
+      list.delete(value);
+    }
+    this.localCache.set(key, list);
   }
-  update(table) {
-    return new Update(this, table);
+  set_has(key, value) {
+    this.logger?.trace("set_has(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
+    if (!(list instanceof Set)) {
+      throw new Error("cannot apply on non Set");
+    }
+    const ret = list.has(value);
+    this.localCache.set(key, list);
+    return ret;
   }
-  delete(table) {
-    return new Delete(this, table);
+  set_clear(key) {
+    this.logger?.trace("set_clear(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : /* @__PURE__ */ new Set();
+    if (!(list instanceof Set)) {
+      throw new Error("cannot apply on non Set");
+    }
+    list.clear();
+    this.localCache.set(key, list);
   }
-  where() {
-    return new Where();
+  array_push(key, value) {
+    this.logger?.trace("array_push(%s)", key);
+    const list = this.localCache.has(key) ? this.localCache.get(key) : [];
+    if (!(list instanceof Array)) {
+      throw new Error("cannot apply on non Array");
+    }
+    list.push(value);
+    this.localCache.set(key, list);
   }
-};
-async function getExecutor(config) {
-  switch (config.dialect) {
-    case "node:sqlite":
-      return await nativeSqlite(config);
-    case "sqlite3-cli":
-      return await sqlite3CLIExecutor(config);
-    case "pg":
-      return await postgresExecutor(config);
-    case "sqlite3":
-      return await sqlite3Executor(config);
-    default:
-      if (config.executor) {
-        return config.executor;
-      }
-      throw new Error("dialect [" + config.dialect + "] not defined");
+  array_clear(key) {
+    this.logger?.trace("array_clear(%s)", key);
+    if (this.localCache.has(key) && !(this.localCache.get(key) instanceof Array)) {
+      throw new Error("cannot apply on non Array");
+    }
+    this.localCache.set(key, []);
   }
-}
-
-// node_modules/@miqro/query/build/migrations/lib.js
-var lib_exports = {};
-__export(lib_exports, {
-  down: () => down,
-  getSortedMigrations: () => getMigrationFolderSortedFiles,
-  init: () => initMigrationsTable,
-  up: () => up
-});
-
-// node_modules/@miqro/query/build/migrations/utils.js
-var import_fs = require("fs");
-var import_path = require("path");
+};
 
-// node_modules/@miqro/query/build/migrations/constants.js
-var MIGRATIONS_TABLE_NAME = "migrations";
-var MIGRATIONS_SCHEMA = {
-  name: {
-    type: "string",
-    primaryKey: true,
-    allowNull: false
+// src/services/utils/websocketmanager.ts
+init_constants();
+var WebSocketManager = class {
+  runningGlobalWSMap = /* @__PURE__ */ new Map();
+  logger = null;
+  name;
+  avoidLogSocket;
+  constructor(options) {
+    this.onUpgrade = this.onUpgrade.bind(this);
+    this.logger = options && options.logger ? options.logger : null;
+    this.name = options && options.name ? options.name : "WebSocketManager";
+    this.avoidLogSocket = options && options.avoidLogSocket ? options.avoidLogSocket : false;
   }
-};
-var NULL_LOGGER = {
-  error: (...args) => {
-  },
-  log: (...args) => {
+  deleteWS(path) {
+    const ws = this.runningGlobalWSMap.get(path);
+    this.disconnectAllFrom(path);
+    ws.dispose();
+    this.runningGlobalWSMap.delete(path);
   }
-};
-
-// node_modules/@miqro/query/build/migrations/utils.js
-async function upMigrationFolder(db, migrationsFolderPath, logger, importFN) {
-  const startMS = Date.now();
-  logger?.log("\n\n====== [running migrations folder] ======\n====== [%s] ======\n", (0, import_path.relative)(process.cwd(), migrationsFolderPath));
-  await initMigrationsTable(db, NULL_LOGGER);
-  const migrations = getMigrationFolderSortedFiles(migrationsFolderPath);
-  for (const migrationName of migrations) {
-    const migrationPath = (0, import_path.resolve)(migrationsFolderPath, migrationName);
-    await upMigration(db, migrationPath, logger, importFN);
+  deleteAllWS() {
+    for (const path of this.runningGlobalWSMap.keys()) {
+      this.deleteWS(path);
+    }
   }
-  const took = Date.now() - startMS;
-  logger?.log("\n\n====== [running migrations folder done] ======\n====== [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationsFolderPath), took);
-  return migrations;
-}
-async function downMigrationFolder(db, migrationsFolderPath, logger, importFN) {
-  const startMS = Date.now();
-  logger?.log("\n\n====== [running migrations folder] ======\n====== [%s] ======\n", (0, import_path.relative)(process.cwd(), migrationsFolderPath));
-  await initMigrationsTable(db, NULL_LOGGER);
-  const migrations = getMigrationFolderSortedFiles(migrationsFolderPath).reverse();
-  for (const migrationName of migrations) {
-    const migrationPath = (0, import_path.resolve)(migrationsFolderPath, migrationName);
-    await downMigration(db, migrationPath, logger, importFN);
+  getWS(path) {
+    return this.runningGlobalWSMap.get(path);
+  }
+  replaceALLWS(list) {
+    this.deleteAllWS();
+    for (const wsConfig of list) {
+      if (!wsConfig.disabled) {
+        if (this.runningGlobalWSMap.has(wsConfig.path)) {
+          throw new Error(`ws on path ${wsConfig.path} already setup!`);
+        }
+        this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
+        const server2 = new ClusterWebSocketServer2(wsConfig.path, wsConfig);
+        this.runningGlobalWSMap.set(wsConfig.path, server2);
+      }
+    }
+  }
+  replaceALLWSBuLOGSocket(list) {
+    for (const path of this.runningGlobalWSMap.keys()) {
+      if (path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+        this.deleteWS(path);
+      }
+    }
+    for (const wsConfig of list) {
+      if (!wsConfig.disabled) {
+        if (wsConfig.path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+          if (this.runningGlobalWSMap.has(wsConfig.path)) {
+            throw new Error(`ws on path ${wsConfig.path} already setup!`);
+          }
+          this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
+          const server2 = new ClusterWebSocketServer2(this.name + wsConfig.path, wsConfig);
+          this.runningGlobalWSMap.set(wsConfig.path, server2);
+        }
+      }
+    }
   }
-  const took = Date.now() - startMS;
-  logger?.log("\n\n====== [running migrations folder done] ======\n====== [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationsFolderPath), took);
-  return migrations;
-}
-async function upMigration(db, migrationPath, logger, importFN) {
-  return runMigration(db, migrationPath, false, logger ? logger : db.config.logger, importFN);
-}
-async function upMigrationModule(db, migrationName, migrationModule, logger) {
-  return runMigrationModule(db, migrationName, migrationModule, false, logger ? logger : db.config.logger);
-}
-async function downMigrationModule(db, migrationName, migrationModule, logger) {
-  return runMigrationModule(db, migrationName, migrationModule, true, logger ? logger : db.config.logger);
-}
-async function downMigration(db, migrationPath, logger, importFN) {
-  return runMigration(db, migrationPath, true, logger ? logger : db.config.logger, importFN);
-}
-async function initMigrationsTable(db, logger) {
-  return db.createTable(MIGRATIONS_TABLE_NAME, MIGRATIONS_SCHEMA).ignoreDuplicates(true).yield(logger);
-}
-function getMigrationFolderSortedFiles(migrationsFolderPath) {
-  const files = (0, import_fs.readdirSync)(migrationsFolderPath);
-  return files.map((file) => {
-    const ext = (0, import_path.extname)(file);
-    if (ext === ".js" || ext === ".mjs" || ext === ".ts" || ext === ".tsx" || ext === ".tsx") {
-      const firstDash = file.indexOf("-");
-      if (firstDash !== -1) {
-        const number = parseInt(file.substring(0, firstDash), 10);
-        if (!isNaN(number)) {
-          return {
-            number,
-            file
-          };
+  /*public setupWS(path: string, server: ClusterWebSocketServer2) {
+    if (this.runningGlobalWSMap.has(path)) {
+      throw new Error(`ws on path ${path} already setup!`);
+    }
+    this.runningGlobalWSMap.set(path, server);
+  }*/
+  disconnectAllFrom(path) {
+    try {
+      this.logger?.debug("disconnect all from [%s]", path);
+      const ws = this.getWS(path);
+      if (ws) {
+        const clients = ws.clients.values();
+        if (clients) {
+          for (const client of clients) {
+            try {
+              client.socket.destroy();
+            } catch (e2) {
+              this.logger?.error("error disconnecting web socket client");
+              this.logger?.error(e2);
+            }
+          }
         }
       }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
     }
-    return {
-      number: 0,
-      file: ""
-    };
-  }).filter((file) => file.file !== "").sort((a, b) => {
-    return a.number - b.number;
-  }).map((file) => file.file);
-}
-async function runMigrationModule(db, migrationName, migrationModule, down2 = false, logger) {
-  const startMS = Date.now();
-  const alreadyRun = (await db.select().from(MIGRATIONS_TABLE_NAME).column("name").limit(1).eq("name", migrationName).yield(NULL_LOGGER)).length > 0;
-  if (down2) {
-    if (alreadyRun) {
-      logger?.log("		====== [%s] ======", (0, import_path.relative)(process.cwd(), migrationName));
-      await migrationModule.down(db, logger);
-      await db.delete(MIGRATIONS_TABLE_NAME).eq("name", migrationName).yield(NULL_LOGGER);
-      const took = Date.now() - startMS;
-      logger?.log("		====== [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationName), took);
-    } else {
-      const took = Date.now() - startMS;
-      logger?.log("		====== skipping down [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationName), took);
+  }
+  disconnectAllButLOGSocket() {
+    try {
+      for (const wsPath of this.runningGlobalWSMap.keys()) {
+        if (wsPath !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+          this.disconnectAllFrom(wsPath);
+        }
+      }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
     }
-  } else {
-    if (alreadyRun) {
-      const took = Date.now() - startMS;
-      logger?.log("		====== skipping up [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationName), took);
-    } else {
-      logger?.log("		====== [%s] ======", (0, import_path.relative)(process.cwd(), migrationName));
-      await migrationModule.up(db, logger);
-      await db.insert(MIGRATIONS_TABLE_NAME).column("name").value([{
-        name: migrationName
-      }]).ignoreDuplicates(true).yield(NULL_LOGGER);
-      const took = Date.now() - startMS;
-      logger?.log("		====== [%s] took [%s]ms ======\n", (0, import_path.relative)(process.cwd(), migrationName), took);
+  }
+  disconnectAll() {
+    try {
+      for (const wsPath of this.runningGlobalWSMap.keys()) {
+        this.disconnectAllFrom(wsPath);
+      }
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
+    }
+  }
+  onUpgrade(req, socket, head) {
+    try {
+      const wsServer = this.getWS(req.path);
+      if (wsServer) {
+        return wsServer.onUpgrade(req, socket, head);
+      } else {
+        socket.destroy();
+      }
+    } catch (e) {
+      this.logger?.error(e);
     }
   }
-}
-async function runMigration(db, migrationPath, down2 = false, logger, importFN) {
-  const migrationName = (0, import_path.basename)(migrationPath).substring(0, (0, import_path.basename)(migrationPath).length - (0, import_path.extname)(migrationPath).length);
-  const migrationModule = (await (importFN ? importFN(migrationPath) : import(migrationPath))).default;
-  return runMigrationModule(db, migrationName, migrationModule, down2, logger);
-}
-
-// node_modules/@miqro/query/build/migrations/lib.js
-var up = {
-  file: upMigration,
-  module: upMigrationModule,
-  folder: upMigrationFolder
-};
-var down = {
-  file: downMigration,
-  module: downMigrationModule,
-  folder: downMigrationFolder
 };
 
 // src/services/utils/db-manager.ts
+var import_node_cluster = __toESM(require("node:cluster"), 1);
 var DBManager = class {
   map = /* @__PURE__ */ new Map();
   options;
@@ -9187,6 +9201,18 @@ var DBManager = class {
       return db;
     }
   }
+  async connectAll() {
+    this.options?.logger?.debug("connection all db connections");
+    const tR = [];
+    for (const name of this.map.keys()) {
+      const db = this.map.get(name);
+      if (db && db.status === "disconnected") {
+        this.options?.logger?.debug("connecting db connection [%s]", name);
+        tR.push(db.connect());
+      }
+    }
+    await Promise.all(tR);
+  }
   async closeAll() {
     this.options?.logger?.debug("closing all db connections");
     for (const name of this.map.keys()) {
@@ -11699,15 +11725,6 @@ async function inflateJSX(inFile, options) {
     throw e;
   }
 }
-async function importAPIRoute(inFile, logger) {
-  const mod = (await importJSXFile(inFile, logger)).default;
-  const module2 = typeof mod === "function" ? { handler: mod } : parser2.parse(mod, APIRouteSchema, (0, import_node_path5.basename)(inFile));
-  if (module2 !== void 0) {
-    return module2;
-  } else {
-    throw new Error(`error with module [${inFile}] undefined`);
-  }
-}
 var APIOptionsSchema = {
   type: "object?",
   properties: {
@@ -11728,6 +11745,7 @@ var APIOptionsSchema = {
     },
     ...RouteOptionsSchema.properties
   }
+  //mode:"add_extra"
 };
 var HTMLModuleSchema = {
   type: "object",
@@ -11737,6 +11755,7 @@ var HTMLModuleSchema = {
     },
     apiOptions: APIOptionsSchema
   }
+  //mode:"add_extra"
 };
 var JSONModuleSchema = {
   type: "object",
@@ -11746,13 +11765,15 @@ var JSONModuleSchema = {
     },
     apiOptions: APIOptionsSchema
   }
+  //mode:"add_extra"
 };
 var MigrationSchema = {
   type: "object",
   properties: {
     up: "function",
     down: "function"
-  }
+  },
+  mode: "add_extra"
 };
 var CORSOptionsSchema = {
   type: "object",
@@ -11762,6 +11783,7 @@ var CORSOptionsSchema = {
     methods: "string?",
     preflightContinue: "boolean?"
   }
+  //mode:"add_extra"
 };
 var WSConfigSchema = {
   type: "object",
@@ -11774,6 +11796,7 @@ var WSConfigSchema = {
     onMessage: "function?",
     onDisconnect: "function?"
   }
+  //mode:"add_extra"
 };
 var DBConfigSchema = {
   type: "object",
@@ -11784,6 +11807,7 @@ var DBConfigSchema = {
     dialect: "string?",
     name: "string"
   }
+  //mode:"add_extra"
 };
 var ServerConfigSchema = {
   type: "object",
@@ -11794,6 +11818,7 @@ var ServerConfigSchema = {
     start: "function?",
     load: "function?"
   }
+  //mode:"add_extra"
 };
 var LogConfigSchema = {
   type: "object",
@@ -11806,13 +11831,24 @@ var LogConfigSchema = {
     replaceFileTransport: "boolean?",
     write: "function"
   }
+  //mode:"add_extra"
 };
 var AuthConfigSchema = {
   type: "object",
   properties: {
     ...SessionHandlerOptionsSchema.properties
   }
+  //mode:"add_extra"
 };
+async function importAPIRoute(inFile, logger) {
+  const mod = (await importJSXFile(inFile, logger)).default;
+  const module2 = typeof mod === "function" ? { handler: mod } : parser2.parse(mod, APIRouteSchema, (0, import_node_path5.basename)(inFile));
+  if (module2 !== void 0) {
+    return module2;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
 async function importMigrationModule(inFile, logger) {
   const module2 = parser2.parse((await importJSXFile(inFile, logger)).default, MigrationSchema, (0, import_node_path5.basename)(inFile));
   if (module2 !== void 0) {
@@ -11822,7 +11858,9 @@ async function importMigrationModule(inFile, logger) {
   }
 }
 async function importHTMLModule(inFile, logger) {
-  const module2 = parser2.parse(await importJSXFile(inFile, logger), HTMLModuleSchema, (0, import_node_path5.basename)(inFile));
+  const module2 = await importJSXFile(inFile, logger);
+  parser2.parse(module2.default, HTMLModuleSchema.properties.default, `${(0, import_node_path5.basename)(inFile)}.default`);
+  parser2.parse(module2.apiOptions, APIOptionsSchema, `${(0, import_node_path5.basename)(inFile)}.apiOptions`);
   if (module2 !== void 0) {
     return module2;
   } else {
@@ -11830,7 +11868,9 @@ async function importHTMLModule(inFile, logger) {
   }
 }
 async function importJSONModule(inFile, logger) {
-  const module2 = parser2.parse(await importJSXFile(inFile, logger), JSONModuleSchema, (0, import_node_path5.basename)(inFile));
+  const module2 = await importJSXFile(inFile, logger);
+  parser2.parse(module2.default, JSONModuleSchema.properties.default, `${(0, import_node_path5.basename)(inFile)}.default`);
+  parser2.parse(module2.apiOptions, APIOptionsSchema, `${(0, import_node_path5.basename)(inFile)}.apiOptions`);
   if (module2 !== void 0) {
     return module2;
   } else {
@@ -13170,6 +13210,11 @@ async function watchAndServer(app) {
   }
   watchLogger?.info("watching for changes on [%s]", app.options.services.join(","));
   reWatch();
+  return {
+    stopWatch: () => {
+      stopWatch();
+    }
+  };
 }
 
 // src/common/exit.ts
@@ -13326,9 +13371,6 @@ async function inflateDBMigrations(logger, service, dbName, inflateDir, errors)
   return false;
 }
 
-// src/services/app.ts
-var import_node_util3 = require("node:util");
-
 // src/services/utils/server-interface.ts
 var import_node_cluster2 = __toESM(require("node:cluster"), 1);
 var import_node_child_process2 = require("node:child_process");
@@ -13425,9 +13467,114 @@ function getPORT() {
   return checkEnvVariable("PORT", "8080");
 }
 
+// src/services/utils/log-transport.ts
+var import_node_util3 = require("node:util");
+init_constants();
+function createLogProviderOptions(app) {
+  const defaultConsole = ConsoleTransport();
+  const defaultFile = FileTransport();
+  const defaultWrite = async (args, level) => {
+    try {
+      const serviceNamesWithLogConfigReplaceConsole = level === void 0 && app.inflated ? Object.keys(app.inflated.logConfigMap).filter((serviceName) => app.inflated.logConfigMap[serviceName].replaceConsoleTransport) : [];
+      const serviceNamesWithLogConfigReplaceFile = level === void 0 && app.inflated ? Object.keys(app.inflated.logConfigMap).filter((serviceName) => app.inflated.logConfigMap[serviceName].replaceFileTransport) : [];
+      await Promise.allSettled((level === void 0 ? [
+        level === void 0 && serviceNamesWithLogConfigReplaceConsole.length === 0 ? defaultConsole.write(args) : Promise.resolve(),
+        level === void 0 && serviceNamesWithLogConfigReplaceFile.length === 0 ? defaultFile.write(args) : Promise.resolve()
+      ] : []).concat(
+        app.inflated ? Object.keys(app.inflated.logConfigMap).map((serviceName) => app.inflated.logConfigMap[serviceName]).filter((c) => c.level === level).map((c) => c.write(args)) : []
+      ));
+    } catch (e) {
+      console.error(e);
+    }
+  };
+  return {
+    name: app.options.name,
+    formatter: (args) => {
+      const params = args.optionalParams;
+      return (0, import_node_util3.format)(
+        `${(/* @__PURE__ */ new Date()).toISOString()} PID[${process.pid}] ${args.identifier ? `[${args.identifier}] ` : ""}${args.level !== "info" ? args.level === "error" || args.level === "warn" ? `[${args.level.toUpperCase()}] ` : `[${args.level}] ` : ""}${args.message}`,
+        ...params
+      );
+    },
+    transports: [
+      ...[void 0, "error", "warn", "info", "debug", "trace"].map((level) => {
+        return level ? {
+          level,
+          write: async (args) => {
+            await defaultWrite(args, level);
+          }
+        } : {
+          write: async (args) => {
+            await defaultWrite(args, void 0);
+          }
+        };
+      }),
+      {
+        level: "trace",
+        write: async (args) => {
+          try {
+            if (app.options.editor) {
+              try {
+                const ws = app.webSocketManager.getWS(LOG_SOCKET_PATH);
+                if (ws) {
+                  await ws.broadcast(JSON.stringify({
+                    type: LOG_WRITE_EVENT,
+                    level: args.level,
+                    identifier: args.identifier,
+                    out: args.out
+                  }));
+                }
+              } catch (e) {
+                console.error(e);
+              }
+            }
+          } catch (e) {
+            console.error(e);
+          }
+        }
+      }
+    ],
+    ...app.options.logProviderOptions ? app.options.logProviderOptions : {}
+  };
+}
+
+// src/services/utils/admin-interface.ts
+function createAdminInterface(app) {
+  const adminCache = new ClusterCache("EditorCache[" + app.options.name + "]");
+  return {
+    getCache: () => adminCache,
+    stop: () => app.stop(),
+    restart: () => app.restart(),
+    reload: () => app.reload(),
+    getHotReloadHTML: getHotReloadScript,
+    getMigrations: () => {
+      if (app.inflated) {
+        const ret = [];
+        for (const db of app.inflated.dbList) {
+          for (const m of db.migrations) {
+            ret.push(m);
+          }
+        }
+        return ret;
+      }
+      return [];
+    },
+    getServices: () => {
+      return app.options.services;
+    },
+    getRouteFileMap: () => {
+      return app.inflated ? app.inflated.fileMap : {};
+    },
+    getInflateErrors: () => {
+      return app.inflated ? app.inflated.errors : [];
+    }
+  };
+}
+
 // src/services/app.ts
 var MiqroApplicationMessageType = "$$$MiqroApplicationMessageType$$$";
 var Miqro = class _Miqro {
+  status = "stopped";
   options;
   server = null;
   cache;
@@ -13442,6 +13589,7 @@ var Miqro = class _Miqro {
   logger;
   loggerProvider;
   static initAssetsPromise = null;
+  watcher;
   constructor(options) {
     this.options = {
       editor: false,
@@ -13450,65 +13598,7 @@ var Miqro = class _Miqro {
       services: [],
       ...options ? options : {}
     };
-    const defaultConsole = ConsoleTransport();
-    const defaultFile = FileTransport();
-    const defaultWrite = async (args, level) => {
-      try {
-        const serviceNamesWithLogConfigReplaceConsole = level === void 0 && this.inflated ? Object.keys(this.inflated.logConfigMap).filter((serviceName) => this.inflated.logConfigMap[serviceName].replaceConsoleTransport) : [];
-        const serviceNamesWithLogConfigReplaceFile = level === void 0 && this.inflated ? Object.keys(this.inflated.logConfigMap).filter((serviceName) => this.inflated.logConfigMap[serviceName].replaceFileTransport) : [];
-        await Promise.allSettled((level === void 0 ? [
-          level === void 0 && serviceNamesWithLogConfigReplaceConsole.length === 0 ? defaultConsole.write(args) : Promise.resolve(),
-          level === void 0 && serviceNamesWithLogConfigReplaceFile.length === 0 ? defaultFile.write(args) : Promise.resolve()
-        ] : []).concat(
-          this.inflated ? Object.keys(this.inflated.logConfigMap).map((serviceName) => this.inflated.logConfigMap[serviceName]).filter((c) => c.level === level).map((c) => c.write(args)) : []
-        ));
-      } catch (e) {
-        console.error(e);
-      }
-    };
-    this.loggerProvider = new LogProvider({
-      name: this.options.name,
-      formatter: ({ identifier, level, message, optionalParams }) => (0, import_node_util3.format)(`${(/* @__PURE__ */ new Date()).toISOString()} PID[${process.pid}] ${identifier ? `[${identifier}] ` : ""}${level !== "info" ? level === "error" || level === "warn" ? `[${level.toUpperCase()}] ` : `[${level}] ` : ""}${message}`, ...optionalParams),
-      transports: [
-        ...[void 0, "error", "warn", "info", "debug", "trace"].map((level) => {
-          return level ? {
-            level,
-            write: async (args) => {
-              await defaultWrite(args, level);
-            }
-          } : {
-            write: async (args) => {
-              await defaultWrite(args, void 0);
-            }
-          };
-        }),
-        {
-          level: "trace",
-          write: async (args) => {
-            try {
-              if (this.options.editor) {
-                try {
-                  const ws = this.webSocketManager.getWS(LOG_SOCKET_PATH);
-                  if (ws) {
-                    await ws.broadcast(JSON.stringify({
-                      type: LOG_WRITE_EVENT,
-                      level: args.level,
-                      identifier: args.identifier,
-                      out: args.out
-                    }));
-                  }
-                } catch (e) {
-                  console.error(e);
-                }
-              }
-            } catch (e) {
-              console.error(e);
-            }
-          }
-        }
-      ],
-      ...this.options.logProviderOptions ? this.options.logProviderOptions : {}
-    });
+    this.loggerProvider = new LogProvider(createLogProviderOptions(this));
     const SERVER_IDENTIFIER = import_node_cluster3.default.isPrimary ? "" : process.env["CLUSTER_NODE_NUMBER"] ? `WORKER_${process.env["CLUSTER_NODE_NUMBER"]}`.toUpperCase() : `WORKER`;
     this.logger = this.options.logger ? this.options.logger : this.loggerProvider.getLogger(SERVER_IDENTIFIER);
     this.listener = async (data) => {
@@ -13554,56 +13644,26 @@ var Miqro = class _Miqro {
       port: this.options.port
     });
     this.serverRequestHandler = ServerRequestHandler(this.serverInterface);
-    const adminCache = new ClusterCache("EditorCache[" + this.options.name + "]");
-    this.adminInterface = {
-      getCache: () => adminCache,
-      stop: () => this.stop(),
-      restart: () => this.restart(),
-      reload: () => this.reload(),
-      getHotReloadHTML: getHotReloadScript,
-      getMigrations: () => {
-        if (this.inflated) {
-          const ret = [];
-          for (const db of this.inflated.dbList) {
-            for (const m of db.migrations) {
-              ret.push(m);
-            }
-          }
-          return ret;
-        }
-        return [];
-      },
-      getServices: () => {
-        return this.options.services;
-      },
-      getRouteFileMap: () => {
-        return this.inflated ? this.inflated.fileMap : {};
-      },
-      getInflateErrors: () => {
-        return this.inflated ? this.inflated.errors : [];
-      }
-      /*,
-      inflateJSX: async function inflateJSX(path, minify: boolean = true) {
-        return realInflateJSX(path, {
-          embemedJSX: true,
-          minify,
-          useExport: true
-        });
-      }*/
-    };
+    this.adminInterface = createAdminInterface(this);
     setupExitHandlers(this);
+  }
+  connect() {
     if (process.send) {
+      process.removeListener("message", this.listener);
       process.on("message", this.listener);
     }
+    this.cache.connect();
+    this.adminInterface?.getCache()?.connect();
   }
-  dispose() {
+  disconnect() {
     if (this.server !== null) {
       throw new Error("already running! call stop() first");
     }
     if (process.send) {
       process.removeListener("message", this.listener);
     }
-    this.cache.dispose();
+    this.cache.disconnect();
+    this.adminInterface?.getCache()?.disconnect();
     this.webSocketManager.disconnectAll();
     this.dbManager.closeAll();
   }
@@ -13773,14 +13833,17 @@ var Miqro = class _Miqro {
     this.inflated = null;
   }
   async start() {
-    if (this.server !== null) {
+    if (this.server !== null || this.status !== "stopped") {
       throw new Error("cannot start app already running.");
     }
     if (!this.isInflated()) {
       throw new Error("cannot start uninflated app. call await app.inflate() first.");
     }
     this.logger?.debug("		==start==");
+    this.status = "starting";
     this.server = void 0;
+    this.connect();
+    await this.dbManager.connectAll();
     this.server = new App({
       onUpgrade: (req, socket, head) => {
         req.server = this.serverInterface;
@@ -13811,17 +13874,24 @@ var Miqro = class _Miqro {
     }
     await notifiyServerConfig(this.logger, this.serverInterface, this.adminInterface, this.inflated.serverConfigMap, "start");
     if (this.options.hotreload && (import_node_cluster3.default.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0")) {
-      await watchAndServer(this);
+      this.watcher = await watchAndServer(this);
     }
     this.logger?.debug("		==start done==");
+    this.status = "started";
     return this.inflated.errors && this.inflated.errors.length > 0 ? this.inflated.errors : null;
   }
   async stop() {
-    if (!this.server || !this.inflated) {
+    if (!this.server || !this.inflated || this.status !== "started") {
       throw new Error("cannot stop server not running");
     }
+    this.status = "stopping";
+    if (this.watcher) {
+      this.watcher.stopWatch();
+      this.watcher = null;
+    }
     const server2 = this.server;
     this.server = null;
+    this.disconnect();
     this.logger?.debug("		==stop==");
     this.logger?.debug("clear running server routes");
     server2.clear();
@@ -13831,13 +13901,14 @@ var Miqro = class _Miqro {
     notifiyServerConfigSync(this, "unload");
     this.logger?.debug("stopping");
     const p = server2.close();
-    notifiyServerConfigSync(this, "stop");
     await p;
     await pD;
+    this.status = "stopped";
+    notifiyServerConfigSync(this, "stop");
     this.logger?.debug("		==stop done==");
   }
   async restart(avoidSend) {
-    if (!this.server || !this.inflated) {
+    if (!this.server || !this.inflated || this.status !== "started") {
       throw new Error("cannot start server not running");
     }
     this.logger?.debug("		==restart==");
@@ -13855,9 +13926,10 @@ var Miqro = class _Miqro {
     return ret;
   }
   async reload(avoidSend) {
-    if (!this.server || !this.inflated) {
+    if (!this.server || !this.inflated || this.status !== "started") {
       throw new Error("cannot reload server not running");
     }
+    this.status = "reloading";
     if (!avoidSend) {
       this.logger?.debug("		==reload==");
     } else {
@@ -13900,6 +13972,7 @@ var Miqro = class _Miqro {
       });
     }
     this.logger?.debug("		==reload done==");
+    this.status = "started";
     return this.inflated.errors && this.inflated.errors.length > 0 ? this.inflated.errors : null;
   }
 };