web-dc-api 0.0.72 → 0.0.74

package/lib/serverless/babel-browser.ts

@@ -0,0 +1,39 @@
+export async function loadBabel() {
+  if (!(globalThis as any).process) {
+    (globalThis as any).process = { env: {} };
+  }
+
+  const [parserMod, typesMod, traverseMod] = await Promise.all([
+    import("@babel/parser"),
+    import("@babel/types"),
+    import("@babel/traverse"),
+  ]);
+
+  // 规范化 parser.parse（兼容多种打包形态）
+  const parse =
+    (parserMod as any).parse ??
+    (parserMod as any).default?.parse ??
+    (parserMod as any).default; // 有些打包器把默认导出直接设为 parse
+
+  if (typeof parse !== "function") {
+    console.error("parserMod keys:", Object.keys(parserMod));
+    throw new Error("Failed to resolve @babel/parser.parse as a function");
+  }
+
+  // types：有的环境在 default 下
+  const t = (typesMod as any).default ?? typesMod;
+
+  // 规范化 traverse
+  const traverse: (node: any, visitors: any) => void =
+    (traverseMod as any).default?.default ??
+    (traverseMod as any).default ??
+    (traverseMod as any).traverse ??
+    (traverseMod as any);
+
+  if (typeof traverse !== "function") {
+    console.error("traverseMod keys:", Object.keys(traverseMod));
+    throw new Error("Failed to resolve @babel/traverse as a function");
+  }
+
+  return { parse, t, traverse };
+}

package/lib/serverless/base_entity.ts

@@ -0,0 +1,78 @@
+// 领域模型基类：不包含任何存储逻辑
+export abstract class BaseEntity {
+  // 默认元字段
+  public dc_timestamp?: number;  // 毫秒时间戳
+  public dc_opuser?: string;    // 操作人
+
+  constructor() {
+    // 时间戳,opuser 留空，主要用于从dc取回数据时填充
+   
+  }
+
+  // 可重写以自定义主键策略
+  protected getPrimaryKey(): string {
+    const anySelf = this as any;
+    const id = anySelf.id ?? anySelf.key ?? anySelf.pk;
+
+    // 仅判 null/undefined，为 0 的数字是合法主键
+    if (id === null || id === undefined) {
+      throw new Error(`${this.constructor.name}: primary key (id/key/pk) is required`);
+    }
+
+    if (typeof id === 'string') {
+      const s = id.trim();
+      if (s.length === 0) {
+        throw new Error(`${this.constructor.name}: primary key (string) cannot be empty`);
+      }
+      return s;
+    }
+
+    if (typeof id === 'number') {
+      if (Number.isNaN(id)) {
+        throw new Error(`${this.constructor.name}: primary key (number) cannot be NaN`);
+      }
+      return String(id);
+    }
+
+    if (typeof id === 'bigint') {
+      return id.toString();
+    }
+
+    // 其它类型统一转字符串（如需自定义请在子类中重写）
+    return String(id);
+  }
+
+  // 标记更新时间与操作人
+  touch(opuser?: string, timeMs: number = Date.now()): this {
+    this.dc_timestamp = timeMs;
+    if (opuser !== undefined) this.dc_opuser = opuser;
+    return this;
+  }
+
+  // 设置操作人
+  setOpUser(opuser: string): this {
+    this.dc_opuser = opuser;
+    return this;
+  }
+
+  // 可选：领域校验（子类覆盖）
+  validate(): void {
+    // no-op by default
+  }
+
+  // 工厂：从 PlainObject 创建实体
+  static from<T extends BaseEntity>(this: new () => T, data: Partial<T>): T {
+    const inst = new this();
+    Object.assign(inst, data);
+    return inst;
+  }
+
+  // 导出为可序列化对象（可覆写以裁剪敏感字段）
+  toJSON(): Record<string, unknown> {
+    const out: Record<string, unknown> = {};
+    for (const k of Object.keys(this as any)) {
+      (out as any)[k] = (this as any)[k];
+    }
+    return out;
+  }
+}

package/lib/serverless/base_repository.ts

@@ -0,0 +1,284 @@
+import { Direction } from "../common/define";
+import type { IKeyValueOperations } from "../interfaces/keyvalue-interface";
+import type { KeyValueDB } from "../implements/keyvalue/manager";
+import { metadata } from "./decorator_factory";
+import { BaseEntity } from "./base_entity";
+
+type Ctor<T> = new (...args: any[]) => T;
+
+const EXTRA_SEP = "$$$dckv_extra$$$";
+
+function extractRawValue(s: string): [string, string]  {
+  const i = s.indexOf(EXTRA_SEP);
+  return i >= 0 ? [s.slice(0, i), s.slice(i + EXTRA_SEP.length)] : [s, ""];
+}
+
+function safeParseJSON<T>(s: string | null): T | null {
+  if (!s) return null;
+  try { return JSON.parse(s) as T; } catch { return null; }
+}
+
+
+
+
+// 兼容 getWithIndex 返回的两种格式（string[] 或 Record<string,string>[]）
+function parseIndexResultValues(raw: string): string[] {
+  const parsed = safeParseJSON<any>(raw);
+  if (!Array.isArray(parsed)) return [];
+  const out: string[] = [];
+  for (const item of parsed) {
+    if (typeof item === "string") {
+      out.push(item);
+    } else if (item && typeof item === "object") {
+      for (const v of Object.values(item)) {
+        if (v != null) out.push(String(v));
+      }
+    }
+  }
+  return out;
+}
+
+function maybeStripKeyPrefix(s: string): string {
+  const t = s.trimStart();
+  const i = t.indexOf(":");
+  if (i > 0 && i < 64 && t[0] !== "{" && t[0] !== "[" && t[0] !== "\"") {
+    return t.slice(i + 1).trim();
+  }
+  return s;
+}
+
+
+
+// 将列声明类型与实际值映射到 KV 可识别的索引类型和值
+function asIndexTypeAndValue(value: unknown, declaredType?: string): { type: string; value: string } {
+  const t = declaredType ?? (value instanceof Date ? "date" : typeof value);
+  switch (t) {
+    case "date":
+      return { type: "number", value: String(value instanceof Date ? value.getTime() : Number(value)) };
+    case "boolean":
+      return { type: "number", value: String(value ? 1 : 0) };
+    case "number":
+      return { type: "number", value: String(value ?? 0) };
+    case "json":
+      return { type: "json", value: JSON.stringify(value) };
+    default:
+      return { type: "string", value: String(value ?? "") };
+  }
+}
+
+function buildIndexPayload(entity: object, ctor: Function): string {
+  const cols = metadata.getColumns(ctor);
+  const colTypeByName = new Map<string, string>();
+  cols.forEach(c => {
+    if (c.options?.type) colTypeByName.set(c.resolvedName, c.options.type);
+  });
+
+  const idxMetas = metadata.getIndexes(ctor);
+  const items: Array<{ key: string; type: string; value: string }> = [];
+
+    for (const idx of idxMetas) {
+    if (!idx.fields.length) continue;
+
+    if (idx.fields.length === 1) {
+      const [first] = idx.fields;
+      if (!first) continue;
+      const f = first.field;
+      const raw = (entity as any)[f];
+      const { type, value } = asIndexTypeAndValue(raw, colTypeByName.get(f));
+      // 单列索引用字段名作为索引键
+      items.push({ key: f, type, value });
+    } else {
+      // 复合索引：索引名作为 key，值为字段值数组的 JSON，类型 json
+      const key = idx.name;
+      const tuple = idx.fields.map(ff => (entity as any)[ff.field]);
+      items.push({ key, type: "json", value: JSON.stringify(tuple) });
+    }
+  }
+
+  return JSON.stringify(items);
+}
+
+export function composeCompositeIndexValue(values: unknown[]): string {
+  // 用于复合索引查询：indexValue 需为 JSON 数组字符串
+  return JSON.stringify(values);
+}
+
+export type FindIndexOptions = {
+  type?: "string" | "number" | "boolean" | "date" | "json" | "binary";
+  limit?: number;
+  seekKey?: string;
+  direction?: Direction;
+  offset?: number;
+  vaccount?: string;
+};
+
+export type FindValuesOptions = {
+  limit?: number;
+  seekKey?: string;
+  direction?: Direction;
+  offset?: number;
+  vaccount?: string;
+};
+
+function sanitizeGetWithIndexOptions(options: FindIndexOptions): { type?: string; limit?: number; seekKey?: string; direction?: Direction; offset?: number } {
+  return {
+    ...(options.type !== undefined ? { type: options.type } : {}),
+    ...(options.limit !== undefined ? { limit: options.limit } : {}),
+    ...(options.seekKey !== undefined ? { seekKey: options.seekKey } : {}),
+    ...(options.direction !== undefined ? { direction: options.direction } : {}),
+    ...(options.offset !== undefined ? { offset: options.offset } : {}),
+  };
+}
+
+function sanitizeGetValuesOptions(options: FindValuesOptions): { limit?: number; seekKey?: string; direction?: Direction; offset?: number } {
+  return {
+    ...(options.limit !== undefined ? { limit: options.limit } : {}),
+    ...(options.seekKey !== undefined ? { seekKey: options.seekKey } : {}),
+    ...(options.direction !== undefined ? { direction: options.direction } : {}),
+    ...(options.offset !== undefined ? { offset: options.offset } : {}),
+  };
+}
+
+
+
+// 通用仓储：承载所有持久化与查询逻辑
+export class EntityRepository<T extends BaseEntity> {
+  constructor(
+    private readonly entityCtor: Ctor<T>,
+    private readonly ops: IKeyValueOperations,
+    private readonly db: KeyValueDB
+  ) {}
+
+  // 保存实体（写入并附带索引）
+  async save(entity: T, vaccount?: string): Promise<number> {
+    entity.validate();
+    const key= (entity as any).getPrimaryKey();
+    //移除dc_timestamp和dc_opuser字段，由dc节点自动维护
+    delete (entity as any).dc_timestamp;
+    delete (entity as any).dc_opuser;
+    const value = JSON.stringify(entity.toJSON());
+    const indexs = buildIndexPayload(entity, this.entityCtor);
+
+    const [ok,resTimestamp, err] = await this.ops.set(this.db, key, value, indexs, vaccount);
+    if (err) throw err;
+    if (!ok) throw new Error(`${this.entityCtor.name}.save failed`);
+    entity.dc_timestamp = resTimestamp ? resTimestamp : 0; // 设置时间戳
+    return entity.dc_timestamp;
+  }
+
+
+  async deleteById(id: string, vaccount?: string): Promise<void> {
+    const key = id;
+    const [ok,_ ,err] = await this.ops.set(this.db, key, "","", vaccount); // 空值用于标记删除
+    if (err) throw err;
+    if (!ok) throw new Error(`${this.entityCtor.name}.deleteById failed`);
+  }
+
+  // 局部更新（按 id 合并字段后保存）
+  async update(id: string, patch: Partial<T>, vaccount?: string): Promise<T | null> {
+    const key = id; 
+     const [curr, err] = await this.ops.getValueSetByCurrentUser(this.db, key, vaccount);
+    if (err || !curr) return null;
+    const [json, extra] = extractRawValue(curr);
+    const obj = safeParseJSON<any>(json);
+    if (!obj) return null;
+    if (extra) {
+        const extraObj = safeParseJSON<any>(extra);
+        if (extraObj) Object.assign(obj, extraObj);
+    }   
+    const inst = new this.entityCtor();
+    Object.assign(inst, obj);
+    Object.assign(inst as any, patch);
+    const resTimestamp = await this.save(inst, vaccount);
+    inst.dc_timestamp = resTimestamp;
+    return inst;
+  }
+
+
+
+  // 通过 id 获取
+  async findById(id: string, writerPubkey?: string, vaccount?: string): Promise<T | null> {
+    const key = id; 
+    const [raw, err] = await this.ops.get(this.db, key, writerPubkey, vaccount);
+    if (err || !raw) return null;
+
+    const [json, extra] = extractRawValue(raw);
+    const obj = safeParseJSON<any>(json);
+    if (!obj) return null;
+    if (extra) {
+      const extraObj = safeParseJSON<any>(extra);
+      if (extraObj) Object.assign(obj, extraObj);
+    }   
+    
+
+    const inst = new this.entityCtor();
+    Object.assign(inst, obj);
+    return inst;
+  }
+
+
+  
+
+  // 通过索引查询（单字段：indexKey=字段名；复合：indexKey=索引名，indexValue=JSON数组字符串）
+  async findByIndex(indexKey: string, indexValue: string, options: FindIndexOptions = {}): Promise<T[]> {
+    const [raw, err] = await this.ops.getWithIndex(
+      this.db,
+      indexKey,
+      indexValue,
+      sanitizeGetWithIndexOptions(options),
+      options.vaccount
+    );
+    if (err || !raw) return [];
+
+    const values = parseIndexResultValues(raw);
+    const out: T[] = [];
+    for (let val of values) {
+      // 兼容老格式 "key:value"；新格式是纯 value，不会命中
+      val = maybeStripKeyPrefix(val);
+
+      const [json, extra] = extractRawValue(val);
+      const obj = safeParseJSON<any>(json);
+      if (!obj) continue;
+      if (extra) {
+        const extraObj = safeParseJSON<any>(extra);
+        if (extraObj) Object.assign(obj, extraObj);
+      }
+      const inst = new this.entityCtor();
+      Object.assign(inst, obj);
+      out.push(inst);
+    }
+    return out;
+  }
+
+  async findOneByIndex(indexKey: string, indexValue: string, options: Omit<FindIndexOptions, "limit"> = {}): Promise<T | null> {
+    const list = await this.findByIndex(indexKey, indexValue, { ...options, limit: 1 });
+    return list[0] ?? null;
+  }
+
+  // 按键前缀遍历（用于分页场景）
+  async getValues(keyPrefix: string, options: FindValuesOptions = {}): Promise<T[]> {
+    const [raw, err] = await this.ops.getValues(
+      this.db,
+      keyPrefix,
+      sanitizeGetValuesOptions(options),
+      options.vaccount
+    );
+    if (err || !raw) return [];
+
+    const list = safeParseJSON<string[]>(raw) ?? [];
+    const out: T[] = [];
+    for (const item of list) {
+      const [v,extra] = extractRawValue(String(item));
+      const obj = safeParseJSON<any>(v);
+      if (!obj) continue;
+      if (extra) {
+        const extraObj = safeParseJSON<any>(extra);
+        if (extraObj) Object.assign(obj, extraObj);
+      }
+      const inst = new this.entityCtor();
+      Object.assign(inst, obj);
+      out.push(inst);
+    }
+    return out;
+  }
+}

package/lib/serverless/browser_schema_extractor.ts

@@ -0,0 +1,282 @@
+import type { NodePath, Visitor } from "@babel/traverse";
+import type * as T from "@babel/types";
+import { loadBabel } from "./babel-browser";
+
+export type PrintableSchema = {
+  entityName: string;
+  namespace?: string;
+  ttlSeconds?: number;
+  versioned?: boolean;
+  columns: Array<{
+    name: string;
+    type?: string;
+    required?: boolean;
+    unique?: boolean;
+    index?: boolean;
+    default?: unknown;
+  }>;
+  indexes: Array<{
+    name: string;
+    fields: Array<{ field: string; order: "asc" | "desc" }>;
+    unique?: boolean;
+    ttlSeconds?: number;
+  }>;
+};
+
+interface FileContentMap {
+  [fileName: string]: string;
+}
+
+export async function extractSchemasFromSources(sources: FileContentMap): Promise<PrintableSchema[]> {
+  const { parse, t, traverse } = await loadBabel();
+  const result: PrintableSchema[] = [];
+
+  // 解析源码（优先标准装饰器，失败回退 legacy）
+  function tryParse(code: string) {
+    const common = {
+      sourceType: "module" as const,
+      errorRecovery: true,
+      plugins: ["typescript"] as any[],
+    };
+    try {
+      return parse(code, {
+        ...common,
+        plugins: [
+          ["decorators", { decoratorsBeforeExport: true }],
+          "classProperties",
+          "classPrivateProperties",
+          ...common.plugins,
+        ],
+      } as any);
+    } catch {
+      return parse(code, {
+        ...common,
+        plugins: [
+          "decorators-legacy",
+          "classProperties",
+          "classPrivateProperties",
+          ...common.plugins,
+        ],
+      } as any);
+    }
+  }
+
+  // 将装饰器参数表达式转 JS 值（常见字面量/对象/数组）
+  function exprToValue(node: any): any {
+    if (!node) return undefined;
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node) || t.isBooleanLiteral(node)) return (node as any).value;
+    if (t.isNullLiteral(node)) return null;
+    if (t.isIdentifier(node) && (node.name === "undefined")) return undefined;
+    if (t.isObjectExpression(node)) {
+      const obj: any = {};
+      for (const p of node.properties) {
+        if (t.isObjectProperty(p)) {
+          const key = t.isIdentifier(p.key) ? p.key.name : t.isStringLiteral(p.key) ? p.key.value : undefined;
+          if (!key) continue;
+          obj[key] = exprToValue(p.value as any);
+        }
+      }
+      return obj;
+    }
+    if (t.isArrayExpression(node)) return node.elements.map((e: any) => exprToValue(e ));
+    return undefined;
+  }
+
+  // 规范化索引字段
+  function normIndexFields(fields: any, fallbackField?: string): Array<{ field: string; order: "asc" | "desc" }> {
+    const out: Array<{ field: string; order: "asc" | "desc" }> = [];
+    const arr = Array.isArray(fields) ? fields : (fields ? [fields] : []);
+    if (arr.length === 0 && fallbackField) return [{ field: fallbackField, order: "asc" }];
+    for (const it of arr) {
+      if (typeof it === "string") out.push({ field: it, order: "asc" });
+      else if (it && typeof it === "object" && typeof it.field === "string") {
+        out.push({ field: it.field, order: it.order === "desc" ? "desc" : "asc" });
+      }
+    }
+    return out;
+  }
+
+  // 默认索引名
+  function defaultIndexName(fields: Array<{ field: string; order: "asc" | "desc" }>) {
+    const seg = fields.map(f => f.field + (f.order === "desc" ? "_desc" : "")).join("_");
+    return `idx_${seg}`;
+  }
+
+  // 去重 key
+  function indexKey(name: string | undefined, fields: Array<{ field: string; order: "asc" | "desc" }>) {
+    const seg = fields.map(f => `${f.field}:${f.order}`).join(",");
+    return `${name ?? defaultIndexName(fields)}|${seg}`;
+  }
+
+  // 装饰器名/参数
+  function getDecoratorName(dec: any): string | undefined {
+    const ex = dec.expression;
+    if (t.isIdentifier(ex)) return ex.name;
+    if (t.isCallExpression(ex) && t.isIdentifier(ex.callee)) return ex.callee.name;
+    return undefined;
+  }
+  function getDecoratorArgs(dec: any): any[] {
+    const ex = dec.expression;
+    if (t.isCallExpression(ex)) return ex.arguments.map((arg: any) => exprToValue(arg as any));
+    return [];
+  }
+
+  // 统一处理类（ClassDeclaration / ClassExpression）
+  const visitClass = (path: NodePath<T.ClassDeclaration | T.ClassExpression>) => {
+    const node = path.node as any;
+    const className = (node.id && node.id.name) || "AnonymousClass";
+    const decorators: any[] = node.decorators ?? [];
+
+    // 解析 @Entity
+    let entityName = className;
+    let entityOpts: any = {};
+    for (const d of decorators) {
+      const name = getDecoratorName(d);
+      if (name === "Entity") {
+        const [opt] = getDecoratorArgs(d);
+        if (opt && typeof opt === "object") {
+          entityOpts = opt;
+          if (typeof opt.name === "string") entityName = opt.name;
+        }
+      }
+    }
+
+    // 字段与字段级装饰器
+    const columns: PrintableSchema["columns"] = [];
+    const fieldLevelIndexes: PrintableSchema["indexes"] = [];
+
+    for (const m of node.body.body as any[]) {
+      const isClassProp = (t as any).isClassProperty?.(m) || (t as any).isPropertyDefinition?.(m);
+      const isPrivateProp = (t as any).isClassPrivateProperty?.(m);
+      if (!isClassProp && !isPrivateProp) continue;
+
+      const keyNode = m.key;
+      const key =
+        t.isIdentifier(keyNode) ? keyNode.name :
+        t.isStringLiteral(keyNode) ? keyNode.value :
+        undefined;
+      if (!key) continue;
+
+      let columnOpts: any | undefined = undefined;
+      const explicitIndexFromDecorator: any[] = [];
+      const mDecos: any[] = m.decorators ?? [];
+
+      for (const d of mDecos) {
+        const dn = getDecoratorName(d);
+        const args = getDecoratorArgs(d);
+        if (dn === "Column") {
+          columnOpts = args[0] && typeof args[0] === "object" ? args[0] : {};
+        } else if (dn === "Index") {
+          explicitIndexFromDecorator.push(args);
+        }
+      }
+
+      const resolvedName = (columnOpts?.name as string) ?? key;
+      columns.push({
+        name: resolvedName,
+        ...(columnOpts?.type !== undefined ? { type: columnOpts.type } : {}),
+        ...(columnOpts?.required !== undefined ? { required: !!columnOpts.required } : {}),
+        ...(columnOpts?.unique !== undefined ? { unique: !!columnOpts.unique } : {}),
+        ...(columnOpts?.index !== undefined ? { index: !!columnOpts.index } : {}),
+        ...(columnOpts?.default !== undefined ? { default: columnOpts.default } : {}),
+      });
+
+      // Column 的 index/unique → 单列索引
+      if (columnOpts?.index || columnOpts?.unique) {
+        const fields = [{ field: resolvedName, order: "asc" as const }];
+        fieldLevelIndexes.push({
+          name: defaultIndexName(fields),
+          fields,
+          ...(columnOpts?.unique ? { unique: true } : {}),
+        });
+      }
+
+      // 字段级 @Index
+      for (const args of explicitIndexFromDecorator) {
+        let idxName: string | undefined;
+        let idxFields: any;
+        let idxUnique: boolean | undefined;
+        let idxTTL: number | undefined;
+        if (args.length === 0) {
+          idxFields = [resolvedName];
+        } else if (typeof args[0] === "string") {
+          idxName = args[0];
+          idxFields = args[1] ?? [resolvedName];
+        } else if (typeof args[0] === "object") {
+          idxName = args[0].name;
+          idxFields = args[0].fields ?? [resolvedName];
+          idxUnique = args[0].unique;
+          idxTTL = args[0].ttlSeconds;
+        }
+        const fields = normIndexFields(idxFields, resolvedName);
+        if (fields.length === 0) continue;
+        const name2 = idxName ?? defaultIndexName(fields);
+        fieldLevelIndexes.push({
+          name: name2,
+          fields,
+          ...(idxUnique !== undefined ? { unique: !!idxUnique } : {}),
+          ...(idxTTL !== undefined ? { ttlSeconds: idxTTL } : {}),
+        });
+      }
+    }
+
+    // 类级 @Index
+    const classLevelIndexes: PrintableSchema["indexes"] = [];
+    for (const d of decorators) {
+      const dn = getDecoratorName(d);
+      if (dn !== "Index") continue;
+      const args = getDecoratorArgs(d);
+      let idxName: string | undefined;
+      let idxFields: any;
+      let idxUnique: boolean | undefined;
+      let idxTTL: number | undefined;
+      if (args.length === 0) continue;
+      else if (typeof args[0] === "string") {
+        idxName = args[0]; idxFields = args[1] ?? [];
+      } else if (typeof args[0] === "object") {
+        idxName = args[0].name; idxFields = args[0].fields ?? [];
+        idxUnique = args[0].unique; idxTTL = args[0].ttlSeconds;
+      }
+      const fields = normIndexFields(idxFields);
+      if (fields.length === 0) continue;
+      const name2 = idxName ?? defaultIndexName(fields);
+      classLevelIndexes.push({
+        name: name2,
+        fields,
+        ...(idxUnique !== undefined ? { unique: !!idxUnique } : {}),
+        ...(idxTTL !== undefined ? { ttlSeconds: idxTTL } : {}),
+      });
+    }
+
+    // 合并去重
+    const allIndexes = [...fieldLevelIndexes, ...classLevelIndexes];
+    const dedup = new Map<string, PrintableSchema["indexes"][number]>();
+    for (const ix of allIndexes) {
+      const key = indexKey(ix.name, ix.fields);
+      if (!dedup.has(key)) dedup.set(key, ix);
+    }
+
+    const printable: PrintableSchema = {
+      entityName: (entityOpts?.name as string) ?? entityName,
+      ...(entityOpts?.namespace !== undefined ? { namespace: entityOpts.namespace } : {}),
+      ...(entityOpts?.ttlSeconds !== undefined ? { ttlSeconds: entityOpts.ttlSeconds } : {}),
+      ...(entityOpts?.versioned !== undefined ? { versioned: entityOpts.versioned } : {}),
+      columns,
+      indexes: Array.from(dedup.values()),
+    };
+
+    result.push(printable);
+  };
+
+  // 遍历每个文件的 AST
+  for (const [, content] of Object.entries(sources)) {
+    const ast = tryParse(content);
+    const visitors: Visitor = {
+      ClassDeclaration(path: NodePath<T.ClassDeclaration>) { visitClass(path); },
+      ClassExpression(path: NodePath<T.ClassExpression>) { visitClass(path); },
+    };
+    traverse(ast as any, visitors);
+  }
+
+  return result;
+}