miqro 6.0.10 → 6.0.11

package/build/lib.cjs

@@ -7068,2114 +7068,2112 @@ 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);
-        }
+// node_modules/@miqro/query/build/executors/sqlite3/utils.js
+function sqlite3ExecutorPrepare(args) {
+  switch (args._type) {
+    case "delete": {
+      const q = args;
+      const where = getWhereStatement(q);
+      const returing = q._returning.length === 0 ? "*" : q._returning.join(",");
+      const whereSQL = where.sql !== "" ? ` WHERE ${where.sql}` : "";
+      const sql = `DELETE FROM ${q._table}${whereSQL}${getOrderBy(q._orderBy)}${getLimit(q._limitBy, q._offsetBy)} RETURNING ${returing}`;
+      return {
+        sql,
+        values: where.values
+      };
+    }
+    case "create-database": {
+      const q = args;
+      const sql = `CREATE DATABASE ${q._dbName}`;
+      return sql;
+    }
+    case "create-table": {
+      const q = args;
+      const sql = `CREATE TABLE${q._ignoreDuplicate ? " IF NOT EXISTS" : ""} ${q._table}${getCreateTableColumns(q._definition)}`;
+      return sql;
+    }
+    case "drop-database": {
+      const q = args;
+      const sql = `DROP DATABASE${q._ignoreDuplicate ? " IF EXISTS" : ""} ${q._dbName}`;
+      return sql;
+    }
+    case "drop-table": {
+      const q = args;
+      const sql = `DROP TABLE${q._ignoreDuplicate ? " IF EXISTS" : ""} ${q._table}`;
+      return sql;
+    }
+    case "alter-table": {
+      const q = args;
+      let alters = [];
+      if (q._renameTable) {
+        alters.push({
+          sql: `ALTER TABLE ${q._table} RENAME TO ?`,
+          values: [q._renameTable]
+        });
       }
-    });
-    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;
+      for (let l of q._changes) {
+        switch (l._action) {
+          case "add":
+            if (!l._definition) {
+              throw new Error("unsupported alter action add without definition");
             }
-            default:
-              throw new Error(`action [${msg.action}] not supported`);
-          }
+            alters.push({
+              sql: `ALTER TABLE ${q._table} ADD COLUMN ${getCreateTableColumn(l._column, l._definition, [])}`
+            });
+            break;
+          case "drop":
+            alters.push({
+              sql: `ALTER TABLE ${q._table} DROP COLUMN ${l._column}`
+            });
+            break;
+          case "rename":
+            alters.push({
+              sql: `ALTER TABLE ${q._table} RENAME COLUMN ${l._column} TO ${l._newName}`
+            });
+            break;
+          default:
+            throw new Error("unsupported alter action");
         }
-      } 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
-      });
+      return alters;
     }
-  }
-  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
-      });
+    case "insert": {
+      const q = args;
+      const rows = getInsertValues(q._columns, q._values);
+      const returing = q._returning.length === 0 ? "*" : q._returning.join(",");
+      const sql = `INSERT${q._ignoreDuplicate ? " OR IGNORE" : ""} INTO ${q._table}${getInsertColumns(q._columns)}${rows.sql} RETURNING ${returing}`;
+      return [{
+        sql,
+        values: rows.values
+      }];
     }
-    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;
+    case "count":
+    case "select": {
+      const isSelect = args._type === "select";
+      const q = isSelect ? args : args;
+      const where = getWhereStatement(q);
+      const columnsSQL = isSelect ? `SELECT ${renderNameAS(q._columns)}` : "SELECT count(*) as count";
+      const whereSQL = where.sql !== "" ? ` WHERE ${where.sql}` : "";
+      const fromSQL = ` FROM ${renderNameAS(q._selectFrom)}`;
+      const join9 = q._joins.map((j) => getJoin(j));
+      const joinValues = join9.reduce(function(ret, current) {
+        ret = ret.concat(current.values);
+        return ret;
+      }, []);
+      const joinSQL = join9.map((j) => j.sql).join(" ");
+      const sql = `${columnsSQL}${fromSQL}${joinSQL}${whereSQL}${getGroupBy(q._groupBy)}${getOrderBy(q._orderBy)}${getLimit(q._limitBy, q._offsetBy)}`;
+      return [{
+        sql,
+        values: joinValues.concat(where.values)
+      }];
+    }
+    case "update": {
+      const q = args;
+      if (!q._sets || !q._table) {
+        throw new Error(`invalid ${args._type} with [${q._table}] and [${q._sets.join(",")}]`);
       }
+      if (q._sets.length === 0) {
+        throw new Error(`invalid ${args._type} with [${q._table}] and [${q._sets.join(",")}]`);
+      }
+      const returing = q._returning.length === 0 ? "*" : q._returning.join(",");
+      const where = getWhereStatement(q);
+      const whereSQL = where.sql !== "" ? ` WHERE ${where.sql}` : "";
+      const setSQL = ` SET ${q._sets.map((set) => `${set.column}=?`)}`;
+      const sql = `UPDATE ${q._table}${setSQL}${whereSQL}${getOrderBy(q._orderBy)}${getLimit(q._limitBy, q._offsetBy)} RETURNING ${returing}`;
+      return [{
+        sql,
+        values: q._sets.map((set) => set.value).concat(where.values)
+      }];
     }
-    if (this.clients.has(clientUUID)) {
-      return super.writeTo(clientUUID, payload);
-    }
+    default:
+      throw new Error(`unsupported ${args}`);
   }
-  isUUIDValid(uuid) {
-    return !this.clients.has(uuid) && !this.remoteClients.has(uuid);
+}
+function getJoin(join9) {
+  const wherePrepare = getWhereStatement(join9._on);
+  return {
+    sql: ` ${join9._verb ? `${join9._verb} ` : ""}JOIN ${renderNameAS(join9._table)} ON ${wherePrepare.sql}`,
+    values: wherePrepare.values
+  };
+}
+function getWhereFilterColumnName(filter) {
+  if (filter._column === void 0 || filter._value === void 0) {
+    throw new Error(`unsupported where filter ${filter._type} with ${filter._column} and ${filter._value}`);
   }
-};
-
-// 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;
-            }
-          }
+  return filter;
+}
+function getWhereStatement(where) {
+  const filters = where._filters;
+  let ret = {
+    sql: "",
+    values: []
+  };
+  filters.map((filter) => {
+    const where2 = filter._where;
+    switch (filter._type) {
+      case "where":
+      case "and": {
+        if (where2 === void 0) {
+          throw new Error(`unsupported where filter ${filter._type} with ${where2}`);
         }
-      } catch (e) {
-        this.logger?.error(e);
+        const prepare = mergePrepareArgs({
+          sql: "",
+          values: []
+        }, (where2 instanceof Array ? where2 : [where2]).map((w) => getWhereStatement(w)));
+        if (prepare.sql !== "") {
+          ret = mergePrepareArgs(ret, {
+            sql: `(${prepare.sql})`,
+            values: prepare.values
+          });
+        }
+        break;
       }
-    };
-    this.connect();
-  }
-  localCache = /* @__PURE__ */ new Map();
-  //private logger: Logger;
-  listener;
-  connect() {
-    if (process.send) {
-      process.removeListener("message", this.listener);
-      process.on("message", this.listener);
-    }
-  }
-  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
+      case "literal": {
+        const literal = filter._literal;
+        if (literal === void 0) {
+          throw new Error(`unsupported where filter ${filter._type} with ${literal}`);
+        }
+        ret = mergePrepareArgs(ret, {
+          sql: `${literal}`,
+          values: []
         });
-      }, 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
+        break;
+      }
+      case "or": {
+        if (where2 === void 0) {
+          throw new Error(`unsupported where filter ${filter._type} with ${where2}`);
+        }
+        const prepare = mergePrepareArgs({
+          sql: "",
+          values: []
+        }, (where2 instanceof Array ? where2 : [where2]).map((w) => getWhereStatement(w)), " OR ");
+        ret = mergePrepareArgs(ret, {
+          sql: `(${prepare.sql})`,
+          values: prepare.values
         });
-      }, 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
+        break;
+      }
+      case "nin": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_column)} not in (${_value.map((v) => "?").join(",")})`,
+          values: _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
+        break;
+      }
+      case "in": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_column)} in (${_value.map((v) => "?").join(",")})`,
+          values: _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
+        break;
+      }
+      case "equal": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_column)}=?`,
+          values: [_value]
         });
-      }, 10);
+        break;
+      }
+      case "gt": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_column)}>?`,
+          values: [_value]
+        });
+        break;
+      }
+      case "gte": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_value)}>=?`,
+          values: [_value]
+        });
+        break;
+      }
+      case "lt": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_column)}<?`,
+          values: [_value]
+        });
+        break;
+      }
+      case "lte": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_column)}<=?`,
+          values: [_value]
+        });
+        break;
+      }
+      case "neq": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_column)}<>?`,
+          values: [_value]
+        });
+        break;
+      }
+      case "like": {
+        const { _column, _value } = getWhereFilterColumnName(filter);
+        ret = mergePrepareArgs(ret, {
+          sql: `${renderColumn(_column)} LIKE ?`,
+          values: [_value]
+        });
+        break;
+      }
+      default:
+        throw new Error(`unsupported where filter ${filter._type}`);
     }
+  });
+  return ret;
+}
+function getCreateTableColumns(definition) {
+  const columnNames = Object.keys(definition);
+  const primaryKeyColumns = columnNames.filter((columnName) => definition[columnName].primaryKey);
+  return `(${columnNames.map((columnName) => {
+    const def = definition[columnName];
+    return getCreateTableColumn(columnName, def, primaryKeyColumns);
+  }).concat(primaryKeyColumns.length > 1 ? [
+    `PRIMARY KEY( ${primaryKeyColumns.join(",")} )`
+  ] : []).join(", ")})`;
+}
+function getCreateTableColumn(columnName, def, primaryKeyColumns) {
+  const primaryKey = primaryKeyColumns.length === 1 && columnName === primaryKeyColumns[0] ? " PRIMARY KEY" : "";
+  const notNull = `${def.allowNull == false ? " NOT NULL" : ""}`;
+  const defaultValue = `${def.defaultValue !== void 0 ? ` DEFAULT '${def.defaultValue}'` : ""}`;
+  const autoIncrement = `${def.autoIncrement !== void 0 && def.autoIncrement === true ? ` AUTOINCREMENT` : ""}`;
+  switch (def.type) {
+    case "datetime":
+      return `${columnName} DATETIME${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
+    case "boolean":
+      return `${columnName} TINYINT${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
+    case "json":
+    case "string":
+      return `${columnName} TEXT${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
+    case "real":
+      return `${columnName} REAL${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
+    case "bigint":
+    case "integer":
+      return `${columnName} INTEGER${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
+    default:
+      throw new Error("unsupported type " + def.type);
   }
-  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, []);
+}
+function getInsertColumns(columns) {
+  return `(${columns.join(",")})`;
+}
+function getInsertValues(columns, values) {
+  let args = [];
+  for (const v of values) {
+    args = args.concat(columns.map((c) => v[c]));
   }
-};
+  return {
+    sql: ` VALUES ${values.map(() => `(${columns.map(() => "?").join(", ")})`)}`,
+    values: args
+  };
+}
+function renderNameAS(input, join9 = ", ") {
+  const list = input instanceof Array ? input : [input];
+  return list.map((i) => typeof i === "string" ? i : `${i.name} AS ${i.as}`).join(join9);
+}
+function getGroupBy(groupBy) {
+  return groupBy.length > 0 ? ` GROUP BY ${groupBy.join(",")}` : "";
+}
+function getOrderBy(orderBy) {
+  return orderBy.length > 0 ? ` ORDER BY ${orderBy.map((o) => `${o.column} ${o.mode}`).join(",")}` : "";
+}
+function getLimit(limit, offsetBy) {
+  return `${limit !== void 0 ? ` LIMIT ${limit}` : ""}${offsetBy ? ` OFFSET ${offsetBy}` : ""}`;
+}
+function renderColumn(column) {
+  return column;
+}
+function mergePrepareArgs(to, merge, concatOperator = " AND ") {
+  return (merge instanceof Array ? merge : [merge]).reduce((current, value) => {
+    if (current.sql !== "") {
+      current.sql += concatOperator;
+    }
+    current.sql += value.sql;
+    current.values = !value.values ? current.values : (current.values ? current.values : []).concat(value.values);
+    return current;
+  }, to);
+}
 
-// 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);
+// node_modules/@miqro/query/build/executors/parser.js
+var parser = new Parser();
+function assertNotUndefined2(obj) {
+  if (obj === void 0) {
+    throw new Error("validation failed");
   }
-  unset(key) {
-    this.logger?.trace("unset(%s)", key);
-    this.localCache.delete(key);
+  return obj;
+}
+var DATABASE_CONFIG_SCHEMA = {
+  type: "object",
+  properties: {
+    executor: {
+      type: "object?",
+      mode: "add_extra",
+      properties: {
+        prepare: "function",
+        query: "function",
+        disconnect: "function"
+      }
+    },
+    logger: {
+      type: "object?",
+      mode: "add_extra",
+      properties: {
+        log: "function?",
+        error: "function?"
+      }
+    },
+    storage: "string?",
+    connectionString: "string?",
+    dialect: {
+      type: "enum?",
+      enumValues: ["node:sqlite", "sqlite3-cli", "sqlite3", "pg"]
+    }
   }
-  has(key) {
-    this.logger?.trace("has(%s)", key);
-    return this.localCache.has(key);
+};
+var ColumnDefinitionTypeSchema = {
+  type: "enum",
+  enumValues: ["string", "integer", "boolean", "datetime", "json", "real", "bigint"]
+};
+var ColumnDefinitionSchema = {
+  type: "object",
+  properties: {
+    type: ColumnDefinitionTypeSchema,
+    primaryKey: "boolean?",
+    autoIncrement: "boolean?",
+    allowNull: "boolean?",
+    defaultValue: "any?"
   }
-  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);
+};
+parser.register("ColumnDefinition", ColumnDefinitionSchema);
+var TableSchemaSchema = {
+  type: "dict",
+  dictType: "ColumnDefinition"
+};
+
+// node_modules/@miqro/query/build/executors/sqlite3/lib.js
+var SQLITE_CONFIG_SCHEMA = {
+  type: "object",
+  mode: "remove_extra",
+  properties: {
+    storage: "string"
   }
-  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);
+};
+async function sqlite3Executor(config) {
+  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA);
+  if (!databaseOptions) {
+    throw new Error("config not valid");
   }
-  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");
+  const sqlite3 = await import("sqlite3");
+  const driver = new sqlite3.default.Database(databaseOptions.storage);
+  return {
+    disconnect: async function sqlite3ExecutorDisconnect() {
+      await driver.close();
+    },
+    prepare: sqlite3ExecutorPrepare,
+    query: async function sqlite3Executor2(sql, values) {
+      return new Promise((resolve20, reject) => {
+        const st = driver.prepare(sql, values, function(error2) {
+          if (error2) {
+            reject(error2);
+          } else {
+            st.all(function(error3, rows) {
+              if (error3) {
+                reject(error3);
+              } else {
+                st.finalize((error4) => {
+                  if (error4) {
+                    reject(error4);
+                  } else {
+                    resolve20(rows);
+                  }
+                });
+              }
+            });
+          }
+        });
+      });
     }
-    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;
-  }
-  deleteWS(path) {
-    const ws = this.runningGlobalWSMap.get(path);
-    this.disconnectAllFrom(path);
-    ws.dispose();
-    this.runningGlobalWSMap.delete(path);
-  }
-  deleteAllWS() {
-    for (const path of this.runningGlobalWSMap.keys()) {
-      this.deleteWS(path);
-    }
+// node_modules/@miqro/query/build/executors/pg/lib.js
+var PG_DATABASE_CONFIG_SCHEMA = {
+  type: "object",
+  mode: "remove_extra",
+  properties: {
+    connectionString: "string"
   }
-  getWS(path) {
-    return this.runningGlobalWSMap.get(path);
+};
+async function postgresExecutor(config) {
+  const databaseOptions = parser.parse(config, PG_DATABASE_CONFIG_SCHEMA);
+  if (!databaseOptions) {
+    throw new Error("bad options");
   }
-  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!`);
+  const pg = await import("pg");
+  const driver = new pg.default.Client({
+    connectionString: databaseOptions.connectionString
+    // "postgresql://postgres:password@localhost:5432/db"
+  });
+  await driver.connect();
+  return {
+    disconnect: async function postgresExecutorDisconnect() {
+      await driver.end();
+    },
+    prepare: function postgresExecutorPrepare(args) {
+      switch (args._type) {
+        case "create-table": {
+          const q = args;
+          const sql = `CREATE TABLE${q._ignoreDuplicate ? " IF NOT EXISTS" : ""} ${q._table}${getCreateTableColumns2(q._definition)}`;
+          return sql;
         }
-        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);
+        case "insert": {
+          const q = args;
+          const rows = getInsertValues(q._columns, q._values);
+          const returing = q._returning.length === 0 ? "*" : q._returning.join(",");
+          const sql = `INSERT INTO ${q._table}${getInsertColumns(q._columns)}${rows.sql} ${q._ignoreDuplicate ? "ON CONFLICT DO NOTHING " : ""}RETURNING ${returing}`;
+          return {
+            sql,
+            values: rows.values
+          };
         }
-      }
-    }
-  }
-  /*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);
+        case "alter-table": {
+          const q = args;
+          let alters = [];
+          if (q._renameTable) {
+            alters.push({
+              sql: `ALTER TABLE ${q._table} RENAME TO ?`,
+              values: [q._renameTable]
+            });
+          }
+          for (let l of q._changes) {
+            switch (l._action) {
+              case "add":
+                if (!l._definition) {
+                  throw new Error("unsupported alter action add without definition");
+                }
+                alters.push({
+                  sql: `ALTER TABLE ${q._table} ADD COLUMN ${getCreateTableColumn2(l._column, l._definition, [])}`
+                });
+                break;
+              case "drop":
+                alters.push({
+                  sql: `ALTER TABLE ${q._table} DROP COLUMN ${l._column}`
+                });
+                break;
+              case "rename":
+                alters.push({
+                  sql: `ALTER TABLE ${q._table} RENAME COLUMN ${l._column} TO ${l._newName}`
+                });
+                break;
+              default:
+                throw new Error("unsupported alter action");
             }
           }
+          return alters;
         }
+        default:
+          return sqlite3ExecutorPrepare(args);
       }
-    } 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);
-        }
+    },
+    query: async function postgresExecutor2(sql, values) {
+      try {
+        const result = await driver.query(tokens2Postgres(sql, values), values);
+        return result.rows;
+      } catch (e) {
+        throw e;
       }
-    } catch (e) {
-      this.logger?.error("error disconnecting web socket clients");
-      this.logger?.error(e.message);
     }
+  };
+}
+function getCreateTableColumns2(definition) {
+  const columnNames = Object.keys(definition);
+  const primaryKeyColumns = columnNames.filter((columnName) => definition[columnName].primaryKey);
+  return `(${columnNames.map((columnName) => {
+    const def = definition[columnName];
+    return getCreateTableColumn2(columnName, def, primaryKeyColumns);
+  }).concat(primaryKeyColumns.length > 1 ? [
+    `PRIMARY KEY( ${primaryKeyColumns.join(",")} )`
+  ] : []).join(", ")})`;
+}
+function getCreateTableColumn2(columnName, def, primaryKeyColumns) {
+  const primaryKey = primaryKeyColumns.length === 1 && columnName === primaryKeyColumns[0] ? " PRIMARY KEY" : "";
+  const notNull = `${def.allowNull == false ? " NOT NULL" : ""}`;
+  const defaultValue = `${def.defaultValue !== void 0 ? ` DEFAULT '${def.defaultValue}'` : ""}`;
+  if (def.autoIncrement) {
+    return `${columnName} BIGSERIAL${primaryKey}`;
   }
-  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);
-    }
+  switch (def.type) {
+    case "datetime":
+      return `${columnName} TIMESTAMP${primaryKey}${notNull}${defaultValue}`;
+    case "boolean":
+      return `${columnName} BOOLEAN${primaryKey}${notNull}${defaultValue}`;
+    case "real":
+      return `${columnName} REAL${primaryKey}${notNull}${defaultValue}`;
+    case "json":
+    case "string":
+      return `${columnName} TEXT${primaryKey}${notNull}${defaultValue}`;
+    case "bigint":
+      return `${columnName} bigint${primaryKey}${notNull}${defaultValue}`;
+    case "integer":
+      return `${columnName} INTEGER${primaryKey}${notNull}${defaultValue}`;
+    default:
+      throw new Error("unsupported type " + def.type);
   }
-  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);
+}
+function tokens2Postgres(inSql, values) {
+  let i = 0;
+  const sql = inSql.replaceAll("?", (string) => {
+    i++;
+    return `$${i}`;
+  });
+  if (i !== (values ? values.length : 0)) {
+    throw new Error("invalid char '?'");
+  }
+  let iSum = 0;
+  for (const c of sql) {
+    if (c === "$") {
+      iSum++;
     }
   }
-};
-
-// src/services/utils/db-manager.ts
-var import_node_cluster = __toESM(require("node:cluster"), 1);
+  if (iSum !== i) {
+    throw new Error("invalid char '$'");
+  }
+  return sql;
+}
 
-// node_modules/@miqro/query/build/executors/sqlite3/utils.js
-function sqlite3ExecutorPrepare(args) {
-  switch (args._type) {
-    case "delete": {
-      const q = args;
-      const where = getWhereStatement(q);
-      const returing = q._returning.length === 0 ? "*" : q._returning.join(",");
-      const whereSQL = where.sql !== "" ? ` WHERE ${where.sql}` : "";
-      const sql = `DELETE FROM ${q._table}${whereSQL}${getOrderBy(q._orderBy)}${getLimit(q._limitBy, q._offsetBy)} RETURNING ${returing}`;
-      return {
-        sql,
-        values: where.values
-      };
-    }
-    case "create-database": {
-      const q = args;
-      const sql = `CREATE DATABASE ${q._dbName}`;
-      return sql;
-    }
-    case "create-table": {
-      const q = args;
-      const sql = `CREATE TABLE${q._ignoreDuplicate ? " IF NOT EXISTS" : ""} ${q._table}${getCreateTableColumns(q._definition)}`;
-      return sql;
-    }
-    case "drop-database": {
-      const q = args;
-      const sql = `DROP DATABASE${q._ignoreDuplicate ? " IF EXISTS" : ""} ${q._dbName}`;
-      return sql;
-    }
-    case "drop-table": {
-      const q = args;
-      const sql = `DROP TABLE${q._ignoreDuplicate ? " IF EXISTS" : ""} ${q._table}`;
-      return sql;
-    }
-    case "alter-table": {
-      const q = args;
-      let alters = [];
-      if (q._renameTable) {
-        alters.push({
-          sql: `ALTER TABLE ${q._table} RENAME TO ?`,
-          values: [q._renameTable]
-        });
-      }
-      for (let l of q._changes) {
-        switch (l._action) {
-          case "add":
-            if (!l._definition) {
-              throw new Error("unsupported alter action add without definition");
-            }
-            alters.push({
-              sql: `ALTER TABLE ${q._table} ADD COLUMN ${getCreateTableColumn(l._column, l._definition, [])}`
-            });
-            break;
-          case "drop":
-            alters.push({
-              sql: `ALTER TABLE ${q._table} DROP COLUMN ${l._column}`
-            });
-            break;
-          case "rename":
-            alters.push({
-              sql: `ALTER TABLE ${q._table} RENAME COLUMN ${l._column} TO ${l._newName}`
-            });
-            break;
-          default:
-            throw new Error("unsupported alter action");
-        }
-      }
-      return alters;
-    }
-    case "insert": {
-      const q = args;
-      const rows = getInsertValues(q._columns, q._values);
-      const returing = q._returning.length === 0 ? "*" : q._returning.join(",");
-      const sql = `INSERT${q._ignoreDuplicate ? " OR IGNORE" : ""} INTO ${q._table}${getInsertColumns(q._columns)}${rows.sql} RETURNING ${returing}`;
-      return [{
-        sql,
-        values: rows.values
-      }];
-    }
-    case "count":
-    case "select": {
-      const isSelect = args._type === "select";
-      const q = isSelect ? args : args;
-      const where = getWhereStatement(q);
-      const columnsSQL = isSelect ? `SELECT ${renderNameAS(q._columns)}` : "SELECT count(*) as count";
-      const whereSQL = where.sql !== "" ? ` WHERE ${where.sql}` : "";
-      const fromSQL = ` FROM ${renderNameAS(q._selectFrom)}`;
-      const join9 = q._joins.map((j) => getJoin(j));
-      const joinValues = join9.reduce(function(ret, current) {
-        ret = ret.concat(current.values);
-        return ret;
-      }, []);
-      const joinSQL = join9.map((j) => j.sql).join(" ");
-      const sql = `${columnsSQL}${fromSQL}${joinSQL}${whereSQL}${getGroupBy(q._groupBy)}${getOrderBy(q._orderBy)}${getLimit(q._limitBy, q._offsetBy)}`;
-      return [{
-        sql,
-        values: joinValues.concat(where.values)
-      }];
-    }
-    case "update": {
-      const q = args;
-      if (!q._sets || !q._table) {
-        throw new Error(`invalid ${args._type} with [${q._table}] and [${q._sets.join(",")}]`);
-      }
-      if (q._sets.length === 0) {
-        throw new Error(`invalid ${args._type} with [${q._table}] and [${q._sets.join(",")}]`);
-      }
-      const returing = q._returning.length === 0 ? "*" : q._returning.join(",");
-      const where = getWhereStatement(q);
-      const whereSQL = where.sql !== "" ? ` WHERE ${where.sql}` : "";
-      const setSQL = ` SET ${q._sets.map((set) => `${set.column}=?`)}`;
-      const sql = `UPDATE ${q._table}${setSQL}${whereSQL}${getOrderBy(q._orderBy)}${getLimit(q._limitBy, q._offsetBy)} RETURNING ${returing}`;
-      return [{
-        sql,
-        values: q._sets.map((set) => set.value).concat(where.values)
-      }];
-    }
-    default:
-      throw new Error(`unsupported ${args}`);
+// node_modules/@miqro/query/build/query/utils.js
+function getStatements(stmts) {
+  if (stmts instanceof Array) {
+    return stmts;
+  } else {
+    return [
+      typeof stmts === "string" ? {
+        sql: stmts
+      } : stmts
+    ];
   }
 }
-function getJoin(join9) {
-  const wherePrepare = getWhereStatement(join9._on);
-  return {
-    sql: ` ${join9._verb ? `${join9._verb} ` : ""}JOIN ${renderNameAS(join9._table)} ON ${wherePrepare.sql}`,
-    values: wherePrepare.values
-  };
+async function runStatementsInTransaction(db, stmts, logger) {
+  return db.transaction(async function runStatementsInTransaction2(db2, logger2) {
+    return runStatements(db2, stmts, logger2);
+  }, logger);
 }
-function getWhereFilterColumnName(filter) {
-  if (filter._column === void 0 || filter._value === void 0) {
-    throw new Error(`unsupported where filter ${filter._type} with ${filter._column} and ${filter._value}`);
+async function runStatements(db, stmts, logger) {
+  if (stmts instanceof Array) {
+    let lastResult = void 0;
+    for (const stmt of stmts) {
+      lastResult = await db.query(stmt.sql, stmt.values, logger);
+    }
+    return lastResult;
+  } else if (typeof stmts === "string") {
+    return db.query(stmts, void 0, logger);
+  } else {
+    return db.query(stmts.sql, stmts.values, logger);
   }
-  return filter;
 }
-function getWhereStatement(where) {
-  const filters = where._filters;
-  let ret = {
-    sql: "",
-    values: []
-  };
-  filters.map((filter) => {
-    const where2 = filter._where;
-    switch (filter._type) {
-      case "where":
-      case "and": {
-        if (where2 === void 0) {
-          throw new Error(`unsupported where filter ${filter._type} with ${where2}`);
-        }
-        const prepare = mergePrepareArgs({
-          sql: "",
-          values: []
-        }, (where2 instanceof Array ? where2 : [where2]).map((w) => getWhereStatement(w)));
-        if (prepare.sql !== "") {
-          ret = mergePrepareArgs(ret, {
-            sql: `(${prepare.sql})`,
-            values: prepare.values
-          });
-        }
-        break;
-      }
-      case "literal": {
-        const literal = filter._literal;
-        if (literal === void 0) {
-          throw new Error(`unsupported where filter ${filter._type} with ${literal}`);
-        }
-        ret = mergePrepareArgs(ret, {
-          sql: `${literal}`,
-          values: []
-        });
-        break;
-      }
-      case "or": {
-        if (where2 === void 0) {
-          throw new Error(`unsupported where filter ${filter._type} with ${where2}`);
-        }
-        const prepare = mergePrepareArgs({
-          sql: "",
-          values: []
-        }, (where2 instanceof Array ? where2 : [where2]).map((w) => getWhereStatement(w)), " OR ");
-        ret = mergePrepareArgs(ret, {
-          sql: `(${prepare.sql})`,
-          values: prepare.values
-        });
-        break;
-      }
-      case "nin": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_column)} not in (${_value.map((v) => "?").join(",")})`,
-          values: _value
-        });
-        break;
-      }
-      case "in": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_column)} in (${_value.map((v) => "?").join(",")})`,
-          values: _value
-        });
-        break;
-      }
-      case "equal": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_column)}=?`,
-          values: [_value]
-        });
-        break;
-      }
-      case "gt": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_column)}>?`,
-          values: [_value]
-        });
-        break;
-      }
-      case "gte": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_value)}>=?`,
-          values: [_value]
-        });
-        break;
-      }
-      case "lt": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_column)}<?`,
-          values: [_value]
-        });
-        break;
-      }
-      case "lte": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_column)}<=?`,
-          values: [_value]
-        });
-        break;
-      }
-      case "neq": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_column)}<>?`,
-          values: [_value]
-        });
-        break;
-      }
-      case "like": {
-        const { _column, _value } = getWhereFilterColumnName(filter);
-        ret = mergePrepareArgs(ret, {
-          sql: `${renderColumn(_column)} LIKE ?`,
-          values: [_value]
-        });
-        break;
-      }
-      default:
-        throw new Error(`unsupported where filter ${filter._type}`);
+
+// node_modules/@miqro/query/build/query/create-database.js
+var CreateDatabase = class _CreateDatabase {
+  constructor(db, _dbName) {
+    this.db = db;
+    this._dbName = _dbName;
+    this._type = "create-database";
+  }
+  async yield(logger) {
+    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  }
+  clone() {
+    const ret = new _CreateDatabase(this.db, this._dbName);
+    return ret;
+  }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
+  }
+};
+
+// node_modules/@miqro/query/build/query/create-table.js
+var CreateTable = class _CreateTable {
+  constructor(db, _table, _definition = {}) {
+    this.db = db;
+    this._table = _table;
+    this._definition = _definition;
+    this._ignoreDuplicate = false;
+    this._type = "create-table";
+    this._definition = assertNotUndefined2(parser.parse(_definition, TableSchemaSchema));
+  }
+  column(column, definition) {
+    if (!definition) {
+      throw new Error("bad column definition");
+    }
+    if (this._definition[column] !== void 0) {
+      throw new Error("already defined!");
+    }
+    const columnDef = assertNotUndefined2(parser.parse(typeof definition === "string" ? {
+      type: definition
+    } : definition, ColumnDefinitionSchema));
+    this._definition[column] = columnDef;
+    return this;
+  }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
+  }
+  async yield(logger) {
+    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  }
+  ignoreDuplicates(ignore = true) {
+    this._ignoreDuplicate = ignore;
+    return this;
+  }
+  clone() {
+    const ret = new _CreateTable(this.db, this._table, this._definition);
+    ret._ignoreDuplicate = this._ignoreDuplicate;
+    return ret;
+  }
+};
+
+// node_modules/@miqro/query/build/query/drop-table.js
+var DropTable = class _DropTable {
+  constructor(db, _table) {
+    this.db = db;
+    this._table = _table;
+    this._type = "drop-table";
+    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 _DropTable(this.db, this._table);
+    ret._ignoreDuplicate = this._ignoreDuplicate;
+    return ret;
+  }
+};
+
+// node_modules/@miqro/query/build/query/alter-table.js
+var AlterTable = class _AlterTable {
+  constructor(db, _table, _inTransaction = false) {
+    this.db = db;
+    this._table = _table;
+    this._inTransaction = _inTransaction;
+    this._type = "alter-table";
+    this._changes = [];
+  }
+  rename(name) {
+    this._renameTable = name;
+    return this;
+  }
+  renameColumn(name, to) {
+    this._changes.push({
+      _action: "rename",
+      _column: name,
+      _newName: to
+    });
+    return this;
+  }
+  addColumn(name, definition) {
+    this._changes.push({
+      _action: "add",
+      _column: name,
+      _definition: assertNotUndefined2(parser.parse(definition, ColumnDefinitionSchema))
+    });
+    return this;
+  }
+  dropColumn(name) {
+    this._changes.push({
+      _action: "drop",
+      _column: name
+    });
+    return this;
+  }
+  clone() {
+    const ret = new _AlterTable(this.db, this._table);
+    ret._changes = structuredClone(this._changes);
+    ret._renameTable = this._renameTable;
+    return ret;
+  }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
+  }
+  yield(logger) {
+    return this._inTransaction ? runStatementsInTransaction(this.db, this.db.getExecutor().prepare(this), logger) : runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  }
+};
+
+// node_modules/@miqro/query/build/query/insert.js
+var Insert = class _Insert {
+  constructor(db, _table) {
+    this.db = db;
+    this._table = _table;
+    this._type = "insert";
+    this._columns = [];
+    this._returning = [];
+    this._values = [];
+    this._ignoreDuplicate = false;
+  }
+  value(value) {
+    this._values = this._values.concat(value);
+    return this;
+  }
+  values(value) {
+    return this.value(value);
+  }
+  returning(column) {
+    this._returning = this._returning.concat(column);
+    return this;
+  }
+  column(column) {
+    this._columns = this._columns.concat(column);
+    return this;
+  }
+  columns(column) {
+    return this.column(column);
+  }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
+  }
+  async yield(logger) {
+    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  }
+  ignoreDuplicates(ignore = true) {
+    this._ignoreDuplicate = ignore;
+    return this;
+  }
+  clone() {
+    const ret = new _Insert(this.db, this._table);
+    ret._columns = structuredClone(this._columns);
+    ret._values = structuredClone(this._values);
+    ret._returning = structuredClone(this._returning);
+    ret._ignoreDuplicate = this._ignoreDuplicate;
+    return ret;
+  }
+};
+
+// node_modules/@miqro/query/build/executors/where.js
+var Where = class {
+  constructor() {
+    this._orderBy = [];
+    this._filters = [];
+  }
+  order(column, mode) {
+    this._orderBy.push({ column, mode });
+    return this;
+  }
+  limit(limit) {
+    this._limitBy = limit;
+    return this;
+  }
+  offset(offset) {
+    this._offsetBy = offset;
+    return this;
+  }
+  and(where) {
+    this._filters.push({
+      _type: "and",
+      _where: where
+    });
+    return this;
+  }
+  or(where) {
+    this._filters.push({
+      _type: "or",
+      _where: where
+    });
+    return this;
+  }
+  where(where) {
+    this._filters.push({
+      _type: "where",
+      _where: where
+    });
+    if (where._orderBy.length > 0) {
+      this._orderBy.push(...where._orderBy);
     }
-  });
-  return ret;
-}
-function getCreateTableColumns(definition) {
-  const columnNames = Object.keys(definition);
-  const primaryKeyColumns = columnNames.filter((columnName) => definition[columnName].primaryKey);
-  return `(${columnNames.map((columnName) => {
-    const def = definition[columnName];
-    return getCreateTableColumn(columnName, def, primaryKeyColumns);
-  }).concat(primaryKeyColumns.length > 1 ? [
-    `PRIMARY KEY( ${primaryKeyColumns.join(",")} )`
-  ] : []).join(", ")})`;
-}
-function getCreateTableColumn(columnName, def, primaryKeyColumns) {
-  const primaryKey = primaryKeyColumns.length === 1 && columnName === primaryKeyColumns[0] ? " PRIMARY KEY" : "";
-  const notNull = `${def.allowNull == false ? " NOT NULL" : ""}`;
-  const defaultValue = `${def.defaultValue !== void 0 ? ` DEFAULT '${def.defaultValue}'` : ""}`;
-  const autoIncrement = `${def.autoIncrement !== void 0 && def.autoIncrement === true ? ` AUTOINCREMENT` : ""}`;
-  switch (def.type) {
-    case "datetime":
-      return `${columnName} DATETIME${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
-    case "boolean":
-      return `${columnName} TINYINT${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
-    case "json":
-    case "string":
-      return `${columnName} TEXT${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
-    case "real":
-      return `${columnName} REAL${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
-    case "bigint":
-    case "integer":
-      return `${columnName} INTEGER${primaryKey}${notNull}${defaultValue}${autoIncrement}`;
-    default:
-      throw new Error("unsupported type " + def.type);
+    if (where._limitBy) {
+      this._limitBy = where._limitBy;
+    }
+    if (where._offsetBy) {
+      this._offsetBy = where._offsetBy;
+    }
+    return this;
   }
-}
-function getInsertColumns(columns) {
-  return `(${columns.join(",")})`;
-}
-function getInsertValues(columns, values) {
-  let args = [];
-  for (const v of values) {
-    args = args.concat(columns.map((c) => v[c]));
+  nin(column, value) {
+    {
+      this._filters.push({
+        _type: "nin",
+        _column: column,
+        _value: value
+      });
+      return this;
+    }
   }
-  return {
-    sql: ` VALUES ${values.map(() => `(${columns.map(() => "?").join(", ")})`)}`,
-    values: args
-  };
-}
-function renderNameAS(input, join9 = ", ") {
-  const list = input instanceof Array ? input : [input];
-  return list.map((i) => typeof i === "string" ? i : `${i.name} AS ${i.as}`).join(join9);
-}
-function getGroupBy(groupBy) {
-  return groupBy.length > 0 ? ` GROUP BY ${groupBy.join(",")}` : "";
-}
-function getOrderBy(orderBy) {
-  return orderBy.length > 0 ? ` ORDER BY ${orderBy.map((o) => `${o.column} ${o.mode}`).join(",")}` : "";
-}
-function getLimit(limit, offsetBy) {
-  return `${limit !== void 0 ? ` LIMIT ${limit}` : ""}${offsetBy ? ` OFFSET ${offsetBy}` : ""}`;
-}
-function renderColumn(column) {
-  return column;
-}
-function mergePrepareArgs(to, merge, concatOperator = " AND ") {
-  return (merge instanceof Array ? merge : [merge]).reduce((current, value) => {
-    if (current.sql !== "") {
-      current.sql += concatOperator;
+  in(column, value) {
+    {
+      this._filters.push({
+        _type: "in",
+        _column: column,
+        _value: value
+      });
+      return this;
     }
-    current.sql += value.sql;
-    current.values = !value.values ? current.values : (current.values ? current.values : []).concat(value.values);
-    return current;
-  }, to);
-}
+  }
+  eq(column, value) {
+    this._filters.push({
+      _type: "equal",
+      _column: column,
+      _value: value
+    });
+    return this;
+  }
+  like(column, value) {
+    this._filters.push({
+      _type: "like",
+      _column: column,
+      _value: value
+    });
+    return this;
+  }
+  gte(column, value) {
+    this._filters.push({
+      _type: "gte",
+      _column: column,
+      _value: value
+    });
+    return this;
+  }
+  gt(column, value) {
+    this._filters.push({
+      _type: "gt",
+      _column: column,
+      _value: value
+    });
+    return this;
+  }
+  lte(column, value) {
+    this._filters.push({
+      _type: "lte",
+      _column: column,
+      _value: value
+    });
+    return this;
+  }
+  lt(column, value) {
+    this._filters.push({
+      _type: "lt",
+      _column: column,
+      _value: value
+    });
+    return this;
+  }
+  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/executors/parser.js
-var parser = new Parser();
-function assertNotUndefined2(obj) {
-  if (obj === void 0) {
-    throw new Error("validation failed");
+// 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 = [];
   }
-  return obj;
-}
-var DATABASE_CONFIG_SCHEMA = {
-  type: "object",
-  properties: {
-    executor: {
-      type: "object?",
-      mode: "add_extra",
-      properties: {
-        prepare: "function",
-        query: "function",
-        disconnect: "function"
-      }
-    },
-    logger: {
-      type: "object?",
-      mode: "add_extra",
-      properties: {
-        log: "function?",
-        error: "function?"
-      }
-    },
-    storage: "string?",
-    connectionString: "string?",
-    dialect: {
-      type: "enum?",
-      enumValues: ["node:sqlite", "sqlite3-cli", "sqlite3", "pg"]
+  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;
   }
-};
-var ColumnDefinitionTypeSchema = {
-  type: "enum",
-  enumValues: ["string", "integer", "boolean", "datetime", "json", "real", "bigint"]
-};
-var ColumnDefinitionSchema = {
-  type: "object",
-  properties: {
-    type: ColumnDefinitionTypeSchema,
-    primaryKey: "boolean?",
-    autoIncrement: "boolean?",
-    allowNull: "boolean?",
-    defaultValue: "any?"
+  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;
   }
-};
-parser.register("ColumnDefinition", ColumnDefinitionSchema);
-var TableSchemaSchema = {
-  type: "dict",
-  dictType: "ColumnDefinition"
 };
 
-// node_modules/@miqro/query/build/executors/sqlite3/lib.js
-var SQLITE_CONFIG_SCHEMA = {
-  type: "object",
-  mode: "remove_extra",
-  properties: {
-    storage: "string"
+// 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 = [];
   }
-};
-async function sqlite3Executor(config) {
-  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA);
-  if (!databaseOptions) {
-    throw new Error("config not valid");
+  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;
   }
-  const sqlite3 = await import("sqlite3");
-  const driver = new sqlite3.default.Database(databaseOptions.storage);
-  return {
-    disconnect: async function sqlite3ExecutorDisconnect() {
-      await driver.close();
-    },
-    prepare: sqlite3ExecutorPrepare,
-    query: async function sqlite3Executor2(sql, values) {
-      return new Promise((resolve20, reject) => {
-        const st = driver.prepare(sql, values, function(error2) {
-          if (error2) {
-            reject(error2);
-          } else {
-            st.all(function(error3, rows) {
-              if (error3) {
-                reject(error3);
-              } else {
-                st.finalize((error4) => {
-                  if (error4) {
-                    reject(error4);
-                  } else {
-                    resolve20(rows);
-                  }
-                });
-              }
-            });
-          }
-        });
-      });
-    }
-  };
-}
-
-// node_modules/@miqro/query/build/executors/pg/lib.js
-var PG_DATABASE_CONFIG_SCHEMA = {
-  type: "object",
-  mode: "remove_extra",
-  properties: {
-    connectionString: "string"
+  from(from) {
+    this._selectFrom = this._selectFrom.concat(from);
+    return this;
   }
-};
-async function postgresExecutor(config) {
-  const databaseOptions = parser.parse(config, PG_DATABASE_CONFIG_SCHEMA);
-  if (!databaseOptions) {
-    throw new Error("bad options");
+  join(table, on, verb) {
+    this._joins.push({
+      _table: table,
+      _on: on,
+      _verb: verb
+    });
+    return this;
   }
-  const pg = await import("pg");
-  const driver = new pg.default.Client({
-    connectionString: databaseOptions.connectionString
-    // "postgresql://postgres:password@localhost:5432/db"
-  });
-  await driver.connect();
-  return {
-    disconnect: async function postgresExecutorDisconnect() {
-      await driver.end();
-    },
-    prepare: function postgresExecutorPrepare(args) {
-      switch (args._type) {
-        case "create-table": {
-          const q = args;
-          const sql = `CREATE TABLE${q._ignoreDuplicate ? " IF NOT EXISTS" : ""} ${q._table}${getCreateTableColumns2(q._definition)}`;
-          return sql;
-        }
-        case "insert": {
-          const q = args;
-          const rows = getInsertValues(q._columns, q._values);
-          const returing = q._returning.length === 0 ? "*" : q._returning.join(",");
-          const sql = `INSERT INTO ${q._table}${getInsertColumns(q._columns)}${rows.sql} ${q._ignoreDuplicate ? "ON CONFLICT DO NOTHING " : ""}RETURNING ${returing}`;
-          return {
-            sql,
-            values: rows.values
-          };
-        }
-        case "alter-table": {
-          const q = args;
-          let alters = [];
-          if (q._renameTable) {
-            alters.push({
-              sql: `ALTER TABLE ${q._table} RENAME TO ?`,
-              values: [q._renameTable]
-            });
-          }
-          for (let l of q._changes) {
-            switch (l._action) {
-              case "add":
-                if (!l._definition) {
-                  throw new Error("unsupported alter action add without definition");
-                }
-                alters.push({
-                  sql: `ALTER TABLE ${q._table} ADD COLUMN ${getCreateTableColumn2(l._column, l._definition, [])}`
-                });
-                break;
-              case "drop":
-                alters.push({
-                  sql: `ALTER TABLE ${q._table} DROP COLUMN ${l._column}`
-                });
-                break;
-              case "rename":
-                alters.push({
-                  sql: `ALTER TABLE ${q._table} RENAME COLUMN ${l._column} TO ${l._newName}`
-                });
-                break;
-              default:
-                throw new Error("unsupported alter action");
-            }
-          }
-          return alters;
-        }
-        default:
-          return sqlite3ExecutorPrepare(args);
-      }
-    },
-    query: async function postgresExecutor2(sql, values) {
-      try {
-        const result = await driver.query(tokens2Postgres(sql, values), values);
-        return result.rows;
-      } catch (e) {
-        throw e;
-      }
-    }
-  };
-}
-function getCreateTableColumns2(definition) {
-  const columnNames = Object.keys(definition);
-  const primaryKeyColumns = columnNames.filter((columnName) => definition[columnName].primaryKey);
-  return `(${columnNames.map((columnName) => {
-    const def = definition[columnName];
-    return getCreateTableColumn2(columnName, def, primaryKeyColumns);
-  }).concat(primaryKeyColumns.length > 1 ? [
-    `PRIMARY KEY( ${primaryKeyColumns.join(",")} )`
-  ] : []).join(", ")})`;
-}
-function getCreateTableColumn2(columnName, def, primaryKeyColumns) {
-  const primaryKey = primaryKeyColumns.length === 1 && columnName === primaryKeyColumns[0] ? " PRIMARY KEY" : "";
-  const notNull = `${def.allowNull == false ? " NOT NULL" : ""}`;
-  const defaultValue = `${def.defaultValue !== void 0 ? ` DEFAULT '${def.defaultValue}'` : ""}`;
-  if (def.autoIncrement) {
-    return `${columnName} BIGSERIAL${primaryKey}`;
+  left(table, on) {
+    return this.join(table, on, "LEFT");
   }
-  switch (def.type) {
-    case "datetime":
-      return `${columnName} TIMESTAMP${primaryKey}${notNull}${defaultValue}`;
-    case "boolean":
-      return `${columnName} BOOLEAN${primaryKey}${notNull}${defaultValue}`;
-    case "real":
-      return `${columnName} REAL${primaryKey}${notNull}${defaultValue}`;
-    case "json":
-    case "string":
-      return `${columnName} TEXT${primaryKey}${notNull}${defaultValue}`;
-    case "bigint":
-      return `${columnName} bigint${primaryKey}${notNull}${defaultValue}`;
-    case "integer":
-      return `${columnName} INTEGER${primaryKey}${notNull}${defaultValue}`;
-    default:
-      throw new Error("unsupported type " + def.type);
+  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)
+  };
 }
-function tokens2Postgres(inSql, values) {
-  let i = 0;
-  const sql = inSql.replaceAll("?", (string) => {
-    i++;
-    return `$${i}`;
-  });
-  if (i !== (values ? values.length : 0)) {
-    throw new Error("invalid char '?'");
+
+// 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 = [];
   }
-  let iSum = 0;
-  for (const c of sql) {
-    if (c === "$") {
-      iSum++;
-    }
+  prepare() {
+    return getStatements(this.db.getExecutor().prepare(this));
   }
-  if (iSum !== i) {
-    throw new Error("invalid char '$'");
+  async yield(logger) {
+    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
   }
-  return sql;
-}
+  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;
+  }
+  set(column, value) {
+    this._sets.push({
+      column,
+      value
+    });
+    return this;
+  }
+};
 
-// node_modules/@miqro/query/build/query/utils.js
-function getStatements(stmts) {
-  if (stmts instanceof Array) {
-    return stmts;
-  } else {
-    return [
-      typeof stmts === "string" ? {
-        sql: stmts
-      } : stmts
-    ];
+// 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 = [];
   }
-}
-async function runStatementsInTransaction(db, stmts, logger) {
-  return db.transaction(async function runStatementsInTransaction2(db2, logger2) {
-    return runStatements(db2, stmts, logger2);
-  }, logger);
-}
-async function runStatements(db, stmts, logger) {
-  if (stmts instanceof Array) {
-    let lastResult = void 0;
-    for (const stmt of stmts) {
-      lastResult = await db.query(stmt.sql, stmt.values, logger);
-    }
-    return lastResult;
-  } else if (typeof stmts === "string") {
-    return db.query(stmts, void 0, logger);
-  } else {
-    return db.query(stmts.sql, stmts.values, logger);
+  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/query/create-database.js
-var CreateDatabase = class _CreateDatabase {
+// node_modules/@miqro/query/build/query/drop-database.js
+var DropDatabase = class _DropDatabase {
   constructor(db, _dbName) {
     this.db = db;
     this._dbName = _dbName;
-    this._type = "create-database";
+    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 _CreateDatabase(this.db, this._dbName);
+    const ret = new _DropDatabase(this.db, this._dbName);
+    ret._ignoreDuplicate = this._ignoreDuplicate;
     return ret;
   }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
+};
+
+// 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);
+        }
+      });
+    }
+  };
+}
 
-// node_modules/@miqro/query/build/query/create-table.js
-var CreateTable = class _CreateTable {
-  constructor(db, _table, _definition = {}) {
-    this.db = db;
-    this._table = _table;
-    this._definition = _definition;
-    this._ignoreDuplicate = false;
-    this._type = "create-table";
-    this._definition = assertNotUndefined2(parser.parse(_definition, TableSchemaSchema));
+// node_modules/@miqro/query/build/executors/sqlite-native/lib.js
+var SQLITE_CONFIG_SCHEMA3 = {
+  type: "object",
+  mode: "remove_extra",
+  properties: {
+    storage: "string"
+  }
+};
+async function nativeSqlite(config) {
+  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA3);
+  if (!databaseOptions) {
+    throw new Error("config not valid");
+  }
+  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;
   }
-  column(column, definition) {
-    if (!definition) {
-      throw new Error("bad column definition");
+  async connect() {
+    if (this.status !== "disconnected") {
+      throw new Error(`cannot connect while ${this.status}`);
     }
-    if (this._definition[column] !== void 0) {
-      throw new Error("already defined!");
+    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;
     }
-    const columnDef = assertNotUndefined2(parser.parse(typeof definition === "string" ? {
-      type: definition
-    } : definition, ColumnDefinitionSchema));
-    this._definition[column] = columnDef;
-    return this;
-  }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
-  }
-  async yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
   }
-  ignoreDuplicates(ignore = true) {
-    this._ignoreDuplicate = ignore;
-    return this;
+  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;
+    }
   }
-  clone() {
-    const ret = new _CreateTable(this.db, this._table, this._definition);
-    ret._ignoreDuplicate = this._ignoreDuplicate;
-    return ret;
+  getExecutor() {
+    if (!this.executor) {
+      throw new Error("executor not initialized!");
+    }
+    return this.executor;
   }
-};
-
-// node_modules/@miqro/query/build/query/drop-table.js
-var DropTable = class _DropTable {
-  constructor(db, _table) {
-    this.db = db;
-    this._table = _table;
-    this._type = "drop-table";
-    this._ignoreDuplicate = false;
+  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;
+    }
   }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
+  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;
+    }
   }
-  ignoreDuplicates(ignore = true) {
-    this._ignoreDuplicate = ignore;
-    return this;
+  createDatabase(dbName) {
+    return new CreateDatabase(this, dbName);
   }
-  async yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  createTable(table, definition) {
+    return new CreateTable(this, table, definition);
   }
-  clone() {
-    const ret = new _DropTable(this.db, this._table);
-    ret._ignoreDuplicate = this._ignoreDuplicate;
-    return ret;
+  dropTable(table) {
+    return new DropTable(this, table);
   }
-};
-
-// node_modules/@miqro/query/build/query/alter-table.js
-var AlterTable = class _AlterTable {
-  constructor(db, _table, _inTransaction = false) {
-    this.db = db;
-    this._table = _table;
-    this._inTransaction = _inTransaction;
-    this._type = "alter-table";
-    this._changes = [];
+  dropDatabase(dbname) {
+    return new DropDatabase(this, dbname);
   }
-  rename(name) {
-    this._renameTable = name;
-    return this;
+  alterTable(table, inTransaction) {
+    return new AlterTable(this, table, inTransaction);
   }
-  renameColumn(name, to) {
-    this._changes.push({
-      _action: "rename",
-      _column: name,
-      _newName: to
-    });
-    return this;
+  insert(table) {
+    return new Insert(this, table);
   }
-  addColumn(name, definition) {
-    this._changes.push({
-      _action: "add",
-      _column: name,
-      _definition: assertNotUndefined2(parser.parse(definition, ColumnDefinitionSchema))
-    });
-    return this;
+  select() {
+    return new Select(this);
   }
-  dropColumn(name) {
-    this._changes.push({
-      _action: "drop",
-      _column: name
-    });
-    return this;
+  count() {
+    return new Count(this);
   }
-  clone() {
-    const ret = new _AlterTable(this.db, this._table);
-    ret._changes = structuredClone(this._changes);
-    ret._renameTable = this._renameTable;
-    return ret;
+  update(table) {
+    return new Update(this, table);
   }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
+  delete(table) {
+    return new Delete(this, table);
   }
-  yield(logger) {
-    return this._inTransaction ? runStatementsInTransaction(this.db, this.db.getExecutor().prepare(this), logger) : runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  where() {
+    return new Where();
   }
 };
-
-// node_modules/@miqro/query/build/query/insert.js
-var Insert = class _Insert {
-  constructor(db, _table) {
-    this.db = db;
-    this._table = _table;
-    this._type = "insert";
-    this._columns = [];
-    this._returning = [];
-    this._values = [];
-    this._ignoreDuplicate = false;
-  }
-  value(value) {
-    this._values = this._values.concat(value);
-    return this;
-  }
-  values(value) {
-    return this.value(value);
-  }
-  returning(column) {
-    this._returning = this._returning.concat(column);
-    return this;
-  }
-  column(column) {
-    this._columns = this._columns.concat(column);
-    return this;
-  }
-  columns(column) {
-    return this.column(column);
-  }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
-  }
-  async yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+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");
   }
-  ignoreDuplicates(ignore = true) {
-    this._ignoreDuplicate = ignore;
-    return 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
   }
-  clone() {
-    const ret = new _Insert(this.db, this._table);
-    ret._columns = structuredClone(this._columns);
-    ret._values = structuredClone(this._values);
-    ret._returning = structuredClone(this._returning);
-    ret._ignoreDuplicate = this._ignoreDuplicate;
-    return ret;
+};
+var NULL_LOGGER = {
+  error: (...args) => {
+  },
+  log: (...args) => {
   }
 };
 
-// node_modules/@miqro/query/build/executors/where.js
-var Where = class {
-  constructor() {
-    this._orderBy = [];
-    this._filters = [];
-  }
-  order(column, mode) {
-    this._orderBy.push({ column, mode });
-    return this;
-  }
-  limit(limit) {
-    this._limitBy = limit;
-    return this;
-  }
-  offset(offset) {
-    this._offsetBy = offset;
-    return this;
-  }
-  and(where) {
-    this._filters.push({
-      _type: "and",
-      _where: where
-    });
-    return this;
+// 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);
   }
-  or(where) {
-    this._filters.push({
-      _type: "or",
-      _where: where
-    });
-    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);
   }
-  where(where) {
-    this._filters.push({
-      _type: "where",
-      _where: where
-    });
-    if (where._orderBy.length > 0) {
-      this._orderBy.push(...where._orderBy);
+  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
+          };
+        }
+      }
     }
-    if (where._limitBy) {
-      this._limitBy = where._limitBy;
+    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);
     }
-    if (where._offsetBy) {
-      this._offsetBy = where._offsetBy;
+  } 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);
     }
-    return this;
   }
-  nin(column, value) {
-    {
-      this._filters.push({
-        _type: "nin",
-        _column: column,
-        _value: value
+}
+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/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);
+      }
+    };
+    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
       });
-      return this;
     }
   }
-  in(column, value) {
-    {
-      this._filters.push({
-        _type: "in",
-        _column: column,
-        _value: value
+  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 this;
     }
+    return super.broadcast(payload, fromUUID);
   }
-  eq(column, value) {
-    this._filters.push({
-      _type: "equal",
-      _column: column,
-      _value: value
-    });
-    return this;
-  }
-  like(column, value) {
-    this._filters.push({
-      _type: "like",
-      _column: column,
-      _value: value
-    });
-    return this;
-  }
-  gte(column, value) {
-    this._filters.push({
-      _type: "gte",
-      _column: column,
-      _value: value
-    });
-    return this;
-  }
-  gt(column, value) {
-    this._filters.push({
-      _type: "gt",
-      _column: column,
-      _value: value
-    });
-    return this;
-  }
-  lte(column, value) {
-    this._filters.push({
-      _type: "lte",
-      _column: column,
-      _value: value
-    });
-    return this;
-  }
-  lt(column, value) {
-    this._filters.push({
-      _type: "lt",
-      _column: column,
-      _value: value
-    });
-    return this;
-  }
-  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);
+  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;
+      }
     }
-    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);
+    if (this.clients.has(clientUUID)) {
+      return super.writeTo(clientUUID, payload);
     }
-    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;
+  isUUIDValid(uuid) {
+    return !this.clients.has(uuid) && !this.remoteClients.has(uuid);
   }
 };
 
-// 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;
+// 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);
+      }
+    };
+    this.connect();
   }
-  left(table, on) {
-    return this.join(table, on, "LEFT");
+  localCache = /* @__PURE__ */ new Map();
+  //private logger: Logger;
+  listener;
+  connect() {
+    if (process.send) {
+      process.removeListener("message", this.listener);
+      process.on("message", this.listener);
+    }
   }
-  right(table, on) {
-    return this.join(table, on, "RIGHT");
+  disconnect() {
+    process.removeListener("message", this.listener);
   }
-  group(column) {
-    this._groupBy.push(column);
-    return this;
+  get(key) {
+    this.logger?.trace("get(%s)", key);
+    return this.localCache.get(key);
   }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
+  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);
+    }
   }
-  async yield(logger) {
-    return parseCountResult(await runStatements(this.db, this.db.getExecutor().prepare(this), logger));
+  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);
+    }
   }
-};
-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 = [];
+  has(key) {
+    this.logger?.trace("has(%s)", key);
+    return this.localCache.has(key);
   }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
+  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 yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  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);
+    }
   }
-  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;
+  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;
   }
-  returning(column) {
-    this._returning = this._returning.concat(column);
-    return this;
+  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);
   }
-  set(column, value) {
-    this._sets.push({
-      column,
-      value
-    });
-    return this;
+  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, []);
   }
 };
 
-// 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 = [];
+// src/services/utils/cache.ts
+var LocalCache = class {
+  constructor(name, logger) {
+    this.name = name;
+    this.logger = logger;
   }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(this));
+  localCache = /* @__PURE__ */ new Map();
+  dispose() {
   }
-  async yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  get(key) {
+    this.logger?.trace("get(%s)", key);
+    return this.localCache.get(key);
   }
-  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;
+  set(key, value) {
+    this.localCache.set(key, value);
+    this.logger?.trace("set(%s, ...)", key);
   }
-  returning(column) {
-    this._returning = this._returning.concat(column);
-    return this;
+  unset(key) {
+    this.logger?.trace("unset(%s)", key);
+    this.localCache.delete(key);
   }
-};
-
-// 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;
+  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);
   }
-  prepare() {
-    return getStatements(this.db.getExecutor().prepare(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);
   }
-  ignoreDuplicates(ignore = true) {
-    this._ignoreDuplicate = ignore;
-    return this;
+  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;
   }
-  async yield(logger) {
-    return runStatements(this.db, this.db.getExecutor().prepare(this), logger);
+  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);
   }
-  clone() {
-    const ret = new _DropDatabase(this.db, this._dbName);
-    ret._ignoreDuplicate = this._ignoreDuplicate;
-    return ret;
+  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, []);
   }
 };
 
-// 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"
+// 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;
   }
-};
-async function sqlite3CLIExecutor(config) {
-  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA2);
-  if (!databaseOptions) {
-    throw new Error("config not valid");
+  deleteWS(path) {
+    const ws = this.runningGlobalWSMap.get(path);
+    this.disconnectAllFrom(path);
+    ws.dispose();
+    this.runningGlobalWSMap.delete(path);
   }
-  (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);
-        }
-      });
+  deleteAllWS() {
+    for (const path of this.runningGlobalWSMap.keys()) {
+      this.deleteWS(path);
     }
-  };
-}
-
-// node_modules/@miqro/query/build/executors/sqlite-native/lib.js
-var SQLITE_CONFIG_SCHEMA3 = {
-  type: "object",
-  mode: "remove_extra",
-  properties: {
-    storage: "string"
   }
-};
-async function nativeSqlite(config) {
-  const databaseOptions = parser.parse(config, SQLITE_CONFIG_SCHEMA3);
-  if (!databaseOptions) {
-    throw new Error("config not valid");
+  getWS(path) {
+    return this.runningGlobalWSMap.get(path);
   }
-  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);
+  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!`);
         }
-      });
-    }
-  };
-}
-
-// 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;
+        this.logger?.debug("setting up websocket on [%s]", wsConfig.path);
+        const server2 = new ClusterWebSocketServer2(wsConfig.path, wsConfig);
+        this.runningGlobalWSMap.set(wsConfig.path, server2);
+      }
     }
   }
-  async disconnect() {
-    if (this.status !== "connected") {
-      throw new Error(`cannot disconnect while ${this.status}`);
+  replaceALLWSBuLOGSocket(list) {
+    for (const path of this.runningGlobalWSMap.keys()) {
+      if (path !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+        this.deleteWS(path);
+      }
     }
-    this.status = "disconnecting";
-    try {
-      await this.getExecutor().disconnect();
-      this.executor = null;
-      this.status = "disconnected";
-    } catch (e) {
-      this.status = "error";
-      throw e;
+    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);
+        }
+      }
     }
   }
-  getExecutor() {
-    if (!this.executor) {
-      throw new Error("executor not initialized!");
+  /*public setupWS(path: string, server: ClusterWebSocketServer2) {
+    if (this.runningGlobalWSMap.has(path)) {
+      throw new Error(`ws on path ${path} already setup!`);
     }
-    return this.executor;
-  }
-  async query(sql, values, logger) {
-    const l = logger ? logger : this.config.logger ? this.config.logger : void 0;
+    this.runningGlobalWSMap.set(path, server);
+  }*/
+  disconnectAllFrom(path) {
     try {
-      l?.log(sql);
-      const result = await this.getExecutor().query(sql, values);
-      return result;
+      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) {
-      l?.error(e);
-      throw e;
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
     }
   }
-  async transaction(transactionCB, logger) {
+  disconnectAllButLOGSocket() {
     try {
-      await this.query("BEGIN", void 0, logger);
-      const ret = await transactionCB(this, logger);
-      await this.query("COMMIT", void 0, logger);
-      return ret;
+      for (const wsPath of this.runningGlobalWSMap.keys()) {
+        if (wsPath !== LOG_SOCKET_PATH || !this.avoidLogSocket) {
+          this.disconnectAllFrom(wsPath);
+        }
+      }
     } catch (e) {
-      await this.query("ROLLBACK", void 0, logger);
-      throw e;
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
     }
   }
-  createDatabase(dbName) {
-    return new CreateDatabase(this, dbName);
-  }
-  createTable(table, definition) {
-    return new CreateTable(this, table, definition);
-  }
-  dropTable(table) {
-    return new DropTable(this, table);
-  }
-  dropDatabase(dbname) {
-    return new DropDatabase(this, dbname);
-  }
-  alterTable(table, inTransaction) {
-    return new AlterTable(this, table, inTransaction);
-  }
-  insert(table) {
-    return new Insert(this, table);
-  }
-  select() {
-    return new Select(this);
-  }
-  count() {
-    return new Count(this);
-  }
-  update(table) {
-    return new Update(this, table);
-  }
-  delete(table) {
-    return new Delete(this, table);
-  }
-  where() {
-    return new Where();
-  }
-};
-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;
+  disconnectAll() {
+    try {
+      for (const wsPath of this.runningGlobalWSMap.keys()) {
+        this.disconnectAllFrom(wsPath);
       }
-      throw new Error("dialect [" + config.dialect + "] not defined");
-  }
-}
-
-// 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
-  }
-};
-var NULL_LOGGER = {
-  error: (...args) => {
-  },
-  log: (...args) => {
-  }
-};
-
-// 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);
-  }
-  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);
+    } catch (e) {
+      this.logger?.error("error disconnecting web socket clients");
+      this.logger?.error(e.message);
+    }
   }
-  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
-          };
-        }
+  onUpgrade(req, socket, head) {
+    try {
+      const wsServer = this.getWS(req.path);
+      if (wsServer) {
+        return wsServer.onUpgrade(req, socket, head);
+      } else {
+        socket.destroy();
       }
-    }
-    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);
+    } 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;