@ysgroup/core 0.1.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@ysgroup/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "dependencies": {
+    "@ysgroup/contracts": "0.1.1"
+  },
+  "peerDependencies": {
+    "pinia": ">=2.2",
+    "vue": ">=3.5"
+  },
+  "license": "MIT",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+/* @ysgroup/core —— 前端运行时：WS RPC 客户端 / 登录态 / 差量订阅 / REST。 */
+
+export { YsWsClient, type Envelope } from "./ws";
+export { useYsStore } from "./store";
+export {
+	YsRest,
+	YsRestError,
+	type DeleteBlocker,
+	type DeleteImpact,
+	type RevealedCredential,
+	type TopologyNode,
+} from "./rest";

package/src/rest.ts

@@ -0,0 +1,227 @@
+/* @ysgroup/core —— REST 客户端（管理接口，带 JWT）。 */
+
+export class YsRestError extends Error {
+  constructor(
+    public status: number,
+    public detail: unknown,
+  ) {
+    super(typeof detail === "string" ? detail : JSON.stringify(detail));
+    this.name = "YsRestError";
+  }
+}
+
+export interface DeleteBlocker {
+  source_table: string;
+  field: string;
+  title: string;
+  count: number;
+  sample_ids: string[];
+}
+
+export interface DeleteImpact {
+  can_delete: boolean;
+  target: { table: string; id: string };
+  blockers: DeleteBlocker[];
+}
+
+export interface RevealedCredential {
+  plain: string;
+  base64: string;
+}
+
+export class YsRest {
+  constructor(
+    private baseUrl: string,
+    private getToken: () => string,
+  ) {}
+
+  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.getToken()}`,
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      let detail: unknown = text;
+      try {
+        const parsed = JSON.parse(text) as { detail?: unknown };
+        detail = parsed.detail ?? parsed;
+      } catch {
+        // 非 JSON 错误保留原文。
+      }
+      throw new YsRestError(resp.status, detail);
+    }
+    return resp.status === 204 ? (undefined as T) : ((await resp.json()) as T);
+  }
+
+  private async upload<T>(path: string, file: File): Promise<T> {
+    const form = new FormData();
+    form.append("upload", file);
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.getToken()}` },
+      body: form,
+    });
+    if (!resp.ok) {
+      const parsed = await resp.json().catch(() => ({ detail: resp.statusText }));
+      throw new YsRestError(resp.status, parsed.detail ?? parsed);
+    }
+    return (await resp.json()) as T;
+  }
+
+  list<T = Record<string, unknown>>(table: string) {
+    return this.request<T[]>("GET", `/api/tables/${table}`);
+  }
+  upsert<T = Record<string, unknown>>(table: string, doc: Record<string, unknown>) {
+    return this.request<T>("PUT", `/api/tables/${table}`, doc);
+  }
+  remove(table: string, id: string) {
+    return this.request<{ deleted: string }>("DELETE", `/api/tables/${table}/${id}`);
+  }
+  deleteImpact(table: string, id: string) {
+    return this.request<DeleteImpact>("GET", `/api/tables/${table}/${id}/delete-impact`);
+  }
+  revealCredentials(table: string, id: string, body: {
+    fields: string[];
+    password: string;
+    reason: string;
+  }) {
+    return this.request<{
+      credentials: Record<string, RevealedCredential>;
+      expires_in: number;
+    }>("POST", `/api/tables/${table}/${id}/credentials/reveal`, body);
+  }
+  updateCredentials(table: string, id: string, body: {
+    credentials: Record<string, string>;
+    password: string;
+    reason: string;
+  }) {
+    return this.request<{ updated_fields: string[] }>(
+      "POST",
+      `/api/tables/${table}/${id}/credentials/update`,
+      body,
+    );
+  }
+  listApps() {
+    return this.request<Record<string, unknown>[]>("GET", "/api/apps");
+  }
+  listAppReferences() {
+    return this.request<Record<string, unknown>[]>("GET", "/api/apps/reference-list");
+  }
+  createApp(body: Record<string, unknown>) {
+    return this.request<Record<string, unknown>>("POST", "/api/apps", body);
+  }
+  setAppStatus(appId: string, status: string) {
+    return this.request("POST", `/api/apps/${appId}/status/${status}`, {});
+  }
+  setGrants(appId: string, grants: Record<string, unknown>) {
+    return this.request("POST", `/api/apps/${appId}/grants`, grants);
+  }
+  updateApp(appId: string, body: Record<string, unknown>) {
+    return this.request<Record<string, unknown>>("PUT", `/api/apps/${appId}`, body);
+  }
+  rotateSecret(appId: string) {
+    return this.request<{ secret: string }>("POST", `/api/apps/${appId}/rotate_secret`, {});
+  }
+  disableUser(userId: string) {
+    return this.request("POST", `/api/users/${userId}/disable`, {});
+  }
+  issueSso(appName: string) {
+    return this.request<{ code: string; expires_in: number }>("POST", "/api/sso/issue", {
+      app_name: appName,
+    });
+  }
+  portalApps() {
+    return this.request<Record<string, unknown>[]>("GET", "/api/portal/apps");
+  }
+  createUser(body: Record<string, unknown>) {
+    return this.request<Record<string, unknown>>("POST", "/api/users", body);
+  }
+  updateUser(id: string, body: Record<string, unknown>) {
+    return this.request<Record<string, unknown>>("PUT", `/api/users/${id}`, body);
+  }
+  setUserEnabled(id: string, enabled: boolean) {
+    return this.request("POST", `/api/users/${id}/${enabled ? "enable" : "disable"}`, {});
+  }
+  resetUserPassword(id: string, newPassword: string, reason: string) {
+    return this.request("POST", `/api/users/${id}/reset-password`, {
+      new_password: newPassword,
+      reason,
+    });
+  }
+  changeMyPassword(currentPassword: string, newPassword: string) {
+    return this.request("POST", "/api/me/change-password", {
+      current_password: currentPassword,
+      new_password: newPassword,
+    });
+  }
+  removeUser(id: string) {
+    return this.request("DELETE", `/api/users/${id}`);
+  }
+  getUserApps(id: string) {
+    return this.request<string[]>("GET", `/api/users/${id}/apps`);
+  }
+  setUserApps(id: string, appIds: string[]) {
+    return this.request<{ app_ids: string[] }>("PUT", `/api/users/${id}/apps`, {
+      app_ids: appIds,
+    });
+  }
+  uploadOpenAccountConfirmation(ownerId: string, file: File) {
+    return this.upload<{
+      file_id: string;
+      parsed: Record<string, string>;
+      exchange_account_id: string;
+      exchange_account_created: boolean;
+    }>(`/api/owners/${ownerId}/open-account-confirmation`, file);
+  }
+  upsertMountExchangeAccount(body: Record<string, unknown>) {
+    return this.request<Record<string, unknown>>("PUT", "/api/mount-exchange-accounts", body);
+  }
+  setProjectOwners(projectId: string, ownerIds: string[]) {
+    return this.request<{ owner_ids: string[] }>("PUT", `/api/projects/${projectId}/owners`, {
+      owner_ids: ownerIds,
+    });
+  }
+  getRelations(entity: "owners" | "accounts", id: string,
+               relation: "apps" | "strategies") {
+    return this.request<{ ids: string[] }>(
+      "GET", `/api/${entity}/${id}/relations/${relation}`,
+    );
+  }
+  setRelations(entity: "owners" | "accounts", id: string,
+               relation: "apps" | "strategies", ids: string[]) {
+    return this.request<{ ids: string[] }>(
+      "PUT", `/api/${entity}/${id}/relations/${relation}`, { ids },
+    );
+  }
+  listOwnerFiles(ownerId: string) {
+    return this.request<Record<string, unknown>[]>("GET", `/api/owners/${ownerId}/files`);
+  }
+  downloadFile(fileId: string) {
+    return fetch(`${this.baseUrl}/api/files/${fileId}/download`, {
+      headers: { Authorization: `Bearer ${this.getToken()}` },
+    }).then(async (resp) => {
+      if (!resp.ok) throw new YsRestError(resp.status, await resp.text());
+      return resp.blob();
+    });
+  }
+  topology() {
+    return this.request<{ nodes: TopologyNode[] }>("GET", "/api/meta/topology");
+  }
+}
+
+export interface TopologyNode {
+  name: string;
+  title: string;
+  kind: string;
+  status: string;
+  port: number;
+  online: boolean;
+  last_heartbeat_at: number;
+  subscribed_tables: string[];
+  heartbeat?: Record<string, unknown>;
+}

package/src/store.ts

@@ -0,0 +1,196 @@
+/* @ysgroup/core —— 登录态 + 差量订阅缓存（Pinia store）。 */
+import { defineStore } from "pinia";
+import { ref, computed } from "vue";
+import { YsWsClient } from "./ws";
+
+interface LoginResult {
+  user?: Record<string, unknown>;
+  access_token: string;
+  refresh_token: string;
+  access_expires_in: number;
+}
+
+const LS_ACCESS = "ys_access_token";
+const LS_REFRESH = "ys_refresh_token";
+
+export const useYsStore = defineStore("ys", () => {
+  const user = ref<Record<string, unknown> | null>(null);
+  const accessToken = ref<string>(localStorage.getItem(LS_ACCESS) ?? "");
+  const refreshToken = ref<string>(localStorage.getItem(LS_REFRESH) ?? "");
+  const connected = ref(false);
+  const appName = ref("");
+  /** 差量订阅的表数据：table -> Map<id, doc> */
+  const tables = ref<Record<string, Map<string, Record<string, unknown>>>>({});
+
+  let ws: YsWsClient | null = null;
+  let renewTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const isLoggedIn = computed(() => !!accessToken.value);
+
+  function tableList(table: string): Record<string, unknown>[] {
+    return Array.from(tables.value[table]?.values() ?? []);
+  }
+
+  function connect(wsUrl: string, app: string) {
+    appName.value = app;
+    ws = new YsWsClient(wsUrl);
+    ws.on("__connected", () => {
+      connected.value = true;
+      if (refreshToken.value && !user.value) void renew();
+    });
+    ws.on("__disconnected", () => (connected.value = false));
+    ws.on("snapshot", (d: unknown) => applySnapshot(d as SnapshotData));
+    ws.on("delta", (d: unknown) => applyDelta(d as DeltaData));
+    ws.on("user_revoked", (d: unknown) => onRevoked(d as { user_id: string }));
+    ws.on("resync", () => {}); // 前端订阅本子系统后端，resync 由后端 SDK 处理
+    ws.start();
+  }
+
+  interface SnapshotData {
+    table: string;
+    docs: Record<string, unknown>[];
+    batch: number;
+    total: number;
+  }
+  interface DeltaData {
+    table: string;
+    changes: { op: string; doc: Record<string, unknown> }[];
+  }
+
+  const snapshotBuf: Record<string, Record<string, unknown>[]> = {};
+
+  function applySnapshot(d: SnapshotData) {
+    (snapshotBuf[d.table] ??= []).push(...d.docs);
+    if (d.batch < d.total) return;
+    const map = new Map<string, Record<string, unknown>>();
+    for (const doc of snapshotBuf[d.table]) map.set(String(doc._id), doc);
+    tables.value = { ...tables.value, [d.table]: map };
+    delete snapshotBuf[d.table];
+  }
+
+  function applyDelta(d: DeltaData) {
+    const map = tables.value[d.table] ?? new Map();
+    for (const c of d.changes) {
+      const id = String(c.doc._id);
+      if (c.op === "delete") map.delete(id);
+      else map.set(id, c.doc);
+    }
+    tables.value = { ...tables.value, [d.table]: new Map(map) };
+  }
+
+  function onRevoked(d: { user_id: string }) {
+    if (user.value && String(user.value._id) === d.user_id) void logout();
+  }
+
+  async function login(username: string, password: string, otp = ""): Promise<void> {
+    if (!ws) throw new Error("未连接");
+    const result = (await ws.call("login", {
+      username,
+      password,
+      otp,
+      app_name: appName.value,
+      user_agent: navigator.userAgent,
+    })) as LoginResult;
+    setSession(result);
+  }
+
+  /** 门户一次性 code 单点登录（子系统前端启动时检测 URL 上的 ?ys_code=）。 */
+  async function loginByCode(code: string): Promise<void> {
+    await waitUntilConnected();
+    if (!ws) throw new Error("未连接");
+    const result = (await ws.call("exchange_sso_code", { code })) as LoginResult;
+    setSession(result);
+  }
+
+  async function waitUntilConnected(timeoutMs = 10000): Promise<void> {
+    if (connected.value) return;
+    if (!ws) throw new Error("未连接");
+    await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        off();
+        reject(new Error("连接服务超时"));
+      }, timeoutMs);
+      const off = ws!.on("__connected", () => {
+        clearTimeout(timer);
+        off();
+        resolve();
+      });
+    });
+  }
+
+  async function changeMyPassword(currentPassword: string, newPassword: string): Promise<void> {
+    if (!ws || !accessToken.value) throw new Error("未登录");
+    if (
+      String(user.value?.role ?? "") === "Root" ||
+      String(user.value?.username ?? "").trim().toLowerCase() === "root"
+    ) {
+      throw new Error("Root 不允许修改登录密码");
+    }
+    await ws.call("change_password", {
+      access_token: accessToken.value,
+      current_password: currentPassword,
+      new_password: newPassword,
+    });
+    clearSession();
+  }
+
+  function setSession(result: LoginResult) {
+    if (result.user) user.value = result.user;
+    accessToken.value = result.access_token;
+    refreshToken.value = result.refresh_token;
+    localStorage.setItem(LS_ACCESS, result.access_token);
+    localStorage.setItem(LS_REFRESH, result.refresh_token);
+    scheduleRenew(result.access_expires_in);
+  }
+
+  function scheduleRenew(ttl: number) {
+    if (renewTimer) clearTimeout(renewTimer);
+    // 提前 60s 静默续期
+    renewTimer = setTimeout(() => void renew(), Math.max(10, ttl - 60) * 1000);
+  }
+
+  async function renew() {
+    if (!ws || !refreshToken.value) return;
+    try {
+      const result = (await ws.call("refresh", {
+        refresh_token: refreshToken.value,
+      })) as LoginResult;
+      if (result.user) user.value = result.user;
+      accessToken.value = result.access_token;
+      refreshToken.value = result.refresh_token;
+      localStorage.setItem(LS_ACCESS, result.access_token);
+      localStorage.setItem(LS_REFRESH, result.refresh_token);
+      scheduleRenew(result.access_expires_in);
+    } catch {
+      void logout();
+    }
+  }
+
+  async function logout() {
+    const token = refreshToken.value;
+    if (ws && token) {
+      try {
+        await ws.call("logout", { refresh_token: token });
+      } catch {
+        // 本地退出必须可用；服务端不可达时仍清除浏览器状态。
+      }
+    }
+    clearSession();
+  }
+
+  function clearSession() {
+    user.value = null;
+    accessToken.value = "";
+    refreshToken.value = "";
+    localStorage.removeItem(LS_ACCESS);
+    localStorage.removeItem(LS_REFRESH);
+    if (renewTimer) clearTimeout(renewTimer);
+    renewTimer = null;
+  }
+
+  return {
+    user, accessToken, refreshToken, connected, isLoggedIn, tables,
+    tableList, connect, login, loginByCode, waitUntilConnected, changeMyPassword, renew, logout,
+    client: () => ws,
+  };
+});

package/src/ws.ts

@@ -0,0 +1,123 @@
+/* @ysgroup/core —— 浏览器端 WS RPC 客户端（与 ys_base.ws.WsRpcClient 信封协议对齐）。 */
+
+export interface Envelope {
+  event: string;
+  id?: string;
+  reply_to?: string;
+  code?: number;
+  message?: string;
+  ts?: number;
+  data?: unknown;
+}
+
+type EventHandler = (data: unknown) => void;
+
+export class YsWsClient {
+  private ws: WebSocket | null = null;
+  private seq = 0;
+  private connectionId = "";
+  private pending = new Map<string, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+  private handlers = new Map<string, EventHandler[]>();
+  private reconnectDelay = 1000;
+  private stopped = false;
+
+  constructor(
+    private url: string,
+    private callTimeout = 10_000,
+  ) {}
+
+  start(): void {
+    this.stopped = false;
+    this.connect();
+  }
+
+  stop(): void {
+    this.stopped = true;
+    this.ws?.close();
+  }
+
+  on(event: string, handler: EventHandler): () => void {
+    const list = this.handlers.get(event) ?? [];
+    list.push(handler);
+    this.handlers.set(event, list);
+    return () => {
+      const current = this.handlers.get(event) ?? [];
+      const next = current.filter((item) => item !== handler);
+      if (next.length) this.handlers.set(event, next);
+      else this.handlers.delete(event);
+    };
+  }
+
+  call(event: string, data: unknown = {}): Promise<unknown> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error("not connected"));
+    }
+    const id = `${this.connectionId || "c0"}:${++this.seq}`;
+    this.ws.send(JSON.stringify({ event, id, ts: Date.now() / 1000, data }));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`call ${event} timed out`));
+      }, this.callTimeout);
+      this.pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        },
+      });
+    });
+  }
+
+  send(event: string, data: unknown = {}): void {
+    this.ws?.send(JSON.stringify({ event, ts: Date.now() / 1000, data }));
+  }
+
+  private connect(): void {
+    const ws = new WebSocket(this.url);
+    this.ws = ws;
+    ws.onopen = () => {
+      this.reconnectDelay = 1000;
+    };
+    ws.onmessage = (e) => this.onMessage(e);
+    ws.onclose = () => {
+      for (const p of this.pending.values()) p.reject(new Error("connection lost"));
+      this.pending.clear();
+      this.emit("__disconnected", null);
+      if (!this.stopped) {
+        setTimeout(() => this.connect(), this.reconnectDelay + Math.random() * 1000);
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, 30_000);
+      }
+    };
+  }
+
+  private onMessage(e: MessageEvent): void {
+    let msg: Envelope;
+    try {
+      msg = JSON.parse(e.data as string);
+    } catch {
+      return;
+    }
+    if (msg.reply_to) {
+      const p = this.pending.get(msg.reply_to);
+      if (p) {
+        this.pending.delete(msg.reply_to);
+        if ((msg.code ?? 0) === 0) p.resolve(msg.data);
+        else p.reject(new Error(`[${msg.code}] ${msg.message ?? ""}`));
+      }
+      return;
+    }
+    if (msg.event === "hello") {
+      this.connectionId = String((msg.data as { connection_id?: string })?.connection_id ?? "");
+      this.emit("__connected", msg.data);
+    }
+    this.emit(msg.event, msg.data);
+  }
+
+  private emit(event: string, data: unknown): void {
+    for (const h of this.handlers.get(event) ?? []) h(data);
+  }
+}