vome-core 0.0.16 → 0.0.18

package/dist/client/base.js

@@ -0,0 +1,77 @@
+import { getClientRequest } from "./configure";
+function stripTimeMeta(data) {
+  if (Array.isArray(data))
+    return data.map((item) => stripTimeMeta(item));
+  if (data && typeof data === "object") {
+    const out = { ...data };
+    delete out.createTime;
+    delete out.updateTime;
+    return out;
+  }
+  return data;
+}
+
+export class BaseService {
+  namespace;
+  constructor(namespace) {
+    if (namespace)
+      this.namespace = namespace.replace(/^\//, "");
+  }
+  async request(options = {}) {
+    let url = options.url || "";
+    if (url && !/^https?:\/\//.test(url)) {
+      if (this.namespace) {
+        const ns = this.namespace.startsWith("/") ? this.namespace : `/${this.namespace}`;
+        url = url.startsWith("/") ? `${ns}${url}` : `${ns}/${url}`;
+      }
+      if (!url.startsWith("/"))
+        url = `/${url}`;
+    }
+    const request = getClientRequest();
+    const method = (options.method || "GET").toUpperCase();
+    if (method === "GET") {
+      const params = options.params || {};
+      const q = new URLSearchParams;
+      for (const [k, v] of Object.entries(params)) {
+        if (v == null)
+          continue;
+        q.set(k, String(v));
+      }
+      const qs = q.toString();
+      return request(qs ? `${url}?${qs}` : url);
+    }
+    return request(url, {
+      method,
+      body: JSON.stringify(stripTimeMeta(options.data ?? {}))
+    });
+  }
+  page(data = {}) {
+    return this.request({ url: "/page", method: "POST", data });
+  }
+  list(data = {}) {
+    return this.request({
+      url: "/list",
+      method: "POST",
+      data
+    });
+  }
+  info(params) {
+    return this.request({
+      url: "/info",
+      method: "GET",
+      params
+    });
+  }
+  add(data) {
+    return this.request({ url: "/add", method: "POST", data });
+  }
+  update(data) {
+    return this.request({ url: "/update", method: "POST", data });
+  }
+  delete(data) {
+    return this.request({ url: "/delete", method: "POST", data });
+  }
+  restore(data) {
+    return this.request({ url: "/restore", method: "POST", data });
+  }
+}

package/dist/client/configure.d.ts

@@ -0,0 +1,9 @@
+import type { RequestOptions } from '../../typings/admin/comm/request';
+/** 宿主注入的 HTTP 能力（admin / web / uni 各自实现） */
+export type ClientRequestFn = <T>(path: string, init?: RequestOptions) => Promise<T>;
+export type ClientHooks = {
+    request: ClientRequestFn;
+};
+/** 各端在加载 request 后立刻调用一次 */
+export declare function configureClient(next: ClientHooks): void;
+export declare function getClientRequest(): ClientRequestFn;

package/dist/client/configure.js

@@ -0,0 +1,10 @@
+let hooks = null;
+export function configureClient(next) {
+  hooks = next;
+}
+export function getClientRequest() {
+  if (!hooks?.request) {
+    throw new Error("[vome-client] configureClient({ request }) before loadEps / service");
+  }
+  return hooks.request;
+}

package/dist/client/eps.d.ts

@@ -0,0 +1,12 @@
+import type { EpsEntity, EpsModuleMap } from '../../typings/admin/comm/eps';
+export type EpsSide = 'admin' | 'app';
+/** 拉取 EPS；公开接口建议 request 侧 toast:false */
+export declare function loadEps(force?: boolean, side?: EpsSide): Promise<EpsModuleMap>;
+export declare function loadAllEps(force?: boolean): Promise<{
+    admin: EpsModuleMap;
+    app: EpsModuleMap;
+}>;
+export declare function getEps(side?: EpsSide): EpsModuleMap;
+/** 按 prefix 找实体，如 /admin/base/user、/app/user/info */
+export declare function findEpsEntity(prefix: string, side?: EpsSide): EpsEntity;
+export declare function clearEpsCache(side?: EpsSide): void;

package/dist/client/eps.js

@@ -0,0 +1,42 @@
+import { getClientRequest } from "./configure";
+const EPS_URL = {
+  admin: "/admin/base/open/eps",
+  app: "/app/base/open/eps"
+};
+const cache = {
+  admin: null,
+  app: null
+};
+export async function loadEps(force = false, side = "admin") {
+  if (cache[side] && !force)
+    return cache[side];
+  const request = getClientRequest();
+  cache[side] = await request(EPS_URL[side], { toast: false }) || {};
+  return cache[side];
+}
+export async function loadAllEps(force = false) {
+  await Promise.all([loadEps(force, "admin"), loadEps(force, "app")]);
+  return { admin: cache.admin, app: cache.app };
+}
+export function getEps(side = "admin") {
+  return cache[side];
+}
+export function findEpsEntity(prefix, side = "admin") {
+  const map = cache[side];
+  if (!map)
+    return;
+  for (const list of Object.values(map)) {
+    const hit = list.find((e) => e.prefix === prefix || e.prefix === prefix.replace(/\/$/, ""));
+    if (hit)
+      return hit;
+  }
+  return;
+}
+export function clearEpsCache(side) {
+  if (side) {
+    cache[side] = null;
+    return;
+  }
+  cache.admin = null;
+  cache.app = null;
+}

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export { configureClient, getClientRequest, type ClientHooks, type ClientRequestFn, } from './configure';
+export { loadEps, loadAllEps, getEps, findEpsEntity, clearEpsCache, type EpsSide, } from './eps';
+export { BaseService } from './base';
+export { service, getService, createEps, bindEpsHotReload, setServicePerms, resolveService, serviceOf, createEpsService, type CreateEpsOptions, type ServiceLeaf, type ServiceTree, } from './service';

package/dist/client/index.js

@@ -0,0 +1,22 @@
+export {
+  configureClient,
+  getClientRequest
+} from "./configure";
+export {
+  loadEps,
+  loadAllEps,
+  getEps,
+  findEpsEntity,
+  clearEpsCache
+} from "./eps";
+export { BaseService } from "./base";
+export {
+  service,
+  getService,
+  createEps,
+  bindEpsHotReload,
+  setServicePerms,
+  resolveService,
+  serviceOf,
+  createEpsService
+} from "./service";

package/dist/client/service.d.ts

@@ -0,0 +1,31 @@
+import type { ServiceLeaf, ServiceTree } from '../../typings/admin/comm/service';
+import { BaseService } from './base';
+import { type EpsSide } from './eps';
+type ServiceRoot = ServiceTree & {
+    request: BaseService['request'];
+};
+export declare function getService(side?: EpsSide): ServiceRoot;
+/** 兼容旧 admin：默认 admin 侧 service */
+export declare const service: ServiceRoot;
+export type CreateEpsOptions = {
+    force?: boolean;
+    side?: EpsSide;
+    /**
+     * 挂载后必须存在的根模块键（admin 为 base）。
+     * false = 只校验 EPS 非空。
+     */
+    requireRoot?: string | false;
+};
+/**
+ * 从 EPS 重建 service 树。
+ * 兼容旧签名：`createEps()` / `createEps(true)` → admin。
+ */
+export declare function createEps(forceOrOpts?: boolean | CreateEpsOptions): Promise<ServiceRoot>;
+/** 开发态：监听 Vite `eps-update` 热更（各端自行调用） */
+export declare function bindEpsHotReload(side?: EpsSide): void;
+export declare function setServicePerms(perms: string[], isSuper?: boolean, side?: EpsSide): void;
+export declare function resolveService(path: string, side?: EpsSide): ServiceLeaf | undefined;
+export declare function serviceOf(prefix: string, side?: EpsSide): ServiceLeaf;
+/** @deprecated 请用 service.xxx */
+export declare function createEpsService(prefix: string, side?: EpsSide): ServiceLeaf;
+export type { ServiceLeaf, ServiceTree };

package/dist/client/service.js

@@ -0,0 +1,299 @@
+import { BaseService } from "./base";
+import { loadEps } from "./eps";
+function toCamel(str) {
+  return str.replace(/([^-])(?:-+([^-]))/g, (_m, a, b) => a + String(b).toUpperCase());
+}
+function methodName(path) {
+  return path.replace(/^\//, "").replace(/[:,\s/-]/g, "");
+}
+function isValidName(name) {
+  return Boolean(name) && !["{", "}", ":"].some((c) => name.includes(c));
+}
+function resolvePermCode(prefix, action, side) {
+  const parts = prefix.replace(/^\//, "").split("/").filter(Boolean);
+  const module = side === "admin" ? parts[1] || parts[0] || "base" : parts[0] || "user";
+  let resource = side === "admin" ? parts.slice(2).join(":") : parts.slice(1).join(":");
+  if (resource === module) {
+    resource = module;
+  } else if (resource.startsWith(`${module}:`)) {
+    resource = resource.slice(module.length + 1);
+  }
+  const head = `${module}-`;
+  if (resource.startsWith(head))
+    resource = resource.slice(head.length);
+  resource = resource.replace(/-/g, ":");
+  if (!resource)
+    resource = module;
+  return `${module}:${resource}:${action}`;
+}
+function prefixToParts(prefix, side) {
+  const raw = prefix.replace(/^\//, "");
+  return raw.replace(new RegExp(`^${side}/?`), "").split("/").filter(Boolean).map(toCamel);
+}
+function bindCrud(leaf, base) {
+  const proto = BaseService.prototype;
+  for (const name of [
+    "request",
+    "page",
+    "list",
+    "info",
+    "add",
+    "update",
+    "delete",
+    "restore"
+  ]) {
+    const fn = proto[name];
+    if (typeof fn === "function") {
+      leaf[name] = fn.bind(base);
+    }
+  }
+}
+function bindApis(leaf, base, apis, side) {
+  leaf.permission ||= {};
+  for (const api of apis) {
+    const name = methodName(api.path);
+    if (!isValidName(name) || /[-:]/g.test(name))
+      continue;
+    const method = (api.method || "get").toLowerCase();
+    leaf[name] = function(data) {
+      return this.request({
+        url: api.path.startsWith("/") ? api.path : `/${api.path}`,
+        method,
+        [method === "post" ? "data" : "params"]: data
+      });
+    }.bind(base);
+    leaf.permission[name] = api.perms?.[0] || resolvePermCode(`/${leaf.namespace}`, name, side);
+  }
+}
+function createLeaf(namespace, apis = [], side) {
+  const ns = namespace.replace(/^\//, "");
+  const base = new BaseService(ns);
+  const leaf = base;
+  leaf.namespace = ns;
+  leaf.permission = {};
+  leaf._permission = {};
+  bindCrud(leaf, base);
+  bindApis(leaf, base, apis, side);
+  return leaf;
+}
+function attachLeaf(tree, prefix, apis = [], side) {
+  const raw = prefix.replace(/^\//, "");
+  const arr = prefixToParts(prefix, side);
+  if (!arr.length)
+    return;
+  let node = tree;
+  for (let i = 0;i < arr.length; i++) {
+    const key = arr[i];
+    const isLast = i === arr.length - 1;
+    if (!isLast) {
+      const cur = node[key];
+      if (!cur || typeof cur !== "object" || "namespace" in cur) {
+        node[key] = {};
+      }
+      node = node[key];
+      continue;
+    }
+    const leaf = createLeaf(raw, apis, side);
+    node[key] = leaf;
+    return leaf;
+  }
+  return;
+}
+function buildFromEps(map, side, root) {
+  const list = Object.values(map).flat();
+  for (const e of list) {
+    if (!e?.prefix)
+      continue;
+    const leaf = attachLeaf(root, e.prefix, e.api || [], side);
+    if (leaf) {
+      const op = e.pageQueryOp;
+      if (op) {
+        leaf.search = {
+          fieldEq: op.fieldEq,
+          fieldLike: op.fieldLike,
+          fieldArray: op.fieldArray,
+          fieldRange: op.fieldRange,
+          keyWordLikeFields: op.keyWordLikeFields
+        };
+      }
+    }
+  }
+}
+function normalizeEpsMap(input) {
+  if (!input || typeof input !== "object")
+    return {};
+  const m = input;
+  if ("code" in m && "data" in m && m.data && typeof m.data === "object" && !Array.isArray(m.data)) {
+    return m.data;
+  }
+  return input;
+}
+function countPrefixedEntities(map) {
+  return Object.values(map).flat().filter((e) => e && typeof e === "object" && Boolean(e.prefix)).length;
+}
+function rootKey(side) {
+  return Symbol.for(`vome.${side}.service.root`);
+}
+function epsKey(side) {
+  return Symbol.for(`vome.${side}.service.eps`);
+}
+function createServiceRoot() {
+  const root = new BaseService;
+  return {
+    request: root.request.bind(root)
+  };
+}
+function getOrCreateRoot(side) {
+  const g = globalThis;
+  const key = rootKey(side);
+  if (!g[key]) {
+    g[key] = createServiceRoot();
+  }
+  return g[key];
+}
+function resetServiceModules(side) {
+  const root = getOrCreateRoot(side);
+  for (const key of Object.keys(root)) {
+    if (key === "request")
+      continue;
+    delete root[key];
+  }
+}
+function createServiceProxy(side) {
+  return new Proxy({}, {
+    get(_t, prop, _r) {
+      const root = getOrCreateRoot(side);
+      const val = Reflect.get(root, prop, root);
+      return typeof val === "function" ? val.bind(root) : val;
+    },
+    set(_t, prop, value) {
+      return Reflect.set(getOrCreateRoot(side), prop, value);
+    },
+    has(_t, prop) {
+      return Reflect.has(getOrCreateRoot(side), prop);
+    },
+    ownKeys() {
+      return Reflect.ownKeys(getOrCreateRoot(side));
+    },
+    getOwnPropertyDescriptor(_t, prop) {
+      const desc = Reflect.getOwnPropertyDescriptor(getOrCreateRoot(side), prop);
+      if (desc)
+        desc.configurable = true;
+      return desc;
+    }
+  });
+}
+const serviceBySide = {};
+export function getService(side = "admin") {
+  if (!serviceBySide[side]) {
+    serviceBySide[side] = createServiceProxy(side);
+  }
+  return serviceBySide[side];
+}
+export const service = getService("admin");
+export async function createEps(forceOrOpts = false) {
+  const opts = typeof forceOrOpts === "boolean" ? { force: forceOrOpts, side: "admin", requireRoot: "base" } : {
+    side: "admin",
+    requireRoot: forceOrOpts.side === "app" ? false : "base",
+    ...forceOrOpts
+  };
+  const side = opts.side ?? "admin";
+  const force = Boolean(opts.force);
+  const requireRoot = opts.requireRoot === undefined ? side === "admin" ? "base" : false : opts.requireRoot;
+  const g = globalThis;
+  const promiseKey = epsKey(side);
+  if (!force && g[promiseKey])
+    return g[promiseKey];
+  const run = (async () => {
+    const raw = await loadEps(force, side) || {};
+    const map = normalizeEpsMap(raw);
+    const n = countPrefixedEntities(map);
+    if (!n) {
+      throw new Error(`[vome-eps] empty or invalid — enable vome.eps and check GET /${side}/base/open/eps`);
+    }
+    resetServiceModules(side);
+    const root = getOrCreateRoot(side);
+    buildFromEps(map, side, root);
+    if (requireRoot) {
+      const hit = root[requireRoot];
+      if (!hit || typeof hit !== "object") {
+        throw new Error(`[vome-eps] mount failed: service.${requireRoot} missing after EPS apply`);
+      }
+    }
+    return root;
+  })();
+  g[promiseKey] = run;
+  try {
+    return await run;
+  } catch (e) {
+    g[promiseKey] = null;
+    throw e;
+  }
+}
+export function bindEpsHotReload(side = "admin") {
+  try {
+    const meta = import.meta;
+    if (!meta.hot)
+      return;
+    meta.hot.on("eps-update", () => {
+      globalThis[epsKey(side)] = null;
+      createEps({ force: true, side }).then(() => {
+        if (meta.env?.DEV)
+          console.log(`[vome-eps] ${side} service hot updated`);
+      });
+    });
+  } catch {}
+}
+export function setServicePerms(perms, isSuper = false, side = "admin") {
+  const list = perms || [];
+  const root = getOrCreateRoot(side);
+  const sidePrefix = `${side}/`;
+  function deep(d) {
+    if (!d || typeof d !== "object")
+      return;
+    const obj = d;
+    if (obj.permission && obj.namespace) {
+      obj._permission = {};
+      for (const key of Object.keys(obj.permission)) {
+        if (isSuper) {
+          obj._permission[key] = true;
+          continue;
+        }
+        const code = obj.permission[key];
+        obj._permission[key] = list.includes(code) || list.some((p) => p.replace(/:/g, "/").includes(`${obj.namespace.replace(new RegExp(`^${sidePrefix}`), "")}/${key}`));
+      }
+      return;
+    }
+    for (const k of Object.keys(obj)) {
+      if (k === "request")
+        continue;
+      deep(obj[k]);
+    }
+  }
+  deep(root);
+}
+export function resolveService(path, side = "admin") {
+  const parts = path.replace(/^\//, "").split(".").filter(Boolean);
+  let cur = getOrCreateRoot(side);
+  for (const p of parts) {
+    if (!cur || typeof cur !== "object")
+      return;
+    cur = cur[p];
+  }
+  if (cur && typeof cur === "object" && "namespace" in cur) {
+    return cur;
+  }
+  return;
+}
+export function serviceOf(prefix, side = "admin") {
+  const raw = prefix.replace(/\/$/, "");
+  const path = prefixToParts(raw, side).join(".");
+  const hit = resolveService(path, side);
+  if (!hit) {
+    throw new Error(`[vome-eps] service missing: ${prefix} (await createEps first)`);
+  }
+  return hit;
+}
+export function createEpsService(prefix, side = "admin") {
+  return serviceOf(prefix, side);
+}

package/dist/client/vite-plugin-eps.d.ts

@@ -0,0 +1,42 @@
+import type { Plugin } from 'vite';
+export type EpsSide = 'admin' | 'app';
+type EpsApi = {
+    method?: string;
+    path?: string;
+    summary?: string;
+    perms?: string[];
+};
+type EpsColumn = {
+    propertyName?: string;
+    type?: string;
+    comment?: string;
+    nullable?: boolean;
+};
+type EpsEntity = {
+    module?: string;
+    prefix?: string;
+    name?: string;
+    api?: EpsApi[];
+    columns?: EpsColumn[];
+    pageColumns?: EpsColumn[];
+};
+/** 生成 declare namespace Eps（按 side 剥前缀） */
+export declare function buildEpsDts(map: Record<string, EpsEntity[]>, side: EpsSide): string;
+export type EpsVitePluginOptions = {
+    /** 生成哪一侧的 d.ts；both 时 d.ts 仍以 dtsSide 为准，json 含双侧 */
+    side?: EpsSide | 'both';
+    /** d.ts 使用的侧，默认与 side 相同；side=both 时默认 admin */
+    dtsSide?: EpsSide;
+    /** 后端根，默认 http://127.0.0.1:3001 */
+    apiBase?: string;
+    /** eps.json 目录，相对项目根，默认 build */
+    dist?: string;
+    /** eps.d.ts 路径，相对项目根，默认 typings/eps.d.ts */
+    dts?: string;
+};
+/**
+ * Vite 插件：拉 EPS → typings/eps.d.ts + build/eps.json
+ * web / uniapp 用 side:'app'；admin 可用 side:'both'
+ */
+export declare function createEpsVitePlugin(options?: EpsVitePluginOptions): Plugin;
+export {};