qhttpx 2.1.0 → 2.3.1

package/dist/index.mjs

@@ -0,0 +1,1863 @@
+import {
+  __require,
+  __toESM,
+  env,
+  loadEnv,
+  require_core
+} from "./chunk-QW72SEAS.mjs";
+
+// src/index.ts
+var import_core = __toESM(require_core());
+
+// src/context.ts
+var Context = class {
+  constructor(engine, id, rawParams, queryString, rawBody, rawHeaders, rawUrl, responseHandle, method, serializer) {
+    this.engine = engine;
+    this.id = id;
+    this.rawParams = rawParams;
+    this.queryString = queryString;
+    this.rawBody = rawBody;
+    this.rawHeaders = rawHeaders;
+    this.responseHandle = responseHandle;
+    this.serializer = serializer;
+    this.method = method;
+    this.env = Object.entries(process.env).filter(([, value]) => value !== void 0).reduce((acc, [key, value]) => {
+      acc[key] = value;
+      return acc;
+    }, {});
+    this.perf = {
+      startTime: Date.now(),
+      dbDuration: 0,
+      parseDuration: 0,
+      allocations: 0
+    };
+    try {
+      this.url = new URL(rawUrl, "http://localhost");
+    } catch {
+      this.url = new URL("http://localhost");
+    }
+    this.path = this.url.pathname;
+    this.db = {
+      query: async (sql, ttl) => {
+        return this.engine.queryDb(sql, ttl);
+      },
+      queryWithParams: async (sql, params, ttl) => {
+        return this.engine.queryDbWithParams(sql, params, ttl);
+      },
+      mongo: (dbName, collName) => ({
+        find: async (query) => {
+          const json = await this.engine.queryMongo(dbName, collName, JSON.stringify(query));
+          return JSON.parse(json);
+        }
+      })
+    };
+  }
+  _status = 200;
+  _params = null;
+  _headers = null;
+  // Placeholder implementations for interface compliance
+  url;
+  method;
+  path;
+  body;
+  env;
+  db;
+  perf;
+  get params() {
+    if (!this._params) {
+      this._params = {};
+      for (let i = 0; i < this.rawParams.length; i += 2) {
+        this._params[this.rawParams[i]] = this.rawParams[i + 1];
+      }
+    }
+    return this._params;
+  }
+  _query = null;
+  get query() {
+    if (!this._query) {
+      this._query = {};
+      if (this.queryString) {
+        const searchParams = new URLSearchParams(this.queryString);
+        searchParams.forEach((value, key) => {
+          if (this._query[key]) {
+            if (Array.isArray(this._query[key])) {
+              this._query[key].push(value);
+            } else {
+              this._query[key] = [this._query[key], value];
+            }
+          } else {
+            this._query[key] = value;
+          }
+        });
+      }
+    }
+    return this._query;
+  }
+  get headers() {
+    if (!this._headers) {
+      this._headers = /* @__PURE__ */ new Map();
+      for (let i = 0; i < this.rawHeaders.length; i += 2) {
+        this._headers.set(this.rawHeaders[i].toLowerCase(), this.rawHeaders[i + 1]);
+      }
+    }
+    return this._headers;
+  }
+  // Body Methods (Getters)
+  text() {
+    return this.rawBody.toString("utf-8");
+  }
+  get req() {
+    return {
+      json: () => {
+        try {
+          return JSON.parse(this.text());
+        } catch (e) {
+          throw new Error(`Invalid JSON body: ${e}`);
+        }
+      },
+      text: () => this.text(),
+      param: (key) => this.params[key],
+      query: (key) => {
+        const val = this.query[key];
+        return Array.isArray(val) ? val[0] : val;
+      },
+      queries: (key) => {
+        const val = this.query[key];
+        return Array.isArray(val) ? val : [val];
+      },
+      header: (key) => this.headers.get(key.toLowerCase())
+    };
+  }
+  // Legacy support (Deprecated)
+  json(data, status) {
+    if (data !== void 0) {
+      if (status) this._status = status;
+      return this.send(data);
+    }
+    return this.req.json();
+  }
+  send(data) {
+    if (typeof data === "string") {
+      this.engine.sendResponse(this.responseHandle, this._status, data);
+    } else {
+      if (this.serializer) {
+        const body = this.serializer(data);
+        this.engine.sendResponse(this.responseHandle, this._status, body);
+      } else {
+        this.engine.sendResponse(this.responseHandle, this._status, JSON.stringify(data));
+      }
+    }
+  }
+  html(content) {
+    this.engine.sendHtml(this.responseHandle, this._status, content);
+  }
+  status(code) {
+    this._status = code;
+    return this;
+  }
+  get statusCode() {
+    return this._status;
+  }
+  snapshot() {
+    const normalizeValue = (value) => {
+      if (Array.isArray(value)) {
+        return [...value].map(normalizeValue).sort();
+      }
+      if (value && typeof value === "object") {
+        const keys = Object.keys(value).sort();
+        const sorted = {};
+        for (const key of keys) {
+          sorted[key] = normalizeValue(value[key]);
+        }
+        return sorted;
+      }
+      return value;
+    };
+    const headers = {};
+    for (const [key, value] of this.headers.entries()) {
+      headers[key] = value;
+    }
+    let body;
+    try {
+      body = this.req.json();
+    } catch {
+      body = this.text();
+    }
+    return {
+      id: this.id,
+      method: this.method,
+      url: this.url.toString(),
+      path: this.path,
+      params: normalizeValue(this.params),
+      query: normalizeValue(this.query),
+      headers: normalizeValue(headers),
+      body: normalizeValue(body),
+      env: normalizeValue(this.env),
+      perf: normalizeValue(this.perf)
+    };
+  }
+};
+
+// src/compose.ts
+function compose(middleware) {
+  if (!Array.isArray(middleware)) throw new TypeError("Middleware stack must be an array!");
+  for (const fn of middleware) {
+    if (typeof fn !== "function") throw new TypeError("Middleware must be composed of functions!");
+  }
+  return function(context, next) {
+    let index = -1;
+    return dispatch(0);
+    function dispatch(i) {
+      if (i <= index) return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      let fn = middleware[i];
+      if (i === middleware.length) fn = next;
+      if (!fn) return Promise.resolve();
+      try {
+        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+  };
+}
+
+// src/index.ts
+import fastJson from "fast-json-stringify";
+
+// src/generator.ts
+function generateClient(routes) {
+  const interfaces = [];
+  const paths = [];
+  let interfaceCounter = 0;
+  function schemaToTs(schema, name) {
+    if (!schema) return "any";
+    if (schema.type === "object") {
+      const props = [];
+      const required = new Set(schema.required || []);
+      for (const key in schema.properties) {
+        const propSchema = schema.properties[key];
+        const isReq = required.has(key);
+        const tsType = schemaToTs(propSchema, `${name}_${key}`);
+        props.push(`    ${key}${isReq ? "" : "?"}: ${tsType};`);
+      }
+      const interfaceName = `I${name}`;
+      interfaces.push(`export interface ${interfaceName} {
+${props.join("\n")}
+}`);
+      return interfaceName;
+    }
+    if (schema.type === "array") {
+      const itemType = schemaToTs(schema.items, `${name}_item`);
+      return `${itemType}[]`;
+    }
+    if (schema.enum) {
+      return schema.enum.map((v) => `'${v}'`).join(" | ");
+    }
+    if (schema.type === "string") return "string";
+    if (schema.type === "integer" || schema.type === "number") return "number";
+    if (schema.type === "boolean") return "boolean";
+    return "any";
+  }
+  const routeMap = {};
+  for (const route of routes) {
+    if (route.path.includes("/docs")) continue;
+    if (!routeMap[route.path]) routeMap[route.path] = {};
+    let reqType = "any";
+    if (route.options && route.options.schema) {
+      try {
+        const schema = JSON.parse(route.options.schema);
+        const name = `${route.method}_${route.path.replace(/[^a-zA-Z0-9]/g, "_")}_Body`;
+        reqType = schemaToTs(schema, name);
+      } catch (e) {
+        console.warn(`Failed to parse schema for client gen: ${route.path}`);
+      }
+    }
+    const resType = "any";
+    routeMap[route.path][route.method] = { req: reqType, res: resType };
+  }
+  const lines = [
+    `// Auto-generated QHTTPX Client`,
+    `// Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    ``,
+    `export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';`,
+    ``,
+    `// --- Interfaces ---`,
+    ...interfaces,
+    ``,
+    `// --- Route Definitions ---`,
+    `export interface AppRoutes {`
+  ];
+  for (const [path, methods] of Object.entries(routeMap)) {
+    lines.push(`    '${path}': {`);
+    for (const [method, types] of Object.entries(methods)) {
+      lines.push(`        '${method}': {`);
+      lines.push(`            request: ${types.req};`);
+      lines.push(`            response: ${types.res};`);
+      lines.push(`        };`);
+    }
+    lines.push(`    };`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`
+export class Client {
+    constructor(private baseUrl: string, private token?: string) {}
+
+    setToken(token: string) {
+        this.token = token;
+    }
+
+    private async request<P extends keyof AppRoutes, M extends keyof AppRoutes[P]>(
+        method: M, 
+        path: P, 
+        body?: any
+    ): Promise<any> {
+        const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+        if (this.token) headers['Authorization'] = \`Bearer \${this.token}\`;
+
+        // Handle path params if any (naive replacement)
+        // Note: The typed path must match the definition (e.g. /users/:id). 
+        // Real usage would need a path builder, but for now we assume exact match or user string manipulation.
+        
+        const res = await fetch(\`\${this.baseUrl}\${path as string}\`, {
+            method: method as string,
+            headers,
+            body: body ? JSON.stringify(body) : undefined
+        });
+
+        if (!res.ok) {
+            throw new Error(\`Request failed: \${res.status} \${res.statusText}\`);
+        }
+
+        const contentType = res.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+            return res.json();
+        }
+        return res.text();
+    }
+
+    get<P extends keyof AppRoutes>(path: P): Promise<AppRoutes[P]['GET' & keyof AppRoutes[P]]['response']> {
+        return this.request('GET', path);
+    }
+
+    post<P extends keyof AppRoutes>(
+        path: P, 
+        body: AppRoutes[P]['POST' & keyof AppRoutes[P]]['request']
+    ): Promise<AppRoutes[P]['POST' & keyof AppRoutes[P]]['response']> {
+        return this.request('POST', path, body);
+    }
+
+    put<P extends keyof AppRoutes>(
+        path: P, 
+        body: AppRoutes[P]['PUT' & keyof AppRoutes[P]]['request']
+    ): Promise<AppRoutes[P]['PUT' & keyof AppRoutes[P]]['response']> {
+        return this.request('PUT', path, body);
+    }
+
+    delete<P extends keyof AppRoutes>(path: P): Promise<AppRoutes[P]['DELETE' & keyof AppRoutes[P]]['response']> {
+        return this.request('DELETE', path);
+    }
+}
+    `);
+  return lines.join("\n");
+}
+
+// src/index.ts
+import * as fs from "fs";
+
+// src/test.ts
+var TestClient = class {
+  app;
+  port;
+  baseUrl;
+  running = false;
+  constructor(app) {
+    this.app = app;
+    this.port = 0;
+    this.baseUrl = "";
+  }
+  async start() {
+    if (this.running) return;
+    this.port = Math.floor(Math.random() * 1e4) + 2e4;
+    this.baseUrl = `http://localhost:${this.port}`;
+    return new Promise((resolve, reject) => {
+      try {
+        this.app.listen(this.port, () => {
+          this.running = true;
+          resolve();
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  async stop() {
+    if (this.running) {
+      this.app.stop();
+      this.running = false;
+    }
+  }
+  async get(path, headers) {
+    const h = { "Connection": "close", ...headers };
+    return fetch(`${this.baseUrl}${path}`, { method: "GET", headers: h });
+  }
+  async post(path, body, headers) {
+    const isJson = typeof body === "object";
+    const h = { "Connection": "close", ...headers };
+    if (isJson && !h["Content-Type"]) h["Content-Type"] = "application/json";
+    return fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: h,
+      body: isJson ? JSON.stringify(body) : body
+    });
+  }
+  async put(path, body, headers) {
+    const isJson = typeof body === "object";
+    const h = { "Connection": "close", ...headers };
+    if (isJson && !h["Content-Type"]) h["Content-Type"] = "application/json";
+    return fetch(`${this.baseUrl}${path}`, {
+      method: "PUT",
+      headers: h,
+      body: isJson ? JSON.stringify(body) : body
+    });
+  }
+  async delete(path, headers) {
+    const h = { "Connection": "close", ...headers };
+    return fetch(`${this.baseUrl}${path}`, { method: "DELETE", headers: h });
+  }
+};
+function createTestClient(app) {
+  return new TestClient(app);
+}
+
+// src/fluent.ts
+var requireOptional = (pkg) => {
+  try {
+    return __require(pkg);
+  } catch (e) {
+    throw new Error(`Dependency '${pkg}' is required for this feature. Please install it: npm install ${pkg}`);
+  }
+};
+var schemaFromValidation = (schema) => {
+  const properties = {};
+  const required = [];
+  for (const [key, type] of Object.entries(schema)) {
+    required.push(key);
+    if (type === "email") {
+      properties[key] = { type: "string", format: "email" };
+    } else if (type === "int" || type === "integer") {
+      properties[key] = { type: "integer" };
+    } else if (type === "bool" || type === "boolean") {
+      properties[key] = { type: "boolean" };
+    } else {
+      properties[key] = { type: "string" };
+    }
+  }
+  return { type: "object", properties, required };
+};
+var FluentBuilder = class {
+  constructor(app, method, path) {
+    this.app = app;
+    this.method = method;
+    this.path = path;
+  }
+  steps = [];
+  requestSchema;
+  responseSchemaDef;
+  queryBuilder;
+  // RouteBuilder compatibility methods
+  desc(description) {
+    this.steps.push({
+      name: "desc",
+      fn: (ctx, state) => {
+        return state;
+      }
+    });
+    return this;
+  }
+  auth(strategy) {
+    this.steps.push({
+      name: "auth",
+      fn: (ctx, state) => {
+        return state;
+      }
+    });
+    return this;
+  }
+  cache(options) {
+    this.steps.push({
+      name: "cache",
+      fn: (ctx, state) => {
+        return state;
+      }
+    });
+    return this;
+  }
+  rateLimit(options) {
+    this.steps.push({
+      name: "rateLimit",
+      fn: (ctx, state) => {
+        return state;
+      }
+    });
+    return this;
+  }
+  status(statusCode) {
+    this.steps.push({
+      name: "status",
+      fn: (ctx, state) => {
+        return { ...state, _status: statusCode };
+      }
+    });
+    return this;
+  }
+  priority(level) {
+    this.steps.push({
+      name: "priority",
+      fn: (ctx, state) => {
+        return state;
+      }
+    });
+    return this;
+  }
+  slo(targetMs) {
+    this.steps.push({
+      name: "slo",
+      fn: (ctx, state) => {
+        return state;
+      }
+    });
+    return this;
+  }
+  // 1. Validation Step
+  validate(schema) {
+    if (!this.requestSchema) {
+      this.requestSchema = schemaFromValidation(schema);
+    }
+    this.steps.push({
+      name: "validate",
+      fn: (ctx, state) => {
+        const body = ctx.req.json();
+        const errors = [];
+        const cleanData = {};
+        for (const [key, type] of Object.entries(schema)) {
+          if (!body[key]) {
+            errors.push(`Missing ${key}`);
+            continue;
+          }
+          if (type === "email" && !body[key].includes("@")) {
+            errors.push(`Invalid email for ${key}`);
+          }
+          cleanData[key] = body[key];
+        }
+        if (errors.length > 0) {
+          throw { status: 400, message: errors.join(", ") };
+        }
+        return { ...state, ...cleanData };
+      }
+    });
+    return this;
+  }
+  schema(def) {
+    this.requestSchema = def;
+    return this;
+  }
+  responseSchema(def) {
+    this.responseSchemaDef = def;
+    return this;
+  }
+  query(schemaBuilder) {
+    this.queryBuilder = schemaBuilder;
+    return this;
+  }
+  queryState(fields) {
+    this.steps.push({
+      name: "queryState",
+      fn: (ctx, state) => {
+        const query = ctx.query;
+        if (!fields || fields.length === 0) {
+          return { ...state, ...query };
+        }
+        const next = { ...state };
+        for (const field of fields) {
+          if (query[field] !== void 0) {
+            next[field] = query[field];
+          }
+        }
+        return next;
+      }
+    });
+    return this;
+  }
+  use(fn) {
+    this.steps.push({
+      name: "use",
+      fn
+    });
+    return this;
+  }
+  sql(query, params) {
+    this.steps.push({
+      name: "sql",
+      fn: async (ctx, state) => {
+        if (!ctx.db) throw { status: 500, message: "Database not connected" };
+        const resolvedParams = typeof params === "function" ? params(state) : params;
+        const res = resolvedParams ? await ctx.db.queryWithParams(query, resolvedParams) : await ctx.db.query(query);
+        return JSON.parse(res);
+      }
+    });
+    return this;
+  }
+  // 2. Transformation Step (e.g., Hashing)
+  transform(fn) {
+    this.steps.push({
+      name: "transform",
+      fn: async (ctx, state) => {
+        const result = await fn(state);
+        return { ...state, ...result };
+      }
+    });
+    return this;
+  }
+  // Pre-built Transform: Hash Password
+  hash(field = "password") {
+    return this.transform(async (data) => {
+      const bcrypt = requireOptional("bcryptjs");
+      if (data[field]) {
+        const hash = await bcrypt.hash(data[field], 10);
+        return { [field]: hash };
+      }
+      return {};
+    });
+  }
+  // 3. Database Step (Insert)
+  insert(table) {
+    this.steps.push({
+      name: `insert:${table}`,
+      fn: async (ctx, state) => {
+        if (!ctx.db) throw { status: 500, message: "Database not connected" };
+        const keys = Object.keys(state);
+        const values = Object.values(state);
+        const placeholders = values.map((_, i) => `$${i + 1}`);
+        const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders.join(", ")}) RETURNING *`;
+        try {
+          const res = await ctx.db.queryWithParams(sql, values);
+          const rows = JSON.parse(res);
+          return rows[0];
+        } catch (e) {
+          if (e.message?.includes("duplicate")) {
+            throw { status: 409, message: "Resource already exists" };
+          }
+          throw e;
+        }
+      }
+    });
+    return this;
+  }
+  // Database Select
+  find(table, by) {
+    this.steps.push({
+      name: `find:${table}`,
+      fn: async (ctx, state) => {
+        if (!ctx.db) throw { status: 500, message: "Database not connected" };
+        const val = state[by] || ctx.req.json()[by];
+        if (!val) throw { status: 400, message: `Missing lookup value for ${by}` };
+        const fields = state._query_select ? state._query_select.join(", ") : "*";
+        const sql = `SELECT ${fields} FROM ${table} WHERE ${by} = $1`;
+        const res = await ctx.db.queryWithParams(sql, [val]);
+        const rows = JSON.parse(res);
+        if (rows.length === 0) return null;
+        return rows[0];
+      }
+    });
+    return this;
+  }
+  // 4. Logic/Guard Step
+  ensure(condition, errorMsg = "Condition failed", status = 400) {
+    this.steps.push({
+      name: "ensure",
+      fn: (ctx, state) => {
+        if (!condition(state)) {
+          throw { status, message: errorMsg };
+        }
+        return state;
+      }
+    });
+    return this;
+  }
+  verifyPassword(field = "password") {
+    this.steps.push({
+      name: "verifyPassword",
+      fn: async (ctx, state) => {
+        const bcrypt = requireOptional("bcryptjs");
+        const body = ctx.req.json();
+        const inputPass = body[field];
+        const storedHash = state[field] || state[`${field}_hash`];
+        if (!inputPass || !storedHash) {
+          throw { status: 400, message: "Missing credentials" };
+        }
+        const valid = await bcrypt.compare(inputPass, storedHash);
+        if (!valid) throw { status: 401, message: "Invalid credentials" };
+        return state;
+      }
+    });
+    return this;
+  }
+  // 5. Auth Step (JWT)
+  jwt(options = {}) {
+    this.steps.push({
+      name: "jwt",
+      fn: (ctx, state) => {
+        const jwt = requireOptional("jsonwebtoken");
+        const secret = options.secret || process.env.JWT_SECRET || "secret";
+        const payload = { ...state };
+        delete payload.password;
+        delete payload.password_hash;
+        if (payload.id) payload.sub = payload.id;
+        const token = jwt.sign(payload, secret, { expiresIn: options.expiresIn || "24h" });
+        return { token, user: payload };
+      }
+    });
+    return this;
+  }
+  // 6. Response Step (Finalizer)
+  respond(handlerOrStatus = 200) {
+    if (typeof handlerOrStatus === "function") {
+      const fn = handlerOrStatus;
+      this.use(async (ctx, state) => await fn(ctx));
+      this.respond(200);
+      return;
+    }
+    if (typeof handlerOrStatus === "object" && handlerOrStatus !== null) {
+      const route2 = this.app[this.method.toLowerCase()](this.path, handlerOrStatus);
+      this.applyOptionsToRoute(route2);
+      return;
+    }
+    const status = handlerOrStatus;
+    const handler = async (ctx) => {
+      let state = {};
+      let finalStatus = status;
+      try {
+        for (const step of this.steps) {
+          const result = await step.fn(ctx, state);
+          if (result !== void 0) {
+            state = result;
+          }
+          if (state._status !== void 0) {
+            finalStatus = state._status;
+            delete state._status;
+          }
+        }
+        ctx.json(state, finalStatus);
+      } catch (e) {
+        const status2 = e.status || 500;
+        const message = e.message || "Internal Server Error";
+        console.error(`[Fluent] Error in ${this.method} ${this.path}:`, e);
+        ctx.json({ error: message }, status2);
+      }
+    };
+    const route = this.app[this.method.toLowerCase()](this.path, handler);
+    this.applyOptionsToRoute(route);
+  }
+  applyOptionsToRoute(route) {
+    if (this.requestSchema) {
+      route.schema(this.requestSchema);
+    }
+    if (this.responseSchemaDef) {
+      route.responseSchema(this.responseSchemaDef);
+    }
+    if (this.queryBuilder) {
+      route.query(this.queryBuilder);
+    }
+    if (this.useJwt) {
+      route.jwt();
+    }
+  }
+  useJwt = false;
+  // Route Options
+  secure() {
+    this.useJwt = true;
+    this.steps.unshift({
+      name: "auth:extract",
+      fn: (ctx, state) => {
+        const authHeader = ctx.req.header("authorization");
+        if (authHeader) {
+          const token = authHeader.split(" ")[1];
+          try {
+            const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+            return { user: payload };
+          } catch (e) {
+          }
+        }
+        return state;
+      }
+    });
+    return this;
+  }
+  // Query Configuration Steps
+  select(fields) {
+    this.steps.push({
+      name: "select",
+      fn: (ctx, state) => ({ ...state, _query_select: fields })
+    });
+    return this;
+  }
+  sort(field, direction = "ASC") {
+    this.steps.push({
+      name: "sort",
+      fn: (ctx, state) => ({ ...state, _query_sort: { field, direction } })
+    });
+    return this;
+  }
+  paginate(options) {
+    this.steps.push({
+      name: "paginate",
+      fn: (ctx, state) => ({ ...state, _query_paginate: options })
+    });
+    return this;
+  }
+  autoFilter(table, allow, options = {}) {
+    const sortAllow = options.sort || allow;
+    const selectAllow = options.select || allow;
+    const defaultSort = options.defaultSort || "id";
+    const defaultSortSafe = sortAllow.length > 0 ? sortAllow.includes(defaultSort) ? defaultSort : sortAllow[0] : defaultSort;
+    const defaultDirection = options.defaultDirection || "DESC";
+    const maxLimit = options.maxLimit || 100;
+    const pageParam = options.pageParam || "page";
+    const limitParam = options.limitParam || "limit";
+    const sortParam = options.sortParam || "sort";
+    const fieldsParam = options.fieldsParam || "fields";
+    const existingQueryBuilder = this.queryBuilder;
+    this.queryBuilder = (q) => {
+      if (existingQueryBuilder) existingQueryBuilder(q);
+      for (const field of allow) {
+        q.string(field).optional();
+      }
+      q.int(pageParam).optional().min(1);
+      q.int(limitParam).optional().min(1).max(maxLimit);
+      q.string(sortParam).optional();
+      q.string(fieldsParam).optional();
+    };
+    this.steps.push({
+      name: `autoFilter:${table}`,
+      fn: async (ctx, state) => {
+        if (!ctx.db) throw { status: 500, message: "Database not connected" };
+        const query = ctx.query;
+        const filters = {};
+        for (const field of allow) {
+          if (query[field] !== void 0) {
+            filters[field] = query[field];
+          }
+        }
+        let selectFields = "*";
+        const fieldsRaw = query[fieldsParam];
+        if (typeof fieldsRaw === "string") {
+          const parts = fieldsRaw.split(",").map((item) => item.trim()).filter((item) => selectAllow.includes(item));
+          if (parts.length > 0) {
+            selectFields = parts.join(", ");
+          }
+        }
+        let sortField = defaultSortSafe;
+        let sortDirection = defaultDirection;
+        const sortRaw = typeof query[sortParam] === "string" ? query[sortParam] : void 0;
+        if (sortRaw) {
+          let field = sortRaw;
+          let direction = defaultDirection;
+          if (sortRaw.includes(":")) {
+            const [f, d] = sortRaw.split(":");
+            field = f;
+            direction = d?.toLowerCase() === "desc" ? "DESC" : "ASC";
+          } else if (sortRaw.endsWith("_desc")) {
+            field = sortRaw.replace("_desc", "");
+            direction = "DESC";
+          } else if (sortRaw.endsWith("_asc")) {
+            field = sortRaw.replace("_asc", "");
+            direction = "ASC";
+          }
+          if (sortAllow.includes(field)) {
+            sortField = field;
+            sortDirection = direction;
+          }
+        }
+        let limit;
+        if (typeof query[limitParam] === "number") {
+          limit = query[limitParam];
+        } else if (typeof query[limitParam] === "string") {
+          const parsed = Number.parseInt(query[limitParam], 10);
+          if (!Number.isNaN(parsed)) limit = parsed;
+        }
+        if (limit !== void 0) {
+          limit = Math.min(Math.max(limit, 1), maxLimit);
+        }
+        let page = typeof query[pageParam] === "number" ? query[pageParam] : 1;
+        if (typeof query[pageParam] === "string") {
+          const parsed = Number.parseInt(query[pageParam], 10);
+          if (!Number.isNaN(parsed)) page = parsed;
+        }
+        if (!page || page < 1) page = 1;
+        let sql = `SELECT ${selectFields} FROM ${table}`;
+        const conditions = [];
+        const params = [];
+        for (const [key, value] of Object.entries(filters)) {
+          if (Array.isArray(value)) {
+            const offset = params.length;
+            for (const item of value) {
+              params.push(item);
+            }
+            const placeholdersFixed = value.map((_, idx) => `$${offset + idx + 1}`).join(", ");
+            conditions.push(`${key} IN (${placeholdersFixed})`);
+          } else {
+            params.push(value);
+            conditions.push(`${key} = $${params.length}`);
+          }
+        }
+        if (conditions.length > 0) {
+          sql += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        if (sortField) {
+          sql += ` ORDER BY ${sortField} ${sortDirection}`;
+        }
+        if (limit !== void 0) {
+          params.push(limit);
+          sql += ` LIMIT $${params.length}`;
+        }
+        if (limit !== void 0) {
+          const offset = (page - 1) * limit;
+          params.push(offset);
+          sql += ` OFFSET $${params.length}`;
+        }
+        const res = await ctx.db.queryWithParams(sql, params);
+        const rows = JSON.parse(res);
+        return {
+          data: rows,
+          meta: {
+            page,
+            limit,
+            sort: { field: sortField, direction: sortDirection },
+            filters
+          }
+        };
+      }
+    });
+    return this;
+  }
+  // Database List (Select with filter)
+  list(table, options = {}) {
+    this.steps.push({
+      name: `list:${table}`,
+      fn: async (ctx, state) => {
+        if (!ctx.db) throw { status: 500, message: "Database not connected" };
+        const fields = state._query_select ? state._query_select.join(", ") : "*";
+        let sql = `SELECT ${fields} FROM ${table}`;
+        const conditions = [];
+        const params = [];
+        if (options.where) {
+          for (const [key, valRef] of Object.entries(options.where)) {
+            let val;
+            if (valRef.startsWith("@")) {
+              const path = valRef.substring(1).split(".");
+              val = path.reduce((acc, part) => acc && acc[part], state);
+            } else {
+              val = valRef;
+            }
+            if (val === void 0) continue;
+            conditions.push(`${key} = $${params.length + 1}`);
+            params.push(val);
+          }
+        }
+        if (conditions.length > 0) {
+          sql += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        if (state._query_sort) {
+          sql += ` ORDER BY ${state._query_sort.field} ${state._query_sort.direction}`;
+        } else {
+          sql += " ORDER BY id DESC";
+        }
+        const limit = options.limit || state._query_paginate?.limit;
+        if (limit) {
+          sql += ` LIMIT ${limit}`;
+        }
+        if (state._query_paginate?.page && limit) {
+          const offset = (state._query_paginate.page - 1) * limit;
+          sql += ` OFFSET ${offset}`;
+        }
+        const res = await ctx.db.queryWithParams(sql, params);
+        return JSON.parse(res);
+      }
+    });
+    return this;
+  }
+  // Database Update
+  update(table, options) {
+    this.steps.push({
+      name: `update:${table}`,
+      fn: async (ctx, state) => {
+        if (!ctx.db) throw { status: 500, message: "Database not connected" };
+        const body = ctx.req.json();
+        const params = [];
+        const updates = [];
+        for (const [key, val] of Object.entries(body)) {
+          if (key === "id") continue;
+          if (options.fields && !options.fields.includes(key)) continue;
+          updates.push(`${key} = $${params.length + 1}`);
+          params.push(val);
+        }
+        if (updates.length === 0) return state;
+        const conditions = [];
+        for (const [key, valRef] of Object.entries(options.where)) {
+          let val;
+          if (valRef.startsWith("@")) {
+            const path = valRef.substring(1).split(".");
+            val = path.reduce((acc, part) => acc && acc[part], state);
+          } else if (valRef.startsWith(":")) {
+            val = ctx.req.param(valRef.substring(1));
+          } else {
+            val = valRef;
+          }
+          if (val === void 0) throw { status: 400, message: `Missing value for ${key}` };
+          conditions.push(`${key} = $${params.length + 1}`);
+          params.push(val);
+        }
+        const sql = `UPDATE ${table} SET ${updates.join(", ")} WHERE ${conditions.join(" AND ")} RETURNING *`;
+        const res = await ctx.db.queryWithParams(sql, params);
+        const rows = JSON.parse(res);
+        if (rows.length === 0) throw { status: 404, message: "Resource not found" };
+        return rows[0];
+      }
+    });
+    return this;
+  }
+  // Database Soft Delete
+  softDelete(table, options) {
+    this.steps.push({
+      name: `softDelete:${table}`,
+      fn: async (ctx, state) => {
+        if (!ctx.db) throw { status: 500, message: "Database not connected" };
+        const conditions = [];
+        const params = [];
+        for (const [key, valRef] of Object.entries(options.where)) {
+          let val;
+          if (valRef.startsWith("@")) {
+            const path = valRef.substring(1).split(".");
+            val = path.reduce((acc, part) => acc && acc[part], state);
+          } else if (valRef.startsWith(":")) {
+            val = ctx.req.param(valRef.substring(1));
+          } else {
+            val = valRef;
+          }
+          if (val === void 0) throw { status: 400, message: `Missing value for ${key}` };
+          conditions.push(`${key} = $${params.length + 1}`);
+          params.push(val);
+        }
+        const sql = `UPDATE ${table} SET deleted_at = NOW() WHERE ${conditions.join(" AND ")} RETURNING *`;
+        const res = await ctx.db.queryWithParams(sql, params);
+        const rows = JSON.parse(res);
+        if (rows.length === 0) throw { status: 404, message: "Resource not found" };
+        return { success: true, deleted: rows[0] };
+      }
+    });
+    return this;
+  }
+  // Database Delete
+  delete(table, options) {
+    this.steps.push({
+      name: `delete:${table}`,
+      fn: async (ctx, state) => {
+        if (!ctx.db) throw { status: 500, message: "Database not connected" };
+        const conditions = [];
+        const params = [];
+        for (const [key, valRef] of Object.entries(options.where)) {
+          let val;
+          if (valRef.startsWith("@")) {
+            const path = valRef.substring(1).split(".");
+            val = path.reduce((acc, part) => acc && acc[part], state);
+          } else if (valRef.startsWith(":")) {
+            val = ctx.req.param(valRef.substring(1));
+          } else {
+            val = valRef;
+          }
+          if (val === void 0) throw { status: 400, message: `Missing value for ${key}` };
+          conditions.push(`${key} = $${params.length + 1}`);
+          params.push(val);
+        }
+        const sql = `DELETE FROM ${table} WHERE ${conditions.join(" AND ")} RETURNING *`;
+        const res = await ctx.db.queryWithParams(sql, params);
+        const rows = JSON.parse(res);
+        if (rows.length === 0) throw { status: 404, message: "Resource not found" };
+        return { success: true, deleted: rows[0] };
+      }
+    });
+    return this;
+  }
+};
+
+// src/index.ts
+loadEnv();
+var Q = class {
+  static env = env;
+  static loadEnv = loadEnv;
+  static app(config) {
+    return new App(config);
+  }
+  static schema(def) {
+    const properties = {};
+    for (const key in def) {
+      if (def[key] && typeof def[key].toJSON === "function") {
+        properties[key] = def[key].toJSON();
+      } else {
+        properties[key] = def[key];
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: Object.keys(properties)
+    };
+  }
+  static string() {
+    return new SchemaBuilder("string");
+  }
+  static int() {
+    return new SchemaBuilder("integer");
+  }
+  static email() {
+    return new SchemaBuilder("string").format("email");
+  }
+  static enum(...values) {
+    return new SchemaBuilder("string").enum(values);
+  }
+};
+var SchemaBuilder = class {
+  def = {};
+  constructor(type) {
+    this.def.type = type;
+  }
+  min(val) {
+    if (this.def.type === "string") this.def.minLength = val;
+    else this.def.minimum = val;
+    return this;
+  }
+  max(val) {
+    if (this.def.type === "string") this.def.maxLength = val;
+    else this.def.maximum = val;
+    return this;
+  }
+  format(fmt) {
+    this.def.format = fmt;
+    return this;
+  }
+  enum(values) {
+    this.def.enum = values;
+    return this;
+  }
+  toJSON() {
+    return this.def;
+  }
+};
+var QuerySchemaBuilder = class {
+  schema = {};
+  string(name) {
+    return new QueryFieldBuilder(this.schema, name, "string");
+  }
+  int(name) {
+    return new QueryFieldBuilder(this.schema, name, "integer");
+  }
+  bool(name) {
+    return new QueryFieldBuilder(this.schema, name, "boolean");
+  }
+};
+var QueryFieldBuilder = class {
+  constructor(schema, name, type) {
+    this.schema = schema;
+    this.name = name;
+    this.type = type;
+    if (!this.schema[this.name]) {
+      this.schema[this.name] = { type: this.type };
+    }
+  }
+  default(val) {
+    this.schema[this.name].default = val;
+    return this;
+  }
+  optional() {
+    this.schema[this.name].optional = true;
+    return this;
+  }
+  max(val) {
+    this.schema[this.name].max = val;
+    return this;
+  }
+  min(val) {
+    this.schema[this.name].min = val;
+    return this;
+  }
+};
+var normalizeQuery = (schema, ctx) => {
+  const errors = [];
+  const normalized = { ...ctx.query };
+  const parseValue = (value, field) => {
+    if (field.type === "integer") {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isNaN(parsed)) {
+        return { ok: false, value };
+      }
+      return { ok: true, value: parsed };
+    }
+    if (field.type === "boolean") {
+      if (value === "true" || value === "1") return { ok: true, value: true };
+      if (value === "false" || value === "0") return { ok: true, value: false };
+      return { ok: false, value };
+    }
+    return { ok: true, value };
+  };
+  const enforceBounds = (value, field) => {
+    if (typeof value === "string") {
+      if (field.min !== void 0 && value.length < field.min) return false;
+      if (field.max !== void 0 && value.length > field.max) return false;
+    }
+    if (typeof value === "number") {
+      if (field.min !== void 0 && value < field.min) return false;
+      if (field.max !== void 0 && value > field.max) return false;
+    }
+    return true;
+  };
+  for (const [key, field] of Object.entries(schema)) {
+    const raw = ctx.query[key];
+    if (raw === void 0) {
+      if (field.default !== void 0) {
+        normalized[key] = field.default;
+        continue;
+      }
+      if (field.optional) {
+        delete normalized[key];
+        continue;
+      }
+      errors.push(`Missing query param: ${key}`);
+      continue;
+    }
+    if (Array.isArray(raw)) {
+      const parsedValues = [];
+      let ok = true;
+      for (const item of raw) {
+        const parsed2 = parseValue(item, field);
+        if (!parsed2.ok) {
+          ok = false;
+          break;
+        }
+        if (!enforceBounds(parsed2.value, field)) {
+          ok = false;
+          break;
+        }
+        parsedValues.push(parsed2.value);
+      }
+      if (!ok) {
+        errors.push(`Invalid query param: ${key}`);
+        continue;
+      }
+      normalized[key] = parsedValues;
+      continue;
+    }
+    const parsed = parseValue(raw, field);
+    if (!parsed.ok || !enforceBounds(parsed.value, field)) {
+      errors.push(`Invalid query param: ${key}`);
+      continue;
+    }
+    normalized[key] = parsed.value;
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return { ok: true, query: normalized };
+};
+var normalizeRoutePath = (path) => {
+  return path.replace(/:([A-Za-z0-9_]+)/g, "{$1}");
+};
+var App = class {
+  constructor(config) {
+    this.config = config;
+    this.db = {
+      connectPostgres: async (url) => {
+        if (!this.engine) throw new Error("Server not started");
+        await this.engine.connectPostgres(url);
+      },
+      connectSqlite: async (url) => {
+        if (!this.engine) throw new Error("Server not started");
+        await this.engine.connectSqlite(url);
+      },
+      connectRedis: (url) => {
+        if (!this.engine) throw new Error("Server not started");
+        this.engine.connectRedis(url);
+      },
+      connectMongo: async (url) => {
+        if (!this.engine) throw new Error("Server not started");
+        await this.engine.connectMongo(url);
+      },
+      query: async (sql, ttl) => {
+        if (!this.engine) throw new Error("Server not started");
+        return this.engine.queryDb(sql, ttl);
+      },
+      redis: {
+        set: async (key, value, ttl) => {
+          if (!this.engine) throw new Error("Server not started");
+          await this.engine.redisSet(key, value, ttl);
+        },
+        get: async (key) => {
+          if (!this.engine) throw new Error("Server not started");
+          return this.engine.redisGet(key);
+        }
+      },
+      mongo: (dbName, collName) => ({
+        find: async (query) => {
+          if (!this.engine) throw new Error("Server not started");
+          const json = await this.engine.queryMongo(dbName, collName, JSON.stringify(query));
+          return JSON.parse(json);
+        }
+      })
+    };
+    this.auth = {
+      setJwtSecret: (secret) => {
+        if (!this.engine) throw new Error("Server not started");
+        this.engine.setJwtSecret(secret);
+      }
+    };
+  }
+  engine = null;
+  routes = [];
+  handlers = /* @__PURE__ */ new Map();
+  handlerCounter = 0;
+  middlewares = [];
+  staticRoutes = /* @__PURE__ */ new Map();
+  // prefix -> dir
+  wsHandlers = /* @__PURE__ */ new Map();
+  activeSockets = /* @__PURE__ */ new Map();
+  corsConfig = null;
+  loggingEnabled = false;
+  errorHandler = null;
+  errorHooksRegistered = false;
+  shutdownHooksRegistered = false;
+  // Fluent API Entry Point
+  flow(method, path) {
+    return new FluentBuilder(this, method, path);
+  }
+  doc(path) {
+    this.get(`${path}/json`, (req) => {
+      const spec = this.generateOpenApiSpec();
+      return req.send(spec);
+    });
+    this.get(path, (req) => {
+      const html = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>API Documentation</title>
+    <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui.css" />
+</head>
+<body>
+<div id="swagger-ui"></div>
+<script src="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui-bundle.js" crossorigin></script>
+<script>
+    window.onload = () => {
+    window.ui = SwaggerUIBundle({
+        url: '${path}/json',
+        dom_id: '#swagger-ui',
+    });
+    };
+</script>
+</body>
+</html>`;
+      return req.html(html);
+    });
+    return this;
+  }
+  exportClient(outputPath) {
+    const code = generateClient(this.routes);
+    fs.writeFileSync(outputPath, code);
+    console.log(`\u2705 Generated Type-Safe Client at ${outputPath}`);
+  }
+  generateOpenApiSpec() {
+    const paths = {};
+    for (const route of this.routes) {
+      if (route.path.includes("/docs")) continue;
+      const specPath = normalizeRoutePath(route.path);
+      if (!paths[specPath]) paths[specPath] = {};
+      const method = route.method.toLowerCase();
+      const operation = {
+        responses: {
+          "200": { description: "Successful response" }
+        }
+      };
+      if (route.description) {
+        operation.summary = route.description;
+      }
+      if (route.options.schema) {
+        try {
+          const schema = typeof route.options.schema === "string" ? JSON.parse(route.options.schema) : route.options.schema;
+          operation.requestBody = {
+            content: {
+              "application/json": {
+                schema
+              }
+            }
+          };
+        } catch (e) {
+          console.warn(`Failed to parse schema for ${method} ${route.path}`);
+        }
+      }
+      if (route.options.query_schema) {
+        const params = [];
+        const querySchema = route.options.query_schema;
+        for (const [name, def] of Object.entries(querySchema)) {
+          params.push({
+            name,
+            in: "query",
+            required: !def.optional && def.default === void 0,
+            schema: {
+              type: def.type === "integer" ? "integer" : def.type === "boolean" ? "boolean" : "string",
+              minimum: def.min,
+              maximum: def.max
+            }
+          });
+        }
+        if (params.length > 0) {
+          operation.parameters = params;
+        }
+      }
+      if (route.options.response_schema) {
+        try {
+          const schema = typeof route.options.response_schema === "string" ? JSON.parse(route.options.response_schema) : route.options.response_schema;
+          operation.responses["200"] = {
+            description: "Successful response",
+            content: {
+              "application/json": { schema }
+            }
+          };
+        } catch (e) {
+          console.warn(`Failed to parse response schema for ${method} ${route.path}`);
+        }
+      }
+      if (route.options.jwt_auth) {
+        operation.security = [{ bearerAuth: [] }];
+      }
+      paths[specPath][method] = operation;
+    }
+    return {
+      openapi: "3.0.0",
+      info: {
+        title: "QHTTPX API",
+        version: "1.0.0"
+      },
+      components: {
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer",
+            bearerFormat: "JWT"
+          }
+        }
+      },
+      paths
+    };
+  }
+  // DB & Auth namespaces
+  enableLogging() {
+    this.engine?.initLogger();
+    this.loggingEnabled = true;
+    if (!process.env.RUST_LOG) {
+      process.env.RUST_LOG = "info";
+    }
+  }
+  getMetrics() {
+    if (!this.engine) throw new Error("Server not started");
+    return this.engine.getMetrics();
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  gracefulShutdown(signals = ["SIGINT", "SIGTERM"]) {
+    if (this.shutdownHooksRegistered) return this;
+    this.shutdownHooksRegistered = true;
+    for (const signal of signals) {
+      process.on(signal, () => {
+        this.stop();
+      });
+    }
+    return this;
+  }
+  security() {
+    if (this.engine) {
+      this.engine.setSecurityHeaders(true);
+    } else {
+      this.pendingSecurity = true;
+    }
+    return this;
+  }
+  pendingSecurity = false;
+  registerErrorHooks() {
+    if (this.errorHooksRegistered) return;
+    this.errorHooksRegistered = true;
+    process.on("unhandledRejection", (reason) => {
+      this.handleError(reason);
+    });
+    process.on("uncaughtException", (err) => {
+      this.handleError(err);
+    });
+  }
+  handleError(err, ctx) {
+    if (this.errorHandler) {
+      try {
+        this.errorHandler(err, ctx);
+        return;
+      } catch (handlerError) {
+        console.error("Error handler failed:", handlerError);
+      }
+    }
+    console.error("Unhandled error:", err);
+  }
+  db;
+  auth;
+  static(prefix, root) {
+    if (!prefix.startsWith("/")) prefix = "/" + prefix;
+    const absRoot = __require("path").resolve(root);
+    this.staticRoutes.set(prefix, absRoot);
+    return this;
+  }
+  use(fn) {
+    this.middlewares.push(fn);
+    return this;
+  }
+  ws(path, handler) {
+    if (!path.startsWith("/")) path = "/" + path;
+    this.wsHandlers.set(path, handler);
+  }
+  cors(config = {}) {
+    this.corsConfig = {
+      origin: config.origin || "*",
+      methods: (config.methods || ["GET", "POST", "PUT", "DELETE", "OPTIONS"]).join(", "),
+      headers: (config.headers || ["Content-Type", "Authorization"]).join(", "),
+      credentials: config.credentials || false
+    };
+    return this;
+  }
+  get(path, arg2, arg3) {
+    const fluentBuilder = new FluentBuilder(this, "GET", path);
+    if (arg3) {
+      const route = this.addRoute("GET", path);
+      route.options = arg2;
+      route.handler = arg3;
+    } else if (arg2) {
+      const route = this.addRoute("GET", path);
+      if (typeof arg2 === "function") {
+        route.handler = arg2;
+      } else if ("json" in arg2 || "text" in arg2 || "upload" in arg2) {
+        route.routeConfig = arg2;
+      } else {
+        route.options = arg2;
+      }
+    }
+    return fluentBuilder;
+  }
+  post(path, arg2, arg3) {
+    const fluentBuilder = new FluentBuilder(this, "POST", path);
+    if (arg3) {
+      const route = this.addRoute("POST", path);
+      route.options = arg2;
+      route.handler = arg3;
+    } else if (arg2) {
+      const route = this.addRoute("POST", path);
+      if (typeof arg2 === "function") {
+        route.handler = arg2;
+      } else if ("json" in arg2 || "text" in arg2 || "upload" in arg2) {
+        route.routeConfig = arg2;
+      } else {
+        route.options = arg2;
+      }
+    }
+    return fluentBuilder;
+  }
+  put(path, arg2, arg3) {
+    const fluentBuilder = new FluentBuilder(this, "PUT", path);
+    if (arg3) {
+      const route = this.addRoute("PUT", path);
+      route.options = arg2;
+      route.handler = arg3;
+    } else if (arg2) {
+      const route = this.addRoute("PUT", path);
+      if (typeof arg2 === "function") {
+        route.handler = arg2;
+      } else if ("json" in arg2 || "text" in arg2 || "upload" in arg2) {
+        route.routeConfig = arg2;
+      } else {
+        route.options = arg2;
+      }
+    }
+    return fluentBuilder;
+  }
+  delete(path, arg2, arg3) {
+    const fluentBuilder = new FluentBuilder(this, "DELETE", path);
+    if (arg3) {
+      const route = this.addRoute("DELETE", path);
+      route.options = arg2;
+      route.handler = arg3;
+    } else if (arg2) {
+      const route = this.addRoute("DELETE", path);
+      if (typeof arg2 === "function") {
+        route.handler = arg2;
+      } else if ("json" in arg2 || "text" in arg2 || "upload" in arg2) {
+        route.routeConfig = arg2;
+      } else {
+        route.options = arg2;
+      }
+    }
+    return fluentBuilder;
+  }
+  addRoute(method, path) {
+    const route = new Route(path, method, this);
+    this.routes.push(route);
+    return route;
+  }
+  registerHandler(handler, serializer) {
+    const id = ++this.handlerCounter;
+    this.handlers.set(id, { handler, serializer });
+    return id;
+  }
+  listen(portOrOptions, cb) {
+    let port;
+    let callback = cb;
+    let tls;
+    if (typeof portOrOptions === "object") {
+      port = portOrOptions.port;
+      callback = portOrOptions.callback || cb;
+      tls = portOrOptions.tls;
+    } else {
+      port = portOrOptions;
+    }
+    if (!this.engine) {
+      this.engine = new import_core.NativeEngine(port);
+      this.registerErrorHooks();
+      if (this.loggingEnabled || process.env.RUST_LOG) {
+        if (!process.env.RUST_LOG) process.env.RUST_LOG = "info";
+        this.engine.initLogger();
+      }
+      if (tls) {
+        this.engine.setTls(tls.cert, tls.key);
+      }
+      for (const [prefix, dir] of this.staticRoutes) {
+        this.engine.addStaticRoute(prefix, dir);
+      }
+      if (this.corsConfig) {
+        this.engine.setCors(
+          this.corsConfig.origin,
+          this.corsConfig.methods,
+          this.corsConfig.headers,
+          this.corsConfig.credentials
+        );
+      }
+      if (this.pendingSecurity) {
+        this.engine.setSecurityHeaders(true);
+      }
+    }
+    this.engine.setHandler((event) => {
+      const { handlerId, reqId, params, query, body, headers, url, responseHandle, method } = event;
+      const routeConfig = this.handlers.get(handlerId);
+      if (routeConfig) {
+        const { handler, serializer } = routeConfig;
+        const ctx = new Context(this.engine, reqId, params, query, body, headers, url, responseHandle, method, serializer);
+        const routeMiddleware = async (c, next) => {
+          const res = await handler(c);
+          if (res !== void 0) {
+            c.send(res);
+          }
+          await next();
+        };
+        const fn = compose([...this.middlewares, routeMiddleware]);
+        fn(ctx).catch((err) => {
+          this.handleError(err, ctx);
+          try {
+            ctx.status(500).send({ error: "Internal Server Error" });
+          } catch {
+          }
+        });
+      } else {
+        console.warn(`No handler found for ID ${handlerId}`);
+      }
+    });
+    this.engine.setWsHandler((event) => {
+      const { socketId, eventType, payload, path } = event;
+      if (eventType === "open") {
+        const handler = this.wsHandlers.get(path);
+        if (handler) {
+          this.activeSockets.set(socketId, { handler, path });
+          if (handler.open) {
+            const ws = {
+              send: (msg) => this.engine.wsSend(socketId, msg),
+              subscribe: (room) => this.engine.wsSubscribe(socketId, room),
+              unsubscribe: (room) => this.engine.wsUnsubscribe(socketId, room),
+              publish: (room, msg) => this.engine.wsPublish(room, msg)
+            };
+            handler.open(ws);
+          }
+        }
+      } else {
+        const ctx = this.activeSockets.get(socketId);
+        if (ctx) {
+          const { handler } = ctx;
+          const ws = {
+            send: (msg) => this.engine.wsSend(socketId, msg),
+            subscribe: (room) => this.engine.wsSubscribe(socketId, room),
+            unsubscribe: (room) => this.engine.wsUnsubscribe(socketId, room),
+            publish: (room, msg) => this.engine.wsPublish(room, msg)
+          };
+          if (eventType === "message") {
+            if (handler.message && payload) {
+              handler.message(ws, payload);
+            }
+          } else if (eventType === "close") {
+            if (handler.close) {
+              handler.close(ws);
+            }
+            this.activeSockets.delete(socketId);
+          }
+        }
+      }
+    });
+    for (const route of this.routes) {
+      const enginePath = normalizeRoutePath(route.path);
+      const options = route.options || {};
+      if (options.schema && typeof options.schema !== "string") {
+        options.schema = JSON.stringify(options.schema);
+      }
+      if (route.routeConfig) {
+        if (route.routeConfig.text) {
+          this.engine.registerStaticRoute(route.method, enginePath, route.routeConfig.text, "text/plain", options);
+        } else if (route.routeConfig.json) {
+          const content = typeof route.routeConfig.json === "string" ? route.routeConfig.json : JSON.stringify(route.routeConfig.json);
+          this.engine.registerJsonRoute(route.method, enginePath, content, options);
+        } else if (route.routeConfig.upload) {
+          let handlerId;
+          if (route.routeConfig.upload.handler) {
+            handlerId = this.registerHandler(route.routeConfig.upload.handler);
+          }
+          this.engine.registerUploadRoute(
+            route.method,
+            enginePath,
+            route.routeConfig.upload.dir,
+            handlerId,
+            options
+          );
+        }
+      } else if (route.handlerId) {
+        try {
+          this.engine.registerRoute(route.method, enginePath, route.handlerId, options);
+        } catch (e) {
+          console.error(`Failed to register route ${route.method} ${route.path}:`, e);
+        }
+      }
+    }
+    this.engine.start().then(() => {
+      if (cb) cb();
+    }).catch((err) => {
+      console.error("Native Engine crashed:", err);
+      process.exit(1);
+    });
+  }
+  stop() {
+    if (this.engine) {
+      try {
+        this.engine.stop();
+      } catch (e) {
+        console.error("Failed to stop engine:", e);
+      }
+    }
+  }
+};
+var Route = class {
+  constructor(path, method, app) {
+    this.path = path;
+    this.method = method;
+    this.app = app;
+  }
+  handlerId = null;
+  routeConfig;
+  options = {};
+  description;
+  middlewares = [];
+  handler;
+  serializer;
+  desc(description) {
+    this.description = description;
+    return this;
+  }
+  auth(strategy) {
+    return this;
+  }
+  jwt() {
+    this.options.jwt_auth = true;
+    return this;
+  }
+  cache(options) {
+    this.options.cache_ttl = options.ttl;
+    return this;
+  }
+  rateLimit(options) {
+    this.options.rate_limit_limit = options.limit;
+    this.options.rate_limit_window = options.window;
+    return this;
+  }
+  query(schemaBuilder) {
+    const builder = new QuerySchemaBuilder();
+    schemaBuilder(builder);
+    this.options.query_schema = builder.schema;
+    return this;
+  }
+  schema(def) {
+    this.options.schema = def;
+    return this;
+  }
+  priority(level) {
+    this.options.priority = level;
+    return this;
+  }
+  slo(targetMs) {
+    this.options.slo_target = targetMs;
+    return this;
+  }
+  responseSchema(def) {
+    try {
+      this.serializer = fastJson(def);
+      this.options.response_schema = def;
+    } catch (e) {
+      console.error(`Failed to compile response schema for ${this.method} ${this.path}:`, e);
+    }
+    return this;
+  }
+  respond(handler) {
+    if (typeof handler === "object" && handler !== null && ("text" in handler || "json" in handler || "upload" in handler)) {
+      this.routeConfig = handler;
+    } else {
+      const original = handler;
+      const wrapped = async (ctx) => {
+        if (this.options.query_schema) {
+          const result = normalizeQuery(this.options.query_schema, ctx);
+          if (!result.ok) {
+            const errors = "errors" in result && result.errors ? result.errors : [];
+            ctx.status(400).send({ error: errors.join(", ") });
+            return;
+          }
+          ctx._query = result.query;
+        }
+        return original(ctx);
+      };
+      this.handlerId = this.app.registerHandler(wrapped, this.serializer);
+    }
+  }
+};
+export {
+  FluentBuilder,
+  Q,
+  TestClient,
+  createTestClient
+};