speexjs 0.2.0

package/dist/server/index.js

@@ -0,0 +1,4185 @@
+// src/server/container/index.ts
+var Container = class {
+  bindings = /* @__PURE__ */ new Map();
+  resolving = /* @__PURE__ */ new Set();
+  bind(name, factory) {
+    this.bindings.set(name, { factory, singleton: false });
+    return this;
+  }
+  singleton(name, factory) {
+    this.bindings.set(name, { factory, singleton: true });
+    return this;
+  }
+  instance(name, instance) {
+    this.bindings.set(name, {
+      factory: () => instance,
+      singleton: true,
+      instance
+    });
+    return this;
+  }
+  resolve(name) {
+    const binding = this.bindings.get(name);
+    if (binding === void 0) {
+      throw new Error(`Binding not found: ${name}`);
+    }
+    if (binding.singleton && binding.instance !== void 0) {
+      return binding.instance;
+    }
+    if (this.resolving.has(name)) {
+      throw new Error(
+        `Circular dependency detected: ${name} is already being resolved`
+      );
+    }
+    this.resolving.add(name);
+    try {
+      const instance = binding.factory();
+      if (binding.singleton) {
+        binding.instance = instance;
+      }
+      return instance;
+    } finally {
+      this.resolving.delete(name);
+    }
+  }
+  has(name) {
+    return this.bindings.has(name);
+  }
+  remove(name) {
+    this.bindings.delete(name);
+  }
+  clear() {
+    this.bindings.clear();
+    this.resolving.clear();
+  }
+  getBindings() {
+    return new Map(this.bindings);
+  }
+};
+
+// src/server/http/status.ts
+var HttpStatus = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+
+// src/server/controller/index.ts
+var controllerPrefixMap = /* @__PURE__ */ new WeakMap();
+var controllerRoutesMap = /* @__PURE__ */ new WeakMap();
+function createRouteDecorator(method) {
+  return (path3) => {
+    return (target, context) => {
+      const classTarget = context.static ? target : target.constructor;
+      const routes = controllerRoutesMap.get(classTarget) ?? [];
+      routes.push({ method, path: path3, handler: context.name });
+      controllerRoutesMap.set(classTarget, routes);
+    };
+  };
+}
+var get = createRouteDecorator("GET");
+var post = createRouteDecorator("POST");
+var put = createRouteDecorator("PUT");
+var patch = createRouteDecorator("PATCH");
+var del = createRouteDecorator("DELETE");
+function getControllerPrefix(controllerClass) {
+  return controllerPrefixMap.get(controllerClass) ?? "";
+}
+function getControllerRoutes(controllerClass) {
+  return controllerRoutesMap.get(controllerClass) ?? [];
+}
+
+// src/server/engine/index.ts
+import { createServer as createHttpServer } from "http";
+
+// src/server/http/headers.ts
+var HeadersMap = class {
+  data;
+  constructor(initial) {
+    this.data = /* @__PURE__ */ new Map();
+    if (initial) {
+      for (const key of Object.keys(initial)) {
+        const value = initial[key];
+        if (value !== void 0) {
+          this.set(key, Array.isArray(value) ? value.join(", ") : value);
+        }
+      }
+    }
+  }
+  get(name) {
+    const values = this.data.get(name.toLowerCase());
+    if (values !== void 0 && values.length > 0) {
+      return values[0];
+    }
+    return void 0;
+  }
+  getAll(name) {
+    const values = this.data.get(name.toLowerCase());
+    return values ?? [];
+  }
+  set(name, value) {
+    this.data.set(name.toLowerCase(), [value]);
+  }
+  append(name, value) {
+    const key = name.toLowerCase();
+    const existing = this.data.get(key);
+    if (existing !== void 0) {
+      existing.push(value);
+    } else {
+      this.data.set(key, [value]);
+    }
+  }
+  has(name) {
+    return this.data.has(name.toLowerCase());
+  }
+  delete(name) {
+    this.data.delete(name.toLowerCase());
+  }
+  *entries() {
+    for (const [key, values] of this.data) {
+      for (const value of values) {
+        yield [key, value];
+      }
+    }
+  }
+  *keys() {
+    for (const key of this.data.keys()) {
+      yield key;
+    }
+  }
+  *values() {
+    for (const [, values] of this.data) {
+      for (const value of values) {
+        yield value;
+      }
+    }
+  }
+  toJSON() {
+    const result = {};
+    for (const [key, values] of this.data) {
+      result[key] = values.length === 1 ? values[0] : values;
+    }
+    return result;
+  }
+  toNodeHeaders() {
+    const result = {};
+    for (const [key, values] of this.data) {
+      if (key === "set-cookie") {
+        result[key] = values;
+      } else {
+        result[key] = values.join(", ");
+      }
+    }
+    return result;
+  }
+  get size() {
+    return this.data.size;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+
+// src/server/http/cookie.ts
+function parseCookies(header) {
+  const result = {};
+  if (!header) return result;
+  const pairs = header.split(";");
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    if (!trimmed) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      result[trimmed] = "";
+      continue;
+    }
+    const name = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    }
+    if (name) {
+      result[decodeURIComponent(name)] = decodeURIComponent(value);
+    }
+  }
+  return result;
+}
+function serializeCookieValue(name, value) {
+  return `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+}
+function serializeCookie(name, value, options) {
+  const parts = [serializeCookieValue(name, value)];
+  if (options) {
+    if (options.maxAge !== void 0) {
+      parts.push(`Max-Age=${Math.floor(options.maxAge)}`);
+    }
+    if (options.expires !== void 0) {
+      parts.push(`Expires=${options.expires.toUTCString()}`);
+    }
+    if (options.path !== void 0) {
+      parts.push(`Path=${options.path}`);
+    } else {
+      parts.push("Path=/");
+    }
+    if (options.domain !== void 0) {
+      parts.push(`Domain=${options.domain}`);
+    }
+    if (options.secure) {
+      parts.push("Secure");
+    }
+    if (options.httpOnly) {
+      parts.push("HttpOnly");
+    }
+    if (options.sameSite !== void 0) {
+      parts.push(`SameSite=${options.sameSite}`);
+    }
+  }
+  return parts.join("; ");
+}
+function clearCookie(name, options) {
+  return serializeCookie(name, "", {
+    ...options,
+    maxAge: 0,
+    expires: /* @__PURE__ */ new Date(0)
+  });
+}
+
+// src/server/http/upload.ts
+import { randomUUID } from "crypto";
+import { writeFile, readFile, unlink, mkdir } from "fs/promises";
+import { join, extname, basename, dirname } from "path";
+import { tmpdir } from "os";
+var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "image/bmp",
+  "image/tiff",
+  "image/avif"
+]);
+var VIDEO_MIME_TYPES = /* @__PURE__ */ new Set([
+  "video/mp4",
+  "video/mpeg",
+  "video/webm",
+  "video/ogg",
+  "video/quicktime",
+  "video/x-msvideo",
+  "video/x-matroska"
+]);
+var SuperUploadedFile = class _SuperUploadedFile {
+  fieldName;
+  originalName;
+  mimeType;
+  size;
+  path;
+  extension;
+  buffer;
+  constructor(opts) {
+    this.fieldName = opts.fieldName;
+    this.originalName = opts.originalName;
+    this.mimeType = opts.mimeType;
+    this.size = opts.size;
+    this.path = opts.path;
+    this.extension = extname(opts.originalName).toLowerCase();
+    this.buffer = opts.buffer ?? null;
+  }
+  async move(destination, filename) {
+    const destName = filename ?? basename(this.path);
+    const destPath = join(destination, destName);
+    await mkdir(dirname(destPath), { recursive: true });
+    const buf = await this.toBuffer();
+    await writeFile(destPath, buf);
+    return destPath;
+  }
+  async toBuffer() {
+    if (this.buffer !== null) return this.buffer;
+    this.buffer = await readFile(this.path);
+    return this.buffer;
+  }
+  toBase64() {
+    if (this.buffer === null) {
+      throw new Error(
+        "Buffer not loaded. Call toBuffer() first or read the file into memory."
+      );
+    }
+    return this.buffer.toString("base64");
+  }
+  isImage() {
+    return IMAGE_MIME_TYPES.has(this.mimeType);
+  }
+  isVideo() {
+    return VIDEO_MIME_TYPES.has(this.mimeType);
+  }
+  static async createFromBuffer(fieldName, originalName, mimeType, buffer, tempDir) {
+    const tmp = tempDir ?? tmpdir();
+    const fileName = `${randomUUID()}${extname(originalName)}`;
+    const filePath = join(tmp, fileName);
+    await writeFile(filePath, buffer);
+    return new _SuperUploadedFile({
+      fieldName,
+      originalName,
+      mimeType: mimeType || "application/octet-stream",
+      size: buffer.length,
+      path: filePath,
+      buffer
+    });
+  }
+  async cleanup() {
+    try {
+      await unlink(this.path);
+    } catch {
+    }
+  }
+};
+
+// src/server/http/request.ts
+var SuperRequest = class {
+  raw;
+  _headers;
+  _query;
+  _cookies = null;
+  _ip;
+  _params = {};
+  bodyCache = null;
+  _bodyReadPromise = null;
+  constructor(raw) {
+    this.raw = raw;
+    this._headers = new HeadersMap(
+      raw.headers
+    );
+    const parsedUrl = new URL(raw.url ?? "/", "http://localhost");
+    this._query = parseQueryParams(parsedUrl.searchParams);
+    this._ip = parseIp(raw);
+    this.path = parsedUrl.pathname;
+    this.url = raw.url ?? "/";
+    this.method = (raw.method ?? "GET").toUpperCase();
+  }
+  method;
+  url;
+  path;
+  get headers() {
+    return this._headers;
+  }
+  get query() {
+    return this._query;
+  }
+  get params() {
+    return this._params;
+  }
+  set params(value) {
+    this._params = value;
+  }
+  get ip() {
+    return this._ip;
+  }
+  async ensureBody() {
+    if (this.bodyCache !== null) return this.bodyCache;
+    if (this._bodyReadPromise === null) {
+      this._bodyReadPromise = this.readBodyFromStream();
+    }
+    this.bodyCache = await this._bodyReadPromise;
+    return this.bodyCache;
+  }
+  async readBodyFromStream() {
+    const chunks = [];
+    for await (const chunk of this.raw) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks);
+    const text = raw.toString("utf-8");
+    let json = void 0;
+    if (this.isContentType("application/json")) {
+      try {
+        json = JSON.parse(text);
+      } catch {
+        json = void 0;
+      }
+    }
+    let formData = null;
+    let multipartParsed = null;
+    let files = null;
+    if (this.isContentType("application/x-www-form-urlencoded")) {
+      formData = parseUrlEncoded(text);
+    } else if (this.isContentType("multipart/form-data")) {
+      const boundary = this.getMultipartBoundary();
+      if (boundary !== void 0) {
+        multipartParsed = parseMultipartBody(raw, boundary);
+        formData = {};
+        files = {};
+        for (const part of multipartParsed) {
+          if (part.type === "field") {
+            formData[part.name] = part.value;
+          } else if (part.type === "file") {
+            const uploadedFile = await SuperUploadedFile.createFromBuffer(
+              part.name,
+              part.filename,
+              part.mimeType,
+              part.data
+            );
+            files[part.name] = uploadedFile;
+          }
+        }
+      }
+    }
+    return {
+      raw,
+      text,
+      json,
+      parsed: json ?? text,
+      formData,
+      files,
+      multipartParsed
+    };
+  }
+  isContentType(expected) {
+    const ct = this._headers.get("content-type");
+    if (ct === void 0) return false;
+    return ct.toLowerCase().startsWith(expected);
+  }
+  getMultipartBoundary() {
+    const ct = this._headers.get("content-type");
+    if (ct === void 0) return void 0;
+    const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+    if (match !== null) {
+      return match[1] ?? match[2];
+    }
+    return void 0;
+  }
+  async body() {
+    const cache = await this.ensureBody();
+    return cache.parsed;
+  }
+  async json() {
+    const cache = await this.ensureBody();
+    if (cache.json !== void 0) return cache.json;
+    throw new Error("Request body is not valid JSON");
+  }
+  async text() {
+    const cache = await this.ensureBody();
+    return cache.text;
+  }
+  async formData() {
+    const cache = await this.ensureBody();
+    if (cache.formData !== null) return cache.formData;
+    if (cache.multipartParsed !== null) {
+      const result = {};
+      for (const part of cache.multipartParsed) {
+        if (part.type === "field") {
+          result[part.name] = part.value;
+        }
+      }
+      return result;
+    }
+    return {};
+  }
+  async file(name) {
+    const cache = await this.ensureBody();
+    if (cache.files !== null) {
+      return cache.files[name];
+    }
+    return void 0;
+  }
+  async files() {
+    const cache = await this.ensureBody();
+    return cache.files ?? {};
+  }
+  cookie(name) {
+    if (this._cookies === null) {
+      const cookieHeader = this._headers.get("cookie");
+      this._cookies = cookieHeader !== void 0 ? parseCookies(cookieHeader) : {};
+    }
+    return this._cookies[name];
+  }
+  async validate(schema) {
+    const data = await this.body();
+    const result = schema.validate(data);
+    if (!result.success) {
+      const messages = (result.errors ?? []).map((e) => {
+        const path3 = e.path ?? "";
+        return path3 ? `${path3}: ${e.message}` : e.message;
+      }).join("; ");
+      throw new ValidationError(messages, result.errors ?? []);
+    }
+    return result.data;
+  }
+  isAjax() {
+    const requestedWith = this._headers.get("x-requested-with");
+    return requestedWith?.toLowerCase() === "xmlhttprequest";
+  }
+  wantsJson() {
+    const accept = this._headers.get("accept");
+    if (accept !== void 0 && accept.includes("application/json")) {
+      return true;
+    }
+    return this.isAjax();
+  }
+  bearerToken() {
+    const auth = this._headers.get("authorization");
+    if (auth === void 0) return void 0;
+    const match = auth.match(/^Bearer\s+(.+)$/i);
+    return match?.[1];
+  }
+  get rawRequest() {
+    return this.raw;
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+  }
+  errors;
+};
+function parseQueryParams(searchParams) {
+  const result = {};
+  for (const key of searchParams.keys()) {
+    const values = searchParams.getAll(key);
+    result[key] = values.length === 1 ? values[0] : values;
+  }
+  return result;
+}
+function parseIp(req) {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (forwarded !== void 0) {
+    const first = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(",")[0];
+    if (first !== void 0) return first.trim();
+  }
+  const realIp = req.headers["x-real-ip"];
+  if (realIp !== void 0) {
+    return Array.isArray(realIp) ? realIp[0] : realIp;
+  }
+  const remote = req.socket.remoteAddress;
+  if (remote !== void 0) {
+    if (remote.startsWith("::ffff:")) return remote.slice(7);
+    return remote;
+  }
+  return "127.0.0.1";
+}
+function parseUrlEncoded(text) {
+  const result = {};
+  const pairs = text.split("&");
+  for (const pair of pairs) {
+    if (!pair) continue;
+    const eqIndex = pair.indexOf("=");
+    if (eqIndex === -1) {
+      result[decodeURIComponent(pair)] = "";
+    } else {
+      const key = decodeURIComponent(pair.slice(0, eqIndex));
+      const value = decodeURIComponent(pair.slice(eqIndex + 1));
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseMultipartBody(body, boundary) {
+  const result = [];
+  const boundaryBuffer = Buffer.from(`--${boundary}`);
+  let start = 0;
+  let searchFrom = 0;
+  while (true) {
+    const boundaryIndex = body.indexOf(boundaryBuffer, searchFrom);
+    if (boundaryIndex === -1) break;
+    searchFrom = boundaryIndex + boundaryBuffer.length;
+    if (searchFrom < body.length && body[searchFrom] === 45 && body[searchFrom + 1] === 45) {
+      break;
+    }
+    if (searchFrom >= body.length) break;
+    if (body[searchFrom] === 13) searchFrom++;
+    if (body[searchFrom] === 10) searchFrom++;
+    start = searchFrom;
+    const nextBoundaryIndex = body.indexOf(boundaryBuffer, searchFrom);
+    if (nextBoundaryIndex === -1) break;
+    let partEnd = nextBoundaryIndex;
+    if (partEnd >= 2 && body[partEnd - 2] === 13 && body[partEnd - 1] === 10) {
+      partEnd -= 2;
+    }
+    const partData = body.slice(start, partEnd);
+    const headerEndIndex = partData.indexOf(Buffer.from("\r\n\r\n"));
+    if (headerEndIndex === -1) {
+      searchFrom = nextBoundaryIndex;
+      continue;
+    }
+    const headerSection = partData.slice(0, headerEndIndex).toString("utf-8");
+    const contentData = partData.slice(headerEndIndex + 4);
+    const disposition = parseDisposition(headerSection);
+    if (disposition === void 0) {
+      searchFrom = nextBoundaryIndex;
+      continue;
+    }
+    if (disposition.filename !== void 0) {
+      const contentType = parseContentType(headerSection);
+      result.push({
+        type: "file",
+        name: disposition.name,
+        filename: disposition.filename,
+        mimeType: contentType,
+        data: Buffer.from(contentData)
+      });
+    } else {
+      result.push({
+        type: "field",
+        name: disposition.name,
+        value: contentData.toString("utf-8").trim()
+      });
+    }
+    searchFrom = nextBoundaryIndex;
+  }
+  return result;
+}
+function parseDisposition(headerSection) {
+  const match = headerSection.match(
+    /content-disposition:\s*form-data;\s*(.+)/i
+  );
+  if (match === null) return void 0;
+  const params = match[1];
+  const nameMatch = params.match(/name="([^"]*)"/i);
+  const filenameMatch = params.match(/filename="([^"]*)"/i);
+  if (nameMatch === null) return void 0;
+  return {
+    name: nameMatch[1],
+    filename: filenameMatch?.[1]
+  };
+}
+function parseContentType(headerSection) {
+  const match = headerSection.match(/content-type:\s*([^\s;]+)/i);
+  return match?.[1] ?? "application/octet-stream";
+}
+
+// src/server/http/response.ts
+import { createReadStream, stat } from "fs";
+import { basename as basename2, extname as extname2 } from "path";
+import { promisify } from "util";
+var statAsync = promisify(stat);
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".xml": "application/xml",
+  ".zip": "application/zip",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav"
+};
+var SuperResponse = class {
+  raw;
+  _statusCode = HttpStatus.OK;
+  _headers = new HeadersMap();
+  _cookies = [];
+  _body = null;
+  _sent = false;
+  _contentTypeSet = false;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  status(code) {
+    this._statusCode = code;
+    return this;
+  }
+  header(name, value) {
+    this._headers.set(name, value);
+    return this;
+  }
+  setHeader(name, value) {
+    return this.header(name, value);
+  }
+  getHeader(name) {
+    return this._headers.get(name);
+  }
+  removeHeader(name) {
+    this._headers.delete(name);
+    return this;
+  }
+  hasHeader(name) {
+    return this._headers.has(name);
+  }
+  type(contentType) {
+    this._headers.set("content-type", contentType);
+    this._contentTypeSet = true;
+    return this;
+  }
+  json(data, status) {
+    if (status !== void 0) this._statusCode = status;
+    const body = JSON.stringify(data);
+    return this.send(body, void 0, "application/json");
+  }
+  send(body, status, contentType) {
+    if (status !== void 0) this._statusCode = status;
+    this._body = body;
+    if (contentType !== void 0 && !this._contentTypeSet) {
+      this._headers.set("content-type", contentType);
+    }
+    return this;
+  }
+  html(html, status) {
+    return this.send(html, status, "text/html; charset=utf-8");
+  }
+  redirect(url2, status = HttpStatus.FOUND) {
+    this._statusCode = status;
+    this._headers.set("location", url2);
+    this._body = null;
+    return this;
+  }
+  stream(stream, status) {
+    if (status !== void 0) this._statusCode = status;
+    this.flushHeaders();
+    this.raw.statusCode = this._statusCode;
+    stream.pipe(this.raw);
+    stream.on("end", () => {
+      this._sent = true;
+    });
+    stream.on("error", (_err) => {
+      if (!this._sent) {
+        this._sent = true;
+        this.raw.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+        this.raw.end();
+      }
+    });
+    return this;
+  }
+  async file(filePath, options) {
+    const fullPath = options?.root ? joinPath(options.root, filePath) : filePath;
+    try {
+      const stats = await statAsync(fullPath);
+      if (!stats.isFile()) {
+        this._statusCode = HttpStatus.NOT_FOUND;
+        this._body = null;
+        return this;
+      }
+      const ext = extname2(fullPath);
+      const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+      this._headers.set("content-type", mimeType);
+      this._headers.set("content-length", String(stats.size));
+      if (options?.cacheControl !== false) {
+        const maxAge = options?.maxAge ?? 0;
+        this._headers.set("cache-control", `public, max-age=${maxAge}`);
+      }
+      if (options?.lastModified !== false) {
+        this._headers.set("last-modified", stats.mtime.toUTCString());
+      }
+      if (options?.headers !== void 0) {
+        for (const [key, value] of Object.entries(options.headers)) {
+          this._headers.set(key, value);
+        }
+      }
+      this.flushHeaders();
+      this.raw.statusCode = this._statusCode;
+      const readStream = createReadStream(fullPath);
+      readStream.pipe(this.raw);
+      readStream.on("end", () => {
+        this._sent = true;
+      });
+      readStream.on("error", () => {
+        if (!this._sent) {
+          this._sent = true;
+          this.raw.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+          this.raw.end();
+        }
+      });
+    } catch {
+      this._statusCode = HttpStatus.NOT_FOUND;
+      this._body = null;
+    }
+    return this;
+  }
+  async download(filePath, filename) {
+    const downloadName = filename ?? basename2(filePath);
+    this._headers.set(
+      "content-disposition",
+      `attachment; filename="${downloadName}"`
+    );
+    await this.file(filePath);
+    return this;
+  }
+  attachment(filename) {
+    if (filename !== void 0) {
+      this._headers.set(
+        "content-disposition",
+        `attachment; filename="${filename}"`
+      );
+    } else {
+      this._headers.set("content-disposition", "attachment");
+    }
+    return this;
+  }
+  cookie(name, value, options) {
+    this._cookies.push(serializeCookie(name, value, options));
+    return this;
+  }
+  clearCookie(name, options) {
+    this._cookies.push(clearCookie(name, options));
+    return this;
+  }
+  get statusCode() {
+    return this._statusCode;
+  }
+  get headersSent() {
+    return this._sent;
+  }
+  get rawResponse() {
+    return this.raw;
+  }
+  async flush() {
+    if (this._sent) return;
+    this._sent = true;
+    this.flushHeaders();
+    this.raw.statusCode = this._statusCode;
+    if (this._body !== null) {
+      this.raw.end(this._body);
+    } else {
+      this.raw.end();
+    }
+  }
+  flushHeaders() {
+    if (this._cookies.length > 0) {
+      this.raw.setHeader("Set-Cookie", this._cookies);
+    }
+    for (const [name, value] of this._headers.entries()) {
+      if (name.toLowerCase() !== "set-cookie") {
+        this.raw.setHeader(name, value);
+      }
+    }
+  }
+};
+function joinPath(root, filePath) {
+  const normalizedRoot = root.replace(/\\/g, "/").replace(/\/$/, "");
+  const normalizedPath = filePath.replace(/\\/g, "/").replace(/^\//, "");
+  return `${normalizedRoot}/${normalizedPath}`;
+}
+
+// src/server/engine/index.ts
+var NodeEngine = class {
+  async createServer(handler) {
+    const server = createHttpServer(async (nodeReq, nodeRes) => {
+      const req = new SuperRequest(nodeReq);
+      const res = new SuperResponse(nodeRes);
+      try {
+        await handler(req, res);
+      } catch (_err) {
+        if (!res.headersSent) {
+          const message = _err instanceof Error ? _err.message : "Internal Server Error";
+          res.status(500).json({ error: message });
+          await res.flush();
+        }
+      }
+      if (!res.headersSent) {
+        await res.flush();
+      }
+    });
+    return {
+      raw: server,
+      close: () => {
+        return new Promise((resolve2, reject) => {
+          server.close((err) => {
+            if (err !== void 0 && err !== null) {
+              reject(err);
+            } else {
+              resolve2();
+            }
+          });
+        });
+      }
+    };
+  }
+  getPort(server) {
+    const addr = server.raw.address();
+    if (addr !== null && typeof addr === "object") {
+      return addr.port;
+    }
+    return 0;
+  }
+  async close(server) {
+    await server.close();
+  }
+};
+
+// src/server/middleware/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { createReadStream as createReadStream2, existsSync, statSync } from "fs";
+import { extname as extname3, join as join2 } from "path";
+import { createGzip } from "zlib";
+function staticFiles(root, options) {
+  const opts = {
+    maxAge: 0,
+    index: "index.html",
+    dotfiles: "deny",
+    extensions: [],
+    ...options
+  };
+  const MIME_TYPES2 = {
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".txt": "text/plain",
+    ".pdf": "application/pdf",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf"
+  };
+  return (ctx, next) => {
+    const { request, response } = ctx;
+    const filePath = request.path;
+    if (opts.dotfiles === "deny") {
+      const segments = filePath.split("/");
+      for (const segment of segments) {
+        if (segment.startsWith(".")) {
+          return next();
+        }
+      }
+    }
+    let fullPath = join2(root, filePath);
+    if (!existsSync(fullPath)) {
+      let found = false;
+      for (const ext2 of opts.extensions) {
+        const tryPath = fullPath + ext2;
+        if (existsSync(tryPath)) {
+          fullPath = tryPath;
+          found = true;
+          break;
+        }
+      }
+      if (!found) return next();
+    }
+    const stats = statSync(fullPath);
+    if (!stats.isFile()) {
+      if (stats.isDirectory()) {
+        const indexPath = join2(fullPath, opts.index);
+        if (existsSync(indexPath) && statSync(indexPath).isFile()) {
+          fullPath = indexPath;
+        } else {
+          return next();
+        }
+      } else {
+        return next();
+      }
+    }
+    const ext = extname3(fullPath);
+    const mimeType = MIME_TYPES2[ext] ?? "application/octet-stream";
+    response.header("content-type", mimeType).header("content-length", String(stats.size)).header("cache-control", `public, max-age=${opts.maxAge}`).header("last-modified", stats.mtime.toUTCString());
+    const readStream = createReadStream2(fullPath);
+    readStream.pipe(response.rawResponse);
+    response.rawResponse.statusCode = HttpStatus.OK;
+    return new Promise((resolve2, reject) => {
+      readStream.on("end", () => resolve2());
+      readStream.on("error", (err) => reject(err));
+    });
+  };
+}
+var MiddlewarePipeline = class {
+  middlewares = [];
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return this;
+  }
+  prepend(middleware) {
+    this.middlewares.unshift(middleware);
+    return this;
+  }
+  remove(name) {
+    this.middlewares = this.middlewares.filter((mw) => mw.name !== name);
+  }
+  async run(ctx, final) {
+    let index = 0;
+    const next = async () => {
+      if (index >= this.middlewares.length) {
+        await final();
+        return;
+      }
+      const middleware = this.middlewares[index];
+      index++;
+      await middleware(ctx, next);
+    };
+    await next();
+  }
+  getMiddlewares() {
+    return [...this.middlewares];
+  }
+};
+
+// src/server/router/index.ts
+var Router = class {
+  routes = [];
+  groupMiddleware = [];
+  groupPrefix = "";
+  namedRoutes = /* @__PURE__ */ new Map();
+  get(path3, handler) {
+    return this.match(["GET"], path3, handler);
+  }
+  post(path3, handler) {
+    return this.match(["POST"], path3, handler);
+  }
+  put(path3, handler) {
+    return this.match(["PUT"], path3, handler);
+  }
+  patch(path3, handler) {
+    return this.match(["PATCH"], path3, handler);
+  }
+  delete(path3, handler) {
+    return this.match(["DELETE"], path3, handler);
+  }
+  options(path3, handler) {
+    return this.match(["OPTIONS"], path3, handler);
+  }
+  any(path3, handler) {
+    return this.match(
+      ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+      path3,
+      handler
+    );
+  }
+  match(methods, path3, handler) {
+    const fullPath = this.groupPrefix + normalizePath(path3);
+    const { regexp, keys } = pathToRegexp(fullPath);
+    this.routes.push({
+      methods: methods.map((m) => m.toUpperCase()),
+      path: fullPath,
+      handler,
+      middleware: [...this.groupMiddleware],
+      regexp,
+      paramKeys: keys
+    });
+    return this;
+  }
+  group(prefix, callback) {
+    const previousPrefix = this.groupPrefix;
+    const previousMiddleware = [...this.groupMiddleware];
+    this.groupPrefix = previousPrefix + normalizePath(prefix);
+    callback(this);
+    this.groupPrefix = previousPrefix;
+    this.groupMiddleware = previousMiddleware;
+    return this;
+  }
+  resource(name, controller) {
+    const actions = {
+      index: "index",
+      create: "create",
+      store: "store",
+      show: "show",
+      edit: "edit",
+      update: "update",
+      destroy: "destroy"
+    };
+    return this.registerResourceRoutes(name, controller, actions);
+  }
+  apiResource(name, controller) {
+    const actions = {
+      index: "index",
+      store: "store",
+      show: "show",
+      update: "update",
+      destroy: "destroy"
+    };
+    return this.registerResourceRoutes(name, controller, actions);
+  }
+  registerResourceRoutes(name, controller, actions) {
+    const basePath = normalizePath(name);
+    const paramName = singularize(name);
+    if (actions.index !== void 0) {
+      this.get(
+        basePath,
+        this.createControllerHandler(controller, actions.index)
+      );
+    }
+    if (actions.create !== void 0) {
+      this.get(
+        `${basePath}/create`,
+        this.createControllerHandler(controller, actions.create)
+      );
+    }
+    if (actions.store !== void 0) {
+      this.post(
+        basePath,
+        this.createControllerHandler(controller, actions.store)
+      );
+    }
+    if (actions.show !== void 0) {
+      this.get(
+        `${basePath}/:${paramName}`,
+        this.createControllerHandler(controller, actions.show)
+      );
+    }
+    if (actions.edit !== void 0) {
+      this.get(
+        `${basePath}/:${paramName}/edit`,
+        this.createControllerHandler(controller, actions.edit)
+      );
+    }
+    if (actions.update !== void 0) {
+      this.put(
+        `${basePath}/:${paramName}`,
+        this.createControllerHandler(controller, actions.update)
+      );
+      this.patch(
+        `${basePath}/:${paramName}`,
+        this.createControllerHandler(controller, actions.update)
+      );
+    }
+    if (actions.destroy !== void 0) {
+      this.delete(
+        `${basePath}/:${paramName}`,
+        this.createControllerHandler(controller, actions.destroy)
+      );
+    }
+    return this;
+  }
+  createControllerHandler(controller, action) {
+    return async (ctx) => {
+      const instance = createControllerInstance(controller, ctx);
+      const handler = instance[action];
+      if (typeof handler === "function") {
+        await handler.call(instance, ctx);
+      } else {
+        throw new Error(
+          `Action ${action} not found on controller ${controller.name}`
+        );
+      }
+    };
+  }
+  middleware(middleware) {
+    const mw = Array.isArray(middleware) ? middleware : [middleware];
+    this.groupMiddleware.push(...mw);
+    return this;
+  }
+  name(name) {
+    if (this.routes.length > 0) {
+      const lastRoute = this.routes[this.routes.length - 1];
+      if (lastRoute !== void 0) {
+        lastRoute.name = name;
+        this.namedRoutes.set(name, lastRoute);
+      }
+    }
+    return this;
+  }
+  route(name, params) {
+    const entry = this.namedRoutes.get(name);
+    if (entry === void 0) {
+      throw new Error(`Route not found: ${name}`);
+    }
+    let url2 = entry.path;
+    if (params !== void 0) {
+      for (const [key, value] of Object.entries(params)) {
+        url2 = url2.replace(`:${key}`, encodeURIComponent(value));
+      }
+    }
+    return url2;
+  }
+  resolve(method, path3) {
+    const normalizedPath = normalizePath(path3);
+    const upperMethod = method.toUpperCase();
+    for (const route of this.routes) {
+      if (!route.methods.includes(upperMethod)) continue;
+      const match = normalizedPath.match(route.regexp);
+      if (match === null) continue;
+      const params = {};
+      for (let i = 0; i < route.paramKeys.length; i++) {
+        const key = route.paramKeys[i];
+        const value = match[i + 1];
+        if (key !== void 0 && value !== void 0) {
+          params[key] = decodeURIComponent(value);
+        }
+      }
+      return {
+        handler: route.handler,
+        params,
+        middleware: route.middleware
+      };
+    }
+    return null;
+  }
+  getRoutes() {
+    return [...this.routes];
+  }
+  getNamedRoutes() {
+    return new Map(this.namedRoutes);
+  }
+};
+function normalizePath(path3) {
+  let normalized = path3.replace(/\\/g, "/");
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function pathToRegexp(pattern) {
+  const keys = [];
+  const regexpStr = pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_match, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*/g, ".*?");
+  return { regexp: new RegExp(`^${regexpStr}$`), keys };
+}
+function singularize(word) {
+  const lastChar = word[word.length - 1];
+  if (lastChar === "s") return word.slice(0, -1);
+  if (lastChar === "S") return word.slice(0, -1);
+  return word;
+}
+function createControllerInstance(controller, ctx) {
+  const instance = new controller();
+  instance.__ctx = ctx;
+  instance.__container = ctx.container;
+  return instance;
+}
+
+// src/server/cache/index.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var Cache = class {
+  store;
+  config;
+  hits = 0;
+  misses = 0;
+  constructor(config) {
+    this.config = {
+      store: "memory",
+      path: path.join(process.cwd(), "cache"),
+      ttl: 3600,
+      prefix: "",
+      ...config
+    };
+    this.store = /* @__PURE__ */ new Map();
+    if (this.config.store === "file") {
+      const dir = this.config.path;
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+  }
+  async get(key) {
+    const fullKey = this.config.prefix + key;
+    if (this.config.store === "file") {
+      return this.fileGet(fullKey);
+    }
+    const entry = this.store.get(fullKey);
+    if (entry === void 0) {
+      this.misses++;
+      return null;
+    }
+    if (this.isExpired(entry)) {
+      this.store.delete(fullKey);
+      this.misses++;
+      return null;
+    }
+    this.hits++;
+    return entry.value;
+  }
+  async remember(key, ttl, callback) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await callback();
+    await this.set(key, value, ttl);
+    return value;
+  }
+  async set(key, value, ttl) {
+    const fullKey = this.config.prefix + key;
+    const expiresAt = ttl !== void 0 ? Date.now() + ttl * 1e3 : Date.now() + this.config.ttl * 1e3;
+    if (this.config.store === "file") {
+      await this.fileSet(fullKey, { value, expiresAt });
+      return;
+    }
+    this.store.set(fullKey, { value, expiresAt });
+  }
+  async add(key, value, ttl) {
+    const exists = await this.has(key);
+    if (exists) {
+      return false;
+    }
+    await this.set(key, value, ttl);
+    return true;
+  }
+  async delete(key) {
+    const fullKey = this.config.prefix + key;
+    if (this.config.store === "file") {
+      return this.fileDelete(fullKey);
+    }
+    return this.store.delete(fullKey);
+  }
+  async clear() {
+    if (this.config.store === "file") {
+      const dir = this.config.path;
+      if (fs.existsSync(dir)) {
+        for (const file of fs.readdirSync(dir)) {
+          fs.unlinkSync(path.join(dir, file));
+        }
+      }
+      return;
+    }
+    this.store.clear();
+  }
+  async has(key) {
+    const value = await this.get(key);
+    return value !== null;
+  }
+  async getMultiple(keys) {
+    const result = {};
+    for (const key of keys) {
+      const value = await this.get(key);
+      if (value !== null) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  async setMultiple(items, ttl) {
+    for (const [key, value] of Object.entries(items)) {
+      await this.set(key, value, ttl);
+    }
+  }
+  async increment(key, value = 1) {
+    const current = await this.get(key);
+    const newValue = (current ?? 0) + value;
+    await this.set(key, newValue);
+    return newValue;
+  }
+  async decrement(key, value = 1) {
+    const current = await this.get(key);
+    const newValue = (current ?? 0) - value;
+    await this.set(key, newValue);
+    return newValue;
+  }
+  async forever(key, value) {
+    const fullKey = this.config.prefix + key;
+    const expiresAt = Number.MAX_SAFE_INTEGER;
+    if (this.config.store === "file") {
+      await this.fileSet(fullKey, { value, expiresAt });
+      return;
+    }
+    this.store.set(fullKey, { value, expiresAt });
+  }
+  stats() {
+    let keyCount = 0;
+    let totalSize = 0;
+    if (this.config.store === "file") {
+      const dir = this.config.path;
+      if (fs.existsSync(dir)) {
+        const files = fs.readdirSync(dir);
+        keyCount = files.length;
+        for (const file of files) {
+          try {
+            const st = fs.statSync(path.join(dir, file));
+            totalSize += st.size;
+          } catch {
+          }
+        }
+      }
+    } else {
+      keyCount = this.store.size;
+      for (const [, entry] of this.store) {
+        totalSize += JSON.stringify(entry).length;
+      }
+    }
+    const sizeStr = totalSize > 1024 * 1024 ? `${(totalSize / (1024 * 1024)).toFixed(2)} MB` : totalSize > 1024 ? `${(totalSize / 1024).toFixed(2)} KB` : `${totalSize} B`;
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      keys: keyCount,
+      size: sizeStr
+    };
+  }
+  getFilePath(key) {
+    const hashedKey = crypto.createHash("md5").update(key).digest("hex");
+    return path.join(this.config.path, `${hashedKey}.json`);
+  }
+  isExpired(entry) {
+    return entry.expiresAt < Date.now();
+  }
+  fileGet(key) {
+    const filePath = this.getFilePath(key);
+    if (!fs.existsSync(filePath)) {
+      this.misses++;
+      return null;
+    }
+    try {
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const entry = JSON.parse(raw);
+      if (this.isExpired(entry)) {
+        fs.unlinkSync(filePath);
+        this.misses++;
+        return null;
+      }
+      this.hits++;
+      return entry.value;
+    } catch {
+      this.misses++;
+      return null;
+    }
+  }
+  fileSet(key, entry) {
+    const filePath = this.getFilePath(key);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(entry), "utf-8");
+  }
+  fileDelete(key) {
+    const filePath = this.getFilePath(key);
+    if (!fs.existsSync(filePath)) {
+      return false;
+    }
+    fs.unlinkSync(filePath);
+    return true;
+  }
+};
+var responseCache = new Cache({ store: "memory" });
+function cacheResponse(ttl) {
+  const cache = responseCache;
+  return async (ctx, next) => {
+    const key = `_cache:${ctx.request.method}:${ctx.request.path}`;
+    if (ctx.request.method !== "GET") {
+      return next();
+    }
+    const cached = await cache.get(key);
+    if (cached !== null) {
+      ctx.response.status(cached.status).type(cached.contentType).send(cached.body);
+      return;
+    }
+    await next();
+    const resp = ctx.response;
+    const body = resp._body;
+    if (body !== null && resp._statusCode >= 200 && resp._statusCode < 300) {
+      const contentType = ctx.response.getHeader("content-type") ?? "text/plain";
+      await cache.set(
+        key,
+        {
+          body: typeof body === "string" ? body : body.toString(),
+          status: resp._statusCode,
+          contentType
+        },
+        ttl
+      );
+    }
+  };
+}
+
+// src/server/database/connection.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/server/database/dialect.ts
+var MysqlDialect = class {
+  wrapIdentifier(identifier) {
+    return `\`${identifier.replace(/`/g, "``")}\``;
+  }
+  makeParameter(_index) {
+    return "?";
+  }
+  compileLimitOffset(bindings, limit, offset) {
+    if (limit === null && offset === null) return "";
+    if (offset !== null) {
+      bindings.push(limit ?? 0, offset);
+      return " LIMIT ? OFFSET ?";
+    }
+    bindings.push(limit);
+    return " LIMIT ?";
+  }
+  compileInsertReturning(sql, _bindings, _idColumn) {
+    return `${sql}; SELECT LAST_INSERT_ID() as id`;
+  }
+  compileTruncate(tableName) {
+    return `TRUNCATE TABLE ${this.wrapIdentifier(tableName)}`;
+  }
+  compileCreateMigrationsTable() {
+    return `CREATE TABLE IF NOT EXISTS \`migrations\` (
+  \`id\` INT AUTO_INCREMENT PRIMARY KEY,
+  \`name\` VARCHAR(255) NOT NULL,
+  \`batch\` INT NOT NULL,
+  \`executed_at\` TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)`;
+  }
+  mapType(type, options) {
+    switch (type) {
+      case "id":
+      case "increments":
+        return "INT AUTO_INCREMENT PRIMARY KEY";
+      case "bigIncrements":
+        return "BIGINT AUTO_INCREMENT PRIMARY KEY";
+      case "string":
+        return `VARCHAR(${options.length ?? 255})`;
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INT";
+      case "bigInteger":
+        return "BIGINT";
+      case "tinyInteger":
+        return "TINYINT";
+      case "smallInteger":
+        return "SMALLINT";
+      case "boolean":
+        return "TINYINT(1)";
+      case "float":
+        return "FLOAT";
+      case "double":
+        return "DOUBLE";
+      case "decimal":
+        return `DECIMAL(${options.precision ?? 10},${options.scale ?? 0})`;
+      case "date":
+        return "DATE";
+      case "datetime":
+        return "DATETIME";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "time":
+        return "TIME";
+      case "year":
+        return "YEAR";
+      case "json":
+      case "jsonb":
+        return "JSON";
+      case "binary":
+        return "BLOB";
+      case "uuid":
+        return "CHAR(36)";
+      case "foreignId":
+        return "INT UNSIGNED";
+      default:
+        return type;
+    }
+  }
+  compileColumn(options) {
+    let sql = `${this.wrapIdentifier(options.name)} ${this.mapType(options.type, options)}`;
+    if (options.unsigned && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements" && options.type !== "foreignId")
+      sql += " UNSIGNED";
+    if (options.autoIncrement && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " AUTO_INCREMENT";
+    if (options.defaultValue !== void 0 && options.defaultValue !== null) {
+      sql += ` DEFAULT ${this.formatDefault(options.defaultValue)}`;
+    } else if (!options.nullable && !options.autoIncrement && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements") {
+      sql += " NOT NULL";
+    }
+    if (options.nullable) sql += " NULL";
+    if (options.primary) sql += " PRIMARY KEY";
+    if (options.unique) sql += " UNIQUE";
+    if (options.comment !== null)
+      sql += ` COMMENT '${options.comment.replace(/'/g, "\\'")}'`;
+    if (options.after !== null)
+      sql += ` AFTER ${this.wrapIdentifier(options.after)}`;
+    return sql;
+  }
+  compileModifyColumn(options) {
+    return `MODIFY COLUMN ${this.compileColumn(options)}`;
+  }
+  compileTableBlueprint(_tableName, columns, constraints) {
+    const parts = [
+      ...columns.map((c) => this.compileColumn(c)),
+      ...constraints
+    ];
+    return parts.join(",\n  ");
+  }
+  compileAddColumns(_tableName, columns) {
+    return `ADD ${columns.map((c) => this.compileColumn(c)).join(", ADD ")}`;
+  }
+  compileDropColumns(_tableName, columns) {
+    return `DROP COLUMN ${columns.map((c) => this.wrapIdentifier(c)).join(", DROP COLUMN ")}`;
+  }
+  compileRenameColumn(_tableName, from, to) {
+    return `RENAME COLUMN ${this.wrapIdentifier(from)} TO ${this.wrapIdentifier(to)}`;
+  }
+  compileCreateTable(tableName, columns, constraints) {
+    const body = this.compileTableBlueprint(tableName, columns, constraints);
+    return `CREATE TABLE ${this.wrapIdentifier(tableName)} (
+  ${body}
+)`;
+  }
+  compileRenameTable(from, to) {
+    return `RENAME TABLE ${this.wrapIdentifier(from)} TO ${this.wrapIdentifier(to)}`;
+  }
+  compileDropTable(tableName) {
+    return `DROP TABLE ${this.wrapIdentifier(tableName)}`;
+  }
+  compileDropTableIfExists(tableName) {
+    return `DROP TABLE IF EXISTS ${this.wrapIdentifier(tableName)}`;
+  }
+  compileHasTable(_tableName) {
+    return `SELECT COUNT(*) as \`count\` FROM \`information_schema\`.\`tables\` WHERE \`table_schema\` = DATABASE() AND \`table_name\` = ?`;
+  }
+  compileHasColumn(_tableName, _columnName) {
+    return `SELECT COUNT(*) as \`count\` FROM \`information_schema\`.\`columns\` WHERE \`table_schema\` = DATABASE() AND \`table_name\` = ? AND \`column_name\` = ?`;
+  }
+  compileInsert(sql) {
+    return sql;
+  }
+  formatDefault(value) {
+    if (typeof value === "string") {
+      if (value === "CURRENT_TIMESTAMP") return value;
+      return `'${value.replace(/'/g, "\\'")}'`;
+    }
+    if (value === null) return "NULL";
+    if (typeof value === "boolean") return value ? "1" : "0";
+    return String(value);
+  }
+};
+var SqliteDialect = class {
+  wrapIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+  makeParameter(_index) {
+    return "?";
+  }
+  compileLimitOffset(bindings, limit, offset) {
+    if (limit === null && offset === null) return "";
+    if (offset !== null) {
+      bindings.push(limit ?? 0, offset);
+      return " LIMIT ? OFFSET ?";
+    }
+    bindings.push(limit);
+    return " LIMIT ?";
+  }
+  compileInsertReturning(sql, _bindings, _idColumn) {
+    return `${sql}; SELECT last_insert_rowid() as id`;
+  }
+  compileTruncate(tableName) {
+    return `DELETE FROM ${this.wrapIdentifier(tableName)}`;
+  }
+  compileCreateMigrationsTable() {
+    return `CREATE TABLE IF NOT EXISTS "migrations" (
+  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "name" TEXT NOT NULL,
+  "batch" INTEGER NOT NULL,
+  "executed_at" TEXT DEFAULT CURRENT_TIMESTAMP
+)`;
+  }
+  mapType(type, options) {
+    switch (type) {
+      case "id":
+      case "increments":
+        return "INTEGER PRIMARY KEY AUTOINCREMENT";
+      case "bigIncrements":
+        return "INTEGER PRIMARY KEY AUTOINCREMENT";
+      case "string":
+        return `VARCHAR(${options.length ?? 255})`;
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INTEGER";
+      case "bigInteger":
+        return "INTEGER";
+      case "tinyInteger":
+        return "INTEGER";
+      case "smallInteger":
+        return "INTEGER";
+      case "boolean":
+        return "INTEGER";
+      case "float":
+        return "REAL";
+      case "double":
+        return "REAL";
+      case "decimal":
+        return "REAL";
+      case "date":
+        return "TEXT";
+      case "datetime":
+        return "TEXT";
+      case "timestamp":
+        return "TEXT";
+      case "time":
+        return "TEXT";
+      case "year":
+        return "TEXT";
+      case "json":
+      case "jsonb":
+        return "TEXT";
+      case "binary":
+        return "BLOB";
+      case "uuid":
+        return "TEXT";
+      case "foreignId":
+        return "INTEGER";
+      default:
+        return type;
+    }
+  }
+  compileColumn(options) {
+    let sql = `${this.wrapIdentifier(options.name)} ${this.mapType(options.type, options)}`;
+    if (options.autoIncrement && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " AUTOINCREMENT";
+    if (!options.nullable && options.defaultValue === void 0 && !options.autoIncrement && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " NOT NULL";
+    if (options.nullable) sql += " NULL";
+    if (options.defaultValue !== void 0 && options.defaultValue !== null) {
+      sql += ` DEFAULT ${this.formatDefault(options.defaultValue)}`;
+    }
+    if (options.primary) sql += " PRIMARY KEY";
+    if (options.unique) sql += " UNIQUE";
+    return sql;
+  }
+  compileModifyColumn(options) {
+    return this.compileColumn(options);
+  }
+  compileTableBlueprint(_tableName, columns, constraints) {
+    const parts = [
+      ...columns.map((c) => this.compileColumn(c)),
+      ...constraints
+    ];
+    return parts.join(",\n  ");
+  }
+  compileAddColumns(_tableName, columns) {
+    return `ADD COLUMN ${columns.map((c) => this.compileColumn(c)).join(", ADD COLUMN ")}`;
+  }
+  compileDropColumns(_tableName, columns) {
+    return `DROP COLUMN ${columns.map((c) => this.wrapIdentifier(c)).join(", DROP COLUMN ")}`;
+  }
+  compileRenameColumn(_tableName, from, to) {
+    return `RENAME COLUMN ${this.wrapIdentifier(from)} TO ${this.wrapIdentifier(to)}`;
+  }
+  compileCreateTable(tableName, columns, constraints) {
+    const body = this.compileTableBlueprint(tableName, columns, constraints);
+    return `CREATE TABLE ${this.wrapIdentifier(tableName)} (
+  ${body}
+)`;
+  }
+  compileRenameTable(from, to) {
+    return `ALTER TABLE ${this.wrapIdentifier(from)} RENAME TO ${this.wrapIdentifier(to)}`;
+  }
+  compileDropTable(tableName) {
+    return `DROP TABLE ${this.wrapIdentifier(tableName)}`;
+  }
+  compileDropTableIfExists(tableName) {
+    return `DROP TABLE IF EXISTS ${this.wrapIdentifier(tableName)}`;
+  }
+  compileHasTable(_tableName) {
+    return `SELECT COUNT(*) as "count" FROM "sqlite_master" WHERE "type" = 'table' AND "name" = ?`;
+  }
+  compileHasColumn(_tableName, _columnName) {
+    return `PRAGMA table_info(${this.wrapIdentifier(_tableName)})`;
+  }
+  compileInsert(sql) {
+    return sql;
+  }
+  formatDefault(value) {
+    if (typeof value === "string") {
+      if (value === "CURRENT_TIMESTAMP") return value;
+      return `'${value.replace(/'/g, "''")}'`;
+    }
+    if (value === null) return "NULL";
+    if (typeof value === "boolean") return value ? "1" : "0";
+    return String(value);
+  }
+};
+var PostgresqlDialect = class {
+  wrapIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+  makeParameter(index) {
+    return `$${index + 1}`;
+  }
+  compileLimitOffset(bindings, limit, offset) {
+    if (limit === null && offset === null) return "";
+    const start = bindings.length;
+    if (offset !== null) {
+      bindings.push(limit ?? 0, offset);
+      return ` LIMIT $${start + 1} OFFSET $${start + 2}`;
+    }
+    bindings.push(limit);
+    return ` LIMIT $${start + 1}`;
+  }
+  compileInsertReturning(sql, _bindings, idColumn = "id") {
+    return `${sql} RETURNING ${this.wrapIdentifier(idColumn)}`;
+  }
+  compileTruncate(tableName) {
+    return `TRUNCATE TABLE ${this.wrapIdentifier(tableName)} RESTART IDENTITY CASCADE`;
+  }
+  compileCreateMigrationsTable() {
+    return `CREATE TABLE IF NOT EXISTS "migrations" (
+  "id" SERIAL PRIMARY KEY,
+  "name" VARCHAR(255) NOT NULL,
+  "batch" INTEGER NOT NULL,
+  "executed_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)`;
+  }
+  mapType(type, options) {
+    switch (type) {
+      case "id":
+      case "increments":
+        return "SERIAL PRIMARY KEY";
+      case "bigIncrements":
+        return "BIGSERIAL PRIMARY KEY";
+      case "string":
+        return `VARCHAR(${options.length ?? 255})`;
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INTEGER";
+      case "bigInteger":
+        return "BIGINT";
+      case "tinyInteger":
+        return "SMALLINT";
+      case "smallInteger":
+        return "SMALLINT";
+      case "boolean":
+        return "BOOLEAN";
+      case "float":
+        return "REAL";
+      case "double":
+        return "DOUBLE PRECISION";
+      case "decimal":
+        return `DECIMAL(${options.precision ?? 10},${options.scale ?? 0})`;
+      case "date":
+        return "DATE";
+      case "datetime":
+        return "TIMESTAMP";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "time":
+        return "TIME";
+      case "year":
+        return "INTEGER";
+      case "json":
+        return "JSON";
+      case "jsonb":
+        return "JSONB";
+      case "binary":
+        return "BYTEA";
+      case "uuid":
+        return "UUID";
+      case "foreignId":
+        return "INTEGER";
+      default:
+        return type;
+    }
+  }
+  compileColumn(options) {
+    let sql = `${this.wrapIdentifier(options.name)} ${this.mapType(options.type, options)}`;
+    if (!options.nullable && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " NOT NULL";
+    if (options.nullable) sql += " NULL";
+    if (options.defaultValue !== void 0 && options.defaultValue !== null) {
+      sql += ` DEFAULT ${this.formatDefault(options.defaultValue)}`;
+    }
+    if (options.primary && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " PRIMARY KEY";
+    if (options.unique) sql += " UNIQUE";
+    if (options.comment !== null)
+      sql += ` -- ${options.comment.replace(/--/g, "")}`;
+    return sql;
+  }
+  compileModifyColumn(options) {
+    return `ALTER COLUMN ${this.wrapIdentifier(options.name)} TYPE ${this.mapType(options.type, options)}`;
+  }
+  compileTableBlueprint(_tableName, columns, constraints) {
+    const parts = [
+      ...columns.map((c) => this.compileColumn(c)),
+      ...constraints
+    ];
+    return parts.join(",\n  ");
+  }
+  compileAddColumns(_tableName, columns) {
+    return `ADD COLUMN ${columns.map((c) => this.compileColumn(c)).join(", ADD COLUMN ")}`;
+  }
+  compileDropColumns(_tableName, columns) {
+    return `DROP COLUMN ${columns.map((c) => this.wrapIdentifier(c)).join(", DROP COLUMN ")}`;
+  }
+  compileRenameColumn(_tableName, from, to) {
+    return `RENAME COLUMN ${this.wrapIdentifier(from)} TO ${this.wrapIdentifier(to)}`;
+  }
+  compileCreateTable(tableName, columns, constraints) {
+    const body = this.compileTableBlueprint(tableName, columns, constraints);
+    return `CREATE TABLE ${this.wrapIdentifier(tableName)} (
+  ${body}
+)`;
+  }
+  compileRenameTable(from, to) {
+    return `ALTER TABLE ${this.wrapIdentifier(from)} RENAME TO ${this.wrapIdentifier(to)}`;
+  }
+  compileDropTable(_tableName) {
+    return `DROP TABLE IF EXISTS ${this.wrapIdentifier(_tableName)}`;
+  }
+  compileDropTableIfExists(tableName) {
+    return `DROP TABLE IF EXISTS ${this.wrapIdentifier(tableName)}`;
+  }
+  compileHasTable(_tableName) {
+    return `SELECT COUNT(*)::int as "count" FROM "information_schema"."tables" WHERE "table_schema" = 'public' AND "table_name" = $1`;
+  }
+  compileHasColumn(_tableName, _columnName) {
+    return `SELECT COUNT(*)::int as "count" FROM "information_schema"."columns" WHERE "table_schema" = 'public' AND "table_name" = $1 AND "column_name" = $2`;
+  }
+  compileInsert(sql) {
+    return sql;
+  }
+  formatDefault(value) {
+    if (typeof value === "string") {
+      if (value === "CURRENT_TIMESTAMP") return value;
+      return `'${value.replace(/'/g, "''")}'`;
+    }
+    if (value === null) return "NULL";
+    if (typeof value === "boolean") return value ? "true" : "false";
+    return String(value);
+  }
+};
+function createDialect(driver) {
+  switch (driver) {
+    case "mysql":
+      return new MysqlDialect();
+    case "sqlite":
+      return new SqliteDialect();
+    case "postgresql":
+      return new PostgresqlDialect();
+    default:
+      return new MysqlDialect();
+  }
+}
+
+// src/server/database/driver.ts
+async function createDriver(config) {
+  const driverType = config.driver ?? "mysql";
+  switch (driverType) {
+    case "mysql":
+      return createMysqlDriver(config);
+    case "postgresql":
+      return createPostgresqlDriver(config);
+    case "sqlite":
+      return createSqliteDriver(config);
+    default:
+      return createMysqlDriver(config);
+  }
+}
+async function createMysqlDriver(config) {
+  let mysqlPackage;
+  try {
+    mysqlPackage = await import("mysql2/promise");
+  } catch {
+    throw new Error(
+      "MySQL driver (mysql2) is not installed. Run: npm install mysql2"
+    );
+  }
+  let connection = null;
+  const dialect = new MysqlDialect();
+  const driver = {
+    async connect() {
+      connection = await mysqlPackage.createConnection({
+        host: config.host ?? "127.0.0.1",
+        port: config.port ?? 3306,
+        user: config.username,
+        password: config.password,
+        database: config.database,
+        charset: config.charset ?? "utf8mb4"
+      });
+    },
+    async disconnect() {
+      if (connection !== null) {
+        await connection.end();
+        connection = null;
+      }
+    },
+    isConnected() {
+      return connection !== null;
+    },
+    async raw(sql, bindings) {
+      if (connection === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const [rows, fields] = await connection.execute(sql, bindings ?? []);
+      return { rows, fields };
+    },
+    async transaction(callback) {
+      if (connection === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      await connection.beginTransaction();
+      try {
+        const result = await callback(driver);
+        await connection.commit();
+        return result;
+      } catch (err) {
+        await connection.rollback();
+        throw err;
+      }
+    },
+    getDialect() {
+      return dialect;
+    },
+    getDriver() {
+      return "mysql";
+    }
+  };
+  return driver;
+}
+async function createPostgresqlDriver(config) {
+  let pgPackage;
+  try {
+    pgPackage = await import("pg");
+  } catch {
+    throw new Error(
+      "PostgreSQL driver (pg) is not installed. Run: npm install pg"
+    );
+  }
+  let pool = null;
+  const dialect = new PostgresqlDialect();
+  const driver = {
+    async connect() {
+      const { Pool } = pgPackage;
+      pool = new Pool({
+        host: config.host ?? "127.0.0.1",
+        port: config.port ?? 5432,
+        user: config.username,
+        password: config.password,
+        database: config.database
+      });
+      await pool.query("SELECT 1");
+    },
+    async disconnect() {
+      if (pool !== null) {
+        await pool.end();
+        pool = null;
+      }
+    },
+    isConnected() {
+      return pool !== null;
+    },
+    async raw(sql, bindings) {
+      if (pool === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const result = await pool.query(sql, bindings ?? []);
+      return { rows: result.rows };
+    },
+    async transaction(callback) {
+      if (pool === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const client = await pool.connect();
+      try {
+        await client.query("BEGIN");
+        const trxDriver = {
+          ...driver,
+          async raw(sql, bindings) {
+            const result2 = await client.query(sql, bindings ?? []);
+            return { rows: result2.rows };
+          },
+          getDialect() {
+            return dialect;
+          },
+          getDriver() {
+            return "postgresql";
+          }
+        };
+        const result = await callback(trxDriver);
+        await client.query("COMMIT");
+        return result;
+      } catch (err) {
+        await client.query("ROLLBACK");
+        throw err;
+      } finally {
+        client.release();
+      }
+    },
+    getDialect() {
+      return dialect;
+    },
+    getDriver() {
+      return "postgresql";
+    }
+  };
+  return driver;
+}
+async function createSqliteDriver(config) {
+  let sqlitePackage;
+  try {
+    sqlitePackage = await import("better-sqlite3");
+  } catch {
+    throw new Error(
+      "SQLite driver (better-sqlite3) is not installed. Run: npm install better-sqlite3"
+    );
+  }
+  let db = null;
+  let connected = false;
+  const dialect = new SqliteDialect();
+  const driver = {
+    async connect() {
+      db = new sqlitePackage(config.database);
+      db.pragma("journal_mode = WAL");
+      connected = true;
+    },
+    async disconnect() {
+      if (db !== null) {
+        db.close();
+        db = null;
+        connected = false;
+      }
+    },
+    isConnected() {
+      return connected;
+    },
+    async raw(sql, bindings) {
+      if (db === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const trimmedSQL = sql.trim().toUpperCase();
+      const isQuery = trimmedSQL.startsWith("SELECT") || trimmedSQL.startsWith("WITH") || trimmedSQL.startsWith("PRAGMA");
+      const stmt = db.prepare(sql);
+      if (isQuery) {
+        const rows = bindings !== void 0 && bindings.length > 0 ? stmt.all(...bindings) : stmt.all();
+        return { rows };
+      }
+      if (bindings !== void 0 && bindings.length > 0) {
+        stmt.run(...bindings);
+      } else {
+        stmt.run();
+      }
+      return { rows: [] };
+    },
+    async transaction(callback) {
+      if (db === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const txn = db.transaction(async () => {
+        return await callback(driver);
+      });
+      return txn();
+    },
+    getDialect() {
+      return dialect;
+    },
+    getDriver() {
+      return "sqlite";
+    }
+  };
+  return driver;
+}
+
+// src/server/database/query.ts
+var QueryBuilder = class _QueryBuilder {
+  connection;
+  tableName;
+  columns = ["*"];
+  distinctEnabled = false;
+  wheres = [];
+  joins = [];
+  orderBys = [];
+  havings = [];
+  groupBys = [];
+  limitValue = null;
+  offsetValue = null;
+  fromSubquery = null;
+  constructor(connection, tableName) {
+    this.connection = connection;
+    this.tableName = tableName;
+  }
+  select(...columns) {
+    this.columns = columns.length > 0 ? columns : ["*"];
+    return this;
+  }
+  addSelect(...columns) {
+    if (this.columns[0] === "*") {
+      this.columns = columns;
+    } else {
+      this.columns.push(...columns);
+    }
+    return this;
+  }
+  distinct() {
+    this.distinctEnabled = true;
+    return this;
+  }
+  from(table) {
+    this.fromSubquery = table;
+    return this;
+  }
+  where(column, operator, value) {
+    if (value === void 0) {
+      value = operator;
+      operator = "=";
+    }
+    this.wheres.push({
+      type: "basic",
+      column,
+      operator: String(operator),
+      value,
+      boolean: "and"
+    });
+    return this;
+  }
+  orWhere(column, operator, value) {
+    if (value === void 0) {
+      value = operator;
+      operator = "=";
+    }
+    this.wheres.push({
+      type: "basic",
+      column,
+      operator: String(operator),
+      value,
+      boolean: "or"
+    });
+    return this;
+  }
+  whereIn(column, values) {
+    this.wheres.push({ type: "in", column, values, boolean: "and" });
+    return this;
+  }
+  whereNotIn(column, values) {
+    this.wheres.push({ type: "notIn", column, values, boolean: "and" });
+    return this;
+  }
+  whereNull(column) {
+    this.wheres.push({ type: "null", column, boolean: "and" });
+    return this;
+  }
+  whereNotNull(column) {
+    this.wheres.push({ type: "notNull", column, boolean: "and" });
+    return this;
+  }
+  whereBetween(column, range) {
+    this.wheres.push({
+      type: "between",
+      column,
+      values: range,
+      boolean: "and"
+    });
+    return this;
+  }
+  whereNotBetween(column, range) {
+    this.wheres.push({
+      type: "notBetween",
+      column,
+      values: range,
+      boolean: "and"
+    });
+    return this;
+  }
+  whereLike(column, pattern) {
+    this.wheres.push({ type: "like", column, value: pattern, boolean: "and" });
+    return this;
+  }
+  orWhereLike(column, pattern) {
+    this.wheres.push({ type: "like", column, value: pattern, boolean: "or" });
+    return this;
+  }
+  whereGroup(callback) {
+    const subQuery = new _QueryBuilder(this.connection, this.tableName);
+    callback(subQuery);
+    this.wheres.push({
+      type: "nested",
+      nested: subQuery.wheres,
+      boolean: "and"
+    });
+    return this;
+  }
+  join(table, first, operator, second, type = "inner") {
+    this.joins.push({ table, first, operator, second, type });
+    return this;
+  }
+  leftJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, "left");
+  }
+  rightJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, "right");
+  }
+  crossJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, "cross");
+  }
+  orderBy(column, direction = "asc") {
+    this.orderBys.push({ column, direction });
+    return this;
+  }
+  orderByDesc(column) {
+    return this.orderBy(column, "desc");
+  }
+  latest(column = "created_at") {
+    return this.orderBy(column, "desc");
+  }
+  oldest(column = "created_at") {
+    return this.orderBy(column, "asc");
+  }
+  inRandomOrder() {
+    this.orderBys.push({ column: "RANDOM()", direction: "asc" });
+    return this;
+  }
+  limit(limit) {
+    this.limitValue = limit;
+    return this;
+  }
+  offset(offset) {
+    this.offsetValue = offset;
+    return this;
+  }
+  skip(skip) {
+    return this.offset(skip);
+  }
+  take(take) {
+    return this.limit(take);
+  }
+  groupBy(...columns) {
+    this.groupBys.push(...columns);
+    return this;
+  }
+  having(column, operator, value) {
+    this.havings.push({ column, operator, value });
+    return this;
+  }
+  async get() {
+    const { sql, bindings } = this.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    return result.rows;
+  }
+  async first() {
+    const qb = this.clone();
+    qb.limitValue = 1;
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    return result.rows.length > 0 ? result.rows[0] : null;
+  }
+  async find(id) {
+    return this.where("id", id).first();
+  }
+  async pluck(column) {
+    const qb = this.clone();
+    qb.columns = [column];
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    return result.rows.map((row) => row[column]);
+  }
+  async count(column = "*") {
+    const qb = this.clone();
+    qb.columns = [
+      `COUNT(${column === "*" ? "*" : this.wrap(column)}) as aggregate`
+    ];
+    qb.orderBys = [];
+    qb.limitValue = null;
+    qb.offsetValue = null;
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    const row = result.rows[0];
+    if (!row) return 0;
+    return Number(row.aggregate ?? row.count ?? row["COUNT(*)"] ?? 0);
+  }
+  async exists() {
+    const count = await this.count();
+    return count > 0;
+  }
+  async doesntExist() {
+    return !await this.exists();
+  }
+  async max(column) {
+    return this.aggregate("MAX", column);
+  }
+  async min(column) {
+    return this.aggregate("MIN", column);
+  }
+  async sum(column) {
+    const result = await this.aggregate("SUM", column);
+    return result ?? 0;
+  }
+  async avg(column) {
+    const result = await this.aggregate("AVG", column);
+    return result ?? 0;
+  }
+  async paginate(perPage = 15, page = 1) {
+    const countQb = this.clone();
+    const total = await countQb.count();
+    const lastPage = Math.max(1, Math.ceil(total / perPage));
+    const currentPage = Math.max(1, Math.min(page, lastPage));
+    const fromVal = (currentPage - 1) * perPage + 1;
+    const toVal = Math.min(currentPage * perPage, total);
+    const qb = this.clone();
+    qb.limitValue = perPage;
+    qb.offsetValue = (currentPage - 1) * perPage;
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    return {
+      data: result.rows,
+      currentPage,
+      perPage,
+      total,
+      lastPage,
+      from: total > 0 ? fromVal : 0,
+      to: total > 0 ? toVal : 0,
+      hasMore: currentPage < lastPage,
+      hasPrev: currentPage > 1,
+      isEmpty: total === 0
+    };
+  }
+  async insert(data) {
+    const { sql, bindings } = this.compileInsert(data);
+    const driverType = this.connection.getDriver();
+    if (driverType === "postgresql") {
+      const dialect = this.connection.getDialect();
+      const returningSQL = dialect.compileInsertReturning(sql, bindings);
+      const result2 = await this.connection.raw(returningSQL, bindings);
+      return result2.rows.length > 0 ? Number(result2.rows[0].id) ?? 0 : 0;
+    }
+    const result = await this.connection.raw(sql, bindings);
+    if (result.rows && result.rows.length > 0) {
+      return Number(result.rows[0].id) ?? result.rows[0].insertId ?? 0;
+    }
+    return 0;
+  }
+  async insertGetId(data) {
+    return this.insert(data);
+  }
+  async insertReturning(data) {
+    const { sql, bindings } = this.compileInsert(data);
+    const dialect = this.connection.getDialect();
+    const returningSQL = dialect.compileInsertReturning(sql, bindings);
+    const result = await this.connection.raw(returningSQL, bindings);
+    return result.rows.length > 0 ? result.rows[0] : null;
+  }
+  async update(data) {
+    const { sql, bindings } = this.compileUpdate(data);
+    const result = await this.connection.raw(sql, bindings);
+    const rows = result.rows;
+    if (rows.length > 0) {
+      const info = rows[0];
+      return info.affectedRows ?? info.changes ?? rows.length;
+    }
+    return 0;
+  }
+  async delete() {
+    const { sql, bindings } = this.compileDelete();
+    const result = await this.connection.raw(sql, bindings);
+    const rows = result.rows;
+    if (rows.length > 0) {
+      const info = rows[0];
+      return info.affectedRows ?? info.changes ?? rows.length;
+    }
+    return 0;
+  }
+  async truncate() {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileTruncate(this.tableName);
+    await this.connection.raw(sql);
+  }
+  async chunk(size, callback) {
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const qb = this.clone();
+      qb.limitValue = size;
+      qb.offsetValue = (page - 1) * size;
+      const rows = await qb.get();
+      if (rows.length === 0) {
+        hasMore = false;
+        break;
+      }
+      await callback(rows);
+      if (rows.length < size) {
+        hasMore = false;
+      }
+      page++;
+    }
+  }
+  clone() {
+    const qb = new _QueryBuilder(this.connection, this.tableName);
+    qb.columns = [...this.columns];
+    qb.distinctEnabled = this.distinctEnabled;
+    qb.wheres = this.cloneWheres(this.wheres);
+    qb.joins = [...this.joins];
+    qb.orderBys = [...this.orderBys];
+    qb.havings = [...this.havings];
+    qb.groupBys = [...this.groupBys];
+    qb.limitValue = this.limitValue;
+    qb.offsetValue = this.offsetValue;
+    qb.fromSubquery = this.fromSubquery;
+    return qb;
+  }
+  toSQL() {
+    const bindings = [];
+    const dialect = this.connection.getDialect();
+    const wrappedColumns = this.columns.map(
+      (c) => c.includes("(") || c === "*" || c.includes(" as ") || c.includes(" AS ") ? c : dialect.wrapIdentifier(c)
+    ).join(", ");
+    const from = this.fromSubquery ?? this.tableName;
+    const wrappedFrom = this.fromSubquery ?? dialect.wrapIdentifier(from);
+    let sql = this.distinctEnabled ? `SELECT DISTINCT ${wrappedColumns} FROM ${wrappedFrom}` : `SELECT ${wrappedColumns} FROM ${wrappedFrom}`;
+    const joinSQL = this.compileJoins(dialect);
+    if (joinSQL) sql += joinSQL;
+    const whereSQL = this.compileWheres(dialect, bindings);
+    if (whereSQL) sql += whereSQL;
+    if (this.groupBys.length > 0) {
+      sql += ` GROUP BY ${this.groupBys.map((c) => dialect.wrapIdentifier(c)).join(", ")}`;
+    }
+    const havingSQL = this.compileHavings(dialect, bindings);
+    if (havingSQL) sql += havingSQL;
+    if (this.orderBys.length > 0) {
+      sql += ` ORDER BY ${this.orderBys.map((o) => {
+        const col = o.column === "RANDOM()" ? o.column : dialect.wrapIdentifier(o.column);
+        return `${col} ${o.direction.toUpperCase()}`;
+      }).join(", ")}`;
+    }
+    const limitOffsetSQL = dialect.compileLimitOffset(
+      bindings,
+      this.limitValue,
+      this.offsetValue
+    );
+    if (limitOffsetSQL) sql += limitOffsetSQL;
+    return { sql, bindings };
+  }
+  dd() {
+    const { sql, bindings } = this.toSQL();
+    const output = `SQL: ${sql}
+Bindings: ${JSON.stringify(bindings)}`;
+    console.error(output);
+    process.exit(1);
+  }
+  compileJoins(dialect) {
+    if (this.joins.length === 0) return "";
+    return " " + this.joins.map((j) => {
+      const type = j.type.toUpperCase();
+      return `${type} JOIN ${dialect.wrapIdentifier(j.table)} ON ${dialect.wrapIdentifier(j.first)} ${j.operator} ${this.wrap(j.second)}`;
+    }).join(" ");
+  }
+  compileWheres(dialect, bindings) {
+    if (this.wheres.length === 0) return "";
+    const sql = this.compileWhereArray(this.wheres, dialect, bindings);
+    return sql ? ` WHERE ${sql}` : "";
+  }
+  compileWhereArray(wheres, dialect, bindings) {
+    if (wheres.length === 0) return "";
+    const parts = [];
+    for (const w of wheres) {
+      const sql = this.compileSingleWhere(w, dialect, bindings);
+      if (sql !== null) parts.push(sql);
+    }
+    if (parts.length === 0) return "";
+    return parts.join(" AND ");
+  }
+  compileSingleWhere(w, dialect, bindings) {
+    const col = w.column ? dialect.wrapIdentifier(w.column) : "";
+    switch (w.type) {
+      case "basic": {
+        bindings.push(w.value);
+        const operator = w.operator === "=" ? "=" : w.operator;
+        return `${col} ${operator} ${dialect.makeParameter(bindings.length - 1)}`;
+      }
+      case "in": {
+        const placeholders = w.values.map((v) => {
+          bindings.push(v);
+          return dialect.makeParameter(bindings.length - 1);
+        }).join(", ");
+        return `${col} IN (${placeholders})`;
+      }
+      case "notIn": {
+        const placeholders = w.values.map((v) => {
+          bindings.push(v);
+          return dialect.makeParameter(bindings.length - 1);
+        }).join(", ");
+        return `${col} NOT IN (${placeholders})`;
+      }
+      case "null":
+        return `${col} IS NULL`;
+      case "notNull":
+        return `${col} IS NOT NULL`;
+      case "between": {
+        bindings.push(w.values[0], w.values[1]);
+        return `${col} BETWEEN ${dialect.makeParameter(bindings.length - 2)} AND ${dialect.makeParameter(bindings.length - 1)}`;
+      }
+      case "notBetween": {
+        bindings.push(w.values[0], w.values[1]);
+        return `${col} NOT BETWEEN ${dialect.makeParameter(bindings.length - 2)} AND ${dialect.makeParameter(bindings.length - 1)}`;
+      }
+      case "like": {
+        bindings.push(w.value);
+        return `${col} LIKE ${dialect.makeParameter(bindings.length - 1)}`;
+      }
+      case "nested": {
+        const nestedSQL = this.compileNestedWhere(w.nested, dialect, bindings);
+        return nestedSQL ? `(${nestedSQL})` : null;
+      }
+      default:
+        return null;
+    }
+  }
+  compileNestedWhere(wheres, dialect, bindings) {
+    const parts = [];
+    for (const w of wheres) {
+      const sql = this.compileSingleWhere(w, dialect, bindings);
+      if (sql !== null) {
+        parts.push(sql);
+      }
+    }
+    if (parts.length === 0) return "";
+    return parts.join(" AND ");
+  }
+  compileHavings(dialect, bindings) {
+    if (this.havings.length === 0) return "";
+    const parts = this.havings.map((h) => {
+      bindings.push(h.value);
+      return `${dialect.wrapIdentifier(h.column)} ${h.operator} ${dialect.makeParameter(bindings.length - 1)}`;
+    });
+    return ` HAVING ${parts.join(" AND ")}`;
+  }
+  compileInsert(data) {
+    const dialect = this.connection.getDialect();
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const bindings = [];
+    const placeholders = values.map((v) => {
+      bindings.push(v);
+      return dialect.makeParameter(bindings.length - 1);
+    }).join(", ");
+    const sql = `INSERT INTO ${dialect.wrapIdentifier(this.tableName)} (${columns.map((c) => dialect.wrapIdentifier(c)).join(", ")}) VALUES (${placeholders})`;
+    return { sql, bindings };
+  }
+  compileUpdate(data) {
+    const dialect = this.connection.getDialect();
+    const bindings = [];
+    const sets = Object.entries(data).map(([key, value]) => {
+      bindings.push(value);
+      return `${dialect.wrapIdentifier(key)} = ${dialect.makeParameter(bindings.length - 1)}`;
+    });
+    let sql = `UPDATE ${dialect.wrapIdentifier(this.tableName)} SET ${sets.join(", ")}`;
+    const whereSQL = this.compileWheres(dialect, bindings);
+    if (whereSQL) sql += whereSQL;
+    if (this.orderBys.length > 0) {
+      sql += ` ORDER BY ${this.orderBys.map((o) => {
+        const col = o.column === "RANDOM()" ? o.column : dialect.wrapIdentifier(o.column);
+        return `${col} ${o.direction.toUpperCase()}`;
+      }).join(", ")}`;
+    }
+    const limitOffsetSQL = dialect.compileLimitOffset(
+      bindings,
+      this.limitValue,
+      this.offsetValue
+    );
+    if (limitOffsetSQL) sql += limitOffsetSQL;
+    return { sql, bindings };
+  }
+  compileDelete() {
+    const dialect = this.connection.getDialect();
+    const bindings = [];
+    let sql = `DELETE FROM ${dialect.wrapIdentifier(this.tableName)}`;
+    const whereSQL = this.compileWheres(dialect, bindings);
+    if (whereSQL) sql += whereSQL;
+    if (this.orderBys.length > 0) {
+      sql += ` ORDER BY ${this.orderBys.map((o) => {
+        const col = o.column === "RANDOM()" ? o.column : dialect.wrapIdentifier(o.column);
+        return `${col} ${o.direction.toUpperCase()}`;
+      }).join(", ")}`;
+    }
+    const limitOffsetSQL = dialect.compileLimitOffset(
+      bindings,
+      this.limitValue,
+      this.offsetValue
+    );
+    if (limitOffsetSQL) sql += limitOffsetSQL;
+    return { sql, bindings };
+  }
+  async aggregate(fn, column) {
+    const qb = this.clone();
+    qb.columns = [`${fn}(${this.wrap(column)}) as aggregate`];
+    qb.orderBys = [];
+    qb.limitValue = null;
+    qb.offsetValue = null;
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    const row = result.rows[0];
+    if (!row) return null;
+    const val = row.aggregate ?? row[`${fn}(${column})`];
+    return val !== null && val !== void 0 ? Number(val) : null;
+  }
+  cloneWheres(wheres) {
+    return wheres.map((w) => ({
+      ...w,
+      values: w.values ? [...w.values] : void 0,
+      nested: w.nested ? this.cloneWheres(w.nested) : void 0
+    }));
+  }
+  wrap(identifier) {
+    if (identifier === "*" || identifier.includes("(")) return identifier;
+    const dialect = this.connection.getDialect();
+    return dialect.wrapIdentifier(identifier);
+  }
+};
+
+// src/server/database/connection.ts
+var DatabaseConnection = class _DatabaseConnection {
+  config;
+  driver = null;
+  constructor(config) {
+    this.config = {
+      driver: "mysql",
+      host: "127.0.0.1",
+      charset: "utf8mb4",
+      prefix: "",
+      ...config
+    };
+    if (this.config.port === void 0) {
+      if (this.config.driver === "mysql") this.config.port = 3306;
+      else if (this.config.driver === "postgresql") this.config.port = 5432;
+    }
+  }
+  async connect() {
+    if (this.driver !== null) return;
+    this.driver = await createDriver(this.config);
+    await this.driver.connect();
+  }
+  async disconnect() {
+    if (this.driver !== null) {
+      await this.driver.disconnect();
+      this.driver = null;
+    }
+  }
+  async raw(sql, bindings) {
+    this.ensureConnected();
+    return this.driver.raw(sql, bindings);
+  }
+  table(tableName) {
+    return new QueryBuilder(this, `${this.config.prefix ?? ""}${tableName}`);
+  }
+  isConnected() {
+    return this.driver !== null && this.driver.isConnected();
+  }
+  getDriver() {
+    return this.config.driver ?? "mysql";
+  }
+  getDialect() {
+    this.ensureConnected();
+    return this.driver.getDialect();
+  }
+  getPrefix() {
+    return this.config.prefix ?? "";
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  async transaction(callback) {
+    this.ensureConnected();
+    return this.driver.transaction(async (_driver) => {
+      const trxConnection = new _DatabaseConnection(this.config);
+      trxConnection["driver"] = this.driver;
+      trxConnection.raw = async (sql, bindings) => {
+        return this.driver.raw(sql, bindings);
+      };
+      return callback(trxConnection);
+    });
+  }
+  static generateId() {
+    return randomUUID3();
+  }
+  ensureConnected() {
+    if (this.driver === null || !this.driver.isConnected()) {
+      throw new Error(
+        "Database not connected. Call connect() before performing operations."
+      );
+    }
+  }
+};
+
+// src/server/database/migration.ts
+var SchemaBuilder = class {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  async createTable(tableName, callback) {
+    const blueprint = new TableBlueprint(this.connection, "create");
+    callback(blueprint);
+    const dialect = this.connection.getDialect();
+    const columns = blueprint.compileColumns();
+    const constraints = blueprint.compileConstraints(dialect);
+    const sql = dialect.compileCreateTable(tableName, columns, constraints);
+    await this.connection.raw(sql);
+  }
+  async dropTable(tableName) {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileDropTable(tableName);
+    await this.connection.raw(sql);
+  }
+  async dropTableIfExists(tableName) {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileDropTableIfExists(tableName);
+    await this.connection.raw(sql);
+  }
+  async renameTable(from, to) {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileRenameTable(from, to);
+    await this.connection.raw(sql);
+  }
+  async alterTable(tableName, callback) {
+    const blueprint = new TableBlueprint(this.connection, "alter");
+    callback(blueprint);
+    const dialect = this.connection.getDialect();
+    if (blueprint.droppedColumns.length > 0) {
+      const dropSQL = dialect.compileDropColumns(
+        tableName,
+        blueprint.droppedColumns
+      );
+      await this.connection.raw(
+        `ALTER TABLE ${dialect.wrapIdentifier(tableName)} ${dropSQL}`
+      );
+    }
+    if (blueprint.renamedColumns.length > 0) {
+      for (const { from, to } of blueprint.renamedColumns) {
+        const renameSQL = dialect.compileRenameColumn(tableName, from, to);
+        await this.connection.raw(
+          `ALTER TABLE ${dialect.wrapIdentifier(tableName)} ${renameSQL}`
+        );
+      }
+    }
+    const compiledColumns = blueprint.compileColumnDefinitions(dialect);
+    if (compiledColumns.length > 0) {
+      for (const colSQL of compiledColumns) {
+        await this.connection.raw(
+          `ALTER TABLE ${dialect.wrapIdentifier(tableName)} ${colSQL}`
+        );
+      }
+    }
+  }
+  async hasTable(tableName) {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileHasTable(tableName);
+    const result = await this.connection.raw(sql, [tableName]);
+    return this.parseCount(result) > 0;
+  }
+  async hasColumn(tableName, columnName) {
+    const dialect = this.connection.getDialect();
+    const driver = this.connection.getDriver();
+    if (driver === "sqlite") {
+      const sql2 = dialect.compileHasColumn(tableName, columnName);
+      const result2 = await this.connection.raw(sql2);
+      return result2.rows.some((row) => row.name === columnName);
+    }
+    const sql = dialect.compileHasColumn(tableName, columnName);
+    const result = await this.connection.raw(sql, [tableName, columnName]);
+    return this.parseCount(result) > 0;
+  }
+  parseCount(result) {
+    if (result.rows.length === 0) return 0;
+    const row = result.rows[0];
+    return Number(row.count ?? row.Count ?? 0);
+  }
+};
+var TableBlueprint = class {
+  mode;
+  columns = [];
+  primaryKeys = [];
+  uniqueKeys = [];
+  indexKeys = [];
+  foreignKeys = [];
+  droppedColumns = [];
+  renamedColumns = [];
+  constructor(_connection, mode) {
+    this.mode = mode;
+  }
+  id(name = "id") {
+    const col = this.addColumn("id", name);
+    col.autoIncrement();
+    col.unsigned();
+    return col;
+  }
+  increments(name = "id") {
+    const col = this.addColumn("increments", name);
+    col.autoIncrement();
+    col.unsigned();
+    return col;
+  }
+  bigIncrements(name = "id") {
+    const col = this.addColumn("bigIncrements", name);
+    col.autoIncrement();
+    col.unsigned();
+    return col;
+  }
+  string(name, length = 255) {
+    const col = this.addColumn("string", name);
+    col.setLength(length);
+    return col;
+  }
+  text(name) {
+    return this.addColumn("text", name);
+  }
+  integer(name) {
+    return this.addColumn("integer", name);
+  }
+  bigInteger(name) {
+    return this.addColumn("bigInteger", name);
+  }
+  tinyInteger(name) {
+    return this.addColumn("tinyInteger", name);
+  }
+  smallInteger(name) {
+    return this.addColumn("smallInteger", name);
+  }
+  boolean(name) {
+    return this.addColumn("boolean", name);
+  }
+  float(name, _precision) {
+    const col = this.addColumn("float", name);
+    if (_precision !== void 0) col.setPrecision(_precision);
+    return col;
+  }
+  double(name) {
+    return this.addColumn("double", name);
+  }
+  decimal(name, precision = 10, scale = 0) {
+    const col = this.addColumn("decimal", name);
+    col.setPrecision(precision);
+    col.setScale(scale);
+    return col;
+  }
+  date(name) {
+    return this.addColumn("date", name);
+  }
+  datetime(name) {
+    return this.addColumn("datetime", name);
+  }
+  timestamp(name) {
+    return this.addColumn("timestamp", name);
+  }
+  time(name) {
+    return this.addColumn("time", name);
+  }
+  year(name) {
+    return this.addColumn("year", name);
+  }
+  json(name) {
+    return this.addColumn("json", name);
+  }
+  jsonb(name) {
+    return this.addColumn("jsonb", name);
+  }
+  binary(name) {
+    return this.addColumn("binary", name);
+  }
+  uuid(name = "uuid") {
+    return this.addColumn("uuid", name);
+  }
+  enum(name, values) {
+    const col = this.addColumn("enum", name);
+    col.setValues(values);
+    return col;
+  }
+  foreignId(name) {
+    const col = this.addColumn("foreignId", name);
+    col.unsigned();
+    return col;
+  }
+  primary(...columns) {
+    this.primaryKeys.push(...columns);
+  }
+  unique(...columns) {
+    this.uniqueKeys.push(columns);
+  }
+  index(...columns) {
+    this.indexKeys.push(columns);
+  }
+  foreign(column) {
+    const fk = {
+      column,
+      references: "",
+      on: "",
+      onDelete: null,
+      onUpdate: null
+    };
+    this.foreignKeys.push(fk);
+    return new ForeignKeyDefinition(fk);
+  }
+  timestamps() {
+    this.timestamp("created_at").nullable();
+    this.timestamp("updated_at").nullable();
+  }
+  softDeletes() {
+    this.timestamp("deleted_at").nullable();
+  }
+  rememberToken() {
+    this.string("remember_token", 100).nullable();
+  }
+  dropColumn(column) {
+    this.droppedColumns.push(column);
+  }
+  renameColumn(from, to) {
+    this.renamedColumns.push({ from, to });
+  }
+  dropPrimary() {
+    this.primaryKeys = [];
+  }
+  dropUnique(_indexName) {
+    this.uniqueKeys = [];
+  }
+  dropIndex(_indexName) {
+    this.indexKeys = [];
+  }
+  dropForeign(_indexName) {
+    this.foreignKeys = [];
+  }
+  dropTimestamps() {
+    this.droppedColumns.push("created_at", "updated_at");
+  }
+  dropSoftDeletes() {
+    this.droppedColumns.push("deleted_at");
+  }
+  dropRememberToken() {
+    this.droppedColumns.push("remember_token");
+  }
+  compileColumns() {
+    return this.columns.filter((c) => this.mode === "create" || c.isNew).map((c) => c.compile());
+  }
+  compileConstraints(dialect) {
+    const constraints = [];
+    const wrap = (name) => dialect.wrapIdentifier(name);
+    for (const pk of this.primaryKeys) {
+      constraints.push(`PRIMARY KEY (${wrap(pk)})`);
+    }
+    for (const uk of this.uniqueKeys) {
+      constraints.push(`UNIQUE (${uk.map((c) => wrap(c)).join(", ")})`);
+    }
+    for (const ik of this.indexKeys) {
+      constraints.push(`INDEX (${ik.map((c) => wrap(c)).join(", ")})`);
+    }
+    for (const fk of this.foreignKeys) {
+      let fkSQL = `FOREIGN KEY (${wrap(fk.column)}) REFERENCES ${wrap(fk.on)} (${wrap(fk.references)})`;
+      if (fk.onDelete) fkSQL += ` ON DELETE ${fk.onDelete}`;
+      if (fk.onUpdate) fkSQL += ` ON UPDATE ${fk.onUpdate}`;
+      constraints.push(fkSQL);
+    }
+    return constraints;
+  }
+  compileColumnDefinitions(dialect) {
+    return this.columns.filter((c) => c.isNew && this.mode === "alter").map((c) => dialect.compileAddColumns("", [c.compile()]));
+  }
+  addColumn(type, name) {
+    const col = new ColumnDefinition(type, name);
+    this.columns.push(col);
+    return col;
+  }
+};
+var ColumnDefinition = class {
+  type;
+  name;
+  isNullable = false;
+  defaultValue = void 0;
+  isUnsigned = false;
+  isUnique = false;
+  isPrimary = false;
+  isIndex = false;
+  commentText = null;
+  afterColumn = null;
+  isFirst = false;
+  isAutoIncrement = false;
+  precisionValue = null;
+  scaleValue = null;
+  lengthValue = null;
+  enumValues = null;
+  isForeignId = false;
+  isNew = true;
+  constructor(type, name) {
+    this.type = type;
+    this.name = name;
+  }
+  nullable() {
+    this.isNullable = true;
+    return this;
+  }
+  default(value) {
+    this.defaultValue = value;
+    return this;
+  }
+  unsigned() {
+    this.isUnsigned = true;
+    return this;
+  }
+  unique() {
+    this.isUnique = true;
+    return this;
+  }
+  primary() {
+    this.isPrimary = true;
+    return this;
+  }
+  index() {
+    this.isIndex = true;
+    return this;
+  }
+  comment(text) {
+    this.commentText = text;
+    return this;
+  }
+  after(column) {
+    this.afterColumn = column;
+    return this;
+  }
+  first() {
+    this.isFirst = true;
+    return this;
+  }
+  autoIncrement() {
+    this.isAutoIncrement = true;
+    return this;
+  }
+  setValues(vals) {
+    this.enumValues = vals;
+    return this;
+  }
+  setLength(len) {
+    this.lengthValue = len;
+    return this;
+  }
+  setPrecision(precision) {
+    this.precisionValue = precision;
+    return this;
+  }
+  setScale(scale) {
+    this.scaleValue = scale;
+    return this;
+  }
+  compile() {
+    return {
+      name: this.name,
+      type: this.type,
+      nullable: this.isNullable,
+      defaultValue: this.defaultValue,
+      unsigned: this.isUnsigned,
+      unique: this.isUnique,
+      primary: this.isPrimary,
+      index: this.isIndex,
+      comment: this.commentText,
+      after: this.afterColumn,
+      first: this.isFirst,
+      autoIncrement: this.isAutoIncrement,
+      precision: this.precisionValue,
+      scale: this.scaleValue,
+      length: this.lengthValue,
+      values: this.enumValues,
+      isForeignId: this.isForeignId
+    };
+  }
+};
+var ForeignKeyDefinition = class {
+  def;
+  constructor(def) {
+    this.def = def;
+  }
+  references(column) {
+    this.def.references = column;
+    return this;
+  }
+  on(table) {
+    this.def.on = table;
+    return this;
+  }
+  onDelete(action) {
+    this.def.onDelete = action;
+    return this;
+  }
+  onUpdate(action) {
+    this.def.onUpdate = action;
+    return this;
+  }
+};
+var Migrator = class {
+  connection;
+  migrations = [];
+  constructor(connection) {
+    this.connection = connection;
+  }
+  addMigrations(migrations) {
+    this.migrations.push(...migrations);
+  }
+  setMigrations(migrations) {
+    this.migrations = migrations;
+  }
+  async run() {
+    await this.ensureMigrationTable();
+    const ran = await this.getRanMigrations();
+    const ranNames = new Set(ran.map((r) => r.name));
+    const pending = this.migrations.filter((m) => !ranNames.has(m.name));
+    if (pending.length === 0) {
+      console.log("Nothing to migrate.");
+      return;
+    }
+    const nextBatch = await this.getNextBatchNumber();
+    const schema = new SchemaBuilder(this.connection);
+    for (const migration of pending) {
+      console.log(`Migrating: ${migration.name}`);
+      try {
+        await migration.up(schema);
+        await this.recordMigration(migration.name, nextBatch);
+        console.log(`Migrated:  ${migration.name}`);
+      } catch (err) {
+        console.error(`Migration failed: ${migration.name}`, err);
+        throw err;
+      }
+    }
+  }
+  async rollback() {
+    await this.ensureMigrationTable();
+    const lastBatch = await this.getLastBatchNumber();
+    if (lastBatch === 0) {
+      console.log("Nothing to rollback.");
+      return;
+    }
+    const lastBatchMigrations = await this.getMigrationsByBatch(lastBatch);
+    const schema = new SchemaBuilder(this.connection);
+    for (const migration of lastBatchMigrations.reverse()) {
+      const def = this.migrations.find((m) => m.name === migration.name);
+      if (def) {
+        console.log(`Rolling back: ${migration.name}`);
+        try {
+          await def.down(schema);
+          await this.removeMigration(migration.name);
+          console.log(`Rolled back:  ${migration.name}`);
+        } catch (err) {
+          console.error(`Rollback failed: ${migration.name}`, err);
+          throw err;
+        }
+      }
+    }
+  }
+  async reset() {
+    await this.ensureMigrationTable();
+    const allRan = await this.getRanMigrations();
+    const schema = new SchemaBuilder(this.connection);
+    for (const migration of allRan.reverse()) {
+      const def = this.migrations.find((m) => m.name === migration.name);
+      if (def) {
+        console.log(`Resetting: ${migration.name}`);
+        try {
+          await def.down(schema);
+          await this.removeMigration(migration.name);
+          console.log(`Reset:  ${migration.name}`);
+        } catch (err) {
+          console.error(`Reset failed: ${migration.name}`, err);
+          throw err;
+        }
+      }
+    }
+  }
+  async refresh() {
+    await this.reset();
+    await this.run();
+  }
+  async status() {
+    await this.ensureMigrationTable();
+    return this.getRanMigrations();
+  }
+  async ensureMigrationTable() {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileCreateMigrationsTable();
+    await this.connection.raw(sql);
+  }
+  async getRanMigrations() {
+    const result = await this.connection.raw(
+      "SELECT name, batch, executed_at as executedAt FROM migrations ORDER BY batch ASC, name ASC"
+    );
+    return result.rows.map((row) => ({
+      name: String(row.name),
+      batch: Number(row.batch),
+      executedAt: String(row.executedAt ?? "")
+    }));
+  }
+  async getNextBatchNumber() {
+    const result = await this.connection.raw(
+      "SELECT COALESCE(MAX(batch), 0) + 1 as next_batch FROM migrations"
+    );
+    return Number(result.rows[0]?.next_batch ?? 1);
+  }
+  async getLastBatchNumber() {
+    const result = await this.connection.raw(
+      "SELECT COALESCE(MAX(batch), 0) as last_batch FROM migrations"
+    );
+    return Number(result.rows[0]?.last_batch ?? 0);
+  }
+  async getMigrationsByBatch(batch) {
+    const result = await this.connection.raw(
+      "SELECT name, batch, executed_at as executedAt FROM migrations WHERE batch = ? ORDER BY name ASC",
+      [batch]
+    );
+    return result.rows.map((row) => ({
+      name: String(row.name),
+      batch: Number(row.batch),
+      executedAt: String(row.executedAt ?? "")
+    }));
+  }
+  async recordMigration(name, batch) {
+    await this.connection.raw(
+      "INSERT INTO migrations (name, batch) VALUES (?, ?)",
+      [name, batch]
+    );
+  }
+  async removeMigration(name) {
+    await this.connection.raw("DELETE FROM migrations WHERE name = ?", [name]);
+  }
+};
+
+// src/server/database/pagination.ts
+var Pagination = class _Pagination {
+  data;
+  currentPage;
+  perPage;
+  total;
+  lastPage;
+  from;
+  to;
+  constructor(result) {
+    this.data = result.data;
+    this.currentPage = result.currentPage;
+    this.perPage = result.perPage;
+    this.total = result.total;
+    this.lastPage = result.lastPage;
+    this.from = result.from;
+    this.to = result.to;
+  }
+  get hasMore() {
+    return this.currentPage < this.lastPage;
+  }
+  get hasPrev() {
+    return this.currentPage > 1;
+  }
+  get isEmpty() {
+    return this.data.length === 0;
+  }
+  nextPage() {
+    if (!this.hasMore) return null;
+    return {
+      page: this.currentPage + 1,
+      perPage: this.perPage,
+      url: null
+    };
+  }
+  prevPage() {
+    if (!this.hasPrev) return null;
+    return {
+      page: this.currentPage - 1,
+      perPage: this.perPage,
+      url: null
+    };
+  }
+  toJSON() {
+    return {
+      data: this.data,
+      pagination: {
+        currentPage: this.currentPage,
+        perPage: this.perPage,
+        total: this.total,
+        lastPage: this.lastPage,
+        from: this.from,
+        to: this.to,
+        hasMore: this.hasMore,
+        hasPrev: this.hasPrev,
+        isEmpty: this.isEmpty
+      }
+    };
+  }
+  map(fn) {
+    return new _Pagination({
+      ...this,
+      data: this.data.map(fn)
+    });
+  }
+  items() {
+    return this.data;
+  }
+  static from(result) {
+    return new _Pagination(result);
+  }
+};
+
+// src/server/database/seeder.ts
+var Seeder = class {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  async call(seederClass) {
+    await seederClass.run(this.connection);
+  }
+  async insert(table, data) {
+    if (data.length === 0) return;
+    const dialect = this.connection.getDialect();
+    const firstRow = data[0];
+    if (!firstRow) return;
+    const columns = Object.keys(firstRow);
+    const wrappedColumns = columns.map((c) => dialect.wrapIdentifier(c)).join(", ");
+    const batchSize = 100;
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize);
+      const placeholders = [];
+      const bindings = [];
+      for (const row of batch) {
+        const rowPlaceholders = columns.map((col) => {
+          bindings.push(row[col]);
+          return dialect.makeParameter(bindings.length - 1);
+        });
+        placeholders.push(`(${rowPlaceholders.join(", ")})`);
+      }
+      const sql = `INSERT INTO ${dialect.wrapIdentifier(table)} (${wrappedColumns}) VALUES ${placeholders.join(", ")}`;
+      await this.connection.raw(sql, bindings);
+    }
+  }
+  async truncate(table) {
+    const dialect = this.connection.getDialect();
+    const driver = this.connection.getDriver();
+    if (driver === "sqlite") {
+      await this.connection.raw(`DELETE FROM ${dialect.wrapIdentifier(table)}`);
+    } else if (driver === "postgresql") {
+      await this.connection.raw(dialect.compileTruncate(table));
+    } else {
+      await this.connection.raw("SET FOREIGN_KEY_CHECKS = 0");
+      await this.connection.raw(dialect.compileTruncate(table));
+      await this.connection.raw("SET FOREIGN_KEY_CHECKS = 1");
+    }
+  }
+  async run() {
+    throw new Error("Seeder.run() must be overridden by subclasses");
+  }
+};
+
+// src/server/events/index.ts
+import { EventEmitter } from "events";
+var Event = class {
+  emitter;
+  wildcardMode;
+  patterns = [];
+  constructor(config) {
+    this.emitter = new EventEmitter();
+    this.wildcardMode = config?.wildcard ?? false;
+    if (config?.maxListeners !== void 0) {
+      this.emitter.setMaxListeners(config.maxListeners);
+    }
+  }
+  on(event2, handler) {
+    this.emitter.on(event2, handler);
+    return this;
+  }
+  addListener(event2, handler) {
+    return this.on(event2, handler);
+  }
+  once(event2, handler) {
+    this.emitter.once(event2, handler);
+    return this;
+  }
+  async emit(event2, ...args) {
+    const listeners = this.emitter.listeners(event2);
+    for (const listener of listeners) {
+      const result = listener(...args);
+      if (result instanceof Promise) {
+        await result;
+      }
+    }
+    if (this.wildcardMode) {
+      for (const entry of this.patterns) {
+        if (entry.regex.test(event2)) {
+          const result = entry.handler(event2, ...args);
+          if (result instanceof Promise) {
+            await result;
+          }
+        }
+      }
+    }
+  }
+  off(event2, handler) {
+    this.emitter.off(event2, handler);
+    return this;
+  }
+  removeListener(event2, handler) {
+    return this.off(event2, handler);
+  }
+  removeAllListeners(event2) {
+    if (event2 !== void 0) {
+      this.emitter.removeAllListeners(event2);
+      this.patterns = this.patterns.filter((p) => p.pattern !== event2);
+    } else {
+      this.emitter.removeAllListeners();
+      this.patterns = [];
+    }
+    return this;
+  }
+  listeners(event2) {
+    return this.emitter.listeners(event2);
+  }
+  hasListeners(event2) {
+    if (this.emitter.listenerCount(event2) > 0) {
+      return true;
+    }
+    if (this.wildcardMode) {
+      for (const entry of this.patterns) {
+        if (entry.regex.test(event2)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  onPattern(pattern, handler) {
+    if (!this.wildcardMode) {
+      throw new Error(
+        "Pattern matching is not enabled. Set wildcard: true in EventConfig."
+      );
+    }
+    const regex = this.patternToRegex(pattern);
+    this.patterns.push({ pattern, regex, handler });
+    return this;
+  }
+  async ask(event2, ...args) {
+    const handlers = this.emitter.listeners(event2);
+    const results = [];
+    for (const handler of handlers) {
+      const result = handler(...args);
+      if (result instanceof Promise) {
+        const resolved = await result;
+        if (resolved !== void 0) {
+          results.push(resolved);
+        }
+      } else if (result !== void 0) {
+        results.push(result);
+      }
+    }
+    if (this.wildcardMode) {
+      for (const entry of this.patterns) {
+        if (entry.regex.test(event2)) {
+          const result = entry.handler(event2, ...args);
+          if (result instanceof Promise) {
+            const resolved = await result;
+            if (resolved !== void 0) {
+              results.push(resolved);
+            }
+          } else if (result !== void 0) {
+            results.push(result);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  listenerCount(event2) {
+    if (event2 !== void 0) {
+      let count = this.emitter.listenerCount(event2);
+      if (this.wildcardMode) {
+        for (const entry of this.patterns) {
+          if (entry.regex.test(event2)) {
+            count++;
+          }
+        }
+      }
+      return count;
+    }
+    return this.emitter.eventNames().reduce((sum, name) => sum + this.emitter.listenerCount(name), 0) + this.patterns.length;
+  }
+  eventNames() {
+    const nativeNames = this.emitter.eventNames();
+    const patternNames = this.patterns.map((p) => p.pattern);
+    return [.../* @__PURE__ */ new Set([...nativeNames, ...patternNames])];
+  }
+  patternToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const regexStr = escaped.replace(/\*/g, "[^.]*");
+    return new RegExp(`^${regexStr}$`);
+  }
+};
+var defaultEvent = null;
+function createEvent(config) {
+  defaultEvent = new Event(config);
+  return defaultEvent;
+}
+function event() {
+  if (defaultEvent === null) {
+    defaultEvent = new Event();
+  }
+  return defaultEvent;
+}
+
+// src/server/helpers.ts
+var defaultBuilder = null;
+var URLBuilder = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl ?? "http://localhost:3000";
+  }
+  route(_name, _params) {
+    throw new Error(
+      "URLBuilder.route() requires a Router reference. Set the router via URLBuilder.setRouter() before calling route()."
+    );
+  }
+  to(path3) {
+    const normalized = path3.replace(/\\/g, "/");
+    const base = this.baseUrl.replace(/\/$/, "");
+    const cleanPath = normalized.startsWith("/") ? normalized : `/${normalized}`;
+    return `${base}${cleanPath}`;
+  }
+  asset(path3) {
+    return this.to(path3);
+  }
+  secure(path3) {
+    const base = this.baseUrl.replace(/^http:/, "https:");
+    const normalized = path3.replace(/\\/g, "/");
+    const cleanPath = normalized.startsWith("/") ? normalized : `/${normalized}`;
+    return `${base}${cleanPath}`;
+  }
+  setBaseUrl(url2) {
+    this.baseUrl = url2;
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+};
+function url() {
+  if (defaultBuilder === null) {
+    defaultBuilder = new URLBuilder();
+  }
+  return defaultBuilder;
+}
+var macroFns = {};
+function responseMacros(response) {
+  for (const [name, fn] of Object.entries(macroFns)) {
+    const bound = fn.bind(response);
+    response[name] = bound;
+  }
+}
+function registerMacro(name, fn) {
+  macroFns[name] = fn;
+}
+registerMacro("success", function(data, message) {
+  return this.json({
+    success: true,
+    message: message ?? "Success",
+    data
+  });
+});
+registerMacro(
+  "error",
+  function(message, status = 400) {
+    return this.json({ success: false, message }, status);
+  }
+);
+registerMacro("created", function(data, message) {
+  return this.status(201).json({
+    success: true,
+    message: message ?? "Created",
+    data
+  });
+});
+registerMacro("noContent", function() {
+  return this.status(204).send("");
+});
+registerMacro(
+  "accepted",
+  function(data, message) {
+    return this.status(202).json({
+      success: true,
+      message: message ?? "Accepted",
+      data
+    });
+  }
+);
+registerMacro(
+  "paginated",
+  function(data, meta) {
+    return this.json({
+      success: true,
+      data,
+      meta
+    });
+  }
+);
+
+// src/server/storage/index.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var LocalDisk = class {
+  root;
+  baseUrl;
+  constructor(root, baseUrl) {
+    this.root = path2.resolve(root);
+    this.baseUrl = baseUrl;
+  }
+  async put(filePath, content) {
+    const fullPath = this.resolvePath(filePath);
+    const dir = path2.dirname(fullPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(fullPath, content);
+    return filePath;
+  }
+  async get(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    if (!fs2.existsSync(fullPath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    return fs2.readFileSync(fullPath);
+  }
+  async exists(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    return fs2.existsSync(fullPath);
+  }
+  async delete(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    if (!fs2.existsSync(fullPath)) {
+      return false;
+    }
+    fs2.unlinkSync(fullPath);
+    return true;
+  }
+  async copy(from, to) {
+    const fromPath = this.resolvePath(from);
+    const toPath = this.resolvePath(to);
+    if (!fs2.existsSync(fromPath)) {
+      return false;
+    }
+    const dir = path2.dirname(toPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.copyFileSync(fromPath, toPath);
+    return true;
+  }
+  async move(from, to) {
+    const fromPath = this.resolvePath(from);
+    const toPath = this.resolvePath(to);
+    if (!fs2.existsSync(fromPath)) {
+      return false;
+    }
+    const dir = path2.dirname(toPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.renameSync(fromPath, toPath);
+    return true;
+  }
+  url(filePath) {
+    if (this.baseUrl === void 0) {
+      throw new Error("Base URL not configured for this disk");
+    }
+    const normalized = filePath.replace(/\\/g, "/");
+    return `${this.baseUrl.replace(/\/$/, "")}/${normalized.replace(/^\//, "")}`;
+  }
+  async size(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    if (!fs2.existsSync(fullPath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    return fs2.statSync(fullPath).size;
+  }
+  async lastModified(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    if (!fs2.existsSync(fullPath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    return fs2.statSync(fullPath).mtime;
+  }
+  async files(directory = "") {
+    const fullPath = this.resolvePath(directory);
+    if (!fs2.existsSync(fullPath)) {
+      return [];
+    }
+    return fs2.readdirSync(fullPath).filter((name) => {
+      const stat2 = fs2.statSync(path2.join(fullPath, name));
+      return stat2.isFile();
+    }).map((name) => path2.join(directory, name).replace(/\\/g, "/"));
+  }
+  async directories(directory = "") {
+    const fullPath = this.resolvePath(directory);
+    if (!fs2.existsSync(fullPath)) {
+      return [];
+    }
+    return fs2.readdirSync(fullPath).filter((name) => {
+      const stat2 = fs2.statSync(path2.join(fullPath, name));
+      return stat2.isDirectory();
+    }).map((name) => path2.join(directory, name).replace(/\\/g, "/"));
+  }
+  async makeDirectory(dirPath) {
+    const fullPath = this.resolvePath(dirPath);
+    fs2.mkdirSync(fullPath, { recursive: true });
+  }
+  async deleteDirectory(dirPath) {
+    const fullPath = this.resolvePath(dirPath);
+    if (fs2.existsSync(fullPath)) {
+      fs2.rmSync(fullPath, { recursive: true, force: true });
+    }
+  }
+  async append(filePath, content) {
+    const fullPath = this.resolvePath(filePath);
+    const dir = path2.dirname(fullPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.appendFileSync(fullPath, content, "utf-8");
+  }
+  async prepend(filePath, content) {
+    const fullPath = this.resolvePath(filePath);
+    const dir = path2.dirname(fullPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    const existing = fs2.existsSync(fullPath) ? fs2.readFileSync(fullPath, "utf-8") : "";
+    fs2.writeFileSync(fullPath, content + existing, "utf-8");
+  }
+  readStream(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    if (!fs2.existsSync(fullPath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    return fs2.createReadStream(fullPath);
+  }
+  writeStream(filePath) {
+    const fullPath = this.resolvePath(filePath);
+    const dir = path2.dirname(fullPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    return fs2.createWriteStream(fullPath);
+  }
+  getRoot() {
+    return this.root;
+  }
+  getUrl() {
+    return this.baseUrl;
+  }
+  resolvePath(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    const resolved = path2.resolve(this.root, normalized);
+    const resolvedRoot = path2.resolve(this.root);
+    if (!resolved.startsWith(resolvedRoot)) {
+      throw new Error(`Path traversal detected: ${filePath}`);
+    }
+    return resolved;
+  }
+};
+var Storage = class {
+  config;
+  diskInstances;
+  constructor(config) {
+    this.config = config;
+    this.diskInstances = /* @__PURE__ */ new Map();
+  }
+  disk(name) {
+    const diskName = name ?? this.config.defaultDisk ?? "local";
+    const existing = this.diskInstances.get(diskName);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const diskConfig = this.config.disks[diskName];
+    if (diskConfig === void 0) {
+      throw new Error(`Disk not configured: ${diskName}`);
+    }
+    const instance = new LocalDisk(diskConfig.root, diskConfig.url);
+    this.diskInstances.set(diskName, instance);
+    return instance;
+  }
+  async put(filePath, content) {
+    return this.disk().put(filePath, content);
+  }
+  async get(filePath) {
+    return this.disk().get(filePath);
+  }
+  async exists(filePath) {
+    return this.disk().exists(filePath);
+  }
+  async delete(filePath) {
+    return this.disk().delete(filePath);
+  }
+  async copy(from, to) {
+    return this.disk().copy(from, to);
+  }
+  async move(from, to) {
+    return this.disk().move(from, to);
+  }
+  async url(filePath) {
+    return this.disk().url(filePath);
+  }
+  async size(filePath) {
+    return this.disk().size(filePath);
+  }
+  async lastModified(filePath) {
+    return this.disk().lastModified(filePath);
+  }
+  async files(directory) {
+    return this.disk().files(directory);
+  }
+  async directories(directory) {
+    return this.disk().directories(directory);
+  }
+  async makeDirectory(dirPath) {
+    return this.disk().makeDirectory(dirPath);
+  }
+  async deleteDirectory(dirPath) {
+    return this.disk().deleteDirectory(dirPath);
+  }
+};
+var defaultInstance = null;
+function createStorage(config) {
+  defaultInstance = new Storage(config);
+  return defaultInstance;
+}
+function storage() {
+  if (defaultInstance === null) {
+    throw new Error(
+      "Storage not initialized. Call createStorage(config) first."
+    );
+  }
+  return defaultInstance;
+}
+
+// src/server/index.ts
+var SuperApp = class {
+  router;
+  container;
+  engine;
+  serverInstance;
+  globalPipeline;
+  started = false;
+  serverPromise;
+  constructor(options = {}) {
+    this.container = options.container ?? new Container();
+    this.router = new Router();
+    this.engine = options.engine ?? new NodeEngine();
+    this.globalPipeline = new MiddlewarePipeline();
+    this.container.instance("app", this);
+    this.container.instance("router", this.router);
+    this.container.instance("container", this.container);
+  }
+  use(middleware) {
+    this.globalPipeline.use(middleware);
+    return this;
+  }
+  get(path3, handler) {
+    this.router.get(path3, handler);
+    return this;
+  }
+  post(path3, handler) {
+    this.router.post(path3, handler);
+    return this;
+  }
+  put(path3, handler) {
+    this.router.put(path3, handler);
+    return this;
+  }
+  patch(path3, handler) {
+    this.router.patch(path3, handler);
+    return this;
+  }
+  delete(path3, handler) {
+    this.router.delete(path3, handler);
+    return this;
+  }
+  options(path3, handler) {
+    this.router.options(path3, handler);
+    return this;
+  }
+  any(path3, handler) {
+    this.router.any(path3, handler);
+    return this;
+  }
+  match(methods, path3, handler) {
+    this.router.match(methods, path3, handler);
+    return this;
+  }
+  group(prefix, callback) {
+    this.router.group(prefix, callback);
+    return this;
+  }
+  resource(name, controller) {
+    this.router.resource(name, controller);
+    return this;
+  }
+  apiResource(name, controller) {
+    this.router.apiResource(name, controller);
+    return this;
+  }
+  controller(ctrl) {
+    const prefix = getControllerPrefix(ctrl);
+    const routes = getControllerRoutes(ctrl.prototype);
+    for (const route of routes) {
+      const handlerPath = `${prefix}${route.path}`;
+      const handlerName = String(route.handler);
+      this.router.match(
+        [route.method],
+        handlerPath,
+        async (ctx) => {
+          const instance = createControllerInstance2(ctrl, ctx);
+          const handlerFn = instance[handlerName];
+          if (typeof handlerFn === "function") {
+            await handlerFn.call(instance, ctx);
+          } else {
+            throw new Error(
+              `Handler ${handlerName} not found on controller ${ctrl.name}`
+            );
+          }
+        }
+      );
+    }
+    return this;
+  }
+  middleware(middleware) {
+    this.router.middleware(middleware);
+    return this;
+  }
+  setEngine(engine) {
+    if (this.started) {
+      throw new Error("Cannot change engine after server has started");
+    }
+    this.engine = engine;
+    return this;
+  }
+  static(path3, options) {
+    this.use(staticFiles(path3, options));
+    return this;
+  }
+  view(_engine) {
+    return this;
+  }
+  getServer() {
+    return this.serverInstance;
+  }
+  async start(port, host) {
+    if (this.started) {
+      throw new Error("Server has already been started");
+    }
+    this.started = true;
+    this.serverInstance = await this.engine.createServer(
+      async (req, res) => {
+        await this.handleRequest(req, res);
+      }
+    );
+    const listenPort = port ?? 3e3;
+    const listenHost = host ?? "0.0.0.0";
+    return new Promise((resolve2) => {
+      const raw = this.serverInstance.raw;
+      raw.listen(listenPort, listenHost, () => {
+        resolve2();
+      });
+    });
+  }
+  listen(port, callback) {
+    this.serverPromise = this.start(port).then(() => {
+      callback?.();
+    });
+  }
+  async close() {
+    if (this.serverInstance !== void 0) {
+      await this.engine.close(this.serverInstance);
+      this.serverInstance = void 0;
+      this.started = false;
+    }
+  }
+  async ready() {
+    if (this.serverPromise !== void 0) {
+      await this.serverPromise;
+    }
+  }
+  async handleRequest(req, res) {
+    const resolvedRoute = this.router.resolve(req.method, req.path);
+    if (resolvedRoute === null) {
+      res.status(HttpStatus.NOT_FOUND).json({
+        error: "Not Found",
+        message: `Route ${req.method} ${req.path} not found`
+      });
+      await res.flush();
+      return;
+    }
+    req.params = resolvedRoute.params;
+    const ctx = {
+      request: req,
+      response: res,
+      params: resolvedRoute.params,
+      query: req.query,
+      container: this.container
+    };
+    await this.globalPipeline.run(ctx, async () => {
+      const routePipeline = new MiddlewarePipeline();
+      for (const mw of resolvedRoute.middleware) {
+        routePipeline.use(mw);
+      }
+      await routePipeline.run(ctx, async () => {
+        await resolvedRoute.handler(ctx);
+      });
+    });
+    if (!res.headersSent) {
+      await res.flush();
+    }
+  }
+};
+function constx(options) {
+  return new SuperApp(options);
+}
+function createControllerInstance2(controller, ctx) {
+  const instance = new controller();
+  instance.__ctx = ctx;
+  instance.__container = ctx.container;
+  return instance;
+}
+export {
+  Cache,
+  ColumnDefinition,
+  DatabaseConnection,
+  Event,
+  ForeignKeyDefinition,
+  LocalDisk,
+  Migrator,
+  MysqlDialect,
+  Pagination,
+  PostgresqlDialect,
+  QueryBuilder,
+  SchemaBuilder,
+  Seeder,
+  SqliteDialect,
+  Storage,
+  SuperApp,
+  TableBlueprint,
+  URLBuilder,
+  cacheResponse,
+  constx,
+  createDialect,
+  createDriver,
+  createEvent,
+  createStorage,
+  event,
+  registerMacro,
+  responseMacros,
+  storage,
+  url
+};
+//# sourceMappingURL=index.js.map