fix update

apps/backend-mock/.nitro/dev/index.mjs

@@ -0,0 +1,2235 @@
+import process from 'node:process';globalThis._importMeta_={url:import.meta.url,env:process.env};import { tmpdir } from 'node:os';
+import destr from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/destr@2.0.5/node_modules/destr/dist/index.mjs';
+import { defineEventHandler, handleCacheHeaders, splitCookiesString, createEvent, fetchWithEvent, isEvent, eventHandler, setHeaders, sendRedirect, proxyRequest, getRequestURL, getRequestHeader, getResponseHeader, getRequestHeaders, setResponseHeaders, setResponseStatus, send, createApp, createRouter as createRouter$1, toNodeListener, lazyEventHandler, createError, getRouterParam, readBody, getQuery as getQuery$1, getHeader, deleteCookie, setCookie, getCookie, setHeader } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/h3@1.15.3/node_modules/h3/dist/index.mjs';
+import { createHooks } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/hookable@5.5.3/node_modules/hookable/dist/index.mjs';
+import { createFetch, Headers as Headers$1 } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/ofetch@1.4.1/node_modules/ofetch/dist/node.mjs';
+import { fetchNodeRequestHandler, callNodeRequestHandler } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/node-mock-http@1.0.1/node_modules/node-mock-http/dist/index.mjs';
+import { parseURL, withoutBase, joinURL, getQuery, withQuery } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/ufo@1.6.1/node_modules/ufo/dist/index.mjs';
+import { createStorage, prefixStorage } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/unstorage@1.16.0_@netlify+blobs@8.2.0_db0@0.3.2_ioredis@5.6.1/node_modules/unstorage/dist/index.mjs';
+import unstorage_47drivers_47fs from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/unstorage@1.16.0_@netlify+blobs@8.2.0_db0@0.3.2_ioredis@5.6.1/node_modules/unstorage/drivers/fs.mjs';
+import { digest } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/index.mjs';
+import { klona } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/klona@2.0.6/node_modules/klona/dist/index.mjs';
+import defu, { defuFn } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs';
+import { snakeCase } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/scule@1.3.0/node_modules/scule/dist/index.mjs';
+import { getContext } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/unctx@2.4.1/node_modules/unctx/dist/index.mjs';
+import { toRouteMatcher, createRouter } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/radix3@1.1.2/node_modules/radix3/dist/index.mjs';
+import { readFile } from 'node:fs/promises';
+import { resolve, dirname, join } from 'node:path';
+import consola from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/index.mjs';
+import { ErrorParser } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/youch-core@0.3.2/node_modules/youch-core/build/index.js';
+import { Youch } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/youch@4.1.0-beta.8/node_modules/youch/build/index.js';
+import { SourceMapConsumer } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/source-map@0.7.4/node_modules/source-map/source-map.js';
+import { Server } from 'node:http';
+import nodeCrypto from 'node:crypto';
+import { parentPort, threadId } from 'node:worker_threads';
+import { faker } from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/@faker-js+faker@9.9.0/node_modules/@faker-js/faker/dist/index.js';
+import jwt from 'file:///Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/node_modules/.pnpm/jsonwebtoken@9.0.2/node_modules/jsonwebtoken/index.js';
+
+const serverAssets = [{"baseName":"server","dir":"/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock/assets"}];
+
+const assets = createStorage();
+
+for (const asset of serverAssets) {
+  assets.mount(asset.baseName, unstorage_47drivers_47fs({ base: asset.dir, ignore: (asset?.ignore || []) }));
+}
+
+const storage = createStorage({});
+
+storage.mount('/assets', assets);
+
+storage.mount('root', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock"}));
+storage.mount('src', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock"}));
+storage.mount('build', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock/.nitro"}));
+storage.mount('cache', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock/.nitro/cache"}));
+storage.mount('data', unstorage_47drivers_47fs({"driver":"fs","base":"/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock/.data/kv"}));
+
+function useStorage(base = "") {
+  return base ? prefixStorage(storage, base) : storage;
+}
+
+const Hasher = /* @__PURE__ */ (() => {
+  class Hasher2 {
+    buff = "";
+    #context = /* @__PURE__ */ new Map();
+    write(str) {
+      this.buff += str;
+    }
+    dispatch(value) {
+      const type = value === null ? "null" : typeof value;
+      return this[type](value);
+    }
+    object(object) {
+      if (object && typeof object.toJSON === "function") {
+        return this.object(object.toJSON());
+      }
+      const objString = Object.prototype.toString.call(object);
+      let objType = "";
+      const objectLength = objString.length;
+      objType = objectLength < 10 ? "unknown:[" + objString + "]" : objString.slice(8, objectLength - 1);
+      objType = objType.toLowerCase();
+      let objectNumber = null;
+      if ((objectNumber = this.#context.get(object)) === void 0) {
+        this.#context.set(object, this.#context.size);
+      } else {
+        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+        this.write("buffer:");
+        return this.write(object.toString("utf8"));
+      }
+      if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+        if (this[objType]) {
+          this[objType](object);
+        } else {
+          this.unknown(object, objType);
+        }
+      } else {
+        const keys = Object.keys(object).sort();
+        const extraKeys = [];
+        this.write("object:" + (keys.length + extraKeys.length) + ":");
+        const dispatchForKey = (key) => {
+          this.dispatch(key);
+          this.write(":");
+          this.dispatch(object[key]);
+          this.write(",");
+        };
+        for (const key of keys) {
+          dispatchForKey(key);
+        }
+        for (const key of extraKeys) {
+          dispatchForKey(key);
+        }
+      }
+    }
+    array(arr, unordered) {
+      unordered = unordered === void 0 ? false : unordered;
+      this.write("array:" + arr.length + ":");
+      if (!unordered || arr.length <= 1) {
+        for (const entry of arr) {
+          this.dispatch(entry);
+        }
+        return;
+      }
+      const contextAdditions = /* @__PURE__ */ new Map();
+      const entries = arr.map((entry) => {
+        const hasher = new Hasher2();
+        hasher.dispatch(entry);
+        for (const [key, value] of hasher.#context) {
+          contextAdditions.set(key, value);
+        }
+        return hasher.toString();
+      });
+      this.#context = contextAdditions;
+      entries.sort();
+      return this.array(entries, false);
+    }
+    date(date) {
+      return this.write("date:" + date.toJSON());
+    }
+    symbol(sym) {
+      return this.write("symbol:" + sym.toString());
+    }
+    unknown(value, type) {
+      this.write(type);
+      if (!value) {
+        return;
+      }
+      this.write(":");
+      if (value && typeof value.entries === "function") {
+        return this.array(
+          [...value.entries()],
+          true
+          /* ordered */
+        );
+      }
+    }
+    error(err) {
+      return this.write("error:" + err.toString());
+    }
+    boolean(bool) {
+      return this.write("bool:" + bool);
+    }
+    string(string) {
+      this.write("string:" + string.length + ":");
+      this.write(string);
+    }
+    function(fn) {
+      this.write("fn:");
+      if (isNativeFunction(fn)) {
+        this.dispatch("[native]");
+      } else {
+        this.dispatch(fn.toString());
+      }
+    }
+    number(number) {
+      return this.write("number:" + number);
+    }
+    null() {
+      return this.write("Null");
+    }
+    undefined() {
+      return this.write("Undefined");
+    }
+    regexp(regex) {
+      return this.write("regex:" + regex.toString());
+    }
+    arraybuffer(arr) {
+      this.write("arraybuffer:");
+      return this.dispatch(new Uint8Array(arr));
+    }
+    url(url) {
+      return this.write("url:" + url.toString());
+    }
+    map(map) {
+      this.write("map:");
+      const arr = [...map];
+      return this.array(arr, false);
+    }
+    set(set) {
+      this.write("set:");
+      const arr = [...set];
+      return this.array(arr, false);
+    }
+    bigint(number) {
+      return this.write("bigint:" + number.toString());
+    }
+  }
+  for (const type of [
+    "uint8array",
+    "uint8clampedarray",
+    "unt8array",
+    "uint16array",
+    "unt16array",
+    "uint32array",
+    "unt32array",
+    "float32array",
+    "float64array"
+  ]) {
+    Hasher2.prototype[type] = function(arr) {
+      this.write(type + ":");
+      return this.array([...arr], false);
+    };
+  }
+  function isNativeFunction(f) {
+    if (typeof f !== "function") {
+      return false;
+    }
+    return Function.prototype.toString.call(f).slice(
+      -15
+      /* "[native code] }".length */
+    ) === "[native code] }";
+  }
+  return Hasher2;
+})();
+function serialize(object) {
+  const hasher = new Hasher();
+  hasher.dispatch(object);
+  return hasher.buff;
+}
+function hash(value) {
+  return digest(typeof value === "string" ? value : serialize(value)).replace(/[-_]/g, "").slice(0, 10);
+}
+
+function defaultCacheOptions() {
+  return {
+    name: "_",
+    base: "/cache",
+    swr: true,
+    maxAge: 1
+  };
+}
+function defineCachedFunction(fn, opts = {}) {
+  opts = { ...defaultCacheOptions(), ...opts };
+  const pending = {};
+  const group = opts.group || "nitro/functions";
+  const name = opts.name || fn.name || "_";
+  const integrity = opts.integrity || hash([fn, opts]);
+  const validate = opts.validate || ((entry) => entry.value !== void 0);
+  async function get(key, resolver, shouldInvalidateCache, event) {
+    const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index");
+    let entry = await useStorage().getItem(cacheKey).catch((error) => {
+      console.error(`[cache] Cache read error.`, error);
+      useNitroApp().captureError(error, { event, tags: ["cache"] });
+    }) || {};
+    if (typeof entry !== "object") {
+      entry = {};
+      const error = new Error("Malformed data read from cache.");
+      console.error("[cache]", error);
+      useNitroApp().captureError(error, { event, tags: ["cache"] });
+    }
+    const ttl = (opts.maxAge ?? 0) * 1e3;
+    if (ttl) {
+      entry.expires = Date.now() + ttl;
+    }
+    const expired = shouldInvalidateCache || entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || validate(entry) === false;
+    const _resolve = async () => {
+      const isPending = pending[key];
+      if (!isPending) {
+        if (entry.value !== void 0 && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) {
+          entry.value = void 0;
+          entry.integrity = void 0;
+          entry.mtime = void 0;
+          entry.expires = void 0;
+        }
+        pending[key] = Promise.resolve(resolver());
+      }
+      try {
+        entry.value = await pending[key];
+      } catch (error) {
+        if (!isPending) {
+          delete pending[key];
+        }
+        throw error;
+      }
+      if (!isPending) {
+        entry.mtime = Date.now();
+        entry.integrity = integrity;
+        delete pending[key];
+        if (validate(entry) !== false) {
+          let setOpts;
+          if (opts.maxAge && !opts.swr) {
+            setOpts = { ttl: opts.maxAge };
+          }
+          const promise = useStorage().setItem(cacheKey, entry, setOpts).catch((error) => {
+            console.error(`[cache] Cache write error.`, error);
+            useNitroApp().captureError(error, { event, tags: ["cache"] });
+          });
+          if (event?.waitUntil) {
+            event.waitUntil(promise);
+          }
+        }
+      }
+    };
+    const _resolvePromise = expired ? _resolve() : Promise.resolve();
+    if (entry.value === void 0) {
+      await _resolvePromise;
+    } else if (expired && event && event.waitUntil) {
+      event.waitUntil(_resolvePromise);
+    }
+    if (opts.swr && validate(entry) !== false) {
+      _resolvePromise.catch((error) => {
+        console.error(`[cache] SWR handler error.`, error);
+        useNitroApp().captureError(error, { event, tags: ["cache"] });
+      });
+      return entry;
+    }
+    return _resolvePromise.then(() => entry);
+  }
+  return async (...args) => {
+    const shouldBypassCache = await opts.shouldBypassCache?.(...args);
+    if (shouldBypassCache) {
+      return fn(...args);
+    }
+    const key = await (opts.getKey || getKey)(...args);
+    const shouldInvalidateCache = await opts.shouldInvalidateCache?.(...args);
+    const entry = await get(
+      key,
+      () => fn(...args),
+      shouldInvalidateCache,
+      args[0] && isEvent(args[0]) ? args[0] : void 0
+    );
+    let value = entry.value;
+    if (opts.transform) {
+      value = await opts.transform(entry, ...args) || value;
+    }
+    return value;
+  };
+}
+function cachedFunction(fn, opts = {}) {
+  return defineCachedFunction(fn, opts);
+}
+function getKey(...args) {
+  return args.length > 0 ? hash(args) : "";
+}
+function escapeKey(key) {
+  return String(key).replace(/\W/g, "");
+}
+function defineCachedEventHandler(handler, opts = defaultCacheOptions()) {
+  const variableHeaderNames = (opts.varies || []).filter(Boolean).map((h) => h.toLowerCase()).sort();
+  const _opts = {
+    ...opts,
+    getKey: async (event) => {
+      const customKey = await opts.getKey?.(event);
+      if (customKey) {
+        return escapeKey(customKey);
+      }
+      const _path = event.node.req.originalUrl || event.node.req.url || event.path;
+      let _pathname;
+      try {
+        _pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index";
+      } catch {
+        _pathname = "-";
+      }
+      const _hashedPath = `${_pathname}.${hash(_path)}`;
+      const _headers = variableHeaderNames.map((header) => [header, event.node.req.headers[header]]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`);
+      return [_hashedPath, ..._headers].join(":");
+    },
+    validate: (entry) => {
+      if (!entry.value) {
+        return false;
+      }
+      if (entry.value.code >= 400) {
+        return false;
+      }
+      if (entry.value.body === void 0) {
+        return false;
+      }
+      if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
+        return false;
+      }
+      return true;
+    },
+    group: opts.group || "nitro/handlers",
+    integrity: opts.integrity || hash([handler, opts])
+  };
+  const _cachedHandler = cachedFunction(
+    async (incomingEvent) => {
+      const variableHeaders = {};
+      for (const header of variableHeaderNames) {
+        const value = incomingEvent.node.req.headers[header];
+        if (value !== void 0) {
+          variableHeaders[header] = value;
+        }
+      }
+      const reqProxy = cloneWithProxy(incomingEvent.node.req, {
+        headers: variableHeaders
+      });
+      const resHeaders = {};
+      let _resSendBody;
+      const resProxy = cloneWithProxy(incomingEvent.node.res, {
+        statusCode: 200,
+        writableEnded: false,
+        writableFinished: false,
+        headersSent: false,
+        closed: false,
+        getHeader(name) {
+          return resHeaders[name];
+        },
+        setHeader(name, value) {
+          resHeaders[name] = value;
+          return this;
+        },
+        getHeaderNames() {
+          return Object.keys(resHeaders);
+        },
+        hasHeader(name) {
+          return name in resHeaders;
+        },
+        removeHeader(name) {
+          delete resHeaders[name];
+        },
+        getHeaders() {
+          return resHeaders;
+        },
+        end(chunk, arg2, arg3) {
+          if (typeof chunk === "string") {
+            _resSendBody = chunk;
+          }
+          if (typeof arg2 === "function") {
+            arg2();
+          }
+          if (typeof arg3 === "function") {
+            arg3();
+          }
+          return this;
+        },
+        write(chunk, arg2, arg3) {
+          if (typeof chunk === "string") {
+            _resSendBody = chunk;
+          }
+          if (typeof arg2 === "function") {
+            arg2(void 0);
+          }
+          if (typeof arg3 === "function") {
+            arg3();
+          }
+          return true;
+        },
+        writeHead(statusCode, headers2) {
+          this.statusCode = statusCode;
+          if (headers2) {
+            if (Array.isArray(headers2) || typeof headers2 === "string") {
+              throw new TypeError("Raw headers  is not supported.");
+            }
+            for (const header in headers2) {
+              const value = headers2[header];
+              if (value !== void 0) {
+                this.setHeader(
+                  header,
+                  value
+                );
+              }
+            }
+          }
+          return this;
+        }
+      });
+      const event = createEvent(reqProxy, resProxy);
+      event.fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
+        fetch: useNitroApp().localFetch
+      });
+      event.$fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
+        fetch: globalThis.$fetch
+      });
+      event.waitUntil = incomingEvent.waitUntil;
+      event.context = incomingEvent.context;
+      event.context.cache = {
+        options: _opts
+      };
+      const body = await handler(event) || _resSendBody;
+      const headers = event.node.res.getHeaders();
+      headers.etag = String(
+        headers.Etag || headers.etag || `W/"${hash(body)}"`
+      );
+      headers["last-modified"] = String(
+        headers["Last-Modified"] || headers["last-modified"] || (/* @__PURE__ */ new Date()).toUTCString()
+      );
+      const cacheControl = [];
+      if (opts.swr) {
+        if (opts.maxAge) {
+          cacheControl.push(`s-maxage=${opts.maxAge}`);
+        }
+        if (opts.staleMaxAge) {
+          cacheControl.push(`stale-while-revalidate=${opts.staleMaxAge}`);
+        } else {
+          cacheControl.push("stale-while-revalidate");
+        }
+      } else if (opts.maxAge) {
+        cacheControl.push(`max-age=${opts.maxAge}`);
+      }
+      if (cacheControl.length > 0) {
+        headers["cache-control"] = cacheControl.join(", ");
+      }
+      const cacheEntry = {
+        code: event.node.res.statusCode,
+        headers,
+        body
+      };
+      return cacheEntry;
+    },
+    _opts
+  );
+  return defineEventHandler(async (event) => {
+    if (opts.headersOnly) {
+      if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
+        return;
+      }
+      return handler(event);
+    }
+    const response = await _cachedHandler(
+      event
+    );
+    if (event.node.res.headersSent || event.node.res.writableEnded) {
+      return response.body;
+    }
+    if (handleCacheHeaders(event, {
+      modifiedTime: new Date(response.headers["last-modified"]),
+      etag: response.headers.etag,
+      maxAge: opts.maxAge
+    })) {
+      return;
+    }
+    event.node.res.statusCode = response.code;
+    for (const name in response.headers) {
+      const value = response.headers[name];
+      if (name === "set-cookie") {
+        event.node.res.appendHeader(
+          name,
+          splitCookiesString(value)
+        );
+      } else {
+        if (value !== void 0) {
+          event.node.res.setHeader(name, value);
+        }
+      }
+    }
+    return response.body;
+  });
+}
+function cloneWithProxy(obj, overrides) {
+  return new Proxy(obj, {
+    get(target, property, receiver) {
+      if (property in overrides) {
+        return overrides[property];
+      }
+      return Reflect.get(target, property, receiver);
+    },
+    set(target, property, value, receiver) {
+      if (property in overrides) {
+        overrides[property] = value;
+        return true;
+      }
+      return Reflect.set(target, property, value, receiver);
+    }
+  });
+}
+const cachedEventHandler = defineCachedEventHandler;
+
+const inlineAppConfig = {};
+
+
+
+const appConfig = defuFn(inlineAppConfig);
+
+function getEnv(key, opts) {
+  const envKey = snakeCase(key).toUpperCase();
+  return destr(
+    process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey]
+  );
+}
+function _isObject(input) {
+  return typeof input === "object" && !Array.isArray(input);
+}
+function applyEnv(obj, opts, parentKey = "") {
+  for (const key in obj) {
+    const subKey = parentKey ? `${parentKey}_${key}` : key;
+    const envValue = getEnv(subKey, opts);
+    if (_isObject(obj[key])) {
+      if (_isObject(envValue)) {
+        obj[key] = { ...obj[key], ...envValue };
+        applyEnv(obj[key], opts, subKey);
+      } else if (envValue === void 0) {
+        applyEnv(obj[key], opts, subKey);
+      } else {
+        obj[key] = envValue ?? obj[key];
+      }
+    } else {
+      obj[key] = envValue ?? obj[key];
+    }
+    if (opts.envExpansion && typeof obj[key] === "string") {
+      obj[key] = _expandFromEnv(obj[key]);
+    }
+  }
+  return obj;
+}
+const envExpandRx = /\{\{([^{}]*)\}\}/g;
+function _expandFromEnv(value) {
+  return value.replace(envExpandRx, (match, key) => {
+    return process.env[key] || match;
+  });
+}
+
+const _inlineRuntimeConfig = {
+  "app": {
+    "baseURL": "/"
+  },
+  "nitro": {
+    "routeRules": {
+      "/api/**": {
+        "cors": true,
+        "headers": {
+          "access-control-allow-origin": "*",
+          "access-control-allow-methods": "*",
+          "access-control-allow-headers": "*",
+          "access-control-max-age": "0",
+          "Access-Control-Allow-Credentials": "true",
+          "Access-Control-Allow-Headers": "Accept, Authorization, Content-Length, Content-Type, If-Match, If-Modified-Since, If-None-Match, If-Unmodified-Since, X-CSRF-TOKEN, X-Requested-With",
+          "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Expose-Headers": "*"
+        }
+      }
+    }
+  }
+};
+const envOptions = {
+  prefix: "NITRO_",
+  altPrefix: _inlineRuntimeConfig.nitro.envPrefix ?? process.env.NITRO_ENV_PREFIX ?? "_",
+  envExpansion: _inlineRuntimeConfig.nitro.envExpansion ?? process.env.NITRO_ENV_EXPANSION ?? false
+};
+const _sharedRuntimeConfig = _deepFreeze(
+  applyEnv(klona(_inlineRuntimeConfig), envOptions)
+);
+function useRuntimeConfig(event) {
+  {
+    return _sharedRuntimeConfig;
+  }
+}
+_deepFreeze(klona(appConfig));
+function _deepFreeze(object) {
+  const propNames = Object.getOwnPropertyNames(object);
+  for (const name of propNames) {
+    const value = object[name];
+    if (value && typeof value === "object") {
+      _deepFreeze(value);
+    }
+  }
+  return Object.freeze(object);
+}
+new Proxy(/* @__PURE__ */ Object.create(null), {
+  get: (_, prop) => {
+    console.warn(
+      "Please use `useRuntimeConfig()` instead of accessing config directly."
+    );
+    const runtimeConfig = useRuntimeConfig();
+    if (prop in runtimeConfig) {
+      return runtimeConfig[prop];
+    }
+    return void 0;
+  }
+});
+
+getContext("nitro-app", {
+  asyncContext: undefined,
+  AsyncLocalStorage: void 0
+});
+
+const config = useRuntimeConfig();
+const _routeRulesMatcher = toRouteMatcher(
+  createRouter({ routes: config.nitro.routeRules })
+);
+function createRouteRulesHandler(ctx) {
+  return eventHandler((event) => {
+    const routeRules = getRouteRules(event);
+    if (routeRules.headers) {
+      setHeaders(event, routeRules.headers);
+    }
+    if (routeRules.redirect) {
+      let target = routeRules.redirect.to;
+      if (target.endsWith("/**")) {
+        let targetPath = event.path;
+        const strpBase = routeRules.redirect._redirectStripBase;
+        if (strpBase) {
+          targetPath = withoutBase(targetPath, strpBase);
+        }
+        target = joinURL(target.slice(0, -3), targetPath);
+      } else if (event.path.includes("?")) {
+        const query = getQuery(event.path);
+        target = withQuery(target, query);
+      }
+      return sendRedirect(event, target, routeRules.redirect.statusCode);
+    }
+    if (routeRules.proxy) {
+      let target = routeRules.proxy.to;
+      if (target.endsWith("/**")) {
+        let targetPath = event.path;
+        const strpBase = routeRules.proxy._proxyStripBase;
+        if (strpBase) {
+          targetPath = withoutBase(targetPath, strpBase);
+        }
+        target = joinURL(target.slice(0, -3), targetPath);
+      } else if (event.path.includes("?")) {
+        const query = getQuery(event.path);
+        target = withQuery(target, query);
+      }
+      return proxyRequest(event, target, {
+        fetch: ctx.localFetch,
+        ...routeRules.proxy
+      });
+    }
+  });
+}
+function getRouteRules(event) {
+  event.context._nitro = event.context._nitro || {};
+  if (!event.context._nitro.routeRules) {
+    event.context._nitro.routeRules = getRouteRulesForPath(
+      withoutBase(event.path.split("?")[0], useRuntimeConfig().app.baseURL)
+    );
+  }
+  return event.context._nitro.routeRules;
+}
+function getRouteRulesForPath(path) {
+  return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
+}
+
+function _captureError(error, type) {
+  console.error(`[${type}]`, error);
+  useNitroApp().captureError(error, { tags: [type] });
+}
+function trapUnhandledNodeErrors() {
+  process.on(
+    "unhandledRejection",
+    (error) => _captureError(error, "unhandledRejection")
+  );
+  process.on(
+    "uncaughtException",
+    (error) => _captureError(error, "uncaughtException")
+  );
+}
+function joinHeaders(value) {
+  return Array.isArray(value) ? value.join(", ") : String(value);
+}
+function normalizeFetchResponse(response) {
+  if (!response.headers.has("set-cookie")) {
+    return response;
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: normalizeCookieHeaders(response.headers)
+  });
+}
+function normalizeCookieHeader(header = "") {
+  return splitCookiesString(joinHeaders(header));
+}
+function normalizeCookieHeaders(headers) {
+  const outgoingHeaders = new Headers();
+  for (const [name, header] of headers) {
+    if (name === "set-cookie") {
+      for (const cookie of normalizeCookieHeader(header)) {
+        outgoingHeaders.append("set-cookie", cookie);
+      }
+    } else {
+      outgoingHeaders.set(name, joinHeaders(header));
+    }
+  }
+  return outgoingHeaders;
+}
+
+const errorHandler$2 = function(error, event) {
+  event.node.res.end(`[Error Handler] ${error.stack}`);
+};
+
+function defineNitroErrorHandler(handler) {
+  return handler;
+}
+
+const errorHandler$1 = defineNitroErrorHandler(
+  async function defaultNitroErrorHandler(error, event) {
+    const res = await defaultHandler(error, event);
+    if (!event.node?.res.headersSent) {
+      setResponseHeaders(event, res.headers);
+    }
+    setResponseStatus(event, res.status, res.statusText);
+    return send(
+      event,
+      typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2)
+    );
+  }
+);
+async function defaultHandler(error, event, opts) {
+  const isSensitive = error.unhandled || error.fatal;
+  const statusCode = error.statusCode || 500;
+  const statusMessage = error.statusMessage || "Server Error";
+  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  if (statusCode === 404) {
+    const baseURL = "/";
+    if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+      const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
+      return {
+        status: 302,
+        statusText: "Found",
+        headers: { location: redirectTo },
+        body: `Redirecting...`
+      };
+    }
+  }
+  await loadStackTrace(error).catch(consola.error);
+  const youch = new Youch();
+  if (isSensitive && !opts?.silent) {
+    const tags = [error.unhandled && "[unhandled]", error.fatal && "[fatal]"].filter(Boolean).join(" ");
+    const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
+    consola.error(
+      `[request error] ${tags} [${event.method}] ${url}
+
+`,
+      ansiError
+    );
+  }
+  const useJSON = opts?.json || !getRequestHeader(event, "accept")?.includes("text/html");
+  const headers = {
+    "content-type": useJSON ? "application/json" : "text/html",
+    // Prevent browser from guessing the MIME types of resources.
+    "x-content-type-options": "nosniff",
+    // Prevent error page from being embedded in an iframe
+    "x-frame-options": "DENY",
+    // Prevent browsers from sending the Referer header
+    "referrer-policy": "no-referrer",
+    // Disable the execution of any js
+    "content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
+  };
+  if (statusCode === 404 || !getResponseHeader(event, "cache-control")) {
+    headers["cache-control"] = "no-cache";
+  }
+  const body = useJSON ? {
+    error: true,
+    url,
+    statusCode,
+    statusMessage,
+    message: error.message,
+    data: error.data,
+    stack: error.stack?.split("\n").map((line) => line.trim())
+  } : await youch.toHTML(error, {
+    request: {
+      url: url.href,
+      method: event.method,
+      headers: getRequestHeaders(event)
+    }
+  });
+  return {
+    status: statusCode,
+    statusText: statusMessage,
+    headers,
+    body
+  };
+}
+async function loadStackTrace(error) {
+  if (!(error instanceof Error)) {
+    return;
+  }
+  const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
+  const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
+  Object.defineProperty(error, "stack", { value: stack });
+  if (error.cause) {
+    await loadStackTrace(error.cause).catch(consola.error);
+  }
+}
+async function sourceLoader(frame) {
+  if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
+    return;
+  }
+  if (frame.type === "app") {
+    const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {
+    });
+    if (rawSourceMap) {
+      const consumer = await new SourceMapConsumer(rawSourceMap);
+      const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber });
+      if (originalPosition.source && originalPosition.line) {
+        frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
+        frame.lineNumber = originalPosition.line;
+        frame.columnNumber = originalPosition.column || 0;
+      }
+    }
+  }
+  const contents = await readFile(frame.fileName, "utf8").catch(() => {
+  });
+  return contents ? { contents } : void 0;
+}
+function fmtFrame(frame) {
+  if (frame.type === "native") {
+    return frame.raw;
+  }
+  const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
+  return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
+}
+
+const errorHandlers = [errorHandler$2, errorHandler$1];
+
+async function errorHandler(error, event) {
+  for (const handler of errorHandlers) {
+    try {
+      await handler(error, event, { defaultHandler });
+      if (event.handled) {
+        return; // Response handled
+      }
+    } catch(error) {
+      // Handler itself thrown, log and continue
+      console.error(error);
+    }
+  }
+  // H3 will handle fallback
+}
+
+const plugins = [
+  
+];
+
+function useResponseSuccess(data) {
+  return {
+    code: 0,
+    data,
+    error: null,
+    message: "ok"
+  };
+}
+function usePageResponseSuccess(page, pageSize, list, { message = "ok" } = {}) {
+  const pageData = pagination(
+    Number.parseInt(`${page}`),
+    Number.parseInt(`${pageSize}`),
+    list
+  );
+  return {
+    ...useResponseSuccess({
+      items: pageData,
+      total: list.length
+    }),
+    message
+  };
+}
+function useResponseError(message, error = null) {
+  return {
+    code: -1,
+    data: null,
+    error,
+    message
+  };
+}
+function forbiddenResponse(event, message = "Forbidden Exception") {
+  setResponseStatus(event, 403);
+  return useResponseError(message, message);
+}
+function unAuthorizedResponse(event) {
+  setResponseStatus(event, 401);
+  return useResponseError("Unauthorized Exception", "Unauthorized Exception");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function pagination(pageNo, pageSize, array) {
+  const offset = (pageNo - 1) * Number(pageSize);
+  return offset + Number(pageSize) >= array.length ? array.slice(offset) : array.slice(offset, offset + Number(pageSize));
+}
+
+const _3Kb7Di = defineEventHandler(async (event) => {
+  var _a;
+  event.node.res.setHeader(
+    "Access-Control-Allow-Origin",
+    (_a = event.headers.get("Origin")) != null ? _a : "*"
+  );
+  if (event.method === "OPTIONS") {
+    event.node.res.statusCode = 204;
+    event.node.res.statusMessage = "No Content.";
+    return "OK";
+  } else if (["DELETE", "PATCH", "POST", "PUT"].includes(event.method) && event.path.startsWith("/api/system/")) {
+    await sleep(Math.floor(Math.random() * 2e3));
+    return forbiddenResponse(event, "\u6F14\u793A\u73AF\u5883\uFF0C\u7981\u6B62\u4FEE\u6539");
+  }
+});
+
+const _lazy_Cjg2LV = () => Promise.resolve().then(function () { return codes$1; });
+const _lazy_rtEwLH = () => Promise.resolve().then(function () { return login_post$1; });
+const _lazy_HQfk2e = () => Promise.resolve().then(function () { return logout_post$1; });
+const _lazy_LV4MmU = () => Promise.resolve().then(function () { return refresh_post$1; });
+const _lazy_hTfDqU = () => Promise.resolve().then(function () { return bigint$1; });
+const _lazy_d4BSOr = () => Promise.resolve().then(function () { return all$1; });
+const _lazy_r9rMys = () => Promise.resolve().then(function () { return status$1; });
+const _lazy_QIRnpN = () => Promise.resolve().then(function () { return _post$1; });
+const _lazy_WxQT4N = () => Promise.resolve().then(function () { return _id__delete$1; });
+const _lazy_DthOu8 = () => Promise.resolve().then(function () { return _id__put$1; });
+const _lazy_9OBCpg = () => Promise.resolve().then(function () { return list$7; });
+const _lazy_UM7Fl_ = () => Promise.resolve().then(function () { return list$5; });
+const _lazy_fqwdxs = () => Promise.resolve().then(function () { return nameExists$1; });
+const _lazy_I47CY1 = () => Promise.resolve().then(function () { return pathExists$1; });
+const _lazy_oMtqRm = () => Promise.resolve().then(function () { return list$3; });
+const _lazy_R0gwfL = () => Promise.resolve().then(function () { return list$1; });
+const _lazy_DbYADR = () => Promise.resolve().then(function () { return test_get$1; });
+const _lazy_Tjiaxz = () => Promise.resolve().then(function () { return test_post$1; });
+const _lazy_Ut5b2V = () => Promise.resolve().then(function () { return upload$1; });
+const _lazy_NDYxuW = () => Promise.resolve().then(function () { return info$1; });
+const _lazy_IBn8TT = () => Promise.resolve().then(function () { return _____$1; });
+
+const handlers = [
+  { route: '', handler: _3Kb7Di, lazy: false, middleware: true, method: undefined },
+  { route: '/api/auth/codes', handler: _lazy_Cjg2LV, lazy: true, middleware: false, method: undefined },
+  { route: '/api/auth/login', handler: _lazy_rtEwLH, lazy: true, middleware: false, method: "post" },
+  { route: '/api/auth/logout', handler: _lazy_HQfk2e, lazy: true, middleware: false, method: "post" },
+  { route: '/api/auth/refresh', handler: _lazy_LV4MmU, lazy: true, middleware: false, method: "post" },
+  { route: '/api/demo/bigint', handler: _lazy_hTfDqU, lazy: true, middleware: false, method: undefined },
+  { route: '/api/menu/all', handler: _lazy_d4BSOr, lazy: true, middleware: false, method: undefined },
+  { route: '/api/status', handler: _lazy_r9rMys, lazy: true, middleware: false, method: undefined },
+  { route: '/api/system/dept/', handler: _lazy_QIRnpN, lazy: true, middleware: false, method: "post" },
+  { route: '/api/system/dept/:id', handler: _lazy_WxQT4N, lazy: true, middleware: false, method: "delete" },
+  { route: '/api/system/dept/:id', handler: _lazy_DthOu8, lazy: true, middleware: false, method: "put" },
+  { route: '/api/system/dept/list', handler: _lazy_9OBCpg, lazy: true, middleware: false, method: undefined },
+  { route: '/api/system/menu/list', handler: _lazy_UM7Fl_, lazy: true, middleware: false, method: undefined },
+  { route: '/api/system/menu/name-exists', handler: _lazy_fqwdxs, lazy: true, middleware: false, method: undefined },
+  { route: '/api/system/menu/path-exists', handler: _lazy_I47CY1, lazy: true, middleware: false, method: undefined },
+  { route: '/api/system/role/list', handler: _lazy_oMtqRm, lazy: true, middleware: false, method: undefined },
+  { route: '/api/table/list', handler: _lazy_R0gwfL, lazy: true, middleware: false, method: undefined },
+  { route: '/api/test', handler: _lazy_DbYADR, lazy: true, middleware: false, method: "get" },
+  { route: '/api/test', handler: _lazy_Tjiaxz, lazy: true, middleware: false, method: "post" },
+  { route: '/api/upload', handler: _lazy_Ut5b2V, lazy: true, middleware: false, method: undefined },
+  { route: '/api/user/info', handler: _lazy_NDYxuW, lazy: true, middleware: false, method: undefined },
+  { route: '/**', handler: _lazy_IBn8TT, lazy: true, middleware: false, method: undefined }
+];
+
+function createNitroApp() {
+  const config = useRuntimeConfig();
+  const hooks = createHooks();
+  const captureError = (error, context = {}) => {
+    const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
+      console.error("Error while capturing another error", error_);
+    });
+    if (context.event && isEvent(context.event)) {
+      const errors = context.event.context.nitro?.errors;
+      if (errors) {
+        errors.push({ error, context });
+      }
+      if (context.event.waitUntil) {
+        context.event.waitUntil(promise);
+      }
+    }
+  };
+  const h3App = createApp({
+    debug: destr(true),
+    onError: (error, event) => {
+      captureError(error, { event, tags: ["request"] });
+      return errorHandler(error, event);
+    },
+    onRequest: async (event) => {
+      event.context.nitro = event.context.nitro || { errors: [] };
+      const fetchContext = event.node.req?.__unenv__;
+      if (fetchContext?._platform) {
+        event.context = {
+          _platform: fetchContext?._platform,
+          // #3335
+          ...fetchContext._platform,
+          ...event.context
+        };
+      }
+      if (!event.context.waitUntil && fetchContext?.waitUntil) {
+        event.context.waitUntil = fetchContext.waitUntil;
+      }
+      event.fetch = (req, init) => fetchWithEvent(event, req, init, { fetch: localFetch });
+      event.$fetch = (req, init) => fetchWithEvent(event, req, init, {
+        fetch: $fetch
+      });
+      event.waitUntil = (promise) => {
+        if (!event.context.nitro._waitUntilPromises) {
+          event.context.nitro._waitUntilPromises = [];
+        }
+        event.context.nitro._waitUntilPromises.push(promise);
+        if (event.context.waitUntil) {
+          event.context.waitUntil(promise);
+        }
+      };
+      event.captureError = (error, context) => {
+        captureError(error, { event, ...context });
+      };
+      await nitroApp$1.hooks.callHook("request", event).catch((error) => {
+        captureError(error, { event, tags: ["request"] });
+      });
+    },
+    onBeforeResponse: async (event, response) => {
+      await nitroApp$1.hooks.callHook("beforeResponse", event, response).catch((error) => {
+        captureError(error, { event, tags: ["request", "response"] });
+      });
+    },
+    onAfterResponse: async (event, response) => {
+      await nitroApp$1.hooks.callHook("afterResponse", event, response).catch((error) => {
+        captureError(error, { event, tags: ["request", "response"] });
+      });
+    }
+  });
+  const router = createRouter$1({
+    preemptive: true
+  });
+  const nodeHandler = toNodeListener(h3App);
+  const localCall = (aRequest) => callNodeRequestHandler(nodeHandler, aRequest);
+  const localFetch = (input, init) => {
+    if (!input.toString().startsWith("/")) {
+      return globalThis.fetch(input, init);
+    }
+    return fetchNodeRequestHandler(
+      nodeHandler,
+      input,
+      init
+    ).then((response) => normalizeFetchResponse(response));
+  };
+  const $fetch = createFetch({
+    fetch: localFetch,
+    Headers: Headers$1,
+    defaults: { baseURL: config.app.baseURL }
+  });
+  globalThis.$fetch = $fetch;
+  h3App.use(createRouteRulesHandler({ localFetch }));
+  for (const h of handlers) {
+    let handler = h.lazy ? lazyEventHandler(h.handler) : h.handler;
+    if (h.middleware || !h.route) {
+      const middlewareBase = (config.app.baseURL + (h.route || "/")).replace(
+        /\/+/g,
+        "/"
+      );
+      h3App.use(middlewareBase, handler);
+    } else {
+      const routeRules = getRouteRulesForPath(
+        h.route.replace(/:\w+|\*\*/g, "_")
+      );
+      if (routeRules.cache) {
+        handler = cachedEventHandler(handler, {
+          group: "nitro/routes",
+          ...routeRules.cache
+        });
+      }
+      router.use(h.route, handler, h.method);
+    }
+  }
+  h3App.use(config.app.baseURL, router.handler);
+  const app = {
+    hooks,
+    h3App,
+    router,
+    localCall,
+    localFetch,
+    captureError
+  };
+  return app;
+}
+function runNitroPlugins(nitroApp2) {
+  for (const plugin of plugins) {
+    try {
+      plugin(nitroApp2);
+    } catch (error) {
+      nitroApp2.captureError(error, { tags: ["plugin"] });
+      throw error;
+    }
+  }
+}
+const nitroApp$1 = createNitroApp();
+function useNitroApp() {
+  return nitroApp$1;
+}
+runNitroPlugins(nitroApp$1);
+
+const scheduledTasks = false;
+
+const tasks = {
+  
+};
+
+const __runningTasks__ = {};
+async function runTask(name, {
+  payload = {},
+  context = {}
+} = {}) {
+  if (__runningTasks__[name]) {
+    return __runningTasks__[name];
+  }
+  if (!(name in tasks)) {
+    throw createError({
+      message: `Task \`${name}\` is not available!`,
+      statusCode: 404
+    });
+  }
+  if (!tasks[name].resolve) {
+    throw createError({
+      message: `Task \`${name}\` is not implemented!`,
+      statusCode: 501
+    });
+  }
+  const handler = await tasks[name].resolve();
+  const taskEvent = { name, payload, context };
+  __runningTasks__[name] = handler.run(taskEvent);
+  try {
+    const res = await __runningTasks__[name];
+    return res;
+  } finally {
+    delete __runningTasks__[name];
+  }
+}
+
+if (!globalThis.crypto) {
+  globalThis.crypto = nodeCrypto;
+}
+const { NITRO_NO_UNIX_SOCKET, NITRO_DEV_WORKER_ID } = process.env;
+trapUnhandledNodeErrors();
+parentPort?.on("message", (msg) => {
+  if (msg && msg.event === "shutdown") {
+    shutdown();
+  }
+});
+const nitroApp = useNitroApp();
+const server = new Server(toNodeListener(nitroApp.h3App));
+let listener;
+listen().catch(() => listen(
+  true
+  /* use random port */
+)).catch((error) => {
+  console.error("Dev worker failed to listen:", error);
+  return shutdown();
+});
+nitroApp.router.get(
+  "/_nitro/tasks",
+  defineEventHandler(async (event) => {
+    const _tasks = await Promise.all(
+      Object.entries(tasks).map(async ([name, task]) => {
+        const _task = await task.resolve?.();
+        return [name, { description: _task?.meta?.description }];
+      })
+    );
+    return {
+      tasks: Object.fromEntries(_tasks),
+      scheduledTasks
+    };
+  })
+);
+nitroApp.router.use(
+  "/_nitro/tasks/:name",
+  defineEventHandler(async (event) => {
+    const name = getRouterParam(event, "name");
+    const payload = {
+      ...getQuery$1(event),
+      ...await readBody(event).then((r) => r?.payload).catch(() => ({}))
+    };
+    return await runTask(name, { payload });
+  })
+);
+function listen(useRandomPort = Boolean(
+  NITRO_NO_UNIX_SOCKET || process.versions.webcontainer || "Bun" in globalThis && process.platform === "win32"
+)) {
+  return new Promise((resolve, reject) => {
+    try {
+      listener = server.listen(useRandomPort ? 0 : getSocketAddress(), () => {
+        const address = server.address();
+        parentPort?.postMessage({
+          event: "listen",
+          address: typeof address === "string" ? { socketPath: address } : { host: "localhost", port: address?.port }
+        });
+        resolve();
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+function getSocketAddress() {
+  const socketName = `nitro-worker-${process.pid}-${threadId}-${NITRO_DEV_WORKER_ID}-${Math.round(Math.random() * 1e4)}.sock`;
+  if (process.platform === "win32") {
+    return join(String.raw`\\.\pipe`, socketName);
+  }
+  if (process.platform === "linux") {
+    const nodeMajor = Number.parseInt(process.versions.node.split(".")[0], 10);
+    if (nodeMajor >= 20) {
+      return `\0${socketName}`;
+    }
+  }
+  return join(tmpdir(), socketName);
+}
+async function shutdown() {
+  server.closeAllConnections?.();
+  await Promise.all([
+    new Promise((resolve) => listener?.close(resolve)),
+    nitroApp.hooks.callHook("close").catch(console.error)
+  ]);
+  parentPort?.postMessage({ event: "exit" });
+}
+
+const MOCK_USERS = [
+  {
+    id: 0,
+    password: "123456",
+    realName: "Vben",
+    roles: ["super"],
+    username: "vben"
+  },
+  {
+    id: 1,
+    password: "123456",
+    realName: "Admin",
+    roles: ["admin"],
+    username: "admin",
+    homePath: "/workspace"
+  },
+  {
+    id: 2,
+    password: "123456",
+    realName: "Jack",
+    roles: ["user"],
+    username: "jack",
+    homePath: "/analytics"
+  }
+];
+const MOCK_CODES = [
+  // super
+  {
+    codes: ["AC_100100", "AC_100110", "AC_100120", "AC_100010"],
+    username: "vben"
+  },
+  {
+    // admin
+    codes: ["AC_100010", "AC_100020", "AC_100030"],
+    username: "admin"
+  },
+  {
+    // user
+    codes: ["AC_1000001", "AC_1000002"],
+    username: "jack"
+  }
+];
+const dashboardMenus = [
+  {
+    meta: {
+      order: -1,
+      title: "page.dashboard.title"
+    },
+    name: "Dashboard",
+    path: "/dashboard",
+    redirect: "/analytics",
+    children: [
+      {
+        name: "Analytics",
+        path: "/analytics",
+        component: "/dashboard/analytics/index",
+        meta: {
+          affixTab: true,
+          title: "page.dashboard.analytics"
+        }
+      },
+      {
+        name: "Workspace",
+        path: "/workspace",
+        component: "/dashboard/workspace/index",
+        meta: {
+          title: "page.dashboard.workspace"
+        }
+      }
+    ]
+  }
+];
+const createDemosMenus = (role) => {
+  const roleWithMenus = {
+    admin: {
+      component: "/demos/access/admin-visible",
+      meta: {
+        icon: "mdi:button-cursor",
+        title: "demos.access.adminVisible"
+      },
+      name: "AccessAdminVisibleDemo",
+      path: "/demos/access/admin-visible"
+    },
+    super: {
+      component: "/demos/access/super-visible",
+      meta: {
+        icon: "mdi:button-cursor",
+        title: "demos.access.superVisible"
+      },
+      name: "AccessSuperVisibleDemo",
+      path: "/demos/access/super-visible"
+    },
+    user: {
+      component: "/demos/access/user-visible",
+      meta: {
+        icon: "mdi:button-cursor",
+        title: "demos.access.userVisible"
+      },
+      name: "AccessUserVisibleDemo",
+      path: "/demos/access/user-visible"
+    }
+  };
+  return [
+    {
+      meta: {
+        icon: "ic:baseline-view-in-ar",
+        keepAlive: true,
+        order: 1e3,
+        title: "demos.title"
+      },
+      name: "Demos",
+      path: "/demos",
+      redirect: "/demos/access",
+      children: [
+        {
+          name: "AccessDemos",
+          path: "/demosaccess",
+          meta: {
+            icon: "mdi:cloud-key-outline",
+            title: "demos.access.backendPermissions"
+          },
+          redirect: "/demos/access/page-control",
+          children: [
+            {
+              name: "AccessPageControlDemo",
+              path: "/demos/access/page-control",
+              component: "/demos/access/index",
+              meta: {
+                icon: "mdi:page-previous-outline",
+                title: "demos.access.pageAccess"
+              }
+            },
+            {
+              name: "AccessButtonControlDemo",
+              path: "/demos/access/button-control",
+              component: "/demos/access/button-control",
+              meta: {
+                icon: "mdi:button-cursor",
+                title: "demos.access.buttonControl"
+              }
+            },
+            {
+              name: "AccessMenuVisible403Demo",
+              path: "/demos/access/menu-visible-403",
+              component: "/demos/access/menu-visible-403",
+              meta: {
+                authority: ["no-body"],
+                icon: "mdi:button-cursor",
+                menuVisibleWithForbidden: true,
+                title: "demos.access.menuVisible403"
+              }
+            },
+            roleWithMenus[role]
+          ]
+        }
+      ]
+    }
+  ];
+};
+const MOCK_MENUS = [
+  {
+    menus: [...dashboardMenus, ...createDemosMenus("super")],
+    username: "vben"
+  },
+  {
+    menus: [...dashboardMenus, ...createDemosMenus("admin")],
+    username: "admin"
+  },
+  {
+    menus: [...dashboardMenus, ...createDemosMenus("user")],
+    username: "jack"
+  }
+];
+const MOCK_MENU_LIST = [
+  {
+    id: 1,
+    name: "Workspace",
+    status: 1,
+    type: "menu",
+    icon: "mdi:dashboard",
+    path: "/workspace",
+    component: "/dashboard/workspace/index",
+    meta: {
+      icon: "carbon:workspace",
+      title: "page.dashboard.workspace",
+      affixTab: true,
+      order: 0
+    }
+  },
+  {
+    id: 2,
+    meta: {
+      icon: "carbon:settings",
+      order: 9997,
+      title: "system.title",
+      badge: "new",
+      badgeType: "normal",
+      badgeVariants: "primary"
+    },
+    status: 1,
+    type: "catalog",
+    name: "System",
+    path: "/system",
+    children: [
+      {
+        id: 201,
+        pid: 2,
+        path: "/system/menu",
+        name: "SystemMenu",
+        authCode: "System:Menu:List",
+        status: 1,
+        type: "menu",
+        meta: {
+          icon: "carbon:menu",
+          title: "system.menu.title"
+        },
+        component: "/system/menu/list",
+        children: [
+          {
+            id: 20101,
+            pid: 201,
+            name: "SystemMenuCreate",
+            status: 1,
+            type: "button",
+            authCode: "System:Menu:Create",
+            meta: { title: "common.create" }
+          },
+          {
+            id: 20102,
+            pid: 201,
+            name: "SystemMenuEdit",
+            status: 1,
+            type: "button",
+            authCode: "System:Menu:Edit",
+            meta: { title: "common.edit" }
+          },
+          {
+            id: 20103,
+            pid: 201,
+            name: "SystemMenuDelete",
+            status: 1,
+            type: "button",
+            authCode: "System:Menu:Delete",
+            meta: { title: "common.delete" }
+          }
+        ]
+      },
+      {
+        id: 202,
+        pid: 2,
+        path: "/system/dept",
+        name: "SystemDept",
+        status: 1,
+        type: "menu",
+        authCode: "System:Dept:List",
+        meta: {
+          icon: "carbon:container-services",
+          title: "system.dept.title"
+        },
+        component: "/system/dept/list",
+        children: [
+          {
+            id: 20401,
+            pid: 201,
+            name: "SystemDeptCreate",
+            status: 1,
+            type: "button",
+            authCode: "System:Dept:Create",
+            meta: { title: "common.create" }
+          },
+          {
+            id: 20402,
+            pid: 201,
+            name: "SystemDeptEdit",
+            status: 1,
+            type: "button",
+            authCode: "System:Dept:Edit",
+            meta: { title: "common.edit" }
+          },
+          {
+            id: 20403,
+            pid: 201,
+            name: "SystemDeptDelete",
+            status: 1,
+            type: "button",
+            authCode: "System:Dept:Delete",
+            meta: { title: "common.delete" }
+          }
+        ]
+      }
+    ]
+  },
+  {
+    id: 9,
+    meta: {
+      badgeType: "dot",
+      order: 9998,
+      title: "demos.vben.title",
+      icon: "carbon:data-center"
+    },
+    name: "Project",
+    path: "/vben-admin",
+    type: "catalog",
+    status: 1,
+    children: [
+      {
+        id: 901,
+        pid: 9,
+        name: "VbenDocument",
+        path: "/vben-admin/document",
+        component: "IFrameView",
+        type: "embedded",
+        status: 1,
+        meta: {
+          icon: "carbon:book",
+          iframeSrc: "https://doc.vben.pro",
+          title: "demos.vben.document"
+        }
+      },
+      {
+        id: 902,
+        pid: 9,
+        name: "VbenGithub",
+        path: "/vben-admin/github",
+        component: "IFrameView",
+        type: "link",
+        status: 1,
+        meta: {
+          icon: "carbon:logo-github",
+          link: "https://github.com/vbenjs/vue-vben-admin",
+          title: "Github"
+        }
+      },
+      {
+        id: 903,
+        pid: 9,
+        name: "VbenAntdv",
+        path: "/vben-admin/antdv",
+        component: "IFrameView",
+        type: "link",
+        status: 0,
+        meta: {
+          icon: "carbon:hexagon-vertical-solid",
+          badgeType: "dot",
+          link: "https://ant.vben.pro",
+          title: "demos.vben.antdv"
+        }
+      }
+    ]
+  },
+  {
+    id: 10,
+    component: "_core/about/index",
+    type: "menu",
+    status: 1,
+    meta: {
+      icon: "lucide:copyright",
+      order: 9999,
+      title: "demos.vben.about"
+    },
+    name: "About",
+    path: "/about"
+  }
+];
+function getMenuIds(menus) {
+  const ids = [];
+  menus.forEach((item) => {
+    ids.push(item.id);
+    if (item.children && item.children.length > 0) {
+      ids.push(...getMenuIds(item.children));
+    }
+  });
+  return ids;
+}
+
+const ACCESS_TOKEN_SECRET = "access_token_secret";
+const REFRESH_TOKEN_SECRET = "refresh_token_secret";
+function generateAccessToken(user) {
+  return jwt.sign(user, ACCESS_TOKEN_SECRET, { expiresIn: "7d" });
+}
+function generateRefreshToken(user) {
+  return jwt.sign(user, REFRESH_TOKEN_SECRET, {
+    expiresIn: "30d"
+  });
+}
+function verifyAccessToken(event) {
+  const authHeader = getHeader(event, "Authorization");
+  if (!(authHeader == null ? void 0 : authHeader.startsWith("Bearer"))) {
+    return null;
+  }
+  const token = authHeader.split(" ")[1];
+  try {
+    const decoded = jwt.verify(token, ACCESS_TOKEN_SECRET);
+    const username = decoded.username;
+    const user = MOCK_USERS.find((item) => item.username === username);
+    const { password: _pwd, ...userinfo } = user;
+    return userinfo;
+  } catch {
+    return null;
+  }
+}
+function verifyRefreshToken(token) {
+  try {
+    const decoded = jwt.verify(token, REFRESH_TOKEN_SECRET);
+    const username = decoded.username;
+    const user = MOCK_USERS.find((item) => item.username === username);
+    const { password: _pwd, ...userinfo } = user;
+    return userinfo;
+  } catch {
+    return null;
+  }
+}
+
+const codes = eventHandler((event) => {
+  var _a, _b;
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  const codes = (_b = (_a = MOCK_CODES.find((item) => item.username === userinfo.username)) == null ? void 0 : _a.codes) != null ? _b : [];
+  return useResponseSuccess(codes);
+});
+
+const codes$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: codes
+});
+
+function clearRefreshTokenCookie(event) {
+  deleteCookie(event, "jwt", {
+    httpOnly: true,
+    sameSite: "none",
+    secure: true
+  });
+}
+function setRefreshTokenCookie(event, refreshToken) {
+  setCookie(event, "jwt", refreshToken, {
+    httpOnly: true,
+    maxAge: 24 * 60 * 60,
+    // unit: seconds
+    sameSite: "none",
+    secure: true
+  });
+}
+function getRefreshTokenFromCookie(event) {
+  const refreshToken = getCookie(event, "jwt");
+  return refreshToken;
+}
+
+const login_post = defineEventHandler(async (event) => {
+  const { password, username } = await readBody(event);
+  if (!password || !username) {
+    setResponseStatus(event, 400);
+    return useResponseError(
+      "BadRequestException",
+      "Username and password are required"
+    );
+  }
+  const findUser = MOCK_USERS.find(
+    (item) => item.username === username && item.password === password
+  );
+  if (!findUser) {
+    clearRefreshTokenCookie(event);
+    return forbiddenResponse(event, "Username or password is incorrect.");
+  }
+  const accessToken = generateAccessToken(findUser);
+  const refreshToken = generateRefreshToken(findUser);
+  setRefreshTokenCookie(event, refreshToken);
+  return useResponseSuccess({
+    ...findUser,
+    accessToken
+  });
+});
+
+const login_post$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: login_post
+});
+
+const logout_post = defineEventHandler(async (event) => {
+  const refreshToken = getRefreshTokenFromCookie(event);
+  if (!refreshToken) {
+    return useResponseSuccess("");
+  }
+  clearRefreshTokenCookie(event);
+  return useResponseSuccess("");
+});
+
+const logout_post$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: logout_post
+});
+
+const refresh_post = defineEventHandler(async (event) => {
+  const refreshToken = getRefreshTokenFromCookie(event);
+  if (!refreshToken) {
+    return forbiddenResponse(event);
+  }
+  clearRefreshTokenCookie(event);
+  const userinfo = verifyRefreshToken(refreshToken);
+  if (!userinfo) {
+    return forbiddenResponse(event);
+  }
+  const findUser = MOCK_USERS.find(
+    (item) => item.username === userinfo.username
+  );
+  if (!findUser) {
+    return forbiddenResponse(event);
+  }
+  const accessToken = generateAccessToken(findUser);
+  setRefreshTokenCookie(event, refreshToken);
+  return accessToken;
+});
+
+const refresh_post$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: refresh_post
+});
+
+const bigint = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  const data = `
+  {
+    "code": 0,
+    "message": "success",
+    "data": [
+              {
+                "id": 123456789012345678901234567890123456789012345678901234567890,
+                "name": "John Doe",
+                "age": 30,
+                "email": "john-doe@demo.com"
+                },
+                {
+                "id": 987654321098765432109876543210987654321098765432109876543210,
+                "name": "Jane Smith",
+                "age": 25,
+                "email": "jane@demo.com"
+                }
+            ]
+  }
+  `;
+  setHeader(event, "Content-Type", "application/json");
+  return data;
+});
+
+const bigint$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: bigint
+});
+
+const all = eventHandler(async (event) => {
+  var _a, _b;
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  const menus = (_b = (_a = MOCK_MENUS.find((item) => item.username === userinfo.username)) == null ? void 0 : _a.menus) != null ? _b : [];
+  return useResponseSuccess(menus);
+});
+
+const all$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: all
+});
+
+const status = eventHandler((event) => {
+  const { status } = getQuery$1(event);
+  setResponseStatus(event, Number(status));
+  return useResponseError(`${status}`);
+});
+
+const status$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: status
+});
+
+const _post = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  await sleep(600);
+  return useResponseSuccess(null);
+});
+
+const _post$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: _post
+});
+
+const _id__delete = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  await sleep(1e3);
+  return useResponseSuccess(null);
+});
+
+const _id__delete$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: _id__delete
+});
+
+const _id__put = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  await sleep(2e3);
+  return useResponseSuccess(null);
+});
+
+const _id__put$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: _id__put
+});
+
+const formatterCN$1 = new Intl.DateTimeFormat("zh-CN", {
+  timeZone: "Asia/Shanghai",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+});
+function generateMockDataList$2(count) {
+  const dataList = [];
+  for (let i = 0; i < count; i++) {
+    const dataItem = {
+      id: faker.string.uuid(),
+      pid: 0,
+      name: faker.commerce.department(),
+      status: faker.helpers.arrayElement([0, 1]),
+      createTime: formatterCN$1.format(
+        faker.date.between({ from: "2021-01-01", to: "2022-12-31" })
+      ),
+      remark: faker.lorem.sentence()
+    };
+    if (faker.datatype.boolean()) {
+      dataItem.children = Array.from(
+        { length: faker.number.int({ min: 1, max: 5 }) },
+        () => ({
+          id: faker.string.uuid(),
+          pid: dataItem.id,
+          name: faker.commerce.department(),
+          status: faker.helpers.arrayElement([0, 1]),
+          createTime: formatterCN$1.format(
+            faker.date.between({ from: "2023-01-01", to: "2023-12-31" })
+          ),
+          remark: faker.lorem.sentence()
+        })
+      );
+    }
+    dataList.push(dataItem);
+  }
+  return dataList;
+}
+const mockData$2 = generateMockDataList$2(10);
+const list$6 = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  const listData = structuredClone(mockData$2);
+  return useResponseSuccess(listData);
+});
+
+const list$7 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: list$6
+});
+
+const list$4 = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  return useResponseSuccess(MOCK_MENU_LIST);
+});
+
+const list$5 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: list$4
+});
+
+const namesMap = {};
+function getNames(menus) {
+  menus.forEach((menu) => {
+    namesMap[menu.name] = String(menu.id);
+    if (menu.children) {
+      getNames(menu.children);
+    }
+  });
+}
+getNames(MOCK_MENU_LIST);
+const nameExists = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  const { id, name } = getQuery$1(event);
+  return name in namesMap && (!id || namesMap[name] !== String(id)) ? useResponseSuccess(true) : useResponseSuccess(false);
+});
+
+const nameExists$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: nameExists
+});
+
+const pathMap = { "/": 0 };
+function getPaths(menus) {
+  menus.forEach((menu) => {
+    pathMap[menu.path] = String(menu.id);
+    if (menu.children) {
+      getPaths(menu.children);
+    }
+  });
+}
+getPaths(MOCK_MENU_LIST);
+const pathExists = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  const { id, path } = getQuery$1(event);
+  return path in pathMap && (!id || pathMap[path] !== String(id)) ? useResponseSuccess(true) : useResponseSuccess(false);
+});
+
+const pathExists$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: pathExists
+});
+
+const formatterCN = new Intl.DateTimeFormat("zh-CN", {
+  timeZone: "Asia/Shanghai",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+});
+const menuIds = getMenuIds(MOCK_MENU_LIST);
+function generateMockDataList$1(count) {
+  const dataList = [];
+  for (let i = 0; i < count; i++) {
+    const dataItem = {
+      id: faker.string.uuid(),
+      name: faker.commerce.product(),
+      status: faker.helpers.arrayElement([0, 1]),
+      createTime: formatterCN.format(
+        faker.date.between({ from: "2022-01-01", to: "2025-01-01" })
+      ),
+      permissions: faker.helpers.arrayElements(menuIds),
+      remark: faker.lorem.sentence()
+    };
+    dataList.push(dataItem);
+  }
+  return dataList;
+}
+const mockData$1 = generateMockDataList$1(100);
+const list$2 = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  const {
+    page = 1,
+    pageSize = 20,
+    name,
+    id,
+    remark,
+    startTime,
+    endTime,
+    status
+  } = getQuery$1(event);
+  let listData = structuredClone(mockData$1);
+  if (name) {
+    listData = listData.filter(
+      (item) => item.name.toLowerCase().includes(String(name).toLowerCase())
+    );
+  }
+  if (id) {
+    listData = listData.filter(
+      (item) => item.id.toLowerCase().includes(String(id).toLowerCase())
+    );
+  }
+  if (remark) {
+    listData = listData.filter(
+      (item) => {
+        var _a, _b;
+        return (_b = (_a = item.remark) == null ? void 0 : _a.toLowerCase()) == null ? void 0 : _b.includes(String(remark).toLowerCase());
+      }
+    );
+  }
+  if (startTime) {
+    listData = listData.filter((item) => item.createTime >= startTime);
+  }
+  if (endTime) {
+    listData = listData.filter((item) => item.createTime <= endTime);
+  }
+  if (["0", "1"].includes(status)) {
+    listData = listData.filter((item) => item.status === Number(status));
+  }
+  return usePageResponseSuccess(page, pageSize, listData);
+});
+
+const list$3 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: list$2
+});
+
+function generateMockDataList(count) {
+  const dataList = [];
+  for (let i = 0; i < count; i++) {
+    const dataItem = {
+      id: faker.string.uuid(),
+      imageUrl: faker.image.avatar(),
+      imageUrl2: faker.image.avatar(),
+      open: faker.datatype.boolean(),
+      status: faker.helpers.arrayElement(["success", "error", "warning"]),
+      productName: faker.commerce.productName(),
+      price: faker.commerce.price(),
+      currency: faker.finance.currencyCode(),
+      quantity: faker.number.int({ min: 1, max: 100 }),
+      available: faker.datatype.boolean(),
+      category: faker.commerce.department(),
+      releaseDate: faker.date.past(),
+      rating: faker.number.float({ min: 1, max: 5 }),
+      description: faker.commerce.productDescription(),
+      weight: faker.number.float({ min: 0.1, max: 10 }),
+      color: faker.color.human(),
+      inProduction: faker.datatype.boolean(),
+      tags: Array.from({ length: 3 }, () => faker.commerce.productAdjective())
+    };
+    dataList.push(dataItem);
+  }
+  return dataList;
+}
+const mockData = generateMockDataList(100);
+const list = eventHandler(async (event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  await sleep(600);
+  const { page, pageSize, sortBy, sortOrder } = getQuery$1(event);
+  const listData = structuredClone(mockData);
+  if (sortBy && Reflect.has(listData[0], sortBy)) {
+    listData.sort((a, b) => {
+      if (sortOrder === "asc") {
+        if (sortBy === "price") {
+          return Number.parseFloat(a[sortBy]) - Number.parseFloat(b[sortBy]);
+        } else {
+          return a[sortBy] > b[sortBy] ? 1 : -1;
+        }
+      } else {
+        if (sortBy === "price") {
+          return Number.parseFloat(b[sortBy]) - Number.parseFloat(a[sortBy]);
+        } else {
+          return a[sortBy] < b[sortBy] ? 1 : -1;
+        }
+      }
+    });
+  }
+  return usePageResponseSuccess(page, pageSize, listData);
+});
+
+const list$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: list
+});
+
+const test_get = defineEventHandler(() => "Test get handler");
+
+const test_get$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: test_get
+});
+
+const test_post = defineEventHandler(() => "Test post handler");
+
+const test_post$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: test_post
+});
+
+const upload = eventHandler((event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  return useResponseSuccess({
+    url: "https://unpkg.com/@vbenjs/static-source@0.1.7/source/logo-v1.webp"
+  });
+});
+
+const upload$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: upload
+});
+
+const info = eventHandler((event) => {
+  const userinfo = verifyAccessToken(event);
+  if (!userinfo) {
+    return unAuthorizedResponse(event);
+  }
+  return useResponseSuccess(userinfo);
+});
+
+const info$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: info
+});
+
+const _____ = defineEventHandler(() => {
+  return `
+<h1>Hello Vben Admin</h1>
+<h2>Mock service is starting</h2>
+<ul>
+<li><a href="/api/user">/api/user/info</a></li>
+<li><a href="/api/menu">/api/menu/all</a></li>
+<li><a href="/api/auth/codes">/api/auth/codes</a></li>
+<li><a href="/api/auth/login">/api/auth/login</a></li>
+<li><a href="/api/upload">/api/upload</a></li>
+</ul>
+`;
+});
+
+const _____$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: _____
+});
+//# sourceMappingURL=index.mjs.map

apps/backend-mock/.nitro/nitro.json

@@ -0,0 +1,17 @@
+{
+  "date": "2025-08-25T11:30:19.481Z",
+  "preset": "nitro-dev",
+  "framework": {
+    "name": "nitro",
+    "version": ""
+  },
+  "versions": {
+    "nitro": "2.11.13"
+  },
+  "dev": {
+    "pid": 39287,
+    "workerAddress": {
+      "socketPath": "/var/folders/zm/fbdy869x6bn2j28qcmc5lxvm0000gn/T/nitro-worker-39287-1-1-3713.sock"
+    }
+  }
+}

apps/backend-mock/.nitro/types/nitro-config.d.ts

@@ -0,0 +1,16 @@
+// Generated by nitro
+
+// App Config
+import type { Defu } from 'defu'
+
+
+
+type UserAppConfig = Defu<{}, []>
+
+declare module "nitropack/types" {
+  interface AppConfig extends UserAppConfig {}
+  interface NitroRuntimeConfig {
+
+  }
+}
+export {}

apps/backend-mock/.nitro/types/nitro-imports.d.ts

@@ -0,0 +1,168 @@
+declare global {
+  const MOCK_CODES: typeof import('../../utils/mock-data')['MOCK_CODES']
+  const MOCK_MENUS: typeof import('../../utils/mock-data')['MOCK_MENUS']
+  const MOCK_MENU_LIST: typeof import('../../utils/mock-data')['MOCK_MENU_LIST']
+  const MOCK_USERS: typeof import('../../utils/mock-data')['MOCK_USERS']
+  const appendCorsHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['appendCorsHeaders']
+  const appendCorsPreflightHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['appendCorsPreflightHeaders']
+  const appendHeader: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['appendHeader']
+  const appendHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['appendHeaders']
+  const appendResponseHeader: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['appendResponseHeader']
+  const appendResponseHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['appendResponseHeaders']
+  const assertMethod: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['assertMethod']
+  const cachedEventHandler: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/cache')['cachedEventHandler']
+  const cachedFunction: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/cache')['cachedFunction']
+  const callNodeListener: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['callNodeListener']
+  const clearRefreshTokenCookie: typeof import('../../utils/cookie-utils')['clearRefreshTokenCookie']
+  const clearResponseHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['clearResponseHeaders']
+  const clearSession: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['clearSession']
+  const createApp: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['createApp']
+  const createAppEventHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['createAppEventHandler']
+  const createError: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['createError']
+  const createEvent: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['createEvent']
+  const createEventStream: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['createEventStream']
+  const createRouter: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['createRouter']
+  const defaultContentType: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defaultContentType']
+  const defineCachedEventHandler: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/cache')['defineCachedEventHandler']
+  const defineCachedFunction: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/cache')['defineCachedFunction']
+  const defineEventHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defineEventHandler']
+  const defineLazyEventHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defineLazyEventHandler']
+  const defineNitroErrorHandler: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/error/utils')['defineNitroErrorHandler']
+  const defineNitroPlugin: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/plugin')['defineNitroPlugin']
+  const defineNodeListener: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defineNodeListener']
+  const defineNodeMiddleware: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defineNodeMiddleware']
+  const defineRenderHandler: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/renderer')['defineRenderHandler']
+  const defineRequestMiddleware: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defineRequestMiddleware']
+  const defineResponseMiddleware: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defineResponseMiddleware']
+  const defineRouteMeta: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/meta')['defineRouteMeta']
+  const defineTask: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/task')['defineTask']
+  const defineWebSocket: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defineWebSocket']
+  const defineWebSocketHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['defineWebSocketHandler']
+  const deleteCookie: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['deleteCookie']
+  const dynamicEventHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['dynamicEventHandler']
+  const eventHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['eventHandler']
+  const fetchWithEvent: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['fetchWithEvent']
+  const forbiddenResponse: typeof import('../../utils/response')['forbiddenResponse']
+  const fromNodeMiddleware: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['fromNodeMiddleware']
+  const fromPlainHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['fromPlainHandler']
+  const fromWebHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['fromWebHandler']
+  const generateAccessToken: typeof import('../../utils/jwt-utils')['generateAccessToken']
+  const generateRefreshToken: typeof import('../../utils/jwt-utils')['generateRefreshToken']
+  const getCookie: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getCookie']
+  const getHeader: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getHeader']
+  const getHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getHeaders']
+  const getMenuIds: typeof import('../../utils/mock-data')['getMenuIds']
+  const getMethod: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getMethod']
+  const getProxyRequestHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getProxyRequestHeaders']
+  const getQuery: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getQuery']
+  const getRefreshTokenFromCookie: typeof import('../../utils/cookie-utils')['getRefreshTokenFromCookie']
+  const getRequestFingerprint: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestFingerprint']
+  const getRequestHeader: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestHeader']
+  const getRequestHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestHeaders']
+  const getRequestHost: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestHost']
+  const getRequestIP: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestIP']
+  const getRequestPath: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestPath']
+  const getRequestProtocol: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestProtocol']
+  const getRequestURL: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestURL']
+  const getRequestWebStream: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRequestWebStream']
+  const getResponseHeader: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getResponseHeader']
+  const getResponseHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getResponseHeaders']
+  const getResponseStatus: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getResponseStatus']
+  const getResponseStatusText: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getResponseStatusText']
+  const getRouteRules: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/route-rules')['getRouteRules']
+  const getRouterParam: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRouterParam']
+  const getRouterParams: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getRouterParams']
+  const getSession: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getSession']
+  const getValidatedQuery: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getValidatedQuery']
+  const getValidatedRouterParams: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['getValidatedRouterParams']
+  const handleCacheHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['handleCacheHeaders']
+  const handleCors: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['handleCors']
+  const isCorsOriginAllowed: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['isCorsOriginAllowed']
+  const isError: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['isError']
+  const isEvent: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['isEvent']
+  const isEventHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['isEventHandler']
+  const isMethod: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['isMethod']
+  const isPreflightRequest: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['isPreflightRequest']
+  const isStream: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['isStream']
+  const isWebResponse: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['isWebResponse']
+  const lazyEventHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['lazyEventHandler']
+  const nitroPlugin: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/plugin')['nitroPlugin']
+  const pagination: typeof import('../../utils/response')['pagination']
+  const parseCookies: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['parseCookies']
+  const promisifyNodeListener: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['promisifyNodeListener']
+  const proxyRequest: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['proxyRequest']
+  const readBody: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['readBody']
+  const readFormData: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['readFormData']
+  const readMultipartFormData: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['readMultipartFormData']
+  const readRawBody: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['readRawBody']
+  const readValidatedBody: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['readValidatedBody']
+  const removeResponseHeader: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['removeResponseHeader']
+  const runTask: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/task')['runTask']
+  const sanitizeStatusCode: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sanitizeStatusCode']
+  const sanitizeStatusMessage: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sanitizeStatusMessage']
+  const sealSession: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sealSession']
+  const send: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['send']
+  const sendError: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sendError']
+  const sendIterable: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sendIterable']
+  const sendNoContent: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sendNoContent']
+  const sendProxy: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sendProxy']
+  const sendRedirect: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sendRedirect']
+  const sendStream: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sendStream']
+  const sendWebResponse: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['sendWebResponse']
+  const serveStatic: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['serveStatic']
+  const setCookie: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['setCookie']
+  const setHeader: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['setHeader']
+  const setHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['setHeaders']
+  const setRefreshTokenCookie: typeof import('../../utils/cookie-utils')['setRefreshTokenCookie']
+  const setResponseHeader: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['setResponseHeader']
+  const setResponseHeaders: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['setResponseHeaders']
+  const setResponseStatus: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['setResponseStatus']
+  const sleep: typeof import('../../utils/response')['sleep']
+  const splitCookiesString: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['splitCookiesString']
+  const toEventHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['toEventHandler']
+  const toNodeListener: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['toNodeListener']
+  const toPlainHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['toPlainHandler']
+  const toWebHandler: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['toWebHandler']
+  const toWebRequest: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['toWebRequest']
+  const unAuthorizedResponse: typeof import('../../utils/response')['unAuthorizedResponse']
+  const unsealSession: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['unsealSession']
+  const updateSession: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['updateSession']
+  const useAppConfig: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/config')['useAppConfig']
+  const useBase: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['useBase']
+  const useEvent: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/context')['useEvent']
+  const useNitroApp: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/app')['useNitroApp']
+  const usePageResponseSuccess: typeof import('../../utils/response')['usePageResponseSuccess']
+  const useResponseError: typeof import('../../utils/response')['useResponseError']
+  const useResponseSuccess: typeof import('../../utils/response')['useResponseSuccess']
+  const useRuntimeConfig: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/config')['useRuntimeConfig']
+  const useSession: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['useSession']
+  const useStorage: typeof import('../../../../node_modules/.pnpm/nitropack@2.11.13_@netlify+blobs@8.2.0_encoding@0.1.13/node_modules/nitropack/dist/runtime/internal/storage')['useStorage']
+  const verifyAccessToken: typeof import('../../utils/jwt-utils')['verifyAccessToken']
+  const verifyRefreshToken: typeof import('../../utils/jwt-utils')['verifyRefreshToken']
+  const writeEarlyHints: typeof import('../../../../node_modules/.pnpm/h3@1.15.3/node_modules/h3')['writeEarlyHints']
+}
+// for type re-export
+declare global {
+  // @ts-ignore
+  export type { UserPayload } from '../../utils/jwt-utils'
+  import('../../utils/jwt-utils')
+  // @ts-ignore
+  export type { UserInfo } from '../../utils/mock-data'
+  import('../../utils/mock-data')
+}
+export { useNitroApp } from 'nitropack/runtime/internal/app';
+export { useRuntimeConfig, useAppConfig } from 'nitropack/runtime/internal/config';
+export { defineNitroPlugin, nitroPlugin } from 'nitropack/runtime/internal/plugin';
+export { defineCachedFunction, defineCachedEventHandler, cachedFunction, cachedEventHandler } from 'nitropack/runtime/internal/cache';
+export { useStorage } from 'nitropack/runtime/internal/storage';
+export { defineRenderHandler } from 'nitropack/runtime/internal/renderer';
+export { defineRouteMeta } from 'nitropack/runtime/internal/meta';
+export { getRouteRules } from 'nitropack/runtime/internal/route-rules';
+export { useEvent } from 'nitropack/runtime/internal/context';
+export { defineTask, runTask } from 'nitropack/runtime/internal/task';
+export { defineNitroErrorHandler } from 'nitropack/runtime/internal/error/utils';
+export { appendCorsHeaders, appendCorsPreflightHeaders, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callNodeListener, clearResponseHeaders, clearSession, createApp, createAppEventHandler, createError, createEvent, createEventStream, createRouter, defaultContentType, defineEventHandler, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, defineRequestMiddleware, defineResponseMiddleware, defineWebSocket, defineWebSocketHandler, deleteCookie, dynamicEventHandler, eventHandler, fetchWithEvent, fromNodeMiddleware, fromPlainHandler, fromWebHandler, getCookie, getHeader, getHeaders, getMethod, getProxyRequestHeaders, getQuery, getRequestFingerprint, getRequestHeader, getRequestHeaders, getRequestHost, getRequestIP, getRequestPath, getRequestProtocol, getRequestURL, getRequestWebStream, getResponseHeader, getResponseHeaders, getResponseStatus, getResponseStatusText, getRouterParam, getRouterParams, getSession, getValidatedQuery, getValidatedRouterParams, handleCacheHeaders, handleCors, isCorsOriginAllowed, isError, isEvent, isEventHandler, isMethod, isPreflightRequest, isStream, isWebResponse, lazyEventHandler, parseCookies, promisifyNodeListener, proxyRequest, readBody, readFormData, readMultipartFormData, readRawBody, readValidatedBody, removeResponseHeader, sanitizeStatusCode, sanitizeStatusMessage, sealSession, send, sendError, sendIterable, sendNoContent, sendProxy, sendRedirect, sendStream, sendWebResponse, serveStatic, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, setResponseStatus, splitCookiesString, toEventHandler, toNodeListener, toPlainHandler, toWebHandler, toWebRequest, unsealSession, updateSession, useBase, useSession, writeEarlyHints } from 'h3';
+export { clearRefreshTokenCookie, setRefreshTokenCookie, getRefreshTokenFromCookie } from '/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock/utils/cookie-utils';
+export { generateAccessToken, generateRefreshToken, verifyAccessToken, verifyRefreshToken } from '/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock/utils/jwt-utils';
+export { MOCK_USERS, MOCK_CODES, MOCK_MENUS, MOCK_MENU_LIST, getMenuIds } from '/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock/utils/mock-data';
+export { useResponseSuccess, usePageResponseSuccess, useResponseError, forbiddenResponse, unAuthorizedResponse, sleep, pagination } from '/Users/linjiancheng/Documents/gameMame/web_admin_fortue_tiger_vben/apps/backend-mock/utils/response';

apps/backend-mock/.nitro/types/nitro-routes.d.ts

@@ -0,0 +1,67 @@
+// Generated by nitro
+import type { Serialize, Simplify } from "nitropack/types";
+declare module "nitropack/types" {
+  type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T
+  interface InternalApi {
+    '/api/auth/codes': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/auth/codes').default>>>>
+    }
+    '/api/auth/login': {
+      'post': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/auth/login.post').default>>>>
+    }
+    '/api/auth/logout': {
+      'post': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/auth/logout.post').default>>>>
+    }
+    '/api/auth/refresh': {
+      'post': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/auth/refresh.post').default>>>>
+    }
+    '/api/demo/bigint': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/demo/bigint').default>>>>
+    }
+    '/api/menu/all': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/menu/all').default>>>>
+    }
+    '/api/status': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/status').default>>>>
+    }
+    '/api/system/dept/': {
+      'post': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/system/dept/.post').default>>>>
+    }
+    '/api/system/dept/:id': {
+      'delete': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/system/dept/[id].delete').default>>>>
+      'put': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/system/dept/[id].put').default>>>>
+    }
+    '/api/system/dept/list': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/system/dept/list').default>>>>
+    }
+    '/api/system/menu/list': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/system/menu/list').default>>>>
+    }
+    '/api/system/menu/name-exists': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/system/menu/name-exists').default>>>>
+    }
+    '/api/system/menu/path-exists': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/system/menu/path-exists').default>>>>
+    }
+    '/api/system/role/list': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/system/role/list').default>>>>
+    }
+    '/api/table/list': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/table/list').default>>>>
+    }
+    '/api/test': {
+      'get': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/test.get').default>>>>
+      'post': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/test.post').default>>>>
+    }
+    '/api/upload': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/upload').default>>>>
+    }
+    '/api/user/info': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../api/user/info').default>>>>
+    }
+    '/**': {
+      'default': Simplify<Serialize<Awaited<ReturnType<typeof import('../../routes/[...]').default>>>>
+    }
+  }
+}
+export {}

apps/backend-mock/.nitro/types/nitro.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="./nitro-routes.d.ts" />
+/// <reference path="./nitro-config.d.ts" />
+/// <reference path="./nitro-imports.d.ts" />

apps/backend-mock/.nitro/types/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "strict": false,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "jsx": "preserve",
+    "allowSyntheticDefaultImports": true,
+    "jsxFactory": "h",
+    "jsxFragmentFactory": "Fragment",
+    "paths": {
+      "#imports": [
+        "./nitro-imports"
+      ],
+      "~/*": [
+        "../../*"
+      ],
+      "@/*": [
+        "../../*"
+      ],
+      "~~/*": [
+        "../../*"
+      ],
+      "@@/*": [
+        "../../*"
+      ]
+    }
+  },
+  "include": [
+    "./nitro.d.ts",
+    "../../**/*"
+  ]
+}

apps/web-antd/src/api/core/user.ts

@@ -6,9 +6,10 @@ import { requestClient } from '#/api/request';
  * 获取用户信息
  */
 export async function getUserInfoApi() {
-  // return requestClient.get<UserInfo>('/user/info');
+  const userinfo = await requestClient.get<UserInfo>('/user/detail');
   return {
     roles: [],
-    realName: ''
+    realName: userinfo['nick_name'],
+    roleName: userinfo['role_name']
   }
-}
+}

apps/web-antd/src/api/player/player_list.ts

@@ -0,0 +1,19 @@
+import {requestClient} from "#/api/request";
+
+interface ApiResultData {
+    data: Object;
+    status: number;
+    total: number;
+    list: Array;
+}
+
+/**
+ * 获取玩家列表
+ */
+export async function getPlayerList(data:any) {
+    const params = new URLSearchParams(data); // 创建一个新的URLSearchParams对象
+    const queryString = params.toString(); // 转换为查询字符串
+    return requestClient.get<ApiResultData>('/player/list?' + queryString, {
+        // withCredentials: true,
+    });
+}

apps/web-antd/src/layouts/basic.vue

@@ -129,8 +129,8 @@ watch(
         :avatar
         :menus
         :text="userStore.userInfo?.realName"
-        description="ann.vben@gmail.com"
-        tag-text="Pro"
+        description=""
+        :tag-text="userStore.userInfo?.roleName"
         @logout="handleLogout"
       />
     </template>

apps/web-antd/src/locales/langs/zh-CN/playerdata.json

@@ -0,0 +1,29 @@
+{
+    "title": "玩家数据",
+    "player_list": "玩家列表",
+    "placeholder": "请输入",
+    "search": {
+        "uname": "平台ID",
+        "nickname": "平台昵称",
+        "user_id": "玩家ID",
+        "reg_ip": "注册IP",
+        "login_ip": "登录IP",
+        "subimt": "查询",
+        "restart": "重置"
+    },
+    "playlist": {
+        "user_id": "玩家ID",
+        "uname": "平台ID",
+        "nickname": "平台昵称",
+        "status": "状态",
+        "today_win": "今日输赢",
+        "history_win": "历史输赢",
+        "today_bet": "今日下注",
+        "balance": "余额",
+        "regulation_status": "调控状态",
+        "today_login_count": "今日登录次数",
+        "history_login_count": "历史登录次数",
+        "login_ip": "登录IP",
+        "reg_ip": "注册IP"
+    }
+}

apps/web-antd/src/router/routes/modules/playerdata.ts

@@ -0,0 +1,28 @@
+import type { RouteRecordRaw } from 'vue-router';
+
+import { $t } from '#/locales';
+
+const routes: RouteRecordRaw[] = [
+    {
+        meta: {
+            icon: 'ic:baseline-view-in-ar',
+            keepAlive: true,
+            order: 2,
+            title: $t('playerdata.title'),
+        },
+        name: '玩家数据',
+        path: '/playerdata',
+        children: [
+            {
+                meta: {
+                    title: $t('playerdata.player_list'),
+                },
+                name: 'AntDesignPlayerList',
+                path: '/player-data/player-list',
+                component: () => import('#/views/playerdata/playerlist/index.vue'),
+            },
+        ],
+    },
+];
+
+export default routes;

apps/web-antd/src/store/auth.ts

@@ -7,7 +7,7 @@ import { LOGIN_PATH } from '@vben/constants';
 import { preferences } from '@vben/preferences';
 import { resetAllStores, useAccessStore, useUserStore } from '@vben/stores';
 
-import { notification } from 'ant-design-vue';
+import { notification, message } from 'ant-design-vue';
 import { defineStore } from 'pinia';
 
 import { getAccessCodesApi, getUserInfoApi, loginApi, logoutApi } from '#/api';
@@ -67,6 +67,13 @@ export const useAuthStore = defineStore('auth', () => {
             message: $t('authentication.loginSuccess'),
           });
         }
+      } else {
+          message.error('login failed');
+          // notification.error({
+          //     description: 'login failed',
+          //     duration: 3,
+          //     message: $t('authentication.loginErrorDesc'),
+          // });
       }
     } finally {
       loginLoading.value = false;

apps/web-antd/src/views/playerdata/playerlist/index.vue

@@ -0,0 +1,276 @@
+<script setup lang="ts">
+import {Card,Button,Form,FormItem,Input,Space,Select,SelectOption,InputGroup, RangePicker, Row, Col, Tag} from 'ant-design-vue';
+import { Page, useVbenModal } from '@vben/common-ui';
+import { $t } from '@vben/locales';
+import { reactive, toRaw } from 'vue';
+import dayjs, { Dayjs } from 'dayjs';
+import type { VxeGridProps } from '#/adapter/vxe-table';
+import { useVbenVxeGrid } from '#/adapter/vxe-table';
+import {getPlayerList} from "#/api/player/player_list";
+
+
+// 列表筛选
+let filterData = <any>{
+	page: 1,
+	limit: 10,
+	player_id:"",
+	nickname:"",
+	uname:"",
+	login_ip:"",
+	reg_ip:"",
+	login_time_start: "",//dayjs().format('YYYY-MM-DD'),
+	login_time_end: "",//dayjs().format('YYYY-MM-DD')
+}
+const disabledDate = (current: Dayjs) => {
+	// Can not select days before today and today
+	return current && current > dayjs().endOf('day');
+};
+
+
+interface RowType {
+	user_id: string;
+	uname: string;
+	nickname: string;
+	status: string;
+	today_win_amount: string | number;
+	history_win_amount: string | number;
+	today_bet_amount: string | number;
+	balance: string | number;
+	adjust_status: string;
+	today_login_count: string | number;
+	history_login_count: string | number;
+	login_ip: string;
+	reg_ip: string;
+}
+const gridOptions: VxeGridProps<RowType> = {
+	border: true,
+	stripe: true,
+	checkboxConfig: {
+		highlight: true,
+		// labelField: 'name',
+	},
+	columns: [
+		{ fixed: 'left',  title: '序号', type: 'seq', width: 50 },
+		{ field: 'user_id', title: $t('playerdata.playlist.user_id'), width: 100 },
+		{ field: 'uname', title:  $t('playerdata.playlist.uname'), width: 120, slots: {default:'uname'}},
+		{ field: 'nickname', title: $t('playerdata.playlist.nickname'), width: 140 },
+		{ field: 'status_text', title: $t('playerdata.playlist.status'), width: 100, slots: {default:'status'} },
+		{ field: 'today_win_amount', title: $t('playerdata.playlist.today_win'), width: 100, slots: { default: 'today-win-amount' },},
+		{ field: 'history_win_amount', title: $t('playerdata.playlist.history_win'), width: 100, slots: { default: 'history-win-amount' }},
+		{ field: 'today_bet_amount', title: $t('playerdata.playlist.today_bet'), width: 100},
+		{ field: 'balance', title: $t('playerdata.playlist.balance'), width: 120},
+		{ field: 'adjust_status_text', title: $t('playerdata.playlist.regulation_status'), width: 100, slots: {default: 'adjust-status'}},
+		{ field: 'today_login_count', title: $t('playerdata.playlist.today_login_count'), width: 100},
+		{ field: 'history_login_count', title: $t('playerdata.playlist.history_login_count'), width: 100},
+		{ field: 'login_ip', title: $t('playerdata.playlist.login_ip'), width: 140},
+		{ field: 'reg_ip', title: $t('playerdata.playlist.reg_ip'), width: 140},
+		// { field: 'releaseDate', formatter: 'formatDateTime', title: 'DateTime' },
+	],
+	exportConfig: {},
+	// height: 'auto', // 如果设置为 auto，则必须确保存在父节点且不允许存在相邻元素，否则会出现高度闪动问题
+	keepSource: true,
+	proxyConfig: {
+		ajax: {
+			query: async ({ page }) => {
+
+				let form = toRaw({
+					...filterData,
+					page: page.currentPage,
+					limit: page.pageSize,
+				});
+				let data = <any>{};
+				for(let k in form) {
+					const value = form[k];
+					if(value) {
+						data[k] = value;
+					}
+				}
+				const list = await getPlayerList(data);
+				return {
+					total: list.total,
+					items: list.list
+				}
+			},
+		},
+	},
+	toolbarConfig: {
+		custom: true,
+		export: true,
+		// import: true,
+		refresh: true,
+		zoom: true,
+	},
+};
+
+const [Grid, gridApi] = useVbenVxeGrid({
+	gridOptions,
+});
+
+
+const useForm = Form.useForm;
+
+// 搜索筛选
+// interface FormData {
+// 	search_type: string;
+// 	serach_text: string;
+// 	ip_type: string;
+// 	ip_text: string;
+// 	range_time: Array<string>;
+// }
+const formData = reactive({
+	search_type: 'uname',
+	search_text: '',
+	ip_type: 'login_ip',
+	ip_text: '',
+	range_time: [ filterData.login_time_start, filterData.login_time_end ],
+});
+const { resetFields } = useForm(formData, []);
+
+const onSearchFinish = () => {
+	if(!formData['range_time']) {
+		formData['range_time'] = [];
+	}
+	const tempForm = toRaw(formData);
+	filterData['page'] = 1;
+	for (let k in filterData) {
+		if (['player_id', 'nickname', 'uname', 'login_ip',  'reg_ip'].includes(k)) {
+			filterData[k] = "";
+		}
+	}
+
+	if(tempForm['ip_type'] == 'login_ip' || tempForm['ip_type'] == 'reg_ip'){
+		filterData[tempForm['ip_type']] = tempForm['ip_text'];
+	}
+
+	if(tempForm['search_type'] == 'uname' || tempForm['search_type'] == 'nickname'){
+		filterData[tempForm['search_type']] = tempForm['search_text'];
+	}else {
+		filterData['player_id'] = tempForm['search_text'];
+	}
+
+	filterData['login_time_start'] = tempForm.range_time[0] || "";
+	filterData['login_time_end'] = tempForm.range_time[1] || "";
+	gridApi.reload();
+};
+
+const onResetSearch = () => {
+	filterData['page'] = 1;
+	for (let k in filterData) {
+		if (['player_id', 'nickname', 'uname', 'login_ip',  'reg_ip'].includes(k)) {
+			filterData[k] = "";
+		}
+	}
+	filterData['login_time_start'] = "";
+	filterData['login_time_end'] = "";
+	resetFields();
+	gridApi.reload();
+}
+
+import ExtraModal from './player_info.vue';
+const [Modal, modalApi] = useVbenModal({
+	// 连接抽离的组件
+	connectedComponent: ExtraModal,
+});
+
+const playerInfo = (row:object) => {
+	console.log(row);
+	modalApi.open();
+}
+
+</script>
+
+<template>
+	<Page>
+		<Card class="mb-5">
+
+			<Form
+				:model="formData"
+				name="formRef"
+				ref="formRef"
+				@finish="onSearchFinish"
+			>
+				<Row>
+					<Col :span="8">
+						<Space>
+							<Form-Item
+							>
+								<Input-Group compact>
+									<Select name="search_type" v-model:value="formData.search_type"  style="width: 40%">
+										<Select-Option value="uname">{{$t('playerdata.search.uname')}}</Select-Option>
+										<Select-Option value="nickname">{{$t('playerdata.search.nickname')}}</Select-Option>
+										<Select-Option value="user_id">{{$t('playerdata.search.user_id')}}</Select-Option>
+									</Select>
+									<Input name="search_text" allowClear :placeholder="$t('playerdata.placeholder') + '' + $t('playerdata.search[\''+formData.search_type+'\']')" v-model:value="formData.search_text" style="width:60%"></Input>
+								</Input-Group>
+							</Form-Item>
+						</Space>
+					</Col>
+					<Col :span="8">
+
+					<Space>
+						<Form-Item
+						>
+							<Input-Group compact>
+								<Select name="ip_type" v-model:value="formData.ip_type"  style="width: 40%">
+									<Select-Option value="login_ip">{{$t('playerdata.search.login_ip')}}</Select-Option>
+									<Select-Option value="reg_ip">{{$t('playerdata.search.reg_ip')}}</Select-Option>
+								</Select>
+								<Input name="ip_text" allowClear :placeholder="$t('playerdata.placeholder') + '' + $t('playerdata.search[\''+formData.ip_type+'\']')" v-model:value="formData.ip_text" style="width:60%"></Input>
+							</Input-Group>
+						</Form-Item>
+					</Space>
+					</Col>
+					<Col :span="8">
+					<Space>
+						<FormItem>
+							<Input-Group compact>
+								<RangePicker v-model:value="formData.range_time" :disabled-date="disabledDate" value-format="YYYY-MM-DD"></RangePicker>
+							</Input-Group>
+						</FormItem>
+					</Space>
+					</Col>
+				</Row>
+				<Row>
+					<Col :span="24" style="text-align: right">
+						<Button style="margin: 0 8px" @click="onResetSearch">{{$t('playerdata.search.restart')}}</Button>
+						<Button type="primary" html-type="submit">{{$t('playerdata.search.subimt')}}</Button>
+					</Col>
+				</Row>
+			</Form>
+		</Card>
+		<Card>
+			<div class="vp-raw w-full">
+				<Grid>
+					<template #uname="{ row }">
+						<Button type="link" @click="playerInfo(row)">{{row.uname}}</Button>
+					</template>
+					<template #status="{ row }">
+						<Tag color="green">{{row.status_text}}</Tag>
+					</template>
+					<template #adjust-status="{ row }">
+						<Tag>{{row.adjust_status_text}}</Tag>
+					</template>
+
+
+					<template #today-win-amount="{ row }">
+						<span v-if="row.today_win_amount >= 0" style="color:green">{{row.today_win_amount }}</span>
+						<span v-else style="color:red">{{row.today_win_amount }}</span>
+					</template>
+					<template #history-win-amount="{ row }">
+						<span v-if="row.history_win_amount >= 0" style="color:green">{{row.history_win_amount }}</span>
+						<span v-else style="color:red">{{row.history_win_amount }}</span>
+					</template>
+				</Grid>
+			</div>
+		</Card>
+
+		<Modal userid="11" />
+
+	</Page>
+</template>
+
+<style scoped>
+:where(.css-dev-only-do-not-override-14589v).ant-input-group.ant-input-group-compact>*:not(:last-child) {
+	border-inline-end-width: 0;
+}
+</style>

apps/web-antd/src/views/playerdata/playerlist/player_info.vue

@@ -0,0 +1,18 @@
+<script lang="ts" setup>
+import { useVbenModal } from '@vben/common-ui';
+
+const [Modal] = useVbenModal({
+	draggable: true,
+});
+
+defineProps(['userid'])
+
+</script>
+
+<template>
+	<Modal title="拖拽示例"> modal content {{userid}} </Modal>
+</template>
+
+<style scoped>
+
+</style>

packages/types/src/user.ts

@@ -15,6 +15,8 @@ interface UserInfo extends BasicUserInfo {
    * accessToken
    */
   token: string;
+    nick_name: string;
+    role_name: string;
 }
 
 export type { UserInfo };